src/test/componenttreetest.cpp

   1 #include <cppunit/TestFixture.h>
   2 #include <cppunit/extensions/HelperMacros.h>
   3
   4 #include <genesorter.h>
   5 #include <geneorder.h>
   6 #include <genealgorithms.h>
   7 #include <componenttree.h>
   8
   9 #include <algorithm>
  10 #include <iterator>
  11 using namespace std;
  12
  13 /*
  14  * A test case that is designed to produce
  15  * example errors and failures.
  16  *
  17  */
  18
  19 #define TESTNAME ComponentTreeTest
  20
  21
  22 class TESTNAME : public CPPUNIT_NS::TestFixture
  23 {
  24   CPPUNIT_TEST_SUITE( TESTNAME );
  25   CPPUNIT_TEST( testCreate );
  26   CPPUNIT_TEST( testMakeUnoriented );
  27   CPPUNIT_TEST_SUITE_END();
  28
  29 protected:
  30                 vector<int> _validPerm;
  31                 vector<int> _validPerm2;
  32                 vector<int> _validPerm3;
  33                 vector<int> _validPerm4;
  34
  35 public:
  36
  37         void setUp (){
  38                 int validPerm[] = {1,2,3,4};
  39                 _validPerm.assign(validPerm,validPerm+4);
  40                 int validPerm2[] = {1,-3,-2,4};
  41                 _validPerm2.assign(validPerm2,validPerm2+4);
  42                 int validPerm3[] = {0,-2,-1,4,3,5,-8,6,7,9};
  43                 _validPerm3.assign(validPerm3,validPerm3+10);
  44                 int validPerm4[] = {-3,1,2,4,6,5,7,-15,-13,-14,-12,-10,-11,-9,8};
  45                 _validPerm4.assign(validPerm4,validPerm4+15);
  46
  47         }
  48
  49 protected:
  50
  51         size_t count(ComponentTree::Node* n, bool all = false){
  52                 size_t num = 0;
  53                 if (all || n->_comp.i2 != 0)
  54                         num += 1;
  55                 for (vector<ComponentTree::Node*>::iterator c = n->_children.begin();
  56                                 c != n->_children.end(); ++c){
  57                         num += count(*c,all);
  58                 }
  59                 return num;
  60         }
  61         void testCreate (){
  62                 GeneOrder go(_validPerm.begin(),_validPerm.end());
  63                 ComponentTree t(findComponents(go));
  64                 ComponentTree::Node* n = &t._root;
  65
  66                 CPPUNIT_ASSERT_EQUAL((size_t)4u,count(n));
  67                 CPPUNIT_ASSERT_EQUAL((size_t)5u,count(n,true));
  68                 CPPUNIT_ASSERT_EQUAL((size_t)4u,n->_children.size());
  69
  70                 Component go10(0,1,0,0,1);
  71                 Component go11(1,2,0,1,2);
  72                 Component go12(2,3,0,2,3);
  73                 Component go13(3,4,0,3,4);
  74                 CPPUNIT_ASSERT(n->_children[0]->_comp == go10);
  75                 CPPUNIT_ASSERT(n->_children[1]->_comp == go11);
  76                 CPPUNIT_ASSERT(n->_children[2]->_comp == go12);
  77                 CPPUNIT_ASSERT(n->_children[3]->_comp == go13);
  78
  79                 GeneOrder go2(_validPerm4.begin(),_validPerm4.end());
  80                 ComponentTree t2(findComponents(go2));
  81                 n = &t2._root;
  82
  83                 CPPUNIT_ASSERT_EQUAL((size_t)6u,count(n));
  84                 CPPUNIT_ASSERT_EQUAL((size_t)9u,count(n,true));
  85                 CPPUNIT_ASSERT_EQUAL((size_t)3u,n->_children.size());
  86                 Component go20(1,2,0,2,3);
  87                 Component go21(0,4,0,0,4);
  88                 Component go22(4,7,1,4,7);
  89                 Component go23(-15,-12,-1,8,11);
  90                 Component go24(-12,-9,-1,11,14);
  91                 Component go25(7,16,0,7,16);
  92                 CPPUNIT_ASSERT(n->_children[0]->_comp == go21);
  93                 CPPUNIT_ASSERT(n->_children[1]->_comp == go22);
  94                 CPPUNIT_ASSERT(n->_children[2]->_comp == go25);
  95                 CPPUNIT_ASSERT(n->_children[0]->_children[0]->_children[0]->_comp == go20);
  96                 CPPUNIT_ASSERT(n->_children[2]->_children[0]->_children[0]->_comp == go23);
  97                 CPPUNIT_ASSERT(n->_children[2]->_children[0]->_children[1]->_comp == go24);
  98
  99         }
 100
 101         void testMakeUnoriented (){
 102                 GeneOrder go(_validPerm.begin(),_validPerm.end());
 103                 ComponentTree t(findComponents(go));
 104                 t.makeUnoriented();
 105                 ComponentTree::Node* n = &t._root;
 106
 107                 CPPUNIT_ASSERT_EQUAL((size_t)0u,count(n));
 108                 CPPUNIT_ASSERT_EQUAL((size_t)1u,count(n,true));
 109                 CPPUNIT_ASSERT_EQUAL((size_t)0u,n->_children.size());
 110
 111                 GeneOrder go2(_validPerm4.begin(),_validPerm4.end());
 112                 ComponentTree t2(findComponents(go2));
 113                 t2.makeUnoriented();
 114                 n = &t2._root;
 115
 116                 CPPUNIT_ASSERT_EQUAL((size_t)4u,count(n));
 117                 CPPUNIT_ASSERT_EQUAL((size_t)6u,count(n,true));
 118                 CPPUNIT_ASSERT_EQUAL((size_t)2u,n->_children.size());
 119                 Component go22(4,7,1,4,7);
 120                 Component go23(-15,-12,-1,8,11);
 121                 Component go24(-12,-9,-1,11,14);
 122                 Component go25(7,16,0,7,16);
 123                 CPPUNIT_ASSERT(n->_children[0]->_comp == go22);
 124                 CPPUNIT_ASSERT(n->_children[1]->_comp == go25);
 125                 CPPUNIT_ASSERT(n->_children[1]->_children[0]->_children[0]->_comp == go23);
 126                 CPPUNIT_ASSERT(n->_children[1]->_children[0]->_children[1]->_comp == go24);
 127         }
 128
 129 };
 130
 131 CPPUNIT_TEST_SUITE_REGISTRATION( TESTNAME );
 132
 133 #undef TESTNAME