CMSIS-DSP: Remove deprecated test framework.

Removed project folder used to build the library binaries since the
library is now distributed in source form only.

CMSIS/DSP/DSP_Lib_TestSuite/CMakeLists.txt

@@ -1,141 +0,0 @@
-cmake_minimum_required (VERSION 3.14)
-cmake_policy(SET CMP0077 NEW)
-# The tests are assuming that MATRIX_CHECK is enabled when building
-# CMSIS-DSP.
-set(MATRIXCHECK ON)
-set(FASTMATHCOMPUTATIONS OFF)
-option(DUMPPATTERN "Dump test patterns when test is failing" ON)
-
-option(CUSTOMIZE_TESTS "Enable customizations of tests" ON)
-option(BASICMATH_TESTS "Enable Basic Math testing" ON)
-option(COMPLEXMATH_TESTS "Enable Complex Math testing" ON)
-option(CONTROLLER_TESTS "Enable Controller testing" ON)
-option(FASTMATH_TESTS "Enable Fast Math testing" ON)
-option(INTRINSICS_TESTS "Enable Intrinsics testing" ON)
-option(FILTERING_TESTS "Enable Filtering testing" ON)
-option(MATRIX_TESTS "Enable Matrix testing" ON)
-option(STATISTICS_TESTS "Enable Statistics testing" ON)
-option(SUPPORT_TESTS "Enable Support testing" ON)
-option(TRANSFORM_TESTS "Enable Transform testing" ON)
-
-# Change behavior of configBoot for scatter file
-set(TESTFRAMEWORK ON)
-
-
-project(DSP_Lib_TestSuite)
-
-# Needed to find the config modules
-list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/..)
-
-
-set(ROOT ${CMAKE_CURRENT_SOURCE_DIR}/../../..)
-
-add_executable(DSP_Lib_TestSuite)
-
-include(config)
-configApp(DSP_Lib_TestSuite ${ROOT})
-
-file(GLOB MAIN "Common/src/*.c")
-file(GLOB BASICMATH_TESTS_SRC "Common/src/basic_math_tests/*.c")
-file(GLOB COMPLEXMATH_TESTS_SRC "Common/src/complex_math_tests/*.c")
-file(GLOB CONTROLLER_TESTS_SRC "Common/src/controller_tests/*.c")
-file(GLOB FASTMATH_TESTS_SRC "Common/src/fast_math_tests/*.c")
-file(GLOB FILTERING_TESTS_SRC "Common/src/filtering_tests/*.c")
-file(GLOB INTRINSINCS_TESTS_SRC "Common/src/intrinsics_tests/*.c")
-file(GLOB MATRIX_TESTS_SRC "Common/src/matrix_tests/*.c")
-file(GLOB STATISTICS_TESTS_SRC "Common/src/statistics_tests/*.c")
-file(GLOB SUPPORT_TESTS_SRC "Common/src/support_tests/*.c")
-file(GLOB TRANSFORM_TESTS_SRC "Common/src/transform_tests/*.c")
-file(GLOB JTEST_MAIN "Common/JTest/src/*.c")
-
-set(TESTSRC ${MAIN}
-  ${BASICMATH_TESTS_SRC}
-  ${COMPLEXMATH_TESTS_SRC}
-  ${CONTROLLER_TESTS_SRC}
-  ${FASTMATH_TESTS_SRC}
-  ${FILTERING_TESTS_SRC}
-  ${INTRINSINCS_TESTS_SRC}
-  ${MATRIX_TESTS_SRC}
-  ${STATISTICS_TESTS_SRC}
-  ${SUPPORT_TESTS_SRC}
-  ${TRANSFORM_TESTS_SRC}
-  ${JTEST_MAIN}
-  )
-
-set(JINCS 
-  Common/JTest/inc
-  Common/JTest/inc/arr_desc
-  Common/inc/basic_math_tests
-  Common/inc/complex_math_tests
-  Common/inc/controller_tests
-  Common/inc/fast_math_tests
-  Common/inc/filtering_tests
-  Common/inc/intrinsics_tests
-  Common/inc/matrix_tests
-  Common/inc/statistics_tests 
-  Common/inc/support_tests 
-  Common/inc/transform_tests
-  )
-
-add_subdirectory(../Source bin_dsp)
-add_subdirectory(RefLibs bin_ref)
-
-
-
-
-if (CUSTOMIZE_TESTS)
-      target_compile_definitions(DSP_Lib_TestSuite PRIVATE CUSTOMIZE_TESTS)
-endif()
-
-if (BASICMATH_TESTS)
-      target_compile_definitions(DSP_Lib_TestSuite PRIVATE ENABLE_BASICMATH_TESTS)
-endif()
-if (COMPLEXMATH_TESTS)
-      target_compile_definitions(DSP_Lib_TestSuite PRIVATE ENABLE_COMPLEXMATH_TESTS)
-endif()
-if (CONTROLLER_TESTS)
-      target_compile_definitions(DSP_Lib_TestSuite PRIVATE ENABLE_CONTROLLER_TESTS)
-endif()
-if (FASTMATH_TESTS)
-      target_compile_definitions(DSP_Lib_TestSuite PRIVATE ENABLE_FASTMATH_TESTS)
-endif()
-if (FILTERING_TESTS)
-      target_compile_definitions(DSP_Lib_TestSuite PRIVATE ENABLE_FILTERING_TESTS)
-endif()
-if (INTRINSICS_TESTS)
-      target_compile_definitions(DSP_Lib_TestSuite PRIVATE ENABLE_INTRINSICS_TESTS)
-endif()
-if (MATRIX_TESTS)
-      target_compile_definitions(DSP_Lib_TestSuite PRIVATE ENABLE_MATRIX_TESTS)
-endif()
-if (STATISTICS_TESTS)
-      target_compile_definitions(DSP_Lib_TestSuite PRIVATE ENABLE_STATISTICS_TESTS)
-endif()
-if (SUPPORT_TESTS)
-      target_compile_definitions(DSP_Lib_TestSuite PRIVATE ENABLE_SUPPORT_TESTS)
-endif()
-if (TRANSFORM_TESTS)
-      target_compile_definitions(DSP_Lib_TestSuite PRIVATE ENABLE_TRANSFORM_TESTS)
-endif()
-
-
-if (DUMPPATTERN)
-      target_compile_definitions(DSP_Lib_TestSuite PRIVATE DUMPPATTERN)
-endif()
-
-
-
-
-file(COPY ${ROOT}/CMSIS/DSP/Examples/ARM/boot/RTE_Components.h DESTINATION tempLink)
-
-target_link_libraries(DSP_Lib_TestSuite PRIVATE CMSISDSP)
-target_link_libraries(DSP_Lib_TestSuite PRIVATE DspRefLibs)
-
-target_sources(DSP_Lib_TestSuite PRIVATE ${TESTSRC})
-
-### Includes
-target_include_directories(DSP_Lib_TestSuite PRIVATE "Common/inc")
-target_include_directories(DSP_Lib_TestSuite PRIVATE "Common/inc/templates")
-target_include_directories(DSP_Lib_TestSuite PRIVATE ${JINCS})
-
-

CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/FVP.ini

@@ -1,13 +0,0 @@
-/* This demonstrates how to setup a Debugger '*.ini' file to interface with the
- * C-code using the JTEST test framework.
- */
-
-//_WDWORD(0x4001F000, 0x00000001);                    /* Remap on */
-
-LOAD %L INCREMENTAL
-
-
-RESET                                               /* Reset the target processor */
-LOG OFF                                             /* Turn off Logging by default. */
-//BK *                                                /* Remove existing breakpoints. */
-

CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/MPS2.ini

@@ -1,13 +0,0 @@
-/* This demonstrates how to setup a Debugger '*.ini' file to interface with the
- * C-code using the JTEST test framework.
- */
-
-//_WDWORD(0x4001F000, 0x00000001);                    /* Remap on */
-
-LOAD %L INCREMENTAL
-
-
-RESET                                               /* Reset the target processor */
-LOG OFF                                             /* Turn off Logging by default. */
-//BK *                                                /* Remove existing breakpoints. */
-

CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/README.org

@@ -1,8 +0,0 @@
-#+Title: JTEST Test Framework
-#+Author: Joseph Jaoudi
-
-* Overview
-  JTEST is a test framework Microcontrollers.  Specifically for
-  Microcontrollers that interface with the Keil Debugging environment.
-
-

CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/Simulator.ini

@@ -1,14 +0,0 @@
-/* This demonstrates how to setup a Debugger '*.ini' file to interface with the
- * C-code using the JTEST test framework.
- */
-
-MAP  0x00000000, 0x001FFFFF  EXEC READ              /* 2048K Flash */
-MAP  0x20000000, 0x201FFFFF  READ WRITE             /* 2048K RAM   */
-
-LOAD %L INCREMENTAL
-
-
-RESET                                               /* Reset the target processor */
-LOG OFF                                             /* Turn off Logging by default. */
-//BK *                                                /* Remove existing breakpoints. */
-

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

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

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

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

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

@@ -1,79 +0,0 @@
-#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)
-*/
-#ifndef ARMv7A
-
-#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)
-
-#else
-/* TODO */
-#define JTEST_COUNT_CYCLES(fn_call)                     \
-    do                                                  \
-    {                                                   \
-		fn_call;   										\
-    } while (0)
-
-#endif
-
-#endif /* _JTEST_CYCLE_H_ */
-
-

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

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

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

@@ -1,282 +0,0 @@
-#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.
- */
-#if defined(ARMv7A) || defined(FILEIO)
-
-#define JTEST_ACT_DUMP(action, buf_name, value) \
-    do                                          \
-    {                                           \
-        JTEST_CLEAR_BUFFER(buf_name);           \
-	    printf("%s",value);                     \
-        strcpy(JTEST_FW.buf_name, (value));     \
-        JTEST_TRIGGER_ACTION(action);           \
-    } while (0)
-
-#else
-
-#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)
-
-#endif
-/**
- *  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.
- */
-#if defined(ARMv7A) || defined(FILEIO)
-
-#define JTEST_DUMP_STRF(format_str, ... )                               \
-    do                                                                  \
-    {                                                                   \
-        JTEST_CLEAR_STR_BUFFER();                                       \
-        sprintf(JTEST_FW.str_buffer,format_str, __VA_ARGS__);           \
-        printf("%s",JTEST_FW.str_buffer);                               \
-        jtest_dump_str_segments();                                      \
-    } while (0)
-
-#else
-
-#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)
-
-#endif
-
-/* 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_ */

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

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

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

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

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

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

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

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

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

@@ -1,94 +0,0 @@
-#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 ARMCM0P_MPU
-  #include "ARMCM0plus_MPU.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"
-#elif defined ARMv7A
-  /* TODO */
-#else
-  #warning "no appropriate header file found!"
-#endif
-
-/*--------------------------------------------------------------------------------*/
-/* Macros and Defines                                                             */
-/*--------------------------------------------------------------------------------*/
-
-/**
- *  Initial value for the SysTick module.
- *
- *  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)->CTRL = SysTick_CTRL_CLKSOURCE_Msk;   \
-                                                            \
-        (systick_ptr)->LOAD = JTEST_SYSTICK_INITIAL_VALUE;  \
-        (systick_ptr)->VAL  = JTEST_SYSTICK_INITIAL_VALUE;  \
-    } 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;                     \
-    } while (0)
-
-/**
- *  Evaluate to the current value of the SysTick timer.
- */
-#define JTEST_SYSTICK_VALUE(systick_ptr)                    \
-    ((systick_ptr)->VAL)
-           
-#endif /* _JTEST_SYSTICK_H_ */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/jtest_FVP.ini

