From 4363088a85a219c6e101e158d4634cd490a8c72d Mon Sep 17 00:00:00 2001 From: Dan Goodliffe Date: Mon, 28 Apr 2025 09:31:42 +0100 Subject: Fix all warnings in enumeration details code/tests --- test/enumDetailsData.h | 15 ++--- test/test-enumDetails.cpp | 46 +++++++------- test/test-static-enumDetails.cpp | 126 +++++++++++++++++++-------------------- 3 files changed, 94 insertions(+), 93 deletions(-) (limited to 'test') diff --git a/test/enumDetailsData.h b/test/enumDetailsData.h index b7bd601..6383838 100644 --- a/test/enumDetailsData.h +++ b/test/enumDetailsData.h @@ -1,23 +1,24 @@ #pragma once +#include #include -enum GlobalUnscoped { aa, b, c }; -enum class GlobalScoped { aa, b, c }; +enum GlobalUnscoped : uint8_t { Aa, B, C }; +enum class GlobalScoped : int8_t { Aa, B, C }; namespace ns { - enum Unscoped { aa, b, c }; - enum class Scoped { aa, b, c }; + enum Unscoped : int8_t { Aa, B, C }; + enum class Scoped : int8_t { Aa, B, C }; } namespace test1 { - enum class DefaultDense { a, bee, ci, de }; + enum class DefaultDense : int8_t { A, Bee, Ci, De }; } namespace test2 { - enum class NumberedSparse { a = 0, bee = 3, ci = -20, de = 100 }; + enum class NumberedSparse : int8_t { A = 0, Bee = 3, Ci = -20, De = 100 }; } template<> struct EnumValueCollection { // Any ordered integer_sequence which includes all enumeration values - using Vs = std::integer_sequence; + using Vs = std::integer_sequence; }; diff --git a/test/test-enumDetails.cpp b/test/test-enumDetails.cpp index 0e759e5..6bcd627 100644 --- a/test/test-enumDetails.cpp +++ b/test/test-enumDetails.cpp @@ -7,47 +7,47 @@ #include #include -constexpr std::array INVALID_NAMES {"", "missing", "GlobalScoped::aa", "GlobalScoped", "ns::aa", "a", "bb"}; -constexpr std::array VALID_NAMES {"aa", "b", "c"}; -template constexpr std::array VALID_VALUES {E::aa, E::b, E::c}; +constexpr std::array INVALID_NAMES {"", "missing", "GlobalScoped::Aa", "GlobalScoped", "ns::Aa", "A", "Bb"}; +constexpr std::array VALID_NAMES {"Aa", "B", "C"}; +template constexpr std::array VALID_VALUES {E::Aa, E::B, E::C}; // Not a template, else Boost test framework throws printing the context constexpr std::array INVALID_VALUES {-1, 3, 20}; #define TESTS_FOR_TYPE(TYPE) \ - BOOST_DATA_TEST_CASE(invalid_check_##TYPE, INVALID_VALUES, in) \ + BOOST_DATA_TEST_CASE(invalid_check_##TYPE, INVALID_VALUES, input) \ { \ - BOOST_CHECK(!EnumDetails::is_valid(static_cast(in))); \ + BOOST_CHECK(!EnumDetails::isValid(static_cast(input))); \ } \ - BOOST_DATA_TEST_CASE(invalid_parse_##TYPE, INVALID_NAMES, in) \ + BOOST_DATA_TEST_CASE(invalid_parse_##TYPE, INVALID_NAMES, input) \ { \ - BOOST_CHECK(!EnumDetails::parse(in).has_value()); \ + BOOST_CHECK(!EnumDetails::parse(input).has_value()); \ } \ - BOOST_DATA_TEST_CASE(invalid_to_string_##TYPE, INVALID_VALUES, in) \ + BOOST_DATA_TEST_CASE(invalid_to_string_##TYPE, INVALID_VALUES, input) \ { \ - BOOST_CHECK(!EnumDetails::to_string(static_cast(in)).has_value()); \ + BOOST_CHECK(!EnumDetails::toString(static_cast(input)).has_value()); \ } \ - BOOST_DATA_TEST_CASE(valid_check_##TYPE, VALID_VALUES, in) \ + BOOST_DATA_TEST_CASE(valid_check_##TYPE, VALID_VALUES, input) \ { \ - BOOST_CHECK(EnumDetails::is_valid(in)); \ + BOOST_CHECK(EnumDetails::isValid(input)); \ } \ - BOOST_DATA_TEST_CASE(valid_parse_##TYPE, VALID_NAMES ^ VALID_VALUES, in, out) \ + BOOST_DATA_TEST_CASE(valid_parse_##TYPE, VALID_NAMES ^ VALID_VALUES, input, output) \ { \ - const auto v = EnumDetails::parse(in); \ - BOOST_CHECK_IF(vo, v.has_value()) { \ - BOOST_CHECK_EQUAL(v.value(), out); \ + const auto parsed = EnumDetails::parse(input); \ + BOOST_CHECK_IF(parsedOK, parsed.has_value()) { \ + BOOST_CHECK_EQUAL(parsed.value(), output); \ } \ } \ - BOOST_DATA_TEST_CASE(valid_to_string_##TYPE, VALID_VALUES ^ VALID_NAMES, in, out) \ + BOOST_DATA_TEST_CASE(valid_to_string_##TYPE, VALID_VALUES ^ VALID_NAMES, input, output) \ { \ - const auto v = EnumDetails::to_string(in); \ - BOOST_CHECK_IF(vo, v.has_value()) { \ - BOOST_CHECK_EQUAL(v.value(), out); \ + const auto parsed = EnumDetails::toString(input); \ + BOOST_CHECK_IF(parsedOK, parsed.has_value()) { \ + BOOST_CHECK_EQUAL(parsed.value(), output); \ } \ } TESTS_FOR_TYPE(GlobalScoped) TESTS_FOR_TYPE(GlobalUnscoped) -using ns_unscoped = ns::Unscoped; -using ns_scoped = ns::Scoped; -TESTS_FOR_TYPE(ns_unscoped) -TESTS_FOR_TYPE(ns_scoped) +using NsUnscoped = ns::Unscoped; +using NsScoped = ns::Scoped; +TESTS_FOR_TYPE(NsUnscoped) +TESTS_FOR_TYPE(NsScoped) diff --git a/test/test-static-enumDetails.cpp b/test/test-static-enumDetails.cpp index 5f81753..932a2af 100644 --- a/test/test-static-enumDetails.cpp +++ b/test/test-static-enumDetails.cpp @@ -3,76 +3,76 @@ #include // Test type name -static_assert(EnumTypeDetails::typeName == "GlobalUnscoped"); -static_assert(EnumTypeDetails::typeName == "GlobalScoped"); -static_assert(EnumTypeDetails::typeName == "ns::Unscoped"); -static_assert(EnumTypeDetails::typeName == "ns::Scoped"); +static_assert(EnumTypeDetails::TYPE_NAME == "GlobalUnscoped"); +static_assert(EnumTypeDetails::TYPE_NAME == "GlobalScoped"); +static_assert(EnumTypeDetails::TYPE_NAME == "ns::Unscoped"); +static_assert(EnumTypeDetails::TYPE_NAME == "ns::Scoped"); -static_assert(EnumValueDetails::valueName == "aa"); -static_assert(EnumValueDetails::valueName == "aa"); -static_assert(EnumValueDetails::valueName == "aa"); -static_assert(EnumValueDetails::valueName == "aa"); +static_assert(EnumValueDetails::VALUE_NAME == "Aa"); +static_assert(EnumValueDetails::VALUE_NAME == "Aa"); +static_assert(EnumValueDetails::VALUE_NAME == "Aa"); +static_assert(EnumValueDetails::VALUE_NAME == "Aa"); namespace test1 { - static_assert(EnumValueDetails::valid); - static_assert(EnumValueDetails::valid); - static_assert(EnumValueDetails(0)>::valid); - static_assert(EnumValueDetails(3)>::valid); - static_assert(!EnumValueDetails(-1)>::valid); - static_assert(!EnumValueDetails(4)>::valid); - static_assert(EnumValueDetails::valueName == "a"); - static_assert(EnumValueDetails::valueName == "de"); - using ED_DD = EnumDetails; - static_assert(EnumValueCollection::Vs::size() == 256); - static_assert(ED_DD::valid_flags.size() == 256); - static_assert(ED_DD::values.size() == 4); - static_assert(std::is_sorted(ED_DD::values.begin(), ED_DD::values.end())); - static_assert(ED_DD::values.at(0) == DefaultDense::a); - static_assert(ED_DD::values.at(3) == DefaultDense::de); - static_assert(ED_DD::names.at(0) == "a"); - static_assert(ED_DD::names.at(3) == "de"); + static_assert(EnumValueDetails::VALID); + static_assert(EnumValueDetails::VALID); + static_assert(EnumValueDetails(0)>::VALID); + static_assert(EnumValueDetails(3)>::VALID); + static_assert(!EnumValueDetails(-1)>::VALID); + static_assert(!EnumValueDetails(4)>::VALID); + static_assert(EnumValueDetails::VALUE_NAME == "A"); + static_assert(EnumValueDetails::VALUE_NAME == "De"); + using EdDd = EnumDetails; + static_assert(EnumValueCollection::Vs::size() == 127); + static_assert(EdDd::VALID_FLAGS.size() == 127); + static_assert(EdDd::VALUES.size() == 4); + static_assert(std::ranges::is_sorted(EdDd::VALUES)); + static_assert(EdDd::VALUES.at(0) == DefaultDense::A); + static_assert(EdDd::VALUES.at(3) == DefaultDense::De); + static_assert(EdDd::NAMES.at(0) == "A"); + static_assert(EdDd::NAMES.at(3) == "De"); - static_assert(ED_DD::is_valid(DefaultDense::a)); - static_assert(ED_DD::is_valid(DefaultDense::de)); - static_assert(!ED_DD::is_valid(DefaultDense(-1))); - static_assert(!ED_DD::parse("").has_value()); - static_assert(!ED_DD::parse("nonsense").has_value()); - static_assert(ED_DD::parse("bee").value() == DefaultDense::bee); - static_assert(ED_DD::parse("ci").value() == DefaultDense::ci); - static_assert(ED_DD::to_string(DefaultDense::de).value() == "de"); - static_assert(!ED_DD::to_string(static_cast(10)).has_value()); + static_assert(EdDd::isValid(DefaultDense::A)); + static_assert(EdDd::isValid(DefaultDense::De)); + static_assert(!EdDd::isValid(DefaultDense(-1))); + static_assert(!EdDd::parse("").has_value()); + static_assert(!EdDd::parse("nonsense").has_value()); + static_assert(EdDd::parse("Bee").value() == DefaultDense::Bee); + static_assert(EdDd::parse("Ci").value() == DefaultDense::Ci); + static_assert(EdDd::toString(DefaultDense::De).value() == "De"); + static_assert(!EdDd::toString(static_cast(10)).has_value()); } namespace test2 { - static_assert(EnumValueDetails::valid); - static_assert(EnumValueDetails(0)>::valid); - static_assert(EnumValueDetails(3)>::valid); - static_assert(EnumValueDetails(-20)>::valid); - static_assert(EnumValueDetails(100)>::valid); - static_assert(!EnumValueDetails(2)>::valid); - static_assert(EnumValueDetails::valueName == "a"); - static_assert(EnumValueDetails::valueName == "de"); - using ED_NS = EnumDetails; + static_assert(EnumValueDetails::VALID); + static_assert(EnumValueDetails(0)>::VALID); + static_assert(EnumValueDetails(3)>::VALID); + static_assert(EnumValueDetails(-20)>::VALID); + static_assert(EnumValueDetails(100)>::VALID); + static_assert(!EnumValueDetails(2)>::VALID); + static_assert(EnumValueDetails::VALUE_NAME == "A"); + static_assert(EnumValueDetails::VALUE_NAME == "De"); + using EdNs = EnumDetails; static_assert(EnumValueCollection::Vs::size() == 7); - static_assert(ED_NS::values.size() == 4); - static_assert(ED_NS::valid_flags.size() == 7); - static_assert(std::is_sorted(ED_NS::values.begin(), ED_NS::values.end())); - static_assert(ED_NS::values.at(0) == NumberedSparse::ci); - static_assert(ED_NS::values.at(1) == NumberedSparse::a); - static_assert(ED_NS::values.at(2) == NumberedSparse::bee); - static_assert(ED_NS::values.at(3) == NumberedSparse::de); - static_assert(ED_NS::names.at(0) == "ci"); - static_assert(ED_NS::names.at(1) == "a"); - static_assert(ED_NS::names.at(2) == "bee"); - static_assert(ED_NS::names.at(3) == "de"); + static_assert(EdNs::VALUES.size() == 4); + static_assert(EdNs::VALID_FLAGS.size() == 7); + static_assert(std::ranges::is_sorted(EdNs::VALUES)); + static_assert(EdNs::VALUES.at(0) == NumberedSparse::Ci); + static_assert(EdNs::VALUES.at(1) == NumberedSparse::A); + static_assert(EdNs::VALUES.at(2) == NumberedSparse::Bee); + static_assert(EdNs::VALUES.at(3) == NumberedSparse::De); + static_assert(EdNs::NAMES.at(0) == "Ci"); + static_assert(EdNs::NAMES.at(1) == "A"); + static_assert(EdNs::NAMES.at(2) == "Bee"); + static_assert(EdNs::NAMES.at(3) == "De"); - static_assert(ED_NS::is_valid(NumberedSparse::a)); - static_assert(ED_NS::is_valid(NumberedSparse::de)); - static_assert(!ED_NS::is_valid(NumberedSparse(-1))); - static_assert(!ED_NS::parse("").has_value()); - static_assert(!ED_NS::parse("nonsense").has_value()); - static_assert(ED_NS::parse("bee").value() == NumberedSparse::bee); - static_assert(ED_NS::parse("ci").value() == NumberedSparse::ci); - static_assert(ED_NS::to_string(NumberedSparse::ci).value() == "ci"); - static_assert(!ED_NS::to_string(static_cast(10)).has_value()); + static_assert(EdNs::isValid(NumberedSparse::A)); + static_assert(EdNs::isValid(NumberedSparse::De)); + static_assert(!EdNs::isValid(NumberedSparse(-1))); + static_assert(!EdNs::parse("").has_value()); + static_assert(!EdNs::parse("nonsense").has_value()); + static_assert(EdNs::parse("Bee").value() == NumberedSparse::Bee); + static_assert(EdNs::parse("Ci").value() == NumberedSparse::Ci); + static_assert(EdNs::toString(NumberedSparse::Ci).value() == "Ci"); + static_assert(!EdNs::toString(static_cast(10)).has_value()); } -- cgit v1.2.3