flower/test-std.cc

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