@@ -1,31 +0,0 @@
-/* This demonstrates how to setup a Debugger '*.ini' file to interface with the
- * C-code using the JTEST test framework.
- */
-
-//_WDWORD(0x4001F000, 0x00000001);                    /* Remap on */
-
-LOAD %L INCREMENTAL
-
-
-RESET                                               /* Reset the target processor */
-LOG OFF                                             /* Turn off Logging by default. */
-BK *                                                /* Remove existing breakpoints. */
-
-INCLUDE ../../Common/JTest/jtest_fns.ini            /* Load the JTEST helper functions */
-INCLUDE ../../Common/JTest/jtest_log_FVP.ini        /* Include specified log file */
-
-/* Break on special members of the JTEST framework.  The framework's
-   name is defined in jtest_fw.h by the #DEFINE JTEST_FW. */
-BS test_start  , 1, "test_start_msg();"
-BS test_end    , 1, "test_end_msg();"
-BS group_start , 1, "group_start_msg();"
-BS group_end   , 1, "group_end_msg();"
-BS dump_str    , 1, "dump_str_fn();"
-//BS dump_data   , 1, "dump_data_fn();"
-BS exit_fw     , 1, "break_fn(); debug_clean_fn(); log_off_fn();"
-
-debug_setup_finished_msg()      /* Output a message to let the output
-                                   parser know that setup has
-                                   finished. */
-
-G                                                   /* Start the Tests */

CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/jtest_MPS2.ini

@@ -1,31 +0,0 @@
-/* This demonstrates how to setup a Debugger '*.ini' file to interface with the
- * C-code using the JTEST test framework.
- */
-
-//_WDWORD(0x4001F000, 0x00000001);                    /* Remap on */
-
-LOAD %L INCREMENTAL
-
-
-RESET                                               /* Reset the target processor */
-LOG OFF                                             /* Turn off Logging by default. */
-BK *                                                /* Remove existing breakpoints. */
-
-INCLUDE ../../Common/JTest/jtest_fns.ini            /* Load the JTEST helper functions */
-INCLUDE ../../Common/JTest/jtest_log_MPS2.ini       /* Include a log file if specified by jtest_log.ini */
-
-/* Break on special members of the JTEST framework.  The framework's
-   name is defined in jtest_fw.h by the #DEFINE JTEST_FW. */
-BS test_start  , 1, "test_start_msg();"
-BS test_end    , 1, "test_end_msg();"
-BS group_start , 1, "group_start_msg();"
-BS group_end   , 1, "group_end_msg();"
-BS dump_str    , 1, "dump_str_fn();"
-//BS dump_data   , 1, "dump_data_fn();"
-BS exit_fw     , 1, "break_fn(); debug_clean_fn(); log_off_fn();"
-
-debug_setup_finished_msg()      /* Output a message to let the output
-                                   parser know that setup has
-                                   finished. */
-
-G                                                   /* Start the Tests */

CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/jtest_Simulator.ini

@@ -1,32 +0,0 @@
-/* This demonstrates how to setup a Debugger '*.ini' file to interface with the
- * C-code using the JTEST test framework.
- */
-
-MAP  0x00000000, 0x001FFFFF  EXEC READ              /* 2048K Flash */
-MAP  0x20000000, 0x201FFFFF  READ WRITE             /* 2048K RAM   */
-
-LOAD %L INCREMENTAL
-
-
-RESET                                               /* Reset the target processor */
-LOG OFF                                             /* Turn off Logging by default. */
-BK *                                                /* Remove existing breakpoints. */
-
-INCLUDE ../../Common/JTest/jtest_fns.ini            /* Load the JTEST helper functions */
-INCLUDE ../../Common/JTest/jtest_log_Simulator.ini  /* Include specified log file */
-
-/* Break on special members of the JTEST framework.  The framework's
-   name is defined in jtest_fw.h by the #DEFINE JTEST_FW. */
-BS test_start  , 1, "test_start_msg();"
-BS test_end    , 1, "test_end_msg();"
-BS group_start , 1, "group_start_msg();"
-BS group_end   , 1, "group_end_msg();"
-BS dump_str    , 1, "dump_str_fn();"
-//BS dump_data   , 1, "dump_data_fn();"
-BS exit_fw     , 1, "break_fn(); debug_clean_fn(); log_off_fn();"
-
-debug_setup_finished_msg()      /* Output a message to let the output
-                                   parser know that setup has
-                                   finished. */
-
-G                                                   /* Start the Tests */

CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/jtest_Simulator.ini.withCoverage

@@ -1,32 +0,0 @@
-/* This demonstrates how to setup a Debugger '*.ini' file to interface with the
- * C-code using the JTEST test framework.
- */
-
-MAP  0x00000000, 0x001FFFFF  EXEC READ              /* 2048K Flash */
-MAP  0x20000000, 0x201FFFFF  READ WRITE             /* 2048K RAM   */
-
-LOAD %L INCREMENTAL
-
-
-RESET                                               /* Reset the target processor */
-LOG OFF                                             /* Turn off Logging by default. */
-BK *                                                /* Remove existing breakpoints. */
-
-INCLUDE ../../Common/JTest/jtest_fns.ini            /* Load the JTEST helper functions */
-INCLUDE ../../Common/JTest/jtest_log_Simulator.ini  /* Include specified log file */
-
-/* Break on special members of the JTEST framework.  The framework's
-   name is defined in jtest_fw.h by the #DEFINE JTEST_FW. */
-BS test_start  , 1, "coverage_clear(); test_start_msg();"
-BS test_end    , 1, "coverage_msg(); test_end_msg();"
-BS group_start , 1, "group_start_msg();"
-BS group_end   , 1, "group_end_msg();"
-BS dump_str    , 1, "dump_str_fn();"
-BS dump_data   , 1, "dump_data_fn();"
-BS exit_fw     , 1, "break_fn(); debug_clean_fn(); log_off_fn();"
-
-debug_setup_finished_msg()      /* Output a message to let the output
-                                   parser know that setup has
-                                   finished. */
-
-G                                                   /* Start the Tests */

CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/jtest_fns.ini

@@ -1,107 +0,0 @@
-
-FUNC void ban_line_thick (void)
-{
-    printf("==================================================\n");
-}
-
-FUNC void ban_line_thin (void)
-{
-    printf("--------------------------------------------------\n");
-}
-
-FUNC void test_start_msg (void)
-{
-    ban_line_thick();
-    printf("Start: Test\n");
-    ban_line_thick();
-}
-
-FUNC void test_end_msg (void)
-{
-    ban_line_thick();
-    printf("End: Test\n");
-    ban_line_thick();
-}
-
-
-FUNC void group_start_msg (void)
-{
-    ban_line_thick();
-    printf("Start: Group\n");
-    ban_line_thick();
-}
-
-FUNC void group_end_msg (void)
-{
-    ban_line_thick();
-    printf("End: Group\n");
-    ban_line_thick();
-}
-
-
-FUNC void coverage_clear (void)
-{
-    exec("COVERAGE CLEAR");
-}
-
-FUNC void coverage_msg(void)
-{
-    ban_line_thin();
-    printf("Start: Coverage Information\n");
-    ban_line_thin();
-    exec("COVERAGE");
-    ban_line_thin();
-    printf("End: Coverage Information\n");
-    ban_line_thin();
-}
-
-FUNC void break_fn (void)
-{
-    _sleep_(5000);
-    exec("_break_ = 1");
-}
-
-FUNC void exit_fn (void)
-{
-    exec("EXIT");
-}
-
-FUNC void debug_clean_fn (void)
-{
-    exec("BK *");
-    exit_fn();
-}
-
-FUNC void debug_setup_finished_msg (void)
-{
-    ban_line_thick();
-    printf("Debug Setup Finished\n");
-    ban_line_thick();
-}
-
-FUNC void dump_str_fn (void)
-{
-    ban_line_thin();
-    printf("Start Dump: String\n");
-    ban_line_thin();
-    exec("D JTEST_FW.str_buffer");
-    ban_line_thin();
-    printf("End Dump: String\n");
-    ban_line_thin();
-}
-
-FUNC void dump_data_fn (void)
-{
-    ban_line_thin();
-    printf("Start Dump: Data\n");
-    ban_line_thin();
-    exec("D JTEST_FW.data_buffer");
-    ban_line_thin();
-    printf("End Dump: Data\n");
-    ban_line_thin();
-}
-
-FUNC void log_off_fn(void)
-{
-    exec("LOG OFF") ;
-}

CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/jtest_log_FVP.ini

@@ -1 +0,0 @@
-LOG > Logs/DspLibTest_FVP.log

CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/jtest_log_MPS2.ini

@@ -1 +0,0 @@
-LOG > Logs/DspLibTest_MPS2.log

CMSIS/DSP/DSP_Lib_TestSuite/Common/JTest/jtest_log_Simulator.ini

@@ -1 +0,0 @@
-LOG > Logs/DspLibTest_Simulator.log

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

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

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

@@ -1,36 +0,0 @@
-#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;
-}

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

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

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

@@ -1,37 +0,0 @@
-
-#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++;
-}

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

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

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

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

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

@@ -1,46 +0,0 @@
-#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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,81 +0,0 @@
-#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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,52 +0,0 @@
-/* ----------------------------------------------------------------------
-* 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,31 +0,0 @@
-#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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,52 +0,0 @@
-/*----------------------------------------------------------------------------
- * 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 */
-}

CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/ARMCC/armcc5_arm.sct

@@ -1,70 +0,0 @@
-#! armcc -E
-; command above MUST be in first line (no comment above!)
-
-/*
-;-------- <<< Use Configuration Wizard in Context Menu >>> ------------------
-*/
-
-/*--------------------- Flash Configuration -------------------------
-; <h> Flash Configuration
-;   <o0> Flash Base Address <0x0-0xFFFFFFFF:8>
-;   <o1> Flash Size (in Bytes) <0x0-0xFFFFFFFF:8>
-; </h>
- *----------------------------------------------------------------------------*/
-#define __ROM_BASE     0x00000000
-#define __ROM_SIZE     0x00200000
-
-/*--------------------- Embedded RAM Configuration ---------------------------
-; <h> RAM Configuration
-;   <o0> RAM Base Address    <0x0-0xFFFFFFFF:8>
-;   <o1> RAM Size (in Bytes) <0x0-0xFFFFFFFF:8>
-; </h>
- *----------------------------------------------------------------------------*/
-#define __RAM_BASE     0x20000000
-#define __RAM_SIZE     0x00200000
-
-/*--------------------- Stack / Heap Configuration ---------------------------
-; <h> Stack / Heap Configuration
-;   <o0> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
-;   <o1> Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
-; </h>
- *----------------------------------------------------------------------------*/
-#define __STACK_SIZE       0x00000400
-#define __HEAP_SIZE        0x00000C00
-
-
-/*----------------------------------------------------------------------------
-  User Stack & Heap boundery definition
- *----------------------------------------------------------------------------*/
-#define __STACK_TOP        (__RAM_BASE + __RAM_SIZE)
-#define __HEAP_BASE        (__RAM_BASE + __RAM_SIZE - __STACK_SIZE - __HEAP_SIZE)
-
-
-/*----------------------------------------------------------------------------
-  Scatter File Definitions definition
- *----------------------------------------------------------------------------*/
-#define __RO_BASE         __ROM_BASE
-#define __RO_SIZE         __ROM_SIZE
-
-#define __RW_BASE        (__RAM_BASE        )
-#define __RW_SIZE        (__RAM_SIZE - __STACK_SIZE - __HEAP_SIZE)
-
-
-
-LR_ROM __RO_BASE __RO_SIZE  {                       ; load region size_region
-  ER_ROM __RO_BASE __RO_SIZE  {                     ; load address = execution address
-   *.o (RESET, +First)
-   *(InRoot$$Sections)
-   .ANY (+RO)
-  }
-  
-  RW_RAM __RW_BASE __RW_SIZE  {                     ; RW data
-   .ANY (+RW +ZI)
-  }
-
-  ARM_LIB_HEAP  __HEAP_BASE EMPTY  __HEAP_SIZE  { ; Reserve empty region for heap
-  }
-
-  ARM_LIB_STACK __STACK_TOP EMPTY -__STACK_SIZE { ; Reserve empty region for stack 
-  }
-}

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

