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         }
 102
 103         void testMakeUnoriented (){
 104                 GeneOrder go(_validPerm.begin(),_validPerm.end());
 105                 ComponentTree t(findComponents(go));
 106                 t.makeUnoriented();
 107                 ComponentTree::Node* n = t._root;
 108
 109                 CPPUNIT_ASSERT_EQUAL((size_t)0u,count(n));
 110                 CPPUNIT_ASSERT_EQUAL((size_t)1u,count(n,true));
 111                 CPPUNIT_ASSERT_EQUAL((size_t)0u,n->_children.size());
 112
 113                 GeneOrder go2(_validPerm4.begin(),_validPerm4.end());
 114                 ComponentTree t2(findComponents(go2));
 115                 t2.makeUnoriented();
 116                 n = t2._root;
 117
 118                 CPPUNIT_ASSERT_EQUAL((size_t)4u,count(n));
 119                 CPPUNIT_ASSERT_EQUAL((size_t)6u,count(n,true));
 120                 CPPUNIT_ASSERT_EQUAL((size_t)2u,n->_children.size());
 121                 Component go22(4,7,1,4,7);
 122                 Component go23(-15,-12,-1,8,11);
 123                 Component go24(-12,-9,-1,11,14);
 124                 Component go25(7,16,0,7,16);
 125                 CPPUNIT_ASSERT(n->_children[0]->_comp == go22);
 126                 CPPUNIT_ASSERT(n->_children[1]->_comp == go25);
 127                 CPPUNIT_ASSERT(n->_children[1]->_children[0]->_children[0]->_comp == go23);
 128                 CPPUNIT_ASSERT(n->_children[1]->_children[0]->_children[1]->_comp == go24);
 129         }
 130
 131         void testCountLeaves (){
 132                 GeneOrder go(_validPerm.begin(),_validPerm.end());
 133                 ComponentTree t(findComponents(go));
 134                 t.makeUnoriented();
 135
 136                 CPPUNIT_ASSERT_EQUAL((size_t)0u,t.countLeaves());
 137
 138                 GeneOrder go2(_validPerm4.begin(),_validPerm4.end());
 139                 ComponentTree t2(findComponents(go2));
 140                 t2.makeUnoriented();
 141                 ComponentTree::Node* n = t2._root;
 142                 CPPUNIT_ASSERT_EQUAL((size_t)2u,n->_children.size());
 143                 CPPUNIT_ASSERT_EQUAL(false,n->_children.empty());
 144                 CPPUNIT_ASSERT_EQUAL((size_t)3u,t2.countLeaves());
 145         }
 146         void testShortBranches (){
 147                 GeneOrder go(_validPerm.begin(),_validPerm.end());
 148                 ComponentTree t(findComponents(go));
 149                 t.makeUnoriented();
 150
 151                 CPPUNIT_ASSERT_EQUAL((size_t)0u,t.shortBranches());
 152
 153                 GeneOrder go2(_validPerm4.begin(),_validPerm4.end());
 154                 ComponentTree t2(findComponents(go2));
 155                 t2.makeUnoriented();
 156                 ComponentTree::Node* n = t2._root;
 157                 //CPPUNIT_ASSERT_EQUAL((size_t)1u,t2.shortBranches());
 158         }
 159
 160 };
 161
 162 CPPUNIT_TEST_SUITE_REGISTRATION( TESTNAME );
 163
 164 #undef TESTNAME