sequencer_tests.cpp 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592
  1. /* Copyright 2020 Rodolphe Belouin
  2. *
  3. * This program is free software: you can redistribute it and/or modify
  4. * it under the terms of the GNU General Public License as published by
  5. * the Free Software Foundation, either version 2 of the License, or
  6. * (at your option) any later version.
  7. *
  8. * This program is distributed in the hope that it will be useful,
  9. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. * GNU General Public License for more details.
  12. *
  13. * You should have received a copy of the GNU General Public License
  14. * along with this program. If not, see <http://www.gnu.org/licenses/>.
  15. */
  16. #include "gtest/gtest.h"
  17. extern "C" {
  18. #include "sequencer.h"
  19. #include "midi_mock.h"
  20. #include "quantum/quantum_keycodes.h"
  21. }
  22. extern "C" {
  23. void set_time(uint32_t t);
  24. void advance_time(uint32_t ms);
  25. }
  26. class SequencerTest : public ::testing::Test {
  27. protected:
  28. void SetUp() override {
  29. config_copy.enabled = sequencer_config.enabled;
  30. for (int i = 0; i < SEQUENCER_STEPS; i++) {
  31. config_copy.steps[i] = sequencer_config.steps[i];
  32. }
  33. for (int i = 0; i < SEQUENCER_TRACKS; i++) {
  34. config_copy.track_notes[i] = sequencer_config.track_notes[i];
  35. }
  36. config_copy.tempo = sequencer_config.tempo;
  37. config_copy.resolution = sequencer_config.resolution;
  38. state_copy.active_tracks = sequencer_internal_state.active_tracks;
  39. state_copy.current_track = sequencer_internal_state.current_track;
  40. state_copy.current_step = sequencer_internal_state.current_step;
  41. state_copy.timer = sequencer_internal_state.timer;
  42. last_noteon = 0;
  43. last_noteoff = 0;
  44. set_time(0);
  45. }
  46. void TearDown() override {
  47. sequencer_config.enabled = config_copy.enabled;
  48. for (int i = 0; i < SEQUENCER_STEPS; i++) {
  49. sequencer_config.steps[i] = config_copy.steps[i];
  50. }
  51. for (int i = 0; i < SEQUENCER_TRACKS; i++) {
  52. sequencer_config.track_notes[i] = config_copy.track_notes[i];
  53. }
  54. sequencer_config.tempo = config_copy.tempo;
  55. sequencer_config.resolution = config_copy.resolution;
  56. sequencer_internal_state.active_tracks = state_copy.active_tracks;
  57. sequencer_internal_state.current_track = state_copy.current_track;
  58. sequencer_internal_state.current_step = state_copy.current_step;
  59. sequencer_internal_state.timer = state_copy.timer;
  60. }
  61. sequencer_config_t config_copy;
  62. sequencer_state_t state_copy;
  63. };
  64. TEST_F(SequencerTest, TestOffByDefault) {
  65. EXPECT_EQ(is_sequencer_on(), false);
  66. }
  67. TEST_F(SequencerTest, TestOn) {
  68. sequencer_config.enabled = false;
  69. sequencer_on();
  70. EXPECT_EQ(is_sequencer_on(), true);
  71. // sequencer_on is idempotent
  72. sequencer_on();
  73. EXPECT_EQ(is_sequencer_on(), true);
  74. }
  75. TEST_F(SequencerTest, TestOff) {
  76. sequencer_config.enabled = true;
  77. sequencer_off();
  78. EXPECT_EQ(is_sequencer_on(), false);
  79. // sequencer_off is idempotent
  80. sequencer_off();
  81. EXPECT_EQ(is_sequencer_on(), false);
  82. }
  83. TEST_F(SequencerTest, TestToggle) {
  84. sequencer_config.enabled = false;
  85. sequencer_toggle();
  86. EXPECT_EQ(is_sequencer_on(), true);
  87. sequencer_toggle();
  88. EXPECT_EQ(is_sequencer_on(), false);
  89. }
  90. TEST_F(SequencerTest, TestNoActiveTrackByDefault) {
  91. for (int i = 0; i < SEQUENCER_TRACKS; i++) {
  92. EXPECT_EQ(is_sequencer_track_active(i), false);
  93. }
  94. }
  95. TEST_F(SequencerTest, TestGetActiveTracks) {
  96. sequencer_internal_state.active_tracks = (1 << 7) + (1 << 6) + (1 << 3) + (1 << 1) + (1 << 0);
  97. EXPECT_EQ(is_sequencer_track_active(0), true);
  98. EXPECT_EQ(is_sequencer_track_active(1), true);
  99. EXPECT_EQ(is_sequencer_track_active(2), false);
  100. EXPECT_EQ(is_sequencer_track_active(3), true);
  101. EXPECT_EQ(is_sequencer_track_active(4), false);
  102. EXPECT_EQ(is_sequencer_track_active(5), false);
  103. EXPECT_EQ(is_sequencer_track_active(6), true);
  104. EXPECT_EQ(is_sequencer_track_active(7), true);
  105. }
  106. TEST_F(SequencerTest, TestGetActiveTracksOutOfBound) {
  107. sequencer_set_track_activation(-1, true);
  108. sequencer_set_track_activation(8, true);
  109. EXPECT_EQ(is_sequencer_track_active(-1), false);
  110. EXPECT_EQ(is_sequencer_track_active(8), false);
  111. }
  112. TEST_F(SequencerTest, TestToggleTrackActivation) {
  113. sequencer_internal_state.active_tracks = (1 << 7) + (1 << 6) + (1 << 3) + (1 << 1) + (1 << 0);
  114. sequencer_toggle_track_activation(6);
  115. EXPECT_EQ(is_sequencer_track_active(0), true);
  116. EXPECT_EQ(is_sequencer_track_active(1), true);
  117. EXPECT_EQ(is_sequencer_track_active(2), false);
  118. EXPECT_EQ(is_sequencer_track_active(3), true);
  119. EXPECT_EQ(is_sequencer_track_active(4), false);
  120. EXPECT_EQ(is_sequencer_track_active(5), false);
  121. EXPECT_EQ(is_sequencer_track_active(6), false);
  122. EXPECT_EQ(is_sequencer_track_active(7), true);
  123. }
  124. TEST_F(SequencerTest, TestToggleSingleTrackActivation) {
  125. sequencer_internal_state.active_tracks = (1 << 7) + (1 << 6) + (1 << 3) + (1 << 1) + (1 << 0);
  126. sequencer_toggle_single_active_track(2);
  127. EXPECT_EQ(is_sequencer_track_active(0), false);
  128. EXPECT_EQ(is_sequencer_track_active(1), false);
  129. EXPECT_EQ(is_sequencer_track_active(2), true);
  130. EXPECT_EQ(is_sequencer_track_active(3), false);
  131. EXPECT_EQ(is_sequencer_track_active(4), false);
  132. EXPECT_EQ(is_sequencer_track_active(5), false);
  133. EXPECT_EQ(is_sequencer_track_active(6), false);
  134. EXPECT_EQ(is_sequencer_track_active(7), false);
  135. }
  136. TEST_F(SequencerTest, TestStepOffByDefault) {
  137. for (int i = 0; i < SEQUENCER_STEPS; i++) {
  138. EXPECT_EQ(is_sequencer_step_on(i), false);
  139. }
  140. }
  141. TEST_F(SequencerTest, TestIsStepOffWithNoActiveTracks) {
  142. sequencer_config.steps[3] = 0xFF;
  143. EXPECT_EQ(is_sequencer_step_on(3), false);
  144. }
  145. TEST_F(SequencerTest, TestIsStepOffWithGivenActiveTracks) {
  146. sequencer_set_track_activation(2, true);
  147. sequencer_set_track_activation(3, true);
  148. sequencer_config.steps[3] = (1 << 0) + (1 << 1);
  149. // No active tracks have the step enabled, so it is off
  150. EXPECT_EQ(is_sequencer_step_on(3), false);
  151. }
  152. TEST_F(SequencerTest, TestIsStepOnWithGivenActiveTracks) {
  153. sequencer_set_track_activation(2, true);
  154. sequencer_set_track_activation(3, true);
  155. sequencer_config.steps[3] = (1 << 2);
  156. // Track 2 has the step enabled, so it is on
  157. EXPECT_EQ(is_sequencer_step_on(3), true);
  158. }
  159. TEST_F(SequencerTest, TestIsStepOffForGivenTrack) {
  160. sequencer_config.steps[3] = 0x00;
  161. EXPECT_EQ(is_sequencer_step_on_for_track(3, 5), false);
  162. }
  163. TEST_F(SequencerTest, TestIsStepOnForGivenTrack) {
  164. sequencer_config.steps[3] = (1 << 5);
  165. EXPECT_EQ(is_sequencer_step_on_for_track(3, 5), true);
  166. }
  167. TEST_F(SequencerTest, TestSetStepOn) {
  168. sequencer_internal_state.active_tracks = (1 << 6) + (1 << 3) + (1 << 2);
  169. sequencer_config.steps[2] = (1 << 5) + (1 << 2);
  170. sequencer_set_step(2, true);
  171. EXPECT_EQ(sequencer_config.steps[2], (1 << 6) + (1 << 5) + (1 << 3) + (1 << 2));
  172. }
  173. TEST_F(SequencerTest, TestSetStepOff) {
  174. sequencer_internal_state.active_tracks = (1 << 6) + (1 << 3) + (1 << 2);
  175. sequencer_config.steps[2] = (1 << 5) + (1 << 2);
  176. sequencer_set_step(2, false);
  177. EXPECT_EQ(sequencer_config.steps[2], (1 << 5));
  178. }
  179. TEST_F(SequencerTest, TestToggleStepOff) {
  180. sequencer_internal_state.active_tracks = (1 << 6) + (1 << 3) + (1 << 2);
  181. sequencer_config.steps[2] = (1 << 5) + (1 << 2);
  182. sequencer_toggle_step(2);
  183. EXPECT_EQ(sequencer_config.steps[2], (1 << 5));
  184. }
  185. TEST_F(SequencerTest, TestToggleStepOn) {
  186. sequencer_internal_state.active_tracks = (1 << 6) + (1 << 3) + (1 << 2);
  187. sequencer_config.steps[2] = 0;
  188. sequencer_toggle_step(2);
  189. EXPECT_EQ(sequencer_config.steps[2], (1 << 6) + (1 << 3) + (1 << 2));
  190. }
  191. TEST_F(SequencerTest, TestSetAllStepsOn) {
  192. sequencer_internal_state.active_tracks = (1 << 6) + (1 << 3) + (1 << 2);
  193. sequencer_config.steps[2] = (1 << 7) + (1 << 6);
  194. sequencer_config.steps[4] = (1 << 3) + (1 << 1);
  195. sequencer_set_all_steps(true);
  196. EXPECT_EQ(sequencer_config.steps[2], (1 << 7) + (1 << 6) + (1 << 3) + (1 << 2));
  197. EXPECT_EQ(sequencer_config.steps[4], (1 << 6) + (1 << 3) + (1 << 2) + (1 << 1));
  198. }
  199. TEST_F(SequencerTest, TestSetAllStepsOff) {
  200. sequencer_internal_state.active_tracks = (1 << 6) + (1 << 3) + (1 << 2);
  201. sequencer_config.steps[2] = (1 << 7) + (1 << 6);
  202. sequencer_config.steps[4] = (1 << 3) + (1 << 1);
  203. sequencer_set_all_steps(false);
  204. EXPECT_EQ(sequencer_config.steps[2], (1 << 7));
  205. EXPECT_EQ(sequencer_config.steps[4], (1 << 1));
  206. }
  207. TEST_F(SequencerTest, TestSetTempoZero) {
  208. sequencer_config.tempo = 123;
  209. sequencer_set_tempo(0);
  210. EXPECT_EQ(sequencer_config.tempo, 123);
  211. }
  212. TEST_F(SequencerTest, TestIncreaseTempoMax) {
  213. sequencer_config.tempo = UINT8_MAX;
  214. sequencer_increase_tempo();
  215. EXPECT_EQ(sequencer_config.tempo, UINT8_MAX);
  216. }
  217. TEST_F(SequencerTest, TestSetResolutionLowerBound) {
  218. sequencer_config.resolution = SQ_RES_4;
  219. sequencer_set_resolution((sequencer_resolution_t)-1);
  220. EXPECT_EQ(sequencer_config.resolution, SQ_RES_4);
  221. }
  222. TEST_F(SequencerTest, TestSetResolutionUpperBound) {
  223. sequencer_config.resolution = SQ_RES_4;
  224. sequencer_set_resolution(SEQUENCER_RESOLUTIONS);
  225. EXPECT_EQ(sequencer_config.resolution, SQ_RES_4);
  226. }
  227. TEST_F(SequencerTest, TestGetBeatDuration) {
  228. EXPECT_EQ(get_beat_duration(60), 1000);
  229. EXPECT_EQ(get_beat_duration(120), 500);
  230. EXPECT_EQ(get_beat_duration(240), 250);
  231. EXPECT_EQ(get_beat_duration(0), 1000);
  232. }
  233. TEST_F(SequencerTest, TestGetStepDuration60) {
  234. /**
  235. * Resolution cheatsheet:
  236. * 1/2 => 2 steps per 4 beats
  237. * 1/2T => 3 steps per 4 beats
  238. * 1/4 => 4 steps per 4 beats
  239. * 1/4T => 6 steps per 4 beats
  240. * 1/8 => 8 steps per 4 beats
  241. * 1/8T => 12 steps per 4 beats
  242. * 1/16 => 16 steps per 4 beats
  243. * 1/16T => 24 steps per 4 beats
  244. * 1/32 => 32 steps per 4 beats
  245. *
  246. * The number of steps for binary resolutions follows the powers of 2.
  247. * The ternary variants are simply 1.5x faster.
  248. */
  249. EXPECT_EQ(get_step_duration(60, SQ_RES_2), 2000);
  250. EXPECT_EQ(get_step_duration(60, SQ_RES_4), 1000);
  251. EXPECT_EQ(get_step_duration(60, SQ_RES_8), 500);
  252. EXPECT_EQ(get_step_duration(60, SQ_RES_16), 250);
  253. EXPECT_EQ(get_step_duration(60, SQ_RES_32), 125);
  254. EXPECT_EQ(get_step_duration(60, SQ_RES_2T), 1333);
  255. EXPECT_EQ(get_step_duration(60, SQ_RES_4T), 666);
  256. EXPECT_EQ(get_step_duration(60, SQ_RES_8T), 333);
  257. EXPECT_EQ(get_step_duration(60, SQ_RES_16T), 166);
  258. }
  259. TEST_F(SequencerTest, TestGetStepDuration120) {
  260. /**
  261. * Resolution cheatsheet:
  262. * 1/2 => 2 steps per 4 beats
  263. * 1/2T => 3 steps per 4 beats
  264. * 1/4 => 4 steps per 4 beats
  265. * 1/4T => 6 steps per 4 beats
  266. * 1/8 => 8 steps per 4 beats
  267. * 1/8T => 12 steps per 4 beats
  268. * 1/16 => 16 steps per 4 beats
  269. * 1/16T => 24 steps per 4 beats
  270. * 1/32 => 32 steps per 4 beats
  271. *
  272. * The number of steps for binary resolutions follows the powers of 2.
  273. * The ternary variants are simply 1.5x faster.
  274. */
  275. EXPECT_EQ(get_step_duration(30, SQ_RES_2), 4000);
  276. EXPECT_EQ(get_step_duration(30, SQ_RES_4), 2000);
  277. EXPECT_EQ(get_step_duration(30, SQ_RES_8), 1000);
  278. EXPECT_EQ(get_step_duration(30, SQ_RES_16), 500);
  279. EXPECT_EQ(get_step_duration(30, SQ_RES_32), 250);
  280. EXPECT_EQ(get_step_duration(30, SQ_RES_2T), 2666);
  281. EXPECT_EQ(get_step_duration(30, SQ_RES_4T), 1333);
  282. EXPECT_EQ(get_step_duration(30, SQ_RES_8T), 666);
  283. EXPECT_EQ(get_step_duration(30, SQ_RES_16T), 333);
  284. }
  285. void setUpMatrixScanSequencerTest(void) {
  286. sequencer_config.enabled = true;
  287. sequencer_config.tempo = 120;
  288. sequencer_config.resolution = SQ_RES_16;
  289. // Configure the notes for each track
  290. sequencer_config.track_notes[0] = QK_MIDI_NOTE_C_0;
  291. sequencer_config.track_notes[1] = QK_MIDI_NOTE_D_0;
  292. sequencer_config.track_notes[2] = QK_MIDI_NOTE_E_0;
  293. sequencer_config.track_notes[3] = QK_MIDI_NOTE_F_0;
  294. sequencer_config.track_notes[4] = QK_MIDI_NOTE_G_0;
  295. sequencer_config.track_notes[5] = QK_MIDI_NOTE_A_0;
  296. sequencer_config.track_notes[6] = QK_MIDI_NOTE_B_0;
  297. sequencer_config.track_notes[7] = QK_MIDI_NOTE_C_0;
  298. // Turn on some steps
  299. sequencer_config.steps[0] = (1 << 0);
  300. sequencer_config.steps[2] = (1 << 1) + (1 << 0);
  301. }
  302. TEST_F(SequencerTest, TestMatrixScanSequencerShouldAttackFirstTrackOfFirstStep) {
  303. setUpMatrixScanSequencerTest();
  304. sequencer_task();
  305. EXPECT_EQ(last_noteon, QK_MIDI_NOTE_C_0);
  306. EXPECT_EQ(last_noteoff, 0);
  307. }
  308. TEST_F(SequencerTest, TestMatrixScanSequencerShouldAttackSecondTrackAfterFirstTrackOfFirstStep) {
  309. setUpMatrixScanSequencerTest();
  310. sequencer_task();
  311. EXPECT_EQ(sequencer_internal_state.current_step, 0);
  312. EXPECT_EQ(sequencer_internal_state.current_track, 1);
  313. EXPECT_EQ(sequencer_internal_state.phase, SEQUENCER_PHASE_ATTACK);
  314. }
  315. TEST_F(SequencerTest, TestMatrixScanSequencerShouldNotAttackInactiveTrackFirstStep) {
  316. setUpMatrixScanSequencerTest();
  317. sequencer_internal_state.current_step = 0;
  318. sequencer_internal_state.current_track = 1;
  319. // Wait some time after the first track has been attacked
  320. advance_time(SEQUENCER_TRACK_THROTTLE);
  321. sequencer_task();
  322. EXPECT_EQ(last_noteon, 0);
  323. EXPECT_EQ(last_noteoff, 0);
  324. }
  325. TEST_F(SequencerTest, TestMatrixScanSequencerShouldAttackThirdTrackAfterSecondTrackOfFirstStep) {
  326. setUpMatrixScanSequencerTest();
  327. sequencer_internal_state.current_step = 0;
  328. sequencer_internal_state.current_track = 1;
  329. // Wait some time after the second track has been attacked
  330. advance_time(2 * SEQUENCER_TRACK_THROTTLE);
  331. sequencer_task();
  332. EXPECT_EQ(sequencer_internal_state.current_step, 0);
  333. EXPECT_EQ(sequencer_internal_state.current_track, 2);
  334. EXPECT_EQ(sequencer_internal_state.phase, SEQUENCER_PHASE_ATTACK);
  335. }
  336. TEST_F(SequencerTest, TestMatrixScanSequencerShouldEnterReleasePhaseAfterLastTrackHasBeenProcessedFirstStep) {
  337. setUpMatrixScanSequencerTest();
  338. sequencer_internal_state.current_step = 0;
  339. sequencer_internal_state.current_track = SEQUENCER_TRACKS - 1;
  340. // Wait until all notes have been attacked
  341. advance_time((SEQUENCER_TRACKS - 1) * SEQUENCER_TRACK_THROTTLE);
  342. sequencer_task();
  343. EXPECT_EQ(last_noteon, 0);
  344. EXPECT_EQ(last_noteoff, 0);
  345. EXPECT_EQ(sequencer_internal_state.current_step, 0);
  346. EXPECT_EQ(sequencer_internal_state.current_track, SEQUENCER_TRACKS - 1);
  347. EXPECT_EQ(sequencer_internal_state.phase, SEQUENCER_PHASE_RELEASE);
  348. }
  349. TEST_F(SequencerTest, TestMatrixScanSequencerShouldReleaseBackwards) {
  350. setUpMatrixScanSequencerTest();
  351. sequencer_internal_state.current_step = 0;
  352. sequencer_internal_state.current_track = SEQUENCER_TRACKS - 1;
  353. sequencer_internal_state.phase = SEQUENCER_PHASE_RELEASE;
  354. // Wait until all notes have been attacked
  355. advance_time((SEQUENCER_TRACKS - 1) * SEQUENCER_TRACK_THROTTLE);
  356. // + the release timeout
  357. advance_time(SEQUENCER_PHASE_RELEASE_TIMEOUT);
  358. sequencer_task();
  359. EXPECT_EQ(sequencer_internal_state.current_step, 0);
  360. EXPECT_EQ(sequencer_internal_state.current_track, SEQUENCER_TRACKS - 2);
  361. EXPECT_EQ(sequencer_internal_state.phase, SEQUENCER_PHASE_RELEASE);
  362. }
  363. TEST_F(SequencerTest, TestMatrixScanSequencerShouldNotReleaseInactiveTrackFirstStep) {
  364. setUpMatrixScanSequencerTest();
  365. sequencer_internal_state.current_step = 0;
  366. sequencer_internal_state.current_track = SEQUENCER_TRACKS - 1;
  367. sequencer_internal_state.phase = SEQUENCER_PHASE_RELEASE;
  368. // Wait until all notes have been attacked
  369. advance_time((SEQUENCER_TRACKS - 1) * SEQUENCER_TRACK_THROTTLE);
  370. // + the release timeout
  371. advance_time(SEQUENCER_PHASE_RELEASE_TIMEOUT);
  372. sequencer_task();
  373. EXPECT_EQ(last_noteon, 0);
  374. EXPECT_EQ(last_noteoff, 0);
  375. }
  376. TEST_F(SequencerTest, TestMatrixScanSequencerShouldReleaseFirstTrackFirstStep) {
  377. setUpMatrixScanSequencerTest();
  378. sequencer_internal_state.current_step = 0;
  379. sequencer_internal_state.current_track = 0;
  380. sequencer_internal_state.phase = SEQUENCER_PHASE_RELEASE;
  381. // Wait until all notes have been attacked
  382. advance_time((SEQUENCER_TRACKS - 1) * SEQUENCER_TRACK_THROTTLE);
  383. // + the release timeout
  384. advance_time(SEQUENCER_PHASE_RELEASE_TIMEOUT);
  385. // + all the other notes have been released
  386. advance_time((SEQUENCER_TRACKS - 1) * SEQUENCER_TRACK_THROTTLE);
  387. sequencer_task();
  388. EXPECT_EQ(last_noteon, 0);
  389. EXPECT_EQ(last_noteoff, QK_MIDI_NOTE_C_0);
  390. }
  391. TEST_F(SequencerTest, TestMatrixScanSequencerShouldEnterPausePhaseAfterRelease) {
  392. setUpMatrixScanSequencerTest();
  393. sequencer_internal_state.current_step = 0;
  394. sequencer_internal_state.current_track = 0;
  395. sequencer_internal_state.phase = SEQUENCER_PHASE_RELEASE;
  396. // Wait until all notes have been attacked
  397. advance_time((SEQUENCER_TRACKS - 1) * SEQUENCER_TRACK_THROTTLE);
  398. // + the release timeout
  399. advance_time(SEQUENCER_PHASE_RELEASE_TIMEOUT);
  400. // + all the other notes have been released
  401. advance_time((SEQUENCER_TRACKS - 1) * SEQUENCER_TRACK_THROTTLE);
  402. sequencer_task();
  403. EXPECT_EQ(sequencer_internal_state.current_step, 0);
  404. EXPECT_EQ(sequencer_internal_state.current_track, 0);
  405. EXPECT_EQ(sequencer_internal_state.phase, SEQUENCER_PHASE_PAUSE);
  406. }
  407. TEST_F(SequencerTest, TestMatrixScanSequencerShouldProcessFirstTrackOfSecondStepAfterPause) {
  408. setUpMatrixScanSequencerTest();
  409. sequencer_internal_state.current_step = 0;
  410. sequencer_internal_state.current_track = 0;
  411. sequencer_internal_state.phase = SEQUENCER_PHASE_PAUSE;
  412. // Wait until all notes have been attacked
  413. advance_time((SEQUENCER_TRACKS - 1) * SEQUENCER_TRACK_THROTTLE);
  414. // + the release timeout
  415. advance_time(SEQUENCER_PHASE_RELEASE_TIMEOUT);
  416. // + all the other notes have been released
  417. advance_time((SEQUENCER_TRACKS - 1) * SEQUENCER_TRACK_THROTTLE);
  418. // + the step duration (one 16th at tempo=120 lasts 125ms)
  419. advance_time(125);
  420. sequencer_task();
  421. EXPECT_EQ(sequencer_internal_state.current_step, 1);
  422. EXPECT_EQ(sequencer_internal_state.current_track, 1);
  423. EXPECT_EQ(sequencer_internal_state.phase, SEQUENCER_PHASE_ATTACK);
  424. }
  425. TEST_F(SequencerTest, TestMatrixScanSequencerShouldProcessSecondTrackTooEarly) {
  426. setUpMatrixScanSequencerTest();
  427. sequencer_internal_state.current_step = 2;
  428. sequencer_internal_state.current_track = 1;
  429. sequencer_task();
  430. EXPECT_EQ(last_noteon, 0);
  431. EXPECT_EQ(last_noteoff, 0);
  432. }
  433. TEST_F(SequencerTest, TestMatrixScanSequencerShouldProcessSecondTrackOnTime) {
  434. setUpMatrixScanSequencerTest();
  435. sequencer_internal_state.current_step = 2;
  436. sequencer_internal_state.current_track = 1;
  437. // Wait until first track has been attacked
  438. advance_time(SEQUENCER_TRACK_THROTTLE);
  439. sequencer_task();
  440. EXPECT_EQ(last_noteon, QK_MIDI_NOTE_D_0);
  441. EXPECT_EQ(last_noteoff, 0);
  442. }
  443. TEST_F(SequencerTest, TestMatrixScanSequencerShouldLoopOnceSequenceIsOver) {
  444. setUpMatrixScanSequencerTest();
  445. sequencer_internal_state.current_step = SEQUENCER_STEPS - 1;
  446. sequencer_internal_state.current_track = 0;
  447. sequencer_internal_state.phase = SEQUENCER_PHASE_PAUSE;
  448. // Wait until all notes have been attacked
  449. advance_time((SEQUENCER_TRACKS - 1) * SEQUENCER_TRACK_THROTTLE);
  450. // + the release timeout
  451. advance_time(SEQUENCER_PHASE_RELEASE_TIMEOUT);
  452. // + all the other notes have been released
  453. advance_time((SEQUENCER_TRACKS - 1) * SEQUENCER_TRACK_THROTTLE);
  454. // + the step duration (one 16th at tempo=120 lasts 125ms)
  455. advance_time(125);
  456. sequencer_task();
  457. EXPECT_EQ(sequencer_internal_state.current_step, 0);
  458. EXPECT_EQ(sequencer_internal_state.current_track, 1);
  459. EXPECT_EQ(sequencer_internal_state.phase, SEQUENCER_PHASE_ATTACK);
  460. }