@@ -1,111 +0,0 @@
-;/* 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.
-;   ---------------------------------------------------------------------------*/
-
-                PRESERVE8
-                THUMB
-
-
-; Vector Table Mapped to Address 0 at Reset
-
-                AREA    RESET, DATA, READONLY
-                IMPORT  ||Image$$ARM_LIB_STACK$$ZI$$Limit||
-                EXPORT  __Vectors
-                EXPORT  __Vectors_End
-                EXPORT  __Vectors_Size
-
-__Vectors       DCD     ||Image$$ARM_LIB_STACK$$ZI$$Limit||              ; 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
-
-                END

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

@@ -1,195 +0,0 @@
-;/* 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

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

@@ -1,134 +0,0 @@
-;/* 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.
-;   ---------------------------------------------------------------------------*/
-
-                PRESERVE8
-                THUMB
-
-
-; Vector Table Mapped to Address 0 at Reset
-
-                AREA    RESET, DATA, READONLY
-                IMPORT  ||Image$$ARM_LIB_STACK$$ZI$$Limit||
-                EXPORT  __Vectors
-                EXPORT  __Vectors_End
-                EXPORT  __Vectors_Size
-
-__Vectors       DCD     ||Image$$ARM_LIB_STACK$$ZI$$Limit||              ; 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
-
-                END

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

@@ -1,218 +0,0 @@
-;/* 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

CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/ARMCLANG/armcc6_arm.sct

@@ -1,70 +0,0 @@
-#! armclang -E --target=arm-arm-none-eabi -mcpu=cortex-m0 -xc
-; command above MUST be in first line (no comment above!)
-
-/*
-;-------- <<< Use Configuration Wizard in Context Menu >>> ------------------
-*/
-
-/*--------------------- Flash Configuration -------------------------
-; <h> Flash Configuration
-;   <o0> Flash Base Address <0x0-0xFFFFFFFF:8>
-;   <o1> Flash Size (in Bytes) <0x0-0xFFFFFFFF:8>
-; </h>
- *----------------------------------------------------------------------------*/
-#define __ROM_BASE     0x00000000
-#define __ROM_SIZE     0x00200000
-
-/*--------------------- Embedded RAM Configuration ---------------------------
-; <h> RAM Configuration
-;   <o0> RAM Base Address    <0x0-0xFFFFFFFF:8>
-;   <o1> RAM Size (in Bytes) <0x0-0xFFFFFFFF:8>
-; </h>
- *----------------------------------------------------------------------------*/
-#define __RAM_BASE     0x20000000
-#define __RAM_SIZE     0x00200000
-
-/*--------------------- Stack / Heap Configuration ---------------------------
-; <h> Stack / Heap Configuration
-;   <o0> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
-;   <o1> Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
-; </h>
- *----------------------------------------------------------------------------*/
-#define __STACK_SIZE       0x00000400
-#define __HEAP_SIZE        0x00000C00
-
-
-/*----------------------------------------------------------------------------
-  User Stack & Heap boundery definition
- *----------------------------------------------------------------------------*/
-#define __STACK_TOP        (__RAM_BASE + __RAM_SIZE)
-#define __HEAP_BASE        (__RAM_BASE + __RAM_SIZE - __STACK_SIZE - __HEAP_SIZE)
-
-
-/*----------------------------------------------------------------------------
-  Scatter File Definitions definition
- *----------------------------------------------------------------------------*/
-#define __RO_BASE         __ROM_BASE
-#define __RO_SIZE         __ROM_SIZE
-
-#define __RW_BASE        (__RAM_BASE        )
-#define __RW_SIZE        (__RAM_SIZE - __STACK_SIZE - __HEAP_SIZE)
-
-
-
-LR_ROM __RO_BASE __RO_SIZE  {                       ; load region size_region
-  ER_ROM __RO_BASE __RO_SIZE  {                     ; load address = execution address
-   *.o (RESET, +First)
-   *(InRoot$$Sections)
-   .ANY (+RO)
-  }
-  
-  RW_RAM __RW_BASE __RW_SIZE  {                     ; RW data
-   .ANY (+RW +ZI)
-  }
-
-  ARM_LIB_HEAP  __HEAP_BASE EMPTY  __HEAP_SIZE  { ; Reserve empty region for heap
-  }
-
-  ARM_LIB_STACK __STACK_TOP EMPTY -__STACK_SIZE { ; Reserve empty region for stack 
-  }
-}

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

