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         Inkscape::Util::ListContainer<int> empty;
 119         TS_ASSERT(empty.empty());
 120         TS_ASSERT_EQUALS(static_cast<int>(empty.size()), 0);
 121         int const a[] = { 1, 2, 3 };
 122         Inkscape::Util::ListContainer<int> c_a(ARRAY_RANGE(a));
 123         TS_ASSERT(!c_a.empty());
 124         TS_ASSERT_EQUALS(static_cast<int>(c_a.size()), 3);
 125
 126         TS_ASSERT_LESS_THAN(0, static_cast<int>(empty.max_size()));
 127     }
 128
 129     void testAppending()
 130     {
 131         Inkscape::Util::ListContainer<int> c;
 132         c.push_back(1);
 133         TS_ASSERT(check_values(c, 1, 1));
 134         c.push_back(2);
 135         TS_ASSERT(check_values(c, 2, 1, 2));
 136         c.push_back(3);
 137         TS_ASSERT(check_values(c, 3, 1, 2, 3));
 138     }
 139
 140     void testBulkAppending()
 141     {
 142         int const a[] = { 1, 2, 3, 4 };
 143         int const b[] = { 5, 6, 7 };
 144         Inkscape::Util::ListContainer<int> c_a(ARRAY_RANGE(a));
 145         Inkscape::Util::ListContainer<int> c_b(ARRAY_RANGE(b));
 146         c_a.insert(c_a.end(), c_b.begin(), c_b.end());
 147         TS_ASSERT(check_values(c_a, 7, 1, 2, 3, 4, 5, 6, 7));
 148     }
 149
 150     void testPrepending()
 151     {
 152         Inkscape::Util::ListContainer<int> c;
 153         c.push_front(1);
 154         TS_ASSERT(check_values(c, 1, 1));
 155         c.push_front(2);
 156         TS_ASSERT(check_values(c, 2, 2, 1));
 157         c.push_front(3);
 158         TS_ASSERT(check_values(c, 3, 3, 2, 1));
 159     }
 160
 161     void testSingleValueInsertion()
 162     {
 163         Inkscape::Util::ListContainer<int> c;
 164
 165         c.insert(c.begin(), 1);
 166         TS_ASSERT(check_values(c, 1, 1));
 167
 168         c.insert(c.end(), 2);
 169         TS_ASSERT(check_values(c, 2, 1, 2));
 170
 171         c.insert(c.begin(), 3);
 172         TS_ASSERT(check_values(c, 3, 3, 1, 2));
 173
 174         Inkscape::Util::ListContainer<int>::iterator pos=c.begin();
 175         ++pos;
 176         c.insert(pos, 4);
 177         TS_ASSERT(check_values(c, 4, 3, 4, 1, 2));
 178     }
 179
 180     void testSingleValueErasure()
 181     {
 182         int const values[] = { 1, 2, 3, 4 };
 183         Inkscape::Util::ListContainer<int> c(ARRAY_RANGE(values));
 184
 185         c.erase(c.begin());
 186         TS_ASSERT(check_values(c, 3, 2, 3, 4));
 187
 188         Inkscape::Util::ListContainer<int>::iterator pos=c.begin();
 189         ++pos;
 190         c.erase(pos);
 191         TS_ASSERT(check_values(c, 2, 2, 4));
 192
 193         pos=c.begin();
 194         ++pos;
 195         c.erase(pos);
 196         TS_ASSERT(check_values(c, 1, 2));
 197
 198         c.erase(c.begin());
 199         TS_ASSERT(check_values(c, 0));
 200     }
 201
 202     void testPopFront()
 203     {
 204         int const full_ary[] = { 1, 2, 3 };
 205         Inkscape::Util::ListContainer<int> t(ARRAY_RANGE(full_ary));
 206         TS_ASSERT(check_values(t, 3,  1, 2, 3));
 207         TS_ASSERT_EQUALS(t.back() , 3);
 208         t.pop_front();
 209         TS_ASSERT(check_values(t, 2,  2, 3));
 210         TS_ASSERT_EQUALS(t.back() , 3);
 211         t.push_back(23);
 212         TS_ASSERT(check_values(t, 3,  2, 3, 23));
 213         TS_ASSERT_EQUALS(t.back() , 23);
 214         t.pop_front();
 215         TS_ASSERT(check_values(t, 2,  3, 23));
 216         TS_ASSERT_EQUALS(t.back() , 23);
 217         t.pop_front();
 218         TS_ASSERT(check_values(t, 1,  23));
 219         TS_ASSERT_EQUALS(t.back() , 23);
 220         t.pop_front();
 221         TS_ASSERT(check_values(t, 0));
 222         t.push_back(42);
 223         TS_ASSERT(check_values(t, 1,  42));
 224         TS_ASSERT_EQUALS(t.back() , 42);
 225     }
 226
 227     void testEraseAfter()
 228     {
 229         int const full_ary[] = { 1, 2, 3, 4 };
 230         int const exp_ary[] = { 1, 3, 4 };
 231         Inkscape::Util::ListContainer<int> full_list(ARRAY_RANGE(full_ary));
 232         Inkscape::Util::ListContainer<int> exp_list(ARRAY_RANGE(exp_ary));
 233         TS_ASSERT(full_list != exp_list);
 234         full_list.erase_after(full_list.begin());
 235         TS_ASSERT(full_list == exp_list);
 236     }
 237 };
 238
 239 /*
 240   Local Variables:
 241   mode:c++
 242   c-file-style:"stroustrup"
 243   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 244   indent-tabs-mode:nil
 245   fill-column:99
 246   End:
 247 */
 248 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :