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( testCountLeaves );
  28   CPPUNIT_TEST( testShortBranches );
  29   CPPUNIT_TEST_SUITE_END();
  30
  31 protected:
  32                 vector<int> _validPerm;
  33                 vector<int> _validPerm2;
  34                 vector<int> _validPerm3;
  35                 vector<int> _validPerm4;
  36
  37 public:
  38
  39         void setUp (){
  40                 int validPerm[] = {1,2,3,4};
  41                 _validPerm.assign(validPerm,validPerm+4);
  42                 int validPerm2[] = {1,-3,-2,4};
  43                 _validPerm2.assign(validPerm2,validPerm2+4);
  44                 int validPerm3[] = {0,-2,-1,4,3,5,8,6,7,9};
  45                 _validPerm3.assign(validPerm3,validPerm3+10);
  46                 int validPerm4[] = {-3,1,2,4,6,5,7,-15,-13,-14,-12,-10,-11,-9,8};
  47                 _validPerm4.assign(validPerm4,validPerm4+15);
  48
  49         }
  50
  51 protected:
  52
  53         size_t count(ComponentTree::Node* n, bool all = false){
  54                 size_t num = 0;
  55                 if (all || n->_comp.i2 != 0)
  56                         num += 1;
  57                 for (vector<ComponentTree::Node*>::iterator c = n->_children.begin();
  58                                 c != n->_children.end(); ++c){
  59                         num += count(*c,all);
  60                 }
  61                 return num;
  62         }
  63         void testCreate (){
  64                 GeneOrder go(_validPerm.begin(),_validPerm.end());
  65                 ComponentTree t(findComponents(go));
  66                 ComponentTree::Node* n = t._root;
  67
  68                 CPPUNIT_ASSERT_EQUAL((size_t)4u,count(n));
  69                 CPPUNIT_ASSERT_EQUAL((size_t)5u,count(n,true));
  70                 CPPUNIT_ASSERT_EQUAL((size_t)4u,n->_children.size());
  71
  72                 Component go10(0,1,0,0,1);
  73                 Component go11(1,2,0,1,2);
  74                 Component go12(2,3,0,2,3);
  75                 Component go13(3,4,0,3,4);
  76                 CPPUNIT_ASSERT(n->_children[0]->_comp == go10);
  77                 CPPUNIT_ASSERT(n->_children[1]->_comp == go11);
  78                 CPPUNIT_ASSERT(n->_children[2]->_comp == go12);
  79                 CPPUNIT_ASSERT(n->_children[3]->_comp == go13);
  80
  81                 GeneOrder go2(_validPerm4.begin(),_validPerm4.end());
  82                 ComponentTree t2(findComponents(go2));
  83                 n = t2._root;
  84
  85                 CPPUNIT_ASSERT_EQUAL((size_t)6u,count(n));
  86                 CPPUNIT_ASSERT_EQUAL((size_t)9u,count(n,true));
  87                 CPPUNIT_ASSERT_EQUAL((size_t)3u,n->_children.size());
  88                 Component go20(1,2,0,2,3);
  89                 Component go21(0,4,0,0,4);
  90                 Component go22(4,7,1,4,7);
  91                 Component go23(-15,-12,-1,8,11);
  92                 Component go24(-12,-9,-1,11,14);
  93                 Component go25(7,16,0,7,16);
  94                 CPPUNIT_ASSERT(n->_children[0]->_comp == go21);
  95                 CPPUNIT_ASSERT(n->_children[1]->_comp == go22);
  96                 CPPUNIT_ASSERT(n->_children[2]->_comp == go25);
  97                 CPPUNIT_ASSERT(n->_children[0]->_children[0]->_children[0]->_comp == go20);
  98                 CPPUNIT_ASSERT(n->_children[2]->_children[0]->_children[0]->_comp == go23);
  99                 CPPUNIT_ASSERT(n->_children[2]->_children[0]->_children[1]->_comp == go24);
 100
 101                 GeneOrder go3(_validPerm3.begin(),_validPerm3.end());
 102                 ComponentTree t3(findComponents(go3));
 103                 n = t3._root;
 104
 105                 CPPUNIT_ASSERT_EQUAL((size_t)4u,count(n));
 106                 CPPUNIT_ASSERT_EQUAL((size_t)7u,count(n,true));
 107                 CPPUNIT_ASSERT_EQUAL((size_t)2u,n->_children.size());
 108
 109                 Component go30(-2,-1,0,1,2);
 110                 Component go31(0,5,0,0,5);
 111                 Component go32(6,7,0,7,8);
 112                 Component go33(5,9,1,5,9);
 113                 CPPUNIT_ASSERT(n->_children[0]->_comp == go31);
 114                 CPPUNIT_ASSERT(n->_children[1]->_comp == go33);
 115                 CPPUNIT_ASSERT(n->_children[0]->_children[0]->_children[0]->_comp == go30);
 116                 CPPUNIT_ASSERT(n->_children[1]->_children[0]->_children[0]->_comp == go32);
 117
 118         }
 119
 120         void testMakeUnoriented (){
 121                 GeneOrder go(_validPerm.begin(),_validPerm.end());
 122                 ComponentTree t(findComponents(go));
 123                 t.makeUnoriented();
 124                 ComponentTree::Node* n = t._root;
 125
 126                 CPPUNIT_ASSERT_EQUAL((size_t)0u,count(n));
 127                 CPPUNIT_ASSERT_EQUAL((size_t)1u,count(n,true));
 128                 CPPUNIT_ASSERT_EQUAL((size_t)0u,n->_children.size());
 129
 130                 GeneOrder go2(_validPerm4.begin(),_validPerm4.end());
 131                 ComponentTree t2(findComponents(go2));
 132                 t2.makeUnoriented();
 133                 n = t2._root;
 134
 135                 CPPUNIT_ASSERT_EQUAL((size_t)4u,count(n));
 136                 CPPUNIT_ASSERT_EQUAL((size_t)6u,count(n,true));
 137                 CPPUNIT_ASSERT_EQUAL((size_t)2u,n->_children.size());
 138                 Component go22(4,7,1,4,7);
 139                 Component go23(-15,-12,-1,8,11);
 140                 Component go24(-12,-9,-1,11,14);
 141                 Component go25(7,16,0,7,16);
 142                 CPPUNIT_ASSERT(n->_children[0]->_comp == go22);
 143                 CPPUNIT_ASSERT(n->_children[1]->_comp == go25);
 144                 CPPUNIT_ASSERT(n->_children[1]->_children[0]->_children[0]->_comp == go23);
 145                 CPPUNIT_ASSERT(n->_children[1]->_children[0]->_children[1]->_comp == go24);
 146
 147                 GeneOrder go3(_validPerm3.begin(),_validPerm3.end());
 148                 ComponentTree t3(findComponents(go3));
 149                 t3.makeUnoriented();
 150                 n = t3._root;
 151
 152                 CPPUNIT_ASSERT_EQUAL((size_t)1u,count(n));
 153                 CPPUNIT_ASSERT_EQUAL((size_t)1u,count(n,true));
 154                 CPPUNIT_ASSERT_EQUAL((size_t)0u,n->_children.size());
 155         }
 156
 157         void testCountLeaves (){
 158                 GeneOrder go(_validPerm.begin(),_validPerm.end());
 159                 ComponentTree t(findComponents(go));
 160                 t.makeUnoriented();
 161
 162                 CPPUNIT_ASSERT_EQUAL((size_t)0u,t.countLeaves());
 163
 164                 GeneOrder go2(_validPerm4.begin(),_validPerm4.end());
 165                 ComponentTree t2(findComponents(go2));
 166                 t2.makeUnoriented();
 167                 ComponentTree::Node* n = t2._root;
 168                 CPPUNIT_ASSERT_EQUAL((size_t)2u,n->_children.size());
 169                 CPPUNIT_ASSERT_EQUAL(false,n->_children.empty());
 170                 CPPUNIT_ASSERT_EQUAL((size_t)3u,t2.countLeaves());
 171
 172                 GeneOrder go3(_validPerm3.begin(),_validPerm3.end());
 173                 ComponentTree t3(findComponents(go3));
 174                 t3.makeUnoriented();
 175                 CPPUNIT_ASSERT_EQUAL((size_t)1u,t3.countLeaves());
 176         }
 177         void testShortBranches (){
 178                 GeneOrder go(_validPerm.begin(),_validPerm.end());
 179                 ComponentTree t(findComponents(go));
 180                 t.makeUnoriented();
 181
 182                 CPPUNIT_ASSERT_EQUAL((size_t)0u,t.shortBranches());
 183
 184                 GeneOrder go2(_validPerm4.begin(),_validPerm4.end());
 185                 ComponentTree t2(findComponents(go2));
 186                 t2.makeUnoriented();
 187                 CPPUNIT_ASSERT_EQUAL((size_t)1u,t2.shortBranches());
 188
 189                 GeneOrder go3(_validPerm3.begin(),_validPerm3.end());
 190                 ComponentTree t3(findComponents(go3));
 191                 t3.makeUnoriented();
 192                 CPPUNIT_ASSERT_EQUAL((size_t)1u,t3.shortBranches());
 193         }
 194
 195 };
 196
 197 CPPUNIT_TEST_SUITE_REGISTRATION( TESTNAME );
 198
 199 #undef TESTNAME