flower/test-std.cc

   1 #define STD_VECTOR 1
   2
   3 #if !STD_VECTOR
   4 #define Array flower_vector
   5 #endif
   6
   7 #define HAVE_BOOST_LAMBDA 1
   8 #include "std-vector.hh"
   9
  10 #include <iostream>
  11
  12 #include <boost/test/auto_unit_test.hpp>
  13 #include <boost/test/floating_point_comparison.hpp>
  14
  15 using boost::unit_test::test_suite;
  16
  17 #if !STD_VECTOR
  18 #define vector flower_vector
  19 #endif
  20
  21 using namespace std;
  22
  23 template<typename T>
  24 void
  25 print (vector<T> v)
  26 {
  27   for (vsize i = 0; i < v.size (); i++)
  28     cout << "v[" << i << "] = " << v[i] << endl;
  29   cout << endl;
  30 }
  31
  32 #if !STD_VECTOR
  33 template<typename T>
  34 void
  35 print (Link_array<T> v)
  36 {
  37   for (vsize i = 0; i < v.size (); i++)
  38     cout << "v[" << i << "] = " << *v[i] << endl;
  39   cout << endl;
  40 }
  41 #endif
  42
  43 BOOST_AUTO_UNIT_TEST (vector_erase)
  44 {
  45   vector<int> v;
  46   v.push_back (0);
  47   v.push_back (1);
  48   BOOST_CHECK_EQUAL (v.size (), vsize (2));
  49   v.erase (v.begin () + 1);
  50   BOOST_CHECK_EQUAL (v.size (), vsize (1));
  51   BOOST_CHECK_EQUAL (v.back (), 0);
  52
  53   v.push_back (1);
  54   BOOST_CHECK_EQUAL (v.size (), vsize (2));
  55   v.erase (v.begin () + 0);
  56   BOOST_CHECK_EQUAL (v.size (), vsize (1));
  57   BOOST_CHECK_EQUAL (v.back (), 1);
  58 }
  59
  60 BOOST_AUTO_UNIT_TEST (vector_slice)
  61 {
  62   vector<int> v;
  63   v.push_back (0);
  64   v.push_back (1);
  65   v.push_back (2);
  66   v.push_back (3);
  67 #if VECTOR_SLICE
  68   BOOST_CHECK_EQUAL (v.slice (0, 0).size (), vsize (0));
  69   BOOST_CHECK_EQUAL (v.slice (0, v.size ()).size (), v.size ());
  70   BOOST_CHECK_EQUAL (v.slice (1, 2).size (), vsize (1));
  71 #else
  72   BOOST_CHECK_EQUAL (vector<int> (v.begin (), v.begin ()).size (), vsize (0));
  73   BOOST_CHECK_EQUAL (vector<int> (v.begin (), v.end ()).size (), v.size ());
  74   BOOST_CHECK_EQUAL (vector<int> (v.begin () + 1, v.begin () + 2).size (),
  75                      vsize (1));
  76 #endif
  77 }
  78
  79 BOOST_AUTO_UNIT_TEST (vector_sorting)
  80 {
  81   vector<int> v;
  82   v.push_back (2);
  83   v.push_back (1);
  84   v.push_back (0);
  85 #if VECTOR_SORT
  86   v.sort (default_compare);
  87 #else
  88   vector_sort (v, default_compare);
  89 #endif
  90   BOOST_CHECK_EQUAL (v[0], 0);
  91   BOOST_CHECK_EQUAL (v[1], 1);
  92   BOOST_CHECK_EQUAL (v[2], 2);
  93 }
  94
  95 BOOST_AUTO_UNIT_TEST (vector_insert)
  96 {
  97   vector<int> v;
  98   v.push_back (0);
  99 #if VECTOR_INSERT
 100   v.insert (1, 0);
 101 #else
 102   v.insert (v.begin (), 1);
 103 #endif
 104   BOOST_CHECK_EQUAL (v[0], 1);
 105 #if VECTOR_INSERT
 106   v.insert (2, v.size ());
 107 #else
 108   v.insert (v.end (), 2);
 109 #endif
 110   BOOST_CHECK_EQUAL (v.back (), 2);
 111   vector<int> u;
 112   u.insert (u.begin (), v.begin (), v.end ());
 113   BOOST_CHECK_EQUAL (u.size (), v.size ());
 114   u.clear ();
 115   u.insert (u.end (), v.begin (), v.end ());
 116   BOOST_CHECK_EQUAL (u.size (), v.size ());
 117   u.clear ();
 118 }
 119
 120 BOOST_AUTO_UNIT_TEST (parray_concat)
 121 {
 122 #if !STD_VECTOR
 123   Link_array<int> u, v;
 124 #else
 125   vector<int*> u, v;
 126 #endif
 127   int a[5] = { 0, 1, 2, 3, 4 };
 128   u.push_back (&a[0]);
 129   u.push_back (&a[1]);
 130   u.push_back (&a[2]);
 131   v.push_back (&a[3]);
 132   v.push_back (&a[4]);
 133   concat (u, v);
 134   BOOST_CHECK_EQUAL (u[0], &a[0]);
 135   BOOST_CHECK_EQUAL (u[1], &a[1]);
 136   BOOST_CHECK_EQUAL (u[2], &a[2]);
 137   BOOST_CHECK_EQUAL (u[3], &a[3]);
 138   BOOST_CHECK_EQUAL (u[4], &a[4]);
 139   BOOST_CHECK_EQUAL (u.size (), vsize (5));
 140   concat (u, v);
 141   BOOST_CHECK_EQUAL (u.size (), vsize (7));
 142
 143   u.clear ();
 144   v.clear ();
 145   v.push_back (&a[0]);
 146   v.push_back (&a[1]);
 147   v.push_back (&a[2]);
 148   v.push_back (&a[3]);
 149   v.push_back (&a[4]);
 150   concat (u, v);
 151   BOOST_CHECK_EQUAL (u[0], &a[0]);
 152   BOOST_CHECK_EQUAL (u[1], &a[1]);
 153   BOOST_CHECK_EQUAL (u[2], &a[2]);
 154   BOOST_CHECK_EQUAL (u[3], &a[3]);
 155   BOOST_CHECK_EQUAL (u[4], &a[4]);
 156   BOOST_CHECK_EQUAL (u.size (), vsize (5));
 157 }
 158
 159 BOOST_AUTO_UNIT_TEST (parray_uniq)
 160 {
 161   vector<int> v;
 162   v.push_back (0);
 163   v.push_back (1);
 164   v.push_back (0);
 165   vector_sort (v, default_compare);
 166   uniq (v);
 167   BOOST_CHECK_EQUAL (v.size (), vsize (2));
 168 }
 169
 170 BOOST_AUTO_UNIT_TEST (vector_search)
 171 {
 172   vector<int> v;
 173   v.push_back (0);
 174   v.push_back (1);
 175   v.push_back (2);
 176   vsize i = binary_search (v, 1, &default_compare);
 177   BOOST_CHECK_EQUAL (i, vsize (1));
 178 }
 179
 180 test_suite*
 181 init_unit_test_suite (int, char**)
 182 {
 183   vsize i = 0;
 184   vsize j = 0;
 185   vector<int> v;
 186   binary_search_bounds (v, 1, &default_compare, &i, &j);
 187   //binary_search_bounds (v, 1, &default_compare, 0, 0);
 188
 189   //Link_array<char> w;
 190   vector<char*> w;
 191   binary_search_bounds (w, (char*)1, &default_compare, &i, &j);
 192
 193   test_suite *test = BOOST_TEST_SUITE("Flower");
 194   test->add (BOOST_TEST_CASE (vector_erase));
 195   test->add (BOOST_TEST_CASE (vector_slice));
 196   test->add (BOOST_TEST_CASE (vector_sorting));
 197   test->add (BOOST_TEST_CASE (vector_insert));
 198   test->add (BOOST_TEST_CASE (parray_concat));
 199   test->add (BOOST_TEST_CASE (parray_uniq));
 200   test->add (BOOST_TEST_CASE (vector_search));
 201   return test;
 202 }