// Copyright 2026 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 "pw_tokenizer/enum.h"

#include <array>
#include <cstddef>
#include <cstdint>
#include <string_view>
#include <type_traits>
#include <utility>

#include "pw_enum/to_string.h"
#include "pw_enum/traits.h"
#include "pw_enum_private/basic_enum.h"
#include "pw_enum_private/complex_enum.h"
#include "pw_enum_private/enum_with_deps.h"
#include "pw_enum_private/standalone_enum.h"
#include "pw_log/tokenized_args.h"
#include "pw_tokenizer/hash.h"
#include "pw_unit_test/constexpr.h"
#include "pw_unit_test/framework.h"

namespace {

enum class HandwrittenTestEnum : uint8_t {
  kFirst = 0,
  kSecond = 1,
  kFromH = ::pw::enum_test::base::kBase,
};

PW_CONSTEXPR_TEST(PwEnumTest, GeneratesCorrectValues, {
  PW_TEST_EXPECT_EQ(::pw::testing::TestEnum::kFirst,
                    static_cast<::pw::testing::TestEnum>(0));
  PW_TEST_EXPECT_EQ(::pw::testing::TestEnum::kSecond,
                    static_cast<::pw::testing::TestEnum>(1));
  PW_TEST_EXPECT_EQ(::pw::testing::TestEnum::kFromH,
                    static_cast<::pw::testing::TestEnum>(100));
});

PW_CONSTEXPR_TEST(PwEnumTest, CompareToHandwritten, {
  PW_TEST_EXPECT_EQ(static_cast<uint8_t>(::pw::testing::TestEnum::kFirst),
                    static_cast<uint8_t>(HandwrittenTestEnum::kFirst));
  PW_TEST_EXPECT_EQ(static_cast<uint8_t>(::pw::testing::TestEnum::kSecond),
                    static_cast<uint8_t>(HandwrittenTestEnum::kSecond));
  PW_TEST_EXPECT_EQ(static_cast<uint8_t>(::pw::testing::TestEnum::kFromH),
                    static_cast<uint8_t>(HandwrittenTestEnum::kFromH));
});

PW_CONSTEXPR_TEST(PwEnumTest, EnumWithComments, {
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithComments::kFirst,
                    static_cast<::pw::testing::EnumWithComments>(1));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithComments::kSecond,
                    static_cast<::pw::testing::EnumWithComments>(2));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithComments::kThird,
                    static_cast<::pw::testing::EnumWithComments>(3));
});

PW_CONSTEXPR_TEST(PwEnumTest, TokenizedEnumString, {
  constexpr const char* log_value =
      ::pw::EnumToString(::pw::testing::TestEnum::kFirst);
  PW_TEST_EXPECT_STREQ("FIRST", log_value);
});

PW_CONSTEXPR_TEST(PwEnumTest, TokenizedEnumStringUnspecified, {
  constexpr const char* log_value =
      ::pw::EnumToString(::pw::testing::TestEnum::kSecond);
  PW_TEST_EXPECT_STREQ("SECOND", log_value);
});

PW_CONSTEXPR_TEST(PwEnumTest, StandaloneEnum, {
  PW_TEST_EXPECT_EQ(::pw::enum_test::Standalone::kOne,
                    static_cast<::pw::enum_test::Standalone>(1));
  PW_TEST_EXPECT_EQ(::pw::enum_test::Standalone::kTwo,
                    static_cast<::pw::enum_test::Standalone>(2));
  PW_TEST_EXPECT_EQ(
      ::pw::tokenizer::EnumDomainToken<::pw::enum_test::Standalone>(),
      ::pw::tokenizer::Hash(PW_ENUM_TEST_STANDALONE_DOMAIN));
});

PW_CONSTEXPR_TEST(PwEnumTest, WithDepsEnum, {
  PW_TEST_EXPECT_EQ(::pw::enum_test::WithDeps::kOk,
                    static_cast<::pw::enum_test::WithDeps>(42));
});

