niklas/cyclonedds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Cleanup CUnit integration and add support for theories

Browse source 
Signed-off-by: Jeroen Koekkoek <jeroen@koekkoek.nl>
This commit is contained in:
Jeroen Koekkoek 2018-11-01 19:32:24 +01:00
parent 6e1df4c564
commit 630178fb12
20 changed files with 764 additions and 555 deletions
Download patch file Download diff file Expand all files Collapse all files

372
src/cmake/modules/CUnit.cmake
View file

@ -11,11 +11,195 @@
# #
find_package(CUnit REQUIRED) find_package(CUnit REQUIRED)
include(Glob)
set(CUNIT_DIR "${CMAKE_CURRENT_LIST_DIR}/CUnit") set(CUNIT_DIR "${CMAKE_CURRENT_LIST_DIR}/CUnit")
function(add_cunit_executable target)
function(get_cunit_header_file SOURCE_FILE HEADER_FILE)
# Return a unique (but consistent) filename where Theory macros can be
# written. The path that will be returned is the location to a header file
# located in the same relative directory, using the basename of the source
# file postfixed with .h. e.g. <project>/foo/bar.h would be converted to
# <project>/build/foo/bar.h.
if(IS_ABSOLUTE "${SOURCE_FILE}")
file(RELATIVE_PATH SOURCE_FILE "${PROJECT_SOURCE_DIR}" "${SOURCE_FILE}")
endif()
get_filename_component(basename "${SOURCE_FILE}" NAME_WE)
get_filename_component(dir "${SOURCE_FILE}" DIRECTORY)
set(${HEADER_FILE} "${CMAKE_BINARY_DIR}/${dir}/${basename}.h" PARENT_SCOPE)
endfunction()
function(parse_cunit_fixtures INPUT TEST_DISABLED TEST_TIMEOUT)
if(INPUT MATCHES ".disabled${s}*=${s}*([tT][rR][uU][eE]|[0-9]+)")
set(${TEST_DISABLED} "TRUE" PARENT_SCOPE)
else()
set(${TEST_DISABLED} "FALSE" PARENT_SCOPE)
endif()
if(INPUT MATCHES ".timeout${s}*=${s}*([0-9]+)")
set(${TEST_TIMEOUT} "${CMAKE_MATCH_1}" PARENT_SCOPE)
else()
set(${TEST_TIMEOUT} "0" PARENT_SCOPE)
endif()
endfunction()
# Parse a single source file, generate a header file with theory definitions
# (if applicable) and return suite and test definitions.
function(process_cunit_source_file SOURCE_FILE HEADER_FILE SUITES TESTS)
set(x "\\*")
set(s "[ \t\r\n]")
set(s_or_x "[ \t\r\n\\*]")
set(w "[_a-zA-Z0-9]")
set(ident_expr "(${s}*${w}+${s}*)")
# Very basic type recognition, only things that contain word characters and
# pointers are handled. And since this script does not actually have to
# compile any code, type checking is left to the compiler. An error (or
# warning) will be thrown if something is off.
#
# The "type" regular expression below will match things like:
# - <word> <word>
# - <word> *<word>
# - <word>* <word> *<word>
set(type_expr "(${s}*${w}+${x}*${s}+${s_or_x}*)+")
set(param_expr "${type_expr}${ident_expr}")
# Test fixture support (based on test fixtures as implemented in Criterion),
# to enable per-test (de)initializers, which is very different from
# per-suite (de)initializers, and timeouts.
#
# The following fixtures are supported:
# - init
# - fini
# - disabled
# - timeout
set(data_expr "(${s}*,${s}*\\.${w}+${s}*=[^,]+)*")
set(suites_wo_init_n_clean)
set(suites_w_init)
set(suites_w_clean)
file(READ "${SOURCE_FILE}" content)
# CU_Init and CU_Clean
#
# Extract all suite initializers and deinitializers so that the list of
# suites can be probably populated when tests and theories are parsed. Suites
# are only registered if it contains at least one test or theory.
set(suite_expr "CU_(Init|Clean)${s}*\\(${ident_expr}\\)")
string(REGEX MATCHALL "${suite_expr}" matches "${content}")
foreach(match ${matches})
string(REGEX REPLACE "${suite_expr}" "\\2" suite "${match}")
if("${match}" MATCHES "CU_Init")
list(APPEND suites_w_init ${suite})
elseif("${match}" MATCHES "CU_Clean")
list(APPEND suites_w_deinit ${suite})
endif()
endforeach()
# CU_Test
set(test_expr "CU_Test${s}*\\(${ident_expr},${ident_expr}${data_expr}\\)")
string(REGEX MATCHALL "${test_expr}" matches "${content}")
foreach(match ${matches})
string(REGEX REPLACE "${test_expr}" "\\1" suite "${match}")
string(REGEX REPLACE "${test_expr}" "\\2" test "${match}")
# Remove leading and trailing whitespace
string(STRIP "${suite}" suite)
string(STRIP "${test}" test)
# Extract fixtures that must be handled by CMake (.disabled and .timeout).
parse_cunit_fixtures("${match}" disabled timeout)
list(APPEND suites_wo_init_n_clean "${suite}")
list(APPEND tests "${suite}:${test}:${disabled}:${timeout}")
endforeach()
# CU_Theory
#
# CU_Theory signatures must be recognized in order to generate structures to
# hold the CU_DataPoints declarations. The generated type is added to the
# compile definitions and inserted by the preprocessor when CU_TheoryDataPoints
# is expanded.
#
# NOTE: Since not all compilers support pushing function-style definitions
# from the command line (CMake will generate a warning too), a header
# file is generated instead. A define is pushed and expanded at
# compile time. It is included by CUnit/Theory.h.
get_cunit_header_file("${SOURCE_FILE}" header)
set(theory_expr "CU_Theory${s}*\\(${s}*\\((${param_expr}(,${param_expr})*)\\)${s}*,${ident_expr},${ident_expr}${data_expr}\\)")
string(REGEX MATCHALL "${theory_expr}" matches "${content}")
foreach(match ${matches})
if(NOT theories)
# Ensure generated header is truncated before anything is written.
file(WRITE "${header}" "")
endif()
string(REGEX REPLACE "${theory_expr}" "\\1" params "${match}")
string(REGEX REPLACE "${theory_expr}" "\\7" suite "${match}")
string(REGEX REPLACE "${theory_expr}" "\\8" test "${match}")
# Remove leading and trailing whitespace
string(STRIP "${params}" params)
string(STRIP "${suite}" suite)
string(STRIP "${test}" test)
# Convert parameters from a string to a list
string(REGEX REPLACE "${s}*,${s}*" ";" params "${params}")
# Extract fixtures that must be handled by CMake (.disabled and .timeout)
parse_cunit_fixtures("${match}" disabled timeout)
list(APPEND suites_wo_init_n_clean "${suite}")
list(APPEND theories "${suite}:${test}:${disabled}:${timeout}")
set(sep)
set(size "CU_TheoryDataPointsSize_${suite}_${test}(datapoints) (")
set(slice "CU_TheoryDataPointsSlice_${suite}_${test}(datapoints, index) (")
set(typedef "CU_TheoryDataPointsTypedef_${suite}_${test}() {")
foreach(param ${params})
string(
REGEX REPLACE "(${type_expr})${ident_expr}" "\\3" name "${param}")
string(
REGEX REPLACE "(${type_expr})${ident_expr}" "\\1" type "${param}")
string(STRIP "${name}" name)
string(STRIP "${type}" type)
set(slice "${slice}${sep} datapoints.${name}.p[index]")
if (NOT sep)
set(size "${size} datapoints.${name}.n")
set(sep ",")
endif()
set(typedef "${typedef} struct { size_t n; ${type} *p; } ${name};")
endforeach()
set(typedef "${typedef} }")
set(slice "${slice} )")
set(size "${size} )")
file(APPEND "${header}" "#define ${size}\n")
file(APPEND "${header}" "#define ${slice}\n")
file(APPEND "${header}" "#define ${typedef}\n")
endforeach()
# Propagate suites, tests and theories extracted from the source file.
list(REMOVE_DUPLICATES suites_wo_init_n_clean)
list(SORT suites_wo_init_n_clean)
foreach(suite ${suites_wo_init_n_clean})
set(init "FALSE")
set(clean "FALSE")
if(${suite} IN_LIST suites_w_init)
set(init "TRUE")
endif()
if(${suite} IN_LIST suites_w_deinit)
set(clean "TRUE")
endif()
list(APPEND suites "${suite}:${init}:${clean}")
endforeach()
if(theories)
set(${HEADER_FILE} "${header}" PARENT_SCOPE)
else()
unset(${HEADER_FILE} PARENT_SCOPE)
endif()
set(${SUITES} ${suites} PARENT_SCOPE)
set(${TESTS} ${tests};${theories} PARENT_SCOPE)
endfunction()
function(add_cunit_executable TARGET)
# Retrieve location of shared libary, which is need to extend the PATH # Retrieve location of shared libary, which is need to extend the PATH
# environment variable on Microsoft Windows, so that the operating # environment variable on Microsoft Windows, so that the operating
# system can locate the .dll that it was linked against. # system can locate the .dll that it was linked against.
@ -24,129 +208,93 @@ function(add_cunit_executable target)
get_target_property(CUNIT_IMPORTED_LOCATION CUnit IMPORTED_LOCATION) get_target_property(CUNIT_IMPORTED_LOCATION CUnit IMPORTED_LOCATION)
get_filename_component(CUNIT_LIBRARY_DIR "${CUNIT_IMPORTED_LOCATION}" PATH) get_filename_component(CUNIT_LIBRARY_DIR "${CUNIT_IMPORTED_LOCATION}" PATH)
# Generate semi-random filename to store the generated code in to avoid set(decls)
# possible naming conflicts. set(defns)
string(RANDOM random) set(sources)
set(runner "${target}_${random}")
set(s "[ \t\r\n]") # space foreach(source ${ARGN})
set(w "[0-9a-zA-Z_]") # word if((EXISTS "${source}" OR EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${source}"))
set(param "${s}*(${w}+)${s}*") unset(suites)
set(pattern "CUnit_${w}+${s}*\\(${param}(,${param}(,${param})?)?\\)") unset(tests)
glob(filenames "c" ${ARGN}) process_cunit_source_file("${source}" header suites tests)
if(header)
set_property(
SOURCE "${source}"
PROPERTY COMPILE_DEFINITIONS CU_THEORY_INCLUDE_FILE=\"${header}\")
endif()
foreach(filename ${filenames}) foreach(suite ${suites})
file(READ "${filename}" contents) string(REPLACE ":" ";" suite ${suite})
string(REGEX MATCHALL "${pattern}" captures "${contents}") list(GET suite 2 clean)
list(GET suite 1 init)
list(GET suite 0 suite)
set(init_func "NULL")
set(clean_func "NULL")
if(init)
set(decls "${decls}\nCU_InitDecl(${suite});")
set(init_func "CU_InitName(${suite})")
endif()
if(clean)
set(decls "${decls}\nCU_CleanDecl(${suite});")
set(clean_func "CU_CleanName(${suite})")
endif()
set(defns "${defns}\nADD_SUITE(${suite}, ${init_func}, ${clean_func});")
endforeach()
list(APPEND sources "${filename}") foreach(test ${tests})
list(LENGTH captures length) string(REPLACE ":" ";" test ${test})
if(length) list(GET test 3 timeout)
foreach(capture ${captures}) list(GET test 2 disabled)
string(REGEX REPLACE "${pattern}" "\\1" suite "${capture}") list(GET test 0 suite)
list(GET test 1 test)
if("${capture}" MATCHES "CUnit_Suite_Initialize") set(enable "true")
list(APPEND suites ${suite}) if(disabled)
list(APPEND suites_w_init ${suite}) set(enable "false")
elseif("${capture}" MATCHES "CUnit_Suite_Cleanup") endif()
list(APPEND suites ${suite}) if(NOT timeout)
list(APPEND suites_w_deinit ${suite}) set(timeout 10)
elseif("${capture}" MATCHES "CUnit_Test") endif()
list(APPEND suites ${suite})
# Specifying a test name is mandatory set(decls "${decls}\nCU_TestDecl(${suite}, ${test});")
if("${capture}" MATCHES ",") set(defns "${defns}\nADD_TEST(${suite}, ${test}, ${enable});")
string(REGEX REPLACE "${pattern}" "\\3" test "${capture}") set(ctest "CUnit_${suite}_${test}")
else()
message(FATAL_ERROR "Bad CUnit_Test signature in ${filename}")
endif()
# Specifying if a test is enabled is optional add_test(
set(enable "true") NAME ${ctest}
if("${capture}" MATCHES ",${param},") COMMAND ${TARGET} -a -r "${suite}-${test}" -s ${suite} -t ${test})
string(REGEX REPLACE "${pattern}" "\\5" enable "${capture}") set_property(TEST ${ctest} PROPERTY TIMEOUT ${timeout})
endif() set_property(TEST ${ctest} PROPERTY DISABLED ${disabled})
if(APPLE)
if((NOT "${enable}" STREQUAL "true") AND set_property(
(NOT "${enable}" STREQUAL "false")) TEST ${ctest}
message(FATAL_ERROR "Bad CUnit_Test signature in ${filename}") PROPERTIES ENVIRONMENT
endif() "DYLD_LIBRARY_PATH=${CUNIT_LIBRARY_DIR}:$ENV{DYLD_LIBRARY_PATH}")
elseif(WIN32 AND ${CUNIT_LIBRARY_TYPE} STREQUAL "SHARED_LIBRARY")
list(APPEND tests "${suite}:${test}:${enable}") set_property(
else() TEST ${ctest}
message(FATAL_ERROR "Bad CUnit signature in ${filename}") PROPERTY ENVIRONMENT
"PATH=${CUNIT_LIBRARY_DIR};$ENV{PATH}")
endif() endif()
endforeach() endforeach()
list(APPEND sources "${source}")
endif() endif()
endforeach() endforeach()
# Test suite signatures can be decided on only after everything is parsed. configure_file(
set(lf "\n") "${CUNIT_DIR}/src/main.c.in" "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.c" @ONLY)
set(declf "")
set(deflf "")
list(REMOVE_DUPLICATES suites)
list(SORT suites)
foreach(suite ${suites})
set(init "NULL")
set(deinit "NULL")
if(${suite} IN_LIST suites_w_init)
set(init "CUnit_Suite_Initialize__(${suite})")
set(decls "${decls}${declf}CUnit_Suite_Initialize_Decl__(${suite});")
set(declf "${lf}")
endif()
if(${suite} IN_LIST suites_w_deinit)
set(deinit "CUnit_Suite_Cleanup__(${suite})")
set(decls "${decls}${declf}CUnit_Suite_Cleanup_Decl__(${suite});")
set(declf "${lf}")
endif()
set(defs "${defs}${deflf}CUnit_Suite__(${suite}, ${init}, ${deinit});")
set(deflf "${lf}")
endforeach()
list(REMOVE_DUPLICATES tests)
list(SORT tests)
foreach(entry ${tests})
string(REPLACE ":" ";" entry ${entry})
list(GET entry 0 suite)
list(GET entry 1 test)
list(GET entry 2 enable)
set(decls "${decls}${declf}CUnit_Test_Decl__(${suite}, ${test});")
set(declf "${lf}")
set(defs "${defs}${deflf}CUnit_Test__(${suite}, ${test}, ${enable});")
set(deflf "${lf}")
add_test(
NAME "CUnit_${suite}_${test}"
COMMAND ${target} -a -r "${suite}-${test}" -s ${suite} -t ${test})
set_tests_properties("CUnit_${suite}_${test}" PROPERTIES TIMEOUT 10)
if(APPLE)
set_property(
TEST "CUnit_${suite}_${test}"
PROPERTY ENVIRONMENT "DYLD_LIBRARY_PATH=${CUNIT_LIBRARY_DIR}:$ENV{DYLD_LIBRARY_PATH}")
endif()
if(WIN32 AND ${CUNIT_LIBRARY_TYPE} STREQUAL "SHARED_LIBRARY")
set_property(
TEST "CUnit_${suite}_${test}"
PROPERTY ENVIRONMENT "PATH=${CUNIT_LIBRARY_DIR};$ENV{PATH}")
endif()
endforeach()
set(root "${CUNIT_DIR}")
set(CUnit_Decls "${decls}")
set(CUnit_Defs "${defs}")
configure_file("${root}/src/main.c.in" "${runner}.c" @ONLY)
add_executable(${target} "${runner}.c" "${root}/src/runner.c" ${sources})
target_link_libraries(${target} CUnit)
target_include_directories(${target} PRIVATE "${root}/include")
if("2.1.3" VERSION_LESS_EQUAL if("2.1.3" VERSION_LESS_EQUAL
"${CUNIT_VERSION_MAJOR}.${CUNIT_VERSION_MINOR}.${CUNIT_VERSION_PATCH}") "${CUNIT_VERSION_MAJOR}.${CUNIT_VERSION_MINOR}.${CUNIT_VERSION_PATCH}")
set_source_files_properties( set_property(
"${root}/src/runner.c" PROPERTIES COMPILE_DEFINITIONS HAVE_ENABLE_JUNIT_XML) SOURCE "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.c"
PROPERTY COMPILE_DEFINITIONS HAVE_ENABLE_JUNIT_XML)
endif() endif()
add_executable(
${TARGET} "${CMAKE_CURRENT_BINARY_DIR}/${TARGET}.c" ${sources})
target_link_libraries(${TARGET} CUnit)
target_include_directories(${TARGET} PRIVATE "${CUNIT_DIR}/include")
endfunction() endfunction()

