libs/evoral/test/SequenceTest.hpp

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