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_MidiInputCallbac...

595 lines
16KB
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. 

  17. template<unsigned Size>

  18. struct VariableSysExSettings : midi::DefaultSettings

  19. {

  20.     static const unsigned SysExMaxSize = Size;

  21. };

  22. 

  23. typedef test_mocks::SerialMock<256> SerialMock;

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

  25. 

  26. typedef VariableSysExSettings<256> Settings;

  27. typedef midi::MidiInterface<Transport, Settings> MidiInterface;

  28. 

  29. MidiInterface* midi;

  30. 

  31. class MidiInputCallbacks : public Test

  32. {

  33. public:

  34.     MidiInputCallbacks()

  35.         : mTransport(mSerial)

  36.         , mMidi(mTransport)

  37.     {

  38.     }

  39.     virtual ~MidiInputCallbacks()

  40.     {

  41.     }

  42. 

  43. protected:

  44.     virtual void SetUp()

  45.     {

  46.         midi = &mMidi;

  47.     }

  48. 

  49.     virtual void TearDown()

  50.     {

  51.         midi = nullptr;

  52.     }

  53. 

  54. protected:

  55.     SerialMock      mSerial;

  56.     Transport       mTransport;

  57.     MidiInterface   mMidi;

  58. };

  59. 

  60. // --

  61. 

  62. void handleNoteOn(byte inChannel, byte inPitch, byte inVelocity)

  63. {

  64.     EXPECT_NE(midi, nullptr);

  65.     midi->sendNoteOn(inPitch, inVelocity, inChannel);

  66. }

  67. 

  68. TEST_F(MidiInputCallbacks, noteOn)

  69. {

  70.     mMidi.setHandleNoteOn(handleNoteOn);

  71.     mMidi.begin(MIDI_CHANNEL_OMNI);

  72.     mMidi.turnThruOff();

  73. 

  74.     static const unsigned rxSize = 3;

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

  76.     mSerial.mRxBuffer.write(rxData, rxSize);

  77. 

  78.     EXPECT_EQ(mMidi.read(), false);

  79.     EXPECT_EQ(mMidi.read(), false);

  80.     EXPECT_EQ(mMidi.read(), true);

  81.     EXPECT_EQ(mMidi.getType(),       midi::NoteOn);

  82.     EXPECT_EQ(mMidi.getChannel(),    12);

  83.     EXPECT_EQ(mMidi.getData1(),      12);

  84.     EXPECT_EQ(mMidi.getData2(),      34);

  85. 

  86.     EXPECT_EQ(mSerial.mTxBuffer.getLength(), 3);

  87.     byte buffer[3] = { 0 };

  88.     mSerial.mTxBuffer.read(buffer, 3);

  89.     EXPECT_THAT(buffer, ContainerEq(rxData));

  90. 

  91.     // Test null velocity note on

  92.     EXPECT_EQ(MidiInterface::Settings::HandleNullVelocityNoteOnAsNoteOff, true);

  93.     mSerial.mRxBuffer.write(0x9b);

  94.     mSerial.mRxBuffer.write(12);

  95.     mSerial.mRxBuffer.write(0);

  96. 

  97.     EXPECT_EQ(mMidi.read(), false);

  98.     EXPECT_EQ(mMidi.read(), false);

  99.     EXPECT_EQ(mMidi.read(), true);

  100.     EXPECT_EQ(mMidi.getType(),       midi::NoteOff);

  101.     EXPECT_EQ(mMidi.getChannel(),    12);

  102.     EXPECT_EQ(mMidi.getData1(),      12);

  103.     EXPECT_EQ(mMidi.getData2(),      0);

  104. 

  105.     EXPECT_EQ(mSerial.mTxBuffer.getLength(), 0);

  106. }

  107. 

  108. // --

  109. 

  110. void handleNoteOff(byte inChannel, byte inPitch, byte inVelocity)

  111. {

  112.     EXPECT_NE(midi, nullptr);

  113.     midi->sendNoteOff(inPitch, inVelocity, inChannel);

  114. }

  115. 

  116. TEST_F(MidiInputCallbacks, noteOff)

  117. {

  118.     mMidi.setHandleNoteOff(handleNoteOff);

  119.     mMidi.begin(MIDI_CHANNEL_OMNI);

  120.     mMidi.turnThruOff();

  121. 

  122.     static const unsigned rxSize = 3;

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

  124.     mSerial.mRxBuffer.write(rxData, rxSize);

  125. 

  126.     EXPECT_EQ(mMidi.read(), false);

  127.     EXPECT_EQ(mMidi.read(), false);

  128.     EXPECT_EQ(mMidi.read(), true);

  129.     EXPECT_EQ(mMidi.getType(),       midi::NoteOff);

  130.     EXPECT_EQ(mMidi.getChannel(),    12);

  131.     EXPECT_EQ(mMidi.getData1(),      12);

  132.     EXPECT_EQ(mMidi.getData2(),      34);

  133. 

  134.     EXPECT_EQ(mSerial.mTxBuffer.getLength(), 3);

  135.     byte buffer[3] = { 0 };

  136.     mSerial.mTxBuffer.read(buffer, 3);

  137.     EXPECT_THAT(buffer, ContainerEq(rxData));

  138. 

  139.     // Test null velocity note on

  140.     EXPECT_EQ(MidiInterface::Settings::HandleNullVelocityNoteOnAsNoteOff, true);

  141.     mSerial.mRxBuffer.write(0x9b);

  142.     mSerial.mRxBuffer.write(12);

  143.     mSerial.mRxBuffer.write(0);

  144. 

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

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

  147.     EXPECT_EQ(mMidi.read(), true);

  148.     EXPECT_EQ(mMidi.getType(),       midi::NoteOff);

  149.     EXPECT_EQ(mMidi.getChannel(),    12);

  150.     EXPECT_EQ(mMidi.getData1(),      12);

  151.     EXPECT_EQ(mMidi.getData2(),      0);

  152. 

  153.     EXPECT_EQ(mSerial.mTxBuffer.getLength(), 3);

  154.     mSerial.mTxBuffer.read(buffer, 3);

  155.     EXPECT_THAT(buffer, ElementsAreArray({

  156.         0x8b, 12, 0

  157.     }));

  158. }

  159. 

  160. // --

  161. 

  162. 

  163. 

  164. void handleAfterTouchPoly(byte inChannel, byte inNote, byte inValue)

  165. {

  166.     EXPECT_NE(midi, nullptr);

  167.     midi->sendAfterTouch(inNote, inValue, inChannel);

  168. }

  169. 

  170. TEST_F(MidiInputCallbacks, afterTouchPoly)

  171. {

  172.     mMidi.setHandleAfterTouchPoly(handleAfterTouchPoly);

  173.     mMidi.begin(MIDI_CHANNEL_OMNI);

  174.     mMidi.turnThruOff();

  175. 

  176.     static const unsigned rxSize = 3;

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

  178.     mSerial.mRxBuffer.write(rxData, rxSize);

  179. 

  180.     EXPECT_EQ(mMidi.read(), false);

  181.     EXPECT_EQ(mMidi.read(), false);

  182.     EXPECT_EQ(mMidi.read(), true);

  183.     EXPECT_EQ(mMidi.getType(),       midi::AfterTouchPoly);

  184.     EXPECT_EQ(mMidi.getChannel(),    12);

  185.     EXPECT_EQ(mMidi.getData1(),      12);

  186.     EXPECT_EQ(mMidi.getData2(),      34);

  187. 

  188.     EXPECT_EQ(mSerial.mTxBuffer.getLength(), 3);

  189.     byte buffer[3] = { 0 };

  190.     mSerial.mTxBuffer.read(buffer, 3);

  191.     EXPECT_THAT(buffer, ContainerEq(rxData));

  192. }

  193. 

  194. // --

  195. 

  196. void handleControlChange(byte inChannel, byte inNumber, byte inValue)

  197. {

  198.     EXPECT_NE(midi, nullptr);

  199.     midi->sendControlChange(inNumber, inValue, inChannel);

  200. }

  201. 

  202. TEST_F(MidiInputCallbacks, controlChange)

  203. {

  204.     mMidi.setHandleControlChange(handleControlChange);

  205.     mMidi.begin(MIDI_CHANNEL_OMNI);

  206.     mMidi.turnThruOff();

  207. 

  208.     static const unsigned rxSize = 3;

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

  210.     mSerial.mRxBuffer.write(rxData, rxSize);

  211. 

  212.     EXPECT_EQ(mMidi.read(), false);

  213.     EXPECT_EQ(mMidi.read(), false);

  214.     EXPECT_EQ(mMidi.read(), true);

  215.     EXPECT_EQ(mMidi.getType(),       midi::ControlChange);

  216.     EXPECT_EQ(mMidi.getChannel(),    12);

  217.     EXPECT_EQ(mMidi.getData1(),      12);

  218.     EXPECT_EQ(mMidi.getData2(),      34);

  219. 

  220.     EXPECT_EQ(mSerial.mTxBuffer.getLength(), 3);

  221.     byte buffer[3] = { 0 };

  222.     mSerial.mTxBuffer.read(buffer, 3);

  223.     EXPECT_THAT(buffer, ContainerEq(rxData));

  224. }

  225. 

  226. // --

  227. 

  228. void handleProgramChange(byte inChannel, byte inNumber)

  229. {

  230.     EXPECT_NE(midi, nullptr);

  231.     midi->sendProgramChange(inNumber, inChannel);

  232. }

  233. 

  234. TEST_F(MidiInputCallbacks, programChange)

  235. {

  236.     mMidi.setHandleProgramChange(handleProgramChange);

  237.     mMidi.begin(MIDI_CHANNEL_OMNI);

  238.     mMidi.turnThruOff();

  239. 

  240.     static const unsigned rxSize = 2;

  241.     static const byte rxData[rxSize] = { 0xcb, 12 };

  242.     mSerial.mRxBuffer.write(rxData, rxSize);

  243. 

  244.     EXPECT_EQ(mMidi.read(), false);

  245.     EXPECT_EQ(mMidi.read(), true);

  246.     EXPECT_EQ(mMidi.getType(),       midi::ProgramChange);

  247.     EXPECT_EQ(mMidi.getChannel(),    12);

  248.     EXPECT_EQ(mMidi.getData1(),      12);

  249.     EXPECT_EQ(mMidi.getData2(),      0);

  250. 

  251.     EXPECT_EQ(mSerial.mTxBuffer.getLength(), 2);

  252.     byte buffer[2] = { 0 };

  253.     mSerial.mTxBuffer.read(buffer, 2);

  254.     EXPECT_THAT(buffer, ContainerEq(rxData));

  255. }

  256. 

  257. // --

  258. 

  259. void handleAfterTouchChannel(byte inChannel, byte inPressure)

  260. {

  261.     EXPECT_NE(midi, nullptr);

  262.     midi->sendAfterTouch(inPressure, inChannel);

  263. }

  264. 

  265. 

  266. TEST_F(MidiInputCallbacks, afterTouchChannel)

  267. {

  268.     mMidi.setHandleAfterTouchChannel(handleAfterTouchChannel);

  269.     mMidi.begin(MIDI_CHANNEL_OMNI);

  270.     mMidi.turnThruOff();

  271. 

  272.     static const unsigned rxSize = 2;

  273.     static const byte rxData[rxSize] = { 0xdb, 12 };

  274.     mSerial.mRxBuffer.write(rxData, rxSize);

  275. 

  276.     EXPECT_EQ(mMidi.read(), false);

  277.     EXPECT_EQ(mMidi.read(), true);

  278.     EXPECT_EQ(mMidi.getType(),       midi::AfterTouchChannel);

  279.     EXPECT_EQ(mMidi.getChannel(),    12);

  280.     EXPECT_EQ(mMidi.getData1(),      12);

  281.     EXPECT_EQ(mMidi.getData2(),      0);

  282. 

  283.     EXPECT_EQ(mSerial.mTxBuffer.getLength(), 2);

  284.     byte buffer[2] = { 0 };

  285.     mSerial.mTxBuffer.read(buffer, 2);

  286.     EXPECT_THAT(buffer, ContainerEq(rxData));

  287. }

  288. 

  289. // --

  290. 

  291. void handlePitchBend(byte inChannel, int inValue)

  292. {

  293.     EXPECT_NE(midi, nullptr);

  294.     midi->sendPitchBend(inValue, inChannel);

  295. }

  296. 

  297. TEST_F(MidiInputCallbacks, pitchBend)

  298. {

  299.     mMidi.setHandlePitchBend(handlePitchBend);

  300.     mMidi.begin(MIDI_CHANNEL_OMNI);

  301.     mMidi.turnThruOff();

  302. 

  303.     static const unsigned rxSize = 3;

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

  305.     mSerial.mRxBuffer.write(rxData, rxSize);

  306. 

  307.     EXPECT_EQ(mMidi.read(), false);

  308.     EXPECT_EQ(mMidi.read(), false);

  309.     EXPECT_EQ(mMidi.read(), true);

  310.     EXPECT_EQ(mMidi.getType(),       midi::PitchBend);

  311.     EXPECT_EQ(mMidi.getChannel(),    12);

  312.     EXPECT_EQ(mMidi.getData1(),      12);

  313.     EXPECT_EQ(mMidi.getData2(),      34);

  314. 

  315.     EXPECT_EQ(mSerial.mTxBuffer.getLength(), 3);

  316.     byte buffer[3] = { 0 };

  317.     mSerial.mTxBuffer.read(buffer, 3);

  318.     EXPECT_THAT(buffer, ContainerEq(rxData));

  319. }

  320. 

  321. // --

  322. 

  323. void handleSysEx(byte* inData, unsigned inSize)

  324. {

  325.     EXPECT_NE(midi, nullptr);

  326.     midi->sendSysEx(inSize, inData, true);

  327. }

  328. 

  329. TEST_F(MidiInputCallbacks, sysEx)

  330. {

  331.     mMidi.setHandleSystemExclusive(handleSysEx);

  332.     mMidi.begin(MIDI_CHANNEL_OMNI);

  333.     mMidi.turnThruOff();

  334. 

  335.     static const unsigned rxSize = 15;

  336.     static const byte rxData[rxSize] = {

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

  338.     };

  339.     mSerial.mRxBuffer.write(rxData, rxSize);

  340. 

  341.     for (unsigned i = 0; i < rxSize - 1; ++i)

  342.     {

  343.         EXPECT_EQ(mMidi.read(), false);

  344.     }

  345.     EXPECT_EQ(mMidi.read(), true);

  346.     EXPECT_EQ(mMidi.getType(),              midi::SystemExclusive);

  347.     EXPECT_EQ(mMidi.getChannel(),           0);

  348.     EXPECT_EQ(mMidi.getSysExArrayLength(),  rxSize);

  349. 

  350.     EXPECT_EQ(unsigned(mSerial.mTxBuffer.getLength()), rxSize);

  351.     const std::vector<byte> sysExData(mMidi.getSysExArray(),

  352.                                       mMidi.getSysExArray() + rxSize);

  353.     EXPECT_THAT(sysExData, ElementsAreArray(rxData));

  354. }

  355. 

  356. TEST_F(MidiInputCallbacks, sysExLong)

  357. {

  358.     mMidi.setHandleSystemExclusive(handleSysEx);

  359.     mMidi.begin(MIDI_CHANNEL_OMNI);

  360.     mMidi.turnThruOff();

  361. 

  362.     static const unsigned rxSize = 210;

  363.     static const byte rxData[rxSize] = {

  364.         0xf0,

  365.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  366.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  367.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  368.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  369.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  370.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  371.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  372.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  373.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  374.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  375.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  376.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  377.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  378.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  379.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  380.             'H','e','l','l','o',',',' ','W','o','r','l','d','!',

  381.         0xf7

  382.     };

  383.     mSerial.mRxBuffer.write(rxData, rxSize);

  384. 

  385.     for (unsigned i = 0; i < rxSize - 1; ++i)

  386.     {

  387.         EXPECT_EQ(mMidi.read(), false);

  388.     }

  389.     EXPECT_EQ(mMidi.read(), true);

  390.     EXPECT_EQ(mMidi.getType(),              midi::SystemExclusive);

  391.     EXPECT_EQ(mMidi.getChannel(),           0);

  392.     EXPECT_EQ(mMidi.getSysExArrayLength(),  rxSize);

  393. 

  394.     EXPECT_EQ(unsigned(mSerial.mTxBuffer.getLength()), rxSize);

  395.     const std::vector<byte> sysExData(mMidi.getSysExArray(),

  396.                                       mMidi.getSysExArray() + rxSize);

  397.     EXPECT_THAT(sysExData, ElementsAreArray(rxData));

  398. }

  399. 

  400. // --

  401. 

  402. void handleMtcQuarterFrame(byte inData)

  403. {

  404.     EXPECT_NE(midi, nullptr);

  405.     midi->sendTimeCodeQuarterFrame(inData);

  406. }

  407. 

  408. TEST_F(MidiInputCallbacks, mtcQuarterFrame)

  409. {

  410.     mMidi.setHandleTimeCodeQuarterFrame(handleMtcQuarterFrame);

  411.     mMidi.begin(MIDI_CHANNEL_OMNI);

  412.     mMidi.turnThruOff();

  413. 

  414.     static const unsigned rxSize = 2;

  415.     static const byte rxData[rxSize] = { 0xf1, 12 };

  416.     mSerial.mRxBuffer.write(rxData, rxSize);

  417. 

  418.     EXPECT_EQ(mMidi.read(), false);

  419.     EXPECT_EQ(mMidi.read(), true);

  420.     EXPECT_EQ(mMidi.getType(),       midi::TimeCodeQuarterFrame);

  421.     EXPECT_EQ(mMidi.getChannel(),    0);

  422.     EXPECT_EQ(mMidi.getData1(),      12);

  423.     EXPECT_EQ(mMidi.getData2(),      0);

  424. 

  425.     EXPECT_EQ(mSerial.mTxBuffer.getLength(), 2);

  426.     byte buffer[2] = { 0 };

  427.     mSerial.mTxBuffer.read(buffer, 2);

  428.     EXPECT_THAT(buffer, ContainerEq(rxData));

  429. }

  430. 

  431. // --

  432. 

  433. void handleSongPosition(unsigned inBeats)

  434. {

  435.     EXPECT_NE(midi, nullptr);

  436.     midi->sendSongPosition(inBeats);

  437. }

  438. 

  439. TEST_F(MidiInputCallbacks, songPosition)

  440. {

  441.     mMidi.setHandleSongPosition(handleSongPosition);

  442.     mMidi.begin(MIDI_CHANNEL_OMNI);

  443.     mMidi.turnThruOff();

  444. 

  445.     static const unsigned rxSize = 3;

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

  447.     mSerial.mRxBuffer.write(rxData, rxSize);

  448. 

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

  450.     EXPECT_EQ(mMidi.read(), false);

  451.     EXPECT_EQ(mMidi.read(), true);

  452.     EXPECT_EQ(mMidi.getType(),       midi::SongPosition);

  453.     EXPECT_EQ(mMidi.getChannel(),    0);

  454.     EXPECT_EQ(mMidi.getData1(),      12);

  455.     EXPECT_EQ(mMidi.getData2(),      34);

  456. 

  457.     EXPECT_EQ(mSerial.mTxBuffer.getLength(), 3);

  458.     byte buffer[3] = { 0 };

  459.     mSerial.mTxBuffer.read(buffer, 3);

  460.     EXPECT_THAT(buffer, ContainerEq(rxData));

  461. }

  462. 

  463. // --

  464. 

  465. void handleSongSelect(byte inSongNumber)

  466. {

  467.     EXPECT_NE(midi, nullptr);

  468.     midi->sendSongSelect(inSongNumber);

  469. }

  470. 

  471. TEST_F(MidiInputCallbacks, songSelect)

  472. {

  473.     mMidi.setHandleSongSelect(handleSongSelect);

  474.     mMidi.begin(MIDI_CHANNEL_OMNI);

  475.     mMidi.turnThruOff();

  476. 

  477.     static const unsigned rxSize = 2;

  478.     static const byte rxData[rxSize] = { 0xf3, 12 };

  479.     mSerial.mRxBuffer.write(rxData, rxSize);

  480. 

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

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

  483.     EXPECT_EQ(mMidi.getType(),       midi::SongSelect);

  484.     EXPECT_EQ(mMidi.getChannel(),    0);

  485.     EXPECT_EQ(mMidi.getData1(),      12);

  486.     EXPECT_EQ(mMidi.getData2(),      0);

  487. 

  488.     EXPECT_EQ(mSerial.mTxBuffer.getLength(), 2);

  489.     byte buffer[2] = { 0 };

  490.     mSerial.mTxBuffer.read(buffer, 2);

  491.     EXPECT_THAT(buffer, ContainerEq(rxData));

  492. }

  493. 

  494. // --

  495. 

  496. void handleTuneRequest()

  497. {

  498.     EXPECT_NE(midi, nullptr);

  499.     midi->sendTuneRequest();

  500. }

  501. 

  502. TEST_F(MidiInputCallbacks, tuneRequest)

  503. {

  504.     mMidi.setHandleTuneRequest(handleTuneRequest);

  505.     mMidi.begin(MIDI_CHANNEL_OMNI);

  506.     mMidi.turnThruOff();

  507. 

  508.     mSerial.mRxBuffer.write(0xf6);

  509. 

  510.     EXPECT_EQ(mMidi.read(), true);

  511.     EXPECT_EQ(mMidi.getType(),       midi::TuneRequest);

  512.     EXPECT_EQ(mMidi.getChannel(),    0);

  513.     EXPECT_EQ(mMidi.getData1(),      0);

  514.     EXPECT_EQ(mMidi.getData2(),      0);

  515. 

  516.     EXPECT_EQ(mSerial.mTxBuffer.getLength(), 1);

  517.     EXPECT_EQ(mSerial.mTxBuffer.read(), 0xf6);

  518. }

  519. 

  520. // --

  521. 

  522. void handleClock()

  523. {

  524.     EXPECT_NE(midi, nullptr);

  525.     midi->sendRealTime(midi::Clock);

  526. }

  527. void handleStart()

  528. {

  529.     EXPECT_NE(midi, nullptr);

  530.     midi->sendRealTime(midi::Start);

  531. }

  532. void handleContinue()

  533. {

  534.     EXPECT_NE(midi, nullptr);

  535.     midi->sendRealTime(midi::Continue);

  536. }

  537. void handleStop()

  538. {

  539.     EXPECT_NE(midi, nullptr);

  540.     midi->sendRealTime(midi::Stop);

  541. }

  542. void handleActiveSensing()

  543. {

  544.     EXPECT_NE(midi, nullptr);

  545.     midi->sendRealTime(midi::ActiveSensing);

  546. }

  547. void handleSystemReset()

  548. {

  549.     EXPECT_NE(midi, nullptr);

  550.     midi->sendRealTime(midi::SystemReset);

  551. }

  552. 

  553. TEST_F(MidiInputCallbacks, realTime)

  554. {

  555.     mMidi.setHandleClock(handleClock);

  556.     mMidi.setHandleStart(handleStart);

  557.     mMidi.setHandleContinue(handleContinue);

  558.     mMidi.setHandleStop(handleStop);

  559.     mMidi.setHandleActiveSensing(handleActiveSensing);

  560.     mMidi.setHandleSystemReset(handleSystemReset);

  561. 

  562.     mMidi.begin(MIDI_CHANNEL_OMNI);

  563.     mMidi.turnThruOff();

  564. 

  565.     static const unsigned rxSize = 6;

  566.     static const byte rxData[rxSize] = {

  567.         0xf8, 0xfa, 0xfb, 0xfc, 0xfe, 0xff

  568.     };

  569.     mSerial.mRxBuffer.write(rxData, rxSize);

  570.     static const midi::MidiType types[rxSize] = {

  571.         midi::Clock,

  572.         midi::Start,

  573.         midi::Continue,

  574.         midi::Stop,

  575.         midi::ActiveSensing,

  576.         midi::SystemReset,

  577.     };

  578. 

  579.     for (unsigned i = 0; i < rxSize; ++i)

  580.     {

  581.         EXPECT_EQ(mMidi.read(),         true);

  582.         EXPECT_EQ(mMidi.getType(),      types[i]);

  583.         EXPECT_EQ(mMidi.getChannel(),   0);

  584.         EXPECT_EQ(mMidi.getData1(),     0);

  585.         EXPECT_EQ(mMidi.getData2(),     0);

  586.         EXPECT_EQ(mSerial.mTxBuffer.getLength(), 1);

  587. 

  588.         const byte read = mSerial.mTxBuffer.read();

  589.         EXPECT_EQ(read, rxData[i]);

  590.         EXPECT_EQ(read, types[i]);

  591.     }

  592. }

  593. 

  594. END_UNNAMED_NAMESPACE