@@ -1,127 +0,0 @@
-/* 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 */
-
-    .global    Image$$ARM_LIB_STACK$$ZI$$Limit
-
-
-    .section RESET, "x"
-    .align  2
-    .globl  __Vectors
-    .globl  __Vectors_End
-    .globl  __Vectors_Size
-__Vectors:
-    .long   Image$$ARM_LIB_STACK$$ZI$$Limit            /* 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       .
-
-    .end

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

@@ -1,203 +0,0 @@
-/* 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

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

@@ -1,159 +0,0 @@
-/* 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   armv7-m
-
-/* .eabi_attribute Tag_ABI_align8_preserved,1    www.support.code-red-tech.com/CodeRedWiki/Preserve8 */
-.eabi_attribute 25, 1   /* Tag_ABI_align_preserved */
-
-    .global    Image$$ARM_LIB_STACK$$ZI$$Limit
-
-
-    .section RESET, "x"
-    .align  2
-    .globl  __Vectors
-    .globl  __Vectors_End
-    .globl  __Vectors_Size
-__Vectors:
-    .long   Image$$ARM_LIB_STACK$$ZI$$Limit            /* 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       .
-
-    .end

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

@@ -1,235 +0,0 @@
-/* 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

CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/GCC/ARMCMx.ld

@@ -1,195 +0,0 @@
-/* Linker script to configure memory regions. */
-MEMORY
-{
-  FLASH (rx)  : ORIGIN = 0x00000000, LENGTH = 2048K
-  RAM   (rwx) : ORIGIN = 0x20000000, LENGTH = 2048K
-}
-
-/* Library configurations */
-GROUP(libgcc.a libc.a libm.a libnosys.a)
-
-/* Linker script to place sections and symbol values. Should be used together
- * with other linker script that defines memory regions FLASH and RAM.
- * It references following symbols, which must be defined in code:
- *   Reset_Handler : Entry of reset handler
- *
- * It defines following symbols, which code can use without definition:
- *   __exidx_start
- *   __exidx_end
- *   __copy_table_start__
- *   __copy_table_end__
- *   __zero_table_start__
- *   __zero_table_end__
- *   __etext
- *   __data_start__
- *   __preinit_array_start
- *   __preinit_array_end
- *   __init_array_start
- *   __init_array_end
- *   __fini_array_start
- *   __fini_array_end
- *   __data_end__
- *   __bss_start__
- *   __bss_end__
- *   __end__
- *   end
- *   __HeapLimit
- *   __StackLimit
- *   __StackTop
- *   __stack
- *   __Vectors_End
- *   __Vectors_Size
- */
-ENTRY(Reset_Handler)
-
-SECTIONS
-{
-	.text :
-	{
-		KEEP(*(.vectors))
-		__Vectors_End = .;
-		__Vectors_Size = __Vectors_End - __Vectors;
-		__end__ = .;
-
-		*(.text*)
-
-		KEEP(*(.init))
-		KEEP(*(.fini))
-
-		/* .ctors */
-		*crtbegin.o(.ctors)
-		*crtbegin?.o(.ctors)
-		*(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors)
-		*(SORT(.ctors.*))
-		*(.ctors)
-
-		/* .dtors */
- 		*crtbegin.o(.dtors)
- 		*crtbegin?.o(.dtors)
- 		*(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors)
- 		*(SORT(.dtors.*))
- 		*(.dtors)
-
-		*(.rodata*)
-
-		KEEP(*(.eh_frame*))
-	} > FLASH
-
-	.ARM.extab :
-	{
-		*(.ARM.extab* .gnu.linkonce.armextab.*)
-	} > FLASH
-
-	__exidx_start = .;
-	.ARM.exidx :
-	{
-		*(.ARM.exidx* .gnu.linkonce.armexidx.*)
-	} > FLASH
-	__exidx_end = .;
-
-	/* To copy multiple ROM to RAM sections,
-	 * uncomment .copy.table section and,
-	 * define __STARTUP_COPY_MULTIPLE in startup_ARMCMx.S */
-	/*
-	.copy.table :
-	{
-		. = ALIGN(4);
-		__copy_table_start__ = .;
-		LONG (__etext)
-		LONG (__data_start__)
-		LONG (__data_end__ - __data_start__)
-		LONG (__etext2)
-		LONG (__data2_start__)
-		LONG (__data2_end__ - __data2_start__)
-		__copy_table_end__ = .;
-	} > FLASH
-	*/
-
-	/* To clear multiple BSS sections,
-	 * uncomment .zero.table section and,
-	 * define __STARTUP_CLEAR_BSS_MULTIPLE in startup_ARMCMx.S */
-	/*
-	.zero.table :
-	{
-		. = ALIGN(4);
-		__zero_table_start__ = .;
-		LONG (__bss_start__)
-		LONG (__bss_end__ - __bss_start__)
-		LONG (__bss2_start__)
-		LONG (__bss2_end__ - __bss2_start__)
-		__zero_table_end__ = .;
-	} > FLASH
-	*/
-
-	__etext = .;
-
-	.data : AT (__etext)
-	{
-		__data_start__ = .;
-		*(vtable)
-		*(.data*)
-
-		. = ALIGN(4);
-		/* preinit data */
-		PROVIDE_HIDDEN (__preinit_array_start = .);
-		KEEP(*(.preinit_array))
-		PROVIDE_HIDDEN (__preinit_array_end = .);
-
-		. = ALIGN(4);
-		/* init data */
-		PROVIDE_HIDDEN (__init_array_start = .);
-		KEEP(*(SORT(.init_array.*)))
-		KEEP(*(.init_array))
-		PROVIDE_HIDDEN (__init_array_end = .);
-
-
-		. = ALIGN(4);
-		/* finit data */
-		PROVIDE_HIDDEN (__fini_array_start = .);
-		KEEP(*(SORT(.fini_array.*)))
-		KEEP(*(.fini_array))
-		PROVIDE_HIDDEN (__fini_array_end = .);
-
-		KEEP(*(.jcr*))
-		. = ALIGN(4);
-		/* All data end */
-		__data_end__ = .;
-
-	} > RAM
-
-	.bss :
-	{
-		. = ALIGN(4);
-		__bss_start__ = .;
-		*(.bss*)
-		*(COMMON)
-		. = ALIGN(4);
-		__bss_end__ = .;
-	} > RAM
-
-	.heap (COPY):
-	{
-		__HeapBase = .;
-		__end__ = .;
-		end = __end__;
-		KEEP(*(.heap*))
-		__HeapLimit = .;
-	} > RAM
-
-	/* .stack_dummy section doesn't contains any symbols. It is only
-	 * used for linker to calculate size of stack sections, and assign
-	 * values to stack symbols later */
-	.stack_dummy (COPY):
-	{
-		KEEP(*(.stack*))
-	} > RAM
-
-	/* Set stack top to end of RAM, and stack limit move down by
-	 * size of stack_dummy section */
-	__StackTop = ORIGIN(RAM) + LENGTH(RAM);
-	__StackLimit = __StackTop - SIZEOF(.stack_dummy);
-	PROVIDE(__stack = __StackTop);
-
-	/* Check if data + heap + stack exceeds RAM limit */
-	ASSERT(__StackLimit >= __HeapLimit, "region RAM overflowed with stack")
-}