PW_CONSTEXPR_TEST(PwEnumTest, ComplexEnums, {
  PW_TEST_EXPECT_EQ(::a::b::c::d::ComplexEnum::kNeg,
                    static_cast<::a::b::c::d::ComplexEnum>(-1));
  PW_TEST_EXPECT_EQ(::a::b::c::d::ComplexEnum::kZero,
                    static_cast<::a::b::c::d::ComplexEnum>(0));
  PW_TEST_EXPECT_EQ(::a::b::c::d::ComplexEnum::kOne,
                    static_cast<::a::b::c::d::ComplexEnum>(1));
  PW_TEST_EXPECT_EQ(::a::b::c::d::ComplexEnum::kTwo,
                    static_cast<::a::b::c::d::ComplexEnum>(2));
  PW_TEST_EXPECT_EQ(::a::b::c::d::ComplexEnum::kBitwise,
                    static_cast<::a::b::c::d::ComplexEnum>(17));
  PW_TEST_EXPECT_EQ(::a::b::c::d::ComplexEnum::kShift,
                    static_cast<::a::b::c::d::ComplexEnum>(4));
  PW_TEST_EXPECT_EQ(::a::b::c::d::ComplexEnum::kFunctionCall,
                    static_cast<::a::b::c::d::ComplexEnum>(9));

  PW_TEST_EXPECT_EQ(::pw::testing::ReferencesComplex::kVal,
                    static_cast<::pw::testing::ReferencesComplex>(2));

  PW_TEST_EXPECT_STREQ("NEG",
                       ::pw::EnumToString(::a::b::c::d::ComplexEnum::kNeg));
  PW_TEST_EXPECT_STREQ("ZERO",
                       ::pw::EnumToString(::a::b::c::d::ComplexEnum::kZero));
  PW_TEST_EXPECT_STREQ("ONE",
                       ::pw::EnumToString(::a::b::c::d::ComplexEnum::kOne));
  PW_TEST_EXPECT_STREQ("TWO",
                       ::pw::EnumToString(::a::b::c::d::ComplexEnum::kTwo));
  PW_TEST_EXPECT_STREQ("BITWISE",
                       ::pw::EnumToString(::a::b::c::d::ComplexEnum::kBitwise));
  PW_TEST_EXPECT_STREQ("SHIFT",
                       ::pw::EnumToString(::a::b::c::d::ComplexEnum::kShift));
  PW_TEST_EXPECT_STREQ(
      "FUNCTION_CALL",
      ::pw::EnumToString(::a::b::c::d::ComplexEnum::kFunctionCall));
});

PW_CONSTEXPR_TEST(PwEnumTest, NestedEnumInStruct, {
  PW_TEST_EXPECT_EQ(::pw::testing::OuterStruct::NestedEnum::kValA,
                    static_cast<::pw::testing::OuterStruct::NestedEnum>(5));
  PW_TEST_EXPECT_EQ(::pw::testing::OuterStruct::NestedEnum::kValB,
                    static_cast<::pw::testing::OuterStruct::NestedEnum>(10));

  PW_TEST_EXPECT_STREQ(
      "VAL_A",
      ::pw::EnumToString(::pw::testing::OuterStruct::NestedEnum::kValA));
  PW_TEST_EXPECT_STREQ(
      "VAL_B",
      ::pw::EnumToString(::pw::testing::OuterStruct::NestedEnum::kValB));
});

