dengweijie/lib_xua
1
0
Fork 0
forked from PAWPAW-Mirror/lib_xua
Code Pull Requests Activity

Queue unit tests

Browse Source
This commit is contained in:
Ed
2024-04-18 09:34:33 +01:00
parent c960d82233
commit 7967275001
5 changed files with 117 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib_xua/src/midi/queue.h
View File

@@ -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_

36
tests/xua_unit_tests/src/test_midi_parse/test_midi_parse.c
View File

@@ -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!?

60
tests/xua_unit_tests/src/test_midi_queue/test_midi_queue.c
View File

@@ -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++;
}
}

56
tests/xua_unit_tests/src/xua_unit_test_helper.xc
View File

@@ -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);
}
}
*/

19
tests/xua_unit_tests/src/xua_unit_tests.h
View File

@@ -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