first generate

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/arr_desc/arr_desc.h

@@ -0,0 +1,220 @@
+#ifndef _ARR_DESC_H_
+#define _ARR_DESC_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+#include <stdint.h>
+#include <string.h>             /* memset() */
+#include "../util/util.h"       /* CONCAT() */
+
+/*--------------------------------------------------------------------------------*/
+/* Type Definitions */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Array-descriptor struct.
+ */
+typedef struct ARR_DESC_struct
+{
+    void *  data_ptr;                /* Pointer to the array contents. */
+    int32_t element_count;           /* Number of current elements. */
+    int32_t element_size;            /* Size of current elements in bytes. */
+    int32_t underlying_size;         /* Size of underlying array in bytes. */
+} ARR_DESC_t;
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Prefix of the array variable's name when creating an array and an array
+ *  descriptor at the same time.
+ */
+#define ARR_DESC_ARR_PREFIX ARR_DESC_ARR_
+
+/**
+ *  Evaluate to the array variable's name when creating an array and an array
+ *  descriptor at the same time.
+ */
+#define ARR_DESC_ARR_NAME(name)                 \
+    CONCAT(ARR_DESC_ARR_PREFIX, name)
+
+/**
+ *  Define an #ARR_DESC_t by itself.
+ *
+ *  @note The user must supply an array to store the data used by the
+ *  #ARR_DESC_t.
+ */
+#define ARR_DESC_INTERNAL_DEFINE(name, data_ptr,                \
+                                 element_count, element_size)   \
+    ARR_DESC_t name = {                                         \
+        data_ptr,                                               \
+        element_count,                                          \
+        element_size,                                           \
+        element_count * element_size                            \
+    }                                                           \
+
+/**
+ *  Define both an array and an #ARR_DESC_t that describes it.
+ *
+ *  @note Use the #CURLY() macro for the content field; it provides the curly
+ *  braces necessary for an array initialization.
+ */
+#define ARR_DESC_DEFINE(type, name, element_count, content)             \
+    type ARR_DESC_ARR_NAME(name)[element_count] = content;              \
+    ARR_DESC_INTERNAL_DEFINE(name,                                      \
+                             &ARR_DESC_ARR_NAME(name),                  \
+                             element_count,                             \
+                             sizeof(type)) /* Note the lacking semicolon */
+
+/**
+ *  Create a #ARR_DESC_t which refers to a subset of the data in another.
+ *
+ *  The new #ARR_DESC_t shares the same underlying array as the aliased
+ *  #ARR_DESC_t, but only describes a subset of the originals values.
+ */
+#define ARR_DESC_DEFINE_SUBSET(name, original, element_cnt)         \
+    ARR_DESC_INTERNAL_DEFINE(name,                                  \
+                             &ARR_DESC_ARR_NAME(original),          \
+                             element_cnt,                           \
+                             sizeof(ARR_DESC_ARR_NAME(original)[0]) \
+        ) /* Note the lacking semicolon */
+
+/**
+ *  Creat an #ARR_DESC_t which points to the data in an existing array.
+ *
+ *  @param start_idx Offset in array_ptr of first element.
+ *  @param element_cnt Number of elements to include in the #ARR_DESC_t.
+ *
+ *  @example
+ *
+ *  float my_floats[4] = {0.0f, 1.0f, 2.0f, 3.0f};
+ *
+ *  ARR_DESC_DEFINE_USING_ARR(my_arr_desc, my_floats, 1, 3);
+ *
+ *  printf("Element 0: %f\n", ARR_DESC_ELT(float, 0, &my_arr_desc));
+ *  printf("Element 1: %f\n", ARR_DESC_ELT(float, 1, &my_arr_desc));
+ *
+ *  Outputs:
+ *
+ *  Element 0: 1.000000
+ *  Element 1: 2.000000
+ *
+ *  @warning There are no checks in place to catch invalid start indices; This
+ *  is left to the user.
+ */
+#define ARR_DESC_DEFINE_USING_ARR(type, name, array_ptr, start_idx, element_cnt) \
+    ARR_DESC_INTERNAL_DEFINE(                                           \
+        name,                                                           \
+        (type *) (array_ptr + start_idx),                               \
+        element_cnt,                                                    \
+        sizeof(type)                                                    \
+        ) /* Note the lacking semicolon*/
+
+/**
+ *  Declare an #ARR_DESC_t object.
+ */
+#define ARR_DESC_DECLARE(name)                              \
+    extern ARR_DESC_t name /* Note the lacking semicolon */
+
+/**
+ *  Evaluate to the number of bytes stored in the #ARR_DESC_t.
+ */
+#define ARR_DESC_BYTES(arr_desc_ptr)                                \
+    ((arr_desc_ptr)->element_count * (arr_desc_ptr)->element_size)
+
+/**
+ *  Set the contents of #ARR_DESC_t to value.
+ */
+#define ARR_DESC_MEMSET(arr_desc_ptr, value, bytes)     \
+    do                                                  \
+    {                                                   \
+        memset((arr_desc_ptr)->data_ptr,                \
+               value,                                   \
+               BOUND(0,                                 \
+                     (arr_desc_ptr)->underlying_size,   \
+                     bytes)                             \
+            );                                          \
+    } while (0)
+
+/**
+ *  Perform a memcpy of 'bytes' bytes from the source #ARR_DESC_t to the
+ *  destination #ARR_DESC_t.
+ */
+#define ARR_DESC_MEMCPY(arr_desc_dest_ptr, arr_desc_src_ptr, bytes) \
+    do                                                              \
+    {                                                               \
+        memcpy((arr_desc_dest_ptr)->data_ptr,                       \
+               (arr_desc_src_ptr)->data_ptr,                        \
+               BOUND(0,                                             \
+                     (arr_desc_dest_ptr)->underlying_size,          \
+                     bytes));                                       \
+    } while (0)
+
+/**
+ *  Evaluate to true if the source #ARR_DESC_t contents will fit into the
+ *  destination #ARR_DESC_t and false otherwise.
+ */
+#define ARR_DESC_COPYABLE(arr_desc_dest_ptr, arr_desc_src_ptr)  \
+      (ARR_DESC_BYTES(arr_desc_src_ptr) <=                      \
+       (arr_desc_dest_ptr)->underlying_size)
+
+/**
+ *  Copy all the data from the source #ARR_DESC_t to the destination
+ *  #ARR_DESC_t.
+ *
+ *  @note If the destination #ARR_DESC_t is too small to fit the source data the
+ *  copy is aborted and nothing happens.
+ */
+#define ARR_DESC_COPY(arr_desc_dest_ptr, arr_desc_src_ptr)      \
+    do                                                          \
+    {                                                           \
+        if (ARR_DESC_COPYABLE(arr_desc_dest_ptr,                 \
+                             arr_desc_src_ptr))                 \
+        {                                                       \
+            ARR_DESC_MEMCPY(arr_desc_dest_ptr,                  \
+                            arr_desc_src_ptr,                   \
+                            ARR_DESC_BYTES(arr_desc_src_ptr));  \
+            /* Update the properties*/                          \
+            (arr_desc_dest_ptr)->element_count =                \
+                (arr_desc_src_ptr)->element_count;              \
+            (arr_desc_dest_ptr)->element_size =                 \
+                (arr_desc_src_ptr)->element_size;               \
+        }                                                       \
+    } while (0)
+
+/**
+ *  Compare the data in two #ARR_DESC_t structs for the specified number of
+ *  bytes.
+ */
+#define ARR_DESC_MEMCMP(arr_desc_ptr_a, arr_desc_ptr_b, bytes)  \
+        memcmp((arr_desc_ptr_a)->data_ptr,                      \
+            (arr_desc_ptr_b)->data_ptr,                         \
+               bytes) /* Note the lacking semicolon */          \
+
+/**
+ *  Zero out the contents of the #ARR_DESC_t.
+ */
+#define ARR_DESC_ZERO(arr_desc_ptr)             \
+        ARR_DESC_MEMSET(arr_desc_ptr,           \
+                        0,                      \
+                        (arr_desc_ptr)->underlying_size)
+
+/**
+ *  Evaluate to the data address in #ARR_DESC_t at offset.
+ */
+#define ARR_DESC_DATA_ADDR(type, arr_desc_ptr, offset)  \
+        ((void*)(((type *)                              \
+                  ((arr_desc_ptr)->data_ptr))           \
+                 + offset))
+
+/**
+ *  Evaluate to the element in #ARR_DESC_t with type at idx.
+ */
+#define ARR_DESC_ELT(type, idx, arr_desc_ptr)           \
+        (*((type *) ARR_DESC_DATA_ADDR(type,            \
+                                       arr_desc_ptr,    \
+                                       idx)))
+
+#endif /* _ARR_DESC_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest.h

@@ -0,0 +1,17 @@
+#ifndef _JTEST_H_
+#define _JTEST_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "jtest_fw.h"
+#include "jtest_test.h"
+#include "jtest_test_define.h"
+#include "jtest_test_call.h"
+#include "jtest_group.h"
+#include "jtest_group_define.h"
+#include "jtest_group_call.h"
+#include "jtest_cycle.h"
+
+#endif /* _JTEST_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_cycle.h

@@ -0,0 +1,65 @@
+#ifndef _JTEST_CYCLE_H_
+#define _JTEST_CYCLE_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "jtest_fw.h"           /* JTEST_DUMP_STRF() */
+#include "jtest_systick.h"
+#include "jtest_util.h"         /* STR() */
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Module Variables */
+/*--------------------------------------------------------------------------------*/
+extern const char * JTEST_CYCLE_STRF;
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Wrap the function call, fn_call, to count execution cycles and display the
+ *  results.
+ */
+/* skipp function name + param
+#define JTEST_COUNT_CYCLES(fn_call)                     \
+    do                                                  \
+    {                                                   \
+        uint32_t __jtest_cycle_end_count;               \
+                                                        \
+        JTEST_SYSTICK_RESET(SysTick);                   \
+        JTEST_SYSTICK_START(SysTick);                   \
+                                                        \
+        fn_call;                                        \
+                                                        \
+        __jtest_cycle_end_count =                       \
+            JTEST_SYSTICK_VALUE(SysTick);               \
+                                                        \
+		JTEST_SYSTICK_RESET(SysTick);                   \
+        JTEST_DUMP_STRF(JTEST_CYCLE_STRF,               \
+                        STR(fn_call),                   \
+                        (JTEST_SYSTICK_INITIAL_VALUE -  \
+                         __jtest_cycle_end_count));     \
+    } while (0)
+*/
+#define JTEST_COUNT_CYCLES(fn_call)                     \
+    do                                                  \
+    {                                                   \
+        uint32_t __jtest_cycle_end_count;               \
+                                                        \
+        JTEST_SYSTICK_RESET(SysTick);                   \
+        JTEST_SYSTICK_START(SysTick);                   \
+                                                        \
+        fn_call;                                        \
+                                                        \
+        __jtest_cycle_end_count =                       \
+            JTEST_SYSTICK_VALUE(SysTick);               \
+                                                        \
+		JTEST_SYSTICK_RESET(SysTick);                   \
+        JTEST_DUMP_STRF(JTEST_CYCLE_STRF,               \
+                        (JTEST_SYSTICK_INITIAL_VALUE -  \
+                         __jtest_cycle_end_count));     \
+    } while (0)
+
+#endif /* _JTEST_CYCLE_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_define.h

@@ -0,0 +1,37 @@
+#ifndef _JTEST_DEFINE_H_
+#define _JTEST_DEFINE_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Makes a symbol for use as a struct name. Names made this way have two parts;
+ *  the first parts is a prefix common to all structs of that class. The second
+ *  is a specifier which differs for each instance of that struct type.
+ */
+#define JTEST_STRUCT_NAME(prefix, specifier)    \
+    CONCAT(prefix, specifier)
+
+/**
+ *  Define a struct with type with a name generated by #JTEST_STRUCT_NAME().
+ */
+#define JTEST_DEFINE_STRUCT(type, struct_name)    \
+    type struct_name
+
+/**
+ *  Declare a struct with type with a name generated by #JTEST_STRUCT_NAME().
+ */
+#define JTEST_DECLARE_STRUCT(struct_definition) \
+    extern struct_definition
+
+/**
+ *  Define and initialize a struct (created with JTEST_DEFINE_STRUCT()) and
+ *  initialize it with init_values.
+ */
+#define JTEST_INIT_STRUCT(struct_definition, init_values)       \
+    struct_definition = {                                       \
+        init_values                                             \
+    }
+
+#endif /* _JTEST_DEFINE_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_fw.h

@@ -0,0 +1,253 @@
+#ifndef _JTEST_FW_H_
+#define _JTEST_FW_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include <stdint.h>             /* int32_t */
+#include <string.h>             /* strcpy() */
+#include <stdio.h>              /* sprintf() */
+#include "jtest_pf.h"           /* Extend JTEST_FW_t with Pass/Fail data */
+#include "jtest_group.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Type Definitions */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  A struct used to interface with the Keil Debugger.
+ */
+typedef struct JTEST_FW_struct
+{
+    /* Action Triggers: The Keil debugger monitors these values for changes.  In
+     * response to a change, the debugger executes code on the host. */
+    volatile int32_t test_start;
+    volatile int32_t test_end;
+    volatile int32_t group_start;
+    volatile int32_t group_end;
+    volatile int32_t dump_str;
+    volatile int32_t dump_data;
+    volatile int32_t exit_fw;
+
+    JTEST_GROUP_t * current_group_ptr;
+
+    /* Buffers: The C-code cannot send strings and data directly to the
+     * debugging framework. Instead, the debugger can be told to read 128 byte
+     * (by default) chunks of memory.  Data received in this manner requires
+     * post-processing to be legible.*/
+    char * str_buffer;
+    char * data_buffer;
+
+    /* Pass/Fail Data */
+    JTEST_PF_MEMBERS;
+
+} JTEST_FW_t;
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Default name for the JTEST_FW struct.
+ *
+ *  Define your own if you want the variable containing the #JTEST_FW_t to have
+ *  a different name.
+ */
+#ifndef JTEST_FW
+#define JTEST_FW JTEST_FW
+#endif
+
+/**
+ *  Default name for the JTEST_FW_STR_BUFFER.
+ *
+ *  Define your own if you want the variable containing the char buffer to have
+ *  a different name.
+ */
+#ifndef JTEST_FW_STR_BUFFER
+#define JTEST_FW_STR_BUFFER JTEST_FW_STR_BUFFER
+#endif
+
+/**
+ *  Size of the #JTEST_FW_t, output string-buffer.
+ *
+ *  If you change this value, make sure the "dump_str_fn" and "dump_data_fn"
+ *  functions in jtest_fns.ini uses the same size. If you aren't sure, read the
+ *  documentation Keil Debugger Command 'DISPLAY'.
+ */
+#define JTEST_BUF_SIZE 256
+
+
+/**
+ *  The maximum number of bytes output at once using #JTEST_DUMP_STRF().
+ */
+#define JTEST_STR_MAX_OUTPUT_SIZE 128
+
+/**
+ *  The maximum number of block transimissions needed to send a string from a
+ *  buffer with JTEST_BUF_SIZE.
+ */
+#define JTEST_STR_MAX_OUTPUT_SEGMENTS           \
+    (JTEST_BUF_SIZE / JTEST_STR_MAX_OUTPUT_SIZE)
+
+/**
+ *  Initialize the JTEST framework.
+ */
+#define JTEST_INIT()                                                    \
+    do                                                                  \
+    {                                                                   \
+        JTEST_FW.str_buffer = JTEST_FW_STR_BUFFER;                      \
+    } while (0)
+
+/* Debugger Action-triggering Macros */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Dispatch macro to trigger various actions in the Keil Debugger.
+ */
+#define JTEST_TRIGGER_ACTION(action_name)       \
+    do                                          \
+    {                                           \
+        action_name();                          \
+    } while (0)
+
+/**
+ *  Trigger the "Test Start" action in the Keil Debugger.
+ */
+#define JTEST_ACT_TEST_START()                  \
+    JTEST_TRIGGER_ACTION(test_start)
+
+/**
+ *  Trigger the "Test End" action in the Keil Debugger.
+ */
+#define JTEST_ACT_TEST_END()                    \
+    JTEST_TRIGGER_ACTION(test_end)
+
+
+/**
+ *  Trigger the "Group Start" action in the Keil Debugger.
+ */
+#define JTEST_ACT_GROUP_START()                 \
+    JTEST_TRIGGER_ACTION(group_start)
+
+/**
+ *  Trigger the "Group End" action in the Keil Debugger.
+ */
+#define JTEST_ACT_GROUP_END()                   \
+    JTEST_TRIGGER_ACTION(group_end)
+
+
+/**
+ *  Fill the buffer named buf_name with value and dump it to the Keil debugger
+ *  using action.
+ */
+#define JTEST_ACT_DUMP(action, buf_name, value) \
+    do                                          \
+    {                                           \
+        JTEST_CLEAR_BUFFER(buf_name);           \
+        strcpy(JTEST_FW.buf_name, (value));     \
+        JTEST_TRIGGER_ACTION(action);           \
+    } while (0)
+
+/**
+ *  Trigger the "Exit Framework" action in the Keil Debugger.
+ */
+#define JTEST_ACT_EXIT_FW()                     \
+    do                                          \
+    {                                           \
+        JTEST_TRIGGER_ACTION(exit_fw);          \
+    } while (0)
+
+
+/* Buffer Manipulation Macros */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Clear the JTEST_FW buffer with name buf_name.
+ */
+#define JTEST_CLEAR_BUFFER(buf_name)                    \
+    do                                                  \
+    {                                                   \
+        memset(JTEST_FW.buf_name, 0, JTEST_BUF_SIZE);   \
+    } while (0)
+
+/**
+ *  Clear the memory needed for the JTEST_FW's string buffer.
+ */
+#define JTEST_CLEAR_STR_BUFFER()                \
+        JTEST_CLEAR_BUFFER(str_buffer)
+
+/**
+ *  Clear the memory needed for the JTEST_FW's data buffer.
+ */
+#define JTEST_CLEAR_DATA_BUFFER()               \
+        JTEST_CLEAR_BUFFER(data_buffer)
+
+/**
+ *  Dump the given string to the Keil Debugger.
+ */
+#define JTEST_DUMP_STR(string)                          \
+        JTEST_ACT_DUMP(dump_str, str_buffer, string)
+
+/**
+ *  Dump a formatted string to the Keil Debugger.
+ */
+#define JTEST_DUMP_STRF(format_str, ... )                               \
+    do                                                                  \
+    {                                                                   \
+        JTEST_CLEAR_STR_BUFFER();                                       \
+        sprintf(JTEST_FW.str_buffer,format_str, __VA_ARGS__);           \
+        jtest_dump_str_segments();                                      \
+    } while (0)
+
+/* Pass/Fail Macros */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Increment the number of passed tests in #JTEST_FW.
+ */
+#define JTEST_FW_INC_PASSED(amount)             \
+        JTEST_PF_INC_PASSED(&JTEST_FW, amount)
+
+/**
+ *  Increment the number of passed tests in #JTEST_FW.
+ */
+#define JTEST_FW_INC_FAILED(amount)             \
+        JTEST_PF_INC_FAILED(&JTEST_FW, amount)
+
+/* Manipulating the Current Group */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Evaluate to the current_group_ptr in #JTEST_FW.
+ */
+#define JTEST_CURRENT_GROUP_PTR()               \
+    (JTEST_FW.current_group_ptr)
+
+#define JTEST_SET_CURRENT_GROUP(group_ptr)      \
+    do                                          \
+    {                                           \
+        JTEST_CURRENT_GROUP_PTR() = group_ptr;  \
+    } while (0)
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Global Variables */
+/*--------------------------------------------------------------------------------*/
+extern char JTEST_FW_STR_BUFFER[JTEST_BUF_SIZE];
+extern volatile JTEST_FW_t JTEST_FW;
+
+/*--------------------------------------------------------------------------------*/
+/* Function Prototypes */
+/*--------------------------------------------------------------------------------*/
+void jtest_dump_str_segments(void);
+
+void test_start  (void);
+void test_end    (void);
+void group_start (void);
+void group_end   (void);
+void dump_str    (void);
+void dump_data   (void);
+void exit_fw     (void);
+
+
+#endif /* _JTEST_FW_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_group.h

@@ -0,0 +1,66 @@
+#ifndef _JTEST_GROUP_H_
+#define _JTEST_GROUP_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "jtest_pf.h"
+#include "jtest_util.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Type Definitions */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  A struct which represents a group of #JTEST_TEST_t structs. This struct is
+ *  used to run the group of tests, and report on their outcomes.
+ */
+typedef struct JTEST_GROUP_struct
+{
+    void (* group_fn_ptr) (void); /**< Pointer to the test group */
+    char * name_str;              /**< Name of the group */
+    
+    /* Extend the #JTEST_GROUP_t with Pass/Fail information.*/
+    JTEST_PF_MEMBERS;
+} JTEST_GROUP_t;
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Set the name of JTEST_GROUP_t.
+ */
+#define JTEST_GROUP_SET_NAME(group_ptr, name)     \
+    JTEST_SET_STRUCT_ATTRIBUTE(group_ptr, name_str, name)
+
+#define JTEST_GROUP_SET_FN(group_ptr, fn_ptr)     \
+    JTEST_SET_STRUCT_ATTRIBUTE(group_ptr, group_fn_ptr, fn_ptr)
+
+/**
+ *  Increment the number of tests passed in the JTEST_GROUP_t pointed to by
+ *  group_ptr.
+ */
+#define JTEST_GROUP_INC_PASSED(group_ptr, amount) \
+    JTEST_PF_INC_PASSED(group_ptr, amount)
+
+/**
+ *  Increment the number of tests failed in the JTEST_GROUP_t pointed to by
+ *  group_ptr.
+ */
+#define JTEST_GROUP_INC_FAILED(group_ptr, amount) \
+    JTEST_PF_INC_FAILED(group_ptr, amount)
+
+/**
+ *  Reset the pass/fail information of the #JTEST_GROUP_t pointed to by
+ *  group_ptr.
+ */
+#define JTEST_GROUP_RESET_PF(group_ptr)         \
+    do                                          \
+    {                                           \
+        JTEST_PF_RESET_PASSED(group_ptr);       \
+        JTEST_PF_RESET_FAILED(group_ptr);       \
+    } while (0)
+
+#endif /* _JTEST_GROUP_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_group_call.h

@@ -0,0 +1,126 @@
+#ifndef _JTEST_GROUP_CALL_H_
+#define _JTEST_GROUP_CALL_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "jtest_fw.h"
+#include <inttypes.h>
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Execute the test in the #JTEST_GROUP_t struct associated witht he identifier
+ *  group_fn.
+ */
+#define JTEST_GROUP_RUN(group_fn)                                   \
+    do                                                              \
+    {                                                               \
+        JTEST_DUMP_STR("Group Name:\n");                            \
+        JTEST_DUMP_STR(JTEST_GROUP_STRUCT_NAME(group_fn).name_str); \
+        JTEST_GROUP_STRUCT_NAME(group_fn).group_fn_ptr();           \
+    } while (0)
+
+
+/**
+ *  Update the enclosing #JTEST_GROUP_t's pass/fail information using the
+ *  current #JTEST_GROUP_t's.
+ *
+ *  @param group_ptr Pointer to the current #JTEST_GROUP_t.
+ *  @param parent_ptr Pointer to the enclosing #JTEST_GROUP_t.
+ *
+ *  @warning Only run this if the current #JTEST_GROUP_t is being called within
+ *  the context of another #JTEST_GROUP_t.
+ */
+#define JTEST_GROUP_UPDATE_PARENT_GROUP_PF(group_ptr, parent_group_ptr) \
+    do                                                                  \
+    {                                                                   \
+        JTEST_GROUP_INC_PASSED(parent_group_ptr,                        \
+                               (group_ptr)->passed);                    \
+        JTEST_GROUP_INC_FAILED(parent_group_ptr,                        \
+                               (group_ptr)->failed);                    \
+    } while (0)
+
+/**
+ *  Update the #JTEST_FW's pass/fail information using the current
+ *  #JTEST_GROUP_t's.
+ */
+#define JTEST_GROUP_UPDATE_FW_PF(group_ptr)                     \
+    do                                                          \
+    {                                                           \
+        JTEST_FW_INC_PASSED((group_ptr)->passed);               \
+        JTEST_FW_INC_FAILED((group_ptr)->failed);               \
+    } while (0)
+
+/**
+ *  Update the enclosing context with the current #JTEST_GROUP_t's pass/fail
+ *  information. If this group isn't in an enclosing group, it updates the
+ *  #JTEST_FW's pass/fail info by default.
+ */
+#define JTEST_GROUP_UPDATE_PARENT_GROUP_OR_FW_PF(group_ptr,         \
+                                                 parent_group_ptr)  \
+    do                                                              \
+    {                                                               \
+        /* Update the pass fail counts in the parent group */       \
+        if (parent_group_ptr /* Null implies Top*/)                 \
+        {                                                           \
+            JTEST_GROUP_UPDATE_PARENT_GROUP_PF(                     \
+                group_ptr,                                          \
+                parent_group_ptr);                                  \
+        } else {                                                    \
+            JTEST_GROUP_UPDATE_FW_PF(                               \
+                group_ptr);                                         \
+        }                                                           \
+    } while (0)
+
+/**
+ *  Dump the results of running the #JTEST_GROUP_t to the Keil Debugger.
+ */
+#define JTEST_GROUP_DUMP_RESULTS(group_ptr)                             \
+        do                                                              \
+        {                                                               \
+            JTEST_DUMP_STRF(                                            \
+                "Tests Run: %" PRIu32 "\n"                              \
+                "----------\n"                                          \
+                "   Passed: %" PRIu32 "\n"                              \
+                "   Failed: %" PRIu32 "\n",                             \
+                (group_ptr)->passed + (group_ptr)->failed,              \
+                (group_ptr)->passed,                                    \
+                (group_ptr)->failed);                                   \
+        } while (0)
+
+/**
+ *  Call the #JTEST_GROUP_t associated with the identifier group_fn.
+ */
+#define JTEST_GROUP_CALL(group_fn)                                      \
+        do                                                              \
+        {   /* Save the current group from JTEST_FW_t before swapping */ \
+            /* it to this group (in order to restore it later )*/       \
+            JTEST_GROUP_t * __jtest_temp_group_ptr =                    \
+                JTEST_CURRENT_GROUP_PTR();                              \
+            JTEST_SET_CURRENT_GROUP(&JTEST_GROUP_STRUCT_NAME(group_fn)); \
+                                                                        \
+            /* Reset this group's pass/fail count. Each group */        \
+            /* should only remember counts for its last execution. */   \
+            JTEST_GROUP_RESET_PF(JTEST_CURRENT_GROUP_PTR());            \
+                                                                        \
+            /* Run the current group */                                 \
+            JTEST_ACT_GROUP_START();                                    \
+            JTEST_GROUP_RUN(group_fn);                                  \
+            JTEST_ACT_GROUP_END();                                      \
+                                                                        \
+            /* Update the pass fail counts in the parent group (or FW) */ \
+            JTEST_GROUP_UPDATE_PARENT_GROUP_OR_FW_PF(                   \
+                JTEST_CURRENT_GROUP_PTR(),                              \
+                __jtest_temp_group_ptr);                                \
+                                                                        \
+            JTEST_GROUP_DUMP_RESULTS(JTEST_CURRENT_GROUP_PTR());        \
+                                                                        \
+            /* Restore the previously current group */                  \
+            JTEST_SET_CURRENT_GROUP(__jtest_temp_group_ptr);            \
+        } while (0)
+
+#endif /* _JTEST_GROUP_CALL_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_group_define.h

@@ -0,0 +1,87 @@
+#ifndef _JTEST_GROUP_DEFINE_H_
+#define _JTEST_GROUP_DEFINE_H_
+
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "jtest_util.h"
+#include "jtest_define.h"
+#include "jtest_group.h"
+
+/* For defining macros with optional arguments */
+#include "opt_arg/opt_arg.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Prefix for all #JTEST_GROUP_t structs.
+ */
+#define JTEST_GROUP_STRUCT_NAME_PREFIX G_JTEST_GROUP_STRUCT_
+
+/**
+ *  Define test template used by #JTEST_GROUP_t tests.
+ */
+#define JTEST_GROUP_FN_TEMPLATE(group_fn)    \
+    void group_fn(void)
+
+#define JTEST_GROUP_FN_PROTOTYPE JTEST_GROUP_FN_TEMPLATE /**< Alias for
+                                                            #JTEST_GROUP_FN_TEMPLATE. */
+
+/**
+ *  Evaluate to the name of the #JTEST_GROUP_t struct associated with group_fn.
+ */
+#define JTEST_GROUP_STRUCT_NAME(group_fn)    \
+    JTEST_STRUCT_NAME(JTEST_GROUP_STRUCT_NAME_PREFIX, group_fn)
+
+/**
+ *  Define a #JTEST_GROUP_t struct based on the given group_fn.
+ */
+#define JTEST_GROUP_DEFINE_STRUCT(group_fn)  \
+    JTEST_DEFINE_STRUCT(JTEST_GROUP_t,       \
+                        JTEST_GROUP_STRUCT_NAME(group_fn))
+
+/**
+ *  Declare a #JTEST_GROUP_t struct based on the given group_fn.
+ */
+#define JTEST_GROUP_DECLARE_STRUCT(group_fn) \
+    JTEST_DECLARE_STRUCT(JTEST_GROUP_DEFINE_STRUCT(group_fn))
+
+/**
+ *  Contents needed to initialize a JTEST_GROUP_t struct.
+ */
+#define JTEST_GROUP_STRUCT_INIT(group_fn)    \
+    group_fn,                                \
+        STR_NL(group_fn),                       \
+        JTEST_PF_MEMBER_INIT
+
+/**
+ *  Initialize the contents of a #JTEST_GROUP_t struct.
+ */
+#define JTEST_GROUP_INIT(group_fn)           \
+    JTEST_GROUP_DEFINE_STRUCT(group_fn) = {  \
+        JTEST_GROUP_STRUCT_INIT(group_fn)    \
+    }
+
+/* Test Definition Macro */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Define a #JTEST_GROUP_t object and a test function.
+ */
+#define JTEST_DEFINE_GROUP(group_fn)         \
+    JTEST_GROUP_FN_PROTOTYPE(group_fn);      \
+    JTEST_GROUP_INIT(group_fn);              \
+    JTEST_GROUP_FN_PROTOTYPE(group_fn) /* Notice the lacking semicolon */
+
+/**
+ *  Declare a #JTEST_GROUP_t object and a test function prototype.
+ */
+#define JTEST_DECLARE_GROUP(group_fn)        \
+    JTEST_GROUP_FN_PROTOTYPE(group_fn);      \
+    JTEST_GROUP_DECLARE_STRUCT(group_fn) /* Note the lacking semicolon */
+
+#endif /* _JTEST_GROUP_DEFINE_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_pf.h

