src/util/list-container-test.cpp

   1 #include <stdarg.h>
   2 #include "../utest/utest.h"
   3 #include "util/list-container.h"
   4
   5 using Inkscape::Util::ListContainer;
   6
   7 #define ARRAY_RANGE(array) (array), (array)+sizeof((array))/sizeof((array)[0])
   8
   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 }
  28
  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);
  36
  37                 ListContainer<int>::iterator container_iter=container.begin();
  38                 int const * values_iter=values;
  39
  40                 while ( values_iter != values_end && container_iter != container.end() ) {
  41                         UTEST_ASSERT(*values_iter == *container_iter);
  42                         ++values_iter;
  43                         ++container_iter;
  44                 }
  45
  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));
  58
  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);
 105
 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;
 136
 137                 c.insert(c.begin(), 1);
 138                 UTEST_ASSERT(check_values(c, 1, 1));
 139
 140                 c.insert(c.end(), 2);
 141                 UTEST_ASSERT(check_values(c, 2, 1, 2));
 142
 143                 c.insert(c.begin(), 3);
 144                 UTEST_ASSERT(check_values(c, 3, 3, 1, 2));
 145
 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));
 154
 155                 c.erase(c.begin());
 156                 UTEST_ASSERT(check_values(c, 3, 2, 3, 4));
 157
 158                 ListContainer<int>::iterator pos=c.begin();
 159                 ++pos;
 160                 c.erase(pos);
 161                 UTEST_ASSERT(check_values(c, 2, 2, 4));
 162
 163                 pos=c.begin();
 164                 ++pos;
 165                 c.erase(pos);
 166                 UTEST_ASSERT(check_values(c, 1, 2));
 167
 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 }