UA

UniversalAggregate.test/0.cc

@@ -0,0 +1,205 @@
+static_assert( __cplusplus > 2020'99 );
+
+#include <functional>
+
+#include <Alepha/UniversalAggregate.h>
+#include <Alepha/Exception.h>
+#include <Alepha/IOStreams/OStreamable.h>
+
+#include <Alepha/Testing/test.h>
+#include <Alepha/Testing/TableTest.h>
+
+/*!
+ * @file
+ * @todo test isVector
+ * @todo test operator/
+ * @todo test from vector constructor
+ * @todo test skipping constructor
+ * @todo test make skipping constructor default to 0 or add copy constructor
+ * @todo more UA tests
+ */
+
+namespace
+{
+	using namespace Alepha::Testing::exports;
+
+	Alepha::UniversalAggregate ua;
+
+	std::string
+	validUA_Key( std::string s )
+	{
+		Alepha::UA_Key uak( s );
+		return Alepha::IOStreams::String{} << uak;
+	};
+
+	bool
+	doesUA_KeyThrow( const std::string &s )
+	{
+		try
+		{
+			Alepha::UA_Key uak( s );
+		}
+		catch( ... )
+		{
+			return true;
+		}
+		return false;
+	}
+
+	std::string
+	parentOfUA_Key( std::string s )
+	{
+		Alepha::UA_Key uak( s );
+		return Alepha::IOStreams::String{} << uak.parent();
+	};
+
+	std::string
+	backOfUA_Key( std::string s )
+	{
+		Alepha::UA_Key uak( s );
+		return Alepha::IOStreams::String{} << uak.back();
+	};
+
+	std::string
+	istreamUA_Key( std::string s )
+	{
+		std::istringstream is(s);
+		Alepha::UA_Key uak;
+		is >> uak;
+		return Alepha::IOStreams::String{} << uak;
+	};
+
+	auto UA_Key_tests= Alepha::Utility::enroll <=[]
+	{
+		"UA_Key.Valid"_test <=TableTest< validUA_Key >::Cases
+		{
+			{ "1k", { "tony" }, "tony" },
+			{ "2k", { "tony.bonnie" }, "tony.bonnie" },
+			{ "1k1i", { "tony[5]" }, "tony[5]" },
+			{ "1k2i1k1i", { "tony[5][6].bonnie[7]" }, "tony[5][6].bonnie[7]" },
+		};
+
+		"UA_Key.Exceptions"_test <=TableTest< doesUA_KeyThrow >::Cases
+		{
+			{ "good", { "tony" }, false },
+			{ "bad-brackets-1", { "tony[[" }, true },
+			{ "bad-brackets-2", { "tony[" }, true },
+			{ "bad-brackets-3", { "tony]" }, true },
+			{ "bad-leading-dot", { ".tony" }, true },
+			{ "bad-leading-open", { "[tony" }, true },
+			{ "bad-leading-close", { "]tony" }, true },
+			{ "bad-index-empty", { "tony[]" }, true },
+			{ "bad-index-alpha", { "tony[a]" }, true },
+			{ "bad-index-containsAlpha", { "tony[1a3]" }, true },
+			{ "bad-index-containsSpace", { "tony[1 3]" }, true },
+			{ "bad-name-empty", { "tony..Bonnie" }, true },
+			{ "bad-name-leadingNumber1", { "2tony.Bonnie" }, true },
+			{ "bad-name-leadingNumber2", { "tony.2Bonnie" }, true },
+			{ "bad-name-illegalChar", { "to%ny" }, true },
+			{ "bad-name-containsSpace", { "to ny" }, true },
+		};
+
+		"UA_Key.Parent"_test <=TableTest< parentOfUA_Key >::Cases
+		{
+			{ "2lev", { std::string("tony.bonnie") }, "tony" },
+			{ "2lev[]", { std::string("tony[5]") }, "tony" },
+			{ "3lev", { std::string("tony[3].bonnie") }, "tony[3]" },
+			{ "1lev", { std::string("tony") }, "" },
+		};
+
+		"UA_Key.istream"_test <=TableTest< istreamUA_Key >::Cases
+		{
+			{ "2lev", { std::string("tony.bonnie") }, "tony.bonnie" },
+			{ "2lev[]", { std::string("tony[5]") }, "tony[5]" },
+			{ "3lev", { std::string("tony[3].bonnie") }, "tony[3].bonnie" },
+			{ "1lev", { std::string("tony") }, "tony" },
+		};
+
+		"UA_Key.Back"_test <=TableTest< backOfUA_Key >::Cases
+		{
+			{ "2lev", { std::string("tony.bonnie") }, "bonnie" },
+			{ "2lev[]", { std::string("tony[5]") }, "5" },
+			{ "3lev", { std::string("tony[3].bonnie") }, "bonnie" },
+			{ "1lev", { std::string("tony") }, "tony" },
+		};
+
+		"UA_KeyDefaultConstructor"_test <=[] () -> bool
+		{
+			Alepha::UA_Key uak;
+			std::ostringstream oss;
+			oss << uak;
+			return ( oss.str() == "" );
+		};
+	};
+
+	auto UA_test= Alepha::Utility::enroll <=[]
+	{
+		"UA_Simple1"_test <=[] () -> bool
+		{
+			Alepha::UniversalAggregate ua;
+			ua.insert( "tony", std::string( "bonnie" ) );
+			return std::get<std::string>( ua.at( "tony" ) ) == "bonnie";
+		};
+
+		"UA_Simple1Const"_test <=[] () -> bool
+		{
+			Alepha::UniversalAggregate ua;
+			ua.insert( "tony", std::string( "bonnie" ) );
+			const Alepha::UniversalAggregate ub= ua;
+			return std::get<std::string>( ub.at( "tony" ) ) == "bonnie";
+		};
+
+		"UA_Simple2"_test <=[] () -> bool
+		{
+			Alepha::UniversalAggregate ua, ub;
+			ua.insert( "tony", std::string( "bonnie" ) );
+			ua.insert( "gina", ub );
+			ua.insert( "gina.bobby", std::string("sam") );
+			return std::get<std::string>( ua.at( "gina.bobby" ) ) == "sam";
+		};
+
+		"UA_GetCreate"_test <=[] () -> bool   // creates missing level
+		{
+			Alepha::UniversalAggregate ua, ub;
+			ua.insert( "tony", std::string( "bonnie" ) );
+			ua.insert( "gina", ub );
+			ua.insert( "gina.bobby.bill", std::string("sam") );
+			return std::get<std::string>( ua.at( "gina.bobby.bill" ) ) == "sam";
+		};
+
+		"UA_Erase1"_test <=[] () -> bool
+		{
+			Alepha::UniversalAggregate ua, ub;
+			ua.insert( "tony", std::string( "bonnie" ) );
+			ua.insert( "gina", ub );
+			ua.erase( "tony" );
+			try
+			{
+				ua.at( "tony" );
+				return false;
+			}
+			catch( ... )
+			{
+				return true;
+			}
+		};
+
+		"UA_Erase2"_test <=[] () -> bool
+		{
+			Alepha::UniversalAggregate ua, ub;
+			ua.insert( "tony", std::string( "bonnie" ) );
+			ua.insert( "gina", ub );
+			ua.erase( "gina" );
+			try
+			{
+				return std::get<std::string>( ua.at( "tony" ) ) == "bonnie";
+			}
+			catch( ... )
+			{
+				return false;
+			}
+		};
+
+
+	};
+}

UniversalAggregate.test/CMakeLists.txt

@@ -0,0 +1 @@
+unit_test( 0 )