1
0
forked from Alepha/Alepha
Files
2024-07-08 17:06:31 -04:00

206 lines
5.0 KiB
C++

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