Alepha/UniversalAggregate.test/0.cc

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;
			}
		};


	};
}