PW_CONSTEXPR_TEST(PwEnumTest, CustomStrings, {
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomStrings::kValueA,
                    static_cast<::pw::testing::EnumWithCustomStrings>(1));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomStrings::kValueB,
                    static_cast<::pw::testing::EnumWithCustomStrings>(2));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomStrings::kValueC,
                    static_cast<::pw::testing::EnumWithCustomStrings>(3));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomStrings::kValueD,
                    static_cast<::pw::testing::EnumWithCustomStrings>(4));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomStrings::kValueE,
                    static_cast<::pw::testing::EnumWithCustomStrings>(5));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomStrings::kValueF,
                    static_cast<::pw::testing::EnumWithCustomStrings>(6));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomStrings::kValueG,
                    static_cast<::pw::testing::EnumWithCustomStrings>(7));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomStrings::kValueH,
                    static_cast<::pw::testing::EnumWithCustomStrings>(8));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomStrings::kValueI,
                    static_cast<::pw::testing::EnumWithCustomStrings>(9));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomStrings::kValueJ,
                    static_cast<::pw::testing::EnumWithCustomStrings>(10));

  PW_TEST_EXPECT_STREQ(
      "custom_a",
      ::pw::EnumToString(::pw::testing::EnumWithCustomStrings::kValueA));
  PW_TEST_EXPECT_STREQ(
      "VALUE_B",
      ::pw::EnumToString(::pw::testing::EnumWithCustomStrings::kValueB));
  PW_TEST_EXPECT_STREQ(
      "custom nested \"quotes\" here",
      ::pw::EnumToString(::pw::testing::EnumWithCustomStrings::kValueC));
  PW_TEST_EXPECT_STREQ(
      "a + b - c",
      ::pw::EnumToString(::pw::testing::EnumWithCustomStrings::kValueD));
  PW_TEST_EXPECT_STREQ(
      "spaces are cool",
      ::pw::EnumToString(::pw::testing::EnumWithCustomStrings::kValueE));
  PW_TEST_EXPECT_STREQ(
      "value_f",
      ::pw::EnumToString(::pw::testing::EnumWithCustomStrings::kValueF));
  PW_TEST_EXPECT_STREQ(
      "line\nbreak",
      ::pw::EnumToString(::pw::testing::EnumWithCustomStrings::kValueG));
  PW_TEST_EXPECT_STREQ(
      "control\x1b_character",
      ::pw::EnumToString(::pw::testing::EnumWithCustomStrings::kValueH));
  PW_TEST_EXPECT_STREQ(
      "tab\tcharacter",
      ::pw::EnumToString(::pw::testing::EnumWithCustomStrings::kValueI));
  PW_TEST_EXPECT_STREQ(
      "emoji 🚀 character",
      ::pw::EnumToString(::pw::testing::EnumWithCustomStrings::kValueJ));
});

PW_CONSTEXPR_TEST(PwEnumTest, CustomAliases, {
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomAliases::kA,
                    static_cast<::pw::testing::EnumWithCustomAliases>(1));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomAliases::kB,
                    static_cast<::pw::testing::EnumWithCustomAliases>(2));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomAliases::kC,
                    static_cast<::pw::testing::EnumWithCustomAliases>(1));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomAliases::kD,
                    static_cast<::pw::testing::EnumWithCustomAliases>(2));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomAliases::kE,
                    static_cast<::pw::testing::EnumWithCustomAliases>(3));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithCustomAliases::kF,
                    static_cast<::pw::testing::EnumWithCustomAliases>(3));

  PW_TEST_EXPECT_STREQ(
      "custom_a|custom_c",
      ::pw::EnumToString(::pw::testing::EnumWithCustomAliases::kA));
  PW_TEST_EXPECT_STREQ(
      "custom_a|custom_c",
      ::pw::EnumToString(::pw::testing::EnumWithCustomAliases::kC));
  PW_TEST_EXPECT_STREQ(
      "B|D", ::pw::EnumToString(::pw::testing::EnumWithCustomAliases::kB));
  PW_TEST_EXPECT_STREQ(
      "B|D", ::pw::EnumToString(::pw::testing::EnumWithCustomAliases::kD));
  PW_TEST_EXPECT_STREQ(
      "E|custom_f",
      ::pw::EnumToString(::pw::testing::EnumWithCustomAliases::kE));
  PW_TEST_EXPECT_STREQ(
      "E|custom_f",
      ::pw::EnumToString(::pw::testing::EnumWithCustomAliases::kF));
});

PW_CONSTEXPR_TEST(PwEnumTest, PartialAliases, {
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithPartialAliases::kA,
                    static_cast<::pw::testing::EnumWithPartialAliases>(1));
  PW_TEST_EXPECT_EQ(::pw::testing::EnumWithPartialAliases::kB,
                    static_cast<::pw::testing::EnumWithPartialAliases>(1));

  // kB is not registered, but it has the same value as kA (1), so it maps
  // to the same generated string "A".
  PW_TEST_EXPECT_STREQ(
      "A", ::pw::EnumToString(::pw::testing::EnumWithPartialAliases::kA));
  PW_TEST_EXPECT_STREQ(
      "A", ::pw::EnumToString(::pw::testing::EnumWithPartialAliases::kB));
});

