| // Copyright 2020 The Pigweed Authors |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| // use this file except in compliance with the License. You may obtain a copy of |
| // the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| // License for the specific language governing permissions and limitations under |
| // the License. |
| |
| #include <cinttypes> |
| #include <cstdint> |
| #include <cstring> |
| |
| #include "gtest/gtest.h" |
| #include "pw_tokenizer/tokenize_to_global_handler.h" |
| #include "pw_tokenizer/tokenize_to_global_handler_with_payload.h" |
| #include "pw_tokenizer_private/tokenize_test.h" |
| |
| namespace pw::tokenizer { |
| namespace { |
| |
| // The hash to use for this test. This makes sure the strings are shorter than |
| // the configured max length to ensure this test works with any reasonable |
| // configuration. |
| template <size_t kSize> |
| constexpr uint32_t TestHash(const char (&string)[kSize]) { |
| constexpr unsigned kTestHashLength = 48; |
| static_assert(kTestHashLength <= PW_TOKENIZER_CFG_HASH_LENGTH); |
| static_assert(kSize <= kTestHashLength + 1); |
| return PwTokenizer65599FixedLengthHash(std::string_view(string, kSize - 1), |
| kTestHashLength); |
| } |
| |
| // Constructs an array with the hashed string followed by the provided bytes. |
| template <uint8_t... kData, size_t kSize> |
| constexpr auto ExpectedData(const char (&format)[kSize]) { |
| const uint32_t value = TestHash(format); |
| return std::array<uint8_t, sizeof(uint32_t) + sizeof...(kData)>{ |
| static_cast<uint8_t>(value & 0xff), |
| static_cast<uint8_t>(value >> 8 & 0xff), |
| static_cast<uint8_t>(value >> 16 & 0xff), |
| static_cast<uint8_t>(value >> 24 & 0xff), |
| kData...}; |
| } |
| |
| // Test fixture for both global handler functions. Both need a global message |
| // buffer. To keep the message buffers separate, template this on the derived |
| // class type. |
| template <typename Impl> |
| class GlobalMessage : 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: |
| GlobalMessage() { |
| std::memset(message_, 0, sizeof(message_)); |
| message_size_bytes_ = 0; |
| } |
| |
| static uint8_t message_[256]; |
| static size_t message_size_bytes_; |
| }; |
| |
| template <typename Impl> |
| uint8_t GlobalMessage<Impl>::message_[256] = {}; |
| template <typename Impl> |
| size_t GlobalMessage<Impl>::message_size_bytes_ = 0; |
| |
| class TokenizeToGlobalHandler : public GlobalMessage<TokenizeToGlobalHandler> { |
| }; |
| |
| TEST_F(TokenizeToGlobalHandler, Variety) { |
| PW_TOKENIZE_TO_GLOBAL_HANDLER("%x%lld%1.2f%s", 0, 0ll, -0.0, ""); |
| const auto expected = |
| ExpectedData<0, 0, 0x00, 0x00, 0x00, 0x80, 0>("%x%lld%1.2f%s"); |
| ASSERT_EQ(expected.size(), message_size_bytes_); |
| EXPECT_EQ(std::memcmp(expected.data(), message_, expected.size()), 0); |
| } |
| |
| TEST_F(TokenizeToGlobalHandler, Strings) { |
| PW_TOKENIZE_TO_GLOBAL_HANDLER("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(TokenizeToGlobalHandler, Domain_Strings) { |
| PW_TOKENIZE_TO_GLOBAL_HANDLER_DOMAIN( |
| "TEST_DOMAIN", "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(TokenizeToGlobalHandler, C_SequentialZigZag) { |
| pw_tokenizer_ToGlobalHandlerTest_SequentialZigZag(); |
| |
| 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); |
| } |
| |
| extern "C" void pw_tokenizer_HandleEncodedMessage( |
| const uint8_t* encoded_message, size_t size_bytes) { |
| TokenizeToGlobalHandler::SetMessage(encoded_message, size_bytes); |
| } |
| |
| class TokenizeToGlobalHandlerWithPayload |
| : public GlobalMessage<TokenizeToGlobalHandlerWithPayload> { |
| public: |
| static void SetPayload(pw_tokenizer_Payload payload) { |
| payload_ = static_cast<intptr_t>(payload); |
| } |
| |
| protected: |
| TokenizeToGlobalHandlerWithPayload() { payload_ = {}; } |
| |
| static intptr_t payload_; |
| }; |
| |
| intptr_t TokenizeToGlobalHandlerWithPayload::payload_; |
| |
| TEST_F(TokenizeToGlobalHandlerWithPayload, Variety) { |
| ASSERT_NE(payload_, 123); |
| |
| const auto expected = |
| ExpectedData<0, 0, 0x00, 0x00, 0x00, 0x80, 0>("%x%lld%1.2f%s"); |
| |
| PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD( |
| static_cast<pw_tokenizer_Payload>(123), |
| "%x%lld%1.2f%s", |
| 0, |
| 0ll, |
| -0.0, |
| ""); |
| ASSERT_EQ(expected.size(), message_size_bytes_); |
| EXPECT_EQ(std::memcmp(expected.data(), message_, expected.size()), 0); |
| EXPECT_EQ(payload_, 123); |
| |
| PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD( |
| static_cast<pw_tokenizer_Payload>(-543), |
| "%x%lld%1.2f%s", |
| 0, |
| 0ll, |
| -0.0, |
| ""); |
| ASSERT_EQ(expected.size(), message_size_bytes_); |
| EXPECT_EQ(std::memcmp(expected.data(), message_, expected.size()), 0); |
| EXPECT_EQ(payload_, -543); |
| } |
| |
| constexpr std::array<uint8_t, 10> kExpected = |
| ExpectedData<5, '5', '4', '3', '2', '!'>("The answer is: %s"); |
| |
| TEST_F(TokenizeToGlobalHandlerWithPayload, Strings_ZeroPayload) { |
| PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD({}, "The answer is: %s", "5432!"); |
| |
| ASSERT_EQ(kExpected.size(), message_size_bytes_); |
| EXPECT_EQ(std::memcmp(kExpected.data(), message_, kExpected.size()), 0); |
| EXPECT_EQ(payload_, 0); |
| } |
| |
| TEST_F(TokenizeToGlobalHandlerWithPayload, Strings_NonZeroPayload) { |
| PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD( |
| static_cast<pw_tokenizer_Payload>(5432), "The answer is: %s", "5432!"); |
| |
| ASSERT_EQ(kExpected.size(), message_size_bytes_); |
| EXPECT_EQ(std::memcmp(kExpected.data(), message_, kExpected.size()), 0); |
| EXPECT_EQ(payload_, 5432); |
| } |
| |
| TEST_F(TokenizeToGlobalHandlerWithPayload, Domain_Strings) { |
| PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD_DOMAIN( |
| "TEST_DOMAIN", |
| static_cast<pw_tokenizer_Payload>(5432), |
| "The answer is: %s", |
| "5432!"); |
| ASSERT_EQ(kExpected.size(), message_size_bytes_); |
| EXPECT_EQ(std::memcmp(kExpected.data(), message_, kExpected.size()), 0); |
| EXPECT_EQ(payload_, 5432); |
| } |
| |
| struct Foo { |
| unsigned char a; |
| bool b; |
| }; |
| |
| TEST_F(TokenizeToGlobalHandlerWithPayload, PointerToStack) { |
| Foo foo{254u, true}; |
| |
| PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD( |
| reinterpret_cast<pw_tokenizer_Payload>(&foo), "Boring!"); |
| |
| constexpr auto expected = ExpectedData("Boring!"); |
| static_assert(expected.size() == 4); |
| ASSERT_EQ(expected.size(), message_size_bytes_); |
| EXPECT_EQ(std::memcmp(expected.data(), message_, expected.size()), 0); |
| |
| Foo* payload_foo = reinterpret_cast<Foo*>(payload_); |
| ASSERT_EQ(&foo, payload_foo); |
| EXPECT_EQ(payload_foo->a, 254u); |
| EXPECT_TRUE(payload_foo->b); |
| } |
| |
| TEST_F(TokenizeToGlobalHandlerWithPayload, C_SequentialZigZag) { |
| pw_tokenizer_ToGlobalHandlerWithPayloadTest_SequentialZigZag(); |
| |
| 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); |
| EXPECT_EQ(payload_, 600613); |
| } |
| |
| extern "C" void pw_tokenizer_HandleEncodedMessageWithPayload( |
| pw_tokenizer_Payload payload, |
| const uint8_t* encoded_message, |
| size_t size_bytes) { |
| TokenizeToGlobalHandlerWithPayload::SetMessage(encoded_message, size_bytes); |
| TokenizeToGlobalHandlerWithPayload::SetPayload(payload); |
| } |
| |
| // Hijack the PW_TOKENIZE_STRING_DOMAIN macro to capture the tokenizer domain. |
| #undef PW_TOKENIZE_STRING_DOMAIN |
| #define PW_TOKENIZE_STRING_DOMAIN(domain, string) \ |
| /* assigned to a variable */ PW_TOKENIZER_STRING_TOKEN(string); \ |
| tokenizer_domain = domain; \ |
| string_literal = string |
| |
| TEST_F(TokenizeToGlobalHandler, Domain_Default) { |
| const char* tokenizer_domain = nullptr; |
| const char* string_literal = nullptr; |
| |
| PW_TOKENIZE_TO_GLOBAL_HANDLER("404"); |
| |
| EXPECT_STREQ(tokenizer_domain, PW_TOKENIZER_DEFAULT_DOMAIN); |
| EXPECT_STREQ(string_literal, "404"); |
| } |
| |
| TEST_F(TokenizeToGlobalHandler, Domain_Specified) { |
| const char* tokenizer_domain = nullptr; |
| const char* string_literal = nullptr; |
| |
| PW_TOKENIZE_TO_GLOBAL_HANDLER_DOMAIN("www.google.com", "404"); |
| |
| EXPECT_STREQ(tokenizer_domain, "www.google.com"); |
| EXPECT_STREQ(string_literal, "404"); |
| } |
| |
| TEST_F(TokenizeToGlobalHandlerWithPayload, Domain_Default) { |
| const char* tokenizer_domain = nullptr; |
| const char* string_literal = nullptr; |
| |
| PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD( |
| static_cast<pw_tokenizer_Payload>(123), "Wow%s", "???"); |
| |
| EXPECT_STREQ(tokenizer_domain, PW_TOKENIZER_DEFAULT_DOMAIN); |
| EXPECT_STREQ(string_literal, "Wow%s"); |
| } |
| |
| TEST_F(TokenizeToGlobalHandlerWithPayload, Domain_Specified) { |
| const char* tokenizer_domain = nullptr; |
| const char* string_literal = nullptr; |
| |
| PW_TOKENIZE_TO_GLOBAL_HANDLER_WITH_PAYLOAD_DOMAIN( |
| "THEDOMAIN", static_cast<pw_tokenizer_Payload>(123), "1234567890"); |
| |
| EXPECT_STREQ(tokenizer_domain, "THEDOMAIN"); |
| EXPECT_STREQ(string_literal, "1234567890"); |
| } |
| |
| } // namespace |
| } // namespace pw::tokenizer |