|
PLearn 0.1
|

Public Member Functions | |
| Test_PP () | |
| bool | emptyCons () |
| Emtpy constructor test. | |
| bool | copieConsOrdinaryPtr () |
| Copie constructor with ordinary ptr test. | |
| bool | copieConsSameTypePP () |
| Copie constructor with same type of PP. | |
| bool | copieConsChildPP () |
| Copie constructor with other(child) type of PP. | |
| bool | illegalCopieCons () |
| Illegal constructors. | |
| bool | conversionOrdinaryPtr () |
| Checking PP methods. | |
| bool | accessPointedObject () |
| tests the dereferenciation of the PP's by calling print() on the pointed object ( array's start at [1] because [0] contains an empty PP) | |
| bool | affectationFromOrdPtr () |
| bool | affectationFromPP () |
| bool | tryDeepCopy () |
Public Attributes | |
| PP< ChildA > * | child_a_array |
| PP< ChildB > * | child_b_array |
| PP< Parent > * | parent_array |
| PP< Other > | otherPP |
| int | size_a |
| int | size_b |
| int | size_p |
Private Member Functions | |
| void | invariants (int oddIndex, int evenIndex) |
| "oddIndex" is the number of references on child_a_array[odd], child_b_array[even] "evenIndex" is the number of references on the PP's object of even indexes | |
| bool | conversionOPchildA () |
| sous-tests de conversionOrdinaryPtr() | |
| bool | conversionOPchildB () |
| Checking conversion to the ordinary pointer in class ChildB. | |
| bool | conversionOPparent () |
| Checking conversion to the ordinary pointer in class Parent. | |
| PLearn::Test_PP::Test_PP | ( | ) | [inline] |
Definition at line 275 of file PPTest.cc.
References PLearn::endl(), and MAX_SIZE.
{
child_a_array = new PP<ChildA>[MAX_SIZE];
child_b_array = new PP<ChildB>[MAX_SIZE];
parent_array = new PP<Parent>[MAX_SIZE];
otherPP = new Other(99, "ninety-nine");
cout << endl << "***** STARTING TEST_PP *****" << endl << endl;
size_a = 0;
size_b = 0;
size_p = 0;
}

| bool PLearn::Test_PP::accessPointedObject | ( | ) |
tests the dereferenciation of the PP's by calling print() on the pointed object ( array's start at [1] because [0] contains an empty PP)
Definition at line 513 of file PPTest.cc.
References PLearn::endl(), PLearn::flush(), i, and PLearn::print().
Referenced by PLearn::PPTest::perform().
{
int i;
// for ChildA
cout << "Printing child_a_array:" << endl;
for( i=1; i< size_a; i++)
{
cout << "child_a_array[" << i << "]: " << flush;
(*child_a_array[i]).print(cout);
}
// for ChildB
cout << endl << "Printing child_b_array:" << endl;
for( i=1; i< size_b; i++)
{
cout << "child_b_array[" << i << "]: " << flush;
(*child_b_array[i]).print(cout);
}
// for Parent
cout << endl << "Printing parent_array:" << endl;
for( i=1; i< size_p; i++)
{
cout << "parent_array[" << i << "]: " << flush;
(*parent_array[i]).print(cout);
}
cout << endl;
return true;
}