CMSIS/DSP/DSP_Lib_TestSuite/Common/platform/GCC/ARMCMx_IoT.ld

@@ -1,195 +0,0 @@
-/* Linker script to configure memory regions. */
-MEMORY
-{
-  FLASH (rx)  : ORIGIN = 0x10000000, LENGTH = 2048K
-  RAM   (rwx) : ORIGIN = 0x38000000, LENGTH = 2048K
-}
-
-/* Library configurations */
-GROUP(libgcc.a libc.a libm.a libnosys.a)
-
-/* Linker script to place sections and symbol values. Should be used together
- * with other linker script that defines memory regions FLASH and RAM.
- * It references following symbols, which must be defined in code:
- *   Reset_Handler : Entry of reset handler
- *
- * It defines following symbols, which code can use without definition:
- *   __exidx_start
- *   __exidx_end
- *   __copy_table_start__
- *   __copy_table_end__
- *   __zero_table_start__
- *   __zero_table_end__
- *   __etext
- *   __data_start__
- *   __preinit_array_start
- *   __preinit_array_end
- *   __init_array_start
- *   __init_array_end
- *   __fini_array_start
- *   __fini_array_end
- *   __data_end__
- *   __bss_start__
- *   __bss_end__
- *   __end__
- *   end
- *   __HeapLimit
- *   __StackLimit
- *   __StackTop
- *   __stack
- *   __Vectors_End
- *   __Vectors_Size
- */
-ENTRY(Reset_Handler)
-
-SECTIONS
-{
-	.text :
-	{
-		KEEP(*(.vectors))
-		__Vectors_End = .;
-		__Vectors_Size = __Vectors_End - __Vectors;
-		__end__ = .;
-
-		*(.text*)
-
-		KEEP(*(.init))
-		KEEP(*(.fini))
-
-		/* .ctors */
-		*crtbegin.o(.ctors)
-		*crtbegin?.o(.ctors)
-		*(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors)
-		*(SORT(.ctors.*))
-		*(.ctors)
-
-		/* .dtors */
- 		*crtbegin.o(.dtors)
- 		*crtbegin?.o(.dtors)
- 		*(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors)
- 		*(SORT(.dtors.*))
- 		*(.dtors)
-
-		*(.rodata*)
-
-		KEEP(*(.eh_frame*))
-	} > FLASH
-
-	.ARM.extab :
-	{
-		*(.ARM.extab* .gnu.linkonce.armextab.*)
-	} > FLASH
-
-	__exidx_start = .;
-	.ARM.exidx :
-	{
-		*(.ARM.exidx* .gnu.linkonce.armexidx.*)
-	} > FLASH
-	__exidx_end = .;
-
-	/* To copy multiple ROM to RAM sections,
-	 * uncomment .copy.table section and,
-	 * define __STARTUP_COPY_MULTIPLE in startup_ARMCMx.S */
-	/*
-	.copy.table :
-	{
-		. = ALIGN(4);
-		__copy_table_start__ = .;
-		LONG (__etext)
-		LONG (__data_start__)
-		LONG (__data_end__ - __data_start__)
-		LONG (__etext2)
-		LONG (__data2_start__)
-		LONG (__data2_end__ - __data2_start__)
-		__copy_table_end__ = .;
-	} > FLASH
-	*/
-
-	/* To clear multiple BSS sections,
-	 * uncomment .zero.table section and,
-	 * define __STARTUP_CLEAR_BSS_MULTIPLE in startup_ARMCMx.S */
-	/*
-	.zero.table :
-	{
-		. = ALIGN(4);
-		__zero_table_start__ = .;
-		LONG (__bss_start__)
-		LONG (__bss_end__ - __bss_start__)
-		LONG (__bss2_start__)
-		LONG (__bss2_end__ - __bss2_start__)
-		__zero_table_end__ = .;
-	} > FLASH
-	*/
-
-	__etext = .;
-
-	.data : AT (__etext)
-	{
-		__data_start__ = .;
-		*(vtable)
-		*(.data*)
-
-		. = ALIGN(4);
-		/* preinit data */
-		PROVIDE_HIDDEN (__preinit_array_start = .);
-		KEEP(*(.preinit_array))
-		PROVIDE_HIDDEN (__preinit_array_end = .);
-
-		. = ALIGN(4);
-		/* init data */
-		PROVIDE_HIDDEN (__init_array_start = .);
-		KEEP(*(SORT(.init_array.*)))
-		KEEP(*(.init_array))
-		PROVIDE_HIDDEN (__init_array_end = .);
-
-
-		. = ALIGN(4);
-		/* finit data */
-		PROVIDE_HIDDEN (__fini_array_start = .);
-		KEEP(*(SORT(.fini_array.*)))
-		KEEP(*(.fini_array))
-		PROVIDE_HIDDEN (__fini_array_end = .);
-
-		KEEP(*(.jcr*))
-		. = ALIGN(4);
-		/* All data end */
-		__data_end__ = .;
-
-	} > RAM
-
-	.bss :
-	{
-		. = ALIGN(4);
-		__bss_start__ = .;
-		*(.bss*)
-		*(COMMON)
-		. = ALIGN(4);
-		__bss_end__ = .;
-	} > RAM
-
-	.heap (COPY):
-	{
-		__HeapBase = .;
-		__end__ = .;
-		end = __end__;
-		KEEP(*(.heap*))
-		__HeapLimit = .;
-	} > RAM
-
-	/* .stack_dummy section doesn't contains any symbols. It is only
-	 * used for linker to calculate size of stack sections, and assign
-	 * values to stack symbols later */
-	.stack_dummy (COPY):
-	{
-		KEEP(*(.stack*))
-	} > RAM
-
-	/* Set stack top to end of RAM, and stack limit move down by
-	 * size of stack_dummy section */
-	__StackTop = ORIGIN(RAM) + LENGTH(RAM);
-	__StackLimit = __StackTop - SIZEOF(.stack_dummy);
-	PROVIDE(__stack = __StackTop);
-
-	/* Check if data + heap + stack exceeds RAM limit */
-	ASSERT(__StackLimit >= __HeapLimit, "region RAM overflowed with stack")
-}

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

