← Back to branch summary

~ubuntu-branches/ubuntu/utopic/ardour3/utopic

« back to all changes in this revision

Viewing changes to libs/evoral/test/SequenceTest.hpp

  • Committer: Package Import Robot
  • Author(s): Felipe Sateler
  • Date: 2013-09-21 19:05:02 UTC
  • Revision ID: package-import@ubuntu.com-20130921190502-8gsftrku6jnzhd7v
Tags: upstream-3.4~dfsg
Import upstream version 3.4~dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
};