cmocka: Remove deprecated functions and cmockery legacy support
This commit is contained in:
parent
ae89bfa145
commit
1003e76472
|
@ -1,5 +1,4 @@
|
|||
option(BUILD_SHARED_LIBS "Build shared libraries" ON)
|
||||
option(WITH_CMOCKERY_SUPPORT "Install a cmockery header" OFF)
|
||||
option(WITH_EXAMPLES "Build examples" ON)
|
||||
option(UNIT_TESTING "Build with unit testing" OFF)
|
||||
option(PICKY_DEVELOPER "Build with picky developer flags" OFF)
|
||||
|
|
|
@ -7,13 +7,3 @@ install(FILES
|
|||
${CMAKE_INSTALL_INCLUDEDIR}
|
||||
COMPONENT
|
||||
${PROJECT_NAME})
|
||||
|
||||
if (WITH_CMOCKERY_SUPPORT)
|
||||
install(FILES
|
||||
cmockery/cmockery.h
|
||||
cmockery/pbc.h
|
||||
DESTINATION
|
||||
${CMAKE_INSTALL_INCLUDEDIR}/cmockery
|
||||
COMPONENT
|
||||
${PROJECT_NAME})
|
||||
endif()
|
||||
|
|
|
@ -1621,31 +1621,6 @@ void fail_msg(const char *msg, ...);
|
|||
} while (0)
|
||||
#endif
|
||||
|
||||
#ifdef DOXYGEN
|
||||
/**
|
||||
* @brief Generic method to run a single test.
|
||||
*
|
||||
* @deprecated This function was deprecated in favor of cmocka_run_group_tests
|
||||
*
|
||||
* @param[in] #function The function to test.
|
||||
*
|
||||
* @return 0 on success, 1 if an error occured.
|
||||
*
|
||||
* @code
|
||||
* // A test case that does nothing and succeeds.
|
||||
* void null_test_success(void **state) {
|
||||
* }
|
||||
*
|
||||
* int main(void) {
|
||||
* return run_test(null_test_success);
|
||||
* }
|
||||
* @endcode
|
||||
*/
|
||||
int run_test(#function);
|
||||
#else
|
||||
#define run_test(f) _run_test(#f, f, NULL, UNIT_TEST_FUNCTION_TYPE_TEST, NULL)
|
||||
#endif
|
||||
|
||||
static inline void _unit_test_dummy(void **state) {
|
||||
(void)state;
|
||||
}
|
||||
|
@ -1740,9 +1715,6 @@ static inline void _unit_test_dummy(void **state) {
|
|||
*/
|
||||
#define cmocka_unit_test_prestate_setup_teardown(f, setup, teardown, state) { #f, f, setup, teardown, state }
|
||||
|
||||
#define run_tests(tests) _run_tests(tests, sizeof(tests) / sizeof((tests)[0]))
|
||||
#define run_group_tests(tests) _run_group_tests(tests, sizeof(tests) / sizeof((tests)[0]))
|
||||
|
||||
#ifdef DOXYGEN
|
||||
/**
|
||||
* @brief Run tests specified by an array of CMUnitTest structures.
|
||||
|
@ -2291,15 +2263,6 @@ CMOCKA_NORETURN void _fail(const char * const file, const int line);
|
|||
|
||||
CMOCKA_NORETURN void _skip(const char * const file, const int line);
|
||||
|
||||
int _run_test(
|
||||
const char * const function_name, const UnitTestFunction Function,
|
||||
void ** const volatile state, const UnitTestFunctionType function_type,
|
||||
const void* const heap_check_point);
|
||||
CMOCKA_DEPRECATED int _run_tests(const UnitTest * const tests,
|
||||
const size_t number_of_tests);
|
||||
CMOCKA_DEPRECATED int _run_group_tests(const UnitTest * const tests,
|
||||
const size_t number_of_tests);
|
||||
|
||||
/* Test runner */
|
||||
int _cmocka_run_group_tests(const char *group_name,
|
||||
const struct CMUnitTest * const tests,
|
||||
|
|
|
@ -1 +0,0 @@
|
|||
#include <cmocka.h>
|
|
@ -1 +0,0 @@
|
|||
#include <cmocka_pbc.h>
|
391
src/cmocka.c
391
src/cmocka.c
|
@ -3274,394 +3274,3 @@ int _cmocka_run_group_tests(const char *group_name,
|
|||
|
||||
return (int)(total_failed + total_errors);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* DEPRECATED TEST RUNNER
|
||||
****************************************************************************/
|
||||
|
||||
int _run_test(
|
||||
const char * const function_name, const UnitTestFunction Function,
|
||||
void ** const volatile state, const UnitTestFunctionType function_type,
|
||||
const void* const heap_check_point) {
|
||||
const ListNode * const volatile check_point = (const ListNode*)
|
||||
(heap_check_point ?
|
||||
heap_check_point : check_point_allocated_blocks());
|
||||
void *current_state = NULL;
|
||||
volatile int rc = 1;
|
||||
int handle_exceptions = 1;
|
||||
#ifdef _WIN32
|
||||
handle_exceptions = !IsDebuggerPresent();
|
||||
#endif /* _WIN32 */
|
||||
#ifdef UNIT_TESTING_DEBUG
|
||||
handle_exceptions = 0;
|
||||
#endif /* UNIT_TESTING_DEBUG */
|
||||
|
||||
cm_error_message_enabled = 0;
|
||||
|
||||
if (handle_exceptions) {
|
||||
#ifndef _WIN32
|
||||
unsigned int i;
|
||||
for (i = 0; i < ARRAY_SIZE(exception_signals); i++) {
|
||||
default_signal_functions[i] = signal(
|
||||
exception_signals[i], exception_handler);
|
||||
}
|
||||
#else /* _WIN32 */
|
||||
previous_exception_filter = SetUnhandledExceptionFilter(
|
||||
exception_filter);
|
||||
#endif /* !_WIN32 */
|
||||
}
|
||||
|
||||
if (function_type == UNIT_TEST_FUNCTION_TYPE_TEST) {
|
||||
print_message("[ RUN ] %s\n", function_name);
|
||||
}
|
||||
initialize_testing(function_name);
|
||||
global_running_test = 1;
|
||||
if (cm_setjmp(global_run_test_env) == 0) {
|
||||
Function(state ? state : ¤t_state);
|
||||
fail_if_leftover_values(function_name);
|
||||
|
||||
/* If this is a setup function then ignore any allocated blocks
|
||||
* only ensure they're deallocated on tear down. */
|
||||
if (function_type != UNIT_TEST_FUNCTION_TYPE_SETUP) {
|
||||
fail_if_blocks_allocated(check_point, function_name);
|
||||
}
|
||||
|
||||
global_running_test = 0;
|
||||
|
||||
if (function_type == UNIT_TEST_FUNCTION_TYPE_TEST) {
|
||||
print_message("[ OK ] %s\n", function_name);
|
||||
}
|
||||
rc = 0;
|
||||
} else {
|
||||
global_running_test = 0;
|
||||
print_message("[ FAILED ] %s\n", function_name);
|
||||
}
|
||||
teardown_testing(function_name);
|
||||
|
||||
if (handle_exceptions) {
|
||||
#ifndef _WIN32
|
||||
unsigned int i;
|
||||
for (i = 0; i < ARRAY_SIZE(exception_signals); i++) {
|
||||
signal(exception_signals[i], default_signal_functions[i]);
|
||||
}
|
||||
#else /* _WIN32 */
|
||||
if (previous_exception_filter) {
|
||||
SetUnhandledExceptionFilter(previous_exception_filter);
|
||||
previous_exception_filter = NULL;
|
||||
}
|
||||
#endif /* !_WIN32 */
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
|
||||
int _run_tests(const UnitTest * const tests, const size_t number_of_tests) {
|
||||
/* Whether to execute the next test. */
|
||||
int run_next_test = 1;
|
||||
/* Whether the previous test failed. */
|
||||
int previous_test_failed = 0;
|
||||
/* Whether the previous setup failed. */
|
||||
int previous_setup_failed = 0;
|
||||
/* Check point of the heap state. */
|
||||
const ListNode * const check_point = check_point_allocated_blocks();
|
||||
/* Current test being executed. */
|
||||
size_t current_test = 0;
|
||||
/* Number of tests executed. */
|
||||
size_t tests_executed = 0;
|
||||
/* Number of failed tests. */
|
||||
size_t total_failed = 0;
|
||||
/* Number of setup functions. */
|
||||
size_t setups = 0;
|
||||
/* Number of teardown functions. */
|
||||
size_t teardowns = 0;
|
||||
size_t i;
|
||||
/*
|
||||
* A stack of test states. A state is pushed on the stack
|
||||
* when a test setup occurs and popped on tear down.
|
||||
*/
|
||||
TestState* test_states =
|
||||
(TestState*)malloc(number_of_tests * sizeof(*test_states));
|
||||
/* The number of test states which should be 0 at the end */
|
||||
long number_of_test_states = 0;
|
||||
/* Names of the tests that failed. */
|
||||
const char** failed_names = (const char**)malloc(number_of_tests *
|
||||
sizeof(*failed_names));
|
||||
void **current_state = NULL;
|
||||
|
||||
/* Count setup and teardown functions */
|
||||
for (i = 0; i < number_of_tests; i++) {
|
||||
const UnitTest * const test = &tests[i];
|
||||
|
||||
if (test->function_type == UNIT_TEST_FUNCTION_TYPE_SETUP) {
|
||||
setups++;
|
||||
}
|
||||
|
||||
if (test->function_type == UNIT_TEST_FUNCTION_TYPE_TEARDOWN) {
|
||||
teardowns++;
|
||||
}
|
||||
}
|
||||
|
||||
print_message("[==========] Running %"PRIdS " test(s).\n",
|
||||
number_of_tests - setups - teardowns);
|
||||
|
||||
/* Make sure uintmax_t is at least the size of a pointer. */
|
||||
assert_true(sizeof(uintmax_t) >= sizeof(void*));
|
||||
|
||||
while (current_test < number_of_tests) {
|
||||
const ListNode *test_check_point = NULL;
|
||||
TestState *current_TestState;
|
||||
const UnitTest * const test = &tests[current_test++];
|
||||
if (!test->function) {
|
||||
continue;
|
||||
}
|
||||
|
||||
switch (test->function_type) {
|
||||
case UNIT_TEST_FUNCTION_TYPE_TEST:
|
||||
if (! previous_setup_failed) {
|
||||
run_next_test = 1;
|
||||
}
|
||||
break;
|
||||
case UNIT_TEST_FUNCTION_TYPE_SETUP: {
|
||||
/* Checkpoint the heap before the setup. */
|
||||
current_TestState = &test_states[number_of_test_states++];
|
||||
current_TestState->check_point = check_point_allocated_blocks();
|
||||
test_check_point = current_TestState->check_point;
|
||||
current_state = ¤t_TestState->state;
|
||||
*current_state = NULL;
|
||||
run_next_test = 1;
|
||||
break;
|
||||
}
|
||||
case UNIT_TEST_FUNCTION_TYPE_TEARDOWN:
|
||||
/* Check the heap based on the last setup checkpoint. */
|
||||
assert_true(number_of_test_states);
|
||||
current_TestState = &test_states[--number_of_test_states];
|
||||
test_check_point = current_TestState->check_point;
|
||||
current_state = ¤t_TestState->state;
|
||||
break;
|
||||
default:
|
||||
print_error("Invalid unit test function type %d\n",
|
||||
test->function_type);
|
||||
exit_test(1);
|
||||
break;
|
||||
}
|
||||
|
||||
if (run_next_test) {
|
||||
int failed = _run_test(test->name, test->function, current_state,
|
||||
test->function_type, test_check_point);
|
||||
if (failed) {
|
||||
failed_names[total_failed] = test->name;
|
||||
}
|
||||
|
||||
switch (test->function_type) {
|
||||
case UNIT_TEST_FUNCTION_TYPE_TEST:
|
||||
previous_test_failed = failed;
|
||||
total_failed += failed;
|
||||
tests_executed ++;
|
||||
break;
|
||||
|
||||
case UNIT_TEST_FUNCTION_TYPE_SETUP:
|
||||
if (failed) {
|
||||
total_failed ++;
|
||||
tests_executed ++;
|
||||
/* Skip forward until the next test or setup function. */
|
||||
run_next_test = 0;
|
||||
previous_setup_failed = 1;
|
||||
}
|
||||
previous_test_failed = 0;
|
||||
break;
|
||||
|
||||
case UNIT_TEST_FUNCTION_TYPE_TEARDOWN:
|
||||
/* If this test failed. */
|
||||
if (failed && !previous_test_failed) {
|
||||
total_failed ++;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
#ifndef _HPUX
|
||||
assert_null("BUG: shouldn't be here!");
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
print_message("[==========] %"PRIdS " test(s) run.\n", tests_executed);
|
||||
print_error("[ PASSED ] %"PRIdS " test(s).\n", tests_executed - total_failed);
|
||||
|
||||
if (total_failed > 0) {
|
||||
print_error("[ FAILED ] %"PRIdS " test(s), listed below:\n", total_failed);
|
||||
for (i = 0; i < total_failed; i++) {
|
||||
print_error("[ FAILED ] %s\n", failed_names[i]);
|
||||
}
|
||||
} else {
|
||||
print_error("\n %"PRIdS " FAILED TEST(S)\n", total_failed);
|
||||
}
|
||||
|
||||
if (number_of_test_states != 0) {
|
||||
print_error("[ ERROR ] Mismatched number of setup %"PRIdS " and "
|
||||
"teardown %"PRIdS " functions\n", setups, teardowns);
|
||||
total_failed = (size_t)-1;
|
||||
}
|
||||
|
||||
free(test_states);
|
||||
free((void*)failed_names);
|
||||
|
||||
fail_if_blocks_allocated(check_point, "run_tests");
|
||||
return (int)total_failed;
|
||||
}
|
||||
|
||||
int _run_group_tests(const UnitTest * const tests, const size_t number_of_tests)
|
||||
{
|
||||
UnitTestFunction setup = NULL;
|
||||
const char *setup_name = NULL;
|
||||
size_t num_setups = 0;
|
||||
UnitTestFunction teardown = NULL;
|
||||
const char *teardown_name = NULL;
|
||||
size_t num_teardowns = 0;
|
||||
size_t current_test = 0;
|
||||
size_t i;
|
||||
|
||||
/* Number of tests executed. */
|
||||
size_t tests_executed = 0;
|
||||
/* Number of failed tests. */
|
||||
size_t total_failed = 0;
|
||||
/* Check point of the heap state. */
|
||||
const ListNode * const check_point = check_point_allocated_blocks();
|
||||
const char **failed_names = NULL;
|
||||
void **current_state = NULL;
|
||||
TestState group_state = {
|
||||
.check_point = NULL,
|
||||
};
|
||||
|
||||
if (number_of_tests == 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
failed_names = (const char **)malloc(number_of_tests *
|
||||
sizeof(*failed_names));
|
||||
if (failed_names == NULL) {
|
||||
return -2;
|
||||
}
|
||||
|
||||
/* Find setup and teardown function */
|
||||
for (i = 0; i < number_of_tests; i++) {
|
||||
const UnitTest * const test = &tests[i];
|
||||
|
||||
if (test->function_type == UNIT_TEST_FUNCTION_TYPE_GROUP_SETUP) {
|
||||
if (setup == NULL) {
|
||||
setup = test->function;
|
||||
setup_name = test->name;
|
||||
num_setups = 1;
|
||||
} else {
|
||||
print_error("[ ERROR ] More than one group setup function detected\n");
|
||||
exit_test(1);
|
||||
}
|
||||
}
|
||||
|
||||
if (test->function_type == UNIT_TEST_FUNCTION_TYPE_GROUP_TEARDOWN) {
|
||||
if (teardown == NULL) {
|
||||
teardown = test->function;
|
||||
teardown_name = test->name;
|
||||
num_teardowns = 1;
|
||||
} else {
|
||||
print_error("[ ERROR ] More than one group teardown function detected\n");
|
||||
exit_test(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
print_message("[==========] Running %"PRIdS " test(s).\n",
|
||||
number_of_tests - num_setups - num_teardowns);
|
||||
|
||||
if (setup != NULL) {
|
||||
int failed;
|
||||
|
||||
group_state.check_point = check_point_allocated_blocks();
|
||||
current_state = &group_state.state;
|
||||
*current_state = NULL;
|
||||
failed = _run_test(setup_name,
|
||||
setup,
|
||||
current_state,
|
||||
UNIT_TEST_FUNCTION_TYPE_SETUP,
|
||||
group_state.check_point);
|
||||
if (failed) {
|
||||
failed_names[total_failed] = setup_name;
|
||||
}
|
||||
|
||||
total_failed += failed;
|
||||
tests_executed++;
|
||||
}
|
||||
|
||||
while (current_test < number_of_tests) {
|
||||
int run_test = 0;
|
||||
const UnitTest * const test = &tests[current_test++];
|
||||
if (test->function == NULL) {
|
||||
continue;
|
||||
}
|
||||
|
||||
switch (test->function_type) {
|
||||
case UNIT_TEST_FUNCTION_TYPE_TEST:
|
||||
run_test = 1;
|
||||
break;
|
||||
case UNIT_TEST_FUNCTION_TYPE_SETUP:
|
||||
case UNIT_TEST_FUNCTION_TYPE_TEARDOWN:
|
||||
case UNIT_TEST_FUNCTION_TYPE_GROUP_SETUP:
|
||||
case UNIT_TEST_FUNCTION_TYPE_GROUP_TEARDOWN:
|
||||
break;
|
||||
default:
|
||||
print_error("Invalid unit test function type %d\n",
|
||||
test->function_type);
|
||||
break;
|
||||
}
|
||||
|
||||
if (run_test) {
|
||||
int failed;
|
||||
|
||||
failed = _run_test(test->name,
|
||||
test->function,
|
||||
current_state,
|
||||
test->function_type,
|
||||
NULL);
|
||||
if (failed) {
|
||||
failed_names[total_failed] = test->name;
|
||||
}
|
||||
|
||||
total_failed += failed;
|
||||
tests_executed++;
|
||||
}
|
||||
}
|
||||
|
||||
if (teardown != NULL) {
|
||||
int failed;
|
||||
|
||||
failed = _run_test(teardown_name,
|
||||
teardown,
|
||||
current_state,
|
||||
UNIT_TEST_FUNCTION_TYPE_GROUP_TEARDOWN,
|
||||
group_state.check_point);
|
||||
if (failed) {
|
||||
failed_names[total_failed] = teardown_name;
|
||||
}
|
||||
|
||||
total_failed += failed;
|
||||
tests_executed++;
|
||||
}
|
||||
|
||||
print_message("[==========] %"PRIdS " test(s) run.\n", tests_executed);
|
||||
print_error("[ PASSED ] %"PRIdS " test(s).\n", tests_executed - total_failed);
|
||||
|
||||
if (total_failed) {
|
||||
print_error("[ FAILED ] %"PRIdS " test(s), listed below:\n", total_failed);
|
||||
for (i = 0; i < total_failed; i++) {
|
||||
print_error("[ FAILED ] %s\n", failed_names[i]);
|
||||
}
|
||||
} else {
|
||||
print_error("\n %"PRIdS " FAILED TEST(S)\n", total_failed);
|
||||
}
|
||||
|
||||
free((void*)failed_names);
|
||||
fail_if_blocks_allocated(check_point, "run_group_tests");
|
||||
|
||||
return (int)total_failed;
|
||||
}
|
||||
|
|
|
@ -34,8 +34,6 @@ EXPORTS
|
|||
_fail
|
||||
_function_called
|
||||
_mock
|
||||
_run_test
|
||||
_run_tests
|
||||
_skip
|
||||
_test_calloc
|
||||
_test_free
|
||||
|
|
|
@ -30,7 +30,6 @@ set(CMOCKA_TESTS
|
|||
test_string
|
||||
test_wildcard
|
||||
test_skip_filter
|
||||
test_cmockery
|
||||
)
|
||||
|
||||
if (TEST_EXCEPTION_HANDLER)
|
||||
|
@ -48,11 +47,6 @@ foreach(_CMOCKA_TEST ${CMOCKA_TESTS})
|
|||
add_cmocka_test_environment(${_CMOCKA_TEST})
|
||||
endforeach()
|
||||
|
||||
### Special Cases
|
||||
if (${CMAKE_C_COMPILER_ID} MATCHES "(GNU|Clang)")
|
||||
set_source_files_properties(test_cmockery.c PROPERTIES COMPILE_FLAGS "-Wno-deprecated-declarations")
|
||||
endif()
|
||||
|
||||
### Exceptions
|
||||
|
||||
# test_skip
|
||||
|
|
|
@ -155,7 +155,6 @@ endif()
|
|||
### Add project default build options here !!!
|
||||
|
||||
add_cmake_cache_entry(UNIT_TESTING ON)
|
||||
add_cmake_cache_entry(WITH_CMOCKERY_SUPPORT ON)
|
||||
|
||||
### Add project default build options here ^^^
|
||||
|
||||
|
|
|
@ -13,7 +13,7 @@ set(CTEST_CMAKE_GENERATOR "Unix Makefiles")
|
|||
set(CTEST_BUILD_CONFIGURATION "Debug")
|
||||
|
||||
## The build options for the project
|
||||
set(CTEST_BUILD_OPTIONS "-DUNIT_TESTING=ON -DWITH_CMOCKERY_SUPPORT=ON")
|
||||
set(CTEST_BUILD_OPTIONS "-DUNIT_TESTING=ON)
|
||||
|
||||
#set(CTEST_CUSTOM_MEMCHECK_IGNORE torture_rand)
|
||||
|
||||
|
|
|
@ -18,7 +18,6 @@ tests = {
|
|||
'returns_fail': true,
|
||||
'wildcard': false,
|
||||
'skip_filter': false,
|
||||
'cmockery': false
|
||||
}
|
||||
|
||||
foreach name, should_fail: tests
|
||||
|
|
|
@ -1,33 +0,0 @@
|
|||
/*
|
||||
* Copyright 2008 Google Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stddef.h>
|
||||
#include <setjmp.h>
|
||||
#include <stdint.h>
|
||||
#include <cmockery/cmockery.h>
|
||||
|
||||
/* A test case that does nothing and succeeds. */
|
||||
static void null_test_success(void **state) {
|
||||
(void) state; /* unused */
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
const UnitTest tests[] = {
|
||||
unit_test(null_test_success),
|
||||
};
|
||||
return run_tests(tests);
|
||||
}
|
Loading…
Reference in New Issue