// Aliases for the generated traits used throughout the tests below.
using TestTraits = ::pw::EnumTraits<::pw::testing::TestEnum>;
using ComplexTraits = ::pw::EnumTraits<::a::b::c::d::ComplexEnum>;
using NestedTraits = ::pw::EnumTraits<::pw::testing::OuterStruct::NestedEnum>;
using StandaloneTraits = ::pw::EnumTraits<::pw::enum_test::Standalone>;
using AliasTraits = ::pw::EnumTraits<::pw::testing::EnumWithCustomAliases>;
using SingleValueTraits = ::pw::EnumTraits<::pw::testing::ReferencesComplex>;
using BoolTraits = ::pw::EnumTraits<::pw::testing::BoolEnum>;

static_assert(std::is_same_v<TestTraits::enum_type, ::pw::testing::TestEnum>);
static_assert(std::is_same_v<TestTraits::underlying_type,
                             std::underlying_type_t<::pw::testing::TestEnum>>);
static_assert(std::is_same_v<TestTraits::underlying_type, uint8_t>);

// The underlying type is reported faithfully for signed enums and for the
// narrowest possible enum.
static_assert(
    std::is_same_v<ComplexTraits::enum_type, ::a::b::c::d::ComplexEnum>);
static_assert(std::is_same_v<ComplexTraits::underlying_type, int32_t>);
static_assert(std::is_same_v<BoolTraits::underlying_type, bool>);

PW_CONSTEXPR_TEST(EnumTraitsTest, MinAndMax, {
  PW_TEST_EXPECT_EQ(TestTraits::kMin, ::pw::testing::TestEnum::kFirst);
  PW_TEST_EXPECT_EQ(TestTraits::kMax, ::pw::testing::TestEnum::kFromH);

  PW_TEST_EXPECT_EQ(ComplexTraits::kMin, ::a::b::c::d::ComplexEnum::kNeg);
  PW_TEST_EXPECT_EQ(ComplexTraits::kMax, ::a::b::c::d::ComplexEnum::kBitwise);

  PW_TEST_EXPECT_EQ(NestedTraits::kMin,
                    ::pw::testing::OuterStruct::NestedEnum::kValA);
  PW_TEST_EXPECT_EQ(NestedTraits::kMax,
                    ::pw::testing::OuterStruct::NestedEnum::kValB);

  PW_TEST_EXPECT_EQ(StandaloneTraits::kMin, ::pw::enum_test::Standalone::kOne);
  PW_TEST_EXPECT_EQ(StandaloneTraits::kMax, ::pw::enum_test::Standalone::kTwo);
});

PW_CONSTEXPR_TEST(EnumTraitsTest, DistinctValueCountIgnoresAliases, {
  PW_TEST_EXPECT_EQ(TestTraits::kDistinctValueCount, 3u);
  PW_TEST_EXPECT_EQ(ComplexTraits::kDistinctValueCount, 7u);
  PW_TEST_EXPECT_EQ(NestedTraits::kDistinctValueCount, 2u);
  PW_TEST_EXPECT_EQ(StandaloneTraits::kDistinctValueCount, 2u);

  // kA/kC, kB/kD, and kE/kF are aliases, so only three values are distinct.
  PW_TEST_EXPECT_EQ(AliasTraits::kDistinctValueCount, 3u);
});

PW_CONSTEXPR_TEST(EnumTraitsTest, IsContiguous, {
  PW_TEST_EXPECT_FALSE(TestTraits::kIsContiguous);
  PW_TEST_EXPECT_FALSE(ComplexTraits::kIsContiguous);
  PW_TEST_EXPECT_FALSE(NestedTraits::kIsContiguous);
  PW_TEST_EXPECT_TRUE(StandaloneTraits::kIsContiguous);
  PW_TEST_EXPECT_TRUE(AliasTraits::kIsContiguous);
  PW_TEST_EXPECT_TRUE(SingleValueTraits::kIsContiguous);
});

