visus
/
framework-arduinoteensy-cxx20
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
Tree: 16a0c39090
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '16a0c39090'
${ noResults }
framework-arduinoteensy-cxx20/libraries/MIDI/test/unit-tests/tests/unit-tests_MidiInput.cpp

992 lines
34KB
Raw Blame History 

  1. #include "unit-tests.h"

  2. #include "unit-tests_Settings.h"

  3. #include <src/MIDI.h>

  4. #include <test/mocks/test-mocks_SerialMock.h>

  5. 

  6. BEGIN_MIDI_NAMESPACE

  7. 

  8. END_MIDI_NAMESPACE

  9. 

  10. // -----------------------------------------------------------------------------

  11. 

  12. BEGIN_UNNAMED_NAMESPACE

  13. 

  14. using namespace testing;

  15. USING_NAMESPACE_UNIT_TESTS

  16. typedef test_mocks::SerialMock<32> SerialMock;

  17. typedef midi::SerialMIDI<SerialMock> Transport;

  18. typedef midi::MidiInterface<Transport> MidiInterface;

  19. 

  20. template<unsigned Size>

  21. struct VariableSysExSettings : midi::DefaultSettings

  22. {

  23.     static const unsigned SysExMaxSize = Size;

  24. };

  25. 

  26. TEST(MidiInput, getTypeFromStatusByte)

  27. {

  28.     // Channel Messages

  29.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0x81), midi::NoteOff);

  30.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0x92), midi::NoteOn);

  31.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xa3), midi::AfterTouchPoly);

  32.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xb4), midi::ControlChange);

  33.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xc5), midi::ProgramChange);

  34.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xd6), midi::AfterTouchChannel);

  35.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xe7), midi::PitchBend);

  36. 

  37.     // System Messages

  38.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xf0), midi::SystemExclusive);

  39.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xf1), midi::TimeCodeQuarterFrame);

  40.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xf2), midi::SongPosition);

  41.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xf3), midi::SongSelect);

  42.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xf6), midi::TuneRequest);

  43.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xf8), midi::Clock);

  44.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xfa), midi::Start);

  45.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xfb), midi::Continue);

  46.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xfc), midi::Stop);

  47.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xfe), midi::ActiveSensing);

  48.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xff), midi::SystemReset);

  49. 

  50.     // Invalid Messages

  51.     for (int i = 0; i < 0x80; ++i)

  52.     {

  53.         EXPECT_EQ(MidiInterface::getTypeFromStatusByte(i), midi::InvalidType);

  54.     }

  55.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xf4), midi::InvalidType);

  56.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xf5), midi::InvalidType);

  57.     EXPECT_EQ(MidiInterface::getTypeFromStatusByte(0xfd), midi::InvalidType);

  58. }

  59. 

  60. TEST(MidiInput, getChannelFromStatusByte)

  61. {

  62.     EXPECT_EQ(MidiInterface::getChannelFromStatusByte(0x00), 1);

  63.     EXPECT_EQ(MidiInterface::getChannelFromStatusByte(0x80), 1);

  64.     EXPECT_EQ(MidiInterface::getChannelFromStatusByte(0x94), 5);

  65.     EXPECT_EQ(MidiInterface::getChannelFromStatusByte(0xaf), 16);

  66. }

  67. 

  68. TEST(MidiInput, isChannelMessage)

  69. {

  70.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::InvalidType),           false);

  71.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::NoteOff),               true);

  72.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::NoteOn),                true);

  73.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::AfterTouchPoly),        true);

  74.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::ControlChange),         true);

  75.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::ProgramChange),         true);

  76.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::AfterTouchChannel),     true);

  77.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::PitchBend),             true);

  78.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::SystemExclusive),       false);

  79.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::TimeCodeQuarterFrame),  false);

  80.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::SongPosition),          false);

  81.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::SongSelect),            false);

  82.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::TuneRequest),           false);

  83.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::Clock),                 false);

  84.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::Start),                 false);

  85.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::Continue),              false);

  86.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::Stop),                  false);

  87.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::ActiveSensing),         false);

  88.     EXPECT_EQ(MidiInterface::isChannelMessage(midi::SystemReset),           false);

  89. }

  90. 

  91. // --

  92. 

  93. TEST(MidiInput, begin)

  94. {

  95.     SerialMock serial;

  96.     Transport transport(serial);

  97.     MidiInterface midi((Transport&)transport);

  98. 

  99.     // Default channel

  100.     midi.begin();

  101.     EXPECT_EQ(serial.mBaudrate, 31250);

  102.     EXPECT_EQ(midi.getInputChannel(), 1);

  103. 

  104.     // Specific channel

  105.     midi.begin(12);

  106.     EXPECT_EQ(serial.mBaudrate, 31250);

  107.     EXPECT_EQ(midi.getInputChannel(), 12);

  108. }

  109. 

  110. TEST(MidiInput, initInputChannel)

  111. {

  112.     SerialMock serial;

  113.     Transport transport(serial);

  114.     MidiInterface midi((Transport&)transport);

  115. 

  116.     EXPECT_EQ(midi.getInputChannel(), 0);

  117.     midi.setInputChannel(12);

  118.     EXPECT_EQ(midi.getInputChannel(), 12);

  119. }

  120. 

  121. TEST(MidiInput, initMessage)

  122. {

  123.     SerialMock serial;

  124.     Transport transport(serial);

  125.     MidiInterface midi((Transport&)transport);

  126. 

  127.     EXPECT_EQ(midi.getType(),               midi::InvalidType);

  128.     EXPECT_EQ(midi.getChannel(),            0);

  129.     EXPECT_EQ(midi.getData1(),              0);

  130.     EXPECT_EQ(midi.getData2(),              0);

  131.     EXPECT_EQ(midi.getSysExArrayLength(),   unsigned(0));

  132.     EXPECT_EQ(midi.check(),                 false);

  133. }

  134. 

  135. TEST(MidiInput, channelFiltering)

  136. {

  137.     SerialMock serial;

  138.     Transport transport(serial);

  139.     MidiInterface midi((Transport&)transport);

  140. 

  141.     static const unsigned rxSize = 3;

  142.     static const byte rxData[rxSize] = { 0x9b, 12, 34 };

  143.     midi.begin(4); // Mistmatching channel

  144.     serial.mRxBuffer.write(rxData, rxSize);

  145.     EXPECT_EQ(midi.read(), false);

  146.     EXPECT_EQ(midi.read(), false);

  147.     EXPECT_EQ(midi.read(), false);

  148. }

  149. 

  150. TEST(MidiInput, noRxData)

  151. {

  152.     SerialMock serial;

  153.     Transport transport(serial);

  154.     MidiInterface midi((Transport&)transport);

  155. 

  156.     midi.begin();

  157.     EXPECT_EQ(midi.read(), false);

  158. }

  159. 

  160. TEST(MidiInput, inputDisabled)

  161. {

  162.     SerialMock serial;

  163.     Transport transport(serial);

  164.     MidiInterface midi((Transport&)transport);

  165. 

  166.     static const unsigned rxSize = 3;

  167.     static const byte rxData[rxSize] = { 0x9b, 12, 34 };

  168.     midi.begin(MIDI_CHANNEL_OFF); // Invalid channel

  169.     serial.mRxBuffer.write(rxData, rxSize);

  170.     EXPECT_EQ(midi.read(), false);

  171.     EXPECT_EQ(midi.read(), false);

  172.     EXPECT_EQ(midi.read(), false);

  173. }

  174. 

  175. TEST(MidiInput, multiByteParsing)

  176. {

  177.     typedef VariableSettings<false, false> Settings;

  178.     typedef midi::MidiInterface<Transport, Settings> MultiByteMidiInterface;

  179. 

  180.     SerialMock serial;

  181.     Transport transport(serial);

  182.     MultiByteMidiInterface midi(transport);

  183.     

  184.     static const unsigned rxSize = 3;

  185.     static const byte rxData[rxSize] = { 0x9b, 12, 34 };

  186.     midi.begin(12);

  187.     serial.mRxBuffer.write(rxData, rxSize);

  188.     EXPECT_EQ(midi.read(), true);

  189. }

  190. 

  191. TEST(MidiInput, noteOn)

  192. {

  193.     SerialMock serial;

  194.     Transport transport(serial);

  195.     MidiInterface midi((Transport&)transport);

  196. 

  197.     static const unsigned rxSize = 10;

  198.     static const byte rxData[rxSize] = {

  199.         0x9b, 12, 34,

  200.         0x9b, 56, 78,

  201.               12, 34,   // Running status

  202.               56, 0     // NoteOn with null velocity interpreted as NoteOff

  203.     };

  204.     midi.begin(12);

  205.     serial.mRxBuffer.write(rxData, rxSize);

  206. 

  207.     // 1 byte parsing

  208.     EXPECT_EQ(midi.read(), false);

  209.     EXPECT_EQ(midi.read(), false);

  210.     EXPECT_EQ(midi.read(), true);

  211. 

  212.     // First NoteOn

  213.     EXPECT_EQ(midi.getType(),       midi::NoteOn);

  214.     EXPECT_EQ(midi.getChannel(),    12);

  215.     EXPECT_EQ(midi.getData1(),      12);

  216.     EXPECT_EQ(midi.getData2(),      34);

  217. 

  218.     EXPECT_EQ(midi.read(), false);

  219.     EXPECT_EQ(midi.read(), false);

  220.     EXPECT_EQ(midi.read(), true);

  221. 

  222.     EXPECT_EQ(midi.getType(),       midi::NoteOn);

  223.     EXPECT_EQ(midi.getChannel(),    12);

  224.     EXPECT_EQ(midi.getData1(),      56);

  225.     EXPECT_EQ(midi.getData2(),      78);

  226. 

  227.     EXPECT_EQ(midi.read(), false);

  228.     EXPECT_EQ(midi.read(), true);

  229. 

  230.     EXPECT_EQ(midi.getType(),       midi::NoteOn);

  231.     EXPECT_EQ(midi.getChannel(),    12);

  232.     EXPECT_EQ(midi.getData1(),      12);

  233.     EXPECT_EQ(midi.getData2(),      34);

  234. 

  235.     EXPECT_EQ(midi.read(), false);

  236.     EXPECT_EQ(midi.read(), true);

  237. 

  238.     EXPECT_EQ(midi.getType(),       midi::NoteOff);

  239.     EXPECT_EQ(midi.getChannel(),    12);

  240.     EXPECT_EQ(midi.getData1(),      56);

  241.     EXPECT_EQ(midi.getData2(),      0);

  242. }

  243. 

  244. TEST(MidiInput, noteOff)

  245. {

  246.     SerialMock serial;

  247.     Transport transport(serial);

  248.     MidiInterface midi((Transport&)transport);

  249. 

  250.     static const unsigned rxSize = 8;

  251.     static const byte rxData[rxSize] = {

  252.         0x8b, 12, 34,

  253.         0x8b, 56, 78,

  254.               12, 34,   // Running status

  255.     };

  256.     midi.begin(12);

  257.     serial.mRxBuffer.write(rxData, rxSize);

  258. 

  259.     // 1 byte parsing

  260.     EXPECT_EQ(midi.read(), false);

  261.     EXPECT_EQ(midi.read(), false);

  262.     EXPECT_EQ(midi.read(), true);

  263. 

  264.     // First NoteOn

  265.     EXPECT_EQ(midi.getType(),       midi::NoteOff);

  266.     EXPECT_EQ(midi.getChannel(),    12);

  267.     EXPECT_EQ(midi.getData1(),      12);

  268.     EXPECT_EQ(midi.getData2(),      34);

  269. 

  270.     EXPECT_EQ(midi.read(), false);

  271.     EXPECT_EQ(midi.read(), false);

  272.     EXPECT_EQ(midi.read(), true);

  273. 

  274.     EXPECT_EQ(midi.getType(),       midi::NoteOff);

  275.     EXPECT_EQ(midi.getChannel(),    12);

  276.     EXPECT_EQ(midi.getData1(),      56);

  277.     EXPECT_EQ(midi.getData2(),      78);

  278. 

  279.     EXPECT_EQ(midi.read(), false);

  280.     EXPECT_EQ(midi.read(), true);

  281. 

  282.     EXPECT_EQ(midi.getType(),       midi::NoteOff);

  283.     EXPECT_EQ(midi.getChannel(),    12);

  284.     EXPECT_EQ(midi.getData1(),      12);

  285.     EXPECT_EQ(midi.getData2(),      34);

  286. }

  287. 

  288. TEST(MidiInput, programChange)

  289. {

  290.     SerialMock serial;

  291.     Transport transport(serial);

  292.     MidiInterface midi((Transport&)transport);

  293. 

  294.     static const unsigned rxSize = 6;

  295.     static const byte rxData[rxSize] = {

  296.         0xc3, 12, 34,

  297.         0xc4, 56, 78

  298.     };

  299.     midi.begin(MIDI_CHANNEL_OMNI);

  300.     serial.mRxBuffer.write(rxData, rxSize);

  301. 

  302.     // 1 byte parsing

  303.     EXPECT_EQ(midi.read(), false);

  304.     EXPECT_EQ(midi.read(), true);

  305. 

  306.     EXPECT_EQ(midi.getType(),       midi::ProgramChange);

  307.     EXPECT_EQ(midi.getChannel(),    4);

  308.     EXPECT_EQ(midi.getData1(),      12);

  309.     EXPECT_EQ(midi.getData2(),      0);

  310. 

  311.     EXPECT_EQ(midi.read(), true);

  312. 

  313.     EXPECT_EQ(midi.getType(),       midi::ProgramChange);

  314.     EXPECT_EQ(midi.getChannel(),    4);

  315.     EXPECT_EQ(midi.getData1(),      34);

  316.     EXPECT_EQ(midi.getData2(),      0);

  317. 

  318.     EXPECT_EQ(midi.read(), false);

  319.     EXPECT_EQ(midi.read(), true);

  320. 

  321.     EXPECT_EQ(midi.getType(),       midi::ProgramChange);

  322.     EXPECT_EQ(midi.getChannel(),    5);

  323.     EXPECT_EQ(midi.getData1(),      56);

  324.     EXPECT_EQ(midi.getData2(),      0);

  325. 

  326.     EXPECT_EQ(midi.read(), true);

  327. 

  328.     EXPECT_EQ(midi.getType(),       midi::ProgramChange);

  329.     EXPECT_EQ(midi.getChannel(),    5);

  330.     EXPECT_EQ(midi.getData1(),      78);

  331.     EXPECT_EQ(midi.getData2(),      0);

  332. }

  333. 

  334. TEST(MidiInput, controlChange)

  335. {

  336.     SerialMock serial;

  337.     Transport transport(serial);

  338.     MidiInterface midi((Transport&)transport);

  339. 

  340.     static const unsigned rxSize = 8;

  341.     static const byte rxData[rxSize] = {

  342.         0xbb, 12, 34,

  343.         0xbb, 56, 78,

  344.               12, 34

  345.     };

  346.     midi.begin(12);

  347.     serial.mRxBuffer.write(rxData, rxSize);

  348. 

  349.     // 1 byte parsing

  350.     EXPECT_EQ(midi.read(), false);

  351.     EXPECT_EQ(midi.read(), false);

  352.     EXPECT_EQ(midi.read(), true);

  353. 

  354.     // First NoteOn

  355.     EXPECT_EQ(midi.getType(),       midi::ControlChange);

  356.     EXPECT_EQ(midi.getChannel(),    12);

  357.     EXPECT_EQ(midi.getData1(),      12);

  358.     EXPECT_EQ(midi.getData2(),      34);

  359. 

  360.     EXPECT_EQ(midi.read(), false);

  361.     EXPECT_EQ(midi.read(), false);

  362.     EXPECT_EQ(midi.read(), true);

  363. 

  364.     EXPECT_EQ(midi.getType(),       midi::ControlChange);

  365.     EXPECT_EQ(midi.getChannel(),    12);

  366.     EXPECT_EQ(midi.getData1(),      56);

  367.     EXPECT_EQ(midi.getData2(),      78);

  368. 

  369.     EXPECT_EQ(midi.read(), false);

  370.     EXPECT_EQ(midi.read(), true);

  371. 

  372.     EXPECT_EQ(midi.getType(),       midi::ControlChange);

  373.     EXPECT_EQ(midi.getChannel(),    12);

  374.     EXPECT_EQ(midi.getData1(),      12);

  375.     EXPECT_EQ(midi.getData2(),      34);

  376. }

  377. 

  378. TEST(MidiInput, pitchBend)

  379. {

  380.     SerialMock serial;

  381.     Transport transport(serial);

  382.     MidiInterface midi((Transport&)transport);

  383. 

  384.     static const unsigned rxSize = 8;

  385.     static const byte rxData[rxSize] = {

  386.         0xeb, 12, 34,

  387.         0xeb, 56, 78,

  388.               12, 34

  389.     };

  390.     midi.begin(12);

  391.     serial.mRxBuffer.write(rxData, rxSize);

  392. 

  393.     // 1 byte parsing

  394.     EXPECT_EQ(midi.read(), false);

  395.     EXPECT_EQ(midi.read(), false);

  396.     EXPECT_EQ(midi.read(), true);

  397. 

  398.     // First NoteOn

  399.     EXPECT_EQ(midi.getType(),       midi::PitchBend);

  400.     EXPECT_EQ(midi.getChannel(),    12);

  401.     EXPECT_EQ(midi.getData1(),      12);

  402.     EXPECT_EQ(midi.getData2(),      34);

  403. 

  404.     EXPECT_EQ(midi.read(), false);

  405.     EXPECT_EQ(midi.read(), false);

  406.     EXPECT_EQ(midi.read(), true);

  407. 

  408.     EXPECT_EQ(midi.getType(),       midi::PitchBend);

  409.     EXPECT_EQ(midi.getChannel(),    12);

  410.     EXPECT_EQ(midi.getData1(),      56);

  411.     EXPECT_EQ(midi.getData2(),      78);

  412. 

  413.     EXPECT_EQ(midi.read(), false);

  414.     EXPECT_EQ(midi.read(), true);

  415. 

  416.     EXPECT_EQ(midi.getType(),       midi::PitchBend);

  417.     EXPECT_EQ(midi.getChannel(),    12);

  418.     EXPECT_EQ(midi.getData1(),      12);

  419.     EXPECT_EQ(midi.getData2(),      34);

  420. }

  421. 

  422. TEST(MidiInput, afterTouchPoly)

  423. {

  424.     SerialMock serial;

  425.     Transport transport(serial);

  426.     MidiInterface midi((Transport&)transport);

  427. 

  428.     static const unsigned rxSize = 8;

  429.     static const byte rxData[rxSize] = {

  430.         0xab, 12, 34,

  431.         0xab, 56, 78,

  432.               12, 34

  433.     };

  434.     midi.begin(12);

  435.     serial.mRxBuffer.write(rxData, rxSize);

  436. 

  437.     // 1 byte parsing

  438.     EXPECT_EQ(midi.read(), false);

  439.     EXPECT_EQ(midi.read(), false);

  440.     EXPECT_EQ(midi.read(), true);

  441. 

  442.     // First NoteOn

  443.     EXPECT_EQ(midi.getType(),       midi::AfterTouchPoly);

  444.     EXPECT_EQ(midi.getChannel(),    12);

  445.     EXPECT_EQ(midi.getData1(),      12);

  446.     EXPECT_EQ(midi.getData2(),      34);

  447. 

  448.     EXPECT_EQ(midi.read(), false);

  449.     EXPECT_EQ(midi.read(), false);

  450.     EXPECT_EQ(midi.read(), true);

  451. 

  452.     EXPECT_EQ(midi.getType(),       midi::AfterTouchPoly);

  453.     EXPECT_EQ(midi.getChannel(),    12);

  454.     EXPECT_EQ(midi.getData1(),      56);

  455.     EXPECT_EQ(midi.getData2(),      78);

  456. 

  457.     EXPECT_EQ(midi.read(), false);

  458.     EXPECT_EQ(midi.read(), true);

  459. 

  460.     EXPECT_EQ(midi.getType(),       midi::AfterTouchPoly);

  461.     EXPECT_EQ(midi.getChannel(),    12);

  462.     EXPECT_EQ(midi.getData1(),      12);

  463.     EXPECT_EQ(midi.getData2(),      34);

  464. }

  465. 

  466. TEST(MidiInput, afterTouchChannel)

  467. {

  468.     SerialMock serial;

  469.     Transport transport(serial);

  470.     MidiInterface midi((Transport&)transport);

  471. 

  472.     static const unsigned rxSize = 6;

  473.     static const byte rxData[rxSize] = {

  474.         0xd3, 12, 34,

  475.         0xd4, 56, 78

  476.     };

  477.     midi.begin(MIDI_CHANNEL_OMNI);

  478.     serial.mRxBuffer.write(rxData, rxSize);

  479. 

  480.     // 1 byte parsing

  481.     EXPECT_EQ(midi.read(), false);

  482.     EXPECT_EQ(midi.read(), true);

  483. 

  484.     EXPECT_EQ(midi.getType(),       midi::AfterTouchChannel);

  485.     EXPECT_EQ(midi.getChannel(),    4);

  486.     EXPECT_EQ(midi.getData1(),      12);

  487.     EXPECT_EQ(midi.getData2(),      0);

  488. 

  489.     EXPECT_EQ(midi.read(), true);

  490. 

  491.     EXPECT_EQ(midi.getType(),       midi::AfterTouchChannel);

  492.     EXPECT_EQ(midi.getChannel(),    4);

  493.     EXPECT_EQ(midi.getData1(),      34);

  494.     EXPECT_EQ(midi.getData2(),      0);

  495. 

  496.     EXPECT_EQ(midi.read(), false);

  497.     EXPECT_EQ(midi.read(), true);

  498. 

  499.     EXPECT_EQ(midi.getType(),       midi::AfterTouchChannel);

  500.     EXPECT_EQ(midi.getChannel(),    5);

  501.     EXPECT_EQ(midi.getData1(),      56);

  502.     EXPECT_EQ(midi.getData2(),      0);

  503. 

  504.     EXPECT_EQ(midi.read(), true);

  505. 

  506.     EXPECT_EQ(midi.getType(),       midi::AfterTouchChannel);

  507.     EXPECT_EQ(midi.getChannel(),    5);

  508.     EXPECT_EQ(midi.getData1(),      78);

  509.     EXPECT_EQ(midi.getData2(),      0);

  510. }

  511. 

  512. TEST(MidiInput, sysExWithinBufferSize)

  513. {

  514.     typedef VariableSysExSettings<1024> Settings;

  515.     typedef test_mocks::SerialMock<2048> LargerSerialMock;

  516.     typedef midi::SerialMIDI<LargerSerialMock> LargerTransport;

  517.     typedef midi::MidiInterface<LargerTransport, Settings> LargerMidiInterface;

  518. 

  519.     LargerSerialMock serial;

  520.     LargerTransport transport(serial);

  521.     LargerMidiInterface midi(transport);

  522. 

  523.     // Short Frame < 256

  524.     {

  525.         static const unsigned frameLength = 15;

  526.         static const byte frame[frameLength] = {

  527.             0xf0, 'H','e','l','l','o',',',' ','W','o','r','l','d','!', 0xf7

  528.         };

  529. 

  530.         midi.begin();

  531.         serial.mRxBuffer.write(frame, frameLength);

  532.         for (unsigned i = 0; i < frameLength - 1; ++i)

  533.         {

  534.             EXPECT_EQ(midi.read(), false);

  535.         }

  536.         EXPECT_EQ(midi.read(), true); // 0xf7

  537. 

  538.         EXPECT_EQ(midi.getSysExArrayLength(), frameLength);

  539.         const std::vector<byte> sysExData(midi.getSysExArray(),

  540.                                           midi.getSysExArray() + frameLength);

  541.         EXPECT_THAT(sysExData, ElementsAreArray(frame));

  542.     }

  543.     // Long Frame

  544.     {

  545.         static const unsigned frameLength = 957;

  546.         static const byte frame[frameLength] = {

  547.             0xf0,

  548.             'L','o','r','e','m',' ','i','p','s','u','m',' ','d','o','l','o','r',' ','s','i','t',' ','a','m','e','t',',',' ',

  549.             'c','o','n','s','e','c','t','e','t','u','r',' ','a','d','i','p','i','s','c','i','n','g',' ','e','l','i','t','.',' ','P','r','o','i','n',' ','m','a','x','i','m','u','s',' ','d','u','i',' ','a',' ','m','a','s','s','a',' ','m','a','x','i','m','u','s',',',' ',

  550.             'a',' ','v','e','s','t','i','b','u','l','u','m',' ','m','i',' ','v','e','n','e','n','a','t','i','s','.',' ','C','r','a','s',' ','s','i','t',' ','a','m','e','t',' ','e','x',' ','i','d',' ','v','e','l','i','t',' ','s','u','s','c','i','p','i','t',' ','p','h','a','r','e','t','r','a',' ','e','g','e','t',            ' ','a',' ','t','u','r','p','i','s','.',' ','P','h','a','s','e','l','l','u','s',' ','i','n','t','e','r','d','u','m',' ','m','e','t','u','s',' ','a','c',' ','s','a','g','i','t','t','i','s',' ','c','u','r','s','u','s','.',' ','N','a','m',' ','q','u','i','s',' ','e','s','t',' ','a','t',' ','n','i','s',            'l',' ','u','l','l','a','m','c','o','r','p','e','r',' ','e','g','e','s','t','a','s',' ','p','u','l','v','i','n','a','r',' ','e','u',' ','e','r','a','t','.',' ','D','u','i','s',' ','a',' ','e','l','i','t',' ','d','i','g','n','i','s','s','i','m',',',' ',

  551.             'v','e','s','t','i','b','u','l','u','m',' ','e','r','o','s',' ','v','e','l',',',' ',

  552.             't','e','m','p','u','s',' ','n','i','s','l','.',' ','A','e','n','e','a','n',' ','t','u','r','p','i','s',' ','n','u','n','c',',',' ',

  553.             'c','u','r','s','u','s',' ','v','e','l',' ','l','a','c','i','n','i','a',' ','n','o','n',',',' ',

  554.             'p','h','a','r','e','t','r','a',' ','e','g','e','t',' ','s','a','p','i','e','n','.',' ','D','u','i','s',' ','c','o','n','d','i','m','e','n','t','u','m',',',' ',

  555.             'l','a','c','u','s',' ','a','t',' ','p','u','l','v','i','n','a','r',' ','t','e','m','p','o','r',',',' ',

  556.             'l','e','o',' ','l','i','b','e','r','o',' ','v','o','l','u','t','p','a','t',' ','n','i','s','l',',',' ',

  557.             'e','g','e','t',' ','p','o','r','t','t','i','t','o','r',' ','l','o','r','e','m',' ','m','i',' ','s','e','d',' ','m','a','g','n','a','.',' ','D','u','i','s',' ','d','i','c','t','u','m',',',' ',

  558.             'm','a','s','s','a',' ','v','e','l',' ','e','u','i','s','m','o','d',' ','i','n','t','e','r','d','u','m',',',' ',

  559.             'l','o','r','e','m',' ','m','i',' ','e','g','e','s','t','a','s',' ','e','l','i','t',',',' ',

  560.             'h','e','n','d','r','e','r','i','t',' ','t','i','n','c','i','d','u','n','t',' ','e','s','t',' ','a','r','c','u',' ','a',' ','l','i','b','e','r','o','.',' ','I','n','t','e','r','d','u','m',' ','e','t',' ','m','a','l','e','s','u','a','d','a',' ','f','a','m','e','s',' ','a','c',' ','a','n','t','e',' ',            'i','p','s','u','m',' ','p','r','i','m','i','s',' ','i','n',' ','f','a','u','c','i','b','u','s','.',' ','C','u','r','a','b','i','t','u','r',' ','v','e','h','i','c','u','l','a',' ','m','a','g','n','a',' ','l','i','b','e','r','o',',',' ',

  561.             'a','t',' ','r','h','o','n','c','u','s',' ','s','e','m',' ','o','r','n','a','r','e',' ','a','.',' ','I','n',' ','e','l','e','m','e','n','t','u','m',',',' ',

  562.             'e','l','i','t',' ','e','t',' ','c','o','n','g','u','e',' ','p','u','l','v','i','n','a','r',',',' ',

  563.             'm','a','s','s','a',' ','v','e','l','i','t',' ','c','o','m','m','o','d','o',' ','v','e','l','i','t',',',' ',

  564.             'n','o','n',' ','e','l','e','m','e','n','t','u','m',' ','p','u','r','u','s',' ','l','i','g','u','l','a',' ','e','g','e','t',' ','l','a','c','u','s','.',' ','D','o','n','e','c',' ','e','f','f','i','c','i','t','u','r',' ','n','i','s','i',' ','e','u',' ','u','l','t','r','i','c','e','s',' ','e','f','f',            'i','c','i','t','u','r','.',' ','D','o','n','e','c',' ','n','e','q','u','e',' ','d','u','i',',',' ',

  565.             'u','l','l','a','m','c','o','r','p','e','r',' ','i','d',' ','m','o','l','e','s','t','i','e',' ','q','u','i','s',',',' ',

  566.             'c','o','n','s','e','q','u','a','t',' ','s','i','t',' ','a','m','e','t',' ','l','i','g','u','l','a','.',

  567.             0xf7,

  568.         };

  569.         midi.begin();

  570.         serial.mRxBuffer.write(frame, frameLength);

  571.         for (unsigned i = 0; i < frameLength - 1; ++i)

  572.         {

  573.             EXPECT_EQ(midi.read(), false);

  574.         }

  575.         EXPECT_EQ(serial.mRxBuffer.getLength(), 1);

  576.         EXPECT_EQ(serial.mRxBuffer.peek(), 0xf7);

  577.         EXPECT_EQ(midi.read(), true);

  578.     }

  579. }

  580. 

  581. TEST(MidiInput, sysExOverBufferSize)

  582. {

  583.     typedef VariableSysExSettings<8> Settings;

  584.     typedef midi::MidiInterface<Transport, Settings> SmallMidiInterface;

  585. 

  586.     SerialMock serial;

  587.     Transport transport(serial);

  588.     SmallMidiInterface midi(transport);

  589. 

  590.     static const unsigned frameLength = 15;

  591.     static const byte frame[frameLength] = {

  592.         0xf0, 'H','e','l','l','o',',',' ','W','o','r','l','d','!', 0xf7

  593.     };

  594. 

  595.     midi.begin();

  596.     serial.mRxBuffer.write(frame, frameLength);

  597. 

  598.     EXPECT_EQ(midi.read(), false); // start sysex f0

  599.     EXPECT_EQ(midi.read(), false); // H

  600.     EXPECT_EQ(midi.read(), false); // e

  601.     EXPECT_EQ(midi.read(), false); // l

  602.     EXPECT_EQ(midi.read(), false); // l

  603.     EXPECT_EQ(midi.read(), false); // o

  604.     EXPECT_EQ(midi.read(), false); // , message send and buffer cleared.

  605.     EXPECT_EQ(midi.read(), false); // start sysex 

  606.     EXPECT_EQ(midi.read(), false); // (space)

  607.     EXPECT_EQ(midi.read(), false); // W

  608.     EXPECT_EQ(midi.read(), false); // o   

  609.     EXPECT_EQ(midi.read(), false); // r

  610.     EXPECT_EQ(midi.read(), false); // l   

  611.     EXPECT_EQ(midi.read(), false); // d

  612.     EXPECT_EQ(midi.read(), true);  // end sysex

  613. }

  614. 

  615. TEST(MidiInput, mtcQuarterFrame)

  616. {

  617.     SerialMock serial;

  618.     Transport transport(serial);

  619.     MidiInterface midi((Transport&)transport);

  620. 

  621.     static const unsigned rxSize = 4;

  622.     static const byte rxData[rxSize] = {

  623.         0xf1, 12,

  624.         0xf1, 42

  625.     };

  626.     midi.begin(12);

  627.     serial.mRxBuffer.write(rxData, rxSize);

  628. 

  629.     // 1 byte parsing

  630.     EXPECT_EQ(midi.read(), false);

  631.     EXPECT_EQ(midi.read(), true);

  632. 

  633.     EXPECT_EQ(midi.getType(),       midi::TimeCodeQuarterFrame);

  634.     EXPECT_EQ(midi.getChannel(),    0);

  635.     EXPECT_EQ(midi.getData1(),      12);

  636.     EXPECT_EQ(midi.getData2(),      0);

  637. 

  638.     EXPECT_EQ(midi.read(), false);

  639.     EXPECT_EQ(midi.read(), true);

  640. 

  641.     EXPECT_EQ(midi.getType(),       midi::TimeCodeQuarterFrame);

  642.     EXPECT_EQ(midi.getChannel(),    0);

  643.     EXPECT_EQ(midi.getData1(),      42);

  644.     EXPECT_EQ(midi.getData2(),      0);

  645. }

  646. 

  647. TEST(MidiInput, songPosition)

  648. {

  649.     SerialMock serial;

  650.     Transport transport(serial);

  651.     MidiInterface midi((Transport&)transport);

  652. 

  653.     static const unsigned rxSize = 6;

  654.     static const byte rxData[rxSize] = {

  655.         0xf2, 12, 34,

  656.         0xf2, 56, 78

  657.     };

  658.     midi.begin(12);

  659.     serial.mRxBuffer.write(rxData, rxSize);

  660. 

  661.     // 1 byte parsing

  662.     EXPECT_EQ(midi.read(), false);

  663.     EXPECT_EQ(midi.read(), false);

  664.     EXPECT_EQ(midi.read(), true);

  665. 

  666.     EXPECT_EQ(midi.getType(),       midi::SongPosition);

  667.     EXPECT_EQ(midi.getChannel(),    0);

  668.     EXPECT_EQ(midi.getData1(),      12);

  669.     EXPECT_EQ(midi.getData2(),      34);

  670. 

  671.     EXPECT_EQ(midi.read(), false);

  672.     EXPECT_EQ(midi.read(), false);

  673.     EXPECT_EQ(midi.read(), true);

  674. 

  675.     EXPECT_EQ(midi.getType(),       midi::SongPosition);

  676.     EXPECT_EQ(midi.getChannel(),    0);

  677.     EXPECT_EQ(midi.getData1(),      56);

  678.     EXPECT_EQ(midi.getData2(),      78);

  679. }

  680. 

  681. TEST(MidiInput, songSelect)

  682. {

  683.     SerialMock serial;

  684.     Transport transport(serial);

  685.     MidiInterface midi((Transport&)transport);

  686. 

  687.     static const unsigned rxSize = 4;

  688.     static const byte rxData[rxSize] = {

  689.         0xf3, 12,

  690.         0xf3, 42

  691.     };

  692.     midi.begin(12);

  693.     serial.mRxBuffer.write(rxData, rxSize);

  694. 

  695.     // 1 byte parsing

  696.     EXPECT_EQ(midi.read(), false);

  697.     EXPECT_EQ(midi.read(), true);

  698. 

  699.     EXPECT_EQ(midi.getType(),       midi::SongSelect);

  700.     EXPECT_EQ(midi.getChannel(),    0);

  701.     EXPECT_EQ(midi.getData1(),      12);

  702.     EXPECT_EQ(midi.getData2(),      0);

  703. 

  704.     EXPECT_EQ(midi.read(), false);

  705.     EXPECT_EQ(midi.read(), true);

  706. 

  707.     EXPECT_EQ(midi.getType(),       midi::SongSelect);

  708.     EXPECT_EQ(midi.getChannel(),    0);

  709.     EXPECT_EQ(midi.getData1(),      42);

  710.     EXPECT_EQ(midi.getData2(),      0);

  711. }

  712. 

  713. TEST(MidiInput, tuneRequest)

  714. {

  715.     SerialMock serial;

  716.     Transport transport(serial);

  717.     MidiInterface midi((Transport&)transport);

  718. 

  719.     static const unsigned rxSize = 1;

  720.     static const byte rxData[rxSize] = {

  721.         0xf6

  722.     };

  723.     midi.begin(12);

  724.     serial.mRxBuffer.write(rxData, rxSize);

  725. 

  726.     EXPECT_EQ(midi.read(), true);

  727.     EXPECT_EQ(midi.getType(),       midi::TuneRequest);

  728.     EXPECT_EQ(midi.getChannel(),    0);

  729.     EXPECT_EQ(midi.getData1(),      0);

  730.     EXPECT_EQ(midi.getData2(),      0);

  731. }

  732. 

  733. TEST(MidiInput, realTime)

  734. {

  735.     SerialMock serial;

  736.     Transport transport(serial);

  737.     MidiInterface midi((Transport&)transport);

  738. 

  739.     static const unsigned rxSize = 8;

  740.     static const byte rxData[rxSize] = {

  741.         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff

  742.     };

  743.     midi.begin(12);

  744.     serial.mRxBuffer.write(rxData, rxSize);

  745. 

  746.     EXPECT_EQ(midi.read(), true);

  747.     EXPECT_EQ(midi.getType(),       midi::Clock);

  748.     EXPECT_EQ(midi.getChannel(),    0);

  749.     EXPECT_EQ(midi.getData1(),      0);

  750.     EXPECT_EQ(midi.getData2(),      0);

  751. 

  752.     EXPECT_EQ(midi.read(), true); 

  753.     EXPECT_EQ(midi.getType(),       midi::Tick);

  754.     EXPECT_EQ(midi.getChannel(),    0);

  755.     EXPECT_EQ(midi.getData1(),      0);

  756.     EXPECT_EQ(midi.getData2(),      0);

  757. 

  758.     EXPECT_EQ(midi.read(), true);

  759.     EXPECT_EQ(midi.getType(),       midi::Start);

  760.     EXPECT_EQ(midi.getChannel(),    0);

  761.     EXPECT_EQ(midi.getData1(),      0);

  762.     EXPECT_EQ(midi.getData2(),      0);

  763. 

  764.     EXPECT_EQ(midi.read(), true);

  765.     EXPECT_EQ(midi.getType(),       midi::Continue);

  766.     EXPECT_EQ(midi.getChannel(),    0);

  767.     EXPECT_EQ(midi.getData1(),      0);

  768.     EXPECT_EQ(midi.getData2(),      0);

  769. 

  770.     EXPECT_EQ(midi.read(), true);

  771.     EXPECT_EQ(midi.getType(),       midi::Stop);

  772.     EXPECT_EQ(midi.getChannel(),    0);

  773.     EXPECT_EQ(midi.getData1(),      0);

  774.     EXPECT_EQ(midi.getData2(),      0);

  775. 

  776.     EXPECT_EQ(midi.read(), false); // 0xfd = undefined

  777. 

  778.     EXPECT_EQ(midi.read(), true);

  779.     EXPECT_EQ(midi.getType(),       midi::ActiveSensing);

  780.     EXPECT_EQ(midi.getChannel(),    0);

  781.     EXPECT_EQ(midi.getData1(),      0);

  782.     EXPECT_EQ(midi.getData2(),      0);

  783. 

  784.     EXPECT_EQ(midi.read(), true);

  785.     EXPECT_EQ(midi.getType(),       midi::SystemReset);

  786.     EXPECT_EQ(midi.getChannel(),    0);

  787.     EXPECT_EQ(midi.getData1(),      0);

  788.     EXPECT_EQ(midi.getData2(),      0);

  789. }

  790. 

  791. // --

  792. 

  793. TEST(MidiInput, interleavedRealTime)

  794. {

  795.     SerialMock serial;

  796.     Transport transport(serial);

  797.     MidiInterface midi((Transport&)transport);

  798. 

  799.     // Interleaved Clocks between NoteOn / Off messages (with running status)

  800.     {

  801.         static const unsigned rxSize = 13;

  802.         static const byte rxData[rxSize] = {

  803.             0x9b, 12, 0xf8, 34,

  804.             12, 0,

  805.             42, 0xf8, 127,

  806.             0xf8,

  807.             42, 0xf8, 0

  808.         };

  809.         midi.begin(12);

  810.         serial.mRxBuffer.write(rxData, rxSize);

  811. 

  812.         EXPECT_EQ(midi.read(), false);

  813.         EXPECT_EQ(midi.read(), false);

  814. 

  815.         EXPECT_EQ(midi.read(), true);

  816.         EXPECT_EQ(midi.getType(),       midi::Clock);

  817.         EXPECT_EQ(midi.getChannel(),    0);

  818.         EXPECT_EQ(midi.getData1(),      0);

  819.         EXPECT_EQ(midi.getData2(),      0);

  820. 

  821.         EXPECT_EQ(midi.read(), true);

  822.         EXPECT_EQ(midi.getType(),       midi::NoteOn);

  823.         EXPECT_EQ(midi.getChannel(),    12);

  824.         EXPECT_EQ(midi.getData1(),      12);

  825.         EXPECT_EQ(midi.getData2(),      34);

  826. 

  827.         EXPECT_EQ(midi.read(), false);

  828.         EXPECT_EQ(midi.read(), true);

  829.         EXPECT_EQ(midi.getType(),       midi::NoteOff);

  830.         EXPECT_EQ(midi.getChannel(),    12);

  831.         EXPECT_EQ(midi.getData1(),      12);

  832.         EXPECT_EQ(midi.getData2(),      0);

  833. 

  834.         EXPECT_EQ(midi.read(), false);

  835.         EXPECT_EQ(midi.read(), true);

  836.         EXPECT_EQ(midi.getType(),       midi::Clock);

  837.         EXPECT_EQ(midi.getChannel(),    0);

  838.         EXPECT_EQ(midi.getData1(),      0);

  839.         EXPECT_EQ(midi.getData2(),      0);

  840. 

  841.         EXPECT_EQ(midi.read(), true);

  842.         EXPECT_EQ(midi.getType(),       midi::NoteOn);

  843.         EXPECT_EQ(midi.getChannel(),    12);

  844.         EXPECT_EQ(midi.getData1(),      42);

  845.         EXPECT_EQ(midi.getData2(),      127);

  846. 

  847.         EXPECT_EQ(midi.read(), true);

  848.         EXPECT_EQ(midi.getType(),       midi::Clock);

  849.         EXPECT_EQ(midi.getChannel(),    0);

  850.         EXPECT_EQ(midi.getData1(),      0);

  851.         EXPECT_EQ(midi.getData2(),      0);

  852. 

  853.         EXPECT_EQ(midi.read(), false);

  854.         EXPECT_EQ(midi.read(), true);

  855.         EXPECT_EQ(midi.getType(),       midi::Clock);

  856.         EXPECT_EQ(midi.getChannel(),    0);

  857.         EXPECT_EQ(midi.getData1(),      0);

  858.         EXPECT_EQ(midi.getData2(),      0);

  859. 

  860.         EXPECT_EQ(midi.read(), true);

  861.         EXPECT_EQ(midi.getType(),       midi::NoteOff);

  862.         EXPECT_EQ(midi.getChannel(),    12);

  863.         EXPECT_EQ(midi.getData1(),      42);

  864.         EXPECT_EQ(midi.getData2(),      0);

  865.     }

  866.     // Interleaved ActiveSensing between SysEx

  867.     {

  868.         static const unsigned rxSize = 6;

  869.         static const byte rxData[rxSize] = {

  870.             0xf0, 12, 34, 0xfe, 56, 0xf7

  871.         };

  872.         midi.begin(12);

  873.         serial.mRxBuffer.write(rxData, rxSize);

  874.         

  875.         EXPECT_EQ(midi.read(), false);

  876.         EXPECT_EQ(midi.read(), false);

  877.         EXPECT_EQ(midi.read(), false);

  878. 

  879.         EXPECT_EQ(midi.read(), true);

  880.         EXPECT_EQ(midi.getType(),       midi::ActiveSensing);

  881.         EXPECT_EQ(midi.getChannel(),    0);

  882.         EXPECT_EQ(midi.getData1(),      0);

  883.         EXPECT_EQ(midi.getData2(),      0);

  884. 

  885.         EXPECT_EQ(midi.read(), false);

  886.         EXPECT_EQ(midi.read(), true);

  887.         EXPECT_EQ(midi.getSysExArrayLength(), rxSize - 1);

  888.         const std::vector<byte> sysExData(midi.getSysExArray(),

  889.                                           midi.getSysExArray() + rxSize - 1);

  890.         EXPECT_THAT(sysExData, ElementsAreArray({

  891.             0xf0, 12, 34, 56, 0xf7

  892.         }));

  893.     }

  894. }

  895. 

  896. TEST(MidiInput, strayEox)

  897. {

  898.     // A stray End of Exclusive will reset the parser, but should it ?

  899.     SerialMock serial;

  900.     Transport transport(serial);

  901.     MidiInterface midi((Transport&)transport);

  902.     

  903.     static const unsigned rxSize = 4;

  904.     static const byte rxData[rxSize] = {

  905.         0x8b, 42, 0xf7, 12

  906.     };

  907.     midi.begin(MIDI_CHANNEL_OMNI);

  908.     serial.mRxBuffer.write(rxData, rxSize);

  909. 

  910.     EXPECT_EQ(midi.read(), false);

  911.     EXPECT_EQ(midi.read(), false);

  912.     EXPECT_EQ(midi.read(), false);

  913.     EXPECT_EQ(midi.read(), false);

  914. }

  915. 

  916. TEST(MidiInput, strayUndefinedOneByteParsing)

  917. {

  918.     SerialMock serial;

  919.     Transport transport(serial);

  920.     MidiInterface midi((Transport&)transport);

  921. 

  922.     static const unsigned rxSize = 13;

  923.     static const byte rxData[rxSize] = {

  924.         0xbb, 12, 0xfd, 34,

  925.         12, 0,

  926.         42, 0xfd, 127,

  927.         0xfd,

  928.         42, 0xfd, 0

  929.     };

  930.     midi.begin(12);

  931.     serial.mRxBuffer.write(rxData, rxSize);

  932. 

  933.     EXPECT_EQ(midi.read(), false);

  934.     EXPECT_EQ(midi.read(), false);

  935.     EXPECT_EQ(midi.read(), false); // Invalid, should not reset parser

  936. 

  937.     EXPECT_EQ(midi.read(), true);

  938.     EXPECT_EQ(midi.getType(),       midi::ControlChange);

  939.     EXPECT_EQ(midi.getChannel(),    12);

  940.     EXPECT_EQ(midi.getData1(),      12);

  941.     EXPECT_EQ(midi.getData2(),      34);

  942. 

  943.     EXPECT_EQ(midi.read(), false);

  944.     EXPECT_EQ(midi.read(), true);

  945.     EXPECT_EQ(midi.getType(),       midi::ControlChange);

  946.     EXPECT_EQ(midi.getChannel(),    12);

  947.     EXPECT_EQ(midi.getData1(),      12);

  948.     EXPECT_EQ(midi.getData2(),      0);

  949. 

  950.     EXPECT_EQ(midi.read(), false);

  951.     EXPECT_EQ(midi.read(), false);

  952.     EXPECT_EQ(midi.read(), true);

  953.     EXPECT_EQ(midi.getType(),       midi::ControlChange);

  954.     EXPECT_EQ(midi.getChannel(),    12);

  955.     EXPECT_EQ(midi.getData1(),      42);

  956.     EXPECT_EQ(midi.getData2(),      127);

  957. 

  958.     EXPECT_EQ(midi.read(), false);

  959.     EXPECT_EQ(midi.read(), false);

  960.     EXPECT_EQ(midi.read(), false);

  961.     EXPECT_EQ(midi.read(), true);

  962.     EXPECT_EQ(midi.getType(),       midi::ControlChange);

  963.     EXPECT_EQ(midi.getChannel(),    12);

  964.     EXPECT_EQ(midi.getData1(),      42);

  965.     EXPECT_EQ(midi.getData2(),      0);

  966. }

  967. 

  968. TEST(MidiInput, strayUndefinedMultiByteParsing)

  969. {

  970.     typedef VariableSettings<false, false> Settings;

  971.     typedef midi::MidiInterface<Transport, Settings> MultiByteMidiInterface;

  972. 

  973.     SerialMock serial;

  974.     Transport transport(serial);

  975.     MultiByteMidiInterface midi(transport);

  976. 

  977.     static const unsigned rxSize = 4;

  978.     static const byte rxData[rxSize] = {

  979.         0xbb, 12, 0xfd, 34,

  980.     };

  981.     midi.begin(12);

  982.     serial.mRxBuffer.write(rxData, rxSize);

  983. 

  984.     EXPECT_EQ(midi.read(), true);

  985.     EXPECT_EQ(midi.getType(),       midi::ControlChange);

  986.     EXPECT_EQ(midi.getChannel(),    12);

  987.     EXPECT_EQ(midi.getData1(),      12);

  988.     EXPECT_EQ(midi.getData2(),      34);

  989. }

  990. 

  991. END_UNNAMED_NAMESPACE