ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Update all instances of status_t in the unit tests to fully namespace them 

to utest::v1::status_t .
Anna Bridge 2016-05-27 11:59:25 +01:00
parent c71e81b371
commit 635afa58fc
13 changed files with 53 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
frameworks/utest/TESTS/unit_tests/basic_test/main.cpp
View File

@ -12,10 +12,10 @@ void test_simple() {
printf("Simple test called\n"); printf("Simple test called\n");
} }
status_t test_repeats_setup(const Case *const source, const size_t index_of_case) { utest::v1::status_t test_repeats_setup(const Case *const source, const size_t index_of_case) {
UTEST_LOG_FUNCTION(); UTEST_LOG_FUNCTION();
// Call the default handler for proper reporting // Call the default handler for proper reporting
status_t status = greentea_case_setup_handler(source, index_of_case); utest::v1::status_t status = greentea_case_setup_handler(source, index_of_case);
printf("Setting up for '%s'\n", source->get_description()); printf("Setting up for '%s'\n", source->get_description());
return status; return status;
} }
@ -28,7 +28,7 @@ control_t test_repeats(const size_t call_count) {
} }
// Custom setup handler required for proper Greentea support // Custom setup handler required for proper Greentea support
status_t greentea_setup(const size_t number_of_cases) { utest::v1::status_t greentea_setup(const size_t number_of_cases) {
UTEST_LOG_FUNCTION(); UTEST_LOG_FUNCTION();
GREENTEA_SETUP(20, "default_auto"); GREENTEA_SETUP(20, "default_auto");
// Call the default reporting function // Call the default reporting function

12
frameworks/utest/TESTS/unit_tests/case_async_validate/main.cpp
View File

@ -72,7 +72,7 @@ control_t multiple_validation_case()
return CaseAwait; return CaseAwait;
} }
status_t multiple_validation_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t multiple_validation_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(1, passed); TEST_ASSERT_EQUAL(1, passed);
TEST_ASSERT_EQUAL(0, failed); TEST_ASSERT_EQUAL(0, failed);
@ -96,7 +96,7 @@ control_t premature_validation_case()
return CaseAwait; return CaseAwait;
} }
status_t premature_validation_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t premature_validation_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(1, passed); TEST_ASSERT_EQUAL(1, passed);
TEST_ASSERT_EQUAL(0, failed); TEST_ASSERT_EQUAL(0, failed);
@ -121,7 +121,7 @@ control_t multiple_premature_validation_case()
return CaseAwait; return CaseAwait;
} }
status_t multiple_premature_validation_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t multiple_premature_validation_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(1, passed); TEST_ASSERT_EQUAL(1, passed);
TEST_ASSERT_EQUAL(0, failed); TEST_ASSERT_EQUAL(0, failed);
@ -150,7 +150,7 @@ control_t attributed_validation_cancel_repeat_case()
return CaseRepeatAll + CaseAwait; return CaseRepeatAll + CaseAwait;
} }
status_t attributed_validation_cancel_repeat_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t attributed_validation_cancel_repeat_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(1, passed); TEST_ASSERT_EQUAL(1, passed);
TEST_ASSERT_EQUAL(0, failed); TEST_ASSERT_EQUAL(0, failed);
@ -186,7 +186,7 @@ control_t attributed_validation_enable_repeat_case(const size_t call_count)
return CaseNext; return CaseNext;
} }
status_t attributed_validation_enable_repeat_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t attributed_validation_enable_repeat_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(2, passed); TEST_ASSERT_EQUAL(2, passed);
TEST_ASSERT_EQUAL(0, failed); TEST_ASSERT_EQUAL(0, failed);
@ -206,7 +206,7 @@ Case cases[] = {
Case("Validate: Attributed Validation: Enable Repeat Handler", attributed_validation_enable_repeat_case, attributed_validation_enable_repeat_case_teardown) Case("Validate: Attributed Validation: Enable Repeat Handler", attributed_validation_enable_repeat_case, attributed_validation_enable_repeat_case_teardown)
}; };
status_t greentea_setup(const size_t number_of_cases) utest::v1::status_t greentea_setup(const size_t number_of_cases)
{ {
GREENTEA_SETUP(15, "default_auto"); GREENTEA_SETUP(15, "default_auto");

16
frameworks/utest/TESTS/unit_tests/case_control_async/main.cpp
View File

@ -65,7 +65,7 @@ control_t timeout_failure_case(const size_t call_count)
TEST_ASSERT_EQUAL(0, call_counter++); TEST_ASSERT_EQUAL(0, call_counter++);
return CaseTimeout(100); return CaseTimeout(100);
} }
status_t timeout_failure_case_failure_handler(const Case *const source, const failure_t failure) utest::v1::status_t timeout_failure_case_failure_handler(const Case *const source, const failure_t failure)
{ {
UTEST_LOG_FUNCTION(); UTEST_LOG_FUNCTION();
TEST_ASSERT_EQUAL(1, call_counter++); TEST_ASSERT_EQUAL(1, call_counter++);
@ -74,7 +74,7 @@ status_t timeout_failure_case_failure_handler(const Case *const source, const fa
verbose_case_failure_handler(source, failure); verbose_case_failure_handler(source, failure);
return STATUS_CONTINUE; return STATUS_CONTINUE;
} }
status_t timeout_failure_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t timeout_failure_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
UTEST_LOG_FUNCTION(); UTEST_LOG_FUNCTION();
TEST_ASSERT_EQUAL(2, call_counter++); TEST_ASSERT_EQUAL(2, call_counter++);
@ -101,7 +101,7 @@ control_t timeout_success_case(const size_t call_count)
return CaseTimeout(200); return CaseTimeout(200);
} }
status_t timeout_success_case_failure_handler(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t timeout_success_case_failure_handler(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
UTEST_LOG_FUNCTION(); UTEST_LOG_FUNCTION();
TEST_ASSERT_EQUAL(5, call_counter++); TEST_ASSERT_EQUAL(5, call_counter++);
@ -126,7 +126,7 @@ control_t await_case(const size_t call_count)
// Control: RepeatAllOnTimeout ---------------------------------------------------------------------------------------- // Control: RepeatAllOnTimeout ----------------------------------------------------------------------------------------
bool repeat_all_start_flag = true; bool repeat_all_start_flag = true;
status_t repeat_all_on_timeout_case_setup(const Case *const source, const size_t index_of_case) utest::v1::status_t repeat_all_on_timeout_case_setup(const Case *const source, const size_t index_of_case)
{ {
if (repeat_all_start_flag){ if (repeat_all_start_flag){
UTEST_TRACE_START UTEST_TRACE_START
@ -153,7 +153,7 @@ control_t repeat_all_on_timeout_case(const size_t call_count)
} }
return CaseRepeatAllOnTimeout(100); return CaseRepeatAllOnTimeout(100);
} }
status_t repeat_all_on_timeout_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t repeat_all_on_timeout_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
UTEST_LOG_FUNCTION(); UTEST_LOG_FUNCTION();
static int repeat_counter(0); static int repeat_counter(0);
@ -169,7 +169,7 @@ status_t repeat_all_on_timeout_case_teardown(const Case *const source, const siz
} }
// Control: RepeatAllOnTimeout ---------------------------------------------------------------------------------------- // Control: RepeatAllOnTimeout ----------------------------------------------------------------------------------------
status_t repeat_handler_on_timeout_case_setup(const Case *const source, const size_t index_of_case) utest::v1::status_t repeat_handler_on_timeout_case_setup(const Case *const source, const size_t index_of_case)
{ {
UTEST_LOG_FUNCTION(); UTEST_LOG_FUNCTION();
TEST_ASSERT_EQUAL(4, index_of_case); TEST_ASSERT_EQUAL(4, index_of_case);
@ -191,7 +191,7 @@ control_t repeat_handler_on_timeout_case(const size_t call_count)
} }
return CaseRepeatHandlerOnTimeout(100); return CaseRepeatHandlerOnTimeout(100);
} }
status_t repeat_handler_on_timeout_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t repeat_handler_on_timeout_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
UTEST_LOG_FUNCTION(); UTEST_LOG_FUNCTION();
TEST_ASSERT_EQUAL(1, passed); TEST_ASSERT_EQUAL(1, passed);
@ -232,7 +232,7 @@ Case cases[] = {
}; };
// Specification: Setup & Teardown ------------------------------------------------------------------------------------ // Specification: Setup & Teardown ------------------------------------------------------------------------------------
status_t greentea_setup(const size_t number_of_cases) utest::v1::status_t greentea_setup(const size_t number_of_cases)
{ {
GREENTEA_SETUP(15, "default_auto"); GREENTEA_SETUP(15, "default_auto");

10
frameworks/utest/TESTS/unit_tests/case_control_repeat/main.cpp
View File

@ -24,7 +24,7 @@ using namespace utest::v1;
static int call_counter(0); static int call_counter(0);
// Control: RepeatAll ------------------------------------------------------------------------------------------------- // Control: RepeatAll -------------------------------------------------------------------------------------------------
status_t repeat_all_case_setup(const Case *const source, const size_t index_of_case) utest::v1::status_t repeat_all_case_setup(const Case *const source, const size_t index_of_case)
{ {
static int repeat_counter(0); static int repeat_counter(0);
TEST_ASSERT_EQUAL(0, index_of_case); TEST_ASSERT_EQUAL(0, index_of_case);
@ -40,7 +40,7 @@ control_t repeat_all_case(const size_t call_count)
TEST_ASSERT_EQUAL((call_count-1)*3 + 1, call_counter++); TEST_ASSERT_EQUAL((call_count-1)*3 + 1, call_counter++);
return (call_count < 10) ? CaseRepeatAll : CaseNoRepeat; return (call_count < 10) ? CaseRepeatAll : CaseNoRepeat;
} }
status_t repeat_all_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t repeat_all_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
static int repeat_counter(0); static int repeat_counter(0);
TEST_ASSERT_EQUAL(repeat_counter*3 + 2, call_counter++); TEST_ASSERT_EQUAL(repeat_counter*3 + 2, call_counter++);
@ -53,7 +53,7 @@ status_t repeat_all_case_teardown(const Case *const source, const size_t passed,
} }
// Control: RepeatHandler --------------------------------------------------------------------------------------------- // Control: RepeatHandler ---------------------------------------------------------------------------------------------
status_t repeat_handler_case_setup(const Case *const source, const size_t index_of_case) utest::v1::status_t repeat_handler_case_setup(const Case *const source, const size_t index_of_case)
{ {
TEST_ASSERT_EQUAL(1, index_of_case); TEST_ASSERT_EQUAL(1, index_of_case);
TEST_ASSERT_EQUAL(30, call_counter++); TEST_ASSERT_EQUAL(30, call_counter++);
@ -67,7 +67,7 @@ control_t repeat_handler_case(const size_t call_count)
TEST_ASSERT_EQUAL((call_count-1) + 31, call_counter++); TEST_ASSERT_EQUAL((call_count-1) + 31, call_counter++);
return (call_count < 10) ? CaseRepeatHandler : CaseNoRepeat; return (call_count < 10) ? CaseRepeatHandler : CaseNoRepeat;
} }
status_t repeat_handler_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t repeat_handler_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(41, call_counter++); TEST_ASSERT_EQUAL(41, call_counter++);
TEST_ASSERT_EQUAL(10, passed); TEST_ASSERT_EQUAL(10, passed);
@ -104,7 +104,7 @@ Case cases[] = {
Case("Control: CaseNext", next_handler_case) Case("Control: CaseNext", next_handler_case)
}; };
status_t greentea_setup(const size_t number_of_cases) utest::v1::status_t greentea_setup(const size_t number_of_cases)
{ {
GREENTEA_SETUP(15, "default_auto"); GREENTEA_SETUP(15, "default_auto");

16
frameworks/utest/TESTS/unit_tests/case_selection/main.cpp
View File

@ -28,7 +28,7 @@ void handler_case_2()
{ {
printf("Executing Case 2...\n"); printf("Executing Case 2...\n");
} }
status_t teardown_case_2(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t teardown_case_2(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(1, passed); TEST_ASSERT_EQUAL(1, passed);
TEST_ASSERT_EQUAL(0, failed); TEST_ASSERT_EQUAL(0, failed);
@ -36,13 +36,13 @@ status_t teardown_case_2(const Case *const source, const size_t passed, const si
TEST_ASSERT_EQUAL(LOCATION_NONE, failure.location); TEST_ASSERT_EQUAL(LOCATION_NONE, failure.location);
TEST_ASSERT_EQUAL(0, call_counter++); TEST_ASSERT_EQUAL(0, call_counter++);
greentea_case_teardown_handler(source, passed, failed, failure); greentea_case_teardown_handler(source, passed, failed, failure);
return status_t(0); return utest::v1::status_t(0);
} }
void handler_case_0() void handler_case_0()
{ {
printf("Executing Case 0...\n"); printf("Executing Case 0...\n");
} }
status_t teardown_case_0(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t teardown_case_0(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(1, passed); TEST_ASSERT_EQUAL(1, passed);
TEST_ASSERT_EQUAL(0, failed); TEST_ASSERT_EQUAL(0, failed);
@ -50,13 +50,13 @@ status_t teardown_case_0(const Case *const source, const size_t passed, const si
TEST_ASSERT_EQUAL(LOCATION_NONE, failure.location); TEST_ASSERT_EQUAL(LOCATION_NONE, failure.location);
TEST_ASSERT_EQUAL(1, call_counter++); TEST_ASSERT_EQUAL(1, call_counter++);
greentea_case_teardown_handler(source, passed, failed, failure); greentea_case_teardown_handler(source, passed, failed, failure);
return status_t(1); return utest::v1::status_t(1);
} }
void handler_case_1() void handler_case_1()
{ {
printf("Executing Case 1...\n"); printf("Executing Case 1...\n");
} }
status_t teardown_case_1(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t teardown_case_1(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(1, passed); TEST_ASSERT_EQUAL(1, passed);
TEST_ASSERT_EQUAL(0, failed); TEST_ASSERT_EQUAL(0, failed);
@ -64,7 +64,7 @@ status_t teardown_case_1(const Case *const source, const size_t passed, const si
TEST_ASSERT_EQUAL(LOCATION_NONE, failure.location); TEST_ASSERT_EQUAL(LOCATION_NONE, failure.location);
TEST_ASSERT_EQUAL(2, call_counter++); TEST_ASSERT_EQUAL(2, call_counter++);
greentea_case_teardown_handler(source, passed, failed, failure); greentea_case_teardown_handler(source, passed, failed, failure);
return status_t(3); return utest::v1::status_t(3);
} }
Case cases[] = Case cases[] =
@ -74,12 +74,12 @@ Case cases[] =
Case("Case 3", handler_case_2, teardown_case_2) Case("Case 3", handler_case_2, teardown_case_2)
}; };
status_t test_setup_handler(const size_t number_of_cases) utest::v1::status_t test_setup_handler(const size_t number_of_cases)
{ {
GREENTEA_SETUP(5, "default_auto"); GREENTEA_SETUP(5, "default_auto");
greentea_test_setup_handler(number_of_cases); greentea_test_setup_handler(number_of_cases);
return status_t(2); return utest::v1::status_t(2);
}; };
void test_teardown_handler(const size_t passed, const size_t failed, const failure_t failure) void test_teardown_handler(const size_t passed, const size_t failed, const failure_t failure)
{ {

14
frameworks/utest/TESTS/unit_tests/case_setup_failure/main.cpp
View File

@ -28,7 +28,7 @@ void never_call_case()
TEST_FAIL_MESSAGE("Case handler should have never been called!"); TEST_FAIL_MESSAGE("Case handler should have never been called!");
} }
status_t abort_case_setup(const Case *const source, const size_t index_of_case) utest::v1::status_t abort_case_setup(const Case *const source, const size_t index_of_case)
{ {
call_counter++; call_counter++;
TEST_ASSERT_EQUAL(0, index_of_case); TEST_ASSERT_EQUAL(0, index_of_case);
@ -36,7 +36,7 @@ status_t abort_case_setup(const Case *const source, const size_t index_of_case)
return STATUS_ABORT; return STATUS_ABORT;
} }
status_t abort_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t abort_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(1, call_counter); TEST_ASSERT_EQUAL(1, call_counter);
TEST_ASSERT_EQUAL(0, passed); TEST_ASSERT_EQUAL(0, passed);
@ -47,7 +47,7 @@ status_t abort_case_teardown(const Case *const source, const size_t passed, cons
return greentea_case_teardown_handler(source, 1, 0, failure); return greentea_case_teardown_handler(source, 1, 0, failure);
} }
status_t ignore_case_setup(const Case *const source, const size_t index_of_case) utest::v1::status_t ignore_case_setup(const Case *const source, const size_t index_of_case)
{ {
TEST_ASSERT_EQUAL(2, call_counter); TEST_ASSERT_EQUAL(2, call_counter);
TEST_ASSERT_EQUAL(1, index_of_case); TEST_ASSERT_EQUAL(1, index_of_case);
@ -56,7 +56,7 @@ status_t ignore_case_setup(const Case *const source, const size_t index_of_case)
return STATUS_IGNORE; // this is the same return STATUS_IGNORE; // this is the same
} }
status_t ignore_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t ignore_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(3, call_counter); TEST_ASSERT_EQUAL(3, call_counter);
TEST_ASSERT_EQUAL(0, passed); TEST_ASSERT_EQUAL(0, passed);
@ -67,7 +67,7 @@ status_t ignore_case_teardown(const Case *const source, const size_t passed, con
return greentea_case_teardown_handler(source, 1, 0, failure); return greentea_case_teardown_handler(source, 1, 0, failure);
} }
status_t continue_case_setup(const Case *const source, const size_t index_of_case) utest::v1::status_t continue_case_setup(const Case *const source, const size_t index_of_case)
{ {
TEST_ASSERT_EQUAL(4, call_counter); TEST_ASSERT_EQUAL(4, call_counter);
TEST_ASSERT_EQUAL(2, index_of_case); TEST_ASSERT_EQUAL(2, index_of_case);
@ -82,7 +82,7 @@ void continue_case_handler()
call_counter++; call_counter++;
} }
status_t continue_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t continue_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(6, call_counter); TEST_ASSERT_EQUAL(6, call_counter);
TEST_ASSERT_EQUAL(1, passed); TEST_ASSERT_EQUAL(1, passed);
@ -99,7 +99,7 @@ Case cases[] = {
Case("Setup handler returns CONTINUE", continue_case_setup, continue_case_handler, continue_case_teardown) Case("Setup handler returns CONTINUE", continue_case_setup, continue_case_handler, continue_case_teardown)
}; };
status_t greentea_setup(const size_t number_of_cases) utest::v1::status_t greentea_setup(const size_t number_of_cases)
{ {
GREENTEA_SETUP(15, "default_auto"); GREENTEA_SETUP(15, "default_auto");

14
frameworks/utest/TESTS/unit_tests/case_teardown_failure/main.cpp
View File

@ -28,7 +28,7 @@ void continue_case()
{ {
TEST_ASSERT_EQUAL(0, call_counter++); TEST_ASSERT_EQUAL(0, call_counter++);
} }
status_t continue_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t continue_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(1, passed); TEST_ASSERT_EQUAL(1, passed);
TEST_ASSERT_EQUAL(0, failed); TEST_ASSERT_EQUAL(0, failed);
@ -37,7 +37,7 @@ status_t continue_case_teardown(const Case *const source, const size_t passed, c
TEST_ASSERT_EQUAL(1, call_counter++); TEST_ASSERT_EQUAL(1, call_counter++);
return greentea_case_teardown_handler(source, passed, failed, failure); return greentea_case_teardown_handler(source, passed, failed, failure);
} }
status_t continue_failure(const Case *const, const failure_t) utest::v1::status_t continue_failure(const Case *const, const failure_t)
{ {
TEST_FAIL_MESSAGE("Failure handler should have never been called!"); TEST_FAIL_MESSAGE("Failure handler should have never been called!");
return STATUS_CONTINUE; return STATUS_CONTINUE;
@ -48,7 +48,7 @@ void ignore_case()
{ {
TEST_ASSERT_EQUAL(2, call_counter++); TEST_ASSERT_EQUAL(2, call_counter++);
} }
status_t ignore_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t ignore_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(1, passed); TEST_ASSERT_EQUAL(1, passed);
TEST_ASSERT_EQUAL(0, failed); TEST_ASSERT_EQUAL(0, failed);
@ -58,7 +58,7 @@ status_t ignore_case_teardown(const Case *const source, const size_t passed, con
greentea_case_teardown_handler(source, passed, failed, failure); greentea_case_teardown_handler(source, passed, failed, failure);
return STATUS_ABORT; return STATUS_ABORT;
} }
status_t ignore_failure(const Case *const source, const failure_t failure) utest::v1::status_t ignore_failure(const Case *const source, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(4, call_counter++); TEST_ASSERT_EQUAL(4, call_counter++);
TEST_ASSERT_EQUAL(REASON_CASE_TEARDOWN, failure.reason); TEST_ASSERT_EQUAL(REASON_CASE_TEARDOWN, failure.reason);
@ -72,7 +72,7 @@ void abort_case()
{ {
TEST_ASSERT_EQUAL(5, call_counter++); TEST_ASSERT_EQUAL(5, call_counter++);
} }
status_t abort_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) utest::v1::status_t abort_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(1, passed); TEST_ASSERT_EQUAL(1, passed);
TEST_ASSERT_EQUAL(0, failed); TEST_ASSERT_EQUAL(0, failed);
@ -82,7 +82,7 @@ status_t abort_case_teardown(const Case *const source, const size_t passed, cons
greentea_case_teardown_handler(source, passed, failed, failure); greentea_case_teardown_handler(source, passed, failed, failure);
return STATUS_ABORT; return STATUS_ABORT;
} }
status_t abort_failure(const Case *const source, const failure_t failure) utest::v1::status_t abort_failure(const Case *const source, const failure_t failure)
{ {
TEST_ASSERT_EQUAL(7, call_counter++); TEST_ASSERT_EQUAL(7, call_counter++);
TEST_ASSERT_EQUAL(REASON_CASE_TEARDOWN, failure.reason); TEST_ASSERT_EQUAL(REASON_CASE_TEARDOWN, failure.reason);
@ -98,7 +98,7 @@ Case cases[] = {
}; };
// Specification: Setup & Teardown ------------------------------------------------------------------------------------ // Specification: Setup & Teardown ------------------------------------------------------------------------------------
status_t greentea_setup(const size_t number_of_cases) utest::v1::status_t greentea_setup(const size_t number_of_cases)
{ {
GREENTEA_SETUP(15, "default_auto"); GREENTEA_SETUP(15, "default_auto");

2
frameworks/utest/TESTS/unit_tests/control_type/main.cpp
View File

@ -260,7 +260,7 @@ Case cases[] =
Case("Testing combinations of different group", test_different_group_combinations) Case("Testing combinations of different group", test_different_group_combinations)
}; };
status_t greentea_setup(const size_t number_of_cases) utest::v1::status_t greentea_setup(const size_t number_of_cases)
{ {
GREENTEA_SETUP(15, "default_auto"); GREENTEA_SETUP(15, "default_auto");

4
frameworks/utest/TESTS/unit_tests/minimal_async_scheduler/main.cpp
View File

@ -127,7 +127,7 @@ control_t test_case_async()
printf("Running Test #%d\n", counter); printf("Running Test #%d\n", counter);
return CaseTimeout(200); return CaseTimeout(200);
} }
status_t test_case_async_failure(const Case *const source, const failure_t reason) utest::v1::status_t test_case_async_failure(const Case *const source, const failure_t reason)
{ {
UTEST_LOG_FUNCTION(); UTEST_LOG_FUNCTION();
// ignore the timeout, since this is a test // ignore the timeout, since this is a test
@ -143,7 +143,7 @@ Case cases[] = {
}; };
// Specification: Setup & Teardown ------------------------------------------------------------------------------------ // Specification: Setup & Teardown ------------------------------------------------------------------------------------
status_t greentea_setup(const size_t number_of_cases) utest::v1::status_t greentea_setup(const size_t number_of_cases)
{ {
GREENTEA_SETUP(15, "default_auto"); GREENTEA_SETUP(15, "default_auto");
return greentea_test_setup_handler(number_of_cases); return greentea_test_setup_handler(number_of_cases);

2
frameworks/utest/TESTS/unit_tests/minimal_scheduler/main.cpp
View File

@ -99,7 +99,7 @@ Case cases[] = {
}; };
// Specification: Setup & Teardown ------------------------------------------------------------------------------------ // Specification: Setup & Teardown ------------------------------------------------------------------------------------
status_t greentea_setup(const size_t number_of_cases) utest::v1::status_t greentea_setup(const size_t number_of_cases)
{ {
GREENTEA_SETUP(15, "default_auto"); GREENTEA_SETUP(15, "default_auto");
return greentea_test_setup_handler(number_of_cases); return greentea_test_setup_handler(number_of_cases);

4
frameworks/utest/TESTS/unit_tests/test_assertion_failure_test_setup/main.cpp
View File

@ -34,11 +34,11 @@ Case cases[] =
}; };
// this setup handler fails // this setup handler fails
status_t failing_setup_handler(const size_t number_of_cases) utest::v1::status_t failing_setup_handler(const size_t number_of_cases)
{ {
GREENTEA_SETUP(5, "default_auto"); GREENTEA_SETUP(5, "default_auto");
status_t status = greentea_test_setup_handler(number_of_cases); utest::v1::status_t status = greentea_test_setup_handler(number_of_cases);
failure_is_in_setup = true; failure_is_in_setup = true;
TEST_FAIL_MESSAGE("Explicit assertion failure in test setup handler!"); TEST_FAIL_MESSAGE("Explicit assertion failure in test setup handler!");

4
frameworks/utest/TESTS/unit_tests/test_setup_case_selection_failure/main.cpp
View File

@ -33,13 +33,13 @@ Case cases[] =
}; };
// this setup handler fails since it sends // this setup handler fails since it sends
status_t failing_setup_handler(const size_t number_of_cases) utest::v1::status_t failing_setup_handler(const size_t number_of_cases)
{ {
GREENTEA_SETUP(5, "default_auto"); GREENTEA_SETUP(5, "default_auto");
TEST_ASSERT_EQUAL(2, number_of_cases); TEST_ASSERT_EQUAL(2, number_of_cases);
greentea_test_setup_handler(number_of_cases); greentea_test_setup_handler(number_of_cases);
return status_t(3); // return an index outside the range of the test cases return utest::v1::status_t(3); // return an index outside the range of the test cases
}; };
// the teardown handler will then be called with the reason `REASON_TEST_SETUP` // the teardown handler will then be called with the reason `REASON_TEST_SETUP`

2
frameworks/utest/TESTS/unit_tests/test_setup_failure/main.cpp
View File

@ -33,7 +33,7 @@ Case cases[] =
}; };
// this setup handler fails // this setup handler fails
status_t failing_setup_handler(const size_t number_of_cases) utest::v1::status_t failing_setup_handler(const size_t number_of_cases)
{ {
GREENTEA_SETUP(5, "default_auto"); GREENTEA_SETUP(5, "default_auto");