PW_CONSTEXPR_TEST(EnumTraitsTest, Names, {
  PW_TEST_EXPECT_EQ(TestTraits::kName, "TestEnum");
  PW_TEST_EXPECT_EQ(TestTraits::kFullyQualifiedName, "::pw::testing::TestEnum");

  PW_TEST_EXPECT_EQ(ComplexTraits::kName, "ComplexEnum");
  PW_TEST_EXPECT_EQ(ComplexTraits::kFullyQualifiedName,
                    "::a::b::c::d::ComplexEnum");

  PW_TEST_EXPECT_EQ(NestedTraits::kName, "NestedEnum");
  PW_TEST_EXPECT_EQ(NestedTraits::kFullyQualifiedName,
                    "::pw::testing::OuterStruct::NestedEnum");

  PW_TEST_EXPECT_EQ(StandaloneTraits::kName, "Standalone");
  PW_TEST_EXPECT_EQ(StandaloneTraits::kFullyQualifiedName,
                    "::pw::enum_test::Standalone");
});

PW_CONSTEXPR_TEST(EnumTraitsTest, TokenDomainMatchesTokenizedDomain, {
  // The domain is versioned, so only its prefix is stable.
  PW_TEST_EXPECT_EQ(TestTraits::kTokenDomain.find("::pw::testing::_pw_enum_"),
                    0u);
  PW_TEST_EXPECT_EQ(StandaloneTraits::kTokenDomain,
                    PW_ENUM_TEST_STANDALONE_DOMAIN);
});

PW_CONSTEXPR_TEST(EnumTraitsTest, ValuesAreDistinctAndAscending, {
  PW_TEST_EXPECT_EQ(TestTraits::kValues.size(),
                    TestTraits::kDistinctValueCount);
  PW_TEST_EXPECT_EQ(TestTraits::kValues[0], ::pw::testing::TestEnum::kFirst);
  PW_TEST_EXPECT_EQ(TestTraits::kValues[1], ::pw::testing::TestEnum::kSecond);
  PW_TEST_EXPECT_EQ(TestTraits::kValues[2], ::pw::testing::TestEnum::kFromH);

  PW_TEST_EXPECT_EQ(StandaloneTraits::kValues.size(), 2u);
  PW_TEST_EXPECT_EQ(StandaloneTraits::kValues[0],
                    ::pw::enum_test::Standalone::kOne);
  PW_TEST_EXPECT_EQ(StandaloneTraits::kValues[1],
                    ::pw::enum_test::Standalone::kTwo);

  // Aliased enumerators appear exactly once.
  PW_TEST_EXPECT_EQ(AliasTraits::kValues.size(), 3u);
  PW_TEST_EXPECT_EQ(AliasTraits::kValues[0],
                    ::pw::testing::EnumWithCustomAliases::kA);
  PW_TEST_EXPECT_EQ(AliasTraits::kValues[1],
                    ::pw::testing::EnumWithCustomAliases::kB);
  PW_TEST_EXPECT_EQ(AliasTraits::kValues[2],
                    ::pw::testing::EnumWithCustomAliases::kE);

  // ComplexEnum is signed and starts negative, so it is the case most likely
  // to break if values are ever sorted as unsigned.
  PW_TEST_EXPECT_EQ(ComplexTraits::kValues.size(),
                    ComplexTraits::kDistinctValueCount);
  PW_TEST_EXPECT_EQ(ComplexTraits::kValues[0], ComplexTraits::kMin);
  PW_TEST_EXPECT_EQ(ComplexTraits::kValues[ComplexTraits::kValues.size() - 1],
                    ComplexTraits::kMax);
  for (size_t i = 1; i < ComplexTraits::kValues.size(); ++i) {
    PW_TEST_EXPECT_TRUE(
        static_cast<ComplexTraits::underlying_type>(
            ComplexTraits::kValues[i - 1]) <
        static_cast<ComplexTraits::underlying_type>(ComplexTraits::kValues[i]));
  }
});

