blob: 1728a5f7c4d165c138342d086e692c781b8eccbe [file] [log] [blame]
// 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