diff options
Diffstat (limited to 'pw_tokenizer/tokenize_test.cc')
| -rw-r--r-- | pw_tokenizer/tokenize_test.cc | 180 |
1 files changed, 72 insertions, 108 deletions
diff --git a/pw_tokenizer/tokenize_test.cc b/pw_tokenizer/tokenize_test.cc index f302e14f0..8efbba446 100644 --- a/pw_tokenizer/tokenize_test.cc +++ b/pw_tokenizer/tokenize_test.cc @@ -52,6 +52,20 @@ TEST(TokenizeString, String_MatchesHash) { EXPECT_EQ(Hash("[:-)"), token); } +TEST(TokenizeString, String_MatchesHashExpr) { + EXPECT_EQ(Hash("[:-)"), PW_TOKENIZE_STRING_EXPR("[:-)")); +} + +TEST(TokenizeString, ExpressionWithStringVariable) { + constexpr char kTestString[] = "test"; + EXPECT_EQ(Hash(kTestString), PW_TOKENIZE_STRING_EXPR(kTestString)); + EXPECT_EQ(Hash(kTestString), + PW_TOKENIZE_STRING_DOMAIN_EXPR("TEST_DOMAIN", kTestString)); + EXPECT_EQ( + Hash(kTestString) & 0xAAAAAAAA, + PW_TOKENIZE_STRING_MASK_EXPR("TEST_DOMAIN", 0xAAAAAAAA, kTestString)); +} + constexpr uint32_t kGlobalToken = PW_TOKENIZE_STRING(">:-[]"); TEST(TokenizeString, GlobalVariable_MatchesHash) { @@ -68,6 +82,28 @@ TEST(TokenizeString, ClassMember_MatchesHash) { EXPECT_EQ(Hash("???"), TokenizedWithinClass().kThisToken); } +TEST(TokenizeString, WithinNonCapturingLambda) { + uint32_t non_capturing_lambda = [] { + return PW_TOKENIZE_STRING("Lambda!"); + }(); + + EXPECT_EQ(Hash("Lambda!"), non_capturing_lambda); +} + +TEST(TokenizeString, WithinCapturingLambda) { + bool executed_lambda = false; + uint32_t capturing_lambda = [&executed_lambda] { + if (executed_lambda) { + return PW_TOKENIZE_STRING("Never should be returned!"); + } + executed_lambda = true; + return PW_TOKENIZE_STRING("Capturing lambda!"); + }(); + + ASSERT_TRUE(executed_lambda); + EXPECT_EQ(Hash("Capturing lambda!"), capturing_lambda); +} + TEST(TokenizeString, Mask) { [[maybe_unused]] constexpr uint32_t token = PW_TOKENIZE_STRING("(O_o)"); [[maybe_unused]] constexpr uint32_t masked_1 = @@ -84,6 +120,22 @@ TEST(TokenizeString, Mask) { static_assert((token & 0xFFFF0000) == masked_3); } +TEST(TokenizeString, MaskExpr) { + uint32_t token = PW_TOKENIZE_STRING("(O_o)"); + uint32_t masked_1 = + PW_TOKENIZE_STRING_MASK_EXPR("domain", 0xAAAAAAAA, "(O_o)"); + uint32_t masked_2 = + PW_TOKENIZE_STRING_MASK_EXPR("domain", 0x55555555, "(O_o)"); + uint32_t masked_3 = + PW_TOKENIZE_STRING_MASK_EXPR("domain", 0xFFFF0000, "(O_o)"); + + EXPECT_TRUE(token != masked_1 && token != masked_2 && token != masked_3); + EXPECT_TRUE(masked_1 != masked_2 && masked_2 != masked_3); + EXPECT_TRUE((token & 0xAAAAAAAA) == masked_1); + EXPECT_TRUE((token & 0x55555555) == masked_2); + EXPECT_TRUE((token & 0xFFFF0000) == masked_3); +} + // Use a function with a shorter name to test tokenizing __func__ and // __PRETTY_FUNCTION__. // @@ -146,10 +198,28 @@ TEST(TokenizeString, MultipleTokenizationsInOneMacroExpansion) { THREE_FOR_ONE("hello", "yes", "something"); } +// Verify that we can tokenize multiple strings from one source line. +#define THREE_FOR_ONE_EXPR(first, second, third) \ + [[maybe_unused]] uint32_t token_1 = \ + PW_TOKENIZE_STRING_DOMAIN_EXPR("TEST_DOMAIN", first); \ + [[maybe_unused]] uint32_t token_2 = \ + PW_TOKENIZE_STRING_DOMAIN_EXPR("TEST_DOMAIN", second); \ + [[maybe_unused]] uint32_t token_3 = \ + PW_TOKENIZE_STRING_DOMAIN_EXPR("TEST_DOMAIN", third); + +TEST(TokenizeString, MultipleTokenizationsInOneMacroExpansionExpr) { + // This verifies that we can safely tokenize multiple times in a single macro + // expansion. This can be useful when for example a name and description are + // both tokenized after being passed into a macro. + // + // This test only verifies that this compiles correctly; it does not test + // that the tokenizations make it to the final token database. + THREE_FOR_ONE_EXPR("hello", "yes", "something"); +} + class TokenizeToBuffer : public ::testing::Test { public: - TokenizeToBuffer() : buffer_ {} - {} + TokenizeToBuffer() : buffer_{} {} protected: uint8_t buffer_[64]; @@ -470,91 +540,6 @@ TEST_F(TokenizeToBuffer, AsArgumentToAnotherMacro) { EXPECT_EQ(std::memcmp(expected.data(), buffer_, expected.size()), 0); } -class TokenizeToCallback : public ::testing::Test { - public: - static void SetMessage(const uint8_t* message, size_t size) { - ASSERT_LE(size, sizeof(message_)); - std::memcpy(message_, message, size); - message_size_bytes_ = size; - } - - protected: - TokenizeToCallback() { - std::memset(message_, 0, sizeof(message_)); - message_size_bytes_ = 0; - } - - static uint8_t message_[256]; - static size_t message_size_bytes_; -}; - -uint8_t TokenizeToCallback::message_[256] = {}; -size_t TokenizeToCallback::message_size_bytes_ = 0; - -TEST_F(TokenizeToCallback, Variety) { - PW_TOKENIZE_TO_CALLBACK( - SetMessage, "%s there are %x (%.2f) of them%c", "Now", 2u, 2.0f, '.'); - const auto expected = // clang-format off - ExpectedData<3, 'N', 'o', 'w', // string "Now" - 0x04, // unsigned 2 (zig-zag encoded) - 0x00, 0x00, 0x00, 0x40, // float 2.0 - 0x5C // char '.' (0x2E, zig-zag encoded) - >("%s there are %x (%.2f) of them%c"); - // clang-format on - ASSERT_EQ(expected.size(), message_size_bytes_); - EXPECT_EQ(std::memcmp(expected.data(), message_, expected.size()), 0); -} - -TEST_F(TokenizeToCallback, Strings) { - PW_TOKENIZE_TO_CALLBACK(SetMessage, "The answer is: %s", "5432!"); - constexpr std::array<uint8_t, 10> expected = - ExpectedData<5, '5', '4', '3', '2', '!'>("The answer is: %s"); - ASSERT_EQ(expected.size(), message_size_bytes_); - EXPECT_EQ(std::memcmp(expected.data(), message_, expected.size()), 0); -} - -TEST_F(TokenizeToCallback, Domain_Strings) { - PW_TOKENIZE_TO_CALLBACK_DOMAIN( - "TEST_DOMAIN", SetMessage, "The answer is: %s", "5432!"); - constexpr std::array<uint8_t, 10> expected = - ExpectedData<5, '5', '4', '3', '2', '!'>("The answer is: %s"); - ASSERT_EQ(expected.size(), message_size_bytes_); - EXPECT_EQ(std::memcmp(expected.data(), message_, expected.size()), 0); -} - -TEST_F(TokenizeToCallback, Mask) { - PW_TOKENIZE_TO_CALLBACK_MASK( - "TEST_DOMAIN", 0x00000FFF, SetMessage, "The answer is: %s", "5432!"); - constexpr std::array<uint8_t, 10> expected = - ExpectedData<5, '5', '4', '3', '2', '!'>("The answer is: %s", 0x00000FFF); - ASSERT_EQ(expected.size(), message_size_bytes_); - EXPECT_EQ(std::memcmp(expected.data(), message_, expected.size()), 0); -} - -TEST_F(TokenizeToCallback, CharArray) { - PW_TOKENIZE_TO_CALLBACK(SetMessage, __func__); - constexpr auto expected = ExpectedData(__func__); - ASSERT_EQ(expected.size(), message_size_bytes_); - EXPECT_EQ(std::memcmp(expected.data(), message_, expected.size()), 0); -} - -TEST_F(TokenizeToCallback, C_SequentialZigZag) { - pw_tokenizer_ToCallbackTest_SequentialZigZag(SetMessage); - - constexpr std::array<uint8_t, 18> expected = - ExpectedData<0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13>( - TEST_FORMAT_SEQUENTIAL_ZIG_ZAG); - ASSERT_EQ(expected.size(), message_size_bytes_); - EXPECT_EQ(std::memcmp(expected.data(), message_, expected.size()), 0); -} - -TEST_F(TokenizeToCallback, AsArgumentToAnotherMacro) { - MACRO_THAT_CALLS_ANOTHER_MACRO(PW_TOKENIZE_TO_CALLBACK(SetMessage, __func__)); - constexpr auto expected = ExpectedData(__func__); - ASSERT_EQ(expected.size(), message_size_bytes_); - EXPECT_EQ(std::memcmp(expected.data(), message_, expected.size()), 0); -} - #undef MACRO_THAT_CALLS_ANOTHER_MACRO #undef ANOTHER_MACRO @@ -589,26 +574,5 @@ TEST_F(TokenizeToBuffer, Domain_Specified) { EXPECT_STREQ(string_literal, "The answer is: %s"); } -TEST_F(TokenizeToCallback, Domain_Default) { - const char* tokenizer_domain = nullptr; - const char* string_literal = nullptr; - - PW_TOKENIZE_TO_CALLBACK(SetMessage, "The answer is: %s", "5432!"); - - EXPECT_STREQ(tokenizer_domain, PW_TOKENIZER_DEFAULT_DOMAIN); - EXPECT_STREQ(string_literal, "The answer is: %s"); -} - -TEST_F(TokenizeToCallback, Domain_Specified) { - const char* tokenizer_domain = nullptr; - const char* string_literal = nullptr; - - PW_TOKENIZE_TO_CALLBACK_DOMAIN( - "ThisIsTheDomain", SetMessage, "The answer is: %s", "5432!"); - - EXPECT_STREQ(tokenizer_domain, "ThisIsTheDomain"); - EXPECT_STREQ(string_literal, "The answer is: %s"); -} - } // namespace } // namespace pw::tokenizer |