PW_CONSTEXPR_TEST(EnumTraitsTest, IsValidEnumerator, {
  // Sparse enum; generated as a switch.
  PW_TEST_EXPECT_TRUE(TestTraits::IsValid(::pw::testing::TestEnum::kFirst));
  PW_TEST_EXPECT_TRUE(TestTraits::IsValid(::pw::testing::TestEnum::kSecond));
  PW_TEST_EXPECT_TRUE(TestTraits::IsValid(::pw::testing::TestEnum::kFromH));
  PW_TEST_EXPECT_FALSE(
      TestTraits::IsValid(static_cast<::pw::testing::TestEnum>(50)));

  // Contiguous enum; generated as a range check.
  PW_TEST_EXPECT_TRUE(
      StandaloneTraits::IsValid(::pw::enum_test::Standalone::kOne));
  PW_TEST_EXPECT_TRUE(
      StandaloneTraits::IsValid(::pw::enum_test::Standalone::kTwo));
  PW_TEST_EXPECT_FALSE(
      StandaloneTraits::IsValid(static_cast<::pw::enum_test::Standalone>(0)));
  PW_TEST_EXPECT_FALSE(
      StandaloneTraits::IsValid(static_cast<::pw::enum_test::Standalone>(3)));

  // Single-value enum; generated as an equality check.
  PW_TEST_EXPECT_TRUE(
      SingleValueTraits::IsValid(::pw::testing::ReferencesComplex::kVal));
  PW_TEST_EXPECT_FALSE(SingleValueTraits::IsValid(
      static_cast<::pw::testing::ReferencesComplex>(0)));

  // Every listed value is valid.
  for (::a::b::c::d::ComplexEnum value : ComplexTraits::kValues) {
    PW_TEST_EXPECT_TRUE(ComplexTraits::IsValid(value));
  }
});

PW_CONSTEXPR_TEST(EnumTraitsTest, IsValidInteger, {
  // TestEnum has an unsigned underlying type.
  PW_TEST_EXPECT_TRUE(TestTraits::IsValid(0));
  PW_TEST_EXPECT_TRUE(TestTraits::IsValid(1));
  PW_TEST_EXPECT_TRUE(TestTraits::IsValid(100));
  PW_TEST_EXPECT_FALSE(TestTraits::IsValid(50));
  PW_TEST_EXPECT_FALSE(TestTraits::IsValid(200));
  // Negative and out-of-range values must not wrap into the valid range.
  PW_TEST_EXPECT_FALSE(TestTraits::IsValid(-1));
  PW_TEST_EXPECT_FALSE(TestTraits::IsValid(-156));
  PW_TEST_EXPECT_FALSE(TestTraits::IsValid(356));
  PW_TEST_EXPECT_FALSE(TestTraits::IsValid(int64_t{-1}));
  PW_TEST_EXPECT_FALSE(TestTraits::IsValid(uint64_t{1} << 40));

  PW_TEST_EXPECT_TRUE(StandaloneTraits::IsValid(1));
  PW_TEST_EXPECT_TRUE(StandaloneTraits::IsValid(2));
  PW_TEST_EXPECT_FALSE(StandaloneTraits::IsValid(0));
  PW_TEST_EXPECT_FALSE(StandaloneTraits::IsValid(3));
  PW_TEST_EXPECT_FALSE(StandaloneTraits::IsValid(-1));

  // ComplexEnum has a signed underlying type and a negative enumerator.
  PW_TEST_EXPECT_TRUE(ComplexTraits::IsValid(-1));
  PW_TEST_EXPECT_TRUE(ComplexTraits::IsValid(0));
  PW_TEST_EXPECT_TRUE(ComplexTraits::IsValid(1));
  PW_TEST_EXPECT_TRUE(ComplexTraits::IsValid(2));
  PW_TEST_EXPECT_TRUE(ComplexTraits::IsValid(17));
  PW_TEST_EXPECT_TRUE(ComplexTraits::IsValid(uint8_t{17}));
  PW_TEST_EXPECT_FALSE(ComplexTraits::IsValid(-2));
  PW_TEST_EXPECT_FALSE(ComplexTraits::IsValid(3));
  PW_TEST_EXPECT_FALSE(ComplexTraits::IsValid(100));
  PW_TEST_EXPECT_FALSE(ComplexTraits::IsValid(uint64_t{1} << 40));
});

