libs/evoral/test/SequenceTest.hpp

   1 #include <cassert>
   2 #include <sigc++/sigc++.h>
   3 #include <cppunit/TestFixture.h>
   4 #include <cppunit/extensions/HelperMacros.h>
   5 #include "evoral/Sequence.hpp"
   6 #include "evoral/TypeMap.hpp"
   7 #include "evoral/EventSink.hpp"
   8 #include "evoral/midi_events.h"
   9 #include "evoral/Control.hpp"
  10
  11 using namespace Evoral;
  12
  13 class DummyTypeMap : public TypeMap {
  14 public:
  15         enum DummyEventType {
  16                 NOTE,
  17                 CONTROL,
  18                 SYSEX
  19         };
  20
  21         ~DummyTypeMap() {}
  22
  23         bool type_is_midi (uint32_t /*type*/) const { return true; }
  24
  25         uint8_t parameter_midi_type(const Parameter& param) const {
  26                 switch (param.type()) {
  27                 case CONTROL:       return MIDI_CMD_CONTROL;
  28                 case SYSEX:         return MIDI_CMD_COMMON_SYSEX;
  29                 default:            return 0;
  30                 };
  31         }
  32
  33         uint32_t midi_event_type(uint8_t status) const {
  34                 status &= 0xf0;
  35                 switch (status) {
  36                 case MIDI_CMD_CONTROL:          return CONTROL;
  37                 case MIDI_CMD_COMMON_SYSEX:     return SYSEX;
  38                 default:                        return 0;
  39                 };
  40         }
  41
  42         bool is_integer (const Evoral::Parameter& /*param*/) const { return true; }
  43
  44         Parameter new_parameter(uint32_t type, uint8_t channel, uint32_t id) const {
  45                 Parameter p(type, channel, id);
  46                 p.set_range(type, 0.0f, 1.0f, 0.0f);
  47                 return p;
  48         }
  49
  50         std::string to_symbol(const Parameter& /*param*/) const { return "control"; }
  51 };
  52
  53 template<typename Time>
  54 class MySequence : public Sequence<Time> {
  55 public:
  56         MySequence(DummyTypeMap&map) : Sequence<Time>(map) {}
  57
  58         boost::shared_ptr<Control> control_factory(const Parameter& param) {
  59
  60                 return boost::shared_ptr<Control>(
  61                         new Control(param, boost::shared_ptr<ControlList> (
  62                                 new ControlList(param)
  63                 )));
  64         }
  65 };
  66
  67 template<typename Time>
  68 class TestSink : public EventSink<Time> {
  69 public:
  70         TestSink() : _last_event_time(-1) {}
  71
  72         /// return value, time, type, size, buffer
  73         sigc::signal<uint32_t, Time, EventType, uint32_t, const uint8_t*> writing;
  74
  75         virtual uint32_t write(Time time, EventType type, uint32_t size, const uint8_t* buf) {
  76                 //std::cerr << "last event time: " << _last_event_time << " time: " << time << std::endl;
  77                 uint32_t result = writing(time, type, size, buf);
  78                 _last_event_time = time;
  79                 return result;
  80         }
  81
  82         uint32_t assertLastEventTimeEarlier(
  83                         Time time, EventType /*type*/, uint32_t /*size*/, const uint8_t* /*buf*/) {
  84                 CPPUNIT_ASSERT(_last_event_time <= time);
  85                 return 0;
  86         }
  87
  88         Time last_event_time() const { return _last_event_time; }
  89
  90 private:
  91         Time _last_event_time;
  92 };
  93
  94 template<typename Time>
  95 class CCTestSink : public EventSink<Time> {
  96 public:
  97         CCTestSink(uint32_t t) : cc_type(t) {}
  98
  99         virtual uint32_t write(Time time, EventType type, uint32_t size, const uint8_t* buf) {
 100                 if (type == cc_type) {
 101                         CPPUNIT_ASSERT(size == 3);
 102                         events.push_back(std::make_pair(time, buf[2]));
 103                 }
 104                 return size;
 105         }
 106
 107         typedef std::vector< std::pair<Time, uint8_t> > Events;
 108         Events events;
 109         uint32_t cc_type;
 110 };
 111
 112 class SequenceTest : public CppUnit::TestFixture
 113 {
 114         CPPUNIT_TEST_SUITE (SequenceTest);
 115         CPPUNIT_TEST (createTest);
 116         CPPUNIT_TEST (preserveEventOrderingTest);
 117         CPPUNIT_TEST (iteratorSeekTest);
 118         CPPUNIT_TEST (controlInterpolationTest);
 119         CPPUNIT_TEST_SUITE_END ();
 120
 121 public:
 122         typedef double Time;
 123         typedef std::vector< boost::shared_ptr< Note<Time> > > Notes;
 124
 125         void setUp () {
 126                 type_map = new DummyTypeMap();
 127                 assert(type_map);
 128                 seq = new MySequence<Time>(*type_map);
 129                 assert(seq);
 130
 131                 for (int i = 0; i < 12; i++) {
 132                         test_notes.push_back(boost::shared_ptr<Note<Time> >
 133                                         (new Note<Time>(0, i * 100, 100, 64 + i, 64)));
 134                 }
 135         }
 136
 137         void tearDown () {
 138                 test_notes.clear();
 139                 delete seq;
 140                 delete type_map;
 141         }
 142
 143         void createTest ();
 144         void preserveEventOrderingTest ();
 145         void iteratorSeekTest ();
 146         void controlInterpolationTest ();
 147
 148 private:
 149         DummyTypeMap*       type_map;
 150         MySequence<Time>*   seq;
 151
 152         Notes test_notes;
 153 };