| bool PLearn::Test_PP::affectationFromOrdPtr | ( | ) |
Definition at line 546 of file PPTest.cc.
References PLearn::Parent::s_par, and T_ASSERT.
Referenced by PLearn::PPTest::perform().
{
ChildA* aPtr = new ChildA(400, "four_hundred", 4);
child_a_array[4] = aPtr;
T_ASSERT( child_a_array[4]->i_par==400 && child_a_array[2]->i_par==200,
"Error in affectationFromOrdPtr(): wrong ptr links in child_a_array" );
ChildB* bPtr = new ChildB("one__");
child_b_array[1] = bPtr;
(*child_b_array[1]).i_par = 100;
child_b_array[1]->s_par = "one_hundred";
T_ASSERT( child_b_array[1]->i_par==100 && child_b_array[3]->i_par==300,
"Error in affectationFromOrdPtr(): wrong ptr links in child_b_array" );
Parent* pPtr = new Parent(400, "four_hundred");
parent_array[4] = pPtr;
T_ASSERT( parent_array[4]->i_par==400 && parent_array[2]->i_par==200,
"Error in affectationFromOrdPtr(): wrong ptr links in parent_array" );
pPtr = new Parent(300, "three_hundred");
parent_array[3] = pPtr;
T_ASSERT( parent_array[1]->i_par==100 && parent_array[3]->i_par==300,
"Error in affectationFromOrdPtr(): wrong ptr links in parent_array" );
pPtr = new Parent(600, "six_hundred");
parent_array[6]= pPtr;
T_ASSERT( child_b_array[2]->i_par!=600 && child_b_array[4]->i_par!=600,
"Error in affectationFromOrdPtr(): wrong ptr links between child_b_array and parent_array" );
parent_array[6]= child_b_array[2];
// after affectationFromOrdPtr()...
// a: {[1][3]p[5], [2], [4]}
// b:{[1], [3], [2][4]p[6]}
// p: {[1], [2], [3], [4], [5]a[1][3], [6]b[2][4]}
accessPointedObject();
invariants(3,1);
return true;
}

| bool PLearn::Test_PP::affectationFromPP | ( | ) |
Definition at line 588 of file PPTest.cc.
References T_ASSERT.
Referenced by PLearn::PPTest::perform().
{
// for ChildA
parent_array[7]= new Parent(700, "seven_hundred");
size_p++;
parent_array[8]= new Parent(800, "eight_hundred");
size_p++;
parent_array[8]= child_a_array[4];
parent_array[7]= child_a_array[4];
child_a_array[2] = child_a_array[4];
T_ASSERT( child_a_array[2]->i_par==child_a_array[4]->i_par ,
"1-Error in affectationFromPP(): wrong ptr links in child_a_array" );
T_ASSERT( child_a_array[4]->i_par==parent_array[7]->i_par && parent_array[7]->i_par==parent_array[8]->i_par,
"2-Error in affectationFromPP(): wrong ptr links in child_a_array" );
// for ChildB
parent_array[10]= new Parent(10, "ten_hundred!!");
parent_array[9]=new Parent(900, "nine_hundred");
size_p+=2;
parent_array[10]= child_b_array[3];
parent_array[9]= child_b_array[3];
child_b_array[1] = child_b_array[3];
T_ASSERT( child_b_array[1]->i_par==child_b_array[3]->i_par && child_b_array[1]->i_par==parent_array[9]->i_par
&& parent_array[9]->i_par==parent_array[10]->i_par,
"3-Error in affectationFromPP(): wrong ptr links in child_b_array" );
// for Parent
parent_array[4] = parent_array[1];
parent_array[3] = parent_array[4];
parent_array[2] = parent_array[4];
T_ASSERT( parent_array[1]->i_par==parent_array[2]->i_par,
"4-Error in affectationFromPP(): wrong ptr links in parent_array" );
T_ASSERT( parent_array[2]->i_par==parent_array[3]->i_par && parent_array[3]->i_par==parent_array[4]->i_par,
"5-Error in affectationFromPP(): wrong ptr links in parent_array" );
accessPointedObject();
invariants(3,4);
return true;
}