@@ -0,0 +1,85 @@
+#ifndef _JTEST_PF_H_
+#define _JTEST_PF_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Purpose */
+/*--------------------------------------------------------------------------------*/
+/* jtest_pf.h Contains macros useful for capturing pass/fail data. */
+
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ * Members that can be added to other structs to extend them pass/fail data and
+ * corresponding functionality.
+ */
+#define JTEST_PF_MEMBERS                            \
+    uint32_t passed;                                \
+    uint32_t failed /* Note the lacking semicolon*/ \
+
+/**
+ *  Used for initializing JTEST_PF_MEMBERS in a struct declaration.
+ */
+#define JTEST_PF_MEMBER_INIT                    \
+    0,                                          \
+    0
+
+/* Member-Incrementing Macros */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Dispatch macro for incrementing #JTEST_PF_MEMBERS.
+ *
+ *  @param xxx Values: 'passed', 'failed'
+ */
+#define JTEST_PF_INC_XXX(xxx, struct_pf_ptr, amount)    \
+    do                                                  \
+    {                                                   \
+        ((struct_pf_ptr)->xxx) += (amount);             \
+    } while (0)
+
+/**
+ *  Specialization of the #JTEST_PF_INC_XXX macro to increment the passed
+ *  member.
+ */
+#define JTEST_PF_INC_PASSED(struct_pf_ptr, amount)  \
+    JTEST_PF_INC_XXX(passed, struct_pf_ptr, amount)
+
+
+/**
+ *  Specialization of the #JTEST_PF_INC_XXX macro to increment the failed
+ *  member.
+ */
+#define JTEST_PF_INC_FAILED(struct_pf_ptr, amount)  \
+    JTEST_PF_INC_XXX(failed, struct_pf_ptr, amount)
+
+
+/* Member-Resetting Macros */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Dispatch macro for setting #JTEST_PF_MEMBERS to zero.
+ *
+ *  @param xxx Values: 'passed', 'failed'
+ */
+#define JTEST_PF_RESET_XXX(xxx, struct_pf_ptr)  \
+    do                                          \
+    {                                           \
+        ((struct_pf_ptr)->xxx) = UINT32_C(0);   \
+    } while (0)
+
+/**
+ *  Specialization of #JTEST_PF_RESET_XXX for the 'passed' member.
+ */
+#define JTEST_PF_RESET_PASSED(struct_pf_ptr)    \
+    JTEST_PF_RESET_XXX(passed, struct_pf_ptr)
+
+/**
+ *  Specialization of #JTEST_PF_RESET_XXX for the 'failed' member.
+ */
+#define JTEST_PF_RESET_FAILED(struct_pf_ptr)    \
+    JTEST_PF_RESET_XXX(failed, struct_pf_ptr)
+
+#endif /* _JTEST_PF_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_systick.h

@@ -0,0 +1,93 @@
+#ifndef _JTEST_SYSTICK_H_
+#define _JTEST_SYSTICK_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+/* Get access to the SysTick structure. */
+#if   defined ARMCM0
+  #include "ARMCM0.h"
+#elif defined ARMCM0P
+  #include "ARMCM0plus.h"
+#elif defined ARMCM3
+  #include "ARMCM3.h"
+#elif defined ARMCM4
+  #include "ARMCM4.h"
+#elif defined ARMCM4_FP
+  #include "ARMCM4_FP.h"
+#elif defined ARMCM7
+  #include "ARMCM7.h" 
+#elif defined ARMCM7_SP
+  #include "ARMCM7_SP.h"
+#elif defined ARMCM7_DP
+  #include "ARMCM7_DP.h"
+#elif defined ARMSC000
+  #include "ARMSC000.h"
+#elif defined ARMSC300
+  #include "ARMSC300.h"
+#elif defined ARMv8MBL
+  #include "ARMv8MBL.h"
+#elif defined ARMv8MML
+  #include "ARMv8MML.h"
+#elif defined ARMv8MML_DSP
+  #include "ARMv8MML_DSP.h"
+#elif defined ARMv8MML_SP
+  #include "ARMv8MML_SP.h"
+#elif defined ARMv8MML_DSP_SP
+  #include "ARMv8MML_DSP_SP.h"
+#elif defined ARMv8MML_DP
+  #include "ARMv8MML_DP.h"
+#elif defined ARMv8MML_DSP_DP
+  #include "ARMv8MML_DSP_DP.h"
+
+#else
+  #warning "no appropriate header file found!"
+#endif
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Initial value for the SysTick module.
+ *
+ *  @note This is also the maximum value, important as SysTick is a decrementing
+ *  counter.
+ */
+#define JTEST_SYSTICK_INITIAL_VALUE 0xFFFFFF
+
+/**
+ *  Reset the SysTick, decrementing timer to it's maximum value and disable it.
+ *
+ *  This macro should leave the SysTick timer in a state that's ready for cycle
+ *  counting.
+ */
+#define JTEST_SYSTICK_RESET(systick_ptr)                    \
+    do                                                      \
+    {                                                       \
+        (systick_ptr)->LOAD = JTEST_SYSTICK_INITIAL_VALUE;  \
+        (systick_ptr)->VAL = 1;                             \
+                                                            \
+        /* Disable the SysTick module. */                   \
+        (systick_ptr)->CTRL = UINT32_C(0x000000);           \
+    } while (0)
+
+/**
+ *  Start the SysTick timer, sourced by the processor clock.
+ */
+#define JTEST_SYSTICK_START(systick_ptr)                    \
+    do                                                      \
+    {                                                       \
+        (systick_ptr)->CTRL =                               \
+            SysTick_CTRL_ENABLE_Msk |                       \
+            SysTick_CTRL_CLKSOURCE_Msk; /* Internal clk*/   \
+    } while (0)
+
+/**
+ *  Evaluate to the current value of the SysTick timer.
+ */
+#define JTEST_SYSTICK_VALUE(systick_ptr)        \
+    ((systick_ptr)->VAL)
+           
+#endif /* _JTEST_SYSTICK_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_test.h

@@ -0,0 +1,100 @@
+#ifndef _JTEST_TEST_H_
+#define _JTEST_TEST_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include <stdint.h>
+#include "jtest_util.h"
+#include "jtest_test_ret.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Type Definitions */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  A struct which represents a Test in the JTEST framework.  This struct is
+ *  used to enable, run, and describe the test it represents.
+ */
+typedef struct JTEST_TEST_struct
+{
+    JTEST_TEST_RET_t ( * test_fn_ptr)(void); /**< Pointer to the test function. */
+    char   * test_fn_str;                    /**< Name of the test function */
+    char   * fut_str;           /**< Name of the function under test. */
+
+    /**
+     *  Flags that govern how the #JTEST_TEST_t behaves.
+     */
+    union {
+        struct {
+            unsigned enabled : 1;
+            unsigned unused  : 7;
+        } bits;
+        uint8_t byte;           /* Access all flags at once. */
+    } flags;
+    
+} JTEST_TEST_t;
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Assign a test function to the #JTEST_TEST_t struct.
+ */
+#define JTEST_TEST_SET_FN(jtest_test_ptr, fn_ptr)                   \
+    JTEST_SET_STRUCT_ATTRIBUTE(jtest_test_ptr, test_fn_ptr, fn_ptr)
+
+/**
+ *  Specify a function under test (FUT) for the #JTEST_TEST_t struct.
+ */
+#define JTEST_TEST_SET_FUT(jtest_test_ptr, str)                 \
+    JTEST_SET_STRUCT_ATTRIBUTE(jtest_test_ptr, fut_str, str)
+
+/* Macros concerning JTEST_TEST_t flags */
+/*--------------------------------------------------------------------------------*/
+
+#define JTEST_TEST_FLAG_SET 1 /**< Value of a set #JTEST_TEST_t flag. */
+#define JTEST_TEST_FLAG_CLR 0 /**< Value of a cleared #JTEST_TEST_t flag. */
+
+/**
+ *  Evaluate to the flag in #JTEST_TEST_t having flag_name.
+ */
+#define JTEST_TEST_FLAG(jtest_test_ptr, flag_name)  \
+    ((jtest_test_ptr)->flags.bits.flag_name)
+
+/**
+ *  Dispatch macro for setting and clearing #JTEST_TEST_t flags.
+ *
+ *  @param jtest_test_ptr Pointer to a #JTEST_TEST_t struct.
+ *  @param flag_name      Name of the flag to set in #JTEST_TEST_t.flags.bits
+ *  @param xxx            Vaid values: "SET" or "CLR"
+ *
+ *  @note This function depends on JTEST_TEST_FLAG_SET and JTEST_TEST_FLAG_CLR.
+ */
+#define JTEST_TEST_XXX_FLAG(jtest_test_ptr, flag_name, xxx)                  \
+    do                                                                       \
+    {                                                                        \
+        JTEST_TEST_FLAG(jtest_test_ptr, flag_name) = JTEST_TEST_FLAG_##xxx ; \
+    } while (0)
+
+/**
+ *  Specification of #JTEST_TEST_XXX_FLAG to set #JTEST_TEST_t flags.
+ */
+#define JTEST_TEST_SET_FLAG(jtest_test_ptr, flag_name)                       \
+    JTEST_TEST_XXX_FLAG(jtest_test_ptr, flag_name, SET)
+
+/**
+ *  Specification of #JTEST_TEST_XXX_FLAG to clear #JTEST_TEST_t flags.
+ */
+#define JTEST_TEST_CLR_FLAG(jtest_test_ptr, flag_name)                       \
+    JTEST_TEST_XXX_FLAG(jtest_test_ptr, flag_name, CLR)
+
+/**
+ *  Evaluate to true if the #JTEST_TEST_t is enabled.
+ */
+#define JTEST_TEST_IS_ENABLED(jtest_test_ptr)                           \
+    (JTEST_TEST_FLAG(jtest_test_ptr, enabled) == JTEST_TEST_FLAG_SET)
+
+#endif /* _JTEST_TEST_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_test_call.h

@@ -0,0 +1,121 @@
+#ifndef _JTEST_TEST_CALL_H_
+#define _JTEST_TEST_CALL_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+#include "jtest_test.h"
+#include "jtest_test_define.h"
+#include "jtest_fw.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Exectute the test in the #JTEST_TEST_t struct associated with the identifier
+ *  test_fn and store the result in retval.
+ */
+#define JTEST_TEST_RUN(retval, test_fn)                                 \
+    do                                                                  \
+    {                                                                   \
+        JTEST_DUMP_STR("Test Name:\n");                                 \
+        JTEST_DUMP_STR(JTEST_TEST_STRUCT_NAME(test_fn).test_fn_str);    \
+        JTEST_DUMP_STR("Function Under Test:\n");                       \
+        JTEST_DUMP_STR(JTEST_TEST_STRUCT_NAME(test_fn).fut_str);        \
+        retval = JTEST_TEST_STRUCT_NAME(test_fn).test_fn_ptr();         \
+    } while (0)
+
+/**
+ *  Update the enclosing #JTEST_GROUP_t's pass/fail information based on
+ *  test_retval.
+ *
+ *  @param test_retval A #JTEST_TEST_RET_enum for the current test.
+ *
+ *  @warning Only use if #JTEST_TEST_t is called in the context of a
+ *  #JTEST_GROUP_t.
+ */
+#define JTEST_TEST_UPDATE_PARENT_GROUP_PF(test_retval)              \
+    do                                                              \
+    {                                                               \
+        /* Update enclosing JTEST_GROUP_t with pass/fail info */    \
+        if (test_retval == JTEST_TEST_PASSED)                       \
+        {                                                           \
+            JTEST_GROUP_INC_PASSED(JTEST_CURRENT_GROUP_PTR(), 1);   \
+        } else {                                                    \
+            JTEST_GROUP_INC_FAILED(JTEST_CURRENT_GROUP_PTR(), 1);   \
+        }                                                           \
+    } while (0)
+
+/**
+ *  Update the #JTEST_FW with pass/fail information based on test_retval.
+ *
+ *  @param test_retval A #JTEST_TEST_RET_enum for the current test.
+ */
+#define JTEST_TEST_UPDATE_FW_PF(test_retval)                        \
+    do                                                              \
+    {                                                               \
+        /* Update the JTEST_FW with pass/fail info */                \
+        if (test_retval == JTEST_TEST_PASSED)                       \
+        {                                                           \
+            JTEST_FW_INC_PASSED( 1);                                \
+        } else {                                                    \
+            JTEST_FW_INC_FAILED(1);                                 \
+        }                                                           \
+    } while (0)
+
+/**
+ *  Update the enclosing JTEST_GROUP_t's pass/fail information, or the
+ *  #JTEST_FW's if this test has no enclosing #JTEST_GROUP_t.
+ *
+ *  @param test_retval A #JTEST_TEST_RET_enum for the current test.
+ */
+#define JTEST_TEST_UPDATE_PARENT_GROUP_OR_FW_PF(test_retval)            \
+    do                                                                  \
+    {                                                                   \
+        /* Update pass-fail information */                              \
+        if (JTEST_CURRENT_GROUP_PTR() /* Non-null */)                    \
+        {                                                               \
+            JTEST_TEST_UPDATE_PARENT_GROUP_PF(test_retval);             \
+        } else {                                                        \
+            JTEST_TEST_UPDATE_FW_PF(test_retval);                       \
+        }                                                               \
+    } while (0)
+
+/**
+ *  Dump the results of the test to the Keil Debugger.
+ */
+#define JTEST_TEST_DUMP_RESULTS(test_retval)        \
+        do                                          \
+        {                                           \
+            if (test_retval == JTEST_TEST_PASSED)   \
+            {                                       \
+                JTEST_DUMP_STR("Test Passed\n");      \
+            } else {                                \
+                JTEST_DUMP_STR("Test Failed\n");      \
+            }                                       \
+        } while (0)
+
+/**
+ *  Call the #JTEST_TEST_t assocaited with the identifier test_fn.
+ */
+#define JTEST_TEST_CALL(test_fn)                                        \
+    do                                                                  \
+    {                                                                   \
+        if (JTEST_TEST_IS_ENABLED(&JTEST_TEST_STRUCT_NAME(test_fn)))    \
+        {                                                               \
+            /* Default to failure */                                    \
+            JTEST_TEST_RET_t __jtest_test_ret = JTEST_TEST_FAILED;      \
+                                                                        \
+            JTEST_ACT_TEST_START();                                     \
+            JTEST_TEST_RUN(__jtest_test_ret, test_fn);                  \
+                                                                        \
+            /* Update pass-fail information */                          \
+            JTEST_TEST_UPDATE_PARENT_GROUP_OR_FW_PF(__jtest_test_ret);  \
+                                                                        \
+            JTEST_TEST_DUMP_RESULTS(__jtest_test_ret);                  \
+            JTEST_ACT_TEST_END();                                       \
+        }                                                               \
+    } while (0)
+
+#endif /* _JTEST_TEST_CALL_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_test_define.h

@@ -0,0 +1,133 @@
+#ifndef _JTEST_TEST_DEFINE_H_
+#define _JTEST_TEST_DEFINE_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "jtest_util.h"
+#include "jtest_define.h"
+#include "jtest_test.h"
+
+/* For defining macros with optional arguments */
+#include "opt_arg/opt_arg.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Prefix for all #JTEST_TEST_t structs.
+ */
+#define JTEST_TEST_STRUCT_NAME_PREFIX G_JTEST_TEST_STRUCT_
+
+/**
+ *  Define test template used by #JTEST_TEST_t tests.
+ */
+#define JTEST_TEST_FN_TEMPLATE(test_fn)                         \
+    JTEST_TEST_RET_t test_fn(void)
+
+#define JTEST_TEST_FN_PROTOTYPE JTEST_TEST_FN_TEMPLATE /**< Alias for
+                                                        * #JTEST_TEST_FN_TEMPLATE. */
+
+/**
+ *  Evaluate to the name of the #JTEST_TEST_t struct associated with test_fn.
+ */
+#define JTEST_TEST_STRUCT_NAME(test_fn)                         \
+    JTEST_STRUCT_NAME(JTEST_TEST_STRUCT_NAME_PREFIX, test_fn)
+
+/**
+ *  Define a #JTEST_TEST_t struct based on the given test_fn.
+ */
+#define JTEST_TEST_DEFINE_STRUCT(test_fn)                   \
+    JTEST_DEFINE_STRUCT(JTEST_TEST_t,                       \
+                        JTEST_TEST_STRUCT_NAME(test_fn))
+
+/**
+ *  Declare a #JTEST_TEST_t struct based on the given test_fn.
+ */
+#define JTEST_TEST_DECLARE_STRUCT(test_fn)      \
+    JTEST_DECLARE_STRUCT(JTEST_TEST_DEFINE_STRUCT(test_fn))
+
+/**
+ *  Contents needed to initialize a JTEST_TEST_t struct.
+ */
+#define JTEST_TEST_STRUCT_INIT(test_fn, fut, enable)    \
+    test_fn,                                            \
+        STR_NL(test_fn),                                   \
+        STR_NL(fut),                                       \
+    {                                                   \
+        {                                               \
+            enable,                                     \
+                0                                       \
+        }                                               \
+    }                                                   \
+        
+
+/**
+ *  Initialize the contents of a #JTEST_TEST_t struct.
+ */
+#define JTEST_TEST_INIT(test_fn, fut, enable)              \
+    JTEST_TEST_DEFINE_STRUCT(test_fn) = {                  \
+        JTEST_TEST_STRUCT_INIT(test_fn, fut, enable)       \
+    }
+
+/* Test Definition Macro */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Define a #JTEST_TEST_t object and a test function.
+ */
+#define _JTEST_DEFINE_TEST(test_fn, fut, enable)           \
+    JTEST_TEST_FN_PROTOTYPE(test_fn);                      \
+    JTEST_TEST_INIT(test_fn, fut, enable);                 \
+    JTEST_TEST_FN_PROTOTYPE(test_fn) /* Notice the lacking semicolon */
+
+/**
+ *  Declare a #JTEST_TEST_t object and a test function prototype.
+ */
+#define JTEST_DECLARE_TEST(test_fn)                                     \
+    JTEST_TEST_FN_PROTOTYPE(test_fn);                                   \
+    JTEST_TEST_DECLARE_STRUCT(test_fn) /* Note the lacking semicolon */
+
+/*--------------------------------------------------------------------------------*/
+/* Macros with optional arguments */
+/*--------------------------------------------------------------------------------*/
+
+/* Top-level Interface */
+#define JTEST_DEFINE_TEST(...)                             \
+    JTEST_DEFINE_TEST_(PP_NARG(__VA_ARGS__), ##__VA_ARGS__)
+
+/* Dispatch Macro*/
+#define JTEST_DEFINE_TEST_(N, ...)                         \
+    SPLICE(JTEST_DEFINE_TEST_, N)(__VA_ARGS__)
+
+/* Default Arguments */
+#define JTEST_DEFINE_TEST_DEFAULT_FUT /* Blank */
+#define JTEST_DEFINE_TEST_DEFAULT_ENABLE                   \
+    JTEST_TRUE                                 /* Tests enabled by
+                                                * default. */ 
+
+/* Dispatch Cases*/
+#define JTEST_DEFINE_TEST_1(_1)                            \
+    _JTEST_DEFINE_TEST(                                    \
+        _1,                                                \
+        JTEST_DEFINE_TEST_DEFAULT_FUT,                     \
+        JTEST_DEFINE_TEST_DEFAULT_ENABLE                   \
+        )
+
+#define JTEST_DEFINE_TEST_2(_1, _2)                        \
+    _JTEST_DEFINE_TEST(                                    \
+        _1,                                                \
+        _2,                                                \
+        JTEST_DEFINE_TEST_DEFAULT_ENABLE                   \
+        )
+
+#define JTEST_DEFINE_TEST_3(_1, _2, _3)                    \
+    _JTEST_DEFINE_TEST(                                    \
+        _1,                                                \
+        _2,                                                \
+        _3                                                 \
+        )
+
+#endif /* _JTEST_TEST_DEFINE_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_test_ret.h

@@ -0,0 +1,17 @@
+#ifndef _JTEST_TEST_RET_H_
+#define _JTEST_TEST_RET_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Type Definitions */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Values a #JTEST_TEST_t can return.
+ */
+typedef enum JTEST_TEST_RET_enum
+{
+    JTEST_TEST_PASSED,
+    JTEST_TEST_FAILED
+} JTEST_TEST_RET_t;
+
+#endif /* _JTEST_TEST_RET_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/jtest_util.h

@@ -0,0 +1,27 @@
+#ifndef _JTEST_UTIL_H_
+#define _JTEST_UTIL_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "util/util.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/* Define boolean values for the framework. */
+#define JTEST_TRUE  1           /**< Value used for TRUE in JTEST. */
+#define JTEST_FALSE 0           /**< Value used for FALSE in JTEST. */
+
+/**
+ *  Set the value of the attribute in the struct to by struct_ptr to value.
+ */
+#define JTEST_SET_STRUCT_ATTRIBUTE(struct_ptr, attribute, value)    \
+    do                                                              \
+    {                                                               \
+        (struct_ptr)->attribute = (value);                          \
+    } while (0)
+
+#endif /* _JTEST_UTIL_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/opt_arg/opt_arg.h

@@ -0,0 +1,15 @@
+#ifndef _OPT_ARG_H_
+#define _OPT_ARG_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "pp_narg.h"
+#include "splice.h"
+
+/* If you are Joseph Jaoudi, you have a snippet which expands into an
+   example. If you are not Joseph, but possess his code, study the examples. If
+   you have no examples, turn back contact Joseph. */
+
+#endif /* _OPT_ARG_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/opt_arg/pp_narg.h

@@ -0,0 +1,25 @@
+#ifndef _PP_NARG_H_
+#define _PP_NARG_H_
+
+#define PP_NARG(...)                                      \
+    PP_NARG_(__VA_ARGS__,PP_RSEQ_N())
+#define PP_NARG_(...)                                     \
+    PP_ARG_N(__VA_ARGS__)
+#define PP_ARG_N(                                         \
+                 _1, _2, _3, _4, _5, _6, _7, _8, _9,_10,  \
+                 _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
+                 _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
+                 _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
+                 _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
+                 _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
+                 _61,_62,_63,N,...) N
+#define PP_RSEQ_N()                                       \
+    63,62,61,60,                                          \
+        59,58,57,56,55,54,53,52,51,50,                    \
+        49,48,47,46,45,44,43,42,41,40,                    \
+        39,38,37,36,35,34,33,32,31,30,                    \
+        29,28,27,26,25,24,23,22,21,20,                    \
+        19,18,17,16,15,14,13,12,11,10,                    \
+        9,8,7,6,5,4,3,2,1,0
+
+#endif /* _PP_NARG_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/opt_arg/splice.h

@@ -0,0 +1,8 @@
+#ifndef _SPLICE_H_
+#define _SPLICE_H_
+
+#define SPLICE(a,b) SPLICE_1(a,b)
+#define SPLICE_1(a,b) SPLICE_2(a,b)
+#define SPLICE_2(a,b) a##b
+
+#endif /* _SPLICE_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/inc/util/util.h

@@ -0,0 +1,52 @@
+#ifndef _UTIL_H_
+#define _UTIL_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Convert a symbol to a string and add a 'NewLine'.
+ */
+#define STR_NL(x)  STR1_NL(x)
+#define STR1_NL(x) (STR2_NL(x)"\n")
+#define STR2_NL(x) #x
+
+/**
+ *  Convert a symbol to a string.
+ */
+#define STR(x)  STR1(x)
+#define STR1(x) STR2(x)
+#define STR2(x) #x
+
+/**
+ *  Concatenate two symbols.
+ */
+#define CONCAT(a, b)  CONCAT1(a, b)
+#define CONCAT1(a, b) CONCAT2(a, b)
+#define CONCAT2(a, b) a##b
+
+
+/**
+ *  Place curly braces around a varaible number of macro arguments.
+ */
+#define CURLY(...) {__VA_ARGS__}
+
+/**
+ *  Place parenthesis around a variable number of macro arguments.
+ */
+#define PAREN(...) (__VA_ARGS__)
+
+/* Standard min/max macros. */
+#define MIN(x,y) (((x) < (y)) ? (x) : (y) )
+#define MAX(x,y) (((x) > (y)) ? (x) : (y) )
+
+/**
+ *  Bound value using low and high limits.
+ *
+ *  Evaluate to a number in the range, endpoint inclusive.
+ */
+#define BOUND(low, high, value)                 \
+    MAX(MIN(high, value), low)
+
+#endif /* _UTIL_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/src/jtest_cycle.c

@@ -0,0 +1,9 @@
+#include "../inc/jtest_cycle.h"
+#include <inttypes.h>
+
+/*--------------------------------------------------------------------------------*/
+/* Define Module Variables */
+/*--------------------------------------------------------------------------------*/
+
+/* const char * JTEST_CYCLE_STRF = "Running: %s\nCycles: %" PRIu32 "\n"; */
+const char * JTEST_CYCLE_STRF = "Cycles: %" PRIu32 "\n"; /* function name + parameter string skipped */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/src/jtest_dump_str_segments.c

@@ -0,0 +1,36 @@
+#include "jtest_fw.h"
+
+/**
+ *  Dump the JTEST_FW.str_buffer the Keil framework in pieces.
+ *
+ *  The JTEST_FW.str_buffer contains more characters than the Keil framework can
+ *  dump at once. This function dumps them in blocks.
+ */
+void jtest_dump_str_segments(void)
+{
+    uint32_t seg_idx      = 0;
+    uint32_t memmove_idx = 0;
+    uint32_t seg_cnt  =
+        (strlen(JTEST_FW.str_buffer) / JTEST_STR_MAX_OUTPUT_SIZE) + 1;
+
+    for( seg_idx = 0; seg_idx < seg_cnt; ++seg_idx)
+    {
+        JTEST_TRIGGER_ACTION(dump_str);
+
+        if (seg_idx < JTEST_STR_MAX_OUTPUT_SEGMENTS)
+        {
+            memmove_idx = 0;
+            while (memmove_idx < (seg_cnt - seg_idx -1) )
+            {
+                memmove(
+                    JTEST_FW.str_buffer+
+                    (memmove_idx* JTEST_STR_MAX_OUTPUT_SIZE),
+                    JTEST_FW.str_buffer+
+                    ((memmove_idx+1)*JTEST_STR_MAX_OUTPUT_SIZE),
+                    JTEST_BUF_SIZE);
+                ++memmove_idx;
+            }
+        }
+    }
+    return;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/src/jtest_fw.c

@@ -0,0 +1,9 @@
+#include "../inc/jtest.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Define Global Variables */
+/*--------------------------------------------------------------------------------*/
+
+char JTEST_FW_STR_BUFFER[JTEST_BUF_SIZE] = {0};
+
+volatile JTEST_FW_t JTEST_FW = {0};

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/src/jtest_trigger_action.c

@@ -0,0 +1,37 @@
+
+#include "jtest_fw.h"
+
+void test_start    (void) {
+//  ;
+  JTEST_FW.test_start++;
+}
+
+void test_end      (void) {
+//  ;
+  JTEST_FW.test_end++;
+}
+
+void group_start   (void) {
+//  ;
+  JTEST_FW.group_start++;
+}
+
+void group_end     (void) {
+//  ;
+  JTEST_FW.group_end++;
+}
+
+void dump_str      (void) {
+//  ;
+  JTEST_FW.dump_str++;
+}
+
+void dump_data     (void) {
+//  ;
+  JTEST_FW.dump_data++;
+}
+
+void exit_fw       (void) {
+//  ;
+  JTEST_FW.exit_fw++;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/all_tests.h

@@ -0,0 +1,9 @@
+#ifndef _ALL_TESTS_H_
+#define _ALL_TESTS_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Test Groups */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(all_tests);
+
+#endif /* _ALL_TESTS_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/basic_math_tests/basic_math_templates.h

@@ -0,0 +1,267 @@
+#ifndef _BASIC_MATH_TEMPLATES_H_
+#define _BASIC_MATH_TEMPLATES_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+#include "test_templates.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Group Specific Templates */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Compare the outputs used by basic math tests for the function under test and
+ *  the reference function.
+ */
+#define BASIC_MATH_COMPARE_INTERFACE(block_size, output_type)   \
+    TEST_ASSERT_BUFFERS_EQUAL(                                  \
+        basic_math_output_ref.data_ptr,                         \
+        basic_math_output_fut.data_ptr,                         \
+        block_size * sizeof(output_type))
+
+/*
+ * Comparison SNR thresholds for the data types used in basic_math_tests.
+ */
+#define BASIC_MATH_SNR_THRESHOLD_float32_t 120
+#define BASIC_MATH_SNR_THRESHOLD_q31_t 100
+#define BASIC_MATH_SNR_THRESHOLD_q15_t 75
+#define BASIC_MATH_SNR_THRESHOLD_q7_t 25
+
+/**
+ *  Compare reference and fut outputs using SNR.
+ *
+ *  @note The outputs are converted to float32_t before comparison.
+ */
+#define BASIC_MATH_SNR_COMPARE_INTERFACE(block_size, output_type)   \
+    do                                                              \
+    {                                                               \
+        TEST_CONVERT_AND_ASSERT_SNR(                                \
+            basic_math_output_f32_ref,                              \
+            basic_math_output_ref.data_ptr,                         \
+            basic_math_output_f32_fut,                              \
+            basic_math_output_fut.data_ptr,                         \
+            block_size,                                             \
+            output_type,                                            \
+            BASIC_MATH_SNR_THRESHOLD_##output_type                  \
+            );                                                      \
+    } while (0)
+
+
+/**
+ *  Compare reference and fut outputs using SNR.
+ *
+ *  @note The outputs are converted to float32_t before comparison.
+ */
+#define BASIC_MATH_SNR_ELT1_COMPARE_INTERFACE(block_size, output_type)  \
+    do                                                                  \
+    {                                                                   \
+        TEST_CONVERT_AND_ASSERT_SNR(                                    \
+            basic_math_output_f32_ref,                                  \
+            basic_math_output_ref.data_ptr,                             \
+            basic_math_output_f32_fut,                                  \
+            basic_math_output_fut.data_ptr,                             \
+            1,                                                          \
+            output_type,                                                \
+            BASIC_MATH_SNR_THRESHOLD_##output_type                      \
+            );                                                          \
+    } while (0)
+
+
+
+/*--------------------------------------------------------------------------------*/
+/* Input Interfaces */
+/*--------------------------------------------------------------------------------*/
+/*
+ *  General:
+ *  Input interfaces provide inputs to functions inside test templates.  They
+ *  ONLY provide the inputs.  The output variables should be hard coded.
+ *
+ *  The input interfaces must have the following format:
+ *
+ *  ARM_xxx_INPUT_INTERFACE() or
+ *  REF_xxx_INPUT_INTERFACE()
+ *
+ *  The xxx must be lowercase, and is intended to be the indentifying substring
+ *  in the function's name.  Acceptable values are 'sub' or 'add' from the
+ *  functions arm_add_q31.
+ */
+
+#define ARM_abs_INPUT_INTERFACE(input, block_size)              \
+    PAREN(input, basic_math_output_fut.data_ptr, block_size)
+
+#define REF_abs_INPUT_INTERFACE(input, block_size)              \
+    PAREN(input, basic_math_output_ref.data_ptr, block_size)
+
+#define ARM_add_INPUT_INTERFACE(input_a, input_b, block_size)           \
+    PAREN(input_a, input_b, basic_math_output_fut.data_ptr, block_size) \
+
+#define REF_add_INPUT_INTERFACE(input_a, input_b, block_size)           \
+    PAREN(input_a, input_b, basic_math_output_ref.data_ptr, block_size) \
+
+#define ARM_dot_prod_INPUT_INTERFACE(input_a, input_b, block_size)      \
+    PAREN(input_a, input_b, block_size, basic_math_output_fut.data_ptr) \
+
+#define REF_dot_prod_INPUT_INTERFACE(input_a, input_b, block_size)      \
+    PAREN(input_a, input_b, block_size, basic_math_output_ref.data_ptr) \
+
+#define ARM_mult_INPUT_INTERFACE(input_a, input_b, block_size)          \
+    PAREN(input_a, input_b, basic_math_output_fut.data_ptr, block_size) \
+
+#define REF_mult_INPUT_INTERFACE(input_a, input_b, block_size)          \
+    PAREN(input_a, input_b, basic_math_output_ref.data_ptr, block_size) \
+
+#define ARM_negate_INPUT_INTERFACE(input, block_size)           \
+    PAREN(input, basic_math_output_fut.data_ptr, block_size)
+
+#define REF_negate_INPUT_INTERFACE(input, block_size)           \
+    PAREN(input, basic_math_output_ref.data_ptr, block_size)
+
+#define ARM_offset_INPUT_INTERFACE(input, elt, block_size)          \
+    PAREN(input, elt, basic_math_output_fut.data_ptr, block_size)   \
+
+#define REF_offset_INPUT_INTERFACE(input, elt, block_size)          \
+    PAREN(input, elt, basic_math_output_ref.data_ptr, block_size)   \
+
+#define ARM_shift_INPUT_INTERFACE(input, elt, block_size)           \
+    PAREN(input, elt, basic_math_output_fut.data_ptr, block_size)   \
+
+#define REF_shift_INPUT_INTERFACE(input, elt, block_size)           \
+    PAREN(input, elt, basic_math_output_ref.data_ptr, block_size)   \
+
+#define ARM_scale_float_INPUT_INTERFACE(input, elt, block_size)     \
+    PAREN(input, elt, basic_math_output_fut.data_ptr, block_size)   \
+
+#define REF_scale_float_INPUT_INTERFACE(input, elt, block_size)     \
+    PAREN(input, elt, basic_math_output_ref.data_ptr, block_size)   \
+
+/* These two are for the fixed point functions */
+#define ARM_scale_INPUT_INTERFACE(input, elt1, elt2, block_size)        \
+    PAREN(input, elt1, elt2, basic_math_output_fut.data_ptr, block_size) \
+
+#define REF_scale_INPUT_INTERFACE(input, elt1, elt2, block_size)        \
+    PAREN(input, elt1, elt2, basic_math_output_ref.data_ptr, block_size) \
+
+#define ARM_sub_INPUT_INTERFACE(input_a, input_b, block_size)           \
+    PAREN(input_a, input_b, basic_math_output_fut.data_ptr, block_size) \
+
+#define REF_sub_INPUT_INTERFACE(input_a, input_b, block_size)           \
+    PAREN(input_a, input_b, basic_math_output_ref.data_ptr, block_size) \
+
+
+/*--------------------------------------------------------------------------------*/
+/* Test Templates */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Specialization of #TEST_TEMPLATE_BUF1_BLK() for basic math tests.
+ *
+ *  @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
+ *  REF_xxx_INPUT_INTERFACEs.
+ */
+#define BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_BLK(fn_name,       \
+                                                 suffix,        \
+                                                 input_type,    \
+                                                 output_type)   \
+    JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test,          \
+                      arm_##fn_name##_##suffix)                 \
+    {                                                           \
+        TEST_TEMPLATE_BUF1_BLK(                                 \
+            basic_math_f_all,                                   \
+            basic_math_block_sizes,                             \
+            input_type,                                         \
+            output_type,                                        \
+            arm_##fn_name##_##suffix,                           \
+            ARM_##fn_name##_INPUT_INTERFACE,                    \
+            ref_##fn_name##_##suffix,                           \
+            REF_##fn_name##_INPUT_INTERFACE,                    \
+            BASIC_MATH_COMPARE_INTERFACE);                      \
+    }
+
+/**
+ *  Specialization of #TEST_TEMPLATE_BUF2_BLK() for basic math tests.
+ *
+ *  @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
+ *  REF_xxx_INPUT_INTERFACEs.
+ */
+#define BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK(fn_name,               \
+                                                 suffix,                \
+                                                 input_type,            \
+                                                 output_type,           \
+                                                 comparison_interface)  \
+    JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test,                  \
+                      arm_##fn_name##_##suffix)                         \
+    {                                                                   \
+        TEST_TEMPLATE_BUF2_BLK(                                         \
+            basic_math_f_all,                                           \
+            basic_math_f_all,                                           \
+            basic_math_block_sizes,                                     \
+            input_type,                                                 \
+            output_type,                                                \
+            arm_##fn_name##_##suffix,                                   \
+            ARM_##fn_name##_INPUT_INTERFACE,                            \
+            ref_##fn_name##_##suffix,                                   \
+            REF_##fn_name##_INPUT_INTERFACE,                            \
+            comparison_interface);                                      \
+    }
+
+/**
+ *  Specialization of #TEST_TEMPLATE_BUF1_ELT1_BLK() for basic math tests.
+ *
+ *  @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
+ *  REF_xxx_INPUT_INTERFACEs.
+ */
+#define BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_ELT1_BLK(fn_name,      \
+                                                      suffix,       \
+                                                      input_type,   \
+                                                      elt_type,     \
+                                                      output_type)  \
+    JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test,              \
+                      arm_##fn_name##_##suffix)                     \
+    {                                                               \
+        TEST_TEMPLATE_BUF1_ELT1_BLK(                                \
+            basic_math_f_all,                                       \
+            basic_math_elts,                                        \
+            basic_math_block_sizes,                                 \
+            input_type,                                             \
+            elt_type,                                               \
+            output_type,                                            \
+            arm_##fn_name##_##suffix,                               \
+            ARM_##fn_name##_INPUT_INTERFACE,                        \
+            ref_##fn_name##_##suffix,                               \
+            REF_##fn_name##_INPUT_INTERFACE,                        \
+            BASIC_MATH_COMPARE_INTERFACE);                          \
+    }
+
+/**
+ *  Specialization of #TEST_TEMPLATE_BUF1_ELT2_BLK() for basic math tests.
+ *
+ *  @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
+ *  REF_xxx_INPUT_INTERFACEs.
+ */
+#define BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_ELT2_BLK(fn_name,      \
+                                                      suffix,       \
+                                                      input_type,   \
+                                                      elt1_type,    \
+                                                      elt2_type,    \
+                                                      output_type)  \
+    JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test,              \
+                      arm_##fn_name##_##suffix)                     \
+    {                                                               \
+        TEST_TEMPLATE_BUF1_ELT2_BLK(                                \
+            basic_math_f_all,                                       \
+            basic_math_elts,                                        \
+            basic_math_elts2,                                       \
+            basic_math_block_sizes,                                 \
+            input_type,                                             \
+            elt1_type,                                              \
+            elt2_type,                                              \
+            output_type,                                            \
+            arm_##fn_name##_##suffix,                               \
+            ARM_##fn_name##_INPUT_INTERFACE,                        \
+            ref_##fn_name##_##suffix,                               \
+            REF_##fn_name##_INPUT_INTERFACE,                        \
+            BASIC_MATH_COMPARE_INTERFACE);                          \
+    }
+
+#endif /* _BASIC_MATH_TEMPLATES_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/basic_math_tests/basic_math_test_data.h

