libs/evoral/test/SequenceTest.cpp

   1 #include "SequenceTest.hpp"
   2 #include <cassert>
   3
   4 CPPUNIT_TEST_SUITE_REGISTRATION(SequenceTest);
   5
   6 using namespace std;
   7 using namespace Evoral;
   8
   9 void
  10 SequenceTest::createTest ()
  11 {
  12         CPPUNIT_ASSERT_EQUAL(size_t(0), seq->sysexes().size());
  13         CPPUNIT_ASSERT_EQUAL(size_t(0), seq->notes().size());
  14         CPPUNIT_ASSERT(seq->notes().begin() == seq->notes().end());
  15 }
  16
  17
  18 void
  19 SequenceTest::preserveEventOrderingTest ()
  20 {
  21         vector< boost::shared_ptr< Event<Time> > > inserted_events;
  22
  23         seq->start_write();
  24
  25         for (Notes::const_iterator i = test_notes.begin(); i != test_notes.end(); ++i) {
  26                 uint8_t buffer[3];
  27                 Event<Time>* event = new Event<Time>(
  28                                 DummyTypeMap::CONTROL, (*i)->on_event().time(), 3, buffer, true
  29                 );
  30
  31                 event->buffer()[0] = MIDI_CMD_CONTROL;
  32                 event->buffer()[1] = event->time().to_double() / 1000;
  33                 event->buffer()[2] = event->time().to_double() / 1000;
  34
  35                 boost::shared_ptr<Event<Time> > event_ptr(event);
  36
  37                 seq->append((*i)->on_event(), next_event_id ());
  38                 inserted_events.push_back(
  39                                 boost::shared_ptr<Event<Time> >(
  40                                                 new Event<Time>((*i)->on_event(), true)
  41                 ));
  42
  43                 seq->append(*event_ptr, next_event_id ());
  44                 inserted_events.push_back(event_ptr);
  45
  46                 seq->append((*i)->off_event(), next_event_id ());
  47                 inserted_events.push_back(
  48                                 boost::shared_ptr<Event<Time> >(
  49                                                 new Event<Time>((*i)->off_event(), true)
  50                 ));
  51         }
  52
  53         seq->end_write (Sequence<Time>::Relax);
  54
  55         TestSink<Time> sink;
  56         sink.writing.connect(sigc::mem_fun(&sink, &TestSink<Time>::assertLastEventTimeEarlier));
  57
  58
  59         for (MySequence<Time>::const_iterator i = seq->begin(); i != seq->end(); ++i) {
  60                 sink.write(i->time(), i->event_type(), i->size(), i->buffer());
  61         }
  62
  63         CPPUNIT_ASSERT_EQUAL(size_t(12), test_notes.size());
  64 }
  65
  66 void
  67 SequenceTest::iteratorSeekTest ()
  68 {
  69         size_t num_notes = 0;
  70
  71         seq->clear();
  72
  73         for (Notes::const_iterator i = test_notes.begin(); i != test_notes.end(); ++i) {
  74                 seq->notes().insert(*i);
  75         }
  76
  77         bool on = true;
  78         for (Sequence<Time>::const_iterator i = seq->begin(Evoral::MusicalTime(600)); i != seq->end(); ++i) {
  79                 if (on) {
  80                         CPPUNIT_ASSERT(((const MIDIEvent<Time>&)*i).is_note_on());
  81                         CPPUNIT_ASSERT_EQUAL(i->time(), Time((num_notes + 6) * 100));
  82                         ++num_notes;
  83                         on = false;
  84                 } else {
  85                         CPPUNIT_ASSERT(((const MIDIEvent<Time>&)*i).is_note_off());
  86                         on = true;
  87                 }
  88         }
  89
  90         CPPUNIT_ASSERT_EQUAL(num_notes, size_t(6));
  91 }
  92
  93 void
  94 SequenceTest::controlInterpolationTest ()
  95 {
  96         seq->clear();
  97
  98         for (Notes::const_iterator i = test_notes.begin(); i != test_notes.end(); ++i) {
  99                 seq->notes().insert(*i);
 100         }
 101
 102         static const uint64_t delay   = 1000;
 103         static const uint32_t cc_type = 1;
 104
 105         boost::shared_ptr<Control> c = seq->control(Parameter(cc_type, 1, 1), true);
 106         CPPUNIT_ASSERT(c);
 107
 108         double min = 0.0;
 109         double max = 127.0;
 110
 111         // Make a ramp like /\ from min to max and back to min
 112         c->set_double(min, 0, true);
 113         c->set_double(max, delay, true);
 114         c->set_double(min, 2*delay, true);
 115
 116         CCTestSink<Time> sink(cc_type);
 117
 118         // Test discrete (lack of) interpolation
 119         c->list()->set_interpolation(ControlList::Discrete);
 120         for (MySequence<Time>::const_iterator i = seq->begin(); i != seq->end(); ++i) {
 121                 sink.write(i->time(), i->event_type(), i->size(), i->buffer());
 122         }
 123         CPPUNIT_ASSERT(sink.events.size() == 3);
 124         CPPUNIT_ASSERT(sink.events[0].first == 0);
 125         CPPUNIT_ASSERT(sink.events[0].second == 0);
 126         CPPUNIT_ASSERT(sink.events[1].first == 1000);
 127         CPPUNIT_ASSERT(sink.events[1].second == 127);
 128         CPPUNIT_ASSERT(sink.events[2].first == 2000);
 129         CPPUNIT_ASSERT(sink.events[2].second == 0);
 130         sink.events.clear();
 131         CPPUNIT_ASSERT(sink.events.size() == 0);
 132
 133         // Test linear interpolation
 134         c->list()->set_interpolation(ControlList::Linear);
 135         for (MySequence<Time>::const_iterator i = seq->begin(); i != seq->end(); ++i) {
 136                 sink.write(i->time(), i->event_type(), i->size(), i->buffer());
 137         }
 138         CPPUNIT_ASSERT(sink.events.size() == 128 * 2 - 1);
 139         Time    last_time(0);
 140         int16_t last_value = -1;
 141         bool    ascending  = true;
 142         for (CCTestSink<Time>::Events::const_iterator i = sink.events.begin();
 143                         i != sink.events.end(); ++i) {
 144                 CPPUNIT_ASSERT(last_time == 0 || i->first > last_time);
 145                 if (last_value == 127) {
 146                         ascending = false;
 147                 }
 148                 if (ascending) {
 149                         CPPUNIT_ASSERT(i->second == last_value + 1);
 150                 } else {
 151                         CPPUNIT_ASSERT(i->second == last_value - 1);
 152                 }
 153                 last_time = i->first;
 154                 last_value = i->second;
 155         }
 156 }