83
src/cmake/modules/CUnit/include/CUnit/Runner.h
View file

@ -1,83 +0,0 @@
/*
* Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
* v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#ifndef CUNIT_RUNNER_H
#define CUNIT_RUNNER_H
#include <stdbool.h>
#include <CUnit/CUnit.h>
#include <CUnit/CUError.h>
#if defined (__cplusplus)
extern "C" {
#endif
#define CUnit_Suite_Initialize_Name__(s) \
s ## _Initialize
#define CUnit_Suite_Initialize(s) \
int CUnit_Suite_Initialize_Name__(s)(void)
#define CUnit_Suite_Initialize_Decl__(s) \
extern CUnit_Suite_Initialize(s)
#define CUnit_Suite_Initialize__(s) \
CUnit_Suite_Initialize_Name__(s)
#define CUnit_Suite_Cleanup_Name__(s) \
s ## _Cleanup
#define CUnit_Suite_Cleanup(s) \
int CUnit_Suite_Cleanup_Name__(s)(void)
#define CUnit_Suite_Cleanup_Decl__(s) \
extern CUnit_Suite_Cleanup(s)
#define CUnit_Suite_Cleanup__(s) \
CUnit_Suite_Cleanup_Name__(s)
#define CUnit_Test_Name__(s, t) \
s ## _ ## t
#define CUnit_Test(s, t, ...) \
void CUnit_Test_Name__(s, t)(void)
#define CUnit_Test_Decl__(s, t) \
extern CUnit_Test(s, t)
#define CUnit_Suite__(s, c, d) \
cu_runner_add_suite(#s, c, d)
#define CUnit_Test__(s, t, e) \
cu_runner_add_test(#s, #t, CUnit_Test_Name__(s, t), e)
CU_ErrorCode
cu_runner_init(
int argc,
char *argv[]);
void
cu_runner_fini(
void);
void
cu_runner_add_suite(
const char *suite,
CU_InitializeFunc pInitFunc,
CU_CleanupFunc pCleanFunc);
void
cu_runner_add_test(
const char *suite,
const char *test,
CU_TestFunc pTestFunc,
bool enable);
CU_ErrorCode
cu_runner_run(
void);
#if defined (__cplusplus)
}
#endif
#endif /* CUNIT_RUNNER_H */

71
src/cmake/modules/CUnit/include/CUnit/Test.h Normal file
View file

@ -0,0 +1,71 @@
#ifndef CUNIT_TEST_H
#define CUNIT_TEST_H
#include <stdbool.h>
#include <CUnit/CUnit.h>
#include <CUnit/CUError.h>
#if defined (__cplusplus)
extern "C" {
#endif
typedef void(*cu_test_init_func_t)(void);
typedef void(*cu_test_fini_func_t)(void);
typedef struct {
cu_test_init_func_t init;
cu_test_fini_func_t fini;
int disabled; /* Parsed by CMake, used at test registration in main. */
int timeout; /* Parsed by CMake, used at test registration in CMake. */
} cu_test_data_t;
#define CU_InitName(suite) \
CU_Init_ ## suite
#define CU_CleanName(suite) \
CU_Fini_ ## suite
#define CU_TestName(suite, test) \
CU_Test_ ## suite ## _ ## test
#define CU_TestProxyName(suite, test) \
CU_TestProxy_ ## suite ## _ ## test
#define CU_Init(suite) \
int CU_InitName(suite)(void)
#define CU_InitDecl(suite) \
extern CU_Init(suite)
#define CU_Clean(suite) \
int CU_CleanName(suite)(void)
#define CU_CleanDecl(suite) \
extern CU_Clean(suite)
/* CU_Test generates a wrapper function that takes care of per-test
initialization and deinitialization, if provided in the CU_Test
signature. */
#define CU_Test(suite, test, ...) \
static void CU_TestName(suite, test)(void); \
\
void CU_TestProxyName(suite, test)(void) { \
static const cu_test_data_t data = { __VA_ARGS__ }; \
\
if (data.init != NULL) { \
data.init(); \
} \
\
CU_TestName(suite, test)(); \
\
if (data.fini != NULL) { \
data.fini(); \
} \
} \
\
static void CU_TestName(suite, test)(void)
#define CU_TestDecl(suite, test) \
extern void CU_TestProxyName(suite, test)(void)
#if defined (__cplusplus)
}
#endif
#endif /* CUNIT_TEST_H */

72
src/cmake/modules/CUnit/include/CUnit/Theory.h Normal file
View file