| bool PLearn::Test_PP::conversionOPchildA | ( | ) | [private] |
sous-tests de conversionOrdinaryPtr()
Checking conversion to the ordinary pointer in class ChildA.
Definition at line 745 of file PPTest.cc.
References a, PLearn::endl(), PLearn::ChildA::i_child_a, PLearn::Parent::i_par, PLearn::Parent::s_par, PLearn::sum(), T_ASSERT, and PLearn::tostring().
{
string key = "hundred";
// for class ChildA
ChildA* a = child_a_array[3];
int sum = (*a).i_child_a + a->i_par;
T_ASSERT(sum==101, "The value of the integer fields in class ChildA are wrong:\n\t\tsum="
+ tostring(sum) + " ,!=101");
int pos = (*a).s_par.find (key,0); // one_hundred: "hundred" in 4th pos
T_ASSERT(pos==4,"The value of the string fields in class ChildA are wrong:\n\t\t pos="
+ tostring(pos) + " ,!=4");
//after modifiying the fields
a->i_child_a=3;
(*a).i_par=300;
a->s_par="three_hundred";
sum = a->i_child_a + (*a).i_par;
T_ASSERT(sum==303, "The value of the integer fields in class ChildA are wrong:\n\t\tsum="
+ tostring(sum) + " ,!=303");
pos = (*a).s_par.find (key,0); // three_hundred: "hundred" in 6th pos
T_ASSERT(pos==6,"The value of the string fields in class ChildA are wrong:\n\t\t pos="
+ tostring(pos) + " ,!=6");
cout << " - Conversion to ordinary ptr verified for class ChildA" << endl;
return true;
}

| bool PLearn::Test_PP::conversionOPchildB | ( | ) | [private] |
Checking conversion to the ordinary pointer in class ChildB.
Definition at line 772 of file PPTest.cc.
References b, PLearn::endl(), PLearn::Parent::i_par, PLearn::ChildB::s_child_b, PLearn::Parent::s_par, T_ASSERT, and PLearn::tostring().
{
string key = "hundred";
// for class ChildB
ChildB* b = child_b_array[1];
string key2 = "e";
int pos = (*b).s_child_b.find(key2,0); // one: "e" in 2nd pos
T_ASSERT(pos==2,"The value of the string fields in class ChildB are wrong:\n\t\t pos="
+ tostring(pos)+ " ,!=2");
b->i_par = 100;
b->s_par = "one_hundred";
T_ASSERT( b->i_par==100,"The value of the integer fields in class ChildB are wrong:\n\t\ti_par="
+ tostring(b->i_par)+ " ,!=100");
// after modifiying the fields
b->i_par = 300;
b->s_par = "three_hundred";
b->s_child_b = "three";
T_ASSERT( b->i_par==300,"The value of the integer fields in class ChildB are wrong:\n\t\ti_par="
+ tostring(b->i_par) + " ,!=300");
pos = (*b).s_par.find(key2,0); // three_hundred: "hundred" in 6th pos
T_ASSERT(pos==3,"The value of the string fields in class ChildB are wrong:\n\t\t pos="
+tostring(pos) + " ,!=3");
pos = (*b).s_child_b.find(key2,0); // three_hundred: "e" in 3rd pos
T_ASSERT(pos==3,"The value of the string fields in class ChildB are wrong:\n\t\t pos="
+ tostring(pos)+ " ,!=3");
cout << " - Conversion to ordinary ptr verified for class ChildB" << endl;
return true;
}

| bool PLearn::Test_PP::conversionOPparent | ( | ) | [private] |
Checking conversion to the ordinary pointer in class Parent.
Definition at line 804 of file PPTest.cc.
References PLearn::endl(), PLearn::Parent::i_par, PLearn::Parent::s_par, T_ASSERT, and PLearn::tostring().
{
string key = "hundred";
// for class Parent
Parent* p = parent_array[5];
//p->i_par should have value 300 because of it's connection to [3]
T_ASSERT( p->i_par==300,"The value of the integer fields in class Parent are wrong:\n\t\ti_par="
+ tostring(p->i_par) + " ,!=300");
int pos = p->s_par.find(key,0); // three_hundred: "hundred" in 6th pos
T_ASSERT(pos==6,"The value of the string fields in class Parent are wrong:\n\t\tpos="
+ tostring(pos)+ " ,!=6");
// after modifiying the fields
p->s_par="five_hundred";
p->i_par=500;
pos = p->s_par.find(key,0); // five_hundred: "hundred" in 5th pos
T_ASSERT(pos==5,"The value of the string fields in class Parent are wrong:\n\t\tpos="
+ tostring(pos)+ " ,!=5");
T_ASSERT( p->i_par==500,"The value of the integer fields in class Parent are wrong:\n\t\ti_par="
+ tostring(p->i_par) + " ,!=500");
p = child_a_array[3]; //p->i_par should have value 500 because of it's connection to [3]and[5]
T_ASSERT( p->i_par==500,"The value of the integer fields in class Parent are wrong:\n\t\ti_par="
+ tostring(p->i_par) + " ,!=500");
p = child_a_array[1]; //p->i_par should have value 500 because of it's connection to [3]and[5]
T_ASSERT( p->i_par==500,"IciThe value of the integer fields in class Parent are wrong:\n\t\ti_par="
+ tostring(p->i_par) + " ,!=500");
cout << " - Conversion to ordinary ptr verified for class Parent" << endl;
return true;
}