@@ -0,0 +1,46 @@
+#ifndef ARM_BASIC_MATH_TEST_DATA_H
+#define ARM_BASIC_MATH_TEST_DATA_H
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "arr_desc.h"
+#include "arm_math.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+#define BASIC_MATH_MAX_INPUT_ELEMENTS 32
+#define BASIC_MATH_BIGGEST_INPUT_TYPE float32_t
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Variables */
+/*--------------------------------------------------------------------------------*/
+
+/* Input/Output Buffers */
+ARR_DESC_DECLARE(basic_math_output_fut);
+ARR_DESC_DECLARE(basic_math_output_ref);
+
+extern BASIC_MATH_BIGGEST_INPUT_TYPE
+basic_math_output_f32_ref[BASIC_MATH_MAX_INPUT_ELEMENTS];
+
+extern BASIC_MATH_BIGGEST_INPUT_TYPE
+basic_math_output_f32_fut[BASIC_MATH_MAX_INPUT_ELEMENTS];
+
+/* Block Sizes*/
+ARR_DESC_DECLARE(basic_math_block_sizes);
+
+/* Numbers */
+ARR_DESC_DECLARE(basic_math_elts);
+ARR_DESC_DECLARE(basic_math_elts2);
+ARR_DESC_DECLARE(basic_math_eltsf);
+
+/* Float Inputs */
+ARR_DESC_DECLARE(basic_math_zeros);
+ARR_DESC_DECLARE(basic_math_f_2);
+ARR_DESC_DECLARE(basic_math_f_15);
+ARR_DESC_DECLARE(basic_math_f_32);
+ARR_DESC_DECLARE(basic_math_f_all);
+
+#endif

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/basic_math_tests/basic_math_test_group.h

@@ -0,0 +1,9 @@
+#ifndef _BASIC_MATH_TEST_GROUP_H_
+#define _BASIC_MATH_TEST_GROUP_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Test Groups */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(basic_math_tests);
+
+#endif /* _BASIC_MATH_TEST_GROUP_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/basic_math_tests/basic_math_tests.h

@@ -0,0 +1,17 @@
+#ifndef _BASIC_MATH_TESTS_H_
+#define _BASIC_MATH_TESTS_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Test/Group Declarations */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(abs_tests);
+JTEST_DECLARE_GROUP(add_tests);
+JTEST_DECLARE_GROUP(dot_prod_tests);
+JTEST_DECLARE_GROUP(mult_tests);
+JTEST_DECLARE_GROUP(negate_tests);
+JTEST_DECLARE_GROUP(offset_tests);
+JTEST_DECLARE_GROUP(scale_tests);
+JTEST_DECLARE_GROUP(shift_tests);
+JTEST_DECLARE_GROUP(sub_tests);
+
+#endif /* _BASIC_MATH_TESTS_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/complex_math_tests/complex_math_templates.h

@@ -0,0 +1,222 @@
+#ifndef _COMPLEX_MATH_TEMPLATES_H_
+#define _COMPLEX_MATH_TEMPLATES_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+#include "test_templates.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Group Specific Templates */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Compare the real outputs from the function under test and the reference
+ *  function.
+ */
+#define COMPLEX_MATH_COMPARE_RE_INTERFACE(block_size, output_type)  \
+    TEST_ASSERT_BUFFERS_EQUAL(                                      \
+        complex_math_output_ref_a.data_ptr,                         \
+        complex_math_output_fut_a.data_ptr,                         \
+        block_size * sizeof(output_type))
+
+/**
+ *  Compare the real and imaginary outputs from the function under test and the
+ *  reference function.
+ */
+#define COMPLEX_MATH_COMPARE_CMPLX_INTERFACE(block_size, output_type)   \
+    do                                                                  \
+    {                                                                   \
+        COMPLEX_MATH_COMPARE_RE_INTERFACE(block_size * 2, output_type); \
+    } while (0)
+
+
+/*
+ * Comparison SNR thresholds for the data types used in complex_math_tests.
+ */
+#define COMPLEX_MATH_SNR_THRESHOLD_float32_t 120
+#define COMPLEX_MATH_SNR_THRESHOLD_q31_t 100
+#define COMPLEX_MATH_SNR_THRESHOLD_q15_t 75
+
+/**
+ *  Compare reference and fut outputs using SNR.
+ *
+ *  The output_suffix specifies which output buffers to use for the
+ *  comparison. An output_suffix of 'a' expands to the following buffers:
+ *
+ *  - complex_math_output_f32_ref_a
+ *  - complex_math_output_f32_fut_a
+ *  - complex_math_output_ref_a
+ *  - complex_math_output_fut_a
+ *
+ *  @note The outputs are converted to float32_t before comparison.
+ */
+#define COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size,      \
+                                               output_type,     \
+                                               output_suffix)   \
+    do                                                          \
+    {                                                           \
+        TEST_CONVERT_AND_ASSERT_SNR(                            \
+            complex_math_output_f32_ref_##output_suffix,        \
+            complex_math_output_ref_##output_suffix.data_ptr,   \
+            complex_math_output_f32_fut_##output_suffix,        \
+            complex_math_output_fut_##output_suffix.data_ptr,   \
+            block_size,                                         \
+            output_type,                                        \
+            COMPLEX_MATH_SNR_THRESHOLD_##output_type            \
+            );                                                  \
+    } while (0)
+
+/**
+ *  Specification of #COMPLEX_MATH_SNR_COMPARE_INTERFACE() for real outputs.
+ */
+#define COMPLEX_MATH_SNR_COMPARE_RE_INTERFACE(block_size,       \
+                                                   output_type) \
+    COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size,          \
+                                           output_type,         \
+                                           a)
+
+/**
+ *  Specification of #COMPLEX_MATH_SNR_COMPARE_INTERFACE() for complex outputs.
+ */
+#define COMPLEX_MATH_SNR_COMPARE_CMPLX_INTERFACE(block_size,    \
+                                                 output_type)   \
+        COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size * 2,  \
+                                               output_type,     \
+                                               a)
+
+/**
+ *  Compare reference and fut split outputs using SNR.
+ *
+ *  'Split' refers to two separate output buffers; one for real and one for
+ *  complex.
+ */
+#define COMPLEX_MATH_SNR_COMPARE_SPLIT_INTERFACE(block_size,    \
+                                                 output_type)   \
+        do                                                      \
+        {                                                       \
+            COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size,  \
+                                                   output_type, \
+                                                   a);          \
+            COMPLEX_MATH_SNR_COMPARE_OUT_INTERFACE(block_size,  \
+                                                   output_type, \
+                                                   b);          \
+        } while (0)
+
+
+/*--------------------------------------------------------------------------------*/
+/* Input Interfaces */
+/*--------------------------------------------------------------------------------*/
+/*
+ *  General:
+ *  Input interfaces provide inputs to functions inside test templates.  They
+ *  ONLY provide the inputs.  The output variables should be hard coded.
+ *
+ *  The input interfaces must have the following format:
+ *
+ *  ARM_xxx_INPUT_INTERFACE() or
+ *  REF_xxx_INPUT_INTERFACE()
+ *
+ *  The xxx must be lowercase, and is intended to be the indentifying substring
+ *  in the function's name.  Acceptable values are 'sub' or 'add' from the
+ *  functions arm_add_q31.
+ */
+
+#define ARM_cmplx_conj_INPUT_INTERFACE(input, block_size)           \
+    PAREN(input, complex_math_output_fut_a.data_ptr, block_size)
+
+#define REF_cmplx_conj_INPUT_INTERFACE(input, block_size)           \
+    PAREN(input, complex_math_output_ref_a.data_ptr, block_size)
+
+#define ARM_cmplx_dot_prod_INPUT_INTERFACE(input_a, input_b, block_size) \
+    PAREN(input_a, input_b, block_size,                                 \
+          complex_math_output_fut_a.data_ptr,                          \
+          complex_math_output_fut_b.data_ptr)
+
+#define REF_cmplx_dot_prod_INPUT_INTERFACE(input_a, input_b, block_size) \
+    PAREN(input_a, input_b, block_size,                                 \
+          complex_math_output_ref_a.data_ptr,                          \
+          complex_math_output_ref_b.data_ptr)
+
+#define ARM_cmplx_mag_INPUT_INTERFACE(input, block_size)            \
+    PAREN(input, complex_math_output_fut_a.data_ptr, block_size)
+
+#define REF_cmplx_mag_INPUT_INTERFACE(input, block_size)            \
+    PAREN(input, complex_math_output_ref_a.data_ptr, block_size)
+
+#define ARM_cmplx_mag_squared_INPUT_INTERFACE(input, block_size)    \
+    PAREN(input, complex_math_output_fut_a.data_ptr, block_size)
+
+#define REF_cmplx_mag_squared_INPUT_INTERFACE(input, block_size)    \
+    PAREN(input, complex_math_output_ref_a.data_ptr, block_size)
+
+#define ARM_cmplx_mult_cmplx_INPUT_INTERFACE(input_a, input_b, block_size) \
+    PAREN(input_a, input_b, complex_math_output_fut_a.data_ptr, block_size)
+
+#define REF_cmplx_mult_cmplx_INPUT_INTERFACE(input_a, input_b, block_size) \
+    PAREN(input_a, input_b, complex_math_output_ref_a.data_ptr, block_size)
+
+#define ARM_cmplx_mult_real_INPUT_INTERFACE(input_a, input_b, block_size) \
+    PAREN(input_a, input_b, complex_math_output_fut_a.data_ptr, block_size)
+
+#define REF_cmplx_mult_real_INPUT_INTERFACE(input_a, input_b, block_size) \
+    PAREN(input_a, input_b, complex_math_output_ref_a.data_ptr, block_size)
+
+/*--------------------------------------------------------------------------------*/
+/* Test Templates */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Specialization of #TEST_TEMPLATE_BUF1_BLK() for complex math tests.
+ *
+ *  @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
+ *  REF_xxx_INPUT_INTERFACEs.
+ */
+#define COMPLEX_MATH_DEFINE_TEST_TEMPLATE_BUF1_BLK(fn_name,         \
+                                                   suffix,          \
+                                                   input_type,      \
+                                                   output_type,     \
+                                                   comparison_interface) \
+    JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test,              \
+                      arm_##fn_name##_##suffix)                     \
+    {                                                               \
+        TEST_TEMPLATE_BUF1_BLK(                                     \
+            complex_math_f_all,                                     \
+            complex_math_block_sizes,                               \
+            input_type,                                             \
+            output_type,                                            \
+            arm_##fn_name##_##suffix,                               \
+            ARM_##fn_name##_INPUT_INTERFACE,                        \
+            ref_##fn_name##_##suffix,                               \
+            REF_##fn_name##_INPUT_INTERFACE,                        \
+            comparison_interface);                                  \
+    }
+
+/**
+ *  Specialization of #TEST_TEMPLATE_BUF2_BLK1() for complex math tests.
+ *
+ *  @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
+ *  REF_xxx_INPUT_INTERFACEs.
+ */
+#define COMPLEX_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK(fn_name,         \
+                                                   suffix,          \
+                                                   input_type,      \
+                                                   output_type,     \
+                                                   comparison_interface) \
+    JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test,              \
+                      arm_##fn_name##_##suffix)                     \
+    {                                                               \
+        TEST_TEMPLATE_BUF2_BLK(                                     \
+            complex_math_f_all,                                     \
+            complex_math_f_all,                                     \
+            complex_math_block_sizes,                               \
+            input_type,                                             \
+            output_type,                                            \
+            arm_##fn_name##_##suffix,                               \
+            ARM_##fn_name##_INPUT_INTERFACE,                        \
+            ref_##fn_name##_##suffix,                               \
+            REF_##fn_name##_INPUT_INTERFACE,                        \
+            comparison_interface);                                  \
+    }
+
+#endif /* _COMPLEX_MATH_TEMPLATES_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/complex_math_tests/complex_math_test_data.h

@@ -0,0 +1,50 @@
+#ifndef _COMPLEX_MATH_TEST_DATA_H_
+#define _COMPLEX_MATH_TEST_DATA_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "arr_desc.h"
+#include "arm_math.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+#define COMPLEX_MATH_MAX_INPUT_ELEMENTS 32
+#define COMPLEX_MATH_BIGGEST_INPUT_TYPE float32_t
+
+/*--------------------------------------------------------------------------------*/
+/* Decalare Variables */
+/*--------------------------------------------------------------------------------*/
+
+/* Input/Output Buffers */
+ARR_DESC_DECLARE(complex_math_output_fut_a);
+ARR_DESC_DECLARE(complex_math_output_fut_b);
+ARR_DESC_DECLARE(complex_math_output_ref_a);
+ARR_DESC_DECLARE(complex_math_output_ref_b);
+
+extern COMPLEX_MATH_BIGGEST_INPUT_TYPE
+complex_math_output_f32_ref_a[COMPLEX_MATH_MAX_INPUT_ELEMENTS * 2];
+
+extern COMPLEX_MATH_BIGGEST_INPUT_TYPE
+complex_math_output_f32_ref_b[COMPLEX_MATH_MAX_INPUT_ELEMENTS * 2];
+
+extern COMPLEX_MATH_BIGGEST_INPUT_TYPE
+complex_math_output_f32_fut_a[COMPLEX_MATH_MAX_INPUT_ELEMENTS * 2];
+
+extern COMPLEX_MATH_BIGGEST_INPUT_TYPE
+complex_math_output_f32_fut_b[COMPLEX_MATH_MAX_INPUT_ELEMENTS * 2];
+
+/* Block Sizes*/
+ARR_DESC_DECLARE(complex_math_block_sizes);
+
+/* Float Inputs */
+ARR_DESC_DECLARE(complex_math_zeros);
+ARR_DESC_DECLARE(complex_math_f_2);
+ARR_DESC_DECLARE(complex_math_f_15);
+ARR_DESC_DECLARE(complex_math_f_32);
+ARR_DESC_DECLARE(complex_math_f_all);
+
+
+#endif /* _COMPLEX_MATH_TEST_DATA_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/complex_math_tests/complex_math_test_group.h

@@ -0,0 +1,9 @@
+#ifndef _COMPLEX_MATH_TEST_GROUP_H_
+#define _COMPLEX_MATH_TEST_GROUP_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Test Groups */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(complex_math_tests);
+
+#endif /* _COMPLEX_MATH_TEST_GROUP_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/complex_math_tests/complex_math_tests.h

@@ -0,0 +1,14 @@
+#ifndef _COMPLEX_MATH_TESTS_H_
+#define _COMPLEX_MATH_TESTS_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Test/Group Declarations */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(cmplx_conj_tests);
+JTEST_DECLARE_GROUP(cmplx_dot_prod_tests);
+JTEST_DECLARE_GROUP(cmplx_mag_tests);
+JTEST_DECLARE_GROUP(cmplx_mag_squared_tests);
+JTEST_DECLARE_GROUP(cmplx_mult_cmplx_tests);
+JTEST_DECLARE_GROUP(cmplx_mult_real_tests);
+
+#endif /* _COMPLEX_MATH_TESTS_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/controller_tests/controller_templates.h

@@ -0,0 +1,46 @@
+#ifndef _CONTROLLER_TEMPLATES_H_
+#define _CONTROLLER_TEMPLATES_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "test_templates.h"
+#include <string.h>             /* memcpy() */
+
+/*--------------------------------------------------------------------------------*/
+/* Group Specific Templates */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ * Comparison SNR thresholds for the data types used in transform_tests.
+ */
+#define CONTROLLER_SNR_THRESHOLD_float32_t 110
+#define CONTROLLER_SNR_THRESHOLD_q31_t     100
+#define CONTROLLER_SNR_THRESHOLD_q15_t     45
+
+/**
+ *  Compare the outputs from the function under test and the reference
+ *  function using SNR.
+ */
+#define CONTROLLER_SNR_COMPARE_INTERFACE(block_size,    \
+                                         output_type)   \
+    do                                                  \
+    {                                                   \
+        TEST_CONVERT_AND_ASSERT_SNR(                    \
+            controller_output_f32_ref,                  \
+            (output_type *) controller_output_ref,      \
+            controller_output_f32_fut,                  \
+            (output_type *) controller_output_fut,      \
+            block_size,                                 \
+            output_type,                                \
+            CONTROLLER_SNR_THRESHOLD_##output_type      \
+            );                                          \
+    } while (0)
+
+
+/*--------------------------------------------------------------------------------*/
+/* TEST Templates */
+/*--------------------------------------------------------------------------------*/
+
+#endif /* _CONTROLLER_TEMPLATES_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/controller_tests/controller_test_data.h

@@ -0,0 +1,33 @@
+#ifndef _CONTROLLER_TEST_DATA_H_
+#define _CONTROLLER_TEST_DATA_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "arm_math.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+#define CONTROLLER_MAX_LEN 1024
+#define CONTROLLER_MAX_COEFFS_LEN (12 * 3)
+#define TRANFORM_BIGGEST_INPUT_TYPE float32_t
+
+/*--------------------------------------------------------------------------------*/
+/* Variable Declarations */
+/*--------------------------------------------------------------------------------*/
+
+extern float32_t controller_output_fut[CONTROLLER_MAX_LEN];
+extern float32_t controller_output_ref[CONTROLLER_MAX_LEN];
+extern float32_t controller_output_f32_fut[CONTROLLER_MAX_LEN];
+extern float32_t controller_output_f32_ref[CONTROLLER_MAX_LEN];
+extern const float32_t controller_f32_inputs[CONTROLLER_MAX_LEN];
+extern const q31_t controller_q31_inputs[CONTROLLER_MAX_LEN];
+extern const q15_t * controller_q15_inputs;
+extern const float32_t controller_f32_coeffs[CONTROLLER_MAX_COEFFS_LEN];
+extern const q31_t controller_q31_coeffs[CONTROLLER_MAX_COEFFS_LEN];
+extern const q15_t controller_q15_coeffs[CONTROLLER_MAX_COEFFS_LEN];
+
+#endif /* _CONTROLLER_TEST_DATA_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/controller_tests/controller_test_group.h

@@ -0,0 +1,9 @@
+#ifndef _CONTROLLER_TEST_GROUP_H_
+#define _CONTROLLER_TEST_GROUP_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Test Group */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(controller_tests);
+
+#endif /* _CONTROLLER_TEST_GROUP_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/controller_tests/controller_tests.h

@@ -0,0 +1,11 @@
+#ifndef _CONTROLLER_TESTS_H_
+#define _CONTROLLER_TESTS_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Test/Group Declarations */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(pid_reset_tests);
+JTEST_DECLARE_GROUP(sin_cos_tests);
+JTEST_DECLARE_GROUP(pid_tests);
+
+#endif /* _CONTROLLER_TESTS_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/fast_math_tests/fast_math_templates.h

