#ifndef _TEST_TEMPLATES_H_
|
#define _TEST_TEMPLATES_H_
|
|
/*--------------------------------------------------------------------------------*/
|
/* Includes */
|
/*--------------------------------------------------------------------------------*/
|
#include "template.h"
|
#include <string.h> /* memcmp() */
|
#include <inttypes.h> /* PRIu32 */
|
#include "math_helper.h" /* arm_snr_f32() */
|
|
/*--------------------------------------------------------------------------------*/
|
/* Function Aliases for use in Templates. */
|
/*--------------------------------------------------------------------------------*/
|
#define ref_q31_t_to_float ref_q31_to_float
|
#define ref_q15_t_to_float ref_q15_to_float
|
#define ref_q7_t_to_float ref_q7_to_float
|
#define ref_float_to_q31_t ref_float_to_q31
|
#define ref_float_to_q15_t ref_float_to_q15
|
#define ref_float_to_q7_t ref_float_to_q7
|
#define ref_float32_t_to_float ref_copy_f32
|
#define ref_float_to_float32_t ref_copy_f32
|
|
|
/*--------------------------------------------------------------------------------*/
|
/* Macros and Defines */
|
/*--------------------------------------------------------------------------------*/
|
|
/**
|
* Call the function-under-test.
|
*/
|
#define TEST_CALL_FUT(fut, fut_args) \
|
JTEST_COUNT_CYCLES(TEMPLATE_CALL_FN(fut, fut_args))
|
|
/**
|
* Call the reference-function.
|
*/
|
#define TEST_CALL_REF(ref, ref_args) \
|
TEMPLATE_CALL_FN(ref, ref_args)
|
|
/**
|
* Call the function-under-test and the reference-function.
|
*/
|
#define TEST_CALL_FUT_AND_REF(fut, fut_args, ref, ref_args) \
|
do { \
|
TEST_CALL_FUT(fut, fut_args); \
|
TEST_CALL_REF(ref, ref_args); \
|
} while (0)
|
|
/**
|
* This macro eats a variable number of arguments and evaluates to a null
|
* statement.
|
*/
|
#define TEST_NULL_STATEMENT(...) (void) "TEST_NULL_STATEMENT"
|
|
/**
|
* A function name, Usable in any template where a fut or ref name is accepted,
|
* that evaluates to a #TEST_NULL_STATEMENT().
|
*/
|
#define TEST_NULL_FN TEST_NULL_STATEMENT
|
|
/**
|
* Assert that buffers A and B are byte-equivalent for a number of bytes.
|
*/
|
#define TEST_ASSERT_BUFFERS_EQUAL(buf_a, buf_b, bytes) \
|
do \
|
{ \
|
if (memcmp(buf_a, buf_b, bytes) != 0) \
|
{ \
|
return JTEST_TEST_FAILED; \
|
} \
|
} while (0)
|
|
/**
|
* Assert that the two entities are equal.
|
*/
|
#define TEST_ASSERT_EQUAL(a, b) \
|
do \
|
{ \
|
if ((a) != (b)) \
|
{ \
|
return JTEST_TEST_FAILED; \
|
} \
|
} while (0)
|
|
/**
|
* Convert elements to from src_type to float.
|
*/
|
#define TEST_CONVERT_TO_FLOAT(src_ptr, dst_ptr, block_size, src_type) \
|
do \
|
{ \
|
ref_##src_type##_to_float( \
|
src_ptr, \
|
dst_ptr, \
|
block_size); \
|
} while (0) \
|
|
/**
|
* Convert elements to from float to dst_type .
|
*/
|
#define TEST_CONVERT_FLOAT_TO(src_ptr, dst_ptr, block_size, dst_type) \
|
do \
|
{ \
|
ref_float_to_##dst_type( \
|
src_ptr, \
|
dst_ptr, \
|
block_size); \
|
} while (0) \
|
|
/**
|
* Assert that the SNR between a reference and test sample is above a given
|
* threshold.
|
*/
|
#define TEST_ASSERT_SNR(ref_ptr, tst_ptr, block_size, threshold) \
|
do \
|
{ \
|
float32_t snr = arm_snr_f32(ref_ptr, tst_ptr, block_size); \
|
if ( snr <= threshold) \
|
{ \
|
JTEST_DUMP_STRF("SNR: %f\n", snr); \
|
return JTEST_TEST_FAILED; \
|
} \
|
} while (0) \
|
|
/**
|
* Assert that the SNR between a reference and test sample is above a given
|
* threshold. Special case for float64_t
|
*/
|
#define TEST_ASSERT_DBL_SNR(ref_ptr, tst_ptr, block_size, threshold) \
|
do \
|
{ \
|
float64_t snr = arm_snr_f64(ref_ptr, tst_ptr, block_size); \
|
if ( snr <= threshold) \
|
{ \
|
JTEST_DUMP_STRF("SNR: %f\n", snr); \
|
return JTEST_TEST_FAILED; \
|
} \
|
} while (0) \
|
|
/**
|
* Compare test and reference elements by converting to float and
|
* calculating an SNR.
|
*
|
* This macro is a merger of the #TEST_CONVERT_TO_FLOAT() and
|
* #TEST_ASSERT_SNR() macros.
|
*/
|
#define TEST_CONVERT_AND_ASSERT_SNR(ref_dst_ptr, ref_src_ptr, \
|
tst_dst_ptr, tst_src_ptr, \
|
block_size, \
|
tst_src_type, \
|
threshold) \
|
do \
|
{ \
|
TEST_CONVERT_TO_FLOAT(ref_src_ptr, \
|
ref_dst_ptr, \
|
block_size, \
|
tst_src_type); \
|
TEST_CONVERT_TO_FLOAT(tst_src_ptr, \
|
tst_dst_ptr, \
|
block_size, \
|
tst_src_type); \
|
TEST_ASSERT_SNR(ref_dst_ptr, \
|
tst_dst_ptr, \
|
block_size, \
|
threshold); \
|
} while (0)
|
|
/**
|
* Execute statements only if the combination of block size, function type
|
* specifier, and input ARR_DESC_t are valid.
|
*
|
* @example An ARR_DESC_t that contains 64 bytes cant service a 32 element
|
* block size if they are extracted in float32_t increments.
|
*
|
* 8 * 32 = 256 > 64.
|
*/
|
#define TEST_DO_VALID_BLOCKSIZE(block_size, fn_type_spec, \
|
input_arr_desc, body) \
|
do \
|
{ \
|
if (block_size * sizeof(fn_type_spec) <= \
|
ARR_DESC_BYTES(input_arr_desc)) \
|
{ \
|
JTEST_DUMP_STRF("Block Size: %"PRIu32"\n", block_size); \
|
body; \
|
} \
|
} while (0) \
|
|
/**
|
* Template for tests that rely on one input buffer and a blocksize parameter.
|
*
|
* The buffer is an #ARR_DESC_t. It is iterated over and it's values are
|
* passed to the function under test and reference functions through their
|
* appropriate argument interfaces. The argument interfaces this template to
|
* execute structurally similar functions.
|
*
|
*/
|
#define TEST_TEMPLATE_BUF1_BLK(arr_desc_inputs, \
|
arr_desc_block_sizes, \
|
input_type, output_type, \
|
fut, fut_arg_interface, \
|
ref, ref_arg_interface, \
|
compare_interface) \
|
do \
|
{ \
|
TEMPLATE_DO_ARR_DESC( \
|
input_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs \
|
, \
|
TEMPLATE_DO_ARR_DESC( \
|
block_size_idx, uint32_t, block_size, arr_desc_block_sizes \
|
, \
|
void * input_data_ptr = input_ptr->data_ptr; \
|
\
|
TEST_DO_VALID_BLOCKSIZE( \
|
block_size, input_type, input_ptr \
|
, \
|
TEST_CALL_FUT_AND_REF( \
|
fut, fut_arg_interface( \
|
input_data_ptr, block_size), \
|
ref, ref_arg_interface( \
|
input_data_ptr, block_size)); \
|
\
|
compare_interface(block_size, output_type)))); \
|
\
|
return JTEST_TEST_PASSED; \
|
\
|
} while (0)
|
|
/**
|
* Template for tests that rely on an input buffer and an element.
|
*
|
* An element can is any thing which doesn't walk and talk like a
|
* sequence. Examples include numbers, and structures.
|
*/
|
#define TEST_TEMPLATE_BUF1_ELT1(arr_desc_inputs, \
|
arr_desc_elts, \
|
input_type, elt_type, output_type, \
|
fut, fut_arg_interface, \
|
ref, ref_arg_interface, \
|
compare_interface) \
|
do \
|
{ \
|
TEMPLATE_DO_ARR_DESC( \
|
input_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs \
|
, \
|
TEMPLATE_DO_ARR_DESC( \
|
elt_idx, elt_type, elt, arr_desc_elts \
|
, \
|
void * input_data_ptr = input_ptr->data_ptr; \
|
TEST_CALL_FUT_AND_REF( \
|
fut, fut_arg_interface(input_data_ptr, elt), \
|
ref, ref_arg_interface(input_data_ptr, elt)); \
|
\
|
compare_interface(output_type))); \
|
return JTEST_TEST_PASSED; \
|
} while (0)
|
|
/**
|
* Template for tests that rely on an input buffer, an element, and a blocksize
|
* parameter.
|
*/
|
#define TEST_TEMPLATE_BUF1_ELT1_BLK(arr_desc_inputs, \
|
arr_desc_elts, \
|
arr_desc_block_sizes, \
|
input_type, elt_type, output_type, \
|
fut, fut_arg_interface, \
|
ref, ref_arg_interface, \
|
compare_interface); \
|
do \
|
{ \
|
TEMPLATE_DO_ARR_DESC( \
|
inut_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs \
|
, \
|
TEMPLATE_DO_ARR_DESC( \
|
block_size_idx, uint32_t, block_size, \
|
arr_desc_block_sizes \
|
, \
|
TEMPLATE_DO_ARR_DESC( \
|
elt_idx, elt_type, elt, arr_desc_elts \
|
, \
|
void * input_data_ptr = input_ptr->data_ptr; \
|
TEST_DO_VALID_BLOCKSIZE( \
|
block_size, input_type, input_ptr, \
|
\
|
TEST_CALL_FUT_AND_REF( \
|
fut, fut_arg_interface( \
|
input_data_ptr, elt, block_size), \
|
ref, ref_arg_interface( \
|
input_data_ptr, elt, block_size)); \
|
compare_interface(block_size, output_type))))); \
|
return JTEST_TEST_PASSED; \
|
} while (0)
|
|
/**
|
* Template for tests that rely on an input buffer, two elements, and a blocksize
|
* parameter.
|
*/
|
#define TEST_TEMPLATE_BUF1_ELT2_BLK(arr_desc_inputs, \
|
arr_desc_elt1s, \
|
arr_desc_elt2s, \
|
arr_desc_block_sizes, \
|
input_type, elt1_type, \
|
elt2_type, output_type, \
|
fut, fut_arg_interface, \
|
ref, ref_arg_interface, \
|
compare_interface) \
|
do \
|
{ \
|
TEMPLATE_DO_ARR_DESC( \
|
inut_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs \
|
, \
|
TEMPLATE_DO_ARR_DESC( \
|
block_size_idx, uint32_t, block_size, \
|
arr_desc_block_sizes \
|
, \
|
TEMPLATE_DO_ARR_DESC( \
|
elt1_idx, elt1_type, elt1, arr_desc_elt1s \
|
, \
|
TEMPLATE_DO_ARR_DESC( \
|
elt2_idx, elt2_type, elt2, arr_desc_elt2s \
|
, \
|
void * input_data_ptr = input_ptr->data_ptr; \
|
TEST_DO_VALID_BLOCKSIZE( \
|
block_size, input_type, input_ptr, \
|
TEST_CALL_FUT_AND_REF( \
|
fut, fut_arg_interface( \
|
input_data_ptr, elt1, elt2, block_size), \
|
ref, ref_arg_interface( \
|
input_data_ptr, elt1, elt2, block_size)); \
|
compare_interface(block_size, output_type)))))); \
|
return JTEST_TEST_PASSED; \
|
} while (0)
|
|
/**
|
* Template for tests that rely on two input buffers and a blocksize parameter.
|
*
|
* The two #ARR_DESC_t, input buffers are iterated through in parallel. The
|
* length of the first #ARR_DESC_t determines the length of the iteration.
|
*/
|
#define TEST_TEMPLATE_BUF2_BLK(arr_desc_inputs_a, \
|
arr_desc_inputs_b, \
|
arr_desc_block_sizes, \
|
input_type, output_type, \
|
fut, fut_arg_interface, \
|
ref, ref_arg_interface, \
|
compare_interface) \
|
do \
|
{ \
|
/* Iterate over two input arrays in parallel.*/ \
|
TEMPLATE_DO_ARR_DESC( \
|
input_idx, ARR_DESC_t *, input_ptr, arr_desc_inputs_a \
|
, \
|
TEMPLATE_DO_ARR_DESC( \
|
block_size_idx, uint32_t, block_size, arr_desc_block_sizes, \
|
void * input_a_ptr = input_ptr->data_ptr; \
|
void * input_b_ptr = ARR_DESC_ELT( \
|
ARR_DESC_t *, input_idx, \
|
&(arr_desc_inputs_b))->data_ptr; \
|
\
|
TEST_DO_VALID_BLOCKSIZE( \
|
block_size, input_type, input_ptr \
|
, \
|
TEST_CALL_FUT_AND_REF( \
|
fut, fut_arg_interface( \
|
input_a_ptr, input_b_ptr, block_size), \
|
ref, ref_arg_interface( \
|
input_a_ptr, input_b_ptr, block_size)); \
|
\
|
compare_interface(block_size, output_type)))); \
|
return JTEST_TEST_PASSED; \
|
} while (0)
|
|
/**
|
* Test template that uses a single element.
|
*/
|
#define TEST_TEMPLATE_ELT1(arr_desc_elts, \
|
elt_type, output_type, \
|
fut, fut_arg_interface, \
|
ref, ref_arg_interface, \
|
compare_interface) \
|
do \
|
{ \
|
TEMPLATE_DO_ARR_DESC( \
|
elt_idx, elt_type, elt, arr_desc_elts \
|
, \
|
TEST_CALL_FUT_AND_REF( \
|
fut, fut_arg_interface( \
|
elt), \
|
ref, ref_arg_interface( \
|
elt)); \
|
/* Comparison interfaces typically accept */ \
|
/* a block_size. Pass a dummy value 1.*/ \
|
compare_interface(1, output_type)); \
|
return JTEST_TEST_PASSED; \
|
} while (0)
|
|
/**
|
* Test template that iterates over two sets of elements in parallel.
|
*
|
* The length of the first set determines the number of iteratsions.
|
*/
|
#define TEST_TEMPLATE_ELT2(arr_desc_elts_a, \
|
arr_desc_elts_b, \
|
elt_a_type, elt_b_type, output_type, \
|
fut, fut_arg_interface, \
|
ref, ref_arg_interface, \
|
compare_interface) \
|
do \
|
{ \
|
TEMPLATE_DO_ARR_DESC( \
|
elt_a_idx, elt_a_type, elt_a, arr_desc_elts_a \
|
, \
|
elt_b_type * elt_b = ARR_DESC_ELT( \
|
elt_b_type, \
|
elt_a_idx, \
|
arr_desc_elts_b); \
|
\
|
TEST_CALL_FUT_AND_REF( \
|
fut, fut_arg_interface( \
|
elt_a, elt_b), \
|
ref, ref_arg_interface( \
|
elt_a, elt_b)); \
|
/* Comparison interfaces typically accept */ \
|
/* a block_size. Pass a dummy value 1.*/ \
|
compare_interface(1, output_type)); \
|
return JTEST_TEST_PASSED; \
|
} while (0)
|
|
/**
|
* Test template that uses an element and a block size.
|
*/
|
#define TEST_TEMPLATE_ELT1_BLK(arr_desc_elts, \
|
arr_desc_block_sizes, \
|
elt_type, output_type, \
|
fut, fut_arg_interface, \
|
ref, ref_arg_interface, \
|
compare_interface) \
|
do \
|
{ \
|
TEMPLATE_DO_ARR_DESC( \
|
block_size_idx, uint32_t, block_size, \
|
arr_desc_block_sizes \
|
, \
|
TEMPLATE_DO_ARR_DESC( \
|
elt_idx, elt_type, elt, arr_desc_elts \
|
, \
|
JTEST_DUMP_STRF("Block Size: %d\n", \
|
(int)block_size); \
|
TEST_CALL_FUT_AND_REF( \
|
fut, fut_arg_interface( \
|
elt, block_size), \
|
ref, ref_arg_interface( \
|
elt, block_size)); \
|
compare_interface(block_size, output_type))); \
|
return JTEST_TEST_PASSED; \
|
} while (0)
|
|
#endif /* _TEST_TEMPLATES_H_ */
|