PW_CONSTEXPR_TEST(EnumTraitsTest, BoolUnderlyingType, {
  // An enum backed by `bool` gets ordinary traits.
  PW_TEST_EXPECT_EQ(BoolTraits::kDistinctValueCount, 2u);
  PW_TEST_EXPECT_TRUE(BoolTraits::kIsContiguous);
  PW_TEST_EXPECT_EQ(BoolTraits::kMin, ::pw::testing::BoolEnum::kFalse);
  PW_TEST_EXPECT_EQ(BoolTraits::kMax, ::pw::testing::BoolEnum::kTrue);

  PW_TEST_EXPECT_TRUE(BoolTraits::IsValid(::pw::testing::BoolEnum::kFalse));
  PW_TEST_EXPECT_TRUE(BoolTraits::IsValid(::pw::testing::BoolEnum::kTrue));

  // Integers are bounds checked against a `bool` [kMin, kMax] pair. This
  // exercises every CmpLess branch that can be reached with an unsigned,
  // one-bit underlying type.
  PW_TEST_EXPECT_TRUE(BoolTraits::IsValid(0));
  PW_TEST_EXPECT_TRUE(BoolTraits::IsValid(1));
  PW_TEST_EXPECT_FALSE(BoolTraits::IsValid(2));
  PW_TEST_EXPECT_FALSE(BoolTraits::IsValid(-1));
  PW_TEST_EXPECT_TRUE(BoolTraits::IsValid(1u));
  PW_TEST_EXPECT_TRUE(BoolTraits::IsValid(uint64_t{1}));
  PW_TEST_EXPECT_FALSE(BoolTraits::IsValid(uint64_t{1} << 40));
  PW_TEST_EXPECT_FALSE(BoolTraits::IsValid(int64_t{-1}));
});

PW_CONSTEXPR_TEST(EnumTraitsTest, IsValidEnumHelper, {
  // The enum type is deduced from an enumerator.
  PW_TEST_EXPECT_TRUE(::pw::IsValidEnum(::pw::enum_test::Standalone::kOne));
  PW_TEST_EXPECT_TRUE(::pw::IsValidEnum(::pw::testing::TestEnum::kFirst));
  PW_TEST_EXPECT_FALSE(
      ::pw::IsValidEnum(static_cast<::pw::testing::TestEnum>(50)));

  // The enum type is specified explicitly for integers.
  PW_TEST_EXPECT_TRUE(::pw::IsValidEnum<::pw::enum_test::Standalone>(1));
  PW_TEST_EXPECT_FALSE(::pw::IsValidEnum<::pw::enum_test::Standalone>(99));
  PW_TEST_EXPECT_TRUE(::pw::IsValidEnum<::pw::testing::TestEnum>(100));
  PW_TEST_EXPECT_FALSE(::pw::IsValidEnum<::pw::testing::TestEnum>(50));
  PW_TEST_EXPECT_FALSE(::pw::IsValidEnum<::pw::testing::TestEnum>(-1));
});

template <typename Enum, typename Arg, typename = void>
struct CanCallTraitsIsValid : std::false_type {};

template <typename Enum, typename Arg>
struct CanCallTraitsIsValid<
    Enum,
    Arg,
    std::void_t<decltype(::pw::EnumTraits<Enum>::IsValid(std::declval<Arg>()))>>
    : std::true_type {};

template <typename Enum, typename Arg, typename = void>
struct CanCallIsValidEnum : std::false_type {};

template <typename Enum, typename Arg>
struct CanCallIsValidEnum<
    Enum,
    Arg,
    std::void_t<decltype(::pw::IsValidEnum<Enum>(std::declval<Arg>()))>>
    : std::true_type {};