| bool PLearn::Test_PP::conversionOrdinaryPtr | ( | ) |
Checking PP methods.
tests conversion to ordinary ptrs and asserts that the access to the objects is still possible threw ptrs
Definition at line 495 of file PPTest.cc.
References PLearn::endl().
Referenced by PLearn::PPTest::perform().
{
bool result = conversionOPchildA();
invariants(3,2);
result = result && conversionOPchildB();
invariants(3,2);
result = result && conversionOPparent();
invariants(3,2);
cout << "--- Conversion to ordinary ptr verified ---" << endl << endl;
return true;
}


| bool PLearn::Test_PP::copieConsChildPP | ( | ) |
Copie constructor with other(child) type of PP.
for class Parent tests constructor with existing children
Definition at line 449 of file PPTest.cc.
References PLearn::endl(), T_ASSERT, and PLearn::usage().
Referenced by PLearn::PPTest::perform().
{
PP<Parent> parentPP5(child_a_array[1]);
T_ASSERT(child_a_array[1]->usage()==3 && child_a_array[3]->usage()==3 && parentPP5->usage()==3 ,
"Error in call to ->usage() while testing Parent's \ncopie constructors with other type of PP");
parent_array[5]= parentPP5;
size_p++;
PP<Parent> parentPP6(child_b_array[2]);
T_ASSERT(child_b_array[2]->usage()==3 && child_b_array[4]->usage()==3 && parentPP6->usage()==3 ,
"Error in call to ->usage() while testing Parent's \ncopie constructors with other type of PP");
parent_array[6]= parentPP6;
size_p++;
cout << "--- Copie constructor with other PP type verified (for class Parent)---" << endl << endl;
return true;
}


