src/util/list-container-test.h

   1 #include <cxxtest/TestSuite.h>
   2
   3 #include <stdarg.h>
   4 #include "util/list-container.h"
   5
   6 #define ARRAY_RANGE(array) (array), (array)+sizeof((array))/sizeof((array)[0])
   7
   8 static bool check_values(Inkscape::Util::ListContainer<int> const &c, unsigned n_values, ...) {
   9     bool ret = true;
  10     va_list args;
  11     va_start(args, n_values);
  12     Inkscape::Util::ListContainer<int>::const_iterator iter(c.begin());
  13     while ( n_values && iter != c.end() ) {
  14         int const value = va_arg(args, int);
  15         if ( value != *iter ) {
  16             ret = false;
  17         }
  18         if ( n_values == 1 && &c.back() != &*iter ) {
  19             ret = false;
  20         }
  21         n_values--;
  22         ++iter;
  23     }
  24     va_end(args);
  25     return ret && n_values == 0 && iter == c.end();
  26 }
  27
  28 class ListContainerTest : public CxxTest::TestSuite {
  29 public:
  30     ListContainerTest()
  31     {
  32         Inkscape::GC::init();
  33     }
  34     virtual ~ListContainerTest() {}
  35
  36 // createSuite and destroySuite get us per-suite setup and teardown
  37 // without us having to worry about static initialization order, etc.
  38     static ListContainerTest *createSuite() { return new ListContainerTest(); }
  39     static void destroySuite( ListContainerTest *suite ) { delete suite; }
  40
  41     void testRangeConstructor()
  42     {
  43         int const values[]={1,2,3,4};
  44         int const * const values_end=values+4;
  45         Inkscape::Util::ListContainer<int> container(values, values_end);
  46
  47         Inkscape::Util::ListContainer<int>::iterator container_iter=container.begin();
  48         int const * values_iter=values;
  49
  50         while ( values_iter != values_end && container_iter != container.end() ) {
  51             TS_ASSERT_EQUALS(*values_iter , *container_iter);
  52             ++values_iter;
  53             ++container_iter;
  54         }
  55
  56         TS_ASSERT_EQUALS(values_iter , values_end);
  57         TS_ASSERT_EQUALS(container_iter , container.end());
  58     }
  59
  60     void testEqualityTests()
  61     {
  62         int const a[] = { 1, 2, 3, 4 };
  63         int const b[] = { 1, 2, 3, 4 };
  64         int const c[] = { 1, 2, 3 };
  65         int const d[] = { 1, 2, 3, 5 };
  66         Inkscape::Util::ListContainer<int> c_a(ARRAY_RANGE(a));
  67         Inkscape::Util::ListContainer<int> c_b(ARRAY_RANGE(b));
  68         Inkscape::Util::ListContainer<int> c_c(ARRAY_RANGE(c));
  69         Inkscape::Util::ListContainer<int> c_d(ARRAY_RANGE(d));
  70
  71         TS_ASSERT(c_a == c_b);
  72         TS_ASSERT(!( c_a != c_b ));
  73         TS_ASSERT(!( c_a == c_c ));
  74         TS_ASSERT(c_a != c_c);
  75         TS_ASSERT(!( c_a == c_d ));
  76         TS_ASSERT(c_a != c_d);
  77     }
  78
  79     void testLessThan()
  80     {
  81         int const a[] = { 1, 2, 3, 4 };
  82         int const b[] = { 1, 2, 2, 4 };
  83         int const c[] = { 1, 2, 4, 4 };
  84         int const d[] = { 1, 2, 3 };
  85         Inkscape::Util::ListContainer<int> c_a(ARRAY_RANGE(a));
  86         Inkscape::Util::ListContainer<int> c_b(ARRAY_RANGE(b));
  87         Inkscape::Util::ListContainer<int> c_c(ARRAY_RANGE(c));
  88         Inkscape::Util::ListContainer<int> c_d(ARRAY_RANGE(d));
  89         TS_ASSERT(c_a >= c_b);
  90         TS_ASSERT(!( c_a < c_b ));
  91         TS_ASSERT(!( c_a >= c_c ));
  92         TS_ASSERT(c_a < c_c);
  93         TS_ASSERT(!( c_a < c_d ));
  94         TS_ASSERT(c_a >= c_d);
  95         TS_ASSERT(c_d < c_a);
  96     }
  97
  98     void testAssignmentOperator()
  99     {
 100         int const a[] = { 1, 2, 3, 4 };
 101         Inkscape::Util::ListContainer<int> c_a(ARRAY_RANGE(a));
 102         Inkscape::Util::ListContainer<int> c_c;
 103         TS_ASSERT(c_a != c_c);
 104         c_c = c_a;
 105         TS_ASSERT(c_a == c_c);
 106         c_c = c_a;
 107         TS_ASSERT(c_a == c_c);
 108     }
 109
 110     void testFillConstructor()
 111     {
 112         Inkscape::Util::ListContainer<int> filled((std::size_t)3, 2);
 113         TS_ASSERT(check_values(filled, 3, 2, 2, 2));
 114     }
 115
 116     void testContainerSize()
 117     {
 118         // max_size() and size() return ListContainer<>::size_type which is unsigned int
 119         Inkscape::Util::ListContainer<int> empty;
 120         TS_ASSERT(empty.empty());
 121         TS_ASSERT_EQUALS(empty.size(), 0u);
 122         int const a[] = { 1, 2, 3 };
 123         Inkscape::Util::ListContainer<int> c_a(ARRAY_RANGE(a));
 124         TS_ASSERT(!c_a.empty());
 125         TS_ASSERT_EQUALS(c_a.size(), 3u);
 126
 127         TS_ASSERT_LESS_THAN(0u, empty.max_size());
 128     }
 129
 130     void testAppending()
 131     {
 132         Inkscape::Util::ListContainer<int> c;
 133         c.push_back(1);
 134         TS_ASSERT(check_values(c, 1, 1));
 135         c.push_back(2);
 136         TS_ASSERT(check_values(c, 2, 1, 2));
 137         c.push_back(3);
 138         TS_ASSERT(check_values(c, 3, 1, 2, 3));
 139     }
 140
 141     void testBulkAppending()
 142     {
 143         int const a[] = { 1, 2, 3, 4 };
 144         int const b[] = { 5, 6, 7 };
 145         Inkscape::Util::ListContainer<int> c_a(ARRAY_RANGE(a));
 146         Inkscape::Util::ListContainer<int> c_b(ARRAY_RANGE(b));
 147         c_a.insert(c_a.end(), c_b.begin(), c_b.end());
 148         TS_ASSERT(check_values(c_a, 7, 1, 2, 3, 4, 5, 6, 7));
 149     }
 150
 151     void testPrepending()
 152     {
 153         Inkscape::Util::ListContainer<int> c;
 154         c.push_front(1);
 155         TS_ASSERT(check_values(c, 1, 1));
 156         c.push_front(2);
 157         TS_ASSERT(check_values(c, 2, 2, 1));
 158         c.push_front(3);
 159         TS_ASSERT(check_values(c, 3, 3, 2, 1));
 160     }
 161
 162     void testSingleValueInsertion()
 163     {
 164         Inkscape::Util::ListContainer<int> c;
 165
 166         c.insert(c.begin(), 1);
 167         TS_ASSERT(check_values(c, 1, 1));
 168
 169         c.insert(c.end(), 2);
 170         TS_ASSERT(check_values(c, 2, 1, 2));
 171
 172         c.insert(c.begin(), 3);
 173         TS_ASSERT(check_values(c, 3, 3, 1, 2));
 174
 175         Inkscape::Util::ListContainer<int>::iterator pos=c.begin();
 176         ++pos;
 177         c.insert(pos, 4);
 178         TS_ASSERT(check_values(c, 4, 3, 4, 1, 2));
 179     }
 180
 181     void testSingleValueErasure()
 182     {
 183         int const values[] = { 1, 2, 3, 4 };
 184         Inkscape::Util::ListContainer<int> c(ARRAY_RANGE(values));
 185
 186         c.erase(c.begin());
 187         TS_ASSERT(check_values(c, 3, 2, 3, 4));
 188
 189         Inkscape::Util::ListContainer<int>::iterator pos=c.begin();
 190         ++pos;
 191         c.erase(pos);
 192         TS_ASSERT(check_values(c, 2, 2, 4));
 193
 194         pos=c.begin();
 195         ++pos;
 196         c.erase(pos);
 197         TS_ASSERT(check_values(c, 1, 2));
 198
 199         c.erase(c.begin());
 200         TS_ASSERT(check_values(c, 0));
 201     }
 202
 203     void testPopFront()
 204     {
 205         int const full_ary[] = { 1, 2, 3 };
 206         Inkscape::Util::ListContainer<int> t(ARRAY_RANGE(full_ary));
 207         TS_ASSERT(check_values(t, 3,  1, 2, 3));
 208         TS_ASSERT_EQUALS(t.back() , 3);
 209         t.pop_front();
 210         TS_ASSERT(check_values(t, 2,  2, 3));
 211         TS_ASSERT_EQUALS(t.back() , 3);
 212         t.push_back(23);
 213         TS_ASSERT(check_values(t, 3,  2, 3, 23));
 214         TS_ASSERT_EQUALS(t.back() , 23);
 215         t.pop_front();
 216         TS_ASSERT(check_values(t, 2,  3, 23));
 217         TS_ASSERT_EQUALS(t.back() , 23);
 218         t.pop_front();
 219         TS_ASSERT(check_values(t, 1,  23));
 220         TS_ASSERT_EQUALS(t.back() , 23);
 221         t.pop_front();
 222         TS_ASSERT(check_values(t, 0));
 223         t.push_back(42);
 224         TS_ASSERT(check_values(t, 1,  42));
 225         TS_ASSERT_EQUALS(t.back() , 42);
 226     }
 227
 228     void testEraseAfter()
 229     {
 230         int const full_ary[] = { 1, 2, 3, 4 };
 231         int const exp_ary[] = { 1, 3, 4 };
 232         Inkscape::Util::ListContainer<int> full_list(ARRAY_RANGE(full_ary));
 233         Inkscape::Util::ListContainer<int> exp_list(ARRAY_RANGE(exp_ary));
 234         TS_ASSERT(full_list != exp_list);
 235         full_list.erase_after(full_list.begin());
 236         TS_ASSERT(full_list == exp_list);
 237     }
 238 };
 239
 240 /*
 241   Local Variables:
 242   mode:c++
 243   c-file-style:"stroustrup"
 244   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 245   indent-tabs-mode:nil
 246   fill-column:99
 247   End:
 248 */
 249 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :