1 #include <stdarg.h>
2 #include "../utest/utest.h"
3 #include "util/list-container.h"
5 using Inkscape::Util::ListContainer;
7 #define ARRAY_RANGE(array) (array), (array)+sizeof((array))/sizeof((array)[0])
9 static bool check_values(ListContainer<int> const &c, unsigned n_values, ...) {
10 bool ret = true;
11 va_list args;
12 va_start(args, n_values);
13 ListContainer<int>::const_iterator iter(c.begin());
14 while ( n_values && iter != c.end() ) {
15 int const value = va_arg(args, int);
16 if ( value != *iter ) {
17 ret = false;
18 }
19 if ( n_values == 1 && &c.back() != &*iter ) {
20 ret = false;
21 }
22 n_values--;
23 ++iter;
24 }
25 va_end(args);
26 return ret && n_values == 0 && iter == c.end();
27 }
29 int main(int /*argc*/, char */*argv*/[]) {
30 Inkscape::GC::init();
31 utest_start("List Container");
32 UTEST_TEST("range constructor") {
33 int const values[]={1,2,3,4};
34 int const * const values_end=values+4;
35 ListContainer<int> container(values, values_end);
37 ListContainer<int>::iterator container_iter=container.begin();
38 int const * values_iter=values;
40 while ( values_iter != values_end && container_iter != container.end() ) {
41 UTEST_ASSERT(*values_iter == *container_iter);
42 ++values_iter;
43 ++container_iter;
44 }
46 UTEST_ASSERT(values_iter == values_end);
47 UTEST_ASSERT(container_iter == container.end());
48 }
49 UTEST_TEST("equality tests") {
50 int const a[] = { 1, 2, 3, 4 };
51 int const b[] = { 1, 2, 3, 4 };
52 int const c[] = { 1, 2, 3 };
53 int const d[] = { 1, 2, 3, 5 };
54 ListContainer<int> c_a(ARRAY_RANGE(a));
55 ListContainer<int> c_b(ARRAY_RANGE(b));
56 ListContainer<int> c_c(ARRAY_RANGE(c));
57 ListContainer<int> c_d(ARRAY_RANGE(d));
59 UTEST_ASSERT(c_a == c_b);
60 UTEST_ASSERT(!( c_a != c_b ));
61 UTEST_ASSERT(!( c_a == c_c ));
62 UTEST_ASSERT(c_a != c_c);
63 UTEST_ASSERT(!( c_a == c_d ));
64 UTEST_ASSERT(c_a != c_d);
65 }
66 UTEST_TEST("lessthan tests") {
67 int const a[] = { 1, 2, 3, 4 };
68 int const b[] = { 1, 2, 2, 4 };
69 int const c[] = { 1, 2, 4, 4 };
70 int const d[] = { 1, 2, 3 };
71 ListContainer<int> c_a(ARRAY_RANGE(a));
72 ListContainer<int> c_b(ARRAY_RANGE(b));
73 ListContainer<int> c_c(ARRAY_RANGE(c));
74 ListContainer<int> c_d(ARRAY_RANGE(d));
75 UTEST_ASSERT(c_a >= c_b);
76 UTEST_ASSERT(!( c_a < c_b ));
77 UTEST_ASSERT(!( c_a >= c_c ));
78 UTEST_ASSERT(c_a < c_c);
79 UTEST_ASSERT(!( c_a < c_d ));
80 UTEST_ASSERT(c_a >= c_d);
81 UTEST_ASSERT(c_d < c_a);
82 }
83 UTEST_TEST("assignment operator") {
84 int const a[] = { 1, 2, 3, 4 };
85 ListContainer<int> c_a(ARRAY_RANGE(a));
86 ListContainer<int> c_c;
87 UTEST_ASSERT(c_a != c_c);
88 c_c = c_a;
89 UTEST_ASSERT(c_a == c_c);
90 c_c = c_a;
91 UTEST_ASSERT(c_a == c_c);
92 }
93 UTEST_TEST("fill constructor") {
94 ListContainer<int> filled((std::size_t)3, 2);
95 UTEST_ASSERT(check_values(filled, 3, 2, 2, 2));
96 }
97 UTEST_TEST("container size") {
98 ListContainer<int> empty;
99 UTEST_ASSERT(empty.empty());
100 UTEST_ASSERT(empty.size() == 0);
101 int const a[] = { 1, 2, 3 };
102 ListContainer<int> c_a(ARRAY_RANGE(a));
103 UTEST_ASSERT(!c_a.empty());
104 UTEST_ASSERT(c_a.size() == 3);
106 UTEST_ASSERT(empty.max_size() > 0);
107 }
108 UTEST_TEST("appending") {
109 ListContainer<int> c;
110 c.push_back(1);
111 UTEST_ASSERT(check_values(c, 1, 1));
112 c.push_back(2);
113 UTEST_ASSERT(check_values(c, 2, 1, 2));
114 c.push_back(3);
115 UTEST_ASSERT(check_values(c, 3, 1, 2, 3));
116 }
117 UTEST_TEST("bulk appending") {
118 int const a[] = { 1, 2, 3, 4 };
119 int const b[] = { 5, 6, 7 };
120 ListContainer<int> c_a(ARRAY_RANGE(a));
121 ListContainer<int> c_b(ARRAY_RANGE(b));
122 c_a.insert(c_a.end(), c_b.begin(), c_b.end());
123 UTEST_ASSERT(check_values(c_a, 7, 1, 2, 3, 4, 5, 6, 7));
124 }
125 UTEST_TEST("prepending") {
126 ListContainer<int> c;
127 c.push_front(1);
128 UTEST_ASSERT(check_values(c, 1, 1));
129 c.push_front(2);
130 UTEST_ASSERT(check_values(c, 2, 2, 1));
131 c.push_front(3);
132 UTEST_ASSERT(check_values(c, 3, 3, 2, 1));
133 }
134 UTEST_TEST("single-value insertion") {
135 ListContainer<int> c;
137 c.insert(c.begin(), 1);
138 UTEST_ASSERT(check_values(c, 1, 1));
140 c.insert(c.end(), 2);
141 UTEST_ASSERT(check_values(c, 2, 1, 2));
143 c.insert(c.begin(), 3);
144 UTEST_ASSERT(check_values(c, 3, 3, 1, 2));
146 ListContainer<int>::iterator pos=c.begin();
147 ++pos;
148 c.insert(pos, 4);
149 UTEST_ASSERT(check_values(c, 4, 3, 4, 1, 2));
150 }
151 UTEST_TEST("single-value erasure") {
152 int const values[] = { 1, 2, 3, 4 };
153 ListContainer<int> c(ARRAY_RANGE(values));
155 c.erase(c.begin());
156 UTEST_ASSERT(check_values(c, 3, 2, 3, 4));
158 ListContainer<int>::iterator pos=c.begin();
159 ++pos;
160 c.erase(pos);
161 UTEST_ASSERT(check_values(c, 2, 2, 4));
163 pos=c.begin();
164 ++pos;
165 c.erase(pos);
166 UTEST_ASSERT(check_values(c, 1, 2));
168 c.erase(c.begin());
169 UTEST_ASSERT(check_values(c, 0));
170 }
171 UTEST_TEST("pop_front") {
172 int const full_ary[] = { 1, 2, 3 };
173 ListContainer<int> t(ARRAY_RANGE(full_ary));
174 UTEST_ASSERT(check_values(t, 3, 1, 2, 3));
175 UTEST_ASSERT(t.back() == 3);
176 t.pop_front();
177 UTEST_ASSERT(check_values(t, 2, 2, 3));
178 UTEST_ASSERT(t.back() == 3);
179 t.push_back(23);
180 UTEST_ASSERT(check_values(t, 3, 2, 3, 23));
181 UTEST_ASSERT(t.back() == 23);
182 t.pop_front();
183 UTEST_ASSERT(check_values(t, 2, 3, 23));
184 UTEST_ASSERT(t.back() == 23);
185 t.pop_front();
186 UTEST_ASSERT(check_values(t, 1, 23));
187 UTEST_ASSERT(t.back() == 23);
188 t.pop_front();
189 UTEST_ASSERT(check_values(t, 0));
190 t.push_back(42);
191 UTEST_ASSERT(check_values(t, 1, 42));
192 UTEST_ASSERT(t.back() == 42);
193 }
194 UTEST_TEST("erase_after") {
195 int const full_ary[] = { 1, 2, 3, 4 };
196 int const exp_ary[] = { 1, 3, 4 };
197 ListContainer<int> full_list(ARRAY_RANGE(full_ary));
198 ListContainer<int> exp_list(ARRAY_RANGE(exp_ary));
199 UTEST_ASSERT(full_list != exp_list);
200 full_list.erase_after(full_list.begin());
201 UTEST_ASSERT(full_list == exp_list);
202 }
203 return utest_end() ? 0 : 1;
204 }