| bool PLearn::Test_PP::copieConsOrdinaryPtr | ( | ) |
Copie constructor with ordinary ptr test.
tests for class ChildA
tests for class ChildB
tests for class Parent
Definition at line 341 of file PPTest.cc.
References PLearn::endl(), PLearn::ChildA::i_child_a, PLearn::Parent::i_par, PLearn::ChildB::s_child_b, PLearn::Parent::s_par, and T_ASSERT.
Referenced by PLearn::PPTest::perform().
{
PP<ChildA> childAPP1 = new ChildA(1, "one_hundred", 100);
T_ASSERT(childAPP1->usage()==1 ,
"Error in call to ->usage() while testing ChildA's \n"
"copie constructors with ordinary ptr");
child_a_array[1] = childAPP1;
size_a++;
ChildA childA2;
childA2.i_child_a = 2;
childA2.i_par = 200;
childA2.s_par = "two_hundred";
ChildA* ptr2= new ChildA(childA2);
PP<ChildA> childAPP2(ptr2);
T_ASSERT(childAPP2->usage()==1 ,"Error in call to ->usage() while testing ChildA's \ncopie constructors with ordinary ptr");
child_a_array[2] = childAPP2;
size_a++;
cout << " - Copie constructor with ordinary pointers verified for class ChildA" << endl;
PP<ChildB> childBPP1 = new ChildB("one");
T_ASSERT(childBPP1->usage()==1 ,"Error in call to ->usage() while testing ChildB's \ncopie constructors with ordinary ptr");
child_b_array[1] = childBPP1;
size_b++;
ChildB childB2;
childB2.s_child_b = "two__";
childB2.i_par = 200;
childB2.s_par = "two_hundred";
ChildB* ptr22 = new ChildB(childB2);
PP<ChildB> childBPP2(ptr22);
T_ASSERT(childBPP2->usage()==1 ,"Error in call to ->usage() while testing ChildB's \ncopie constructors with ordinary ptr");
child_b_array[2] = childBPP2;
size_b++;
cout << " - Copie constructor with ordinary pointers verified for class ChildB" << endl;
PP<Parent> parentPP1 = new Parent(100, "one_hundred" );
T_ASSERT(parentPP1->usage()==1 ,"Error in call to ->usage() while testing Parent's \ncopie constructors with ordinary ptr");
parent_array[1] = parentPP1;
size_p++;
Parent parent2;
parent2.i_par=200;
parent2.s_par="two_hundred";
Parent* ptr200 = new Parent(parent2);
PP<Parent> parentPP2(ptr200);
T_ASSERT(parentPP2->usage()==1 ,"Error in call to ->usage() while testing Parent's \ncopie constructors with ordinary ptr");
parent_array[2] = parentPP2;
size_p++;
cout << " - Copie constructor with ordinary pointers verified for class Parent" << endl;
cout << "--- Copie constructor with ordinary pointers verified ---" << endl << endl;
return true;
}


| bool PLearn::Test_PP::copieConsSameTypePP | ( | ) |
Copie constructor with same type of PP.
tests for class ChildA
tests for class ChildB
tests for class Parent
Definition at line 401 of file PPTest.cc.
References PLearn::endl(), T_ASSERT, and PLearn::usage().
Referenced by PLearn::PPTest::perform().
{
PP<ChildA> childAPP3(child_a_array[1]);
T_ASSERT(child_a_array[1]->usage()==2 && childAPP3->usage()==2 ,
"Error in call to ->usage() while testing ChildA's \ncopie constructors with same type of PP");
child_a_array[3] = childAPP3;
size_a++;
PP<ChildA> childAPP4(child_a_array[2]);
T_ASSERT(child_a_array[2]->usage()==2 && childAPP4->usage()==2 ,
"Error in call to ->usage() while testing ChildA's \ncopie constructors with same type of PP");
child_a_array[4] = childAPP4;
size_a++;
cout << " - Copie constructor with same type of PP verified for class ChildA " << endl;
PP<ChildB> childBPP3(child_b_array[1]);
T_ASSERT(child_b_array[1]->usage()==2 && childBPP3->usage()==2,
"Error in call to ->usage() while testing ChildB's \ncopie constructors with same type of PP");
child_b_array[3] = childBPP3;
size_b++;
PP<ChildB> childBPP4(child_b_array[2]);
T_ASSERT(child_b_array[2]->usage()==2 && childBPP4->usage()==2,
"Error in call to ->usage() while testing ChildB's \ncopie constructors with same type of PP");
child_b_array[4] = childBPP4;
size_b++;
cout << " - Copie constructor with same type of PP verified for class ChildB" << endl;
PP<Parent> parentPP3(parent_array[1]);
T_ASSERT(parent_array[1]->usage()==2 && parentPP3->usage()==2,
"Error in call to ->usage() while testing Parent's \ncopie constructors with same type of PP");
parent_array[3] = parentPP3;
size_p++;
PP<Parent> parentPP4(parent_array[2]);
T_ASSERT(parent_array[2]->usage()==2 && parentPP4->usage()==2 ,
"Error in call to ->usage() while testing Parent's \ncopie constructors with same type of PP");
parent_array[4] = parentPP4;
size_p++;
cout << " - Copie constructor with same type of PP verified for class Parent" << endl;
cout << "--- Copie constructor with other PPs verified ---" << endl << endl;
return true;
}


