libs/evoral/test/RangeTest.cpp

   1 #include "RangeTest.hpp"
   2 #include "evoral/Range.hpp"
   3 #include <stdlib.h>
   4
   5 CPPUNIT_TEST_SUITE_REGISTRATION (RangeTest);
   6
   7 using namespace Evoral;
   8
   9 void
  10 RangeTest::coalesceTest ()
  11 {
  12         RangeList<int> fred;
  13         fred.add (Range<int> (2, 4));
  14         fred.add (Range<int> (5, 6));
  15         fred.add (Range<int> (6, 8));
  16
  17         RangeList<int>::List jim = fred.get ();
  18
  19         RangeList<int>::List::iterator i = jim.begin ();
  20         CPPUNIT_ASSERT_EQUAL (2, i->from);
  21         CPPUNIT_ASSERT_EQUAL (4, i->to);
  22
  23         ++i;
  24         CPPUNIT_ASSERT_EQUAL (5, i->from);
  25         CPPUNIT_ASSERT_EQUAL (8, i->to);
  26 }
  27
  28 /* Basic subtraction of a few smaller ranges from a larger one */
  29 void
  30 RangeTest::subtractTest1 ()
  31 {
  32         Range<int> fred (0, 10);
  33
  34         RangeList<int> jim;
  35         jim.add (Range<int> (2, 4));
  36         jim.add (Range<int> (7, 8));
  37
  38         RangeList<int> sheila = subtract (fred, jim);
  39
  40         RangeList<int>::List s = sheila.get ();
  41         CPPUNIT_ASSERT_EQUAL (size_t (3), s.size ());
  42
  43         RangeList<int>::List::iterator i = s.begin ();
  44         CPPUNIT_ASSERT_EQUAL (0, i->from);
  45         CPPUNIT_ASSERT_EQUAL (1, i->to);
  46
  47         ++i;
  48         CPPUNIT_ASSERT_EQUAL (4, i->from);
  49         CPPUNIT_ASSERT_EQUAL (6, i->to);
  50
  51         ++i;
  52         CPPUNIT_ASSERT_EQUAL (8, i->from);
  53         CPPUNIT_ASSERT_EQUAL (10, i->to);
  54 }
  55
  56 /* Test subtraction of a range B from a range A, where A and B do not overlap */
  57 void
  58 RangeTest::subtractTest2 ()
  59 {
  60         Range<int> fred (0, 10);
  61
  62         RangeList<int> jim;
  63         jim.add (Range<int> (12, 19));
  64
  65         RangeList<int> sheila = subtract (fred, jim);
  66
  67         RangeList<int>::List s = sheila.get ();
  68         CPPUNIT_ASSERT_EQUAL (size_t (1), s.size ());
  69
  70         RangeList<int>::List::iterator i = s.begin ();
  71         CPPUNIT_ASSERT_EQUAL (0, i->from);
  72         CPPUNIT_ASSERT_EQUAL (10, i->to);
  73 }
  74
  75 /* Test subtraction of B from A, where B entirely overlaps A */
  76 void
  77 RangeTest::subtractTest3 ()
  78 {
  79         Range<int> fred (0, 10);
  80
  81         RangeList<int> jim;
  82         jim.add (Range<int> (0, 12));
  83
  84         RangeList<int> sheila = subtract (fred, jim);
  85
  86         RangeList<int>::List s = sheila.get ();
  87         CPPUNIT_ASSERT_EQUAL (size_t (0), s.size ());
  88 }
  89
  90 /* A bit like subtractTest1, except some of the ranges
  91    we are subtracting overlap.
  92 */
  93 void
  94 RangeTest::subtractTest4 ()
  95 {
  96         Range<int> fred (0, 10);
  97
  98         RangeList<int> jim;
  99         jim.add (Range<int> (2, 4));
 100         jim.add (Range<int> (7, 8));
 101         jim.add (Range<int> (8, 9));
 102
 103         RangeList<int> sheila = subtract (fred, jim);
 104
 105         RangeList<int>::List s = sheila.get ();
 106         CPPUNIT_ASSERT_EQUAL (size_t (3), s.size ());
 107
 108         RangeList<int>::List::iterator i = s.begin ();
 109         CPPUNIT_ASSERT_EQUAL (0, i->from);
 110         CPPUNIT_ASSERT_EQUAL (1, i->to);
 111
 112         ++i;
 113         CPPUNIT_ASSERT_EQUAL (4, i->from);
 114         CPPUNIT_ASSERT_EQUAL (6, i->to);
 115
 116         ++i;
 117         CPPUNIT_ASSERT_EQUAL (9, i->from);
 118         CPPUNIT_ASSERT_EQUAL (10, i->to);
 119 }
 120
 121 /* A bit like subtractTest1, except some of the ranges
 122    we are subtracting overlap the start / end of the
 123    initial range.
 124 */
 125 void
 126 RangeTest::subtractTest5 ()
 127 {
 128         Range<int> fred (1, 12);
 129
 130         RangeList<int> jim;
 131         jim.add (Range<int> (0, 4));
 132         jim.add (Range<int> (6, 7));
 133         jim.add (Range<int> (9, 42));
 134
 135         RangeList<int> sheila = subtract (fred, jim);
 136
 137         RangeList<int>::List s = sheila.get ();
 138         CPPUNIT_ASSERT_EQUAL (size_t (2), s.size ());
 139
 140         RangeList<int>::List::iterator i = s.begin ();
 141         CPPUNIT_ASSERT_EQUAL (4, i->from);
 142         CPPUNIT_ASSERT_EQUAL (5, i->to);
 143
 144         ++i;
 145         CPPUNIT_ASSERT_EQUAL (7, i->from);
 146         CPPUNIT_ASSERT_EQUAL (8, i->to);
 147 }
 148
 149 /* Test coverage() with all possible types of overlap.
 150  */
 151
 152 void
 153 RangeTest::coverageTest ()
 154 {
 155
 156         // b starts before a
 157         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 1, 1), Evoral::OverlapNone);
 158         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 1, 2), Evoral::OverlapNone);
 159         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 1, 3), Evoral::OverlapStart);
 160         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 1, 5), Evoral::OverlapStart);
 161         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 1, 7), Evoral::OverlapExternal);
 162         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 1, 9), Evoral::OverlapExternal);
 163
 164         // b starts at a
 165         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 3, 3), Evoral::OverlapStart);
 166         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 3, 5), Evoral::OverlapStart);
 167         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 3, 7), Evoral::OverlapExternal);
 168         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 3, 9), Evoral::OverlapExternal);
 169
 170         // b starts inside a
 171         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 4, 4), Evoral::OverlapInternal);
 172         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 4, 6), Evoral::OverlapInternal);
 173         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 4, 7), Evoral::OverlapEnd);
 174         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 4, 8), Evoral::OverlapEnd);
 175
 176         // b starts at end of a
 177         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 7, 7), Evoral::OverlapEnd);
 178         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 7, 9), Evoral::OverlapEnd);
 179
 180         // b starts after end of a
 181         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 8, 8), Evoral::OverlapNone);
 182         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 8, 9), Evoral::OverlapNone);
 183
 184         // zero-length range a
 185         CPPUNIT_ASSERT_EQUAL (coverage(3, 3, 2, 4), Evoral::OverlapExternal);
 186         CPPUNIT_ASSERT_EQUAL (coverage(3, 3, 1, 2), Evoral::OverlapNone);
 187         CPPUNIT_ASSERT_EQUAL (coverage(3, 3, 3, 3), Evoral::OverlapExternal);
 188         CPPUNIT_ASSERT_EQUAL (coverage(3, 3, 8, 9), Evoral::OverlapNone);
 189
 190         // negative length range a
 191         // XXX these are debatable - should we just consider start & end to be
 192         // swapped if end < start?
 193         CPPUNIT_ASSERT_EQUAL (coverage(4, 3, 1, 2), Evoral::OverlapNone);
 194         CPPUNIT_ASSERT_EQUAL (coverage(4, 3, 2, 3), Evoral::OverlapNone);
 195         CPPUNIT_ASSERT_EQUAL (coverage(4, 3, 2, 4), Evoral::OverlapNone);
 196         CPPUNIT_ASSERT_EQUAL (coverage(4, 3, 3, 3), Evoral::OverlapNone);
 197         CPPUNIT_ASSERT_EQUAL (coverage(4, 3, 8, 9), Evoral::OverlapNone);
 198
 199         // negative length range b
 200         // b starts before a
 201         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 1, 0), Evoral::OverlapNone);
 202         // b starts at a
 203         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 3, 2), Evoral::OverlapNone);
 204         // b starts inside a
 205         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 4, 3), Evoral::OverlapNone);
 206         // b starts at end of a
 207         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 7, 5), Evoral::OverlapNone);
 208         // b starts after end of a
 209         CPPUNIT_ASSERT_EQUAL (coverage(3, 7, 8, 7), Evoral::OverlapNone);
 210
 211 }