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