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