Ichthyostega
b0368a6d2b
horay! seems like madness? well -- found and squashed a bug: equality on RecordRef implicitly converted to GenNode(RecordRef), which always generates new (distinct) IDs and so never succeeds. What we really want is equality test on the references
762 lines
34 KiB
C++
762 lines
34 KiB
C++
/*
|
|
GenNodeBasic(Test) - fundamental properties of a generic tree node element
|
|
|
|
Copyright (C) Lumiera.org
|
|
2015, Hermann Vosseler <Ichthyostega@web.de>
|
|
|
|
This program 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.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
* *****************************************************/
|
|
|
|
|
|
#include "lib/test/run.hpp"
|
|
#include "lib/test/test-helper.hpp"
|
|
#include "lib/format-util.hpp"
|
|
#include "lib/diff/gen-node.hpp"
|
|
#include "lib/diff/record.hpp"
|
|
#include "lib/time/timevalue.hpp"
|
|
#include "lib/util.hpp"
|
|
|
|
//#include <utility>
|
|
//#include <string>
|
|
//#include <vector>
|
|
#include <iostream>
|
|
#include <cmath>
|
|
|
|
using util::isnil;
|
|
using util::contains;
|
|
using util::isSameObject;
|
|
using lib::hash::LuidH;
|
|
using lib::time::FSecs;
|
|
using lib::time::Time;
|
|
using lib::time::TimeSpan;
|
|
using lib::test::randTime;
|
|
//using std::string;
|
|
//using std::vector;
|
|
//using std::swap;
|
|
using std::fabs;
|
|
using std::cout;
|
|
using std::endl;
|
|
|
|
|
|
namespace lib {
|
|
namespace diff{
|
|
namespace test{
|
|
|
|
// using lumiera::error::LUMIERA_ERROR_LOGIC;
|
|
using error::LUMIERA_ERROR_WRONG_TYPE;
|
|
using error::LUMIERA_ERROR_BOTTOM_VALUE;
|
|
|
|
namespace {//Test fixture....
|
|
|
|
|
|
|
|
}//(End)Test fixture
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************//**
|
|
* @test Verify properties of a special collection type shaped for
|
|
* external representation of object-like data.
|
|
* - GenNode elements can be created "right away", picking up
|
|
* the given type, assumed that the payload is one of the
|
|
* supported basic types.
|
|
* - optionally, GenNode elements can be named
|
|
* - unnamed elements get a marker ID plus unique number extension
|
|
* - object-like elements can be represented by using a diff:Record<GenNode>
|
|
* as payload. Obviously, the resulting data structure type is recursive.
|
|
* - a shortcut is provided to simplify defining empty baseline objects
|
|
* - there is a special notation to create "id references", which can
|
|
* can be used to stand-in for an "object" (Record). This shortcut
|
|
* notation is relevant for the tree diff language -- used within
|
|
* Lumiera as "External Tree Description" of object networks.
|
|
*
|
|
* @see IndexTable
|
|
* @see DiffListApplication_test
|
|
*/
|
|
class GenNodeBasic_test : public Test
|
|
{
|
|
|
|
virtual void
|
|
run (Arg)
|
|
{
|
|
simpleUsage();
|
|
equalityMatch();
|
|
objectShortcut();
|
|
symbolReference();
|
|
sequenceIteration();
|
|
}
|
|
|
|
|
|
void
|
|
simpleUsage()
|
|
{
|
|
// can build from the supported value types
|
|
GenNode n1(42);
|
|
CHECK (42 == n1.data.get<int>());
|
|
CHECK (!n1.isNamed());
|
|
CHECK (contains (n1.idi.getSym(), "_CHILD_"));
|
|
CHECK (contains (name(n1), "_CHILD_"));
|
|
|
|
// can optionally be named
|
|
GenNode n2("π", 3.14159265358979323846264338328);
|
|
CHECK (fabs (3.14159265 - n2.data.get<double>()) < 1e-5 );
|
|
CHECK (n2.isNamed());
|
|
CHECK ("π" == n2.idi.getSym());
|
|
CHECK ("π" == name(n2));
|
|
|
|
// is a copyable value
|
|
GenNode n11(n1);
|
|
CHECK (n1 == n11);
|
|
CHECK (42 == n11.data.get<int>());
|
|
|
|
// is assignable with compatible payload value
|
|
n11.data = 24;
|
|
CHECK (n1 != n11);
|
|
CHECK (24 == n11.data.get<int>());
|
|
CHECK (42 == n1.data.get<int>());
|
|
|
|
// is assignable within the same kind of value
|
|
n1 = n11;
|
|
CHECK (n1 == n11);
|
|
|
|
// but assignment may not alter payload type
|
|
VERIFY_ERROR (WRONG_TYPE, n1 = n2 );
|
|
|
|
// can build recursive data structures
|
|
GenNode n3(Rec({GenNode("type", "spam"), GenNode("ham", "eggs")}));
|
|
CHECK ("spam" == n3.data.get<Rec>().getType());
|
|
CHECK ("eggs" == n3.data.get<Rec>().get("ham").data.get<string>());
|
|
CHECK ("ham" == n3.data.get<Rec>().get("ham").idi.getSym());
|
|
CHECK (n3.data.get<Rec>().get("ham").isNamed());
|
|
CHECK (!n3.isNamed());
|
|
|
|
cout << string(n3) <<endl; // diagnostic spam
|
|
}
|
|
|
|
|
|
void
|
|
objectShortcut()
|
|
{
|
|
auto o0 = MakeRec().genNode();
|
|
auto o1 = MakeRec().genNode("νόμος");
|
|
auto o2 = MakeRec().type("spam").genNode();
|
|
auto o3 = MakeRec().attrib("Ψ", int64_t(42), "π", 3.14159265358979323846264338328).genNode("λόγος");
|
|
|
|
CHECK (!o0.isNamed());
|
|
CHECK (isnil(o0.data.get<Rec>()));
|
|
CHECK ("NIL" == o0.data.get<Rec>().getType());
|
|
|
|
CHECK (o1.isNamed());
|
|
CHECK ("νόμος" == o1.idi.getSym());
|
|
CHECK (isnil(o1.data.get<Rec>()));
|
|
|
|
CHECK (!o2.isNamed());
|
|
CHECK ("spam" == o2.data.get<Rec>().getType());
|
|
CHECK (isnil(o2.data.get<Rec>()));
|
|
|
|
CHECK (o3.isNamed());
|
|
CHECK ("λόγος" == o3.idi.getSym());
|
|
CHECK ("NIL" == o3.data.get<Rec>().getType());
|
|
CHECK (GenNode("Ψ", int64_t(42)) == o3.data.get<Rec>().get("Ψ"));
|
|
CHECK (42L == o3.data.get<Rec>().get("Ψ").data.get<int64_t>());
|
|
CHECK (1e-7 > fabs (3.14159265 - o3.data.get<Rec>().get("π").data.get<double>()));
|
|
|
|
LuidH luid;
|
|
//Demonstration: object builder is based on the mutator mechanism for Records...
|
|
auto o4 = Rec::Mutator(o2.data.get<Rec>()) // ...use GenNode o2 as starting point
|
|
.appendChild(GenNode("τ", Time(1,2,3,4))) // a named node with Time value
|
|
.scope('*' // a char node
|
|
,"★" // a string node
|
|
,luid // a hash value (LUID)
|
|
,TimeSpan(Time::ZERO, FSecs(23,25)) // a time span
|
|
,MakeRec().type("ham").scope("eggs").genNode()) // a spam object
|
|
.genNode("baked beans"); // ---> finish into named node
|
|
|
|
CHECK (o4.isNamed());
|
|
CHECK ("baked beans" == o4.idi.getSym());
|
|
CHECK ("spam" == o4.data.get<Rec>().getType()); // this was "inherited" from o2
|
|
|
|
auto scope = o4.data.get<Rec>().scope();
|
|
CHECK (!isnil(scope));
|
|
CHECK (GenNode("τ", Time(1,2,3,4)) == *scope);
|
|
++scope;
|
|
CHECK (GenNode(char('*')) == *scope);
|
|
++scope;
|
|
CHECK ("★" == scope->data.get<string>());
|
|
++scope;
|
|
CHECK (luid == scope->data.get<LuidH>());
|
|
++scope;
|
|
CHECK (Time(920,0) == scope->data.get<TimeSpan>().end());
|
|
++scope;
|
|
auto spam = *scope;
|
|
CHECK (!++scope);
|
|
CHECK ("ham" == spam.data.get<Rec>().getType());
|
|
CHECK (spam.contains (GenNode("eggs")));
|
|
|
|
// but while o4 was based on o2,
|
|
// adding all the additional contents didn't mutate o2
|
|
CHECK (isnil(o2.data.get<Rec>()));
|
|
}
|
|
|
|
|
|
|
|
void
|
|
symbolReference()
|
|
{
|
|
GenNode ham = MakeRec().type("spam").attrib("τ", Time(23,42)).genNode("egg bacon sausage and spam");
|
|
|
|
GenNode::ID hamID(ham);
|
|
CHECK (hamID == ham.idi);
|
|
CHECK (hamID.getSym() == ham.idi.getSym());
|
|
CHECK (hamID.getHash() == ham.idi.getHash());
|
|
CHECK (contains (string(hamID), "spam")); // Lovely spam!
|
|
|
|
Ref ref1("egg bacon sausage and spam");
|
|
Ref ref2(ham);
|
|
|
|
CHECK (ref1.idi == ham.idi);
|
|
CHECK (ref2.idi == ham.idi);
|
|
|
|
// can stand-in for the original Record...
|
|
CHECK (isSameObject (ham, ref2.data.get<Rec>()));
|
|
VERIFY_ERROR (BOTTOM_VALUE, ref1.data.get<Rec>());
|
|
|
|
RecRef rr1 = ref1.data.get<RecRef>();
|
|
RecRef rr2 = ref2.data.get<RecRef>();
|
|
|
|
CHECK ( isnil(rr1));
|
|
CHECK (!isnil(rr2));
|
|
Rec& ham_ref = rr2;
|
|
CHECK (isSameObject(ham, ham_ref));
|
|
CHECK (isSameObject(&ham, rr2.get()));
|
|
|
|
// pre-defined special ref-tokens
|
|
CHECK ("_END_" == name(Ref::END));
|
|
CHECK ("_THIS_" == name(Ref::THIS));
|
|
CHECK ("_CHILD_" == name(Ref::CHILD));
|
|
CHECK ("_ATTRIBS_" == name(Ref::ATTRIBS));
|
|
|
|
CHECK (isnil (Ref::END.data.get<RecRef>()));
|
|
CHECK (isnil (Ref::THIS.data.get<RecRef>()));
|
|
CHECK (isnil (Ref::CHILD.data.get<RecRef>()));
|
|
CHECK (isnil (Ref::ATTRIBS.data.get<RecRef>()));
|
|
}
|
|
|
|
|
|
void
|
|
equalityMatch()
|
|
{
|
|
int i1 = 12; GenNode ni1(i1);
|
|
int i2 = 23; GenNode ni2(i2);
|
|
int64_t l1 = 12; GenNode nl1(l1);
|
|
int64_t l2 = 23; GenNode nl2(l2);
|
|
short s1 = 12; GenNode ns1(s1);
|
|
short s2 = 23; GenNode ns2(s2);
|
|
double d1 = 12; GenNode nd1(d1);
|
|
double d2 = 23; GenNode nd2(d2);
|
|
char c1 = '@'; GenNode nc1(c1);
|
|
char c2 = '~'; GenNode nc2(c2);
|
|
bool b1 = true; GenNode nb1(b1);
|
|
bool b2 = false; GenNode nb2(b2);
|
|
string z1 = ""; GenNode nz1(z1);
|
|
string z2 = "↯"; GenNode nz2(z2);
|
|
|
|
time::Time t1 = randTime(); GenNode nt1(t1);
|
|
time::Time t2(-t1); GenNode nt2(t2);
|
|
time::Offset to1(t1); GenNode nto1(to1);
|
|
time::Offset to2(t2); GenNode nto2(to2);
|
|
time::Duration td1(to2); GenNode ntd1(td1);
|
|
time::Duration td2(to2*2); GenNode ntd2(td2);
|
|
time::TimeSpan ts1(t1, td1); GenNode nts1(ts1);
|
|
time::TimeSpan ts2(t2, td2); GenNode nts2(ts2);
|
|
hash::LuidH h1; GenNode nh1(h1);
|
|
hash::LuidH h2; GenNode nh2(h2);
|
|
|
|
Rec spam1({GenNode("ham", "eggs")}); GenNode rec1(spam1);
|
|
Rec spam2(MakeRec(spam1).type("spam")); GenNode rec2(spam2);
|
|
|
|
RecRef r1(spam1); GenNode ref1(r1);
|
|
RecRef r2(spam2); GenNode ref2(r2);
|
|
|
|
CHECK (ni1 == ni1);
|
|
CHECK (ni2 == ni2);
|
|
CHECK (nl1 == nl1);
|
|
CHECK (nl2 == nl2);
|
|
CHECK (ns1 == ns1);
|
|
CHECK (ns2 == ns2);
|
|
CHECK (nd1 == nd1);
|
|
CHECK (nd2 == nd2);
|
|
CHECK (nc1 == nc1);
|
|
CHECK (nc2 == nc2);
|
|
CHECK (nb1 == nb1);
|
|
CHECK (nb2 == nb2);
|
|
CHECK (nz1 == nz1);
|
|
CHECK (nz2 == nz2);
|
|
CHECK (nt1 == nt1 );
|
|
CHECK (nt2 == nt2 );
|
|
CHECK (nto1 == nto1);
|
|
CHECK (nto2 == nto2);
|
|
CHECK (ntd1 == ntd1);
|
|
CHECK (ntd2 == ntd2);
|
|
CHECK (nts1 == nts1);
|
|
CHECK (nts2 == nts2);
|
|
CHECK (nh1 == nh1 );
|
|
CHECK (nh2 == nh2 );
|
|
CHECK (rec1 == rec1);
|
|
CHECK (rec2 == rec2);
|
|
CHECK (ref1 == ref1);
|
|
CHECK (ref2 == ref2);
|
|
|
|
CHECK (ni1 != ni2); CHECK (ni2 != ni1);
|
|
CHECK (nl1 != nl2); CHECK (nl2 != nl1);
|
|
CHECK (ns1 != ns2); CHECK (ns2 != ns1);
|
|
CHECK (nd1 != nd2); CHECK (nd2 != nd1);
|
|
CHECK (nc1 != nc2); CHECK (nc2 != nc1);
|
|
CHECK (nb1 != nb2); CHECK (nb2 != nb1);
|
|
CHECK (nz1 != nz2); CHECK (nz2 != nz1);
|
|
CHECK (nt1 != nt2 ); CHECK (nt2 != nt1 );
|
|
CHECK (nto1 != nto2); CHECK (nto2 != nto1);
|
|
CHECK (ntd1 != ntd2); CHECK (ntd2 != ntd1);
|
|
CHECK (nts1 != nts2); CHECK (nts2 != nts1);
|
|
CHECK (nh1 != nh2 ); CHECK (nh2 != nh1 );
|
|
CHECK (rec1 != rec2); CHECK (rec2 != rec1);
|
|
CHECK (ref1 != ref2); CHECK (ref2 != ref1);
|
|
|
|
CHECK (ni1 != ni2); CHECK (ni2 != ni1);
|
|
CHECK (ni1 != nl1); CHECK (nl1 != ni1);
|
|
CHECK (ni1 != nl2); CHECK (nl2 != ni1);
|
|
CHECK (ni1 != ns1); CHECK (ns1 != ni1);
|
|
CHECK (ni1 != ns2); CHECK (ns2 != ni1);
|
|
CHECK (ni1 != nd1); CHECK (nd1 != ni1);
|
|
CHECK (ni1 != nd2); CHECK (nd2 != ni1);
|
|
CHECK (ni1 != nc1); CHECK (nc1 != ni1);
|
|
CHECK (ni1 != nc2); CHECK (nc2 != ni1);
|
|
CHECK (ni1 != nb1); CHECK (nb1 != ni1);
|
|
CHECK (ni1 != nb2); CHECK (nb2 != ni1);
|
|
CHECK (ni1 != nz1); CHECK (nz1 != ni1);
|
|
CHECK (ni1 != nz2); CHECK (nz2 != ni1);
|
|
CHECK (ni1 != nt1 ); CHECK (nt1 != ni1);
|
|
CHECK (ni1 != nt2 ); CHECK (nt2 != ni1);
|
|
CHECK (ni1 != nto1); CHECK (nto1 != ni1);
|
|
CHECK (ni1 != nto2); CHECK (nto2 != ni1);
|
|
CHECK (ni1 != ntd1); CHECK (ntd1 != ni1);
|
|
CHECK (ni1 != ntd2); CHECK (ntd2 != ni1);
|
|
CHECK (ni1 != nts1); CHECK (nts1 != ni1);
|
|
CHECK (ni1 != nts2); CHECK (nts2 != ni1);
|
|
CHECK (ni1 != nh1 ); CHECK (nh1 != ni1);
|
|
CHECK (ni1 != nh2 ); CHECK (nh2 != ni1);
|
|
CHECK (ni1 != rec1); CHECK (rec1 != ni1);
|
|
CHECK (ni1 != rec2); CHECK (rec2 != ni1);
|
|
CHECK (ni1 != ref1); CHECK (ref1 != ni1);
|
|
CHECK (ni1 != ref2); CHECK (ref2 != ni1);
|
|
|
|
CHECK (ni2 != nl1); CHECK (nl1 != ni2);
|
|
CHECK (ni2 != nl2); CHECK (nl2 != ni2);
|
|
CHECK (ni2 != ns1); CHECK (ns1 != ni2);
|
|
CHECK (ni2 != ns2); CHECK (ns2 != ni2);
|
|
CHECK (ni2 != nd1); CHECK (nd1 != ni2);
|
|
CHECK (ni2 != nd2); CHECK (nd2 != ni2);
|
|
CHECK (ni2 != nc1); CHECK (nc1 != ni2);
|
|
CHECK (ni2 != nc2); CHECK (nc2 != ni2);
|
|
CHECK (ni2 != nb1); CHECK (nb1 != ni2);
|
|
CHECK (ni2 != nb2); CHECK (nb2 != ni2);
|
|
CHECK (ni2 != nz1); CHECK (nz1 != ni2);
|
|
CHECK (ni2 != nz2); CHECK (nz2 != ni2);
|
|
CHECK (ni2 != nt1 ); CHECK (nt1 != ni2);
|
|
CHECK (ni2 != nt2 ); CHECK (nt2 != ni2);
|
|
CHECK (ni2 != nto1); CHECK (nto1 != ni2);
|
|
CHECK (ni2 != nto2); CHECK (nto2 != ni2);
|
|
CHECK (ni2 != ntd1); CHECK (ntd1 != ni2);
|
|
CHECK (ni2 != ntd2); CHECK (ntd2 != ni2);
|
|
CHECK (ni2 != nts1); CHECK (nts1 != ni2);
|
|
CHECK (ni2 != nts2); CHECK (nts2 != ni2);
|
|
CHECK (ni2 != nh1 ); CHECK (nh1 != ni2);
|
|
CHECK (ni2 != nh2 ); CHECK (nh2 != ni2);
|
|
CHECK (ni2 != rec1); CHECK (rec1 != ni2);
|
|
CHECK (ni2 != rec2); CHECK (rec2 != ni2);
|
|
CHECK (ni2 != ref1); CHECK (ref1 != ni2);
|
|
CHECK (ni2 != ref2); CHECK (ref2 != ni2);
|
|
|
|
CHECK (nl1 != nl2); CHECK (nl2 != nl1);
|
|
CHECK (nl1 != ns1); CHECK (ns1 != nl1);
|
|
CHECK (nl1 != ns2); CHECK (ns2 != nl1);
|
|
CHECK (nl1 != nd1); CHECK (nd1 != nl1);
|
|
CHECK (nl1 != nd2); CHECK (nd2 != nl1);
|
|
CHECK (nl1 != nc1); CHECK (nc1 != nl1);
|
|
CHECK (nl1 != nc2); CHECK (nc2 != nl1);
|
|
CHECK (nl1 != nb1); CHECK (nb1 != nl1);
|
|
CHECK (nl1 != nb2); CHECK (nb2 != nl1);
|
|
CHECK (nl1 != nz1); CHECK (nz1 != nl1);
|
|
CHECK (nl1 != nz2); CHECK (nz2 != nl1);
|
|
CHECK (nl1 != nt1 ); CHECK (nt1 != nl1);
|
|
CHECK (nl1 != nt2 ); CHECK (nt2 != nl1);
|
|
CHECK (nl1 != nto1); CHECK (nto1 != nl1);
|
|
CHECK (nl1 != nto2); CHECK (nto2 != nl1);
|
|
CHECK (nl1 != ntd1); CHECK (ntd1 != nl1);
|
|
CHECK (nl1 != ntd2); CHECK (ntd2 != nl1);
|
|
CHECK (nl1 != nts1); CHECK (nts1 != nl1);
|
|
CHECK (nl1 != nts2); CHECK (nts2 != nl1);
|
|
CHECK (nl1 != nh1 ); CHECK (nh1 != nl1);
|
|
CHECK (nl1 != nh2 ); CHECK (nh2 != nl1);
|
|
CHECK (nl1 != rec1); CHECK (rec1 != nl1);
|
|
CHECK (nl1 != rec2); CHECK (rec2 != nl1);
|
|
CHECK (nl1 != ref1); CHECK (ref1 != nl1);
|
|
CHECK (nl1 != ref2); CHECK (ref2 != nl1);
|
|
|
|
CHECK (nl2 != ns1); CHECK (ns1 != nl2);
|
|
CHECK (nl2 != ns2); CHECK (ns2 != nl2);
|
|
CHECK (nl2 != nd1); CHECK (nd1 != nl2);
|
|
CHECK (nl2 != nd2); CHECK (nd2 != nl2);
|
|
CHECK (nl2 != nc1); CHECK (nc1 != nl2);
|
|
CHECK (nl2 != nc2); CHECK (nc2 != nl2);
|
|
CHECK (nl2 != nb1); CHECK (nb1 != nl2);
|
|
CHECK (nl2 != nb2); CHECK (nb2 != nl2);
|
|
CHECK (nl2 != nz1); CHECK (nz1 != nl2);
|
|
CHECK (nl2 != nz2); CHECK (nz2 != nl2);
|
|
CHECK (nl2 != nt1 ); CHECK (nt1 != nl2);
|
|
CHECK (nl2 != nt2 ); CHECK (nt2 != nl2);
|
|
CHECK (nl2 != nto1); CHECK (nto1 != nl2);
|
|
CHECK (nl2 != nto2); CHECK (nto2 != nl2);
|
|
CHECK (nl2 != ntd1); CHECK (ntd1 != nl2);
|
|
CHECK (nl2 != ntd2); CHECK (ntd2 != nl2);
|
|
CHECK (nl2 != nts1); CHECK (nts1 != nl2);
|
|
CHECK (nl2 != nts2); CHECK (nts2 != nl2);
|
|
CHECK (nl2 != nh1 ); CHECK (nh1 != nl2);
|
|
CHECK (nl2 != nh2 ); CHECK (nh2 != nl2);
|
|
CHECK (nl2 != rec1); CHECK (rec1 != nl2);
|
|
CHECK (nl2 != rec2); CHECK (rec2 != nl2);
|
|
CHECK (nl2 != ref1); CHECK (ref1 != nl2);
|
|
CHECK (nl2 != ref2); CHECK (ref2 != nl2);
|
|
|
|
CHECK (ns1 != ns2); CHECK (ns2 != ns1);
|
|
CHECK (ns1 != nd1); CHECK (nd1 != ns1);
|
|
CHECK (ns1 != nd2); CHECK (nd2 != ns1);
|
|
CHECK (ns1 != nc1); CHECK (nc1 != ns1);
|
|
CHECK (ns1 != nc2); CHECK (nc2 != ns1);
|
|
CHECK (ns1 != nb1); CHECK (nb1 != ns1);
|
|
CHECK (ns1 != nb2); CHECK (nb2 != ns1);
|
|
CHECK (ns1 != nz1); CHECK (nz1 != ns1);
|
|
CHECK (ns1 != nz2); CHECK (nz2 != ns1);
|
|
CHECK (ns1 != nt1 ); CHECK (nt1 != ns1);
|
|
CHECK (ns1 != nt2 ); CHECK (nt2 != ns1);
|
|
CHECK (ns1 != nto1); CHECK (nto1 != ns1);
|
|
CHECK (ns1 != nto2); CHECK (nto2 != ns1);
|
|
CHECK (ns1 != ntd1); CHECK (ntd1 != ns1);
|
|
CHECK (ns1 != ntd2); CHECK (ntd2 != ns1);
|
|
CHECK (ns1 != nts1); CHECK (nts1 != ns1);
|
|
CHECK (ns1 != nts2); CHECK (nts2 != ns1);
|
|
CHECK (ns1 != nh1 ); CHECK (nh1 != ns1);
|
|
CHECK (ns1 != nh2 ); CHECK (nh2 != ns1);
|
|
CHECK (ns1 != rec1); CHECK (rec1 != ns1);
|
|
CHECK (ns1 != rec2); CHECK (rec2 != ns1);
|
|
CHECK (ns1 != ref1); CHECK (ref1 != ns1);
|
|
CHECK (ns1 != ref2); CHECK (ref2 != ns1);
|
|
|
|
CHECK (ns2 != nd1); CHECK (nd1 != ns2);
|
|
CHECK (ns2 != nd2); CHECK (nd2 != ns2);
|
|
CHECK (ns2 != nc1); CHECK (nc1 != ns2);
|
|
CHECK (ns2 != nc2); CHECK (nc2 != ns2);
|
|
CHECK (ns2 != nb1); CHECK (nb1 != ns2);
|
|
CHECK (ns2 != nb2); CHECK (nb2 != ns2);
|
|
CHECK (ns2 != nz1); CHECK (nz1 != ns2);
|
|
CHECK (ns2 != nz2); CHECK (nz2 != ns2);
|
|
CHECK (ns2 != nt1 ); CHECK (nt1 != ns2);
|
|
CHECK (ns2 != nt2 ); CHECK (nt2 != ns2);
|
|
CHECK (ns2 != nto1); CHECK (nto1 != ns2);
|
|
CHECK (ns2 != nto2); CHECK (nto2 != ns2);
|
|
CHECK (ns2 != ntd1); CHECK (ntd1 != ns2);
|
|
CHECK (ns2 != ntd2); CHECK (ntd2 != ns2);
|
|
CHECK (ns2 != nts1); CHECK (nts1 != ns2);
|
|
CHECK (ns2 != nts2); CHECK (nts2 != ns2);
|
|
CHECK (ns2 != nh1 ); CHECK (nh1 != ns2);
|
|
CHECK (ns2 != nh2 ); CHECK (nh2 != ns2);
|
|
CHECK (ns2 != rec1); CHECK (rec1 != ns2);
|
|
CHECK (ns2 != rec2); CHECK (rec2 != ns2);
|
|
CHECK (ns2 != ref1); CHECK (ref1 != ns2);
|
|
CHECK (ns2 != ref2); CHECK (ref2 != ns2);
|
|
|
|
CHECK (nd1 != nd2); CHECK (nd2 != nd1);
|
|
CHECK (nd1 != nc1); CHECK (nc1 != nd1);
|
|
CHECK (nd1 != nc2); CHECK (nc2 != nd1);
|
|
CHECK (nd1 != nb1); CHECK (nb1 != nd1);
|
|
CHECK (nd1 != nb2); CHECK (nb2 != nd1);
|
|
CHECK (nd1 != nz1); CHECK (nz1 != nd1);
|
|
CHECK (nd1 != nz2); CHECK (nz2 != nd1);
|
|
CHECK (nd1 != nt1 ); CHECK (nt1 != nd1);
|
|
CHECK (nd1 != nt2 ); CHECK (nt2 != nd1);
|
|
CHECK (nd1 != nto1); CHECK (nto1 != nd1);
|
|
CHECK (nd1 != nto2); CHECK (nto2 != nd1);
|
|
CHECK (nd1 != ntd1); CHECK (ntd1 != nd1);
|
|
CHECK (nd1 != ntd2); CHECK (ntd2 != nd1);
|
|
CHECK (nd1 != nts1); CHECK (nts1 != nd1);
|
|
CHECK (nd1 != nts2); CHECK (nts2 != nd1);
|
|
CHECK (nd1 != nh1 ); CHECK (nh1 != nd1);
|
|
CHECK (nd1 != nh2 ); CHECK (nh2 != nd1);
|
|
CHECK (nd1 != rec1); CHECK (rec1 != nd1);
|
|
CHECK (nd1 != rec2); CHECK (rec2 != nd1);
|
|
CHECK (nd1 != ref1); CHECK (ref1 != nd1);
|
|
CHECK (nd1 != ref2); CHECK (ref2 != nd1);
|
|
|
|
CHECK (nd2 != nc1); CHECK (nc1 != nd2);
|
|
CHECK (nd2 != nc2); CHECK (nc2 != nd2);
|
|
CHECK (nd2 != nb1); CHECK (nb1 != nd2);
|
|
CHECK (nd2 != nb2); CHECK (nb2 != nd2);
|
|
CHECK (nd2 != nz1); CHECK (nz1 != nd2);
|
|
CHECK (nd2 != nz2); CHECK (nz2 != nd2);
|
|
CHECK (nd2 != nt1 ); CHECK (nt1 != nd2);
|
|
CHECK (nd2 != nt2 ); CHECK (nt2 != nd2);
|
|
CHECK (nd2 != nto1); CHECK (nto1 != nd2);
|
|
CHECK (nd2 != nto2); CHECK (nto2 != nd2);
|
|
CHECK (nd2 != ntd1); CHECK (ntd1 != nd2);
|
|
CHECK (nd2 != ntd2); CHECK (ntd2 != nd2);
|
|
CHECK (nd2 != nts1); CHECK (nts1 != nd2);
|
|
CHECK (nd2 != nts2); CHECK (nts2 != nd2);
|
|
CHECK (nd2 != nh1 ); CHECK (nh1 != nd2);
|
|
CHECK (nd2 != nh2 ); CHECK (nh2 != nd2);
|
|
CHECK (nd2 != rec1); CHECK (rec1 != nd2);
|
|
CHECK (nd2 != rec2); CHECK (rec2 != nd2);
|
|
CHECK (nd2 != ref1); CHECK (ref1 != nd2);
|
|
CHECK (nd2 != ref2); CHECK (ref2 != nd2);
|
|
|
|
CHECK (nc1 != nc2); CHECK (nc2 != nc1);
|
|
CHECK (nc1 != nb1); CHECK (nb1 != nc1);
|
|
CHECK (nc1 != nb2); CHECK (nb2 != nc1);
|
|
CHECK (nc1 != nz1); CHECK (nz1 != nc1);
|
|
CHECK (nc1 != nz2); CHECK (nz2 != nc1);
|
|
CHECK (nc1 != nt1 ); CHECK (nt1 != nc1);
|
|
CHECK (nc1 != nt2 ); CHECK (nt2 != nc1);
|
|
CHECK (nc1 != nto1); CHECK (nto1 != nc1);
|
|
CHECK (nc1 != nto2); CHECK (nto2 != nc1);
|
|
CHECK (nc1 != ntd1); CHECK (ntd1 != nc1);
|
|
CHECK (nc1 != ntd2); CHECK (ntd2 != nc1);
|
|
CHECK (nc1 != nts1); CHECK (nts1 != nc1);
|
|
CHECK (nc1 != nts2); CHECK (nts2 != nc1);
|
|
CHECK (nc1 != nh1 ); CHECK (nh1 != nc1);
|
|
CHECK (nc1 != nh2 ); CHECK (nh2 != nc1);
|
|
CHECK (nc1 != rec1); CHECK (rec1 != nc1);
|
|
CHECK (nc1 != rec2); CHECK (rec2 != nc1);
|
|
CHECK (nc1 != ref1); CHECK (ref1 != nc1);
|
|
CHECK (nc1 != ref2); CHECK (ref2 != nc1);
|
|
|
|
CHECK (nc2 != nb1); CHECK (nb1 != nc2);
|
|
CHECK (nc2 != nb2); CHECK (nb2 != nc2);
|
|
CHECK (nc2 != nz1); CHECK (nz1 != nc2);
|
|
CHECK (nc2 != nz2); CHECK (nz2 != nc2);
|
|
CHECK (nc2 != nt1 ); CHECK (nt1 != nc2);
|
|
CHECK (nc2 != nt2 ); CHECK (nt2 != nc2);
|
|
CHECK (nc2 != nto1); CHECK (nto1 != nc2);
|
|
CHECK (nc2 != nto2); CHECK (nto2 != nc2);
|
|
CHECK (nc2 != ntd1); CHECK (ntd1 != nc2);
|
|
CHECK (nc2 != ntd2); CHECK (ntd2 != nc2);
|
|
CHECK (nc2 != nts1); CHECK (nts1 != nc2);
|
|
CHECK (nc2 != nts2); CHECK (nts2 != nc2);
|
|
CHECK (nc2 != nh1 ); CHECK (nh1 != nc2);
|
|
CHECK (nc2 != nh2 ); CHECK (nh2 != nc2);
|
|
CHECK (nc2 != rec1); CHECK (rec1 != nc2);
|
|
CHECK (nc2 != rec2); CHECK (rec2 != nc2);
|
|
CHECK (nc2 != ref1); CHECK (ref1 != nc2);
|
|
CHECK (nc2 != ref2); CHECK (ref2 != nc2);
|
|
|
|
CHECK (nb1 != nb2); CHECK (nb2 != nb1);
|
|
CHECK (nb1 != nz1); CHECK (nz1 != nb1);
|
|
CHECK (nb1 != nz2); CHECK (nz2 != nb1);
|
|
CHECK (nb1 != nt1 ); CHECK (nt1 != nb1);
|
|
CHECK (nb1 != nt2 ); CHECK (nt2 != nb1);
|
|
CHECK (nb1 != nto1); CHECK (nto1 != nb1);
|
|
CHECK (nb1 != nto2); CHECK (nto2 != nb1);
|
|
CHECK (nb1 != ntd1); CHECK (ntd1 != nb1);
|
|
CHECK (nb1 != ntd2); CHECK (ntd2 != nb1);
|
|
CHECK (nb1 != nts1); CHECK (nts1 != nb1);
|
|
CHECK (nb1 != nts2); CHECK (nts2 != nb1);
|
|
CHECK (nb1 != nh1 ); CHECK (nh1 != nb1);
|
|
CHECK (nb1 != nh2 ); CHECK (nh2 != nb1);
|
|
CHECK (nb1 != rec1); CHECK (rec1 != nb1);
|
|
CHECK (nb1 != rec2); CHECK (rec2 != nb1);
|
|
CHECK (nb1 != ref1); CHECK (ref1 != nb1);
|
|
CHECK (nb1 != ref2); CHECK (ref2 != nb1);
|
|
|
|
CHECK (nb2 != nz1); CHECK (nz1 != nb2);
|
|
CHECK (nb2 != nz2); CHECK (nz2 != nb2);
|
|
CHECK (nb2 != nt1 ); CHECK (nt1 != nb2);
|
|
CHECK (nb2 != nt2 ); CHECK (nt2 != nb2);
|
|
CHECK (nb2 != nto1); CHECK (nto1 != nb2);
|
|
CHECK (nb2 != nto2); CHECK (nto2 != nb2);
|
|
CHECK (nb2 != ntd1); CHECK (ntd1 != nb2);
|
|
CHECK (nb2 != ntd2); CHECK (ntd2 != nb2);
|
|
CHECK (nb2 != nts1); CHECK (nts1 != nb2);
|
|
CHECK (nb2 != nts2); CHECK (nts2 != nb2);
|
|
CHECK (nb2 != nh1 ); CHECK (nh1 != nb2);
|
|
CHECK (nb2 != nh2 ); CHECK (nh2 != nb2);
|
|
CHECK (nb2 != rec1); CHECK (rec1 != nb2);
|
|
CHECK (nb2 != rec2); CHECK (rec2 != nb2);
|
|
CHECK (nb2 != ref1); CHECK (ref1 != nb2);
|
|
CHECK (nb2 != ref2); CHECK (ref2 != nb2);
|
|
|
|
CHECK (nz1 != nt2 ); CHECK (nt2 != nz1);
|
|
CHECK (nz1 != nto1); CHECK (nto1 != nz1);
|
|
CHECK (nz1 != nto2); CHECK (nto2 != nz1);
|
|
CHECK (nz1 != ntd1); CHECK (ntd1 != nz1);
|
|
CHECK (nz1 != ntd2); CHECK (ntd2 != nz1);
|
|
CHECK (nz1 != nts1); CHECK (nts1 != nz1);
|
|
CHECK (nz1 != nts2); CHECK (nts2 != nz1);
|
|
CHECK (nz1 != nh1 ); CHECK (nh1 != nz1);
|
|
CHECK (nz1 != nh2 ); CHECK (nh2 != nz1);
|
|
CHECK (nz1 != rec1); CHECK (rec1 != nz1);
|
|
CHECK (nz1 != rec2); CHECK (rec2 != nz1);
|
|
CHECK (nz1 != ref1); CHECK (ref1 != nz1);
|
|
CHECK (nz1 != ref2); CHECK (ref2 != nz1);
|
|
|
|
CHECK (nz2 != nt1 ); CHECK (nt1 != nz2);
|
|
CHECK (nz2 != nt2 ); CHECK (nt2 != nz2);
|
|
CHECK (nz2 != nto1); CHECK (nto1 != nz2);
|
|
CHECK (nz2 != nto2); CHECK (nto2 != nz2);
|
|
CHECK (nz2 != ntd1); CHECK (ntd1 != nz2);
|
|
CHECK (nz2 != ntd2); CHECK (ntd2 != nz2);
|
|
CHECK (nz2 != nts1); CHECK (nts1 != nz2);
|
|
CHECK (nz2 != nts2); CHECK (nts2 != nz2);
|
|
CHECK (nz2 != nh1 ); CHECK (nh1 != nz2);
|
|
CHECK (nz2 != nh2 ); CHECK (nh2 != nz2);
|
|
CHECK (nz2 != rec1); CHECK (rec1 != nz2);
|
|
CHECK (nz2 != rec2); CHECK (rec2 != nz2);
|
|
CHECK (nz2 != ref1); CHECK (ref1 != nz2);
|
|
CHECK (nz2 != ref2); CHECK (ref2 != nz2);
|
|
|
|
CHECK (nt1 != nt2 ); CHECK (nt2 != nt1);
|
|
CHECK (nt1 != nto1); CHECK (nto1 != nt1);
|
|
CHECK (nt1 != nto2); CHECK (nto2 != nt1);
|
|
CHECK (nt1 != ntd1); CHECK (ntd1 != nt1);
|
|
CHECK (nt1 != ntd2); CHECK (ntd2 != nt1);
|
|
CHECK (nt1 != nts1); CHECK (nts1 != nt1);
|
|
CHECK (nt1 != nts2); CHECK (nts2 != nt1);
|
|
CHECK (nt1 != nh1 ); CHECK (nh1 != nt1);
|
|
CHECK (nt1 != nh2 ); CHECK (nh2 != nt1);
|
|
CHECK (nt1 != rec1); CHECK (rec1 != nt1);
|
|
CHECK (nt1 != rec2); CHECK (rec2 != nt1);
|
|
CHECK (nt1 != ref1); CHECK (ref1 != nt1);
|
|
CHECK (nt1 != ref2); CHECK (ref2 != nt1);
|
|
|
|
CHECK (nt2 != nto1); CHECK (nto1 != nt2);
|
|
CHECK (nt2 != nto2); CHECK (nto2 != nt2);
|
|
CHECK (nt2 != ntd1); CHECK (ntd1 != nt2);
|
|
CHECK (nt2 != ntd2); CHECK (ntd2 != nt2);
|
|
CHECK (nt2 != nts1); CHECK (nts1 != nt2);
|
|
CHECK (nt2 != nts2); CHECK (nts2 != nt2);
|
|
CHECK (nt2 != nh1 ); CHECK (nh1 != nt2);
|
|
CHECK (nt2 != nh2 ); CHECK (nh2 != nt2);
|
|
CHECK (nt2 != rec1); CHECK (rec1 != nt2);
|
|
CHECK (nt2 != rec2); CHECK (rec2 != nt2);
|
|
CHECK (nt2 != ref1); CHECK (ref1 != nt2);
|
|
CHECK (nt2 != ref2); CHECK (ref2 != nt2);
|
|
|
|
CHECK (nto1 != nto2); CHECK (nto2 != nto1);
|
|
CHECK (nto1 != ntd1); CHECK (ntd1 != nto1);
|
|
CHECK (nto1 != ntd2); CHECK (ntd2 != nto1);
|
|
CHECK (nto1 != nts1); CHECK (nts1 != nto1);
|
|
CHECK (nto1 != nts2); CHECK (nts2 != nto1);
|
|
CHECK (nto1 != nh1 ); CHECK (nh1 != nto1);
|
|
CHECK (nto1 != nh2 ); CHECK (nh2 != nto1);
|
|
CHECK (nto1 != rec1); CHECK (rec1 != nto1);
|
|
CHECK (nto1 != rec2); CHECK (rec2 != nto1);
|
|
CHECK (nto1 != ref1); CHECK (ref1 != nto1);
|
|
CHECK (nto1 != ref2); CHECK (ref2 != nto1);
|
|
|
|
CHECK (nto2 != ntd1); CHECK (ntd1 != nto2);
|
|
CHECK (nto2 != ntd2); CHECK (ntd2 != nto2);
|
|
CHECK (nto2 != nts1); CHECK (nts1 != nto2);
|
|
CHECK (nto2 != nts2); CHECK (nts2 != nto2);
|
|
CHECK (nto2 != nh1 ); CHECK (nh1 != nto2);
|
|
CHECK (nto2 != nh2 ); CHECK (nh2 != nto2);
|
|
CHECK (nto2 != rec1); CHECK (rec1 != nto2);
|
|
CHECK (nto2 != rec2); CHECK (rec2 != nto2);
|
|
CHECK (nto2 != ref1); CHECK (ref1 != nto2);
|
|
CHECK (nto2 != ref2); CHECK (ref2 != nto2);
|
|
|
|
CHECK (ntd1 != ntd2); CHECK (ntd2 != ntd1);
|
|
CHECK (ntd1 != nts1); CHECK (nts1 != ntd1);
|
|
CHECK (ntd1 != nts2); CHECK (nts2 != ntd1);
|
|
CHECK (ntd1 != nh1 ); CHECK (nh1 != ntd1);
|
|
CHECK (ntd1 != nh2 ); CHECK (nh2 != ntd1);
|
|
CHECK (ntd1 != rec1); CHECK (rec1 != ntd1);
|
|
CHECK (ntd1 != rec2); CHECK (rec2 != ntd1);
|
|
CHECK (ntd1 != ref1); CHECK (ref1 != ntd1);
|
|
CHECK (ntd1 != ref2); CHECK (ref2 != ntd1);
|
|
|
|
CHECK (ntd2 != nts1); CHECK (nts1 != ntd2);
|
|
CHECK (ntd2 != nts2); CHECK (nts2 != ntd2);
|
|
CHECK (ntd2 != nh1 ); CHECK (nh1 != ntd2);
|
|
CHECK (ntd2 != nh2 ); CHECK (nh2 != ntd2);
|
|
CHECK (ntd2 != rec1); CHECK (rec1 != ntd2);
|
|
CHECK (ntd2 != rec2); CHECK (rec2 != ntd2);
|
|
CHECK (ntd2 != ref1); CHECK (ref1 != ntd2);
|
|
CHECK (ntd2 != ref2); CHECK (ref2 != ntd2);
|
|
|
|
CHECK (nts1 != nts2); CHECK (nts2 != nts1);
|
|
CHECK (nts1 != nh1 ); CHECK (nh1 != nts1);
|
|
CHECK (nts1 != nh2 ); CHECK (nh2 != nts1);
|
|
CHECK (nts1 != rec1); CHECK (rec1 != nts1);
|
|
CHECK (nts1 != rec2); CHECK (rec2 != nts1);
|
|
CHECK (nts1 != ref1); CHECK (ref1 != nts1);
|
|
CHECK (nts1 != ref2); CHECK (ref2 != nts1);
|
|
|
|
CHECK (nts2 != nh1 ); CHECK (nh1 != nts2);
|
|
CHECK (nts2 != nh2 ); CHECK (nh2 != nts2);
|
|
CHECK (nts2 != rec1); CHECK (rec1 != nts2);
|
|
CHECK (nts2 != rec2); CHECK (rec2 != nts2);
|
|
CHECK (nts2 != ref1); CHECK (ref1 != nts2);
|
|
CHECK (nts2 != ref2); CHECK (ref2 != nts2);
|
|
|
|
CHECK (nh1 != nh2 ); CHECK (nh2 != nh1);
|
|
CHECK (nh1 != rec1); CHECK (rec1 != nh1);
|
|
CHECK (nh1 != rec2); CHECK (rec2 != nh1);
|
|
CHECK (nh1 != ref1); CHECK (ref1 != nh1);
|
|
CHECK (nh1 != ref2); CHECK (ref2 != nh1);
|
|
|
|
CHECK (nh2 != rec1); CHECK (rec1 != nh2);
|
|
CHECK (nh2 != rec2); CHECK (rec2 != nh2);
|
|
CHECK (nh2 != ref1); CHECK (ref1 != nh2);
|
|
CHECK (nh2 != ref2); CHECK (ref2 != nh2);
|
|
|
|
CHECK (rec1 != rec2); CHECK (rec2 != rec1);
|
|
CHECK (rec1 != ref1); CHECK (ref1 != rec1);
|
|
CHECK (rec1 != ref2); CHECK (ref2 != rec1);
|
|
|
|
CHECK (rec2 != ref1); CHECK (ref1 != rec2);
|
|
CHECK (rec2 != ref2); CHECK (ref2 != rec2);
|
|
|
|
CHECK (ref1 != ref2); CHECK (ref2 != ref1);
|
|
}
|
|
|
|
|
|
void
|
|
sequenceIteration()
|
|
{
|
|
UNIMPLEMENTED ("wtf");
|
|
}
|
|
};
|
|
|
|
|
|
/** Register this test class... */
|
|
LAUNCHER (GenNodeBasic_test, "unit common");
|
|
|
|
|
|
|
|
}}} // namespace lib::diff::test
|