@@ -0,0 +1,102 @@
+#ifndef _FAST_MATH_TEMPLATES_H_
+#define _FAST_MATH_TEMPLATES_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "test_templates.h"
+#include <string.h>             /* memcpy() */
+
+/*--------------------------------------------------------------------------------*/
+/* Group Specific Templates */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ * Comparison SNR thresholds for the data types used in transform_tests.
+ */
+#define FAST_MATH_SNR_THRESHOLD_float32_t 95
+#define FAST_MATH_SNR_THRESHOLD_q31_t     95
+#define FAST_MATH_SNR_THRESHOLD_q15_t     45
+
+/**
+ *  Compare the outputs from the function under test and the reference
+ *  function using SNR.
+ */
+#define FAST_MATH_SNR_COMPARE_INTERFACE(block_size,     \
+                                        output_type)    \
+    do                                                  \
+    {                                                   \
+        TEST_CONVERT_AND_ASSERT_SNR(                    \
+            fast_math_output_f32_ref,                   \
+            (output_type *) fast_math_output_ref,       \
+            fast_math_output_f32_fut,                   \
+            (output_type *) fast_math_output_fut,       \
+            block_size,                                 \
+            output_type,                                \
+            FAST_MATH_SNR_THRESHOLD_##output_type       \
+            );                                          \
+    } while (0)
+
+
+/*--------------------------------------------------------------------------------*/
+/* TEST Templates */
+/*--------------------------------------------------------------------------------*/
+
+#define SQRT_TEST_TEMPLATE_ELT1(suffix)                             \
+                                                                    \
+    JTEST_DEFINE_TEST(arm_sqrt_##suffix##_test, arm_sqrt_##suffix)  \
+    {                                                               \
+        uint32_t i;                                                 \
+                                                                    \
+        JTEST_COUNT_CYCLES(                                         \
+            for(i=0;i<FAST_MATH_MAX_LEN;i++)                        \
+            {                                                       \
+                arm_sqrt_##suffix(                                  \
+                    (suffix##_t)fast_math_##suffix##_inputs[i]      \
+                    ,(suffix##_t*)fast_math_output_fut + i);        \
+            });                                                     \
+                                                                    \
+        for(i=0;i<FAST_MATH_MAX_LEN;i++)                            \
+        {                                                           \
+            ref_sqrt_##suffix(                                      \
+                (suffix##_t)fast_math_##suffix##_inputs[i]          \
+                ,(suffix##_t*)fast_math_output_ref + i);            \
+        }                                                           \
+                                                                    \
+        FAST_MATH_SNR_COMPARE_INTERFACE(                            \
+            FAST_MATH_MAX_LEN,                                      \
+            suffix##_t);                                            \
+                                                                    \
+        return JTEST_TEST_PASSED;                                   \
+    }
+
+
+#define SIN_COS_TEST_TEMPLATE_ELT1(suffix, type, func)                  \
+                                                                        \
+        JTEST_DEFINE_TEST(arm_##func##_##suffix##_test, arm_##func##_##suffix) \
+        {                                                               \
+            uint32_t i;                                                 \
+                                                                        \
+            JTEST_COUNT_CYCLES(                                         \
+                for(i=0;i<FAST_MATH_MAX_LEN;i++)                        \
+                {                                                       \
+                    *((type*)fast_math_output_fut + i) = arm_##func##_##suffix( \
+                        fast_math_##suffix##_inputs[i]);                \
+                });                                                     \
+                                                                        \
+            JTEST_COUNT_CYCLES(                                         \
+                for(i=0;i<FAST_MATH_MAX_LEN;i++)                        \
+                {                                                       \
+                    *((type*)fast_math_output_ref + i) = ref_##func##_##suffix( \
+                        fast_math_##suffix##_inputs[i]);                \
+                });                                                     \
+                                                                        \
+            FAST_MATH_SNR_COMPARE_INTERFACE(                            \
+                FAST_MATH_MAX_LEN,                                      \
+                type);                                                  \
+                                                                        \
+            return JTEST_TEST_PASSED;                                   \
+        }
+
+#endif /* _FAST_MATH_TEMPLATES_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/fast_math_tests/fast_math_test_data.h

@@ -0,0 +1,29 @@
+#ifndef _FAST_MATH_TEST_DATA_H_
+#define _FAST_MATH_TEST_DATA_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "arm_math.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+#define FAST_MATH_MAX_LEN 1024
+#define TRANFORM_BIGGEST_INPUT_TYPE float32_t
+
+/*--------------------------------------------------------------------------------*/
+/* Variable Declarations */
+/*--------------------------------------------------------------------------------*/
+
+extern float32_t fast_math_output_fut[FAST_MATH_MAX_LEN];
+extern float32_t fast_math_output_ref[FAST_MATH_MAX_LEN];
+extern float32_t fast_math_output_f32_fut[FAST_MATH_MAX_LEN];
+extern float32_t fast_math_output_f32_ref[FAST_MATH_MAX_LEN];
+extern const float32_t fast_math_f32_inputs[FAST_MATH_MAX_LEN];
+extern const q31_t fast_math_q31_inputs[FAST_MATH_MAX_LEN];
+extern const q15_t * fast_math_q15_inputs;
+
+#endif /* _FAST_MATH_TEST_DATA_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/fast_math_tests/fast_math_test_group.h

@@ -0,0 +1,9 @@
+#ifndef _FAST_MATH_TEST_GROUP_H_
+#define _FAST_MATH_TEST_GROUP_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Test Groups */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(fast_math_tests);
+
+#endif /* _FAST_MATH_TEST_GROUP_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/filtering_tests/filtering_templates.h

@@ -0,0 +1,91 @@
+#ifndef _FILTERING_TEMPLATES_H_
+#define _FILTERING_TEMPLATES_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+#include "test_templates.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Group Specific Templates */
+/*--------------------------------------------------------------------------------*/
+
+/*
+ * Comparison SNR thresholds for the data types used in statistics_tests.
+ */
+#define FILTERING_SNR_THRESHOLD_float64_t 120
+#define FILTERING_SNR_THRESHOLD_float32_t 99
+#define FILTERING_SNR_THRESHOLD_q31_t 90
+#define FILTERING_SNR_THRESHOLD_q15_t 60
+#define FILTERING_SNR_THRESHOLD_q7_t 30
+
+/**
+ *  Compare reference and fut outputs using SNR.
+ *
+ *  @note The outputs are converted to float32_t before comparison.
+ */
+#define FILTERING_SNR_COMPARE_INTERFACE(block_size,                     \
+                                        output_type)                    \
+    FILTERING_SNR_COMPARE_INTERFACE_OFFSET(0, block_size, output_type)
+
+/**
+ *  Compare reference and fut outputs starting at some offset using SNR.
+ */
+#define FILTERING_SNR_COMPARE_INTERFACE_OFFSET(offset,      \
+                                               block_size,  \
+                                               output_type) \
+    do                                                      \
+    {                                                       \
+        TEST_CONVERT_AND_ASSERT_SNR(                        \
+            filtering_output_f32_ref,                       \
+            (output_type *) filtering_output_ref + offset,  \
+            filtering_output_f32_fut,                       \
+            (output_type *) filtering_output_fut + offset,  \
+            block_size,                                     \
+            output_type,                                    \
+            FILTERING_SNR_THRESHOLD_##output_type           \
+            );                                              \
+    } while (0)                                              
+
+/**
+ *  Compare reference and fut outputs starting at some offset using SNR.
+ *  Special case for float64_t
+ */
+#define FILTERING_DBL_SNR_COMPARE_INTERFACE(block_size,  				\
+                                            output_type) 				\
+    do                                                      		\
+    {                                                       		\
+        TEST_ASSERT_DBL_SNR(                        						\
+            (float64_t*)filtering_output_ref,               \
+            (float64_t*)filtering_output_fut,               \
+            block_size,                                     		\
+            FILTERING_SNR_THRESHOLD_##output_type           		\
+            );                                              		\
+    } while (0)                                              
+		
+/*--------------------------------------------------------------------------------*/
+/* Input Interfaces */
+/*--------------------------------------------------------------------------------*/
+/*
+ *  General:
+ *  Input interfaces provide inputs to functions inside test templates.  They
+ *  ONLY provide the inputs.  The output variables should be hard coded.
+ *
+ *  The input interfaces must have the following format:
+ *
+ *  ARM_xxx_INPUT_INTERFACE() or
+ *  REF_xxx_INPUT_INTERFACE()
+ *
+ *  The xxx must be lowercase, and is intended to be the indentifying substring
+ *  in the function's name.  Acceptable values are 'sub' or 'add' from the
+ *  functions arm_add_q31.
+ */
+
+
+/*--------------------------------------------------------------------------------*/
+/* Test Templates */
+/*--------------------------------------------------------------------------------*/
+
+
+
+#endif /* _FILTERING_TEMPLATES_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/filtering_tests/filtering_test_data.h

@@ -0,0 +1,81 @@
+#ifndef FILTERING_TEST_DATA_H
+#define FILTERING_TEST_DATA_H
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "arr_desc.h"
+#include "arm_math.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+#define FILTERING_MAX_BLOCKSIZE  33
+#define LMS_MAX_BLOCKSIZE        512
+#define FILTERING_MAX_NUMTAPS		34
+#define FILTERING_MAX_NUMSTAGES  14
+#define FILTERING_MAX_POSTSHIFT  8
+#define FILTERING_MAX_TAP_DELAY	0xFF
+#define FILTERING_MAX_L				3
+#define FILTERING_MAX_M				33
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Variables */
+/*--------------------------------------------------------------------------------*/
+
+/* Input/Output Buffers */
+extern float32_t filtering_output_fut[LMS_MAX_BLOCKSIZE*2];
+extern float32_t filtering_output_ref[LMS_MAX_BLOCKSIZE*2];
+extern float32_t filtering_output_f32_fut[LMS_MAX_BLOCKSIZE*2];
+extern float32_t filtering_output_f32_ref[LMS_MAX_BLOCKSIZE*2];
+extern float32_t filtering_input_lms[LMS_MAX_BLOCKSIZE*2];
+extern float32_t filtering_pState[LMS_MAX_BLOCKSIZE + FILTERING_MAX_NUMTAPS];
+extern float32_t filtering_scratch[FILTERING_MAX_BLOCKSIZE * 3];
+extern float32_t filtering_scratch2[FILTERING_MAX_BLOCKSIZE * 3];
+extern float32_t filtering_coeffs_lms[FILTERING_MAX_NUMTAPS];
+
+extern const float64_t filtering_f64_inputs[FILTERING_MAX_BLOCKSIZE * FILTERING_MAX_M + FILTERING_MAX_NUMTAPS];
+extern const float32_t filtering_f32_inputs[FILTERING_MAX_BLOCKSIZE * FILTERING_MAX_M + FILTERING_MAX_NUMTAPS];
+extern const q31_t filtering_q31_inputs[FILTERING_MAX_BLOCKSIZE * FILTERING_MAX_M + FILTERING_MAX_NUMTAPS];
+extern const q15_t * filtering_q15_inputs;
+extern const q7_t * filtering_q7_inputs;
+
+/* Block Sizes */
+ARR_DESC_DECLARE(filtering_blocksizes);
+ARR_DESC_DECLARE(lms_blocksizes);
+ARR_DESC_DECLARE(filtering_numtaps);
+ARR_DESC_DECLARE(filtering_numtaps2);
+ARR_DESC_DECLARE(filtering_postshifts);
+ARR_DESC_DECLARE(filtering_numstages);
+ARR_DESC_DECLARE(filtering_Ls);
+ARR_DESC_DECLARE(filtering_Ms);
+
+/* Coefficient Lists */
+extern const float64_t filtering_coeffs_f64[FILTERING_MAX_NUMSTAGES * 6 + 2];
+extern const float64_t filtering_coeffs_b_f64[FILTERING_MAX_NUMSTAGES * 6 + 2];
+extern const float32_t filtering_coeffs_f32[FILTERING_MAX_NUMSTAGES * 6 + 2];
+extern const float32_t filtering_coeffs_b_f32[FILTERING_MAX_NUMSTAGES * 6 + 2];
+extern const float32_t *filtering_coeffs_c_f32;
+extern float32_t filtering_coeffs_lms_f32[FILTERING_MAX_NUMTAPS];
+extern const q31_t filtering_coeffs_q31[FILTERING_MAX_NUMSTAGES * 6 + 2];
+extern const q31_t *filtering_coeffs_b_q31;
+extern const q31_t *filtering_coeffs_c_q31;
+extern q31_t filtering_coeffs_lms_q31[FILTERING_MAX_NUMTAPS];
+extern const q15_t filtering_coeffs_q15[FILTERING_MAX_NUMSTAGES * 6 + 4];
+extern const q15_t *filtering_coeffs_b_q15;
+extern const q15_t *filtering_coeffs_c_q15;
+extern q15_t filtering_coeffs_lms_q15[FILTERING_MAX_NUMTAPS];
+extern const q7_t filtering_coeffs_q7[FILTERING_MAX_NUMSTAGES * 6 + 8];
+extern const q7_t *filtering_coeffs_b_q7;
+extern const q7_t *filtering_coeffs_c_q7;
+
+/* Tap Delay Lists */
+extern const int32_t filtering_tap_delay[FILTERING_MAX_NUMTAPS];
+
+/* Numbers */
+
+/* Float Inputs */
+
+#endif

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/filtering_tests/filtering_test_group.h

@@ -0,0 +1,9 @@
+#ifndef _FILTERING_TEST_GROUP_H_
+#define _FILTERING_TEST_GROUP_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Test Groups */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(filtering_tests);
+
+#endif /* _FILTERING_TEST_GROUP_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/filtering_tests/filtering_tests.h

@@ -0,0 +1,15 @@
+#ifndef _FILTERING_TESTS_H_
+#define _FILTERING_TESTS_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Test/Group Declarations */
+/*--------------------------------------------------------------------------------*/
+
+JTEST_DECLARE_GROUP(biquad_tests);
+JTEST_DECLARE_GROUP(conv_tests);
+JTEST_DECLARE_GROUP(correlate_tests);
+JTEST_DECLARE_GROUP(fir_tests);
+JTEST_DECLARE_GROUP(iir_tests);
+JTEST_DECLARE_GROUP(lms_tests);
+
+#endif /* _FILTERING_TESTS_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/intrinsics_tests/intrinsics_templates.h

@@ -0,0 +1,166 @@
+#ifndef _INTRINSICS_TEMPLATES_H_
+#define _INTRINSICS_TEMPLATES_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "test_templates.h"
+#include <string.h>             /* memcpy() */
+
+/*--------------------------------------------------------------------------------*/
+/* Group Specific Templates */
+/*--------------------------------------------------------------------------------*/
+
+/**
+* Comparison SNR thresholds for the data types used in transform_tests.
+*/
+#define INTRINSICS_SNR_THRESHOLD_q63_t     120
+#define INTRINSICS_SNR_THRESHOLD_q31_t     95
+
+/**
+*  Compare the outputs from the function under test and the reference
+*  function using SNR.
+*/
+#define INTRINSICS_SNR_COMPARE_INTERFACE(block_size,  \
+   output_type)                                       \
+   do                                                 \
+   {                                                  \
+      TEST_CONVERT_AND_ASSERT_SNR(                    \
+         intrinsics_output_f32_ref,                   \
+         (output_type##_t *) intrinsics_output_ref,   \
+         intrinsics_output_f32_fut,                   \
+         (output_type##_t *) intrinsics_output_fut,   \
+         block_size,                                  \
+         output_type,                                 \
+         INTRINSICS_SNR_THRESHOLD_##output_type##_t   \
+      );                                              \
+   } while (0)
+
+
+/*--------------------------------------------------------------------------------*/
+/* TEST Templates */
+/*--------------------------------------------------------------------------------*/
+
+#define INTRINSICS_TEST_TEMPLATE_ELT1(functionName, dataType)              \
+                                                                           \
+   JTEST_DEFINE_TEST(functionName##_test, functionName)                    \
+   {                                                                       \
+      uint32_t i;                                                          \
+                                                                           \
+      JTEST_COUNT_CYCLES(                                                  \
+         for(i=0;i<INTRINSICS_MAX_LEN;i++)                                 \
+         {                                                                 \
+            *((dataType##_t*)intrinsics_output_fut + i) =                  \
+               functionName(                                               \
+                  (dataType##_t)intrinsics_##dataType##_inputs[i]);        \
+         });                                                               \
+                                                                           \
+      for(i=0;i<INTRINSICS_MAX_LEN;i++)                                    \
+      {                                                                    \
+         *((dataType##_t*)intrinsics_output_ref + i) =                     \
+            ref##functionName(                                             \
+               (dataType##_t)intrinsics_##dataType##_inputs[i]);           \
+      }                                                                    \
+                                                                           \
+      INTRINSICS_SNR_COMPARE_INTERFACE(                                    \
+         INTRINSICS_MAX_LEN,                                               \
+         dataType);                                                        \
+                                                                           \
+      return JTEST_TEST_PASSED;                                            \
+   }
+
+#define INTRINSICS_TEST_TEMPLATE_ELT2(functionName, dataType)              \
+                                                                           \
+   JTEST_DEFINE_TEST(functionName##_test, functionName)                    \
+   {                                                                       \
+      uint32_t i;                                                          \
+                                                                           \
+      JTEST_COUNT_CYCLES(                                                  \
+         for(i=0;i<INTRINSICS_MAX_LEN;i++)                                 \
+         {                                                                 \
+            *((dataType##_t*)intrinsics_output_fut + i) =                  \
+               functionName(                                               \
+                  (dataType##_t)intrinsics_##dataType##_inputs[i]          \
+                  ,(dataType##_t)intrinsics_##dataType##_inputs[i]);       \
+         });                                                               \
+                                                                           \
+      for(i=0;i<INTRINSICS_MAX_LEN;i++)                                    \
+      {                                                                    \
+         *((dataType##_t*)intrinsics_output_ref + i) =                     \
+            ref##functionName(                                             \
+               (dataType##_t)intrinsics_##dataType##_inputs[i]             \
+               ,(dataType##_t)intrinsics_##dataType##_inputs[i]);          \
+      }                                                                    \
+                                                                           \
+      INTRINSICS_SNR_COMPARE_INTERFACE(                                    \
+         INTRINSICS_MAX_LEN,                                               \
+         dataType);                                                        \
+                                                                           \
+      return JTEST_TEST_PASSED;                                            \
+   }
+
+#define INTRINSICS_TEST_TEMPLATE_ELT3(functionName, dataType)              \
+                                                                           \
+   JTEST_DEFINE_TEST(functionName##_test, functionName)                    \
+   {                                                                       \
+      uint32_t i;                                                          \
+                                                                           \
+      JTEST_COUNT_CYCLES(                                                  \
+         for(i=0;i<INTRINSICS_MAX_LEN;i++)                                 \
+         {                                                                 \
+            *((dataType##_t*)intrinsics_output_fut + i) =                  \
+               functionName(                                               \
+                  (dataType##_t)intrinsics_##dataType##_inputs[i]          \
+                  ,(dataType##_t)intrinsics_##dataType##_inputs[i]         \
+                  ,(dataType##_t)intrinsics_##dataType##_inputs[i]);       \
+         });                                                               \
+                                                                           \
+      for(i=0;i<INTRINSICS_MAX_LEN;i++)                                    \
+      {                                                                    \
+         *((dataType##_t*)intrinsics_output_ref + i) =                     \
+            ref##functionName(                                             \
+               (dataType##_t)intrinsics_##dataType##_inputs[i]             \
+               ,(dataType##_t)intrinsics_##dataType##_inputs[i]            \
+               ,(dataType##_t)intrinsics_##dataType##_inputs[i]);          \
+      }                                                                    \
+                                                                           \
+      INTRINSICS_SNR_COMPARE_INTERFACE(                                    \
+         INTRINSICS_MAX_LEN,                                               \
+         dataType);                                                        \
+                                                                           \
+      return JTEST_TEST_PASSED;                                            \
+   }
+
+#define INTRINSICS_TEST_TEMPLATE_ELT4(functionName, dataType, dataType2)   \
+   JTEST_DEFINE_TEST(functionName##_test, functionName)                    \
+   {                                                                       \
+      uint32_t i;                                                          \
+                                                                           \
+      JTEST_COUNT_CYCLES(                                                  \
+         for(i=0;i<INTRINSICS_MAX_LEN;i++)                                 \
+         {                                                                 \
+            *((dataType2##_t*)intrinsics_output_fut + i) =                 \
+               functionName(                                               \
+                  (dataType##_t)intrinsics_##dataType##_inputs[i]          \
+                  ,(dataType##_t)intrinsics_##dataType##_inputs[i]         \
+                  ,(dataType2##_t)intrinsics_##dataType2##_inputs[i]);     \
+         });                                                               \
+                                                                           \
+      for(i=0;i<INTRINSICS_MAX_LEN;i++)                                    \
+      {                                                                    \
+         *((dataType2##_t*)intrinsics_output_ref + i) =                    \
+            ref##functionName(                                             \
+               (dataType##_t)intrinsics_##dataType##_inputs[i]             \
+               ,(dataType##_t)intrinsics_##dataType##_inputs[i]            \
+               ,(dataType2##_t)intrinsics_##dataType2##_inputs[i]);        \
+      }                                                                    \
+                                                                           \
+      INTRINSICS_SNR_COMPARE_INTERFACE(                                    \
+         INTRINSICS_MAX_LEN,                                               \
+         dataType2);                                                       \
+                                                                           \
+      return JTEST_TEST_PASSED;                                            \
+   }
+
+#endif /* _INTRINSICS_TEMPLATES_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/intrinsics_tests/intrinsics_test_data.h

@@ -0,0 +1,27 @@
+#ifndef _INTRINSICS_TEST_DATA_H_
+#define _INTRINSICS_TEST_DATA_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "arm_math.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+#define INTRINSICS_MAX_LEN 1024
+
+/*--------------------------------------------------------------------------------*/
+/* Variable Declarations */
+/*--------------------------------------------------------------------------------*/
+
+extern q63_t intrinsics_output_fut[INTRINSICS_MAX_LEN];
+extern q63_t intrinsics_output_ref[INTRINSICS_MAX_LEN];
+extern float32_t intrinsics_output_f32_fut[INTRINSICS_MAX_LEN];
+extern float32_t intrinsics_output_f32_ref[INTRINSICS_MAX_LEN];
+extern const q63_t intrinsics_q63_inputs[INTRINSICS_MAX_LEN];
+extern const q31_t *intrinsics_q31_inputs;
+
+#endif /* _INTRINSICS_TEST_DATA_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/intrinsics_tests/intrinsics_test_group.h

@@ -0,0 +1,9 @@
+#ifndef _INTRINSICS_TEST_GROUP_H_
+#define _INTRINSICS_TEST_GROUP_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Test Groups */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(intrinsics_tests);
+
+#endif /* _INTRINSICS_TEST_GROUP_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/math_helper.h

@@ -0,0 +1,52 @@
+/* ----------------------------------------------------------------------
+* Copyright (C) 2010 ARM Limited. All rights reserved.
+*
+* $Date:        29. November 2010
+* $Revision:    V1.0.3
+*
+* Project:      CMSIS DSP Library
+*
+* Title:        math_helper.h
+*
+*
+* Description:	Prototypes of all helper functions required.
+*
+* Target Processor: Cortex-M4/Cortex-M3
+*
+* Version 1.0.3 2010/11/29
+*    Re-organized the CMSIS folders and updated documentation.
+*
+* Version 1.0.2 2010/11/11
+*    Documentation updated.
+*
+* Version 1.0.1 2010/10/05
+*    Production release and review comments incorporated.
+*
+* Version 1.0.0 2010/09/20
+*    Production release and review comments incorporated.
+*
+* Version 0.0.7  2010/06/10
+*    Misra-C changes done
+* -------------------------------------------------------------------- */
+
+#ifndef MATH_HELPER_H
+#define MATH_HELPER_H
+
+#include "arm_math.h"
+
+float arm_snr_f32(float *pRef, float *pTest,  uint32_t buffSize);
+double arm_snr_f64(double *pRef, double *pTest,  uint32_t buffSize);
+void arm_float_to_q12_20(float *pIn, q31_t * pOut, uint32_t numSamples);
+void arm_provide_guard_bits_q15(q15_t *input_buf, uint32_t blockSize, uint32_t guard_bits);
+void arm_provide_guard_bits_q31(q31_t *input_buf, uint32_t blockSize, uint32_t guard_bits);
+void arm_float_to_q14(float *pIn, q15_t *pOut, uint32_t numSamples);
+void arm_float_to_q29(float *pIn, q31_t *pOut, uint32_t numSamples);
+void arm_float_to_q28(float *pIn, q31_t *pOut, uint32_t numSamples);
+void arm_float_to_q30(float *pIn, q31_t *pOut, uint32_t numSamples);
+void arm_clip_f32(float *pIn, uint32_t numSamples);
+uint32_t arm_calc_guard_bits(uint32_t num_adds);
+void arm_apply_guard_bits (float32_t * pIn, uint32_t numSamples, uint32_t guard_bits);
+uint32_t arm_compare_fixed_q15(q15_t *pIn, q15_t * pOut, uint32_t numSamples);
+uint32_t arm_compare_fixed_q31(q31_t *pIn, q31_t *pOut, uint32_t numSamples);
+uint32_t arm_calc_2pow(uint32_t guard_bits);
+#endif

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/matrix_tests/matrix_templates.h

@@ -0,0 +1,370 @@
+#ifndef _MATRIX_TEMPLATES_H_
+#define _MATRIX_TEMPLATES_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+#include "test_templates.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Group Specific Templates */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Compare the outputs from the function under test and the reference
+ *  function.
+ */
+#define MATRIX_COMPARE_INTERFACE(output_type, output_content_type)  \
+    TEST_ASSERT_BUFFERS_EQUAL(                                      \
+        ((output_type *) &matrix_output_ref)->pData,                \
+        ((output_type *) &matrix_output_fut)->pData,                \
+        ((output_type *) &matrix_output_fut)->numRows *             \
+        ((output_type *) &matrix_output_ref)->numCols *             \
+        sizeof(output_content_type))
+
+/**
+ * Comparison SNR thresholds for the data types used in matrix_tests.
+ */
+#define MATRIX_SNR_THRESHOLD 120
+
+/**
+ *  Compare the outputs from the function under test and the reference
+ *  function using SNR.
+ */
+#define MATRIX_SNR_COMPARE_INTERFACE(output_type, output_content_type)  \
+    do                                                                  \
+    {                                                                   \
+        TEST_CONVERT_AND_ASSERT_SNR(                                    \
+            (float32_t *)matrix_output_f32_ref,                         \
+            ((output_type *) &matrix_output_ref)->pData,                \
+            (float32_t *)matrix_output_f32_fut,                         \
+            ((output_type *) &matrix_output_ref)->pData,                \
+            ((output_type *) &matrix_output_fut)->numRows *             \
+            ((output_type *) &matrix_output_ref)->numCols,              \
+            output_content_type,                                        \
+            MATRIX_SNR_THRESHOLD                                        \
+            );                                                          \
+    } while (0)
+
+/**
+ *  Compare the outputs from the function under test and the reference
+ *  function using SNR. This is special for float64_t
+ */
+#define MATRIX_DBL_SNR_COMPARE_INTERFACE(output_type)                   \
+    do                                                                  \
+    {                                                                   \
+        TEST_ASSERT_DBL_SNR(                                            \
+            (float64_t *)matrix_output_f32_ref,                         \
+            (float64_t *)matrix_output_f32_fut,                         \
+            ((output_type *) &matrix_output_fut)->numRows *             \
+            ((output_type *) &matrix_output_ref)->numCols,              \
+            MATRIX_SNR_THRESHOLD                                        \
+            );                                                          \
+    } while (0)
+
+/*--------------------------------------------------------------------------------*/
+/* Input Interfaces */
+/*--------------------------------------------------------------------------------*/
+/*
+ *  General:
+ *  Input interfaces provide inputs to functions inside test templates.  They
+ *  ONLY provide the inputs.  The output variables should be hard coded.
+ *
+ *  The input interfaces must have the following format:
+ *
+ *  ARM_xxx_INPUT_INTERFACE() or
+ *  REF_xxx_INPUT_INTERFACE()
+ *
+ *  The xxx must be lowercase, and is intended to be the indentifying substring
+ *  in the function's name.  Acceptable values are 'sub' or 'add' from the
+ *  functions arm_add_q31.
+ */
+
+#define ARM_mat_add_INPUT_INTERFACE(input_a_ptr, input_b_ptr)    \
+    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
+
+#define REF_mat_add_INPUT_INTERFACE(input_a_ptr, input_b_ptr)    \
+    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
+
+#define ARM_mat_cmplx_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr)    \
+    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
+
+#define REF_mat_cmplx_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr)    \
+    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
+
+#define ARM_mat_inverse_INPUT_INTERFACE(input_ptr)  \
+    PAREN(input_ptr, (void *) &matrix_output_fut)
+
+#define REF_mat_inverse_INPUT_INTERFACE(input_ptr)  \
+    PAREN(input_ptr, (void *) &matrix_output_ref)
+
+#define ARM_mat_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr)      \
+    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
+
+#define REF_mat_mult_INPUT_INTERFACE(input_a_ptr, input_b_ptr)      \
+    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
+
+#define ARM_mat_mult_fast_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
+    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
+
+#define REF_mat_mult_fast_INPUT_INTERFACE(input_a_ptr, input_b_ptr) \
+    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
+
+#define ARM_mat_sub_INPUT_INTERFACE(input_a_ptr, input_b_ptr)    \
+    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_fut)
+
+#define REF_mat_sub_INPUT_INTERFACE(input_a_ptr, input_b_ptr)    \
+    PAREN(input_a_ptr, input_b_ptr, (void *) &matrix_output_ref)
+
+#define ARM_mat_trans_INPUT_INTERFACE(input_ptr)    \
+    PAREN(input_ptr, (void *) &matrix_output_fut)
+
+#define REF_mat_trans_INPUT_INTERFACE(input_ptr)    \
+    PAREN(input_ptr, (void *) &matrix_output_ref)
+
+/*--------------------------------------------------------------------------------*/
+/* Dimension Validation Interfaces */
+/*--------------------------------------------------------------------------------*/
+
+#define MATRIX_TEST_VALID_ADDITIVE_DIMENSIONS(input_type,   \
+                                              matrix_a_ptr, \
+                                              matrix_b_ptr) \
+    ((((input_type) (matrix_a_ptr))->numRows ==             \
+      ((input_type) (matrix_b_ptr))->numRows) &&            \
+     (((input_type) (matrix_a_ptr))->numCols ==             \
+      ((input_type) (matrix_b_ptr))->numCols))
+
+#define MATRIX_TEST_VALID_MULTIPLICATIVE_DIMENSIONS(input_type,     \
+                                                    matrix_a_ptr,   \
+                                                    matrix_b_ptr)   \
+    (((input_type) (matrix_a_ptr))->numCols ==                      \
+     ((input_type) (matrix_b_ptr))->numRows)
+
+#define MATRIX_TEST_VALID_SQUARE_DIMENSIONS(input_type, \
+                                            matrix_ptr) \
+    (((input_type)(matrix_ptr))->numRows ==             \
+     ((input_type)(matrix_ptr))->numCols)
+
+#define MATRIX_TEST_VALID_DIMENSIONS_ALWAYS(input_type, \
+                                            matrix_ptr) \
+    (1 == 1)                                            \
+
+/*--------------------------------------------------------------------------------*/
+/* Output Configuration Interfaces */
+/*--------------------------------------------------------------------------------*/
+/* The matrix tests assume the output matrix is always the correct size.  These
+ * interfaces size the properly size the output matrices according to the input
+ * matrices and the operation at hand.*/
+
+#define MATRIX_TEST_CONFIG_ADDITIVE_OUTPUT(input_type,      \
+                                           matrix_a_ptr,    \
+                                           matrix_b_ptr)    \
+    do                                                      \
+    {                                                       \
+        ((input_type) &matrix_output_fut)->numRows =        \
+            ((input_type)(matrix_a_ptr))->numRows;          \
+        ((input_type) &matrix_output_fut)->numCols =        \
+            ((input_type)(matrix_a_ptr))->numCols;          \
+        ((input_type) &matrix_output_ref)->numRows =        \
+            ((input_type)(matrix_a_ptr))->numRows;          \
+        ((input_type) &matrix_output_ref)->numCols =        \
+            ((input_type)(matrix_a_ptr))->numCols;          \
+    } while (0)
+
+#define MATRIX_TEST_CONFIG_MULTIPLICATIVE_OUTPUT(input_type,    \
+                                                 matrix_a_ptr,  \
+                                                 matrix_b_ptr)  \
+    do                                                          \
+    {                                                           \
+        ((input_type) &matrix_output_fut)->numRows =            \
+            ((input_type)(matrix_a_ptr))->numRows;              \
+        ((input_type) &matrix_output_fut)->numCols =            \
+            ((input_type)(matrix_b_ptr))->numCols;              \
+        ((input_type) &matrix_output_ref)->numRows =            \
+            ((input_type)(matrix_a_ptr))->numRows;              \
+        ((input_type) &matrix_output_ref)->numCols =            \
+            ((input_type)(matrix_b_ptr))->numCols;              \
+    } while (0)
+
+#define MATRIX_TEST_CONFIG_SAMESIZE_OUTPUT(input_type,  \
+                                           matrix_ptr)  \
+    do                                                  \
+    {                                                   \
+        ((input_type) &matrix_output_fut)->numRows =    \
+            ((input_type)(matrix_ptr))->numRows;        \
+        ((input_type) &matrix_output_fut)->numCols =    \
+            ((input_type)(matrix_ptr))->numCols;        \
+        ((input_type) &matrix_output_ref)->numRows =    \
+            ((input_type)(matrix_ptr))->numRows;        \
+        ((input_type) &matrix_output_ref)->numCols =    \
+            ((input_type)(matrix_ptr))->numCols;        \
+    } while (0)
+
+#define MATRIX_TEST_CONFIG_TRANSPOSE_OUTPUT(input_type,     \
+                                            matrix_ptr)     \
+        do                                                  \
+        {                                                   \
+            ((input_type) &matrix_output_fut)->numRows =    \
+                ((input_type)(matrix_ptr))->numCols;        \
+            ((input_type) &matrix_output_fut)->numCols =    \
+                ((input_type)(matrix_ptr))->numRows;        \
+            ((input_type) &matrix_output_ref)->numRows =    \
+                ((input_type)(matrix_ptr))->numCols;        \
+            ((input_type) &matrix_output_ref)->numCols =    \
+                ((input_type)(matrix_ptr))->numRows;        \
+        } while (0)
+
+/*--------------------------------------------------------------------------------*/
+/* TEST Templates */
+/*--------------------------------------------------------------------------------*/
+
+#define MATRIX_TEST_TEMPLATE_ELT1(arr_desc_inputs,                      \
+                                  input_type,                           \
+                                  output_type, output_content_type,     \
+                                  fut, fut_arg_interface,               \
+                                  ref, ref_arg_interface,               \
+                                  output_config_interface,              \
+                                  dim_validation_interface,             \
+                                  compare_interface)                    \
+    do                                                                  \
+    {                                                                   \
+        TEMPLATE_DO_ARR_DESC(                                           \
+            input_idx, input_type, input, arr_desc_inputs               \
+            ,                                                           \
+            JTEST_DUMP_STRF("Matrix Dimensions: %dx%d\n",               \
+                         (int)input->numRows,                           \
+                         (int)input->numCols);                          \
+                                                                        \
+            if (dim_validation_interface(input_type,                     \
+                                        input)) {                       \
+                output_config_interface(input_type,                     \
+                                        input);                         \
+                TEST_CALL_FUT_AND_REF(                                  \
+                    fut, fut_arg_interface(input),                      \
+                    ref, ref_arg_interface(input));                     \
+                compare_interface(output_type,                          \
+                                  output_content_type);                 \
+            } else {                                                    \
+                arm_status matrix_test_retval;                          \
+                TEST_CALL_FUT(                                          \
+                    matrix_test_retval = fut,                           \
+                    fut_arg_interface(input));                          \
+                                                                        \
+                /* If dimensions are known bad, the fut should */       \
+                /* detect it. */                                        \
+                if ( matrix_test_retval != ARM_MATH_SIZE_MISMATCH) {     \
+                    return JTEST_TEST_FAILED;                           \
+                }                                                       \
+            });                                                         \
+        return JTEST_TEST_PASSED;                                       \
+    } while (0)
+
+
+#define MATRIX_TEST_TEMPLATE_ELT2(arr_desc_inputs_a,                    \
+                                  arr_desc_inputs_b,                    \
+                                  input_type,                           \
+                                  output_type, output_content_type,     \
+                                  fut, fut_arg_interface,               \
+                                  ref, ref_arg_interface,               \
+                                  output_config_interface,              \
+                                  dim_validation_interface,             \
+                                  compare_interface)                    \
+    do                                                                  \
+    {                                                                   \
+        TEMPLATE_DO_ARR_DESC(                                           \
+            input_a_idx, input_type, input_a, arr_desc_inputs_a         \
+            ,                                                           \
+            input_type input_b = ARR_DESC_ELT(                          \
+                input_type, input_a_idx,                                \
+                &(arr_desc_inputs_b));                                  \
+                                                                        \
+            JTEST_DUMP_STRF("Matrix Dimensions: A %dx%d  B %dx%d\n",    \
+                     (int)input_a->numRows,                             \
+                     (int)input_a->numCols,                             \
+                     (int)input_b->numRows,                             \
+                     (int)input_b->numCols);                            \
+                                                                        \
+            if (dim_validation_interface(input_type,                     \
+                                        input_a,                        \
+                                        input_b)) {                     \
+                                                                        \
+                output_config_interface(input_type,                     \
+                                        input_a,                        \
+                                        input_b);                       \
+                                                                        \
+                TEST_CALL_FUT_AND_REF(                                  \
+                    fut, fut_arg_interface(input_a, input_b),           \
+                    ref, ref_arg_interface(input_a, input_b));          \
+                                                                        \
+                compare_interface(output_type, output_content_type);    \
+                                                                        \
+            } else {                                                    \
+                arm_status matrix_test_retval;                          \
+                TEST_CALL_FUT(                                          \
+                    matrix_test_retval = fut, fut_arg_interface(input_a, input_b)); \
+                                                                        \
+                /* If dimensions are known bad, the fut should */       \
+                /* detect it. */                                        \
+                if ( matrix_test_retval != ARM_MATH_SIZE_MISMATCH) {     \
+                    return JTEST_TEST_FAILED;                           \
+                }                                                       \
+            });                                                         \
+        return JTEST_TEST_PASSED;                                       \
+    } while (0)
+
+/**
+ *  Specialization of #MATRIX_TEST_TEMPLATE_ELT2() for matrix tests.
+ *
+ *  @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
+ *  REF_xxx_INPUT_INTERFACEs.
+ */
+#define MATRIX_DEFINE_TEST_TEMPLATE_ELT2(fn_name, suffix,           \
+                                         output_config_interface,   \
+                                         dim_validation_interface,  \
+                                         comparison_interface)      \
+        JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test,          \
+                          arm_##fn_name##_##suffix)                 \
+        {                                                           \
+            MATRIX_TEST_TEMPLATE_ELT2(                              \
+                matrix_##suffix##_a_inputs,                         \
+                matrix_##suffix##_b_inputs,                         \
+                arm_matrix_instance_##suffix * ,                    \
+                arm_matrix_instance_##suffix,                       \
+                TYPE_FROM_ABBREV(suffix),                           \
+                arm_##fn_name##_##suffix,                           \
+                ARM_##fn_name##_INPUT_INTERFACE,                    \
+                ref_##fn_name##_##suffix,                           \
+                REF_##fn_name##_INPUT_INTERFACE,                    \
+                output_config_interface,                            \
+                dim_validation_interface,                           \
+                comparison_interface);                              \
+        }                                                           \
+
+/**
+ *  Specialization of #MATRIX_TEST_TEMPLATE_ELT1() for matrix tests.
+ *
+ *  @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
+ *  REF_xxx_INPUT_INTERFACEs.
+ */
+#define MATRIX_DEFINE_TEST_TEMPLATE_ELT1(fn_name, suffix,           \
+                                         output_config_interface,   \
+                                         dim_validation_interface)  \
+        JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test,          \
+                          arm_##fn_name##_##suffix)                 \
+        {                                                           \
+            MATRIX_TEST_TEMPLATE_ELT1(                              \
+                matrix_##suffix##_a_inputs,                         \
+                arm_matrix_instance_##suffix * ,                    \
+                arm_matrix_instance_##suffix,                       \
+                TYPE_FROM_ABBREV(suffix),                           \
+                arm_##fn_name##_##suffix,                           \
+                ARM_##fn_name##_INPUT_INTERFACE,                    \
+                ref_##fn_name##_##suffix,                           \
+                REF_##fn_name##_INPUT_INTERFACE,                    \
+                output_config_interface,                            \
+                dim_validation_interface,                           \
+                MATRIX_COMPARE_INTERFACE);                          \
+        }                                                           \
+
+
+#endif /* _MATRIX_TEMPLATES_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/matrix_tests/matrix_test_data.h

@@ -0,0 +1,54 @@
+#ifndef _MATRIX_TEST_DATA_H_
+#define _MATRIX_TEST_DATA_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "arr_desc.h"
+#include "arm_math.h"           /* float32_t */
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+#define MATRIX_TEST_MAX_ROWS 4
+#define MATRIX_TEST_MAX_COLS 4
+#define MATRIX_TEST_BIGGEST_INPUT_TYPE float64_t
+#define MATRIX_TEST_MAX_ELTS (MATRIX_TEST_MAX_ROWS * MATRIX_TEST_MAX_COLS)
+#define MATRIX_MAX_COEFFS_LEN 16
+#define MATRIX_MAX_SHIFTS_LEN 5
+
+/**
+ *  Declare the matrix inputs defined by MATRIX_DEFINE_INPUTS.
+ */
+#define MATRIX_DECLARE_INPUTS(suffix)               \
+    ARR_DESC_DECLARE(matrix_##suffix##_a_inputs);   \
+    ARR_DESC_DECLARE(matrix_##suffix##_b_inputs);   \
+    ARR_DESC_DECLARE(matrix_##suffix##_invertible_inputs)
+
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Variables */
+/*--------------------------------------------------------------------------------*/
+
+/* Input/Output Buffers */
+extern arm_matrix_instance_f32 matrix_output_fut;
+extern arm_matrix_instance_f32 matrix_output_ref;
+extern arm_matrix_instance_f64 matrix_output_fut64;
+extern arm_matrix_instance_f64 matrix_output_ref64;
+extern MATRIX_TEST_BIGGEST_INPUT_TYPE matrix_output_f32_fut[MATRIX_TEST_MAX_ELTS];
+extern MATRIX_TEST_BIGGEST_INPUT_TYPE matrix_output_f32_ref[MATRIX_TEST_MAX_ELTS];
+extern MATRIX_TEST_BIGGEST_INPUT_TYPE matrix_output_scratch[MATRIX_TEST_MAX_ELTS];
+
+/* Matrix Inputs */
+MATRIX_DECLARE_INPUTS(f64);
+MATRIX_DECLARE_INPUTS(f32);
+MATRIX_DECLARE_INPUTS(q31);
+MATRIX_DECLARE_INPUTS(q15);
+
+extern const float32_t matrix_f32_scale_values[MATRIX_MAX_COEFFS_LEN];
+extern const q31_t matrix_q31_scale_values[MATRIX_MAX_COEFFS_LEN];
+extern const q15_t matrix_q15_scale_values[MATRIX_MAX_COEFFS_LEN];
+extern const int32_t matrix_shift_values[MATRIX_MAX_SHIFTS_LEN];
+
+#endif /* _MATRIX_TEST_DATA_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/matrix_tests/matrix_test_group.h

@@ -0,0 +1,9 @@
+#ifndef _MATRIX_TEST_GROUP_H_
+#define _MATRIX_TEST_GROUP_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Test Groups */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(matrix_tests);
+
+#endif /* _MATRIX_TEST_GROUP_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/matrix_tests/matrix_tests.h

@@ -0,0 +1,17 @@
+#ifndef _MATRIX_TESTS_H_
+#define _MATRIX_TESTS_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Test/Group Declarations */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(mat_add_tests);
+JTEST_DECLARE_GROUP(mat_cmplx_mult_tests);
+JTEST_DECLARE_GROUP(mat_init_tests);
+JTEST_DECLARE_GROUP(mat_inverse_tests);
+JTEST_DECLARE_GROUP(mat_mult_tests);
+JTEST_DECLARE_GROUP(mat_mult_fast_tests);
+JTEST_DECLARE_GROUP(mat_sub_tests);
+JTEST_DECLARE_GROUP(mat_trans_tests);
+JTEST_DECLARE_GROUP(mat_scale_tests);
+
+#endif /* _MATRIX_TESTS_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/statistics_tests/statistics_templates.h

@@ -0,0 +1,157 @@
+#ifndef _STATISTICS_TEMPLATES_H_
+#define _STATISTICS_TEMPLATES_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "test_templates.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Group Specific Templates */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Compare the outputs from the function under test and the reference function.
+ */
+#define STATISTICS_COMPARE_INTERFACE(block_size,    \
+                                     output_type)   \
+    do                                              \
+    {                                               \
+        TEST_ASSERT_BUFFERS_EQUAL(                  \
+            statistics_output_ref.data_ptr,         \
+            statistics_output_fut.data_ptr,         \
+            1 * sizeof(output_type) /* All fns return one value*/   \
+            );                                      \
+        TEST_ASSERT_EQUAL(                          \
+            statistics_idx_fut,                     \
+            statistics_idx_ref);                    \
+    } while (0)                                      \
+
+/*
+ * Comparison SNR thresholds for the data types used in statistics_tests.
+ */
+#define STATISTICS_SNR_THRESHOLD_float32_t 120
+#define STATISTICS_SNR_THRESHOLD_q31_t 100
+#define STATISTICS_SNR_THRESHOLD_q15_t 60
+#define STATISTICS_SNR_THRESHOLD_q7_t 30
+
+/**
+ *  Compare reference and fut outputs using SNR.
+ *
+ *  @note The outputs are converted to float32_t before comparison.
+ */
+#define STATISTICS_SNR_COMPARE_INTERFACE(block_size,    \
+                                         output_type)   \
+    do                                                  \
+    {                                                   \
+        TEST_CONVERT_AND_ASSERT_SNR(                    \
+            statistics_output_f32_ref,                  \
+            statistics_output_ref.data_ptr,             \
+            statistics_output_f32_fut,                  \
+            statistics_output_fut.data_ptr,             \
+                1, /* All fns return one element*/      \
+            output_type,                                \
+            STATISTICS_SNR_THRESHOLD_##output_type      \
+            );                                          \
+    } while (0)
+
+
+
+/*--------------------------------------------------------------------------------*/
+/* Input Interfaces */
+/*--------------------------------------------------------------------------------*/
+/*
+ *  General:
+ *  Input interfaces provide inputs to functions inside test templates.  They
+ *  ONLY provide the inputs.  The output variables should be hard coded.
+ *
+ *  The input interfaces must have the following format:
+ *
+ *  ARM_xxx_INPUT_INTERFACE() or
+ *  REF_xxx_INPUT_INTERFACE()
+ *
+ *  The xxx must be lowercase, and is intended to be the indentifying substring
+ *  in the function's name.  Acceptable values are 'sub' or 'add' from the
+ *  functions arm_add_q31.
+ */
+
+#define ARM_max_INPUT_INTERFACE(input, block_size)              \
+    PAREN(input, block_size,                                    \
+          statistics_output_fut.data_ptr, &statistics_idx_fut)
+
+#define REF_max_INPUT_INTERFACE(input, block_size)              \
+    PAREN(input, block_size,                                    \
+          statistics_output_ref.data_ptr, &statistics_idx_ref)
+
+#define ARM_mean_INPUT_INTERFACE(input, block_size)             \
+    PAREN(input, block_size, statistics_output_fut.data_ptr)
+
+#define REF_mean_INPUT_INTERFACE(input, block_size)             \
+    PAREN(input, block_size, statistics_output_ref.data_ptr)
+
+#define ARM_min_INPUT_INTERFACE(input, block_size)              \
+    PAREN(input, block_size,                                    \
+          statistics_output_fut.data_ptr, &statistics_idx_fut)
+
+#define REF_min_INPUT_INTERFACE(input, block_size)              \
+    PAREN(input, block_size,                                    \
+          statistics_output_ref.data_ptr, &statistics_idx_ref)
+
+#define ARM_power_INPUT_INTERFACE(input, block_size)            \
+    PAREN(input, block_size, statistics_output_fut.data_ptr)
+
+#define REF_power_INPUT_INTERFACE(input, block_size)            \
+    PAREN(input, block_size, statistics_output_ref.data_ptr)
+
+#define ARM_rms_INPUT_INTERFACE(input, block_size)              \
+    PAREN(input, block_size, statistics_output_fut.data_ptr)
+
+#define REF_rms_INPUT_INTERFACE(input, block_size)              \
+    PAREN(input, block_size, statistics_output_ref.data_ptr)
+
+#define ARM_std_INPUT_INTERFACE(input, block_size)              \
+    PAREN(input, block_size, statistics_output_fut.data_ptr)
+
+#define REF_std_INPUT_INTERFACE(input, block_size)              \
+    PAREN(input, block_size, statistics_output_ref.data_ptr)
+
+#define ARM_var_INPUT_INTERFACE(input, block_size)              \
+    PAREN(input, block_size, statistics_output_fut.data_ptr)
+
+#define REF_var_INPUT_INTERFACE(input, block_size)              \
+    PAREN(input, block_size, statistics_output_ref.data_ptr)
+
+
+/*--------------------------------------------------------------------------------*/
+/* Test Templates */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Specialization of #TEST_TEMPLATE_BUF1_BLK() for statistics tests.
+ *
+ *  @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
+ *  REF_xxx_INPUT_INTERFACEs.
+ */
+#define STATISTICS_DEFINE_TEST_TEMPLATE_BUF1_BLK(fn_name,       \
+                                                 suffix,        \
+                                                 input_type,    \
+                                                 output_type,   \
+                                                 comparison_interface)  \
+    JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test,          \
+                      arm_##fn_name##_##suffix)                 \
+    {                                                           \
+        TEST_TEMPLATE_BUF1_BLK(                                 \
+            statistics_f_all,                                   \
+            statistics_block_sizes,                             \
+            input_type,                                         \
+            output_type,                                        \
+            arm_##fn_name##_##suffix,                           \
+            ARM_##fn_name##_INPUT_INTERFACE,                    \
+            ref_##fn_name##_##suffix,                           \
+            REF_##fn_name##_INPUT_INTERFACE,                    \
+            comparison_interface);                              \
+    }
+
+
+#endif /* _STATISTICS_TEMPLATES_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/statistics_tests/statistics_test_data.h

@@ -0,0 +1,44 @@
+#ifndef _STATISTICS_TEST_DATA_H_
+#define _STATISTICS_TEST_DATA_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "arr_desc.h"
+#include "arm_math.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+#define STATISTICS_MAX_INPUT_ELEMENTS 32
+#define STATISTICS_BIGGEST_INPUT_TYPE float32_t
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Variables */
+/*--------------------------------------------------------------------------------*/
+
+/* Input/Output Buffers */
+ARR_DESC_DECLARE(statistics_output_fut);
+ARR_DESC_DECLARE(statistics_output_ref);
+extern uint32_t statistics_idx_fut;
+extern uint32_t statistics_idx_ref;
+
+extern STATISTICS_BIGGEST_INPUT_TYPE
+statistics_output_f32_ref[STATISTICS_MAX_INPUT_ELEMENTS];
+
+extern STATISTICS_BIGGEST_INPUT_TYPE
+statistics_output_f32_fut[STATISTICS_MAX_INPUT_ELEMENTS];
+
+
+/* Block Sizes */
+ARR_DESC_DECLARE(statistics_block_sizes);
+
+/* Float Inputs */
+ARR_DESC_DECLARE(statistics_zeros);
+ARR_DESC_DECLARE(statistics_f_2);
+ARR_DESC_DECLARE(statistics_f_15);
+ARR_DESC_DECLARE(statistics_f_32);
+ARR_DESC_DECLARE(statistics_f_all);
+
+#endif /* _STATISTICS_TEST_DATA_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/statistics_tests/statistics_test_group.h

@@ -0,0 +1,9 @@
+#ifndef _STATISTICS_TEST_GROUP_H_
+#define _STATISTICS_TEST_GROUP_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Test Groups */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(statistics_tests);
+
+#endif /* _STATISTICS_TEST_GROUP_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/statistics_tests/statistics_tests.h

@@ -0,0 +1,15 @@
+#ifndef _STATISTICS_TESTS_H_
+#define _STATISTICS_TESTS_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Test/Group Declarations */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(max_tests);
+JTEST_DECLARE_GROUP(mean_tests);
+JTEST_DECLARE_GROUP(min_tests);
+JTEST_DECLARE_GROUP(power_tests);
+JTEST_DECLARE_GROUP(rms_tests);
+JTEST_DECLARE_GROUP(std_tests);
+JTEST_DECLARE_GROUP(var_tests);
+
+#endif /* _STATISTICS_TESTS_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/support_tests/support_templates.h

@@ -0,0 +1,120 @@
+#ifndef _SUPPORT_TEMPLATES_H_
+#define _SUPPORT_TEMPLATES_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "test_templates.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Group Specific Templates */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Compare the outputs from the function under test and the reference function.
+ */
+#define SUPPORT_COMPARE_INTERFACE(block_size,   \
+                                  output_type)  \
+    do                                          \
+    {                                           \
+        TEST_ASSERT_BUFFERS_EQUAL(              \
+            support_output_ref.data_ptr,        \
+            support_output_fut.data_ptr,        \
+            block_size * sizeof(output_type));  \
+    } while (0)                                  \
+
+/*--------------------------------------------------------------------------------*/
+/* Input Interfaces */
+/*--------------------------------------------------------------------------------*/
+/*
+ *  General:
+ *  Input interfaces provide inputs to functions inside test templates.  They
+ *  ONLY provide the inputs.  The output variables should be hard coded.
+ *
+ *  The input interfaces must have the following format:
+ *
+ *  ARM_xxx_INPUT_INTERFACE() or
+ *  REF_xxx_INPUT_INTERFACE()
+ *
+ *  The xxx must be lowercase, and is intended to be the indentifying substring
+ *  in the function's name.  Acceptable values are 'sub' or 'add' from the
+ *  functions arm_add_q31.
+ */
+
+#define ARM_copy_INPUT_INTERFACE(input, block_size)         \
+    PAREN(input, support_output_fut.data_ptr, block_size)
+
+#define REF_copy_INPUT_INTERFACE(input, block_size)         \
+    PAREN(input, support_output_ref.data_ptr, block_size)
+
+#define ARM_fill_INPUT_INTERFACE(elt, block_size)       \
+    PAREN(elt, support_output_fut.data_ptr, block_size)
+
+#define REF_fill_INPUT_INTERFACE(elt, block_size)       \
+    PAREN(elt, support_output_ref.data_ptr, block_size)
+
+#define ARM_x_to_y_INPUT_INTERFACE(input, block_size)       \
+    PAREN(input, support_output_fut.data_ptr, block_size)
+
+#define REF_x_to_y_INPUT_INTERFACE(input, block_size)       \
+    PAREN(input, support_output_ref.data_ptr, block_size)
+
+/*--------------------------------------------------------------------------------*/
+/* Test Templates */
+/*--------------------------------------------------------------------------------*/
+
+
+/**
+ *  Specialization of #TEST_TEMPLATE_BUF1_BLK() for support tests.
+ *
+ *  @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
+ *  REF_xxx_INPUT_INTERFACEs.
+ */
+#define SUPPORT_DEFINE_TEST_TEMPLATE_BUF1_BLK(fn_name,              \
+                                              suffix,               \
+                                              input_type,           \
+                                              output_type,          \
+                                              comparison_interface) \
+    JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test,              \
+                      arm_##fn_name##_##suffix)                     \
+    {                                                               \
+        TEST_TEMPLATE_BUF1_BLK(                                     \
+            support_f_all,                                          \
+            support_block_sizes,                                    \
+            input_type,                                             \
+            output_type,                                            \
+            arm_##fn_name##_##suffix,                               \
+            ARM_##fn_name##_INPUT_INTERFACE,                        \
+            ref_##fn_name##_##suffix,                               \
+            REF_##fn_name##_INPUT_INTERFACE,                        \
+            comparison_interface);                                  \
+    }
+
+/**
+ *  Specialization of #TEST_TEMPLATE_ELT1_BLK() for support tests.
+ *
+ *  @note This macro relies on the existance of ARM_xxx_INPUT_INTERFACE and
+ *  REF_xxx_INPUT_INTERFACEs.
+ */
+#define SUPPORT_DEFINE_TEST_TEMPLATE_ELT1_BLK(fn_name,              \
+                                              suffix,               \
+                                              elt_type,             \
+                                              output_type,          \
+                                              comparison_interface) \
+    JTEST_DEFINE_TEST(arm_##fn_name##_##suffix##_test,              \
+                      arm_##fn_name##_##suffix)                     \
+    {                                                               \
+        TEST_TEMPLATE_ELT1_BLK(                                     \
+            support_elts,                                           \
+            support_block_sizes,                                    \
+            elt_type,                                               \
+            output_type,                                            \
+            arm_##fn_name##_##suffix,                               \
+            ARM_##fn_name##_INPUT_INTERFACE,                        \
+            ref_##fn_name##_##suffix,                               \
+            REF_##fn_name##_INPUT_INTERFACE,                        \
+            comparison_interface);                                  \
+    }
+
+#endif /* _SUPPORT_TEMPLATES_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/support_tests/support_test_data.h

@@ -0,0 +1,31 @@
+#ifndef ARM_SUPPORT_TEST_DATA_H
+#define ARM_SUPPORT_TEST_DATA_H
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "arr_desc.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Variables */
+/*--------------------------------------------------------------------------------*/
+
+/* Input/Output Buffers */
+ARR_DESC_DECLARE(support_output_fut);
+ARR_DESC_DECLARE(support_output_ref);
+
+/* Block Sizes*/
+ARR_DESC_DECLARE(support_block_sizes);
+
+/* Numbers */
+ARR_DESC_DECLARE(support_elts);
+
+/* Float Inputs */
+ARR_DESC_DECLARE(support_zeros);
+ARR_DESC_DECLARE(support_f_2);
+ARR_DESC_DECLARE(support_f_15);
+ARR_DESC_DECLARE(support_f_32);
+ARR_DESC_DECLARE(support_f_all);
+
+#endif

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/support_tests/support_test_group.h

@@ -0,0 +1,9 @@
+#ifndef _SUPPORT_TEST_GROUP_H_
+#define _SUPPORT_TEST_GROUP_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Test Groups */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(support_tests);
+
+#endif /* _SUPPORT_TEST_GROUP_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/support_tests/support_tests.h

@@ -0,0 +1,11 @@
+#ifndef _SUPPORT_TESTS_H_
+#define _SUPPORT_TESTS_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Test/Group Declarations */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(copy_tests);
+JTEST_DECLARE_GROUP(fill_tests);
+JTEST_DECLARE_GROUP(x_to_y_tests);
+
+#endif /* _SUPPORT_TESTS_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/templates/template.h

@@ -0,0 +1,88 @@
+#ifndef _TEMPLATE_H_
+#define _TEMPLATE_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Looping and Iteration */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Template for the general structure of a loop.
+ */
+#define TEMPLATE_LOOP(setup, loop_def, body)    \
+    do                                          \
+    {                                           \
+        setup;                                  \
+        loop_def {                              \
+            body;                               \
+        }                                       \
+    } while (0)
+
+/**
+ *  Template for looping over an array-like sequence.
+ */
+#define TEMPLATE_DO_ARR_LIKE(iter_idx, type,                            \
+                             arr, arr_length,                           \
+                             iter_elem_setup,                           \
+                             body)                                      \
+    do                                                                  \
+    {                                                                   \
+        TEMPLATE_LOOP(                                                  \
+            int iter_idx,                                               \
+            for(iter_idx = 0; iter_idx < (arr_length); ++iter_idx),     \
+            iter_elem_setup;                                            \
+            body);                                                      \
+    } while (0)
+
+/**
+ *  Template for looping over the contents of an array.
+ */
+#define TEMPLATE_DO_ARR(iter_idx, type, iter_elem, arr, arr_length, body) \
+    do                                                                  \
+    {                                                                   \
+        TEMPLATE_DO_ARR_LIKE(                                           \
+            iter_idx, type, arr, arr_length,                            \
+            type iter_elem = (arr)[iter_idx],                           \
+            body);                                                      \
+    } while (0)
+
+/**
+ *  Template for looping over the contents of an #ARR_DESC.
+ */
+#define TEMPLATE_DO_ARR_DESC(iter_idx, type, iter_elem, arr_desc, body) \
+    do                                                                  \
+    {                                                                   \
+        TEMPLATE_DO_ARR_LIKE(                                           \
+            iter_idx, type, arr_desc, (arr_desc).element_count,         \
+            type iter_elem = ARR_DESC_ELT(type, iter_idx, &(arr_desc)), \
+            body);                                                      \
+    } while (0)
+
+/*--------------------------------------------------------------------------------*/
+/* Test Definition */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Template for the general structure of a test.
+ */
+#define TEMPLATE_TEST(setup, body, teardown)    \
+        do                                      \
+        {                                       \
+            setup;                              \
+            body;                               \
+            teardown;                           \
+        } while (0)
+
+/**
+ *  Template for calling a function.
+ *
+ *  @note Surround function arguments with the #PAREN() macro.
+ *
+ *  @example
+ *  void my_func(int arg1, int arg2);
+ *
+ *  TEMPLATE_CALL_FN(my_func, PAREN(3, 7));
+ */
+#define TEMPLATE_CALL_FN(fn, fn_args)           \
+        fn fn_args
+
+#endif /* _TEMPLATE_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/templates/test_templates.h

@@ -0,0 +1,458 @@
+#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_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/transform_tests/transform_templates.h

@@ -0,0 +1,181 @@
+#ifndef _TRANSFORM_TEMPLATES_H_
+#define _TRANSFORM_TEMPLATES_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "test_templates.h"
+#include <string.h>             /* memcpy() */
+
+/*--------------------------------------------------------------------------------*/
+/* Group Specific Templates */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ * Comparison SNR thresholds for the data types used in transform_tests.
+ */
+#define TRANSFORM_SNR_THRESHOLD_float32_t 90
+#define TRANSFORM_SNR_THRESHOLD_q31_t     90
+#define TRANSFORM_SNR_THRESHOLD_q15_t     30
+
+#define DCT4_TRANSFORM_SNR_THRESHOLD_float32_t 80
+#define DCT4_TRANSFORM_SNR_THRESHOLD_q31_t     75
+#define DCT4_TRANSFORM_SNR_THRESHOLD_q15_t     11
+
+/**
+ *  Compare the outputs from the function under test and the reference
+ *  function using SNR.
+ */
+#define TRANSFORM_SNR_COMPARE_INTERFACE(block_size,     \
+                                        output_type)    \
+    do                                                  \
+    {                                                   \
+        TEST_CONVERT_AND_ASSERT_SNR(                    \
+            transform_fft_output_f32_ref,               \
+            (output_type *) transform_fft_output_ref,   \
+            transform_fft_output_f32_fut,               \
+            (output_type *) transform_fft_output_fut,   \
+            block_size,                                 \
+            output_type,                                \
+            TRANSFORM_SNR_THRESHOLD_##output_type       \
+            );                                          \
+    } while (0)
+    
+/**
+ *  Compare the outputs from the function under test and the reference
+ *  function using SNR.
+ */
+#define DCT_TRANSFORM_SNR_COMPARE_INTERFACE(block_size,  \
+                                            output_type) \
+    do                                                   \
+    {                                                    \
+        TEST_CONVERT_AND_ASSERT_SNR(                     \
+            transform_fft_output_f32_ref,                \
+            (output_type *) transform_fft_output_ref,    \
+            transform_fft_output_f32_fut,                \
+            (output_type *) transform_fft_output_fut,    \
+            block_size,                                  \
+            output_type,                                 \
+            DCT4_TRANSFORM_SNR_THRESHOLD_##output_type   \
+            );                                           \
+    } while (0)                                           \
+
+/**
+ *  Specialization on #TRANSFORM_SNR_COMPARE_INTERFACE() to fix the block_size
+ *  for complex datasets.
+ */
+#define TRANSFORM_SNR_COMPARE_CMPLX_INTERFACE(block_size, output_type)  \
+    /* Complex numbers have two components*/                            \
+    TRANSFORM_SNR_COMPARE_INTERFACE(block_size * 2, output_type )
+
+/**
+ * This macro copys data from the input_ptr into input arrays.
+ *
+ * Some functions modify their input data; in order to provide the same data to
+ * multiple tests, copies must be made so the changes from one function don't
+ * impact the others.
+ */
+#define TRANSFORM_COPY_INPUTS(input_ptr,        \
+                              bytes)            \
+    do                                          \
+    {                                           \
+        memcpy(                                 \
+            transform_fft_input_fut,            \
+            input_ptr,                          \
+            bytes);                             \
+        memcpy(                                 \
+            transform_fft_input_ref,            \
+            input_ptr,                          \
+            bytes);                             \
+    } while (0)
+
+/**
+ * This macro copys data from the input_ptr into input arrays. It also creates
+ * symmetric input data for rfft inverse.
+ *
+ * The 4.534234f just makes the middle entry of the array semi random.  It's
+ * actual value doesn't seem to matter much.
+ *
+ * Some functions modify their input data; in order to provide the same data to
+ * multiple tests, copies must be made so the changes from one function don't
+ * impact the others.
+ */
+#define TRANSFORM_PREPARE_INVERSE_INPUTS(input_ptr,                              \
+                              fftlen, input_type, bytes)                         \
+    do                                                                           \
+    {                                                                            \
+        uint32_t i;                                                              \
+                                                                                 \
+        memcpy(                                                                  \
+            transform_fft_input_fut,                                             \
+            input_ptr,                                                           \
+            bytes);                                                              \
+                                                                                 \
+        ((input_type*)transform_fft_input_fut)[1] = 0;                           \
+        ((input_type*)transform_fft_input_fut)[fftlen + 0] = 0;                  \
+        ((input_type*)transform_fft_input_fut)[fftlen + 1] = 0;                  \
+        for(i=1;i<fftlen/2;i++)                                                  \
+        {                                                                        \
+           *((input_type*)transform_fft_input_fut + fftlen + 2*i + 0) =          \
+               *((input_type*)transform_fft_input_fut + fftlen - 2*i + 0);       \
+           *((input_type*)transform_fft_input_fut + fftlen + 2*i + 1) =          \
+               -(*((input_type*)transform_fft_input_fut + fftlen - 2*i + 1));    \
+                                                                                 \
+        }                                                                        \
+                                                                                 \
+        memcpy(                                                                  \
+            transform_fft_input_ref,                                             \
+            transform_fft_input_fut,                                             \
+            bytes * 2);                                                          \
+    } while (0)
+
+/**
+ * This macro copys data from the input_ptr into the in-place input arrays.
+ *
+ * Some functions modify their input data; in order to provide the same data to
+ * multiple tests, copies must be made so the changes from one function don't
+ * impact the others.
+ */
+#define TRANSFORM_PREPARE_INPLACE_INPUTS_DOWNSHIFT(input_ptr,       \
+                                         bytes,                     \
+                                         type)                      \
+    do                                                              \
+    {                                                               \
+        uint32_t i;                                                 \
+        memcpy(                                                     \
+            transform_fft_inplace_input_fut,                        \
+            input_ptr,                                              \
+            bytes);                                                 \
+        memcpy(                                                     \
+            transform_fft_inplace_input_ref,                        \
+            input_ptr,                                              \
+            bytes);                                                 \
+        for(i=0;i<bytes/sizeof(type);i++) {                         \
+            *((type*)transform_fft_inplace_input_fut + i) >>= 1;    \
+            *((type*)transform_fft_inplace_input_ref + i) >>= 1;}   \
+    } while (0)
+
+/**
+ * This macro copys data from the input_ptr into the in-place input arrays.
+ *
+ * Some functions modify their input data; in order to provide the same data to
+ * multiple tests, copies must be made so the changes from one function don't
+ * impact the others.
+ */
+#define TRANSFORM_PREPARE_INPLACE_INPUTS(input_ptr, \
+                                         bytes)     \
+    do                                              \
+    {                                               \
+        memcpy(                                     \
+            transform_fft_inplace_input_fut,        \
+            input_ptr,                              \
+            bytes);                                 \
+        memcpy(                                     \
+            transform_fft_inplace_input_ref,        \
+            input_ptr,                              \
+            bytes);                                 \
+    } while (0)
+
+
+#endif /* _TRANSFORM_TEMPLATES_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/transform_tests/transform_test_data.h

@@ -0,0 +1,48 @@
+#ifndef _TRANSFORM_TEST_DATA_H_
+#define _TRANSFORM_TEST_DATA_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Includes */
+/*--------------------------------------------------------------------------------*/
+
+#include "arr_desc.h"
+#include "arm_math.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+#define TRANSFORM_MAX_FFT_LEN 4096
+#define TRANFORM_BIGGEST_INPUT_TYPE float32_t
+
+/*--------------------------------------------------------------------------------*/
+/* Variable Declarations */
+/*--------------------------------------------------------------------------------*/
+
+/* Lengths are multiplied by 2 to accomodate complex numbers*/
+extern float32_t transform_fft_output_fut[TRANSFORM_MAX_FFT_LEN * 2];
+extern float32_t transform_fft_output_ref[TRANSFORM_MAX_FFT_LEN * 2];
+extern float32_t transform_fft_input_fut[TRANSFORM_MAX_FFT_LEN * 2];
+extern float32_t transform_fft_input_ref[TRANSFORM_MAX_FFT_LEN * 2];
+extern float32_t transform_fft_output_f32_fut[TRANSFORM_MAX_FFT_LEN * 2];
+extern float32_t transform_fft_output_f32_ref[TRANSFORM_MAX_FFT_LEN * 2];
+extern float32_t * transform_fft_inplace_input_fut;
+extern float32_t * transform_fft_inplace_input_ref;
+extern float32_t transform_fft_f32_inputs[TRANSFORM_MAX_FFT_LEN * 2];
+extern q31_t transform_fft_q31_inputs[TRANSFORM_MAX_FFT_LEN * 2];
+extern q15_t * transform_fft_q15_inputs;
+extern q15_t dct4_transform_fft_q15_inputs[TRANSFORM_MAX_FFT_LEN * 2];
+
+/* FFT Lengths */
+ARR_DESC_DECLARE(transform_radix2_fftlens);
+ARR_DESC_DECLARE(transform_radix4_fftlens);
+ARR_DESC_DECLARE(transform_rfft_fftlens);
+ARR_DESC_DECLARE(transform_rfft_fast_fftlens);
+ARR_DESC_DECLARE(transform_dct_fftlens);
+
+/* CFFT Structs */
+ARR_DESC_DECLARE(transform_cfft_f32_structs);
+ARR_DESC_DECLARE(transform_cfft_q31_structs);
+ARR_DESC_DECLARE(transform_cfft_q15_structs);
+
+#endif /* _TRANSFORM_TEST_DATA_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/transform_tests/transform_test_group.h

@@ -0,0 +1,9 @@
+#ifndef _TRANSFORM_TEST_GROUP_H_
+#define _TRANSFORM_TEST_GROUP_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Declare Test Groups */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(transform_tests);
+
+#endif /* _TRANSFORM_TEST_GROUP_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/transform_tests/transform_tests.h

@@ -0,0 +1,13 @@
+#ifndef _TRANSFORM_TESTS_H_
+#define _TRANSFORM_TESTS_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Test/Group Declarations */
+/*--------------------------------------------------------------------------------*/
+JTEST_DECLARE_GROUP(cfft_tests);
+JTEST_DECLARE_GROUP(cfft_family_tests);
+JTEST_DECLARE_GROUP(dct4_tests);
+JTEST_DECLARE_GROUP(rfft_tests);
+JTEST_DECLARE_GROUP(rfft_fast_tests);
+
+#endif /* _TRANSFORM_TESTS_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/inc/type_abbrev.h

@@ -0,0 +1,37 @@
+#ifndef _TYPE_ABBREV_H_
+#define _TYPE_ABBREV_H_
+
+/*--------------------------------------------------------------------------------*/
+/* Macros and Defines */
+/*--------------------------------------------------------------------------------*/
+
+/**
+ *  Expand the abbreviation for a type into the type itself.
+ */
+#define TYPE_FROM_ABBREV(abbrev)                \
+    TYPE_ABBREV_##abbrev                        \
+
+/**
+ *  Expand the type to an abbreviation for that type.
+ *
+ *  Inverse of #TYPE_FROM_ABBREV().
+ *
+ *  @note Should be able to get a type back by writing.
+ *  TYPE_FROM_ABBREV(ABBREV_FROM_TYPE(type))
+ */
+#define ABBREV_FROM_TYPE(type)                  \
+    TYPE_SUFFIX_##type
+
+#define TYPE_ABBREV_f64 float64_t
+#define TYPE_ABBREV_f32 float32_t
+#define TYPE_ABBREV_q31 q31_t
+#define TYPE_ABBREV_q15 q15_t
+#define TYPE_ABBREV_q7  q7_t
+
+#define TYPE_SUFFIX_float64_t f64
+#define TYPE_SUFFIX_float32_t f32
+#define TYPE_SUFFIX_q31_t q31
+#define TYPE_SUFFIX_q15_t q15
+#define TYPE_SUFFIX_q7_t q7
+
+#endif /* _TYPE_ABBREV_H_ */

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/ARMCC/Retarget.c

@@ -0,0 +1,52 @@
+/*----------------------------------------------------------------------------
+ * Name:    Retarget.c
+ * Purpose: 'Retarget' layer for target-dependent low level functions
+ * Note(s):
+ *----------------------------------------------------------------------------
+ * This file is part of the uVision/ARM development tools.
+ * This software may only be used under the terms of a valid, current,
+ * end user licence from KEIL for a compatible version of KEIL software
+ * development tools. Nothing else gives you the right to use this software.
+ *
+ * This software is supplied "AS IS" without warranties of any kind.
+ *
+ * Copyright (c) 2011 Keil - An ARM Company. All rights reserved.
+ *----------------------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <rt_misc.h>
+#include "Serial.h"
+
+#pragma import(__use_no_semihosting_swi)
+
+
+
+struct __FILE { int handle; /* Add whatever you need here */ };
+FILE __stdout;
+FILE __stdin;
+
+
+int fputc(int c, FILE *f) {
+  return (SER_PutChar(c));
+}
+
+
+int fgetc(FILE *f) {
+  return (SER_GetChar());
+}
+
+
+int ferror(FILE *f) {
+  /* Your implementation of ferror */
+  return EOF;
+}
+
+
+void _ttywrch(int c) {
+  SER_PutChar(c);
+}
+
+
+void _sys_exit(int return_code) {
+label:  goto label;  /* endless loop */
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/ARMCC/startup_armv6-m.s

@@ -0,0 +1,195 @@
+;/* File: startup_armv6-m.s
+; * Purpose: startup file for armv7-m architecture devices.
+; *          Should be used with ARMCC
+; * Version: V2.00
+; * Date: 16 November 2015
+; *
+; */
+;/* Copyright (c) 2011 - 2014 ARM LIMITED
+;
+;   All rights reserved.
+;   Redistribution and use in source and binary forms, with or without
+;   modification, are permitted provided that the following conditions are met:
+;   - Redistributions of source code must retain the above copyright
+;     notice, this list of conditions and the following disclaimer.
+;   - Redistributions in binary form must reproduce the above copyright
+;     notice, this list of conditions and the following disclaimer in the
+;     documentation and/or other materials provided with the distribution.
+;   - Neither the name of ARM nor the names of its contributors may be used
+;     to endorse or promote products derived from this software without
+;     specific prior written permission.
+;   *
+;   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+;   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+;   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
+;   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+;   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+;   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+;   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+;   POSSIBILITY OF SUCH DAMAGE.
+;   ---------------------------------------------------------------------------*/
+;/*
+;  //-------- <<< Use Configuration Wizard in Context Menu >>> ------------------
+;*/
+
+
+; <h> Stack Configuration
+;   <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
+; </h>
+
+Stack_Size      EQU     0x00000400
+
+                AREA    STACK, NOINIT, READWRITE, ALIGN=3
+Stack_Mem       SPACE   Stack_Size
+__initial_sp
+
+
+; <h> Heap Configuration
+;   <o>  Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
+; </h>
+
+Heap_Size       EQU     0x00000C00
+
+                AREA    HEAP, NOINIT, READWRITE, ALIGN=3
+__heap_base
+Heap_Mem        SPACE   Heap_Size
+__heap_limit
+
+
+                PRESERVE8
+                THUMB
+
+
+; Vector Table Mapped to Address 0 at Reset
+
+                AREA    RESET, DATA, READONLY
+                EXPORT  __Vectors
+                EXPORT  __Vectors_End
+                EXPORT  __Vectors_Size
+
+__Vectors       DCD     __initial_sp              ; Top of Stack
+                DCD     Reset_Handler             ; Reset Handler
+                DCD     NMI_Handler               ; NMI Handler
+                DCD     HardFault_Handler         ; Hard Fault Handler
+                DCD     0                         ; Reserved
+                DCD     0                         ; Reserved
+                DCD     0                         ; Reserved
+                DCD     0                         ; Reserved
+                DCD     0                         ; Reserved
+                DCD     0                         ; Reserved
+                DCD     0                         ; Reserved
+                DCD     SVC_Handler               ; SVCall Handler
+                DCD     0                         ; Reserved
+                DCD     0                         ; Reserved
+                DCD     PendSV_Handler            ; PendSV Handler
+                DCD     SysTick_Handler           ; SysTick Handler
+__Vectors_End
+
+__Vectors_Size  EQU     __Vectors_End - __Vectors
+
+                AREA    |.text|, CODE, READONLY
+
+
+; Reset Handler
+
+Reset_Handler   PROC
+                EXPORT  Reset_Handler             [WEAK]
+                IMPORT  SystemInit
+                IMPORT  __main
+                LDR     R0, =SystemInit
+                BLX     R0
+                LDR     R0, =__main
+                BX      R0
+                ENDP
+
+
+; Dummy Exception Handlers (infinite loops which can be modified)
+
+NMI_Handler     PROC
+                EXPORT  NMI_Handler               [WEAK]
+                BKPT #0
+                B       .
+                ENDP
+HardFault_Handler\
+                PROC
+                EXPORT  HardFault_Handler         [WEAK]
+                BKPT #0
+                B       .
+                ENDP
+SVC_Handler     PROC
+                EXPORT  SVC_Handler               [WEAK]
+                B       .
+                ENDP
+PendSV_Handler  PROC
+                EXPORT  PendSV_Handler            [WEAK]
+                B       .
+                ENDP
+SysTick_Handler PROC
+                EXPORT  SysTick_Handler           [WEAK]
+                B       .
+                ENDP
+
+                ALIGN
+
+; User Initial Stack & Heap
+                IF      :DEF:__MICROLIB
+
+                EXPORT  __initial_sp
+                EXPORT  __heap_base
+                EXPORT  __heap_limit
+
+                ELSE
+
+                IMPORT  __use_two_region_memory
+
+;/*
+;  __user_setup_stackheap() returns the:
+;     - heap base in r0 (if the program uses the heap)
+;     - stack base in sp
+;     - heap limit in r2 (if the program uses the heap and uses two-region memory).
+; */
+                EXPORT  __user_setup_stackheap
+
+__user_setup_stackheap PROC
+                LDR     R0, = __initial_sp
+                MOV     SP, R0
+				IF Heap_Size > 0
+                LDR     R2, = __heap_limit
+                LDR     R0, = __heap_base
+				ELSE
+                MOV     R0, #0
+                MOV     R2, #0
+                ENDIF
+                BX      LR
+                ENDP
+
+
+;/*
+;__user_initial_stackheap() returns the:
+;   - heap base in r0
+;   - stack base in r1, that is, the highest address in the stack region
+;   - heap limit in r2
+;   - stack limit in r3, that is, the lowest address in the stack region.
+; */
+;
+;/* DEPRICATED
+;                EXPORT  __user_initial_stackheap
+;
+;__user_initial_stackheap PROC
+;                LDR     R0, =  Heap_Mem
+;                LDR     R1, =(Stack_Mem + Stack_Size)
+;                LDR     R2, = (Heap_Mem +  Heap_Size)
+;                LDR     R3, = Stack_Mem
+;                BX      LR
+;                ENDP
+; */
+
+                ALIGN
+
+                ENDIF
+
+
+                END

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/ARMCC/startup_armv7-m.s

@@ -0,0 +1,218 @@
+;/* File: startup_armv7-m.s
+; * Purpose: startup file for armv7-m architecture devices.
+; *          Should be used with ARMCC
+; * Version: V2.00
+; * Date: 16 November 2015
+; *
+; */
+;/* Copyright (c) 2011 - 2014 ARM LIMITED
+;
+;   All rights reserved.
+;   Redistribution and use in source and binary forms, with or without
+;   modification, are permitted provided that the following conditions are met:
+;   - Redistributions of source code must retain the above copyright
+;     notice, this list of conditions and the following disclaimer.
+;   - Redistributions in binary form must reproduce the above copyright
+;     notice, this list of conditions and the following disclaimer in the
+;     documentation and/or other materials provided with the distribution.
+;   - Neither the name of ARM nor the names of its contributors may be used
+;     to endorse or promote products derived from this software without
+;     specific prior written permission.
+;   *
+;   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+;   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+;   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
+;   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+;   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+;   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+;   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+;   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+;   POSSIBILITY OF SUCH DAMAGE.
+;   ---------------------------------------------------------------------------*/
+;/*
+;  //-------- <<< Use Configuration Wizard in Context Menu >>> ------------------
+;*/
+
+
+; <h> Stack Configuration
+;   <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
+; </h>
+
+Stack_Size      EQU     0x00000400
+
+                AREA    STACK, NOINIT, READWRITE, ALIGN=3
+Stack_Mem       SPACE   Stack_Size
+__initial_sp
+
+
+; <h> Heap Configuration
+;   <o>  Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
+; </h>
+
+Heap_Size       EQU     0x00000C00
+
+                AREA    HEAP, NOINIT, READWRITE, ALIGN=3
+__heap_base
+Heap_Mem        SPACE   Heap_Size
+__heap_limit
+
+
+                PRESERVE8
+                THUMB
+
+
+; Vector Table Mapped to Address 0 at Reset
+
+                AREA    RESET, DATA, READONLY
+                EXPORT  __Vectors
+                EXPORT  __Vectors_End
+                EXPORT  __Vectors_Size
+
+__Vectors       DCD     __initial_sp              ; Top of Stack
+                DCD     Reset_Handler             ; Reset Handler
+                DCD     NMI_Handler               ; NMI Handler
+                DCD     HardFault_Handler         ; Hard Fault Handler
+                DCD     MemManage_Handler         ; MPU Fault Handler
+                DCD     BusFault_Handler          ; Bus Fault Handler
+                DCD     UsageFault_Handler        ; Usage Fault Handler
+                DCD     0                         ; Reserved
+                DCD     0                         ; Reserved
+                DCD     0                         ; Reserved
+                DCD     0                         ; Reserved
+                DCD     SVC_Handler               ; SVCall Handler
+                DCD     DebugMon_Handler          ; Debug Monitor Handler
+                DCD     0                         ; Reserved
+                DCD     PendSV_Handler            ; PendSV Handler
+                DCD     SysTick_Handler           ; SysTick Handler
+__Vectors_End
+
+__Vectors_Size  EQU     __Vectors_End - __Vectors
+
+                AREA    |.text|, CODE, READONLY
+
+
+; Reset Handler
+
+Reset_Handler   PROC
+                EXPORT  Reset_Handler             [WEAK]
+                IMPORT  SystemInit
+                IMPORT  __main
+                LDR     R0, =SystemInit
+                BLX     R0
+                LDR     R0, =__main
+                BX      R0
+                ENDP
+
+
+; Dummy Exception Handlers (infinite loops which can be modified)
+
+NMI_Handler     PROC
+                EXPORT  NMI_Handler               [WEAK]
+                BKPT #0
+                B       .
+                ENDP
+HardFault_Handler\
+                PROC
+                EXPORT  HardFault_Handler         [WEAK]
+                BKPT #0
+                B       .
+                ENDP
+MemManage_Handler\
+                PROC
+                EXPORT  MemManage_Handler         [WEAK]
+                BKPT #0
+                B       .
+                ENDP
+BusFault_Handler\
+                PROC
+                EXPORT  BusFault_Handler          [WEAK]
+                BKPT #0
+                B       .
+                ENDP
+UsageFault_Handler\
+                PROC
+                EXPORT  UsageFault_Handler        [WEAK]
+                BKPT #0
+                B       .
+                ENDP
+SVC_Handler     PROC
+                EXPORT  SVC_Handler               [WEAK]
+                B       .
+                ENDP
+DebugMon_Handler\
+                PROC
+                EXPORT  DebugMon_Handler          [WEAK]
+                B       .
+                ENDP
+PendSV_Handler  PROC
+                EXPORT  PendSV_Handler            [WEAK]
+                B       .
+                ENDP
+SysTick_Handler PROC
+                EXPORT  SysTick_Handler           [WEAK]
+                B       .
+                ENDP
+
+                ALIGN
+
+; User Initial Stack & Heap
+                IF      :DEF:__MICROLIB
+
+                EXPORT  __initial_sp
+                EXPORT  __heap_base
+                EXPORT  __heap_limit
+
+                ELSE
+
+                IMPORT  __use_two_region_memory
+
+;/*
+;  __user_setup_stackheap() returns the:
+;     - heap base in r0 (if the program uses the heap)
+;     - stack base in sp
+;     - heap limit in r2 (if the program uses the heap and uses two-region memory).
+; */
+                EXPORT  __user_setup_stackheap
+
+__user_setup_stackheap PROC
+                LDR     R0, = __initial_sp
+                MOV     SP, R0
+				IF Heap_Size > 0
+                LDR     R2, = __heap_limit
+                LDR     R0, = __heap_base
+				ELSE
+                MOV     R0, #0
+                MOV     R2, #0
+                ENDIF
+                BX      LR
+                ENDP
+
+
+;/*
+;__user_initial_stackheap() returns the:
+;   - heap base in r0
+;   - stack base in r1, that is, the highest address in the stack region
+;   - heap limit in r2
+;   - stack limit in r3, that is, the lowest address in the stack region.
+; */
+;
+;/* DEPRICATED
+;                EXPORT  __user_initial_stackheap
+;
+;__user_initial_stackheap PROC
+;                LDR     R0, =  Heap_Mem
+;                LDR     R1, =(Stack_Mem + Stack_Size)
+;                LDR     R2, = (Heap_Mem +  Heap_Size)
+;                LDR     R3, = Stack_Mem
+;                BX      LR
+;                ENDP
+; */
+
+                ALIGN
+
+                ENDIF
+
+
+                END

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/ARMCLANG/startup_armv6-m.S

@@ -0,0 +1,203 @@
+/* File: startup_armv6-m.S
+ * Purpose: startup file for armv6-m architecture devices.
+ *          Should be used with ARMCLANG
+ * Version: V2.00
+ * Date: 16 November 2015
+ *
+ */
+/* Copyright (c) 2011 - 2015 ARM LIMITED
+
+   All rights reserved.
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are met:
+   - Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+   - Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+   - Neither the name of ARM nor the names of its contributors may be used
+     to endorse or promote products derived from this software without
+     specific prior written permission.
+   *
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
+   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+   POSSIBILITY OF SUCH DAMAGE.
+   ---------------------------------------------------------------------------*/
+/*
+  ;//-------- <<< Use Configuration Wizard in Context Menu >>> ------------------
+*/
+
+
+    .syntax unified
+    .arch   armv6-m
+
+/* .eabi_attribute Tag_ABI_align8_preserved,1    www.support.code-red-tech.com/CodeRedWiki/Preserve8 */
+.eabi_attribute 25, 1   /* Tag_ABI_align_preserved */
+
+
+/*
+  ;<h> Stack Configuration
+  ;  <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
+  ;</h>
+*/
+    .equ    Stack_Size, 0x00000400
+
+    .section STACK, "w"
+    .align  3
+    .globl  __StackTop
+    .globl  __StackLimit
+__StackLimit:
+    .space  Stack_Size
+__StackTop:   /* formerly known as __initial_sp */
+
+
+/*
+  ;<h> Heap Configuration
+  ;  <o>  Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
+  ;</h>
+*/
+    .equ    Heap_Size, 0x00000C00
+
+    .section HEAP, "w"
+    .align  3
+    .globl  __HeapBase
+    .globl  __HeapLimit
+__HeapBase:
+    .if Heap_Size
+    .space  Heap_Size
+    .endif
+__HeapLimit:
+
+
+    .section RESET, "x"
+    .align  2
+    .globl  __Vectors
+    .globl  __Vectors_End
+    .globl  __Vectors_Size
+__Vectors:
+    .long   __StackTop            /* Top of Stack */
+    .long   Reset_Handler         /* Reset Handler */
+    .long   NMI_Handler           /* NMI Handler */
+    .long   HardFault_Handler     /* Hard Fault Handler */
+    .long   0                     /* Reserved */
+    .long   0                     /* Reserved */
+    .long   0                     /* Reserved */
+    .long   0                     /* Reserved */
+    .long   0                     /* Reserved */
+    .long   0                     /* Reserved */
+    .long   0                     /* Reserved */
+    .long   SVC_Handler           /* SVCall Handler */
+    .long   0                     /* Reserved */
+    .long   0                     /* Reserved */
+    .long   PendSV_Handler        /* PendSV Handler */
+    .long   SysTick_Handler       /* SysTick Handler */
+__Vectors_End:
+
+    .equ    __Vectors_Size, __Vectors_End - __Vectors
+
+
+    .text
+    .thumb
+    .align  2
+
+    .globl  Reset_Handler
+    .weak   Reset_Handler
+    .type   Reset_Handler, %function
+    .thumb_func
+Reset_Handler:
+    bl      SystemInit
+    bl      __main
+
+    .globl  NMI_Handler
+    .weak   NMI_Handler
+    .type   NMI_Handler, %function
+    .thumb_func
+NMI_Handler:
+    bkpt    #0
+    b       .
+
+    .globl  HardFault_Handler
+    .weak   HardFault_Handler
+    .type   HardFault_Handler, %function
+    .thumb_func
+HardFault_Handler:
+    bkpt    #0
+    b       .
+
+    .globl  SVC_Handler
+    .weak   SVC_Handler
+    .type   SVC_Handler, %function
+    .thumb_func
+SVC_Handler:
+    bkpt    #0
+    b       .
+
+    .globl  PendSV_Handler
+    .weak   PendSV_Handler
+    .type   PendSV_Handler, %function
+    .thumb_func
+PendSV_Handler:
+    bkpt    #0
+    b       .
+
+    .globl  SysTick_Handler
+    .weak   SysTick_Handler
+    .type   SysTick_Handler, %function
+    .thumb_func
+SysTick_Handler:
+    bkpt    #0
+    b       .
+
+
+    .global __use_two_region_memory
+
+/*
+  __user_setup_stackheap() returns the:
+     - heap base in r0 (if the program uses the heap)
+     - stack base in sp
+     - heap limit in r2 (if the program uses the heap and uses two-region memory).
+ */
+    .globl  __user_setup_stackheap
+    .type   __user_setup_stackheap, %function
+    .thumb_func
+__user_setup_stackheap:
+    ldr     r0, =__StackTop
+    mov     sp, r0
+    .if Heap_Size
+    ldr     r0, =__HeapBase
+    ldr     r2, =__HeapLimit
+    .else
+    mov     r0, #0
+    mov     r2, #0
+    .endif
+    bx      lr
+
+
+/*
+__user_initial_stackheap() returns the:
+   - heap base in r0
+   - stack base in r1, that is, the highest address in the stack region
+   - heap limit in r2
+   - stack limit in r3, that is, the lowest address in the stack region.
+ */
+/* DEPRICATED
+    .globl  __user_initial_stackheap
+    .type   __user_initial_stackheap, %function
+    .thumb_func
+__user_initial_stackheap:
+    ldr     r0, = __HeapBase
+    ldr     r1, = __StackTop
+    ldr     r2, = __HeapLimit
+    ldr     r3, = __StackLimit
+    bx      lr
+*/
+
+    .end

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/ARMCLANG/startup_armv7-m.S

@@ -0,0 +1,235 @@
+/* File: startup_armv7-m.S
+ * Purpose: startup file for armv7-m architecture devices.
+ *          Should be used with ARMCLANG
+ * Version: V2.00
+ * Date: 16 November 2015
+ *
+ */
+/* Copyright (c) 2011 - 2015 ARM LIMITED
+
+   All rights reserved.
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are met:
+   - Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+   - Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+   - Neither the name of ARM nor the names of its contributors may be used
+     to endorse or promote products derived from this software without
+     specific prior written permission.
+   *
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
+   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+   POSSIBILITY OF SUCH DAMAGE.
+   ---------------------------------------------------------------------------*/
+/*
+  ;//-------- <<< Use Configuration Wizard in Context Menu >>> ------------------
+*/
+
+
+    .syntax unified
+    .arch   armv6-m
+
+/* .eabi_attribute Tag_ABI_align8_preserved,1    www.support.code-red-tech.com/CodeRedWiki/Preserve8 */
+.eabi_attribute 25, 1   /* Tag_ABI_align_preserved */
+
+
+/*
+  ;<h> Stack Configuration
+  ;  <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
+  ;</h>
+*/
+    .equ    Stack_Size, 0x00000400
+
+    .section STACK, "w"
+    .align  3
+    .globl  __StackTop
+    .globl  __StackLimit
+__StackLimit:
+    .space  Stack_Size
+__StackTop:   /* formerly known as __initial_sp */
+
+
+/*
+  ;<h> Heap Configuration
+  ;  <o>  Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
+  ;</h>
+*/
+    .equ    Heap_Size, 0x00000C00
+
+    .section HEAP, "w"
+    .align  3
+    .globl  __HeapBase
+    .globl  __HeapLimit
+__HeapBase:
+    .if Heap_Size
+    .space  Heap_Size
+    .endif
+__HeapLimit:
+
+
+    .section RESET, "x"
+    .align  2
+    .globl  __Vectors
+    .globl  __Vectors_End
+    .globl  __Vectors_Size
+__Vectors:
+    .long   __StackTop            /* Top of Stack */
+    .long   Reset_Handler         /* Reset Handler */
+    .long   NMI_Handler           /* NMI Handler */
+    .long   HardFault_Handler     /* Hard Fault Handler */
+    .long   MemManage_Handler     /* MPU Fault Handler */
+    .long   BusFault_Handler      /* Bus Fault Handler */
+    .long   UsageFault_Handler    /* Usage Fault Handler */
+    .long   0                     /* Reserved */
+    .long   0                     /* Reserved */
+    .long   0                     /* Reserved */
+    .long   0                     /* Reserved */
+    .long   SVC_Handler           /* SVCall Handler */
+    .long   DebugMon_Handler      /* Debug Monitor Handler */
+    .long   0                     /* Reserved */
+    .long   PendSV_Handler        /* PendSV Handler */
+    .long   SysTick_Handler       /* SysTick Handler */
+__Vectors_End:
+
+    .equ    __Vectors_Size, __Vectors_End - __Vectors
+
+
+    .text
+    .thumb
+    .align  2
+
+    .globl  Reset_Handler
+    .weak   Reset_Handler
+    .type   Reset_Handler, %function
+    .thumb_func
+Reset_Handler:
+    bl      SystemInit
+    bl      __main
+
+    .globl  NMI_Handler
+    .weak   NMI_Handler
+    .type   NMI_Handler, %function
+    .thumb_func
+NMI_Handler:
+    bkpt    #0
+    b       .
+
+    .globl  HardFault_Handler
+    .weak   HardFault_Handler
+    .type   HardFault_Handler, %function
+    .thumb_func
+HardFault_Handler:
+    bkpt    #0
+    b       .
+
+    .globl  MemManage_Handler
+    .weak   MemManage_Handler
+    .type   MemManage_Handler, %function
+    .thumb_func
+MemManage_Handler:
+    bkpt    #0
+    b       .
+
+    .globl  BusFault_Handler
+    .weak   BusFault_Handler
+    .type   BusFault_Handler, %function
+    .thumb_func
+BusFault_Handler:
+    bkpt    #0
+    b       .
+
+    .globl  UsageFault_Handler
+    .weak   UsageFault_Handler
+    .type   UsageFault_Handler, %function
+    .thumb_func
+UsageFault_Handler:
+    bkpt    #0
+    b       .
+
+    .globl  SVC_Handler
+    .weak   SVC_Handler
+    .type   SVC_Handler, %function
+    .thumb_func
+SVC_Handler:
+    bkpt    #0
+    b       .
+
+    .globl  DebugMon_Handler
+    .weak   DebugMon_Handler
+    .type   DebugMon_Handler, %function
+    .thumb_func
+DebugMon_Handler:
+    bkpt    #0
+    b       .
+
+    .globl  PendSV_Handler
+    .weak   PendSV_Handler
+    .type   PendSV_Handler, %function
+    .thumb_func
+PendSV_Handler:
+    bkpt    #0
+    b       .
+
+    .globl  SysTick_Handler
+    .weak   SysTick_Handler
+    .type   SysTick_Handler, %function
+    .thumb_func
+SysTick_Handler:
+    bkpt    #0
+    b       .
+
+
+    .global __use_two_region_memory
+
+/*
+  __user_setup_stackheap() returns the:
+     - heap base in r0 (if the program uses the heap)
+     - stack base in sp
+     - heap limit in r2 (if the program uses the heap and uses two-region memory).
+ */
+    .globl  __user_setup_stackheap
+    .type   __user_setup_stackheap, %function
+    .thumb_func
+__user_setup_stackheap:
+    ldr     r0, =__StackTop
+    mov     sp, r0
+    .if Heap_Size
+    ldr     r0, =__HeapBase
+    ldr     r2, =__HeapLimit
+    .else
+    mov     r0, #0
+    mov     r2, #0
+    .endif
+    bx      lr
+
+
+/*
+__user_initial_stackheap() returns the:
+   - heap base in r0
+   - stack base in r1, that is, the highest address in the stack region
+   - heap limit in r2
+   - stack limit in r3, that is, the lowest address in the stack region.
+ */
+/* DEPRICATED
+    .globl  __user_initial_stackheap
+    .type   __user_initial_stackheap, %function
+    .thumb_func
+__user_initial_stackheap:
+    ldr     r0, = __HeapBase
+    ldr     r1, = __StackTop
+    ldr     r2, = __HeapLimit
+    ldr     r3, = __StackLimit
+    bx      lr
+*/
+
+    .end

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/GCC/Retarget.c

@@ -0,0 +1,106 @@
+/*----------------------------------------------------------------------------
+ * Name:    Retarget.c
+ * Purpose: 'Retarget' layer for target-dependent low level functions
+ * Note(s):
+ *----------------------------------------------------------------------------
+ * This file is part of the uVision/ARM development tools.
+ * This software may only be used under the terms of a valid, current,
+ * end user licence from KEIL for a compatible version of KEIL software
+ * development tools. Nothing else gives you the right to use this software.
+ *
+ * This software is supplied "AS IS" without warranties of any kind.
+ *
+ * Copyright (c) 2012 Keil - An ARM Company. All rights reserved.
+ *----------------------------------------------------------------------------*/
+
+#include <sys/stat.h>
+#include <string.h>
+#include <errno.h>
+
+int SER_PutChar (int c) {
+
+  return (c);
+}
+
+int SER_GetChar (void) {
+
+  return (-1);
+}
+
+/*-- GCC - Newlib runtime support --------------------------------------------*/
+
+extern int  __HeapBase;
+extern int  __HeapLimit;
+
+int _open (const char * path, int flags, ...) 
+{
+  return (-1);
+}
+
+int _close (int fd) 
+{
+  return (-1);
+}
+
+int _lseek (int fd, int ptr, int dir) 
+{
+  return (0);
+}
+
+int __attribute__((weak)) _fstat (int fd, struct stat * st) 
+{
+  memset (st, 0, sizeof (* st));
+  st->st_mode = S_IFCHR;
+  return (0);
+}
+
+int _isatty (int fd) 
+{
+  return (1);
+}
+
+int _read (int fd, char * ptr, int len) 
+{
+  char c;
+  int  i;
+
+  for (i = 0; i < len; i++) 
+  {
+    c = SER_GetChar();
+    if (c == 0x0D) break;
+    *ptr++ = c;
+    SER_PutChar(c);
+  }
+  return (len - i);
+}
+
+int _write (int fd, char * ptr, int len) 
+{
+  int i;
+
+  for (i = 0; i < len; i++) SER_PutChar (*ptr++);
+  return (i);
+}
+
+caddr_t _sbrk (int incr) 
+{
+  static char * heap;
+         char * prev_heap;
+
+  if (heap == NULL) 
+  {
+    heap = (char *)&__HeapBase;
+  }
+  
+  prev_heap = heap;
+
+  if ((heap + incr) > (char *)&__HeapLimit) 
+  {
+    errno = ENOMEM;
+    return (caddr_t) -1;
+  }
+  
+  heap += incr;
+
+  return (caddr_t) prev_heap;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/GCC/startup_armv6-m.S

@@ -0,0 +1,263 @@
+/* File: startup_armv6-m.S
+ * Purpose: startup file for armv6-m architecture devices.
+ *          Should be used with GCC for ARM Embedded Processors
+ * Version: V2.00
+ * Date: 16 November 2015
+ *
+ */
+/* Copyright (c) 2011 - 2015 ARM LIMITED
+
+   All rights reserved.
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are met:
+   - Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+   - Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+   - Neither the name of ARM nor the names of its contributors may be used
+     to endorse or promote products derived from this software without
+     specific prior written permission.
+   *
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
+   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+   POSSIBILITY OF SUCH DAMAGE.
+   ---------------------------------------------------------------------------*/
+
+
+	.syntax	unified
+	.arch	armv6-m
+
+	.section .stack
+	.align	3
+#ifdef __STACK_SIZE
+	.equ	Stack_Size, __STACK_SIZE
+#else
+	.equ	Stack_Size, 0x00000400
+#endif
+	.globl	__StackTop
+	.globl	__StackLimit
+__StackLimit:
+	.space	Stack_Size
+	.size	__StackLimit, . - __StackLimit
+__StackTop:
+	.size	__StackTop, . - __StackTop
+
+	.section .heap
+	.align	3
+#ifdef __HEAP_SIZE
+	.equ	Heap_Size, __HEAP_SIZE
+#else
+	.equ	Heap_Size, 0x00000C00
+#endif
+	.globl	__HeapBase
+	.globl	__HeapLimit
+__HeapBase:
+	.if	Heap_Size
+	.space	Heap_Size
+	.endif
+	.size	__HeapBase, . - __HeapBase
+__HeapLimit:
+	.size	__HeapLimit, . - __HeapLimit
+
+	.section .vectors
+	.align 2
+	.globl	__Vectors
+__Vectors:
+	.long	__StackTop            /* Top of Stack */
+	.long	Reset_Handler         /* Reset Handler */
+	.long	NMI_Handler           /* NMI Handler */
+	.long	HardFault_Handler     /* Hard Fault Handler */
+	.long	0                     /* Reserved */
+	.long	0                     /* Reserved */
+	.long	0                     /* Reserved */
+	.long	0                     /* Reserved */
+	.long	0                     /* Reserved */
+	.long	0                     /* Reserved */
+	.long	0                     /* Reserved */
+	.long	SVC_Handler           /* SVCall Handler */
+	.long	0                     /* Reserved */
+	.long	0                     /* Reserved */
+	.long	PendSV_Handler        /* PendSV Handler */
+	.long	SysTick_Handler       /* SysTick Handler */
+
+	.size	__Vectors, . - __Vectors
+
+	.text
+	.thumb
+	.thumb_func
+	.align	1
+	.globl	Reset_Handler
+	.type	Reset_Handler, %function
+Reset_Handler:
+/*  Firstly it copies data from read only memory to RAM. There are two schemes
+ *  to copy. One can copy more than one sections. Another can only copy
+ *  one section.  The former scheme needs more instructions and read-only
+ *  data to implement than the latter.
+ *  Macro __STARTUP_COPY_MULTIPLE is used to choose between two schemes.  */
+
+#ifdef __STARTUP_COPY_MULTIPLE
+/*  Multiple sections scheme.
+ *
+ *  Between symbol address __copy_table_start__ and __copy_table_end__,
+ *  there are array of triplets, each of which specify:
+ *    offset 0: LMA of start of a section to copy from
+ *    offset 4: VMA of start of a section to copy to
+ *    offset 8: size of the section to copy. Must be multiply of 4
+ *
+ *  All addresses must be aligned to 4 bytes boundary.
+ */
+	ldr	r4, =__copy_table_start__
+	ldr	r5, =__copy_table_end__
+
+.L_loop0:
+	cmp	r4, r5
+	bge	.L_loop0_done
+	ldr	r1, [r4]
+	ldr	r2, [r4, #4]
+	ldr	r3, [r4, #8]
+
+.L_loop0_0:
+	subs	r3, #4
+	blt	.L_loop0_0_done
+	ldr	r0, [r1, r3]
+	str	r0, [r2, r3]
+	b	.L_loop0_0
+
+.L_loop0_0_done:
+	adds	r4, #12
+	b	.L_loop0
+
+.L_loop0_done:
+#else
+/*  Single section scheme.
+ *
+ *  The ranges of copy from/to are specified by following symbols
+ *    __etext: LMA of start of the section to copy from. Usually end of text
+ *    __data_start__: VMA of start of the section to copy to
+ *    __data_end__: VMA of end of the section to copy to
+ *
+ *  All addresses must be aligned to 4 bytes boundary.
+ */
+	ldr	r1, =__etext
+	ldr	r2, =__data_start__
+	ldr	r3, =__data_end__
+
+	subs	r3, r2
+	ble	.L_loop1_done
+
+.L_loop1:
+	subs	r3, #4
+	ldr	r0, [r1,r3]
+	str	r0, [r2,r3]
+	bgt	.L_loop1
+
+.L_loop1_done:
+#endif /*__STARTUP_COPY_MULTIPLE */
+
+/*  This part of work usually is done in C library startup code. Otherwise,
+ *  define this macro to enable it in this startup.
+ *
+ *  There are two schemes too. One can clear multiple BSS sections. Another
+ *  can only clear one section. The former is more size expensive than the
+ *  latter.
+ *
+ *  Define macro __STARTUP_CLEAR_BSS_MULTIPLE to choose the former.
+ *  Otherwise efine macro __STARTUP_CLEAR_BSS to choose the later.
+ */
+#ifdef __STARTUP_CLEAR_BSS_MULTIPLE
+/*  Multiple sections scheme.
+ *
+ *  Between symbol address __copy_table_start__ and __copy_table_end__,
+ *  there are array of tuples specifying:
+ *    offset 0: Start of a BSS section
+ *    offset 4: Size of this BSS section. Must be multiply of 4
+ */
+	ldr	r3, =__zero_table_start__
+	ldr	r4, =__zero_table_end__
+
+.L_loop2:
+	cmp	r3, r4
+	bge	.L_loop2_done
+	ldr	r1, [r3]
+	ldr	r2, [r3, #4]
+	movs	r0, 0
+
+.L_loop2_0:
+	subs	r2, #4
+	blt	.L_loop2_0_done
+	str	r0, [r1, r2]
+	b	.L_loop2_0
+.L_loop2_0_done:
+
+	adds	r3, #8
+	b	.L_loop2
+.L_loop2_done:
+#elif defined (__STARTUP_CLEAR_BSS)
+/*  Single BSS section scheme.
+ *
+ *  The BSS section is specified by following symbols
+ *    __bss_start__: start of the BSS section.
+ *    __bss_end__: end of the BSS section.
+ *
+ *  Both addresses must be aligned to 4 bytes boundary.
+ */
+	ldr	r1, =__bss_start__
+	ldr	r2, =__bss_end__
+
+	movs	r0, 0
+
+	subs	r2, r1
+	ble	.L_loop3_done
+
+.L_loop3:
+	subs	r2, #4
+	str	r0, [r1, r2]
+	bgt	.L_loop3
+.L_loop3_done:
+#endif /* __STARTUP_CLEAR_BSS_MULTIPLE || __STARTUP_CLEAR_BSS */
+
+#ifndef __NO_SYSTEM_INIT
+	bl	SystemInit
+#endif
+
+#ifndef __START
+#define __START _start
+#endif
+	bl	__START
+
+	.pool
+	.size	Reset_Handler, . - Reset_Handler
+
+	.align	1
+	.thumb_func
+	.weak	Default_Handler
+	.type	Default_Handler, %function
+Default_Handler:
+    bkpt #0
+	b	.
+	.size	Default_Handler, . - Default_Handler
+
+/*    Macro to define default handlers. Default handler
+ *    will be weak symbol and just dead loops. They can be
+ *    overwritten by other handlers */
+	.macro	def_irq_handler	handler_name
+	.weak	\handler_name
+	.set	\handler_name, Default_Handler
+	.endm
+
+	def_irq_handler	NMI_Handler
+	def_irq_handler	HardFault_Handler
+	def_irq_handler	SVC_Handler
+	def_irq_handler	PendSV_Handler
+	def_irq_handler	SysTick_Handler
+
+	.end

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/GCC/startup_armv7-m.S

@@ -0,0 +1,257 @@
+/* File: startup_armv7-m.S
+ * Purpose: startup file for armv7-m architecture devices.
+ *          Should be used with GCC for ARM Embedded Processors
+ * Version: V2.00
+ * Date: 16 November 2015
+ *
+ */
+/* Copyright (c) 2011 - 2015 ARM LIMITED
+
+   All rights reserved.
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are met:
+   - Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+   - Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+   - Neither the name of ARM nor the names of its contributors may be used
+     to endorse or promote products derived from this software without
+     specific prior written permission.
+   *
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+   ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
+   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+   POSSIBILITY OF SUCH DAMAGE.
+   ---------------------------------------------------------------------------*/
+
+
+	.syntax	unified
+	.arch	armv7-m
+
+	.section .stack
+	.align	3
+#ifdef __STACK_SIZE
+	.equ	Stack_Size, __STACK_SIZE
+#else
+	.equ	Stack_Size, 0x00000400
+#endif
+	.globl	__StackTop
+	.globl	__StackLimit
+__StackLimit:
+	.space	Stack_Size
+	.size	__StackLimit, . - __StackLimit
+__StackTop:
+	.size	__StackTop, . - __StackTop
+
+	.section .heap
+	.align	3
+#ifdef __HEAP_SIZE
+	.equ	Heap_Size, __HEAP_SIZE
+#else
+	.equ	Heap_Size, 0x00000C00
+#endif
+	.globl	__HeapBase
+	.globl	__HeapLimit
+__HeapBase:
+	.if	Heap_Size
+	.space	Heap_Size
+	.endif
+	.size	__HeapBase, . - __HeapBase
+__HeapLimit:
+	.size	__HeapLimit, . - __HeapLimit
+
+	.section .vectors
+	.align	2
+	.globl	__Vectors
+__Vectors:
+	.long	__StackTop            /* Top of Stack */
+	.long	Reset_Handler         /* Reset Handler */
+	.long	NMI_Handler           /* NMI Handler */
+	.long	HardFault_Handler     /* Hard Fault Handler */
+	.long	MemManage_Handler     /* MPU Fault Handler */
+	.long	BusFault_Handler      /* Bus Fault Handler */
+	.long	UsageFault_Handler    /* Usage Fault Handler */
+	.long	0                     /* Reserved */
+	.long	0                     /* Reserved */
+	.long	0                     /* Reserved */
+	.long	0                     /* Reserved */
+	.long	SVC_Handler           /* SVCall Handler */
+	.long	DebugMon_Handler      /* Debug Monitor Handler */
+	.long	0                     /* Reserved */
+	.long	PendSV_Handler        /* PendSV Handler */
+	.long	SysTick_Handler       /* SysTick Handler */
+
+	.size	__Vectors, . - __Vectors
+
+	.text
+	.thumb
+	.thumb_func
+	.align	2
+	.globl	Reset_Handler
+	.type	Reset_Handler, %function
+Reset_Handler:
+/*  Firstly it copies data from read only memory to RAM. There are two schemes
+ *  to copy. One can copy more than one sections. Another can only copy
+ *  one section.  The former scheme needs more instructions and read-only
+ *  data to implement than the latter.
+ *  Macro __STARTUP_COPY_MULTIPLE is used to choose between two schemes.  */
+
+#ifdef __STARTUP_COPY_MULTIPLE
+/*  Multiple sections scheme.
+ *
+ *  Between symbol address __copy_table_start__ and __copy_table_end__,
+ *  there are array of triplets, each of which specify:
+ *    offset 0: LMA of start of a section to copy from
+ *    offset 4: VMA of start of a section to copy to
+ *    offset 8: size of the section to copy. Must be multiply of 4
+ *
+ *  All addresses must be aligned to 4 bytes boundary.
+ */
+	ldr	r4, =__copy_table_start__
+	ldr	r5, =__copy_table_end__
+
+.L_loop0:
+	cmp	r4, r5
+	bge	.L_loop0_done
+	ldr	r1, [r4]
+	ldr	r2, [r4, #4]
+	ldr	r3, [r4, #8]
+
+.L_loop0_0:
+	subs	r3, #4
+	ittt	ge
+	ldrge	r0, [r1, r3]
+	strge	r0, [r2, r3]
+	bge	.L_loop0_0
+
+	adds	r4, #12
+	b	.L_loop0
+
+.L_loop0_done:
+#else
+/*  Single section scheme.
+ *
+ *  The ranges of copy from/to are specified by following symbols
+ *    __etext: LMA of start of the section to copy from. Usually end of text
+ *    __data_start__: VMA of start of the section to copy to
+ *    __data_end__: VMA of end of the section to copy to
+ *
+ *  All addresses must be aligned to 4 bytes boundary.
+ */
+	ldr	r1, =__etext
+	ldr	r2, =__data_start__
+	ldr	r3, =__data_end__
+
+.L_loop1:
+	cmp	r2, r3
+	ittt	lt
+	ldrlt	r0, [r1], #4
+	strlt	r0, [r2], #4
+	blt	.L_loop1
+#endif /*__STARTUP_COPY_MULTIPLE */
+
+/*  This part of work usually is done in C library startup code. Otherwise,
+ *  define this macro to enable it in this startup.
+ *
+ *  There are two schemes too. One can clear multiple BSS sections. Another
+ *  can only clear one section. The former is more size expensive than the
+ *  latter.
+ *
+ *  Define macro __STARTUP_CLEAR_BSS_MULTIPLE to choose the former.
+ *  Otherwise efine macro __STARTUP_CLEAR_BSS to choose the later.
+ */
+#ifdef __STARTUP_CLEAR_BSS_MULTIPLE
+/*  Multiple sections scheme.
+ *
+ *  Between symbol address __copy_table_start__ and __copy_table_end__,
+ *  there are array of tuples specifying:
+ *    offset 0: Start of a BSS section
+ *    offset 4: Size of this BSS section. Must be multiply of 4
+ */
+	ldr	r3, =__zero_table_start__
+	ldr	r4, =__zero_table_end__
+
+.L_loop2:
+	cmp	r3, r4
+	bge	.L_loop2_done
+	ldr	r1, [r3]
+	ldr	r2, [r3, #4]
+	movs	r0, 0
+
+.L_loop2_0:
+	subs	r2, #4
+	itt	ge
+	strge	r0, [r1, r2]
+	bge	.L_loop2_0
+
+	adds	r3, #8
+	b	.L_loop2
+.L_loop2_done:
+#elif defined (__STARTUP_CLEAR_BSS)
+/*  Single BSS section scheme.
+ *
+ *  The BSS section is specified by following symbols
+ *    __bss_start__: start of the BSS section.
+ *    __bss_end__: end of the BSS section.
+ *
+ *  Both addresses must be aligned to 4 bytes boundary.
+ */
+	ldr	r1, =__bss_start__
+	ldr	r2, =__bss_end__
+
+	movs	r0, 0
+.L_loop3:
+	cmp	r1, r2
+	itt	lt
+	strlt	r0, [r1], #4
+	blt	.L_loop3
+#endif /* __STARTUP_CLEAR_BSS_MULTIPLE || __STARTUP_CLEAR_BSS */
+
+#ifndef __NO_SYSTEM_INIT
+	bl	SystemInit
+#endif
+
+#ifndef __START
+#define __START _start
+#endif
+	bl	__START
+
+	.pool
+	.size	Reset_Handler, . - Reset_Handler
+
+	.align	1
+	.thumb_func
+	.weak	Default_Handler
+	.type	Default_Handler, %function
+Default_Handler:
+    bkpt #0
+	b	.
+	.size	Default_Handler, . - Default_Handler
+
+/*    Macro to define default handlers. Default handler
+ *    will be weak symbol and just dead loops. They can be
+ *    overwritten by other handlers */
+	.macro	def_irq_handler	handler_name
+	.weak	\handler_name
+	.set	\handler_name, Default_Handler
+	.endm
+
+	def_irq_handler	NMI_Handler
+	def_irq_handler	HardFault_Handler
+	def_irq_handler	MemManage_Handler
+	def_irq_handler	BusFault_Handler
+	def_irq_handler	UsageFault_Handler
+	def_irq_handler	SVC_Handler
+	def_irq_handler	DebugMon_Handler
+	def_irq_handler	PendSV_Handler
+	def_irq_handler	SysTick_Handler
+
+	.end

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/startup_generic.S

@@ -0,0 +1,62 @@
+
+#if defined (__CC_ARM)
+  #if   (defined (ARM_MATH_CM0))
+    #include "ARMCC\startup_armv6-m.s"
+  #elif (defined (ARM_MATH_CM0P))
+    #include "ARMCC\startup_armv6-m.s"
+  #elif (defined (ARM_MATH_CM3))
+    #include "ARMCC\startup_armv7-m.s"
+  #elif (defined (ARM_MATH_CM4))
+    #include "ARMCC\startup_armv7-m.s"
+  #elif (defined (ARM_MATH_CM7))
+    #include "ARMCC\startup_armv7-m.s"
+  #elif (defined (ARM_MATH_ARMV8MBL))
+    #include "ARMCC\startup_armv6-m.s"
+  #elif (defined (ARM_MATH_ARMV8MML))
+    #include "ARMCC\startup_armv7-m.s"
+  #else
+    #error "No appropriate startup file found!"
+  #endif
+
+#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
+  #if   (defined (ARM_MATH_CM0))
+    #include "ARMCLANG\startup_armv6-m.S"
+  #elif (defined (ARM_MATH_CM0P))
+    #include "ARMCLANG\startup_armv6-m.S"
+  #elif (defined (ARM_MATH_CM3))
+    #include "ARMCLANG\startup_armv7-m.S"
+  #elif (defined (ARM_MATH_CM4))
+    #include "ARMCLANG\startup_armv7-m.S"
+  #elif (defined (ARM_MATH_CM7))
+    #include "ARMCLANG\startup_armv7-m.S"
+  #elif (defined (ARM_MATH_ARMV8MBL))
+    #include "ARMCLANG\startup_armv6-m.S"
+  #elif (defined (ARM_MATH_ARMV8MML))
+    #include "ARMCLANG\startup_armv7-m.S"
+  #else
+    #error "No appropriate startup file found!"
+  #endif
+
+#elif defined (__GNUC__)
+  #if   (defined (ARM_MATH_CM0))
+    #include "GCC\startup_armv6-m.S"
+  #elif (defined (ARM_MATH_CM0P))
+    #include "GCC\startup_armv6-m.S"
+  #elif (defined (ARM_MATH_CM3))
+    #include "GCC\startup_armv7-m.S"
+  #elif (defined (ARM_MATH_CM4))
+    #include "GCC\startup_armv7-m.S"
+  #elif (defined (ARM_MATH_CM7))
+    #include "GCC\startup_armv7-m.S"
+  #elif (defined (ARM_MATH_ARMV8MBL))
+    #include "GCC\startup_armv6-m.S"
+  #elif (defined (ARM_MATH_ARMV8MML))
+    #include "GCC\startup_armv7-m.S"
+  #else
+    #error "No appropriate startup file found!"
+  #endif
+
+#else
+  #error "Compiler not supported!"
+#endif
+

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/system_ARMCM0.c

@@ -0,0 +1,56 @@
+/**************************************************************************//**
+ * @file     system_ARMCM0.c
+ * @brief    CMSIS Device System Source File for
+ *           ARMCM0 Device Series
+ * @version  V5.00
+ * @date     07. September 2016
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2016 ARM Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ARMCM0.h"
+
+/*----------------------------------------------------------------------------
+  Define clocks
+ *----------------------------------------------------------------------------*/
+#define  XTAL            ( 5000000UL)      /* Oscillator frequency */
+
+#define  SYSTEM_CLOCK    (5U * XTAL)
+
+
+/*----------------------------------------------------------------------------
+  System Core Clock Variable
+ *----------------------------------------------------------------------------*/
+uint32_t SystemCoreClock = SYSTEM_CLOCK;
+
+
+/*----------------------------------------------------------------------------
+  System Core Clock update function
+ *----------------------------------------------------------------------------*/
+void SystemCoreClockUpdate (void)
+{
+  SystemCoreClock = SYSTEM_CLOCK;
+}
+
+/*----------------------------------------------------------------------------
+  System initialization function
+ *----------------------------------------------------------------------------*/
+void SystemInit (void)
+{
+  SystemCoreClock = SYSTEM_CLOCK;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/system_ARMCM23.c

@@ -0,0 +1,82 @@
+/**************************************************************************//**
+ * @file     system_ARMCM23.c
+ * @brief    CMSIS Device System Source File for
+ *           ARMCM23 Device Series
+ * @version  V5.00
+ * @date     21. October 2016
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2016 ARM Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if defined (ARMCM23)
+  #include "ARMCM23.h"
+#elif defined (ARMCM23_TZ)
+  #include "ARMCM23_TZ.h"
+
+  #if defined (__ARM_FEATURE_CMSE) &&  (__ARM_FEATURE_CMSE == 3U)
+    #include "partition_ARMCM23.h"
+  #endif
+#else
+  #error device not specified!
+#endif
+
+/*----------------------------------------------------------------------------
+  Define clocks
+ *----------------------------------------------------------------------------*/
+#define  XTAL            ( 5000000UL)      /* Oscillator frequency */
+
+#define  SYSTEM_CLOCK    (5U * XTAL)
+
+
+/*----------------------------------------------------------------------------
+  Externals
+ *----------------------------------------------------------------------------*/
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  extern uint32_t __Vectors;
+#endif
+
+/*----------------------------------------------------------------------------
+  System Core Clock Variable
+ *----------------------------------------------------------------------------*/
+uint32_t SystemCoreClock = SYSTEM_CLOCK;
+
+
+/*----------------------------------------------------------------------------
+  System Core Clock update function
+ *----------------------------------------------------------------------------*/
+void SystemCoreClockUpdate (void)
+{
+  SystemCoreClock = SYSTEM_CLOCK;
+}
+
+/*----------------------------------------------------------------------------
+  System initialization function
+ *----------------------------------------------------------------------------*/
+void SystemInit (void)
+{
+
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  SCB->VTOR = (uint32_t) &__Vectors;
+#endif
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+  TZ_SAU_Setup();
+#endif
+
+  SystemCoreClock = SYSTEM_CLOCK;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/system_ARMCM3.c

@@ -0,0 +1,68 @@
+/**************************************************************************//**
+ * @file     system_ARMCM3.c
+ * @brief    CMSIS Device System Source File for
+ *           ARMCM3 Device Series
+ * @version  V5.00
+ * @date     07. September 2016
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2016 ARM Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ARMCM3.h"
+
+/*----------------------------------------------------------------------------
+  Define clocks
+ *----------------------------------------------------------------------------*/
+#define  XTAL            ( 5000000UL)      /* Oscillator frequency */
+
+#define  SYSTEM_CLOCK    (5U * XTAL)
+
+
+/*----------------------------------------------------------------------------
+  Externals
+ *----------------------------------------------------------------------------*/
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  extern uint32_t __Vectors;
+#endif
+
+/*----------------------------------------------------------------------------
+  System Core Clock Variable
+ *----------------------------------------------------------------------------*/
+uint32_t SystemCoreClock = SYSTEM_CLOCK;
+
+
+/*----------------------------------------------------------------------------
+  System Core Clock update function
+ *----------------------------------------------------------------------------*/
+void SystemCoreClockUpdate (void)
+{
+  SystemCoreClock = SYSTEM_CLOCK;
+}
+
+/*----------------------------------------------------------------------------
+  System initialization function
+ *----------------------------------------------------------------------------*/
+void SystemInit (void)
+{
+
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  SCB->VTOR = (uint32_t) &__Vectors;
+#endif
+
+  SystemCoreClock = SYSTEM_CLOCK;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/system_ARMCM33.c

@@ -0,0 +1,99 @@
+/**************************************************************************//**
+ * @file     system_ARMCM33.c
+ * @brief    CMSIS Device System Source File for
+ *           ARMCM33 Device Series
+ * @version  V5.00
+ * @date     02. November 2016
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2016 ARM Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if defined (ARMCM33)
+  #include "ARMCM33.h"
+#elif defined (ARMCM33_TZ)
+  #include "ARMCM33_TZ.h"
+
+  #if defined (__ARM_FEATURE_CMSE) &&  (__ARM_FEATURE_CMSE == 3U)
+    #include "partition_ARMCM33.h"
+  #endif
+#elif defined (ARMCM33_DSP_FP)
+  #include "ARMCM33_DSP_FP.h"
+#elif defined (ARMCM33_DSP_FP_TZ)
+  #include "ARMCM33_DSP_FP_TZ.h"
+
+  #if defined (__ARM_FEATURE_CMSE) &&  (__ARM_FEATURE_CMSE == 3U)
+    #include "partition_ARMCM33.h"
+  #endif
+#else
+  #error device not specified!
+#endif
+
+/*----------------------------------------------------------------------------
+  Define clocks
+ *----------------------------------------------------------------------------*/
+#define  XTAL            ( 5000000UL)      /* Oscillator frequency */
+
+#define  SYSTEM_CLOCK    (5U * XTAL)
+
+
+/*----------------------------------------------------------------------------
+  Externals
+ *----------------------------------------------------------------------------*/
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  extern uint32_t __Vectors;
+#endif
+
+/*----------------------------------------------------------------------------
+  System Core Clock Variable
+ *----------------------------------------------------------------------------*/
+uint32_t SystemCoreClock = SYSTEM_CLOCK;
+
+
+/*----------------------------------------------------------------------------
+  System Core Clock update function
+ *----------------------------------------------------------------------------*/
+void SystemCoreClockUpdate (void)
+{
+  SystemCoreClock = SYSTEM_CLOCK;
+}
+
+/*----------------------------------------------------------------------------
+  System initialization function
+ *----------------------------------------------------------------------------*/
+void SystemInit (void)
+{
+
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  SCB->VTOR = (uint32_t) &__Vectors;
+#endif
+
+#if defined (__FPU_USED) && (__FPU_USED == 1U)
+  SCB->CPACR |= ((3U << 10U*2U) |           /* set CP10 Full Access */
+                 (3U << 11U*2U)  );         /* set CP11 Full Access */
+#endif
+
+#ifdef UNALIGNED_SUPPORT_DISABLE
+  SCB->CCR |= SCB_CCR_UNALIGN_TRP_Msk;
+#endif
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+  TZ_SAU_Setup();
+#endif
+
+  SystemCoreClock = SYSTEM_CLOCK;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/system_ARMCM4.c

@@ -0,0 +1,83 @@
+/**************************************************************************//**
+ * @file     system_ARMCM4.c
+ * @brief    CMSIS Device System Source File for
+ *           ARMCM4 Device Series
+ * @version  V5.00
+ * @date     07. September 2016
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2016 ARM Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if defined (ARMCM4)
+  #include "ARMCM4.h"
+#elif defined (ARMCM4_FP)
+  #include "ARMCM4_FP.h"
+#else
+  #error device not specified!
+#endif
+
+/*----------------------------------------------------------------------------
+  Define clocks
+ *----------------------------------------------------------------------------*/
+#define  XTAL            ( 5000000UL)      /* Oscillator frequency */
+
+#define  SYSTEM_CLOCK    (5U * XTAL)
+
+
+/*----------------------------------------------------------------------------
+  Externals
+ *----------------------------------------------------------------------------*/
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  extern uint32_t __Vectors;
+#endif
+
+/*----------------------------------------------------------------------------
+  System Core Clock Variable
+ *----------------------------------------------------------------------------*/
+uint32_t SystemCoreClock = SYSTEM_CLOCK;
+
+
+/*----------------------------------------------------------------------------
+  System Core Clock update function
+ *----------------------------------------------------------------------------*/
+void SystemCoreClockUpdate (void)
+{
+  SystemCoreClock = SYSTEM_CLOCK;
+}
+
+/*----------------------------------------------------------------------------
+  System initialization function
+ *----------------------------------------------------------------------------*/
+void SystemInit (void)
+{
+
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  SCB->VTOR = (uint32_t) &__Vectors;
+#endif
+
+#if defined (__FPU_USED) && (__FPU_USED == 1U)
+  SCB->CPACR |= ((3U << 10U*2U) |           /* set CP10 Full Access */
+                 (3U << 11U*2U)  );         /* set CP11 Full Access */
+#endif
+
+#ifdef UNALIGNED_SUPPORT_DISABLE
+  SCB->CCR |= SCB_CCR_UNALIGN_TRP_Msk;
+#endif
+
+  SystemCoreClock = SYSTEM_CLOCK;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/system_ARMCM7.c

@@ -0,0 +1,85 @@
+/**************************************************************************//**
+ * @file     system_ARMCM7.c
+ * @brief    CMSIS Device System Source File for
+ *           ARMCM7 Device Series
+ * @version  V5.00
+ * @date     07. September 2016
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2016 ARM Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if defined (ARMCM7)
+  #include "ARMCM7.h"
+#elif defined (ARMCM7_SP)
+  #include "ARMCM7_SP.h"
+#elif defined (ARMCM7_DP)
+  #include "ARMCM7_DP.h"
+#else
+  #error device not specified!
+#endif
+
+/*----------------------------------------------------------------------------
+  Define clocks
+ *----------------------------------------------------------------------------*/
+#define  XTAL            ( 5000000UL)      /* Oscillator frequency */
+
+#define  SYSTEM_CLOCK    (5U * XTAL)
+
+
+/*----------------------------------------------------------------------------
+  Externals
+ *----------------------------------------------------------------------------*/
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  extern uint32_t __Vectors;
+#endif
+
+/*----------------------------------------------------------------------------
+  System Core Clock Variable
+ *----------------------------------------------------------------------------*/
+uint32_t SystemCoreClock = SYSTEM_CLOCK;
+
+
+/*----------------------------------------------------------------------------
+  System Core Clock update function
+ *----------------------------------------------------------------------------*/
+void SystemCoreClockUpdate (void)
+{
+  SystemCoreClock = SYSTEM_CLOCK;
+}
+
+/*----------------------------------------------------------------------------
+  System initialization function
+ *----------------------------------------------------------------------------*/
+void SystemInit (void)
+{
+
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  SCB->VTOR = (uint32_t) &__Vectors;
+#endif
+
+#if defined (__FPU_USED) && (__FPU_USED == 1U)
+  SCB->CPACR |= ((3U << 10U*2U) |           /* set CP10 Full Access */
+                 (3U << 11U*2U)  );         /* set CP11 Full Access */
+#endif
+
+#ifdef UNALIGNED_SUPPORT_DISABLE
+  SCB->CCR |= SCB_CCR_UNALIGN_TRP_Msk;
+#endif
+
+  SystemCoreClock = SYSTEM_CLOCK;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/system_ARMSC000.c

@@ -0,0 +1,56 @@
+/**************************************************************************//**
+ * @file     system_ARMSC000.c
+ * @brief    CMSIS Device System Source File for
+ *           for ARMSC000 Device Series
+ * @version  V5.00
+ * @date     07. September 2016
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2016 ARM Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ARMSC000.h"
+
+/*----------------------------------------------------------------------------
+  Define clocks
+ *----------------------------------------------------------------------------*/
+#define  XTAL            ( 5000000UL)      /* Oscillator frequency */
+
+#define  SYSTEM_CLOCK    (5U * XTAL)
+
+
+/*----------------------------------------------------------------------------
+  System Core Clock Variable
+ *----------------------------------------------------------------------------*/
+uint32_t SystemCoreClock = SYSTEM_CLOCK;
+
+
+/*----------------------------------------------------------------------------
+  System Core Clock update function
+ *----------------------------------------------------------------------------*/
+void SystemCoreClockUpdate (void)
+{
+  SystemCoreClock = SYSTEM_CLOCK;
+}
+
+/*----------------------------------------------------------------------------
+  System initialization function
+ *----------------------------------------------------------------------------*/
+void SystemInit (void)
+{
+  SystemCoreClock = SYSTEM_CLOCK;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/system_ARMSC300.c

@@ -0,0 +1,72 @@
+/**************************************************************************//**
+ * @file     system_ARMSC300.c
+ * @brief    CMSIS Device System Source File for
+ *           ARMSC300 Device Series
+ * @version  V5.00
+ * @date     07. September 2016
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2016 ARM Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ARMSC300.h"
+
+/*----------------------------------------------------------------------------
+  Define clocks
+ *----------------------------------------------------------------------------*/
+#define  XTAL            ( 5000000UL)      /* Oscillator frequency */
+
+#define  SYSTEM_CLOCK    (5U * XTAL)
+
+
+/*----------------------------------------------------------------------------
+  Externals
+ *----------------------------------------------------------------------------*/
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  extern uint32_t __Vectors;
+#endif
+
+/*----------------------------------------------------------------------------
+  System Core Clock Variable
+ *----------------------------------------------------------------------------*/
+uint32_t SystemCoreClock = SYSTEM_CLOCK;
+
+
+/*----------------------------------------------------------------------------
+  System Core Clock update function
+ *----------------------------------------------------------------------------*/
+void SystemCoreClockUpdate (void)
+{
+  SystemCoreClock = SYSTEM_CLOCK;
+}
+
+/*----------------------------------------------------------------------------
+  System initialization function
+ *----------------------------------------------------------------------------*/
+void SystemInit (void)
+{
+
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  SCB->VTOR = (uint32_t) &__Vectors;
+#endif
+
+#ifdef UNALIGNED_SUPPORT_DISABLE
+  SCB->CCR |= SCB_CCR_UNALIGN_TRP_Msk;
+#endif
+
+  SystemCoreClock = SYSTEM_CLOCK;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/system_ARMv8MBL.c

@@ -0,0 +1,76 @@
+/**************************************************************************//**
+ * @file     system_ARMv8MBL.c
+ * @brief    CMSIS Device System Source File for
+ *           ARMv8MBL Device Series
+ * @version  V5.00
+ * @date     07. September 2016
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2016 ARM Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ARMv8MBL.h"
+
+#if defined (__ARM_FEATURE_CMSE) &&  (__ARM_FEATURE_CMSE == 3U)
+  #include "partition_ARMv8MBL.h"
+#endif
+
+/*----------------------------------------------------------------------------
+  Define clocks
+ *----------------------------------------------------------------------------*/
+#define  XTAL            ( 5000000UL)      /* Oscillator frequency */
+
+#define  SYSTEM_CLOCK    (5U * XTAL)
+
+
+/*----------------------------------------------------------------------------
+  Externals
+ *----------------------------------------------------------------------------*/
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  extern uint32_t __Vectors;
+#endif
+
+/*----------------------------------------------------------------------------
+  System Core Clock Variable
+ *----------------------------------------------------------------------------*/
+uint32_t SystemCoreClock = SYSTEM_CLOCK;
+
+
+/*----------------------------------------------------------------------------
+  System Core Clock update function
+ *----------------------------------------------------------------------------*/
+void SystemCoreClockUpdate (void)
+{
+  SystemCoreClock = SYSTEM_CLOCK;
+}
+
+/*----------------------------------------------------------------------------
+  System initialization function
+ *----------------------------------------------------------------------------*/
+void SystemInit (void)
+{
+
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  SCB->VTOR = (uint32_t) &__Vectors;
+#endif
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+  TZ_SAU_Setup();
+#endif
+
+  SystemCoreClock = SYSTEM_CLOCK;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/system_ARMv8MML.c

@@ -0,0 +1,99 @@
+/**************************************************************************//**
+ * @file     system_ARMv8MML.c
+ * @brief    CMSIS Device System Source File for
+ *           ARMv8MML Device Series
+ * @version  V5.00
+ * @date     02. November 2016
+ ******************************************************************************/
+/*
+ * Copyright (c) 2009-2016 ARM Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if defined (ARMv8MML)
+  #include "ARMv8MML.h"
+#elif defined (ARMv8MML_DSP)
+  #include "ARMv8MML_DSP.h"
+#elif defined (ARMv8MML_SP)
+  #include "ARMv8MML_SP.h"
+#elif defined (ARMv8MML_DSP_SP)
+  #include "ARMv8MML_DSP_SP.h"
+#elif defined (ARMv8MML_DP)
+  #include "ARMv8MML_DP.h"
+#elif defined (ARMv8MML_DSP_DP)
+  #include "ARMv8MML_DSP_DP.h"
+#else
+  #error device not specified!
+#endif
+
+#if defined (__ARM_FEATURE_CMSE) &&  (__ARM_FEATURE_CMSE == 3U)
+  #include "partition_ARMv8MML.h"
+#endif
+
+/*----------------------------------------------------------------------------
+  Define clocks
+ *----------------------------------------------------------------------------*/
+#define  XTAL            ( 5000000UL)      /* Oscillator frequency */
+
+#define  SYSTEM_CLOCK    (5U * XTAL)
+
+
+/*----------------------------------------------------------------------------
+  Externals
+ *----------------------------------------------------------------------------*/
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  extern uint32_t __Vectors;
+#endif
+
+/*----------------------------------------------------------------------------
+  System Core Clock Variable
+ *----------------------------------------------------------------------------*/
+uint32_t SystemCoreClock = SYSTEM_CLOCK;
+
+
+/*----------------------------------------------------------------------------
+  System Core Clock update function
+ *----------------------------------------------------------------------------*/
+void SystemCoreClockUpdate (void)
+{
+  SystemCoreClock = SYSTEM_CLOCK;
+}
+
+/*----------------------------------------------------------------------------
+  System initialization function
+ *----------------------------------------------------------------------------*/
+void SystemInit (void)
+{
+
+#if defined (__VTOR_PRESENT) && (__VTOR_PRESENT == 1U)
+  SCB->VTOR = (uint32_t) &__Vectors;
+#endif
+
+#if defined (__FPU_USED) && (__FPU_USED == 1U)
+  SCB->CPACR |= ((3U << 10U*2U) |           /* set CP10 Full Access */
+                 (3U << 11U*2U)  );         /* set CP11 Full Access */
+#endif
+
+#ifdef UNALIGNED_SUPPORT_DISABLE
+  SCB->CCR |= SCB_CCR_UNALIGN_TRP_Msk;
+#endif
+
+#if defined (__ARM_FEATURE_CMSE) && (__ARM_FEATURE_CMSE == 3U)
+  TZ_SAU_Setup();
+#endif
+
+  SystemCoreClock = SYSTEM_CLOCK;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/system_generic.c

@@ -0,0 +1,27 @@
+
+#if   (defined (ARMCM0))
+  #include "system_ARMCM0.c"
+
+#elif (defined (ARMCM0P))
+  #include "system_ARMCM0plus.c"
+
+#elif (defined (ARMCM3))
+  #include "system_ARMCM3.c"
+
+#elif (defined (ARMCM4) || defined (ARMCM4_FP))
+  #include "system_ARMCM4.c"
+
+#elif (defined (ARMCM7) || defined (ARMCM7_SP) || defined (ARMCM7_DP))
+  #include "system_ARMCM7.c"
+
+#elif defined (ARMv8MBL)
+  #include "system_ARMv8MBL.c"
+
+#elif (defined (ARMv8MML)    || defined (ARMv8MML_DSP)    || \
+       defined (ARMv8MML_SP) || defined (ARMv8MML_DSP_SP) || \
+       defined (ARMv8MML_DP) || defined (ARMv8MML_DSP_DP)   )
+  #include "system_ARMv8MML.c"
+
+#else
+  #error "No appropriate system file found!"
+#endif

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/all_tests.c

@@ -0,0 +1,30 @@
+#include "jtest.h"
+#include "basic_math_test_group.h"
+#include "complex_math_test_group.h"
+#include "controller_test_group.h"
+#include "fast_math_test_group.h"
+#include "filtering_test_group.h"
+#include "matrix_test_group.h"
+#include "statistics_test_group.h"
+#include "support_test_group.h"
+#include "transform_test_group.h"
+#include "intrinsics_test_group.h"
+
+JTEST_DEFINE_GROUP(all_tests)
+{
+    /*
+      To skip a test, comment it out
+    */
+    JTEST_GROUP_CALL(basic_math_tests);
+    JTEST_GROUP_CALL(complex_math_tests);
+    JTEST_GROUP_CALL(controller_tests);
+    JTEST_GROUP_CALL(fast_math_tests);
+    JTEST_GROUP_CALL(filtering_tests);
+    JTEST_GROUP_CALL(matrix_tests);
+    JTEST_GROUP_CALL(statistics_tests);
+    JTEST_GROUP_CALL(support_tests);
+    JTEST_GROUP_CALL(transform_tests);
+    JTEST_GROUP_CALL(intrinsics_tests);
+
+    return;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/abs_tests.c

@@ -0,0 +1,32 @@
+#include "jtest.h"
+#include "basic_math_test_data.h"
+#include "arr_desc.h"
+#include "arm_math.h"           /* FUTs */
+#include "ref.h"                /* Reference Functions */
+#include "test_templates.h"
+#include "basic_math_templates.h"
+#include "type_abbrev.h"
+
+#define JTEST_ARM_ABS_TEST(suffix)              \
+    BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_BLK(   \
+        abs,                                    \
+        suffix,                                 \
+        TYPE_FROM_ABBREV(suffix),               \
+        TYPE_FROM_ABBREV(suffix))
+    
+JTEST_ARM_ABS_TEST(f32);
+JTEST_ARM_ABS_TEST(q31);
+JTEST_ARM_ABS_TEST(q15);
+JTEST_ARM_ABS_TEST(q7 );
+
+/*--------------------------------------------------------------------------------*/
+/* Collect all tests in a group. */
+/*--------------------------------------------------------------------------------*/
+
+JTEST_DEFINE_GROUP(abs_tests)
+{
+    JTEST_TEST_CALL(arm_abs_f32_test);
+    JTEST_TEST_CALL(arm_abs_q31_test);
+    JTEST_TEST_CALL(arm_abs_q15_test);
+    JTEST_TEST_CALL(arm_abs_q7_test);
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/add_tests.c

@@ -0,0 +1,33 @@
+#include "jtest.h"
+#include "basic_math_test_data.h"
+#include "arr_desc.h"
+#include "arm_math.h"           /* FUTs */
+#include "ref.h"                /* Reference Functions */
+#include "test_templates.h"
+#include "basic_math_templates.h"
+#include "type_abbrev.h"
+
+#define JTEST_ARM_ADD_TEST(suffix)              \
+    BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK(   \
+        add,                                    \
+        suffix,                                 \
+        TYPE_FROM_ABBREV(suffix),               \
+        TYPE_FROM_ABBREV(suffix),               \
+        BASIC_MATH_COMPARE_INTERFACE)
+
+JTEST_ARM_ADD_TEST(f32);
+JTEST_ARM_ADD_TEST(q31);
+JTEST_ARM_ADD_TEST(q15);
+JTEST_ARM_ADD_TEST(q7);
+
+/*--------------------------------------------------------------------------------*/
+/* Collect all tests in a group. */
+/*--------------------------------------------------------------------------------*/
+
+JTEST_DEFINE_GROUP(add_tests)
+{
+    JTEST_TEST_CALL(arm_add_f32_test);
+    JTEST_TEST_CALL(arm_add_q31_test);
+    JTEST_TEST_CALL(arm_add_q15_test);
+    JTEST_TEST_CALL(arm_add_q7_test);
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/basic_math_test_common_data.c

@@ -0,0 +1,101 @@
+#include "basic_math_test_data.h"
+
+/*--------------------------------------------------------------------------------*/
+/* Input/Output Buffers */
+/*--------------------------------------------------------------------------------*/
+
+ARR_DESC_DEFINE(BASIC_MATH_BIGGEST_INPUT_TYPE,
+                basic_math_output_fut,
+                BASIC_MATH_MAX_INPUT_ELEMENTS,
+                CURLY(0));
+
+ARR_DESC_DEFINE(BASIC_MATH_BIGGEST_INPUT_TYPE,
+                basic_math_output_ref,
+                BASIC_MATH_MAX_INPUT_ELEMENTS,
+                CURLY(0));
+
+BASIC_MATH_BIGGEST_INPUT_TYPE
+basic_math_output_f32_ref[BASIC_MATH_MAX_INPUT_ELEMENTS];
+
+BASIC_MATH_BIGGEST_INPUT_TYPE
+basic_math_output_f32_fut[BASIC_MATH_MAX_INPUT_ELEMENTS];
+
+/*--------------------------------------------------------------------------------*/
+/* Block Sizes */
+/*--------------------------------------------------------------------------------*/
+
+/* 
+  To change test parameter values add/remove values inside CURLY and update 
+  the preceeding parameter to reflect the number of values inside CURLY. 
+*/
+
+ARR_DESC_DEFINE(uint32_t,
+                basic_math_block_sizes,
+                4,
+                CURLY( 2, 7, 15, 32));
+
+/*--------------------------------------------------------------------------------*/
+/* Numbers */
+/*--------------------------------------------------------------------------------*/
+
+/* 
+  To change test parameter values add/remove values inside CURLY and update 
+  the preceeding parameter to reflect the number of values inside CURLY. 
+*/
+
+ARR_DESC_DEFINE(uint32_t,
+                basic_math_elts,
+                4,
+                CURLY( 0, 1, 0x80000000, 0x7fffffff));
+
+ARR_DESC_DEFINE(int8_t,
+                basic_math_elts2,
+                5,
+                CURLY( 0, 3, -3, -7, 7));
+
+ARR_DESC_DEFINE(float32_t,
+                basic_math_eltsf,
+                6,
+                CURLY( 0.0f, 1.0f, 1.254001, -1.665584, -127.435646, 245.34634267));
+
+/*--------------------------------------------------------------------------------*/
+/* Test Data */
+/*--------------------------------------------------------------------------------*/
+
+ARR_DESC_DEFINE(float32_t,
+                basic_math_f_32,
+                32,
+                CURLY(
+                      -0.432565, -1.665584,  0.125332,  0.287676, -1.146471,
+                       1.190915,  1.189164, -0.037633,  0.327292,  0.174639,
+                      -0.186709,  0.725791, -0.588317,  2.183186, -0.136396,
+                       0.113931,  1.066768,  0.059281, -0.095648, -0.832349,
+                       0.294411, -1.336182,  0.714325,  1.623562, -0.691776,
+                       0.857997,  1.254001, -1.593730, -1.440964,  0.571148,
+                      -0.399886,  0.689997
+                      ));
+
+/* Alias the 32 element array with wrappers that end sooner. */
+ARR_DESC_DEFINE_SUBSET(basic_math_f_15,
+                       basic_math_f_32,
+                       15);
+
+ARR_DESC_DEFINE_SUBSET(basic_math_f_2,
+                       basic_math_f_32,
+                       2);
+
+ARR_DESC_DEFINE(float32_t,
+                basic_math_zeros,
+                32,
+                CURLY(0));
+
+/* Aggregate all float datasets. */
+ARR_DESC_DEFINE(ARR_DESC_t *,
+                basic_math_f_all,
+                4,
+                CURLY(
+                      &basic_math_zeros,
+                      &basic_math_f_2,
+                      &basic_math_f_15,
+                      &basic_math_f_32
+                      ));

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/basic_math_test_group.c

@@ -0,0 +1,17 @@
+#include "jtest.h"
+#include "basic_math_tests.h"
+
+JTEST_DEFINE_GROUP(basic_math_tests)
+{
+    JTEST_GROUP_CALL(abs_tests);
+    JTEST_GROUP_CALL(add_tests);
+    JTEST_GROUP_CALL(dot_prod_tests);
+    JTEST_GROUP_CALL(mult_tests);
+    JTEST_GROUP_CALL(negate_tests);
+    JTEST_GROUP_CALL(offset_tests);
+    JTEST_GROUP_CALL(scale_tests); 
+    JTEST_GROUP_CALL(shift_tests);
+    JTEST_GROUP_CALL(sub_tests);
+
+    return;
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/dot_prod_tests.c

@@ -0,0 +1,33 @@
+#include "jtest.h"
+#include "basic_math_test_data.h"
+#include "arr_desc.h"
+#include "arm_math.h"           /* FUTs */
+#include "ref.h"                /* Reference Functions */
+#include "test_templates.h"
+#include "basic_math_templates.h"
+#include "type_abbrev.h"
+
+#define JTEST_ARM_DOT_PROD_TEST(suffix)         \
+    BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK(   \
+        dot_prod,                               \
+        suffix,                                 \
+        TYPE_FROM_ABBREV(suffix),               \
+        TYPE_FROM_ABBREV(suffix),               \
+        BASIC_MATH_SNR_ELT1_COMPARE_INTERFACE)
+
+JTEST_ARM_DOT_PROD_TEST(f32);
+JTEST_ARM_DOT_PROD_TEST(q31);
+JTEST_ARM_DOT_PROD_TEST(q15);
+JTEST_ARM_DOT_PROD_TEST(q7);
+
+/*--------------------------------------------------------------------------------*/
+/* Collect all tests in a group. */
+/*--------------------------------------------------------------------------------*/
+
+JTEST_DEFINE_GROUP(dot_prod_tests)
+{
+    JTEST_TEST_CALL(arm_dot_prod_f32_test);
+    JTEST_TEST_CALL(arm_dot_prod_q31_test);
+    JTEST_TEST_CALL(arm_dot_prod_q15_test);
+    JTEST_TEST_CALL(arm_dot_prod_q7_test);
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/mult_tests.c

@@ -0,0 +1,33 @@
+#include "jtest.h"
+#include "basic_math_test_data.h"
+#include "arr_desc.h"
+#include "arm_math.h"           /* FUTs */
+#include "ref.h"                /* Reference Functions */
+#include "test_templates.h"
+#include "basic_math_templates.h"
+#include "type_abbrev.h"
+
+#define JTEST_ARM_MULT_TEST(suffix, compare_interface)  \
+    BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK(   \
+        mult,                                   \
+        suffix,                                 \
+        TYPE_FROM_ABBREV(suffix),               \
+        TYPE_FROM_ABBREV(suffix),               \
+        compare_interface)
+
+JTEST_ARM_MULT_TEST(f32, BASIC_MATH_COMPARE_INTERFACE);
+JTEST_ARM_MULT_TEST(q31, BASIC_MATH_SNR_COMPARE_INTERFACE);
+JTEST_ARM_MULT_TEST(q15, BASIC_MATH_COMPARE_INTERFACE);
+JTEST_ARM_MULT_TEST(q7 , BASIC_MATH_COMPARE_INTERFACE);
+
+/*--------------------------------------------------------------------------------*/
+/* Collect all tests in a group. */
+/*--------------------------------------------------------------------------------*/
+
+JTEST_DEFINE_GROUP(mult_tests)
+{
+    JTEST_TEST_CALL(arm_mult_f32_test);
+    JTEST_TEST_CALL(arm_mult_q31_test);
+    JTEST_TEST_CALL(arm_mult_q15_test);
+    JTEST_TEST_CALL(arm_mult_q7_test);
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/negate_tests.c

@@ -0,0 +1,32 @@
+#include "jtest.h"
+#include "basic_math_test_data.h"
+#include "arr_desc.h"
+#include "arm_math.h"           /* FUTs */
+#include "ref.h"                /* Reference Functions */
+#include "test_templates.h"
+#include "basic_math_templates.h"
+#include "type_abbrev.h"
+
+#define JTEST_ARM_NEGATE_TEST(suffix)           \
+    BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_BLK(   \
+        negate,                                 \
+        suffix,                                 \
+        TYPE_FROM_ABBREV(suffix),               \
+        TYPE_FROM_ABBREV(suffix))
+    
+JTEST_ARM_NEGATE_TEST(f32);
+JTEST_ARM_NEGATE_TEST(q31);
+JTEST_ARM_NEGATE_TEST(q15);
+JTEST_ARM_NEGATE_TEST(q7);
+
+/*--------------------------------------------------------------------------------*/
+/* Collect all tests in a group. */
+/*--------------------------------------------------------------------------------*/
+
+JTEST_DEFINE_GROUP(negate_tests)
+{
+    JTEST_TEST_CALL(arm_negate_f32_test);
+    JTEST_TEST_CALL(arm_negate_q31_test);
+    JTEST_TEST_CALL(arm_negate_q15_test);
+    JTEST_TEST_CALL(arm_negate_q7_test);
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/offset_tests.c

@@ -0,0 +1,33 @@
+#include "jtest.h"
+#include "basic_math_test_data.h"
+#include "arr_desc.h"
+#include "arm_math.h"           /* FUTs */
+#include "ref.h"                /* Reference Functions */
+#include "test_templates.h"
+#include "basic_math_templates.h"
+#include "type_abbrev.h"
+
+#define JTEST_ARM_OFFSET_TEST(suffix)               \
+    BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_ELT1_BLK(  \
+        offset,                                     \
+        suffix,                                     \
+        TYPE_FROM_ABBREV(suffix),                   \
+        TYPE_FROM_ABBREV(suffix),                   \
+        TYPE_FROM_ABBREV(suffix))
+
+JTEST_ARM_OFFSET_TEST(f32);
+JTEST_ARM_OFFSET_TEST(q31);
+JTEST_ARM_OFFSET_TEST(q15);
+JTEST_ARM_OFFSET_TEST(q7);
+
+/*--------------------------------------------------------------------------------*/
+/* Collect all tests in a group. */
+/*--------------------------------------------------------------------------------*/
+
+JTEST_DEFINE_GROUP(offset_tests)
+{
+    JTEST_TEST_CALL(arm_offset_f32_test);
+    JTEST_TEST_CALL(arm_offset_q31_test);
+    JTEST_TEST_CALL(arm_offset_q15_test);
+    JTEST_TEST_CALL(arm_offset_q7_test);
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/scale_tests.c

@@ -0,0 +1,52 @@
+#include "jtest.h"
+#include "basic_math_test_data.h"
+#include "arr_desc.h"
+#include "arm_math.h"           /* FUTs */
+#include "ref.h"                /* Reference Functions */
+#include "test_templates.h"
+#include "basic_math_templates.h"
+#include "type_abbrev.h"
+
+
+#define JTEST_ARM_SCALE_TEST(suffix)                \
+    BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_ELT2_BLK(  \
+        scale,                                      \
+        suffix,                                     \
+        TYPE_FROM_ABBREV(suffix),                   \
+        TYPE_FROM_ABBREV(suffix), /*elt1_type*/     \
+        int8_t, /*elt2_type*/                       \
+        TYPE_FROM_ABBREV(suffix))
+
+/* float32_t defined separately because it has less arguments */
+JTEST_DEFINE_TEST(arm_scale_f32_test,
+                  arm_scale_f32)
+{
+    TEST_TEMPLATE_BUF1_ELT1_BLK(
+        basic_math_f_all,
+        basic_math_eltsf,
+        basic_math_block_sizes,
+        float32_t,
+        float32_t,
+        float32_t,
+        arm_scale_f32,
+        ARM_scale_float_INPUT_INTERFACE,
+        ref_scale_f32,
+        REF_scale_float_INPUT_INTERFACE,
+        BASIC_MATH_COMPARE_INTERFACE);
+}
+
+JTEST_ARM_SCALE_TEST(q31);
+JTEST_ARM_SCALE_TEST(q15);
+JTEST_ARM_SCALE_TEST(q7);
+
+/*--------------------------------------------------------------------------------*/
+/* Collect all tests in a group. */
+/*--------------------------------------------------------------------------------*/
+
+JTEST_DEFINE_GROUP(scale_tests)
+{
+    JTEST_TEST_CALL(arm_scale_f32_test);
+    JTEST_TEST_CALL(arm_scale_q31_test);
+    JTEST_TEST_CALL(arm_scale_q15_test);
+    JTEST_TEST_CALL(arm_scale_q7_test);
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/shift_tests.c

@@ -0,0 +1,31 @@
+#include "jtest.h"
+#include "basic_math_test_data.h"
+#include "arr_desc.h"
+#include "arm_math.h"           /* FUTs */
+#include "ref.h"                /* Reference Functions */
+#include "test_templates.h"
+#include "basic_math_templates.h"
+#include "type_abbrev.h"
+
+#define JTEST_ARM_SHIFT_TEST(suffix)                \
+    BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF1_ELT1_BLK(  \
+        shift,                                      \
+        suffix,                                     \
+        TYPE_FROM_ABBREV(suffix),                   \
+        int8_t, /*elt_type*/                        \
+        TYPE_FROM_ABBREV(suffix))
+
+JTEST_ARM_SHIFT_TEST(q31);
+JTEST_ARM_SHIFT_TEST(q15);
+JTEST_ARM_SHIFT_TEST(q7);
+
+/*--------------------------------------------------------------------------------*/
+/* Collect all tests in a group. */
+/*--------------------------------------------------------------------------------*/
+
+JTEST_DEFINE_GROUP(shift_tests)
+{
+    JTEST_TEST_CALL(arm_shift_q31_test);
+    JTEST_TEST_CALL(arm_shift_q15_test);
+    JTEST_TEST_CALL(arm_shift_q7_test);
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/basic_math_tests/sub_tests.c

@@ -0,0 +1,33 @@
+#include "jtest.h"
+#include "basic_math_test_data.h"
+#include "arr_desc.h"
+#include "arm_math.h"           /* FUTs */
+#include "ref.h"                /* Reference Functions */
+#include "test_templates.h"
+#include "basic_math_templates.h"
+#include "type_abbrev.h"
+
+#define JTEST_ARM_SUB_TEST(suffix)              \
+    BASIC_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK(   \
+        sub,                                    \
+        suffix,                                 \
+        TYPE_FROM_ABBREV(suffix),               \
+        TYPE_FROM_ABBREV(suffix),               \
+        BASIC_MATH_COMPARE_INTERFACE)
+
+JTEST_ARM_SUB_TEST(f32);
+JTEST_ARM_SUB_TEST(q31);
+JTEST_ARM_SUB_TEST(q15);
+JTEST_ARM_SUB_TEST(q7);
+
+/*--------------------------------------------------------------------------------*/
+/* Collect all tests in a group. */
+/*--------------------------------------------------------------------------------*/
+
+JTEST_DEFINE_GROUP(sub_tests)
+{
+    JTEST_TEST_CALL(arm_sub_f32_test);
+    JTEST_TEST_CALL(arm_sub_q31_test);
+    JTEST_TEST_CALL(arm_sub_q15_test);
+    JTEST_TEST_CALL(arm_sub_q7_test);
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/complex_math_tests/cmplx_conj_tests.c

@@ -0,0 +1,31 @@
+#include "jtest.h"
+#include "complex_math_test_data.h"
+#include "arr_desc.h"
+#include "arm_math.h"           /* FUTs */
+#include "ref.h"                /* Reference Functions */
+#include "test_templates.h"
+#include "complex_math_templates.h"
+#include "type_abbrev.h"
+
+#define JTEST_ARM_CMPLX_CONJ_TEST(suffix)           \
+    COMPLEX_MATH_DEFINE_TEST_TEMPLATE_BUF1_BLK(     \
+        cmplx_conj,                                 \
+        suffix,                                     \
+        TYPE_FROM_ABBREV(suffix),                   \
+        TYPE_FROM_ABBREV(suffix),                   \
+        COMPLEX_MATH_SNR_COMPARE_CMPLX_INTERFACE)
+
+JTEST_ARM_CMPLX_CONJ_TEST(f32);
+JTEST_ARM_CMPLX_CONJ_TEST(q31);
+JTEST_ARM_CMPLX_CONJ_TEST(q15);
+
+/*--------------------------------------------------------------------------------*/
+/* Collect all tests in a group. */
+/*--------------------------------------------------------------------------------*/
+
+JTEST_DEFINE_GROUP(cmplx_conj_tests)
+{
+    JTEST_TEST_CALL(arm_cmplx_conj_f32_test);
+    JTEST_TEST_CALL(arm_cmplx_conj_q31_test);
+    JTEST_TEST_CALL(arm_cmplx_conj_q15_test);
+}

Drivers/CMSIS/DSP/DSP_Lib_TestSuite/Common/src/complex_math_tests/cmplx_dot_prod_tests.c

@@ -0,0 +1,31 @@
+#include "jtest.h"
+#include "complex_math_test_data.h"
+#include "arr_desc.h"
+#include "arm_math.h"           /* FUTs */
+#include "ref.h"                /* Reference Functions */
+#include "test_templates.h"
+#include "complex_math_templates.h"
+#include "type_abbrev.h"
+
+#define JTEST_ARM_CMPLX_DOT_PROD_TEST(suffix, comparison_interface) \
+    COMPLEX_MATH_DEFINE_TEST_TEMPLATE_BUF2_BLK(                     \
+        cmplx_dot_prod,                                             \
+        suffix,                                                     \
+        TYPE_FROM_ABBREV(suffix),                                   \
+        TYPE_FROM_ABBREV(suffix),                                   \
+        comparison_interface)
+
+JTEST_ARM_CMPLX_DOT_PROD_TEST(f32, COMPLEX_MATH_SNR_COMPARE_SPLIT_INTERFACE);
+JTEST_ARM_CMPLX_DOT_PROD_TEST(q31, COMPLEX_MATH_SNR_COMPARE_SPLIT_INTERFACE);
+JTEST_ARM_CMPLX_DOT_PROD_TEST(q15, COMPLEX_MATH_SNR_COMPARE_SPLIT_INTERFACE);
+
+/*--------------------------------------------------------------------------------*/
+/* Collect all tests in a group. */
+/*--------------------------------------------------------------------------------*/
+
+JTEST_DEFINE_GROUP(cmplx_dot_prod_tests)
+{
+    JTEST_TEST_CALL(arm_cmplx_dot_prod_f32_test);
+    JTEST_TEST_CALL(arm_cmplx_dot_prod_q31_test);
+    JTEST_TEST_CALL(arm_cmplx_dot_prod_q15_test);
+}