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

Merge pull request #154 from adbridge/status_t_update 

Update all instances of status_t in the unit tests to fully namespace…
Marcus Shawcroft 2016-05-27 13:16:14 +01:00
parent be0fcfb02b 635afa58fc
commit 2a456e5a58
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");
}
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();
// 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());
return status;
}
@ -28,7 +28,7 @@ control_t test_repeats(const size_t call_count) {
}
// 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();
GREENTEA_SETUP(20, "default_auto");
// 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;
}
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(0, failed);
@ -96,7 +96,7 @@ control_t premature_validation_case()
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(0, failed);
@ -121,7 +121,7 @@ control_t multiple_premature_validation_case()
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(0, failed);
@ -150,7 +150,7 @@ control_t attributed_validation_cancel_repeat_case()
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(0, failed);
@ -186,7 +186,7 @@ control_t attributed_validation_enable_repeat_case(const size_t call_count)
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(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)
};
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");

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++);
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();
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);
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();
TEST_ASSERT_EQUAL(2, call_counter++);
@ -101,7 +101,7 @@ control_t timeout_success_case(const size_t call_count)
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();
TEST_ASSERT_EQUAL(5, call_counter++);
@ -126,7 +126,7 @@ control_t await_case(const size_t call_count)
// Control: RepeatAllOnTimeout ----------------------------------------------------------------------------------------
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){
UTEST_TRACE_START
@ -153,7 +153,7 @@ control_t repeat_all_on_timeout_case(const size_t call_count)
}
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();
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 ----------------------------------------------------------------------------------------
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();
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);
}
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();
TEST_ASSERT_EQUAL(1, passed);
@ -232,7 +232,7 @@ Case cases[] = {
};
// 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");

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);
// 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);
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++);
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);
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 ---------------------------------------------------------------------------------------------
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(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++);
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(10, passed);
@ -104,7 +104,7 @@ Case cases[] = {
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");

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");
}
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(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(0, call_counter++);
greentea_case_teardown_handler(source, passed, failed, failure);
return status_t(0);
return utest::v1::status_t(0);
}
void handler_case_0()
{
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(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(1, call_counter++);
greentea_case_teardown_handler(source, passed, failed, failure);
return status_t(1);
return utest::v1::status_t(1);
}
void handler_case_1()
{
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(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(2, call_counter++);
greentea_case_teardown_handler(source, passed, failed, failure);
return status_t(3);
return utest::v1::status_t(3);
}
Case cases[] =
@ -74,12 +74,12 @@ Case cases[] =
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_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)
{

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!");
}
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++;
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;
}
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(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);
}
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(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
}
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(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);
}
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(2, index_of_case);
@ -82,7 +82,7 @@ void continue_case_handler()
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(1, passed);
@ -99,7 +99,7 @@ Case cases[] = {
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");

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++);
}
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(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++);
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!");
return STATUS_CONTINUE;
@ -48,7 +48,7 @@ void ignore_case()
{
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(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);
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(REASON_CASE_TEARDOWN, failure.reason);
@ -72,7 +72,7 @@ void abort_case()
{
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(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);
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(REASON_CASE_TEARDOWN, failure.reason);
@ -98,7 +98,7 @@ Case cases[] = {
};
// 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");

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)
};
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");

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);
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();
// ignore the timeout, since this is a test
@ -143,7 +143,7 @@ Case cases[] = {
};
// 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");
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 ------------------------------------------------------------------------------------
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");
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
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");
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;
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
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");
TEST_ASSERT_EQUAL(2, 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`

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

@ -33,7 +33,7 @@ Case cases[] =
};
// 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");