diff --git a/.travis.yml b/.travis.yml index ecc3cd3..560a56a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -61,7 +61,6 @@ install: - conan user before_script: - - conan remote add atolab https://api.bintray.com/conan/atolab/public-conan - conan remote add bincrafters https://api.bintray.com/conan/bincrafters/public-conan script: diff --git a/appveyor.yml b/appveyor.yml index 797a586..8d7aef4 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -30,7 +30,6 @@ install: - conan user # Creates the conan data directory before_build: - - conan remote add atolab https://api.bintray.com/conan/atolab/public-conan - conan remote add bincrafters https://api.bintray.com/conan/bincrafters/public-conan build_script: diff --git a/conanfile.txt b/conanfile.txt index b87f94b..6d20935 100644 --- a/conanfile.txt +++ b/conanfile.txt @@ -1,6 +1,5 @@ [requires] cunit/2.1-3@bincrafters/stable -criterion/2.3.2@atolab/stable [generators] cmake diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index ef98c81..3bb256b 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -117,11 +117,10 @@ include(AnalyzeBuild) # in the Coverage module should that ever be necessary. include(Coverage) set(MEMORYCHECK_COMMAND_OPTIONS "--track-origins=yes --leak-check=full --trace-children=yes --child-silent-after-fork=yes --xml=yes --xml-file=TestResultValgrind_%p.xml --tool=memcheck --show-reachable=yes --leak-resolution=high") -set(MEMORYCHECK_SUPPRESSIONS_FILE "${CMAKE_CURRENT_LIST_DIR}/valgrind.supp" CACHE FILEPATH "suppression file") # By default building the testing tree is enabled by including CTest, but -# since not everybody has CUnit and/or Criterion installed, and because it is -# not strictly required to build the product itself, switch to off by default. +# since not everybody has CUnit, and because it is not strictly required to +# build the product itself, switch to off by default. option(BUILD_TESTING "Build the testing tree." OFF) include(CTest) diff --git a/src/cmake/modules/CUnit.cmake b/src/cmake/modules/CUnit.cmake index 7c5364c..cd766c3 100644 --- a/src/cmake/modules/CUnit.cmake +++ b/src/cmake/modules/CUnit.cmake @@ -174,20 +174,22 @@ function(process_cunit_source_file SOURCE_FILE HEADER_FILE SUITES TESTS) 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() + if(suites_wo_init_n_clean) + 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() + list(APPEND suites "${suite}:${init}:${clean}") + endforeach() + endif() if(theories) set(${HEADER_FILE} "${header}" PARENT_SCOPE) diff --git a/src/cmake/modules/Criterion.cmake b/src/cmake/modules/Criterion.cmake deleted file mode 100644 index ac65040..0000000 --- a/src/cmake/modules/Criterion.cmake +++ /dev/null @@ -1,96 +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 -# -find_package(Criterion REQUIRED) - -include(Glob) - -set(_criterion_dir "${CMAKE_CURRENT_LIST_DIR}/Criterion") - -function(add_criterion_executable _target) - # Retrieve location of shared libary, which is need to extend the PATH - # environment variable on Microsoft Windows, so that the operating - # system can locate the .dll that it was linked against. - get_target_property(CRITERION_LIBRARY_TYPE Criterion TYPE) - get_target_property(CRITERION_IMPORTED_LOCATION Criterion IMPORTED_LOCATION) - get_filename_component(CRITERION_LIBRARY_DIR "${CRITERION_IMPORTED_LOCATION}" PATH) - - set(s "[ \t\r\n]") # space - set(w "[0-9a-zA-Z_]") # word - set(b "[^0-9a-zA-Z_]") # boundary - set(arg "${s}*(${w}+)${s}*") - set(test "(^|${b})Test${s}*\\(${arg},${arg}(,[^\\)]+)?\\)") # Test - set(params "${s}*\\([^\\)]*\\)${s}*") - set(theory "(^|${b})Theory${s}*\\(${params},${arg},${arg}(,[^\\)]+)?\\)") # Theory - set(paramtest "(^|${b})ParameterizedTest${s}*\\([^,]+,${arg},${arg}(,[^\\)]+)?\\)") # ParameterizedTest - - glob(_files "c" ${ARGN}) - - foreach(_file ${_files}) - file(READ "${_file}" _contents) - string(REGEX MATCHALL "${test}" _matches "${_contents}") - - list(APPEND _sources "${_file}") - list(LENGTH _matches _length) - if(_length) - foreach(_match ${_matches}) - string(REGEX REPLACE "${test}" "\\2" _suite "${_match}") - string(REGEX REPLACE "${test}" "\\3" _name "${_match}") - list(APPEND _tests "${_suite}:${_name}") - endforeach() - endif() - - string(REGEX MATCHALL "${theory}" _matches "${_contents}") - list(LENGTH _matches _length) - if(_length) - foreach(_match ${_matches}) - string(REGEX REPLACE "${theory}" "\\2" _suite "${_match}") - string(REGEX REPLACE "${theory}" "\\3" _name "${_match}") - list(APPEND _tests "${_suite}:${_name}") - endforeach() - endif() - - string(REGEX MATCHALL "${paramtest}" _matches "${_contents}") - list(LENGTH _matches _length) - if(_length) - foreach(_match ${_matches}) - string(REGEX REPLACE "${paramtest}" "\\2" _suite "${_match}") - string(REGEX REPLACE "${paramtest}" "\\3" _name "${_match}") - list(APPEND _tests "${_suite}:${_name}") - endforeach() - endif() - endforeach() - - add_executable(${_target} "${_criterion_dir}/src/runner.c" ${_sources}) - target_link_libraries(${_target} Criterion) - - foreach(_entry ${_tests}) - string(REPLACE ":" ";" _entry ${_entry}) - list(GET _entry 0 _suite) - list(GET _entry 1 _name) - - add_test( - NAME "Criterion_${_suite}_${_name}" - COMMAND ${_target} -j1 --suite ${_suite} --test ${_name} --cunit=${_suite}-${_name} --quiet) - set_tests_properties("Criterion_${_suite}_${_name}" PROPERTIES TIMEOUT 10) - if(APPLE) - set_property( - TEST "Criterion_${_suite}_${_name}" - PROPERTY ENVIRONMENT "DYLD_LIBRARY_PATH=${CRITERION_LIBRARY_DIR}:$ENV{DYLD_LIBRARY_PATH}") - endif() - if(WIN32 AND ${CRITERION_LIBRARY_TYPE} STREQUAL "SHARED_LIBRARY") - set_property( - TEST "Criterion_${_suite}_${_name}" - PROPERTY ENVIRONMENT "PATH=${CRITERION_LIBRARY_DIR};$ENV{PATH}") - endif() - endforeach() -endfunction() - diff --git a/src/cmake/modules/Criterion/src/runner.c b/src/cmake/modules/Criterion/src/runner.c deleted file mode 100644 index 62c1ee6..0000000 --- a/src/cmake/modules/Criterion/src/runner.c +++ /dev/null @@ -1,475 +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 -#include -#include -#include -#include -#include -#include - -#include -#include -#include - -#ifdef _WIN32 -#include -#define LF "\r\n" -#define NAME_MAX _MAX_FNAME -#else -#define LF "\n" -#endif - -static const char *suitepat = "*"; -static const char *testpat = "*"; -static char runfn[NAME_MAX + 1] = { 0 }; -static char listfn[NAME_MAX + 1] = { 0 }; -static char stamp[64] = { 0 }; - -static const char -run_hdr[] = - "" LF - "" LF - "" LF - "" LF - " " LF; - -/* TODO: Criterion version number is not available in any of the header files, - but print_version() is. The function prints a message along the lines - of: Tests compiled with Criterion v2.3.2. The version number therefore - can be retrieved by temporarily swapping out stdout for a FILE handle - opened by open_memstream. However, I don't consider the version number - important enough to go through all that trouble. */ -static const char -run_ftr[] = - " File Generated By Criterion - %s " LF - ""; - -static const char -run_result_hdr[] = - " " LF; - -static const char -run_result_ftr[] = - " " LF; - -static const char -run_suite_hdr[] = - " " LF - " " LF - " %s " LF; - -static const char -run_suite_ftr[] = - " " LF - " " LF; - -static const char -run_test_hdr[] = - " " LF; - -static const char -run_test_ftr[] = - " " LF; - -static const char -run_test_ok[] = - " " LF - " %s " LF - " " LF; - -static const char -run_test_nok[] = - " " LF - " %s " LF - " %s " LF - " %u " LF - " %s " LF - " " LF; - -static const char -run_stats[] = - " " LF - " " LF - " Suites " LF - " %zu " LF - " %zu " LF - " - NA - " LF - " %zu " LF - " %zu " LF - " " LF - " " LF - " Test Cases " LF - " %zu " LF - " %zu " LF - " %zu " LF - " %zu " LF - " %zu " LF - " " LF - " " LF - " Assertions " LF - " %zu " LF - " %zu " LF - " %zu " LF - " %zu " LF - " n/a " LF - " " LF - " " LF; - -static const char -list_hdr[] = - "" LF - "" LF - "" LF - "" LF - " " LF; - -/* TODO: Criterion version number not available. See previous comment. */ -static const char -list_ftr[] = - " File Generated By Criterion - %s " LF - ""; - -static const char -list_stats[] = - " " LF - " " LF - " Total Number of Suites " LF - " %zu " LF - " " LF - " " LF - " Total Number of Test Cases " LF - " %zu " LF - " " LF - " " LF; - -static const char -list_suites_hdr[] = - " " LF; - -static const char -list_suites_ftr[] = - " " LF; - -static const char -list_suite_hdr[] = - " " LF - " " LF - " %s " LF - " %s " LF - " %s " LF - " %s " LF - " %zu " LF - " " LF - " " LF; - -static const char -list_suite_ftr[] = - " " LF - " " LF; - -static const char -list_test[] = - " " LF - " %s " LF - " %s " LF - " " LF; - -static void -print_run_test_stats(FILE *file, struct criterion_test_stats *stats) -{ - struct criterion_assert_stats *itr; - - (void)fprintf(file, run_test_hdr); - if (stats->test_status == CR_STATUS_PASSED) { - (void)fprintf(file, run_test_ok, stats->test->name); - } else if (stats->test_status == CR_STATUS_FAILED) { - for (itr = stats->asserts; itr != NULL; itr = itr->next) { - if (!itr->passed) { - (void)fprintf( - file, - run_test_nok, - stats->test->name, - itr->file, - itr->line, - itr->message); - break; - } - } - } - (void)fprintf(file, run_test_ftr); -} - -static void -print_run_suite_stats(FILE *file, struct criterion_suite_stats *stats) -{ - struct criterion_test_stats *itr; - - (void)fprintf(file, run_suite_hdr, stats->suite->name); - for (itr = stats->tests; itr != NULL; itr = itr->next) { - if (itr->test_status != CR_STATUS_SKIPPED) { - print_run_test_stats(file, itr); - } - } - (void)fprintf(file, run_suite_ftr); -} - -static void -print_run_stats(FILE *file, struct criterion_global_stats *stats) -{ - size_t suites_failed = 0; - size_t suites_passed = 0; - struct criterion_suite_stats *itr; - - (void)fprintf(file, run_hdr); - (void)fprintf(file, run_result_hdr); - for (itr = stats->suites; itr != NULL; itr = itr->next) { - if (itr->tests_skipped != itr->nb_tests) { - print_run_suite_stats(file, itr); - if (itr->tests_failed == itr->nb_tests) { - suites_failed++; - } else { - suites_passed++; - } - } - } - (void)fprintf(file, run_result_ftr); - (void)fprintf( - file, - run_stats, - stats->nb_suites, - suites_passed, - suites_failed, - (stats->nb_suites - (suites_passed - suites_failed)), - stats->nb_tests, - (stats->tests_passed + stats->tests_failed + stats->tests_crashed), - stats->tests_passed, - (stats->tests_failed + stats->tests_crashed), - stats->tests_skipped, - stats->nb_asserts, - (stats->asserts_passed + stats->asserts_failed), - stats->asserts_passed, - stats->asserts_failed); - (void)fprintf(file, run_ftr, stamp); -} - -static void -print_list_test_stats(FILE *file, struct criterion_test_stats *stats) -{ - (void)fprintf( - file, - list_test, - stats->test->name, - (stats->test_status == CR_STATUS_SKIPPED ? "No" : "Yes")); -} - -static void -print_list_suite_stats(FILE *file, struct criterion_suite_stats *stats) -{ - struct criterion_test_stats *itr; - - (void)fprintf( - file, - list_suite_hdr, - stats->suite->name, - "No", // - "No", // - (stats->nb_tests == stats->tests_skipped ? "No" : "Yes"), - stats->nb_tests); - for (itr = stats->tests; itr != NULL; itr = itr->next) { - print_list_test_stats(file, itr); - } - (void)fprintf(file, list_suite_ftr); -} - -static void -print_list_stats(FILE *file, struct criterion_global_stats *stats) -{ - struct criterion_suite_stats *itr; - - (void)fprintf(file, list_hdr); - (void)fprintf(file, list_stats, stats->nb_suites, stats->nb_tests); - (void)fprintf(file, list_suites_hdr); - - for (itr = stats->suites; itr != NULL; itr = itr->next) { - print_list_suite_stats(file, itr); - } - - (void)fprintf(file, list_suites_ftr); - (void)fprintf(file, list_ftr, stamp); -} - -static 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; -} - -/* Criterion actually prescribes */ -ReportHook(POST_ALL)(struct criterion_global_stats *stats) -{ - FILE *runfh, *listfh; - - if (listfn[0] != '\0' && runfn[0] != '\0') { - runfh = NULL; - listfh = NULL; - - if ((runfh = fopen(runfn, "w")) != NULL && - (listfh = fopen(listfn, "w")) != NULL) - { - print_run_stats(runfh, stats); - print_list_stats(listfh, stats); - } else { - (void)fprintf(stderr, "Cannot write results in CUnit format\n"); - } - - if (runfh != NULL) { - (void)fclose(runfh); - } - if (listfh != NULL) { - (void)fclose(listfh); - } - } -} - -#if defined(_WIN32) -__declspec(dllexport) -#endif -int -main(int argc, char *argv[]) -{ - int result = 0; - int argno, cr_argc, sz; - char *pfx, **cr_argv; - const char runfmt[] = "%s-Results.xml"; - const char listfmt[] = "%s-Listing.xml"; - const char stampfmt[] = "%a %b %e %H:%M:%S %Y"; - time_t now; - - /* Before handing over argc and argv over to criterion, go over the list to - extract the custom options. Note that these are meant to be "hidden" */ - cr_argc = 0; - if ((cr_argv = calloc((unsigned)argc, sizeof(*cr_argv))) == NULL) { - result = 1; - } else { - for (argno = 0; argno < argc; argno++) { - /* FIXME: - Eventually CUnit output format should be supported through an - actual logger implementation, but it will do for now. - See: http://criterion.readthedocs.io/en/master/output.html */ - if (strncmp(argv[argno], "--cunit", 7) == 0) { - if ((pfx = strchr(argv[argno], '=')) != NULL) { - pfx++; - } else { - pfx = "CriterionAutomated"; - } - - sz = snprintf(runfn, sizeof(runfn), runfmt, pfx); - assert(sz > 0 && sz < (int)sizeof(runfn)); - sz = snprintf(listfn, sizeof(listfn), listfmt, pfx); - assert(sz > 0 && sz < (int)sizeof(listfn)); - now = time(NULL); - sz = (int)strftime( - stamp, sizeof(stamp), stampfmt, localtime(&now)); - assert(sz != 0); - (void)sz; - } else if (strncmp(argv[argno], "--suite", 7) == 0) { - if ((argno + 1) == argc) { - fprintf(stderr, "--suite requires an argument\n"); - result = 1; - goto bail; - } - suitepat = (const char *)argv[++argno]; - } else if (strncmp(argv[argno], "--test", 6) == 0) { - if ((argno + 1) == argc) { - fprintf(stderr, "--test requires an argument\n"); - result = 1; - goto bail; - } - testpat = (const char *)argv[++argno]; - } else { - cr_argv[cr_argc++] = argv[argno]; - } - } - - /* FIXME: Depending on internal knowledge is not very pretty, but it is - the only way to provide a filter that will work on both *nix - and non-*nix platforms. */ - struct criterion_test_set *tests = criterion_initialize(); - struct criterion_ordered_set_node *suite_itr, *test_itr; - struct criterion_suite_set *suite; - struct criterion_test *test; - - for (suite_itr = tests->suites->first; - suite_itr != NULL; - suite_itr = suite_itr->next) - { - suite = (struct criterion_suite_set *)(suite_itr + 1); - for (test_itr = suite->tests->first; - test_itr != NULL; - test_itr = test_itr->next) - { - test = (struct criterion_test *)(test_itr + 1); - if (!patmatch(suitepat, test->category) || - !patmatch(testpat, test->name)) - { - test->data->disabled = true; - } - } - } - - if (criterion_handle_args(cr_argc, cr_argv, true)) { - result = !criterion_run_all_tests(tests); - } - - criterion_finalize(tests); - -bail: - free(cr_argv); - } - - return result; -} diff --git a/src/cmake/modules/FindCriterion.cmake b/src/cmake/modules/FindCriterion.cmake deleted file mode 100644 index 19cb871..0000000 --- a/src/cmake/modules/FindCriterion.cmake +++ /dev/null @@ -1,61 +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 -# -find_path(CRITERION_INCLUDE_DIR criterion/criterion.h) -find_library(CRITERION_LIBRARY criterion) - -mark_as_advanced(CRITERION_INCLUDE_DIR) - -# Criterion does not define the version number anywhere. - -include(FindPackageHandleStandardArgs) -find_package_handle_standard_args(Criterion DEFAULT_MSG CRITERION_LIBRARY CRITERION_INCLUDE_DIR) - -if(CRITERION_FOUND) - set(CRITERION_INCLUDE_DIRS ${CRITERION_INCLUDE_DIR}) - set(CRITERION_LIBRARIES ${CRITERION_LIBRARY}) - - if(WIN32) - get_filename_component(CRITERION_LIBRARY_DIR "${CRITERION_LIBRARY}}" PATH) - get_filename_component(CRITERION_BASENAME "${CRITERION_LIBRARY}}" NAME_WE) - get_filename_component(CRITERION_PREFIX "${CRITERION_LIBRARY_DIR}" PATH) - - find_program( - CRITERION_DLL - "${CMAKE_SHARED_LIBRARY_PREFIX}${CRITERION_BASENAME}${CMAKE_SHARED_LIBRARY_SUFFIX}" - HINTS - ${CRITERION_PREFIX} - PATH_SUFFIXES - bin - NO_DEFAULT_PATH) - mark_as_advanced(CRITERION_DLL) - - if(CRITERION_DLL) - add_library(Criterion SHARED IMPORTED) - set_target_properties( - Criterion PROPERTIES IMPORTED_IMPLIB "${CRITERION_LIBRARY}") - set_target_properties( - Criterion PROPERTIES IMPORTED_LOCATION "${CRITERION_DLL}") - else() - add_library(Criterion STATIC IMPORTED) - set_target_properties( - Criterion PROPERTIES IMPORTED_LOCATION "${CRITERION_LIBRARY}") - endif() - else() - add_library(Criterion UNKNOWN IMPORTED) - set_target_properties( - Criterion PROPERTIES IMPORTED_LOCATION "${CRITERION_LIBRARY}") - endif() - - set_target_properties( - Criterion PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${CRITERION_INCLUDE_DIR}") -endif() - diff --git a/src/core/ddsc/tests/CMakeLists.txt b/src/core/ddsc/tests/CMakeLists.txt index d9be667..10cd2bb 100644 --- a/src/core/ddsc/tests/CMakeLists.txt +++ b/src/core/ddsc/tests/CMakeLists.txt @@ -9,29 +9,62 @@ # # SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause # -include(Criterion) +include(CUnit) idlc_generate(RoundTrip RoundTrip.idl) idlc_generate(Space Space.idl) idlc_generate(TypesArrayKey TypesArrayKey.idl) -add_criterion_executable(criterion_ddsc .) -target_include_directories(criterion_ddsc PRIVATE + +set(ddsc_test_sources + "basic.c" + "builtin_topics.c" + "config.c" + "dispose.c" + "entity_api.c" + "entity_hierarchy.c" + "entity_status.c" + "err.c" + "file_id.c" + "instance_get_key.c" + "listener.c" + "participant.c" + "publisher.c" + "qos.c" + "querycondition.c" + "readcondition.c" + "reader.c" + "reader_iterator.c" + "read_instance.c" + "register.c" + "return_loan.c" + "subscriber.c" + "take_instance.c" + "time.c" + "topic.c" + "transientlocal.c" + "types.c" + "unregister.c" + "unsupported.c" + "waitset.c" + "write.c" + "writer.c") + +add_cunit_executable(cunit_ddsc ${ddsc_test_sources}) +target_include_directories(cunit_ddsc PRIVATE "$") -target_link_libraries(criterion_ddsc RoundTrip Space TypesArrayKey ddsc OSAPI) +target_link_libraries(cunit_ddsc RoundTrip Space TypesArrayKey ddsc OSAPI) # Setup environment for config-tests -get_test_property(Criterion_ddsc_config_simple_udp ENVIRONMENT Criterion_ddsc_config_simple_udp_env) -set(Criterion_ddsc_config_simple_udp_file "${CMAKE_CURRENT_LIST_DIR}/config_simple_udp.xml") -set(Criterion_ddsc_config_simple_udp_uri "file://${Criterion_ddsc_config_simple_udp_file}") -set(Criterion_ddsc_config_simple_udp_max_participants "0") -set(Criterion_ddsc_config_simple_udp_env "${CMAKE_PROJECT_NAME_CAPS}_URI=${Criterion_ddsc_config_simple_udp_uri};MAX_PARTICIPANTS=${Criterion_ddsc_config_simple_udp_max_participants};${Criterion_ddsc_config_simple_udp_env}") - -message(STATUS "ENV: ${Criterion_ddsc_config_simple_udp_env}") +get_test_property(CUnit_ddsc_config_simple_udp ENVIRONMENT CUnit_ddsc_config_simple_udp_env) +set(CUnit_ddsc_config_simple_udp_file "${CMAKE_CURRENT_LIST_DIR}/config_simple_udp.xml") +set(CUnit_ddsc_config_simple_udp_uri "file://${CUnit_ddsc_config_simple_udp_file}") +set(CUnit_ddsc_config_simple_udp_max_participants "0") +set(CUnit_ddsc_config_simple_udp_env "${CMAKE_PROJECT_NAME_CAPS}_URI=${CUnit_ddsc_config_simple_udp_uri};MAX_PARTICIPANTS=${CUnit_ddsc_config_simple_udp_max_participants};${CUnit_ddsc_config_simple_udp_env}") set_tests_properties( - Criterion_ddsc_config_simple_udp + CUnit_ddsc_config_simple_udp PROPERTIES - REQUIRED_FILES ${Criterion_ddsc_config_simple_udp_file} - ENVIRONMENT "${Criterion_ddsc_config_simple_udp_env}") + REQUIRED_FILES ${CUnit_ddsc_config_simple_udp_file} + ENVIRONMENT "${CUnit_ddsc_config_simple_udp_env}") configure_file("config_env.h.in" "config_env.h") diff --git a/src/core/ddsc/tests/basic.c b/src/core/ddsc/tests/basic.c index cab9810..11b6bd1 100644 --- a/src/core/ddsc/tests/basic.c +++ b/src/core/ddsc/tests/basic.c @@ -10,19 +10,16 @@ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ #include "ddsc/dds.h" -#include -#include +#include "CUnit/Test.h" -Test(ddsc_basic, test) +CU_Test(ddsc_basic, test) { - dds_entity_t participant; - dds_return_t status; + dds_entity_t participant; + dds_return_t status; - participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0); + participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); + CU_ASSERT_FATAL(participant > 0); - /* TODO: CHAM-108: Add some simple read/write test(s). */ - - status = dds_delete(participant); - cr_assert_eq(status, DDS_RETCODE_OK); + status = dds_delete(participant); + CU_ASSERT_EQUAL_FATAL(status, DDS_RETCODE_OK); } diff --git a/src/core/ddsc/tests/builtin_topics.c b/src/core/ddsc/tests/builtin_topics.c old mode 100755 new mode 100644 index 69a3d6b..e6b59bc --- a/src/core/ddsc/tests/builtin_topics.c +++ b/src/core/ddsc/tests/builtin_topics.c @@ -14,8 +14,8 @@ #include "ddsc/dds.h" #include "os/os.h" #include "test-common.h" -#include -#include + +#include "CUnit/Test.h" static dds_entity_t g_participant = 0; static dds_entity_t g_subscriber = 0; @@ -59,7 +59,7 @@ static void qos_init(void) { g_qos = dds_create_qos(); - cr_assert_not_null(g_qos); + CU_ASSERT_PTR_NOT_NULL_FATAL(g_qos); g_pol_userdata.value._buffer = dds_alloc(strlen(c_userdata) + 1); g_pol_userdata.value._length = (uint32_t)strlen(c_userdata) + 1; @@ -149,13 +149,13 @@ setup(void) qos_init(); g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0); g_topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, "RoundTrip", NULL, NULL); - cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic"); + CU_ASSERT_FATAL(g_topic> 0); g_subscriber = dds_create_subscriber(g_participant, NULL, NULL); - cr_assert_gt(g_subscriber, 0, "Failed to create prerequisite g_subscriber"); + CU_ASSERT_FATAL(g_subscriber> 0); g_publisher = dds_create_publisher(g_participant, NULL, NULL); - cr_assert_gt(g_publisher, 0, "Failed to create prerequisite g_publisher"); + CU_ASSERT_FATAL(g_publisher> 0); } static void @@ -197,10 +197,10 @@ check_default_qos_of_builtin_entity(dds_entity_t entity) uint32_t plen; dds_qos_t *qos = dds_create_qos(); - cr_assert_not_null(qos); + CU_ASSERT_PTR_NOT_NULL_FATAL(qos); ret = dds_get_qos(entity, qos); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to get QOS of builtin entity"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); dds_qget_durability(qos, &durability_kind); dds_qget_presentation(qos, &presentation_access_scope_kind, &g_pol_presentation.coherent_access, &g_pol_presentation.ordered_access); @@ -217,31 +217,31 @@ check_default_qos_of_builtin_entity(dds_entity_t entity) // no getter for ENTITY_FACTORY if ((entity & DDS_ENTITY_KIND_MASK) == DDS_KIND_SUBSCRIBER) { - cr_expect_eq(plen, 1); + CU_ASSERT_EQUAL(plen, 1); if (plen > 0) { - cr_expect_str_eq(partitions[0], "__BUILT-IN PARTITION__"); + CU_ASSERT_STRING_EQUAL(partitions[0], "__BUILT-IN PARTITION__"); } } else if ((entity & DDS_ENTITY_KIND_MASK) == DDS_KIND_READER) { - cr_expect_eq(durability_kind, DDS_DURABILITY_TRANSIENT_LOCAL); - cr_expect_eq(presentation_access_scope_kind, DDS_PRESENTATION_TOPIC); - cr_expect_eq(g_pol_presentation.coherent_access, false); - cr_expect_eq(g_pol_presentation.ordered_access, false); - cr_expect_eq(deadline, DDS_INFINITY); - cr_expect_eq(ownership_kind, DDS_OWNERSHIP_SHARED); - cr_expect_eq(liveliness_kind, DDS_LIVELINESS_AUTOMATIC); - cr_expect_eq(minimum_separation, 0); - cr_expect_eq(reliability_kind, DDS_RELIABILITY_RELIABLE); - cr_expect_eq(max_blocking_time, DDS_MSECS(100)); - cr_expect_eq(destination_order_kind, DDS_DESTINATIONORDER_BY_RECEPTION_TIMESTAMP); - cr_expect_eq(history_kind, DDS_HISTORY_KEEP_LAST); - cr_expect_eq(g_pol_history.depth, 1); - cr_expect_eq(g_pol_resource_limits.max_instances, DDS_LENGTH_UNLIMITED); - cr_expect_eq(g_pol_resource_limits.max_samples, DDS_LENGTH_UNLIMITED); - cr_expect_eq(g_pol_resource_limits.max_samples_per_instance, DDS_LENGTH_UNLIMITED); - cr_expect_eq(autopurge_nowriter_samples_delay, DDS_INFINITY); - cr_expect_eq(autopurge_disposed_samples_delay, DDS_INFINITY); + CU_ASSERT_EQUAL(durability_kind, DDS_DURABILITY_TRANSIENT_LOCAL); + CU_ASSERT_EQUAL(presentation_access_scope_kind, DDS_PRESENTATION_TOPIC); + CU_ASSERT_EQUAL(g_pol_presentation.coherent_access, false); + CU_ASSERT_EQUAL(g_pol_presentation.ordered_access, false); + CU_ASSERT_EQUAL(deadline, DDS_INFINITY); + CU_ASSERT_EQUAL(ownership_kind, DDS_OWNERSHIP_SHARED); + CU_ASSERT_EQUAL(liveliness_kind, DDS_LIVELINESS_AUTOMATIC); + CU_ASSERT_EQUAL(minimum_separation, 0); + CU_ASSERT_EQUAL(reliability_kind, DDS_RELIABILITY_RELIABLE); + CU_ASSERT_EQUAL(max_blocking_time, DDS_MSECS(100)); + CU_ASSERT_EQUAL(destination_order_kind, DDS_DESTINATIONORDER_BY_RECEPTION_TIMESTAMP); + CU_ASSERT_EQUAL(history_kind, DDS_HISTORY_KEEP_LAST); + CU_ASSERT_EQUAL(g_pol_history.depth, 1); + CU_ASSERT_EQUAL(g_pol_resource_limits.max_instances, DDS_LENGTH_UNLIMITED); + CU_ASSERT_EQUAL(g_pol_resource_limits.max_samples, DDS_LENGTH_UNLIMITED); + CU_ASSERT_EQUAL(g_pol_resource_limits.max_samples_per_instance, DDS_LENGTH_UNLIMITED); + CU_ASSERT_EQUAL(autopurge_nowriter_samples_delay, DDS_INFINITY); + CU_ASSERT_EQUAL(autopurge_disposed_samples_delay, DDS_INFINITY); } else { - cr_assert_fail("Unsupported entity kind %s", entity_kind_str(entity)); + CU_FAIL_FATAL("Unsupported entity kind"); } if (plen > 0) { for (uint32_t i = 0; i < plen; i++) { @@ -254,11 +254,11 @@ check_default_qos_of_builtin_entity(dds_entity_t entity) static dds_entity_t builtin_topic_handles[10]; -Test(ddsc_builtin_topics, types_allocation) +CU_Test(ddsc_builtin_topics, types_allocation) { #define TEST_ALLOC(type) do { \ DDS_##type##BuiltinTopicData *data = DDS_##type##BuiltinTopicData__alloc(); \ - cr_expect_not_null(data, "Failed to allocate DDS_" #type "BuiltinTopicData"); \ + CU_ASSERT_PTR_NOT_NULL(data); \ DDS_##type##BuiltinTopicData_free(data, DDS_FREE_ALL); \ } while(0) @@ -275,28 +275,28 @@ Test(ddsc_builtin_topics, types_allocation) #undef TEST_ALLOC } -Test(ddsc_builtin_topics, availability_builtin_topics, .init = setup, .fini = teardown) +CU_Test(ddsc_builtin_topics, availability_builtin_topics, .init = setup, .fini = teardown) { dds_entity_t topic; topic = dds_find_topic(g_participant, "DCPSParticipant"); - cr_assert_gt(topic, 0); + CU_ASSERT_FATAL(topic > 0); dds_delete(topic); topic = dds_find_topic(g_participant, "DCPSTopic"); - cr_assert_lt(topic, 0); + CU_ASSERT_FATAL(topic < 0); //TODO CHAM-347: dds_delete(topic); topic = dds_find_topic(g_participant, "DCPSType"); - cr_assert_lt(topic, 0); + CU_ASSERT_FATAL(topic < 0); //TODO CHAM-347: dds_delete(topic); topic = dds_find_topic(g_participant, "DCPSSubscription"); - cr_assert_lt(topic, 0); + CU_ASSERT_FATAL(topic < 0); //TODO CHAM-347: dds_delete(topic); topic = dds_find_topic(g_participant, "DCSPPublication"); - cr_assert_lt(topic, 0); + CU_ASSERT_FATAL(topic < 0); //TODO CHAM-347: dds_delete(topic); } -Test(ddsc_builtin_topics, read_publication_data, .init = setup, .fini = teardown) +CU_Test(ddsc_builtin_topics, read_publication_data, .init = setup, .fini = teardown) { dds_entity_t reader; #if 0 /* disabled pending CHAM-347 */ @@ -307,28 +307,28 @@ Test(ddsc_builtin_topics, read_publication_data, .init = setup, .fini = teardown reader = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSPUBLICATION, NULL, NULL); - cr_assert_gt(reader, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSPUBLICATION."); + CU_ASSERT_FATAL(reader > 0); samples[0] = DDS_PublicationBuiltinTopicData__alloc(); #if 0 /* disabled pending CHAM-347 */ ret = dds_read(reader, samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_gt(ret, 0, "Failed to read samples DCPSPublication"); + CU_ASSERT_FATAL(ret > 0); data = (DDS_PublicationBuiltinTopicData *)samples; - cr_assert_str_eq(data->topic_name, "DCPSPublication"); + CU_ASSERT_STRING_EQUAL_FATAL(data->topic_name, "DCPSPublication"); #endif DDS_PublicationBuiltinTopicData_free(samples[0], DDS_FREE_ALL); } -Test(ddsc_builtin_topics, create_reader) +CU_Test(ddsc_builtin_topics, create_reader) { dds_entity_t participant; dds_entity_t t1; /* Create a participant */ participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant > 0); /* * The topics are created by the middleware as soon as a participant @@ -336,7 +336,7 @@ Test(ddsc_builtin_topics, create_reader) */ #define TEST_FIND(p, t) do { \ t1 = dds_find_topic(p, t); \ - cr_expect_gt(t1, 0, "dds_find_topic(\"" t "\") returned a valid handle"); \ + CU_ASSERT(t1 > 0); \ dds_delete(t1); \ } while(0); @@ -350,7 +350,7 @@ Test(ddsc_builtin_topics, create_reader) */ #define TEST_NOTFOUND(p, t) do { \ t1 = dds_find_topic(p, t); \ - cr_expect_lt(t1, 0, "dds_find_topic(\"" t "\") returned a valid handle"); \ + CU_ASSERT(t1 < 0); \ } while(0); /* A builtin-topic proxy is created 'on demand' and should not exist before a reader is created for it */ @@ -383,18 +383,18 @@ Test(ddsc_builtin_topics, create_reader) for (int i = 0; i < 10; i++) { readers[i] = dds_create_reader(participant, builtin_topic_handles[i], NULL, NULL); - cr_expect_gt(readers[i], 0, "Failed to created reader for builtin topic handle %d", builtin_topic_handles[i]); + CU_ASSERT(readers[i]> 0); if (i == 0) { /* Check the parent of reader is a subscriber */ builtin_subscriber = dds_get_parent(readers[i]); - cr_assert_gt(builtin_subscriber, 0, "Failed to get parent of first builtin-reader (%s)", dds_err_str(builtin_subscriber)); - cr_assert_eq(builtin_subscriber & DDS_ENTITY_KIND_MASK, DDS_KIND_SUBSCRIBER, "Parent is not a subscriber"); + CU_ASSERT_FATAL(builtin_subscriber > 0); + CU_ASSERT_EQUAL_FATAL(builtin_subscriber & DDS_ENTITY_KIND_MASK, DDS_KIND_SUBSCRIBER); } else { /* Check the parent of reader equals parent of first reader */ s = dds_get_parent(readers[i]); - cr_assert_gt(s, 0, "Failed to get parent of builtin-reader (%s)", dds_err_str(s)); - cr_assert_eq(s, builtin_subscriber, "Parent subscriber of reader(%d) doesn't equal builtin-subscriber", i); + CU_ASSERT_FATAL(s > 0); + CU_ASSERT_EQUAL_FATAL(s, builtin_subscriber); //dds_delete(s); } } @@ -402,7 +402,7 @@ Test(ddsc_builtin_topics, create_reader) #define TEST_FOUND(p, t) do { \ t1 = dds_find_topic(p, t); \ - cr_expect_gt(t1, 0, "dds_find_topic(\"" t "\") returned an invalid handle (%s)", dds_err_str(t1)); \ + CU_ASSERT(t1 > 0); \ if (t1 > 0) { \ dds_delete(t1); \ } \ @@ -424,7 +424,7 @@ Test(ddsc_builtin_topics, create_reader) dds_delete(participant); } -Test(ddsc_builtin_topics, read_subscription_data, .init = setup, .fini = teardown) +CU_Test(ddsc_builtin_topics, read_subscription_data, .init = setup, .fini = teardown) { dds_entity_t reader; #if 0 /* not supported yet */ @@ -434,68 +434,66 @@ Test(ddsc_builtin_topics, read_subscription_data, .init = setup, .fini = teardow void * samples[MAX_SAMPLES]; reader = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION, NULL, NULL); - cr_assert_gt(reader, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION."); + CU_ASSERT_FATAL(reader> 0); samples[0] = DDS_SubscriptionBuiltinTopicData__alloc(); #if 0 /* not supported yet */ ret = dds_read(reader, samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_gt(ret, 0, "Failed to read samples DCPSSubscription"); + CU_ASSERT_FATAL(ret> 0); data = (DDS_SubscriptionBuiltinTopicData *)samples; - cr_assert_str_eq(data->topic_name, "DCPSSubscription"); + CU_ASSERT_STRING_EQUAL_FATAL(data->topic_name, "DCPSSubscription"); #endif DDS_SubscriptionBuiltinTopicData_free(samples[0], DDS_FREE_ALL); } -Test(ddsc_builtin_topics, read_participant_data, .init = setup, .fini = teardown) +CU_Test(ddsc_builtin_topics, read_participant_data, .init = setup, .fini = teardown) { dds_entity_t reader; dds_return_t ret; void * samples[MAX_SAMPLES]; reader = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSPARTICIPANT, NULL, NULL); - cr_assert_gt(reader, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSPARTICIPANT."); + CU_ASSERT_FATAL(reader > 0); samples[0] = DDS_ParticipantBuiltinTopicData__alloc(); ret = dds_read(reader, samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_gt(ret, 0, "Failed to read samples DCPSParticipant"); - + CU_ASSERT_FATAL(ret > 0); +#if 0 { DDS_ParticipantBuiltinTopicData *data = (DDS_ParticipantBuiltinTopicData*)samples[0]; - cr_log_info("Participant.key: %x.%x.%x\n", data->key[0], data->key[1], data->key[2]); - cr_log_info("Participant.userdata: %s\n", data->user_data.value._buffer); } +#endif DDS_ParticipantBuiltinTopicData_free(samples[0], DDS_FREE_ALL); } -Test(ddsc_builtin_topics, read_cmparticipant_data, .init = setup, .fini = teardown) +CU_Test(ddsc_builtin_topics, read_cmparticipant_data, .init = setup, .fini = teardown) { dds_entity_t reader; dds_return_t ret; void * samples[MAX_SAMPLES]; reader = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_CMPARTICIPANT, NULL, NULL); - cr_assert_gt(reader, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSPARTICIPANT."); + CU_ASSERT_FATAL(reader > 0); samples[0] = DDS_CMParticipantBuiltinTopicData__alloc(); ret = dds_read(reader, samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_gt(ret, 0, "Failed to read samples CMParticipant"); - + CU_ASSERT_FATAL(ret > 0); +#if 0 { DDS_CMParticipantBuiltinTopicData *data = (DDS_CMParticipantBuiltinTopicData*)samples[0]; - cr_log_info("CMParticipant.key: %x.%x.%x\n", data->key[0], data->key[1], data->key[2]); - cr_log_info("CMParticipant.product: %s\n", data->product.value); } +#endif DDS_CMParticipantBuiltinTopicData_free(samples[0], DDS_FREE_ALL); } -Test(ddsc_builtin_topics, read_topic_data, .init = setup, .fini = teardown) +CU_Test(ddsc_builtin_topics, read_topic_data, .init = setup, .fini = teardown) { dds_entity_t reader; #if 0 /* disabled pending CHAM-347 */ @@ -506,20 +504,20 @@ Test(ddsc_builtin_topics, read_topic_data, .init = setup, .fini = teardown) reader = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSTOPIC, NULL, NULL); - cr_assert_gt(reader, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSTOPIC."); + CU_ASSERT_FATAL(reader > 0); samples[0] = DDS_TopicBuiltinTopicData__alloc(); #if 0 /* disabled pending CHAM-347 */ ret = dds_read(reader, samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_gt(ret, 0, "Failed to read samples DCPSTopic"); + CU_ASSERT_FATAL(ret> 0); data = (DDS_TopicBuiltinTopicData *)samples; - cr_assert_str_eq(data->name, "DCPSSubscription"); + CU_ASSERT_STRING_EQUAL_FATAL(data->name, "DCPSSubscription"); #endif DDS_ParticipantBuiltinTopicData_free(samples[0], DDS_FREE_ALL); } -Test(ddsc_builtin_topics, read_type_data, .init = setup, .fini = teardown) +CU_Test(ddsc_builtin_topics, read_type_data, .init = setup, .fini = teardown) { dds_entity_t reader; #if 0 /* disabled pending CHAM-347 */ @@ -529,20 +527,20 @@ Test(ddsc_builtin_topics, read_type_data, .init = setup, .fini = teardown) void * samples[MAX_SAMPLES]; reader = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSTYPE, NULL, NULL); - cr_assert_gt(reader, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSTYPE."); + CU_ASSERT_FATAL(reader > 0); samples[0] = DDS_TypeBuiltinTopicData__alloc(); #if 0 /* disabled pending CHAM-347 */ ret = dds_read(reader, samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_gt(ret, 0, "Failed to read samples DCPSType"); + CU_ASSERT_FATAL(ret > 0); data = (DDS_TypeBuiltinTopicData *)samples; - cr_assert_str_eq(data->name, "DCPSType"); + CU_ASSERT_STRING_EQUAL_FATAL(data->name, "DCPSType"); #endif DDS_TypeBuiltinTopicData_free(samples[0], DDS_FREE_ALL); } -Test(ddsc_builtin_topics, same_subscriber, .init = setup, .fini = teardown) +CU_Test(ddsc_builtin_topics, same_subscriber, .init = setup, .fini = teardown) { dds_entity_t subscription_rdr; dds_entity_t subscription_subscriber; @@ -560,54 +558,54 @@ Test(ddsc_builtin_topics, same_subscriber, .init = setup, .fini = teardown) dds_entity_t type_subscriber; subscription_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION, NULL, NULL); - cr_assert_gt(subscription_rdr, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION."); + CU_ASSERT_FATAL(subscription_rdr > 0); subscription_subscriber = dds_get_parent(subscription_rdr); - cr_assert_gt(subscription_subscriber, 0, "Could not find builtin subscriber for DSCPSSubscription-reader."); + CU_ASSERT_FATAL(subscription_subscriber > 0); publication_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSPUBLICATION, NULL, NULL); - cr_assert_gt(publication_rdr, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSPUBLICATION."); + CU_ASSERT_FATAL(publication_rdr > 0); publication_subscriber = dds_get_parent(publication_rdr); - cr_assert_gt(publication_subscriber, 0, "Could not find builtin subscriber for DSCPSPublication-reader."); + CU_ASSERT_FATAL(publication_subscriber > 0); - cr_assert_eq(subscription_subscriber, publication_subscriber); + CU_ASSERT_EQUAL_FATAL(subscription_subscriber, publication_subscriber); participant_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSPARTICIPANT, NULL, NULL); - cr_assert_gt(participant_rdr, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSPARTICIPANT."); + CU_ASSERT_FATAL(participant_rdr > 0); participant_subscriber = dds_get_parent(participant_rdr); - cr_assert_gt(participant_subscriber, 0, "Could not find builtin subscriber for DSCPSParticipant-reader."); + CU_ASSERT_FATAL(participant_subscriber > 0); - cr_assert_eq(publication_subscriber, participant_subscriber); + CU_ASSERT_EQUAL_FATAL(publication_subscriber, participant_subscriber); topic_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSTOPIC, NULL, NULL); - cr_assert_gt(topic_rdr, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSTOPIC."); + CU_ASSERT_FATAL(topic_rdr > 0); topic_subscriber = dds_get_parent(topic_rdr); - cr_assert_gt(topic_subscriber, 0, "Could not find builtin subscriber for DSCPSTopic-reader."); + CU_ASSERT_FATAL(topic_subscriber > 0); - cr_assert_eq(participant_subscriber, topic_subscriber); + CU_ASSERT_EQUAL_FATAL(participant_subscriber, topic_subscriber); type_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSTYPE, NULL, NULL); - cr_assert_gt(type_rdr, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSTYPE."); + CU_ASSERT_FATAL(type_rdr > 0); type_subscriber = dds_get_parent(type_rdr); - cr_assert_gt(type_subscriber, 0, "Could not find builtin subscriber for DSCPSType-reader."); + CU_ASSERT_FATAL(type_subscriber > 0); - cr_assert_eq(topic_subscriber, type_subscriber); + CU_ASSERT_EQUAL_FATAL(topic_subscriber, type_subscriber); } -Test(ddsc_builtin_topics, builtin_qos, .init = setup, .fini = teardown) +CU_Test(ddsc_builtin_topics, builtin_qos, .init = setup, .fini = teardown) { dds_entity_t dds_sub_rdr; dds_entity_t dds_sub_subscriber; dds_sub_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION, NULL, NULL); - cr_assert_gt(dds_sub_rdr, 0, "Failed to create a data reader for DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION."); + CU_ASSERT_FATAL(dds_sub_rdr > 0); check_default_qos_of_builtin_entity(dds_sub_rdr); dds_sub_subscriber = dds_get_parent(dds_sub_rdr); - cr_assert_gt(dds_sub_subscriber, 0, "Could not find builtin subscriber for DSCPSSubscription-reader."); + CU_ASSERT_FATAL(dds_sub_subscriber > 0); check_default_qos_of_builtin_entity(dds_sub_subscriber); } -Test(ddsc_builtin_topics, datareader_qos, .init = setup, .fini = teardown) +CU_Test(ddsc_builtin_topics, datareader_qos, .init = setup, .fini = teardown) { dds_entity_t rdr; dds_entity_t subscription_rdr; @@ -633,57 +631,57 @@ Test(ddsc_builtin_topics, datareader_qos, .init = setup, .fini = teardown) dds_qset_groupdata(g_qos, g_pol_groupdata.value._buffer, g_pol_groupdata.value._length); rdr = dds_create_reader(g_subscriber, g_topic, g_qos, NULL); - cr_assert_gt(rdr, 0, "Failed to create a data reader."); + CU_ASSERT_FATAL(rdr > 0); subscription_samples[0] = DDS_SubscriptionBuiltinTopicData__alloc(); subscription_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSSUBSCRIPTION, NULL, NULL); - cr_assert_gt(subscription_rdr, 0, "Failed to retrieve built-in datareader for DCPSSubscription"); + CU_ASSERT_FATAL(subscription_rdr > 0); #if 0 /* disabled pending CHAM-347 */ ret = dds_read(subscription_rdr, subscription_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_gt(ret, 0, "Failed to read Subscription data"); + CU_ASSERT_FATAL(ret > 0); // Check the QOS settings of the 'remote' qos' subscription_data = (DDS_SubscriptionBuiltinTopicData *)subscription_samples[0]; - cr_assert_str_eq(subscription_data->topic_name, "RoundTrip"); - cr_assert_str_eq(subscription_data->type_name, "RoundTripModule::DataType"); - cr_assert_eq(subscription_data->durability.kind, g_pol_durability.kind); - cr_assert_eq(subscription_data->deadline.period.sec, g_pol_deadline.period.sec); - cr_assert_eq(subscription_data->deadline.period.nanosec, g_pol_deadline.period.nanosec); - cr_assert_eq(subscription_data->latency_budget.duration.sec, g_pol_latency_budget.duration.sec); - cr_assert_eq(subscription_data->latency_budget.duration.nanosec, g_pol_latency_budget.duration.nanosec); - cr_assert_eq(subscription_data->liveliness.kind, g_pol_liveliness.kind); - cr_assert_eq(subscription_data->liveliness.lease_duration.sec, g_pol_liveliness.lease_duration.sec); - cr_assert_eq(subscription_data->liveliness.lease_duration.nanosec, g_pol_liveliness.lease_duration.nanosec); - cr_assert_eq(subscription_data->reliability.kind, g_pol_reliability.kind); - cr_assert_eq(subscription_data->reliability.max_blocking_time.sec, g_pol_reliability.max_blocking_time.sec); - cr_assert_eq(subscription_data->reliability.max_blocking_time.nanosec, g_pol_reliability.max_blocking_time.nanosec); - cr_assert_eq(subscription_data->ownership.kind, g_pol_ownership.kind); - cr_assert_eq(subscription_data->destination_order.kind, g_pol_destination_order.kind); - cr_assert_eq(subscription_data->user_data.value._buffer, g_pol_userdata.value._buffer); - cr_assert_eq(subscription_data->user_data.value._length, g_pol_userdata.value._length); - cr_assert_eq(subscription_data->time_based_filter.minimum_separation.sec, g_pol_time_based_filter.minimum_separation.sec); - cr_assert_eq(subscription_data->time_based_filter.minimum_separation.nanosec, g_pol_time_based_filter.minimum_separation.nanosec); - cr_assert_eq(subscription_data->presentation.access_scope, g_pol_presentation.access_scope); - cr_assert_eq(subscription_data->presentation.coherent_access, g_pol_presentation.coherent_access); - cr_assert_eq(subscription_data->presentation.ordered_access, g_pol_presentation.ordered_access); + CU_ASSERT_STRING_EQUAL_FATAL(subscription_data->topic_name, "RoundTrip"); + CU_ASSERT_STRING_EQUAL_FATAL(subscription_data->type_name, "RoundTripModule::DataType"); + CU_ASSERT_EQUAL_FATAL(subscription_data->durability.kind, g_pol_durability.kind); + CU_ASSERT_EQUAL_FATAL(subscription_data->deadline.period.sec, g_pol_deadline.period.sec); + CU_ASSERT_EQUAL_FATAL(subscription_data->deadline.period.nanosec, g_pol_deadline.period.nanosec); + CU_ASSERT_EQUAL_FATAL(subscription_data->latency_budget.duration.sec, g_pol_latency_budget.duration.sec); + CU_ASSERT_EQUAL_FATAL(subscription_data->latency_budget.duration.nanosec, g_pol_latency_budget.duration.nanosec); + CU_ASSERT_EQUAL_FATAL(subscription_data->liveliness.kind, g_pol_liveliness.kind); + CU_ASSERT_EQUAL_FATAL(subscription_data->liveliness.lease_duration.sec, g_pol_liveliness.lease_duration.sec); + CU_ASSERT_EQUAL_FATAL(subscription_data->liveliness.lease_duration.nanosec, g_pol_liveliness.lease_duration.nanosec); + CU_ASSERT_EQUAL_FATAL(subscription_data->reliability.kind, g_pol_reliability.kind); + CU_ASSERT_EQUAL_FATAL(subscription_data->reliability.max_blocking_time.sec, g_pol_reliability.max_blocking_time.sec); + CU_ASSERT_EQUAL_FATAL(subscription_data->reliability.max_blocking_time.nanosec, g_pol_reliability.max_blocking_time.nanosec); + CU_ASSERT_EQUAL_FATAL(subscription_data->ownership.kind, g_pol_ownership.kind); + CU_ASSERT_EQUAL_FATAL(subscription_data->destination_order.kind, g_pol_destination_order.kind); + CU_ASSERT_EQUAL_FATAL(subscription_data->user_data.value._buffer, g_pol_userdata.value._buffer); + CU_ASSERT_EQUAL_FATAL(subscription_data->user_data.value._length, g_pol_userdata.value._length); + CU_ASSERT_EQUAL_FATAL(subscription_data->time_based_filter.minimum_separation.sec, g_pol_time_based_filter.minimum_separation.sec); + CU_ASSERT_EQUAL_FATAL(subscription_data->time_based_filter.minimum_separation.nanosec, g_pol_time_based_filter.minimum_separation.nanosec); + CU_ASSERT_EQUAL_FATAL(subscription_data->presentation.access_scope, g_pol_presentation.access_scope); + CU_ASSERT_EQUAL_FATAL(subscription_data->presentation.coherent_access, g_pol_presentation.coherent_access); + CU_ASSERT_EQUAL_FATAL(subscription_data->presentation.ordered_access, g_pol_presentation.ordered_access); - cr_assert_eq(subscription_data->partition.name._length, g_pol_partition.name._length); + CU_ASSERT_EQUAL_FATAL(subscription_data->partition.name._length, g_pol_partition.name._length); for (uint32_t i = 0; i < subscription_data->partition.name._length; ++i) { - cr_assert_str_eq(subscription_data->partition.name._buffer[i], c_partitions[i]); + CU_ASSERT_STRING_EQUAL_FATAL(subscription_data->partition.name._buffer[i], c_partitions[i]); } - cr_assert_str_eq(subscription_data->topic_data.value._buffer, g_pol_topicdata.value._buffer); - cr_assert_eq(subscription_data->topic_data.value._length, g_pol_topicdata.value._length); - cr_assert_str_eq(subscription_data->group_data.value._buffer, g_pol_groupdata.value._buffer); - cr_assert_eq(subscription_data->group_data.value._length, g_pol_groupdata.value._length); + CU_ASSERT_STRING_EQUAL_FATAL(subscription_data->topic_data.value._buffer, g_pol_topicdata.value._buffer); + CU_ASSERT_EQUAL_FATAL(subscription_data->topic_data.value._length, g_pol_topicdata.value._length); + CU_ASSERT_STRING_EQUAL_FATAL(subscription_data->group_data.value._buffer, g_pol_groupdata.value._buffer); + CU_ASSERT_EQUAL_FATAL(subscription_data->group_data.value._length, g_pol_groupdata.value._length); #endif DDS_SubscriptionBuiltinTopicData_free(subscription_samples[0], DDS_FREE_ALL); } -Test(ddsc_builtin_topics, datawriter_qos, .init = setup, .fini = teardown) +CU_Test(ddsc_builtin_topics, datawriter_qos, .init = setup, .fini = teardown) { dds_entity_t wrtr; dds_entity_t publication_rdr; @@ -709,59 +707,59 @@ Test(ddsc_builtin_topics, datawriter_qos, .init = setup, .fini = teardown) dds_qset_topicdata(g_qos, g_pol_topicdata.value._buffer, g_pol_topicdata.value._length); wrtr = dds_create_writer(g_publisher, g_topic, g_qos, NULL); - cr_assert_gt(wrtr, 0, "Failed to create a data writer."); + CU_ASSERT_FATAL(wrtr > 0); publication_samples[0] = DDS_PublicationBuiltinTopicData__alloc(); publication_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSPUBLICATION, NULL, NULL); - cr_assert_gt(publication_rdr, 0, "Failed to retrieve built-in datareader for DCPSPublication"); + CU_ASSERT_FATAL(publication_rdr > 0); #if 0 /* disabled pending CHAM-347 */ ret = dds_read(publication_rdr, publication_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_gt(ret, 0, "Failed to read Publication data"); + CU_ASSERT_FATAL(ret> 0); // Check the QOS settings of the 'remote' qos' publication_data = (DDS_PublicationBuiltinTopicData *)publication_samples[0]; - cr_assert_str_eq(publication_data->topic_name, "RoundTrip"); - cr_assert_str_eq(publication_data->type_name, "RoundTripModule::DataType"); - cr_assert_eq(publication_data->durability.kind, g_pol_durability.kind); - cr_assert_eq(publication_data->deadline.period.sec, g_pol_deadline.period.sec); - cr_assert_eq(publication_data->deadline.period.nanosec, g_pol_deadline.period.nanosec); - cr_assert_eq(publication_data->latency_budget.duration.sec, g_pol_latency_budget.duration.sec); - cr_assert_eq(publication_data->latency_budget.duration.nanosec, g_pol_latency_budget.duration.nanosec); - cr_assert_eq(publication_data->liveliness.kind, g_pol_liveliness.kind); - cr_assert_eq(publication_data->liveliness.lease_duration.sec, g_pol_liveliness.lease_duration.sec); - cr_assert_eq(publication_data->liveliness.lease_duration.nanosec, g_pol_liveliness.lease_duration.nanosec); - cr_assert_eq(publication_data->reliability.kind, g_pol_reliability.kind); - cr_assert_eq(publication_data->reliability.max_blocking_time.sec, g_pol_reliability.max_blocking_time.sec); - cr_assert_eq(publication_data->reliability.max_blocking_time.nanosec, g_pol_reliability.max_blocking_time.nanosec); - cr_assert_eq(publication_data->lifespan.duration.sec, g_pol_lifespan.duration.sec); - cr_assert_eq(publication_data->lifespan.duration.nanosec, g_pol_lifespan.duration.nanosec); - cr_assert_eq(publication_data->destination_order.kind, g_pol_destination_order.kind); - cr_assert_eq(publication_data->user_data.value._buffer, g_pol_userdata.value._buffer); - cr_assert_eq(publication_data->user_data.value._length, g_pol_userdata.value._length); - cr_assert_eq(publication_data->ownership.kind, g_pol_ownership.kind); - cr_assert_eq(publication_data->ownership_strength.value, g_pol_ownership_strength.value); - cr_assert_eq(publication_data->presentation.access_scope, g_pol_presentation.access_scope); - cr_assert_eq(publication_data->presentation.coherent_access, g_pol_presentation.coherent_access); - cr_assert_eq(publication_data->presentation.ordered_access, g_pol_presentation.ordered_access); + CU_ASSERT_STRING_EQUAL_FATAL(publication_data->topic_name, "RoundTrip"); + CU_ASSERT_STRING_EQUAL_FATAL(publication_data->type_name, "RoundTripModule::DataType"); + CU_ASSERT_EQUAL_FATAL(publication_data->durability.kind, g_pol_durability.kind); + CU_ASSERT_EQUAL_FATAL(publication_data->deadline.period.sec, g_pol_deadline.period.sec); + CU_ASSERT_EQUAL_FATAL(publication_data->deadline.period.nanosec, g_pol_deadline.period.nanosec); + CU_ASSERT_EQUAL_FATAL(publication_data->latency_budget.duration.sec, g_pol_latency_budget.duration.sec); + CU_ASSERT_EQUAL_FATAL(publication_data->latency_budget.duration.nanosec, g_pol_latency_budget.duration.nanosec); + CU_ASSERT_EQUAL_FATAL(publication_data->liveliness.kind, g_pol_liveliness.kind); + CU_ASSERT_EQUAL_FATAL(publication_data->liveliness.lease_duration.sec, g_pol_liveliness.lease_duration.sec); + CU_ASSERT_EQUAL_FATAL(publication_data->liveliness.lease_duration.nanosec, g_pol_liveliness.lease_duration.nanosec); + CU_ASSERT_EQUAL_FATAL(publication_data->reliability.kind, g_pol_reliability.kind); + CU_ASSERT_EQUAL_FATAL(publication_data->reliability.max_blocking_time.sec, g_pol_reliability.max_blocking_time.sec); + CU_ASSERT_EQUAL_FATAL(publication_data->reliability.max_blocking_time.nanosec, g_pol_reliability.max_blocking_time.nanosec); + CU_ASSERT_EQUAL_FATAL(publication_data->lifespan.duration.sec, g_pol_lifespan.duration.sec); + CU_ASSERT_EQUAL_FATAL(publication_data->lifespan.duration.nanosec, g_pol_lifespan.duration.nanosec); + CU_ASSERT_EQUAL_FATAL(publication_data->destination_order.kind, g_pol_destination_order.kind); + CU_ASSERT_EQUAL_FATAL(publication_data->user_data.value._buffer, g_pol_userdata.value._buffer); + CU_ASSERT_EQUAL_FATAL(publication_data->user_data.value._length, g_pol_userdata.value._length); + CU_ASSERT_EQUAL_FATAL(publication_data->ownership.kind, g_pol_ownership.kind); + CU_ASSERT_EQUAL_FATAL(publication_data->ownership_strength.value, g_pol_ownership_strength.value); + CU_ASSERT_EQUAL_FATAL(publication_data->presentation.access_scope, g_pol_presentation.access_scope); + CU_ASSERT_EQUAL_FATAL(publication_data->presentation.coherent_access, g_pol_presentation.coherent_access); + CU_ASSERT_EQUAL_FATAL(publication_data->presentation.ordered_access, g_pol_presentation.ordered_access); - cr_assert_eq(publication_data->partition.name._length, g_pol_partition.name._length); + CU_ASSERT_EQUAL_FATAL(publication_data->partition.name._length, g_pol_partition.name._length); for (uint32_t i = 0; i < publication_data->partition.name._length; ++i) { - cr_assert_str_eq(publication_data->partition.name._buffer[i], c_partitions[i]); + CU_ASSERT_STRING_EQUAL_FATAL(publication_data->partition.name._buffer[i], c_partitions[i]); } - cr_assert_str_eq(publication_data->topic_data.value._buffer, g_pol_topicdata.value._buffer); - cr_assert_eq(publication_data->topic_data.value._length, g_pol_topicdata.value._length); - cr_assert_str_eq(publication_data->group_data.value._buffer, g_pol_groupdata.value._buffer); - cr_assert_eq(publication_data->group_data.value._length, g_pol_groupdata.value._length); + CU_ASSERT_STRING_EQUAL_FATAL(publication_data->topic_data.value._buffer, g_pol_topicdata.value._buffer); + CU_ASSERT_EQUAL_FATAL(publication_data->topic_data.value._length, g_pol_topicdata.value._length); + CU_ASSERT_STRING_EQUAL_FATAL(publication_data->group_data.value._buffer, g_pol_groupdata.value._buffer); + CU_ASSERT_EQUAL_FATAL(publication_data->group_data.value._length, g_pol_groupdata.value._length); #endif DDS_PublicationBuiltinTopicData_free(publication_samples[0], DDS_FREE_ALL); } -Test(ddsc_builtin_topics, topic_qos, .init = setup, .fini = teardown) +CU_Test(ddsc_builtin_topics, topic_qos, .init = setup, .fini = teardown) { dds_entity_t tpc; dds_entity_t topic_rdr; @@ -796,50 +794,50 @@ Test(ddsc_builtin_topics, topic_qos, .init = setup, .fini = teardown) tpc = dds_create_topic(g_participant, &Space_Type1_desc, "SpaceType1", g_qos, NULL); - cr_assert_gt(tpc, 0, "Failed to create a topic."); + CU_ASSERT_FATAL(tpc > 0); topic_samples[0] = DDS_PublicationBuiltinTopicData__alloc(); topic_rdr = dds_create_reader(g_participant, DDS_BUILTIN_TOPIC_DCPSTOPIC, NULL, NULL); - cr_assert_gt(topic_rdr, 0, "Failed to retrieve built-in datareader for DCPSPublication"); + CU_ASSERT_FATAL(topic_rdr > 0 ); #if 0 /* disabled pending CHAM-347 */ ret = dds_read(topic_rdr, topic_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_gt(ret, 0, "Failed to read Topic data"); + CU_ASSERT_FATAL(ret > 0); topic_data = (DDS_TopicBuiltinTopicData *)topic_samples[0]; - cr_assert_str_eq(topic_data->name, "SpaceType1"); - cr_assert_str_eq(topic_data->type_name, "RoundTripModule::DataType"); - cr_assert_eq(topic_data->durability.kind, g_pol_durability.kind); - cr_assert_eq(topic_data->durability_service.service_cleanup_delay.sec, g_pol_durability_service.service_cleanup_delay.sec); - cr_assert_eq(topic_data->durability_service.service_cleanup_delay.nanosec, g_pol_durability_service.service_cleanup_delay.nanosec); - cr_assert_eq(topic_data->durability_service.history_kind, g_pol_durability_service.history_kind); - cr_assert_eq(topic_data->durability_service.history_depth, g_pol_durability_service.history_depth); - cr_assert_eq(topic_data->durability_service.max_samples, g_pol_durability_service.max_samples); - cr_assert_eq(topic_data->durability_service.max_instances, g_pol_durability_service.max_instances); - cr_assert_eq(topic_data->durability_service.max_samples_per_instance, g_pol_durability_service.max_samples_per_instance); - cr_assert_eq(topic_data->deadline.period.sec, g_pol_deadline.period.sec); - cr_assert_eq(topic_data->deadline.period.nanosec, g_pol_deadline.period.nanosec); - cr_assert_eq(topic_data->latency_budget.duration.sec, g_pol_latency_budget.duration.sec); - cr_assert_eq(topic_data->latency_budget.duration.nanosec, g_pol_latency_budget.duration.nanosec); - cr_assert_eq(topic_data->liveliness.kind, g_pol_liveliness.kind); - cr_assert_eq(topic_data->liveliness.lease_duration.sec, g_pol_liveliness.lease_duration.sec); - cr_assert_eq(topic_data->liveliness.lease_duration.nanosec, g_pol_liveliness.lease_duration.nanosec); - cr_assert_eq(topic_data->reliability.kind, g_pol_reliability.kind); - cr_assert_eq(topic_data->reliability.max_blocking_time.sec, g_pol_reliability.max_blocking_time.sec); - cr_assert_eq(topic_data->reliability.max_blocking_time.nanosec, g_pol_reliability.max_blocking_time.nanosec); - cr_assert_eq(topic_data->transport_priority.value, g_pol_transport_priority.value); - cr_assert_eq(topic_data->lifespan.duration.sec, g_pol_lifespan.duration.sec); - cr_assert_eq(topic_data->lifespan.duration.nanosec, g_pol_lifespan.duration.nanosec); - cr_assert_eq(topic_data->destination_order.kind, g_pol_destination_order.kind); - cr_assert_eq(topic_data->history.kind, g_pol_history.kind); - cr_assert_eq(topic_data->history.depth, g_pol_history.depth); - cr_assert_eq(topic_data->resource_limits.max_samples, g_pol_resource_limits.max_samples); - cr_assert_eq(topic_data->resource_limits.max_instances, g_pol_resource_limits.max_instances); - cr_assert_eq(topic_data->resource_limits.max_samples_per_instance, g_pol_resource_limits.max_samples_per_instance); - cr_assert_eq(topic_data->ownership.kind, g_pol_ownership.kind); - cr_assert_str_eq(topic_data->topic_data.value._buffer, g_pol_topicdata.value._buffer); - cr_assert_eq(topic_data->topic_data.value._length, g_pol_topicdata.value._length); + CU_ASSERT_STRING_EQUAL_FATAL(topic_data->name, "SpaceType1"); + CU_ASSERT_STRING_EQUAL_FATAL(topic_data->type_name, "RoundTripModule::DataType"); + CU_ASSERT_EQUAL_FATAL(topic_data->durability.kind, g_pol_durability.kind); + CU_ASSERT_EQUAL_FATAL(topic_data->durability_service.service_cleanup_delay.sec, g_pol_durability_service.service_cleanup_delay.sec); + CU_ASSERT_EQUAL(topic_data->durability_service.service_cleanup_delay.nanosec, g_pol_durability_service.service_cleanup_delay.nanosec); + CU_ASSERT_EQUAL_FATAL(topic_data->durability_service.history_kind, g_pol_durability_service.history_kind); + CU_ASSERT_EQUAL_FATAL(topic_data->durability_service.history_depth, g_pol_durability_service.history_depth); + CU_ASSERT_EQUAL_FATAL(topic_data->durability_service.max_samples, g_pol_durability_service.max_samples); + CU_ASSERT_EQUAL_FATAL(topic_data->durability_service.max_instances, g_pol_durability_service.max_instances); + CU_ASSERT_EQUAL_FATAL(topic_data->durability_service.max_samples_per_instance, g_pol_durability_service.max_samples_per_instance); + CU_ASSERT_EQUAL_FATAL(topic_data->deadline.period.sec, g_pol_deadline.period.sec); + CU_ASSERT_EQUAL_FATAL(topic_data->deadline.period.nanosec, g_pol_deadline.period.nanosec); + CU_ASSERT_EQUAL_FATAL(topic_data->latency_budget.duration.sec, g_pol_latency_budget.duration.sec); + CU_ASSERT_EQUAL_FATAL(topic_data->latency_budget.duration.nanosec, g_pol_latency_budget.duration.nanosec); + CU_ASSERT_EQUAL_FATAL(topic_data->liveliness.kind, g_pol_liveliness.kind); + CU_ASSERT_EQUAL_FATAL(topic_data->liveliness.lease_duration.sec, g_pol_liveliness.lease_duration.sec); + CU_ASSERT_EQUAL_FATAL(topic_data->liveliness.lease_duration.nanosec, g_pol_liveliness.lease_duration.nanosec); + CU_ASSERT_EQUAL_FATAL(topic_data->reliability.kind, g_pol_reliability.kind); + CU_ASSERT_EQUAL_FATAL(topic_data->reliability.max_blocking_time.sec, g_pol_reliability.max_blocking_time.sec); + CU_ASSERT_EQUAL_FATAL(topic_data->reliability.max_blocking_time.nanosec, g_pol_reliability.max_blocking_time.nanosec); + CU_ASSERT_EQUAL_FATAL(topic_data->transport_priority.value, g_pol_transport_priority.value); + CU_ASSERT_EQUAL_FATAL(topic_data->lifespan.duration.sec, g_pol_lifespan.duration.sec); + CU_ASSERT_EQUAL_FATAL(topic_data->lifespan.duration.nanosec, g_pol_lifespan.duration.nanosec); + CU_ASSERT_EQUAL_FATAL(topic_data->destination_order.kind, g_pol_destination_order.kind); + CU_ASSERT_EQUAL_FATAL(topic_data->history.kind, g_pol_history.kind); + CU_ASSERT_EQUAL_FATAL(topic_data->history.depth, g_pol_history.depth); + CU_ASSERT_EQUAL_FATAL(topic_data->resource_limits.max_samples, g_pol_resource_limits.max_samples); + CU_ASSERT_EQUAL_FATAL(topic_data->resource_limits.max_instances, g_pol_resource_limits.max_instances); + CU_ASSERT_EQUAL_FATAL(topic_data->resource_limits.max_samples_per_instance, g_pol_resource_limits.max_samples_per_instance); + CU_ASSERT_EQUAL_FATAL(topic_data->ownership.kind, g_pol_ownership.kind); + CU_ASSERT_STRING_EQUAL_FATAL(topic_data->topic_data.value._buffer, g_pol_topicdata.value._buffer); + CU_ASSERT_EQUAL_FATAL(topic_data->topic_data.value._length, g_pol_topicdata.value._length); #endif DDS_TopicBuiltinTopicData_free(topic_samples[0], DDS_FREE_ALL); } diff --git a/src/core/ddsc/tests/config.c b/src/core/ddsc/tests/config.c index 30bb2d7..92e3a4f 100644 --- a/src/core/ddsc/tests/config.c +++ b/src/core/ddsc/tests/config.c @@ -10,8 +10,7 @@ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ #include "ddsc/dds.h" -#include -#include +#include "CUnit/Test.h" #include "os/os.h" #include "config_env.h" #include "ddsc/ddsc_project.h" @@ -26,18 +25,18 @@ static void config__check_env( _In_z_ const char * expected_value) { const char * env_uri = os_getenv(env_variable); +#if 0 const char * const env_not_set = "Environment variable '%s' isn't set. This needs to be set to '%s' for this test to run."; const char * const env_not_as_expected = "Environment variable '%s' has an unexpected value: '%s' (expected: '%s')"; +#endif #ifdef FORCE_ENV { bool env_ok; if ( env_uri == NULL ) { - cr_log_info(env_not_set, env_variable, expected_value); env_ok = false; } else if ( strncmp(env_uri, expected_value, strlen(expected_value)) != 0 ) { - cr_log_info(env_not_as_expected, env_variable, env_uri, expected_value); env_ok = false; } else { env_ok = true; @@ -51,20 +50,19 @@ static void config__check_env( (void) sprintf(envstr, "%s=%s", env_variable, expected_value); r = os_putenv(envstr); - cr_assert_eq(r, os_resultSuccess, "Invoking os_putenv(\"%s\") failed", envstr); - cr_log_warn("Environment variable '%s' set to expected value '%s'", env_variable, expected_value); + CU_ASSERT_EQUAL_FATAL(r, os_resultSuccess); os_free(envstr); } } #else - cr_assert_not_null(env_uri, env_not_set, env_variable, expected_value); - cr_assert_str_eq(env_uri, expected_value, env_not_as_expected, env_variable, env_uri, expected_value); + CU_ASSERT_PTR_NOT_NULL_FATAL(env_uri); + CU_ASSERT_STRING_EQUAL_FATAL(env_uri, expected_value); #endif /* FORCE_ENV */ } -Test(ddsc_config, simple_udp, .init = os_osInit, .fini = os_osExit) { +CU_Test(ddsc_config, simple_udp, .init = os_osInit, .fini = os_osExit) { dds_entity_t participant; @@ -73,7 +71,7 @@ Test(ddsc_config, simple_udp, .init = os_osInit, .fini = os_osExit) { participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "dds_create_participant"); + CU_ASSERT_FATAL(participant> 0); dds_delete(participant); } diff --git a/src/core/ddsc/tests/config_env.h.in b/src/core/ddsc/tests/config_env.h.in index 30a5439..5d984d6 100644 --- a/src/core/ddsc/tests/config_env.h.in +++ b/src/core/ddsc/tests/config_env.h.in @@ -12,7 +12,7 @@ #ifndef CONFIG_ENV_H #define CONFIG_ENV_H -#define CONFIG_ENV_SIMPLE_UDP "@Criterion_ddsc_config_simple_udp_uri@" -#define CONFIG_ENV_MAX_PARTICIPANTS "@Criterion_ddsc_config_simple_udp_max_participants@" +#define CONFIG_ENV_SIMPLE_UDP "@CUnit_ddsc_config_simple_udp_uri@" +#define CONFIG_ENV_MAX_PARTICIPANTS "@CUnit_ddsc_config_simple_udp_max_participants@" #endif /* CONFIG_ENV_H */ diff --git a/src/core/ddsc/tests/dispose.c b/src/core/ddsc/tests/dispose.c index 7f80a24..343232a 100644 --- a/src/core/ddsc/tests/dispose.c +++ b/src/core/ddsc/tests/dispose.c @@ -11,21 +11,10 @@ */ #include "ddsc/dds.h" #include "os/os.h" -#include -#include -#include +#include "CUnit/Test.h" +#include "CUnit/Theory.h" #include "Space.h" -/* Add --verbose command line argument to get the cr_log_info traces (if there are any). */ - -#if 0 -#define PRINT_SAMPLE(info, sample) cr_log_info("%s (%d, %d, %d)\n", info, sample.long_1, sample.long_2, sample.long_3); -#else -#define PRINT_SAMPLE(info, sample) -#endif - - - /************************************************************************************************** * * Test fixtures @@ -71,55 +60,54 @@ disposing_init(void) dds_qset_destination_order(qos, DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP); g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0); g_waitset = dds_create_waitset(g_participant); - cr_assert_gt(g_waitset, 0, "Failed to create g_waitset"); + CU_ASSERT_FATAL(g_waitset > 0); g_topic = dds_create_topic(g_participant, &Space_Type1_desc, create_topic_name("ddsc_disposing_test", name, sizeof name), qos, NULL); - cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic"); + CU_ASSERT_FATAL(g_topic > 0); /* Create a reader that keeps one sample on three instances. */ dds_qset_reliability(qos, DDS_RELIABILITY_RELIABLE, DDS_MSECS(100)); dds_qset_resource_limits(qos, DDS_LENGTH_UNLIMITED, 3, 1); g_reader = dds_create_reader(g_participant, g_topic, qos, NULL); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite g_reader"); + CU_ASSERT_FATAL(g_reader > 0); /* Create a writer that will not automatically dispose unregistered samples. */ dds_qset_writer_data_lifecycle(qos, false); g_writer = dds_create_writer(g_participant, g_topic, qos, NULL); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer"); + CU_ASSERT_FATAL(g_writer > 0 ); /* Sync g_writer to g_reader. */ ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_writer status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_writer, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_writer r"); - cr_assert_eq(g_writer, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_writer a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_writer, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Sync g_reader to g_writer. */ ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_reader r"); - cr_assert_eq(g_reader, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_reader a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_reader, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Write initial samples. */ for (int i = 0; i < INITIAL_SAMPLES; i++) { sample.long_1 = i; sample.long_2 = i*2; sample.long_3 = i*3; - PRINT_SAMPLE("INIT: Write ", sample); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /* Initialize reading buffers. */ @@ -154,33 +142,33 @@ disposing_fini(void) * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_writedispose, deleted, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_writedispose, deleted, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; dds_delete(g_writer); OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose(g_writer, NULL); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_writedispose, null, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_writedispose, null, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose(g_writer, NULL); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_writedispose, invalid_writers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_writedispose, invalid_writers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_writedispose, invalid_writers, .init=disposing_init, .fini=disposing_fini) +CU_Theory((dds_entity_t writer), ddsc_writedispose, invalid_writers, .init=disposing_init, .fini=disposing_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; @@ -188,117 +176,117 @@ Theory((dds_entity_t writer), ddsc_writedispose, invalid_writers, .init=disposin OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose(writer, NULL); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_writedispose, non_writers) = { - DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_writedispose, non_writers) = { + CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), }; -Theory((dds_entity_t *writer), ddsc_writedispose, non_writers, .init=disposing_init, .fini=disposing_fini) +CU_Theory((dds_entity_t *writer), ddsc_writedispose, non_writers, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose(*writer, NULL); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_writedispose, disposing_old_instance, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_writedispose, disposing_old_instance, .init=disposing_init, .fini=disposing_fini) { Space_Type1 oldInstance = { 0, 22, 22 }; dds_return_t ret; ret = dds_writedispose(g_writer, &oldInstance); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all samples that matches filter. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 == 0) { /* Check data. */ - cr_assert_eq(sample->long_2, 22); - cr_assert_eq(sample->long_3, 22); + CU_ASSERT_EQUAL_FATAL(sample->long_2, 22); + CU_ASSERT_EQUAL_FATAL(sample->long_3, 22); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); } else if (sample->long_1 == 1) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_writedispose, disposing_new_instance, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_writedispose, disposing_new_instance, .init=disposing_init, .fini=disposing_fini) { Space_Type1 newInstance = { INITIAL_SAMPLES, 42, 42 }; dds_return_t ret; ret = dds_writedispose(g_writer, &newInstance); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing new instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all samples that matches filter. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 3, "# read %d, expected %d", ret, 3); + CU_ASSERT_EQUAL_FATAL(ret, 3 ); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 < INITIAL_SAMPLES) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else if (sample->long_1 == INITIAL_SAMPLES) { /* Check data. */ - cr_assert_eq(sample->long_2, 42); - cr_assert_eq(sample->long_3, 42); + CU_ASSERT_EQUAL_FATAL(sample->long_2, 42); + CU_ASSERT_EQUAL_FATAL(sample->long_3, 42); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_writedispose, timeout, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_writedispose, timeout, .init=disposing_init, .fini=disposing_fini) { Space_Type1 newInstance1 = { INITIAL_SAMPLES , 22, 22 }; Space_Type1 newInstance2 = { INITIAL_SAMPLES+1, 42, 42 }; dds_return_t ret; ret = dds_writedispose(g_writer, &newInstance1); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing new instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_writedispose(g_writer, &newInstance2); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_TIMEOUT, "Disposing new instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_TIMEOUT); } /*************************************************************************************************/ @@ -311,47 +299,47 @@ Test(ddsc_writedispose, timeout, .init=disposing_init, .fini=disposing_fini) * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_writedispose_ts, deleted, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_writedispose_ts, deleted, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; dds_delete(g_writer); OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose_ts(g_writer, NULL, g_present); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_writedispose_ts, null, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_writedispose_ts, null, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose_ts(g_writer, NULL, g_present); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_writedispose_ts, timeout, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_writedispose_ts, timeout, .init=disposing_init, .fini=disposing_fini) { Space_Type1 newInstance1 = { INITIAL_SAMPLES , 22, 22 }; Space_Type1 newInstance2 = { INITIAL_SAMPLES+1, 42, 42 }; dds_return_t ret; ret = dds_writedispose_ts(g_writer, &newInstance1, g_present); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing new instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_writedispose_ts(g_writer, &newInstance2, g_present); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_TIMEOUT, "Disposing new instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_TIMEOUT); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_writedispose_ts, invalid_writers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_writedispose_ts, invalid_writers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_writedispose_ts, invalid_writers, .init=disposing_init, .fini=disposing_fini) +CU_Theory((dds_entity_t writer), ddsc_writedispose_ts, invalid_writers, .init=disposing_init, .fini=disposing_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; @@ -359,143 +347,143 @@ Theory((dds_entity_t writer), ddsc_writedispose_ts, invalid_writers, .init=dispo OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose_ts(writer, NULL, g_present); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_writedispose_ts, non_writers) = { - DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_writedispose_ts, non_writers) = { + CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), }; -Theory((dds_entity_t *writer), ddsc_writedispose_ts, non_writers, .init=disposing_init, .fini=disposing_fini) +CU_Theory((dds_entity_t *writer), ddsc_writedispose_ts, non_writers, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_writedispose_ts(*writer, NULL, g_present); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_writedispose_ts, disposing_old_instance, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_writedispose_ts, disposing_old_instance, .init=disposing_init, .fini=disposing_fini) { Space_Type1 oldInstance = { 0, 22, 22 }; dds_return_t ret; ret = dds_writedispose_ts(g_writer, &oldInstance, g_present); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 == 0) { /* Check data. */ - cr_assert_eq(sample->long_2, 22); - cr_assert_eq(sample->long_3, 22); + CU_ASSERT_EQUAL_FATAL(sample->long_2, 22); + CU_ASSERT_EQUAL_FATAL(sample->long_3, 22); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); } else if (sample->long_1 == 1) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_writedispose_ts, disposing_new_instance, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_writedispose_ts, disposing_new_instance, .init=disposing_init, .fini=disposing_fini) { Space_Type1 newInstance = { INITIAL_SAMPLES, 42, 42 }; dds_return_t ret; ret = dds_writedispose_ts(g_writer, &newInstance, g_present); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing new instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 3, "# read %d, expected %d", ret, 3); + CU_ASSERT_EQUAL_FATAL(ret, 3); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 < INITIAL_SAMPLES) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else if (sample->long_1 == INITIAL_SAMPLES) { /* Check data. */ - cr_assert_eq(sample->long_2, 42); - cr_assert_eq(sample->long_3, 42); + CU_ASSERT_EQUAL_FATAL(sample->long_2, 42); + CU_ASSERT_EQUAL_FATAL(sample->long_3, 42); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_writedispose_ts, disposing_past_sample, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_writedispose_ts, disposing_past_sample, .init=disposing_init, .fini=disposing_fini) { Space_Type1 oldInstance = { 0, 0, 0 }; dds_return_t ret; /* Disposing a sample in the past should trigger a lost sample. */ ret = dds_set_enabled_status(g_reader, DDS_SAMPLE_LOST_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Now, dispose a sample in the past. */ ret = dds_writedispose_ts(g_writer, &oldInstance, g_past); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Wait for 'sample lost'. */ ret = dds_waitset_wait(g_waitset, NULL, 0, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Disposing past sample did not trigger 'sample lost'"); + CU_ASSERT_EQUAL_FATAL(ret, 1); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 < INITIAL_SAMPLES) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } @@ -511,47 +499,47 @@ Test(ddsc_writedispose_ts, disposing_past_sample, .init=disposing_init, .fini=di * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose, deleted, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose, deleted, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; dds_delete(g_writer); OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose(g_writer, NULL); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose, null, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose, null, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose(g_writer, NULL); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose, timeout, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose, timeout, .init=disposing_init, .fini=disposing_fini) { Space_Type1 newInstance1 = { INITIAL_SAMPLES , 22, 22 }; Space_Type1 newInstance2 = { INITIAL_SAMPLES+1, 42, 42 }; dds_return_t ret; ret = dds_dispose(g_writer, &newInstance1); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing new instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_dispose(g_writer, &newInstance2); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_TIMEOUT, "Disposing new instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_TIMEOUT); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_dispose, invalid_writers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_dispose, invalid_writers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_dispose, invalid_writers, .init=disposing_init, .fini=disposing_fini) +CU_Theory((dds_entity_t writer), ddsc_dispose, invalid_writers, .init=disposing_init, .fini=disposing_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; @@ -559,99 +547,99 @@ Theory((dds_entity_t writer), ddsc_dispose, invalid_writers, .init=disposing_ini OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose(writer, NULL); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_dispose, non_writers) = { - DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_dispose, non_writers) = { + CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), }; -Theory((dds_entity_t *writer), ddsc_dispose, non_writers, .init=disposing_init, .fini=disposing_fini) +CU_Theory((dds_entity_t *writer), ddsc_dispose, non_writers, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose(*writer, NULL); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose, disposing_old_instance, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose, disposing_old_instance, .init=disposing_init, .fini=disposing_fini) { Space_Type1 oldInstance = { 0, 22, 22 }; dds_return_t ret; ret = dds_dispose(g_writer, &oldInstance); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 == 0) { /* Check data. */ - cr_assert_eq(sample->long_2, 0); - cr_assert_eq(sample->long_3, 0); + CU_ASSERT_EQUAL_FATAL(sample->long_2, 0); + CU_ASSERT_EQUAL_FATAL(sample->long_3, 0); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); } else if (sample->long_1 == 1) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose, disposing_new_instance, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose, disposing_new_instance, .init=disposing_init, .fini=disposing_fini) { Space_Type1 newInstance = { INITIAL_SAMPLES, 42, 42 }; dds_return_t ret; ret = dds_dispose(g_writer, &newInstance); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing new instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 3, "# read %d, expected %d", ret, 3); + CU_ASSERT_EQUAL_FATAL(ret, 3); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 < INITIAL_SAMPLES) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else if (sample->long_1 == INITIAL_SAMPLES) { /* Don't check data; it's not valid. */ /* Check states. */ - cr_assert_eq(g_info[i].valid_data, false); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, false); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } } @@ -666,47 +654,47 @@ Test(ddsc_dispose, disposing_new_instance, .init=disposing_init, .fini=disposing * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose_ts, deleted, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose_ts, deleted, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; dds_delete(g_writer); OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose_ts(g_writer, NULL, g_present); OS_WARNING_MSVC_ON(6387); /* Disable SAL warning on intentional misuse of the API */ - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose_ts, null, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose_ts, null, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose_ts(g_writer, NULL, g_present); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose_ts, timeout, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose_ts, timeout, .init=disposing_init, .fini=disposing_fini) { Space_Type1 newInstance1 = { INITIAL_SAMPLES , 22, 22 }; Space_Type1 newInstance2 = { INITIAL_SAMPLES+1, 42, 42 }; dds_return_t ret; ret = dds_dispose_ts(g_writer, &newInstance1, g_present); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing new instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_dispose_ts(g_writer, &newInstance2, g_present); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_TIMEOUT, "Disposing new instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_TIMEOUT); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_dispose_ts, invalid_writers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_dispose_ts, invalid_writers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_dispose_ts, invalid_writers, .init=disposing_init, .fini=disposing_fini) +CU_Theory((dds_entity_t writer), ddsc_dispose_ts, invalid_writers, .init=disposing_init, .fini=disposing_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; @@ -714,141 +702,141 @@ Theory((dds_entity_t writer), ddsc_dispose_ts, invalid_writers, .init=disposing_ OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose_ts(writer, NULL, g_present); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_dispose_ts, non_writers) = { - DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_dispose_ts, non_writers) = { + CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), }; -Theory((dds_entity_t *writer), ddsc_dispose_ts, non_writers, .init=disposing_init, .fini=disposing_fini) +CU_Theory((dds_entity_t *writer), ddsc_dispose_ts, non_writers, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_dispose_ts(*writer, NULL, g_present); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose_ts, disposing_old_instance, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose_ts, disposing_old_instance, .init=disposing_init, .fini=disposing_fini) { Space_Type1 oldInstance = { 0, 22, 22 }; dds_return_t ret; ret = dds_dispose_ts(g_writer, &oldInstance, g_present); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 == 0) { /* Check data (data part of dispose is not used, only the key part). */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); } else if (sample->long_1 == 1) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose_ts, disposing_new_instance, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose_ts, disposing_new_instance, .init=disposing_init, .fini=disposing_fini) { Space_Type1 newInstance = { INITIAL_SAMPLES, 42, 42 }; dds_return_t ret; ret = dds_dispose_ts(g_writer, &newInstance, g_present); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing new instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 3, "# read %d, expected %d", ret, 3); + CU_ASSERT_EQUAL_FATAL(ret, 3); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 < INITIAL_SAMPLES) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else if (sample->long_1 == INITIAL_SAMPLES) { /* Don't check data; it's not valid. */ /* Check states. */ - cr_assert_eq(g_info[i].valid_data, false); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, false); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose_ts, disposing_past_sample, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose_ts, disposing_past_sample, .init=disposing_init, .fini=disposing_fini) { Space_Type1 oldInstance = { 0, 0, 0 }; dds_return_t ret; /* Disposing a sample in the past should trigger a lost sample. */ ret = dds_set_enabled_status(g_reader, DDS_SAMPLE_LOST_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Now, dispose a sample in the past. */ ret = dds_dispose_ts(g_writer, &oldInstance, g_past); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Wait for 'sample lost'. */ ret = dds_waitset_wait(g_waitset, NULL, 0, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Disposing past sample did not trigger 'sample lost'"); + CU_ASSERT_EQUAL_FATAL(ret, 1); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if ((sample->long_1 == 0) || (sample->long_1 == 1)) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } @@ -864,90 +852,90 @@ Test(ddsc_dispose_ts, disposing_past_sample, .init=disposing_init, .fini=disposi * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose_ih, deleted, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose_ih, deleted, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; dds_delete(g_writer); ret = dds_dispose_ih(g_writer, DDS_HANDLE_NIL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_dispose_ih, invalid_handles) = { - DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), +CU_TheoryDataPoints(ddsc_dispose_ih, invalid_handles) = { + CU_DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), }; -Theory((dds_instance_handle_t handle), ddsc_dispose_ih, invalid_handles, .init=disposing_init, .fini=disposing_fini) +CU_Theory((dds_instance_handle_t handle), ddsc_dispose_ih, invalid_handles, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; ret = dds_dispose_ih(g_writer, handle); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_dispose_ih, invalid_writers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_dispose_ih, invalid_writers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_dispose_ih, invalid_writers, .init=disposing_init, .fini=disposing_fini) +CU_Theory((dds_entity_t writer), ddsc_dispose_ih, invalid_writers, .init=disposing_init, .fini=disposing_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_dispose_ih(writer, DDS_HANDLE_NIL); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_dispose_ih, non_writers) = { - DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_dispose_ih, non_writers) = { + CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), }; -Theory((dds_entity_t *writer), ddsc_dispose_ih, non_writers, .init=disposing_init, .fini=disposing_fini) +CU_Theory((dds_entity_t *writer), ddsc_dispose_ih, non_writers, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; ret = dds_dispose_ih(*writer, DDS_HANDLE_NIL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose_ih, disposing_old_instance, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose_ih, disposing_old_instance, .init=disposing_init, .fini=disposing_fini) { Space_Type1 oldInstance = { 0, 22, 22 }; dds_instance_handle_t hdl = dds_instance_lookup(g_writer, &oldInstance); dds_return_t ret; ret = dds_dispose_ih(g_writer, hdl); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 == 0) { /* Check data. */ - cr_assert_eq(sample->long_2, 0); - cr_assert_eq(sample->long_3, 0); + CU_ASSERT_EQUAL_FATAL(sample->long_2, 0); + CU_ASSERT_EQUAL_FATAL(sample->long_3, 0); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); } else if (sample->long_1 == 1) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } } @@ -962,97 +950,97 @@ Test(ddsc_dispose_ih, disposing_old_instance, .init=disposing_init, .fini=dispos * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose_ih_ts, deleted, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose_ih_ts, deleted, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; dds_delete(g_writer); ret = dds_dispose_ih_ts(g_writer, DDS_HANDLE_NIL, g_present); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_dispose_ih_ts, invalid_handles) = { - DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), +CU_TheoryDataPoints(ddsc_dispose_ih_ts, invalid_handles) = { + CU_DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), }; -Theory((dds_instance_handle_t handle), ddsc_dispose_ih_ts, invalid_handles, .init=disposing_init, .fini=disposing_fini) +CU_Theory((dds_instance_handle_t handle), ddsc_dispose_ih_ts, invalid_handles, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; ret = dds_dispose_ih_ts(g_writer, handle, g_present); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_dispose_ih_ts, invalid_writers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_dispose_ih_ts, invalid_writers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_dispose_ih_ts, invalid_writers, .init=disposing_init, .fini=disposing_fini) +CU_Theory((dds_entity_t writer), ddsc_dispose_ih_ts, invalid_writers, .init=disposing_init, .fini=disposing_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_dispose_ih_ts(writer, DDS_HANDLE_NIL, g_present); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_dispose_ih_ts, non_writers) = { - DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_dispose_ih_ts, non_writers) = { + CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), }; -Theory((dds_entity_t *writer), ddsc_dispose_ih_ts, non_writers, .init=disposing_init, .fini=disposing_fini) +CU_Theory((dds_entity_t *writer), ddsc_dispose_ih_ts, non_writers, .init=disposing_init, .fini=disposing_fini) { dds_return_t ret; ret = dds_dispose_ih_ts(*writer, DDS_HANDLE_NIL, g_present); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose_ih_ts, disposing_old_instance, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose_ih_ts, disposing_old_instance, .init=disposing_init, .fini=disposing_fini) { Space_Type1 oldInstance = { 0, 22, 22 }; dds_instance_handle_t hdl = dds_instance_lookup(g_writer, &oldInstance); dds_return_t ret; ret = dds_dispose_ih_ts(g_writer, hdl, g_present); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 == 0) { /* Check data (data part of dispose is not used, only the key part). */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_NOT_ALIVE_DISPOSED); } else if (sample->long_1 == 1) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_dispose_ih_ts, disposing_past_sample, .init=disposing_init, .fini=disposing_fini) +CU_Test(ddsc_dispose_ih_ts, disposing_past_sample, .init=disposing_init, .fini=disposing_fini) { Space_Type1 oldInstance = { 0, 0, 0 }; dds_instance_handle_t hdl = dds_instance_lookup(g_writer, &oldInstance); @@ -1060,35 +1048,35 @@ Test(ddsc_dispose_ih_ts, disposing_past_sample, .init=disposing_init, .fini=disp /* Disposing a sample in the past should trigger a lost sample. */ ret = dds_set_enabled_status(g_reader, DDS_SAMPLE_LOST_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Now, dispose a sample in the past. */ ret = dds_dispose_ih_ts(g_writer, hdl, g_past); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Wait for 'sample lost'. */ ret = dds_waitset_wait(g_waitset, NULL, 0, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Disposing past sample did not trigger 'sample lost'"); + CU_ASSERT_EQUAL_FATAL(ret, 1); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if ((sample->long_1 == 0) || (sample->long_1 == 1)) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } diff --git a/src/core/ddsc/tests/entity_api.c b/src/core/ddsc/tests/entity_api.c index f0d826a..3edf263 100644 --- a/src/core/ddsc/tests/entity_api.c +++ b/src/core/ddsc/tests/entity_api.c @@ -10,8 +10,7 @@ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ #include "ddsc/dds.h" -#include -#include +#include "CUnit/Test.h" /* We are deliberately testing some bad arguments that SAL will complain about. * So, silence SAL regarding these issues. */ @@ -24,49 +23,49 @@ static dds_entity_t entity = -1; -#define cr_assert_status_eq(s1, s2, ...) cr_assert_eq(dds_err_nr(s1), s2, __VA_ARGS__) +#define cu_assert_status_eq(s1, s2) CU_ASSERT_FATAL(dds_err_nr(s1)== s2) /* Fixture to create prerequisite entity */ void create_entity(void) { - cr_assert_eq(entity, -1, "entity already created pre create_entity fixture"); + CU_ASSERT_EQUAL_FATAL(entity, -1); entity = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(entity, 0, "create_entity fixture failed"); + CU_ASSERT_FATAL(entity > 0); } /* Fixture to delete prerequisite entity */ void delete_entity(void) { - cr_assert_gt(entity, 0, "entity not created pre delete_entity fixture"); + CU_ASSERT_FATAL(entity > 0); dds_return_t ret = dds_delete(entity); - cr_assert_status_eq(ret, DDS_RETCODE_OK, "delete_entity fixture failed (ret: %d)", dds_err_nr(ret)); + cu_assert_status_eq(ret, DDS_RETCODE_OK); entity = -1; } -Test(ddsc_entity, create, .fini = delete_entity) +CU_Test(ddsc_entity, create, .fini = delete_entity) { /* Use participant as entity in the tests. */ entity = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(entity, 0, "dds_create_participant"); + CU_ASSERT_FATAL(entity > 0 ); } -Test(ddsc_entity, enable, .init = create_entity, .fini = delete_entity) +CU_Test(ddsc_entity, enable, .init = create_entity, .fini = delete_entity) { dds_return_t status; /* Check enabling with bad parameters. */ status = dds_enable(0); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_enable (NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Check actual enabling. */ /* TODO: CHAM-96: Check enabling. status = dds_enable(&entity); - cr_assert_status_eq(status, dds_err_nr(DDS_RETCODE_OK), "dds_enable (delayed enable)"); + cu_assert_status_eq(status, dds_err_nr(DDS_RETCODE_OK), "dds_enable (delayed enable)"); */ /* Check re-enabling (should be a noop). */ status = dds_enable(entity); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_enable (already enabled)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); } void entity_qos_get_set(dds_entity_t e, const char* info) @@ -74,17 +73,19 @@ void entity_qos_get_set(dds_entity_t e, const char* info) dds_return_t status; dds_qos_t *qos = dds_create_qos(); + (void)info; + /* Get QoS. */ status = dds_get_qos (e, qos); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_qos(e, qos) ret: %d, %s", dds_err_nr(status), info); + cu_assert_status_eq(status, DDS_RETCODE_OK); status = dds_set_qos (e, qos); /* Doesn't change anything, so no need to forbid. But we return NOT_SUPPORTED anyway for now*/ - cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_set_qos(entity, qos) %s", info); + cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); dds_delete_qos(qos); } -Test(ddsc_entity, qos, .init = create_entity, .fini = delete_entity) +CU_Test(ddsc_entity, qos, .init = create_entity, .fini = delete_entity) { dds_return_t status; dds_qos_t *qos = dds_create_qos(); @@ -94,19 +95,19 @@ Test(ddsc_entity, qos, .init = create_entity, .fini = delete_entity) /* Check getting QoS with bad parameters. */ status = dds_get_qos (0, NULL); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_qos(NULL, NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_qos (entity, NULL); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_qos(entity, NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_qos (0, qos); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_qos(NULL, qos)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Check setting QoS with bad parameters. */ status = dds_set_qos (0, NULL); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_set_qos(NULL, NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_set_qos (entity, NULL); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_set_qos(entity, NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_set_qos (0, qos); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_set_qos(NULL, qos)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Check set/get with entity without initial qos. */ entity_qos_get_set(entity, "{without initial qos}"); @@ -122,7 +123,7 @@ Test(ddsc_entity, qos, .init = create_entity, .fini = delete_entity) dds_delete_qos(qos); } -Test(ddsc_entity, listener, .init = create_entity, .fini = delete_entity) +CU_Test(ddsc_entity, listener, .init = create_entity, .fini = delete_entity) { dds_return_t status; dds_listener_t *l1 = dds_create_listener(NULL); @@ -144,67 +145,67 @@ Test(ddsc_entity, listener, .init = create_entity, .fini = delete_entity) /* Check getting Listener with bad parameters. */ status = dds_get_listener (0, NULL); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_listener(NULL, NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_listener (entity, NULL); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_listener(entity, NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_listener (0, l1); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_listener(NULL, listener)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Get Listener, which should be unset. */ status = dds_get_listener (entity, l1); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_listener(entity, listener)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); dds_lget_liveliness_changed (l1, (dds_on_liveliness_changed_fn*)&cb1); - cr_assert_eq(cb1, DDS_LUNSET, "Listener not initialized to NULL"); + CU_ASSERT_EQUAL_FATAL(cb1, DDS_LUNSET); dds_lget_requested_deadline_missed (l1, (dds_on_requested_deadline_missed_fn*)&cb1); - cr_assert_eq(cb1, DDS_LUNSET, "Listener not initialized to NULL"); + CU_ASSERT_EQUAL_FATAL(cb1, DDS_LUNSET); dds_lget_requested_incompatible_qos (l1, (dds_on_requested_incompatible_qos_fn*)&cb1); - cr_assert_eq(cb1, DDS_LUNSET, "Listener not initialized to NULL"); + CU_ASSERT_EQUAL_FATAL(cb1, DDS_LUNSET); dds_lget_publication_matched (l1, (dds_on_publication_matched_fn*)&cb1); - cr_assert_eq(cb1, DDS_LUNSET, "Listener not initialized to NULL"); + CU_ASSERT_EQUAL_FATAL(cb1, DDS_LUNSET); /* Check setting Listener with bad parameters. */ status = dds_set_listener (0, NULL); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_set_listener(NULL, NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_set_listener (0, l2); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_set_listener(NULL, listener)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Getting after setting should return set listener. */ status = dds_set_listener (entity, l2); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_set_listener(entity, listener)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); status = dds_get_listener (entity, l1); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_listener(entity, listener)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); dds_lget_liveliness_changed (l1, (dds_on_liveliness_changed_fn*)&cb1); dds_lget_liveliness_changed (l2, (dds_on_liveliness_changed_fn*)&cb2); - cr_assert_eq(cb1, cb2, "Listeners are not equal"); + CU_ASSERT_EQUAL_FATAL(cb1, cb2); dds_lget_requested_deadline_missed (l1, (dds_on_requested_deadline_missed_fn*)&cb1); dds_lget_requested_deadline_missed (l2, (dds_on_requested_deadline_missed_fn*)&cb2); - cr_assert_eq(cb1, cb2, "Listeners are not equal"); + CU_ASSERT_EQUAL_FATAL(cb1, cb2); dds_lget_requested_incompatible_qos (l1, (dds_on_requested_incompatible_qos_fn*)&cb1); dds_lget_requested_incompatible_qos (l2, (dds_on_requested_incompatible_qos_fn*)&cb2); - cr_assert_eq(cb1, cb2, "Listeners are not equal"); + CU_ASSERT_EQUAL_FATAL(cb1, cb2); dds_lget_publication_matched (l1, (dds_on_publication_matched_fn*)&cb1); dds_lget_publication_matched (l2, (dds_on_publication_matched_fn*)&cb2); - cr_assert_eq(cb1, cb2, "Listeners are not equal"); + CU_ASSERT_EQUAL_FATAL(cb1, cb2); /* Reset listener. */ status = dds_set_listener (entity, NULL); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_set_listener(entity, NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); status = dds_get_listener (entity, l2); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_listener(entity, listener)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); dds_lget_liveliness_changed (l2, (dds_on_liveliness_changed_fn*)&cb2); - cr_assert_eq(cb2, DDS_LUNSET, "Listener not reset"); + CU_ASSERT_EQUAL_FATAL(cb2, DDS_LUNSET); dds_lget_requested_deadline_missed (l2, (dds_on_requested_deadline_missed_fn*)&cb2); - cr_assert_eq(cb2, DDS_LUNSET, "Listener not reset"); + CU_ASSERT_EQUAL_FATAL(cb2, DDS_LUNSET); dds_lget_requested_incompatible_qos (l2, (dds_on_requested_incompatible_qos_fn*)&cb2); - cr_assert_eq(cb2, DDS_LUNSET, "Listener not reset"); + CU_ASSERT_EQUAL_FATAL(cb2, DDS_LUNSET); dds_lget_publication_matched (l2, (dds_on_publication_matched_fn*)&cb2); - cr_assert_eq(cb2, DDS_LUNSET, "Listener not reset"); + CU_ASSERT_EQUAL_FATAL(cb2, DDS_LUNSET); dds_free(l2); dds_free(l1); } -Test(ddsc_entity, status, .init = create_entity, .fini = delete_entity) +CU_Test(ddsc_entity, status, .init = create_entity, .fini = delete_entity) { dds_return_t status1; uint32_t s1 = 0; @@ -214,50 +215,50 @@ Test(ddsc_entity, status, .init = create_entity, .fini = delete_entity) /* Check getting Status with bad parameters. */ status1 = dds_get_enabled_status (0, NULL); - cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_get_enabled_status(NULL, NULL)"); + cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); status1 = dds_get_enabled_status (entity, NULL); - cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_get_enabled_status(entity, NULL)"); + cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); status1 = dds_get_enabled_status (0, &s1); - cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_get_enabled_status(NULL, status)"); + cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); /* Get Status, which should be 0 for a participant. */ status1 = dds_get_enabled_status (entity, &s1); - cr_assert_status_eq(status1, DDS_RETCODE_OK, "dds_get_enabled_status(entity, status)"); - cr_assert_eq(s1, 0, "Enabled status mask is not 0"); + cu_assert_status_eq(status1, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(s1, 0); /* Check setting Status with bad parameters. */ status1 = dds_set_enabled_status (0, 0); - cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_set_enabled_status(NULL, 0)"); + cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); /* I shouldn't be able to set statuses on a participant. */ status1 = dds_set_enabled_status (entity, 0); - cr_assert_status_eq(status1, DDS_RETCODE_OK, "dds_set_enabled_status(entity, 0) %d", dds_err_nr(status1)); + cu_assert_status_eq(status1, DDS_RETCODE_OK); status1 = dds_set_enabled_status (entity, DDS_DATA_AVAILABLE_STATUS); - cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_set_enabled_status(entity, status)"); + cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); /* Check getting Status changes with bad parameters. */ status1 = dds_get_status_changes (0, NULL); - cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_get_status_changes(NULL, NULL)"); + cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); status1 = dds_get_status_changes (entity, NULL); - cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_get_status_changes(entity, NULL)"); + cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); status1 = dds_get_status_changes (0, &s1); - cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_get_status_changes(NULL, status)"); + cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); status1 = dds_get_status_changes (entity, &s1); - cr_assert_status_eq(status1, DDS_RETCODE_OK, "dds_get_status_changes(entity, status)"); + cu_assert_status_eq(status1, DDS_RETCODE_OK); /* Status read and take shouldn't work either. */ status1 = dds_read_status (0, &s1, 0); - cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_read_status(NULL, status, 0)"); + cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); status1 = dds_read_status (entity, &s1, 0); - cr_assert_status_eq(status1, DDS_RETCODE_OK, "dds_read_status(entity, status, 0)"); + cu_assert_status_eq(status1, DDS_RETCODE_OK); status1 = dds_take_status (0, &s1, 0); - cr_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER, "dds_take_status(NULL, status, 0)"); + cu_assert_status_eq(status1, DDS_RETCODE_BAD_PARAMETER); status1 = dds_take_status (entity, &s1, 0); - cr_assert_status_eq(status1, DDS_RETCODE_OK, "dds_take_status(entity, status, 0)"); + cu_assert_status_eq(status1, DDS_RETCODE_OK); } -Test(ddsc_entity, instance_handle, .init = create_entity, .fini = delete_entity) +CU_Test(ddsc_entity, instance_handle, .init = create_entity, .fini = delete_entity) { dds_return_t status; dds_instance_handle_t hdl; @@ -267,19 +268,19 @@ Test(ddsc_entity, instance_handle, .init = create_entity, .fini = delete_entity) /* Check getting Handle with bad parameters. */ status = dds_get_instance_handle (0, NULL); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_instancehandle_get(NULL, NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_instance_handle (entity, NULL); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_instancehandle_get(entity, NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_instance_handle (0, &hdl); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_instancehandle_get(NULL, handle)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Get Instance Handle, which should not be 0 for a participant. */ status = dds_get_instance_handle (entity, &hdl); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_instancehandle_get(entity, handle)"); - cr_assert_neq(hdl, 0, "Entity instance handle is 0"); + cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_NOT_EQUAL_FATAL(hdl, 0); } -Test(ddsc_entity, get_entities, .init = create_entity, .fini = delete_entity) +CU_Test(ddsc_entity, get_entities, .init = create_entity, .fini = delete_entity) { dds_return_t status; dds_entity_t par; @@ -289,78 +290,78 @@ Test(ddsc_entity, get_entities, .init = create_entity, .fini = delete_entity) /* Check getting Parent with bad parameters. */ par = dds_get_parent (0); - cr_assert_eq(dds_err_nr(par), DDS_RETCODE_BAD_PARAMETER, "Parent was returned (despite of bad parameter)"); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(par), DDS_RETCODE_BAD_PARAMETER); /* Get Parent, a participant doesn't have a parent. */ par = dds_get_parent (entity); - cr_assert_eq(dds_err_nr(par), DDS_ENTITY_NIL, "Parent was returned (despite of it being a participant)"); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(par), DDS_ENTITY_NIL); /* ---------- Get Participant ------------ */ /* Check getting Participant with bad parameters. */ par = dds_get_participant (0); - cr_assert_eq(dds_err_nr(par), DDS_RETCODE_BAD_PARAMETER, "Participant was returned (despite of bad parameter)"); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(par), DDS_RETCODE_BAD_PARAMETER); /* Get Participant, a participants' participant is itself. */ par = dds_get_participant (entity); - cr_assert_eq(par, entity, "Returned participant was not expected"); + CU_ASSERT_EQUAL_FATAL(par, entity); /* ---------- Get Children ------------ */ /* Check getting Children with bad parameters. */ status = dds_get_children (0, &child, 1); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_children(NULL, child, 1)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_children (entity, NULL, 1); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_children(entity, NULL, 1)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_children (entity, &child, 0); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_children(entity, child, 0)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_children (0, NULL, 1); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_children(NULL, NULL, 1)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_children (0, &child, 0); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_children(NULL, child, 0)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Get Children, of which there are currently none. */ status = dds_get_children (entity, NULL, 0); if (status > 0) { - cr_assert(false, "dds_get_children(entity, NULL, 0) un-expectantly found children"); + CU_ASSERT_FATAL(false); } else { - cr_assert_eq(status, 0, "dds_get_children(entity, NULL, 0) failed"); + CU_ASSERT_EQUAL_FATAL(status, 0); } status = dds_get_children (entity, &child, 1); if (status > 0) { - cr_assert(false, "dds_get_children(entity, child, 1) un-expectantly returned children"); + CU_ASSERT_FATAL(false); } else { - cr_assert_eq(status, 0, "dds_get_children(entity, child, 1) failed"); + CU_ASSERT_EQUAL_FATAL(status, 0); } } -Test(ddsc_entity, get_domainid, .init = create_entity, .fini = delete_entity) +CU_Test(ddsc_entity, get_domainid, .init = create_entity, .fini = delete_entity) { dds_return_t status; dds_domainid_t id; /* Check getting ID with bad parameters. */ status = dds_get_domainid (0, NULL); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_domainid(NULL, NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_domainid (entity, NULL); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_domainid(entity, NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_get_domainid (0, &id); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_get_domainid(NULL, id)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Get and check the domain id. */ status = dds_get_domainid (entity, &id); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(entity, id)"); - cr_assert_eq(id, 0, "Different domain_id was returned than expected"); + cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(id, 0); } -Test(ddsc_entity, delete, .init = create_entity) +CU_Test(ddsc_entity, delete, .init = create_entity) { dds_return_t status; status = dds_delete(0); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_delete(NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); status = dds_delete(entity); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_delete(entity)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); entity = 0; } diff --git a/src/core/ddsc/tests/entity_hierarchy.c b/src/core/ddsc/tests/entity_hierarchy.c index 18cd46c..e3ab0cf 100644 --- a/src/core/ddsc/tests/entity_hierarchy.c +++ b/src/core/ddsc/tests/entity_hierarchy.c @@ -11,9 +11,8 @@ */ #include "ddsc/dds.h" #include "os/os.h" -#include -#include -#include +#include "CUnit/Test.h" +#include "CUnit/Theory.h" #include "RoundTrip.h" /* Add --verbose command line argument to get the cr_log_info traces (if there are any). */ @@ -61,28 +60,28 @@ hierarchy_init(void) char name[100]; g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0 ); g_topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, create_topic_name("ddsc_hierarchy_test", name, sizeof name), NULL, NULL); - cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic"); + CU_ASSERT_FATAL(g_topic > 0); g_publisher = dds_create_publisher(g_participant, NULL, NULL); - cr_assert_gt(g_publisher, 0, "Failed to create prerequisite g_publisher"); + CU_ASSERT_FATAL(g_publisher > 0 ); g_subscriber = dds_create_subscriber(g_participant, NULL, NULL); - cr_assert_gt(g_subscriber, 0, "Failed to create prerequisite g_subscriber"); + CU_ASSERT_FATAL(g_subscriber > 0 ); g_writer = dds_create_writer(g_publisher, g_topic, NULL, NULL); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer"); + CU_ASSERT_FATAL(g_writer > 0 ); g_reader = dds_create_reader(g_subscriber, g_topic, NULL, NULL); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite g_reader"); + CU_ASSERT_FATAL(g_reader > 0); g_readcond = dds_create_readcondition(g_reader, mask); - cr_assert_gt(g_readcond, 0, "Failed to create prerequisite g_readcond"); + CU_ASSERT_FATAL(g_readcond > 0); g_querycond = dds_create_querycondition(g_reader, mask, accept_all); - cr_assert_gt(g_querycond, 0, "Failed to create prerequisite g_querycond"); + CU_ASSERT_FATAL(g_querycond > 0); /* The deletion of the last participant will close down every thing. This * means that the API will react differently after that. Because the @@ -91,7 +90,7 @@ hierarchy_init(void) * participant, which will keep everything running. */ g_keep = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_keep, 0, "Failed to create prerequisite g_keep"); + CU_ASSERT_FATAL(g_keep > 0); } static void @@ -118,55 +117,55 @@ hierarchy_fini(void) * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_delete, recursive, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_delete, recursive, .init=hierarchy_init, .fini=hierarchy_fini) { dds_domainid_t id; dds_return_t ret; /* First be sure that 'dds_get_domainid' returns ok. */ ret = dds_get_domainid(g_participant, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); ret = dds_get_domainid(g_topic, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); ret = dds_get_domainid(g_publisher, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); ret = dds_get_domainid(g_subscriber, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); ret = dds_get_domainid(g_writer, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); ret = dds_get_domainid(g_reader, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); ret = dds_get_domainid(g_readcond, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); ret = dds_get_domainid(g_querycond, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); /* Deleting the top dog (participant) should delete all children. */ ret = dds_delete(g_participant); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); /* Check if all the entities are deleted now. */ ret = dds_get_domainid(g_participant, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); ret = dds_get_domainid(g_topic, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); ret = dds_get_domainid(g_publisher, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); ret = dds_get_domainid(g_subscriber, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); ret = dds_get_domainid(g_writer, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); ret = dds_get_domainid(g_reader, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); ret = dds_get_domainid(g_readcond, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); ret = dds_get_domainid(g_querycond, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_delete, recursive_with_deleted_topic) +CU_Test(ddsc_entity_delete, recursive_with_deleted_topic) { dds_domainid_t id; dds_return_t ret; @@ -178,34 +177,34 @@ Test(ddsc_entity_delete, recursive_with_deleted_topic) /* First, create a topic and a writer with that topic. */ g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0); g_topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, create_topic_name("ddsc_hierarchy_test", name, 100), NULL, NULL); - cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic"); + CU_ASSERT_FATAL(g_topic > 0); g_writer = dds_create_writer(g_participant, g_topic, NULL, NULL); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer"); + CU_ASSERT_FATAL(g_writer> 0); g_keep = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_keep, 0, "Failed to create prerequisite g_keep"); + CU_ASSERT_FATAL(g_keep > 0); /* Second, delete the topic to make sure that the writer holds the last * reference to the topic and thus will delete it when it itself is * deleted. */ ret = dds_delete(g_topic); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); /* Third, deleting the participant should delete all children of which * the writer with the last topic reference is one. */ ret = dds_delete(g_participant); /* Before the CHAM-424 fix, we would not get here because of a crash, * or it (incidentally) continued but returned an error. */ - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); /* Check if the entities are actually deleted. */ ret = dds_get_domainid(g_participant, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "%s", dds_err_str(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED ); ret = dds_get_domainid(g_topic, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); ret = dds_get_domainid(g_writer, &id); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); dds_delete(g_keep); } @@ -220,41 +219,41 @@ Test(ddsc_entity_delete, recursive_with_deleted_topic) * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_participant, valid_entities) = { - DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader, &g_subscriber, &g_writer, &g_publisher, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_entity_get_participant, valid_entities) = { + CU_DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader, &g_subscriber, &g_writer, &g_publisher, &g_topic, &g_participant), }; -Theory((dds_entity_t *entity), ddsc_entity_get_participant, valid_entities, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *entity), ddsc_entity_get_participant, valid_entities, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t participant; participant = dds_get_participant(*entity); - cr_assert_eq(participant, g_participant); + CU_ASSERT_EQUAL_FATAL(participant, g_participant); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_participant, deleted_entities) = { - DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader, &g_subscriber, &g_writer, &g_publisher, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_entity_get_participant, deleted_entities) = { + CU_DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader, &g_subscriber, &g_writer, &g_publisher, &g_topic, &g_participant), }; -Theory((dds_entity_t *entity), ddsc_entity_get_participant, deleted_entities, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *entity), ddsc_entity_get_participant, deleted_entities, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t participant; dds_delete(*entity); participant = dds_get_participant(*entity); - cr_assert_eq(dds_err_nr(participant), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(participant)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(participant), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_participant, invalid_entities) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_entity_get_participant, invalid_entities) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t entity), ddsc_entity_get_participant, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t entity), ddsc_entity_get_participant, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t participant; participant = dds_get_participant(entity); - cr_assert_eq(dds_err_nr(participant), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(participant), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(participant), dds_err_nr(exp)); } /*************************************************************************************************/ @@ -268,80 +267,80 @@ Theory((dds_entity_t entity), ddsc_entity_get_participant, invalid_entities, .in * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_parent, conditions) = { - DataPoints(dds_entity_t*, &g_readcond, &g_querycond), +CU_TheoryDataPoints(ddsc_entity_get_parent, conditions) = { + CU_DataPoints(dds_entity_t*, &g_readcond, &g_querycond), }; -Theory((dds_entity_t *entity), ddsc_entity_get_parent, conditions, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *entity), ddsc_entity_get_parent, conditions, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t parent; parent = dds_get_parent(*entity); - cr_assert_eq(parent, g_reader); + CU_ASSERT_EQUAL_FATAL(parent, g_reader); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_parent, reader, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_get_parent, reader, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t parent; parent = dds_get_parent(g_reader); - cr_assert_eq(parent, g_subscriber); + CU_ASSERT_EQUAL_FATAL(parent, g_subscriber); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_parent, writer, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_get_parent, writer, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t parent; parent = dds_get_parent(g_writer); - cr_assert_eq(parent, g_publisher); + CU_ASSERT_EQUAL_FATAL(parent, g_publisher); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_parent, pubsubtop) = { - DataPoints(dds_entity_t*, &g_publisher, &g_subscriber, &g_topic), +CU_TheoryDataPoints(ddsc_entity_get_parent, pubsubtop) = { + CU_DataPoints(dds_entity_t*, &g_publisher, &g_subscriber, &g_topic), }; -Theory((dds_entity_t *entity), ddsc_entity_get_parent, pubsubtop, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *entity), ddsc_entity_get_parent, pubsubtop, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t parent; parent = dds_get_parent(*entity); - cr_assert_eq(parent, g_participant); + CU_ASSERT_EQUAL_FATAL(parent, g_participant); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_parent, participant, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_get_parent, participant, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t parent; parent = dds_get_parent(g_participant); - cr_assert_eq(dds_err_nr(parent), DDS_ENTITY_NIL, "returned %d", dds_err_nr(parent)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(parent), DDS_ENTITY_NIL); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_parent, deleted_entities) = { - DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader, &g_subscriber, &g_writer, &g_publisher, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_entity_get_parent, deleted_entities) = { + CU_DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader, &g_subscriber, &g_writer, &g_publisher, &g_topic, &g_participant), }; -Theory((dds_entity_t *entity), ddsc_entity_get_parent, deleted_entities, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *entity), ddsc_entity_get_parent, deleted_entities, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t parent; dds_delete(*entity); parent = dds_get_parent(*entity); - cr_assert_eq(dds_err_nr(parent), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(parent), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_parent, invalid_entities) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_entity_get_parent, invalid_entities) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t entity), ddsc_entity_get_parent, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t entity), ddsc_entity_get_parent, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t parent; parent = dds_get_parent(entity); - cr_assert_eq(dds_err_nr(parent), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(parent), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(parent), dds_err_nr(exp)); } /*************************************************************************************************/ @@ -355,145 +354,145 @@ Theory((dds_entity_t entity), ddsc_entity_get_parent, invalid_entities, .init=hi * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_children, null, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_get_children, null, .init=hierarchy_init, .fini=hierarchy_fini) { dds_return_t ret; ret = dds_get_children(g_participant, NULL, 0); - cr_assert_eq(ret, 3); + CU_ASSERT_EQUAL_FATAL(ret, 3); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_children, invalid_size, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_get_children, invalid_size, .init=hierarchy_init, .fini=hierarchy_fini) { dds_return_t ret; dds_entity_t child; ret = dds_get_children(g_participant, &child, INT32_MAX); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_children, too_small, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_get_children, too_small, .init=hierarchy_init, .fini=hierarchy_fini) { dds_return_t ret; dds_entity_t children[2]; ret = dds_get_children(g_participant, children, 2); - cr_assert_eq(ret, 3); - cr_assert((children[0] == g_publisher) || (children[0] == g_subscriber) || (children[0] == g_topic)); - cr_assert((children[1] == g_publisher) || (children[1] == g_subscriber) || (children[1] == g_topic)); - cr_assert_neq(children[0], children[1]); + CU_ASSERT_EQUAL_FATAL(ret, 3); + CU_ASSERT_FATAL((children[0] == g_publisher) || (children[0] == g_subscriber) || (children[0] == g_topic)); + CU_ASSERT_FATAL((children[1] == g_publisher) || (children[1] == g_subscriber) || (children[1] == g_topic)); + CU_ASSERT_NOT_EQUAL_FATAL(children[0], children[1]); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_children, participant, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_get_children, participant, .init=hierarchy_init, .fini=hierarchy_fini) { dds_return_t ret; dds_entity_t children[4]; ret = dds_get_children(g_participant, children, 4); - cr_assert_eq(ret, 3); - cr_assert((children[0] == g_publisher) || (children[0] == g_subscriber) || (children[0] == g_topic)); - cr_assert((children[1] == g_publisher) || (children[1] == g_subscriber) || (children[1] == g_topic)); - cr_assert((children[2] == g_publisher) || (children[2] == g_subscriber) || (children[2] == g_topic)); - cr_assert_neq(children[0], children[1]); - cr_assert_neq(children[0], children[2]); - cr_assert_neq(children[1], children[2]); + CU_ASSERT_EQUAL_FATAL(ret, 3); + CU_ASSERT_FATAL((children[0] == g_publisher) || (children[0] == g_subscriber) || (children[0] == g_topic)); + CU_ASSERT_FATAL((children[1] == g_publisher) || (children[1] == g_subscriber) || (children[1] == g_topic)); + CU_ASSERT_FATAL((children[2] == g_publisher) || (children[2] == g_subscriber) || (children[2] == g_topic)); + CU_ASSERT_NOT_EQUAL_FATAL(children[0], children[1]); + CU_ASSERT_NOT_EQUAL_FATAL(children[0], children[2]); + CU_ASSERT_NOT_EQUAL_FATAL(children[1], children[2]); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_children, topic, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_get_children, topic, .init=hierarchy_init, .fini=hierarchy_fini) { dds_return_t ret; dds_entity_t child; ret = dds_get_children(g_topic, &child, 1); - cr_assert_eq(ret, 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_children, publisher, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_get_children, publisher, .init=hierarchy_init, .fini=hierarchy_fini) { dds_return_t ret; dds_entity_t child; ret = dds_get_children(g_publisher, &child, 1); - cr_assert_eq(ret, 1); - cr_assert_eq(child, g_writer); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(child, g_writer); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_children, subscriber, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_get_children, subscriber, .init=hierarchy_init, .fini=hierarchy_fini) { dds_return_t ret; dds_entity_t children[2]; ret = dds_get_children(g_subscriber, children, 2); - cr_assert_eq(ret, 1); - cr_assert_eq(children[0], g_reader); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(children[0], g_reader); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_children, writer, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_get_children, writer, .init=hierarchy_init, .fini=hierarchy_fini) { dds_return_t ret; ret = dds_get_children(g_writer, NULL, 0); - cr_assert_eq(ret, 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_children, reader, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_get_children, reader, .init=hierarchy_init, .fini=hierarchy_fini) { dds_return_t ret; dds_entity_t children[2]; ret = dds_get_children(g_reader, children, 2); - cr_assert_eq(ret, 2); - cr_assert((children[0] == g_readcond) || (children[0] == g_querycond)); - cr_assert((children[1] == g_readcond) || (children[1] == g_querycond)); - cr_assert_neq(children[0], children[1]); + CU_ASSERT_EQUAL_FATAL(ret, 2); + CU_ASSERT_FATAL((children[0] == g_readcond) || (children[0] == g_querycond)); + CU_ASSERT_FATAL((children[1] == g_readcond) || (children[1] == g_querycond)); + CU_ASSERT_NOT_EQUAL_FATAL(children[0], children[1]); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_children, conditions) = { - DataPoints(dds_entity_t*, &g_readcond, &g_querycond), +CU_TheoryDataPoints(ddsc_entity_get_children, conditions) = { + CU_DataPoints(dds_entity_t*, &g_readcond, &g_querycond), }; -Theory((dds_entity_t *entity), ddsc_entity_get_children, conditions, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *entity), ddsc_entity_get_children, conditions, .init=hierarchy_init, .fini=hierarchy_fini) { dds_return_t ret; dds_entity_t child; ret = dds_get_children(*entity, &child, 1); - cr_assert_eq(ret, 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_children, deleted_entities) = { - DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader, &g_subscriber, &g_writer, &g_publisher, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_entity_get_children, deleted_entities) = { + CU_DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader, &g_subscriber, &g_writer, &g_publisher, &g_topic, &g_participant), }; -Theory((dds_entity_t *entity), ddsc_entity_get_children, deleted_entities, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *entity), ddsc_entity_get_children, deleted_entities, .init=hierarchy_init, .fini=hierarchy_fini) { dds_return_t ret; dds_entity_t children[4]; dds_delete(*entity); ret = dds_get_children(*entity, children, 4); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_children, invalid_entities) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_entity_get_children, invalid_entities) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t entity), ddsc_entity_get_children, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t entity), ddsc_entity_get_children, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t children[4]; dds_return_t ret; ret = dds_get_children(entity, children, 4); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ @@ -507,53 +506,53 @@ Theory((dds_entity_t entity), ddsc_entity_get_children, invalid_entities, .init= * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_topic, data_entities) = { - DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader, &g_writer), +CU_TheoryDataPoints(ddsc_entity_get_topic, data_entities) = { + CU_DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader, &g_writer), }; -Theory((dds_entity_t *entity), ddsc_entity_get_topic, data_entities, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *entity), ddsc_entity_get_topic, data_entities, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t topic; topic = dds_get_topic(*entity); - cr_assert_eq(topic, g_topic ); + CU_ASSERT_EQUAL_FATAL(topic, g_topic ); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_topic, deleted_entities) = { - DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader, &g_writer), +CU_TheoryDataPoints(ddsc_entity_get_topic, deleted_entities) = { + CU_DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader, &g_writer), }; -Theory((dds_entity_t *entity), ddsc_entity_get_topic, deleted_entities, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *entity), ddsc_entity_get_topic, deleted_entities, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t topic; dds_delete(*entity); topic = dds_get_topic(*entity); - cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_topic, invalid_entities) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_entity_get_topic, invalid_entities) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t entity), ddsc_entity_get_topic, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t entity), ddsc_entity_get_topic, invalid_entities, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t topic; topic = dds_get_topic(entity); - cr_assert_eq(dds_err_nr(topic), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(topic), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_topic, non_data_entities) = { - DataPoints(dds_entity_t*, &g_subscriber, &g_publisher, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_entity_get_topic, non_data_entities) = { + CU_DataPoints(dds_entity_t*, &g_subscriber, &g_publisher, &g_topic, &g_participant), }; -Theory((dds_entity_t *entity), ddsc_entity_get_topic, non_data_entities, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *entity), ddsc_entity_get_topic, non_data_entities, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t topic; topic = dds_get_topic(*entity); - cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(topic)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -567,47 +566,47 @@ Theory((dds_entity_t *entity), ddsc_entity_get_topic, non_data_entities, .init=h * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_publisher, writer, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_get_publisher, writer, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t publisher; publisher = dds_get_publisher(g_writer); - cr_assert_eq(publisher, g_publisher); + CU_ASSERT_EQUAL_FATAL(publisher, g_publisher); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_publisher, deleted_writer, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Test(ddsc_entity_get_publisher, deleted_writer, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t publisher; dds_delete(g_writer); publisher = dds_get_publisher(g_writer); - cr_assert_eq(dds_err_nr(publisher), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_publisher, invalid_writers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_entity_get_publisher, invalid_writers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t entity), ddsc_entity_get_publisher, invalid_writers, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t entity), ddsc_entity_get_publisher, invalid_writers, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t publisher; publisher = dds_get_publisher(entity); - cr_assert_eq(dds_err_nr(publisher), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(publisher), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_publisher, non_writers) = { - DataPoints(dds_entity_t*, &g_publisher, &g_reader, &g_publisher, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_entity_get_publisher, non_writers) = { + CU_DataPoints(dds_entity_t*, &g_publisher, &g_reader, &g_publisher, &g_topic, &g_participant), }; -Theory((dds_entity_t *cond), ddsc_entity_get_publisher, non_writers, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *cond), ddsc_entity_get_publisher, non_writers, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t publisher; publisher = dds_get_publisher(*cond); - cr_assert_eq(dds_err_nr(publisher), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(publisher)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -620,53 +619,53 @@ Theory((dds_entity_t *cond), ddsc_entity_get_publisher, non_writers, .init=hiera * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_subscriber, readers) = { - DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader), +CU_TheoryDataPoints(ddsc_entity_get_subscriber, readers) = { + CU_DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader), }; -Theory((dds_entity_t *entity), ddsc_entity_get_subscriber, readers, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *entity), ddsc_entity_get_subscriber, readers, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t subscriber; subscriber = dds_get_subscriber(*entity); - cr_assert_eq(subscriber, g_subscriber); + CU_ASSERT_EQUAL_FATAL(subscriber, g_subscriber); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_subscriber, deleted_readers) = { - DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader), +CU_TheoryDataPoints(ddsc_entity_get_subscriber, deleted_readers) = { + CU_DataPoints(dds_entity_t*, &g_readcond, &g_querycond, &g_reader), }; -Theory((dds_entity_t *entity), ddsc_entity_get_subscriber, deleted_readers, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *entity), ddsc_entity_get_subscriber, deleted_readers, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t subscriber; dds_delete(*entity); subscriber = dds_get_subscriber(*entity); - cr_assert_eq(dds_err_nr(subscriber), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_subscriber, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_entity_get_subscriber, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t entity), ddsc_entity_get_subscriber, invalid_readers, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t entity), ddsc_entity_get_subscriber, invalid_readers, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t subscriber; subscriber = dds_get_subscriber(entity); - cr_assert_eq(dds_err_nr(subscriber), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(subscriber), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_subscriber, non_readers) = { - DataPoints(dds_entity_t*, &g_subscriber, &g_writer, &g_publisher, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_entity_get_subscriber, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_subscriber, &g_writer, &g_publisher, &g_topic, &g_participant), }; -Theory((dds_entity_t *cond), ddsc_entity_get_subscriber, non_readers, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *cond), ddsc_entity_get_subscriber, non_readers, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t subscriber; subscriber = dds_get_subscriber(*cond); - cr_assert_eq(dds_err_nr(subscriber), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(subscriber)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -681,59 +680,59 @@ Theory((dds_entity_t *cond), ddsc_entity_get_subscriber, non_readers, .init=hier * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_datareader, conditions) = { - DataPoints(dds_entity_t*, &g_readcond, &g_querycond), +CU_TheoryDataPoints(ddsc_entity_get_datareader, conditions) = { + CU_DataPoints(dds_entity_t*, &g_readcond, &g_querycond), }; -Theory((dds_entity_t *cond), ddsc_entity_get_datareader, conditions, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *cond), ddsc_entity_get_datareader, conditions, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t reader; reader = dds_get_datareader(*cond); - cr_assert_eq(reader, g_reader); + CU_ASSERT_EQUAL_FATAL(reader, g_reader); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_datareader, deleted_conds) = { - DataPoints(dds_entity_t*, &g_readcond, &g_querycond), +CU_TheoryDataPoints(ddsc_entity_get_datareader, deleted_conds) = { + CU_DataPoints(dds_entity_t*, &g_readcond, &g_querycond), }; -Theory((dds_entity_t *cond), ddsc_entity_get_datareader, deleted_conds, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *cond), ddsc_entity_get_datareader, deleted_conds, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t reader; dds_delete(*cond); reader = dds_get_datareader(*cond); - cr_assert_eq(dds_err_nr(reader), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(reader), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_datareader, invalid_conds) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_entity_get_datareader, invalid_conds) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t cond), ddsc_entity_get_datareader, invalid_conds, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t cond), ddsc_entity_get_datareader, invalid_conds, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t reader; reader = dds_get_datareader(cond); - cr_assert_eq(dds_err_nr(reader), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(reader), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(reader), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_entity_get_datareader, non_conds) = { - DataPoints(dds_entity_t*, &g_reader, &g_subscriber, &g_writer, &g_publisher, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_entity_get_datareader, non_conds) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_subscriber, &g_writer, &g_publisher, &g_topic, &g_participant), }; -Theory((dds_entity_t *cond), ddsc_entity_get_datareader, non_conds, .init=hierarchy_init, .fini=hierarchy_fini) +CU_Theory((dds_entity_t *cond), ddsc_entity_get_datareader, non_conds, .init=hierarchy_init, .fini=hierarchy_fini) { dds_entity_t reader; reader = dds_get_datareader(*cond); - cr_assert_eq(dds_err_nr(reader), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(reader)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(reader), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_implicit_publisher, deleted) +CU_Test(ddsc_entity_implicit_publisher, deleted) { dds_entity_t participant; dds_entity_t writer; @@ -742,21 +741,21 @@ Test(ddsc_entity_implicit_publisher, deleted) char name[100]; participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0); + CU_ASSERT_FATAL(participant > 0); topic = dds_create_topic(participant, &RoundTripModule_DataType_desc, create_topic_name("ddsc_entity_implicit_publisher_test", name, 100), NULL, NULL); - cr_assert_gt(topic, 0); + CU_ASSERT_FATAL(topic > 0); writer = dds_create_writer(participant, topic, NULL, NULL); - cr_assert_gt(writer, 0); + CU_ASSERT_FATAL(writer > 0); ret = dds_get_children(participant, NULL, 0); - cr_assert_eq(ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); dds_delete(writer); ret = dds_get_children(participant, NULL, 0); - cr_assert_eq(ret, 1); + CU_ASSERT_EQUAL_FATAL(ret, 1); dds_delete(topic); dds_delete(participant); @@ -764,20 +763,20 @@ Test(ddsc_entity_implicit_publisher, deleted) /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_implicit_publisher, invalid_topic) +CU_Test(ddsc_entity_implicit_publisher, invalid_topic) { dds_entity_t participant; dds_entity_t writer; participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0); + CU_ASSERT_FATAL(participant > 0); /* Disable SAL warning on intentional misuse of the API */ OS_WARNING_MSVC_OFF(28020); writer = dds_create_writer(participant, 0, NULL, NULL); /* Disable SAL warning on intentional misuse of the API */ OS_WARNING_MSVC_ON(28020); - cr_assert_lt(writer, 0); + CU_ASSERT_FATAL(writer < 0); dds_delete(writer); dds_delete(participant); @@ -785,7 +784,7 @@ Test(ddsc_entity_implicit_publisher, invalid_topic) /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_implicit_subscriber, deleted) +CU_Test(ddsc_entity_implicit_subscriber, deleted) { dds_entity_t participant; dds_entity_t reader; @@ -794,21 +793,21 @@ Test(ddsc_entity_implicit_subscriber, deleted) char name[100]; participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0); + CU_ASSERT_FATAL(participant > 0); topic = dds_create_topic(participant, &RoundTripModule_DataType_desc, create_topic_name("ddsc_entity_implicit_subscriber_test", name, 100), NULL, NULL); - cr_assert_gt(topic, 0); + CU_ASSERT_FATAL(topic > 0); reader = dds_create_reader(participant, topic, NULL, NULL); - cr_assert_gt(reader, 0); + CU_ASSERT_FATAL(reader > 0); ret = dds_get_children(participant, NULL, 0); - cr_assert_eq(ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); dds_delete(reader); ret = dds_get_children(participant, NULL, 0); - cr_assert_eq(ret, 1); + CU_ASSERT_EQUAL_FATAL(ret, 1); dds_delete(topic); dds_delete(participant); @@ -816,21 +815,21 @@ Test(ddsc_entity_implicit_subscriber, deleted) /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_explicit_subscriber, invalid_topic) +CU_Test(ddsc_entity_explicit_subscriber, invalid_topic) { dds_entity_t participant; dds_entity_t reader; dds_entity_t subscriber; participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0); + CU_ASSERT_FATAL(participant > 0); subscriber = dds_create_subscriber(participant, NULL,NULL); /* Disable SAL warning on intentional misuse of the API */ OS_WARNING_MSVC_OFF(28020); reader = dds_create_reader(subscriber, 0, NULL, NULL); OS_WARNING_MSVC_ON(28020); - cr_assert_lt(reader, 0); + CU_ASSERT_FATAL(reader < 0); dds_delete(reader); dds_delete(participant); @@ -838,7 +837,7 @@ Test(ddsc_entity_explicit_subscriber, invalid_topic) /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_children, implicit_publisher) +CU_Test(ddsc_entity_get_children, implicit_publisher) { dds_entity_t participant; dds_entity_t publisher = 0; @@ -849,33 +848,33 @@ Test(ddsc_entity_get_children, implicit_publisher) char name[100]; participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0); + CU_ASSERT_FATAL(participant > 0); topic = dds_create_topic(participant, &RoundTripModule_DataType_desc, create_topic_name("ddsc_entity_implicit_publisher_test", name, 100), NULL, NULL); - cr_assert_gt(topic, 0); + CU_ASSERT_FATAL(topic > 0); writer = dds_create_writer(participant, topic, NULL, NULL); - cr_assert_gt(writer, 0); + CU_ASSERT_FATAL(writer > 0); ret = dds_get_children(participant, child, 2); - cr_assert_eq(ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); if(child[0] == topic){ publisher = child[1]; } else if(child[1] == topic){ publisher = child[0]; } else{ - cr_assert(false, "topic was not returned"); + CU_FAIL_FATAL("topic was not returned"); } - cr_assert_neq(publisher, topic); + CU_ASSERT_NOT_EQUAL_FATAL(publisher, topic); - cr_assert_gt(publisher, 0); - cr_assert_neq(publisher, writer); + CU_ASSERT_FATAL(publisher > 0); + CU_ASSERT_NOT_EQUAL_FATAL(publisher, writer); dds_delete(writer); ret = dds_get_children(participant, child2, 2); - cr_assert_eq(ret, 2); - cr_assert( (child2[0] == child[0]) || (child2[0] == child[1]) ); - cr_assert( (child2[1] == child[0]) || (child2[1] == child[1]) ); + CU_ASSERT_EQUAL_FATAL(ret, 2); + CU_ASSERT_FATAL( (child2[0] == child[0]) || (child2[0] == child[1]) ); + CU_ASSERT_FATAL( (child2[1] == child[0]) || (child2[1] == child[1]) ); dds_delete(topic); dds_delete(participant); @@ -883,7 +882,7 @@ Test(ddsc_entity_get_children, implicit_publisher) /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_children, implicit_subscriber) +CU_Test(ddsc_entity_get_children, implicit_subscriber) { dds_entity_t participant; dds_entity_t subscriber = 0; @@ -894,33 +893,33 @@ Test(ddsc_entity_get_children, implicit_subscriber) char name[100]; participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0); + CU_ASSERT_FATAL(participant > 0); topic = dds_create_topic(participant, &RoundTripModule_DataType_desc, create_topic_name("ddsc_entity_implicit_subscriber_test", name, 100), NULL, NULL); - cr_assert_gt(topic, 0); + CU_ASSERT_FATAL(topic > 0); reader = dds_create_reader(participant, topic, NULL, NULL); - cr_assert_gt(reader, 0); + CU_ASSERT_FATAL(reader > 0); ret = dds_get_children(participant, child, 2); - cr_assert_eq(ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); if(child[0] == topic){ subscriber = child[1]; } else if(child[1] == topic){ subscriber = child[0]; } else{ - cr_assert(false, "topic was not returned"); + CU_FAIL_FATAL("topic was not returned"); } - cr_assert_neq(subscriber, topic); + CU_ASSERT_NOT_EQUAL_FATAL(subscriber, topic); - cr_assert_gt(subscriber, 0); - cr_assert_neq(subscriber, reader); + CU_ASSERT_FATAL(subscriber > 0); + CU_ASSERT_NOT_EQUAL_FATAL(subscriber, reader); dds_delete(reader); ret = dds_get_children(participant, child2, 2); - cr_assert_eq(ret, 2); - cr_assert( (child2[0] == child[0]) || (child2[0] == child[1]) ); - cr_assert( (child2[1] == child[0]) || (child2[1] == child[1]) ); + CU_ASSERT_EQUAL_FATAL(ret, 2); + CU_ASSERT_FATAL( (child2[0] == child[0]) || (child2[0] == child[1]) ); + CU_ASSERT_FATAL( (child2[1] == child[0]) || (child2[1] == child[1]) ); dds_delete(topic); dds_delete(participant); @@ -929,7 +928,7 @@ Test(ddsc_entity_get_children, implicit_subscriber) /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_parent, implicit_publisher) +CU_Test(ddsc_entity_get_parent, implicit_publisher) { dds_entity_t participant; dds_entity_t writer; @@ -939,28 +938,28 @@ Test(ddsc_entity_get_parent, implicit_publisher) char name[100]; participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0); + CU_ASSERT_FATAL(participant > 0); topic = dds_create_topic(participant, &RoundTripModule_DataType_desc, create_topic_name("ddsc_entity_implicit_publisher_promotion_test", name, 100), NULL, NULL); - cr_assert_gt(topic, 0); + CU_ASSERT_FATAL(topic > 0); writer = dds_create_writer(participant, topic, NULL, NULL); - cr_assert_gt(writer, 0); + CU_ASSERT_FATAL(writer > 0); parent = dds_get_parent(writer); - cr_assert_neq(parent, participant); - cr_assert_gt(parent, 0); + CU_ASSERT_NOT_EQUAL_FATAL(parent, participant); + CU_ASSERT_FATAL(parent > 0); dds_delete(writer); ret = dds_delete(parent); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); dds_delete(participant); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_entity_get_parent, implicit_subscriber) +CU_Test(ddsc_entity_get_parent, implicit_subscriber) { dds_entity_t participant; dds_entity_t reader; @@ -970,22 +969,22 @@ Test(ddsc_entity_get_parent, implicit_subscriber) char name[100]; participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0); + CU_ASSERT_FATAL(participant > 0); topic = dds_create_topic(participant, &RoundTripModule_DataType_desc, create_topic_name("ddsc_entity_implicit_subscriber_promotion_test", name, 100), NULL, NULL); - cr_assert_gt(topic, 0); + CU_ASSERT_FATAL(topic > 0); reader = dds_create_reader(participant, topic, NULL, NULL); - cr_assert_gt(reader, 0); + CU_ASSERT_FATAL(reader > 0); parent = dds_get_parent(reader); - cr_assert_neq(parent, participant); - cr_assert_gt(parent, 0); + CU_ASSERT_NOT_EQUAL_FATAL(parent, participant); + CU_ASSERT_FATAL(parent > 0); dds_delete(reader); ret = dds_delete(parent); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); dds_delete(participant); } diff --git a/src/core/ddsc/tests/entity_status.c b/src/core/ddsc/tests/entity_status.c index d927fee..116e605 100644 --- a/src/core/ddsc/tests/entity_status.c +++ b/src/core/ddsc/tests/entity_status.c @@ -10,14 +10,11 @@ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ #include +#include "CUnit/Theory.h" #include "ddsc/dds.h" #include "os/os.h" #include "RoundTrip.h" -#include -#include -#include -#define cr_assert_dds_return_t_eq(ret_t, expected, ...) cr_assert_eq(dds_err_nr(ret_t), (expected), __VA_ARGS__) /**************************************************************************** * Test globals. @@ -66,40 +63,40 @@ init_entity_status(void) char topicName[100]; participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "Failed to create prerequisite participant"); + CU_ASSERT(participant > 0); top = dds_create_topic(participant, &RoundTripModule_DataType_desc, create_topic_name("ddsc_status_test", topicName, 100), NULL, NULL); - cr_assert_gt(top, 0, "Failed to create prerequisite topic"); + CU_ASSERT(top > 0); qos = dds_create_qos(); - cr_assert_not_null(qos, "Failed to create prerequisite qos"); + CU_ASSERT_PTR_NOT_NULL_FATAL(qos); dds_qset_resource_limits (qos, resource_limits.max_samples, resource_limits.max_instances, resource_limits.max_samples_per_instance); dds_qset_reliability(qos, DDS_RELIABILITY_BEST_EFFORT, DDS_MSECS(100)); dds_qset_history (qos, DDS_HISTORY_KEEP_ALL, 0); dds_qset_destination_order (qos, DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP); subscriber = dds_create_subscriber(participant, qos, NULL); - cr_assert_gt(subscriber, 0); + CU_ASSERT_FATAL(subscriber > 0); rea = dds_create_reader(subscriber, top, qos, NULL); - cr_assert_gt(rea, 0); + CU_ASSERT_FATAL(rea > 0); publisher = dds_create_publisher(participant, qos, NULL); - cr_assert_gt(publisher, 0); + CU_ASSERT_FATAL(publisher > 0); wri = dds_create_writer(publisher, top, qos, NULL); - cr_assert_gt(wri, 0); + CU_ASSERT_FATAL(wri > 0); waitSetwr = dds_create_waitset(participant); ret = dds_waitset_attach (waitSetwr, wri, wri); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); waitSetrd = dds_create_waitset(participant); ret = dds_waitset_attach (waitSetrd, rea, rea); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Get reader/writer handles because they can be tested against. */ ret = dds_get_instance_handle(rea, &reader_i_hdl); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to get prerequisite reader_i_hdl"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_get_instance_handle(wri, &writer_i_hdl); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to get prerequisite writer_i_hdl"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } static void @@ -122,81 +119,81 @@ fini_entity_status(void) /**************************************************************************** * Triggering tests ****************************************************************************/ -Test(ddsc_entity_status, publication_matched, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_entity_status, publication_matched, .init=init_entity_status, .fini=fini_entity_status) { /* We're interested in publication matched status. */ ret = dds_set_enabled_status(wri, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Wait for publication matched status */ ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_get_publication_matched_status(wri, &publication_matched); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(publication_matched.current_count, 1); - cr_assert_eq(publication_matched.current_count_change, 1); - cr_assert_eq(publication_matched.total_count, 1); - cr_assert_eq(publication_matched.total_count_change, 1); - cr_assert_eq(publication_matched.last_subscription_handle, reader_i_hdl); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(publication_matched.current_count, 1); + CU_ASSERT_EQUAL_FATAL(publication_matched.current_count_change, 1); + CU_ASSERT_EQUAL_FATAL(publication_matched.total_count, 1); + CU_ASSERT_EQUAL_FATAL(publication_matched.total_count_change, 1); + CU_ASSERT_EQUAL_FATAL(publication_matched.last_subscription_handle, reader_i_hdl); /* Getting the status should have reset the trigger, * meaning that the wait should timeout. */ ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, shortTimeout); - cr_assert_eq(dds_err_nr(ret), 0, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0); /* Un-match the publication by deleting the reader. */ dds_delete(rea); /* Wait for publication matched status */ ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_get_publication_matched_status(wri, &publication_matched); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(publication_matched.current_count, 0); - cr_assert_eq(publication_matched.current_count_change, -1); - cr_assert_eq(publication_matched.total_count, 1); - cr_assert_eq(publication_matched.total_count_change, 0); - cr_assert_eq(publication_matched.last_subscription_handle, reader_i_hdl); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(publication_matched.current_count, 0); + CU_ASSERT_EQUAL_FATAL(publication_matched.current_count_change, -1); + CU_ASSERT_EQUAL_FATAL(publication_matched.total_count, 1); + CU_ASSERT_EQUAL_FATAL(publication_matched.total_count_change, 0); + CU_ASSERT_EQUAL_FATAL(publication_matched.last_subscription_handle, reader_i_hdl); } -Test(ddsc_entity_status, subscription_matched, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_entity_status, subscription_matched, .init=init_entity_status, .fini=fini_entity_status) { /* We're interested in subscription matched status. */ ret = dds_set_enabled_status(rea, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Wait for subscription matched status */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_get_subscription_matched_status(rea, &subscription_matched); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(subscription_matched.current_count, 1); - cr_assert_eq(subscription_matched.current_count_change, 1); - cr_assert_eq(subscription_matched.total_count, 1); - cr_assert_eq(subscription_matched.total_count_change, 1); - cr_assert_eq(subscription_matched.last_publication_handle, writer_i_hdl); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(subscription_matched.current_count, 1); + CU_ASSERT_EQUAL_FATAL(subscription_matched.current_count_change, 1); + CU_ASSERT_EQUAL_FATAL(subscription_matched.total_count, 1); + CU_ASSERT_EQUAL_FATAL(subscription_matched.total_count_change, 1); + CU_ASSERT_EQUAL_FATAL(subscription_matched.last_publication_handle, writer_i_hdl); /* Getting the status should have reset the trigger, * meaning that the wait should timeout. */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); - cr_assert_eq(dds_err_nr(ret), 0, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0); /* Un-match the subscription by deleting the writer. */ dds_delete(wri); /* Wait for subscription matched status */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_get_subscription_matched_status(rea, &subscription_matched); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(subscription_matched.current_count, 0); - cr_assert_eq(subscription_matched.current_count_change, -1); - cr_assert_eq(subscription_matched.total_count, 1); - cr_assert_eq(subscription_matched.total_count_change, 0); - cr_assert_eq(subscription_matched.last_publication_handle, writer_i_hdl); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(subscription_matched.current_count, 0); + CU_ASSERT_EQUAL_FATAL(subscription_matched.current_count_change, -1); + CU_ASSERT_EQUAL_FATAL(subscription_matched.total_count, 1); + CU_ASSERT_EQUAL_FATAL(subscription_matched.total_count_change, 0); + CU_ASSERT_EQUAL_FATAL(subscription_matched.last_publication_handle, writer_i_hdl); } -Test(ddsc_entity, incompatible_qos, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_entity, incompatible_qos, .init=init_entity_status, .fini=fini_entity_status) { dds_entity_t reader2; dds_requested_incompatible_qos_status_t req_incompatible_qos; @@ -207,101 +204,101 @@ Test(ddsc_entity, incompatible_qos, .init=init_entity_status, .fini=fini_entity_ /* Create a reader with persistent durability */ reader2 = dds_create_reader(participant, top, qos, NULL); - cr_assert_gt(reader2, 0); + CU_ASSERT_FATAL(reader2 > 0); ret = dds_waitset_attach (waitSetrd, reader2, reader2); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Get reader and writer status conditions and attach to waitset */ ret = dds_set_enabled_status(rea, DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_set_enabled_status(reader2, DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_set_enabled_status(wri, DDS_OFFERED_INCOMPATIBLE_QOS_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Wait for subscription requested incompatible status, which should only be * triggered on reader2. */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, 1); - cr_assert_eq(reader2, (dds_entity_t)(intptr_t)wsresults[0]); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(reader2, (dds_entity_t)(intptr_t)wsresults[0]); /* Get and check the status. */ ret = dds_get_requested_incompatible_qos_status (reader2, &req_incompatible_qos); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(req_incompatible_qos.total_count, 1); - cr_assert_eq(req_incompatible_qos.total_count_change, 1); - cr_assert_eq(req_incompatible_qos.last_policy_id, DDS_DURABILITY_QOS_POLICY_ID); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(req_incompatible_qos.total_count, 1); + CU_ASSERT_EQUAL_FATAL(req_incompatible_qos.total_count_change, 1); + CU_ASSERT_EQUAL_FATAL(req_incompatible_qos.last_policy_id, DDS_DURABILITY_QOS_POLICY_ID); /*Getting the status should have reset the trigger, waitset should timeout */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); - cr_assert_eq(dds_err_nr(ret), 0, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0); /* Wait for offered incompatible QoS status */ ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_get_offered_incompatible_qos_status (wri, &off_incompatible_qos); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(off_incompatible_qos.total_count, 1); - cr_assert_eq(off_incompatible_qos.total_count_change, 1); - cr_assert_eq(off_incompatible_qos.last_policy_id, DDS_DURABILITY_QOS_POLICY_ID); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(off_incompatible_qos.total_count, 1); + CU_ASSERT_EQUAL_FATAL(off_incompatible_qos.total_count_change, 1); + CU_ASSERT_EQUAL_FATAL(off_incompatible_qos.last_policy_id, DDS_DURABILITY_QOS_POLICY_ID); /*Getting the status should have reset the trigger, waitset should timeout */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); - cr_assert_eq(dds_err_nr(ret), 0, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0); ret = dds_waitset_detach(waitSetrd, reader2); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); dds_delete(reader2); } -Test(ddsc_entity, liveliness_changed, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_entity, liveliness_changed, .init=init_entity_status, .fini=fini_entity_status) { uint32_t set_status = 0; dds_liveliness_changed_status_t liveliness_changed; ret = dds_set_enabled_status(rea, DDS_LIVELINESS_CHANGED_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Get the status set */ ret = dds_get_enabled_status (rea, &set_status); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(set_status, DDS_LIVELINESS_CHANGED_STATUS); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(set_status, DDS_LIVELINESS_CHANGED_STATUS); /* wait for LIVELINESS_CHANGED status */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_get_liveliness_changed_status (rea, &liveliness_changed); - cr_assert_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(liveliness_changed.alive_count, 1); - cr_assert_eq(liveliness_changed.alive_count_change, 1); - cr_assert_eq(liveliness_changed.not_alive_count, 0); - cr_assert_eq(liveliness_changed.not_alive_count_change,0); - cr_assert_eq(liveliness_changed.last_publication_handle, writer_i_hdl); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(liveliness_changed.alive_count, 1); + CU_ASSERT_EQUAL_FATAL(liveliness_changed.alive_count_change, 1); + CU_ASSERT_EQUAL_FATAL(liveliness_changed.not_alive_count, 0); + CU_ASSERT_EQUAL_FATAL(liveliness_changed.not_alive_count_change,0); + CU_ASSERT_EQUAL_FATAL(liveliness_changed.last_publication_handle, writer_i_hdl); /*Getting the status should have reset the trigger, waitset should timeout */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); - cr_assert_eq(dds_err_nr(ret), 0, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0); /* Reset writer */ ret = dds_waitset_detach(waitSetwr, wri); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); dds_delete(wri); /* wait for LIVELINESS_CHANGED when a writer is deleted */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_get_liveliness_changed_status (rea, &liveliness_changed); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(liveliness_changed.alive_count, 0); - cr_assert_eq(liveliness_changed.alive_count_change, 0); - cr_assert_eq(liveliness_changed.not_alive_count, 1); - cr_assert_eq(liveliness_changed.not_alive_count_change,1); - cr_assert_eq(liveliness_changed.last_publication_handle, writer_i_hdl); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(liveliness_changed.alive_count, 0); + CU_ASSERT_EQUAL_FATAL(liveliness_changed.alive_count_change, 0); + CU_ASSERT_EQUAL_FATAL(liveliness_changed.not_alive_count, 1); + CU_ASSERT_EQUAL_FATAL(liveliness_changed.not_alive_count_change,1); + CU_ASSERT_EQUAL_FATAL(liveliness_changed.last_publication_handle, writer_i_hdl); } -Test(ddsc_entity, sample_rejected, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_entity, sample_rejected, .init=init_entity_status, .fini=fini_entity_status) { dds_sample_rejected_status_t sample_rejected; @@ -311,38 +308,38 @@ Test(ddsc_entity, sample_rejected, .init=init_entity_status, .fini=fini_entity_s memset (&sample, 0, sizeof (sample)); ret = dds_set_enabled_status(wri, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_set_enabled_status(rea, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_SAMPLE_REJECTED_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Wait for subscription matched and publication matched */ ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_set_enabled_status(rea, DDS_SAMPLE_REJECTED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* write data - write more than resource limits set by a data reader */ for (int i = 0; i < 5; i++) { - ret = dds_write (wri, &sample); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + ret = dds_write (wri, &sample); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /* wait for sample rejected status */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_get_sample_rejected_status (rea, &sample_rejected); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(sample_rejected.total_count, 4); - cr_assert_eq(sample_rejected.total_count_change, 4); - cr_assert_eq(sample_rejected.last_reason, DDS_REJECTED_BY_SAMPLES_LIMIT); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(sample_rejected.total_count, 4); + CU_ASSERT_EQUAL_FATAL(sample_rejected.total_count_change, 4); + CU_ASSERT_EQUAL_FATAL(sample_rejected.last_reason, DDS_REJECTED_BY_SAMPLES_LIMIT); /*Getting the status should have reset the trigger, waitset should timeout */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); - cr_assert_eq(dds_err_nr(ret), 0, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0); } #if 0 @@ -388,7 +385,7 @@ Test(ddsc_entity, inconsistent_topic) } #endif -Test(ddsc_entity, sample_lost, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_entity, sample_lost, .init=init_entity_status, .fini=fini_entity_status) { dds_sample_lost_status_t sample_lost; @@ -399,85 +396,85 @@ Test(ddsc_entity, sample_lost, .init=init_entity_status, .fini=fini_entity_statu memset (&sample, 0, sizeof (sample)); ret = dds_set_enabled_status(wri, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_set_enabled_status(rea, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_SAMPLE_LOST_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Wait for subscription matched and publication matched */ ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_set_enabled_status(rea, DDS_SAMPLE_LOST_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* get current time - subtraction ensures that this is truly historic on all platforms. */ time1 = dds_time () - 1000000; /* write a sample with current timestamp */ ret = dds_write_ts (wri, &sample, dds_time ()); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* second sample with older timestamp */ ret = dds_write_ts (wri, &sample, time1); /* wait for sample lost status */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_get_sample_lost_status (rea, &sample_lost); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(sample_lost.total_count, 1); - cr_assert_eq(sample_lost.total_count_change, 1); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(sample_lost.total_count, 1); + CU_ASSERT_EQUAL_FATAL(sample_lost.total_count_change, 1); /*Getting the status should have reset the trigger, waitset should timeout */ ret = dds_waitset_wait(waitSetrd, wsresults, wsresultsize, shortTimeout); - cr_assert_eq(dds_err_nr(ret), 0, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), 0); } -Test(ddsc_entity, data_available, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_entity, data_available, .init=init_entity_status, .fini=fini_entity_status) { RoundTripModule_DataType sample; memset (&sample, 0, sizeof (sample)); ret = dds_set_enabled_status(wri, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_set_enabled_status(rea, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_DATA_AVAILABLE_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Wait for subscription and publication matched status */ ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_waitset_wait(waitSetrd, wsresults2, wsresultsize2, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); /* Write the sample */ ret = dds_write (wri, &sample); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* wait for data available */ ret = dds_take_status(rea, &sta, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(sta, DDS_SUBSCRIPTION_MATCHED_STATUS); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(sta, DDS_SUBSCRIPTION_MATCHED_STATUS); ret = dds_waitset_wait(waitSetrd, wsresults2, wsresultsize2, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_get_status_changes (rea, &sta); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_detach(waitSetrd, rea); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); dds_delete(rea); /* Wait for reader to be deleted */ ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, waitTimeout); - cr_assert_neq(ret, 0); + CU_ASSERT_NOT_EQUAL_FATAL(ret, 0); } -Test(ddsc_entity, all_data_available, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_entity, all_data_available, .init=init_entity_status, .fini=fini_entity_status) { dds_entity_t reader2; dds_entity_t waitSetrd2; @@ -493,89 +490,89 @@ Test(ddsc_entity, all_data_available, .init=init_entity_status, .fini=fini_entit s_samples[0] = &s_sample; reader2 = dds_create_reader(subscriber, top, NULL, NULL); - cr_assert_gt(reader2, 0); + CU_ASSERT_FATAL(reader2 > 0); ret = dds_set_enabled_status(wri, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_set_enabled_status(rea, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_DATA_AVAILABLE_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_set_enabled_status(reader2, DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_DATA_AVAILABLE_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); waitSetrd2 = dds_create_waitset(participant); ret = dds_waitset_attach (waitSetrd2, reader2, reader2); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Wait for publication matched status */ ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); /* Wait for subscription matched status on both readers */ ret = dds_waitset_wait(waitSetrd, wsresults2, wsresultsize2, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_waitset_wait(waitSetrd2, wsresults2, wsresultsize2, waitTimeout); - cr_assert_eq(ret, (dds_return_t)wsresultsize); + CU_ASSERT_EQUAL_FATAL(ret, (dds_return_t)wsresultsize); ret = dds_write (wri, &p_sample); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Reset the publication and subscription matched status */ ret = dds_get_publication_matched_status(wri, NULL); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_take_status (rea, &sta, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(sta, DDS_SUBSCRIPTION_MATCHED_STATUS); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(sta, DDS_SUBSCRIPTION_MATCHED_STATUS); ret = dds_take_status (reader2, &sta, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(sta, DDS_SUBSCRIPTION_MATCHED_STATUS); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(sta, DDS_SUBSCRIPTION_MATCHED_STATUS); /* wait for data */ ret = dds_waitset_wait(waitSetrd, wsresults2, wsresultsize2, waitTimeout); - cr_assert_neq(ret, 0); + CU_ASSERT_NOT_EQUAL_FATAL(ret, 0); ret = dds_waitset_wait(waitSetrd2, wsresults2, wsresultsize2, waitTimeout); - cr_assert_neq(ret, 0); + CU_ASSERT_NOT_EQUAL_FATAL(ret, 0); ret = dds_waitset_detach(waitSetrd, rea); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_detach(waitSetrd2, reader2); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_delete(waitSetrd2); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Get DATA_ON_READERS status*/ ret = dds_get_status_changes (subscriber, &sta); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(sta, DDS_DATA_ON_READERS_STATUS); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(sta, DDS_DATA_ON_READERS_STATUS); /* Get DATA_AVAILABLE status */ ret = dds_get_status_changes (rea, &sta); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(sta, DDS_DATA_AVAILABLE_STATUS); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(sta, DDS_DATA_AVAILABLE_STATUS); /* Get DATA_AVAILABLE status */ ret = dds_get_status_changes (reader2, &sta); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(sta, DDS_DATA_AVAILABLE_STATUS); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(sta, DDS_DATA_AVAILABLE_STATUS); /* Read 1 data sample from reader1 */ ret = dds_take (rea, s_samples, &info, 1, 1); - cr_assert_eq(ret, 1); + CU_ASSERT_EQUAL_FATAL(ret, 1); /* status after taking the data should be reset */ ret = dds_get_status_changes (rea, &sta); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_neq(sta, ~DDS_DATA_AVAILABLE_STATUS); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_NOT_EQUAL(sta, ~DDS_DATA_AVAILABLE_STATUS); /* status from reader2 */ ret = dds_get_status_changes (reader2, &sta); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_neq(sta, ~DDS_DATA_AVAILABLE_STATUS); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_NOT_EQUAL(sta, ~DDS_DATA_AVAILABLE_STATUS); /* status from subscriber */ ret = dds_get_status_changes (subscriber, &sta); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(sta, 0); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(sta, 0); RoundTripModule_DataType_free (&s_sample, DDS_FREE_CONTENTS); @@ -583,760 +580,760 @@ Test(ddsc_entity, all_data_available, .init=init_entity_status, .fini=fini_entit /* Wait for reader to be deleted */ ret = dds_waitset_wait(waitSetwr, wsresults, wsresultsize, waitTimeout); - cr_assert_neq(ret, 0); + CU_ASSERT_NOT_EQUAL_FATAL(ret, 0); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_enabled_status, bad_param) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_get_enabled_status, bad_param) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t e), ddsc_get_enabled_status, bad_param) +CU_Theory((dds_entity_t e), ddsc_get_enabled_status, bad_param) { uint32_t status; dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_enabled_status(e, &status); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } -Test(ddsc_get_enabled_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_enabled_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; dds_delete(rea); ret = dds_get_enabled_status(rea, &status); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "dds_get_enabled_status(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } -Test(ddsc_get_enabled_status, illegal, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_enabled_status, illegal, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; ret = dds_get_enabled_status(waitSetrd, &status); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } -TheoryDataPoints(ddsc_get_enabled_status, status_ok) = { - DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber), +CU_TheoryDataPoints(ddsc_get_enabled_status, status_ok) = { + CU_DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber), }; -Theory((dds_entity_t *e), ddsc_get_enabled_status, status_ok, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *e), ddsc_get_enabled_status, status_ok, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; ret = dds_get_enabled_status (*e, &status); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK, "dds_get_enabled_status(entity, status)"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_set_enabled_status, bad_param) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_set_enabled_status, bad_param) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t e), ddsc_set_enabled_status, bad_param) +CU_Theory((dds_entity_t e), ddsc_set_enabled_status, bad_param) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_set_enabled_status(e, 0 /*mask*/); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } -Test(ddsc_set_enabled_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_set_enabled_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(rea); ret = dds_set_enabled_status(rea, 0 /*mask*/); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "dds_set_enabled_status(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } -Test(ddsc_set_enabled_status, illegal, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_set_enabled_status, illegal, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_set_enabled_status(waitSetrd, 0); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "dds_set_enabled_status(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } -TheoryDataPoints(ddsc_set_enabled_status, status_ok) = { - DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber), +CU_TheoryDataPoints(ddsc_set_enabled_status, status_ok) = { + CU_DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber), }; -Theory((dds_entity_t *entity), ddsc_set_enabled_status, status_ok, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *entity), ddsc_set_enabled_status, status_ok, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_set_enabled_status (*entity, 0); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK, "dds_set_enabled_status(entity, mask)"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_status, bad_param) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_read_status, bad_param) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t e), ddsc_read_status, bad_param) +CU_Theory((dds_entity_t e), ddsc_read_status, bad_param) { uint32_t status; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_read_status(e, &status, 0 /*mask*/); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } -Test(ddsc_read_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_read_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; dds_delete(rea); ret = dds_read_status(rea, &status, 0 /*mask*/); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "dds_read_status(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } -Test (ddsc_read_status, illegal, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_read_status, illegal, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; ret = dds_read_status(waitSetrd, &status, 0); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "dds_read_status(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } -TheoryDataPoints(ddsc_read_status, status_ok) = { - DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber), +CU_TheoryDataPoints(ddsc_read_status, status_ok) = { + CU_DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber), }; -Theory((dds_entity_t *e), ddsc_read_status, status_ok, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *e), ddsc_read_status, status_ok, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; ret = dds_read_status (*e, &status, 0); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK, "dds_read_status(entity, status, mask)"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } -Test (ddsc_read_status, invalid_status_on_reader, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_read_status, invalid_status_on_reader, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; ret = dds_read_status(rea, &status, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "dds_read_status(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } -Test (ddsc_read_status, invalid_status_on_writer, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_read_status, invalid_status_on_writer, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; ret = dds_read_status(wri, &status, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "dds_read_status(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_status, bad_param) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_take_status, bad_param) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t e), ddsc_take_status, bad_param) +CU_Theory((dds_entity_t e), ddsc_take_status, bad_param) { uint32_t status; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_take_status(e, &status, 0 /*mask*/); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } -Test(ddsc_take_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_take_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; dds_delete(rea); ret = dds_take_status(rea, &status, 0 /*mask*/); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "dds_take_status(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } -Test(ddsc_take_status, illegal, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_take_status, illegal, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; ret = dds_take_status(waitSetrd, &status, 0); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "dds_take_status(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } -TheoryDataPoints(ddsc_take_status, status_ok) = { - DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber), +CU_TheoryDataPoints(ddsc_take_status, status_ok) = { + CU_DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber), }; -Theory((dds_entity_t *e), ddsc_take_status, status_ok, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *e), ddsc_take_status, status_ok, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; ret = dds_take_status (*e, &status, 0 /*mask*/); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK, "dds_take_status(entity, status, mask)"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_status_changes, bad_param) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_get_status_changes, bad_param) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t e), ddsc_get_status_changes, bad_param) +CU_Theory((dds_entity_t e), ddsc_get_status_changes, bad_param) { uint32_t status; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_status_changes(e, &status); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } -Test(ddsc_get_status_changes, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_status_changes, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; dds_delete(rea); ret = dds_get_status_changes(rea, &status); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "dds_get_status_changes(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } -Test(ddsc_get_status_changes, illegal, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_status_changes, illegal, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; ret = dds_get_status_changes(waitSetrd, &status); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "dds_get_status_changes(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } -TheoryDataPoints(ddsc_get_status_changes, status_ok) = { - DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber), +CU_TheoryDataPoints(ddsc_get_status_changes, status_ok) = { + CU_DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber), }; -Theory((dds_entity_t *e), ddsc_get_status_changes, status_ok, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *e), ddsc_get_status_changes, status_ok, .init=init_entity_status, .fini=fini_entity_status) { uint32_t status; ret = dds_get_status_changes (*e, &status); - cr_assert_dds_return_t_eq(ret, DDS_RETCODE_OK, "dds_get_status_changes(entity, status)"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_triggered, bad_param) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_triggered, bad_param) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t e), ddsc_triggered, bad_param) +CU_Theory((dds_entity_t e), ddsc_triggered, bad_param) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_triggered(e); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "dds_triggered(): returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } -Test(ddsc_triggered, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_triggered, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(rea); ret = dds_triggered(rea); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "dds_triggered(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } -TheoryDataPoints(ddsc_triggered, status_ok) = { - DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber, &waitSetrd), +CU_TheoryDataPoints(ddsc_triggered, status_ok) = { + CU_DataPoints(dds_entity_t *,&rea, &wri, &participant, &top, &publisher, &subscriber, &waitSetrd), }; -Theory((dds_entity_t *e), ddsc_triggered, status_ok, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *e), ddsc_triggered, status_ok, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_triggered (*e); - cr_assert_geq(ret, 0, "dds_triggered(entity)"); + CU_ASSERT_FATAL(ret >= 0); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_inconsistent_topic_status, inconsistent_topic_status, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_inconsistent_topic_status, inconsistent_topic_status, .init=init_entity_status, .fini=fini_entity_status) { dds_inconsistent_topic_status_t inconsistent_topic_status; ret = dds_get_inconsistent_topic_status(top, &inconsistent_topic_status); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); - cr_assert_eq(inconsistent_topic_status.total_count, 0); - cr_assert_eq(inconsistent_topic_status.total_count_change, 0); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(inconsistent_topic_status.total_count, 0); + CU_ASSERT_EQUAL_FATAL(inconsistent_topic_status.total_count_change, 0); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_inconsistent_topic_status, bad_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_get_inconsistent_topic_status, bad_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t topic), ddsc_get_inconsistent_topic_status, bad_params) +CU_Theory((dds_entity_t topic), ddsc_get_inconsistent_topic_status, bad_params) { dds_inconsistent_topic_status_t topic_status; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_inconsistent_topic_status(topic, &topic_status); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_inconsistent_topic_status, null, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_inconsistent_topic_status, null, .init=init_entity_status, .fini=fini_entity_status) { dds_set_enabled_status(top, 0); ret = dds_get_inconsistent_topic_status(top, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_inconsistent_topic_status, non_topics) = { - DataPoints(dds_entity_t*, &rea, &wri, &participant), +CU_TheoryDataPoints(ddsc_get_inconsistent_topic_status, non_topics) = { + CU_DataPoints(dds_entity_t*, &rea, &wri, &participant), }; -Theory((dds_entity_t *topic), ddsc_get_inconsistent_topic_status, non_topics, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *topic), ddsc_get_inconsistent_topic_status, non_topics, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_inconsistent_topic_status(*topic, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_inconsistent_topic_status, deleted_topic, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_inconsistent_topic_status, deleted_topic, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(top); ret = dds_get_inconsistent_topic_status(top, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %s", dds_err_str(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_publication_matched_status, bad_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_get_publication_matched_status, bad_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_get_publication_matched_status, bad_params) +CU_Theory((dds_entity_t writer), ddsc_get_publication_matched_status, bad_params) { dds_publication_matched_status_t status; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_publication_matched_status(writer, &status); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_publication_matched_status, null, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_publication_matched_status, null, .init=init_entity_status, .fini=fini_entity_status) { dds_set_enabled_status(wri, 0); ret = dds_get_publication_matched_status(wri, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_publication_matched_status, non_writers) = { - DataPoints(dds_entity_t*, &rea, &top, &participant), +CU_TheoryDataPoints(ddsc_get_publication_matched_status, non_writers) = { + CU_DataPoints(dds_entity_t*, &rea, &top, &participant), }; -Theory((dds_entity_t *writer), ddsc_get_publication_matched_status, non_writers, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *writer), ddsc_get_publication_matched_status, non_writers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_publication_matched_status(*writer, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_publication_matched_status, deleted_writer, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_publication_matched_status, deleted_writer, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(wri); ret = dds_get_publication_matched_status(wri, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_liveliness_lost_status, liveliness_lost_status, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_liveliness_lost_status, liveliness_lost_status, .init=init_entity_status, .fini=fini_entity_status) { dds_liveliness_lost_status_t liveliness_lost_status; ret = dds_get_liveliness_lost_status(wri, &liveliness_lost_status); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); - cr_assert_eq(liveliness_lost_status.total_count, 0); - cr_assert_eq(liveliness_lost_status.total_count_change, 0); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(liveliness_lost_status.total_count, 0); + CU_ASSERT_EQUAL_FATAL(liveliness_lost_status.total_count_change, 0); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_liveliness_lost_status, bad_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_get_liveliness_lost_status, bad_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_get_liveliness_lost_status, bad_params) +CU_Theory((dds_entity_t writer), ddsc_get_liveliness_lost_status, bad_params) { dds_liveliness_lost_status_t status; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_liveliness_lost_status(writer, &status); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_liveliness_lost_status, null, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_liveliness_lost_status, null, .init=init_entity_status, .fini=fini_entity_status) { dds_set_enabled_status(wri, 0); ret = dds_get_liveliness_lost_status(wri, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_liveliness_lost_status, non_writers) = { - DataPoints(dds_entity_t*, &rea, &top, &participant), +CU_TheoryDataPoints(ddsc_get_liveliness_lost_status, non_writers) = { + CU_DataPoints(dds_entity_t*, &rea, &top, &participant), }; -Theory((dds_entity_t *writer), ddsc_get_liveliness_lost_status, non_writers, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *writer), ddsc_get_liveliness_lost_status, non_writers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_liveliness_lost_status(*writer, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_liveliness_lost_status, deleted_writer, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_liveliness_lost_status, deleted_writer, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(wri); ret = dds_get_liveliness_lost_status(wri, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_offered_deadline_missed_status, offered_deadline_missed_status, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_offered_deadline_missed_status, offered_deadline_missed_status, .init=init_entity_status, .fini=fini_entity_status) { dds_offered_deadline_missed_status_t offered_deadline_missed_status; ret = dds_get_offered_deadline_missed_status(wri, &offered_deadline_missed_status); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); - cr_assert_eq(offered_deadline_missed_status.total_count, 0); - cr_assert_eq(offered_deadline_missed_status.total_count_change, 0); - cr_assert_eq(offered_deadline_missed_status.last_instance_handle, 0); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(offered_deadline_missed_status.total_count, 0); + CU_ASSERT_EQUAL_FATAL(offered_deadline_missed_status.total_count_change, 0); + CU_ASSERT_EQUAL_FATAL(offered_deadline_missed_status.last_instance_handle, 0); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_offered_deadline_missed_status, bad_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_get_offered_deadline_missed_status, bad_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_get_offered_deadline_missed_status, bad_params) +CU_Theory((dds_entity_t writer), ddsc_get_offered_deadline_missed_status, bad_params) { dds_offered_deadline_missed_status_t status; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_offered_deadline_missed_status(writer, &status); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_offered_deadline_missed_status, null, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_offered_deadline_missed_status, null, .init=init_entity_status, .fini=fini_entity_status) { dds_set_enabled_status(wri, 0); ret = dds_get_offered_deadline_missed_status(wri, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_offered_deadline_missed_status, non_writers) = { - DataPoints(dds_entity_t*, &rea, &top, &participant), +CU_TheoryDataPoints(ddsc_get_offered_deadline_missed_status, non_writers) = { + CU_DataPoints(dds_entity_t*, &rea, &top, &participant), }; -Theory((dds_entity_t *writer), ddsc_get_offered_deadline_missed_status, non_writers, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *writer), ddsc_get_offered_deadline_missed_status, non_writers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_offered_deadline_missed_status(*writer, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_offered_deadline_missed_status, deleted_writer, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_offered_deadline_missed_status, deleted_writer, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(wri); ret = dds_get_offered_deadline_missed_status(wri, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_offered_incompatible_qos_status, bad_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_get_offered_incompatible_qos_status, bad_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_get_offered_incompatible_qos_status, bad_params) +CU_Theory((dds_entity_t writer), ddsc_get_offered_incompatible_qos_status, bad_params) { dds_offered_incompatible_qos_status_t status; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_offered_incompatible_qos_status(writer, &status); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_offered_incompatible_qos_status, null, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_offered_incompatible_qos_status, null, .init=init_entity_status, .fini=fini_entity_status) { dds_set_enabled_status(wri, 0); ret = dds_get_offered_incompatible_qos_status(wri, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_offered_incompatible_qos_status, non_writers) = { - DataPoints(dds_entity_t*, &rea, &top, &participant), +CU_TheoryDataPoints(ddsc_get_offered_incompatible_qos_status, non_writers) = { + CU_DataPoints(dds_entity_t*, &rea, &top, &participant), }; -Theory((dds_entity_t *writer), ddsc_get_offered_incompatible_qos_status, non_writers, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *writer), ddsc_get_offered_incompatible_qos_status, non_writers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_offered_incompatible_qos_status(*writer, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_offered_incompatible_qos_status, deleted_writer, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_offered_incompatible_qos_status, deleted_writer, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(wri); ret = dds_get_offered_incompatible_qos_status(wri, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_subscription_matched_status, bad_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_get_subscription_matched_status, bad_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t reader), ddsc_get_subscription_matched_status, bad_params) +CU_Theory((dds_entity_t reader), ddsc_get_subscription_matched_status, bad_params) { dds_subscription_matched_status_t status; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_subscription_matched_status(reader, &status); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_subscription_matched_status, null, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_subscription_matched_status, null, .init=init_entity_status, .fini=fini_entity_status) { dds_set_enabled_status(rea, 0); ret = dds_get_subscription_matched_status(rea, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %s", dds_err_str(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_subscription_matched_status, non_readers) = { - DataPoints(dds_entity_t*, &wri, &top, &participant), +CU_TheoryDataPoints(ddsc_get_subscription_matched_status, non_readers) = { + CU_DataPoints(dds_entity_t*, &wri, &top, &participant), }; -Theory((dds_entity_t *reader), ddsc_get_subscription_matched_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *reader), ddsc_get_subscription_matched_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_subscription_matched_status(*reader, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_subscription_matched_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_subscription_matched_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(rea); ret = dds_get_subscription_matched_status(rea, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_liveliness_changed_status, bad_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_get_liveliness_changed_status, bad_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t reader), ddsc_get_liveliness_changed_status, bad_params) +CU_Theory((dds_entity_t reader), ddsc_get_liveliness_changed_status, bad_params) { dds_liveliness_changed_status_t status; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_liveliness_changed_status(reader, &status); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_liveliness_changed_status, null, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_liveliness_changed_status, null, .init=init_entity_status, .fini=fini_entity_status) { dds_set_enabled_status(rea, 0); ret = dds_get_liveliness_changed_status(rea, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_liveliness_changed_status, non_readers) = { - DataPoints(dds_entity_t*, &wri, &top, &participant), +CU_TheoryDataPoints(ddsc_get_liveliness_changed_status, non_readers) = { + CU_DataPoints(dds_entity_t*, &wri, &top, &participant), }; -Theory((dds_entity_t *reader), ddsc_get_liveliness_changed_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *reader), ddsc_get_liveliness_changed_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_liveliness_changed_status(*reader, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_liveliness_changed_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_liveliness_changed_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(rea); ret = dds_get_liveliness_changed_status(rea, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_sample_rejected_status, bad_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_get_sample_rejected_status, bad_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t reader), ddsc_get_sample_rejected_status, bad_params) +CU_Theory((dds_entity_t reader), ddsc_get_sample_rejected_status, bad_params) { dds_sample_rejected_status_t status; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_sample_rejected_status(reader, &status); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_sample_rejected_status, null, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_sample_rejected_status, null, .init=init_entity_status, .fini=fini_entity_status) { dds_set_enabled_status(rea, 0); ret = dds_get_sample_rejected_status(rea, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_sample_rejected_status, non_readers) = { - DataPoints(dds_entity_t*, &wri, &top, &participant), +CU_TheoryDataPoints(ddsc_get_sample_rejected_status, non_readers) = { + CU_DataPoints(dds_entity_t*, &wri, &top, &participant), }; -Theory((dds_entity_t *reader), ddsc_get_sample_rejected_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *reader), ddsc_get_sample_rejected_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_sample_rejected_status(*reader, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_sample_rejected_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_sample_rejected_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(rea); ret = dds_get_sample_rejected_status(rea, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_sample_lost_status, bad_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_get_sample_lost_status, bad_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t reader), ddsc_get_sample_lost_status, bad_params) +CU_Theory((dds_entity_t reader), ddsc_get_sample_lost_status, bad_params) { dds_sample_lost_status_t status; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_sample_lost_status(reader, &status); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_sample_lost_status, null, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_sample_lost_status, null, .init=init_entity_status, .fini=fini_entity_status) { dds_set_enabled_status(rea, 0); ret = dds_get_sample_lost_status(rea, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_sample_lost_status, non_readers) = { - DataPoints(dds_entity_t*, &wri, &top, &participant), +CU_TheoryDataPoints(ddsc_get_sample_lost_status, non_readers) = { + CU_DataPoints(dds_entity_t*, &wri, &top, &participant), }; -Theory((dds_entity_t *reader), ddsc_get_sample_lost_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *reader), ddsc_get_sample_lost_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_sample_lost_status(*reader, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_sample_lost_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_sample_lost_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(rea); ret = dds_get_sample_lost_status(rea, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_requested_deadline_missed_status, requested_deadline_missed_status, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_requested_deadline_missed_status, requested_deadline_missed_status, .init=init_entity_status, .fini=fini_entity_status) { dds_requested_deadline_missed_status_t requested_deadline_missed_status; ret = dds_get_requested_deadline_missed_status(rea, &requested_deadline_missed_status); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); - cr_assert_eq(requested_deadline_missed_status.total_count, 0); - cr_assert_eq(requested_deadline_missed_status.total_count_change, 0); - cr_assert_eq(requested_deadline_missed_status.last_instance_handle, DDS_HANDLE_NIL); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(requested_deadline_missed_status.total_count, 0); + CU_ASSERT_EQUAL_FATAL(requested_deadline_missed_status.total_count_change, 0); + CU_ASSERT_EQUAL_FATAL(requested_deadline_missed_status.last_instance_handle, DDS_HANDLE_NIL); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_requested_deadline_missed_status, bad_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_get_requested_deadline_missed_status, bad_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t reader), ddsc_get_requested_deadline_missed_status, bad_params) +CU_Theory((dds_entity_t reader), ddsc_get_requested_deadline_missed_status, bad_params) { dds_requested_deadline_missed_status_t status; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_requested_deadline_missed_status(reader, &status); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_requested_deadline_missed_status, null, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_requested_deadline_missed_status, null, .init=init_entity_status, .fini=fini_entity_status) { dds_set_enabled_status(rea, 0); ret = dds_get_requested_deadline_missed_status(rea, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_requested_deadline_missed_status, non_readers) = { - DataPoints(dds_entity_t*, &wri, &top, &participant), +CU_TheoryDataPoints(ddsc_get_requested_deadline_missed_status, non_readers) = { + CU_DataPoints(dds_entity_t*, &wri, &top, &participant), }; -Theory((dds_entity_t *reader), ddsc_get_requested_deadline_missed_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *reader), ddsc_get_requested_deadline_missed_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_requested_deadline_missed_status(*reader, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_requested_deadline_missed_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_requested_deadline_missed_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(rea); ret = dds_get_requested_deadline_missed_status(rea, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_requested_incompatible_qos_status, bad_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_get_requested_incompatible_qos_status, bad_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t reader), ddsc_get_requested_incompatible_qos_status, bad_params) +CU_Theory((dds_entity_t reader), ddsc_get_requested_incompatible_qos_status, bad_params) { dds_requested_incompatible_qos_status_t status; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; ret = dds_get_requested_incompatible_qos_status(reader, &status); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_requested_incompatible_qos_status, null, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_requested_incompatible_qos_status, null, .init=init_entity_status, .fini=fini_entity_status) { dds_set_enabled_status(rea, 0); ret = dds_get_requested_incompatible_qos_status(rea, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_get_requested_incompatible_qos_status, non_readers) = { - DataPoints(dds_entity_t*, &wri, &top, &participant), +CU_TheoryDataPoints(ddsc_get_requested_incompatible_qos_status, non_readers) = { + CU_DataPoints(dds_entity_t*, &wri, &top, &participant), }; -Theory((dds_entity_t *reader), ddsc_get_requested_incompatible_qos_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) +CU_Theory((dds_entity_t *reader), ddsc_get_requested_incompatible_qos_status, non_readers, .init=init_entity_status, .fini=fini_entity_status) { ret = dds_get_requested_incompatible_qos_status(*reader, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_get_requested_incompatible_qos_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) +CU_Test(ddsc_get_requested_incompatible_qos_status, deleted_reader, .init=init_entity_status, .fini=fini_entity_status) { dds_delete(rea); ret = dds_get_requested_incompatible_qos_status(rea, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/err.c b/src/core/ddsc/tests/err.c index 4994294..09700f6 100644 --- a/src/core/ddsc/tests/err.c +++ b/src/core/ddsc/tests/err.c @@ -10,24 +10,23 @@ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ #include "ddsc/dds.h" -#include -#include +#include "CUnit/Test.h" -Test(ddsc_err, str) +CU_Test(ddsc_err, str) { - cr_assert_str_eq(dds_err_str(1 ), "Success"); - cr_assert_str_eq(dds_err_str(-255 ), "Unknown"); - cr_assert_str_eq(dds_err_str(DDS_RETCODE_OK * -1), "Success"); - cr_assert_str_eq(dds_err_str(DDS_RETCODE_ERROR * -1), "Error"); - cr_assert_str_eq(dds_err_str(DDS_RETCODE_UNSUPPORTED * -1), "Unsupported"); - cr_assert_str_eq(dds_err_str(DDS_RETCODE_BAD_PARAMETER * -1), "Bad Parameter"); - cr_assert_str_eq(dds_err_str(DDS_RETCODE_PRECONDITION_NOT_MET * -1), "Precondition Not Met"); - cr_assert_str_eq(dds_err_str(DDS_RETCODE_OUT_OF_RESOURCES * -1), "Out Of Resources"); - cr_assert_str_eq(dds_err_str(DDS_RETCODE_NOT_ENABLED * -1), "Not Enabled"); - cr_assert_str_eq(dds_err_str(DDS_RETCODE_IMMUTABLE_POLICY * -1), "Immutable Policy"); - cr_assert_str_eq(dds_err_str(DDS_RETCODE_INCONSISTENT_POLICY * -1), "Inconsistent Policy"); - cr_assert_str_eq(dds_err_str(DDS_RETCODE_ALREADY_DELETED * -1), "Already Deleted"); - cr_assert_str_eq(dds_err_str(DDS_RETCODE_TIMEOUT * -1), "Timeout"); - cr_assert_str_eq(dds_err_str(DDS_RETCODE_NO_DATA * -1), "No Data"); - cr_assert_str_eq(dds_err_str(DDS_RETCODE_ILLEGAL_OPERATION * -1), "Illegal Operation"); + CU_ASSERT_STRING_EQUAL(dds_err_str(1 ), "Success"); + CU_ASSERT_STRING_EQUAL(dds_err_str(-255 ), "Unknown"); + CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_OK * -1), "Success"); + CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_ERROR * -1), "Error"); + CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_UNSUPPORTED * -1), "Unsupported"); + CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_BAD_PARAMETER * -1), "Bad Parameter"); + CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_PRECONDITION_NOT_MET * -1), "Precondition Not Met"); + CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_OUT_OF_RESOURCES * -1), "Out Of Resources"); + CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_NOT_ENABLED * -1), "Not Enabled"); + CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_IMMUTABLE_POLICY * -1), "Immutable Policy"); + CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_INCONSISTENT_POLICY * -1), "Inconsistent Policy"); + CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_ALREADY_DELETED * -1), "Already Deleted"); + CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_TIMEOUT * -1), "Timeout"); + CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_NO_DATA * -1), "No Data"); + CU_ASSERT_STRING_EQUAL(dds_err_str(DDS_RETCODE_ILLEGAL_OPERATION * -1), "Illegal Operation"); } diff --git a/src/core/ddsc/tests/file_id.c b/src/core/ddsc/tests/file_id.c index d672aff..dee2849 100644 --- a/src/core/ddsc/tests/file_id.c +++ b/src/core/ddsc/tests/file_id.c @@ -10,30 +10,27 @@ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ #include "ddsc/dds.h" -#include -#include +#include "CUnit/Test.h" #include "os/os.h" -Test(ddsc_err, unique_file_id) +CU_Test(ddsc_err, unique_file_id) { dds_entity_t participant, reader, writer; participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0); + CU_ASSERT_FATAL(participant > 0); /* Disable SAL warning on intentional misuse of the API */ OS_WARNING_MSVC_OFF(28020); reader = dds_create_reader(0, 0, NULL, NULL); - cr_assert_lt(reader, 0); + CU_ASSERT_FATAL(reader < 0); writer = dds_create_writer(0, 0, NULL, NULL); - cr_assert_lt(writer, 0); + CU_ASSERT_FATAL(writer < 0); OS_WARNING_MSVC_ON(28020); - cr_log_info("file_id for dds_create_reader: %d", dds_err_file_id(reader)); - cr_log_info("file_id for dds_create_writer: %d", dds_err_file_id(writer)); - cr_assert_neq(dds_err_file_id(reader), dds_err_file_id(writer)); + CU_ASSERT_NOT_EQUAL_FATAL(dds_err_file_id(reader), dds_err_file_id(writer)); dds_delete(participant); } diff --git a/src/core/ddsc/tests/instance_get_key.c b/src/core/ddsc/tests/instance_get_key.c index 8a934bf..aaa0f9a 100644 --- a/src/core/ddsc/tests/instance_get_key.c +++ b/src/core/ddsc/tests/instance_get_key.c @@ -1,8 +1,18 @@ +/* + * 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 #include #include -#include -#include +#include "CUnit/Test.h" #include "os/os.h" #include "ddsc/dds.h" @@ -21,19 +31,19 @@ static RoundTripModule_Address data; static void setup(void) { participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0); + CU_ASSERT_FATAL(participant > 0); topic = dds_create_topic(participant, &RoundTripModule_Address_desc, "ddsc_instance_get_key", NULL, NULL); - cr_assert_gt(topic, 0); + CU_ASSERT_FATAL(topic > 0); publisher = dds_create_publisher(participant, NULL, NULL); - cr_assert_gt(publisher, 0); + CU_ASSERT_FATAL(publisher > 0); writer = dds_create_writer(publisher, topic, NULL, NULL); - cr_assert_gt(writer, 0); + CU_ASSERT_FATAL(writer > 0); memset(&data, 0, sizeof(data)); data.ip = os_strdup("some data"); - cr_assert_not_null(data.ip); + CU_ASSERT_PTR_NOT_NULL_FATAL(data.ip); data.port = 1; } @@ -48,48 +58,48 @@ static void teardown(void) dds_delete(participant); } -Test(ddsc_instance_get_key, bad_entity, .init=setup, .fini=teardown) +CU_Test(ddsc_instance_get_key, bad_entity, .init=setup, .fini=teardown) { dds_return_t ret; ret = dds_instance_get_key(participant, handle, &data); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } -Test(ddsc_instance_get_key, null_data, .init=setup, .fini=teardown) +CU_Test(ddsc_instance_get_key, null_data, .init=setup, .fini=teardown) { dds_return_t ret; ret = dds_register_instance(writer, &handle, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "Argument data is NULL"); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } -Test(ddsc_instance_get_key, null_handle, .init=setup, .fini=teardown) +CU_Test(ddsc_instance_get_key, null_handle, .init=setup, .fini=teardown) { dds_return_t ret; ret = dds_register_instance(writer, &handle, &data); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_register_instance succeeded (ret: %d)", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_instance_get_key(writer, DDS_HANDLE_NIL, &data); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "Argument data is not null, but handle is null"); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } -Test(ddsc_instance_get_key, registered_instance, .init=setup, .fini=teardown) +CU_Test(ddsc_instance_get_key, registered_instance, .init=setup, .fini=teardown) { dds_return_t ret; RoundTripModule_Address key_data; ret = dds_register_instance(writer, &handle, &data); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_register_instance succeeded (ret: %d)", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); memset(&key_data, 0, sizeof(key_data)); ret = dds_instance_get_key(writer, handle, &key_data); - cr_assert_not_null(key_data.ip); - cr_assert_eq(strcmp(key_data.ip, data.ip) , 0); - cr_assert_eq(key_data.port, data.port); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_PTR_NOT_NULL_FATAL(key_data.ip); + CU_ASSERT_STRING_EQUAL_FATAL(key_data.ip, data.ip); + CU_ASSERT_EQUAL_FATAL(key_data.port, data.port); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); RoundTripModule_Address_free(&key_data, DDS_FREE_CONTENTS); } diff --git a/src/core/ddsc/tests/listener.c b/src/core/ddsc/tests/listener.c index 47329ea..85d0c5e 100644 --- a/src/core/ddsc/tests/listener.c +++ b/src/core/ddsc/tests/listener.c @@ -12,8 +12,7 @@ #include "ddsc/dds.h" #include "os/os.h" #include "RoundTrip.h" -#include -#include +#include "CUnit/Test.h" /**************************************************************************** * TODO: (CHAM-279) Add DDS_INCONSISTENT_TOPIC_STATUS test @@ -31,7 +30,7 @@ do { \ dds_on_##fntype##_fn cb; \ dds_lget_##fntype(listener, &cb); \ - cr_expect_eq(cb, expected, "Callback 'on_" #fntype "' matched expected value '" #expected "'"); \ + CU_ASSERT_EQUAL(cb, expected); \ } while (0) #define STR(fntype) #fntype##_cb @@ -46,7 +45,7 @@ dds_lget_##fntype(NULL, NULL); \ dds_lget_##fntype(listener, NULL); \ dds_lget_##fntype(NULL, &dummy); \ - cr_expect_eq(dummy, NULL, "lget 'on_" #fntype "' with NULL listener was not a noop"); \ + CU_ASSERT_EQUAL_FATAL(dummy, NULL); \ /* Set to NULL, get to confirm it succeeds */ \ dds_lset_##fntype(listener, NULL); \ ASSERT_CALLBACK_EQUAL(fntype, listener, NULL); \ @@ -330,22 +329,22 @@ init_triggering_base(void) os_condInit(&g_cond, &g_mutex); g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0); g_subscriber = dds_create_subscriber(g_participant, NULL, NULL); - cr_assert_gt(g_subscriber, 0, "Failed to create prerequisite g_subscriber"); + CU_ASSERT_FATAL(g_subscriber > 0); g_publisher = dds_create_publisher(g_participant, NULL, NULL); - cr_assert_gt(g_publisher, 0, "Failed to create prerequisite g_publisher"); + CU_ASSERT_FATAL(g_publisher > 0); g_topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, create_topic_name("ddsc_listener_test", name, 100), NULL, NULL); - cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic"); + CU_ASSERT_FATAL(g_topic > 0); g_listener = dds_create_listener(NULL); - cr_assert_not_null(g_listener, "Failed to create prerequisite g_listener"); + CU_ASSERT_PTR_NOT_NULL_FATAL(g_listener); g_qos = dds_create_qos(); - cr_assert_not_null(g_qos, "Failed to create prerequisite g_qos"); + CU_ASSERT_PTR_NOT_NULL_FATAL(g_qos); dds_qset_reliability(g_qos, DDS_RELIABILITY_RELIABLE, DDS_SECS(1)); dds_qset_history(g_qos, DDS_HISTORY_KEEP_ALL, 0); } @@ -370,15 +369,15 @@ init_triggering_test(void) /* Create reader and writer with proper listeners. */ g_writer = dds_create_writer(g_publisher, g_topic, g_qos, g_listener); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite writer"); + CU_ASSERT(g_writer > 0); g_reader = dds_create_reader(g_subscriber, g_topic, g_qos, g_listener); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite reader"); + CU_ASSERT(g_reader > 0); /* Sync. */ triggered = waitfor_cb(DDS_PUBLICATION_MATCHED_STATUS | DDS_SUBSCRIPTION_MATCHED_STATUS | DDS_LIVELINESS_CHANGED_STATUS); - cr_assert_eq(triggered & DDS_LIVELINESS_CHANGED_STATUS, DDS_LIVELINESS_CHANGED_STATUS); - cr_assert_eq(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_LIVELINESS_CHANGED_STATUS, DDS_LIVELINESS_CHANGED_STATUS); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS); } static void @@ -401,17 +400,15 @@ fini_triggering_test(void) } -#if 0 -#else /**************************************************************************** * API tests ****************************************************************************/ -Test(ddsc_listener, create_and_delete) +CU_Test(ddsc_listener, create_and_delete) { /* Verify create doesn't return null */ dds_listener_t *listener; listener = dds_create_listener(NULL); - cr_assert_not_null(listener); + CU_ASSERT_PTR_NOT_NULL_FATAL(listener); /* Check default cb's are set */ ASSERT_CALLBACK_EQUAL(inconsistent_topic, listener, DDS_LUNSET); @@ -434,11 +431,11 @@ Test(ddsc_listener, create_and_delete) OS_WARNING_MSVC_ON(6387); } -Test(ddsc_listener, reset) +CU_Test(ddsc_listener, reset) { dds_listener_t *listener; listener = dds_create_listener(NULL); - cr_assert_not_null(listener); + CU_ASSERT_PTR_NOT_NULL_FATAL(listener); /* Set a listener cb to a non-default value */ dds_lset_data_available(listener, NULL); @@ -454,13 +451,13 @@ Test(ddsc_listener, reset) dds_delete_listener(listener); } -Test(ddsc_listener, copy) +CU_Test(ddsc_listener, copy) { dds_listener_t *listener1 = NULL, *listener2 = NULL; listener1 = dds_create_listener(NULL); listener2 = dds_create_listener(NULL); - cr_assert_not_null(listener1); - cr_assert_not_null(listener2); + CU_ASSERT_PTR_NOT_NULL_FATAL(listener1); + CU_ASSERT_PTR_NOT_NULL_FATAL(listener2); /* Set some listener1 callbacks to non-default values */ dds_lset_data_available(listener1, NULL); @@ -488,13 +485,13 @@ Test(ddsc_listener, copy) dds_delete_listener(listener2); } -Test(ddsc_listener, merge) +CU_Test(ddsc_listener, merge) { dds_listener_t *listener1 = NULL, *listener2 = NULL; listener1 = dds_create_listener(NULL); listener2 = dds_create_listener(NULL); - cr_assert_not_null(listener1); - cr_assert_not_null(listener2); + CU_ASSERT_PTR_NOT_NULL_FATAL(listener1); + CU_ASSERT_PTR_NOT_NULL_FATAL(listener2); /* Set all listener1 callbacks to non-default values */ dds_lset_inconsistent_topic (listener1, inconsistent_topic_cb); @@ -565,11 +562,11 @@ Test(ddsc_listener, merge) dds_delete_listener(listener2); } -Test(ddsc_listener, getters_setters) +CU_Test(ddsc_listener, getters_setters) { /* test all individual cb get/set methods */ dds_listener_t *listener = dds_create_listener(NULL); - cr_assert_not_null(listener); + CU_ASSERT_PTR_NOT_NULL_FATAL(listener); OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ \ TEST_GET_SET(listener, inconsistent_topic, inconsistent_topic_cb); @@ -595,7 +592,7 @@ Test(ddsc_listener, getters_setters) /**************************************************************************** * Triggering tests ****************************************************************************/ -Test(ddsc_listener, propagation, .init=init_triggering_base, .fini=fini_triggering_base) +CU_Test(ddsc_listener, propagation, .init=init_triggering_base, .fini=fini_triggering_base) { dds_listener_t *listener_par = NULL; dds_listener_t *listener_pub = NULL; @@ -607,57 +604,57 @@ Test(ddsc_listener, propagation, .init=init_triggering_base, .fini=fini_triggeri /* Let participant be interested in data. */ listener_par = dds_create_listener(NULL); - cr_assert_not_null(listener_par, "Failed to create prerequisite listener_par"); + CU_ASSERT_PTR_NOT_NULL_FATAL(listener_par); dds_lset_data_on_readers(listener_par, data_on_readers_cb); ret = dds_set_listener(g_participant, listener_par); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite listener_par"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); dds_delete_listener(listener_par); /* Let publisher be interested in publication matched. */ listener_pub = dds_create_listener(NULL); - cr_assert_not_null(listener_pub, "Failed to create prerequisite listener_pub"); + CU_ASSERT_PTR_NOT_NULL_FATAL(listener_pub); dds_lset_publication_matched(listener_pub, publication_matched_cb); ret = dds_set_listener(g_publisher, listener_pub); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite listener_pub"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); dds_delete_listener(listener_pub); /* Let subscriber be interested in subscription matched. */ listener_sub = dds_create_listener(NULL); - cr_assert_not_null(listener_pub, "Failed to create prerequisite listener_sub"); + CU_ASSERT_PTR_NOT_NULL_FATAL(listener_pub); dds_lset_subscription_matched(listener_sub, subscription_matched_cb); ret = dds_set_listener(g_subscriber, listener_sub); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite listener_sub"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); dds_delete_listener(listener_sub); /* Create reader and writer without listeners. */ g_reader = dds_create_reader(g_subscriber, g_topic, g_qos, NULL); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite reader"); + CU_ASSERT_FATAL(g_reader > 0); g_writer = dds_create_writer(g_publisher, g_topic, g_qos, NULL); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite writer"); + CU_ASSERT_FATAL(g_writer > 0); /* Publication and Subscription should be matched. */ triggered = waitfor_cb(DDS_PUBLICATION_MATCHED_STATUS | DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS, "DDS_SUBSCRIPTION_MATCHED_STATUS not triggered"); - cr_assert_eq(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS, "DDS_PUBLICATION_MATCHED_STATUS not triggered"); - cr_assert_eq(cb_writer, g_writer); - cr_assert_eq(cb_reader, g_reader); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS); + CU_ASSERT_EQUAL_FATAL(cb_writer, g_writer); + CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader); /* Write sample. */ ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write prerequisite data"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Data on readers should be triggered with the right status. */ triggered = waitfor_cb(DDS_DATA_ON_READERS_STATUS); - cr_assert_eq(triggered & DDS_DATA_ON_READERS_STATUS, DDS_DATA_ON_READERS_STATUS, "DDS_DATA_ON_READERS_STATUS not triggered"); - cr_assert_eq(cb_subscriber, g_subscriber); - cr_assert_neq(triggered & DDS_DATA_AVAILABLE_STATUS, DDS_DATA_AVAILABLE_STATUS, "DDS_DATA_AVAILABLE_STATUS triggered"); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_DATA_ON_READERS_STATUS, DDS_DATA_ON_READERS_STATUS); + CU_ASSERT_EQUAL_FATAL(cb_subscriber, g_subscriber); + CU_ASSERT_NOT_EQUAL_FATAL(triggered & DDS_DATA_AVAILABLE_STATUS, DDS_DATA_AVAILABLE_STATUS); dds_delete(g_writer); dds_delete(g_reader); } -Test(ddsc_listener, matched, .init=init_triggering_base, .fini=fini_triggering_base) +CU_Test(ddsc_listener, matched, .init=init_triggering_base, .fini=fini_triggering_base) { uint32_t triggered; @@ -672,22 +669,22 @@ Test(ddsc_listener, matched, .init=init_triggering_base, .fini=fini_triggering_b /* Create reader and writer with proper listeners. * The creation order is deliberately different from publication_matched and subscription_matched. */ g_reader = dds_create_reader(g_participant, g_topic, g_qos, g_listener); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite reader"); + CU_ASSERT_FATAL(g_reader > 0); g_writer = dds_create_writer(g_participant, g_topic, g_qos, g_listener); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite writer"); + CU_ASSERT_FATAL(g_writer > 0); /* Both matched should be triggered on the right entities. */ triggered = waitfor_cb(DDS_PUBLICATION_MATCHED_STATUS | DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS, "DDS_SUBSCRIPTION_MATCHED_STATUS not triggered"); - cr_assert_eq(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS, "DDS_PUBLICATION_MATCHED_STATUS not triggered"); - cr_assert_eq(cb_writer, g_writer); - cr_assert_eq(cb_reader, g_reader); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS); + CU_ASSERT_EQUAL_FATAL(cb_writer, g_writer); + CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader); dds_delete(g_writer); dds_delete(g_reader); } -Test(ddsc_listener, publication_matched, .init=init_triggering_test, .fini=fini_triggering_test) +CU_Test(ddsc_listener, publication_matched, .init=init_triggering_test, .fini=fini_triggering_test) { dds_instance_handle_t reader_hdl; dds_return_t ret; @@ -696,22 +693,22 @@ Test(ddsc_listener, publication_matched, .init=init_triggering_test, .fini=fini_ /* Get reader handle that should be part of the status. */ ret = dds_get_instance_handle(g_reader, &reader_hdl); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to get prerequisite reader_hdl"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Publication matched should be triggered with the right status. */ triggered = waitfor_cb(DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS, "DDS_PUBLICATION_MATCHED_STATUS not triggered"); - cr_assert_eq(cb_writer, g_writer); - cr_assert_eq(cb_publication_matched_status.current_count, 1); - cr_assert_eq(cb_publication_matched_status.current_count_change, 1); - cr_assert_eq(cb_publication_matched_status.total_count, 1); - cr_assert_eq(cb_publication_matched_status.total_count_change, 1); - cr_assert_eq(cb_publication_matched_status.last_subscription_handle, reader_hdl); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS); + CU_ASSERT_EQUAL_FATAL(cb_writer, g_writer); + CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.current_count, 1); + CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.current_count_change, 1); + CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.total_count, 1); + CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.total_count_change, 1); + CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.last_subscription_handle, reader_hdl); /* The listener should have swallowed the status. */ ret = dds_read_status(g_writer, &status, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed"); - cr_assert_eq(status, 0); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, 0); /* Reset the trigger flags. */ cb_called = 0; @@ -721,16 +718,16 @@ Test(ddsc_listener, publication_matched, .init=init_triggering_test, .fini=fini_ /* Publication matched should be triggered with the right status. */ triggered = waitfor_cb(DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS, "DDS_PUBLICATION_MATCHED_STATUS not triggered"); - cr_assert_eq(cb_writer, g_writer); - cr_assert_eq(cb_publication_matched_status.current_count, 0); - cr_assert_eq(cb_publication_matched_status.current_count_change, -1); - cr_assert_eq(cb_publication_matched_status.total_count, 1); - cr_assert_eq(cb_publication_matched_status.total_count_change, 0); - cr_assert_eq(cb_publication_matched_status.last_subscription_handle, reader_hdl); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_PUBLICATION_MATCHED_STATUS, DDS_PUBLICATION_MATCHED_STATUS); + CU_ASSERT_EQUAL_FATAL(cb_writer, g_writer); + CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.current_count, 0); + CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.current_count_change, -1); + CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.total_count, 1); + CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.total_count_change, 0); + CU_ASSERT_EQUAL_FATAL(cb_publication_matched_status.last_subscription_handle, reader_hdl); } -Test(ddsc_listener, subscription_matched, .init=init_triggering_test, .fini=fini_triggering_test) +CU_Test(ddsc_listener, subscription_matched, .init=init_triggering_test, .fini=fini_triggering_test) { dds_instance_handle_t writer_hdl; dds_return_t ret; @@ -739,22 +736,22 @@ Test(ddsc_listener, subscription_matched, .init=init_triggering_test, .fini=fini /* Get writer handle that should be part of the status. */ ret = dds_get_instance_handle(g_writer, &writer_hdl); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to get prerequisite writer_hdl"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Subscription matched should be triggered with the right status. */ triggered = waitfor_cb(DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS, "DDS_SUBSCRIPTION_MATCHED_STATUS not triggered"); - cr_assert_eq(cb_reader, g_reader); - cr_assert_eq(cb_subscription_matched_status.current_count, 1); - cr_assert_eq(cb_subscription_matched_status.current_count_change, 1); - cr_assert_eq(cb_subscription_matched_status.total_count, 1); - cr_assert_eq(cb_subscription_matched_status.total_count_change, 1); - cr_assert_eq(cb_subscription_matched_status.last_publication_handle, writer_hdl); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS); + CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader); + CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.current_count, 1); + CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.current_count_change, 1); + CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.total_count, 1); + CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.total_count_change, 1); + CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.last_publication_handle, writer_hdl); /* The listener should have swallowed the status. */ ret = dds_read_status(g_reader, &status, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed"); - cr_assert_eq(status, 0); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, 0); /* Reset the trigger flags. */ cb_called = 0; @@ -764,16 +761,16 @@ Test(ddsc_listener, subscription_matched, .init=init_triggering_test, .fini=fini /* Subscription matched should be triggered with the right status. */ triggered = waitfor_cb(DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS, "DDS_SUBSCRIPTION_MATCHED_STATUS not triggered"); - cr_assert_eq(cb_reader, g_reader); - cr_assert_eq(cb_subscription_matched_status.current_count, 0); - cr_assert_eq(cb_subscription_matched_status.current_count_change, -1); - cr_assert_eq(cb_subscription_matched_status.total_count, 1); - cr_assert_eq(cb_subscription_matched_status.total_count_change, 0); - cr_assert_eq(cb_subscription_matched_status.last_publication_handle, writer_hdl); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_SUBSCRIPTION_MATCHED_STATUS, DDS_SUBSCRIPTION_MATCHED_STATUS); + CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader); + CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.current_count, 0); + CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.current_count_change, -1); + CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.total_count, 1); + CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.total_count_change, 0); + CU_ASSERT_EQUAL_FATAL(cb_subscription_matched_status.last_publication_handle, writer_hdl); } -Test(ddsc_listener, incompatible_qos, .init=init_triggering_base, .fini=fini_triggering_base) +CU_Test(ddsc_listener, incompatible_qos, .init=init_triggering_base, .fini=fini_triggering_base) { dds_return_t ret; uint32_t triggered; @@ -786,37 +783,37 @@ Test(ddsc_listener, incompatible_qos, .init=init_triggering_base, .fini=fini_tri /* Create reader and writer with proper listeners. * But create reader with persistent durability to get incompatible qos. */ g_writer = dds_create_writer(g_participant, g_topic, g_qos, g_listener); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite writer"); + CU_ASSERT_FATAL(g_writer > 0); dds_qset_durability (g_qos, DDS_DURABILITY_PERSISTENT); g_reader = dds_create_reader(g_participant, g_topic, g_qos, g_listener); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite reader"); + CU_ASSERT_FATAL(g_reader > 0); /* Incompatible QoS should be triggered with the right status. */ triggered = waitfor_cb(DDS_OFFERED_INCOMPATIBLE_QOS_STATUS | DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS); - cr_assert_eq(triggered & DDS_OFFERED_INCOMPATIBLE_QOS_STATUS, DDS_OFFERED_INCOMPATIBLE_QOS_STATUS, "DDS_OFFERED_INCOMPATIBLE_QOS_STATUS not triggered"); - cr_assert_eq(triggered & DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS, DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS, "DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS not triggered"); - cr_assert_eq(cb_reader, g_reader); - cr_assert_eq(cb_writer, g_writer); - cr_assert_eq(cb_offered_incompatible_qos_status.total_count, 1, "cb_offered_incompatible_qos_status.total_count(%d) != 1", cb_offered_incompatible_qos_status.total_count); - cr_assert_eq(cb_offered_incompatible_qos_status.total_count_change, 1); - cr_assert_eq(cb_offered_incompatible_qos_status.last_policy_id, DDS_DURABILITY_QOS_POLICY_ID); - cr_assert_eq(cb_requested_incompatible_qos_status.total_count, 1, "cb_requested_incompatible_qos_status.total_count(%d) != 1", cb_requested_incompatible_qos_status.total_count); - cr_assert_eq(cb_requested_incompatible_qos_status.total_count_change, 1); - cr_assert_eq(cb_requested_incompatible_qos_status.last_policy_id, DDS_DURABILITY_QOS_POLICY_ID); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_OFFERED_INCOMPATIBLE_QOS_STATUS, DDS_OFFERED_INCOMPATIBLE_QOS_STATUS); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS, DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS); + CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader); + CU_ASSERT_EQUAL_FATAL(cb_writer, g_writer); + CU_ASSERT_EQUAL_FATAL(cb_offered_incompatible_qos_status.total_count, 1); + CU_ASSERT_EQUAL_FATAL(cb_offered_incompatible_qos_status.total_count_change, 1); + CU_ASSERT_EQUAL_FATAL(cb_offered_incompatible_qos_status.last_policy_id, DDS_DURABILITY_QOS_POLICY_ID); + CU_ASSERT_EQUAL_FATAL(cb_requested_incompatible_qos_status.total_count, 1); + CU_ASSERT_EQUAL_FATAL(cb_requested_incompatible_qos_status.total_count_change, 1); + CU_ASSERT_EQUAL_FATAL(cb_requested_incompatible_qos_status.last_policy_id, DDS_DURABILITY_QOS_POLICY_ID); /* The listener should have swallowed the status. */ ret = dds_read_status(g_writer, &status, DDS_OFFERED_INCOMPATIBLE_QOS_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed"); - cr_assert_eq(status, 0); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, 0); ret = dds_read_status(g_reader, &status, DDS_REQUESTED_INCOMPATIBLE_QOS_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed"); - cr_assert_eq(status, 0); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, 0); dds_delete(g_writer); dds_delete(g_reader); } -Test(ddsc_listener, data_available, .init=init_triggering_test, .fini=fini_triggering_test) +CU_Test(ddsc_listener, data_available, .init=init_triggering_test, .fini=fini_triggering_test) { dds_return_t ret; uint32_t triggered; @@ -827,27 +824,27 @@ Test(ddsc_listener, data_available, .init=init_triggering_test, .fini=fini_trigg /* We are interested in data available notifications. */ dds_lset_data_available(g_listener, data_available_cb); ret = dds_set_listener(g_reader, g_listener); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set listener"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Write sample. */ ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write prerequisite data"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Data available should be triggered with the right status. */ triggered = waitfor_cb(DDS_DATA_AVAILABLE_STATUS); - cr_assert_eq(triggered & DDS_DATA_AVAILABLE_STATUS, DDS_DATA_AVAILABLE_STATUS, "DDS_DATA_AVAILABLE_STATUS not triggered"); - cr_assert_eq(cb_reader, g_reader); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_DATA_AVAILABLE_STATUS, DDS_DATA_AVAILABLE_STATUS); + CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader); /* The listener should have swallowed the status. */ ret = dds_read_status(g_subscriber, &status, DDS_DATA_ON_READERS_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed"); - cr_assert_eq(status, 0); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, 0); ret = dds_read_status(g_reader, &status, DDS_DATA_AVAILABLE_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed"); - cr_assert_eq(status, 0); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, 0); } -Test(ddsc_listener, data_on_readers, .init=init_triggering_test, .fini=fini_triggering_test) +CU_Test(ddsc_listener, data_on_readers, .init=init_triggering_test, .fini=fini_triggering_test) { dds_return_t ret; uint32_t triggered; @@ -858,34 +855,34 @@ Test(ddsc_listener, data_on_readers, .init=init_triggering_test, .fini=fini_trig /* We are interested in data available notifications. */ dds_lset_data_on_readers(g_listener, data_on_readers_cb); ret = dds_set_listener(g_subscriber, g_listener); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set listener"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Setting data available notifications should not 'sabotage' the on_readers call. */ dds_lset_data_available(g_listener, data_available_cb); ret = dds_set_listener(g_reader, g_listener); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set listener"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Write sample. */ ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write prerequisite data"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Data on readers should be triggered with the right status. */ triggered = waitfor_cb(DDS_DATA_ON_READERS_STATUS); - cr_assert_eq(triggered & DDS_DATA_ON_READERS_STATUS, DDS_DATA_ON_READERS_STATUS, "DDS_DATA_ON_READERS_STATUS not triggered"); - cr_assert_eq(cb_subscriber, g_subscriber); - cr_assert_neq(triggered & DDS_DATA_AVAILABLE_STATUS, DDS_DATA_AVAILABLE_STATUS, "DDS_DATA_AVAILABLE_STATUS triggered"); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_DATA_ON_READERS_STATUS, DDS_DATA_ON_READERS_STATUS); + CU_ASSERT_EQUAL_FATAL(cb_subscriber, g_subscriber); + CU_ASSERT_NOT_EQUAL_FATAL(triggered & DDS_DATA_AVAILABLE_STATUS, DDS_DATA_AVAILABLE_STATUS); /* The listener should have swallowed the status. */ ret = dds_read_status(g_subscriber, &status, DDS_DATA_ON_READERS_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed"); - cr_assert_eq(status, 0); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, 0); ret = dds_read_status(g_reader, &status, DDS_DATA_AVAILABLE_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed"); - cr_assert_eq(status, 0); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, 0); } -Test(ddsc_listener, sample_lost, .init=init_triggering_test, .fini=fini_triggering_test) +CU_Test(ddsc_listener, sample_lost, .init=init_triggering_test, .fini=fini_triggering_test) { dds_return_t ret; uint32_t triggered; @@ -900,30 +897,30 @@ Test(ddsc_listener, sample_lost, .init=init_triggering_test, .fini=fini_triggeri /* We are interested in sample lost notifications. */ dds_lset_sample_lost(g_listener, sample_lost_cb); ret = dds_set_listener(g_reader, g_listener); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set listener"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Write first sample with current timestamp. */ ret = dds_write_ts(g_writer, &sample, dds_time()); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write contemporary data"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Write second sample with older timestamp. */ ret = dds_write_ts(g_writer, &sample, the_past); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write pre-historic data"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Sample lost should be triggered with the right status. */ triggered = waitfor_cb(DDS_SAMPLE_LOST_STATUS); - cr_assert_eq(triggered & DDS_SAMPLE_LOST_STATUS, DDS_SAMPLE_LOST_STATUS, "DDS_SAMPLE_LOST_STATUS not triggered"); - cr_assert_eq(cb_reader, g_reader); - cr_assert_eq(cb_sample_lost_status.total_count, 1); - cr_assert_eq(cb_sample_lost_status.total_count_change, 1); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_SAMPLE_LOST_STATUS, DDS_SAMPLE_LOST_STATUS); + CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader); + CU_ASSERT_EQUAL_FATAL(cb_sample_lost_status.total_count, 1); + CU_ASSERT_EQUAL_FATAL(cb_sample_lost_status.total_count_change, 1); /* The listener should have swallowed the status. */ ret = dds_read_status(g_reader, &status, DDS_SAMPLE_LOST_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed"); - cr_assert_eq(status, 0); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, 0); } -Test(ddsc_listener, sample_rejected, .init=init_triggering_test, .fini=fini_triggering_test) +CU_Test(ddsc_listener, sample_rejected, .init=init_triggering_test, .fini=fini_triggering_test) { dds_return_t ret; uint32_t triggered; @@ -934,30 +931,30 @@ Test(ddsc_listener, sample_rejected, .init=init_triggering_test, .fini=fini_trig /* We are interested in sample rejected notifications. */ dds_lset_sample_rejected(g_listener, sample_rejected_cb); ret = dds_set_listener(g_reader, g_listener); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set listener"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Write more than resource limits set by the reader. */ ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write data 1"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write data 2"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to write data 3"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Sample lost should be triggered with the right status. */ triggered = waitfor_cb(DDS_SAMPLE_REJECTED_STATUS); - cr_assert_eq(triggered & DDS_SAMPLE_REJECTED_STATUS, DDS_SAMPLE_REJECTED_STATUS, "DDS_SAMPLE_REJECTED_STATUS not triggered"); - cr_assert_eq(cb_reader, g_reader); - cr_assert_eq(cb_sample_rejected_status.total_count, 2); - cr_assert_eq(cb_sample_rejected_status.total_count_change, 1); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_SAMPLE_REJECTED_STATUS, DDS_SAMPLE_REJECTED_STATUS); + CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader); + CU_ASSERT_EQUAL_FATAL(cb_sample_rejected_status.total_count, 2); + CU_ASSERT_EQUAL_FATAL(cb_sample_rejected_status.total_count_change, 1); /* The listener should have swallowed the status. */ ret = dds_read_status(g_reader, &status, DDS_SAMPLE_REJECTED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed"); - cr_assert_eq(status, 0); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, 0); } -Test(ddsc_listener, liveliness_changed, .init=init_triggering_test, .fini=fini_triggering_base) +CU_Test(ddsc_listener, liveliness_changed, .init=init_triggering_test, .fini=fini_triggering_base) { dds_instance_handle_t writer_hdl; dds_return_t ret; @@ -968,22 +965,22 @@ Test(ddsc_listener, liveliness_changed, .init=init_triggering_test, .fini=fini_t /* Get writer handle that should be part of the status. */ ret = dds_get_instance_handle(g_writer, &writer_hdl); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to get prerequisite writer_hdl"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Liveliness changed should be triggered with the right status. */ triggered = waitfor_cb(DDS_LIVELINESS_CHANGED_STATUS); - cr_assert_eq(triggered & DDS_LIVELINESS_CHANGED_STATUS, DDS_LIVELINESS_CHANGED_STATUS, "DDS_LIVELINESS_CHANGED_STATUS not triggered"); - cr_assert_eq(cb_reader, g_reader); - cr_assert_eq(cb_liveliness_changed_status.alive_count, 1); - cr_assert_eq(cb_liveliness_changed_status.alive_count_change, 1); - cr_assert_eq(cb_liveliness_changed_status.not_alive_count, 0); - cr_assert_eq(cb_liveliness_changed_status.not_alive_count_change, 0); - cr_assert_eq(cb_liveliness_changed_status.last_publication_handle, writer_hdl); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_LIVELINESS_CHANGED_STATUS, DDS_LIVELINESS_CHANGED_STATUS); + CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader); + CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.alive_count, 1); + CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.alive_count_change, 1); + CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.not_alive_count, 0); + CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.not_alive_count_change, 0); + CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.last_publication_handle, writer_hdl); /* The listener should have swallowed the status. */ ret = dds_read_status(g_reader, &status, DDS_LIVELINESS_CHANGED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_read_status failed"); - cr_assert_eq(status, 0); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(status, 0); /* Reset the trigger flags. */ cb_called = 0; @@ -993,13 +990,13 @@ Test(ddsc_listener, liveliness_changed, .init=init_triggering_test, .fini=fini_t /* Liveliness changed should be triggered with the right status. */ triggered = waitfor_cb(DDS_LIVELINESS_CHANGED_STATUS); - cr_assert_eq(triggered & DDS_LIVELINESS_CHANGED_STATUS, DDS_LIVELINESS_CHANGED_STATUS, "DDS_LIVELINESS_CHANGED_STATUS not triggered"); - cr_assert_eq(cb_reader, g_reader); - cr_assert_eq(cb_liveliness_changed_status.alive_count, 0); - cr_assert_eq(cb_liveliness_changed_status.alive_count_change, 0); - cr_assert_eq(cb_liveliness_changed_status.not_alive_count, 1); - cr_assert_eq(cb_liveliness_changed_status.not_alive_count_change, 1); - cr_assert_eq(cb_liveliness_changed_status.last_publication_handle, writer_hdl); + CU_ASSERT_EQUAL_FATAL(triggered & DDS_LIVELINESS_CHANGED_STATUS, DDS_LIVELINESS_CHANGED_STATUS); + CU_ASSERT_EQUAL_FATAL(cb_reader, g_reader); + CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.alive_count, 0); + CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.alive_count_change, 0); + CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.not_alive_count, 1); + CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.not_alive_count_change, 1); + CU_ASSERT_EQUAL_FATAL(cb_liveliness_changed_status.last_publication_handle, writer_hdl); } #if 0 @@ -1059,4 +1056,4 @@ Test(ddsc_listener, inconsistent_topic, .init=init_triggering_base, .fini=fini_t dds_delete_qos(g_qos); } #endif -#endif + diff --git a/src/core/ddsc/tests/participant.c b/src/core/ddsc/tests/participant.c index 7122280..a3ae74f 100644 --- a/src/core/ddsc/tests/participant.c +++ b/src/core/ddsc/tests/participant.c @@ -10,30 +10,30 @@ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ #include "ddsc/dds.h" -#include +#include "CUnit/Test.h" #include #include "config_env.h" #include "ddsc/ddsc_project.h" -#define cr_assert_status_eq(s1, s2, ...) cr_assert_eq(dds_err_nr(s1), s2, __VA_ARGS__) +#define cu_assert_status_eq(s1, s2) CU_ASSERT_EQUAL_FATAL(dds_err_nr(s1), s2) -Test(ddsc_participant, create_and_delete) { +CU_Test(ddsc_participant, create_and_delete) { dds_entity_t participant, participant2, participant3; participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant > 0); participant2 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant2, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant2 > 0); dds_delete (participant); dds_delete (participant2); participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant3, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant3 > 0); dds_delete (participant3); @@ -41,32 +41,32 @@ Test(ddsc_participant, create_and_delete) { /* Test for creating participant with no configuration file */ -Test(ddsc_participant, create_with_no_conf_no_env) { +CU_Test(ddsc_participant, create_with_no_conf_no_env) { dds_entity_t participant, participant2, participant3; dds_return_t status; dds_domainid_t domain_id; dds_domainid_t valid_domain=3; const char * env_uri = os_getenv(DDSC_PROJECT_NAME_NOSPACE_CAPS"_URI"); - cr_assert_eq(env_uri, NULL, DDSC_PROJECT_NAME_NOSPACE_CAPS"_URI must be NULL"); + CU_ASSERT_EQUAL_FATAL(env_uri, NULL); //invalid domain participant = dds_create_participant (-2, NULL, NULL); - cr_assert_lt(participant, 0, "Error must be received for invalid domain value"); + CU_ASSERT_FATAL(participant < 0); //valid specific domain value participant2 = dds_create_participant (valid_domain, NULL, NULL); - cr_assert_gt(participant2, 0, "Valid participant must be received for valid specific domain value"); + CU_ASSERT_FATAL(participant2 > 0); status = dds_get_domainid(participant2, &domain_id); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)"); - cr_assert_eq(domain_id, valid_domain, "Retrieved domain ID must be valid"); + cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain); //DDS_DOMAIN_DEFAULT from user participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant3, 0, "Valid participant must be received for DDS_DOMAIN_DEFAULT"); + CU_ASSERT_FATAL(participant3 > 0); status = dds_get_domainid(participant3, &domain_id); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)"); - cr_assert_eq(domain_id, valid_domain, "Retrieved domain ID must be valid"); + cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain); dds_delete(participant2); dds_delete(participant3); @@ -78,50 +78,49 @@ Test(ddsc_participant, create_with_no_conf_no_env) { ////WITH CONF /* Test for creating participant with valid configuration file */ -Test(ddsc_participant, create_with_conf_no_env) { - dds_entity_t participant, participant2, participant3; - dds_return_t status; - dds_domainid_t domain_id; - dds_domainid_t valid_domain=3; +CU_Test(ddsc_participant, create_with_conf_no_env) { + dds_entity_t participant, participant2, participant3; + dds_return_t status; + dds_domainid_t domain_id; + dds_domainid_t valid_domain=3; - static char env_uri_str[1000]; - (void) sprintf(env_uri_str, "%s=%s", DDSC_PROJECT_NAME_NOSPACE_CAPS"_URI", CONFIG_ENV_SIMPLE_UDP); - os_putenv(env_uri_str); + static char env_uri_str[1000]; + (void) sprintf(env_uri_str, "%s=%s", DDSC_PROJECT_NAME_NOSPACE_CAPS"_URI", CONFIG_ENV_SIMPLE_UDP); + os_putenv(env_uri_str); + printf("env_uri_str %s\n", env_uri_str); - static char env_mp_str[100]; - (void) sprintf(env_mp_str, "%s=%s", "MAX_PARTICIPANTS", CONFIG_ENV_MAX_PARTICIPANTS); - os_putenv(env_mp_str); + static char env_mp_str[100]; + (void) sprintf(env_mp_str, "%s=%s", "MAX_PARTICIPANTS", CONFIG_ENV_MAX_PARTICIPANTS); + os_putenv(env_mp_str); + + const char * env_uri = os_getenv(DDSC_PROJECT_NAME_NOSPACE_CAPS"_URI"); + CU_ASSERT_NOT_EQUAL_FATAL(env_uri, NULL); + + //invalid domain + participant = dds_create_participant (1, NULL, NULL); + printf("\n participant is %d\n", participant); + CU_ASSERT_FATAL(participant < 0); + + //valid specific domain value + participant2 = dds_create_participant (valid_domain, NULL, NULL); + CU_ASSERT_FATAL(participant2 > 0); + status = dds_get_domainid(participant2, &domain_id); + cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain); - const char * env_uri = os_getenv(DDSC_PROJECT_NAME_NOSPACE_CAPS"_URI"); - cr_assert_neq(env_uri, NULL, DDSC_PROJECT_NAME_NOSPACE_CAPS"_URI must be set"); - - //invalid domain - participant = dds_create_participant (1, NULL, NULL); - cr_assert_lt(participant, 0, "Error must be received for invalid domain value"); - - //valid specific domain value - participant2 = dds_create_participant (valid_domain, NULL, NULL); - cr_assert_gt(participant2, 0, "Valid participant must be received for valid specific domain value"); - status = dds_get_domainid(participant2, &domain_id); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)"); - cr_assert_eq(domain_id, valid_domain, "Retrieved domain ID must be valid"); - - - //DDS_DOMAIN_DEFAULT from the user - participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant3, 0, "Valid participant must be received for DDS_DOMAIN_DEFAULT"); - status = dds_get_domainid(participant3, &domain_id); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)"); - cr_assert_eq(domain_id, valid_domain, "Retrieved domain ID must be valid"); - - dds_delete(participant2); - dds_delete(participant3); - + //DDS_DOMAIN_DEFAULT from the user + participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); + CU_ASSERT_FATAL(participant3 > 0); + status = dds_get_domainid(participant3, &domain_id); + cu_assert_status_eq(status, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(domain_id, valid_domain); + dds_delete(participant2); + dds_delete(participant3); } -Test(ddsc_participant_lookup, one) { +CU_Test(ddsc_participant_lookup, one) { dds_entity_t participant; dds_entity_t participants[3]; @@ -131,20 +130,20 @@ Test(ddsc_participant_lookup, one) { /* Create a participant */ participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant > 0); /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); num_of_found_pp = dds_lookup_participant( domain_id, participants, size); - cr_assert_eq(num_of_found_pp, 1, "dds_lookup_participant(domain_id, participants, size)"); - cr_assert_eq(participants[0], participant,"dds_lookup_participant did not return the participant"); + CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 1); + CU_ASSERT_EQUAL_FATAL(participants[0], participant); dds_delete (participant); } -Test(ddsc_participant_lookup, multiple) { +CU_Test(ddsc_participant_lookup, multiple) { dds_entity_t participant, participant2; dds_entity_t participants[2]; @@ -154,26 +153,26 @@ Test(ddsc_participant_lookup, multiple) { /* Create participants */ participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant > 0); participant2 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant2, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant2 > 0); /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); num_of_found_pp = dds_lookup_participant( domain_id, participants, size); - cr_assert_eq(num_of_found_pp, 2, "dds_lookup_participant(domain_id, participants, size)"); - cr_assert(participants[0] == participant || participants[0] == participant2,"ddsc_participant_lookup"); - cr_assert(participants[1] == participant || participants[1] == participant2,"ddsc_participant_lookup"); - cr_assert_neq(participants[0], participants[1], "dds_lookup_participant returned a participant twice"); + CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 2); + CU_ASSERT_FATAL(participants[0] == participant || participants[0] == participant2); + CU_ASSERT_FATAL(participants[1] == participant || participants[1] == participant2); + CU_ASSERT_NOT_EQUAL_FATAL(participants[0], participants[1]); dds_delete (participant2); dds_delete (participant); } -Test(ddsc_participant_lookup, array_too_small) { +CU_Test(ddsc_participant_lookup, array_too_small) { dds_entity_t participant, participant2, participant3; dds_entity_t participants[2]; @@ -183,30 +182,30 @@ Test(ddsc_participant_lookup, array_too_small) { /* Create participants */ participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant > 0); participant2 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant2, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant2 > 0); participant3 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant3, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant3 > 0); /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); num_of_found_pp = dds_lookup_participant( domain_id, participants, size); - cr_assert_eq(num_of_found_pp, 3, "dds_lookup_participant(domain_id, participants, size)"); - cr_assert(participants[0] == participant || participants[0] == participant2 || participants[0] == participant3,"ddsc_participant_lookup"); - cr_assert(participants[1] == participant || participants[1] == participant2 || participants[1] == participant3,"ddsc_participant_lookup"); - cr_assert_neq(participants[0], participants[1], "dds_lookup_participant returned a participant twice"); + CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 3); + CU_ASSERT_FATAL(participants[0] == participant || participants[0] == participant2 || participants[0] == participant3); + CU_ASSERT_FATAL(participants[1] == participant || participants[1] == participant2 || participants[1] == participant3); + CU_ASSERT_NOT_EQUAL_FATAL(participants[0], participants[1]); dds_delete (participant3); dds_delete (participant2); dds_delete (participant); } -Test(ddsc_participant_lookup, null_zero){ +CU_Test(ddsc_participant_lookup, null_zero){ dds_entity_t participant; dds_domainid_t domain_id; @@ -215,19 +214,19 @@ Test(ddsc_participant_lookup, null_zero){ /* Create a participant */ participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant > 0); /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); num_of_found_pp = dds_lookup_participant( domain_id, NULL, size); - cr_assert_eq(num_of_found_pp, 1, "dds_lookup_participant(domain_id, participants, size)"); + CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 1); dds_delete (participant); } -Test(ddsc_participant_lookup, null_nonzero){ +CU_Test(ddsc_participant_lookup, null_nonzero){ dds_entity_t participant; dds_domainid_t domain_id; @@ -236,19 +235,19 @@ Test(ddsc_participant_lookup, null_nonzero){ /* Create a participant */ participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant > 0); /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); num_of_found_pp = dds_lookup_participant( domain_id, NULL, size); - cr_assert_status_eq(num_of_found_pp, DDS_RETCODE_BAD_PARAMETER, "dds_lookup_participant did not return bad parameter"); + cu_assert_status_eq(num_of_found_pp, DDS_RETCODE_BAD_PARAMETER); dds_delete (participant); } -Test(ddsc_participant_lookup, unknown_id) { +CU_Test(ddsc_participant_lookup, unknown_id) { dds_entity_t participant; dds_entity_t participants[3]; @@ -258,30 +257,30 @@ Test(ddsc_participant_lookup, unknown_id) { /* Create a participant */ participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant > 0); /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); domain_id ++; num_of_found_pp = dds_lookup_participant( domain_id, participants, size); - cr_assert_eq(num_of_found_pp, 0, "dds_lookup_participant(domain_id, participants, size)"); + CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 0); dds_delete (participant); } -Test(ddsc_participant_lookup, none) { +CU_Test(ddsc_participant_lookup, none) { dds_entity_t participants[2]; dds_return_t num_of_found_pp; size_t size = 2; num_of_found_pp = dds_lookup_participant( 0, participants, size); - cr_assert_eq(num_of_found_pp, 0, "dds_lookup_participant did not return 0"); + CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 0); } -Test(ddsc_participant_lookup, no_more) { +CU_Test(ddsc_participant_lookup, no_more) { dds_entity_t participant; dds_entity_t participants[3]; @@ -291,19 +290,19 @@ Test(ddsc_participant_lookup, no_more) { /* Create a participant */ participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant > 0); /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); dds_delete (participant); num_of_found_pp = dds_lookup_participant( domain_id, participants, size); - cr_assert_eq(num_of_found_pp, 0, "dds_lookup_participant did not return 0"); + CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 0); } -Test(ddsc_participant_lookup, deleted) { +CU_Test(ddsc_participant_lookup, deleted) { dds_entity_t participant, participant2; dds_entity_t participants[2]; @@ -313,20 +312,20 @@ Test(ddsc_participant_lookup, deleted) { /* Create participants */ participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant > 0); participant2 = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant2, 0, "dds_participant_create"); + CU_ASSERT_FATAL(participant2 > 0); /* Get domain id */ status = dds_get_domainid(participant, &domain_id); - cr_assert_status_eq(status, DDS_RETCODE_OK, "dds_get_domainid(participant, domain_id)"); + cu_assert_status_eq(status, DDS_RETCODE_OK); dds_delete (participant2); num_of_found_pp = dds_lookup_participant( domain_id, participants, size); - cr_assert_eq(num_of_found_pp, 1, "dds_lookup_participant did not return one participant"); - cr_assert(participants[0] == participant,"ddsc_participant_lookup"); + CU_ASSERT_EQUAL_FATAL(num_of_found_pp, 1); + CU_ASSERT_FATAL(participants[0] == participant); dds_delete (participant); } diff --git a/src/core/ddsc/tests/publisher.c b/src/core/ddsc/tests/publisher.c index feaca64..a136e7c 100644 --- a/src/core/ddsc/tests/publisher.c +++ b/src/core/ddsc/tests/publisher.c @@ -10,8 +10,7 @@ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ #include "ddsc/dds.h" -#include -#include +#include "CUnit/Test.h" /* We are deliberately testing some bad arguments that SAL will complain about. * So, silence SAL regarding these issues. */ @@ -20,7 +19,7 @@ #pragma warning(disable: 28020) #endif -#define cr_assert_status_eq(s1, s2, ...) cr_assert_eq(dds_err_nr(s1), s2, __VA_ARGS__) +#define cu_assert_status_eq(s1, s2) CU_ASSERT_EQUAL_FATAL(dds_err_nr(s1), s2) /* Dummy callback */ static void data_available_cb(dds_entity_t reader, void* arg) @@ -30,7 +29,7 @@ static void data_available_cb(dds_entity_t reader, void* arg) } -Test(ddsc_publisher, create) +CU_Test(ddsc_publisher, create) { const char *singlePartitions[] = { "partition" }; const char *multiplePartitions[] = { "partition1", "partition2" }; @@ -43,27 +42,27 @@ Test(ddsc_publisher, create) /* Use NULL participant */ publisher = dds_create_publisher(0, NULL, NULL); - cr_assert_eq(dds_err_nr(publisher), DDS_RETCODE_BAD_PARAMETER, "dds_create_publisher(NULL,NULL,NULL)"); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher), DDS_RETCODE_BAD_PARAMETER); participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "dds_create_participant(DDS_DOMAIN_DEFAULT,NULL,NULL)"); + CU_ASSERT_FATAL(participant > 0); /* Use non-null participant */ publisher = dds_create_publisher(participant, NULL, NULL); - cr_assert_gt(publisher, 0, "dds_create_publisher(participant,NULL,NULL)"); + CU_ASSERT_FATAL(publisher > 0); /* Use entity that is not a participant */ publisher1 = dds_create_publisher(publisher, NULL, NULL); - cr_assert_eq(dds_err_nr(publisher1), DDS_RETCODE_ILLEGAL_OPERATION, "dds_create_publisher(publisher,NULL,NULL)"); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(publisher1), DDS_RETCODE_ILLEGAL_OPERATION); dds_delete(publisher); /* Create a non-null qos */ qos = dds_create_qos(); - cr_assert_neq(qos, NULL, "dds_create_qos()"); + CU_ASSERT_NOT_EQUAL_FATAL(qos, NULL); /* Use qos without partition; in that case the default partition should be used */ publisher = dds_create_publisher(participant, qos, NULL); - cr_assert_gt(publisher, 0, "dds_create_publisher(participant,qos,NULL) where qos with default partition"); + CU_ASSERT_FATAL(publisher > 0); dds_delete(publisher); /* Somehow, the compiler thinks the char arrays might not be zero-terminated... */ @@ -75,19 +74,19 @@ Test(ddsc_publisher, create) /* Use qos with single partition */ dds_qset_partition (qos, 1, singlePartitions); publisher = dds_create_publisher(participant, qos, NULL); - cr_assert_gt(publisher, 0, "dds_create_publisher(participant,qos,NULL) where qos with single partition"); + CU_ASSERT_FATAL(publisher > 0); dds_delete(publisher); /* Use qos with multiple partitions */ dds_qset_partition (qos, 2, multiplePartitions); publisher = dds_create_publisher(participant, qos, NULL); - cr_assert_gt(publisher, 0, "dds_create_publisher(participant,qos,NULL) where qos with multiple partitions"); + CU_ASSERT_FATAL(publisher > 0); dds_delete(publisher); /* Use qos with multiple partitions */ dds_qset_partition (qos, 2, duplicatePartitions); publisher = dds_create_publisher(participant, qos, NULL); - cr_assert_gt(publisher, 0, "dds_create_publisher(participant,qos,NULL) where qos with duplicate partitions"); + CU_ASSERT_FATAL(publisher > 0); dds_delete(publisher); #ifdef _MSC_VER @@ -96,9 +95,9 @@ Test(ddsc_publisher, create) /* Use listener(NULL) */ listener = dds_create_listener(NULL); - cr_assert_neq(listener, NULL, "dds_create_listener(NULL)"); + CU_ASSERT_NOT_EQUAL_FATAL(listener, NULL); publisher = dds_create_publisher(participant, NULL, listener); - cr_assert_gt(publisher, 0, "dds_create_publisher(participant,NULL,listener(NULL))"); + CU_ASSERT_FATAL(publisher > 0); dds_delete(publisher); dds_reset_listener(listener); @@ -106,7 +105,7 @@ Test(ddsc_publisher, create) /* Use listener for data_available */ dds_lset_data_available(listener, NULL); publisher = dds_create_publisher(participant, NULL, listener); - cr_assert_gt(publisher, 0, "dds_create_publisher(participant,NULL,listener) with dds_lset_data_available(listener, NULL)"); + CU_ASSERT_FATAL(publisher > 0); dds_delete(publisher); dds_reset_listener(listener); @@ -114,7 +113,7 @@ Test(ddsc_publisher, create) /* Use DDS_LUNSET for data_available */ dds_lset_data_available(listener, DDS_LUNSET); publisher = dds_create_publisher(participant, NULL, listener); - cr_assert_gt(publisher, 0, "dds_create_publisher(participant,NULL,listener) with dds_lset_data_available(listener, DDS_LUNSET)"); + CU_ASSERT_FATAL(publisher > 0); dds_delete(publisher); dds_reset_listener(listener); @@ -122,13 +121,13 @@ Test(ddsc_publisher, create) /* Use callback for data_available */ dds_lset_data_available(listener, data_available_cb); publisher = dds_create_publisher(participant, NULL, listener); - cr_assert_gt(publisher, 0, "dds_create_publisher(participant,NULL,listener) with dds_lset_data_available(listener, data_available_cb)"); + CU_ASSERT_FATAL(publisher > 0); dds_delete(publisher); /* Use both qos setting and callback listener */ dds_lset_data_available(listener, data_available_cb); publisher = dds_create_publisher(participant, qos, listener); - cr_assert_gt(publisher, 0, "dds_create_publisher(participant,qos,listener) with dds_lset_data_available(listener, data_available_cb)"); + CU_ASSERT(publisher > 0); dds_delete(publisher); dds_delete_listener(listener); @@ -136,7 +135,7 @@ Test(ddsc_publisher, create) dds_delete (participant); } -Test(ddsc_publisher, suspend_resume) +CU_Test(ddsc_publisher, suspend_resume) { dds_entity_t participant, publisher; @@ -144,35 +143,35 @@ Test(ddsc_publisher, suspend_resume) /* Suspend a 0 publisher */ status = dds_suspend(0); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_suspend(NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Resume a 0 publisher */ status = dds_resume(0); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_resume(NULL)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Uae dds_suspend on something else than a publisher */ participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "dds_create_participant(DDS_DOMAIN_DEFAULT,NULL,NULL)"); + CU_ASSERT_FATAL(participant > 0); status = dds_suspend(participant); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_suspend(participant)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Use dds_resume on something else than a publisher */ status = dds_resume(participant); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_resume(participant)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Use dds_resume without calling dds_suspend */ publisher = dds_create_publisher(participant, NULL, NULL); - cr_assert_gt(publisher, 0, "dds_create_publisher(participant,NULL,NULL)"); + CU_ASSERT_FATAL(publisher > 0); status = dds_resume(publisher); /* Should be precondition not met? */ - cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_resume(publisher) without prior suspend"); + cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); /* Use dds_suspend on non-null publisher */ status = dds_suspend(publisher); - cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_suspend(publisher)"); + cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); /* Use dds_resume on non-null publisher */ status = dds_resume(publisher); - cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_resume(publisher)"); + cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); dds_delete(publisher); dds_delete(participant); @@ -180,7 +179,7 @@ Test(ddsc_publisher, suspend_resume) return; } -Test(ddsc_publisher, wait_for_acks) +CU_Test(ddsc_publisher, wait_for_acks) { dds_entity_t participant, publisher; dds_return_t status; @@ -190,78 +189,78 @@ Test(ddsc_publisher, wait_for_acks) /* Wait_for_acks on 0 publisher or writer and minusOneSec timeout */ status = dds_wait_for_acks(0, minusOneSec); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(NULL,-1)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Wait_for_acks on NULL publisher or writer and zeroSec timeout */ status = dds_wait_for_acks(0, zeroSec); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(NULL,0)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* wait_for_acks on NULL publisher or writer and oneSec timeout */ status = dds_wait_for_acks(0, oneSec); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(NULL,1)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* wait_for_acks on NULL publisher or writer and DDS_INFINITE timeout */ status = dds_wait_for_acks(0, DDS_INFINITY); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(NULL,DDS_INFINITY)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); participant = dds_create_participant (DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "dds_create_participant(DDS_DOMAIN_DEFAULT,NULL,NULL)"); + CU_ASSERT_FATAL(participant > 0); /* Wait_for_acks on participant and minusOneSec timeout */ status = dds_wait_for_acks(participant, minusOneSec); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(participant,-1)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Wait_for_acks on participant and zeroSec timeout */ status = dds_wait_for_acks(participant, zeroSec); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(participant,0)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Wait_for_acks on participant and oneSec timeout */ status = dds_wait_for_acks(participant, oneSec); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(participant,1)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); /* Wait_for_acks on participant and DDS_INFINITE timeout */ status = dds_wait_for_acks(participant, DDS_INFINITY); - cr_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER, "dds_wait_for_acks(participant,DDS_INFINITY)"); + cu_assert_status_eq(status, DDS_RETCODE_BAD_PARAMETER); publisher = dds_create_publisher(participant, NULL, NULL); - cr_assert_gt(publisher, 0, "dds_create_publisher(participant,NULL,NULL)"); + CU_ASSERT_FATAL(publisher > 0); /* Wait_for_acks on publisher and minusOneSec timeout */ status = dds_wait_for_acks(publisher, minusOneSec); - cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(publisher,-1)"); + cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); /* Wait_for_acks on publisher and zeroSec timeout */ status = dds_wait_for_acks(publisher, zeroSec); - cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(publisher,0)"); + cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); /* Wait_for_acks on publisher and oneSec timeout */ status = dds_wait_for_acks(publisher, oneSec); - cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(publisher,1)"); + cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); /* Wait_for_acks on publisher and DDS_INFINITE timeout */ status = dds_wait_for_acks(publisher, DDS_INFINITY); - cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(publisher,DDS_INFINITY)"); + cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); /* TODO: create tests by calling dds_qwait_for_acks on writers */ status = dds_suspend(publisher); - cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_suspend(publisher)"); + cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); /* Wait_for_acks on suspended publisher and minusOneSec timeout */ status = dds_wait_for_acks(publisher, minusOneSec); - cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(suspended_publisher,-1)"); + cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); /* Wait_for_acks on suspended publisher and zeroSec timeout */ status = dds_wait_for_acks(publisher, zeroSec); - cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(suspended_publisher,0)"); + cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); /* Wait_for_acks on suspended publisher and oneSec timeout */ status = dds_wait_for_acks(publisher, oneSec); - cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(suspended_publisher,1)"); + cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); /* Wait_for_acks on suspended publisher and DDS_INFINITE timeout */ status = dds_wait_for_acks(publisher, DDS_INFINITY); - cr_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED, "dds_wait_for_acks(suspended_publisher,DDS_INFINITY)"); + cu_assert_status_eq(status, DDS_RETCODE_UNSUPPORTED); dds_delete(publisher); dds_delete(participant); @@ -269,7 +268,7 @@ Test(ddsc_publisher, wait_for_acks) return; } -Test(ddsc_publisher, coherency) +CU_Test(ddsc_publisher, coherency) { return; } diff --git a/src/core/ddsc/tests/qos.c b/src/core/ddsc/tests/qos.c index 6219a08..5886f3a 100644 --- a/src/core/ddsc/tests/qos.c +++ b/src/core/ddsc/tests/qos.c @@ -9,10 +9,9 @@ * * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ +#include "CUnit/Test.h" #include "ddsc/dds.h" #include "os/os.h" -#include -#include /* We are deliberately testing some bad arguments that SAL will complain about. * So, silence SAL regarding these issues. */ @@ -168,7 +167,7 @@ static void qos_init(void) { g_qos = dds_create_qos(); - cr_assert_not_null(g_qos); + CU_ASSERT_PTR_NOT_NULL_FATAL(g_qos); g_pol_userdata.value = (void*)c_userdata; g_pol_userdata.sz = strlen((char*)g_pol_userdata.value) + 1; @@ -239,46 +238,46 @@ qos_fini(void) /**************************************************************************** * API tests ****************************************************************************/ -Test(ddsc_qos, copy_bad_source, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, copy_bad_source, .init=qos_init, .fini=qos_fini) { dds_return_t result; result = dds_copy_qos(g_qos, NULL); - cr_assert_eq(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(result)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER); } -Test(ddsc_qos, copy_bad_destination, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, copy_bad_destination, .init=qos_init, .fini=qos_fini) { dds_return_t result; result = dds_copy_qos(NULL, g_qos); - cr_assert_eq(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(result)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER); } -Test(ddsc_qos, copy_with_partition, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, copy_with_partition, .init=qos_init, .fini=qos_fini) { dds_return_t result; dds_qos_t *qos; struct pol_partition p = { 0, NULL }; qos = dds_create_qos(); - cr_assert_not_null(qos); + CU_ASSERT_PTR_NOT_NULL_FATAL(qos); dds_qset_partition(g_qos, g_pol_partition.n, (const char **)g_pol_partition.ps); result = dds_copy_qos(qos, g_qos); - cr_assert_eq(result, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(result, DDS_RETCODE_OK); dds_qget_partition(qos, &p.n, &p.ps); - cr_assert_eq(p.n, g_pol_partition.n); + CU_ASSERT_EQUAL_FATAL(p.n, g_pol_partition.n); for (uint32_t cnt = 0; cnt < p.n; cnt++) { - cr_assert_str_eq(p.ps[cnt], g_pol_partition.ps[cnt]); + CU_ASSERT_STRING_EQUAL_FATAL(p.ps[cnt], g_pol_partition.ps[cnt]); } dds_delete_qos(qos); } -Test(ddsc_qos, userdata, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, userdata, .init=qos_init, .fini=qos_fini) { struct pol_userdata p = { NULL, 0 }; @@ -290,13 +289,13 @@ Test(ddsc_qos, userdata, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_userdata(g_qos, g_pol_userdata.value, g_pol_userdata.sz); dds_qget_userdata(g_qos, &p.value, &p.sz); - cr_assert_eq(p.sz, g_pol_userdata.sz); - cr_assert_str_eq(p.value, g_pol_userdata.value); + CU_ASSERT_EQUAL_FATAL(p.sz, g_pol_userdata.sz); + CU_ASSERT_STRING_EQUAL_FATAL(p.value, g_pol_userdata.value); dds_free(p.value); } -Test(ddsc_qos, topicdata, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, topicdata, .init=qos_init, .fini=qos_fini) { struct pol_topicdata p = { NULL, 0 }; @@ -308,13 +307,13 @@ Test(ddsc_qos, topicdata, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_topicdata(g_qos, g_pol_topicdata.value, g_pol_topicdata.sz); dds_qget_topicdata(g_qos, &p.value, &p.sz); - cr_assert_eq(p.sz, g_pol_topicdata.sz); - cr_assert_str_eq(p.value, g_pol_topicdata.value); + CU_ASSERT_EQUAL_FATAL(p.sz, g_pol_topicdata.sz); + CU_ASSERT_STRING_EQUAL_FATAL(p.value, g_pol_topicdata.value); dds_free(p.value); } -Test(ddsc_qos, groupdata, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, groupdata, .init=qos_init, .fini=qos_fini) { struct pol_groupdata p = { NULL, 0 }; @@ -326,13 +325,13 @@ Test(ddsc_qos, groupdata, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_groupdata(g_qos, g_pol_groupdata.value, g_pol_groupdata.sz); dds_qget_groupdata(g_qos, &p.value, &p.sz); - cr_assert_eq(p.sz, g_pol_groupdata.sz); - cr_assert_str_eq(p.value, g_pol_groupdata.value); + CU_ASSERT_EQUAL_FATAL(p.sz, g_pol_groupdata.sz); + CU_ASSERT_STRING_EQUAL_FATAL(p.value, g_pol_groupdata.value); dds_free(p.value); } -Test(ddsc_qos, durability, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, durability, .init=qos_init, .fini=qos_fini) { struct pol_durability p = { DDS_DURABILITY_VOLATILE }; @@ -344,10 +343,10 @@ Test(ddsc_qos, durability, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_durability(g_qos, g_pol_durability.kind); dds_qget_durability(g_qos, &p.kind); - cr_assert_eq(p.kind, g_pol_durability.kind); + CU_ASSERT_EQUAL_FATAL(p.kind, g_pol_durability.kind); } -Test(ddsc_qos, history, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, history, .init=qos_init, .fini=qos_fini) { struct pol_history p = { DDS_HISTORY_KEEP_ALL, 0 }; @@ -359,11 +358,11 @@ Test(ddsc_qos, history, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_history(g_qos, g_pol_history.kind, g_pol_history.depth); dds_qget_history(g_qos, &p.kind, &p.depth); - cr_assert_eq(p.kind, g_pol_history.kind); - cr_assert_eq(p.depth, g_pol_history.depth); + CU_ASSERT_EQUAL_FATAL(p.kind, g_pol_history.kind); + CU_ASSERT_EQUAL_FATAL(p.depth, g_pol_history.depth); } -Test(ddsc_qos, resource_limits, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, resource_limits, .init=qos_init, .fini=qos_fini) { struct pol_resource_limits p = { 0, 0, 0 }; @@ -375,12 +374,12 @@ Test(ddsc_qos, resource_limits, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_resource_limits(g_qos, g_pol_resource_limits.max_samples, g_pol_resource_limits.max_instances, g_pol_resource_limits.max_samples_per_instance); dds_qget_resource_limits(g_qos, &p.max_samples, &p.max_instances, &p.max_samples_per_instance); - cr_assert_eq(p.max_samples, g_pol_resource_limits.max_samples); - cr_assert_eq(p.max_instances, g_pol_resource_limits.max_instances); - cr_assert_eq(p.max_samples_per_instance, g_pol_resource_limits.max_samples_per_instance); + CU_ASSERT_EQUAL_FATAL(p.max_samples, g_pol_resource_limits.max_samples); + CU_ASSERT_EQUAL_FATAL(p.max_instances, g_pol_resource_limits.max_instances); + CU_ASSERT_EQUAL_FATAL(p.max_samples_per_instance, g_pol_resource_limits.max_samples_per_instance); } -Test(ddsc_qos, presentation, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, presentation, .init=qos_init, .fini=qos_fini) { struct pol_presentation p = { DDS_PRESENTATION_INSTANCE, false, false }; @@ -392,12 +391,12 @@ Test(ddsc_qos, presentation, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_presentation(g_qos, g_pol_presentation.access_scope, g_pol_presentation.coherent_access, g_pol_presentation.ordered_access); dds_qget_presentation(g_qos, &p.access_scope, &p.coherent_access, &p.ordered_access); - cr_assert_eq(p.access_scope, g_pol_presentation.access_scope); - cr_assert_eq(p.coherent_access, g_pol_presentation.coherent_access); - cr_assert_eq(p.ordered_access, g_pol_presentation.ordered_access); + CU_ASSERT_EQUAL_FATAL(p.access_scope, g_pol_presentation.access_scope); + CU_ASSERT_EQUAL_FATAL(p.coherent_access, g_pol_presentation.coherent_access); + CU_ASSERT_EQUAL_FATAL(p.ordered_access, g_pol_presentation.ordered_access); } -Test(ddsc_qos, lifespan, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, lifespan, .init=qos_init, .fini=qos_fini) { struct pol_lifespan p = { 0 }; @@ -409,10 +408,10 @@ Test(ddsc_qos, lifespan, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_lifespan(g_qos, g_pol_lifespan.lifespan); dds_qget_lifespan(g_qos, &p.lifespan); - cr_assert_eq(p.lifespan, g_pol_lifespan.lifespan); + CU_ASSERT_EQUAL_FATAL(p.lifespan, g_pol_lifespan.lifespan); } -Test(ddsc_qos, deadline, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, deadline, .init=qos_init, .fini=qos_fini) { struct pol_deadline p = { 0 }; @@ -424,10 +423,10 @@ Test(ddsc_qos, deadline, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_deadline(g_qos, g_pol_deadline.deadline); dds_qget_deadline(g_qos, &p.deadline); - cr_assert_eq(p.deadline, g_pol_deadline.deadline); + CU_ASSERT_EQUAL_FATAL(p.deadline, g_pol_deadline.deadline); } -Test(ddsc_qos, latency_budget, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, latency_budget, .init=qos_init, .fini=qos_fini) { struct pol_latency_budget p = { 0 }; @@ -439,10 +438,10 @@ Test(ddsc_qos, latency_budget, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_latency_budget(g_qos, g_pol_latency_budget.duration); dds_qget_latency_budget(g_qos, &p.duration); - cr_assert_eq(p.duration, g_pol_latency_budget.duration); + CU_ASSERT_EQUAL_FATAL(p.duration, g_pol_latency_budget.duration); } -Test(ddsc_qos, ownership, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, ownership, .init=qos_init, .fini=qos_fini) { struct pol_ownership p = { DDS_OWNERSHIP_SHARED }; @@ -454,10 +453,10 @@ Test(ddsc_qos, ownership, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_ownership(g_qos, g_pol_ownership.kind); dds_qget_ownership(g_qos, &p.kind); - cr_assert_eq(p.kind, g_pol_ownership.kind); + CU_ASSERT_EQUAL_FATAL(p.kind, g_pol_ownership.kind); } -Test(ddsc_qos, ownership_strength, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, ownership_strength, .init=qos_init, .fini=qos_fini) { struct pol_ownership_strength p = { 0 }; @@ -469,10 +468,10 @@ Test(ddsc_qos, ownership_strength, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_ownership_strength(g_qos, g_pol_ownership_strength.value); dds_qget_ownership_strength(g_qos, &p.value); - cr_assert_eq(p.value, g_pol_ownership_strength.value); + CU_ASSERT_EQUAL_FATAL(p.value, g_pol_ownership_strength.value); } -Test(ddsc_qos, liveliness, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, liveliness, .init=qos_init, .fini=qos_fini) { struct pol_liveliness p = { DDS_LIVELINESS_AUTOMATIC, 0 }; @@ -484,11 +483,11 @@ Test(ddsc_qos, liveliness, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_liveliness(g_qos, g_pol_liveliness.kind, g_pol_liveliness.lease_duration); dds_qget_liveliness(g_qos, &p.kind, &p.lease_duration); - cr_assert_eq(p.kind, g_pol_liveliness.kind); - cr_assert_eq(p.lease_duration, g_pol_liveliness.lease_duration); + CU_ASSERT_EQUAL_FATAL(p.kind, g_pol_liveliness.kind); + CU_ASSERT_EQUAL_FATAL(p.lease_duration, g_pol_liveliness.lease_duration); } -Test(ddsc_qos, time_base_filter, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, time_base_filter, .init=qos_init, .fini=qos_fini) { struct pol_time_based_filter p = { 0 }; @@ -500,10 +499,10 @@ Test(ddsc_qos, time_base_filter, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_time_based_filter(g_qos, g_pol_time_based_filter.minimum_separation); dds_qget_time_based_filter(g_qos, &p.minimum_separation); - cr_assert_eq(p.minimum_separation, g_pol_time_based_filter.minimum_separation); + CU_ASSERT_EQUAL_FATAL(p.minimum_separation, g_pol_time_based_filter.minimum_separation); } -Test(ddsc_qos, partition, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, partition, .init=qos_init, .fini=qos_fini) { struct pol_partition p = { 0, NULL }; @@ -515,17 +514,17 @@ Test(ddsc_qos, partition, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_partition(g_qos, g_pol_partition.n, c_partitions); dds_qget_partition(g_qos, &p.n, &p.ps); - cr_assert_eq(p.n, 2); - cr_assert_eq(p.n, g_pol_partition.n); - cr_assert_str_eq(p.ps[0], g_pol_partition.ps[0]); - cr_assert_str_eq(p.ps[1], g_pol_partition.ps[1]); + CU_ASSERT_EQUAL_FATAL(p.n, 2); + CU_ASSERT_EQUAL_FATAL(p.n, g_pol_partition.n); + CU_ASSERT_STRING_EQUAL_FATAL(p.ps[0], g_pol_partition.ps[0]); + CU_ASSERT_STRING_EQUAL_FATAL(p.ps[1], g_pol_partition.ps[1]); dds_free(p.ps[0]); dds_free(p.ps[1]); dds_free(p.ps); } -Test(ddsc_qos, reliability, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, reliability, .init=qos_init, .fini=qos_fini) { struct pol_reliability p = { DDS_RELIABILITY_BEST_EFFORT, 0 }; @@ -537,11 +536,11 @@ Test(ddsc_qos, reliability, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_reliability(g_qos, g_pol_reliability.kind, g_pol_reliability.max_blocking_time); dds_qget_reliability(g_qos, &p.kind, &p.max_blocking_time); - cr_assert_eq(p.kind, g_pol_reliability.kind); - cr_assert_eq(p.max_blocking_time, g_pol_reliability.max_blocking_time); + CU_ASSERT_EQUAL_FATAL(p.kind, g_pol_reliability.kind); + CU_ASSERT_EQUAL_FATAL(p.max_blocking_time, g_pol_reliability.max_blocking_time); } -Test(ddsc_qos, transport_priority, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, transport_priority, .init=qos_init, .fini=qos_fini) { struct pol_transport_priority p = { 0 }; @@ -553,10 +552,10 @@ Test(ddsc_qos, transport_priority, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_transport_priority(g_qos, g_pol_transport_priority.value); dds_qget_transport_priority(g_qos, &p.value); - cr_assert_eq(p.value, g_pol_transport_priority.value); + CU_ASSERT_EQUAL_FATAL(p.value, g_pol_transport_priority.value); } -Test(ddsc_qos, destination_order, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, destination_order, .init=qos_init, .fini=qos_fini) { struct pol_destination_order p = { DDS_DESTINATIONORDER_BY_RECEPTION_TIMESTAMP }; @@ -568,10 +567,10 @@ Test(ddsc_qos, destination_order, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_destination_order(g_qos, g_pol_destination_order.kind); dds_qget_destination_order(g_qos, &p.kind); - cr_assert_eq(p.kind, g_pol_destination_order.kind); + CU_ASSERT_EQUAL_FATAL(p.kind, g_pol_destination_order.kind); } -Test(ddsc_qos, writer_data_lifecycle, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, writer_data_lifecycle, .init=qos_init, .fini=qos_fini) { struct pol_writer_data_lifecycle p = { false }; @@ -583,10 +582,10 @@ Test(ddsc_qos, writer_data_lifecycle, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_writer_data_lifecycle(g_qos, g_pol_writer_data_lifecycle.autodispose); dds_qget_writer_data_lifecycle(g_qos, &p.autodispose); - cr_assert_eq(p.autodispose, g_pol_writer_data_lifecycle.autodispose); + CU_ASSERT_EQUAL_FATAL(p.autodispose, g_pol_writer_data_lifecycle.autodispose); } -Test(ddsc_qos, reader_data_lifecycle, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, reader_data_lifecycle, .init=qos_init, .fini=qos_fini) { struct pol_reader_data_lifecycle p = { 0, 0 }; @@ -598,11 +597,11 @@ Test(ddsc_qos, reader_data_lifecycle, .init=qos_init, .fini=qos_fini) /* Getting after setting, should yield the original input. */ dds_qset_reader_data_lifecycle(g_qos, g_pol_reader_data_lifecycle.autopurge_nowriter_samples_delay, g_pol_reader_data_lifecycle.autopurge_disposed_samples_delay); dds_qget_reader_data_lifecycle(g_qos, &p.autopurge_nowriter_samples_delay, &p.autopurge_disposed_samples_delay); - cr_assert_eq(p.autopurge_nowriter_samples_delay, g_pol_reader_data_lifecycle.autopurge_nowriter_samples_delay); - cr_assert_eq(p.autopurge_disposed_samples_delay, g_pol_reader_data_lifecycle.autopurge_disposed_samples_delay); + CU_ASSERT_EQUAL_FATAL(p.autopurge_nowriter_samples_delay, g_pol_reader_data_lifecycle.autopurge_nowriter_samples_delay); + CU_ASSERT_EQUAL_FATAL(p.autopurge_disposed_samples_delay, g_pol_reader_data_lifecycle.autopurge_disposed_samples_delay); } -Test(ddsc_qos, durability_service, .init=qos_init, .fini=qos_fini) +CU_Test(ddsc_qos, durability_service, .init=qos_init, .fini=qos_fini) { struct pol_durability_service p = { 0, DDS_HISTORY_KEEP_LAST, 0, 0, 0, 0 }; @@ -644,12 +643,12 @@ Test(ddsc_qos, durability_service, .init=qos_init, .fini=qos_fini) &p.max_samples, &p.max_instances, &p.max_samples_per_instance); - cr_assert_eq(p.service_cleanup_delay, g_pol_durability_service.service_cleanup_delay); - cr_assert_eq(p.history_kind, g_pol_durability_service.history_kind); - cr_assert_eq(p.history_depth, g_pol_durability_service.history_depth); - cr_assert_eq(p.max_samples, g_pol_durability_service.max_samples); - cr_assert_eq(p.max_instances, g_pol_durability_service.max_instances); - cr_assert_eq(p.max_samples_per_instance, g_pol_durability_service.max_samples_per_instance); + CU_ASSERT_EQUAL_FATAL(p.service_cleanup_delay, g_pol_durability_service.service_cleanup_delay); + CU_ASSERT_EQUAL_FATAL(p.history_kind, g_pol_durability_service.history_kind); + CU_ASSERT_EQUAL_FATAL(p.history_depth, g_pol_durability_service.history_depth); + CU_ASSERT_EQUAL_FATAL(p.max_samples, g_pol_durability_service.max_samples); + CU_ASSERT_EQUAL_FATAL(p.max_instances, g_pol_durability_service.max_instances); + CU_ASSERT_EQUAL_FATAL(p.max_samples_per_instance, g_pol_durability_service.max_samples_per_instance); } #ifdef _MSC_VER diff --git a/src/core/ddsc/tests/querycondition.c b/src/core/ddsc/tests/querycondition.c index ac95a4e..8b486f4 100644 --- a/src/core/ddsc/tests/querycondition.c +++ b/src/core/ddsc/tests/querycondition.c @@ -11,22 +11,10 @@ */ #include "ddsc/dds.h" #include "os/os.h" -#include -#include -#include +#include "CUnit/Test.h" +#include "CUnit/Theory.h" #include "Space.h" -/* Add --verbose command line argument to get the cr_log_info traces (if there are any). */ - -//#define VERBOSE_INIT -#ifdef VERBOSE_INIT -#define PRINT_SAMPLE(info, sample) cr_log_info("%s (%d, %d, %d)\n", info, sample.long_1, sample.long_2, sample.long_3); -#else -#define PRINT_SAMPLE(info, sample) -#endif - - - /************************************************************************************************** * * Test fixtures @@ -96,45 +84,45 @@ querycondition_init(void) char name[100]; g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0); g_waitset = dds_create_waitset(g_participant); - cr_assert_gt(g_waitset, 0, "Failed to create g_waitset"); + CU_ASSERT_FATAL(g_waitset > 0); g_topic = dds_create_topic(g_participant, &Space_Type1_desc, create_topic_name("ddsc_querycondition_test", name, sizeof name), NULL, NULL); - cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic"); + CU_ASSERT_FATAL(g_topic > 0); /* Create a reader that keeps last sample of all instances. */ dds_qset_history(qos, DDS_HISTORY_KEEP_LAST, 1); g_reader = dds_create_reader(g_participant, g_topic, qos, NULL); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite g_reader"); + CU_ASSERT_FATAL(g_reader > 0); /* Create a reader that will not automatically dispose unregistered samples. */ dds_qset_writer_data_lifecycle(qos, false); g_writer = dds_create_writer(g_participant, g_topic, qos, NULL); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer"); + CU_ASSERT_FATAL(g_writer > 0); /* Sync g_reader to g_writer. */ ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_reader r"); - cr_assert_eq(g_reader, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_reader a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_reader, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Sync g_writer to g_reader. */ ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_writer status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_writer, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_writer r"); - cr_assert_eq(g_writer, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_writer a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_writer, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Initialize reading buffers. */ memset (g_data, 0, sizeof (g_data)); @@ -149,29 +137,25 @@ querycondition_init(void) sample.long_2 = i/2; sample.long_3 = i/3; - PRINT_SAMPLE("INIT: Write ", sample); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); if (ist == DDS_IST_NOT_ALIVE_DISPOSED) { - PRINT_SAMPLE("INIT: Dispose ", sample); ret = dds_dispose(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite dispose"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } if (ist == DDS_IST_NOT_ALIVE_NO_WRITERS) { - PRINT_SAMPLE("INIT: Unregister", sample); ret = dds_unregister_instance(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite unregister"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } } /* Read samples to get read&old_view states. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, SAMPLE_LAST_OLD_VST + 1); - cr_assert_eq(ret, SAMPLE_LAST_OLD_VST + 1, "Failed prerequisite read"); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_LAST_OLD_VST + 1); #ifdef VERBOSE_INIT for(int i = 0; i < ret; i++) { Space_Type1 *s = (Space_Type1*)g_samples[i]; - PRINT_SAMPLE("INIT: Read ", (*s)); } #endif @@ -182,19 +166,16 @@ querycondition_init(void) sample.long_2 = i/2; sample.long_3 = i/3; - PRINT_SAMPLE("INIT: Rewrite ", sample); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); if ((ist == DDS_IST_NOT_ALIVE_DISPOSED) && (i != 4)) { - PRINT_SAMPLE("INIT: Dispose ", sample); ret = dds_dispose(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite dispose"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } if (ist == DDS_IST_NOT_ALIVE_NO_WRITERS) { - PRINT_SAMPLE("INIT: Unregister", sample); ret = dds_unregister_instance(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite unregister"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } } @@ -212,15 +193,13 @@ querycondition_fini(void) } -#if 0 -#else /************************************************************************************************** * * These will check the querycondition creation in various ways. * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_create, second, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_create, second, .init=querycondition_init, .fini=querycondition_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t cond1; @@ -228,57 +207,57 @@ Test(ddsc_querycondition_create, second, .init=querycondition_init, .fini=queryc dds_return_t ret; cond1 = dds_create_querycondition(g_reader, mask, filter_mod2); - cr_assert_gt(cond1, 0, "dds_create_querycondition(): returned %d", dds_err_nr(cond1)); + CU_ASSERT_FATAL(cond1 > 0); cond2 = dds_create_querycondition(g_reader, mask, filter_mod2); - cr_assert_gt(cond2, 0, "dds_create_querycondition(): returned %d", dds_err_nr(cond2)); + CU_ASSERT_FATAL(cond2 > 0); /* Also, we should be able to delete both. */ ret = dds_delete(cond1); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_delete(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* And, of course, be able to delete the first one (return code isn't checked in the test fixtures). */ ret = dds_delete(cond2); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_delete(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_create, deleted_reader, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_create, deleted_reader, .init=querycondition_init, .fini=querycondition_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t cond; dds_delete(g_reader); cond = dds_create_querycondition(g_reader, mask, filter_mod2); - cr_assert_eq(dds_err_nr(cond), DDS_RETCODE_ALREADY_DELETED, "dds_create_querycondition(): returned %d", dds_err_nr(cond)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_querycondition_create, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_querycondition_create, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_querycondition_create, invalid_readers, .init=querycondition_init, .fini=querycondition_fini) +CU_Theory((dds_entity_t rdr), ddsc_querycondition_create, invalid_readers, .init=querycondition_init, .fini=querycondition_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t cond; cond = dds_create_querycondition(rdr, mask, filter_mod2); - cr_assert_eq(dds_err_nr(cond), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(cond), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_querycondition_create, non_readers) = { - DataPoints(dds_entity_t*, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_querycondition_create, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_topic, &g_participant), }; -Theory((dds_entity_t *rdr), ddsc_querycondition_create, non_readers, .init=querycondition_init, .fini=querycondition_fini) +CU_Theory((dds_entity_t *rdr), ddsc_querycondition_create, non_readers, .init=querycondition_init, .fini=querycondition_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t cond; cond = dds_create_querycondition(*rdr, mask, filter_mod2); - cr_assert_eq(dds_err_nr(cond), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(cond)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -292,71 +271,71 @@ Theory((dds_entity_t *rdr), ddsc_querycondition_create, non_readers, .init=query * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_get_mask, deleted, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_get_mask, deleted, .init=querycondition_init, .fini=querycondition_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t condition; dds_return_t ret; condition = dds_create_querycondition(g_reader, mask, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); dds_delete(condition); mask = 0; ret = dds_get_mask(condition, &mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_get_mask, null, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_get_mask, null, .init=querycondition_init, .fini=querycondition_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t condition; dds_return_t ret; condition = dds_create_querycondition(g_reader, mask, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_get_mask(condition, NULL); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); dds_delete(condition); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_querycondition_get_mask, invalid_conditions) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_querycondition_get_mask, invalid_conditions) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t cond), ddsc_querycondition_get_mask, invalid_conditions, .init=querycondition_init, .fini=querycondition_fini) +CU_Theory((dds_entity_t cond), ddsc_querycondition_get_mask, invalid_conditions, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; uint32_t mask; ret = dds_get_mask(cond, &mask); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_querycondition_get_mask, non_conditions) = { - DataPoints(dds_entity_t*, &g_reader, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_querycondition_get_mask, non_conditions) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_topic, &g_participant), }; -Theory((dds_entity_t *cond), ddsc_querycondition_get_mask, non_conditions, .init=querycondition_init, .fini=querycondition_fini) +CU_Theory((dds_entity_t *cond), ddsc_querycondition_get_mask, non_conditions, .init=querycondition_init, .fini=querycondition_fini) { dds_return_t ret; uint32_t mask; ret = dds_get_mask(*cond, &mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_querycondition_get_mask, various_masks) = { - DataPoints(uint32_t, DDS_ANY_SAMPLE_STATE, DDS_READ_SAMPLE_STATE, DDS_NOT_READ_SAMPLE_STATE), - DataPoints(uint32_t, DDS_ANY_VIEW_STATE, DDS_NEW_VIEW_STATE, DDS_NOT_NEW_VIEW_STATE), - DataPoints(uint32_t, DDS_ANY_INSTANCE_STATE, DDS_ALIVE_INSTANCE_STATE, DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE), +CU_TheoryDataPoints(ddsc_querycondition_get_mask, various_masks) = { + CU_DataPoints(uint32_t, DDS_ANY_SAMPLE_STATE, DDS_READ_SAMPLE_STATE, DDS_NOT_READ_SAMPLE_STATE), + CU_DataPoints(uint32_t, DDS_ANY_VIEW_STATE, DDS_NEW_VIEW_STATE, DDS_NOT_NEW_VIEW_STATE), + CU_DataPoints(uint32_t, DDS_ANY_INSTANCE_STATE, DDS_ALIVE_INSTANCE_STATE, DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE), }; -Theory((uint32_t ss, uint32_t vs, uint32_t is), ddsc_querycondition_get_mask, various_masks, .init=querycondition_init, .fini=querycondition_fini) +CU_Theory((uint32_t ss, uint32_t vs, uint32_t is), ddsc_querycondition_get_mask, various_masks, .init=querycondition_init, .fini=querycondition_fini) { uint32_t maskIn = ss | vs | is; uint32_t maskOut = 0xFFFFFFFF; @@ -364,11 +343,11 @@ Theory((uint32_t ss, uint32_t vs, uint32_t is), ddsc_querycondition_get_mask, va dds_return_t ret; condition = dds_create_querycondition(g_reader, maskIn, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); ret = dds_get_mask(condition, &maskOut); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); - cr_assert_eq(maskIn, maskOut); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(maskIn, maskOut); dds_delete(condition); } @@ -383,18 +362,18 @@ Theory((uint32_t ss, uint32_t vs, uint32_t is), ddsc_querycondition_get_mask, va * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_read, any, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_read, any, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all samples that matches filter. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 4, "# read %d, expected %d", ret, 4); + CU_ASSERT_EQUAL_FATAL(ret, 4); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -409,7 +388,6 @@ Test(ddsc_querycondition_read, any, .init=querycondition_init, .fini=querycondit * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_querycondition_read::any: Read", (*sample)); /* Expected states. */ int expected_long_1 = i * 2; @@ -418,15 +396,15 @@ Test(ddsc_querycondition_read, any, .init=querycondition_init, .fini=querycondit dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -434,18 +412,18 @@ Test(ddsc_querycondition_read, any, .init=querycondition_init, .fini=querycondit /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_read, not_read_sample_state, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_read, not_read_sample_state, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all non-read samples and matches filter. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -460,7 +438,6 @@ Test(ddsc_querycondition_read, not_read_sample_state, .init=querycondition_init, * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_querycondition_read::not_read_sample_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i == 0) ? 4 : 6; @@ -469,15 +446,15 @@ Test(ddsc_querycondition_read, not_read_sample_state, .init=querycondition_init, dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -485,18 +462,18 @@ Test(ddsc_querycondition_read, not_read_sample_state, .init=querycondition_init, /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_read, read_sample_state, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_read, read_sample_state, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all already read samples and matches filter. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -511,7 +488,6 @@ Test(ddsc_querycondition_read, read_sample_state, .init=querycondition_init, .fi * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_querycondition_read::read_sample_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i * 2; @@ -520,15 +496,15 @@ Test(ddsc_querycondition_read, read_sample_state, .init=querycondition_init, .fi dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -536,18 +512,18 @@ Test(ddsc_querycondition_read, read_sample_state, .init=querycondition_init, .fi /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_read, new_view_state, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_read, new_view_state, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all new-view samples and matches filter. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -562,7 +538,6 @@ Test(ddsc_querycondition_read, new_view_state, .init=querycondition_init, .fini= * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_querycondition_read::new_view_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i == 0) ? 4 : 6; @@ -571,15 +546,15 @@ Test(ddsc_querycondition_read, new_view_state, .init=querycondition_init, .fini= dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -587,18 +562,18 @@ Test(ddsc_querycondition_read, new_view_state, .init=querycondition_init, .fini= /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_read, not_new_view_state, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_read, not_new_view_state, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all old-view samples and matches filter. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -613,7 +588,6 @@ Test(ddsc_querycondition_read, not_new_view_state, .init=querycondition_init, .f * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_querycondition_read::not_new_view_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i * 2; @@ -622,15 +596,15 @@ Test(ddsc_querycondition_read, not_new_view_state, .init=querycondition_init, .f dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -638,18 +612,18 @@ Test(ddsc_querycondition_read, not_new_view_state, .init=querycondition_init, .f /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_read, alive_instance_state, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_read, alive_instance_state, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all alive samples and matches filter. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -664,7 +638,6 @@ Test(ddsc_querycondition_read, alive_instance_state, .init=querycondition_init, * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_querycondition_read::alive_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i == 0) ? 0 : 6; @@ -673,15 +646,15 @@ Test(ddsc_querycondition_read, alive_instance_state, .init=querycondition_init, dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -689,18 +662,18 @@ Test(ddsc_querycondition_read, alive_instance_state, .init=querycondition_init, /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_read, disposed_instance_state, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_read, disposed_instance_state, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all disposed samples and matches filter. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 1, "# read %d, expected %d", ret, 1); + CU_ASSERT_EQUAL_FATAL(ret, 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -715,7 +688,6 @@ Test(ddsc_querycondition_read, disposed_instance_state, .init=querycondition_ini * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_querycondition_read::disposed_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = 4; @@ -724,15 +696,15 @@ Test(ddsc_querycondition_read, disposed_instance_state, .init=querycondition_ini dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_DISPOSED; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -740,18 +712,18 @@ Test(ddsc_querycondition_read, disposed_instance_state, .init=querycondition_ini /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_read, no_writers_instance_state, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_read, no_writers_instance_state, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all samples without a writer and matches filter. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 1, "# read %d, expected %d", ret, 1); + CU_ASSERT_EQUAL_FATAL(ret, 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -766,7 +738,6 @@ Test(ddsc_querycondition_read, no_writers_instance_state, .init=querycondition_i * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_querycondition_read::no_writers_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = 2; @@ -775,15 +746,15 @@ Test(ddsc_querycondition_read, no_writers_instance_state, .init=querycondition_i dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_NO_WRITERS; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -791,18 +762,18 @@ Test(ddsc_querycondition_read, no_writers_instance_state, .init=querycondition_i /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_read, combination_of_states, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_read, combination_of_states, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all samples that match the mask and filter (should be only one). */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 1, "# read %d, expected %d", ret, 1); + CU_ASSERT_EQUAL_FATAL(ret, 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -817,7 +788,6 @@ Test(ddsc_querycondition_read, combination_of_states, .init=querycondition_init, * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_querycondition_read::combination_of_states: Read", (*sample)); /* Expected states. */ int expected_long_1 = 6; @@ -826,15 +796,15 @@ Test(ddsc_querycondition_read, combination_of_states, .init=querycondition_init, dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -842,18 +812,18 @@ Test(ddsc_querycondition_read, combination_of_states, .init=querycondition_init, /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_read, none, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_read, none, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all samples that match the mask AND filter (should be none). */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 0, "# read %d, expected %d", ret, 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); /* * | long_1 | long_2 | long_3 | sst | vst | ist | @@ -872,19 +842,19 @@ Test(ddsc_querycondition_read, none, .init=querycondition_init, .fini=querycondi /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_read, with_mask, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_read, with_mask, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all samples that match the or'd masks. */ ret = dds_read_mask(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, DDS_NOT_READ_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -899,7 +869,6 @@ Test(ddsc_querycondition_read, with_mask, .init=querycondition_init, .fini=query * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_querycondition_read::with_mask: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i == 0) ? 4 : 6; @@ -908,15 +877,15 @@ Test(ddsc_querycondition_read, with_mask, .init=querycondition_init, .fini=query dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -924,22 +893,22 @@ Test(ddsc_querycondition_read, with_mask, .init=querycondition_init, .fini=query /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_read, already_deleted, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_read, already_deleted, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Delete condition. */ ret = dds_delete(condition); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to delete prerequisite condition"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Try to read with a deleted condition. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_expect_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ @@ -956,18 +925,18 @@ Test(ddsc_querycondition_read, already_deleted, .init=querycondition_init, .fini * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_take, any, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_take, any, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all samples that match the filter. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 4, "# read %d, expected %d", ret, 4); + CU_ASSERT_EQUAL_FATAL(ret, 4); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -982,7 +951,6 @@ Test(ddsc_querycondition_take, any, .init=querycondition_init, .fini=querycondit * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_querycondition_take::any: Take", (*sample)); /* Expected states. */ int expected_long_1 = i * 2; @@ -991,15 +959,15 @@ Test(ddsc_querycondition_take, any, .init=querycondition_init, .fini=querycondit dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1007,18 +975,18 @@ Test(ddsc_querycondition_take, any, .init=querycondition_init, .fini=querycondit /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_take, not_read_sample_state, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_take, not_read_sample_state, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all non-read samples that match the filter. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1033,7 +1001,6 @@ Test(ddsc_querycondition_take, not_read_sample_state, .init=querycondition_init, * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_querycondition_take::not_read_sample_state: Take", (*sample)); /* Expected states. */ int expected_long_1 = (i == 0) ? 4 : 6; @@ -1042,15 +1009,15 @@ Test(ddsc_querycondition_take, not_read_sample_state, .init=querycondition_init, dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1058,18 +1025,18 @@ Test(ddsc_querycondition_take, not_read_sample_state, .init=querycondition_init, /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_take, read_sample_state, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_take, read_sample_state, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all already read samples that match the filter. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1084,7 +1051,6 @@ Test(ddsc_querycondition_take, read_sample_state, .init=querycondition_init, .fi * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_querycondition_take::read_sample_state: Take", (*sample)); /* Expected states. */ int expected_long_1 = i * 2; @@ -1093,15 +1059,15 @@ Test(ddsc_querycondition_take, read_sample_state, .init=querycondition_init, .fi dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1109,18 +1075,18 @@ Test(ddsc_querycondition_take, read_sample_state, .init=querycondition_init, .fi /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_take, new_view_state, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_take, new_view_state, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all new-view samples that match the filter. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1135,7 +1101,6 @@ Test(ddsc_querycondition_take, new_view_state, .init=querycondition_init, .fini= * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_querycondition_take::new_view_state: Take", (*sample)); /* Expected states. */ int expected_long_1 = (i == 0) ? 4 : 6; @@ -1144,15 +1109,15 @@ Test(ddsc_querycondition_take, new_view_state, .init=querycondition_init, .fini= dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1160,18 +1125,18 @@ Test(ddsc_querycondition_take, new_view_state, .init=querycondition_init, .fini= /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_take, not_new_view_state, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_take, not_new_view_state, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all old-view samples that match the filter. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1186,7 +1151,6 @@ Test(ddsc_querycondition_take, not_new_view_state, .init=querycondition_init, .f * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_querycondition_take::not_new_view_state: Take", (*sample)); /* Expected states. */ int expected_long_1 = i * 2; @@ -1195,15 +1159,15 @@ Test(ddsc_querycondition_take, not_new_view_state, .init=querycondition_init, .f dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1211,18 +1175,18 @@ Test(ddsc_querycondition_take, not_new_view_state, .init=querycondition_init, .f /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_take, alive_instance_state, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_take, alive_instance_state, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all alive samples that match the filter. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1237,7 +1201,6 @@ Test(ddsc_querycondition_take, alive_instance_state, .init=querycondition_init, * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_querycondition_take::alive_instance_state: Take", (*sample)); /* Expected states. */ int expected_long_1 = i * 6; @@ -1246,15 +1209,15 @@ Test(ddsc_querycondition_take, alive_instance_state, .init=querycondition_init, dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1262,18 +1225,18 @@ Test(ddsc_querycondition_take, alive_instance_state, .init=querycondition_init, /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_take, disposed_instance_state, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_take, disposed_instance_state, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all disposed samples that match the filter. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 1, "# read %d, expected %d", ret, 1); + CU_ASSERT_EQUAL_FATAL(ret, 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1288,7 +1251,6 @@ Test(ddsc_querycondition_take, disposed_instance_state, .init=querycondition_ini * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_querycondition_take::disposed_instance_state: Take", (*sample)); /* Expected states. */ int expected_long_1 = 4; @@ -1297,15 +1259,15 @@ Test(ddsc_querycondition_take, disposed_instance_state, .init=querycondition_ini dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_DISPOSED; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1313,18 +1275,18 @@ Test(ddsc_querycondition_take, disposed_instance_state, .init=querycondition_ini /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_take, no_writers_instance_state, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_take, no_writers_instance_state, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all samples without a writer that match the filter. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 1, "# read %d, expected %d", ret, 1); + CU_ASSERT_EQUAL_FATAL(ret, 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1339,7 +1301,6 @@ Test(ddsc_querycondition_take, no_writers_instance_state, .init=querycondition_i * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_querycondition_take::no_writers_instance_state: Take", (*sample)); /* Expected states. */ int expected_long_1 = 2; @@ -1348,15 +1309,15 @@ Test(ddsc_querycondition_take, no_writers_instance_state, .init=querycondition_i dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_NO_WRITERS; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1364,18 +1325,18 @@ Test(ddsc_querycondition_take, no_writers_instance_state, .init=querycondition_i /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_take, combination_of_states, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_take, combination_of_states, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all samples that match the mask and the filter. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 1, "# read %d, expected %d", ret, 1); + CU_ASSERT_EQUAL_FATAL(ret, 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1390,7 +1351,6 @@ Test(ddsc_querycondition_take, combination_of_states, .init=querycondition_init, * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_querycondition_take::combination_of_states: Take", (*sample)); /* Expected states. */ int expected_long_1 = 6; @@ -1399,15 +1359,15 @@ Test(ddsc_querycondition_take, combination_of_states, .init=querycondition_init, dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1415,18 +1375,18 @@ Test(ddsc_querycondition_take, combination_of_states, .init=querycondition_init, /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_take, none, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_take, none, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all samples that match the mask AND filter (should be none). */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 0, "# read %d, expected %d", ret, 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); /* * | long_1 | long_2 | long_3 | sst | vst | ist | @@ -1445,19 +1405,19 @@ Test(ddsc_querycondition_take, none, .init=querycondition_init, .fini=querycondi /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_take, with_mask, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_take, with_mask, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all samples that match the or'd masks and match the filter. */ ret = dds_take_mask(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, DDS_NOT_READ_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1472,7 +1432,6 @@ Test(ddsc_querycondition_take, with_mask, .init=querycondition_init, .fini=query * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_querycondition_take::with_mask: Take", (*sample)); /* Expected states. */ int expected_long_1 = (i == 0) ? 4 : 6; @@ -1481,15 +1440,15 @@ Test(ddsc_querycondition_take, with_mask, .init=querycondition_init, .fini=query dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1497,25 +1456,21 @@ Test(ddsc_querycondition_take, with_mask, .init=querycondition_init, .fini=query /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_querycondition_take, already_deleted, .init=querycondition_init, .fini=querycondition_fini) +CU_Test(ddsc_querycondition_take, already_deleted, .init=querycondition_init, .fini=querycondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Delete condition. */ ret = dds_delete(condition); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to delete prerequisite condition"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Try to take with a deleted condition. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_expect_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ - - - -#endif diff --git a/src/core/ddsc/tests/read_instance.c b/src/core/ddsc/tests/read_instance.c index ac57921..4548e0a 100644 --- a/src/core/ddsc/tests/read_instance.c +++ b/src/core/ddsc/tests/read_instance.c @@ -10,23 +10,12 @@ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ #include - #include "ddsc/dds.h" #include "os/os.h" #include "Space.h" #include "RoundTrip.h" -#include -#include -#include - - -#if 0 -#define PRINT_SAMPLE(info, sample) cr_log_info("%s (%d, %d, %d)\n", info, sample.long_1, sample.long_2, sample.long_3); -#else -#define PRINT_SAMPLE(info, sample) -#endif - - +#include "CUnit/Test.h" +#include "CUnit/Theory.h" /************************************************************************************************** * @@ -95,62 +84,62 @@ read_instance_init(void) dds_qos_t *qos; qos = dds_create_qos(); - cr_assert_not_null(qos, "Failed to create prerequisite qos"); + CU_ASSERT_PTR_NOT_NULL_FATAL(qos); g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0); g_subscriber = dds_create_subscriber(g_participant, NULL, NULL); - cr_assert_gt(g_subscriber, 0, "Failed to create prerequisite g_subscriber"); + CU_ASSERT_FATAL(g_subscriber > 0); g_publisher = dds_create_publisher(g_participant, NULL, NULL); - cr_assert_gt(g_publisher, 0, "Failed to create prerequisite g_publisher"); + CU_ASSERT_FATAL(g_publisher > 0); g_waitset = dds_create_waitset(g_participant); - cr_assert_gt(g_waitset, 0, "Failed to create g_waitset"); + CU_ASSERT_FATAL(g_waitset > 0); g_topic = dds_create_topic(g_participant, &Space_Type1_desc, create_topic_name("ddsc_read_instance_test", name, sizeof name), NULL, NULL); - cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic"); + CU_ASSERT_FATAL(g_topic > 0); /* Create a writer that will not automatically dispose unregistered samples. */ dds_qset_writer_data_lifecycle(qos, false); g_writer = dds_create_writer(g_publisher, g_topic, qos, NULL); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer"); + CU_ASSERT_FATAL(g_writer > 0); /* Create a reader that keeps all samples when not taken. */ dds_qset_history(qos, DDS_HISTORY_KEEP_ALL, DDS_LENGTH_UNLIMITED); g_reader = dds_create_reader(g_subscriber, g_topic, qos, NULL); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite g_reader"); + CU_ASSERT_FATAL(g_reader > 0); /* Create a read condition that only reads not_read samples. */ g_rcond = dds_create_readcondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(g_rcond, 0, "Failed to create prerequisite g_rcond"); + CU_ASSERT_FATAL(g_rcond > 0); /* Create a query condition that only reads not_read samples of instances mod2. */ g_qcond = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(g_qcond, 0, "Failed to create prerequisite g_qcond"); + CU_ASSERT_FATAL(g_qcond > 0); /* Sync g_reader to g_writer. */ ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_reader r"); - cr_assert_eq(g_reader, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_reader a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_reader, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Sync g_writer to g_reader. */ ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_writer status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_writer, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_writer r"); - cr_assert_eq(g_writer, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_writer a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_writer, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Initialize reading buffers. */ memset (g_data, 0, sizeof (g_data)); @@ -165,9 +154,8 @@ read_instance_init(void) sample.long_1 = 0; sample.long_2 = 0; sample.long_3 = 0; - PRINT_SAMPLE("INIT: Write ", sample); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* | long_1 | long_2 | long_3 | sst | vst | ist | * ---------------------------------------------------------- * | 0 | 0 | 0 | not_read | new | alive | @@ -175,10 +163,9 @@ read_instance_init(void) /* Read sample that will become {sst(read), vst(old), ist(alive)}. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 1, "Failed prerequisite read"); + CU_ASSERT_EQUAL_FATAL(ret, 1); for(int i = 0; i < ret; i++) { Space_Type1 *s = (Space_Type1*)g_samples[i]; - PRINT_SAMPLE("INIT: Read ", (*s)); (void)s; } /* | long_1 | long_2 | long_3 | sst | vst | ist | @@ -190,9 +177,8 @@ read_instance_init(void) sample.long_1 = 0; sample.long_2 = 1; sample.long_3 = 2; - PRINT_SAMPLE("INIT: Write ", sample); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* | long_1 | long_2 | long_3 | sst | vst | ist | * ---------------------------------------------------------- * | 0 | 0 | 0 | read | old | alive | @@ -204,9 +190,8 @@ read_instance_init(void) sample.long_1 = i - 1; sample.long_2 = i; sample.long_3 = i*2; - PRINT_SAMPLE("INIT: Write ", sample); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /* | long_1 | long_2 | long_3 | sst | vst | ist | * ---------------------------------------------------------- @@ -221,9 +206,8 @@ read_instance_init(void) sample.long_1 = 2; sample.long_2 = 3; sample.long_3 = 6; - PRINT_SAMPLE("INIT: Dispose ", sample); ret = dds_dispose(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite dispose"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* | long_1 | long_2 | long_3 | sst | vst | ist | * ---------------------------------------------------------- * | 0 | 0 | 0 | read | old | alive | @@ -237,9 +221,8 @@ read_instance_init(void) sample.long_1 = 3; sample.long_2 = 4; sample.long_3 = 8; - PRINT_SAMPLE("INIT: Unregister", sample); ret = dds_unregister_instance(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite unregister"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* | long_1 | long_2 | long_3 | sst | vst | ist | * ---------------------------------------------------------- * | 0 | 0 | 0 | read | old | alive | @@ -254,7 +237,7 @@ read_instance_init(void) sample.long_2 = 0; sample.long_3 = 0; g_hdl_valid = dds_instance_lookup(g_reader, &sample); - cr_assert_neq(g_hdl_valid, DDS_HANDLE_NIL, "Failed prerequisite dds_instance_lookup"); + CU_ASSERT_NOT_EQUAL_FATAL(g_hdl_valid, DDS_HANDLE_NIL); dds_delete_qos(qos); } @@ -278,7 +261,7 @@ samples_cnt(void) { dds_return_t ret; ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_geq(ret, 0, "Failed samples count read: %d", dds_err_nr(ret)); + CU_ASSERT_FATAL(ret >= 0); return ret; } @@ -292,92 +275,101 @@ samples_cnt(void) * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance, invalid_params) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(void**, g_samples, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0), - DataPoints(size_t, 0, 2, MAX_SAMPLES), - DataPoints(uint32_t, 0, 2, MAX_SAMPLES), +CU_TheoryDataPoints(ddsc_read_instance, invalid_params) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(void**, g_samples, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL), + CU_DataPoints(size_t, 0, 2, MAX_SAMPLES), + CU_DataPoints(uint32_t, 0, 2, MAX_SAMPLES), }; -Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_read_instance, invalid_params, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_read_instance, invalid_params, .init=read_instance_init, .fini=read_instance_fini) { dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid and neither is the handle. So, don't test that. */ - cr_assume((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); + CU_ASSERT_FATAL((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); /* TODO: CHAM-306, currently, a buffer is automatically 'promoted' to a loan when a buffer is * provided with NULL pointers. So, in fact, there's currently no real difference between calling * dds_read() dds_read_wl() (except for the provided bufsz). This will change, which means that * the given buffer should contain valid pointers, which again means that 'loan intended' buffer * should result in bad_parameter. * However, that's not the case yet. So don't test it. */ - cr_assume(buf != g_loans); - ret = dds_read_instance(*ent, buf, si, bufsz, maxs, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + if (buf != g_loans) { + ret = dds_read_instance(*ent, buf, si, bufsz, maxs, g_hdl_valid); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + } else { + CU_PASS(); + } } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_wl, invalid_params) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(void**, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0), - DataPoints(size_t, 0, 2, MAX_SAMPLES), +CU_TheoryDataPoints(ddsc_read_instance_wl, invalid_params) = { + CU_DataPoints(dds_entity_t *, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(void **, g_samples, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t *, g_info, NULL, NULL), + CU_DataPoints(uint32_t, 0, 2, MAX_SAMPLES), }; -Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_read_instance_wl, invalid_params, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_read_instance_wl, invalid_params, .init=read_instance_init, .fini=read_instance_fini) { dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid and neither is the handle. So, don't test that. */ - cr_assume((buf != g_loans) || (si != g_info) || (maxs == 0)); - ret = dds_read_instance_wl(*ent, buf, si, maxs, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + if ((buf != g_loans) || (si != g_info) || (maxs == 0)) { + ret = dds_read_instance_wl(*ent, buf, si, maxs, g_hdl_valid); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + } else { + CU_PASS(); + } } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_mask, invalid_params) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(void**, g_samples, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0), - DataPoints(size_t, 0, 2, MAX_SAMPLES), - DataPoints(uint32_t, 0, 2, MAX_SAMPLES), +CU_TheoryDataPoints(ddsc_read_instance_mask, invalid_params) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(void**, g_samples, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL), + CU_DataPoints(size_t, 0, 2, MAX_SAMPLES), + CU_DataPoints(uint32_t, 0, 2, MAX_SAMPLES), }; -Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_read_instance_mask, invalid_params, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_read_instance_mask, invalid_params, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid and neither is the handle. So, don't test that. */ - cr_assume((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); + CU_ASSERT_FATAL((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); /* TODO: CHAM-306, currently, a buffer is automatically 'promoted' to a loan when a buffer is * provided with NULL pointers. So, in fact, there's currently no real difference between calling * dds_read() dds_read_wl() (except for the provided bufsz). This will change, which means that * the given buffer should contain valid pointers, which again means that 'loan intended' buffer * should result in bad_parameter. * However, that's not the case yet. So don't test it. */ - cr_assume(buf != g_loans); - ret = dds_read_instance_mask(*ent, buf, si, bufsz, maxs, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + if (buf != g_loans) { + ret = dds_read_instance_mask(*ent, buf, si, bufsz, maxs, g_hdl_valid, mask); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + } else { + CU_PASS(); + } } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_mask_wl, invalid_params) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(void**, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0), - DataPoints(size_t, 0, 2, MAX_SAMPLES), +CU_TheoryDataPoints(ddsc_read_instance_mask_wl, invalid_params) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(void**, g_loans, (void**)0, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL), + CU_DataPoints(uint32_t, 0, 2, MAX_SAMPLES), }; -Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_read_instance_mask_wl, invalid_params, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_read_instance_mask_wl, invalid_params, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid and neither is the handle. So, don't test that. */ - cr_assume((buf != g_loans) || (si != g_info) || (maxs == 0)); + CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); ret = dds_read_instance_mask_wl(*ent, buf, si, maxs, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -391,56 +383,56 @@ Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs), dd * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance, invalid_handles) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), +CU_TheoryDataPoints(ddsc_read_instance, invalid_handles) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), }; -Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance, invalid_handles, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance, invalid_handles, .init=read_instance_init, .fini=read_instance_fini) { dds_return_t ret; ret = dds_read_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_wl, invalid_handles) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), +CU_TheoryDataPoints(ddsc_read_instance_wl, invalid_handles) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), }; -Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance_wl, invalid_handles, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance_wl, invalid_handles, .init=read_instance_init, .fini=read_instance_fini) { dds_return_t ret; ret = dds_read_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_mask, invalid_handles) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), +CU_TheoryDataPoints(ddsc_read_instance_mask, invalid_handles) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), }; -Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance_mask, invalid_handles, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance_mask, invalid_handles, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_read_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_mask_wl, invalid_handles) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), +CU_TheoryDataPoints(ddsc_read_instance_mask_wl, invalid_handles) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), }; -Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance_mask_wl, invalid_handles, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance_mask_wl, invalid_handles, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_read_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -454,60 +446,60 @@ Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_read_instance_mask_w * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_read_instance, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_read_instance, invalid_readers, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t rdr), ddsc_read_instance, invalid_readers, .init=read_instance_init, .fini=read_instance_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_instance(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_wl, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_read_instance_wl, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_read_instance_wl, invalid_readers, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t rdr), ddsc_read_instance_wl, invalid_readers, .init=read_instance_init, .fini=read_instance_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_instance_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_mask, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_read_instance_mask, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_read_instance_mask, invalid_readers, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t rdr), ddsc_read_instance_mask, invalid_readers, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_instance_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_mask_wl, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_read_instance_mask_wl, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_read_instance_mask_wl, invalid_readers, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t rdr), ddsc_read_instance_mask_wl, invalid_readers, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_instance_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ @@ -522,52 +514,52 @@ Theory((dds_entity_t rdr), ddsc_read_instance_mask_wl, invalid_readers, .init=re * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), +CU_TheoryDataPoints(ddsc_read_instance, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_read_instance, non_readers, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_instance, non_readers, .init=read_instance_init, .fini=read_instance_fini) { dds_return_t ret; ret = dds_read_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_wl, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), +CU_TheoryDataPoints(ddsc_read_instance_wl, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_read_instance_wl, non_readers, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_instance_wl, non_readers, .init=read_instance_init, .fini=read_instance_fini) { dds_return_t ret; ret = dds_read_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_mask, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), +CU_TheoryDataPoints(ddsc_read_instance_mask, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_read_instance_mask, non_readers, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_instance_mask, non_readers, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_read_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_mask_wl, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), +CU_TheoryDataPoints(ddsc_read_instance_mask_wl, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_read_instance_mask_wl, non_readers, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_instance_mask_wl, non_readers, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_read_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -582,60 +574,60 @@ Theory((dds_entity_t *rdr), ddsc_read_instance_mask_wl, non_readers, .init=read_ * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance, already_deleted) = { - DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), +CU_TheoryDataPoints(ddsc_read_instance, already_deleted) = { + CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), }; -Theory((dds_entity_t *rdr), ddsc_read_instance, already_deleted, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_instance, already_deleted, .init=read_instance_init, .fini=read_instance_fini) { dds_return_t ret; ret = dds_delete(*rdr); - cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_read_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_wl, already_deleted) = { - DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), +CU_TheoryDataPoints(ddsc_read_instance_wl, already_deleted) = { + CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), }; -Theory((dds_entity_t *rdr), ddsc_read_instance_wl, already_deleted, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_instance_wl, already_deleted, .init=read_instance_init, .fini=read_instance_fini) { dds_return_t ret; ret = dds_delete(*rdr); - cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_read_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_mask, already_deleted) = { - DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), +CU_TheoryDataPoints(ddsc_read_instance_mask, already_deleted) = { + CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), }; -Theory((dds_entity_t *rdr), ddsc_read_instance_mask, already_deleted, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_instance_mask, already_deleted, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_delete(*rdr); - cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_read_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_instance_mask_wl, already_deleted) = { - DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), +CU_TheoryDataPoints(ddsc_read_instance_mask_wl, already_deleted) = { + CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), }; -Theory((dds_entity_t *rdr), ddsc_read_instance_mask_wl, already_deleted, .init=read_instance_init, .fini=read_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_instance_mask_wl, already_deleted, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_delete(*rdr); - cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_read_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ @@ -650,13 +642,13 @@ Theory((dds_entity_t *rdr), ddsc_read_instance_mask_wl, already_deleted, .init=r * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_instance, reader, .init=read_instance_init, .fini=read_instance_fini) +CU_Test(ddsc_read_instance, reader, .init=read_instance_init, .fini=read_instance_fini) { dds_return_t expected_cnt = 2; dds_return_t ret; ret = dds_read_instance(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -669,7 +661,6 @@ Test(ddsc_read_instance, reader, .init=read_instance_init, .fini=read_instance_f * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_read_instance::reader: Read", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -679,31 +670,31 @@ Test(ddsc_read_instance, reader, .init=read_instance_init, .fini=read_instance_f dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_instance_wl, reader, .init=read_instance_init, .fini=read_instance_fini) +CU_Test(ddsc_read_instance_wl, reader, .init=read_instance_init, .fini=read_instance_fini) { dds_return_t expected_cnt = 2; dds_return_t ret; ret = dds_read_instance_wl(g_reader, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -716,7 +707,6 @@ Test(ddsc_read_instance_wl, reader, .init=read_instance_init, .fini=read_instanc * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_read_instance_wl::reader: Read", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -726,35 +716,35 @@ Test(ddsc_read_instance_wl, reader, .init=read_instance_init, .fini=read_instanc dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_instance_mask, reader, .init=read_instance_init, .fini=read_instance_fini) +CU_Test(ddsc_read_instance_mask, reader, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_read_instance_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -767,7 +757,6 @@ Test(ddsc_read_instance_mask, reader, .init=read_instance_init, .fini=read_insta * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_read_instance_mask::reader: Read", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -777,32 +766,32 @@ Test(ddsc_read_instance_mask, reader, .init=read_instance_init, .fini=read_insta dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_instance_mask_wl, reader, .init=read_instance_init, .fini=read_instance_fini) +CU_Test(ddsc_read_instance_mask_wl, reader, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_read_instance_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -815,7 +804,6 @@ Test(ddsc_read_instance_mask_wl, reader, .init=read_instance_init, .fini=read_in * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_read_instance_mask_wl::reader: Read", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -825,23 +813,23 @@ Test(ddsc_read_instance_mask_wl, reader, .init=read_instance_init, .fini=read_in dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ @@ -856,13 +844,13 @@ Test(ddsc_read_instance_mask_wl, reader, .init=read_instance_init, .fini=read_in * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_instance, readcondition, .init=read_instance_init, .fini=read_instance_fini) +CU_Test(ddsc_read_instance, readcondition, .init=read_instance_init, .fini=read_instance_fini) { dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_read_instance(g_rcond, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -875,7 +863,6 @@ Test(ddsc_read_instance, readcondition, .init=read_instance_init, .fini=read_ins * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_read_instance::readcondition: Read", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -885,31 +872,31 @@ Test(ddsc_read_instance, readcondition, .init=read_instance_init, .fini=read_ins dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_instance_wl, readcondition, .init=read_instance_init, .fini=read_instance_fini) +CU_Test(ddsc_read_instance_wl, readcondition, .init=read_instance_init, .fini=read_instance_fini) { dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_read_instance_wl(g_rcond, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -922,7 +909,6 @@ Test(ddsc_read_instance_wl, readcondition, .init=read_instance_init, .fini=read_ * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_read_instance_wl::readcondition: Read", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -932,35 +918,35 @@ Test(ddsc_read_instance_wl, readcondition, .init=read_instance_init, .fini=read_ dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_instance_mask, readcondition, .init=read_instance_init, .fini=read_instance_fini) +CU_Test(ddsc_read_instance_mask, readcondition, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 2; dds_return_t ret; ret = dds_read_instance_mask(g_rcond, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -973,7 +959,6 @@ Test(ddsc_read_instance_mask, readcondition, .init=read_instance_init, .fini=rea * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_read_instance_mask::readcondition: Read", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -983,32 +968,32 @@ Test(ddsc_read_instance_mask, readcondition, .init=read_instance_init, .fini=rea dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_instance_mask_wl, readcondition, .init=read_instance_init, .fini=read_instance_fini) +CU_Test(ddsc_read_instance_mask_wl, readcondition, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_read_instance_mask_wl(g_rcond, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1021,7 +1006,6 @@ Test(ddsc_read_instance_mask_wl, readcondition, .init=read_instance_init, .fini= * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_read_instance_mask_wl::readcondition: Read", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -1031,23 +1015,23 @@ Test(ddsc_read_instance_mask_wl, readcondition, .init=read_instance_init, .fini= dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ @@ -1062,13 +1046,13 @@ Test(ddsc_read_instance_mask_wl, readcondition, .init=read_instance_init, .fini= * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_instance, querycondition, .init=read_instance_init, .fini=read_instance_fini) +CU_Test(ddsc_read_instance, querycondition, .init=read_instance_init, .fini=read_instance_fini) { dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_read_instance(g_qcond, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1081,7 +1065,6 @@ Test(ddsc_read_instance, querycondition, .init=read_instance_init, .fini=read_in * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_read_instance::querycondition: Read", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -1091,31 +1074,31 @@ Test(ddsc_read_instance, querycondition, .init=read_instance_init, .fini=read_in dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_instance_wl, querycondition, .init=read_instance_init, .fini=read_instance_fini) +CU_Test(ddsc_read_instance_wl, querycondition, .init=read_instance_init, .fini=read_instance_fini) { dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_read_instance_wl(g_qcond, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1128,7 +1111,6 @@ Test(ddsc_read_instance_wl, querycondition, .init=read_instance_init, .fini=read * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_read_instance_wl::querycondition: Read", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -1138,35 +1120,35 @@ Test(ddsc_read_instance_wl, querycondition, .init=read_instance_init, .fini=read dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_instance_mask, querycondition, .init=read_instance_init, .fini=read_instance_fini) +CU_Test(ddsc_read_instance_mask, querycondition, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_read_instance_mask(g_qcond, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1179,7 +1161,6 @@ Test(ddsc_read_instance_mask, querycondition, .init=read_instance_init, .fini=re * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_read_instance_mask::querycondition: Read", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -1189,32 +1170,32 @@ Test(ddsc_read_instance_mask, querycondition, .init=read_instance_init, .fini=re dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_instance_mask_wl, querycondition, .init=read_instance_init, .fini=read_instance_fini) +CU_Test(ddsc_read_instance_mask_wl, querycondition, .init=read_instance_init, .fini=read_instance_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_read_instance_mask_wl(g_qcond, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1227,7 +1208,6 @@ Test(ddsc_read_instance_mask_wl, querycondition, .init=read_instance_init, .fini * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_read_instance_mask_wl::querycondition: Read", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -1237,22 +1217,22 @@ Test(ddsc_read_instance_mask_wl, querycondition, .init=read_instance_init, .fini dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/readcondition.c b/src/core/ddsc/tests/readcondition.c index 1bdce96..c49e3d4 100644 --- a/src/core/ddsc/tests/readcondition.c +++ b/src/core/ddsc/tests/readcondition.c @@ -11,22 +11,10 @@ */ #include "ddsc/dds.h" #include "os/os.h" -#include -#include -#include +#include "CUnit/Test.h" +#include "CUnit/Theory.h" #include "Space.h" -/* Add --verbose command line argument to get the cr_log_info traces (if there are any). */ - -//#define VERBOSE_INIT -#ifdef VERBOSE_INIT -#define PRINT_SAMPLE(info, sample) cr_log_info("%s (%d, %d, %d)\n", info, sample.long_1, sample.long_2, sample.long_3); -#else -#define PRINT_SAMPLE(info, sample) -#endif - - - /************************************************************************************************** * * Test fixtures @@ -89,45 +77,45 @@ readcondition_init(void) char name[100]; g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0); g_waitset = dds_create_waitset(g_participant); - cr_assert_gt(g_waitset, 0, "Failed to create g_waitset"); + CU_ASSERT_FATAL(g_waitset > 0); g_topic = dds_create_topic(g_participant, &Space_Type1_desc, create_topic_name("ddsc_readcondition_test", name, 100), NULL, NULL); - cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic"); + CU_ASSERT_FATAL(g_topic > 0); /* Create a reader that keeps last sample of all instances. */ dds_qset_history(qos, DDS_HISTORY_KEEP_LAST, 1); g_reader = dds_create_reader(g_participant, g_topic, qos, NULL); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite g_reader"); + CU_ASSERT_FATAL(g_reader > 0); /* Create a reader that will not automatically dispose unregistered samples. */ dds_qset_writer_data_lifecycle(qos, false); g_writer = dds_create_writer(g_participant, g_topic, qos, NULL); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer"); + CU_ASSERT_FATAL(g_writer > 0); /* Sync g_reader to g_writer. */ ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_reader r"); - cr_assert_eq(g_reader, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_reader a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_reader, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Sync g_writer to g_reader. */ ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_writer status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_writer, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_writer r"); - cr_assert_eq(g_writer, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_writer a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_writer, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Initialize reading buffers. */ memset (g_data, 0, sizeof (g_data)); @@ -142,29 +130,25 @@ readcondition_init(void) sample.long_2 = i/2; sample.long_3 = i/3; - PRINT_SAMPLE("INIT: Write ", sample); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); if (ist == DDS_IST_NOT_ALIVE_DISPOSED) { - PRINT_SAMPLE("INIT: Dispose ", sample); ret = dds_dispose(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite dispose"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } if (ist == DDS_IST_NOT_ALIVE_NO_WRITERS) { - PRINT_SAMPLE("INIT: Unregister", sample); ret = dds_unregister_instance(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite unregister"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } } /* Read samples to get read&old_view states. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, SAMPLE_LAST_OLD_VST + 1); - cr_assert_eq(ret, SAMPLE_LAST_OLD_VST + 1, "Failed prerequisite read"); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_LAST_OLD_VST + 1); #ifdef VERBOSE_INIT for(int i = 0; i < ret; i++) { Space_Type1 *s = (Space_Type1*)g_samples[i]; - PRINT_SAMPLE("INIT: Read ", (*s)); } #endif @@ -175,19 +159,16 @@ readcondition_init(void) sample.long_2 = i/2; sample.long_3 = i/3; - PRINT_SAMPLE("INIT: Rewrite ", sample); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); if ((ist == DDS_IST_NOT_ALIVE_DISPOSED) && (i != 4)) { - PRINT_SAMPLE("INIT: Dispose ", sample); ret = dds_dispose(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite dispose"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } if (ist == DDS_IST_NOT_ALIVE_NO_WRITERS) { - PRINT_SAMPLE("INIT: Unregister", sample); ret = dds_unregister_instance(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite unregister"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } } @@ -213,7 +194,7 @@ readcondition_fini(void) * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_create, second, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_create, second, .init=readcondition_init, .fini=readcondition_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t cond1; @@ -221,57 +202,57 @@ Test(ddsc_readcondition_create, second, .init=readcondition_init, .fini=readcond dds_return_t ret; cond1 = dds_create_readcondition(g_reader, mask); - cr_assert_gt(cond1, 0, "dds_create_readcondition(): returned %d", dds_err_nr(cond1)); + CU_ASSERT_FATAL(cond1 > 0); cond2 = dds_create_readcondition(g_reader, mask); - cr_assert_gt(cond2, 0, "dds_create_readcondition(): returned %d", dds_err_nr(cond2)); + CU_ASSERT_FATAL(cond2 > 0); /* Also, we should be able to delete both. */ ret = dds_delete(cond1); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_delete(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* And, of course, be able to delete the first one (return code isn't checked in the test fixtures). */ ret = dds_delete(cond2); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_delete(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_create, deleted_reader, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_create, deleted_reader, .init=readcondition_init, .fini=readcondition_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t cond; dds_delete(g_reader); cond = dds_create_readcondition(g_reader, mask); - cr_assert_eq(dds_err_nr(cond), DDS_RETCODE_ALREADY_DELETED, "dds_create_readcondition(): returned %d", dds_err_nr(cond)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_readcondition_create, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_readcondition_create, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_readcondition_create, invalid_readers, .init=readcondition_init, .fini=readcondition_fini) +CU_Theory((dds_entity_t rdr), ddsc_readcondition_create, invalid_readers, .init=readcondition_init, .fini=readcondition_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t cond; cond = dds_create_readcondition(rdr, mask); - cr_assert_eq(dds_err_nr(cond), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(cond), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_readcondition_create, non_readers) = { - DataPoints(dds_entity_t*, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_readcondition_create, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_topic, &g_participant), }; -Theory((dds_entity_t *rdr), ddsc_readcondition_create, non_readers, .init=readcondition_init, .fini=readcondition_fini) +CU_Theory((dds_entity_t *rdr), ddsc_readcondition_create, non_readers, .init=readcondition_init, .fini=readcondition_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t cond; cond = dds_create_readcondition(*rdr, mask); - cr_assert_eq(dds_err_nr(cond), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(cond)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(cond), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -285,71 +266,71 @@ Theory((dds_entity_t *rdr), ddsc_readcondition_create, non_readers, .init=readco * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_get_mask, deleted, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_get_mask, deleted, .init=readcondition_init, .fini=readcondition_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t condition; dds_return_t ret; condition = dds_create_readcondition(g_reader, mask); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); dds_delete(condition); mask = 0; ret = dds_get_mask(condition, &mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_get_mask, null, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_get_mask, null, .init=readcondition_init, .fini=readcondition_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t condition; dds_return_t ret; condition = dds_create_readcondition(g_reader, mask); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_get_mask(condition, NULL); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); dds_delete(condition); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_readcondition_get_mask, invalid_conditions) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_readcondition_get_mask, invalid_conditions) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t cond), ddsc_readcondition_get_mask, invalid_conditions, .init=readcondition_init, .fini=readcondition_fini) +CU_Theory((dds_entity_t cond), ddsc_readcondition_get_mask, invalid_conditions, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; uint32_t mask; ret = dds_get_mask(cond, &mask); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_readcondition_get_mask, non_conditions) = { - DataPoints(dds_entity_t*, &g_reader, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_readcondition_get_mask, non_conditions) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_topic, &g_participant), }; -Theory((dds_entity_t *cond), ddsc_readcondition_get_mask, non_conditions, .init=readcondition_init, .fini=readcondition_fini) +CU_Theory((dds_entity_t *cond), ddsc_readcondition_get_mask, non_conditions, .init=readcondition_init, .fini=readcondition_fini) { dds_return_t ret; uint32_t mask; ret = dds_get_mask(*cond, &mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_readcondition_get_mask, various_masks) = { - DataPoints(uint32_t, DDS_ANY_SAMPLE_STATE, DDS_READ_SAMPLE_STATE, DDS_NOT_READ_SAMPLE_STATE), - DataPoints(uint32_t, DDS_ANY_VIEW_STATE, DDS_NEW_VIEW_STATE, DDS_NOT_NEW_VIEW_STATE), - DataPoints(uint32_t, DDS_ANY_INSTANCE_STATE, DDS_ALIVE_INSTANCE_STATE, DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE), +CU_TheoryDataPoints(ddsc_readcondition_get_mask, various_masks) = { + CU_DataPoints(uint32_t, DDS_ANY_SAMPLE_STATE, DDS_READ_SAMPLE_STATE, DDS_NOT_READ_SAMPLE_STATE), + CU_DataPoints(uint32_t, DDS_ANY_VIEW_STATE, DDS_NEW_VIEW_STATE, DDS_NOT_NEW_VIEW_STATE), + CU_DataPoints(uint32_t, DDS_ANY_INSTANCE_STATE, DDS_ALIVE_INSTANCE_STATE, DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE), }; -Theory((uint32_t ss, uint32_t vs, uint32_t is), ddsc_readcondition_get_mask, various_masks, .init=readcondition_init, .fini=readcondition_fini) +CU_Theory((uint32_t ss, uint32_t vs, uint32_t is), ddsc_readcondition_get_mask, various_masks, .init=readcondition_init, .fini=readcondition_fini) { uint32_t maskIn = ss | vs | is; uint32_t maskOut = 0xFFFFFFFF; @@ -357,11 +338,11 @@ Theory((uint32_t ss, uint32_t vs, uint32_t is), ddsc_readcondition_get_mask, var dds_return_t ret; condition = dds_create_readcondition(g_reader, maskIn); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); ret = dds_get_mask(condition, &maskOut); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_OK, "returned %d", dds_err_nr(ret)); - cr_assert_eq(maskIn, maskOut); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(maskIn, maskOut); dds_delete(condition); } @@ -376,18 +357,18 @@ Theory((uint32_t ss, uint32_t vs, uint32_t is), ddsc_readcondition_get_mask, var * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_read, any, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_read, any, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all samples. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, MAX_SAMPLES, "# read %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -402,7 +383,6 @@ Test(ddsc_readcondition_read, any, .init=readcondition_init, .fini=readcondition * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_readcondition_read::any: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -411,15 +391,15 @@ Test(ddsc_readcondition_read, any, .init=readcondition_init, .fini=readcondition dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -427,18 +407,18 @@ Test(ddsc_readcondition_read, any, .init=readcondition_init, .fini=readcondition /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_read, not_read_sample_state, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_read, not_read_sample_state, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all non-read samples (should be last part). */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, MAX_SAMPLES - (SAMPLE_LAST_READ_SST + 1), "# read %d, expected %d", ret, MAX_SAMPLES - (SAMPLE_LAST_READ_SST + 1)); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - (SAMPLE_LAST_READ_SST + 1)); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -453,7 +433,6 @@ Test(ddsc_readcondition_read, not_read_sample_state, .init=readcondition_init, . * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_readcondition_read::not_read_sample_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = SAMPLE_LAST_READ_SST + 1 + i; @@ -462,15 +441,15 @@ Test(ddsc_readcondition_read, not_read_sample_state, .init=readcondition_init, . dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -478,18 +457,18 @@ Test(ddsc_readcondition_read, not_read_sample_state, .init=readcondition_init, . /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_read, read_sample_state, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_read, read_sample_state, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all already read samples (should be first part). */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, SAMPLE_LAST_READ_SST + 1, "# read %d, expected %d", ret, SAMPLE_LAST_READ_SST + 1); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_LAST_READ_SST + 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -504,7 +483,6 @@ Test(ddsc_readcondition_read, read_sample_state, .init=readcondition_init, .fini * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_readcondition_read::read_sample_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -513,15 +491,15 @@ Test(ddsc_readcondition_read, read_sample_state, .init=readcondition_init, .fini dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -529,18 +507,18 @@ Test(ddsc_readcondition_read, read_sample_state, .init=readcondition_init, .fini /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_read, new_view_state, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_read, new_view_state, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all new-view samples (should be last part). */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, MAX_SAMPLES - (SAMPLE_LAST_OLD_VST + 1), "# read %d, expected %d", ret, MAX_SAMPLES - (SAMPLE_LAST_OLD_VST + 1)); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - (SAMPLE_LAST_OLD_VST + 1)); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -555,7 +533,6 @@ Test(ddsc_readcondition_read, new_view_state, .init=readcondition_init, .fini=re * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_readcondition_read::new_view_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = SAMPLE_LAST_OLD_VST + 1 + i; @@ -564,15 +541,15 @@ Test(ddsc_readcondition_read, new_view_state, .init=readcondition_init, .fini=re dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -580,18 +557,18 @@ Test(ddsc_readcondition_read, new_view_state, .init=readcondition_init, .fini=re /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_read, not_new_view_state, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_read, not_new_view_state, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all old-view samples (should be first part). */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, SAMPLE_LAST_OLD_VST + 1, "# read %d, expected %d", ret, SAMPLE_LAST_OLD_VST + 1); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_LAST_OLD_VST + 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -606,7 +583,6 @@ Test(ddsc_readcondition_read, not_new_view_state, .init=readcondition_init, .fin * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_readcondition_read::not_new_view_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -615,15 +591,15 @@ Test(ddsc_readcondition_read, not_new_view_state, .init=readcondition_init, .fin dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -631,18 +607,18 @@ Test(ddsc_readcondition_read, not_new_view_state, .init=readcondition_init, .fin /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_read, alive_instance_state, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_read, alive_instance_state, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all alive samples. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, SAMPLE_ALIVE_IST_CNT, "# read %d, expected %d", ret, SAMPLE_ALIVE_IST_CNT); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_ALIVE_IST_CNT); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -657,7 +633,6 @@ Test(ddsc_readcondition_read, alive_instance_state, .init=readcondition_init, .f * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_readcondition_read::alive_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i * 3; @@ -666,15 +641,15 @@ Test(ddsc_readcondition_read, alive_instance_state, .init=readcondition_init, .f dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -682,18 +657,18 @@ Test(ddsc_readcondition_read, alive_instance_state, .init=readcondition_init, .f /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_read, disposed_instance_state, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_read, disposed_instance_state, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all disposed samples. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, SAMPLE_DISPOSED_IST_CNT, "# read %d, expected %d", ret, SAMPLE_DISPOSED_IST_CNT); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_DISPOSED_IST_CNT); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -708,7 +683,6 @@ Test(ddsc_readcondition_read, disposed_instance_state, .init=readcondition_init, * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_readcondition_read::disposed_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i * 3) + 1; @@ -717,15 +691,15 @@ Test(ddsc_readcondition_read, disposed_instance_state, .init=readcondition_init, dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_DISPOSED; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -733,18 +707,18 @@ Test(ddsc_readcondition_read, disposed_instance_state, .init=readcondition_init, /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_read, no_writers_instance_state, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_read, no_writers_instance_state, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all samples without a writer. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, SAMPLE_NO_WRITER_IST_CNT, "# read %d, expected %d", ret, SAMPLE_NO_WRITER_IST_CNT); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_NO_WRITER_IST_CNT); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -759,7 +733,6 @@ Test(ddsc_readcondition_read, no_writers_instance_state, .init=readcondition_ini * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_readcondition_read::no_writers_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i * 3) + 2; @@ -768,15 +741,15 @@ Test(ddsc_readcondition_read, no_writers_instance_state, .init=readcondition_ini dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_NO_WRITERS; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -784,18 +757,18 @@ Test(ddsc_readcondition_read, no_writers_instance_state, .init=readcondition_ini /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_read, combination_of_states, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_read, combination_of_states, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all samples that match the mask (should be only one). */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 1, "# read %d, expected %d", ret, 1); + CU_ASSERT_EQUAL_FATAL(ret, 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -810,7 +783,6 @@ Test(ddsc_readcondition_read, combination_of_states, .init=readcondition_init, . * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_readcondition_read::combination_of_states: Read", (*sample)); /* Expected states. */ int expected_long_1 = 3; @@ -819,15 +791,15 @@ Test(ddsc_readcondition_read, combination_of_states, .init=readcondition_init, . dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -835,18 +807,18 @@ Test(ddsc_readcondition_read, combination_of_states, .init=readcondition_init, . /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_read, none, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_read, none, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_READ_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all samples that match the mask (should be none). */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 0, "# read %d, expected %d", ret, 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); /* * | long_1 | long_2 | long_3 | sst | vst | ist | @@ -865,19 +837,19 @@ Test(ddsc_readcondition_read, none, .init=readcondition_init, .fini=readconditio /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_read, with_mask, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_read, with_mask, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Read all samples that match the or'd masks. */ ret = dds_read_mask(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, DDS_NOT_READ_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE); - cr_assert_eq(ret, 3, "# read %d, expected %d", ret, 3); + CU_ASSERT_EQUAL_FATAL(ret, 3); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -892,7 +864,6 @@ Test(ddsc_readcondition_read, with_mask, .init=readcondition_init, .fini=readcon * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_readcondition_read::with_mask: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i == 0) ? 3 : (i == 1) ? 4 : 6; @@ -901,15 +872,15 @@ Test(ddsc_readcondition_read, with_mask, .init=readcondition_init, .fini=readcon dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -917,50 +888,43 @@ Test(ddsc_readcondition_read, with_mask, .init=readcondition_init, .fini=readcon /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_read, already_deleted, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_read, already_deleted, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Delete condition. */ ret = dds_delete(condition); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to delete prerequisite condition"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Try to read with a deleted condition. */ ret = dds_read(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_expect_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ - - - - - - - /************************************************************************************************** * * These will check the readcondition taking in various ways. * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_take, any, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_take, any, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all non-read samples (should be last part). */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, MAX_SAMPLES, "# read %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -975,7 +939,6 @@ Test(ddsc_readcondition_take, any, .init=readcondition_init, .fini=readcondition * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_readcondition_take::any: Take", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -984,15 +947,15 @@ Test(ddsc_readcondition_take, any, .init=readcondition_init, .fini=readcondition dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1000,18 +963,18 @@ Test(ddsc_readcondition_take, any, .init=readcondition_init, .fini=readcondition /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_take, not_read_sample_state, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_take, not_read_sample_state, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all non-read samples (should be last part). */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, MAX_SAMPLES - (SAMPLE_LAST_READ_SST + 1), "# read %d, expected %d", ret, MAX_SAMPLES - (SAMPLE_LAST_READ_SST + 1)); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - (SAMPLE_LAST_READ_SST + 1)); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1026,7 +989,6 @@ Test(ddsc_readcondition_take, not_read_sample_state, .init=readcondition_init, . * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_readcondition_take::not_read_sample_state: Take", (*sample)); /* Expected states. */ int expected_long_1 = SAMPLE_LAST_READ_SST + 1 + i; @@ -1035,15 +997,15 @@ Test(ddsc_readcondition_take, not_read_sample_state, .init=readcondition_init, . dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1051,18 +1013,18 @@ Test(ddsc_readcondition_take, not_read_sample_state, .init=readcondition_init, . /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_take, read_sample_state, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_take, read_sample_state, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all already read samples (should be first part). */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, SAMPLE_LAST_READ_SST + 1, "# read %d, expected %d", ret, SAMPLE_LAST_READ_SST + 1); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_LAST_READ_SST + 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1077,7 +1039,6 @@ Test(ddsc_readcondition_take, read_sample_state, .init=readcondition_init, .fini * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_readcondition_take::read_sample_state: Take", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -1086,15 +1047,15 @@ Test(ddsc_readcondition_take, read_sample_state, .init=readcondition_init, .fini dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1102,18 +1063,18 @@ Test(ddsc_readcondition_take, read_sample_state, .init=readcondition_init, .fini /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_take, new_view_state, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_take, new_view_state, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all new-view samples (should be last part). */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, MAX_SAMPLES - (SAMPLE_LAST_OLD_VST + 1), "# read %d, expected %d", ret, MAX_SAMPLES - (SAMPLE_LAST_OLD_VST + 1)); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - (SAMPLE_LAST_OLD_VST + 1)); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1128,7 +1089,6 @@ Test(ddsc_readcondition_take, new_view_state, .init=readcondition_init, .fini=re * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_readcondition_take::new_view_state: Take", (*sample)); /* Expected states. */ int expected_long_1 = SAMPLE_LAST_OLD_VST + 1 + i; @@ -1137,15 +1097,15 @@ Test(ddsc_readcondition_take, new_view_state, .init=readcondition_init, .fini=re dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1153,18 +1113,18 @@ Test(ddsc_readcondition_take, new_view_state, .init=readcondition_init, .fini=re /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_take, not_new_view_state, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_take, not_new_view_state, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all old-view samples (should be first part). */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, SAMPLE_LAST_OLD_VST + 1, "# read %d, expected %d", ret, SAMPLE_LAST_OLD_VST + 1); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_LAST_OLD_VST + 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1179,7 +1139,6 @@ Test(ddsc_readcondition_take, not_new_view_state, .init=readcondition_init, .fin * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_readcondition_take::not_new_view_state: Take", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -1188,15 +1147,15 @@ Test(ddsc_readcondition_take, not_new_view_state, .init=readcondition_init, .fin dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1204,18 +1163,18 @@ Test(ddsc_readcondition_take, not_new_view_state, .init=readcondition_init, .fin /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_take, alive_instance_state, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_take, alive_instance_state, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all alive samples. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, SAMPLE_ALIVE_IST_CNT, "# read %d, expected %d", ret, SAMPLE_ALIVE_IST_CNT); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_ALIVE_IST_CNT); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1230,7 +1189,6 @@ Test(ddsc_readcondition_take, alive_instance_state, .init=readcondition_init, .f * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_readcondition_take::alive_instance_state: Take", (*sample)); /* Expected states. */ int expected_long_1 = i * 3; @@ -1239,15 +1197,15 @@ Test(ddsc_readcondition_take, alive_instance_state, .init=readcondition_init, .f dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1255,18 +1213,18 @@ Test(ddsc_readcondition_take, alive_instance_state, .init=readcondition_init, .f /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_take, disposed_instance_state, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_take, disposed_instance_state, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all disposed samples. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, SAMPLE_DISPOSED_IST_CNT, "# read %d, expected %d", ret, SAMPLE_DISPOSED_IST_CNT); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_DISPOSED_IST_CNT); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1281,7 +1239,6 @@ Test(ddsc_readcondition_take, disposed_instance_state, .init=readcondition_init, * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_readcondition_take::disposed_instance_state: Take", (*sample)); /* Expected states. */ int expected_long_1 = (i * 3) + 1; @@ -1290,15 +1247,15 @@ Test(ddsc_readcondition_take, disposed_instance_state, .init=readcondition_init, dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_DISPOSED; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1306,18 +1263,18 @@ Test(ddsc_readcondition_take, disposed_instance_state, .init=readcondition_init, /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_take, no_writers_instance_state, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_take, no_writers_instance_state, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all samples without a writer. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, SAMPLE_NO_WRITER_IST_CNT, "# read %d, expected %d", ret, SAMPLE_NO_WRITER_IST_CNT); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_NO_WRITER_IST_CNT); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1332,7 +1289,6 @@ Test(ddsc_readcondition_take, no_writers_instance_state, .init=readcondition_ini * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_readcondition_take::no_writers_instance_state: Take", (*sample)); /* Expected states. */ int expected_long_1 = (i * 3) + 2; @@ -1341,15 +1297,15 @@ Test(ddsc_readcondition_take, no_writers_instance_state, .init=readcondition_ini dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_NO_WRITERS; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1357,18 +1313,18 @@ Test(ddsc_readcondition_take, no_writers_instance_state, .init=readcondition_ini /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_take, combination_of_states, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_take, combination_of_states, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all samples that match the mask (should be only one). */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 1, "# read %d, expected %d", ret, 1); + CU_ASSERT_EQUAL_FATAL(ret, 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1383,7 +1339,6 @@ Test(ddsc_readcondition_take, combination_of_states, .init=readcondition_init, . * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_readcondition_take::combination_of_states: Take", (*sample)); /* Expected states. */ int expected_long_1 = 3; @@ -1392,15 +1347,15 @@ Test(ddsc_readcondition_take, combination_of_states, .init=readcondition_init, . dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1408,18 +1363,18 @@ Test(ddsc_readcondition_take, combination_of_states, .init=readcondition_init, . /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_take, none, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_take, none, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_READ_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all samples that match the mask (should be none). */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 0, "# read %d, expected %d", ret, 0); + CU_ASSERT_EQUAL_FATAL(ret, 0); /* * | long_1 | long_2 | long_3 | sst | vst | ist | @@ -1438,19 +1393,19 @@ Test(ddsc_readcondition_take, none, .init=readcondition_init, .fini=readconditio /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_take, with_mask, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_take, with_mask, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Take all samples that match the or'd masks. */ ret = dds_take_mask(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, DDS_NOT_READ_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE); - cr_assert_eq(ret, 3, "# read %d, expected %d", ret, 3); + CU_ASSERT_EQUAL_FATAL(ret, 3); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1465,7 +1420,6 @@ Test(ddsc_readcondition_take, with_mask, .init=readcondition_init, .fini=readcon * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_readcondition_take::with_mask: Take", (*sample)); /* Expected states. */ int expected_long_1 = (i == 0) ? 3 : (i == 1) ? 4 : 6; @@ -1474,15 +1428,15 @@ Test(ddsc_readcondition_take, with_mask, .init=readcondition_init, .fini=readcon dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } dds_delete(condition); @@ -1490,22 +1444,22 @@ Test(ddsc_readcondition_take, with_mask, .init=readcondition_init, .fini=readcon /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_readcondition_take, already_deleted, .init=readcondition_init, .fini=readcondition_fini) +CU_Test(ddsc_readcondition_take, already_deleted, .init=readcondition_init, .fini=readcondition_fini) { dds_entity_t condition; dds_return_t ret; /* Create condition. */ condition = dds_create_readcondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(condition, 0, "Failed to create prerequisite condition"); + CU_ASSERT_FATAL(condition > 0); /* Delete condition. */ ret = dds_delete(condition); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to delete prerequisite condition"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Try to take with a deleted condition. */ ret = dds_take(condition, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_expect_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/reader.c b/src/core/ddsc/tests/reader.c index e18addc..3f3b435 100644 --- a/src/core/ddsc/tests/reader.c +++ b/src/core/ddsc/tests/reader.c @@ -15,18 +15,8 @@ #include "os/os.h" #include "Space.h" #include "RoundTrip.h" -#include -#include -#include - - -#if 0 -#define PRINT_SAMPLE(info, sample) cr_log_info("%s (%d, %d, %d)\n", info, sample.long_1, sample.long_2, sample.long_3); -#else -#define PRINT_SAMPLE(info, sample) -#endif - - +#include "CUnit/Test.h" +#include "CUnit/Theory.h" /************************************************************************************************** * @@ -93,48 +83,48 @@ reader_init(void) g_listener = dds_create_listener(NULL); g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0); g_subscriber = dds_create_subscriber(g_participant, NULL, NULL); - cr_assert_gt(g_subscriber, 0, "Failed to create prerequisite g_subscriber"); + CU_ASSERT_FATAL(g_subscriber > 0); g_waitset = dds_create_waitset(g_participant); - cr_assert_gt(g_waitset, 0, "Failed to create g_waitset"); + CU_ASSERT_FATAL(g_waitset > 0); g_topic = dds_create_topic(g_participant, &Space_Type1_desc, create_topic_name("ddsc_reader_test", name, sizeof name), NULL, NULL); - cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic"); + CU_ASSERT_FATAL(g_topic > 0); /* Create a reader that keeps last sample of all instances. */ dds_qset_history(g_qos, DDS_HISTORY_KEEP_LAST, 1); g_reader = dds_create_reader(g_participant, g_topic, g_qos, NULL); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite g_reader"); + CU_ASSERT_FATAL(g_reader > 0); /* Create a reader that will not automatically dispose unregistered samples. */ dds_qset_writer_data_lifecycle(g_qos, false); g_writer = dds_create_writer(g_participant, g_topic, g_qos, NULL); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer"); + CU_ASSERT_FATAL(g_writer > 0); /* Sync g_reader to g_writer. */ ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_reader r"); - cr_assert_eq(g_reader, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_reader a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_reader, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Sync g_writer to g_reader. */ ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_writer status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_writer, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_writer r"); - cr_assert_eq(g_writer, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_writer a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_writer, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Initialize reading buffers. */ memset (g_data, 0, sizeof (g_data)); @@ -152,28 +142,24 @@ reader_init(void) sample.long_2 = i/2; sample.long_3 = i/3; - PRINT_SAMPLE("INIT: Write ", sample); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); if (ist == DDS_IST_NOT_ALIVE_DISPOSED) { - PRINT_SAMPLE("INIT: Dispose ", sample); ret = dds_dispose(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite dispose"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } if (ist == DDS_IST_NOT_ALIVE_NO_WRITERS) { - PRINT_SAMPLE("INIT: Unregister", sample); ret = dds_unregister_instance(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite unregister"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } } /* Read samples to get read&old_view states. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, SAMPLE_LAST_OLD_VST + 1); - cr_assert_eq(ret, SAMPLE_LAST_OLD_VST + 1, "Failed prerequisite read"); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_LAST_OLD_VST + 1); for(int i = 0; i < ret; i++) { Space_Type1 *s = (Space_Type1*)g_samples[i]; - PRINT_SAMPLE("INIT: Read ", (*s)); (void)s; } @@ -184,19 +170,16 @@ reader_init(void) sample.long_2 = i/2; sample.long_3 = i/3; - PRINT_SAMPLE("INIT: Rewrite ", sample); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); if ((ist == DDS_IST_NOT_ALIVE_DISPOSED) && (i != 4)) { - PRINT_SAMPLE("INIT: Dispose ", sample); ret = dds_dispose(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite dispose"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } if (ist == DDS_IST_NOT_ALIVE_NO_WRITERS) { - PRINT_SAMPLE("INIT: Unregister", sample); ret = dds_unregister_instance(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite unregister"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } } @@ -219,7 +202,7 @@ samples_cnt(void) { dds_return_t ret; ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_geq(ret, 0, "Failed samples count read: %d", dds_err_nr(ret)); + CU_ASSERT_FATAL(ret >= 0); return ret; } @@ -229,24 +212,24 @@ samples_cnt(void) * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_reader_create, valid) = { - DataPoints(dds_entity_t*, &g_subscriber, &g_participant), - DataPoints(dds_qos_t**, &g_qos_null, &g_qos ), - DataPoints(dds_listener_t**, &g_list_null, &g_listener ), +CU_TheoryDataPoints(ddsc_reader_create, valid) = { + CU_DataPoints(dds_entity_t*, &g_subscriber, &g_participant), + CU_DataPoints(dds_qos_t**, &g_qos_null, &g_qos ), + CU_DataPoints(dds_listener_t**, &g_list_null, &g_listener ), }; -Theory((dds_entity_t *ent, dds_qos_t **qos, dds_listener_t **listener), ddsc_reader_create, valid, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t *ent, dds_qos_t **qos, dds_listener_t **listener), ddsc_reader_create, valid, .init=reader_init, .fini=reader_fini) { dds_entity_t rdr; dds_return_t ret; rdr = dds_create_reader(*ent, g_topic, *qos, *listener); - cr_assert_gt(rdr, 0, "Failed dds_create_reader(%p, %p, %p): %d", ent, *qos, *listener, dds_err_nr(rdr)); + CU_ASSERT_FATAL(rdr > 0); ret = dds_delete(rdr); - cr_assert_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_reader_create, invalid_qos_participant, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_reader_create, invalid_qos_participant, .init=reader_init, .fini=reader_fini) { dds_entity_t rdr; dds_qos_t *qos = dds_create_qos(); @@ -255,13 +238,13 @@ Test(ddsc_reader_create, invalid_qos_participant, .init=reader_init, .fini=reade dds_qset_reader_data_lifecycle(qos, DDS_SECS(-1), DDS_SECS(-1)); OS_WARNING_MSVC_ON(28020); rdr = dds_create_reader(g_participant, g_topic, qos, NULL); - cr_assert_eq(dds_err_nr(rdr), DDS_RETCODE_INCONSISTENT_POLICY, "returned %d", dds_err_nr(rdr)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(rdr), DDS_RETCODE_INCONSISTENT_POLICY); dds_delete_qos(qos); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_reader_create, invalid_qos_subscriber, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_reader_create, invalid_qos_subscriber, .init=reader_init, .fini=reader_fini) { dds_entity_t rdr; dds_qos_t *qos = dds_create_qos(); @@ -270,24 +253,24 @@ Test(ddsc_reader_create, invalid_qos_subscriber, .init=reader_init, .fini=reader dds_qset_reader_data_lifecycle(qos, DDS_SECS(-1), DDS_SECS(-1)); OS_WARNING_MSVC_ON(28020); rdr = dds_create_reader(g_subscriber, g_topic, qos, NULL); - cr_assert_eq(dds_err_nr(rdr), DDS_RETCODE_INCONSISTENT_POLICY, "returned %d", dds_err_nr(rdr)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(rdr), DDS_RETCODE_INCONSISTENT_POLICY); dds_delete_qos(qos); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_reader_create, non_participants_non_topics) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_reader, &g_waitset), - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_reader, &g_waitset), +CU_TheoryDataPoints(ddsc_reader_create, non_participants_non_topics) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_reader, &g_waitset), + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_reader, &g_waitset), }; -Theory((dds_entity_t *par, dds_entity_t *top), ddsc_reader_create, non_participants_non_topics, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t *par, dds_entity_t *top), ddsc_reader_create, non_participants_non_topics, .init=reader_init, .fini=reader_fini) { dds_entity_t rdr; /* The only valid permutation is when par is actual the participant and top is * actually the topic. So, don't test that permutation. */ - cr_assume((par != &g_participant) || (top != &g_topic)); + CU_ASSERT_FATAL((par != &g_participant) || (top != &g_topic)); rdr = dds_create_reader(*par, *top, NULL, NULL); - cr_assert_eq(dds_err_nr(rdr), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(rdr)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(rdr), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -301,74 +284,77 @@ Theory((dds_entity_t *par, dds_entity_t *top), ddsc_reader_create, non_participa * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read, invalid_buffers) = { - DataPoints(void**, g_samples, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), - DataPoints(size_t, 0, 3, MAX_SAMPLES ), - DataPoints(uint32_t, 0, 3, MAX_SAMPLES ), +CU_TheoryDataPoints(ddsc_read, invalid_buffers) = { + CU_DataPoints(void**, g_samples, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL), + CU_DataPoints(size_t, 0, 3, MAX_SAMPLES), + CU_DataPoints(uint32_t, 0, 3, MAX_SAMPLES), }; -Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_read, invalid_buffers, .init=reader_init, .fini=reader_fini) +CU_Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_read, invalid_buffers, .init=reader_init, .fini=reader_fini) { dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid. So, don't test that. */ - cr_assume((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); + CU_ASSERT_FATAL((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); /* TODO: CHAM-306, currently, a buffer is automatically 'promoted' to a loan when a buffer is * provided with NULL pointers. So, in fact, there's currently no real difference between calling * dds_read() dds_read_wl() (except for the provided bufsz). This will change, which means that * the given buffer should contain valid pointers, which again means that 'loan intended' buffer * should result in bad_parameter. * However, that's not the case yet. So don't test it. */ - cr_assume(buf != g_loans); - ret = dds_read(g_reader, buf, si, bufsz, maxs); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + if (buf != g_loans) { + ret = dds_read(g_reader, buf, si, bufsz, maxs); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + } else { + CU_PASS(); + } } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_read, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_read, invalid_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t rdr), ddsc_read, invalid_readers, .init=reader_init, .fini=reader_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), +CU_TheoryDataPoints(ddsc_read, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_read, non_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read, non_readers, .init=reader_init, .fini=reader_fini) { dds_return_t ret; ret = dds_read(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read, already_deleted, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read, already_deleted, .init=reader_init, .fini=reader_fini) { dds_return_t ret; /* Try to read with a deleted reader. */ dds_delete(g_reader); ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_expect_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read, valid, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read, valid, .init=reader_init, .fini=reader_fini) { dds_return_t ret; ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, MAX_SAMPLES, "# read %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -383,7 +369,6 @@ Test(ddsc_read, valid, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_read::valid: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -392,20 +377,20 @@ Test(ddsc_read, valid, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ @@ -420,66 +405,66 @@ Test(ddsc_read, valid, .init=reader_init, .fini=reader_fini) * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_wl, invalid_buffers) = { - DataPoints(void**, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), - DataPoints(uint32_t, 0, 3, MAX_SAMPLES ), +CU_TheoryDataPoints(ddsc_read_wl, invalid_buffers) = { + CU_DataPoints(void**, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), + CU_DataPoints(uint32_t, 0, 3, MAX_SAMPLES ), }; -Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_read_wl, invalid_buffers, .init=reader_init, .fini=reader_fini) +CU_Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_read_wl, invalid_buffers, .init=reader_init, .fini=reader_fini) { dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid. So, don't test that. */ - cr_assume((buf != g_loans) || (si != g_info) || (maxs == 0)); + CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); ret = dds_read_wl(g_reader, buf, si, maxs); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_wl, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_read_wl, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_read_wl, invalid_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t rdr), ddsc_read_wl, invalid_readers, .init=reader_init, .fini=reader_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_wl(rdr, g_loans, g_info, MAX_SAMPLES); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_wl, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), +CU_TheoryDataPoints(ddsc_read_wl, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_read_wl, non_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_wl, non_readers, .init=reader_init, .fini=reader_fini) { dds_return_t ret; ret = dds_read_wl(*rdr, g_loans, g_info, MAX_SAMPLES); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_wl, already_deleted, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_wl, already_deleted, .init=reader_init, .fini=reader_fini) { dds_return_t ret; /* Try to read with a deleted reader. */ dds_delete(g_reader); ret = dds_read_wl(g_reader, g_loans, g_info, MAX_SAMPLES); - cr_expect_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_wl, valid, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_wl, valid, .init=reader_init, .fini=reader_fini) { dds_return_t ret; ret = dds_read_wl(g_reader, g_loans, g_info, MAX_SAMPLES); - cr_assert_eq(ret, MAX_SAMPLES, "# read %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -494,7 +479,6 @@ Test(ddsc_read_wl, valid, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_read::valid: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -503,23 +487,23 @@ Test(ddsc_read_wl, valid, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ @@ -533,80 +517,83 @@ Test(ddsc_read_wl, valid, .init=reader_init, .fini=reader_fini) * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_mask, invalid_buffers) = { - DataPoints(void**, g_samples, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), - DataPoints(size_t, 0, 3, MAX_SAMPLES ), - DataPoints(uint32_t, 0, 3, MAX_SAMPLES ), +CU_TheoryDataPoints(ddsc_read_mask, invalid_buffers) = { + CU_DataPoints(void**, g_samples, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL), + CU_DataPoints(size_t, 0, 3, MAX_SAMPLES), + CU_DataPoints(uint32_t, 0, 3, MAX_SAMPLES), }; -Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_read_mask, invalid_buffers, .init=reader_init, .fini=reader_fini) +CU_Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_read_mask, invalid_buffers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid. So, don't test that. */ - cr_assume((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); + CU_ASSERT_FATAL((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); /* TODO: CHAM-306, currently, a buffer is automatically 'promoted' to a loan when a buffer is * provided with NULL pointers. So, in fact, there's currently no real difference between calling * dds_read_mask() dds_read_mask_wl() (except for the provided bufsz). This will change, which means that * the given buffer should contain valid pointers, which again means that 'loan intended' buffer * should result in bad_parameter. * However, that's not the case yet. So don't test it. */ - cr_assume(buf != g_loans); - ret = dds_read_mask(g_reader, buf, si, bufsz, maxs, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + if (buf != g_loans) { + ret = dds_read_mask(g_reader, buf, si, bufsz, maxs, mask); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + } else { + CU_PASS(); + } } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_mask, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_read_mask, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_read_mask, invalid_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t rdr), ddsc_read_mask, invalid_readers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_mask, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), +CU_TheoryDataPoints(ddsc_read_mask, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_read_mask, non_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_mask, non_readers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_read_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask, already_deleted, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask, already_deleted, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* Try to read with a deleted reader. */ dds_delete(g_reader); ret = dds_read_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_expect_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask, any, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask, any, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, MAX_SAMPLES, "# read %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -621,7 +608,6 @@ Test(ddsc_read_mask, any, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_read_mask::any: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -630,32 +616,32 @@ Test(ddsc_read_mask, any, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask, not_read_sample_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask, not_read_sample_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, MAX_SAMPLES - (SAMPLE_LAST_READ_SST + 1), "# read %d, expected %d", ret, MAX_SAMPLES - (SAMPLE_LAST_READ_SST + 1)); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - (SAMPLE_LAST_READ_SST + 1)); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -670,7 +656,6 @@ Test(ddsc_read_mask, not_read_sample_state, .init=reader_init, .fini=reader_fini * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_read_mask::not_read_sample_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = SAMPLE_LAST_READ_SST + 1 + i; @@ -679,32 +664,32 @@ Test(ddsc_read_mask, not_read_sample_state, .init=reader_init, .fini=reader_fini dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask, read_sample_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask, read_sample_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, SAMPLE_LAST_READ_SST + 1, "# read %d, expected %d", ret, SAMPLE_LAST_READ_SST + 1); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_LAST_READ_SST + 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -719,7 +704,6 @@ Test(ddsc_read_mask, read_sample_state, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_read_mask::read_sample_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -728,32 +712,32 @@ Test(ddsc_read_mask, read_sample_state, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask, new_view_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask, new_view_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, MAX_SAMPLES - (SAMPLE_LAST_OLD_VST + 1), "# read %d, expected %d", ret, MAX_SAMPLES - (SAMPLE_LAST_OLD_VST + 1)); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - (SAMPLE_LAST_OLD_VST + 1)); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -768,7 +752,6 @@ Test(ddsc_read_mask, new_view_state, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_read_mask::new_view_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = SAMPLE_LAST_OLD_VST + 1 + i; @@ -777,32 +760,32 @@ Test(ddsc_read_mask, new_view_state, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask, not_new_view_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask, not_new_view_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, SAMPLE_LAST_OLD_VST + 1, "# read %d, expected %d", ret, SAMPLE_LAST_OLD_VST + 1); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_LAST_OLD_VST + 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -817,7 +800,6 @@ Test(ddsc_read_mask, not_new_view_state, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_read_mask::not_new_view_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -826,32 +808,32 @@ Test(ddsc_read_mask, not_new_view_state, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask, alive_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask, alive_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, 3, "# read %d, expected %d", ret, 3); + CU_ASSERT_EQUAL_FATAL(ret, 3); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -866,7 +848,6 @@ Test(ddsc_read_mask, alive_instance_state, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_read_mask::alive_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i * 3; @@ -875,32 +856,32 @@ Test(ddsc_read_mask, alive_instance_state, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask, not_alive_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask, not_alive_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE | DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, 4, "# read %d, expected %d", ret, 4); + CU_ASSERT_EQUAL_FATAL(ret, 4); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -915,7 +896,6 @@ Test(ddsc_read_mask, not_alive_instance_state, .init=reader_init, .fini=reader_f * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_read_mask::alive_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i <= 1) ? i + 1 : i + 2; @@ -924,33 +904,33 @@ Test(ddsc_read_mask, not_alive_instance_state, .init=reader_init, .fini=reader_f dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); - cr_assert_neq(g_info[i].instance_state, DDS_IST_ALIVE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); + CU_ASSERT_NOT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_ALIVE); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask, disposed_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask, disposed_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -965,7 +945,6 @@ Test(ddsc_read_mask, disposed_instance_state, .init=reader_init, .fini=reader_fi * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_read_mask::disposed_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i * 3) + 1; @@ -974,32 +953,32 @@ Test(ddsc_read_mask, disposed_instance_state, .init=reader_init, .fini=reader_fi dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_DISPOSED; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask, no_writers_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask, no_writers_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1014,7 +993,6 @@ Test(ddsc_read_mask, no_writers_instance_state, .init=reader_init, .fini=reader_ * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_read_mask::no_writers_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i * 3) + 2; @@ -1023,32 +1001,32 @@ Test(ddsc_read_mask, no_writers_instance_state, .init=reader_init, .fini=reader_ dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_NO_WRITERS; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask, combination_of_states, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask, combination_of_states, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, 1, "# read %d, expected %d", ret, 1); + CU_ASSERT_EQUAL_FATAL(ret, 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1063,7 +1041,6 @@ Test(ddsc_read_mask, combination_of_states, .init=reader_init, .fini=reader_fini * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_read_mask::combination_of_states: Read", (*sample)); /* Expected states. */ int expected_long_1 = 3; @@ -1072,20 +1049,20 @@ Test(ddsc_read_mask, combination_of_states, .init=reader_init, .fini=reader_fini dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ @@ -1099,72 +1076,72 @@ Test(ddsc_read_mask, combination_of_states, .init=reader_init, .fini=reader_fini * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_mask_wl, invalid_buffers) = { - DataPoints(void**, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), - DataPoints(uint32_t, 0, 3, MAX_SAMPLES ), +CU_TheoryDataPoints(ddsc_read_mask_wl, invalid_buffers) = { + CU_DataPoints(void**, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), + CU_DataPoints(uint32_t, 0, 3, MAX_SAMPLES ), }; -Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_read_mask_wl, invalid_buffers, .init=reader_init, .fini=reader_fini) +CU_Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_read_mask_wl, invalid_buffers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid. So, don't test that. */ - cr_assume((buf != g_loans) || (si != g_info) || (maxs == 0)); + CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); ret = dds_read_mask_wl(g_reader, buf, si, maxs, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_mask_wl, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_read_mask_wl, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_read_mask_wl, invalid_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t rdr), ddsc_read_mask_wl, invalid_readers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_mask_wl, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), +CU_TheoryDataPoints(ddsc_read_mask_wl, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_read_mask_wl, non_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_mask_wl, non_readers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_read_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask_wl, already_deleted, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask_wl, already_deleted, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* Try to read with a deleted reader. */ dds_delete(g_reader); ret = dds_read_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_expect_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask_wl, any, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask_wl, any, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, MAX_SAMPLES, "# read %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1179,7 +1156,6 @@ Test(ddsc_read_mask_wl, any, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_read_mask_wl::any: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -1188,35 +1164,35 @@ Test(ddsc_read_mask_wl, any, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask_wl, not_read_sample_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask_wl, not_read_sample_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, MAX_SAMPLES - (SAMPLE_LAST_READ_SST + 1), "# read %d, expected %d", ret, MAX_SAMPLES - (SAMPLE_LAST_READ_SST + 1)); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - (SAMPLE_LAST_READ_SST + 1)); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1231,7 +1207,6 @@ Test(ddsc_read_mask_wl, not_read_sample_state, .init=reader_init, .fini=reader_f * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_read_mask_wl::not_read_sample_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = SAMPLE_LAST_READ_SST + 1 + i; @@ -1240,35 +1215,35 @@ Test(ddsc_read_mask_wl, not_read_sample_state, .init=reader_init, .fini=reader_f dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask_wl, read_sample_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask_wl, read_sample_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, SAMPLE_LAST_READ_SST + 1, "# read %d, expected %d", ret, SAMPLE_LAST_READ_SST + 1); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_LAST_READ_SST + 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1283,7 +1258,6 @@ Test(ddsc_read_mask_wl, read_sample_state, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_read_mask_wl::read_sample_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -1292,35 +1266,35 @@ Test(ddsc_read_mask_wl, read_sample_state, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask_wl, new_view_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask_wl, new_view_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, MAX_SAMPLES - (SAMPLE_LAST_OLD_VST + 1), "# read %d, expected %d", ret, MAX_SAMPLES - (SAMPLE_LAST_OLD_VST + 1)); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - (SAMPLE_LAST_OLD_VST + 1)); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1335,7 +1309,6 @@ Test(ddsc_read_mask_wl, new_view_state, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_read_mask_wl::new_view_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = SAMPLE_LAST_OLD_VST + 1 + i; @@ -1344,35 +1317,35 @@ Test(ddsc_read_mask_wl, new_view_state, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask_wl, not_new_view_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask_wl, not_new_view_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, SAMPLE_LAST_OLD_VST + 1, "# read %d, expected %d", ret, SAMPLE_LAST_OLD_VST + 1); + CU_ASSERT_EQUAL_FATAL(ret, SAMPLE_LAST_OLD_VST + 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1387,7 +1360,6 @@ Test(ddsc_read_mask_wl, not_new_view_state, .init=reader_init, .fini=reader_fini * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_read_mask_wl::not_new_view_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -1396,35 +1368,35 @@ Test(ddsc_read_mask_wl, not_new_view_state, .init=reader_init, .fini=reader_fini dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask_wl, alive_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask_wl, alive_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, 3, "# read %d, expected %d", ret, 3); + CU_ASSERT_EQUAL_FATAL(ret, 3); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1439,7 +1411,6 @@ Test(ddsc_read_mask_wl, alive_instance_state, .init=reader_init, .fini=reader_fi * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_read_mask_wl::alive_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i * 3; @@ -1448,35 +1419,35 @@ Test(ddsc_read_mask_wl, alive_instance_state, .init=reader_init, .fini=reader_fi dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask_wl, not_alive_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask_wl, not_alive_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE | DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, 4, "# read %d, expected %d", ret, 4); + CU_ASSERT_EQUAL_FATAL(ret, 4); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1491,7 +1462,6 @@ Test(ddsc_read_mask_wl, not_alive_instance_state, .init=reader_init, .fini=reade * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_read_mask_wl::alive_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i <= 1) ? i + 1 : i + 2; @@ -1500,36 +1470,36 @@ Test(ddsc_read_mask_wl, not_alive_instance_state, .init=reader_init, .fini=reade dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); - cr_assert_neq(g_info[i].instance_state, DDS_IST_ALIVE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); + CU_ASSERT_NOT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_ALIVE); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask_wl, disposed_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask_wl, disposed_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1544,7 +1514,6 @@ Test(ddsc_read_mask_wl, disposed_instance_state, .init=reader_init, .fini=reader * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_read_mask_wl::disposed_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i * 3) + 1; @@ -1553,35 +1522,35 @@ Test(ddsc_read_mask_wl, disposed_instance_state, .init=reader_init, .fini=reader dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_DISPOSED; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask_wl, no_writers_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask_wl, no_writers_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1596,7 +1565,6 @@ Test(ddsc_read_mask_wl, no_writers_instance_state, .init=reader_init, .fini=read * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_read_mask_wl::no_writers_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i * 3) + 2; @@ -1605,35 +1573,35 @@ Test(ddsc_read_mask_wl, no_writers_instance_state, .init=reader_init, .fini=read dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_NO_WRITERS; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_mask_wl, combination_of_states, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_read_mask_wl, combination_of_states, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE; dds_return_t ret; /* Read all samples that matches the mask. */ ret = dds_read_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, 1, "# read %d, expected %d", ret, 1); + CU_ASSERT_EQUAL_FATAL(ret, 1); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1648,7 +1616,6 @@ Test(ddsc_read_mask_wl, combination_of_states, .init=reader_init, .fini=reader_f * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_read_mask_wl::combination_of_states: Read", (*sample)); /* Expected states. */ int expected_long_1 = 3; @@ -1657,23 +1624,23 @@ Test(ddsc_read_mask_wl, combination_of_states, .init=reader_init, .fini=reader_f dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ @@ -1687,75 +1654,78 @@ Test(ddsc_read_mask_wl, combination_of_states, .init=reader_init, .fini=reader_f * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take, invalid_buffers) = { - DataPoints(void**, g_samples, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), - DataPoints(size_t, 0, 3, MAX_SAMPLES ), - DataPoints(uint32_t, 0, 3, MAX_SAMPLES ), +CU_TheoryDataPoints(ddsc_take, invalid_buffers) = { + CU_DataPoints(void**, g_samples, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL), + CU_DataPoints(size_t, 0, 3, MAX_SAMPLES), + CU_DataPoints(uint32_t, 0, 3, MAX_SAMPLES), }; -Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_take, invalid_buffers, .init=reader_init, .fini=reader_fini) +CU_Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_take, invalid_buffers, .init=reader_init, .fini=reader_fini) { dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid. So, don't test that. */ - cr_assume((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); + CU_ASSERT_FATAL((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); /* TODO: CHAM-306, currently, a buffer is automatically 'promoted' to a loan when a buffer is * provided with NULL pointers. So, in fact, there's currently no real difference between calling * dds_take() dds_take_wl() (except for the provided bufsz). This will change, which means that * the given buffer should contain valid pointers, which again means that 'loan intended' buffer * should result in bad_parameter. * However, that's not the case yet. So don't test it. */ - cr_assume(buf != g_loans); - ret = dds_take(g_reader, buf, si, bufsz, maxs); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + if (buf != g_loans) { + ret = dds_take(g_reader, buf, si, bufsz, maxs); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + } else { + CU_PASS(); + } } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_take, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_take, invalid_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t rdr), ddsc_take, invalid_readers, .init=reader_init, .fini=reader_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), +CU_TheoryDataPoints(ddsc_take, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_take, non_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take, non_readers, .init=reader_init, .fini=reader_fini) { dds_return_t ret; ret = dds_take(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take, already_deleted, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take, already_deleted, .init=reader_init, .fini=reader_fini) { dds_return_t ret; /* Try to take with a deleted reader. */ dds_delete(g_reader); ret = dds_take(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_expect_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take, valid, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take, valid, .init=reader_init, .fini=reader_fini) { dds_return_t expected_cnt = MAX_SAMPLES; dds_return_t ret; ret = dds_take(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, MAX_SAMPLES, "# read %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1770,7 +1740,6 @@ Test(ddsc_take, valid, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_read::valid: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -1779,20 +1748,20 @@ Test(ddsc_take, valid, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ @@ -1806,67 +1775,67 @@ Test(ddsc_take, valid, .init=reader_init, .fini=reader_fini) * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_wl, invalid_buffers) = { - DataPoints(void**, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), - DataPoints(uint32_t, 0, 3, MAX_SAMPLES ), +CU_TheoryDataPoints(ddsc_take_wl, invalid_buffers) = { + CU_DataPoints(void**, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), + CU_DataPoints(uint32_t, 0, 3, MAX_SAMPLES ), }; -Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_take_wl, invalid_buffers, .init=reader_init, .fini=reader_fini) +CU_Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_take_wl, invalid_buffers, .init=reader_init, .fini=reader_fini) { dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid. So, don't test that. */ - cr_assume((buf != g_loans) || (si != g_info) || (maxs == 0)); + CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); ret = dds_take_wl(g_reader, buf, si, maxs); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_wl, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_take_wl, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_take_wl, invalid_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t rdr), ddsc_take_wl, invalid_readers, .init=reader_init, .fini=reader_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_wl(rdr, g_loans, g_info, MAX_SAMPLES); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_wl, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), +CU_TheoryDataPoints(ddsc_take_wl, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_take_wl, non_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_wl, non_readers, .init=reader_init, .fini=reader_fini) { dds_return_t ret; ret = dds_take_wl(*rdr, g_loans, g_info, MAX_SAMPLES); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_wl, already_deleted, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_wl, already_deleted, .init=reader_init, .fini=reader_fini) { dds_return_t ret; /* Try to read with a deleted reader. */ dds_delete(g_reader); ret = dds_take_wl(g_reader, g_loans, g_info, MAX_SAMPLES); - cr_expect_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_wl, valid, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_wl, valid, .init=reader_init, .fini=reader_fini) { dds_return_t expected_cnt = MAX_SAMPLES; dds_return_t ret; ret = dds_take_wl(g_reader, g_loans, g_info, MAX_SAMPLES); - cr_assert_eq(ret, MAX_SAMPLES, "# read %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1881,7 +1850,6 @@ Test(ddsc_take_wl, valid, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_take::valid: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -1890,23 +1858,23 @@ Test(ddsc_take_wl, valid, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ @@ -1920,73 +1888,76 @@ Test(ddsc_take_wl, valid, .init=reader_init, .fini=reader_fini) * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_mask, invalid_buffers) = { - DataPoints(void**, g_samples, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), - DataPoints(size_t, 0, 3, MAX_SAMPLES ), - DataPoints(uint32_t, 0, 3, MAX_SAMPLES ), +CU_TheoryDataPoints(ddsc_take_mask, invalid_buffers) = { + CU_DataPoints(void**, g_samples, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL), + CU_DataPoints(size_t, 0, 3, MAX_SAMPLES), + CU_DataPoints(uint32_t, 0, 3, MAX_SAMPLES), }; -Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_take_mask, invalid_buffers, .init=reader_init, .fini=reader_fini) +CU_Theory((void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_take_mask, invalid_buffers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid. So, don't test that. */ - cr_assume((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); + CU_ASSERT_FATAL((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); /* TODO: CHAM-306, currently, a buffer is automatically 'promoted' to a loan when a buffer is * provided with NULL pointers. So, in fact, there's currently no real difference between calling * dds_take_mask() dds_take_mask_wl() (except for the provided bufsz). This will change, which means that * the given buffer should contain valid pointers, which again means that 'loan intended' buffer * should result in bad_parameter. * However, that's not the case yet. So don't test it. */ - cr_assume(buf != g_loans); - ret = dds_take_mask(g_reader, buf, si, bufsz, maxs, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + if (buf != g_loans) { + ret = dds_take_mask(g_reader, buf, si, bufsz, maxs, mask); + CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + } else { + CU_PASS(); + } } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_mask, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_take_mask, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_take_mask, invalid_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t rdr), ddsc_take_mask, invalid_readers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_mask, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), +CU_TheoryDataPoints(ddsc_take_mask, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_take_mask, non_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_mask, non_readers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_take_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask, already_deleted, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask, already_deleted, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* Try to read with a deleted reader. */ dds_delete(g_reader); ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_expect_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask, any, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask, any, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = MAX_SAMPLES; @@ -1994,7 +1965,7 @@ Test(ddsc_take_mask, any, .init=reader_init, .fini=reader_fini) /* Read all samples that matches the mask. */ ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -2009,7 +1980,6 @@ Test(ddsc_take_mask, any, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_take_mask::any: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -2018,25 +1988,25 @@ Test(ddsc_take_mask, any, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask, not_read_sample_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask, not_read_sample_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 4; @@ -2044,7 +2014,7 @@ Test(ddsc_take_mask, not_read_sample_state, .init=reader_init, .fini=reader_fini /* Read all samples that matches the mask. */ ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -2059,7 +2029,6 @@ Test(ddsc_take_mask, not_read_sample_state, .init=reader_init, .fini=reader_fini * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_take_mask::not_read_sample_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = SAMPLE_LAST_READ_SST + 1 + i; @@ -2068,25 +2037,25 @@ Test(ddsc_take_mask, not_read_sample_state, .init=reader_init, .fini=reader_fini dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask, read_sample_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask, read_sample_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 3; @@ -2094,7 +2063,7 @@ Test(ddsc_take_mask, read_sample_state, .init=reader_init, .fini=reader_fini) /* Read all samples that matches the mask. */ ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -2109,7 +2078,6 @@ Test(ddsc_take_mask, read_sample_state, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_take_mask::read_sample_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -2118,25 +2086,25 @@ Test(ddsc_take_mask, read_sample_state, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask, new_view_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask, new_view_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 3; @@ -2144,7 +2112,7 @@ Test(ddsc_take_mask, new_view_state, .init=reader_init, .fini=reader_fini) /* Read all samples that matches the mask. */ ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -2159,7 +2127,6 @@ Test(ddsc_take_mask, new_view_state, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_take_mask::new_view_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = SAMPLE_LAST_OLD_VST + 1 + i; @@ -2168,25 +2135,25 @@ Test(ddsc_take_mask, new_view_state, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask, not_new_view_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask, not_new_view_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 4; @@ -2194,7 +2161,7 @@ Test(ddsc_take_mask, not_new_view_state, .init=reader_init, .fini=reader_fini) /* Read all samples that matches the mask. */ ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -2209,7 +2176,6 @@ Test(ddsc_take_mask, not_new_view_state, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_take_mask::not_new_view_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -2218,25 +2184,25 @@ Test(ddsc_take_mask, not_new_view_state, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask, alive_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask, alive_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE; dds_return_t expected_cnt = 3; @@ -2244,7 +2210,7 @@ Test(ddsc_take_mask, alive_instance_state, .init=reader_init, .fini=reader_fini) /* Read all samples that matches the mask. */ ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -2259,7 +2225,6 @@ Test(ddsc_take_mask, alive_instance_state, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_take_mask::alive_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i * 3; @@ -2268,25 +2233,25 @@ Test(ddsc_take_mask, alive_instance_state, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask, not_alive_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask, not_alive_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE | DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE; dds_return_t expected_cnt = 4; @@ -2294,7 +2259,7 @@ Test(ddsc_take_mask, not_alive_instance_state, .init=reader_init, .fini=reader_f /* Read all samples that matches the mask. */ ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -2309,7 +2274,6 @@ Test(ddsc_take_mask, not_alive_instance_state, .init=reader_init, .fini=reader_f * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_take_mask::alive_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i <= 1) ? i + 1 : i + 2; @@ -2318,26 +2282,26 @@ Test(ddsc_take_mask, not_alive_instance_state, .init=reader_init, .fini=reader_f dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); - cr_assert_neq(g_info[i].instance_state, DDS_IST_ALIVE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); + CU_ASSERT_NOT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_ALIVE); } /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask, disposed_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask, disposed_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE; dds_return_t expected_cnt = 2; @@ -2345,7 +2309,7 @@ Test(ddsc_take_mask, disposed_instance_state, .init=reader_init, .fini=reader_fi /* Read all samples that matches the mask. */ ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -2360,7 +2324,6 @@ Test(ddsc_take_mask, disposed_instance_state, .init=reader_init, .fini=reader_fi * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_take_mask::disposed_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i * 3) + 1; @@ -2369,25 +2332,25 @@ Test(ddsc_take_mask, disposed_instance_state, .init=reader_init, .fini=reader_fi dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_DISPOSED; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask, no_writers_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask, no_writers_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE; dds_return_t expected_cnt = 2; @@ -2395,7 +2358,7 @@ Test(ddsc_take_mask, no_writers_instance_state, .init=reader_init, .fini=reader_ /* Read all samples that matches the mask. */ ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -2410,7 +2373,6 @@ Test(ddsc_take_mask, no_writers_instance_state, .init=reader_init, .fini=reader_ * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_take_mask::no_writers_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i * 3) + 2; @@ -2419,25 +2381,25 @@ Test(ddsc_take_mask, no_writers_instance_state, .init=reader_init, .fini=reader_ dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_NO_WRITERS; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask, combination_of_states, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask, combination_of_states, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE; dds_return_t expected_cnt = 1; @@ -2445,7 +2407,7 @@ Test(ddsc_take_mask, combination_of_states, .init=reader_init, .fini=reader_fini /* Read all samples that matches the mask. */ ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -2460,7 +2422,6 @@ Test(ddsc_take_mask, combination_of_states, .init=reader_init, .fini=reader_fini * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_take_mask::combination_of_states: Read", (*sample)); /* Expected states. */ int expected_long_1 = 3; @@ -2469,25 +2430,25 @@ Test(ddsc_take_mask, combination_of_states, .init=reader_init, .fini=reader_fini dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask, take_instance_last_sample) +CU_Test(ddsc_take_mask, take_instance_last_sample) { #define WOULD_CRASH #ifdef WOULD_CRASH @@ -2509,37 +2470,37 @@ Test(ddsc_take_mask, take_instance_last_sample) g_qos = dds_create_qos(); dds_qset_history(g_qos, DDS_HISTORY_KEEP_ALL, DDS_LENGTH_UNLIMITED); g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0); g_waitset = dds_create_waitset(g_participant); - cr_assert_gt(g_waitset, 0, "Failed to create g_waitset"); + CU_ASSERT_FATAL(g_waitset > 0); g_topic = dds_create_topic(g_participant, &Space_Type1_desc, create_topic_name("ddsc_reader_test", name, 100), NULL, NULL); - cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic"); + CU_ASSERT_FATAL(g_topic > 0); g_reader = dds_create_reader(g_participant, g_topic, g_qos, NULL); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite g_reader"); + CU_ASSERT_FATAL(g_reader > 0); g_writer = dds_create_writer(g_participant, g_topic, NULL, NULL); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer"); + CU_ASSERT_FATAL(g_writer > 0); /* Sync g_reader to g_writer. */ ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_reader r"); - cr_assert_eq(g_reader, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_reader a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_reader, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Sync g_writer to g_reader. */ ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_writer status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_writer, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_writer r"); - cr_assert_eq(g_writer, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_writer a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_writer, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Initialize reading buffers. */ memset (g_data, 0, sizeof (g_data)); @@ -2557,16 +2518,16 @@ Test(ddsc_take_mask, take_instance_last_sample) sample.long_2 = 1; sample.long_3 = 2; ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 1, "Failed prerequisite read"); + CU_ASSERT_EQUAL_FATAL(ret, 1); sample.long_3 = 3; ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Take just one sample of the instance (the last one). */ ret = dds_take_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *s = (Space_Type1*)g_samples[i]; @@ -2576,23 +2537,22 @@ Test(ddsc_take_mask, take_instance_last_sample) * | 0 | 1 | 2 | read | old | alive | <--- no worries * | 0 | 1 | 3 | not_read | old | alive | <--- crashed */ - PRINT_SAMPLE("ddsc_take_mask::crash: Take", (*s)); /* Check data. */ - cr_assert_eq(s->long_1, 0); - cr_assert_eq(s->long_2, 1); - cr_assert_eq(s->long_3, expected_long_3); + CU_ASSERT_EQUAL_FATAL(s->long_1, 0); + CU_ASSERT_EQUAL_FATAL(s->long_2, 1); + CU_ASSERT_EQUAL_FATAL(s->long_3, expected_long_3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, DDS_VST_OLD); - cr_assert_eq(g_info[i].instance_state, DDS_IST_ALIVE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_OLD); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_ALIVE); } /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, 1, "# samples %d, expected %d", ret, 1); + CU_ASSERT_EQUAL_FATAL(ret, 1); /* * So far so good. @@ -2620,65 +2580,65 @@ Test(ddsc_take_mask, take_instance_last_sample) * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_mask_wl, invalid_buffers) = { - DataPoints(void**, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), - DataPoints(uint32_t, 0, 3, MAX_SAMPLES ), +CU_TheoryDataPoints(ddsc_take_mask_wl, invalid_buffers) = { + CU_DataPoints(void**, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), + CU_DataPoints(uint32_t, 0, 3, MAX_SAMPLES ), }; -Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_take_mask_wl, invalid_buffers, .init=reader_init, .fini=reader_fini) +CU_Theory((void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_take_mask_wl, invalid_buffers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid. So, don't test that. */ - cr_assume((buf != g_loans) || (si != g_info) || (maxs == 0)); + CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); ret = dds_take_mask_wl(g_reader, buf, si, maxs, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_mask_wl, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_take_mask_wl, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_take_mask_wl, invalid_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t rdr), ddsc_take_mask_wl, invalid_readers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_mask_wl, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), +CU_TheoryDataPoints(ddsc_take_mask_wl, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_take_mask_wl, non_readers, .init=reader_init, .fini=reader_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_mask_wl, non_readers, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_take_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask_wl, already_deleted, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask_wl, already_deleted, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* Try to read with a deleted reader. */ dds_delete(g_reader); ret = dds_take_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_expect_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask_wl, any, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask_wl, any, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = MAX_SAMPLES; @@ -2686,7 +2646,7 @@ Test(ddsc_take_mask_wl, any, .init=reader_init, .fini=reader_fini) /* Read all samples that matches the mask. */ ret = dds_take_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -2701,7 +2661,6 @@ Test(ddsc_take_mask_wl, any, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_take_mask_wl::any: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -2710,28 +2669,28 @@ Test(ddsc_take_mask_wl, any, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask_wl, not_read_sample_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask_wl, not_read_sample_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 4; @@ -2739,7 +2698,7 @@ Test(ddsc_take_mask_wl, not_read_sample_state, .init=reader_init, .fini=reader_f /* Read all samples that matches the mask. */ ret = dds_take_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -2754,7 +2713,6 @@ Test(ddsc_take_mask_wl, not_read_sample_state, .init=reader_init, .fini=reader_f * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_take_mask_wl::not_read_sample_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = SAMPLE_LAST_READ_SST + 1 + i; @@ -2763,28 +2721,28 @@ Test(ddsc_take_mask_wl, not_read_sample_state, .init=reader_init, .fini=reader_f dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask_wl, read_sample_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask_wl, read_sample_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 3; @@ -2792,7 +2750,7 @@ Test(ddsc_take_mask_wl, read_sample_state, .init=reader_init, .fini=reader_fini) /* Read all samples that matches the mask. */ ret = dds_take_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -2807,7 +2765,6 @@ Test(ddsc_take_mask_wl, read_sample_state, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_take_mask_wl::read_sample_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -2816,28 +2773,28 @@ Test(ddsc_take_mask_wl, read_sample_state, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask_wl, new_view_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask_wl, new_view_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 3; @@ -2845,7 +2802,7 @@ Test(ddsc_take_mask_wl, new_view_state, .init=reader_init, .fini=reader_fini) /* Read all samples that matches the mask. */ ret = dds_take_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -2860,7 +2817,6 @@ Test(ddsc_take_mask_wl, new_view_state, .init=reader_init, .fini=reader_fini) * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_take_mask_wl::new_view_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = SAMPLE_LAST_OLD_VST + 1 + i; @@ -2869,28 +2825,28 @@ Test(ddsc_take_mask_wl, new_view_state, .init=reader_init, .fini=reader_fini) dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask_wl, not_new_view_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask_wl, not_new_view_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 4; @@ -2898,7 +2854,7 @@ Test(ddsc_take_mask_wl, not_new_view_state, .init=reader_init, .fini=reader_fini /* Read all samples that matches the mask. */ ret = dds_take_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -2913,7 +2869,6 @@ Test(ddsc_take_mask_wl, not_new_view_state, .init=reader_init, .fini=reader_fini * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_take_mask_wl::not_new_view_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i; @@ -2922,28 +2877,28 @@ Test(ddsc_take_mask_wl, not_new_view_state, .init=reader_init, .fini=reader_fini dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask_wl, alive_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask_wl, alive_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE; dds_return_t expected_cnt = 3; @@ -2951,7 +2906,7 @@ Test(ddsc_take_mask_wl, alive_instance_state, .init=reader_init, .fini=reader_fi /* Read all samples that matches the mask. */ ret = dds_take_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -2966,7 +2921,6 @@ Test(ddsc_take_mask_wl, alive_instance_state, .init=reader_init, .fini=reader_fi * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | <--- */ - PRINT_SAMPLE("ddsc_take_mask_wl::alive_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = i * 3; @@ -2975,28 +2929,28 @@ Test(ddsc_take_mask_wl, alive_instance_state, .init=reader_init, .fini=reader_fi dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask_wl, not_alive_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask_wl, not_alive_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE | DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE; dds_return_t expected_cnt = 4; @@ -3004,7 +2958,7 @@ Test(ddsc_take_mask_wl, not_alive_instance_state, .init=reader_init, .fini=reade /* Read all samples that matches the mask. */ ret = dds_take_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -3019,7 +2973,6 @@ Test(ddsc_take_mask_wl, not_alive_instance_state, .init=reader_init, .fini=reade * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_take_mask_wl::alive_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i <= 1) ? i + 1 : i + 2; @@ -3028,29 +2981,29 @@ Test(ddsc_take_mask_wl, not_alive_instance_state, .init=reader_init, .fini=reade dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); - cr_assert_neq(g_info[i].instance_state, DDS_IST_ALIVE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); + CU_ASSERT_NOT_EQUAL_FATAL(g_info[i].instance_state, DDS_IST_ALIVE); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask_wl, disposed_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask_wl, disposed_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE; dds_return_t expected_cnt = 2; @@ -3058,7 +3011,7 @@ Test(ddsc_take_mask_wl, disposed_instance_state, .init=reader_init, .fini=reader /* Read all samples that matches the mask. */ ret = dds_take_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -3073,7 +3026,6 @@ Test(ddsc_take_mask_wl, disposed_instance_state, .init=reader_init, .fini=reader * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_take_mask_wl::disposed_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i * 3) + 1; @@ -3082,28 +3034,28 @@ Test(ddsc_take_mask_wl, disposed_instance_state, .init=reader_init, .fini=reader dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_DISPOSED; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask_wl, no_writers_instance_state, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask_wl, no_writers_instance_state, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE; dds_return_t expected_cnt = 2; @@ -3111,7 +3063,7 @@ Test(ddsc_take_mask_wl, no_writers_instance_state, .init=reader_init, .fini=read /* Read all samples that matches the mask. */ ret = dds_take_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -3126,7 +3078,6 @@ Test(ddsc_take_mask_wl, no_writers_instance_state, .init=reader_init, .fini=read * | 5 | 2 | 1 | not_read | new | no_writers | <--- * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_take_mask_wl::no_writers_instance_state: Read", (*sample)); /* Expected states. */ int expected_long_1 = (i * 3) + 2; @@ -3135,28 +3086,28 @@ Test(ddsc_take_mask_wl, no_writers_instance_state, .init=reader_init, .fini=read dds_instance_state_t expected_ist = DDS_IST_NOT_ALIVE_NO_WRITERS; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_mask_wl, combination_of_states, .init=reader_init, .fini=reader_fini) +CU_Test(ddsc_take_mask_wl, combination_of_states, .init=reader_init, .fini=reader_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ALIVE_INSTANCE_STATE; dds_return_t expected_cnt = 1; @@ -3164,7 +3115,7 @@ Test(ddsc_take_mask_wl, combination_of_states, .init=reader_init, .fini=reader_f /* Read all samples that matches the mask. */ ret = dds_take_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -3179,7 +3130,6 @@ Test(ddsc_take_mask_wl, combination_of_states, .init=reader_init, .fini=reader_f * | 5 | 2 | 1 | not_read | new | no_writers | * | 6 | 3 | 2 | not_read | new | alive | */ - PRINT_SAMPLE("ddsc_take_mask_wl::combination_of_states: Read", (*sample)); /* Expected states. */ int expected_long_1 = 3; @@ -3188,22 +3138,22 @@ Test(ddsc_take_mask_wl, combination_of_states, .init=reader_init, .fini=reader_f dds_instance_state_t expected_ist = DDS_IST_ALIVE; /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_1/2); - cr_assert_eq(sample->long_3, expected_long_1/3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_1/2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_1/3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Only samples that weren't taken should be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/reader_iterator.c b/src/core/ddsc/tests/reader_iterator.c index d10d07b..e275d44 100644 --- a/src/core/ddsc/tests/reader_iterator.c +++ b/src/core/ddsc/tests/reader_iterator.c @@ -15,16 +15,8 @@ #include "os/os.h" #include "Space.h" #include "RoundTrip.h" -#include -#include -#include - -#if 0 -#define PRINT_SAMPLE(info, sample) cr_log_info("%s (%d, %d, %d)\n", info, sample.long_1, sample.long_2, sample.long_3); -#else -#define PRINT_SAMPLE(info, sample) -#endif - +#include "CUnit/Test.h" +#include "CUnit/Theory.h" /************************************************************************************************** * @@ -132,62 +124,62 @@ reader_iterator_init(void) dds_qos_t *qos; qos = dds_create_qos(); - cr_assert_not_null(qos, "Failed to create prerequisite qos"); + CU_ASSERT_PTR_NOT_NULL_FATAL(qos); g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0); g_subscriber = dds_create_subscriber(g_participant, NULL, NULL); - cr_assert_gt(g_subscriber, 0, "Failed to create prerequisite g_subscriber"); + CU_ASSERT_FATAL(g_subscriber > 0); g_publisher = dds_create_publisher(g_participant, NULL, NULL); - cr_assert_gt(g_publisher, 0, "Failed to create prerequisite g_publisher"); + CU_ASSERT_FATAL(g_publisher > 0); g_waitset = dds_create_waitset(g_participant); - cr_assert_gt(g_waitset, 0, "Failed to create g_waitset"); + CU_ASSERT_FATAL(g_waitset > 0); g_topic = dds_create_topic(g_participant, &Space_Type1_desc, create_topic_name("ddsc_read_iterator_test", name, sizeof name), NULL, NULL); - cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic"); + CU_ASSERT_FATAL(g_topic > 0); /* Create a writer that will not automatically dispose unregistered samples. */ dds_qset_writer_data_lifecycle(qos, false); g_writer = dds_create_writer(g_publisher, g_topic, qos, NULL); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer"); + CU_ASSERT_FATAL(g_writer > 0); /* Create a reader that keeps all samples when not taken. */ dds_qset_history(qos, DDS_HISTORY_KEEP_ALL, DDS_LENGTH_UNLIMITED); g_reader = dds_create_reader(g_subscriber, g_topic, qos, NULL); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite g_reader"); + CU_ASSERT_FATAL(g_reader > 0); /* Create a read condition that only reads old samples. */ g_rcond = dds_create_readcondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_NOT_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(g_rcond, 0, "Failed to create prerequisite g_rcond"); + CU_ASSERT_FATAL(g_rcond > 0); /* Create a query condition that only reads of instances mod2. */ g_qcond = dds_create_querycondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(g_qcond, 0, "Failed to create prerequisite g_qcond"); + CU_ASSERT_FATAL(g_qcond > 0); /* Sync g_reader to g_writer. */ ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_reader r"); - cr_assert_eq(g_reader, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_reader a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_reader, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Sync g_writer to g_reader. */ ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_writer status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_writer, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_writer r"); - cr_assert_eq(g_writer, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_writer a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_writer, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Initialize reading buffers. */ memset (g_data, 0, sizeof (g_data)); @@ -205,7 +197,7 @@ reader_iterator_init(void) sample.long_2 = i; sample.long_3 = i*2; ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /* | long_1 | long_2 | long_3 | sst | vst | ist | * ----------------------------------------------------- @@ -239,50 +231,25 @@ reader_iterator_init(void) /* Create a query condition that reads the specific sample to get a set of 'read' samples after init. */ qcond = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_init); - cr_assert_gt(g_qcond, 0, "Failed to create prerequisite qcond"); + CU_ASSERT_FATAL(g_qcond > 0); ret = dds_read(qcond, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_gt(ret, 0, "Failed prerequisite read: %d", dds_err_nr(ret)); + CU_ASSERT_FATAL(ret > 0); dds_delete(qcond); } - /* | long_1 | long_2 | long_3 | sst | vst | ist | - * ----------------------------------------------------- - * | 0 | 0 | 0 | not_read | new | alive | - * | 0 | 1 | 2 | not_read | new | alive | - * | 0 | 2 | 4 | not_read | new | alive | - * | 1 | 3 | 6 | read | old | alive | - * | 1 | 4 | 8 | read | old | alive | - * | 1 | 5 | 10 | read | old | alive | - * | 2 | 6 | 12 | not_read | old | alive | - * | 2 | 7 | 14 | not_read | old | alive | - * | 2 | 8 | 16 | read | old | alive | - * | 3 | 9 | 18 | not_read | old | alive | - * | 3 | 10 | 20 | read | old | alive | - * | 3 | 11 | 22 | not_read | old | alive | - * | 4 | 12 | 24 | read | old | alive | - * | 4 | 13 | 26 | not_read | old | alive | - * | 4 | 14 | 28 | not_read | old | alive | - * | 5 | 15 | 30 | read | old | alive | - * | 5 | 16 | 32 | not_read | old | alive | - * | 5 | 17 | 34 | read | old | alive | - * | 6 | 18 | 36 | read | old | alive | - * | 6 | 19 | 38 | not_read | old | alive | - * | 6 | 20 | 40 | read | old | alive | - */ - /* Dispose and unregister the last two samples. */ sample.long_1 = 5; sample.long_2 = 15; sample.long_3 = 30; ret = dds_dispose(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite dispose"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); sample.long_1 = 6; sample.long_2 = 16; sample.long_3 = 32; ret = dds_unregister_instance(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite unregister"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* | long_1 | long_2 | long_3 | sst | vst | ist | * ---------------------------------------------------------- * | 0 | 0 | 0 | not_read | new | alive | @@ -330,7 +297,7 @@ samples_cnt(void) { dds_return_t ret; ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_geq(ret, 0, "Failed samples count read: %d", dds_err_nr(ret)); + CU_ASSERT_FATAL(ret >= 0); return ret; } @@ -340,17 +307,16 @@ samples_cnt(void) * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_next, reader, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Test(ddsc_read_next, reader, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t cnt = 0, cntinv = 0; dds_return_t ret = 1; while (ret == 1){ ret = dds_read_next(g_reader, g_samples, g_info); - cr_assert_geq(ret, 0 , "# read %d", ret); + CU_ASSERT_FATAL(ret >= 0 ); if(ret == 1 && g_info[0].valid_data){ Space_Type1 *sample = (Space_Type1*)g_samples[0]; - PRINT_SAMPLE("ddsc_read_next::reader: Read", (*sample)); /* Expected states. */ int expected_long_2 = rdr_expected_long_2[cnt]; @@ -361,84 +327,86 @@ Test(ddsc_read_next, reader, .init=reader_iterator_init, .fini=reader_iterator_f dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1); - cr_assert_eq(sample->long_2, expected_long_2); - cr_assert_eq(sample->long_3, expected_long_3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_3); /* Check states. */ - cr_assert_eq(g_info[0].valid_data, true); - cr_assert_eq(g_info[0].sample_state, expected_sst); - cr_assert_eq(g_info[0].view_state, expected_vst); - cr_assert_eq(g_info[0].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[0].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[0].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[0].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[0].instance_state, expected_ist); cnt ++; } else if (ret == 1 && !g_info[0].valid_data) { cntinv ++; } } - cr_assert_eq(cnt, RDR_NOT_READ_CNT); - cr_assert_eq(cntinv, RDR_INV_READ_CNT); + CU_ASSERT_EQUAL_FATAL(cnt, RDR_NOT_READ_CNT); + CU_ASSERT_EQUAL_FATAL(cntinv, RDR_INV_READ_CNT); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_next, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_read_next, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_read_next, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((dds_entity_t rdr), ddsc_read_next, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_next(rdr, g_samples, g_info); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_next, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond), +CU_TheoryDataPoints(ddsc_read_next, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond), }; -Theory((dds_entity_t *rdr), ddsc_read_next, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_next, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t ret; ret = dds_read_next(*rdr, g_samples, g_info); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_next, already_deleted) = { - DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), +CU_TheoryDataPoints(ddsc_read_next, already_deleted) = { + CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), }; -Theory((dds_entity_t *rdr), ddsc_read_next, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_next, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t ret; ret = dds_delete(*rdr); - cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_read_next(*rdr, g_samples, g_info); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_next, invalid_buffers) = { - DataPoints(void**, g_samples, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), +CU_TheoryDataPoints(ddsc_read_next, invalid_buffers) = { + CU_DataPoints(void**, g_samples, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL), }; -Theory((void **buf, dds_sample_info_t *si), ddsc_read_next, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((void **buf, dds_sample_info_t *si), ddsc_read_next, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t ret; - cr_assume((buf != g_samples) || (si != g_info)); - cr_assume(buf != g_loans); - ret = dds_read_next(g_reader, buf, si); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + if ((buf != g_samples || si != g_info) && (buf != g_loans)) { + ret = dds_read_next(g_reader, buf, si); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + } else { + CU_PASS(); + } } /*************************************************************************************************/ @@ -452,17 +420,16 @@ Theory((void **buf, dds_sample_info_t *si), ddsc_read_next, invalid_buffers, .in * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_read_next_wl, reader, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Test(ddsc_read_next_wl, reader, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t cnt = 0, cntinv = 0; dds_return_t ret = 1; while (ret == 1){ ret = dds_read_next_wl(g_reader, g_loans, g_info); - cr_assert_geq(ret, 0 , "# read %d", ret); + CU_ASSERT_FATAL(ret >= 0 ); if(ret == 1 && g_info[0].valid_data){ Space_Type1 *sample = (Space_Type1*)g_loans[0]; - PRINT_SAMPLE("ddsc_read_next_wl::reader: Read", (*sample)); /* Expected states. */ int expected_long_2 = rdr_expected_long_2[cnt]; @@ -473,86 +440,89 @@ Test(ddsc_read_next_wl, reader, .init=reader_iterator_init, .fini=reader_iterato dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1); - cr_assert_eq(sample->long_2, expected_long_2); - cr_assert_eq(sample->long_3, expected_long_3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_3); /* Check states. */ - cr_assert_eq(g_info[0].valid_data, true); - cr_assert_eq(g_info[0].sample_state, expected_sst); - cr_assert_eq(g_info[0].view_state, expected_vst); - cr_assert_eq(g_info[0].instance_state, expected_ist); - cnt ++; + CU_ASSERT_EQUAL_FATAL(g_info[0].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[0].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[0].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[0].instance_state, expected_ist); + cnt++; } else if (ret == 1 && !g_info[0].valid_data) { - cntinv ++; + cntinv++; } } - cr_assert_eq(cnt, RDR_NOT_READ_CNT); - cr_assert_eq(cntinv, RDR_INV_READ_CNT); + CU_ASSERT_EQUAL_FATAL(cnt, RDR_NOT_READ_CNT); + CU_ASSERT_EQUAL_FATAL(cntinv, RDR_INV_READ_CNT); ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES, "# samples %d, expected %d", ret, MAX_SAMPLES); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_next_wl, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_read_next_wl, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_read_next_wl, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((dds_entity_t rdr), ddsc_read_next_wl, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_read_next_wl(rdr, g_loans, g_info); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_next_wl, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond), +CU_TheoryDataPoints(ddsc_read_next_wl, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond), }; -Theory((dds_entity_t *rdr), ddsc_read_next_wl, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_next_wl, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t ret; ret = dds_read_next_wl(*rdr, g_loans, g_info); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_next_wl, already_deleted) = { - DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), +CU_TheoryDataPoints(ddsc_read_next_wl, already_deleted) = { + CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), }; -Theory((dds_entity_t *rdr), ddsc_read_next_wl, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((dds_entity_t *rdr), ddsc_read_next_wl, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t ret; ret = dds_delete(*rdr); - cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_read_next_wl(*rdr, g_loans, g_info); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_read_next_wl, invalid_buffers) = { - DataPoints(void**, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), +CU_TheoryDataPoints(ddsc_read_next_wl, invalid_buffers) = { + CU_DataPoints(void**, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL), }; -Theory((void **buf, dds_sample_info_t *si), ddsc_read_next_wl, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((void **buf, dds_sample_info_t *si), ddsc_read_next_wl, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t ret; - cr_assume((buf != g_loans) || (si != g_info)); - ret = dds_read_next_wl(g_reader, buf, si); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + if (buf != g_loans || si != g_info) { + ret = dds_read_next_wl(g_reader, buf, si); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + } else { + CU_PASS(); + } } /*************************************************************************************************/ @@ -566,17 +536,16 @@ Theory((void **buf, dds_sample_info_t *si), ddsc_read_next_wl, invalid_buffers, * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_next, reader, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Test(ddsc_take_next, reader, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t cnt = 0, cntinv = 0; dds_return_t ret = 1; while (ret == 1){ ret = dds_take_next(g_reader, g_samples, g_info); - cr_assert_geq(ret, 0 , "# read %d", ret); + CU_ASSERT_FATAL(ret >= 0 ); if(ret == 1 && g_info[0].valid_data){ Space_Type1 *sample = (Space_Type1*)g_samples[0]; - PRINT_SAMPLE("ddsc_take_next::reader: Read", (*sample)); /* Expected states. */ int expected_long_2 = rdr_expected_long_2[cnt]; @@ -587,82 +556,83 @@ Test(ddsc_take_next, reader, .init=reader_iterator_init, .fini=reader_iterator_f dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1); - cr_assert_eq(sample->long_2, expected_long_2); - cr_assert_eq(sample->long_3, expected_long_3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_3); /* Check states. */ - cr_assert_eq(g_info[0].valid_data, true); - cr_assert_eq(g_info[0].sample_state, expected_sst); - cr_assert_eq(g_info[0].view_state, expected_vst); - cr_assert_eq(g_info[0].instance_state, expected_ist); - cnt ++; + CU_ASSERT_EQUAL_FATAL(g_info[0].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[0].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[0].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[0].instance_state, expected_ist); + cnt++; } else if (ret == 1 && !g_info[0].valid_data) { - cntinv ++; + cntinv++; } } - cr_assert_eq(cnt, RDR_NOT_READ_CNT); - cr_assert_eq(cntinv, RDR_INV_READ_CNT); + CU_ASSERT_EQUAL_FATAL(cnt, RDR_NOT_READ_CNT); + CU_ASSERT_EQUAL_FATAL(cntinv, RDR_INV_READ_CNT); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, (MAX_SAMPLES - RDR_NOT_READ_CNT), "# samples %d, expected %d", ret, MAX_SAMPLES); - + CU_ASSERT_EQUAL_FATAL(ret, (MAX_SAMPLES - RDR_NOT_READ_CNT)); } /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_next, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_take_next, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_take_next, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((dds_entity_t rdr), ddsc_take_next, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_next(rdr, g_samples, g_info); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_next, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond), +CU_TheoryDataPoints(ddsc_take_next, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond), }; -Theory((dds_entity_t *rdr), ddsc_take_next, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_next, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t ret; ret = dds_take_next(*rdr, g_samples, g_info); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_next, already_deleted) = { - DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), +CU_TheoryDataPoints(ddsc_take_next, already_deleted) = { + CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), }; -Theory((dds_entity_t *rdr), ddsc_take_next, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_next, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t ret; ret = dds_delete(*rdr); - cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_take_next(*rdr, g_samples, g_info); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_next, invalid_buffers) = { - DataPoints(void**, g_samples, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), +CU_TheoryDataPoints(ddsc_take_next, invalid_buffers) = { + CU_DataPoints(void**, g_samples, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL), }; -Theory((void **buf, dds_sample_info_t *si), ddsc_take_next, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((void **buf, dds_sample_info_t *si), ddsc_take_next, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t ret; - cr_assume((buf != g_samples) || (si != g_info)); - cr_assume(buf != g_loans); - ret = dds_take_next(g_reader, buf, si); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + if ((buf != g_samples || si != g_info) && (buf != g_loans)) { + ret = dds_take_next(g_reader, buf, si); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + } else { + CU_PASS(); + } } /*************************************************************************************************/ @@ -676,17 +646,16 @@ Theory((void **buf, dds_sample_info_t *si), ddsc_take_next, invalid_buffers, .in * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_next_wl, reader, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Test(ddsc_take_next_wl, reader, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t cnt = 0, cntinv = 0; dds_return_t ret = 1; while (ret == 1){ ret = dds_take_next_wl(g_reader, g_loans, g_info); - cr_assert_geq(ret, 0 , "# read %d", ret); + CU_ASSERT_FATAL(ret >= 0); if(ret == 1 && g_info[0].valid_data){ Space_Type1 *sample = (Space_Type1*)g_loans[0]; - PRINT_SAMPLE("ddsc_read_next_wl::reader: Read", (*sample)); /* Expected states. */ int expected_long_2 = rdr_expected_long_2[cnt]; @@ -697,83 +666,85 @@ Test(ddsc_take_next_wl, reader, .init=reader_iterator_init, .fini=reader_iterato dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_1); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1); - cr_assert_eq(sample->long_2, expected_long_2); - cr_assert_eq(sample->long_3, expected_long_3); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_3); /* Check states. */ - cr_assert_eq(g_info[0].valid_data, true); - cr_assert_eq(g_info[0].sample_state, expected_sst); - cr_assert_eq(g_info[0].view_state, expected_vst); - cr_assert_eq(g_info[0].instance_state, expected_ist); - cnt ++; + CU_ASSERT_EQUAL_FATAL(g_info[0].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[0].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[0].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[0].instance_state, expected_ist); + cnt++; } else if (ret == 1 && !g_info[0].valid_data) { - cntinv ++; + cntinv++; } } - cr_assert_eq(cnt, RDR_NOT_READ_CNT); - cr_assert_eq(cntinv, RDR_INV_READ_CNT); + CU_ASSERT_EQUAL_FATAL(cnt, RDR_NOT_READ_CNT); + CU_ASSERT_EQUAL_FATAL(cntinv, RDR_INV_READ_CNT); ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* All samples should still be available. */ ret = samples_cnt(); - cr_assert_eq(ret, (MAX_SAMPLES - RDR_NOT_READ_CNT), "# samples %d, expected %d", ret, MAX_SAMPLES); - + CU_ASSERT_EQUAL_FATAL(ret, (MAX_SAMPLES - RDR_NOT_READ_CNT)); } /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_next_wl, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_take_next_wl, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_take_next_wl, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((dds_entity_t rdr), ddsc_take_next_wl, invalid_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_next_wl(rdr, g_loans, g_info); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_next_wl, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond), +CU_TheoryDataPoints(ddsc_take_next_wl, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset, &g_rcond, &g_qcond), }; -Theory((dds_entity_t *rdr), ddsc_take_next_wl, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_next_wl, non_readers, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t ret; ret = dds_take_next_wl(*rdr, g_loans, g_info); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_next_wl, already_deleted) = { - DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), +CU_TheoryDataPoints(ddsc_take_next_wl, already_deleted) = { + CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), }; -Theory((dds_entity_t *rdr), ddsc_take_next_wl, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_next_wl, already_deleted, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t ret; ret = dds_delete(*rdr); - cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_take_next_wl(*rdr, g_loans, g_info); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_next_wl, invalid_buffers) = { - DataPoints(void**, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0 ), +CU_TheoryDataPoints(ddsc_take_next_wl, invalid_buffers) = { + CU_DataPoints(void**, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL), }; -Theory((void **buf, dds_sample_info_t *si), ddsc_take_next_wl, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini) +CU_Theory((void **buf, dds_sample_info_t *si), ddsc_take_next_wl, invalid_buffers, .init=reader_iterator_init, .fini=reader_iterator_fini) { dds_return_t ret; - cr_assume((buf != g_loans) || (si != g_info)); - ret = dds_take_next_wl(g_reader, buf, si); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + if (buf != g_loans || si != g_info) { + ret = dds_take_next_wl(g_reader, buf, si); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + } else { + CU_PASS(); + } } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/register.c b/src/core/ddsc/tests/register.c index 4e7d1bf..f8c9d24 100644 --- a/src/core/ddsc/tests/register.c +++ b/src/core/ddsc/tests/register.c @@ -13,9 +13,8 @@ #include "ddsc/dds.h" #include "os/os.h" -#include -#include -#include +#include "CUnit/Test.h" +#include "CUnit/Theory.h" #include "Space.h" @@ -63,46 +62,46 @@ registering_init(void) dds_qset_destination_order(qos, DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP); g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0); g_waitset = dds_create_waitset(g_participant); - cr_assert_gt(g_waitset, 0, "Failed to create g_waitset"); + CU_ASSERT_FATAL(g_waitset > 0); g_topic = dds_create_topic(g_participant, &Space_Type1_desc, create_topic_name("ddsc_registering_test", name, sizeof name), qos, NULL); - cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic"); + CU_ASSERT_FATAL(g_topic > 0); /* Create a reader that keeps one sample on three instances. */ dds_qset_reliability(qos, DDS_RELIABILITY_RELIABLE, DDS_MSECS(100)); dds_qset_resource_limits(qos, DDS_LENGTH_UNLIMITED, 3, 1); g_reader = dds_create_reader(g_participant, g_topic, qos, NULL); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite g_reader"); + CU_ASSERT_FATAL(g_reader > 0); /* Create a writer that will not automatically dispose unregistered samples. */ dds_qset_writer_data_lifecycle(qos, false); g_writer = dds_create_writer(g_participant, g_topic, qos, NULL); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer"); + CU_ASSERT_FATAL(g_writer > 0); /* Sync g_writer to g_reader. */ ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_writer status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_writer, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_writer r"); - cr_assert_eq(g_writer, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_writer a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_writer, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Sync g_reader to g_writer. */ ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_reader r"); - cr_assert_eq(g_reader, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_reader a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_reader, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Write initial samples. */ for (int i = 0; i < INITIAL_SAMPLES; i++) { @@ -110,7 +109,7 @@ registering_init(void) sample.long_2 = i*2; sample.long_3 = i*3; ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /* Initialize reading buffers. */ @@ -137,89 +136,86 @@ registering_fini(void) } -#if 0 -#else /************************************************************************************************** * * These will check the dds_register_instance() in various ways. * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_register_instance, deleted_entity, .init=registering_init, .fini=registering_fini) +CU_Test(ddsc_register_instance, deleted_entity, .init=registering_init, .fini=registering_fini) { dds_return_t ret; dds_instance_handle_t handle; dds_delete(g_writer); ret = dds_register_instance(g_writer, &handle, g_data); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } static dds_instance_handle_t hndle = 0; static Space_Type1 data; -TheoryDataPoints(ddsc_register_instance, invalid_params) = { - DataPoints(dds_instance_handle_t *, &hndle, NULL), - DataPoints(void*, &data, NULL) +CU_TheoryDataPoints(ddsc_register_instance, invalid_params) = { + CU_DataPoints(dds_instance_handle_t *, &hndle, NULL), + CU_DataPoints(void*, NULL, &data) }; -Theory((dds_instance_handle_t *hndl2, void *datap), ddsc_register_instance, invalid_params/*, .init=registering_init, .fini=registering_fini*/) +CU_Theory((dds_instance_handle_t *hndl2, void *datap), ddsc_register_instance, invalid_params, .init=registering_init, .fini=registering_fini) { dds_return_t ret; /* Only test when the combination of parameters is actually invalid.*/ - cr_assume((hndl2 == NULL) || (datap == NULL)); + CU_ASSERT_FATAL((hndl2 == NULL) || (datap == NULL)); OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_register_instance(g_writer, hndl2, datap); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d != expected %d", dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } -TheoryDataPoints(ddsc_register_instance, invalid_writers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_register_instance, invalid_writers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_register_instance, invalid_writers, .init=registering_init, .fini=registering_fini) +CU_Theory((dds_entity_t writer), ddsc_register_instance, invalid_writers, .init=registering_init, .fini=registering_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; dds_instance_handle_t handle; ret = dds_register_instance(writer, &handle, g_data); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } -TheoryDataPoints(ddsc_register_instance, non_writers) = { - DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_register_instance, non_writers) = { + CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), }; -Theory((dds_entity_t *writer), ddsc_register_instance, non_writers, .init=registering_init, .fini=registering_fini) +CU_Theory((dds_entity_t *writer), ddsc_register_instance, non_writers, .init=registering_init, .fini=registering_fini) { dds_return_t ret; dds_instance_handle_t handle; ret = dds_register_instance(*writer, &handle, g_data); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } -Test(ddsc_register_instance, registering_new_instance, .init=registering_init, .fini=registering_fini) +CU_Test(ddsc_register_instance, registering_new_instance, .init=registering_init, .fini=registering_fini) { dds_instance_handle_t instHndl, instHndl2; dds_return_t ret; Space_Type1 newInstance = { INITIAL_SAMPLES, 0, 0 }; instHndl = dds_instance_lookup(g_writer, &newInstance); - cr_assert_eq(instHndl, DDS_HANDLE_NIL); + CU_ASSERT_EQUAL_FATAL(instHndl, DDS_HANDLE_NIL); ret = dds_register_instance(g_writer, &instHndl2, &newInstance); - cr_assert_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); instHndl = dds_instance_lookup(g_writer, &newInstance); - cr_assert_eq(instHndl, instHndl2); + CU_ASSERT_EQUAL_FATAL(instHndl, instHndl2); } -Test(ddsc_register_instance, data_already_available, .init=registering_init, .fini=registering_fini) +CU_Test(ddsc_register_instance, data_already_available, .init=registering_init, .fini=registering_fini) { dds_instance_handle_t instHndl, instHndl2; dds_return_t ret; instHndl = dds_instance_lookup(g_writer, &g_data); - cr_assert_neq(instHndl, DDS_HANDLE_NIL); + CU_ASSERT_NOT_EQUAL_FATAL(instHndl, DDS_HANDLE_NIL); ret = dds_register_instance(g_writer, &instHndl2, &g_data); - cr_assert_eq(ret, DDS_RETCODE_OK); - cr_assert_eq(instHndl2, instHndl); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(instHndl2, instHndl); } -#endif diff --git a/src/core/ddsc/tests/return_loan.c b/src/core/ddsc/tests/return_loan.c index 2808c13..e031406 100644 --- a/src/core/ddsc/tests/return_loan.c +++ b/src/core/ddsc/tests/return_loan.c @@ -14,31 +14,30 @@ #include "os/os.h" #include -#include -#include +#include "CUnit/Test.h" dds_entity_t participant = 0, topic = 0, reader = 0, read_condition = 0; void create_entities(void) { participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0); + CU_ASSERT_FATAL(participant > 0); topic = dds_create_topic(participant, &RoundTripModule_DataType_desc, "ddsc_reader_return_loan_RoundTrip", NULL, NULL); - cr_assert_gt(topic, 0); + CU_ASSERT_FATAL(topic > 0); reader = dds_create_reader(participant, topic, NULL, NULL); - cr_assert_gt(reader, 0); + CU_ASSERT_FATAL(reader > 0); read_condition = dds_create_readcondition(reader, DDS_ANY_STATE); - cr_assert_gt(read_condition, 0); + CU_ASSERT_FATAL(read_condition > 0); } void delete_entities(void) { dds_return_t result; result = dds_delete(participant); - cr_assert_eq(dds_err_nr(result), DDS_RETCODE_OK, "Recursively delete entities, Expected(%s) Returned(%s)", DDS_TO_STRING(DDS_RETCODE_OK), dds_err_str(result)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(result), DDS_RETCODE_OK); dds_delete(read_condition); } @@ -69,7 +68,7 @@ static void delete_loan_buf(void **buf, size_t sz, bool empty) for (i = 0; i < sz; i++) { RoundTripModule_DataType *s = buf[i]; if (!empty) { - cr_expect_gt(s->payload._length, 0, "Expected allocated 'payload'-sequence in sample-contents of loan"); + CU_ASSERT(s->payload._length > 0); if (s->payload._length > 0) { /* Freed by a successful dds_return_loan */ dds_free(s->payload._buffer); @@ -82,15 +81,13 @@ static void delete_loan_buf(void **buf, size_t sz, bool empty) } /* Verify DDS_RETCODE_BAD_PARAMETER is returned */ -Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = delete_entities) +CU_Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = delete_entities) { dds_return_t result; void **buf = NULL; result = dds_return_loan(reader, NULL, 0); - cr_expect_eq(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER, "Invalid buffer(null), Expected(%s) Returned(%s)", - DDS_TO_STRING(DDS_RETCODE_BAD_PARAMETER), - dds_err_str(result)); + CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER); #ifdef _MSC_VER #pragma warning(push) @@ -100,9 +97,7 @@ Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = delet #ifdef _MSC_VER #pragma warning(pop) #endif - cr_expect_eq(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER, "Invalid buffer size, Expected(%s) Returned(%s)", - DDS_TO_STRING(DDS_RETCODE_BAD_PARAMETER), - dds_err_str(result)); + CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER); buf = create_loan_buf(10, false); #ifdef _MSC_VER @@ -113,20 +108,16 @@ Test(ddsc_reader, return_loan_bad_params, .init = create_entities, .fini = delet #ifdef _MSC_VER #pragma warning(pop) #endif - cr_expect_eq(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER, "Invalid entity, Expected(%s) Returned(%s)", - DDS_TO_STRING(DDS_RETCODE_BAD_PARAMETER), - dds_err_str(result)); + CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_BAD_PARAMETER); result = dds_return_loan(participant, buf, 0); - cr_expect_eq(dds_err_nr(result), DDS_RETCODE_ILLEGAL_OPERATION, "Invalid entity-kind, Expected(%s) Returned(%s)", - DDS_TO_STRING(DDS_RETCODE_ILLEGAL_OPERATION), - dds_err_str(result)); + CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_ILLEGAL_OPERATION); delete_loan_buf(buf, 10, false); } /* Verify DDS_RETCODE_OK is returned */ -Test(ddsc_reader, return_loan_success, .init = create_entities, .fini = delete_entities) +CU_Test(ddsc_reader, return_loan_success, .init = create_entities, .fini = delete_entities) { void **buf; void *buf2 = NULL; @@ -134,25 +125,17 @@ Test(ddsc_reader, return_loan_success, .init = create_entities, .fini = delete_e buf = create_loan_buf(10, false); result = dds_return_loan(reader, buf, 10); - cr_expect_eq(dds_err_nr(result), DDS_RETCODE_OK, "Return loan of size 10 via reader entity, Expected(%s) Returned(%s)", - DDS_TO_STRING(DDS_RETCODE_OK), - dds_err_str(result)); + CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK); result = dds_return_loan(reader, &buf2, 0); - cr_expect_eq(dds_err_nr(result), DDS_RETCODE_OK, "Return empty loan via reader entity, Expected(%s) Returned(%s)", - DDS_TO_STRING(DDS_RETCODE_OK), - dds_err_str(result)); + CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK); delete_loan_buf(buf, 10, true); buf = create_loan_buf(10, false); result = dds_return_loan(read_condition, buf, 10); - cr_expect_eq(dds_err_nr(result), DDS_RETCODE_OK, "Return loan of size 10 via read-condition entity, Expected(%s) Returned(%s)", - DDS_TO_STRING(DDS_RETCODE_OK), - dds_err_str(result)); + CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK); result = dds_return_loan(read_condition, &buf2, 0); - cr_expect_eq(dds_err_nr(result), DDS_RETCODE_OK, "Return empty loan via read-condition entity, Expected(%s) Returned(%s)", - DDS_TO_STRING(DDS_RETCODE_OK), - dds_err_str(result)); + CU_ASSERT_EQUAL(dds_err_nr(result), DDS_RETCODE_OK); delete_loan_buf(buf, 10, true); } diff --git a/src/core/ddsc/tests/subscriber.c b/src/core/ddsc/tests/subscriber.c index 033918f..6dd2786 100644 --- a/src/core/ddsc/tests/subscriber.c +++ b/src/core/ddsc/tests/subscriber.c @@ -12,8 +12,7 @@ #include "ddsc/dds.h" #include -#include -#include +#include "CUnit/Test.h" /* We are deliberately testing some bad arguments that SAL will complain about. * So, silence SAL regarding these issues. */ @@ -35,27 +34,27 @@ static void on_publication_matched(dds_entity_t writer, const dds_publication_ma (void)arg; } -Test(ddsc_subscriber, notify_readers) { +CU_Test(ddsc_subscriber, notify_readers) { dds_entity_t participant; dds_entity_t subscriber; dds_return_t ret; participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "Failed to create prerequisite participant"); + CU_ASSERT_FATAL(participant > 0); subscriber = dds_create_subscriber(participant, NULL, NULL); - cr_assert_gt(subscriber, 0, "Failed to create prerequisite subscriber"); + CU_ASSERT_FATAL(subscriber > 0); /* todo implement tests */ ret = dds_notify_readers(subscriber); - cr_expect_eq(dds_err_nr(ret), DDS_RETCODE_UNSUPPORTED, "Invalid return code %d", ret); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_UNSUPPORTED); dds_delete(subscriber); dds_delete(participant); } -Test(ddsc_subscriber, create) { +CU_Test(ddsc_subscriber, create) { dds_entity_t participant; dds_entity_t subscriber; @@ -63,57 +62,57 @@ Test(ddsc_subscriber, create) { dds_qos_t *sqos; participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "Failed to create prerequisite participant"); + CU_ASSERT_FATAL(participant > 0); /*** Verify participant parameter ***/ subscriber = dds_create_subscriber(0, NULL, NULL); - cr_assert_eq(dds_err_nr(subscriber), DDS_RETCODE_BAD_PARAMETER, "dds_create_subscriber: invalid participant parameter"); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), DDS_RETCODE_BAD_PARAMETER); subscriber = dds_create_subscriber(participant, NULL, NULL); - cr_assert_gt(subscriber, 0, "dds_create_subscriber: valid participant parameter"); + CU_ASSERT_FATAL(subscriber > 0); dds_delete(subscriber); /*** Verify qos parameter ***/ sqos = dds_create_qos(); /* Use defaults (no user-defined policies) */ subscriber = dds_create_subscriber(participant, sqos, NULL); - cr_assert_gt(subscriber, 0, "dds_create_subscriber: default QoS parameter"); + CU_ASSERT_FATAL(subscriber > 0); dds_delete(subscriber); dds_delete_qos(sqos); sqos = dds_create_qos(); dds_qset_destination_order(sqos, 3); /* Set invalid dest. order (ignored, not applicable for subscriber) */ subscriber = dds_create_subscriber(participant, sqos, NULL); - cr_assert_gt(subscriber, 0, "dds_create_subscriber: invalid non-applicable QoS parameter"); + CU_ASSERT_FATAL(subscriber > 0); dds_delete(subscriber); dds_delete_qos(sqos); sqos = dds_create_qos(); dds_qset_presentation(sqos, 123, 1, 1); /* Set invalid presentation policy */ subscriber = dds_create_subscriber(participant, sqos, NULL); - cr_assert_eq(dds_err_nr(subscriber), DDS_RETCODE_INCONSISTENT_POLICY, "dds_create_subscriber: invalid presentation access_scope QoS parameter"); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(subscriber), DDS_RETCODE_INCONSISTENT_POLICY); dds_delete_qos(sqos); /*** Verify listener parameter ***/ listener = dds_create_listener(NULL); /* Use defaults (all listeners unset) */ subscriber = dds_create_subscriber(participant, NULL, listener); - cr_assert_gt(subscriber, 0, "dds_create_subscriber: unset listeners"); + CU_ASSERT_FATAL(subscriber > 0); dds_delete(subscriber); dds_delete_listener(listener); listener = dds_create_listener(NULL); dds_lset_data_available(listener, &on_data_available); /* Set on_data_available listener */ subscriber = dds_create_subscriber(participant, NULL, listener); - cr_assert_gt(subscriber, 0, "dds_create_subscriber: on_data_available listener"); + CU_ASSERT_FATAL(subscriber > 0); dds_delete(subscriber); dds_delete_listener(listener); listener = dds_create_listener(NULL); dds_lset_publication_matched(listener, &on_publication_matched); /* Set on_publication_matched listener (ignored, not applicable for subscriber) */ subscriber = dds_create_subscriber(participant, NULL, listener); - cr_assert_gt(subscriber, 0, "dds_create_subscriber: on_publication_matched listener"); + CU_ASSERT_FATAL(subscriber > 0); dds_delete(subscriber); dds_delete_listener(listener); diff --git a/src/core/ddsc/tests/take_instance.c b/src/core/ddsc/tests/take_instance.c index 6328d75..a943602 100644 --- a/src/core/ddsc/tests/take_instance.c +++ b/src/core/ddsc/tests/take_instance.c @@ -15,18 +15,8 @@ #include "os/os.h" #include "Space.h" #include "RoundTrip.h" -#include -#include -#include - - -#if 0 -#define PRINT_SAMPLE(info, sample) cr_log_info("%s (%d, %d, %d)\n", info, sample.long_1, sample.long_2, sample.long_3); -#else -#define PRINT_SAMPLE(info, sample) -#endif - - +#include "CUnit/Test.h" +#include "CUnit/Theory.h" /************************************************************************************************** * @@ -95,62 +85,62 @@ take_instance_init(void) dds_qos_t *qos; qos = dds_create_qos(); - cr_assert_not_null(qos, "Failed to create prerequisite qos"); + CU_ASSERT_PTR_NOT_NULL_FATAL(qos); g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0); g_subscriber = dds_create_subscriber(g_participant, NULL, NULL); - cr_assert_gt(g_subscriber, 0, "Failed to create prerequisite g_subscriber"); + CU_ASSERT_FATAL(g_subscriber > 0); g_publisher = dds_create_publisher(g_participant, NULL, NULL); - cr_assert_gt(g_publisher, 0, "Failed to create prerequisite g_publisher"); + CU_ASSERT_FATAL(g_publisher > 0); g_waitset = dds_create_waitset(g_participant); - cr_assert_gt(g_waitset, 0, "Failed to create g_waitset"); + CU_ASSERT_FATAL(g_waitset > 0); g_topic = dds_create_topic(g_participant, &Space_Type1_desc, create_topic_name("ddsc_take_instance_test", name, sizeof name), NULL, NULL); - cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic"); + CU_ASSERT_FATAL(g_topic > 0); /* Create a writer that will not automatically dispose unregistered samples. */ dds_qset_writer_data_lifecycle(qos, false); g_writer = dds_create_writer(g_publisher, g_topic, qos, NULL); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer"); + CU_ASSERT_FATAL(g_writer > 0); /* Create a reader that keeps all samples when not taken. */ dds_qset_history(qos, DDS_HISTORY_KEEP_ALL, DDS_LENGTH_UNLIMITED); g_reader = dds_create_reader(g_subscriber, g_topic, qos, NULL); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite g_reader"); + CU_ASSERT_FATAL(g_reader > 0); /* Create a read condition that only reads not_read samples. */ g_rcond = dds_create_readcondition(g_reader, DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE); - cr_assert_gt(g_rcond, 0, "Failed to create prerequisite g_rcond"); + CU_ASSERT_FATAL(g_rcond > 0); /* Create a query condition that only reads not_read samples of instances mod2. */ g_qcond = dds_create_querycondition(g_reader, DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE, filter_mod2); - cr_assert_gt(g_qcond, 0, "Failed to create prerequisite g_qcond"); + CU_ASSERT_FATAL(g_qcond > 0); /* Sync g_reader to g_writer. */ ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_reader r"); - cr_assert_eq(g_reader, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_reader a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_reader, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Sync g_writer to g_reader. */ ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_writer status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_writer, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_writer r"); - cr_assert_eq(g_writer, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_writer a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_writer, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Initialize reading buffers. */ memset (g_data, 0, sizeof (g_data)); @@ -165,9 +155,8 @@ take_instance_init(void) sample.long_1 = 0; sample.long_2 = 0; sample.long_3 = 0; - PRINT_SAMPLE("INIT: Write ", sample); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* | long_1 | long_2 | long_3 | sst | vst | ist | * ---------------------------------------------------------- * | 0 | 0 | 0 | not_read | new | alive | @@ -175,10 +164,9 @@ take_instance_init(void) /* Read sample that will become {sst(read), vst(old), ist(alive)}. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 1, "Failed prerequisite read"); + CU_ASSERT_EQUAL_FATAL(ret, 1); for(int i = 0; i < ret; i++) { Space_Type1 *s = (Space_Type1*)g_samples[i]; - PRINT_SAMPLE("INIT: Read ", (*s)); (void)s; } /* | long_1 | long_2 | long_3 | sst | vst | ist | @@ -190,9 +178,8 @@ take_instance_init(void) sample.long_1 = 0; sample.long_2 = 1; sample.long_3 = 2; - PRINT_SAMPLE("INIT: Write ", sample); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* | long_1 | long_2 | long_3 | sst | vst | ist | * ---------------------------------------------------------- * | 0 | 0 | 0 | read | old | alive | @@ -204,9 +191,8 @@ take_instance_init(void) sample.long_1 = i - 1; sample.long_2 = i; sample.long_3 = i*2; - PRINT_SAMPLE("INIT: Write ", sample); ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /* | long_1 | long_2 | long_3 | sst | vst | ist | * ---------------------------------------------------------- @@ -221,9 +207,8 @@ take_instance_init(void) sample.long_1 = 2; sample.long_2 = 3; sample.long_3 = 6; - PRINT_SAMPLE("INIT: Dispose ", sample); ret = dds_dispose(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite dispose"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* | long_1 | long_2 | long_3 | sst | vst | ist | * ---------------------------------------------------------- * | 0 | 0 | 0 | read | old | alive | @@ -237,9 +222,8 @@ take_instance_init(void) sample.long_1 = 3; sample.long_2 = 4; sample.long_3 = 8; - PRINT_SAMPLE("INIT: Unregister", sample); ret = dds_unregister_instance(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite unregister"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* | long_1 | long_2 | long_3 | sst | vst | ist | * ---------------------------------------------------------- * | 0 | 0 | 0 | read | old | alive | @@ -254,7 +238,7 @@ take_instance_init(void) sample.long_2 = 0; sample.long_3 = 0; g_hdl_valid = dds_instance_lookup(g_reader, &sample); - cr_assert_neq(g_hdl_valid, DDS_HANDLE_NIL, "Failed prerequisite dds_instance_lookup"); + CU_ASSERT_NOT_EQUAL_FATAL(g_hdl_valid, DDS_HANDLE_NIL); dds_delete_qos(qos); } @@ -278,7 +262,7 @@ samples_cnt(void) { dds_return_t ret; ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_geq(ret, 0, "Failed samples count read: %d", dds_err_nr(ret)); + CU_ASSERT_FATAL(ret >= 0); return ret; } @@ -292,92 +276,98 @@ samples_cnt(void) * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance, invalid_params) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(void**, g_samples, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0), - DataPoints(size_t, 0, 2, MAX_SAMPLES), - DataPoints(uint32_t, 0, 2, MAX_SAMPLES), +CU_TheoryDataPoints(ddsc_take_instance, invalid_params) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(void**, g_samples, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL), + CU_DataPoints(size_t, 0, 2, MAX_SAMPLES), + CU_DataPoints(uint32_t, 0, 2, MAX_SAMPLES), }; -Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_take_instance, invalid_params, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_take_instance, invalid_params, .init=take_instance_init, .fini=take_instance_fini) { dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid and neither is the handle. So, don't test that. */ - cr_assume((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); + CU_ASSERT_FATAL((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); /* TODO: CHAM-306, currently, a buffer is automatically 'promoted' to a loan when a buffer is * provided with NULL pointers. So, in fact, there's currently no real difference between calling * dds_take() dds_take_wl() (except for the provided bufsz). This will change, which means that * the given buffer should contain valid pointers, which again means that 'loan intended' buffer * should result in bad_parameter. * However, that's not the case yet. So don't test it. */ - cr_assume(buf != g_loans); - ret = dds_take_instance(*ent, buf, si, bufsz, maxs, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + if (buf != g_loans) { + ret = dds_take_instance(*ent, buf, si, bufsz, maxs, g_hdl_valid); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + } else { + CU_PASS(); + } } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_wl, invalid_params) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(void**, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0), - DataPoints(size_t, 0, 2, MAX_SAMPLES), +CU_TheoryDataPoints(ddsc_take_instance_wl, invalid_params) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(void**, g_loans, (void**)0, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL), + CU_DataPoints(uint32_t, 0, 2, MAX_SAMPLES), }; -Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_take_instance_wl, invalid_params, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_take_instance_wl, invalid_params, .init=take_instance_init, .fini=take_instance_fini) { dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid and neither is the handle. So, don't test that. */ - cr_assume((buf != g_loans) || (si != g_info) || (maxs == 0)); + CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); ret = dds_take_instance_wl(*ent, buf, si, maxs, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_mask, invalid_params) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(void**, g_samples, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0), - DataPoints(size_t, 0, 2, MAX_SAMPLES), - DataPoints(uint32_t, 0, 2, MAX_SAMPLES), +CU_TheoryDataPoints(ddsc_take_instance_mask, invalid_params) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(void**, g_samples, g_loans, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL), + CU_DataPoints(size_t, 0, 2, MAX_SAMPLES), + CU_DataPoints(uint32_t, 0, 2, MAX_SAMPLES), }; -Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_take_instance_mask, invalid_params, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, size_t bufsz, uint32_t maxs), ddsc_take_instance_mask, invalid_params, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid and neither is the handle. So, don't test that. */ - cr_assume((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); + CU_ASSERT_FATAL((buf != g_samples) || (si != g_info) || (bufsz == 0) || (maxs == 0) || (bufsz < maxs)); /* TODO: CHAM-306, currently, a buffer is automatically 'promoted' to a loan when a buffer is * provided with NULL pointers. So, in fact, there's currently no real difference between calling * dds_take() dds_take_wl() (except for the provided bufsz). This will change, which means that * the given buffer should contain valid pointers, which again means that 'loan intended' buffer * should result in bad_parameter. * However, that's not the case yet. So don't test it. */ - cr_assume(buf != g_loans); - ret = dds_take_instance_mask(*ent, buf, si, bufsz, maxs, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + if (buf != g_loans) { + ret = dds_take_instance_mask(*ent, buf, si, bufsz, maxs, g_hdl_valid, mask); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + } else { + CU_PASS(); + } } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_mask_wl, invalid_params) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(void**, g_loans, (void**)0), - DataPoints(dds_sample_info_t*, g_info, (dds_sample_info_t*)0), - DataPoints(size_t, 0, 2, MAX_SAMPLES), +CU_TheoryDataPoints(ddsc_take_instance_mask_wl, invalid_params) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(void**, g_loans, (void**)0, (void**)0), + CU_DataPoints(dds_sample_info_t*, g_info, NULL, NULL), + CU_DataPoints(uint32_t, 0, 2, MAX_SAMPLES), }; -Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_take_instance_mask_wl, invalid_params, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs), ddsc_take_instance_mask_wl, invalid_params, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; /* The only valid permutation is when non of the buffer values are * invalid and neither is the handle. So, don't test that. */ - cr_assume((buf != g_loans) || (si != g_info) || (maxs == 0)); + CU_ASSERT_FATAL((buf != g_loans) || (si != g_info) || (maxs == 0)); ret = dds_take_instance_mask_wl(*ent, buf, si, maxs, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -391,56 +381,56 @@ Theory((dds_entity_t *ent, void **buf, dds_sample_info_t *si, uint32_t maxs), dd * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance, invalid_handles) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(dds_instance_handle_t, 1, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), +CU_TheoryDataPoints(ddsc_take_instance, invalid_handles) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(dds_instance_handle_t, 1, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), }; -Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance, invalid_handles, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance, invalid_handles, .init=take_instance_init, .fini=take_instance_fini) { dds_return_t ret; ret = dds_take_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_wl, invalid_handles) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), +CU_TheoryDataPoints(ddsc_take_instance_wl, invalid_handles) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), }; -Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance_wl, invalid_handles, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance_wl, invalid_handles, .init=take_instance_init, .fini=take_instance_fini) { dds_return_t ret; ret = dds_take_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_mask, invalid_handles) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), +CU_TheoryDataPoints(ddsc_take_instance_mask, invalid_handles) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), }; -Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance_mask, invalid_handles, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance_mask, invalid_handles, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_take_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, hdl, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_mask_wl, invalid_handles) = { - DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), - DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), +CU_TheoryDataPoints(ddsc_take_instance_mask_wl, invalid_handles) = { + CU_DataPoints(dds_entity_t*, &g_reader, &g_rcond, &g_qcond), + CU_DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), }; -Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance_mask_wl, invalid_handles, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance_mask_wl, invalid_handles, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_take_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, hdl, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -454,60 +444,60 @@ Theory((dds_entity_t *rdr, dds_instance_handle_t hdl), ddsc_take_instance_mask_w * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_take_instance, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_take_instance, invalid_readers, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t rdr), ddsc_take_instance, invalid_readers, .init=take_instance_init, .fini=take_instance_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_instance(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_wl, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_take_instance_wl, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_take_instance_wl, invalid_readers, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t rdr), ddsc_take_instance_wl, invalid_readers, .init=take_instance_init, .fini=take_instance_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_instance_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_mask, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_take_instance_mask, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_take_instance_mask, invalid_readers, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t rdr), ddsc_take_instance_mask, invalid_readers, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_instance_mask(rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_mask_wl, invalid_readers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_take_instance_mask_wl, invalid_readers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t rdr), ddsc_take_instance_mask_wl, invalid_readers, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t rdr), ddsc_take_instance_mask_wl, invalid_readers, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_take_instance_mask_wl(rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ @@ -522,52 +512,52 @@ Theory((dds_entity_t rdr), ddsc_take_instance_mask_wl, invalid_readers, .init=ta * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), +CU_TheoryDataPoints(ddsc_take_instance, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_take_instance, non_readers, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_instance, non_readers, .init=take_instance_init, .fini=take_instance_fini) { dds_return_t ret; ret = dds_take_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_wl, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), +CU_TheoryDataPoints(ddsc_take_instance_wl, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_take_instance_wl, non_readers, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_instance_wl, non_readers, .init=take_instance_init, .fini=take_instance_fini) { dds_return_t ret; ret = dds_take_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_mask, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), +CU_TheoryDataPoints(ddsc_take_instance_mask, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_take_instance_mask, non_readers, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_instance_mask, non_readers, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_take_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_mask_wl, non_readers) = { - DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), +CU_TheoryDataPoints(ddsc_take_instance_mask_wl, non_readers) = { + CU_DataPoints(dds_entity_t*, &g_participant, &g_topic, &g_writer, &g_subscriber, &g_publisher, &g_waitset), }; -Theory((dds_entity_t *rdr), ddsc_take_instance_mask_wl, non_readers, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_instance_mask_wl, non_readers, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_take_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -582,60 +572,60 @@ Theory((dds_entity_t *rdr), ddsc_take_instance_mask_wl, non_readers, .init=take_ * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance, already_deleted) = { - DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), +CU_TheoryDataPoints(ddsc_take_instance, already_deleted) = { + CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), }; -Theory((dds_entity_t *rdr), ddsc_take_instance, already_deleted, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_instance, already_deleted, .init=take_instance_init, .fini=take_instance_fini) { dds_return_t ret; ret = dds_delete(*rdr); - cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_take_instance(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_wl, already_deleted) = { - DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), +CU_TheoryDataPoints(ddsc_take_instance_wl, already_deleted) = { + CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), }; -Theory((dds_entity_t *rdr), ddsc_take_instance_wl, already_deleted, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_instance_wl, already_deleted, .init=take_instance_init, .fini=take_instance_fini) { dds_return_t ret; ret = dds_delete(*rdr); - cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_take_instance_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_mask, already_deleted) = { - DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), +CU_TheoryDataPoints(ddsc_take_instance_mask, already_deleted) = { + CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), }; -Theory((dds_entity_t *rdr), ddsc_take_instance_mask, already_deleted, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_instance_mask, already_deleted, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_delete(*rdr); - cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_take_instance_mask(*rdr, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_take_instance_mask_wl, already_deleted) = { - DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), +CU_TheoryDataPoints(ddsc_take_instance_mask_wl, already_deleted) = { + CU_DataPoints(dds_entity_t*, &g_rcond, &g_qcond, &g_reader), }; -Theory((dds_entity_t *rdr), ddsc_take_instance_mask_wl, already_deleted, .init=take_instance_init, .fini=take_instance_fini) +CU_Theory((dds_entity_t *rdr), ddsc_take_instance_mask_wl, already_deleted, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_ANY_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t ret; ret = dds_delete(*rdr); - cr_assert_eq(ret, DDS_RETCODE_OK, "prerequisite delete failed: %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_take_instance_mask_wl(*rdr, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ @@ -650,13 +640,13 @@ Theory((dds_entity_t *rdr), ddsc_take_instance_mask_wl, already_deleted, .init=t * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_instance, reader, .init=take_instance_init, .fini=take_instance_fini) +CU_Test(ddsc_take_instance, reader, .init=take_instance_init, .fini=take_instance_fini) { dds_return_t expected_cnt = 2; dds_return_t ret; ret = dds_take_instance(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -669,7 +659,6 @@ Test(ddsc_take_instance, reader, .init=take_instance_init, .fini=take_instance_f * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_take_instance::reader: Take", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -679,31 +668,31 @@ Test(ddsc_take_instance, reader, .init=take_instance_init, .fini=take_instance_f dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Taken samples should be gone. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_instance_wl, reader, .init=take_instance_init, .fini=take_instance_fini) +CU_Test(ddsc_take_instance_wl, reader, .init=take_instance_init, .fini=take_instance_fini) { dds_return_t expected_cnt = 2; dds_return_t ret; ret = dds_take_instance_wl(g_reader, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -716,7 +705,6 @@ Test(ddsc_take_instance_wl, reader, .init=take_instance_init, .fini=take_instanc * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_take_instance_wl::reader: Take", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -726,35 +714,35 @@ Test(ddsc_take_instance_wl, reader, .init=take_instance_init, .fini=take_instanc dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Taken samples should be gone. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_instance_mask, reader, .init=take_instance_init, .fini=take_instance_fini) +CU_Test(ddsc_take_instance_mask, reader, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_take_instance_mask(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -767,7 +755,6 @@ Test(ddsc_take_instance_mask, reader, .init=take_instance_init, .fini=take_insta * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_take_instance_mask::reader: Take", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -777,32 +764,32 @@ Test(ddsc_take_instance_mask, reader, .init=take_instance_init, .fini=take_insta dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Taken samples should be gone. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_instance_mask_wl, reader, .init=take_instance_init, .fini=take_instance_fini) +CU_Test(ddsc_take_instance_mask_wl, reader, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_take_instance_mask_wl(g_reader, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -815,7 +802,6 @@ Test(ddsc_take_instance_mask_wl, reader, .init=take_instance_init, .fini=take_in * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_take_instance_mask_wl::reader: Take", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -825,23 +811,23 @@ Test(ddsc_take_instance_mask_wl, reader, .init=take_instance_init, .fini=take_in dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Taken samples should be gone. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ @@ -856,13 +842,13 @@ Test(ddsc_take_instance_mask_wl, reader, .init=take_instance_init, .fini=take_in * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_instance, readcondition, .init=take_instance_init, .fini=take_instance_fini) +CU_Test(ddsc_take_instance, readcondition, .init=take_instance_init, .fini=take_instance_fini) { dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_take_instance(g_rcond, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -875,7 +861,6 @@ Test(ddsc_take_instance, readcondition, .init=take_instance_init, .fini=take_ins * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_take_instance::readcondition: Take", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -885,31 +870,31 @@ Test(ddsc_take_instance, readcondition, .init=take_instance_init, .fini=take_ins dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Taken samples should be gone. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_instance_wl, readcondition, .init=take_instance_init, .fini=take_instance_fini) +CU_Test(ddsc_take_instance_wl, readcondition, .init=take_instance_init, .fini=take_instance_fini) { dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_take_instance_wl(g_rcond, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -922,7 +907,6 @@ Test(ddsc_take_instance_wl, readcondition, .init=take_instance_init, .fini=take_ * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_take_instance_wl::readcondition: Take", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -932,35 +916,35 @@ Test(ddsc_take_instance_wl, readcondition, .init=take_instance_init, .fini=take_ dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Taken samples should be gone. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_instance_mask, readcondition, .init=take_instance_init, .fini=take_instance_fini) +CU_Test(ddsc_take_instance_mask, readcondition, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 2; dds_return_t ret; ret = dds_take_instance_mask(g_rcond, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -973,7 +957,6 @@ Test(ddsc_take_instance_mask, readcondition, .init=take_instance_init, .fini=tak * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_take_instance_mask::readcondition: Take", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -983,32 +966,32 @@ Test(ddsc_take_instance_mask, readcondition, .init=take_instance_init, .fini=tak dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Taken samples should be gone. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_instance_mask_wl, readcondition, .init=take_instance_init, .fini=take_instance_fini) +CU_Test(ddsc_take_instance_mask_wl, readcondition, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_NEW_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_take_instance_mask_wl(g_rcond, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1021,7 +1004,6 @@ Test(ddsc_take_instance_mask_wl, readcondition, .init=take_instance_init, .fini= * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_take_instance_mask_wl::readcondition: Take", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -1031,23 +1013,23 @@ Test(ddsc_take_instance_mask_wl, readcondition, .init=take_instance_init, .fini= dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Taken samples should be gone. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ @@ -1062,13 +1044,13 @@ Test(ddsc_take_instance_mask_wl, readcondition, .init=take_instance_init, .fini= * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_instance, querycondition, .init=take_instance_init, .fini=take_instance_fini) +CU_Test(ddsc_take_instance, querycondition, .init=take_instance_init, .fini=take_instance_fini) { dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_take_instance(g_qcond, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1081,7 +1063,6 @@ Test(ddsc_take_instance, querycondition, .init=take_instance_init, .fini=take_in * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_take_instance::querycondition: Take", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -1091,31 +1072,31 @@ Test(ddsc_take_instance, querycondition, .init=take_instance_init, .fini=take_in dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Taken samples should be gone. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_instance_wl, querycondition, .init=take_instance_init, .fini=take_instance_fini) +CU_Test(ddsc_take_instance_wl, querycondition, .init=take_instance_init, .fini=take_instance_fini) { dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_take_instance_wl(g_qcond, g_loans, g_info, MAX_SAMPLES, g_hdl_valid); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1128,7 +1109,6 @@ Test(ddsc_take_instance_wl, querycondition, .init=take_instance_init, .fini=take * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_take_instance_wl::querycondition: Take", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -1138,35 +1118,35 @@ Test(ddsc_take_instance_wl, querycondition, .init=take_instance_init, .fini=take dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Taken samples should be gone. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_instance_mask, querycondition, .init=take_instance_init, .fini=take_instance_fini) +CU_Test(ddsc_take_instance_mask, querycondition, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_take_instance_mask(g_qcond, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; @@ -1179,7 +1159,6 @@ Test(ddsc_take_instance_mask, querycondition, .init=take_instance_init, .fini=ta * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_take_instance_mask::querycondition: Take", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -1189,32 +1168,32 @@ Test(ddsc_take_instance_mask, querycondition, .init=take_instance_init, .fini=ta dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } /* Taken samples should be gone. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_take_instance_mask_wl, querycondition, .init=take_instance_init, .fini=take_instance_fini) +CU_Test(ddsc_take_instance_mask_wl, querycondition, .init=take_instance_init, .fini=take_instance_fini) { uint32_t mask = DDS_NOT_READ_SAMPLE_STATE | DDS_ANY_VIEW_STATE | DDS_ANY_INSTANCE_STATE; dds_return_t expected_cnt = 1; dds_return_t ret; ret = dds_take_instance_mask_wl(g_qcond, g_loans, g_info, MAX_SAMPLES, g_hdl_valid, mask); - cr_assert_eq(ret, expected_cnt, "# read %d, expected %d", ret, expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, expected_cnt); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_loans[i]; @@ -1227,7 +1206,6 @@ Test(ddsc_take_instance_mask_wl, querycondition, .init=take_instance_init, .fini * | 2 | 3 | 6 | not_read | new | disposed | * | 3 | 4 | 8 | not_read | new | no_writers | */ - PRINT_SAMPLE("ddsc_take_instance_mask_wl::querycondition: Take", (*sample)); /* Expected states. */ int expected_long_1 = 0; @@ -1237,22 +1215,22 @@ Test(ddsc_take_instance_mask_wl, querycondition, .init=take_instance_init, .fini dds_instance_state_t expected_ist = SAMPLE_IST(expected_long_2); /* Check data. */ - cr_assert_eq(sample->long_1, expected_long_1 ); - cr_assert_eq(sample->long_2, expected_long_2 ); - cr_assert_eq(sample->long_3, expected_long_2*2); + CU_ASSERT_EQUAL_FATAL(sample->long_1, expected_long_1 ); + CU_ASSERT_EQUAL_FATAL(sample->long_2, expected_long_2 ); + CU_ASSERT_EQUAL_FATAL(sample->long_3, expected_long_2*2); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, expected_sst); - cr_assert_eq(g_info[i].view_state, expected_vst); - cr_assert_eq(g_info[i].instance_state, expected_ist); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, expected_sst); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, expected_vst); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, expected_ist); } ret = dds_return_loan(g_reader, g_loans, ret); - cr_assert_eq (ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL (ret, DDS_RETCODE_OK); /* Taken samples should be gone. */ ret = samples_cnt(); - cr_assert_eq(ret, MAX_SAMPLES - expected_cnt, "# samples %d, expected %d", ret, MAX_SAMPLES - expected_cnt); + CU_ASSERT_EQUAL_FATAL(ret, MAX_SAMPLES - expected_cnt); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/time.c b/src/core/ddsc/tests/time.c index 5aceb37..d7c6dba 100644 --- a/src/core/ddsc/tests/time.c +++ b/src/core/ddsc/tests/time.c @@ -1,17 +1,26 @@ -#include -#include - +/* + * 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/Test.h" #include "ddsc/dds.h" -Test(ddsc_time, request_time) +CU_Test(ddsc_time, request_time) { dds_time_t now, then; dds_duration_t pause = 1 * DDS_NSECS_IN_SEC; now = dds_time(); - cr_assert_gt(now, 0); + CU_ASSERT_FATAL(now > 0); /* Sleep for 1 second, every platform should (hopefully) support that */ dds_sleepfor(pause); then = dds_time(); - cr_assert_geq(then, now + pause); + CU_ASSERT_FATAL(then >= (now + pause)); } diff --git a/src/core/ddsc/tests/topic.c b/src/core/ddsc/tests/topic.c index aa7bd53..57ee13e 100644 --- a/src/core/ddsc/tests/topic.c +++ b/src/core/ddsc/tests/topic.c @@ -12,9 +12,8 @@ #include "ddsc/dds.h" #include "os/os.h" #include "RoundTrip.h" -#include -#include -#include +#include "CUnit/Test.h" +#include "CUnit/Theory.h" /************************************************************************************************** * @@ -52,13 +51,13 @@ ddsc_topic_init(void) create_topic_name("ddsc_topic_test_rtm_datatype", g_topicRtmDataTypeName, MAX_NAME_SIZE); g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0); - g_topicRtmAddress = dds_create_topic(g_participant, &RoundTripModule_Address_desc, g_topicRtmAddressName, NULL, NULL); - cr_assert_gt(g_topicRtmAddress, 0, "Failed to create prerequisite g_topicRtmAddress"); + g_topicRtmAddress = dds_create_topic(g_participant, &RoundTripModule_Address_desc, g_topicRtmAddressName, NULL, NULL); + CU_ASSERT_FATAL(g_topicRtmAddress > 0); g_topicRtmDataType = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, g_topicRtmDataTypeName, NULL, NULL); - cr_assert_gt(g_topicRtmDataType, 0, "Failed to create prerequisite g_topicRtmDataType"); + CU_ASSERT_FATAL(g_topicRtmDataType > 0); g_qos = dds_create_qos(); g_listener = dds_create_listener(NULL); @@ -82,24 +81,24 @@ ddsc_topic_fini(void) * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_topic_create, valid) = { - DataPoints(char *, "valid", "_VALID", "Val1d", "valid_", "vA_1d"), - DataPoints(dds_qos_t**, &g_qos_null, &g_qos ), - DataPoints(dds_listener_t**, &g_list_null, &g_listener ), +CU_TheoryDataPoints(ddsc_topic_create, valid) = { + CU_DataPoints(char *, "valid", "_VALID", "Val1d", "valid_", "vA_1d"), + CU_DataPoints(dds_qos_t**, &g_qos_null, &g_qos, &g_qos_null, &g_qos_null, &g_qos_null), + CU_DataPoints(dds_listener_t**, &g_list_null, &g_listener, &g_list_null, &g_list_null, &g_list_null), }; -Theory((char *name, dds_qos_t **qos, dds_listener_t **listener), ddsc_topic_create, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Theory((char *name, dds_qos_t **qos, dds_listener_t **listener), ddsc_topic_create, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_entity_t topic; dds_return_t ret; topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, name, *qos, *listener); - cr_assert_gt(topic, 0, "Failed dds_create_topic(par, desc, %s, %p, %p): %s", name, *qos, *listener, dds_err_str(topic)); + CU_ASSERT_FATAL(topic > 0); ret = dds_delete(topic); - cr_assert_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_create, invalid_qos, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_create, invalid_qos, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_entity_t topic; dds_qos_t *qos = dds_create_qos(); @@ -107,82 +106,82 @@ Test(ddsc_topic_create, invalid_qos, .init=ddsc_topic_init, .fini=ddsc_topic_fin dds_qset_lifespan(qos, DDS_SECS(-1)); OS_WARNING_MSVC_OFF(28020); topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, "inconsistent", qos, NULL); - cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_INCONSISTENT_POLICY, "returned %s", dds_err_str(topic)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_INCONSISTENT_POLICY); dds_delete_qos(qos); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_create, non_participants, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_create, non_participants, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_entity_t topic; topic = dds_create_topic(g_topicRtmDataType, &RoundTripModule_DataType_desc, "non_participant", NULL, NULL); - cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION, "returned %s", dds_err_str(topic)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_create, duplicate, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_create, duplicate, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_entity_t topic; dds_return_t ret; /* Creating the same topic should succeed. */ topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, g_topicRtmDataTypeName, NULL, NULL); - cr_assert_gt(topic, 0, "returned %s", dds_err_str(topic)); + CU_ASSERT_FATAL(topic > 0); ret = dds_delete(topic); - cr_assert_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_create, same_name, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_create, same_name, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_entity_t topic; /* Creating the different topic with same name should fail. */ topic = dds_create_topic(g_participant, &RoundTripModule_Address_desc, g_topicRtmDataTypeName, NULL, NULL); - cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %s", dds_err_str(topic)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_create, recreate, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_create, recreate, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_entity_t topic; dds_return_t ret; /* Re-creating previously created topic should succeed. */ ret = dds_delete(g_topicRtmDataType); - cr_assert_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); topic = dds_create_topic (g_participant, &RoundTripModule_DataType_desc, g_topicRtmDataTypeName, NULL, NULL); - cr_assert_gt(topic, 0, "returned %s", dds_err_str(topic)); + CU_ASSERT_FATAL(topic > 0); ret = dds_delete(topic); - cr_assert_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_create, desc_null, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_create, desc_null, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_entity_t topic; OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ topic = dds_create_topic (g_participant, NULL, "desc_null", NULL, NULL); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER, "returned %s", dds_err_str(topic)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_topic_create, invalid_names) = { - DataPoints(char *, NULL, "", "mi-dle", "-start", "end-", "1st", "Thus$", "pl+s", "t(4)"), +CU_TheoryDataPoints(ddsc_topic_create, invalid_names) = { + CU_DataPoints(char *, NULL, "", "mi-dle", "-start", "end-", "1st", "Thus$", "pl+s", "t(4)"), }; -Theory((char *name), ddsc_topic_create, invalid_names, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Theory((char *name), ddsc_topic_create, invalid_names, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_entity_t topic; topic = dds_create_topic(g_participant, &RoundTripModule_DataType_desc, name, NULL, NULL); - cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER, "dds_create_topic(%s) returned %s", name, dds_err_str(topic)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ @@ -194,55 +193,55 @@ Theory((char *name), ddsc_topic_create, invalid_names, .init=ddsc_topic_init, .f * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_find, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_find, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_entity_t topic; dds_return_t ret; topic = dds_find_topic(g_participant, g_topicRtmDataTypeName); - cr_assert_eq(topic, g_topicRtmDataType, "returned %s", dds_err_str(topic)); + CU_ASSERT_EQUAL_FATAL(topic, g_topicRtmDataType); ret = dds_delete(topic); - cr_assert_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_find, non_participants, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_find, non_participants, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_entity_t topic; topic = dds_find_topic(g_topicRtmDataType, "non_participant"); - cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION, "returned %s", dds_err_str(topic)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_find, null, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_find, null, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_entity_t topic; OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ topic = dds_find_topic(g_participant, NULL); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER, "returned %s", dds_err_str(topic)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_find, unknown, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_find, unknown, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_entity_t topic; topic = dds_find_topic(g_participant, "unknown"); - cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %s", dds_err_str(topic)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_find, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_find, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_entity_t topic; dds_delete(g_topicRtmDataType); topic = dds_find_topic(g_participant, g_topicRtmDataTypeName); - cr_assert_eq(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %s", dds_err_str(topic)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(topic), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -254,66 +253,66 @@ Test(ddsc_topic_find, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini) * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_get_name, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_get_name, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { char name[MAX_NAME_SIZE]; dds_return_t ret; ret = dds_get_name(g_topicRtmDataType, name, MAX_NAME_SIZE); - cr_assert_eq(ret, DDS_RETCODE_OK); - cr_assert_str_eq(name, g_topicRtmDataTypeName); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_STRING_EQUAL_FATAL(name, g_topicRtmDataTypeName); ret = dds_get_name(g_topicRtmAddress, name, MAX_NAME_SIZE); - cr_assert_eq(ret, DDS_RETCODE_OK); - cr_assert_str_eq(name, g_topicRtmAddressName); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_STRING_EQUAL_FATAL(name, g_topicRtmAddressName); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_get_name, too_small, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_get_name, too_small, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { char name[10]; dds_return_t ret; ret = dds_get_name(g_topicRtmDataType, name, 10); - cr_assert_eq(ret, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); g_topicRtmDataTypeName[9] = '\0'; - cr_assert_str_eq(name, g_topicRtmDataTypeName); + CU_ASSERT_STRING_EQUAL_FATAL(name, g_topicRtmDataTypeName); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_get_name, non_topic, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_get_name, non_topic, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { char name[MAX_NAME_SIZE]; dds_return_t ret; ret = dds_get_name(g_participant, name, MAX_NAME_SIZE); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %s", dds_err_str(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_topic_get_name, invalid_params) = { - DataPoints(char*, (char*)0, g_nameBuffer), - DataPoints(size_t, 0, MAX_NAME_SIZE), +CU_TheoryDataPoints(ddsc_topic_get_name, invalid_params) = { + CU_DataPoints(char*, g_nameBuffer, NULL), + CU_DataPoints(size_t, 0, MAX_NAME_SIZE), }; -Theory((char *name, size_t size), ddsc_topic_get_name, invalid_params, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Theory((char *name, size_t size), ddsc_topic_get_name, invalid_params, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_return_t ret; - cr_assume((name != g_nameBuffer) || (size != MAX_NAME_SIZE)); + CU_ASSERT_FATAL((name != g_nameBuffer) || (size != MAX_NAME_SIZE)); ret = dds_get_name(g_topicRtmDataType, name, size); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %s", dds_err_str(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_get_name, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_get_name, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { char name[MAX_NAME_SIZE]; dds_return_t ret; dds_delete(g_topicRtmDataType); ret = dds_get_name(g_topicRtmDataType, name, MAX_NAME_SIZE); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %s", dds_err_str(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ @@ -325,7 +324,7 @@ Test(ddsc_topic_get_name, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini) * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_get_type_name, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_get_type_name, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { const char *rtmDataTypeType = "RoundTripModule::DataType"; const char *rtmAddressType = "RoundTripModule::Address"; @@ -333,60 +332,60 @@ Test(ddsc_topic_get_type_name, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fi dds_return_t ret; ret = dds_get_type_name(g_topicRtmDataType, name, MAX_NAME_SIZE); - cr_assert_eq(ret, DDS_RETCODE_OK); - cr_assert_str_eq(name, rtmDataTypeType); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_STRING_EQUAL_FATAL(name, rtmDataTypeType); ret = dds_get_type_name(g_topicRtmAddress, name, MAX_NAME_SIZE); - cr_assert_eq(ret, DDS_RETCODE_OK); - cr_assert_str_eq(name, rtmAddressType); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_STRING_EQUAL_FATAL(name, rtmAddressType); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_get_type_name, too_small, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_get_type_name, too_small, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { const char *rtmDataTypeType = "RoundTrip"; char name[10]; dds_return_t ret; ret = dds_get_type_name(g_topicRtmDataType, name, 10); - cr_assert_eq(ret, DDS_RETCODE_OK); - cr_assert_str_eq(name, rtmDataTypeType); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); + CU_ASSERT_STRING_EQUAL_FATAL(name, rtmDataTypeType); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_get_type_name, non_topic, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_get_type_name, non_topic, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { char name[MAX_NAME_SIZE]; dds_return_t ret; ret = dds_get_type_name(g_participant, name, MAX_NAME_SIZE); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %s", dds_err_str(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_topic_get_type_name, invalid_params) = { - DataPoints(char*, (char*)0, g_nameBuffer), - DataPoints(size_t, 0, MAX_NAME_SIZE), +CU_TheoryDataPoints(ddsc_topic_get_type_name, invalid_params) = { + CU_DataPoints(char*, g_nameBuffer, NULL), + CU_DataPoints(size_t, 0, MAX_NAME_SIZE), }; -Theory((char *name, size_t size), ddsc_topic_get_type_name, invalid_params, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Theory((char *name, size_t size), ddsc_topic_get_type_name, invalid_params, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_return_t ret; - cr_assume((name != g_nameBuffer) || (size != MAX_NAME_SIZE)); + CU_ASSERT_FATAL((name != g_nameBuffer) || (size != MAX_NAME_SIZE)); ret = dds_get_type_name(g_topicRtmDataType, name, size); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %s", dds_err_str(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_get_type_name, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_get_type_name, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { char name[MAX_NAME_SIZE]; dds_return_t ret; dds_delete(g_topicRtmDataType); ret = dds_get_type_name(g_topicRtmDataType, name, MAX_NAME_SIZE); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %s", dds_err_str(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ @@ -398,34 +397,34 @@ Test(ddsc_topic_get_type_name, deleted, .init=ddsc_topic_init, .fini=ddsc_topic_ * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_set_qos, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_set_qos, valid, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_return_t ret; /* Latency is the only one allowed to change. */ dds_qset_latency_budget(g_qos, DDS_SECS(1)); ret = dds_set_qos(g_topicRtmDataType, g_qos); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_UNSUPPORTED, "returned %s", dds_err_str(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_UNSUPPORTED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_set_qos, inconsistent, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_set_qos, inconsistent, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_return_t ret; OS_WARNING_MSVC_OFF(28020); /* Disable SAL warning on intentional misuse of the API */ dds_qset_lifespan(g_qos, DDS_SECS(-1)); OS_WARNING_MSVC_ON(28020); ret = dds_set_qos(g_topicRtmDataType, g_qos); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_INCONSISTENT_POLICY, "returned %s", dds_err_str(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_INCONSISTENT_POLICY); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_topic_set_qos, immutable, .init=ddsc_topic_init, .fini=ddsc_topic_fini) +CU_Test(ddsc_topic_set_qos, immutable, .init=ddsc_topic_init, .fini=ddsc_topic_fini) { dds_return_t ret; dds_qset_destination_order(g_qos, DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP); /* Immutable */ ret = dds_set_qos(g_topicRtmDataType, g_qos); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_IMMUTABLE_POLICY, "returned %s", dds_err_str(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_IMMUTABLE_POLICY); } /*************************************************************************************************/ diff --git a/src/core/ddsc/tests/transientlocal.c b/src/core/ddsc/tests/transientlocal.c index 6b20ab9..6dba616 100644 --- a/src/core/ddsc/tests/transientlocal.c +++ b/src/core/ddsc/tests/transientlocal.c @@ -12,12 +12,10 @@ #include #include "ddsc/dds.h" #include "Space.h" -#include -#include +#include "CUnit/Test.h" -#define TRACE_SAMPLE(info, sample) cr_log_info("%s (%d, %d, %d)\n", info, sample.long_1, sample.long_2, sample.long_3); #define MAX_SAMPLES (7) -Test(ddsc_transient_local, late_joiner) +CU_Test(ddsc_transient_local, late_joiner) { Space_Type1 sample = { 0, 0, 0 }; dds_return_t ret; @@ -45,60 +43,54 @@ Test(ddsc_transient_local, late_joiner) /* Create participant and topic. */ par = dds_create_participant(DDS_DOMAIN_DEFAULT, qos, NULL); - cr_assert_gt(par, 0, "Failed to create prerequisite par"); + CU_ASSERT_FATAL(par > 0); top = dds_create_topic(par, &Space_Type1_desc, "ddsc_transient_local_happy_days", qos, NULL); - cr_assert_gt(par, 0, "Failed to create prerequisite top"); + CU_ASSERT_FATAL(par > 0); /* Create publishing entities. */ - cr_log_info("Create writer\n"); pub = dds_create_publisher(par, qos, NULL); - cr_assert_gt(pub, 0, "Failed to create prerequisite pub"); + CU_ASSERT_FATAL(pub > 0); wrt = dds_create_writer(pub, top, qos, NULL); - cr_assert_gt(wrt, 0, "Failed to create prerequisite wrt"); + CU_ASSERT_FATAL(wrt > 0); /* Write first set of samples. */ sample.long_1 = 1; sample.long_2 = 1; sample.long_3 = 1; - TRACE_SAMPLE("Write ", sample); ret = dds_write(wrt, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); sample.long_1 = 2; sample.long_2 = 2; sample.long_3 = 2; - TRACE_SAMPLE("Write ", sample); ret = dds_write(wrt, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Create subscribing entities. */ - cr_log_info("Create reader\n"); sub = dds_create_subscriber(par, qos, NULL); - cr_assert_gt(sub, 0, "Failed to create prerequisite sub"); + CU_ASSERT_FATAL(sub > 0); rdr = dds_create_reader(sub, top, qos, NULL); - cr_assert_gt(rdr, 0, "Failed to create prerequisite g_reader"); + CU_ASSERT_FATAL(rdr > 0); /* Write second set of samples. */ sample.long_1 = 8; sample.long_2 = 8; sample.long_3 = 8; - TRACE_SAMPLE("Write ", sample); ret = dds_write(wrt, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); sample.long_1 = 9; sample.long_2 = 9; sample.long_3 = 9; - TRACE_SAMPLE("Write ", sample); ret = dds_write(wrt, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read samples, which should be all four. */ ret = dds_read(rdr, samples, info, MAX_SAMPLES, MAX_SAMPLES); - cr_log_info("Read cnt %d\n", ret); +#if 0 for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)samples[i]; - TRACE_SAMPLE("Read ", (*sample)); } - cr_assert_eq(ret, 4, "# read %d, expected 4", ret); +#endif + CU_ASSERT_EQUAL_FATAL(ret, 4); dds_delete(par); dds_delete_qos(qos); diff --git a/src/core/ddsc/tests/types.c b/src/core/ddsc/tests/types.c index 463eaf0..4588a1e 100644 --- a/src/core/ddsc/tests/types.c +++ b/src/core/ddsc/tests/types.c @@ -9,8 +9,7 @@ * * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ -#include -#include +#include "CUnit/Test.h" #include "ddsc/dds.h" #include "TypesArrayKey.h" @@ -24,14 +23,14 @@ for( unsigned i = 0; i < (sizeof data.key / sizeof *data.key); i++) data.key[i] = (init); \ \ par = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); \ - cr_assert_gt(par, 0); \ + CU_ASSERT_FATAL(par > 0); \ top = dds_create_topic(par, &TypesArrayKey_##type##_arraytypekey_desc, strfy(type), NULL, NULL); \ - cr_assert_gt(top, 0); \ + CU_ASSERT_FATAL(top > 0); \ wri = dds_create_writer(par, top, NULL, NULL); \ - cr_assert_gt(wri, 0); \ + CU_ASSERT_FATAL(wri > 0); \ \ status = dds_write(wri, &data); \ - cr_assert_eq(dds_err_nr(status), DDS_RETCODE_OK); \ + CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK); \ \ dds_delete(wri); \ dds_delete(top); \ @@ -39,57 +38,57 @@ } while (0) -Test(ddsc_types, long_arraytypekey) +CU_Test(ddsc_types, long_arraytypekey) { DDSC_ARRAYTYPEKEY_TEST(long, 1); } -Test(ddsc_types, longlong_arraytypekey) +CU_Test(ddsc_types, longlong_arraytypekey) { DDSC_ARRAYTYPEKEY_TEST(longlong, 1); } -Test(ddsc_types, unsignedshort_arraytypekey) +CU_Test(ddsc_types, unsignedshort_arraytypekey) { DDSC_ARRAYTYPEKEY_TEST(unsignedshort, 1); } -Test(ddsc_types, unsignedlong_arraytypekey) +CU_Test(ddsc_types, unsignedlong_arraytypekey) { DDSC_ARRAYTYPEKEY_TEST(unsignedlong, 1); } -Test(ddsc_types, unsignedlonglong_arraytypekey) +CU_Test(ddsc_types, unsignedlonglong_arraytypekey) { DDSC_ARRAYTYPEKEY_TEST(unsignedlonglong, 1); } -Test(ddsc_types, float_arraytypekey) +CU_Test(ddsc_types, float_arraytypekey) { DDSC_ARRAYTYPEKEY_TEST(float, 1.0f); } -Test(ddsc_types, double_arraytypekey) +CU_Test(ddsc_types, double_arraytypekey) { DDSC_ARRAYTYPEKEY_TEST(double, 1.0f); } -Test(ddsc_types, char_arraytypekey) +CU_Test(ddsc_types, char_arraytypekey) { DDSC_ARRAYTYPEKEY_TEST(char, '1'); } -Test(ddsc_types, boolean_arraytypekey) +CU_Test(ddsc_types, boolean_arraytypekey) { DDSC_ARRAYTYPEKEY_TEST(boolean, true); } -Test(ddsc_types, octet_arraytypekey) +CU_Test(ddsc_types, octet_arraytypekey) { DDSC_ARRAYTYPEKEY_TEST(octet, 1); } -Test(ddsc_types, alltypeskey) +CU_Test(ddsc_types, alltypeskey) { dds_return_t status; dds_entity_t par, top, wri; @@ -108,14 +107,14 @@ Test(ddsc_types, alltypeskey) }; par = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(par, 0); + CU_ASSERT_FATAL(par > 0); top = dds_create_topic(par, &TypesArrayKey_alltypeskey_desc, "AllTypesKey", NULL, NULL); - cr_assert_gt(top, 0); + CU_ASSERT_FATAL(top > 0); wri = dds_create_writer(par, top, NULL, NULL); - cr_assert_gt(wri, 0); + CU_ASSERT_FATAL(wri > 0); status = dds_write(wri, &atk_data); - cr_assert_eq(dds_err_nr(status), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK); dds_delete(wri); dds_delete(top); diff --git a/src/core/ddsc/tests/unregister.c b/src/core/ddsc/tests/unregister.c index dbcd4a6..a30aabf 100644 --- a/src/core/ddsc/tests/unregister.c +++ b/src/core/ddsc/tests/unregister.c @@ -13,9 +13,8 @@ #include "ddsc/dds.h" #include "os/os.h" -#include -#include -#include +#include "CUnit/Test.h" +#include "CUnit/Theory.h" #include "Space.h" @@ -63,46 +62,46 @@ unregistering_init(void) dds_qset_destination_order(qos, DDS_DESTINATIONORDER_BY_SOURCE_TIMESTAMP); g_participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(g_participant, 0, "Failed to create prerequisite g_participant"); + CU_ASSERT_FATAL(g_participant > 0); g_waitset = dds_create_waitset(g_participant); - cr_assert_gt(g_waitset, 0, "Failed to create g_waitset"); + CU_ASSERT_FATAL(g_waitset > 0); g_topic = dds_create_topic(g_participant, &Space_Type1_desc, create_topic_name("ddsc_unregistering_test", name, 100), qos, NULL); - cr_assert_gt(g_topic, 0, "Failed to create prerequisite g_topic"); + CU_ASSERT_FATAL(g_topic > 0); /* Create a reader that keeps one sample on three instances. */ dds_qset_reliability(qos, DDS_RELIABILITY_RELIABLE, DDS_MSECS(100)); dds_qset_resource_limits(qos, DDS_LENGTH_UNLIMITED, 3, 1); g_reader = dds_create_reader(g_participant, g_topic, qos, NULL); - cr_assert_gt(g_reader, 0, "Failed to create prerequisite g_reader"); + CU_ASSERT_FATAL(g_reader > 0); /* Create a writer that will not automatically dispose unregistered samples. */ dds_qset_writer_data_lifecycle(qos, false); g_writer = dds_create_writer(g_participant, g_topic, qos, NULL); - cr_assert_gt(g_writer, 0, "Failed to create prerequisite g_writer"); + CU_ASSERT_FATAL(g_writer > 0); /* Sync g_writer to g_reader. */ ret = dds_set_enabled_status(g_writer, DDS_PUBLICATION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_writer status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_writer, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_writer r"); - cr_assert_eq(g_writer, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_writer a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_writer, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Sync g_reader to g_writer. */ ret = dds_set_enabled_status(g_reader, DDS_SUBSCRIPTION_MATCHED_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Failed prerequisite dds_waitset_wait g_reader r"); - cr_assert_eq(g_reader, (dds_entity_t)(intptr_t)triggered, "Failed prerequisite dds_waitset_wait g_reader a"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(g_reader, (dds_entity_t)(intptr_t)triggered); ret = dds_waitset_detach(g_waitset, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to detach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Write initial samples. */ for (int i = 0; i < INITIAL_SAMPLES; i++) { @@ -110,7 +109,7 @@ unregistering_init(void) sample.long_2 = i*2; sample.long_3 = i*3; ret = dds_write(g_writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed prerequisite write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /* Initialize reading buffers. */ @@ -145,87 +144,87 @@ unregistering_fini(void) * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_unregister_instance, deleted, .init=unregistering_init, .fini=unregistering_fini) +CU_Test(ddsc_unregister_instance, deleted, .init=unregistering_init, .fini=unregistering_fini) { dds_return_t ret; dds_delete(g_writer); ret = dds_unregister_instance(g_writer, g_data); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_unregister_instance, null, .init=unregistering_init, .fini=unregistering_fini) +CU_Test(ddsc_unregister_instance, null, .init=unregistering_init, .fini=unregistering_fini) { dds_return_t ret; ret = dds_unregister_instance(g_writer, NULL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_unregister_instance, invalid_writers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_unregister_instance, invalid_writers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_unregister_instance, invalid_writers, .init=unregistering_init, .fini=unregistering_fini) +CU_Theory((dds_entity_t writer), ddsc_unregister_instance, invalid_writers, .init=unregistering_init, .fini=unregistering_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_unregister_instance(writer, g_data); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_unregister_instance, non_writers) = { - DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_unregister_instance, non_writers) = { + CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), }; -Theory((dds_entity_t *writer), ddsc_unregister_instance, non_writers, .init=unregistering_init, .fini=unregistering_fini) +CU_Theory((dds_entity_t *writer), ddsc_unregister_instance, non_writers, .init=unregistering_init, .fini=unregistering_fini) { dds_return_t ret; ret = dds_unregister_instance(*writer, g_data); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_unregister_instance, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini) +CU_Test(ddsc_unregister_instance, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini) { Space_Type1 oldInstance = { 0, 22, 22 }; dds_return_t ret; ret = dds_unregister_instance(g_writer, &oldInstance); - cr_assert_eq(ret, DDS_RETCODE_OK, "Unregistering old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 == 0) { /* Check data. */ - cr_assert_eq(sample->long_2, 0); - cr_assert_eq(sample->long_3, 0); + CU_ASSERT_EQUAL_FATAL(sample->long_2, 0); + CU_ASSERT_EQUAL_FATAL(sample->long_3, 0); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE); } else if (sample->long_1 == 1) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } } @@ -240,93 +239,93 @@ Test(ddsc_unregister_instance, unregistering_old_instance, .init=unregistering_i * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_unregister_instance_ts, deleted, .init=unregistering_init, .fini=unregistering_fini) +CU_Test(ddsc_unregister_instance_ts, deleted, .init=unregistering_init, .fini=unregistering_fini) { dds_return_t ret; dds_delete(g_writer); ret = dds_unregister_instance_ts(g_writer, g_data, g_present); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_unregister_instance_ts, null, .init=unregistering_init, .fini=unregistering_fini) +CU_Test(ddsc_unregister_instance_ts, null, .init=unregistering_init, .fini=unregistering_fini) { dds_return_t ret; ret = dds_unregister_instance_ts(g_writer, NULL, g_present); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_unregister_instance_ts, invalid_writers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_unregister_instance_ts, invalid_writers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_unregister_instance_ts, invalid_writers, .init=unregistering_init, .fini=unregistering_fini) +CU_Theory((dds_entity_t writer), ddsc_unregister_instance_ts, invalid_writers, .init=unregistering_init, .fini=unregistering_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_unregister_instance_ts(writer, g_data, g_present); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_unregister_instance_ts, non_writers) = { - DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_unregister_instance_ts, non_writers) = { + CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), }; -Theory((dds_entity_t *writer), ddsc_unregister_instance_ts, non_writers, .init=unregistering_init, .fini=unregistering_fini) +CU_Theory((dds_entity_t *writer), ddsc_unregister_instance_ts, non_writers, .init=unregistering_init, .fini=unregistering_fini) { dds_return_t ret; ret = dds_unregister_instance_ts(*writer, g_data, g_present); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_unregister_instance_ts, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini) +CU_Test(ddsc_unregister_instance_ts, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini) { Space_Type1 oldInstance = { 0, 22, 22 }; dds_return_t ret; ret = dds_unregister_instance_ts(g_writer, &oldInstance, g_present); - cr_assert_eq(ret, DDS_RETCODE_OK, "Unregistering old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 == 0) { /* Check data (data part of unregister is not used, only the key part). */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE); } else if (sample->long_1 == 1) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL( "Unknown sample read"); } } } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_unregister_instance_ts, unregistering_past_sample, .init=unregistering_init, .fini=unregistering_fini) +CU_Test(ddsc_unregister_instance_ts, unregistering_past_sample, .init=unregistering_init, .fini=unregistering_fini) { Space_Type1 oldInstance = { 0, 0, 0 }; dds_attach_t triggered; @@ -334,34 +333,34 @@ Test(ddsc_unregister_instance_ts, unregistering_past_sample, .init=unregistering /* Unregistering a sample in the past should trigger a lost sample. */ ret = dds_set_enabled_status(g_reader, DDS_SAMPLE_LOST_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Now, unregister a sample in the past. */ ret = dds_unregister_instance_ts(g_writer, &oldInstance, g_past); - cr_assert_eq(ret, DDS_RETCODE_OK, "Unregistering old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Wait for 'sample lost'. */ ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Unregistering past sample did not trigger 'sample lost'"); + CU_ASSERT_EQUAL_FATAL(ret, 1); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if ((sample->long_1 == 0) || (sample->long_1 == 1)) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } @@ -377,90 +376,90 @@ Test(ddsc_unregister_instance_ts, unregistering_past_sample, .init=unregistering * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_unregister_instance_ih, deleted, .init=unregistering_init, .fini=unregistering_fini) +CU_Test(ddsc_unregister_instance_ih, deleted, .init=unregistering_init, .fini=unregistering_fini) { dds_return_t ret; dds_delete(g_writer); ret = dds_unregister_instance_ih(g_writer, DDS_HANDLE_NIL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_unregister_instance_ih, invalid_handles) = { - DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), +CU_TheoryDataPoints(ddsc_unregister_instance_ih, invalid_handles) = { + CU_DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), }; -Theory((dds_instance_handle_t handle), ddsc_unregister_instance_ih, invalid_handles, .init=unregistering_init, .fini=unregistering_fini) +CU_Theory((dds_instance_handle_t handle), ddsc_unregister_instance_ih, invalid_handles, .init=unregistering_init, .fini=unregistering_fini) { dds_return_t ret; ret = dds_unregister_instance_ih(g_writer, handle); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_unregister_instance_ih, invalid_writers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_unregister_instance_ih, invalid_writers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_unregister_instance_ih, invalid_writers, .init=unregistering_init, .fini=unregistering_fini) +CU_Theory((dds_entity_t writer), ddsc_unregister_instance_ih, invalid_writers, .init=unregistering_init, .fini=unregistering_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_unregister_instance_ih(writer, DDS_HANDLE_NIL); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_unregister_instance_ih, non_writers) = { - DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_unregister_instance_ih, non_writers) = { + CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), }; -Theory((dds_entity_t *writer), ddsc_unregister_instance_ih, non_writers, .init=unregistering_init, .fini=unregistering_fini) +CU_Theory((dds_entity_t *writer), ddsc_unregister_instance_ih, non_writers, .init=unregistering_init, .fini=unregistering_fini) { dds_return_t ret; ret = dds_unregister_instance_ih(*writer, DDS_HANDLE_NIL); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_unregister_instance_ih, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini) +CU_Test(ddsc_unregister_instance_ih, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini) { Space_Type1 oldInstance = { 0, 22, 22 }; dds_instance_handle_t hdl = dds_instance_lookup(g_writer, &oldInstance); dds_return_t ret; ret = dds_unregister_instance_ih(g_writer, hdl); - cr_assert_eq(ret, DDS_RETCODE_OK, "Unregistering old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 == 0) { /* Check data. */ - cr_assert_eq(sample->long_2, 0); - cr_assert_eq(sample->long_3, 0); + CU_ASSERT_EQUAL_FATAL(sample->long_2, 0); + CU_ASSERT_EQUAL_FATAL(sample->long_3, 0); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE); } else if (sample->long_1 == 1) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } } @@ -475,97 +474,97 @@ Test(ddsc_unregister_instance_ih, unregistering_old_instance, .init=unregisterin * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_unregister_instance_ih_ts, deleted, .init=unregistering_init, .fini=unregistering_fini) +CU_Test(ddsc_unregister_instance_ih_ts, deleted, .init=unregistering_init, .fini=unregistering_fini) { dds_return_t ret; dds_delete(g_writer); ret = dds_unregister_instance_ih_ts(g_writer, DDS_HANDLE_NIL, g_present); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_unregister_instance_ih_ts, invalid_handles) = { - DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), +CU_TheoryDataPoints(ddsc_unregister_instance_ih_ts, invalid_handles) = { + CU_DataPoints(dds_instance_handle_t, DDS_HANDLE_NIL, 0, 1, 100, UINT64_MAX), }; -Theory((dds_instance_handle_t handle), ddsc_unregister_instance_ih_ts, invalid_handles, .init=unregistering_init, .fini=unregistering_fini) +CU_Theory((dds_instance_handle_t handle), ddsc_unregister_instance_ih_ts, invalid_handles, .init=unregistering_init, .fini=unregistering_fini) { dds_return_t ret; ret = dds_unregister_instance_ih_ts(g_writer, handle, g_present); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_unregister_instance_ih_ts, invalid_writers) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_unregister_instance_ih_ts, invalid_writers) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t writer), ddsc_unregister_instance_ih_ts, invalid_writers, .init=unregistering_init, .fini=unregistering_fini) +CU_Theory((dds_entity_t writer), ddsc_unregister_instance_ih_ts, invalid_writers, .init=unregistering_init, .fini=unregistering_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_unregister_instance_ih_ts(writer, DDS_HANDLE_NIL, g_present); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_unregister_instance_ih_ts, non_writers) = { - DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), +CU_TheoryDataPoints(ddsc_unregister_instance_ih_ts, non_writers) = { + CU_DataPoints(dds_entity_t*, &g_waitset, &g_reader, &g_topic, &g_participant), }; -Theory((dds_entity_t *writer), ddsc_unregister_instance_ih_ts, non_writers, .init=unregistering_init, .fini=unregistering_fini) +CU_Theory((dds_entity_t *writer), ddsc_unregister_instance_ih_ts, non_writers, .init=unregistering_init, .fini=unregistering_fini) { dds_return_t ret; ret = dds_unregister_instance_ih_ts(*writer, DDS_HANDLE_NIL, g_present); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_unregister_instance_ih_ts, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini) +CU_Test(ddsc_unregister_instance_ih_ts, unregistering_old_instance, .init=unregistering_init, .fini=unregistering_fini) { Space_Type1 oldInstance = { 0, 22, 22 }; dds_instance_handle_t hdl = dds_instance_lookup(g_writer, &oldInstance); dds_return_t ret; ret = dds_unregister_instance_ih_ts(g_writer, hdl, g_present); - cr_assert_eq(ret, DDS_RETCODE_OK, "Unregistering old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 == 0) { /* Check data (data part of unregister is not used, only the key part). */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE); } else if (sample->long_1 == 1) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_unregister_instance_ih_ts, unregistering_past_sample, .init=unregistering_init, .fini=unregistering_fini) +CU_Test(ddsc_unregister_instance_ih_ts, unregistering_past_sample, .init=unregistering_init, .fini=unregistering_fini) { Space_Type1 oldInstance = { 0, 0, 0 }; dds_instance_handle_t hdl = dds_instance_lookup(g_writer, &oldInstance); @@ -574,34 +573,34 @@ Test(ddsc_unregister_instance_ih_ts, unregistering_past_sample, .init=unregister /* Unregistering a sample in the past should trigger a lost sample. */ ret = dds_set_enabled_status(g_reader, DDS_SAMPLE_LOST_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to set prerequisite g_reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(g_waitset, g_reader, g_reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite g_reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Now, unregister a sample in the past. */ ret = dds_unregister_instance_ih_ts(g_writer, hdl, g_past); - cr_assert_eq(ret, DDS_RETCODE_OK, "Unregistering old instance returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Wait for 'sample lost'. */ ret = dds_waitset_wait(g_waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "Unregistering past sample did not trigger 'sample lost'"); + CU_ASSERT_EQUAL_FATAL(ret, 1); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 2, "# read %d, expected %d", ret, 2); + CU_ASSERT_EQUAL_FATAL(ret, 2); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if ((sample->long_1 == 0) || (sample->long_1 == 1)) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } @@ -609,48 +608,48 @@ Test(ddsc_unregister_instance_ih_ts, unregistering_past_sample, .init=unregister /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_unregister_instance, dispose_unregistered_sample, .init=unregistering_init, .fini=unregistering_fini) +CU_Test(ddsc_unregister_instance, dispose_unregistered_sample, .init=unregistering_init, .fini=unregistering_fini) { dds_entity_t writer; writer = dds_create_writer(g_participant, g_topic, NULL, NULL); - cr_assert_gt(g_writer, 0, "Failed to create writer"); + CU_ASSERT_FATAL(g_writer > 0); Space_Type1 newInstance = { INITIAL_SAMPLES, 0, 0 }; dds_return_t ret; ret = dds_write(writer, &newInstance); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_unregister_instance(writer, &newInstance); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing unregistered sample returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 3, "# read %d, expected %d", ret, 3); + CU_ASSERT_EQUAL_FATAL(ret, 3); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 <= 1) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else if (sample->long_1 == 2) { /* Check data. */ - cr_assert_eq(sample->long_2, 0); - cr_assert_eq(sample->long_3, 0); + CU_ASSERT_EQUAL_FATAL(sample->long_2, 0); + CU_ASSERT_EQUAL_FATAL(sample->long_3, 0); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } dds_delete(writer); @@ -658,48 +657,48 @@ Test(ddsc_unregister_instance, dispose_unregistered_sample, .init=unregistering_ /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_unregister_instance_ts, dispose_unregistered_sample, .init=unregistering_init, .fini=unregistering_fini) +CU_Test(ddsc_unregister_instance_ts, dispose_unregistered_sample, .init=unregistering_init, .fini=unregistering_fini) { dds_entity_t writer; writer = dds_create_writer(g_participant, g_topic, NULL, NULL); - cr_assert_gt(g_writer, 0, "Failed to create writer"); + CU_ASSERT_FATAL(g_writer > 0); Space_Type1 newInstance = { INITIAL_SAMPLES, 0, 0 }; dds_return_t ret; ret = dds_write(writer, &newInstance); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed write"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_unregister_instance(writer, &newInstance); - cr_assert_eq(ret, DDS_RETCODE_OK, "Disposing unregistered sample returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Read all available samples. */ ret = dds_read(g_reader, g_samples, g_info, MAX_SAMPLES, MAX_SAMPLES); - cr_assert_eq(ret, 3, "# read %d, expected %d", ret, 3); + CU_ASSERT_EQUAL_FATAL(ret, 3); for(int i = 0; i < ret; i++) { Space_Type1 *sample = (Space_Type1*)g_samples[i]; if (sample->long_1 <= 1) { /* Check data. */ - cr_assert_eq(sample->long_2, sample->long_1 * 2); - cr_assert_eq(sample->long_3, sample->long_1 * 3); + CU_ASSERT_EQUAL_FATAL(sample->long_2, sample->long_1 * 2); + CU_ASSERT_EQUAL_FATAL(sample->long_3, sample->long_1 * 3); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_ALIVE_INSTANCE_STATE); } else if (sample->long_1 == 2) { /* Check data. */ - cr_assert_eq(sample->long_2, 0); - cr_assert_eq(sample->long_3, 0); + CU_ASSERT_EQUAL_FATAL(sample->long_2, 0); + CU_ASSERT_EQUAL_FATAL(sample->long_3, 0); /* Check states. */ - cr_assert_eq(g_info[i].valid_data, true); - cr_assert_eq(g_info[i].sample_state, DDS_SST_NOT_READ); - cr_assert_eq(g_info[i].view_state, DDS_VST_NEW); - cr_assert_eq(g_info[i].instance_state, DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE); + CU_ASSERT_EQUAL_FATAL(g_info[i].valid_data, true); + CU_ASSERT_EQUAL_FATAL(g_info[i].sample_state, DDS_SST_NOT_READ); + CU_ASSERT_EQUAL_FATAL(g_info[i].view_state, DDS_VST_NEW); + CU_ASSERT_EQUAL_FATAL(g_info[i].instance_state, DDS_NOT_ALIVE_DISPOSED_INSTANCE_STATE); } else { - cr_assert(false, "Unknown sample read"); + CU_FAIL_FATAL("Unknown sample read"); } } dds_delete(writer); diff --git a/src/core/ddsc/tests/unsupported.c b/src/core/ddsc/tests/unsupported.c index 1bc1cce..b07ac10 100644 --- a/src/core/ddsc/tests/unsupported.c +++ b/src/core/ddsc/tests/unsupported.c @@ -10,9 +10,7 @@ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ #include -#include -#include -#include +#include "CUnit/Test.h" #include "ddsc/dds.h" #include "RoundTrip.h" @@ -30,23 +28,28 @@ static dds_entity_t e[8]; #define RCD (6) /* ReadCondition */ #define BAD (7) /* Bad (non-entity) */ +struct index_result { + unsigned index; + dds_return_t exp_res; +}; + static void setup(void) { e[PAR] = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(e[PAR], 0); + CU_ASSERT_FATAL(e[PAR] > 0); e[TOP] = dds_create_topic(e[PAR], &RoundTripModule_DataType_desc, "RoundTrip", NULL, NULL); - cr_assert_gt(e[TOP], 0); + CU_ASSERT_FATAL(e[TOP] > 0); e[PUB] = dds_create_publisher(e[PAR], NULL, NULL); - cr_assert_gt(e[PUB], 0); + CU_ASSERT_FATAL(e[PUB] > 0); e[WRI] = dds_create_writer(e[PUB], e[TOP], NULL, NULL); - cr_assert_gt(e[WRI], 0); + CU_ASSERT_FATAL(e[WRI] > 0); e[SUB] = dds_create_subscriber(e[PAR], NULL, NULL); - cr_assert_gt(e[SUB], 0); + CU_ASSERT_FATAL(e[SUB] > 0); e[REA] = dds_create_reader(e[SUB], e[TOP], NULL, NULL); - cr_assert_gt(e[REA], 0); + CU_ASSERT_FATAL(e[REA] > 0); e[RCD] = dds_create_readcondition(e[REA], DDS_ANY_STATE); - cr_assert_gt(e[RCD], 0); + CU_ASSERT_FATAL(e[RCD] > 0); e[BAD] = 1; } @@ -59,124 +62,97 @@ teardown(void) } /*************************************************************************************************/ -struct index_result { - unsigned index; - dds_return_t exp_res; -}; -/*************************************************************************************************/ -ParameterizedTestParameters(ddsc_unsupported, dds_begin_end_coherent) { - /* The parameters seem to be initialized before spawning children, - * so it makes no sense to try and store anything dynamic here. */ - static struct index_result pars[] = { - {PUB, DDS_RETCODE_UNSUPPORTED}, - {WRI, DDS_RETCODE_UNSUPPORTED}, - {SUB, DDS_RETCODE_UNSUPPORTED}, - {REA, DDS_RETCODE_UNSUPPORTED}, - {BAD, DDS_RETCODE_BAD_PARAMETER} - }; - return cr_make_param_array(struct index_result, pars, sizeof pars / sizeof *pars); -}; -ParameterizedTest(struct index_result *par, ddsc_unsupported, dds_begin_end_coherent, .init = setup, .fini = teardown) +CU_Test(ddsc_unsupported, dds_begin_end_coherent, .init = setup, .fini = teardown) { dds_return_t result; - result = dds_begin_coherent(e[par->index]); - cr_expect_eq(dds_err_nr(result), par->exp_res, "Unexpected return code %d \"%s\" (expected %d \"%s\") from dds_begin_coherent(%s): (%d)", dds_err_nr(result), dds_err_str(result), par->exp_res, dds_err_str(-par->exp_res), entity_kind_str(e[par->index]), result); - - result = dds_end_coherent(e[par->index]); - cr_expect_eq(dds_err_nr(result), par->exp_res, "Unexpected return code %d \"%s\" (expected %d \"%s\") from dds_end_coherent(%s): (%d)", dds_err_nr(result), dds_err_str(result), par->exp_res, dds_err_str(-par->exp_res), entity_kind_str(e[par->index]), result); -} - -/*************************************************************************************************/ -ParameterizedTestParameters(ddsc_unsupported, dds_wait_for_acks) { static struct index_result pars[] = { - {PUB, DDS_RETCODE_UNSUPPORTED}, - {WRI, DDS_RETCODE_UNSUPPORTED}, - {BAD, DDS_RETCODE_BAD_PARAMETER} + {PUB, DDS_RETCODE_UNSUPPORTED}, + {WRI, DDS_RETCODE_UNSUPPORTED}, + {SUB, DDS_RETCODE_UNSUPPORTED}, + {REA, DDS_RETCODE_UNSUPPORTED}, + {BAD, DDS_RETCODE_BAD_PARAMETER} }; - return cr_make_param_array(struct index_result, pars, sizeof pars / sizeof *pars); -}; + for (int i=0; i < 5; i++) { + result = dds_begin_coherent(e[pars[i].index]); + CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res); + result = dds_end_coherent(e[pars[i].index]); + CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res); + } +} -ParameterizedTest(struct index_result *par, ddsc_unsupported, dds_wait_for_acks, .init = setup, .fini = teardown) +CU_Test(ddsc_unsupported, dds_wait_for_acks, .init = setup, .fini = teardown) { dds_return_t result; - result = dds_wait_for_acks(e[par->index], 0); - cr_expect_eq(dds_err_nr(result), par->exp_res, "Unexpected return code %d \"%s\" (expected %d \"%s\") from dds_wait_for_acks(%s, 0): (%d)", dds_err_nr(result), dds_err_str(result), par->exp_res, dds_err_str(-par->exp_res), entity_kind_str(e[par->index]), result); -} - -/*************************************************************************************************/ -ParameterizedTestParameters(ddsc_unsupported, dds_suspend_resume) { static struct index_result pars[] = { - {PUB, DDS_RETCODE_UNSUPPORTED}, - {WRI, DDS_RETCODE_BAD_PARAMETER}, - {BAD, DDS_RETCODE_BAD_PARAMETER} + {PUB, DDS_RETCODE_UNSUPPORTED}, + {WRI, DDS_RETCODE_UNSUPPORTED}, + {BAD, DDS_RETCODE_BAD_PARAMETER} }; - return cr_make_param_array(struct index_result, pars, sizeof pars / sizeof *pars); -}; + for (int i=0; i< 3; i++) { + result = dds_wait_for_acks(e[pars[i].index], 0); + CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res); + } +} -ParameterizedTest(struct index_result *par, ddsc_unsupported, dds_suspend_resume, .init = setup, .fini = teardown) +CU_Test(ddsc_unsupported, dds_suspend_resume, .init = setup, .fini = teardown) { dds_return_t result; - result = dds_suspend(e[par->index]); - cr_expect_eq(dds_err_nr(result), par->exp_res, "Unexpected return code %d \"%s\" (expected %d \"%s\") from dds_suspend(%s): (%d)", dds_err_nr(result), dds_err_str(result), par->exp_res, dds_err_str(-par->exp_res), entity_kind_str(e[par->index]), result); - - result = dds_resume(e[par->index]); - cr_expect_eq(dds_err_nr(result), par->exp_res, "Unexpected return code %d \"%s\" (expected %d \"%s\") from dds_resume(%s): (%d)", dds_err_nr(result), dds_err_str(result), par->exp_res, dds_err_str(-par->exp_res), entity_kind_str(e[par->index]), result); -} - -/*************************************************************************************************/ -ParameterizedTestParameters(ddsc_unsupported, dds_get_instance_handle) { - /* The parameters seem to be initialized before spawning children, - * so it makes no sense to try and store anything dynamic here. */ static struct index_result pars[] = { - {TOP, DDS_RETCODE_ILLEGAL_OPERATION}, /* TODO: Shouldn't this be either supported or unsupported? */ - {PUB, DDS_RETCODE_UNSUPPORTED}, - {SUB, DDS_RETCODE_UNSUPPORTED}, - {RCD, DDS_RETCODE_ILLEGAL_OPERATION}, - {BAD, DDS_RETCODE_BAD_PARAMETER} + {PUB, DDS_RETCODE_UNSUPPORTED}, + {WRI, DDS_RETCODE_BAD_PARAMETER}, + {BAD, DDS_RETCODE_BAD_PARAMETER} }; - return cr_make_param_array(struct index_result, pars, sizeof pars / sizeof *pars); -}; + for (int i=0; i< 3; i++) { + result = dds_suspend(e[pars[i].index]); + CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res); + result = dds_resume(e[pars[i].index]); + CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res); + } +} -ParameterizedTest(struct index_result *par, ddsc_unsupported, dds_get_instance_handle, .init = setup, .fini = teardown) +CU_Test(ddsc_unsupported, dds_get_instance_handle, .init = setup, .fini = teardown) { dds_return_t result; dds_instance_handle_t ih; - - result = dds_get_instance_handle(e[par->index], &ih); - cr_expect_eq(dds_err_nr(result), par->exp_res, "Unexpected return code %d \"%s\" (expected %d \"%s\") from dds_get_instance_handle(%s): (%d)", dds_err_nr(result), dds_err_str(result), par->exp_res, dds_err_str(-par->exp_res), entity_kind_str(e[par->index]), result); -} - -/*************************************************************************************************/ -ParameterizedTestParameters(ddsc_unsupported, dds_set_qos) { - /* The parameters seem to be initialized before spawning children, - * so it makes no sense to try and store anything dynamic here. */ static struct index_result pars[] = { - {PAR, DDS_RETCODE_UNSUPPORTED}, - {TOP, DDS_RETCODE_UNSUPPORTED}, - {PUB, DDS_RETCODE_UNSUPPORTED}, - {WRI, DDS_RETCODE_UNSUPPORTED}, - {SUB, DDS_RETCODE_UNSUPPORTED}, - {REA, DDS_RETCODE_UNSUPPORTED}, - {RCD, DDS_RETCODE_ILLEGAL_OPERATION}, - {BAD, DDS_RETCODE_BAD_PARAMETER} + {TOP, DDS_RETCODE_ILLEGAL_OPERATION}, /* TODO: Shouldn't this be either supported or unsupported? */ + {PUB, DDS_RETCODE_UNSUPPORTED}, + {SUB, DDS_RETCODE_UNSUPPORTED}, + {RCD, DDS_RETCODE_ILLEGAL_OPERATION}, + {BAD, DDS_RETCODE_BAD_PARAMETER} }; - return cr_make_param_array(struct index_result, pars, sizeof pars / sizeof *pars); -}; + for (int i=0; i < 5; i++) { + result = dds_get_instance_handle(e[pars[i].index], &ih); + CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res); + } +} -ParameterizedTest(struct index_result *par, ddsc_unsupported, dds_set_qos, .init = setup, .fini = teardown) +CU_Test(ddsc_unsupported, dds_set_qos, .init = setup, .fini = teardown) { dds_return_t result; dds_qos_t *qos; + static struct index_result pars[] = { + {PAR, DDS_RETCODE_UNSUPPORTED}, + {TOP, DDS_RETCODE_UNSUPPORTED}, + {PUB, DDS_RETCODE_UNSUPPORTED}, + {WRI, DDS_RETCODE_UNSUPPORTED}, + {SUB, DDS_RETCODE_UNSUPPORTED}, + {REA, DDS_RETCODE_UNSUPPORTED}, + {RCD, DDS_RETCODE_ILLEGAL_OPERATION}, + {BAD, DDS_RETCODE_BAD_PARAMETER} + }; qos = dds_create_qos(); - result = dds_set_qos(e[par->index], qos); - cr_expect_eq(dds_err_nr(result), par->exp_res, "Unexpected return code %d \"%s\" (expected %d \"%s\") from dds_set_qos(%s, qos): (%d)", dds_err_nr(result), dds_err_str(result), par->exp_res, dds_err_str(-par->exp_res), entity_kind_str(e[par->index]), result); + for (int i=0; i < 8;i++) { + result = dds_set_qos(e[pars[i].index], qos); + CU_ASSERT_EQUAL(dds_err_nr(result), pars[i].exp_res); + } dds_delete_qos(qos); } diff --git a/src/core/ddsc/tests/waitset.c b/src/core/ddsc/tests/waitset.c index bbec5d0..f13efbd 100644 --- a/src/core/ddsc/tests/waitset.c +++ b/src/core/ddsc/tests/waitset.c @@ -13,13 +13,10 @@ #include "ddsc/dds.h" #include "os/os.h" -#include -#include -#include +#include "CUnit/Test.h" +#include "CUnit/Theory.h" #include "RoundTrip.h" -/* Add --verbose command line argument to get the cr_log_info traces (if there are any). */ - /************************************************************************************************** * * Some thread related convenience stuff. @@ -75,10 +72,10 @@ static void ddsc_waitset_basic_init(void) { participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0, "Failed to create prerequisite participant"); + CU_ASSERT_FATAL(participant > 0); waitset = dds_create_waitset(participant); - cr_assert_gt(waitset, 0, "Failed to create waitset"); + CU_ASSERT_FATAL(waitset > 0); } static void @@ -101,22 +98,22 @@ ddsc_waitset_init(void) ddsc_waitset_basic_init(); publisher = dds_create_publisher(participant, NULL, NULL); - cr_assert_gt(publisher, 0, "Failed to create prerequisite publisher"); + CU_ASSERT_FATAL(publisher > 0); subscriber = dds_create_subscriber(participant, NULL, NULL); - cr_assert_gt(subscriber, 0, "Failed to create prerequisite subscriber"); + CU_ASSERT_FATAL(subscriber > 0); topic = dds_create_topic(participant, &RoundTripModule_DataType_desc, create_topic_name("ddsc_waitset_test", name, sizeof name), NULL, NULL); - cr_assert_gt(topic, 0, "Failed to create prerequisite topic"); + CU_ASSERT_FATAL(topic > 0); reader = dds_create_reader(subscriber, topic, NULL, NULL); - cr_assert_gt(reader, 0, "Failed to create prerequisite reader"); + CU_ASSERT_FATAL(reader > 0); writer = dds_create_writer(publisher, topic, NULL, NULL); - cr_assert_gt(writer, 0, "Failed to create prerequisite writer"); + CU_ASSERT_FATAL(writer > 0); readcond = dds_create_readcondition(reader, mask); - cr_assert_gt(readcond, 0, "Failed to create prerequisite publisher"); + CU_ASSERT_FATAL(readcond > 0); } static void @@ -143,33 +140,33 @@ ddsc_waitset_attached_init(void) /* Start with interest in nothing. */ ret = dds_set_enabled_status(participant, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to remove prerequisite participant status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_set_enabled_status(writer, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to remove prerequisite writer status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_set_enabled_status(reader, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to remove prerequisite reader status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_set_enabled_status(topic, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to remove prerequisite topic status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_set_enabled_status(publisher, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to remove prerequisite publisher status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_set_enabled_status(subscriber, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to remove prerequisite subscriber status"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Attach all entities to the waitset. */ ret = dds_waitset_attach(waitset, participant, participant); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite participant"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(waitset, waitset, waitset); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite waitset"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(waitset, writer, writer); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite writer"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(waitset, reader, reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite reader"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(waitset, topic, topic); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite topic"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(waitset, publisher, publisher); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite publisher"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(waitset, subscriber, subscriber); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to attach prerequisite subscriber"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } @@ -196,7 +193,7 @@ ddsc_waitset_attached_fini(void) * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_create, second, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Test(ddsc_waitset_create, second, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_entity_t ws; dds_return_t ret; @@ -204,53 +201,53 @@ Test(ddsc_waitset_create, second, .init=ddsc_waitset_basic_init, .fini=ddsc_wait /* Basically, ddsc_waitset_basic_init() already tested the creation of a waitset. But * just see if we can create a second one. */ ws = dds_create_waitset(participant); - cr_assert_gt(ws, 0, "dds_create_waitset(): returned %d", dds_err_nr(ws)); + CU_ASSERT_FATAL(ws > 0); /* Also, we should be able to delete this second one. */ ret = dds_delete(ws); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_delete(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* And, of course, be able to delete the first one (return code isn't checked in the test fixtures). */ ret = dds_delete(waitset); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_delete(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_create, deleted_participant, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Test(ddsc_waitset_create, deleted_participant, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_entity_t ws; dds_entity_t deleted; deleted = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); dds_delete(deleted); ws = dds_create_waitset(deleted); - cr_assert_eq(dds_err_nr(ws), DDS_RETCODE_ALREADY_DELETED, "dds_create_waitset(): returned %d", dds_err_nr(ws)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ws), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_create, invalid_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_waitset_create, invalid_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t par), ddsc_waitset_create, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Theory((dds_entity_t par), ddsc_waitset_create, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_entity_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t ws; ws = dds_create_waitset(par); - cr_assert_eq(dds_err_nr(ws), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ws), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ws), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_create, non_participants) = { - DataPoints(dds_entity_t*, &topic, &writer, &reader, &waitset, &publisher, &subscriber, &readcond), +CU_TheoryDataPoints(ddsc_waitset_create, non_participants) = { + CU_DataPoints(dds_entity_t*, &topic, &writer, &reader, &waitset, &publisher, &subscriber, &readcond), }; -Theory((dds_entity_t *par), ddsc_waitset_create, non_participants, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) +CU_Theory((dds_entity_t *par), ddsc_waitset_create, non_participants, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) { dds_entity_t ws; ws = dds_create_waitset(*par); - cr_assert_eq(dds_err_nr(ws), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ws)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ws), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -266,54 +263,54 @@ Theory((dds_entity_t *par), ddsc_waitset_create, non_participants, .init=ddsc_wa * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_attach, invalid_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), - DataPoints(dds_attach_t, (dds_attach_t)NULL, (dds_attach_t)&reader, (dds_attach_t)3), +CU_TheoryDataPoints(ddsc_waitset_attach, invalid_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), + CU_DataPoints(dds_attach_t, (dds_attach_t)NULL, (dds_attach_t)&reader, (dds_attach_t)3), }; -Theory((dds_entity_t e, dds_attach_t a), ddsc_waitset_attach, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Theory((dds_entity_t e, dds_attach_t a), ddsc_waitset_attach, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_return_t ret; ret = dds_waitset_attach(waitset, e, a); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d != expected %d", dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_attach, invalid_waitsets) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), - DataPoints(dds_attach_t, (dds_attach_t)NULL, (dds_attach_t)&reader, (dds_attach_t)3), +CU_TheoryDataPoints(ddsc_waitset_attach, invalid_waitsets) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), + CU_DataPoints(dds_attach_t, (dds_attach_t)NULL, (dds_attach_t)&reader, (dds_attach_t)3), }; -Theory((dds_entity_t ws, dds_attach_t a), ddsc_waitset_attach, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Theory((dds_entity_t ws, dds_attach_t a), ddsc_waitset_attach, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_waitset_attach(ws, participant, a); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_attach, non_waitsets) = { - DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &publisher, &subscriber, &readcond), - DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &waitset, &publisher, &subscriber, &readcond), - DataPoints(dds_attach_t, (dds_attach_t)NULL, (dds_attach_t)&reader, (dds_attach_t)3), +CU_TheoryDataPoints(ddsc_waitset_attach, non_waitsets) = { + CU_DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &publisher, &subscriber, &readcond), + CU_DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &waitset, &publisher, &subscriber, &readcond), + CU_DataPoints(dds_attach_t, (dds_attach_t)NULL, (dds_attach_t)&reader, (dds_attach_t)3), }; -Theory((dds_entity_t *ws, dds_entity_t *e, dds_attach_t a), ddsc_waitset_attach, non_waitsets, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) +CU_Theory((dds_entity_t *ws, dds_entity_t *e, dds_attach_t a), ddsc_waitset_attach, non_waitsets, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) { dds_return_t ret; ret = dds_waitset_attach(*ws, *e, a); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_attach, deleted_waitset, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Test(ddsc_waitset_attach, deleted_waitset, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_return_t ret; dds_delete(waitset); ret = dds_waitset_attach(waitset, participant, 0); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ @@ -325,12 +322,12 @@ Test(ddsc_waitset_attach, deleted_waitset, .init=ddsc_waitset_basic_init, .fini= * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_attach_detach, valid_entities) = { - DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &waitset, &publisher, &subscriber, &readcond), - DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &waitset, &publisher, &subscriber, &readcond), - DataPoints(dds_attach_t, (dds_attach_t)NULL, (dds_attach_t)&reader, (dds_attach_t)3), +CU_TheoryDataPoints(ddsc_waitset_attach_detach, valid_entities) = { + CU_DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &waitset, &publisher, &subscriber, &readcond), + CU_DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &waitset, &publisher, &subscriber, &readcond), + CU_DataPoints(dds_attach_t, (dds_attach_t)NULL, (dds_attach_t)&reader, (dds_attach_t)3), }; -Theory((dds_entity_t *ws, dds_entity_t *e, dds_attach_t a), ddsc_waitset_attach_detach, valid_entities, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) +CU_Theory((dds_entity_t *ws, dds_entity_t *e, dds_attach_t a), ddsc_waitset_attach_detach, valid_entities, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) { dds_return_t exp; dds_return_t ret; @@ -345,32 +342,32 @@ Theory((dds_entity_t *ws, dds_entity_t *e, dds_attach_t a), ddsc_waitset_attach_ /* Try to attach. */ ret = dds_waitset_attach(*ws, *e, a); - cr_assert_eq(dds_err_nr(ret), exp, "returned %d != expected %d", dds_err_nr(ret), exp); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), exp); /* Detach when needed. */ if (ret == DDS_RETCODE_OK) { ret = dds_waitset_detach(*ws, *e); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_detach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_attach_detach, second, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Test(ddsc_waitset_attach_detach, second, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_return_t ret; ret = dds_waitset_attach(waitset, waitset, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_attach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_attach(waitset, waitset, 0); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "dds_waitset_attach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); ret = dds_waitset_detach(waitset, waitset); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_detach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_detach(waitset, waitset); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET, "dds_waitset_detach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_PRECONDITION_NOT_MET); } /*************************************************************************************************/ @@ -390,37 +387,37 @@ Test(ddsc_waitset_attach_detach, second, .init=ddsc_waitset_basic_init, .fini=dd * *************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_detach, invalid_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_waitset_detach, invalid_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t e), ddsc_waitset_detach, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Theory((dds_entity_t e), ddsc_waitset_detach, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_return_t ret; ret = dds_waitset_detach(waitset, e); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d != expected %d", dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_detach, invalid_waitsets) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_waitset_detach, invalid_waitsets) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t ws), ddsc_waitset_detach, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Theory((dds_entity_t ws), ddsc_waitset_detach, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_waitset_detach(ws, participant); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_detach, valid_entities) = { - DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &waitset, &publisher, &subscriber, &readcond), - DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &waitset, &publisher, &subscriber, &readcond), +CU_TheoryDataPoints(ddsc_waitset_detach, valid_entities) = { + CU_DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &waitset, &publisher, &subscriber, &readcond), + CU_DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &waitset, &publisher, &subscriber, &readcond), }; -Theory((dds_entity_t *ws, dds_entity_t *e), ddsc_waitset_detach, valid_entities, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) +CU_Theory((dds_entity_t *ws, dds_entity_t *e), ddsc_waitset_detach, valid_entities, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) { dds_return_t exp; dds_return_t ret; @@ -434,7 +431,7 @@ Theory((dds_entity_t *ws, dds_entity_t *e), ddsc_waitset_detach, valid_entities, } ret = dds_waitset_detach(*ws, *e); - cr_assert_eq(dds_err_nr(ret), exp, "returned %d != expected %d", dds_err_nr(ret), exp); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), exp); } /*************************************************************************************************/ @@ -448,54 +445,54 @@ Theory((dds_entity_t *ws, dds_entity_t *e), ddsc_waitset_detach, valid_entities, * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_attach_detach, itself, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Test(ddsc_waitset_attach_detach, itself, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_return_t ret; ret = dds_waitset_attach(waitset, waitset, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_attach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_detach(waitset, waitset); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_detach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_attach_detach, participant, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Test(ddsc_waitset_attach_detach, participant, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_return_t ret; ret = dds_waitset_attach(waitset, participant, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_attach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_detach(waitset, participant); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_detach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_attach_detach, reader, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) +CU_Test(ddsc_waitset_attach_detach, reader, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) { dds_return_t ret; ret = dds_waitset_attach(waitset, reader, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_attach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_detach(waitset, reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_detach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_attach_detach, readcondition, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) +CU_Test(ddsc_waitset_attach_detach, readcondition, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) { dds_return_t ret; ret = dds_waitset_attach(waitset, readcond, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_attach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_waitset_detach(waitset, readcond); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_detach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -513,54 +510,54 @@ Test(ddsc_waitset_attach_detach, readcondition, .init=ddsc_waitset_init, .fini=d * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_delete_attached, self, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Test(ddsc_waitset_delete_attached, self, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_return_t ret; ret = dds_waitset_attach(waitset, waitset, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_attach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_delete(waitset); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_delete(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_delete_attached, participant, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Test(ddsc_waitset_delete_attached, participant, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_return_t ret; ret = dds_waitset_attach(waitset, participant, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_attach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_delete(participant); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_delete(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_delete_attached, reader, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) +CU_Test(ddsc_waitset_delete_attached, reader, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) { dds_return_t ret; ret = dds_waitset_attach(waitset, reader, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_attach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_delete(reader); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_delete(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_delete_attached, readcondition, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) +CU_Test(ddsc_waitset_delete_attached, readcondition, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) { dds_return_t ret; ret = dds_waitset_attach(waitset, readcond, 0); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_attach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_delete(readcond); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_delete(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -573,38 +570,38 @@ Test(ddsc_waitset_delete_attached, readcondition, .init=ddsc_waitset_init, .fini * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_set_trigger, deleted_waitset, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Test(ddsc_waitset_set_trigger, deleted_waitset, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_return_t ret; dds_delete(waitset); ret = dds_waitset_set_trigger(waitset, true); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_set_trigger, invalid_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_waitset_set_trigger, invalid_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t ws), ddsc_waitset_set_trigger, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Theory((dds_entity_t ws), ddsc_waitset_set_trigger, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_waitset_set_trigger(ws, true); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_set_trigger, non_waitsets) = { - DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &publisher, &subscriber, &readcond), +CU_TheoryDataPoints(ddsc_waitset_set_trigger, non_waitsets) = { + CU_DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &publisher, &subscriber, &readcond), }; -Theory((dds_entity_t *ws), ddsc_waitset_set_trigger, non_waitsets, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) +CU_Theory((dds_entity_t *ws), ddsc_waitset_set_trigger, non_waitsets, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) { dds_return_t ret; ret = dds_waitset_set_trigger(*ws, true); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -617,128 +614,128 @@ Theory((dds_entity_t *ws), ddsc_waitset_set_trigger, non_waitsets, .init=ddsc_wa * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_wait, deleted_waitset, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) +CU_Test(ddsc_waitset_wait, deleted_waitset, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) { dds_attach_t triggered; dds_return_t ret; dds_delete(waitset); ret = dds_waitset_wait(waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_wait, invalid_waitsets) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_waitset_wait, invalid_waitsets) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t ws), ddsc_waitset_wait, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Theory((dds_entity_t ws), ddsc_waitset_wait, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_attach_t triggered; dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_waitset_wait(ws, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_wait, non_waitsets) = { - DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &publisher, &subscriber, &readcond), +CU_TheoryDataPoints(ddsc_waitset_wait, non_waitsets) = { + CU_DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &publisher, &subscriber, &readcond), }; -Theory((dds_entity_t *ws), ddsc_waitset_wait, non_waitsets, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) +CU_Theory((dds_entity_t *ws), ddsc_waitset_wait, non_waitsets, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) { dds_attach_t triggered; dds_return_t ret; ret = dds_waitset_wait(*ws, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ static dds_attach_t attachment; -TheoryDataPoints(ddsc_waitset_wait, invalid_params) = { - DataPoints(dds_attach_t *, &attachment, NULL), - DataPoints(size_t, 0, 1, 100), - DataPoints(int, -1, 0, 1), +CU_TheoryDataPoints(ddsc_waitset_wait, invalid_params) = { + CU_DataPoints(dds_attach_t *, &attachment, NULL), + CU_DataPoints(size_t, 0, 1, 100), + CU_DataPoints(int, -1, 0, 1), }; -Theory((dds_attach_t *a, size_t size, int msec), ddsc_waitset_wait, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Theory((dds_attach_t *a, size_t size, int msec), ddsc_waitset_wait, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_return_t ret; /* Only test when the combination of parameters is actually invalid. */ - cr_assume(((a == NULL) && (size != 0)) || ((a != NULL) && (size == 0)) || (msec < 0)); + CU_ASSERT_FATAL(((a == NULL) && (size != 0)) || ((a != NULL) && (size == 0)) || (msec < 0)); ret = dds_waitset_wait(waitset, a, size, DDS_MSECS(msec)); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d != expected %d", dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_wait_until, deleted_waitset, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) +CU_Test(ddsc_waitset_wait_until, deleted_waitset, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) { dds_attach_t triggered; dds_return_t ret; dds_delete(waitset); ret = dds_waitset_wait_until(waitset, &triggered, 1, dds_time()); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_wait_until, invalid_waitsets) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_waitset_wait_until, invalid_waitsets) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t ws), ddsc_waitset_wait_until, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Theory((dds_entity_t ws), ddsc_waitset_wait_until, invalid_waitsets, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_attach_t triggered; dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_return_t ret; ret = dds_waitset_wait_until(ws, &triggered, 1, dds_time()); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_wait_until, non_waitsets) = { - DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &publisher, &subscriber, &readcond), +CU_TheoryDataPoints(ddsc_waitset_wait_until, non_waitsets) = { + CU_DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &publisher, &subscriber, &readcond), }; -Theory((dds_entity_t *ws), ddsc_waitset_wait_until, non_waitsets, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) +CU_Theory((dds_entity_t *ws), ddsc_waitset_wait_until, non_waitsets, .init=ddsc_waitset_init, .fini=ddsc_waitset_fini) { dds_attach_t triggered; dds_return_t ret; ret = dds_waitset_wait_until(*ws, &triggered, 1, dds_time()); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ /*************************************************************************************************/ static dds_attach_t attachment; -TheoryDataPoints(ddsc_waitset_wait_until, invalid_params) = { - DataPoints(dds_attach_t *, &attachment, NULL), - DataPoints(size_t, 0, 1, 100) +CU_TheoryDataPoints(ddsc_waitset_wait_until, invalid_params) = { + CU_DataPoints(dds_attach_t *, &attachment, NULL), + CU_DataPoints(size_t, 0, 1, 100) }; -Theory((dds_attach_t *a, size_t size), ddsc_waitset_wait_until, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) +CU_Theory((dds_attach_t *a, size_t size), ddsc_waitset_wait_until, invalid_params, .init=ddsc_waitset_basic_init, .fini=ddsc_waitset_basic_fini) { dds_return_t ret; /* Only test when the combination of parameters is actually invalid. */ - cr_assume(((a == NULL) && (size != 0)) || ((a != NULL) && (size == 0))); + CU_ASSERT_FATAL(((a == NULL) && (size != 0)) || ((a != NULL) && (size == 0))); ret = dds_waitset_wait_until(waitset, a, size, dds_time()); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER, "returned %d != expected %d", dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_BAD_PARAMETER); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_wait_until, past, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) +CU_Test(ddsc_waitset_wait_until, past, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) { dds_attach_t triggered; dds_return_t ret; ret = dds_waitset_wait_until(waitset, &triggered, 1, dds_time() - 100000); - cr_assert_eq(ret, 0, "returned %d != expected 0", ret); + CU_ASSERT_EQUAL_FATAL(ret, 0); } /*************************************************************************************************/ @@ -770,10 +767,10 @@ static uint32_t NumberOfSetBits(uint32_t i) } /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_get_entities, array_sizes) = { - DataPoints(size_t, 0, 1, 7, MAX_ENTITIES_CNT), +CU_TheoryDataPoints(ddsc_waitset_get_entities, array_sizes) = { + CU_DataPoints(size_t, 0, 1, 7, MAX_ENTITIES_CNT), }; -Theory((size_t size), ddsc_waitset_get_entities, array_sizes, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) +CU_Theory((size_t size), ddsc_waitset_get_entities, array_sizes, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) { uint32_t found = 0; dds_return_t i; @@ -782,94 +779,94 @@ Theory((size_t size), ddsc_waitset_get_entities, array_sizes, .init=ddsc_waitset /* Make sure at least one entity is in the waitsets' internal triggered list. */ ret = dds_waitset_set_trigger(waitset, true); - cr_assert_eq(ret, DDS_RETCODE_OK, "Failed to prerequisite trigger entity"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Get the actual attached entities. */ ret = dds_waitset_get_entities(waitset, entities, size); /* ddsc_waitset_attached_init() attached 7 entities. */ - cr_assert_eq(ret, 7, "entities cnt %d (err %d)", ret, dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, 7); /* Found entities should be only present once. */ ret = ((dds_return_t)size < ret) ? (dds_return_t)size : ret; for (i = 0; i < ret; i++) { if (entities[i] == participant) { - cr_assert(!(found & FOUND_PARTICIPANT), "Participant found twice"); + CU_ASSERT_FATAL(!(found & FOUND_PARTICIPANT)); found |= FOUND_PARTICIPANT; } else if (entities[i] == publisher) { - cr_assert(!(found & FOUND_PUBLISHER), "Publisher found twice"); + CU_ASSERT_FATAL(!(found & FOUND_PUBLISHER)); found |= FOUND_PUBLISHER; } else if (entities[i] == subscriber) { - cr_assert(!(found & FOUND_SUBSCRIBER), "Subscriber found twice"); + CU_ASSERT_FATAL(!(found & FOUND_SUBSCRIBER)); found |= FOUND_SUBSCRIBER; } else if (entities[i] == waitset) { - cr_assert(!(found & FOUND_WAITSET), "Waitset found twice"); + CU_ASSERT_FATAL(!(found & FOUND_WAITSET)); found |= FOUND_WAITSET; } else if (entities[i] == topic) { - cr_assert(!(found & FOUND_TOPIC), "Topic found twice"); + CU_ASSERT_FATAL(!(found & FOUND_TOPIC)); found |= FOUND_TOPIC; } else if (entities[i] == reader) { - cr_assert(!(found & FOUND_READER), "Reader found twice"); + CU_ASSERT_FATAL(!(found & FOUND_READER)); found |= FOUND_READER; } else if (entities[i] == writer) { - cr_assert(!(found & FOUND_WRITER), "Writer found twice"); + CU_ASSERT_FATAL(!(found & FOUND_WRITER)); found |= FOUND_WRITER; } } /* Every found entity should be a known one. */ - cr_assert_eq((dds_return_t)NumberOfSetBits(found), ret, "Not all found entities are known"); + CU_ASSERT_EQUAL_FATAL((dds_return_t)NumberOfSetBits(found), ret); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_get_entities, no_array, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) +CU_Test(ddsc_waitset_get_entities, no_array, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) { dds_return_t ret; OS_WARNING_MSVC_OFF(6387); /* Disable SAL warning on intentional misuse of the API */ ret = dds_waitset_get_entities(waitset, NULL, 1); OS_WARNING_MSVC_ON(6387); /* ddsc_waitset_attached_init attached 7 entities. */ - cr_assert_eq(ret, 7, "entities cnt %d (err %d)", ret, dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, 7); } /*************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_get_entities, deleted_waitset, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) +CU_Test(ddsc_waitset_get_entities, deleted_waitset, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) { dds_return_t ret; dds_entity_t entities[MAX_ENTITIES_CNT]; dds_delete(waitset); ret = dds_waitset_get_entities(waitset, entities, MAX_ENTITIES_CNT); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ALREADY_DELETED); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_get_entities, invalid_params) = { - DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), +CU_TheoryDataPoints(ddsc_waitset_get_entities, invalid_params) = { + CU_DataPoints(dds_entity_t, -2, -1, 0, 1, 100, INT_MAX, INT_MIN), }; -Theory((dds_entity_t ws), ddsc_waitset_get_entities, invalid_params, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) +CU_Theory((dds_entity_t ws), ddsc_waitset_get_entities, invalid_params, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) { dds_return_t exp = DDS_RETCODE_BAD_PARAMETER * -1; dds_entity_t entities[MAX_ENTITIES_CNT]; dds_return_t ret; ret = dds_waitset_get_entities(ws, entities, MAX_ENTITIES_CNT); - cr_assert_eq(dds_err_nr(ret), dds_err_nr(exp), "returned %d != expected %d", dds_err_nr(ret), dds_err_nr(exp)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), dds_err_nr(exp)); } /*************************************************************************************************/ /*************************************************************************************************/ -TheoryDataPoints(ddsc_waitset_get_entities, non_waitsets) = { - DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &publisher, &subscriber, &readcond), +CU_TheoryDataPoints(ddsc_waitset_get_entities, non_waitsets) = { + CU_DataPoints(dds_entity_t*, &participant, &topic, &writer, &reader, &publisher, &subscriber, &readcond), }; -Theory((dds_entity_t *ws), ddsc_waitset_get_entities, non_waitsets, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) +CU_Theory((dds_entity_t *ws), ddsc_waitset_get_entities, non_waitsets, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) { dds_entity_t entities[MAX_ENTITIES_CNT]; dds_return_t ret; ret = dds_waitset_get_entities(*ws, entities, MAX_ENTITIES_CNT); - cr_assert_eq(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION, "returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(ret), DDS_RETCODE_ILLEGAL_OPERATION); } /*************************************************************************************************/ @@ -891,7 +888,7 @@ Theory((dds_entity_t *ws), ddsc_waitset_get_entities, non_waitsets, .init=ddsc_w * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_triggering, on_self, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) +CU_Test(ddsc_waitset_triggering, on_self, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) { dds_attach_t triggered; thread_arg_t arg; @@ -899,7 +896,7 @@ Test(ddsc_waitset_triggering, on_self, .init=ddsc_waitset_attached_init, .fini=d /* The waitset should not have been triggered. */ ret = dds_triggered(waitset); - cr_assert_eq(ret, 0, "dds_triggered(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, 0); /* Start a thread that'll wait because no entity attached to the waitset * has been triggered (for instance by a status change). */ @@ -907,24 +904,24 @@ Test(ddsc_waitset_triggering, on_self, .init=ddsc_waitset_attached_init, .fini=d /* Triggering of the waitset should unblock the thread. */ ret = dds_waitset_set_trigger(waitset, true); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_set_trigger(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = waiting_thread_expect_exit(&arg); - cr_assert_eq(ret, DDS_RETCODE_OK, "waiting thread did not unblock"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Now the trigger state should be true. */ ret = dds_triggered(waitset); - cr_assert_gt(ret, 0, "dds_triggered(): returned %d", dds_err_nr(ret)); + CU_ASSERT_FATAL(ret > 0); /* Waitset shouldn't wait, but immediately return our waitset. */ ret = dds_waitset_wait(waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "dds_waitset_wait(): returned %d", ret); - cr_assert_eq(waitset, (dds_entity_t)(intptr_t)triggered); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(waitset, (dds_entity_t)(intptr_t)triggered); /* Reset waitset trigger. */ ret = dds_waitset_set_trigger(waitset, false); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_set_trigger(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = dds_triggered(waitset); - cr_assert_eq(ret, 0, "dds_triggered(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, 0); } /*************************************************************************************************/ @@ -945,7 +942,7 @@ Test(ddsc_waitset_triggering, on_self, .init=ddsc_waitset_attached_init, .fini=d * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_triggering, on_reader, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) +CU_Test(ddsc_waitset_triggering, on_reader, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) { RoundTripModule_DataType sample; dds_attach_t triggered; @@ -956,11 +953,11 @@ Test(ddsc_waitset_triggering, on_reader, .init=ddsc_waitset_attached_init, .fini /* Only interested in data_available for this test. */ ret = dds_set_enabled_status(reader, DDS_DATA_AVAILABLE_STATUS); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_set_enabled_status(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* The reader should not have been triggered. */ ret = dds_triggered(reader); - cr_assert_eq(ret, 0, "dds_triggered(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, 0); /* Start a thread that'll wait because no entity attached to the waitset * has been triggered (for instance by a status change). */ @@ -968,18 +965,18 @@ Test(ddsc_waitset_triggering, on_reader, .init=ddsc_waitset_attached_init, .fini /* Writing data should unblock the thread. */ ret = dds_write(writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_write(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = waiting_thread_expect_exit(&arg); - cr_assert_eq(ret, DDS_RETCODE_OK, "waiting thread did not unblock"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Now the trigger state should be true. */ ret = dds_triggered(reader); - cr_assert_gt(ret, 0, "dds_triggered: Invalid return code %d", dds_err_nr(ret)); + CU_ASSERT_FATAL(ret > 0); /* Waitset shouldn't wait, but immediately return our reader. */ ret = dds_waitset_wait(waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "dds_waitset_wait ret"); - cr_assert_eq(reader, (dds_entity_t)(intptr_t)triggered, "dds_waitset_wait attachment"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(reader, (dds_entity_t)(intptr_t)triggered); } /*************************************************************************************************/ @@ -1000,7 +997,7 @@ Test(ddsc_waitset_triggering, on_reader, .init=ddsc_waitset_attached_init, .fini * *************************************************************************************************/ /*************************************************************************************************/ -Test(ddsc_waitset_triggering, on_readcondition, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) +CU_Test(ddsc_waitset_triggering, on_readcondition, .init=ddsc_waitset_attached_init, .fini=ddsc_waitset_attached_fini) { RoundTripModule_DataType sample; dds_attach_t triggered; @@ -1011,11 +1008,11 @@ Test(ddsc_waitset_triggering, on_readcondition, .init=ddsc_waitset_attached_init /* Make sure that we start un-triggered. */ ret = dds_triggered(readcond); - cr_assert_eq(ret, 0, "dds_triggered: Invalid return code %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, 0); /* Attach condition to the waitset. */ ret = dds_waitset_attach(waitset, readcond, readcond); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_attach(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Start a thread that'll wait because no entity attached to the waitset * has been triggered (for instance by a status change). */ @@ -1023,22 +1020,22 @@ Test(ddsc_waitset_triggering, on_readcondition, .init=ddsc_waitset_attached_init /* Writing data should unblock the thread. */ ret = dds_write(writer, &sample); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_write(): returned %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); ret = waiting_thread_expect_exit(&arg); - cr_assert_eq(ret, DDS_RETCODE_OK, "waiting thread did not unblock"); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); /* Now the trigger state should be true. */ ret = dds_triggered(readcond); - cr_assert_gt(ret, 0, "dds_triggered: Invalid return code %d", dds_err_nr(ret)); + CU_ASSERT(ret > 0); /* Waitset shouldn't wait, but immediately return our reader. */ ret = dds_waitset_wait(waitset, &triggered, 1, DDS_SECS(1)); - cr_assert_eq(ret, 1, "dds_waitset_wait ret"); - cr_assert_eq(readcond, (dds_entity_t)(intptr_t)triggered, "dds_waitset_wait attachment"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(readcond, (dds_entity_t)(intptr_t)triggered); /* Detach condition. */ ret = dds_waitset_detach(waitset, readcond); - cr_assert_eq(ret, DDS_RETCODE_OK, "dds_waitset_attach: Invalid return code %d", dds_err_nr(ret)); + CU_ASSERT_EQUAL_FATAL(ret, DDS_RETCODE_OK); } /*************************************************************************************************/ @@ -1064,8 +1061,8 @@ waiting_thread(void *a) arg->state = WAITING; /* This should block until the main test released all claims. */ ret = dds_waitset_wait(waitset, &triggered, 1, DDS_SECS(1000)); - cr_assert_eq(ret, 1, "dds_waitset_wait returned %d", ret); - cr_assert_eq(arg->expected, (dds_entity_t)(intptr_t)triggered, "dds_waitset_wait attachment"); + CU_ASSERT_EQUAL_FATAL(ret, 1); + CU_ASSERT_EQUAL_FATAL(arg->expected, (dds_entity_t)(intptr_t)triggered); arg->state = STOPPED; return 0; @@ -1097,15 +1094,15 @@ waiting_thread_start(struct thread_arg_t *arg, dds_entity_t expected) arg->state = STARTING; os_threadAttrInit(&thread_attr); osr = os_threadCreate(&thread_id, "waiting_thread", &thread_attr, waiting_thread, arg); - cr_assert_eq(osr, os_resultSuccess, "os_threadCreate"); + CU_ASSERT_EQUAL_FATAL(osr, os_resultSuccess); /* The thread should reach 'waiting' state. */ osr = thread_reached_state(&(arg->state), WAITING, 1000); - cr_assert_eq(osr, os_resultSuccess, "waiting returned %d", osr); + CU_ASSERT_EQUAL_FATAL(osr, os_resultSuccess); /* But thread should block and thus NOT reach 'stopped' state. */ osr = thread_reached_state(&(arg->state), STOPPED, 100); - cr_assert_eq(osr, os_resultTimeout, "waiting returned %d", osr); + CU_ASSERT_EQUAL_FATAL(osr, os_resultTimeout); arg->tid = thread_id; } diff --git a/src/core/ddsc/tests/write.c b/src/core/ddsc/tests/write.c index 24e2412..a67814b 100644 --- a/src/core/ddsc/tests/write.c +++ b/src/core/ddsc/tests/write.c @@ -10,8 +10,8 @@ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ #include -#include -#include +#include "CUnit/Test.h" +#include "CUnit/Theory.h" #include "ddsc/dds.h" #include "RoundTrip.h" #include "Space.h" @@ -32,13 +32,13 @@ static void setup(void) { participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0); + CU_ASSERT_FATAL(participant > 0); topic = dds_create_topic(participant, &RoundTripModule_DataType_desc, "RoundTrip", NULL, NULL); - cr_assert_gt(topic, 0); + CU_ASSERT_FATAL(topic > 0); publisher = dds_create_publisher(participant, NULL, NULL); - cr_assert_gt(publisher, 0); + CU_ASSERT_FATAL(publisher > 0); writer = dds_create_writer(participant, topic, NULL, NULL); - cr_assert_gt(writer, 0); + CU_ASSERT_FATAL(writer > 0); memset(&data, 0, sizeof(data)); data.payload._length = payloadSize; @@ -60,15 +60,15 @@ teardown(void) dds_delete(participant); } -Test(ddsc_write, basic, .init = setup, .fini = teardown) +CU_Test(ddsc_write, basic, .init = setup, .fini = teardown) { dds_return_t status; status = dds_write(writer, &data); - cr_assert_eq(dds_err_nr(status), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK); } -Test(ddsc_write, null_writer, .init = setup, .fini = teardown) +CU_Test(ddsc_write, null_writer, .init = setup, .fini = teardown) { dds_return_t status; @@ -76,29 +76,29 @@ Test(ddsc_write, null_writer, .init = setup, .fini = teardown) OS_WARNING_MSVC_OFF(28020); status = dds_write(0, &data); OS_WARNING_MSVC_ON(28020); - cr_assert_eq(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER); } -Test(ddsc_write, bad_writer, .init = setup, .fini = teardown) +CU_Test(ddsc_write, bad_writer, .init = setup, .fini = teardown) { dds_return_t status; status = dds_write(publisher, &data); - cr_assert_eq(dds_err_nr(status), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_ILLEGAL_OPERATION); } -Test(ddsc_write, closed_writer, .init = setup, .fini = teardown) +CU_Test(ddsc_write, closed_writer, .init = setup, .fini = teardown) { dds_return_t status; status = dds_delete(writer); - cr_assert_eq(dds_err_nr(status), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK); status = dds_write(writer, &data); writer = 0; - cr_assert_eq(dds_err_nr(status), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_ALREADY_DELETED); } -Test(ddsc_write, null_sample, .init = setup, .fini = teardown) +CU_Test(ddsc_write, null_sample, .init = setup, .fini = teardown) { dds_return_t status; @@ -107,26 +107,26 @@ Test(ddsc_write, null_sample, .init = setup, .fini = teardown) status = dds_write(writer, NULL); OS_WARNING_MSVC_ON(6387); - cr_assert_eq(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER); } -Test(ddsc_write_ts, basic, .init = setup, .fini = teardown) +CU_Test(ddsc_write_ts, basic, .init = setup, .fini = teardown) { dds_return_t status; status = dds_write_ts(writer, &data, dds_time()); - cr_assert_eq(dds_err_nr(status), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK); } -Test(ddsc_write_ts, bad_timestamp, .init = setup, .fini = teardown) +CU_Test(ddsc_write_ts, bad_timestamp, .init = setup, .fini = teardown) { dds_return_t status; status = dds_write_ts(writer, &data, -1); - cr_assert_eq(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_BAD_PARAMETER); } -Test(ddsc_write, simpletypes) +CU_Test(ddsc_write, simpletypes) { dds_return_t status; dds_entity_t par, top, wri; @@ -145,14 +145,14 @@ Test(ddsc_write, simpletypes) }; par = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(par, 0); + CU_ASSERT_FATAL(par > 0); top = dds_create_topic(par, &Space_simpletypes_desc, "SimpleTypes", NULL, NULL); - cr_assert_gt(top, 0); + CU_ASSERT_FATAL(top > 0); wri = dds_create_writer(par, top, NULL, NULL); - cr_assert_gt(wri, 0); + CU_ASSERT_FATAL(wri > 0); status = dds_write(wri, &st_data); - cr_assert_eq(dds_err_nr(status), DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(status), DDS_RETCODE_OK); dds_delete(wri); dds_delete(top); diff --git a/src/core/ddsc/tests/writer.c b/src/core/ddsc/tests/writer.c index 068e502..025413a 100644 --- a/src/core/ddsc/tests/writer.c +++ b/src/core/ddsc/tests/writer.c @@ -10,9 +10,7 @@ * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ #include -#include -#include - +#include "CUnit/Test.h" #include "ddsc/dds.h" #include "RoundTrip.h" #include "os/os.h" @@ -26,11 +24,11 @@ static void setup(void) { participant = dds_create_participant(DDS_DOMAIN_DEFAULT, NULL, NULL); - cr_assert_gt(participant, 0); + CU_ASSERT_FATAL(participant > 0); topic = dds_create_topic(participant, &RoundTripModule_DataType_desc, "RoundTrip", NULL, NULL); - cr_assert_gt(topic, 0); + CU_ASSERT_FATAL(topic > 0); publisher = dds_create_publisher(participant, NULL, NULL); - cr_assert_gt(publisher, 0); + CU_ASSERT_FATAL(publisher > 0); } static void @@ -42,69 +40,69 @@ teardown(void) dds_delete(participant); } -Test(ddsc_create_writer, basic, .init = setup, .fini = teardown) +CU_Test(ddsc_create_writer, basic, .init = setup, .fini = teardown) { dds_return_t result; writer = dds_create_writer(participant, topic, NULL, NULL); - cr_assert_gt(writer, 0); + CU_ASSERT_FATAL(writer > 0); result = dds_delete(writer); - cr_assert_eq(result, DDS_RETCODE_OK); + CU_ASSERT_EQUAL_FATAL(result, DDS_RETCODE_OK); } -Test(ddsc_create_writer, null_parent, .init = setup, .fini = teardown) +CU_Test(ddsc_create_writer, null_parent, .init = setup, .fini = teardown) { OS_WARNING_MSVC_OFF(28020); /* Disable SAL warning on intentional misuse of the API */ writer = dds_create_writer(0, topic, NULL, NULL); OS_WARNING_MSVC_ON(28020); - cr_assert_eq(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER); } -Test(ddsc_create_writer, bad_parent, .init = setup, .fini = teardown) +CU_Test(ddsc_create_writer, bad_parent, .init = setup, .fini = teardown) { writer = dds_create_writer(topic, topic, NULL, NULL); - cr_assert_eq(dds_err_nr(writer), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_ILLEGAL_OPERATION); } -Test(ddsc_create_writer, participant, .init = setup, .fini = teardown) +CU_Test(ddsc_create_writer, participant, .init = setup, .fini = teardown) { writer = dds_create_writer(participant, topic, NULL, NULL); - cr_assert_gt(writer, 0); + CU_ASSERT_FATAL(writer > 0); } -Test(ddsc_create_writer, publisher, .init = setup, .fini = teardown) +CU_Test(ddsc_create_writer, publisher, .init = setup, .fini = teardown) { writer = dds_create_writer(publisher, topic, NULL, NULL); - cr_assert_gt(writer, 0); + CU_ASSERT_FATAL(writer > 0); } -Test(ddsc_create_writer, deleted_publisher, .init = setup, .fini = teardown) +CU_Test(ddsc_create_writer, deleted_publisher, .init = setup, .fini = teardown) { dds_delete(publisher); writer = dds_create_writer(publisher, topic, NULL, NULL); - cr_assert_eq(dds_err_nr(writer), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_ALREADY_DELETED); } -Test(ddsc_create_writer, null_topic, .init = setup, .fini = teardown) +CU_Test(ddsc_create_writer, null_topic, .init = setup, .fini = teardown) { OS_WARNING_MSVC_OFF(28020); /* Disable SAL warning on intentional misuse of the API */ writer = dds_create_writer(publisher, 0, NULL, NULL); OS_WARNING_MSVC_ON(28020); - cr_assert_eq(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_BAD_PARAMETER); } -Test(ddsc_create_writer, bad_topic, .init = setup, .fini = teardown) +CU_Test(ddsc_create_writer, bad_topic, .init = setup, .fini = teardown) { writer = dds_create_writer(publisher, publisher, NULL, NULL); - cr_assert_eq(dds_err_nr(writer), DDS_RETCODE_ILLEGAL_OPERATION); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_ILLEGAL_OPERATION); } -Test(ddsc_create_writer, deleted_topic, .init = setup, .fini = teardown) +CU_Test(ddsc_create_writer, deleted_topic, .init = setup, .fini = teardown) { dds_delete(topic); writer = dds_create_writer(publisher, topic, NULL, NULL); - cr_assert_eq(dds_err_nr(writer), DDS_RETCODE_ALREADY_DELETED); + CU_ASSERT_EQUAL_FATAL(dds_err_nr(writer), DDS_RETCODE_ALREADY_DELETED); } diff --git a/src/tools/pubsub/tests/CMakeLists.txt b/src/tools/pubsub/tests/CMakeLists.txt index e3fce1a..4437526 100644 --- a/src/tools/pubsub/tests/CMakeLists.txt +++ b/src/tools/pubsub/tests/CMakeLists.txt @@ -9,6 +9,7 @@ # # SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause # -include(Criterion) -add_criterion_executable(criterion_tools_pubsub . ../common.c ../testtype.c ../porting.c) -target_link_libraries(criterion_tools_pubsub util CycloneDDS::ddsc) +include(CUnit) + +add_cunit_executable(CUnit_tools_pubsub ../common.c ../testtype.c ../porting.c basic.c) +target_link_libraries(CUnit_tools_pubsub util CycloneDDS::ddsc) \ No newline at end of file diff --git a/src/tools/pubsub/tests/basic.c b/src/tools/pubsub/tests/basic.c index 3ead6c4..9e8d440 100644 --- a/src/tools/pubsub/tests/basic.c +++ b/src/tools/pubsub/tests/basic.c @@ -9,20 +9,17 @@ * * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause */ -#include -#include +#include "CUnit/Test.h" #define MAIN test_main #include "../pubsub.c" -Test(tools_pubsub, main) { +CU_Test(tools_pubsub, main) { char *argv[] = {"pubsub", "-T", "pubsubTestTopic", "-K", "KS", "-w1:1", "-D", "1", "-q", "t:d=t,r=r", "pubsub_partition"}; int argc = sizeof(argv) / sizeof(char*); - cr_log_info("Starting pubsub basic test"); int result = MAIN(argc, argv); if (result != 0) printf("exitcode was %d\n", result); - cr_assert_eq(result, 0, "pubsub exited non-zero"); - cr_log_info("Stopping pubsub basic test"); + CU_ASSERT_EQUAL_FATAL(result, 0); } diff --git a/src/util/tests/CMakeLists.txt b/src/util/tests/CMakeLists.txt index 6058c4e..f3e7655 100644 --- a/src/util/tests/CMakeLists.txt +++ b/src/util/tests/CMakeLists.txt @@ -9,6 +9,7 @@ # # SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause # -include(Criterion) -add_criterion_executable(criterion_util .) -target_link_libraries(criterion_util util) +include(CUnit) + +add_cunit_executable(CUnit_util "handleserver.c") +target_link_libraries(CUnit_util util) \ No newline at end of file diff --git a/src/util/tests/handleserver.c b/src/util/tests/handleserver.c index 039b4be..c009c25 100644 --- a/src/util/tests/handleserver.c +++ b/src/util/tests/handleserver.c @@ -11,13 +11,10 @@ */ #include "os/os.h" #include "util/ut_handleserver.h" -#include -#include - -/* Add --verbose command line argument to get the cr_log_info traces (if there are any). */ +#include "CUnit/Test.h" /*****************************************************************************************/ -Test(util_handleserver, basic) +CU_Test(util_handleserver, basic) { const os_time zero = { 0, 0 }; int32_t kind = 0x10000000; @@ -27,29 +24,29 @@ Test(util_handleserver, basic) void *argx; ret = ut_handleserver_init(); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handleserver_init"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); hdl = ut_handle_create(kind, (void*)&arg); - cr_assert(hdl > 0, "ut_handle_create"); + CU_ASSERT_FATAL(hdl > 0); ret = ut_handle_claim(hdl, NULL, kind, &argx); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_claim ret"); - cr_assert_eq(argx, &arg, "ut_handle_claim arg"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); + CU_ASSERT_EQUAL_FATAL(argx, &arg); ut_handle_release(hdl, NULL); ret = ut_handle_delete(hdl, NULL, zero); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_delete"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); ret = ut_handle_claim(hdl, NULL, kind, &argx); - cr_assert_eq(ret, UT_HANDLE_DELETED, "ut_handle_claim ret"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_DELETED); ut_handleserver_fini(); } /*****************************************************************************************/ -Test(util_handleserver, close) +CU_Test(util_handleserver, close) { const os_time zero = { 0, 0 }; int32_t kind = 0x10000000; @@ -60,33 +57,33 @@ Test(util_handleserver, close) bool closed; ret = ut_handleserver_init(); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handleserver_init"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); hdl = ut_handle_create(kind, (void*)&arg); - cr_assert(hdl > 0, "ut_handle_create"); + CU_ASSERT_FATAL(hdl > 0); closed = ut_handle_is_closed(hdl, NULL); - cr_assert_eq(closed, false, "ut_handle_is_closed ret"); + CU_ASSERT_EQUAL_FATAL(closed, false); ut_handle_close(hdl, NULL); closed = ut_handle_is_closed(hdl, NULL); - cr_assert_eq(closed, true, "ut_handle_is_closed ret"); + CU_ASSERT_EQUAL_FATAL(closed, true); ret = ut_handle_claim(hdl, NULL, kind, &argx); - cr_assert_eq(ret, UT_HANDLE_CLOSED, "ut_handle_claim ret"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_CLOSED); ret = ut_handle_delete(hdl, NULL, zero); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_delete"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); ret = ut_handle_claim(hdl, NULL, kind, &argx); - cr_assert_eq(ret, UT_HANDLE_DELETED, "ut_handle_claim ret"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_DELETED); ut_handleserver_fini(); } /*****************************************************************************************/ -Test(util_handleserver, link) +CU_Test(util_handleserver, link) { const os_time zero = { 0, 0 }; int32_t kind = 0x10000000; @@ -97,32 +94,32 @@ Test(util_handleserver, link) void *argx; ret = ut_handleserver_init(); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handleserver_init"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); hdl = ut_handle_create(kind, (void*)&arg); - cr_assert(hdl > 0, "ut_handle_create"); + CU_ASSERT_FATAL(hdl > 0); link = ut_handle_get_link(hdl); - cr_assert_neq(link, NULL, "ut_handle_get_link"); + CU_ASSERT_NOT_EQUAL_FATAL(link, NULL); ret = ut_handle_claim(hdl, link, kind, &argx); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_claim ret"); - cr_assert_eq(argx, &arg, "ut_handle_claim arg"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); + CU_ASSERT_EQUAL_FATAL(argx, &arg); ut_handle_release(hdl, link); ret = ut_handle_delete(hdl, link, zero); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_delete"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); link = ut_handle_get_link(hdl); - cr_assert_eq(link, NULL, "ut_handle_get_link"); + CU_ASSERT_EQUAL_FATAL(link, NULL); ut_handleserver_fini(); } /*****************************************************************************************/ -Test(util_handleserver, types) +CU_Test(util_handleserver, types) { const os_time zero = { 0, 0 }; int32_t kind1 = 0x10000000; @@ -137,55 +134,55 @@ Test(util_handleserver, types) void *argx; ret = ut_handleserver_init(); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handleserver_init"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); hdl1a = ut_handle_create(kind1, (void*)&arg1a); - cr_assert(hdl1a > 0, "ut_handle_create"); + CU_ASSERT_FATAL(hdl1a > 0); hdl1b = ut_handle_create(kind1, (void*)&arg1b); - cr_assert(hdl1b > 0, "ut_handle_create"); + CU_ASSERT_FATAL(hdl1b > 0); hdl2 = ut_handle_create(kind2, (void*)&arg2); - cr_assert(hdl2 > 0, "ut_handle_create"); + CU_ASSERT_FATAL(hdl2 > 0); ret = ut_handle_claim(hdl1a, NULL, kind1, &argx); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_claim ret"); - cr_assert_eq(argx, &arg1a, "ut_handle_claim arg"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); + CU_ASSERT_EQUAL_FATAL(argx, &arg1a); ret = ut_handle_claim(hdl1b, NULL, kind1, &argx); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_claim ret"); - cr_assert_eq(argx, &arg1b, "ut_handle_claim arg"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); + CU_ASSERT_EQUAL_FATAL(argx, &arg1b); ret = ut_handle_claim(hdl2, NULL, kind2, &argx); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_claim ret"); - cr_assert_eq(argx, &arg2, "ut_handle_claim arg"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); + CU_ASSERT_EQUAL_FATAL(argx, &arg2); ret = ut_handle_claim(hdl1a, NULL, kind2, &argx); - cr_assert_eq(ret, UT_HANDLE_UNEQUAL_KIND, "ut_handle_claim ret"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_UNEQUAL_KIND); ret = ut_handle_claim(hdl1a, NULL, kind2, &argx); - cr_assert_eq(ret, UT_HANDLE_UNEQUAL_KIND, "ut_handle_claim ret"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_UNEQUAL_KIND); ret = ut_handle_claim(hdl2, NULL, kind1, &argx); - cr_assert_eq(ret, UT_HANDLE_UNEQUAL_KIND, "ut_handle_claim ret"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_UNEQUAL_KIND); ut_handle_release(hdl1a, NULL); ut_handle_release(hdl1b, NULL); ut_handle_release(hdl2, NULL); ret = ut_handle_delete(hdl1a, NULL, zero); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_delete"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); ret = ut_handle_delete(hdl1b, NULL, zero); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_delete"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); ret = ut_handle_delete(hdl2, NULL, zero); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_delete"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); ut_handleserver_fini(); } /*****************************************************************************************/ -Test(util_handleserver, timeout) +CU_Test(util_handleserver, timeout) { const os_time zero = { 0, 0 }; int32_t kind = 0x10000000; @@ -195,22 +192,22 @@ Test(util_handleserver, timeout) void *argx; ret = ut_handleserver_init(); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handleserver_init"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); hdl = ut_handle_create(kind, (void*)&arg); - cr_assert(hdl > 0, "ut_handle_create"); + CU_ASSERT_FATAL(hdl > 0); ret = ut_handle_claim(hdl, NULL, kind, &argx); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_claim ret"); - cr_assert_eq(argx, &arg, "ut_handle_claim arg"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); + CU_ASSERT_EQUAL_FATAL(argx, &arg); ret = ut_handle_delete(hdl, NULL, zero); - cr_assert_eq(ret, UT_HANDLE_TIMEOUT, "ut_handle_delete"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_TIMEOUT); ut_handle_release(hdl, NULL); ret = ut_handle_delete(hdl, NULL, zero); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_delete"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); ut_handleserver_fini(); } @@ -238,7 +235,7 @@ deleting_thread(void *a) arg->state = DELETING; /* This should block until the main test released all claims. */ ret = ut_handle_delete(arg->hdl, NULL, ten); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_delete ret"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); arg->state = STOPPED; return 0; @@ -256,7 +253,7 @@ thread_reached_state(thread_state_t *actual, thread_state_t expected, int32_t ms return (*actual == expected) ? os_resultSuccess : os_resultTimeout; } -Test(util_handleserver, wakeup) +CU_Test(util_handleserver, wakeup) { int32_t kind = 0x10000000; ut_handle_retcode_t ret; @@ -270,37 +267,37 @@ Test(util_handleserver, wakeup) os_result osr; ret = ut_handleserver_init(); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handleserver_init"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); hdl = ut_handle_create(kind, (void*)&arg); - cr_assert(hdl > 0, "ut_handle_create"); + CU_ASSERT_FATAL(hdl > 0); ret = ut_handle_claim(hdl, NULL, kind, &argx); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_claim1 ret"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); ret = ut_handle_claim(hdl, NULL, kind, &argx); - cr_assert_eq(ret, UT_HANDLE_OK, "ut_handle_claim2 ret"); + CU_ASSERT_EQUAL_FATAL(ret, UT_HANDLE_OK); /* Try deleting in other thread, which should block. */ thread_arg.hdl = hdl; thread_arg.state = STARTING; os_threadAttrInit(&thread_attr); osr = os_threadCreate(&thread_id, "deleting_thread", &thread_attr, deleting_thread, (void*)&thread_arg); - cr_assert_eq(osr, os_resultSuccess, "os_threadCreate"); + CU_ASSERT_EQUAL_FATAL(osr, os_resultSuccess); osr = thread_reached_state(&thread_arg.state, DELETING, 1000); - cr_assert_eq(osr, os_resultSuccess, "deleting"); + CU_ASSERT_EQUAL_FATAL(osr, os_resultSuccess); osr = thread_reached_state(&thread_arg.state, STOPPED, 500); - cr_assert_eq(osr, os_resultTimeout, "deleting"); + CU_ASSERT_EQUAL_FATAL(osr, os_resultTimeout); /* First release of the hdl should not unblock the thread. */ ut_handle_release(hdl, NULL); osr = thread_reached_state(&thread_arg.state, STOPPED, 500); - cr_assert_eq(osr, os_resultTimeout, "deleting"); + CU_ASSERT_EQUAL_FATAL(osr, os_resultTimeout); /* Second release of the hdl should unblock the thread. */ ut_handle_release(hdl, NULL); osr = thread_reached_state(&thread_arg.state, STOPPED, 500); - cr_assert_eq(osr, os_resultSuccess, "deleting"); + CU_ASSERT_EQUAL_FATAL(osr, os_resultSuccess); os_threadWaitExit(thread_id, NULL); /* The handle is deleted within the thread. */ diff --git a/src/valgrind.supp b/src/valgrind.supp deleted file mode 100644 index 4d477aa..0000000 --- a/src/valgrind.supp +++ /dev/null @@ -1,10 +0,0 @@ -{ - Criterion memory leak - Memcheck:Leak - match-leak-kinds: reachable - fun:malloc - fun:__fopen_internal - fun:process_all_output - fun:criterion_run_all_tests - fun:main -}