| bool PLearn::Test_PP::emptyCons | ( | ) |
Emtpy constructor test.
Checking PP constructors and operator-> by accessing a PPointable method(usage()) after each modification
test for class ChildA
test for class ChildB
test for class Parent
Definition at line 317 of file PPTest.cc.
References PLearn::endl().
Referenced by PLearn::PPTest::perform().
{
PP<ChildA> childAPP0;
child_a_array[0] = childAPP0;
size_a++;
cout << " - Empty constructor verified for class ChildA " << endl;
PP<ChildB> childBPP0;
child_b_array[0] = childBPP0;
size_b++;
cout << " - Empty constructor verified for class ChildB " << endl;
PP<Parent> parentPP0;
parent_array[0] = parentPP0;
size_p++;
cout << " - Empty constructor verified for class Parent " << endl;
cout << "--- Empty constructor verified ---" << endl << endl;
return true;
}


| bool PLearn::Test_PP::illegalCopieCons | ( | ) |
Illegal constructors.
Definition at line 470 of file PPTest.cc.
References PLearn::endl().
Referenced by PLearn::PPTest::perform().
{
#ifdef CHECK_COMPILATION
PP<ChildA> childAPP4(parent_array[2]);
child_a_array[4] = childAPP4;
PP<ChildA> childAPP4(child_a__array[2]);
child_a_array[4] = childAPP4;
PP<Parent> parentPP4(otherPP);
parent_array[4] = parentPP4;
cout << "--- Illegal Copie constructors should not be verified: error has occured!---" << endl << endl;
#endif
return true;
}


"oddIndex" is the number of references on child_a_array[odd], child_b_array[even] "evenIndex" is the number of references on the PP's object of even indexes
Checking invariants.
Definition at line 728 of file PPTest.cc.
References T_ASSERT, PLearn::tostring(), and PLearn::usage().
{
T_ASSERT(child_a_array[1]->usage()==nb1 && child_a_array[3]->usage()==nb1 && parent_array[5]->usage()==nb1,
"1-Error in call to ->usage() in invariants()");
T_ASSERT(child_a_array[2]->usage()==nb2 && child_a_array[4]->usage()==nb2,
"2-Error in call to ->usage() in invariants()");
T_ASSERT(child_b_array[1]->usage()==nb2 && child_b_array[3]->usage()==nb2,
"3-Error in call to ->usage() in invariants() " + tostring(child_b_array[1]->usage()));
T_ASSERT(child_b_array[2]->usage()==nb1 && child_b_array[4]->usage()==nb1 && parent_array[6]->usage()==nb1 ,
"4-Error in call to ->usage() in invariants()");
T_ASSERT(parent_array[1]->usage()==nb2 && parent_array[3]->usage()==nb2,
"5-Error in call to ->usage() in invariants()");
T_ASSERT(parent_array[2]->usage()==nb2 && parent_array[4]->usage()==nb2 ,
"6-Error in call to ->usage() in invariants()");
}

