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_SUITE_END();
  29
  30 protected:
  31                 vector<int> _validPerm;
  32                 vector<int> _validPerm2;
  33                 vector<int> _validPerm3;
  34                 vector<int> _validPerm4;
  35
  36 public:
  37
  38         void setUp (){
  39                 int validPerm[] = {1,2,3,4};
  40                 _validPerm.assign(validPerm,validPerm+4);
  41                 int validPerm2[] = {1,-3,-2,4};
  42                 _validPerm2.assign(validPerm2,validPerm2+4);
  43                 int validPerm3[] = {0,-2,-1,4,3,5,-8,6,7,9};
  44                 _validPerm3.assign(validPerm3,validPerm3+10);
  45                 int validPerm4[] = {-3,1,2,4,6,5,7,-15,-13,-14,-12,-10,-11,-9,8};
  46                 _validPerm4.assign(validPerm4,validPerm4+15);
  47
  48         }
  49
  50 protected:
  51
  52         size_t count(ComponentTree::Node* n, bool all = false){
  53                 size_t num = 0;
  54                 if (all || n->_comp.i2 != 0)
  55                         num += 1;
  56                 for (vector<ComponentTree::Node*>::iterator c = n->_children.begin();
  57                                 c != n->_children.end(); ++c){
  58                         num += count(*c,all);
  59                 }
  60                 return num;
  61         }
  62         void testCreate (){
  63                 GeneOrder go(_validPerm.begin(),_validPerm.end());
  64                 ComponentTree t(findComponents(go));
  65                 ComponentTree::Node* n = t._root;
  66
  67                 CPPUNIT_ASSERT_EQUAL((size_t)4u,count(n));
  68                 CPPUNIT_ASSERT_EQUAL((size_t)5u,count(n,true));
  69                 CPPUNIT_ASSERT_EQUAL((size_t)4u,n->_children.size());
  70
  71                 Component go10(0,1,0,0,1);
  72                 Component go11(1,2,0,1,2);
  73                 Component go12(2,3,0,2,3);
  74                 Component go13(3,4,0,3,4);
  75                 CPPUNIT_ASSERT(n->_children[0]->_comp == go10);
  76                 CPPUNIT_ASSERT(n->_children[1]->_comp == go11);
  77                 CPPUNIT_ASSERT(n->_children[2]->_comp == go12);
  78                 CPPUNIT_ASSERT(n->_children[3]->_comp == go13);
  79
  80                 GeneOrder go2(_validPerm4.begin(),_validPerm4.end());
  81                 ComponentTree t2(findComponents(go2));
  82                 n = t2._root;
  83
  84                 CPPUNIT_ASSERT_EQUAL((size_t)6u,count(n));
  85                 CPPUNIT_ASSERT_EQUAL((size_t)9u,count(n,true));
  86                 CPPUNIT_ASSERT_EQUAL((size_t)3u,n->_children.size());
  87                 Component go20(1,2,0,2,3);
  88                 Component go21(0,4,0,0,4);
  89                 Component go22(4,7,1,4,7);
  90                 Component go23(-15,-12,-1,8,11);
  91                 Component go24(-12,-9,-1,11,14);
  92                 Component go25(7,16,0,7,16);
  93                 CPPUNIT_ASSERT(n->_children[0]->_comp == go21);
  94                 CPPUNIT_ASSERT(n->_children[1]->_comp == go22);
  95                 CPPUNIT_ASSERT(n->_children[2]->_comp == go25);
  96                 CPPUNIT_ASSERT(n->_children[0]->_children[0]->_children[0]->_comp == go20);
  97                 CPPUNIT_ASSERT(n->_children[2]->_children[0]->_children[0]->_comp == go23);
  98                 CPPUNIT_ASSERT(n->_children[2]->_children[0]->_children[1]->_comp == go24);
  99
 100         }
 101
 102         void testMakeUnoriented (){
 103                 GeneOrder go(_validPerm.begin(),_validPerm.end());
 104                 ComponentTree t(findComponents(go));
 105                 t.makeUnoriented();
 106                 ComponentTree::Node* n = t._root;
 107
 108                 CPPUNIT_ASSERT_EQUAL((size_t)0u,count(n));
 109                 CPPUNIT_ASSERT_EQUAL((size_t)1u,count(n,true));
 110                 CPPUNIT_ASSERT_EQUAL((size_t)0u,n->_children.size());
 111
 112                 GeneOrder go2(_validPerm4.begin(),_validPerm4.end());
 113                 ComponentTree t2(findComponents(go2));
 114                 t2.makeUnoriented();
 115                 n = t2._root;
 116
 117                 CPPUNIT_ASSERT_EQUAL((size_t)4u,count(n));
 118                 CPPUNIT_ASSERT_EQUAL((size_t)6u,count(n,true));
 119                 CPPUNIT_ASSERT_EQUAL((size_t)2u,n->_children.size());
 120                 Component go22(4,7,1,4,7);
 121                 Component go23(-15,-12,-1,8,11);
 122                 Component go24(-12,-9,-1,11,14);
 123                 Component go25(7,16,0,7,16);
 124                 CPPUNIT_ASSERT(n->_children[0]->_comp == go22);
 125                 CPPUNIT_ASSERT(n->_children[1]->_comp == go25);
 126                 CPPUNIT_ASSERT(n->_children[1]->_children[0]->_children[0]->_comp == go23);
 127                 CPPUNIT_ASSERT(n->_children[1]->_children[0]->_children[1]->_comp == go24);
 128         }
 129
 130         void testCountLeaves (){
 131                 GeneOrder go(_validPerm.begin(),_validPerm.end());
 132                 ComponentTree t(findComponents(go));
 133                 t.makeUnoriented();
 134
 135                 CPPUNIT_ASSERT_EQUAL((size_t)0u,t.countLeaves());
 136
 137                 GeneOrder go2(_validPerm4.begin(),_validPerm4.end());
 138                 ComponentTree t2(findComponents(go2));
 139                 t2.makeUnoriented();
 140                 ComponentTree::Node* n = t2._root;
 141                 CPPUNIT_ASSERT_EQUAL((size_t)2u,n->_children.size());
 142                 CPPUNIT_ASSERT_EQUAL(false,n->_children.empty());
 143                 CPPUNIT_ASSERT_EQUAL((size_t)3u,t2.countLeaves());
 144         }
 145
 146 };
 147
 148 CPPUNIT_TEST_SUITE_REGISTRATION( TESTNAME );
 149
 150 #undef TESTNAME