@ -0,0 +1,72 @@
#ifndef CUNIT_THEORY_H
#define CUNIT_THEORY_H
/* Function-style macros cannot be defined on the command line. */
#ifdef CU_THEORY_INCLUDE_FILE
#include CU_THEORY_INCLUDE_FILE
#endif
#include "CUnit/Test.h"
#if defined (__cplusplus)
extern "C" {
#endif
#define CU_TheoryDataPointsName(suite, test) \
CU_TheoryDataPoints_ ## suite ## _ ## test
#define CU_TheoryDataPointsTypeName(suite, test) \
CU_TheoryDataPointsType_ ## suite ## _ ## test
#define CU_TheoryDataPointsSize(suite, test) \
CU_TheoryDataPointsSize_ ## suite ## _ ## test ( \
CU_TheoryDataPointsName(suite, test))
#define CU_TheoryDataPointsSlice(suite, test, index) \
CU_TheoryDataPointsSlice_ ## suite ## _ ## test ( \
CU_TheoryDataPointsName(suite, test), index)
#define CU_TheoryDataPointsTypedef(suite, test) \
CU_TheoryDataPointsTypedef_ ## suite ## _ ## test()
#define CU_TheoryDataPoints(suite, test) \
struct CU_TheoryDataPointsTypeName(suite, test) \
CU_TheoryDataPointsTypedef(suite, test) ; \
\
static struct CU_TheoryDataPointsTypeName(suite, test) \
CU_TheoryDataPointsName(suite, test)
#define CU_DataPoints(type, ...) { \
.p = (type[]) { __VA_ARGS__ }, \
.n = (sizeof((type[]) { __VA_ARGS__ }) / sizeof(type)) \
}
#define CU_Theory(signature, suite, test, ...) \
static void CU_TestName(suite, test) signature; \
\
void CU_TestProxyName(suite, test)(void) { \
static const cu_test_data_t data = { __VA_ARGS__ }; \
size_t i, n; \
\
if (data.init != NULL) { \
data.init(); \
} \
\
for (i = 0, n = CU_TheoryDataPointsSize(suite, test); i < n; i++) { \
CU_TestName(suite, test) CU_TheoryDataPointsSlice(suite, test, i) ; \
} \
\
if (data.fini != NULL) { \
data.fini(); \
} \
} \
\
static void CU_TestName(suite, test) signature
#if defined (__cplusplus)
}
#endif
#endif /* CUNIT_THEORY_H */

221
src/cmake/modules/CUnit/src/main.c.in
View file

@ -9,23 +9,224 @@
* *
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/ */
#include "CUnit/Runner.h" #include <stdio.h>
#include <string.h>
@CUnit_Decls@ #include <CUnit/Basic.h>
#include <CUnit/Automated.h>
#include <CUnit/Test.h>
int main (int argc, char *argv[]) static struct {
bool print_help;
bool automated;
bool junit;
const char *results;
CU_BasicRunMode mode;
CU_ErrorAction error_action;
const char *suite;
const char *test;
} opts = {
false,
false,
false,
NULL,
CU_BRM_NORMAL,
CUEA_IGNORE,
"*",
"*"
};
int patmatch(const char *pat, const char *str)
{
while (*pat) {
if (*pat == '?') {
/* any character will do */
if (*str++ == 0) {
return 0;
}
pat++;
} else if (*pat == '*') {
/* collapse a sequence of wildcards, requiring as many
characters in str as there are ?s in the sequence */
while (*pat == '*' || *pat == '?') {
if (*pat == '?' && *str++ == 0) {
return 0;
}
pat++;
}
/* try matching on all positions where str matches pat */
while (*str) {
if (*str == *pat && patmatch(pat+1, str+1)) {
return 1;
}
str++;
}
return *pat == 0;
} else {
/* only an exact match */
if (*str++ != *pat++) {
return 0;
}
}
}
return *str == 0;
}
static void usage(const char *name)
{
fprintf(stderr, "Usage: %s OPTIONS\n", name);
fprintf(stderr, "Try '%s -h' for more information\n", name);
}
static void help(const char *name)
{
printf("Usage: %s [OPTIONS]\n", name);
printf("\n");
printf("Possible options:\n");
printf(" -a run in automated mode\n");
printf(" -f fail fast\n");
printf(" -h display this help and exit\n");
printf(" -j junit format results \n");
printf(" -r FILENAME results file for automated run\n");
printf(" -s PATTERN run only tests in suites matching pattern\n");
printf(" -t PATTERN run only test matching pattern\n");
}
static CU_ErrorCode parse_options(int argc, char *argv[])
{
CU_ErrorCode err = CUE_SUCCESS;
for (int i = 1; err == CUE_SUCCESS && i < argc; i++) {
switch ((argv[i][0] == '-') ? argv[i][1] : 0) {
case 'a':
opts.automated = true;
break;
case 'f':
opts.error_action = CUEA_FAIL;
break;
case 'h':
opts.print_help = true;
break;
case 'j':
opts.junit = true;
break;
case 'r':
if((i+1) < argc){
opts.results = argv[++i];
break;
}
/* FALLS THROUGH */
case 's':
if ((i+1) < argc) {
opts.suite = argv[++i];
break;
}
/* FALLS THROUGH */
case 't':
if ((i+1) < argc) {
opts.test = argv[++i];
break;
}
/* FALLS THROUGH */
default:
err = (CU_ErrorCode)256;
CU_set_error(err); /* Will print as "Undefined Errpr" */
break;
}
}
return err;
}
void
add_suite(
const char *suite,
CU_InitializeFunc pInitFunc,
CU_CleanupFunc pCleanFunc)
{
CU_pSuite pSuite;
pSuite = CU_get_suite(suite);
if (pSuite == NULL) {
pSuite = CU_add_suite(suite, pInitFunc, pCleanFunc);
CU_set_suite_active(pSuite, patmatch(opts.suite, suite));
}
}
#define ADD_SUITE(suite, init, clean) \
add_suite(#suite, init, clean)
void
add_test(
const char *suite,
const char *test,
CU_TestFunc pTestFunc,
bool enable)
{
CU_pSuite pSuite;
CU_pTest pTest;
pSuite = CU_get_suite(suite);
pTest = CU_add_test(pSuite, test, pTestFunc);
CU_set_test_active(pTest, enable && patmatch(opts.test, test));
}
#define ADD_TEST(suite, test, enable) \
add_test(#suite, #test, CU_TestProxyName(suite, test), enable)
/* CMake will expand the macro below to declare generated functions. */
@decls@
int main(int argc, char *argv[])
{ {
CU_ErrorCode err; CU_ErrorCode err;
if ((err = cu_runner_init(argc, argv))) { if ((err = parse_options(argc, argv)) != CUE_SUCCESS) {
goto err_init; usage(argv[0]);
return err;
} else if (opts.print_help) {
help(argv[0]);
return CUE_SUCCESS;
} }
@CUnit_Defs@ if ((err = CU_initialize_registry()) != CUE_SUCCESS) {
fprintf(stderr, "CU_initialize_registry: %s\n", CU_get_error_msg());
return err;
}
err = cu_runner_run(); /* CMake will expand the macro below to register all suites and tests. */
cu_runner_fini(); @defns@
err_init:
return (int)err; CU_set_error_action(opts.error_action);
if (opts.automated) {
if (opts.results != NULL) {
CU_set_output_filename(opts.results);
}
#if defined(HAVE_ENABLE_JUNIT_XML)
if (opts.junit) {
CU_automated_enable_junit_xml(CU_TRUE);
} else
#endif
{
CU_list_tests_to_file();
}
CU_automated_run_tests();
} else {
CU_basic_set_mode(opts.mode);
CU_basic_run_tests();
}
err = CU_get_error();
if (err == CUE_SUCCESS) {
err = (CU_ErrorCode)(CU_get_number_of_failures() == 0 ? 0 : 256);
}
CU_cleanup_registry();
return err;
} }

215
src/cmake/modules/CUnit/src/runner.c
View file

@ -1,215 +0,0 @@
/*
* Copyright(c) 2006 to 2018 ADLINK Technology Limited and others
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0, or the Eclipse Distribution License
* v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/
#include <CUnit/Basic.h>
#include <CUnit/Automated.h>
#include "CUnit/Runner.h"
static struct cunit_runner {
bool automated;
bool junit;
const char * results;
CU_BasicRunMode mode;
CU_ErrorAction error_action;
const char *suite;
const char *test;
} runner;
static void
usage(
const char * name)
{
fprintf(stderr, "usage: %s [flags]\n", name);
fprintf(stderr, "Supported flags:\n");
fprintf(stderr, " -a run in automated mode\n");
fprintf(stderr, " -r <file_name> results file for automated run\n");
fprintf(stderr, " -j junit format results \n");
fprintf(stderr, " -f fail fast \n");
fprintf(stderr, " -s suite\n");
fprintf(stderr, " -t test\n");
}
int
patmatch(
const char *pat,
const char *str)
{
while (*pat) {
if (*pat == '?') {
/* any character will do */
if (*str++ == 0) {
return 0;
}
pat++;
} else if (*pat == '*') {
/* collapse a sequence of wildcards, requiring as many
characters in str as there are ?s in the sequence */
while (*pat == '*' || *pat == '?') {
if (*pat == '?' && *str++ == 0) {
return 0;
}
pat++;
}
/* try matching on all positions where str matches pat */
while (*str) {
if (*str == *pat && patmatch(pat+1, str+1)) {
return 1;
}
str++;
}
return *pat == 0;
} else {
/* only an exact match */
if (*str++ != *pat++) {
return 0;
}
}
}
return *str == 0;
}
CU_ErrorCode
cu_runner_init(
int argc,
char* argv[])
{
int c, i;
CU_ErrorCode e = CUE_SUCCESS;
runner.automated = false;
runner.junit = false;
runner.results = NULL;
runner.mode = CU_BRM_NORMAL;
runner.error_action = CUEA_IGNORE;
runner.suite = "*";
runner.test = "*";
for (i = 1; e == CUE_SUCCESS && i < argc; i++) {
c = (argv[i][0] == '-') ? argv[i][1] : -1;
switch (c) {
case 'a':
runner.automated = true;
break;
case 'f':
runner.error_action = CUEA_FAIL;
break;
case 'j':
runner.junit = true;
break;
case 'r':
if((i+1) < argc){
runner.results = argv[++i];
break;
}
/* FALLS THROUGH */
case 's':
if ((i+1) < argc) {
runner.suite = argv[++i];
break;
}
/* FALLS THROUGH */
case 't':
if ((i+1) < argc) {
runner.test = argv[++i];
break;
}
/* FALLS THROUGH */
default:
e = (CU_ErrorCode)256;
CU_set_error(e); /* Will print as "Undefined Errpr" */
usage(argv[0]);
break;
}
}
if (e == CUE_SUCCESS) {
if ((e = CU_initialize_registry()) != CUE_SUCCESS) {
fprintf(
stderr, "Test registry initialization failed: %s\n", CU_get_error_msg());
}
}
CU_set_error_action (runner.error_action);
return e;
}
void
cu_runner_fini(
void)
{
CU_cleanup_registry();
}
void
cu_runner_add_suite(
const char *suite,
CU_InitializeFunc pInitFunc,
CU_CleanupFunc pCleanFunc)
{
CU_pSuite pSuite;
pSuite = CU_get_suite(suite);
if (pSuite == NULL) {
pSuite = CU_add_suite(suite, pInitFunc, pCleanFunc);
//assert(pSuite != NULL);
CU_set_suite_active(pSuite, patmatch(runner.suite, suite));
}
}
void
cu_runner_add_test(
const char *suite,
const char *test,
CU_TestFunc pTestFunc,
bool enable)
{
CU_pSuite pSuite;
CU_pTest pTest;
pSuite = CU_get_suite(suite);
//assert(pSuite != NULL);
pTest = CU_add_test(pSuite, test, pTestFunc);
//assert(pTest != NULL);
CU_set_test_active(pTest, enable && patmatch(runner.test, test));
}
CU_ErrorCode
cu_runner_run(
void)
{
if (runner.automated) {
/* Generate CUnit or JUnit format results */
if (runner.results != NULL) {
CU_set_output_filename(runner.results);
}
if (runner.junit) {
#if defined(HAVE_ENABLE_JUNIT_XML)
CU_automated_enable_junit_xml(CU_TRUE);
#endif
} else {
CU_list_tests_to_file();
}
CU_automated_run_tests();
} else {
CU_basic_set_mode(runner.mode);
CU_basic_run_tests();
}
if (CU_get_error() == 0) {
return (CU_get_number_of_failures() != 0);
}
return CU_get_error();
}

