Ichthyostega
20392eee1c
This resolves an intricate problem related to metaprogramming with variadic templates and function signatures. Due to exceptional complexity, a direct solution was blocked for several years, and required a better organisation of the support code involved; several workarounds were developed, gradually leading to a transition path, which could now be completed in an focused clean-up effort over the last week. Metaprogramming with sequences of types is organised into three layers: - simple tasks can be solved with the standard facilities of the language, using pattern match with variadic template specialisations - the ''type-sequence'' construct `Types<T...>` takes the centre stage for the explicit definition of collections of types; it can be re-bound to other variadic templates and supports simple direct manipulation - for more elaborate and advanced processing tasks, a ''Loki-style type list'' can be obtained from a type-sequence, allowing to perform recursive list processing task with a technique similar to LISP.
261 lines
7.4 KiB
C++
261 lines
7.4 KiB
C++
/*
|
||
Variant(Test) - verify the lightweight typesafe union record
|
||
|
||
Copyright (C)
|
||
2015, Hermann Vosseler <Ichthyostega@web.de>
|
||
|
||
**Lumiera** is free software; you can redistribute it and/or modify it
|
||
under the terms of the GNU General Public License as published by the
|
||
Free Software Foundation; either version 2 of the License, or (at your
|
||
option) any later version. See the file COPYING for further details.
|
||
|
||
* *****************************************************************/
|
||
|
||
/** @file variant-test.cpp
|
||
** unit test \ref Variant_test
|
||
*/
|
||
|
||
|
||
|
||
#include "lib/test/run.hpp"
|
||
#include "lib/test/test-helper.hpp"
|
||
#include "lib/time/timevalue.hpp"
|
||
#include "lib/format-cout.hpp"
|
||
#include "lib/variant.hpp"
|
||
#include "lib/util.hpp"
|
||
|
||
#include <string>
|
||
|
||
|
||
namespace lib {
|
||
namespace test{
|
||
|
||
using ::Test;
|
||
using meta::Types;
|
||
using lib::time::Time;
|
||
using lib::time::TimeVar;
|
||
|
||
using util::contains;
|
||
using std::string;
|
||
|
||
using error::LUMIERA_ERROR_WRONG_TYPE;
|
||
using error::LUMIERA_ERROR_LOGIC;
|
||
|
||
|
||
// Test fixture...
|
||
using TestVariant = Variant<Types<bool,int,string,Time>>;
|
||
|
||
|
||
|
||
|
||
/****************************************************************************//**
|
||
* @test cover the essential properties of Lumiera's lightweight variant record.
|
||
* - this typesafe union can never be constructed empty
|
||
* - it defaults to the default constructed first type in list
|
||
* - it is copyable and assignable, but only with compatible type
|
||
* - value access requires knowledge of the contained type
|
||
* - generic visitor style access
|
||
*
|
||
* @see lib::Variant
|
||
* @see util::AccessCasted
|
||
* @see lib::OpaqueHolder
|
||
* @see TreeMutator_test
|
||
*/
|
||
class Variant_test : public Test
|
||
{
|
||
|
||
virtual void
|
||
run (Arg)
|
||
{
|
||
seedRand();
|
||
createVariant();
|
||
accessVariant();
|
||
acceptPredicate();
|
||
verifyAssignment();
|
||
}
|
||
|
||
|
||
void
|
||
createVariant()
|
||
{
|
||
Time someTime;
|
||
TestVariant v0;
|
||
TestVariant v1(11);
|
||
TestVariant v2(string("lololo"));
|
||
TestVariant v3(someTime);
|
||
|
||
//// does not compile....
|
||
// TestVariant evil(3.1415);
|
||
|
||
cout << v0 <<endl
|
||
<< v1 <<endl
|
||
<< v2 <<endl
|
||
<< v3 <<endl;
|
||
|
||
CHECK (contains (string(v0), "Variant"));
|
||
CHECK (contains (string(v0), "bool"));
|
||
CHECK (contains (string(v0), "false"));
|
||
|
||
CHECK (contains (string(v1), "Variant"));
|
||
CHECK (contains (string(v1), "int"));
|
||
CHECK (contains (string(v1), "11"));
|
||
|
||
CHECK (contains (string(v2), "Variant"));
|
||
CHECK (contains (string(v2), "string"));
|
||
CHECK (contains (string(v2), "lololo"));
|
||
|
||
CHECK (contains (string(v3), "Variant"));
|
||
CHECK (contains (string(v3), "Time"));
|
||
CHECK (contains (string(v3), "0:00:00.000"));
|
||
}
|
||
|
||
|
||
void
|
||
accessVariant()
|
||
{
|
||
int someVal = rani(10000);
|
||
string someStr = randStr(55);
|
||
Time someTime = randTime();
|
||
|
||
TestVariant v3(someTime);
|
||
TestVariant v2(someStr);
|
||
TestVariant v1 = someVal;
|
||
TestVariant v0; v0 = true;
|
||
|
||
CHECK (true == v0.get<bool>() );
|
||
CHECK (someVal == v1.get<int>());
|
||
CHECK (someStr == v2.get<string>() );
|
||
CHECK (someTime == v3.get<Time>() );
|
||
|
||
VERIFY_ERROR (WRONG_TYPE, v0.get<int>() );
|
||
VERIFY_ERROR (WRONG_TYPE, v0.get<string>() );
|
||
VERIFY_ERROR (WRONG_TYPE, v0.get<Time>() );
|
||
|
||
VERIFY_ERROR (WRONG_TYPE, v1.get<bool>() );
|
||
VERIFY_ERROR (WRONG_TYPE, v1.get<string>() );
|
||
VERIFY_ERROR (WRONG_TYPE, v1.get<Time>() );
|
||
|
||
VERIFY_ERROR (WRONG_TYPE, v2.get<bool>() );
|
||
VERIFY_ERROR (WRONG_TYPE, v2.get<int>() );
|
||
VERIFY_ERROR (WRONG_TYPE, v2.get<Time>() );
|
||
|
||
VERIFY_ERROR (WRONG_TYPE, v3.get<bool>() );
|
||
VERIFY_ERROR (WRONG_TYPE, v3.get<int>() );
|
||
VERIFY_ERROR (WRONG_TYPE, v3.get<string>() );
|
||
|
||
//// does not compile...
|
||
// v0.get<int>();
|
||
// v1.get<double>();
|
||
// v3.get<TimeVar>();
|
||
|
||
struct Accessor
|
||
: TestVariant::Visitor
|
||
{
|
||
bool b_ = false;
|
||
int i_ = 12;
|
||
TimeVar t_;
|
||
|
||
void handle (bool& b) { b_ = b; }
|
||
void handle (Time& t) { t_ = t; }
|
||
|
||
void handle (int& i6)
|
||
{
|
||
i_ = i6;
|
||
++i6;
|
||
}
|
||
};
|
||
|
||
Accessor acs;
|
||
CHECK (!acs.b_);
|
||
CHECK (acs.i_ == 12);
|
||
|
||
v0.accept (acs);
|
||
CHECK (acs.b_);
|
||
CHECK (acs.i_ == 12);
|
||
|
||
v3.accept (acs);
|
||
CHECK (acs.b_);
|
||
CHECK (acs.i_ == 12);
|
||
CHECK (acs.t_ == someTime);
|
||
|
||
v2.accept (acs);
|
||
// nothing changed,
|
||
// since we defined no accessor function
|
||
CHECK (acs.b_);
|
||
CHECK (acs.i_ == 12);
|
||
CHECK (acs.t_ == someTime);
|
||
|
||
v1.accept (acs);
|
||
CHECK (acs.b_);
|
||
CHECK (acs.t_ == someTime);
|
||
CHECK (acs.i_ == someVal);
|
||
|
||
// side-effect!
|
||
CHECK (someVal+1 == v1.get<int>());
|
||
v1.accept (acs);
|
||
CHECK (someVal+2 == v1.get<int>());
|
||
CHECK (someVal+1 == acs.i_);
|
||
}
|
||
|
||
|
||
void
|
||
acceptPredicate()
|
||
{
|
||
const TestVariant v1(12);
|
||
const TestVariant v2(string("123"));
|
||
const TestVariant v3(Time::NEVER);
|
||
|
||
struct Checker
|
||
: TestVariant::Predicate
|
||
{
|
||
bool handle (int const& i) { return i % 2; }
|
||
bool handle (string const& s) { return s.length() % 2; }
|
||
}
|
||
check;
|
||
|
||
CHECK (12 == v1.get<int>());
|
||
CHECK ("123" == v2.get<string>());
|
||
CHECK (Time::NEVER == v3.get<Time>());
|
||
|
||
CHECK (!v1.accept(check));
|
||
CHECK ( v2.accept(check));
|
||
CHECK (!v3.accept(check));
|
||
|
||
CHECK (12 == v1.get<int>());
|
||
CHECK ("123" == v2.get<string>());
|
||
CHECK (Time::NEVER == v3.get<Time>());
|
||
}
|
||
|
||
|
||
void
|
||
verifyAssignment()
|
||
{
|
||
TestVariant v1(string("boo"));
|
||
TestVariant v2(23);
|
||
TestVariant v3(42);
|
||
|
||
v1 = string("booo");
|
||
v2 = v3;
|
||
v3 = 24;
|
||
CHECK ("booo" == v1.get<string>());
|
||
CHECK (42 == v2.get<int>());
|
||
CHECK (24 == v3.get<int>());
|
||
|
||
VERIFY_ERROR (WRONG_TYPE, v1 = v2 );
|
||
VERIFY_ERROR (WRONG_TYPE, v1 = 22);
|
||
VERIFY_ERROR (WRONG_TYPE, v2 = string("2"));
|
||
|
||
TestVariant v4 = Time();
|
||
TestVariant v44 = Time(0,4,4,4); // OK: copy initialisation
|
||
VERIFY_ERROR (LOGIC, v4 = v44); // Runtime Error: not assignable
|
||
|
||
// v44 = Time(4,4); // does not compile: Time is not assignable
|
||
}
|
||
};
|
||
|
||
|
||
/** Register this test class... */
|
||
LAUNCHER (Variant_test, "unit common");
|
||
|
||
|
||
}} // namespace lib::test
|