midi_message_queue_unittest.cc 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572
  1. // Copyright 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "media/midi/midi_message_queue.h"
  5. #include <stddef.h>
  6. #include <stdint.h>
  7. #include "testing/gtest/include/gtest/gtest.h"
  8. namespace midi {
  9. namespace {
  10. const uint8_t kGMOn[] = {0xf0, 0x7e, 0x7f, 0x09, 0x01, 0xf7};
  11. const uint8_t kPartialGMOn1st[] = {0xf0};
  12. const uint8_t kPartialGMOn2nd[] = {0x7e, 0x7f, 0x09, 0x01};
  13. const uint8_t kPartialGMOn3rd[] = {0xf7};
  14. const uint8_t kGSOn[] = {
  15. 0xf0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7f, 0x00, 0x41, 0xf7,
  16. };
  17. const uint8_t kNoteOn[] = {0x90, 0x3c, 0x7f};
  18. const uint8_t kPartialNoteOn1st[] = {0x90};
  19. const uint8_t kPartialNoteOn2nd[] = {0x3c};
  20. const uint8_t kPartialNoteOn3rd[] = {0x7f};
  21. const uint8_t kNoteOnWithRunningStatus[] = {
  22. 0x90, 0x3c, 0x7f, 0x3c, 0x7f, 0x3c, 0x7f,
  23. };
  24. const uint8_t kChannelPressure[] = {0xd0, 0x01};
  25. const uint8_t kChannelPressureWithRunningStatus[] = {
  26. 0xd0, 0x01, 0x01, 0x01,
  27. };
  28. const uint8_t kTimingClock[] = {0xf8};
  29. const uint8_t kSystemCommonMessageTuneRequest[] = {0xf6};
  30. const uint8_t kMTCFrame[] = {0xf1, 0x00};
  31. const uint8_t kBrokenData1[] = {0x92};
  32. const uint8_t kBrokenData2[] = {0xf7};
  33. const uint8_t kBrokenData3[] = {0xf2, 0x00};
  34. const uint8_t kDataByte0[] = {0x00};
  35. const uint8_t kReservedMessage1[] = {0xf4};
  36. const uint8_t kReservedMessage2[] = {0xf5};
  37. const uint8_t kReservedMessage1WithDataBytes[] = {0xf4, 0x01, 0x01,
  38. 0x01, 0x01, 0x01};
  39. template <typename T, size_t N>
  40. void Add(MidiMessageQueue* queue, const T(&array)[N]) {
  41. queue->Add(array, N);
  42. }
  43. template <typename T, size_t N>
  44. ::testing::AssertionResult ExpectEqualSequence(
  45. const char* expr1, const char* expr2,
  46. const T(&expected)[N], const std::vector<T>& actual) {
  47. if (actual.size() != N) {
  48. return ::testing::AssertionFailure()
  49. << "expected: " << ::testing::PrintToString(expected)
  50. << ", actual: " << ::testing::PrintToString(actual);
  51. }
  52. for (size_t i = 0; i < N; ++i) {
  53. if (expected[i] != actual[i]) {
  54. return ::testing::AssertionFailure()
  55. << "expected: " << ::testing::PrintToString(expected)
  56. << ", actual: " << ::testing::PrintToString(actual);
  57. }
  58. }
  59. return ::testing::AssertionSuccess();
  60. }
  61. #define EXPECT_MESSAGE(expected, actual) \
  62. EXPECT_PRED_FORMAT2(ExpectEqualSequence, expected, actual)
  63. TEST(MidiMessageQueueTest, EmptyData) {
  64. MidiMessageQueue queue(false);
  65. std::vector<uint8_t> message;
  66. queue.Get(&message);
  67. EXPECT_TRUE(message.empty());
  68. }
  69. TEST(MidiMessageQueueTest, RunningStatusDisabled) {
  70. MidiMessageQueue queue(false);
  71. Add(&queue, kGMOn);
  72. Add(&queue, kBrokenData1);
  73. Add(&queue, kNoteOnWithRunningStatus);
  74. Add(&queue, kBrokenData2);
  75. Add(&queue, kChannelPressureWithRunningStatus);
  76. Add(&queue, kBrokenData3);
  77. Add(&queue, kNoteOn);
  78. Add(&queue, kBrokenData1);
  79. Add(&queue, kGSOn);
  80. Add(&queue, kBrokenData2);
  81. Add(&queue, kTimingClock);
  82. Add(&queue, kBrokenData3);
  83. std::vector<uint8_t> message;
  84. queue.Get(&message);
  85. EXPECT_MESSAGE(kGMOn, message);
  86. queue.Get(&message);
  87. EXPECT_MESSAGE(kNoteOn, message) << "Running status should be ignored";
  88. queue.Get(&message);
  89. EXPECT_MESSAGE(kChannelPressure, message)
  90. << "Running status should be ignored";
  91. queue.Get(&message);
  92. EXPECT_MESSAGE(kNoteOn, message);
  93. queue.Get(&message);
  94. EXPECT_MESSAGE(kGSOn, message);
  95. queue.Get(&message);
  96. EXPECT_MESSAGE(kTimingClock, message);
  97. queue.Get(&message);
  98. EXPECT_TRUE(message.empty());
  99. }
  100. TEST(MidiMessageQueueTest, RunningStatusEnabled) {
  101. MidiMessageQueue queue(true);
  102. Add(&queue, kGMOn);
  103. Add(&queue, kBrokenData1);
  104. Add(&queue, kNoteOnWithRunningStatus);
  105. Add(&queue, kBrokenData2);
  106. Add(&queue, kChannelPressureWithRunningStatus);
  107. Add(&queue, kBrokenData3);
  108. Add(&queue, kNoteOn);
  109. Add(&queue, kBrokenData1);
  110. Add(&queue, kGSOn);
  111. Add(&queue, kBrokenData2);
  112. Add(&queue, kTimingClock);
  113. Add(&queue, kDataByte0);
  114. std::vector<uint8_t> message;
  115. queue.Get(&message);
  116. EXPECT_MESSAGE(kGMOn, message);
  117. queue.Get(&message);
  118. EXPECT_MESSAGE(kNoteOn, message);
  119. queue.Get(&message);
  120. EXPECT_MESSAGE(kNoteOn, message)
  121. << "Running status should be converted into a canonical MIDI message";
  122. queue.Get(&message);
  123. EXPECT_MESSAGE(kNoteOn, message)
  124. << "Running status should be converted into a canonical MIDI message";
  125. queue.Get(&message);
  126. EXPECT_MESSAGE(kChannelPressure, message);
  127. queue.Get(&message);
  128. EXPECT_MESSAGE(kChannelPressure, message)
  129. << "Running status should be converted into a canonical MIDI message";
  130. queue.Get(&message);
  131. EXPECT_MESSAGE(kChannelPressure, message)
  132. << "Running status should be converted into a canonical MIDI message";
  133. queue.Get(&message);
  134. EXPECT_MESSAGE(kNoteOn, message);
  135. queue.Get(&message);
  136. EXPECT_MESSAGE(kGSOn, message);
  137. queue.Get(&message);
  138. EXPECT_MESSAGE(kTimingClock, message);
  139. queue.Get(&message);
  140. EXPECT_TRUE(message.empty())
  141. << "Running status must not be applied to real time messages";
  142. }
  143. TEST(MidiMessageQueueTest, RunningStatusEnabledWithRealTimeEvent) {
  144. MidiMessageQueue queue(true);
  145. const uint8_t kNoteOnWithRunningStatusWithTimingClock[] = {
  146. 0x90, 0xf8, 0x3c, 0xf8, 0x7f, 0xf8, 0x3c,
  147. 0xf8, 0x7f, 0xf8, 0x3c, 0xf8, 0x7f,
  148. };
  149. Add(&queue, kNoteOnWithRunningStatusWithTimingClock);
  150. std::vector<uint8_t> message;
  151. queue.Get(&message);
  152. EXPECT_MESSAGE(kTimingClock, message);
  153. queue.Get(&message);
  154. EXPECT_MESSAGE(kTimingClock, message);
  155. queue.Get(&message);
  156. EXPECT_MESSAGE(kNoteOn, message);
  157. queue.Get(&message);
  158. EXPECT_MESSAGE(kTimingClock, message);
  159. queue.Get(&message);
  160. EXPECT_MESSAGE(kTimingClock, message);
  161. queue.Get(&message);
  162. EXPECT_MESSAGE(kNoteOn, message);
  163. queue.Get(&message);
  164. EXPECT_MESSAGE(kTimingClock, message);
  165. queue.Get(&message);
  166. EXPECT_MESSAGE(kTimingClock, message);
  167. queue.Get(&message);
  168. EXPECT_MESSAGE(kNoteOn, message);
  169. queue.Get(&message);
  170. EXPECT_TRUE(message.empty());
  171. }
  172. TEST(MidiMessageQueueTest, RunningStatusEnabledWithSystemCommonMessage) {
  173. MidiMessageQueue queue(true);
  174. const uint8_t kNoteOnWithRunningStatusWithSystemCommonMessage[] = {
  175. 0x90, 0x3c, 0x7f, 0xf1, 0x00, 0x3c, 0x7f, 0xf8, 0x90, 0x3c, 0x7f,
  176. };
  177. Add(&queue, kNoteOnWithRunningStatusWithSystemCommonMessage);
  178. std::vector<uint8_t> message;
  179. queue.Get(&message);
  180. EXPECT_MESSAGE(kNoteOn, message);
  181. queue.Get(&message);
  182. EXPECT_MESSAGE(kMTCFrame, message);
  183. queue.Get(&message);
  184. EXPECT_MESSAGE(kTimingClock, message) << "Running status should be reset";
  185. queue.Get(&message);
  186. EXPECT_MESSAGE(kNoteOn, message);
  187. queue.Get(&message);
  188. EXPECT_TRUE(message.empty());
  189. }
  190. TEST(MidiMessageQueueTest, Issue540016) {
  191. const uint8_t kData[] = {0xf4, 0x3a};
  192. MidiMessageQueue queue(false);
  193. Add(&queue, kData);
  194. std::vector<uint8_t> message;
  195. queue.Get(&message);
  196. EXPECT_TRUE(message.empty());
  197. }
  198. TEST(MidiMessageQueueTest, ReconstructNonSysExMessage) {
  199. MidiMessageQueue queue(true);
  200. std::vector<uint8_t> message;
  201. Add(&queue, kPartialNoteOn1st);
  202. queue.Get(&message);
  203. EXPECT_TRUE(message.empty());
  204. Add(&queue, kPartialNoteOn2nd);
  205. queue.Get(&message);
  206. EXPECT_TRUE(message.empty());
  207. Add(&queue, kPartialNoteOn3rd);
  208. queue.Get(&message);
  209. EXPECT_MESSAGE(kNoteOn, message);
  210. queue.Get(&message);
  211. EXPECT_TRUE(message.empty());
  212. }
  213. TEST(MidiMessageQueueTest, ReconstructBrokenNonSysExMessage) {
  214. MidiMessageQueue queue(true);
  215. std::vector<uint8_t> message;
  216. Add(&queue, kPartialNoteOn1st);
  217. queue.Get(&message);
  218. EXPECT_TRUE(message.empty());
  219. Add(&queue, kPartialNoteOn2nd);
  220. queue.Get(&message);
  221. EXPECT_TRUE(message.empty());
  222. Add(&queue, kPartialGMOn1st);
  223. queue.Get(&message);
  224. EXPECT_TRUE(message.empty());
  225. Add(&queue, kPartialNoteOn3rd);
  226. queue.Get(&message);
  227. EXPECT_TRUE(message.empty());
  228. }
  229. TEST(MidiMessageQueueTest, ReconstructSysExMessage) {
  230. MidiMessageQueue queue(true);
  231. std::vector<uint8_t> message;
  232. Add(&queue, kPartialGMOn1st);
  233. queue.Get(&message);
  234. EXPECT_TRUE(message.empty());
  235. Add(&queue, kPartialGMOn2nd);
  236. queue.Get(&message);
  237. EXPECT_TRUE(message.empty());
  238. Add(&queue, kPartialGMOn3rd);
  239. queue.Get(&message);
  240. EXPECT_MESSAGE(kGMOn, message);
  241. queue.Get(&message);
  242. EXPECT_TRUE(message.empty());
  243. }
  244. TEST(MidiMessageQueueTest, ReconstructBrokenSysExMessage) {
  245. MidiMessageQueue queue(true);
  246. std::vector<uint8_t> message;
  247. Add(&queue, kPartialGMOn1st);
  248. queue.Get(&message);
  249. EXPECT_TRUE(message.empty());
  250. Add(&queue, kPartialGMOn2nd);
  251. queue.Get(&message);
  252. EXPECT_TRUE(message.empty());
  253. Add(&queue, kPartialNoteOn1st);
  254. queue.Get(&message);
  255. EXPECT_TRUE(message.empty());
  256. Add(&queue, kPartialGMOn3rd);
  257. queue.Get(&message);
  258. EXPECT_TRUE(message.empty());
  259. queue.Get(&message);
  260. EXPECT_TRUE(message.empty());
  261. }
  262. TEST(MidiMessageQueueTest, OneByteMessage) {
  263. MidiMessageQueue queue(true);
  264. std::vector<uint8_t> message;
  265. Add(&queue, kSystemCommonMessageTuneRequest);
  266. Add(&queue, kSystemCommonMessageTuneRequest);
  267. Add(&queue, kSystemCommonMessageTuneRequest);
  268. Add(&queue, kSystemCommonMessageTuneRequest);
  269. Add(&queue, kNoteOn);
  270. Add(&queue, kSystemCommonMessageTuneRequest);
  271. Add(&queue, kNoteOn);
  272. Add(&queue, kNoteOn);
  273. Add(&queue, kSystemCommonMessageTuneRequest);
  274. queue.Get(&message);
  275. EXPECT_MESSAGE(kSystemCommonMessageTuneRequest, message);
  276. queue.Get(&message);
  277. EXPECT_MESSAGE(kSystemCommonMessageTuneRequest, message);
  278. queue.Get(&message);
  279. EXPECT_MESSAGE(kSystemCommonMessageTuneRequest, message);
  280. queue.Get(&message);
  281. EXPECT_MESSAGE(kSystemCommonMessageTuneRequest, message);
  282. queue.Get(&message);
  283. EXPECT_MESSAGE(kNoteOn, message);
  284. queue.Get(&message);
  285. EXPECT_MESSAGE(kSystemCommonMessageTuneRequest, message);
  286. queue.Get(&message);
  287. EXPECT_MESSAGE(kNoteOn, message);
  288. queue.Get(&message);
  289. EXPECT_MESSAGE(kNoteOn, message);
  290. queue.Get(&message);
  291. EXPECT_MESSAGE(kSystemCommonMessageTuneRequest, message);
  292. queue.Get(&message);
  293. EXPECT_TRUE(message.empty());
  294. }
  295. TEST(MidiMessageQueueTest, OneByteMessageInjectedInNonSysExMessage) {
  296. MidiMessageQueue queue(true);
  297. std::vector<uint8_t> message;
  298. Add(&queue, kPartialNoteOn1st);
  299. queue.Get(&message);
  300. EXPECT_TRUE(message.empty());
  301. Add(&queue, kPartialNoteOn2nd);
  302. queue.Get(&message);
  303. EXPECT_TRUE(message.empty());
  304. Add(&queue, kSystemCommonMessageTuneRequest);
  305. queue.Get(&message);
  306. EXPECT_MESSAGE(kSystemCommonMessageTuneRequest, message);
  307. queue.Get(&message);
  308. EXPECT_TRUE(message.empty());
  309. Add(&queue, kPartialNoteOn3rd);
  310. queue.Get(&message);
  311. EXPECT_TRUE(message.empty());
  312. }
  313. TEST(MidiMessageQueueTest, OneByteMessageInjectedInSysExMessage) {
  314. MidiMessageQueue queue(true);
  315. std::vector<uint8_t> message;
  316. Add(&queue, kPartialGMOn1st);
  317. queue.Get(&message);
  318. EXPECT_TRUE(message.empty());
  319. Add(&queue, kPartialGMOn2nd);
  320. queue.Get(&message);
  321. EXPECT_TRUE(message.empty());
  322. Add(&queue, kSystemCommonMessageTuneRequest);
  323. queue.Get(&message);
  324. EXPECT_MESSAGE(kSystemCommonMessageTuneRequest, message);
  325. queue.Get(&message);
  326. EXPECT_TRUE(message.empty());
  327. Add(&queue, kPartialGMOn3rd);
  328. queue.Get(&message);
  329. EXPECT_TRUE(message.empty());
  330. }
  331. TEST(MidiMessageQueueTest, ReservedMessage) {
  332. MidiMessageQueue queue(true);
  333. std::vector<uint8_t> message;
  334. Add(&queue, kReservedMessage1);
  335. Add(&queue, kNoteOn);
  336. Add(&queue, kReservedMessage2);
  337. Add(&queue, kNoteOn);
  338. Add(&queue, kReservedMessage1WithDataBytes);
  339. Add(&queue, kNoteOn);
  340. Add(&queue, kReservedMessage2);
  341. Add(&queue, kReservedMessage1WithDataBytes);
  342. Add(&queue, kNoteOn);
  343. Add(&queue, kReservedMessage1WithDataBytes);
  344. Add(&queue, kReservedMessage2);
  345. Add(&queue, kNoteOn);
  346. queue.Get(&message);
  347. EXPECT_MESSAGE(kNoteOn, message);
  348. queue.Get(&message);
  349. EXPECT_MESSAGE(kNoteOn, message);
  350. queue.Get(&message);
  351. EXPECT_MESSAGE(kNoteOn, message);
  352. queue.Get(&message);
  353. EXPECT_MESSAGE(kNoteOn, message);
  354. queue.Get(&message);
  355. EXPECT_MESSAGE(kNoteOn, message);
  356. Add(&queue, kReservedMessage1);
  357. queue.Get(&message);
  358. EXPECT_TRUE(message.empty());
  359. queue.Get(&message);
  360. EXPECT_TRUE(message.empty());
  361. Add(&queue, kNoteOn);
  362. queue.Get(&message);
  363. EXPECT_MESSAGE(kNoteOn, message);
  364. queue.Get(&message);
  365. EXPECT_TRUE(message.empty());
  366. Add(&queue, kReservedMessage2);
  367. queue.Get(&message);
  368. EXPECT_TRUE(message.empty());
  369. queue.Get(&message);
  370. EXPECT_TRUE(message.empty());
  371. Add(&queue, kNoteOn);
  372. queue.Get(&message);
  373. EXPECT_MESSAGE(kNoteOn, message);
  374. queue.Get(&message);
  375. EXPECT_TRUE(message.empty());
  376. Add(&queue, kReservedMessage1WithDataBytes);
  377. queue.Get(&message);
  378. EXPECT_TRUE(message.empty());
  379. queue.Get(&message);
  380. EXPECT_TRUE(message.empty());
  381. Add(&queue, kNoteOn);
  382. queue.Get(&message);
  383. EXPECT_MESSAGE(kNoteOn, message);
  384. queue.Get(&message);
  385. EXPECT_TRUE(message.empty());
  386. Add(&queue, kReservedMessage2);
  387. Add(&queue, kReservedMessage1WithDataBytes);
  388. queue.Get(&message);
  389. EXPECT_TRUE(message.empty());
  390. queue.Get(&message);
  391. EXPECT_TRUE(message.empty());
  392. Add(&queue, kNoteOn);
  393. queue.Get(&message);
  394. EXPECT_MESSAGE(kNoteOn, message);
  395. queue.Get(&message);
  396. EXPECT_TRUE(message.empty());
  397. Add(&queue, kReservedMessage1WithDataBytes);
  398. Add(&queue, kReservedMessage2);
  399. queue.Get(&message);
  400. EXPECT_TRUE(message.empty());
  401. queue.Get(&message);
  402. EXPECT_TRUE(message.empty());
  403. Add(&queue, kNoteOn);
  404. queue.Get(&message);
  405. EXPECT_MESSAGE(kNoteOn, message);
  406. queue.Get(&message);
  407. EXPECT_TRUE(message.empty());
  408. }
  409. TEST(MidiMessageQueueTest, ReservedMessageInjectedInNonSysExMessage) {
  410. MidiMessageQueue queue(true);
  411. std::vector<uint8_t> message;
  412. // Inject |kReservedMessage1|
  413. Add(&queue, kPartialNoteOn1st);
  414. queue.Get(&message);
  415. EXPECT_TRUE(message.empty());
  416. Add(&queue, kPartialNoteOn2nd);
  417. queue.Get(&message);
  418. EXPECT_TRUE(message.empty());
  419. Add(&queue, kReservedMessage1);
  420. queue.Get(&message);
  421. EXPECT_TRUE(message.empty());
  422. Add(&queue, kPartialNoteOn3rd);
  423. queue.Get(&message);
  424. EXPECT_TRUE(message.empty());
  425. // Inject |kReservedMessage2|
  426. Add(&queue, kPartialNoteOn1st);
  427. queue.Get(&message);
  428. EXPECT_TRUE(message.empty());
  429. Add(&queue, kPartialNoteOn2nd);
  430. queue.Get(&message);
  431. EXPECT_TRUE(message.empty());
  432. Add(&queue, kReservedMessage2);
  433. queue.Get(&message);
  434. EXPECT_TRUE(message.empty());
  435. Add(&queue, kPartialNoteOn3rd);
  436. queue.Get(&message);
  437. EXPECT_TRUE(message.empty());
  438. // Inject |kReservedMessage1WithDataBytes|
  439. Add(&queue, kPartialNoteOn1st);
  440. queue.Get(&message);
  441. EXPECT_TRUE(message.empty());
  442. Add(&queue, kPartialNoteOn2nd);
  443. queue.Get(&message);
  444. EXPECT_TRUE(message.empty());
  445. Add(&queue, kReservedMessage1WithDataBytes);
  446. queue.Get(&message);
  447. EXPECT_TRUE(message.empty());
  448. Add(&queue, kPartialNoteOn3rd);
  449. queue.Get(&message);
  450. EXPECT_TRUE(message.empty());
  451. }
  452. TEST(MidiMessageQueueTest, ReservedMessageInjectedInSysExMessage) {
  453. MidiMessageQueue queue(true);
  454. std::vector<uint8_t> message;
  455. // Inject |kReservedMessage1|
  456. Add(&queue, kPartialGMOn1st);
  457. queue.Get(&message);
  458. EXPECT_TRUE(message.empty());
  459. Add(&queue, kPartialGMOn2nd);
  460. queue.Get(&message);
  461. EXPECT_TRUE(message.empty());
  462. Add(&queue, kReservedMessage1);
  463. queue.Get(&message);
  464. EXPECT_TRUE(message.empty());
  465. Add(&queue, kPartialGMOn3rd);
  466. queue.Get(&message);
  467. EXPECT_TRUE(message.empty());
  468. // Inject |kReservedMessage2|
  469. Add(&queue, kPartialGMOn1st);
  470. queue.Get(&message);
  471. EXPECT_TRUE(message.empty());
  472. Add(&queue, kPartialGMOn2nd);
  473. queue.Get(&message);
  474. EXPECT_TRUE(message.empty());
  475. Add(&queue, kReservedMessage2);
  476. queue.Get(&message);
  477. EXPECT_TRUE(message.empty());
  478. Add(&queue, kPartialGMOn3rd);
  479. queue.Get(&message);
  480. EXPECT_TRUE(message.empty());
  481. // Inject |kReservedMessage1WithDataBytes|
  482. Add(&queue, kPartialGMOn1st);
  483. queue.Get(&message);
  484. EXPECT_TRUE(message.empty());
  485. Add(&queue, kPartialGMOn2nd);
  486. queue.Get(&message);
  487. EXPECT_TRUE(message.empty());
  488. Add(&queue, kReservedMessage1WithDataBytes);
  489. queue.Get(&message);
  490. EXPECT_TRUE(message.empty());
  491. Add(&queue, kPartialGMOn3rd);
  492. queue.Get(&message);
  493. EXPECT_TRUE(message.empty());
  494. }
  495. } // namespace
  496. } // namespace midi