| bool PLearn::Test_PP::tryDeepCopy | ( | ) |
Creates a dependance pattern between PP<Parent>, PP<ChildA> and PP<ChilB>, copies the root of the pattern by deepCopy and verifies the copie's pattern.
deep copying the root
1rst T_ASSERT :asserts that the changes applied to childA through parent are respected within ChildB 2nd T_ASSERT :asserts that the changes applied to childB through parent are respected within ChildA
Definition at line 633 of file PPTest.cc.
References PLearn::deepCopy(), PLearn::endl(), and T_ASSERT.
{
/* creating the pattern:
: -parentPP --> : -parentPP -->
child_a_array[i] | child_a_array[i+1} | etc. && parentPP: ->childBPP
: -childBB --> : -childBB -->
*/
cout << "- creating pattern..." << endl;
child_a_array[1] = new ChildA(100, "one_hundred", 1);
child_a_array[2] = new ChildA(300, "three_hundred", 3);
child_a_array[1]->parentPP = new Parent(200,"two_hundred");
child_a_array[1]->childBPP = new ChildB("two");
child_a_array[1]->parentPP->childAPP = child_a_array[2];
child_a_array[1]->childBPP->childAPP = child_a_array[2];
child_a_array[1]->parentPP->childBPP = child_a_array[1]->childBPP;
cout << "- deep copying..." << endl;
ChildA* t = PLearn::deepCopy(child_a_array[1]);
PP<ChildA> root_copy = t;
cout << "- verifying different levels of the deep copy..." << endl;
PP<ChildA> root_copy2 = root_copy->parentPP->childAPP;
root_copy2->i_child_a = 2;
T_ASSERT(root_copy2->i_child_a == root_copy->childBPP->childAPP->i_child_a,
"Error, the copy does not respect the initial map - root_copy1, i_child_a");
PP<ChildB> root_copy3 = root_copy->parentPP->childBPP;
root_copy3->s_child_b = "two";
T_ASSERT(root_copy3->s_child_b == root_copy->childBPP->s_child_b,
"Error, the copy does not respect the initial map - root copy1, s_child_b");
// int i, j;
// for(i=2; i<size_a && i<size_b; i++)
// {
// j = 2*(i-1);
// child_a_array[i-1]->parentPP = new Parent(j*100, tostring(j)+(string)"_hundred");
// child_a_array[i-1]->childBPP = new ChildB( tostring(j)+(string)"s");
// child_a_array[i-1]->parentPP->childAPP = child_a_array[i];
// child_a_array[i-1]->childBPP->childAPP = child_a_array[i];
// child_a_array[i-1]->parentPP->childBPP = child_a_array[i-1]->childBPP;
// }
// cout << "- deep copying the root..." << endl;
// //! deep copying the root
// ChildA* test = PLearn::deepCopy(child_a_array[3]);
// PP<ChildA> root_copy = test;
// cout << "- verifying different levels of the deep copy..." << endl;
// //! 1rst T_ASSERT :asserts that the changes applied to childA through parent are respected within ChildB
// //! 2nd T_ASSERT :asserts that the changes applied to childB through parent are respected within ChildA
// PP<ChildA> root_copy2 = root_copy->parentPP->childAPP;
// root_copy2->i_child_a = 2;
// T_ASSERT(root_copy2->i_child_a == root_copy->childBPP->childAPP->i_child_a,
// "Error, the copy does not respect the initial map - root_copy1, i_child_a");
// root_copy->parentPP->childBPP->s_child_b = "two";
// T_ASSERT(root_copy->parentPP->childBPP->s_child_b == root_copy->childBPP->s_child_b,
// "Error, the copy does not respect the initial map - root copy1, s_child_b");
// cout << "- root_copy1 done" << endl;
// PP<ChildA> root_copy3 = root_copy2->parentPP->childAPP;
// root_copy3->i_child_a = 4;
// T_ASSERT(root_copy3->i_child_a == root_copy2->childBPP->childAPP->i_child_a,
// "Error, the copy does not respect the initial map - root_copy2, i_child_a");
// root_copy2->parentPP->childBPP->s_child_b = "four";
// T_ASSERT(root_copy->parentPP->childBPP->s_child_b == root_copy->childBPP->s_child_b,
// "Error, the copy does not respect the initial map - root copy2, s_child_b");
// cout << "- root_copy2 done" << endl;
// PP<ChildA> root_copy4 = root_copy3->parentPP->childAPP;
// root_copy4->i_child_a = 6;
// T_ASSERT(root_copy4->i_child_a == root_copy3->childBPP->childAPP->i_child_a,
// "Error, the copy does not respect the initial map - root_copy3, i_child_a");
// root_copy3->parentPP->childBPP->s_child_b = "six";
// T_ASSERT(root_copy->parentPP->childBPP->s_child_b == root_copy->childBPP->s_child_b,
// "Error, the copy does not respect the initial map - root copy3, s_child_b");
// cout << "- root_copy3 done" << endl;
return true;
}

1.7.4