]> git.donarmstrong.com Git - lilypond.git/blob - flower/test-std.cc
(class Sources): idem.
[lilypond.git] / 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 }