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_MidiThru.cpp

390 lines
11KB
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. typedef std::vector<byte> Buffer;

  20. 

  21. template<unsigned Size>

  22. struct VariableSysExSettings : midi::DefaultSettings

  23. {

  24.     static const unsigned SysExMaxSize = Size;

  25. };

  26. 

  27. // -----------------------------------------------------------------------------

  28. 

  29. TEST(MidiThru, defaultValues)

  30. {

  31.     SerialMock serial;

  32.     Transport transport(serial);

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

  34. 

  35.     EXPECT_EQ(midi.getThruState(),  true);

  36.     EXPECT_EQ(midi.getFilterMode(), midi::Thru::Full);

  37.     midi.begin(); // Should not change the state

  38.     EXPECT_EQ(midi.getThruState(),  true);

  39.     EXPECT_EQ(midi.getFilterMode(), midi::Thru::Full);

  40. }

  41. 

  42. TEST(MidiThru, beginEnablesThru)

  43. {

  44.     SerialMock serial;

  45.     Transport transport(serial);

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

  47. 

  48.     midi.turnThruOff();

  49.     EXPECT_EQ(midi.getThruState(),  false);

  50.     EXPECT_EQ(midi.getFilterMode(), midi::Thru::Off);

  51.     midi.begin();

  52.     EXPECT_EQ(midi.getThruState(),  true);

  53.     EXPECT_EQ(midi.getFilterMode(), midi::Thru::Full);

  54. }

  55. 

  56. TEST(MidiThru, setGet)

  57. {

  58.     SerialMock serial;

  59.     Transport transport(serial);

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

  61. 

  62.     midi.turnThruOff();

  63.     EXPECT_EQ(midi.getThruState(),  false);

  64.     EXPECT_EQ(midi.getFilterMode(), midi::Thru::Off);

  65. 

  66.     midi.turnThruOn();

  67.     EXPECT_EQ(midi.getThruState(),  true);

  68.     EXPECT_EQ(midi.getFilterMode(), midi::Thru::Full);

  69.     midi.turnThruOn(midi::Thru::SameChannel);

  70.     EXPECT_EQ(midi.getThruState(),  true);

  71.     EXPECT_EQ(midi.getFilterMode(), midi::Thru::SameChannel);

  72.     midi.turnThruOn(midi::Thru::DifferentChannel);

  73.     EXPECT_EQ(midi.getThruState(),  true);

  74.     EXPECT_EQ(midi.getFilterMode(), midi::Thru::DifferentChannel);

  75. 

  76.     midi.setThruFilterMode(midi::Thru::Full);

  77.     EXPECT_EQ(midi.getThruState(),  true);

  78.     EXPECT_EQ(midi.getFilterMode(), midi::Thru::Full);

  79.     midi.setThruFilterMode(midi::Thru::SameChannel);

  80.     EXPECT_EQ(midi.getThruState(),  true);

  81.     EXPECT_EQ(midi.getFilterMode(), midi::Thru::SameChannel);

  82.     midi.setThruFilterMode(midi::Thru::DifferentChannel);

  83.     EXPECT_EQ(midi.getThruState(),  true);

  84.     EXPECT_EQ(midi.getFilterMode(), midi::Thru::DifferentChannel);

  85.     midi.setThruFilterMode(midi::Thru::Off);

  86.     EXPECT_EQ(midi.getThruState(),  false);

  87.     EXPECT_EQ(midi.getFilterMode(), midi::Thru::Off);

  88. }

  89. 

  90. TEST(MidiThru, off)

  91. {

  92.     SerialMock serial;

  93.     Transport transport(serial);

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

  95. 

  96.     midi.begin(MIDI_CHANNEL_OMNI);

  97.     midi.turnThruOff();

  98. 

  99.     static const unsigned rxSize = 5;

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

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

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

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

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

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

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

  107. 

  108.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

  109. }

  110. 

  111. TEST(MidiThru, full)

  112. {

  113.     SerialMock serial;

  114.     Transport transport(serial);

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

  116. 

  117.     Buffer buffer;

  118. 

  119.     midi.begin(MIDI_CHANNEL_OMNI);

  120.     midi.setThruFilterMode(midi::Thru::Full);

  121. 

  122.     static const unsigned rxSize = 6;

  123.     static const byte rxData[rxSize] = { 0x9b, 12, 34, 0x9c, 56, 78 };

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

  125. 

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

  127.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  129.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  131. 

  132.     buffer.clear();

  133.     buffer.resize(3);

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

  135.     serial.mTxBuffer.read(&buffer[0], 3);

  136.     EXPECT_THAT(buffer, ElementsAreArray({

  137.         0x9b, 12, 34

  138.     }));

  139. 

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

  141.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  143.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  145. 

  146.     buffer.clear();

  147.     buffer.resize(3);

  148.     EXPECT_EQ(serial.mTxBuffer.getLength(), 3);

  149.     serial.mTxBuffer.read(&buffer[0], 3);

  150.     EXPECT_THAT(buffer, ElementsAreArray({

  151.         0x9c, 56, 78

  152.     }));

  153. }

  154. 

  155. TEST(MidiThru, sameChannel)

  156. {

  157.     SerialMock serial;

  158.     Transport transport(serial);

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

  160. 

  161.     Buffer buffer;

  162. 

  163.     midi.begin(12);

  164.     midi.setThruFilterMode(midi::Thru::SameChannel);

  165. 

  166.     static const unsigned rxSize = 6;

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

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

  169. 

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

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

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

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

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

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

  176. 

  177.     buffer.clear();

  178.     buffer.resize(3);

  179.     EXPECT_EQ(serial.mTxBuffer.getLength(), 3);

  180.     serial.mTxBuffer.read(&buffer[0], 3);

  181.     EXPECT_THAT(buffer, ElementsAreArray({

  182.         0x9b, 12, 34

  183.     }));

  184. }

  185. 

  186. TEST(MidiThru, sameChannelOmni) // Acts like full

  187. {

  188.     SerialMock serial;

  189.     Transport transport(serial);

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

  191. 

  192.     Buffer buffer;

  193. 

  194.     midi.begin(MIDI_CHANNEL_OMNI);

  195.     midi.setThruFilterMode(midi::Thru::SameChannel);

  196. 

  197.     static const unsigned rxSize = 6;

  198.     static const byte rxData[rxSize] = { 0x9b, 12, 34, 0x9c, 56, 78 };

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

  200. 

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

  202.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  204.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  206. 

  207.     buffer.clear();

  208.     buffer.resize(3);

  209.     EXPECT_EQ(serial.mTxBuffer.getLength(), 3);

  210.     serial.mTxBuffer.read(&buffer[0], 3);

  211.     EXPECT_THAT(buffer, ElementsAreArray({

  212.         0x9b, 12, 34

  213.     }));

  214. 

  215.     buffer.clear();

  216.     buffer.resize(3);

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

  218.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  220.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  222. 

  223.     EXPECT_EQ(serial.mTxBuffer.getLength(), 3); // Not using TX running status

  224.     serial.mTxBuffer.read(&buffer[0], 3);

  225.     EXPECT_THAT(buffer, ElementsAreArray({

  226.         0x9c, 56, 78

  227.     }));

  228. }

  229. 

  230. TEST(MidiThru, differentChannel)

  231. {

  232.     SerialMock serial;

  233.     Transport transport(serial);

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

  235. 

  236.     Buffer buffer;

  237. 

  238.     midi.begin(12);

  239.     midi.setThruFilterMode(midi::Thru::DifferentChannel);

  240. 

  241.     static const unsigned rxSize = 6;

  242.     static const byte rxData[rxSize] = { 0x9b, 12, 34, 0x9c, 56, 78 };

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

  244. 

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

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

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

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

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

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

  251. 

  252.     buffer.clear();

  253.     buffer.resize(3);

  254.     EXPECT_EQ(serial.mTxBuffer.getLength(), 3);

  255.     serial.mTxBuffer.read(&buffer[0], 3);

  256.     EXPECT_THAT(buffer, ElementsAreArray({

  257.         0x9c, 56, 78

  258.     }));

  259. }

  260. 

  261. TEST(MidiThru, differentChannelOmni) // Acts like off

  262. {

  263.     SerialMock serial;

  264.     Transport transport(serial);

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

  266. 

  267.     Buffer buffer;

  268. 

  269.     midi.begin(MIDI_CHANNEL_OMNI);

  270.     midi.setThruFilterMode(midi::Thru::DifferentChannel);

  271. 

  272.     static const unsigned rxSize = 6;

  273.     static const byte rxData[rxSize] = { 0x9b, 12, 34, 0x9c, 56, 78 };

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

  275. 

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

  277.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  279.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  281.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

  282. 

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

  284.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  286.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  288.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

  289. }

  290. 

  291. TEST(MidiThru, multiByteThru)

  292. {

  293.     typedef VariableSettings<false, false> MultiByteParsing;

  294.     typedef midi::MidiInterface<Transport, MultiByteParsing> MultiByteMidiInterface;

  295. 

  296.     SerialMock serial;

  297.     Transport transport(serial);

  298.     MultiByteMidiInterface midi((Transport&)transport);

  299.     

  300.     Buffer buffer;

  301. 

  302.     midi.begin(MIDI_CHANNEL_OMNI);

  303.     midi.setThruFilterMode(midi::Thru::Full);

  304. 

  305.     static const unsigned rxSize = 6;

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

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

  308. 

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

  310.     EXPECT_EQ(serial.mTxBuffer.getLength(), 3);

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

  312.     EXPECT_EQ(serial.mTxBuffer.getLength(), 6);

  313. 

  314.     buffer.clear();

  315.     buffer.resize(6);

  316.     serial.mTxBuffer.read(&buffer[0], 6);

  317.     EXPECT_THAT(buffer, ElementsAreArray({

  318.         0x9b, 12, 34, 0x9b, 56, 78

  319.     }));

  320. }

  321. 

  322. TEST(MidiThru, withTxRunningStatus)

  323. {

  324.     typedef VariableSettings<true, true> Settings;

  325.     typedef midi::MidiInterface<Transport, Settings> RsMidiInterface;

  326. 

  327.     SerialMock serial;

  328.     Transport transport(serial);

  329.     RsMidiInterface midi((Transport&)transport);

  330.     

  331.     Buffer buffer;

  332. 

  333.     midi.begin(MIDI_CHANNEL_OMNI);

  334.     midi.setThruFilterMode(midi::Thru::Full);

  335. 

  336.     static const unsigned rxSize = 5;

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

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

  339. 

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

  341.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  343.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  345. 

  346.     buffer.clear();

  347.     buffer.resize(3);

  348.     EXPECT_EQ(serial.mTxBuffer.getLength(), 3);

  349.     serial.mTxBuffer.read(&buffer[0], 3);

  350.     EXPECT_THAT(buffer, ElementsAreArray({

  351.         0x9b, 12, 34

  352.     }));

  353. 

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

  355.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

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

  357. 

  358.     buffer.clear();

  359.     buffer.resize(2);

  360.     EXPECT_EQ(serial.mTxBuffer.getLength(), 2);

  361.     serial.mTxBuffer.read(&buffer[0], 2);

  362.     EXPECT_THAT(buffer, ElementsAreArray({

  363.         56, 78

  364.     }));

  365. }

  366. 

  367. TEST(MidiThru, invalidMode)

  368. {

  369.     SerialMock serial;

  370.     Transport transport(serial);

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

  372. 

  373.     midi.begin(MIDI_CHANNEL_OMNI);

  374.     midi.setThruFilterMode(midi::Thru::Mode(42));

  375. 

  376.     static const unsigned rxSize = 6;

  377.     static const byte rxData[rxSize] = { 0x9b, 12, 34, 0x9c, 56, 78 };

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

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

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

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

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

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

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

  385. 

  386.     EXPECT_EQ(serial.mTxBuffer.getLength(), 0);

  387. }

  388. 

  389. END_UNNAMED_NAMESPACE