509 lines
14 KiB
C++
509 lines
14 KiB
C++
#include "unit-tests.h"
|
|
#include "unit-tests_Settings.h"
|
|
#include <src/MIDI.h>
|
|
#include <test/mocks/test-mocks_SerialMock.h>
|
|
|
|
BEGIN_MIDI_NAMESPACE
|
|
|
|
END_MIDI_NAMESPACE
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
BEGIN_UNNAMED_NAMESPACE
|
|
|
|
using namespace testing;
|
|
USING_NAMESPACE_UNIT_TESTS
|
|
typedef test_mocks::SerialMock<32> SerialMock;
|
|
typedef midi::SerialMIDI<SerialMock> Transport;
|
|
typedef midi::MidiInterface<Transport> MidiInterface;
|
|
typedef std::vector<byte> Buffer;
|
|
|
|
template<unsigned Size>
|
|
struct VariableSysExSettings : midi::DefaultSettings
|
|
{
|
|
static const unsigned SysExMaxSize = Size;
|
|
};
|
|
|
|
// -----------------------------------------------------------------------------
|
|
|
|
TEST(MidiThru, defaultValues)
|
|
{
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
MidiInterface midi((Transport&)transport);
|
|
|
|
EXPECT_EQ(midi.getThruState(), true);
|
|
EXPECT_EQ(midi.getFilterMode(), midi::Thru::Full);
|
|
midi.begin(); // Should not change the state
|
|
EXPECT_EQ(midi.getThruState(), true);
|
|
EXPECT_EQ(midi.getFilterMode(), midi::Thru::Full);
|
|
}
|
|
|
|
TEST(MidiThru, beginEnablesThru)
|
|
{
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
MidiInterface midi((Transport&)transport);
|
|
|
|
midi.turnThruOff();
|
|
EXPECT_EQ(midi.getThruState(), false);
|
|
EXPECT_EQ(midi.getFilterMode(), midi::Thru::Off);
|
|
midi.begin();
|
|
EXPECT_EQ(midi.getThruState(), true);
|
|
EXPECT_EQ(midi.getFilterMode(), midi::Thru::Full);
|
|
}
|
|
|
|
TEST(MidiThru, setGet)
|
|
{
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
MidiInterface midi((Transport&)transport);
|
|
|
|
midi.turnThruOff();
|
|
EXPECT_EQ(midi.getThruState(), false);
|
|
EXPECT_EQ(midi.getFilterMode(), midi::Thru::Off);
|
|
|
|
midi.turnThruOn();
|
|
EXPECT_EQ(midi.getThruState(), true);
|
|
EXPECT_EQ(midi.getFilterMode(), midi::Thru::Full);
|
|
midi.turnThruOn(midi::Thru::SameChannel);
|
|
EXPECT_EQ(midi.getThruState(), true);
|
|
EXPECT_EQ(midi.getFilterMode(), midi::Thru::SameChannel);
|
|
midi.turnThruOn(midi::Thru::DifferentChannel);
|
|
EXPECT_EQ(midi.getThruState(), true);
|
|
EXPECT_EQ(midi.getFilterMode(), midi::Thru::DifferentChannel);
|
|
|
|
midi.setThruFilterMode(midi::Thru::Full);
|
|
EXPECT_EQ(midi.getThruState(), true);
|
|
EXPECT_EQ(midi.getFilterMode(), midi::Thru::Full);
|
|
midi.setThruFilterMode(midi::Thru::SameChannel);
|
|
EXPECT_EQ(midi.getThruState(), true);
|
|
EXPECT_EQ(midi.getFilterMode(), midi::Thru::SameChannel);
|
|
midi.setThruFilterMode(midi::Thru::DifferentChannel);
|
|
EXPECT_EQ(midi.getThruState(), true);
|
|
EXPECT_EQ(midi.getFilterMode(), midi::Thru::DifferentChannel);
|
|
midi.setThruFilterMode(midi::Thru::Off);
|
|
EXPECT_EQ(midi.getThruState(), false);
|
|
EXPECT_EQ(midi.getFilterMode(), midi::Thru::Off);
|
|
}
|
|
|
|
TEST(MidiThru, off)
|
|
{
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
MidiInterface midi((Transport&)transport);
|
|
|
|
midi.begin(MIDI_CHANNEL_OMNI);
|
|
midi.turnThruOff();
|
|
|
|
static const unsigned rxSize = 5;
|
|
static const byte rxData[rxSize] = { 0x9b, 12, 34, 56, 78 };
|
|
serial.mRxBuffer.write(rxData, rxSize);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), true);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), true);
|
|
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
}
|
|
|
|
TEST(MidiThru, full)
|
|
{
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
MidiInterface midi((Transport&)transport);
|
|
|
|
Buffer buffer;
|
|
|
|
midi.begin(MIDI_CHANNEL_OMNI);
|
|
midi.setThruFilterMode(midi::Thru::Full);
|
|
|
|
static const unsigned rxSize = 6;
|
|
static const byte rxData[rxSize] = { 0x9b, 12, 34, 0x9c, 56, 78 };
|
|
serial.mRxBuffer.write(rxData, rxSize);
|
|
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), true);
|
|
|
|
buffer.clear();
|
|
buffer.resize(3);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 3);
|
|
serial.mTxBuffer.read(&buffer[0], 3);
|
|
EXPECT_THAT(buffer, ElementsAreArray({
|
|
0x9b, 12, 34
|
|
}));
|
|
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), true);
|
|
|
|
buffer.clear();
|
|
buffer.resize(3);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 3);
|
|
serial.mTxBuffer.read(&buffer[0], 3);
|
|
EXPECT_THAT(buffer, ElementsAreArray({
|
|
0x9c, 56, 78
|
|
}));
|
|
}
|
|
|
|
TEST(MidiThru, sameChannel)
|
|
{
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
MidiInterface midi((Transport&)transport);
|
|
|
|
Buffer buffer;
|
|
|
|
midi.begin(12);
|
|
midi.setThruFilterMode(midi::Thru::SameChannel);
|
|
|
|
static const unsigned rxSize = 6;
|
|
static const byte rxData[rxSize] = { 0x9b, 12, 34, 0x9c, 56, 78 };
|
|
serial.mRxBuffer.write(rxData, rxSize);
|
|
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), true);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), false);
|
|
|
|
buffer.clear();
|
|
buffer.resize(3);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 3);
|
|
serial.mTxBuffer.read(&buffer[0], 3);
|
|
EXPECT_THAT(buffer, ElementsAreArray({
|
|
0x9b, 12, 34
|
|
}));
|
|
}
|
|
|
|
TEST(MidiThru, sameChannelOmni) // Acts like full
|
|
{
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
MidiInterface midi((Transport&)transport);
|
|
|
|
Buffer buffer;
|
|
|
|
midi.begin(MIDI_CHANNEL_OMNI);
|
|
midi.setThruFilterMode(midi::Thru::SameChannel);
|
|
|
|
static const unsigned rxSize = 6;
|
|
static const byte rxData[rxSize] = { 0x9b, 12, 34, 0x9c, 56, 78 };
|
|
serial.mRxBuffer.write(rxData, rxSize);
|
|
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), true);
|
|
|
|
buffer.clear();
|
|
buffer.resize(3);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 3);
|
|
serial.mTxBuffer.read(&buffer[0], 3);
|
|
EXPECT_THAT(buffer, ElementsAreArray({
|
|
0x9b, 12, 34
|
|
}));
|
|
|
|
buffer.clear();
|
|
buffer.resize(3);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), true);
|
|
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 3); // Not using TX running status
|
|
serial.mTxBuffer.read(&buffer[0], 3);
|
|
EXPECT_THAT(buffer, ElementsAreArray({
|
|
0x9c, 56, 78
|
|
}));
|
|
}
|
|
|
|
TEST(MidiThru, differentChannel)
|
|
{
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
MidiInterface midi((Transport&)transport);
|
|
|
|
Buffer buffer;
|
|
|
|
midi.begin(12);
|
|
midi.setThruFilterMode(midi::Thru::DifferentChannel);
|
|
|
|
static const unsigned rxSize = 6;
|
|
static const byte rxData[rxSize] = { 0x9b, 12, 34, 0x9c, 56, 78 };
|
|
serial.mRxBuffer.write(rxData, rxSize);
|
|
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), true);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), false);
|
|
|
|
buffer.clear();
|
|
buffer.resize(3);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 3);
|
|
serial.mTxBuffer.read(&buffer[0], 3);
|
|
EXPECT_THAT(buffer, ElementsAreArray({
|
|
0x9c, 56, 78
|
|
}));
|
|
}
|
|
|
|
TEST(MidiThru, differentChannelOmni) // Acts like off
|
|
{
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
MidiInterface midi((Transport&)transport);
|
|
|
|
Buffer buffer;
|
|
|
|
midi.begin(MIDI_CHANNEL_OMNI);
|
|
midi.setThruFilterMode(midi::Thru::DifferentChannel);
|
|
|
|
static const unsigned rxSize = 6;
|
|
static const byte rxData[rxSize] = { 0x9b, 12, 34, 0x9c, 56, 78 };
|
|
serial.mRxBuffer.write(rxData, rxSize);
|
|
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), true);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), true);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
}
|
|
|
|
TEST(MidiThru, multiByteThru)
|
|
{
|
|
typedef VariableSettings<false, false> MultiByteParsing;
|
|
typedef midi::MidiInterface<Transport, MultiByteParsing> MultiByteMidiInterface;
|
|
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
MultiByteMidiInterface midi((Transport&)transport);
|
|
|
|
Buffer buffer;
|
|
|
|
midi.begin(MIDI_CHANNEL_OMNI);
|
|
midi.setThruFilterMode(midi::Thru::Full);
|
|
|
|
static const unsigned rxSize = 6;
|
|
static const byte rxData[rxSize] = { 0x9b, 12, 34, 56, 78 };
|
|
serial.mRxBuffer.write(rxData, rxSize);
|
|
|
|
EXPECT_EQ(midi.read(), true);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 3);
|
|
EXPECT_EQ(midi.read(), true);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 6);
|
|
|
|
buffer.clear();
|
|
buffer.resize(6);
|
|
serial.mTxBuffer.read(&buffer[0], 6);
|
|
EXPECT_THAT(buffer, ElementsAreArray({
|
|
0x9b, 12, 34, 0x9b, 56, 78
|
|
}));
|
|
}
|
|
|
|
TEST(MidiThru, withTxRunningStatus)
|
|
{
|
|
typedef VariableSettings<true, true> Settings;
|
|
typedef midi::MidiInterface<Transport, Settings> RsMidiInterface;
|
|
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
RsMidiInterface midi((Transport&)transport);
|
|
|
|
Buffer buffer;
|
|
|
|
midi.begin(MIDI_CHANNEL_OMNI);
|
|
midi.setThruFilterMode(midi::Thru::Full);
|
|
|
|
static const unsigned rxSize = 5;
|
|
static const byte rxData[rxSize] = { 0x9b, 12, 34, 56, 78 };
|
|
serial.mRxBuffer.write(rxData, rxSize);
|
|
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), true);
|
|
|
|
buffer.clear();
|
|
buffer.resize(3);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 3);
|
|
serial.mTxBuffer.read(&buffer[0], 3);
|
|
EXPECT_THAT(buffer, ElementsAreArray({
|
|
0x9b, 12, 34
|
|
}));
|
|
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), true);
|
|
|
|
buffer.clear();
|
|
buffer.resize(2);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 2);
|
|
serial.mTxBuffer.read(&buffer[0], 2);
|
|
EXPECT_THAT(buffer, ElementsAreArray({
|
|
56, 78
|
|
}));
|
|
}
|
|
|
|
TEST(MidiThru, invalidMode)
|
|
{
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
MidiInterface midi((Transport&)transport);
|
|
|
|
midi.begin(MIDI_CHANNEL_OMNI);
|
|
midi.setThruFilterMode(midi::Thru::Mode(42));
|
|
|
|
static const unsigned rxSize = 6;
|
|
static const byte rxData[rxSize] = { 0x9b, 12, 34, 0x9c, 56, 78 };
|
|
serial.mRxBuffer.write(rxData, rxSize);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), true);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), true);
|
|
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
}
|
|
|
|
TEST(MidiThru, unmutedChannelsNoneMuted) // acts like full
|
|
{
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
MidiInterface midi((Transport&)transport);
|
|
|
|
Buffer buffer;
|
|
|
|
midi.begin(MIDI_CHANNEL_OMNI);
|
|
midi.setThruFilterMode(midi::Thru::UnmutedChannels);
|
|
|
|
static const unsigned rxSize = 6;
|
|
static const byte rxData[rxSize] = { 0x9b, 12, 34, 0x9c, 56, 78 };
|
|
serial.mRxBuffer.write(rxData, rxSize);
|
|
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), true);
|
|
|
|
buffer.clear();
|
|
buffer.resize(3);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 3);
|
|
serial.mTxBuffer.read(&buffer[0], 3);
|
|
EXPECT_THAT(buffer, ElementsAreArray({
|
|
0x9b, 12, 34
|
|
}));
|
|
|
|
buffer.clear();
|
|
buffer.resize(3);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), true);
|
|
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 3); // Not using TX running status
|
|
serial.mTxBuffer.read(&buffer[0], 3);
|
|
EXPECT_THAT(buffer, ElementsAreArray({
|
|
0x9c, 56, 78
|
|
}));
|
|
}
|
|
|
|
TEST(MidiThru, unmutedChannelsWithMutedChannelTwelve)
|
|
{
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
MidiInterface midi((Transport&)transport);
|
|
|
|
Buffer buffer;
|
|
|
|
midi.begin(MIDI_CHANNEL_OMNI);
|
|
midi.setThruFilterMode(midi::Thru::UnmutedChannels);
|
|
bool thruMutedChannels[17] = {
|
|
false,
|
|
false, false, false, false, false, false, false, false,
|
|
false, false, false, true, false, false, false, false
|
|
};
|
|
midi.setThruMutedChannels(thruMutedChannels);
|
|
|
|
|
|
static const unsigned rxSize = 6;
|
|
static const byte rxData[rxSize] = { 0x9b, 12, 34, 0x9c, 56, 78 };
|
|
serial.mRxBuffer.write(rxData, rxSize);
|
|
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), true);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(midi.read(), true);
|
|
|
|
buffer.clear();
|
|
buffer.resize(3);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 3);
|
|
serial.mTxBuffer.read(&buffer[0], 3);
|
|
EXPECT_THAT(buffer, ElementsAreArray({
|
|
0x9c, 56, 78
|
|
}));
|
|
}
|
|
|
|
TEST(MidiThru, unmutedChannelsWithChannelZeroMuted) // acts like off
|
|
{
|
|
SerialMock serial;
|
|
Transport transport(serial);
|
|
MidiInterface midi((Transport&)transport);
|
|
|
|
Buffer buffer;
|
|
|
|
midi.begin(MIDI_CHANNEL_OMNI);
|
|
midi.setThruFilterMode(midi::Thru::UnmutedChannels);
|
|
bool thruMutedChannels[17] = {
|
|
true,
|
|
false, false, false, false, false, false, false, false,
|
|
false, false, false, true, false, false, false, false
|
|
};
|
|
midi.setThruMutedChannels(thruMutedChannels);
|
|
|
|
|
|
static const unsigned rxSize = 6;
|
|
static const byte rxData[rxSize] = { 0x9b, 12, 34, 0x9c, 56, 78 };
|
|
serial.mRxBuffer.write(rxData, rxSize);
|
|
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), true);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), false);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
EXPECT_EQ(midi.read(), true);
|
|
EXPECT_EQ(serial.mTxBuffer.getLength(), 0);
|
|
}
|
|
|
|
END_UNNAMED_NAMESPACE
|