From 4363088a85a219c6e101e158d4634cd490a8c72d Mon Sep 17 00:00:00 2001
From: Dan Goodliffe <dan.goodliffe@octal.co.uk>
Date: Mon, 28 Apr 2025 09:31:42 +0100
Subject: Fix all warnings in enumeration details code/tests

---
 test/test-static-enumDetails.cpp | 126 +++++++++++++++++++--------------------
 1 file changed, 63 insertions(+), 63 deletions(-)

(limited to 'test/test-static-enumDetails.cpp')

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 <enumDetails.h>
 
 // Test type name
-static_assert(EnumTypeDetails<GlobalUnscoped>::typeName == "GlobalUnscoped");
-static_assert(EnumTypeDetails<GlobalScoped>::typeName == "GlobalScoped");
-static_assert(EnumTypeDetails<ns::Unscoped>::typeName == "ns::Unscoped");
-static_assert(EnumTypeDetails<ns::Scoped>::typeName == "ns::Scoped");
+static_assert(EnumTypeDetails<GlobalUnscoped>::TYPE_NAME == "GlobalUnscoped");
+static_assert(EnumTypeDetails<GlobalScoped>::TYPE_NAME == "GlobalScoped");
+static_assert(EnumTypeDetails<ns::Unscoped>::TYPE_NAME == "ns::Unscoped");
+static_assert(EnumTypeDetails<ns::Scoped>::TYPE_NAME == "ns::Scoped");
 
-static_assert(EnumValueDetails<GlobalUnscoped::aa>::valueName == "aa");
-static_assert(EnumValueDetails<GlobalScoped::aa>::valueName == "aa");
-static_assert(EnumValueDetails<ns::Unscoped::aa>::valueName == "aa");
-static_assert(EnumValueDetails<ns::Scoped::aa>::valueName == "aa");
+static_assert(EnumValueDetails<GlobalUnscoped::Aa>::VALUE_NAME == "Aa");
+static_assert(EnumValueDetails<GlobalScoped::Aa>::VALUE_NAME == "Aa");
+static_assert(EnumValueDetails<ns::Unscoped::Aa>::VALUE_NAME == "Aa");
+static_assert(EnumValueDetails<ns::Scoped::Aa>::VALUE_NAME == "Aa");
 
 namespace test1 {
-	static_assert(EnumValueDetails<DefaultDense::a>::valid);
-	static_assert(EnumValueDetails<DefaultDense::de>::valid);
-	static_assert(EnumValueDetails<static_cast<DefaultDense>(0)>::valid);
-	static_assert(EnumValueDetails<static_cast<DefaultDense>(3)>::valid);
-	static_assert(!EnumValueDetails<static_cast<DefaultDense>(-1)>::valid);
-	static_assert(!EnumValueDetails<static_cast<DefaultDense>(4)>::valid);
-	static_assert(EnumValueDetails<DefaultDense::a>::valueName == "a");
-	static_assert(EnumValueDetails<DefaultDense::de>::valueName == "de");
-	using ED_DD = EnumDetails<DefaultDense>;
-	static_assert(EnumValueCollection<DefaultDense>::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<DefaultDense::A>::VALID);
+	static_assert(EnumValueDetails<DefaultDense::De>::VALID);
+	static_assert(EnumValueDetails<static_cast<DefaultDense>(0)>::VALID);
+	static_assert(EnumValueDetails<static_cast<DefaultDense>(3)>::VALID);
+	static_assert(!EnumValueDetails<static_cast<DefaultDense>(-1)>::VALID);
+	static_assert(!EnumValueDetails<static_cast<DefaultDense>(4)>::VALID);
+	static_assert(EnumValueDetails<DefaultDense::A>::VALUE_NAME == "A");
+	static_assert(EnumValueDetails<DefaultDense::De>::VALUE_NAME == "De");
+	using EdDd = EnumDetails<DefaultDense>;
+	static_assert(EnumValueCollection<DefaultDense>::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<DefaultDense>(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<DefaultDense>(10)).has_value());
 }
 
 namespace test2 {
-	static_assert(EnumValueDetails<NumberedSparse::bee>::valid);
-	static_assert(EnumValueDetails<static_cast<NumberedSparse>(0)>::valid);
-	static_assert(EnumValueDetails<static_cast<NumberedSparse>(3)>::valid);
-	static_assert(EnumValueDetails<static_cast<NumberedSparse>(-20)>::valid);
-	static_assert(EnumValueDetails<static_cast<NumberedSparse>(100)>::valid);
-	static_assert(!EnumValueDetails<static_cast<NumberedSparse>(2)>::valid);
-	static_assert(EnumValueDetails<NumberedSparse::a>::valueName == "a");
-	static_assert(EnumValueDetails<NumberedSparse::de>::valueName == "de");
-	using ED_NS = EnumDetails<NumberedSparse>;
+	static_assert(EnumValueDetails<NumberedSparse::Bee>::VALID);
+	static_assert(EnumValueDetails<static_cast<NumberedSparse>(0)>::VALID);
+	static_assert(EnumValueDetails<static_cast<NumberedSparse>(3)>::VALID);
+	static_assert(EnumValueDetails<static_cast<NumberedSparse>(-20)>::VALID);
+	static_assert(EnumValueDetails<static_cast<NumberedSparse>(100)>::VALID);
+	static_assert(!EnumValueDetails<static_cast<NumberedSparse>(2)>::VALID);
+	static_assert(EnumValueDetails<NumberedSparse::A>::VALUE_NAME == "A");
+	static_assert(EnumValueDetails<NumberedSparse::De>::VALUE_NAME == "De");
+	using EdNs = EnumDetails<NumberedSparse>;
 	static_assert(EnumValueCollection<NumberedSparse>::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<NumberedSparse>(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<NumberedSparse>(10)).has_value());
 }
-- 
cgit v1.2.3