@@ -1,106 +0,0 @@
-/*----------------------------------------------------------------------------
- * 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;
-}

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

@@ -1,263 +0,0 @@
-/* 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

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

@@ -1,257 +0,0 @@
-/* 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

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

@@ -1,68 +0,0 @@
-
-#if defined (__CC_ARM)
-  #if   (defined (ARMCM0))
-    #include "ARMCC\startup_armv6-m.s"
-  #elif (defined (ARMCM0P) || defined (ARMCM0P_MPU))
-    #include "ARMCC\startup_armv6-m.s"
-  #elif (defined (ARMCM3))
-    #include "ARMCC\startup_armv7-m.s"
-  #elif (defined (ARMCM4) || defined (ARMCM4_FP))
-    #include "ARMCC\startup_armv7-m.s"
-  #elif (defined (ARMCM7) || defined (ARMCM7_SP) || defined (ARMCM7_DP))
-    #include "ARMCC\startup_armv7-m.s"
-  #elif (defined (ARMv8MBL))
-    #include "ARMCC\startup_armv6-m.s"
-  #elif (defined (ARMv8MML)    || defined (ARMv8MML_DSP)    || \
-         defined (ARMv8MML_SP) || defined (ARMv8MML_DSP_SP) || \
-         defined (ARMv8MML_DP) || defined (ARMv8MML_DSP_DP)   )
-    #include "ARMCC\startup_armv7-m.s"
-  #else
-    #error "No appropriate startup file found!"
-  #endif
-
-#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
-  #if   (defined (ARMCM0))
-    #include "ARMCLANG\startup_armv6-m.S"
-  #elif (defined (ARMCM0P) || defined (ARMCM0P_MPU))
-    #include "ARMCLANG\startup_armv6-m.S"
-  #elif (defined (ARMCM3))
-    #include "ARMCLANG\startup_armv7-m.S"
-  #elif (defined (ARMCM4) || defined (ARMCM4_FP))
-    #include "ARMCLANG\startup_armv7-m.S"
-  #elif (defined (ARMCM7) || defined (ARMCM7_SP) || defined (ARMCM7_DP))
-    #include "ARMCLANG\startup_armv7-m.S"
-  #elif (defined (ARMv8MBL))
-    #include "ARMCLANG\startup_armv6-m.S"
-  #elif (defined (ARMv8MML)    || defined (ARMv8MML_DSP)    || \
-         defined (ARMv8MML_SP) || defined (ARMv8MML_DSP_SP) || \
-         defined (ARMv8MML_DP) || defined (ARMv8MML_DSP_DP)   )
-    #include "ARMCLANG\startup_armv7-m.S"
-  #else
-    #error "No appropriate startup file found!"
-  #endif
-
-#elif defined (__GNUC__)
-  #if   (defined (ARMCM0))
-    #include "GCC\startup_armv6-m.S"
-  #elif (defined (ARMCM0P) || defined (ARMCM0P_MPU))
-    #include "GCC\startup_armv6-m.S"
-  #elif (defined (ARMCM3))
-    #include "GCC\startup_armv7-m.S"
-  #elif (defined (ARMCM4) || defined (ARMCM4_FP))
-    #include "GCC\startup_armv7-m.S"
-  #elif (defined (ARMCM7) || defined (ARMCM7_SP) || defined (ARMCM7_DP))
-    #include "GCC\startup_armv7-m.S"
-  #elif (defined (ARMv8MBL))
-    #include "GCC\startup_armv6-m.S"
-  #elif (defined (ARMv8MML)    || defined (ARMv8MML_DSP)    || \
-         defined (ARMv8MML_SP) || defined (ARMv8MML_DSP_SP) || \
-         defined (ARMv8MML_DP) || defined (ARMv8MML_DSP_DP)   )
-    #include "GCC\startup_armv7-m.S"
-  #else
-    #error "No appropriate startup file found!"
-  #endif
-
-#else
-  #error "Compiler not supported!"
-#endif
-

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

@@ -1,56 +0,0 @@
-/**************************************************************************//**
- * @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;
-}

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

@@ -1,82 +0,0 @@
-/**************************************************************************//**
- * @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;
-}

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

@@ -1,68 +0,0 @@
-/**************************************************************************//**
- * @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;
-}

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

@@ -1,99 +0,0 @@
-/**************************************************************************//**
- * @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;
-}