17
src/os/tests/CMakeLists.txt
View file

@ -11,6 +11,21 @@
# #
include(CUnit) include(CUnit)
add_cunit_executable(abstraction .) set(sources
"atomics.c"
"error_no.c"
"heap.c"
"ifaddrs.c"
"iter.c"
"mutex.c"
"once.c"
"report.c"
"rwlock.c"
"stdlib.c"
"strtoll.c"
"thread.c"
"thread_cleanup.c")
add_cunit_executable(abstraction ${sources})
target_link_libraries(abstraction OSAPI) target_link_libraries(abstraction OSAPI)

18
src/os/tests/atomics.c
View file

@ -10,7 +10,7 @@
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/ */
#include "os/os.h" #include "os/os.h"
#include "CUnit/Runner.h" #include "CUnit/Test.h"
uint32_t _osuint32 = 0; uint32_t _osuint32 = 0;
uint64_t _osuint64 = 0; uint64_t _osuint64 = 0;
@ -19,7 +19,7 @@ uintptr_t _osaddress = 0;
ptrdiff_t _ptrdiff = 0; ptrdiff_t _ptrdiff = 0;
void * _osvoidp = (uintptr_t *)0; void * _osvoidp = (uintptr_t *)0;
CUnit_Test(os_atomics, load_store) CU_Test(os_atomics, load_store)
{ {
volatile os_atomic_uint32_t uint32 = OS_ATOMIC_UINT32_INIT(5); volatile os_atomic_uint32_t uint32 = OS_ATOMIC_UINT32_INIT(5);
#if OS_ATOMIC64_SUPPORT #if OS_ATOMIC64_SUPPORT
@ -57,7 +57,7 @@ CUnit_Test(os_atomics, load_store)
printf ("Ending atomics_load_store\n"); printf ("Ending atomics_load_store\n");
} }
CUnit_Test(os_atomics, compare_and_swap) CU_Test(os_atomics, compare_and_swap)
{ {
/* Compare and Swap /* Compare and Swap
* if (ptr == expected) { ptr = newval; } * if (ptr == expected) { ptr = newval; }
@ -115,7 +115,7 @@ CUnit_Test(os_atomics, compare_and_swap)
printf ("Ending atomics_compare_and_swap\n"); printf ("Ending atomics_compare_and_swap\n");
} }
CUnit_Test(os_atomics, increment) CU_Test(os_atomics, increment)
{ {
volatile os_atomic_uint32_t uint32 = OS_ATOMIC_UINT32_INIT(0); volatile os_atomic_uint32_t uint32 = OS_ATOMIC_UINT32_INIT(0);
#if OS_ATOMIC64_SUPPORT #if OS_ATOMIC64_SUPPORT
@ -164,7 +164,7 @@ CUnit_Test(os_atomics, increment)
printf ("Ending atomics_increment\n"); printf ("Ending atomics_increment\n");
} }
CUnit_Test(os_atomics, decrement) CU_Test(os_atomics, decrement)
{ {
volatile os_atomic_uint32_t uint32 = OS_ATOMIC_UINT32_INIT(1); volatile os_atomic_uint32_t uint32 = OS_ATOMIC_UINT32_INIT(1);
#if OS_ATOMIC64_SUPPORT #if OS_ATOMIC64_SUPPORT
@ -213,7 +213,7 @@ CUnit_Test(os_atomics, decrement)
printf ("Ending atomics_decrement\n"); printf ("Ending atomics_decrement\n");
} }
CUnit_Test(os_atomics, add) CU_Test(os_atomics, add)
{ {
volatile os_atomic_uint32_t uint32 = OS_ATOMIC_UINT32_INIT(1); volatile os_atomic_uint32_t uint32 = OS_ATOMIC_UINT32_INIT(1);
#if OS_ATOMIC64_SUPPORT #if OS_ATOMIC64_SUPPORT
@ -273,7 +273,7 @@ CUnit_Test(os_atomics, add)
printf ("Ending atomics_add\n"); printf ("Ending atomics_add\n");
} }
CUnit_Test(os_atomics, subtract) CU_Test(os_atomics, subtract)
{ {
volatile os_atomic_uint32_t uint32 = OS_ATOMIC_UINT32_INIT(5); volatile os_atomic_uint32_t uint32 = OS_ATOMIC_UINT32_INIT(5);
#if OS_ATOMIC64_SUPPORT #if OS_ATOMIC64_SUPPORT
@ -333,7 +333,7 @@ CUnit_Test(os_atomics, subtract)
printf ("Ending atomics_subtract\n"); printf ("Ending atomics_subtract\n");
} }
CUnit_Test(os_atomics, and) CU_Test(os_atomics, and)
{ {
/* AND Operation: /* AND Operation:
@ -399,7 +399,7 @@ CUnit_Test(os_atomics, and)
printf ("Ending atomics_and\n"); printf ("Ending atomics_and\n");
} }
CUnit_Test(os_atomics, or) CU_Test(os_atomics, or)
{ {
/* OR Operation: /* OR Operation:

8
src/os/tests/error_no.c
View file

@ -9,11 +9,11 @@
* *
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/ */
#include "CUnit/Runner.h" #include "CUnit/Test.h"
#include "os/os.h" #include "os/os.h"
CUnit_Suite_Initialize(os_errno) CU_Init(os_errno)
{ {
int result = 0; int result = 0;
os_osInit(); os_osInit();
@ -22,7 +22,7 @@ CUnit_Suite_Initialize(os_errno)
return result; return result;
} }
CUnit_Suite_Cleanup(os_errno) CU_Clean(os_errno)
{ {
int result = 0; int result = 0;
os_osExit(); os_osExit();
@ -31,7 +31,7 @@ CUnit_Suite_Cleanup(os_errno)
return result; return result;
} }
CUnit_Test(os_errno, get_and_set) CU_Test(os_errno, get_and_set)
{ {
printf ("Starting os_errno_get_and_set_001\n"); printf ("Starting os_errno_get_and_set_001\n");
os_setErrno (0); os_setErrno (0);

22
src/os/tests/heap.c
View file

@ -9,11 +9,11 @@
* *
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/ */
#include "CUnit/Runner.h" #include "CUnit/Test.h"
#include "os/os.h" #include "os/os.h"
CUnit_Suite_Initialize(os_heap) CU_Init(os_heap)
{ {
int result = 0; int result = 0;
os_osInit(); os_osInit();
@ -22,7 +22,7 @@ CUnit_Suite_Initialize(os_heap)
return result; return result;
} }
CUnit_Suite_Cleanup(os_heap) CU_Clean(os_heap)
{ {
int result = 0; int result = 0;
os_osExit(); os_osExit();
@ -34,7 +34,7 @@ CUnit_Suite_Cleanup(os_heap)
static const size_t allocsizes[] = {0, 1, 2, 3, 4, 5, 10, 20, 257, 1024}; static const size_t allocsizes[] = {0, 1, 2, 3, 4, 5, 10, 20, 257, 1024};
static const size_t nof_allocsizes = sizeof allocsizes / sizeof *allocsizes; static const size_t nof_allocsizes = sizeof allocsizes / sizeof *allocsizes;
CUnit_Test(os_heap, os_malloc) CU_Test(os_heap, os_malloc)
{ {
for(size_t i = 0; i < nof_allocsizes; i++) { for(size_t i = 0; i < nof_allocsizes; i++) {
for(size_t j = 0; j < nof_allocsizes; j++) { for(size_t j = 0; j < nof_allocsizes; j++) {
@ -48,7 +48,7 @@ CUnit_Test(os_heap, os_malloc)
CU_PASS("os_malloc"); CU_PASS("os_malloc");
} }
CUnit_Test(os_heap, os_malloc_0) CU_Test(os_heap, os_malloc_0)
{ {
for(size_t i = 0; i < nof_allocsizes; i++) { for(size_t i = 0; i < nof_allocsizes; i++) {
for(size_t j = 0; j < nof_allocsizes; j++) { for(size_t j = 0; j < nof_allocsizes; j++) {
@ -64,7 +64,7 @@ CUnit_Test(os_heap, os_malloc_0)
CU_PASS("os_malloc_0"); CU_PASS("os_malloc_0");
} }
CUnit_Test(os_heap, os_calloc) CU_Test(os_heap, os_calloc)
{ {
for(size_t i = 0; i < nof_allocsizes; i++) { for(size_t i = 0; i < nof_allocsizes; i++) {
for(size_t j = 0; j < nof_allocsizes; j++) { for(size_t j = 0; j < nof_allocsizes; j++) {
@ -79,7 +79,7 @@ CUnit_Test(os_heap, os_calloc)
CU_PASS("os_calloc"); CU_PASS("os_calloc");
} }
CUnit_Test(os_heap, os_realloc) CU_Test(os_heap, os_realloc)
{ {
char *ptr = NULL; char *ptr = NULL;
size_t unchanged, s, prevs = 0; size_t unchanged, s, prevs = 0;
@ -105,7 +105,7 @@ CUnit_Test(os_heap, os_realloc)
static const size_t allocsizes_s[] = {0, 1, 2, 3, 4, 5, 10, 20, 257, 1024, 8192}; static const size_t allocsizes_s[] = {0, 1, 2, 3, 4, 5, 10, 20, 257, 1024, 8192};
static const size_t nof_allocsizes_s = sizeof allocsizes_s / sizeof *allocsizes_s; static const size_t nof_allocsizes_s = sizeof allocsizes_s / sizeof *allocsizes_s;
CUnit_Test(os_heap, os_malloc_s) CU_Test(os_heap, os_malloc_s)
{ {
for(size_t i = 0; i < nof_allocsizes_s; i++) { for(size_t i = 0; i < nof_allocsizes_s; i++) {
for(size_t j = 0; j < nof_allocsizes_s; j++) { for(size_t j = 0; j < nof_allocsizes_s; j++) {
@ -124,7 +124,7 @@ CUnit_Test(os_heap, os_malloc_s)
CU_PASS("os_malloc_s"); CU_PASS("os_malloc_s");
} }
CUnit_Test(os_heap, os_malloc_0_s) CU_Test(os_heap, os_malloc_0_s)
{ {
for(size_t i = 0; i < nof_allocsizes_s; i++) { for(size_t i = 0; i < nof_allocsizes_s; i++) {
for(size_t j = 0; j < nof_allocsizes_s; j++) { for(size_t j = 0; j < nof_allocsizes_s; j++) {
@ -145,7 +145,7 @@ CUnit_Test(os_heap, os_malloc_0_s)
CU_PASS("os_malloc_0_s"); CU_PASS("os_malloc_0_s");
} }
CUnit_Test(os_heap, os_calloc_s) CU_Test(os_heap, os_calloc_s)
{ {
for(size_t i = 0; i < nof_allocsizes_s; i++) { for(size_t i = 0; i < nof_allocsizes_s; i++) {
for(size_t j = 0; j < nof_allocsizes_s; j++) { for(size_t j = 0; j < nof_allocsizes_s; j++) {
@ -166,7 +166,7 @@ CUnit_Test(os_heap, os_calloc_s)
CU_PASS("os_calloc_s"); CU_PASS("os_calloc_s");
} }
CUnit_Test(os_heap, os_realloc_s) CU_Test(os_heap, os_realloc_s)
{ {
char *newptr, *ptr = NULL; char *newptr, *ptr = NULL;
size_t unchanged, s, prevs = 0; size_t unchanged, s, prevs = 0;

16
src/os/tests/ifaddrs.c
View file

@ -9,7 +9,7 @@
* *
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/ */
#include "CUnit/Runner.h" #include "CUnit/Test.h"
#include "os/os.h" #include "os/os.h"
/* FIXME: It's not possible to predict what network interfaces are available /* FIXME: It's not possible to predict what network interfaces are available
@ -24,7 +24,7 @@
static int ipv6_enabled = 1; static int ipv6_enabled = 1;
#endif #endif
CUnit_Suite_Initialize(os_getifaddrs) CU_Init(os_getifaddrs)
{ {
os_osInit(); os_osInit();
@ -51,7 +51,7 @@ CUnit_Suite_Initialize(os_getifaddrs)
return 0; return 0;
} }
CUnit_Suite_Cleanup(os_getifaddrs) CU_Clean(os_getifaddrs)
{ {
os_osExit(); os_osExit();
return 0; return 0;
@ -60,7 +60,7 @@ CUnit_Suite_Cleanup(os_getifaddrs)
/* Assume every test machine has at least one IPv4 enabled interface. This /* Assume every test machine has at least one IPv4 enabled interface. This
simple test verifies an interface can at least be found and that the simple test verifies an interface can at least be found and that the
IFF_LOOPBACK flags are properly set. */ IFF_LOOPBACK flags are properly set. */
CUnit_Test(os_getifaddrs, ipv4) CU_Test(os_getifaddrs, ipv4)
{ {
int err; int err;
int seen = 0; int seen = 0;
@ -87,7 +87,7 @@ CUnit_Test(os_getifaddrs, ipv4)
os_freeifaddrs(ifa_root); os_freeifaddrs(ifa_root);
} }
CUnit_Test(os_getifaddrs, null_filter) CU_Test(os_getifaddrs, null_filter)
{ {
int err; int err;
int cnt = 0; int cnt = 0;
@ -105,7 +105,7 @@ CUnit_Test(os_getifaddrs, null_filter)
os_freeifaddrs(ifa_root); os_freeifaddrs(ifa_root);
} }
CUnit_Test(os_getifaddrs, empty_filter) CU_Test(os_getifaddrs, empty_filter)
{ {
int err; int err;
os_ifaddrs_t *ifa_root; os_ifaddrs_t *ifa_root;
@ -119,7 +119,7 @@ CUnit_Test(os_getifaddrs, empty_filter)
} }
#ifdef OS_SOCKET_HAS_IPV6 #ifdef OS_SOCKET_HAS_IPV6
CUnit_Test(os_getifaddrs, ipv6) CU_Test(os_getifaddrs, ipv6)
{ {
if (ipv6_enabled == 1) { if (ipv6_enabled == 1) {
int err; int err;
@ -154,7 +154,7 @@ CUnit_Test(os_getifaddrs, ipv6)
/* Assume at least one IPv4 and one IPv6 interface are available when IPv6 is /* Assume at least one IPv4 and one IPv6 interface are available when IPv6 is
available on the platform. */ available on the platform. */
CUnit_Test(os_getifaddrs, ipv4_n_ipv6) CU_Test(os_getifaddrs, ipv4_n_ipv6)
{ {
if (ipv6_enabled == 1) { if (ipv6_enabled == 1) {
int err; int err;

18
src/os/tests/iter.c
View file

@ -9,7 +9,7 @@
* *
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/ */
#include "CUnit/Runner.h" #include "CUnit/Test.h"
#include "os/os.h" #include "os/os.h"
#include "assert.h" #include "assert.h"
@ -19,7 +19,7 @@ static int32_t three = 3;
static int32_t four = 4; static int32_t four = 4;
static int32_t five = 5; static int32_t five = 5;
CUnit_Test(os_iter, create) CU_Test(os_iter, create)
{ {
os_iter *iter; os_iter *iter;
@ -31,7 +31,7 @@ CUnit_Test(os_iter, create)
os_iterFree(iter, NULL); os_iterFree(iter, NULL);
} }
CUnit_Test(os_iter, prepend) CU_Test(os_iter, prepend)
{ {
os_iter *iter; os_iter *iter;
int32_t idx; int32_t idx;
@ -51,7 +51,7 @@ CUnit_Test(os_iter, prepend)
os_iterFree(iter, NULL); os_iterFree(iter, NULL);
} }
CUnit_Test(os_iter, append) CU_Test(os_iter, append)
{ {
os_iter *iter; os_iter *iter;
int32_t idx; int32_t idx;
@ -71,7 +71,7 @@ CUnit_Test(os_iter, append)
os_iterFree(iter, NULL); os_iterFree(iter, NULL);
} }
CUnit_Test(os_iter, insert) CU_Test(os_iter, insert)
{ {
os_iter *iter; os_iter *iter;
int32_t idx; int32_t idx;
@ -104,7 +104,7 @@ iter_free_callback(
(*(int32_t *)ptr)++; (*(int32_t *)ptr)++;
} }
CUnit_Test(os_iter, free) CU_Test(os_iter, free)
{ {
os_iter *iter; os_iter *iter;
int32_t cnt = 0; int32_t cnt = 0;
@ -126,7 +126,7 @@ iter_walk_callback(
(*(int32_t *)arg)++; (*(int32_t *)arg)++;
} }
CUnit_Test(os_iter, walk) CU_Test(os_iter, walk)
{ {
os_iter *iter; os_iter *iter;
int32_t cnt = 0; int32_t cnt = 0;
@ -166,7 +166,7 @@ iter_new(
return iter; return iter;
} }
CUnit_Test(os_iter, object_indices) CU_Test(os_iter, object_indices)
{ {
os_iter *iter; os_iter *iter;
int32_t *num; int32_t *num;
@ -198,7 +198,7 @@ CUnit_Test(os_iter, object_indices)
os_iterFree(iter, NULL); os_iterFree(iter, NULL);
} }
CUnit_Test(os_iter, take_indices) CU_Test(os_iter, take_indices)
{ {
os_iter *iter; os_iter *iter;
int32_t *num, cnt = 0; int32_t *num, cnt = 0;

16
src/os/tests/mutex.c
View file

@ -9,7 +9,7 @@
* *
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/ */
#include "CUnit/Runner.h" #include "CUnit/Test.h"
#include "os/os.h" #include "os/os.h"
#ifdef __VXWORKS__ #ifdef __VXWORKS__
@ -157,7 +157,7 @@ uint32_t concurrent_trylock_thread (_In_opt_ void *arg)
return 0; return 0;
} }
CUnit_Suite_Initialize(os_mutex) CU_Init(os_mutex)
{ {
printf ( "Run os_mutex_Initialize\n" ); printf ( "Run os_mutex_Initialize\n" );
@ -166,7 +166,7 @@ CUnit_Suite_Initialize(os_mutex)
return 0; return 0;
} }
CUnit_Suite_Cleanup(os_mutex) CU_Clean(os_mutex)
{ {
printf("Run os_mutex_Cleanup\n"); printf("Run os_mutex_Cleanup\n");
@ -176,7 +176,7 @@ CUnit_Suite_Cleanup(os_mutex)
} }
/* This test only checks a single-threaded use-case; just API availability.*/ /* This test only checks a single-threaded use-case; just API availability.*/
CUnit_Test(os_mutex, basic) CU_Test(os_mutex, basic)
{ {
os_mutex m; os_mutex m;
os_result r; os_result r;
@ -227,7 +227,7 @@ os_mutex_init_thr(
return r != os_resultSuccess; /* Return true on faulure */ return r != os_resultSuccess; /* Return true on faulure */
} }
CUnit_Test(os_mutex, init_stress) CU_Test(os_mutex, init_stress)
{ {
struct os_mutex_stress threads[NUM_THREADS]; struct os_mutex_stress threads[NUM_THREADS];
os_threadAttr tattr; os_threadAttr tattr;
@ -259,7 +259,7 @@ CUnit_Test(os_mutex, init_stress)
printf("Ending os_mutex_init_stress\n"); printf("Ending os_mutex_init_stress\n");
} }
CUnit_Test(os_mutex, lock, false) CU_Test(os_mutex, lock, false)
{ {
/* Test critical section access with locking and PRIVATE scope */ /* Test critical section access with locking and PRIVATE scope */
printf ("Starting tc_os_mutex_lock_001\n"); printf ("Starting tc_os_mutex_lock_001\n");
@ -330,7 +330,7 @@ CUnit_Test(os_mutex, lock, false)
printf ("Ending os_mutex_lock\n"); printf ("Ending os_mutex_lock\n");
} }
CUnit_Test(os_mutex, trylock, false) CU_Test(os_mutex, trylock, false)
{ {
os_result result; os_result result;
@ -355,7 +355,7 @@ CUnit_Test(os_mutex, trylock, false)
printf ("Ending os_mutex_trylock\n"); printf ("Ending os_mutex_trylock\n");
} }
CUnit_Test(os_mutex, destroy, false) CU_Test(os_mutex, destroy, false)
{ {
/* Deinitialize mutex with PRIVATE scope and Success result */ /* Deinitialize mutex with PRIVATE scope and Success result */
printf ("Starting os_mutex_destroy_001\n"); printf ("Starting os_mutex_destroy_001\n");

10
src/os/tests/once.c
View file

@ -9,11 +9,11 @@
* *
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/ */
#include "CUnit/Runner.h" #include "CUnit/Test.h"
#include "os/os.h" #include "os/os.h"
/* Suite os_once*/ /* Suite os_once*/
CUnit_Suite_Initialize(os_once) CU_Init(os_once)
{ {
printf("Run os_once_Initialize\n"); printf("Run os_once_Initialize\n");
@ -22,7 +22,7 @@ CUnit_Suite_Initialize(os_once)
return 0; return 0;
} }
CUnit_Suite_Cleanup(os_once) CU_Clean(os_once)
{ {
printf("Run os_once_Cleanup\n"); printf("Run os_once_Cleanup\n");
@ -40,7 +40,7 @@ static void once_func(void)
} }
/* This test only checks a single-threaded use-case; mostly API availability and mere basics.*/ /* This test only checks a single-threaded use-case; mostly API availability and mere basics.*/
CUnit_Test(os_once, basic) CU_Test(os_once, basic)
{ {
static os_once_t init = OS_ONCE_T_STATIC_INIT; static os_once_t init = OS_ONCE_T_STATIC_INIT;
@ -127,7 +127,7 @@ os_once_parallel_thr(
return 0; return 0;
} }
CUnit_Test(os_once, parallel) CU_Test(os_once, parallel)
{ {
os_threadId threads[OS_ONCE_NUM_THREADS]; os_threadId threads[OS_ONCE_NUM_THREADS];
struct os_once_parallel state = { struct os_once_parallel state = {

44
src/os/tests/report.c
View file

@ -9,13 +9,13 @@
* *
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/ */
#include "CUnit/Runner.h" #include "CUnit/Test.h"
#include "os/os.h" #include "os/os.h"
#include "os/os_project.h" #include "os/os_project.h"
#include <stdio.h> #include <stdio.h>
CUnit_Suite_Initialize(os_report) CU_Init(os_report)
{ {
os_putenv(OS_PROJECT_NAME_NOSPACE_CAPS"_ERRORFILE=vdds_test_error"); os_putenv(OS_PROJECT_NAME_NOSPACE_CAPS"_ERRORFILE=vdds_test_error");
os_putenv(OS_PROJECT_NAME_NOSPACE_CAPS"_INFOFILE=vdds_test_info"); os_putenv(OS_PROJECT_NAME_NOSPACE_CAPS"_INFOFILE=vdds_test_info");
@ -42,7 +42,7 @@ void check_existence(os_result error_log_existence, os_result info_log_existence
CU_ASSERT(os_access(info_file_name, OS_ROK) == info_log_existence); CU_ASSERT(os_access(info_file_name, OS_ROK) == info_log_existence);
} }
CUnit_Suite_Cleanup(os_report) CU_Clean(os_report)
{ {
remove_logs(); remove_logs();
@ -50,7 +50,7 @@ CUnit_Suite_Cleanup(os_report)
} }
CUnit_Test(os_report, re_init) CU_Test(os_report, re_init)
{ {
os_reportInit(true); os_reportInit(true);
@ -72,7 +72,7 @@ CUnit_Test(os_report, re_init)
} }
CUnit_Test(os_report, stack_critical) CU_Test(os_report, stack_critical)
{ {
os_reportInit(true); os_reportInit(true);
@ -93,7 +93,7 @@ CUnit_Test(os_report, stack_critical)
} }
CUnit_Test(os_report, stack_non_critical) CU_Test(os_report, stack_non_critical)
{ {
os_reportInit(true); os_reportInit(true);
@ -114,7 +114,7 @@ CUnit_Test(os_report, stack_non_critical)
} }
CUnit_Test(os_report, error_file_creation_critical) CU_Test(os_report, error_file_creation_critical)
{ {
os_reportInit(true); os_reportInit(true);
@ -128,7 +128,7 @@ CUnit_Test(os_report, error_file_creation_critical)
} }
CUnit_Test(os_report, error_file_creation_fatal) CU_Test(os_report, error_file_creation_fatal)
{ {
os_reportInit(true); os_reportInit(true);
@ -142,7 +142,7 @@ CUnit_Test(os_report, error_file_creation_fatal)
} }
CUnit_Test(os_report, info_file_creation_warning) CU_Test(os_report, info_file_creation_warning)
{ {
os_reportInit(true); os_reportInit(true);
@ -156,7 +156,7 @@ CUnit_Test(os_report, info_file_creation_warning)
} }
CUnit_Test(os_report, info_file_creation_info) CU_Test(os_report, info_file_creation_info)
{ {
os_reportInit(true); os_reportInit(true);
@ -170,7 +170,7 @@ CUnit_Test(os_report, info_file_creation_info)
} }
CUnit_Test(os_report, verbosity_low) CU_Test(os_report, verbosity_low)
{ {
os_reportInit(true); os_reportInit(true);
check_existence(os_resultFail, os_resultFail); check_existence(os_resultFail, os_resultFail);
@ -187,7 +187,7 @@ CUnit_Test(os_report, verbosity_low)
} }
CUnit_Test(os_report, verbosity_high) CU_Test(os_report, verbosity_high)
{ {
os_reportInit(true); os_reportInit(true);
check_existence(os_resultFail, os_resultFail); check_existence(os_resultFail, os_resultFail);
@ -205,7 +205,7 @@ CUnit_Test(os_report, verbosity_high)
CUnit_Test(os_report, verbosity_equal) CU_Test(os_report, verbosity_equal)
{ {
os_reportInit(true); os_reportInit(true);
check_existence(os_resultFail, os_resultFail); check_existence(os_resultFail, os_resultFail);
@ -222,7 +222,7 @@ CUnit_Test(os_report, verbosity_equal)
} }
CUnit_Test(os_report, stack_verbosity_low) CU_Test(os_report, stack_verbosity_low)
{ {
os_reportInit(true); os_reportInit(true);
check_existence(os_resultFail, os_resultFail); check_existence(os_resultFail, os_resultFail);
@ -241,7 +241,7 @@ CUnit_Test(os_report, stack_verbosity_low)
} }
CUnit_Test(os_report, stack_verbosity_high) CU_Test(os_report, stack_verbosity_high)
{ {
os_reportInit(true); os_reportInit(true);
check_existence(os_resultFail, os_resultFail); check_existence(os_resultFail, os_resultFail);
@ -261,7 +261,7 @@ CUnit_Test(os_report, stack_verbosity_high)
CUnit_Test(os_report, stack_verbosity_equal) CU_Test(os_report, stack_verbosity_equal)
{ {
os_reportInit(true); os_reportInit(true);
check_existence(os_resultFail, os_resultFail); check_existence(os_resultFail, os_resultFail);
@ -280,7 +280,7 @@ CUnit_Test(os_report, stack_verbosity_equal)
} }
CUnit_Test(os_report, no_log_append) CU_Test(os_report, no_log_append)
{ {
os_reportInit(true); os_reportInit(true);
check_existence(os_resultFail, os_resultFail); check_existence(os_resultFail, os_resultFail);
@ -305,7 +305,7 @@ CUnit_Test(os_report, no_log_append)
} }
CUnit_Test(os_report, log_dir) CU_Test(os_report, log_dir)
{ {
os_putenv(OS_PROJECT_NAME_NOSPACE_CAPS"_LOGPATH=."); os_putenv(OS_PROJECT_NAME_NOSPACE_CAPS"_LOGPATH=.");
@ -324,7 +324,7 @@ CUnit_Test(os_report, log_dir)
} }
CUnit_Test(os_report, verbosity_env_value_info) CU_Test(os_report, verbosity_env_value_info)
{ {
os_putenv(OS_PROJECT_NAME_NOSPACE_CAPS"_VERBOSITY=0"); os_putenv(OS_PROJECT_NAME_NOSPACE_CAPS"_VERBOSITY=0");
os_reportInit(true); os_reportInit(true);
@ -344,7 +344,7 @@ CUnit_Test(os_report, verbosity_env_value_info)
} }
CUnit_Test(os_report, verbosity_env_value_error) CU_Test(os_report, verbosity_env_value_error)
{ {
os_putenv(OS_PROJECT_NAME_NOSPACE_CAPS"_VERBOSITY=3"); os_putenv(OS_PROJECT_NAME_NOSPACE_CAPS"_VERBOSITY=3");
os_reportInit(true); os_reportInit(true);
@ -364,7 +364,7 @@ CUnit_Test(os_report, verbosity_env_value_error)
} }
CUnit_Test(os_report, verbosity_env_value_error_as_string) CU_Test(os_report, verbosity_env_value_error_as_string)
{ {
os_putenv(OS_PROJECT_NAME_NOSPACE_CAPS"_VERBOSITY=ERROR"); os_putenv(OS_PROJECT_NAME_NOSPACE_CAPS"_VERBOSITY=ERROR");
os_reportInit(true); os_reportInit(true);
@ -384,7 +384,7 @@ CUnit_Test(os_report, verbosity_env_value_error_as_string)
} }
CUnit_Test(os_report, verbosity_wrong_env_value) CU_Test(os_report, verbosity_wrong_env_value)
{ {
os_putenv(OS_PROJECT_NAME_NOSPACE_CAPS"_VERBOSITY=WRONG"); os_putenv(OS_PROJECT_NAME_NOSPACE_CAPS"_VERBOSITY=WRONG");
os_reportInit(true); os_reportInit(true);

22
src/os/tests/rwlock.c
View file

@ -9,7 +9,7 @@
* *
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/ */
#include "CUnit/Runner.h" #include "CUnit/Test.h"
#include "os/os.h" #include "os/os.h"
#ifdef __VXWORKS__ #ifdef __VXWORKS__
@ -256,7 +256,7 @@ uint32_t concurrent_tryread_thread (_In_ void *arg)
return 0; return 0;
} }
CUnit_Suite_Initialize(os_rwlock) CU_Init(os_rwlock)
{ {
int result = 0; int result = 0;
os_osInit(); os_osInit();
@ -270,7 +270,7 @@ CUnit_Suite_Initialize(os_rwlock)
return result; return result;
} }
CUnit_Suite_Cleanup(os_rwlock) CU_Clean(os_rwlock)
{ {
int result = 0; int result = 0;
@ -279,7 +279,7 @@ CUnit_Suite_Cleanup(os_rwlock)
return result; return result;
} }
CUnit_Test(os_rwlock, init) CU_Test(os_rwlock, init)
{ {
/* Initilalize reader/writer lock with PRIVATE scope and Success result */ /* Initilalize reader/writer lock with PRIVATE scope and Success result */
printf ("Starting os_rwlock_init_001\n"); printf ("Starting os_rwlock_init_001\n");
@ -292,7 +292,7 @@ CUnit_Test(os_rwlock, init)
printf ("Ending os_rwlock_init\n"); printf ("Ending os_rwlock_init\n");
} }
CUnit_Test(os_rwlock, read, false) CU_Test(os_rwlock, read, false)
{ {
os_time rdelay = { 3, 0 }; os_time rdelay = { 3, 0 };
struct Par par[RWLOCK_THREADS]; struct Par par[RWLOCK_THREADS];
@ -438,7 +438,7 @@ CUnit_Test(os_rwlock, read, false)
printf ("Ending os_rwlock_read\n"); printf ("Ending os_rwlock_read\n");
} }
CUnit_Test(os_rwlock, write, false) CU_Test(os_rwlock, write, false)
{ {
/* Test critical section WRITE access with locking and PRIVATE scope */ /* Test critical section WRITE access with locking and PRIVATE scope */
printf ("Starting os_rwlock_write_001\n"); printf ("Starting os_rwlock_write_001\n");
@ -458,7 +458,7 @@ CUnit_Test(os_rwlock, write, false)
printf ("Ending tc_rwlockWrite\n"); printf ("Ending tc_rwlockWrite\n");
} }
CUnit_Test(rwlock, tryread, false) CU_Test(rwlock, tryread, false)
{ {
os_result result; os_result result;
/* Test critical section READ access with trylocking and PRIVATE scope */ /* Test critical section READ access with trylocking and PRIVATE scope */
@ -488,7 +488,7 @@ CUnit_Test(rwlock, tryread, false)
printf ("Ending os_rwlock_tryread\n"); printf ("Ending os_rwlock_tryread\n");
} }
CUnit_Test(os_rwlock, trywrite, false) CU_Test(os_rwlock, trywrite, false)
{ {
os_result result; os_result result;
/* Test critical section WRITE access with trylocking and PRIVATE scope */ /* Test critical section WRITE access with trylocking and PRIVATE scope */
@ -518,7 +518,7 @@ CUnit_Test(os_rwlock, trywrite, false)
printf ("Ending os_rwlock_trywrite\n"); printf ("Ending os_rwlock_trywrite\n");
} }
CUnit_Test(os_rwlock, unlock, false) CU_Test(os_rwlock, unlock, false)
{ {
os_result result; os_result result;
/* Unlock rwlock with PRIVATE scope and Success result and claimed with read */ /* Unlock rwlock with PRIVATE scope and Success result and claimed with read */
@ -550,7 +550,7 @@ CUnit_Test(os_rwlock, unlock, false)
printf ("Ending tc_rwlockUnlock\n"); printf ("Ending tc_rwlockUnlock\n");
} }
CUnit_Test(os_rwlock, destroy, false) CU_Test(os_rwlock, destroy, false)
{ {
/* Deinitialize rwlock with PRIVATE scope and Success result */ /* Deinitialize rwlock with PRIVATE scope and Success result */
printf ("Starting os_rwlock_destroy_001\n"); printf ("Starting os_rwlock_destroy_001\n");
@ -563,7 +563,7 @@ CUnit_Test(os_rwlock, destroy, false)
printf ("Ending tc_rwlockDestroy\n"); printf ("Ending tc_rwlockDestroy\n");
} }
CUnit_Test(os_rwlock, destroy_shared) CU_Test(os_rwlock, destroy_shared)
{ {
os_rwlock mylock; os_rwlock mylock;

30
src/os/tests/stdlib.c
View file

@ -9,7 +9,7 @@
* *
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/ */
#include "CUnit/Runner.h" #include "CUnit/Test.h"
#include "os/os.h" #include "os/os.h"
#ifndef WINCE #ifndef WINCE
@ -283,14 +283,14 @@ vsnprintfTest(
return result; return result;
} }
CUnit_Suite_Initialize(os_stdlib) CU_Init(os_stdlib)
{ {
int result = 0; int result = 0;
os_osInit(); os_osInit();
return result; return result;
} }
CUnit_Suite_Cleanup(os_stdlib) CU_Clean(os_stdlib)
{ {
/* Remove files used to test permissions */ /* Remove files used to test permissions */
remove ("exec_only"); remove ("exec_only");
@ -303,7 +303,7 @@ CUnit_Suite_Cleanup(os_stdlib)
return 0; return 0;
} }
CUnit_Test(os_stdlib, strcasecmp) CU_Test(os_stdlib, strcasecmp)
{ {
int res; int res;
char *s1, *s2; char *s1, *s2;
@ -353,7 +353,7 @@ CUnit_Test(os_stdlib, strcasecmp)
printf ("Ending os_stdlib_strcasecmp\n"); printf ("Ending os_stdlib_strcasecmp\n");
} }
CUnit_Test(os_stdlib, strncasecmp) CU_Test(os_stdlib, strncasecmp)
{ {
int res; int res;
char *s1, *s2; char *s1, *s2;
@ -415,7 +415,7 @@ CUnit_Test(os_stdlib, strncasecmp)
printf ("Ending os_stdlib_strncasecmp\n"); printf ("Ending os_stdlib_strncasecmp\n");
} }
CUnit_Test(os_stdlib, gethostname) CU_Test(os_stdlib, gethostname)
{ {
int res; int res;
os_result os_res; os_result os_res;
@ -437,7 +437,7 @@ CUnit_Test(os_stdlib, gethostname)
printf ("Ending os_stdlib_gethostname\n"); printf ("Ending os_stdlib_gethostname\n");
} }
CUnit_Test(os_stdlib, putenv) CU_Test(os_stdlib, putenv)
{ {
os_result os_res; os_result os_res;
@ -448,7 +448,7 @@ CUnit_Test(os_stdlib, putenv)
printf ("Ending os_stdlib_putenv\n"); printf ("Ending os_stdlib_putenv\n");
} }
CUnit_Test(os_stdlib, getenv) CU_Test(os_stdlib, getenv)
{ {
const char *env; const char *env;
os_result res; os_result res;
@ -468,7 +468,7 @@ CUnit_Test(os_stdlib, getenv)
printf ("Ending os_stdlib_getenv\n"); printf ("Ending os_stdlib_getenv\n");
} }
CUnit_Test(os_stdlib, fileSep) CU_Test(os_stdlib, fileSep)
{ {
#if defined WIN32 #if defined WIN32
const char *wanted= "\\"; const char *wanted= "\\";
@ -480,7 +480,7 @@ CUnit_Test(os_stdlib, fileSep)
printf ("Ending os_stdlib_fileSep\n"); printf ("Ending os_stdlib_fileSep\n");
} }
CUnit_Test(os_stdlib, access) CU_Test(os_stdlib, access)
{ {
os_result os_res; os_result os_res;
os_result wanted; os_result wanted;
@ -716,7 +716,7 @@ CUnit_Test(os_stdlib, access)
printf ("Ending stdlib_os_access\n"); printf ("Ending stdlib_os_access\n");
} }
CUnit_Test(os_stdlib, vsnprintf) CU_Test(os_stdlib, vsnprintf)
{ {
printf ("Starting os_stdlib_vsnprintf_001\n"); printf ("Starting os_stdlib_vsnprintf_001\n");
CU_ASSERT (vsnprintfTest("%s","test") == 4); CU_ASSERT (vsnprintfTest("%s","test") == 4);
@ -726,7 +726,7 @@ CUnit_Test(os_stdlib, vsnprintf)
printf ("Ending os_stdlib_vsnprintf\n"); printf ("Ending os_stdlib_vsnprintf\n");
} }
CUnit_Test(os_stdlib, strtok_r) CU_Test(os_stdlib, strtok_r)
{ {
char * res; char * res;
char *strtok_r_ts1; char *strtok_r_ts1;
@ -781,7 +781,7 @@ CUnit_Test(os_stdlib, strtok_r)
printf ("Ending os_stdlib_strtok_r\n"); printf ("Ending os_stdlib_strtok_r\n");
} }
CUnit_Test(os_stdlib, index) CU_Test(os_stdlib, index)
{ {
char * res; char * res;
char *index_ts1; char *index_ts1;
@ -806,7 +806,7 @@ CUnit_Test(os_stdlib, index)
printf ("Ending os_stdlib_index\n"); printf ("Ending os_stdlib_index\n");
} }
CUnit_Test(os_stdlib, flockfile) CU_Test(os_stdlib, flockfile)
{ {
bool result = false; bool result = false;
@ -827,7 +827,7 @@ CUnit_Test(os_stdlib, flockfile)
os_osExit(); os_osExit();
} }
CUnit_Test(os_stdlib, getopt) CU_Test(os_stdlib, getopt)
{ {
int c = 0; int c = 0;
int argc = 3; int argc = 3;

18
src/os/tests/strtoll.c
View file

@ -9,7 +9,7 @@
* *
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/ */
#include "CUnit/Runner.h" #include "CUnit/Test.h"
#include "os/os.h" #include "os/os.h"
long long ll; long long ll;
@ -31,7 +31,7 @@ long long llmin = OS_MIN_INTEGER(long long);
long long llmax = OS_MAX_INTEGER(long long); long long llmax = OS_MAX_INTEGER(long long);
unsigned long long ullmax = OS_MAX_INTEGER(unsigned long long); unsigned long long ullmax = OS_MAX_INTEGER(unsigned long long);
CUnit_Suite_Initialize(os_str_convert) CU_Init(os_str_convert)
{ {
int result = 0; int result = 0;
os_osInit(); os_osInit();
@ -48,7 +48,7 @@ CUnit_Suite_Initialize(os_str_convert)
return result; return result;
} }
CUnit_Suite_Cleanup(os_str_convert) CU_Clean(os_str_convert)
{ {
int result = 0; int result = 0;
@ -57,7 +57,7 @@ CUnit_Suite_Cleanup(os_str_convert)
return result; return result;
} }
CUnit_Test(os_str_convert, strtoll) CU_Test(os_str_convert, strtoll)
{ {
printf ("Starting os_strtoll_001a\n"); printf ("Starting os_strtoll_001a\n");
str = "gibberish"; str = "gibberish";
@ -223,7 +223,7 @@ CUnit_Test(os_str_convert, strtoll)
printf ("Ending os_strtoll\n"); printf ("Ending os_strtoll\n");
} }
CUnit_Test(os_str_convert, strtoull) CU_Test(os_str_convert, strtoull)
{ {
printf ("Starting os_strtoull_001a\n"); printf ("Starting os_strtoull_001a\n");
str = "0xffffffffffffffff"; str = "0xffffffffffffffff";
@ -243,7 +243,7 @@ CUnit_Test(os_str_convert, strtoull)
printf ("Ending os_strtoull\n"); printf ("Ending os_strtoull\n");
} }
CUnit_Test(os_str_convert, atoll) CU_Test(os_str_convert, atoll)
{ {
printf ("Starting os_atoll_001\n"); printf ("Starting os_atoll_001\n");
str = "10"; str = "10";
@ -253,7 +253,7 @@ CUnit_Test(os_str_convert, atoll)
printf ("Ending os_atoll\n"); printf ("Ending os_atoll\n");
} }
CUnit_Test(os_str_convert, atoull) CU_Test(os_str_convert, atoull)
{ {
printf ("Starting os_atoull_001\n"); printf ("Starting os_atoull_001\n");
str = "10"; str = "10";
@ -263,7 +263,7 @@ CUnit_Test(os_str_convert, atoull)
printf ("Ending tc_os_atoull\n"); printf ("Ending tc_os_atoull\n");
} }
CUnit_Test(os_str_convert, lltostr) CU_Test(os_str_convert, lltostr)
{ {
printf ("Starting os_lltostr_001\n"); printf ("Starting os_lltostr_001\n");
ll = llmax; ll = llmax;
@ -304,7 +304,7 @@ CUnit_Test(os_str_convert, lltostr)
printf ("Ending os_lltostr\n"); printf ("Ending os_lltostr\n");
} }
CUnit_Test(os_str_convert, ulltostr) CU_Test(os_str_convert, ulltostr)
{ {
printf ("Starting os_ulltostr_001\n"); printf ("Starting os_ulltostr_001\n");
ull = ullmax; ull = ullmax;

24
src/os/tests/thread.c
View file

@ -9,7 +9,7 @@
* *
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
*/ */
#include "CUnit/Runner.h" #include "CUnit/Test.h"
#include "os/os.h" #include "os/os.h"
#include "assert.h" #include "assert.h"
@ -107,7 +107,7 @@ uint32_t threadMemory_thread (_In_opt_ void *args)
return 0; return 0;
} }
CUnit_Suite_Initialize(os_thread) CU_Init(os_thread)
{ {
int result = 0; int result = 0;
os_osInit(); os_osInit();
@ -116,7 +116,7 @@ CUnit_Suite_Initialize(os_thread)
return result; return result;
} }
CUnit_Suite_Cleanup(os_thread) CU_Clean(os_thread)
{ {
int result = 0; int result = 0;
@ -125,7 +125,7 @@ CUnit_Suite_Cleanup(os_thread)
return result; return result;
} }
CUnit_Test(os_thread, create) CU_Test(os_thread, create)
{ {
int result; int result;
os_result osResult; os_result osResult;
@ -452,7 +452,7 @@ CUnit_Test(os_thread, create)
printf ("Ending os_thread_create\n"); printf ("Ending os_thread_create\n");
} }
CUnit_Test(os_thread, idself) CU_Test(os_thread, idself)
{ {
os_threadId thread_os_threadId; os_threadId thread_os_threadId;
os_threadAttr thread_os_threadAttr; os_threadAttr thread_os_threadAttr;
@ -486,7 +486,7 @@ CUnit_Test(os_thread, idself)
printf ("Ending tc_threadIdSelf\n"); printf ("Ending tc_threadIdSelf\n");
} }
CUnit_Test(os_thread, join) CU_Test(os_thread, join)
{ {
os_threadId thread_os_threadId; os_threadId thread_os_threadId;
os_threadAttr thread_os_threadAttr; os_threadAttr thread_os_threadAttr;
@ -612,7 +612,7 @@ CUnit_Test(os_thread, join)
printf ("Ending tc_threadWaitExit\n"); printf ("Ending tc_threadWaitExit\n");
} }
CUnit_Test(os_thread, figure_identity) CU_Test(os_thread, figure_identity)
{ {
#if !defined(_WIN32) #if !defined(_WIN32)
os_threadId thread_os_threadId; os_threadId thread_os_threadId;
@ -718,7 +718,7 @@ CUnit_Test(os_thread, figure_identity)
printf ("Ending os_thread_figure_identity\n"); printf ("Ending os_thread_figure_identity\n");
} }
CUnit_Test(os_thread, attr_init) CU_Test(os_thread, attr_init)
{ {
os_threadAttr thread_os_threadAttr; os_threadAttr thread_os_threadAttr;
/* Check default attributes: schedClass */ /* Check default attributes: schedClass */
@ -744,7 +744,7 @@ CUnit_Test(os_thread, attr_init)
printf ("Ending os_thread_attr_init\n"); printf ("Ending os_thread_attr_init\n");
} }
CUnit_Test(os_thread, memmalloc) CU_Test(os_thread, memmalloc)
{ {
/* Check os_threadMemMalloc with success result for main thread */ /* Check os_threadMemMalloc with success result for main thread */
printf ("Starting os_thread_memmalloc_001\n"); printf ("Starting os_thread_memmalloc_001\n");
@ -772,7 +772,7 @@ CUnit_Test(os_thread, memmalloc)
printf ("Ending tc_thread_memmalloc\n"); printf ("Ending tc_thread_memmalloc\n");
} }
CUnit_Test(os_thread, memget) CU_Test(os_thread, memget)
{ {
/* Check os_threadMemGet for main thread and non allocated index */ /* Check os_threadMemGet for main thread and non allocated index */
printf ("Starting os_thread_memget_001\n"); printf ("Starting os_thread_memget_001\n");
@ -793,7 +793,7 @@ CUnit_Test(os_thread, memget)
printf ("Ending tc_thread_memget\n"); printf ("Ending tc_thread_memget\n");
} }
CUnit_Test(os_thread, memfree) CU_Test(os_thread, memfree)
{ {
/* Check os_threadMemFree for main thread and non allocated index */ /* Check os_threadMemFree for main thread and non allocated index */
printf ("Starting os_thread_memfree_001\n"); printf ("Starting os_thread_memfree_001\n");
@ -814,7 +814,7 @@ CUnit_Test(os_thread, memfree)
printf ("Ending os_thread_memfree\n"); printf ("Ending os_thread_memfree\n");
} }
CUnit_Test(os_thread, module) CU_Test(os_thread, module)
{ {
os_threadId tid; os_threadId tid;
os_threadAttr tattr; os_threadAttr tattr;

22
src/os/tests/thread_cleanup.c
View file

@ -13,15 +13,15 @@
#include <stdint.h> #include <stdint.h>
#include "os/os.h" #include "os/os.h"
#include "CUnit/Runner.h" #include "CUnit/Test.h"
CUnit_Suite_Initialize(os_thread_cleanup) CU_Init(os_thread_cleanup)
{ {
os_osInit(); os_osInit();
return 0; return 0;
} }
CUnit_Suite_Cleanup(os_thread_cleanup) CU_Clean(os_thread_cleanup)
{ {
os_osExit(); os_osExit();
return 0; return 0;
@ -137,7 +137,7 @@ setup(
} }
/* verify the cleanup routine is called */ /* verify the cleanup routine is called */
CUnit_Test(os_thread_cleanup, push_one) CU_Test(os_thread_cleanup, push_one)
{ {
int flags = THREAD_RESET_1; int flags = THREAD_RESET_1;
struct thread_argument *targ = make_thread_argument(flags, 0, 1, 2); struct thread_argument *targ = make_thread_argument(flags, 0, 1, 2);
@ -152,7 +152,7 @@ CUnit_Test(os_thread_cleanup, push_one)
} }
/* verify all cleanup routines are called if multiple are registered */ /* verify all cleanup routines are called if multiple are registered */
CUnit_Test(os_thread_cleanup, push_two) CU_Test(os_thread_cleanup, push_two)
{ {
int flags = THREAD_RESET_1 | THREAD_RESET_2; int flags = THREAD_RESET_1 | THREAD_RESET_2;
struct thread_argument *targ = make_thread_argument(flags, 0, 1, 2); struct thread_argument *targ = make_thread_argument(flags, 0, 1, 2);
@ -167,7 +167,7 @@ CUnit_Test(os_thread_cleanup, push_two)
} }
/* verify the first cleanup routine is still called if second got popped */ /* verify the first cleanup routine is still called if second got popped */
CUnit_Test(os_thread_cleanup, push_two_pop_one_no_exec) CU_Test(os_thread_cleanup, push_two_pop_one_no_exec)
{ {
int flags = THREAD_RESET_1 | THREAD_RESET_2; int flags = THREAD_RESET_1 | THREAD_RESET_2;
struct thread_argument *targ = make_thread_argument(flags, 1, 1, 2); struct thread_argument *targ = make_thread_argument(flags, 1, 1, 2);
@ -181,7 +181,7 @@ CUnit_Test(os_thread_cleanup, push_two_pop_one_no_exec)
free(targ); free(targ);
} }
CUnit_Test(os_thread_cleanup, push_two_pop_one_exec) CU_Test(os_thread_cleanup, push_two_pop_one_exec)
{ {
int flags = THREAD_RESET_1 | THREAD_RESET_2 | THREAD_RUN_1; int flags = THREAD_RESET_1 | THREAD_RESET_2 | THREAD_RUN_1;
struct thread_argument *targ = make_thread_argument(flags, 1, 1, 2); struct thread_argument *targ = make_thread_argument(flags, 1, 1, 2);
@ -196,7 +196,7 @@ CUnit_Test(os_thread_cleanup, push_two_pop_one_exec)
} }
/* verify no cleanup routines are called if all got popped */ /* verify no cleanup routines are called if all got popped */
CUnit_Test(os_thread_cleanup, push_two_pop_two_no_exec) CU_Test(os_thread_cleanup, push_two_pop_two_no_exec)
{ {
int flags = THREAD_RESET_1 | THREAD_RESET_2; int flags = THREAD_RESET_1 | THREAD_RESET_2;
struct thread_argument *targ = make_thread_argument(flags, 2, 1, 2); struct thread_argument *targ = make_thread_argument(flags, 2, 1, 2);
@ -210,7 +210,7 @@ CUnit_Test(os_thread_cleanup, push_two_pop_two_no_exec)
free(targ); free(targ);
} }
CUnit_Test(os_thread_cleanup, push_two_pop_two_exec_one) CU_Test(os_thread_cleanup, push_two_pop_two_exec_one)
{ {
int flags = THREAD_RESET_1 | THREAD_RESET_2 | THREAD_RUN_1; int flags = THREAD_RESET_1 | THREAD_RESET_2 | THREAD_RUN_1;
struct thread_argument *targ = make_thread_argument(flags, 2, 1, 2); struct thread_argument *targ = make_thread_argument(flags, 2, 1, 2);
@ -224,7 +224,7 @@ CUnit_Test(os_thread_cleanup, push_two_pop_two_exec_one)
free(targ); free(targ);
} }
CUnit_Test(os_thread_cleanup, push_two_pop_two_exec_both) CU_Test(os_thread_cleanup, push_two_pop_two_exec_both)
{ {
int flags = THREAD_RESET_1 | THREAD_RESET_2 | THREAD_RUN_1 | THREAD_RUN_2; int flags = THREAD_RESET_1 | THREAD_RESET_2 | THREAD_RUN_1 | THREAD_RUN_2;
struct thread_argument *targ = make_thread_argument(flags, 2, 1, 2); struct thread_argument *targ = make_thread_argument(flags, 2, 1, 2);
@ -238,7 +238,7 @@ CUnit_Test(os_thread_cleanup, push_two_pop_two_exec_both)
free(targ); free(targ);
} }
CUnit_Test(os_thread_cleanup, no_interference) CU_Test(os_thread_cleanup, no_interference)
{ {
int flags = THREAD_RESET_1 | THREAD_RESET_2; int flags = THREAD_RESET_1 | THREAD_RESET_2;
struct thread_argument *targ1 = make_thread_argument(flags, 0, 1, 2); struct thread_argument *targ1 = make_thread_argument(flags, 0, 1, 2);