diff --git a/lib_xua/src/midi/queue.h b/lib_xua/src/midi/queue.h index b056c309..3e51b328 100644 --- a/lib_xua/src/midi/queue.h +++ b/lib_xua/src/midi/queue.h @@ -1,4 +1,4 @@ -// Copyright 2013-2021 XMOS LIMITED. +// Copyright 2013-2024 XMOS LIMITED. // This Software is subject to the terms of the XMOS Public Licence: Version 1. #ifndef QUEUE_H_ #define QUEUE_H_ diff --git a/tests/xua_unit_tests/src/test_midi_parse/test_midi_parse.c b/tests/xua_unit_tests/src/test_midi_parse/test_midi_parse.c index 89989429..e99e8115 100644 --- a/tests/xua_unit_tests/src/test_midi_parse/test_midi_parse.c +++ b/tests/xua_unit_tests/src/test_midi_parse/test_midi_parse.c @@ -29,22 +29,22 @@ unsigned mini_in_parse_ut(unsigned midi[3]){ struct midi_in_parse_state m_state; void * mips = &m_state; - reset_midi_state_wrap(mips); + reset_midi_state_c_wrapper(mips); unsigned valid = 0; unsigned packed = 0; - midi_in_parse_wrap(mips, CABLE_NUM, midi[0], &valid, &packed); + midi_in_parse_c_wrapper(mips, CABLE_NUM, midi[0], &valid, &packed); // printf("Valid: %d data: %u\n", valid, packed); if(valid){ return packed; } - midi_in_parse_wrap(mips, CABLE_NUM, midi[1], &valid, &packed); + midi_in_parse_c_wrapper(mips, CABLE_NUM, midi[1], &valid, &packed); // printf("Valid: %d data: %u\n", valid, packed); if(valid){ return packed; } - midi_in_parse_wrap(mips, CABLE_NUM, midi[2], &valid, &packed); + midi_in_parse_c_wrapper(mips, CABLE_NUM, midi[2], &valid, &packed); // printf("Valid: %d data: %u\n", valid, packed); if(valid){ return packed; @@ -56,14 +56,14 @@ unsigned mini_in_parse_ut(unsigned midi[3]){ unsigned rndm = RANDOM_SEED; -void test_note(void) { +void test_midi_note(void) { for(int cmd = NOTE_OFF; cmd < NOTE_ON + NUM_CHANS; cmd++){ for(int test = 0; test < NUM_TESTS_PER_TEST; test++){ unsigned midi_ref[3] = {cmd, random(&rndm) & DATA_MASK, random(&rndm) & DATA_MASK}; unsigned packed = mini_in_parse_ut(midi_ref); unsigned midi_dut[3] = {0}; unsigned size = 0; - midi_out_parse_wrap(packed, midi_dut, &size); + midi_out_parse_c_wrapper(packed, midi_dut, &size); // printf("size: %d data: 0x%x 0x%x 0x%x\n", size, midi_ref[0], midi_ref[1], midi_ref[2]); // printf("size: %d data: 0x%x 0x%x 0x%x\n", size, midi_dut[0], midi_dut[1], midi_dut[2]); //TEST_ASSERT_EQUAL_UINT32_ARRAY not working!? @@ -74,14 +74,14 @@ void test_note(void) { } } -void test_pressure(void) { +void test_midi_pressure(void) { for(int cmd = PRESSURE; cmd < PRESSURE + NUM_CHANS; cmd++){ for(int test = 0; test < NUM_TESTS_PER_TEST; test++){ unsigned midi_ref[3] = {cmd, random(&rndm) & DATA_MASK, random(&rndm) & DATA_MASK}; unsigned packed = mini_in_parse_ut(midi_ref); unsigned midi_dut[3] = {0}; unsigned size = 0; - midi_out_parse_wrap(packed, midi_dut, &size); + midi_out_parse_c_wrapper(packed, midi_dut, &size); // printf("size: %d data: 0x%x 0x%x 0x%x\n", size, midi_ref[0], midi_ref[1], midi_ref[2]); // printf("size: %d data: 0x%x 0x%x 0x%x\n", size, midi_dut[0], midi_dut[1], midi_dut[2]); //TEST_ASSERT_EQUAL_UINT32_ARRAY not working!? @@ -92,14 +92,14 @@ void test_pressure(void) { } } -void test_control(void) { +void test_midi_control(void) { for(int cmd = CONTROL; cmd < CONTROL + NUM_CHANS; cmd++){ for(int test = 0; test < NUM_TESTS_PER_TEST; test++){ unsigned midi_ref[3] = {cmd, random(&rndm) & DATA_MASK, random(&rndm) & DATA_MASK}; unsigned packed = mini_in_parse_ut(midi_ref); unsigned midi_dut[3] = {0}; unsigned size = 0; - midi_out_parse_wrap(packed, midi_dut, &size); + midi_out_parse_c_wrapper(packed, midi_dut, &size); // printf("size: %d data: 0x%x 0x%x 0x%x\n", size, midi_ref[0], midi_ref[1], midi_ref[2]); // printf("size: %d data: 0x%x 0x%x 0x%x\n", size, midi_dut[0], midi_dut[1], midi_dut[2]); //TEST_ASSERT_EQUAL_UINT32_ARRAY not working!? @@ -110,14 +110,14 @@ void test_control(void) { } } -void test_program(void) { +void test_midi_program(void) { for(int cmd = PROGRAM; cmd < PROGRAM + NUM_CHANS; cmd++){ for(int test = 0; test < NUM_TESTS_PER_TEST; test++){ unsigned midi_ref[3] = {cmd, random(&rndm) & DATA_MASK, random(&rndm) & DATA_MASK}; unsigned packed = mini_in_parse_ut(midi_ref); unsigned midi_dut[3] = {0}; unsigned size = 0; - midi_out_parse_wrap(packed, midi_dut, &size); + midi_out_parse_c_wrapper(packed, midi_dut, &size); // printf("size: %d data: 0x%x 0x%x 0x%x\n", size, midi_ref[0], midi_ref[1], midi_ref[2]); // printf("size: %d data: 0x%x 0x%x 0x%x\n", size, midi_dut[0], midi_dut[1], midi_dut[2]); //TEST_ASSERT_EQUAL_UINT32_ARRAY not working!? @@ -128,14 +128,14 @@ void test_program(void) { } } -void test_pressure_val(void) { +void test_midi_pressure_val(void) { for(int cmd = PRESSURE_VAL; cmd < PRESSURE_VAL + NUM_CHANS; cmd++){ for(int test = 0; test < NUM_TESTS_PER_TEST; test++){ unsigned midi_ref[3] = {cmd, random(&rndm) & DATA_MASK, random(&rndm) & DATA_MASK}; unsigned packed = mini_in_parse_ut(midi_ref); unsigned midi_dut[3] = {0}; unsigned size = 0; - midi_out_parse_wrap(packed, midi_dut, &size); + midi_out_parse_c_wrapper(packed, midi_dut, &size); // printf("size: %d data: 0x%x 0x%x 0x%x\n", size, midi_ref[0], midi_ref[1], midi_ref[2]); // printf("size: %d data: 0x%x 0x%x 0x%x\n", size, midi_dut[0], midi_dut[1], midi_dut[2]); //TEST_ASSERT_EQUAL_UINT32_ARRAY not working!? @@ -146,14 +146,14 @@ void test_pressure_val(void) { } } -void test_range(void) { +void test_midi_range(void) { for(int cmd = RANGE; cmd < RANGE + NUM_CHANS; cmd++){ for(int test = 0; test < NUM_TESTS_PER_TEST; test++){ unsigned midi_ref[3] = {cmd, random(&rndm) & DATA_MASK, random(&rndm) & DATA_MASK}; unsigned packed = mini_in_parse_ut(midi_ref); unsigned midi_dut[3] = {0}; unsigned size = 0; - midi_out_parse_wrap(packed, midi_dut, &size); + midi_out_parse_c_wrapper(packed, midi_dut, &size); // printf("size: %d data: 0x%x 0x%x 0x%x\n", size, midi_ref[0], midi_ref[1], midi_ref[2]); // printf("size: %d data: 0x%x 0x%x 0x%x\n", size, midi_dut[0], midi_dut[1], midi_dut[2]); //TEST_ASSERT_EQUAL_UINT32_ARRAY not working!? @@ -164,14 +164,14 @@ void test_range(void) { } } -void test_manufacturer_id(void) { +void test_midi_manufacturer_id(void) { for(int cmd = MANUFACTURE_ID; cmd < MANUFACTURE_ID + NUM_CHANS; cmd++){ for(int test = 0; test < NUM_TESTS_PER_TEST; test++){ unsigned midi_ref[3] = {cmd, random(&rndm) & DATA_MASK, random(&rndm) & DATA_MASK}; unsigned packed = mini_in_parse_ut(midi_ref); unsigned midi_dut[3] = {0}; unsigned size = 0; - midi_out_parse_wrap(packed, midi_dut, &size); + midi_out_parse_c_wrapper(packed, midi_dut, &size); // printf("size: %d data: 0x%x 0x%x 0x%x\n", size, midi_ref[0], midi_ref[1], midi_ref[2]); // printf("size: %d data: 0x%x 0x%x 0x%x\n", size, midi_dut[0], midi_dut[1], midi_dut[2]); //TEST_ASSERT_EQUAL_UINT32_ARRAY not working!? diff --git a/tests/xua_unit_tests/src/test_midi_queue/test_midi_queue.c b/tests/xua_unit_tests/src/test_midi_queue/test_midi_queue.c index a203e88b..07e643e0 100644 --- a/tests/xua_unit_tests/src/test_midi_queue/test_midi_queue.c +++ b/tests/xua_unit_tests/src/test_midi_queue/test_midi_queue.c @@ -6,6 +6,14 @@ #include "xua_unit_tests.h" #include "../../../lib_xua/src/midi/queue.h" +#define DEBUG 0 + +#if DEBUG +#define dprintf(...) printf(__VA_ARGS__) +#else +#define dprintf(...) +#endif + #define RANDOM_SEED 55378008 #define USB_MIDI_DEVICE_OUT_FIFO_SIZE 1024 @@ -14,12 +22,56 @@ unsigned rndm = RANDOM_SEED; -void test_midi_queue(void) { +void test_midi_queue_init(void) { queue_t symbol_fifo; unsigned symbol_fifo_storage[USB_MIDI_DEVICE_OUT_FIFO_SIZE]; - queue_init_wrap(&symbol_fifo, ARRAY_SIZE(symbol_fifo_storage)); + queue_init_c_wrapper(&symbol_fifo, ARRAY_SIZE(symbol_fifo_storage)); - int empty = queue_is_empty_wrap(&symbol_fifo); - TEST_ASSERT_EQUAL_UINT32(1, empty); + int empty = queue_is_empty_c_wrapper(&symbol_fifo); + TEST_ASSERT_EQUAL_INT32(1, empty); + int full = queue_is_full_c_wrapper(&symbol_fifo); + TEST_ASSERT_EQUAL_INT32(0, full); + + unsigned items = queue_items_c_wrapper(&symbol_fifo); + TEST_ASSERT_EQUAL_UINT32(0, items); + + unsigned space = queue_space_c_wrapper(&symbol_fifo); + TEST_ASSERT_EQUAL_UINT32(USB_MIDI_DEVICE_OUT_FIFO_SIZE, space); +} + +void test_midi_queue_push_pop(void) { + queue_t symbol_fifo; + unsigned symbol_fifo_storage[USB_MIDI_DEVICE_OUT_FIFO_SIZE]; + queue_init_c_wrapper(&symbol_fifo, ARRAY_SIZE(symbol_fifo_storage)); + + for(unsigned i = 0; i < USB_MIDI_DEVICE_OUT_FIFO_SIZE; i++){ + int items = queue_items_c_wrapper(&symbol_fifo); + dprintf("Pre i: %u items: %d\n", i, items); + TEST_ASSERT_EQUAL_UINT32(i, items); + + unsigned entry = i + 1000; + queue_push_word_c_wrapper(&symbol_fifo, symbol_fifo_storage, entry); + dprintf("pushed: %u\n", entry); + + items = queue_items_c_wrapper(&symbol_fifo); + TEST_ASSERT_EQUAL_UINT32(i + 1, items); + + dprintf("Post items: %d\n", items); + } + + unsigned counter = 0; + for(int i = USB_MIDI_DEVICE_OUT_FIFO_SIZE; i > 0; i--){ + int items = queue_items_c_wrapper(&symbol_fifo); + dprintf("i: %u items: %d\n", i, items); + TEST_ASSERT_EQUAL_UINT32(i, items); + + unsigned entry = queue_pop_word_c_wrapper(&symbol_fifo, symbol_fifo_storage); + unsigned expected = 1000 + counter; + + dprintf("expected: %u got: %d\n", expected, entry); + TEST_ASSERT_EQUAL_UINT32(expected, entry); + + counter++; + } } \ No newline at end of file diff --git a/tests/xua_unit_tests/src/xua_unit_test_helper.xc b/tests/xua_unit_tests/src/xua_unit_test_helper.xc index 611f95b7..cb7c321b 100644 --- a/tests/xua_unit_tests/src/xua_unit_test_helper.xc +++ b/tests/xua_unit_tests/src/xua_unit_test_helper.xc @@ -36,20 +36,20 @@ unsigned random(unsigned &x){ } ////////////////////// Wrappers for midi parse because C doesn't support return tuples -void midi_in_parse_wrap(void * unsafe mips, unsigned cable_number, unsigned char b, unsigned * unsafe valid, unsigned *unsafe packed){ +void midi_in_parse_c_wrapper(void * unsafe mips, unsigned cable_number, unsigned char b, unsigned * unsafe valid, unsigned *unsafe packed){ unsafe{ struct midi_in_parse_state * unsafe ptr = mips; {*valid, *packed} = midi_in_parse(*ptr, cable_number, b); } } -void midi_out_parse_wrap(unsigned tx_data, unsigned midi[3], unsigned * unsafe size){ +void midi_out_parse_c_wrapper(unsigned tx_data, unsigned midi[3], unsigned * unsafe size){ unsafe{ {midi[0], midi[1], midi[2], *size} = midi_out_parse(tx_data); } } -void reset_midi_state_wrap(void * unsafe mips){ +void reset_midi_state_c_wrapper(void * unsafe mips){ unsafe{ struct midi_in_parse_state * unsafe ptr = mips; reset_midi_state(*ptr); @@ -59,53 +59,57 @@ void reset_midi_state_wrap(void * unsafe mips){ /////////////////////// Wrappers for queue test -void queue_init_wrap(queue_t *q, unsigned size) { +void queue_init_c_wrapper(queue_t *q, unsigned size) { unsafe{ queue_init(*q, size); } } -int queue_is_empty_wrap(queue_t *unsafe q) { +int queue_is_empty_c_wrapper(queue_t *unsafe q) { unsafe{ return queue_is_empty(*q); } } -int queue_is_full_wrap(queue_t *unsafe q) { +int queue_is_full_c_wrapper(queue_t *unsafe q) { unsafe{ return queue_is_full(*q); } } -/* -inline void queue_push_word(queue_t &q, unsigned array[], unsigned data) -{ - assert(!queue_is_full(q)); - array[q.wrptr++ & q.mask] = data; +void queue_push_word_c_wrapper(queue_t *q, unsigned array[], unsigned data){ + unsafe{ + queue_push_word(*q, array, data); + } } -inline unsigned queue_pop_word(queue_t &q, unsigned array[]) { - assert(!queue_is_empty(q)); - return array[q.rdptr++ & q.mask]; +unsigned queue_pop_word_c_wrapper(queue_t *q, unsigned array[]){ + unsafe{ + return queue_pop_word(*q, array); + } } -inline void queue_push_byte(queue_t &q, unsigned char array[], unsigned data) -{ - assert(!queue_is_full(q)); - array[q.wrptr++ & q.mask] = data; +void queue_push_byte_c_wrapper(queue_t *q, unsigned char array[], unsigned data){ + unsafe{ + queue_push_byte(*q, array, data); + } } -inline unsigned queue_pop_byte(queue_t &q, unsigned char array[]) { - assert(!queue_is_empty(q)); - return array[q.rdptr++ & q.mask]; +unsigned queue_pop_byte_c_wrapper(queue_t *q, unsigned char array[]){ + unsafe{ + return queue_pop_byte(*q, array); + } } -inline unsigned queue_items(const queue_t &q) { - return q.wrptr - q.rdptr; +unsigned queue_items_c_wrapper(const queue_t *q){ + unsafe{ + return queue_items(*q); + } } -inline unsigned queue_space(const queue_t &q) { - return q.size - queue_items(q); +unsigned queue_space_c_wrapper(const queue_t *q){ + unsafe{ + return queue_space(*q); + } } -*/ \ No newline at end of file diff --git a/tests/xua_unit_tests/src/xua_unit_tests.h b/tests/xua_unit_tests/src/xua_unit_tests.h index 53cf0dcd..5deec2dc 100644 --- a/tests/xua_unit_tests/src/xua_unit_tests.h +++ b/tests/xua_unit_tests/src/xua_unit_tests.h @@ -8,15 +8,20 @@ #include "../../../lib_xua/src/midi/queue.h" #ifndef __XC__ -void midi_in_parse_wrap(void * mips, unsigned cable_number, unsigned char b, unsigned * valid, unsigned * packed); -void midi_out_parse_wrap(unsigned tx_data, unsigned midi[3], unsigned * size); -void reset_midi_state_wrap(void *mips); +void midi_in_parse_c_wrapper(void * mips, unsigned cable_number, unsigned char b, unsigned * valid, unsigned * packed); +void midi_out_parse_c_wrapper(unsigned tx_data, unsigned midi[3], unsigned * size); +void reset_midi_state_c_wrapper(void *mips); unsigned random(unsigned *x); -void queue_init_wrap(queue_t *q, unsigned size); -int queue_is_empty_wrap(const queue_t *q); -int queue_is_full_wrap(const queue_t *q); - +void queue_init_c_wrapper(queue_t *q, unsigned size); +int queue_is_empty_c_wrapper(const queue_t *q); +int queue_is_full_c_wrapper(const queue_t *q); +void queue_push_word_c_wrapper(queue_t *q, unsigned array[], unsigned data); +unsigned queue_pop_word_c_wrapper(queue_t *q, unsigned array[]); +void queue_push_byte_c_wrapper(queue_t *q, unsigned char array[], unsigned data); +unsigned queue_pop_byte_c_wrapper(queue_t *q, unsigned char array[]); +unsigned queue_items_c_wrapper(const queue_t *q); +unsigned queue_space_c_wrapper(const queue_t *q); #endif