TEST(EnumTraitsTest, RejectsNonIntegerAndUnrelatedTypes) {
  static_assert(CanCallTraitsIsValid<::pw::testing::TestEnum,
                                     ::pw::testing::TestEnum>::value);
  static_assert(CanCallTraitsIsValid<::pw::testing::TestEnum, int>::value);
  static_assert(CanCallTraitsIsValid<::pw::testing::TestEnum, uint8_t>::value);
  static_assert(!CanCallTraitsIsValid<::pw::testing::TestEnum, bool>::value);
  static_assert(
      !CanCallTraitsIsValid<::pw::testing::TestEnum, const bool>::value);
  static_assert(!CanCallTraitsIsValid<::pw::testing::TestEnum, double>::value);
  static_assert(!CanCallTraitsIsValid<::pw::testing::TestEnum,
                                      ::pw::enum_test::Standalone>::value);
  static_assert(!CanCallTraitsIsValid<::pw::testing::TestEnum,
                                      ::pw::enum_test::base::BaseEnum>::value);

  static_assert(CanCallIsValidEnum<::pw::testing::TestEnum,
                                   ::pw::testing::TestEnum>::value);
  static_assert(CanCallIsValidEnum<::pw::testing::TestEnum, int>::value);
  static_assert(CanCallIsValidEnum<::pw::testing::TestEnum, uint8_t>::value);
  static_assert(!CanCallIsValidEnum<::pw::testing::TestEnum, bool>::value);
  static_assert(!CanCallIsValidEnum<::pw::testing::TestEnum, double>::value);
  static_assert(!CanCallIsValidEnum<::pw::testing::TestEnum,
                                    ::pw::enum_test::Standalone>::value);
  static_assert(!CanCallIsValidEnum<::pw::testing::TestEnum,
                                    ::pw::enum_test::base::BaseEnum>::value);

  // `bool` is rejected as an argument even when the enum's underlying type is
  // `bool`. Pass an enumerator instead.
  static_assert(CanCallTraitsIsValid<::pw::testing::BoolEnum, int>::value);
  static_assert(!CanCallTraitsIsValid<::pw::testing::BoolEnum, bool>::value);
  static_assert(!CanCallIsValidEnum<::pw::testing::BoolEnum, bool>::value);
}

TEST(EnumTraitsTest, HasEnumTraits) {
  static_assert(::pw::has_enum_traits_v<::pw::testing::TestEnum>);
  static_assert(::pw::has_enum_traits_v<::a::b::c::d::ComplexEnum>);
  static_assert(
      ::pw::has_enum_traits_v<::pw::testing::OuterStruct::NestedEnum>);
  static_assert(::pw::has_enum_traits_v<::pw::enum_test::Standalone>);
  static_assert(::pw::has_enum_traits_v<::pw::testing::BoolEnum>);

  static_assert(!::pw::has_enum_traits_v<HandwrittenTestEnum>);
  static_assert(!::pw::has_enum_traits_v<int>);
}

}  // namespace

// Enum used to verify that a hand-written `pw::EnumTraits` specialization is
// not accepted. It lives at namespace scope because a specialization must be
// declared in the namespace enclosing the primary template.
//
// Do not copy this pattern: specializing `pw::EnumTraits` by hand is exactly
// what this test exists to reject. Use PW_ENUM instead.
enum class UntaggedTraitsEnum { kValue = 0 };

namespace pw {

// Provides the whole documented API, but is missing the generated tag.
template <>
struct EnumTraits<UntaggedTraitsEnum> {
  using enum_type = UntaggedTraitsEnum;
  using underlying_type = std::underlying_type_t<enum_type>;

  static constexpr std::string_view kName = "UntaggedTraitsEnum";
  static constexpr std::string_view kFullyQualifiedName =
      "::UntaggedTraitsEnum";
  static constexpr std::string_view kTokenDomain = "";

  static constexpr size_t kDistinctValueCount = 1;
  static constexpr bool kIsContiguous = true;

  static constexpr enum_type kMin = UntaggedTraitsEnum::kValue;
  static constexpr enum_type kMax = UntaggedTraitsEnum::kValue;

  static constexpr std::array<enum_type, kDistinctValueCount> kValues = {{
      UntaggedTraitsEnum::kValue,
  }};

  static constexpr bool IsValid(enum_type value) { return value == kMin; }

  template <typename Integer,
            typename = std::enable_if_t<internal::kIsInteger<Integer>>>
  static constexpr bool IsValid(Integer value) {
    return internal::IsValidInteger<enum_type>(value);
  }
};

}  // namespace pw

namespace {

TEST(EnumTraitsTest, RejectsHandWrittenSpecializations) {
  // Only specializations tagged by the code generator are recognized, even if
  // they otherwise provide the entire API.
  static_assert(!::pw::has_enum_traits_v<UntaggedTraitsEnum>);
}

}  // namespace