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

Tests: Drivers: Watchdog: Add tests

pull/10657/head
Filip Jagodzinski 2018-01-30 17:08:02 +01:00 committed by Filip Jagodzinski
parent c4d9300f9d
commit 8baf16760d
4 changed files with 691 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
TESTS/mbed_drivers/watchdog/Watchdog_tests.h Normal file
View File

@ -0,0 +1,108 @@
/* mbed Microcontroller Library
* Copyright (c) 2018 ARM Limited
*
* 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.
*/
/**
* @addtogroup drivers_watchdog_tests
* @{
*/
#ifndef MBED_DRIVERS_WATCHDOG_TESTS_H
#define MBED_DRIVERS_WATCHDOG_TESTS_H
#if DEVICE_WATCHDOG
/** Test max_timeout is valid
*
* Given a device supporting Watchdog driver API
* When @a Watchdog::max_timeout() is called
* Then the returned value is greater than 1
*/
void test_max_timeout_is_valid();
/** Test watchdog can be stopped
*
* Given a platform with a support for disabling a running watchdog
* When watchdog is not running and @a Watchdog::stop() is called
* Then WATCHDOG_STATUS_OK is returned
* When watchdog is running
* and @a Watchdog::stop() is called before timeout
* Then WATCHDOG_STATUS_OK is returned
* and watchdog does not reset the device
* When watchdog has already been stopped and @a Watchdog::stop() is called
* Then WATCHDOG_STATUS_OK is returned
*/
void test_stop();
/** Test restart watchdog multiple times
*
* Given @a max_timeout value returned by @a Watchdog::max_timeout()
* and @a Watchdog::start() called multiple times
* When @a timeout is set to max_timeout - delta
* Then return value of @a Watchdog::start() is @a WATCHDOG_STATUS_OK
* and @a Watchdog::reload_value() returns max_timeout - delta
* When @a timeout is set to max_timeout
* Then return value of @a Watchdog::start() is @a WATCHDOG_STATUS_OK
* and @a Watchdog::reload_value() returns max_timeout
* When @a timeout is set to max_timeout + delta
* Then return value of @a Watchdog::start() is @a WATCHDOG_STATUS_INVALID_ARGUMENT
* and @a Watchdog::reload_value() returns previously set value (max_timeout)
* When @a timeout is set to 0
* Then return value of @a Watchdog::start() is @a WATCHDOG_STATUS_INVALID_ARGUMENT
* and @a Watchdog::reload_value() returns previously set value (max_timeout)
*/
void test_restart();
/** Test start with 0 ms
*
* Given a device supporting Watchdog driver API
* When @a timeout is set to 0 ms
* Then return value of Watchdog::start() is @a WATCHDOG_STATUS_INVALID_ARGUMENT
*/
void test_start_zero();
/** Test start with a valid config
*
* Given a device supporting Watchdog driver API
* When @a timeout is set to value X within platform's timeout range
* Then return value of Watchdog::start() is @a WATCHDOG_STATUS_OK
* and @a Watchdog::reload_value() returns X
*/
template<uint32_t timeout_ms>
void test_start();
/** Test start with a max_timeout
*
* Given @a max_timeout value returned by @a Watchdog::max_timeout()
* When @a timeout is set to max_timeout
* Then return value of Watchdog::start() is @a WATCHDOG_STATUS_OK
* and @a Watchdog::reload_value() returns max_timeout
*/
void test_start_max_timeout();
/** Test start with a timeout value exceeding max_timeout
*
* Given a device supporting Watchdog driver API
* When @a timeout is set to max_timeout + 1
* Then return value of Watchdog::start() is @a WATCHDOG_STATUS_INVALID_ARGUMENT
*/
void test_start_max_timeout_exceeded();
#endif
#endif
/** @}*/

221
TESTS/mbed_drivers/watchdog/main.cpp Normal file
View File

@ -0,0 +1,221 @@
/* mbed Microcontroller Library
* Copyright (c) 2018 ARM Limited
*
* 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.
*/
#if !DEVICE_WATCHDOG
#error [NOT_SUPPORTED] Watchdog not supported for this target
#endif
#define __STDC_LIMIT_MACROS
#include <stdint.h>
#include "greentea-client/test_env.h"
#include "utest/utest.h"
#include "unity/unity.h"
#include "drivers/Watchdog.h"
#include "Watchdog_tests.h"
/* This is platform specific and depends on the watchdog timer implementation,
* e.g. STM32F4 uses 32kHz internal RC oscillator to clock the IWDG, so
* when the prescaler divider is set to max value of 256 the resolution
* drops to 8 ms.
*/
#define WORST_TIMEOUT_RESOLUTION_MS 8UL
#define TIMEOUT_DELTA_MS (WORST_TIMEOUT_RESOLUTION_MS)
#define WDG_TIMEOUT_MS 500UL
#define MSG_VALUE_DUMMY "0"
#define MSG_VALUE_LEN 24
#define MSG_KEY_LEN 24
#define MSG_KEY_DEVICE_READY "ready"
#define MSG_KEY_START_CASE "start_case"
#define MSG_KEY_DEVICE_RESET "reset_on_case_teardown"
int CASE_INDEX_START;
int CASE_INDEX_CURRENT;
using utest::v1::Case;
using utest::v1::Specification;
using utest::v1::Harness;
void test_max_timeout_is_valid()
{
Watchdog watchdog;
TEST_ASSERT(watchdog.max_timeout() > 1UL);
}
void test_stop()
{
Watchdog watchdog;
if (watchdog.stop() == WATCHDOG_STATUS_NOT_SUPPORTED) {
TEST_IGNORE_MESSAGE("Disabling watchdog not supported for this platform");
return;
}
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, watchdog.stop());
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, watchdog.start(WDG_TIMEOUT_MS));
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, watchdog.stop());
// Make sure that a disabled watchdog does not reset the core.
wait_ms(WDG_TIMEOUT_MS + TIMEOUT_DELTA_MS);
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, watchdog.stop());
}
void test_restart()
{
Watchdog watchdog;
watchdog.start(watchdog.max_timeout());
uint64_t timeout = watchdog.max_timeout() - 2ULL * WORST_TIMEOUT_RESOLUTION_MS;
watchdog_status_t status = watchdog.start(timeout);
if (status == WATCHDOG_STATUS_NOT_SUPPORTED) {
TEST_IGNORE_MESSAGE("Updating watchdog config not supported for this platform");
return;
}
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, status);
TEST_ASSERT_UINT32_WITHIN(WORST_TIMEOUT_RESOLUTION_MS, timeout, watchdog.reload_value());
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, watchdog.start(watchdog.max_timeout()));
TEST_ASSERT_UINT32_WITHIN(WORST_TIMEOUT_RESOLUTION_MS, watchdog.max_timeout(), watchdog.reload_value());
timeout = watchdog.max_timeout() + 2ULL * WORST_TIMEOUT_RESOLUTION_MS;
// Make sure requested timeout does not overflow uint32_t.
if (timeout <= UINT32_MAX) {
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_INVALID_ARGUMENT, watchdog.start(timeout));
TEST_ASSERT_UINT32_WITHIN(WORST_TIMEOUT_RESOLUTION_MS, watchdog.max_timeout(), watchdog.reload_value());
}
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_INVALID_ARGUMENT, watchdog.start(0UL));
TEST_ASSERT_UINT32_WITHIN(WORST_TIMEOUT_RESOLUTION_MS, watchdog.max_timeout(), watchdog.reload_value());
}
utest::v1::status_t case_setup_sync_on_reset(const Case * const source, const size_t index_of_case)
{
CASE_INDEX_CURRENT = index_of_case;
return utest::v1::greentea_case_setup_handler(source, index_of_case);
}
utest::v1::status_t case_teardown_sync_on_reset(const Case * const source, const size_t passed, const size_t failed,
const utest::v1::failure_t failure)
{
utest::v1::status_t status = utest::v1::greentea_case_teardown_handler(source, passed, failed, failure);
if (failed) {
/* Return immediately and skip the device reset, if the test case failed.
* Provided that the device won't be restarted by other means (i.e. watchdog timer),
* this should allow the test suite to finish in a defined manner
* and report failure to host.
* In case of watchdog reset during test suite teardown, the loss of serial
* connection is possible, so the host-test-runner may return 'TIMEOUT'
* instead of 'FAIL'.
*/
return status;
}
greentea_send_kv(MSG_KEY_DEVICE_RESET, CASE_INDEX_START + CASE_INDEX_CURRENT);
utest_printf("The device will now restart.\n");
wait_ms(10); // Wait for the serial buffers to flush.
NVIC_SystemReset();
return status; // Reset is instant so this line won't be reached.
}
void test_start_zero()
{
Watchdog watchdog;
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_INVALID_ARGUMENT, watchdog.start(0UL));
}
template<uint32_t timeout_ms>
void test_start()
{
Watchdog watchdog;
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, watchdog.start(timeout_ms));
TEST_ASSERT_UINT32_WITHIN(WORST_TIMEOUT_RESOLUTION_MS, timeout_ms, watchdog.reload_value());
}
void test_start_max_timeout()
{
Watchdog watchdog;
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, watchdog.start(watchdog.max_timeout()));
TEST_ASSERT_UINT32_WITHIN(WORST_TIMEOUT_RESOLUTION_MS, watchdog.max_timeout(), watchdog.reload_value());
}
void test_start_max_timeout_exceeded()
{
Watchdog watchdog;
uint64_t timeout = watchdog.max_timeout() + 2ULL * WORST_TIMEOUT_RESOLUTION_MS;
// Make sure requested timeout does not overflow uint32_t.
if (timeout > UINT32_MAX) {
TEST_IGNORE_MESSAGE("Requested timeout overflows uint32_t -- ignoring test case.");
return;
}
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_INVALID_ARGUMENT, watchdog.start(timeout));
}
int testsuite_setup_sync_on_reset(const size_t number_of_cases)
{
GREENTEA_SETUP(45, "sync_on_reset");
utest::v1::status_t status = utest::v1::greentea_test_setup_handler(number_of_cases);
if (status != utest::v1::STATUS_CONTINUE) {
return status;
}
char key[MSG_KEY_LEN + 1] = { };
char value[MSG_VALUE_LEN + 1] = { };
greentea_send_kv(MSG_KEY_DEVICE_READY, MSG_VALUE_DUMMY);
greentea_parse_kv(key, value, MSG_KEY_LEN, MSG_VALUE_LEN);
if (strcmp(key, MSG_KEY_START_CASE) != 0) {
utest_printf("Invalid message key.\n");
return utest::v1::STATUS_ABORT;
}
char *tailptr = NULL;
CASE_INDEX_START = (int) strtol(value, &tailptr, 10);
if (*tailptr != '\0' || CASE_INDEX_START < 0) {
utest_printf("Invalid start case index received from host\n");
return utest::v1::STATUS_ABORT;
}
utest_printf("Starting with test case index %i of all %i defined test cases.\n", CASE_INDEX_START, number_of_cases);
return CASE_INDEX_START;
}
Case cases[] = {
Case("max_timeout is valid", test_max_timeout_is_valid),
Case("Stop", test_stop),
Case("Restart multiple times", (utest::v1::case_setup_handler_t) case_setup_sync_on_reset,
test_restart, (utest::v1::case_teardown_handler_t) case_teardown_sync_on_reset),
// Do not set watchdog timeout shorter than 500 ms as it may cause the
// host-test-runner return 'TIMEOUT' instead of 'FAIL' / 'PASS' if watchdog
// performs reset during test suite teardown.
Case("Start, 500 ms", (utest::v1::case_setup_handler_t) case_setup_sync_on_reset,
test_start<500UL>, (utest::v1::case_teardown_handler_t) case_teardown_sync_on_reset),
Case("Start, max_timeout", (utest::v1::case_setup_handler_t) case_setup_sync_on_reset,
test_start_max_timeout, (utest::v1::case_teardown_handler_t) case_teardown_sync_on_reset),
Case("Start, 0 ms", test_start_zero),
Case("Start, max_timeout exceeded", test_start_max_timeout_exceeded),
};
Specification specification((utest::v1::test_setup_handler_t) testsuite_setup_sync_on_reset, cases);
int main()
{
// Harness will start with a test case index provided by host script.
return !Harness::run(specification);
}

77
TESTS/mbed_drivers/watchdog_reset/Watchdog_reset_tests.h Normal file
View File

@ -0,0 +1,77 @@
/* mbed Microcontroller Library
* Copyright (c) 2018 ARM Limited
*
* 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.
*/
/**
* @addtogroup drivers_watchdog_tests
* @{
*/
#ifndef MBED_DRIVERS_WATCHDOG_RESET_TESTS_H
#define MBED_DRIVERS_WATCHDOG_RESET_TESTS_H
#if DEVICE_WATCHDOG
/** Test watchdog reset
*
* Given a device with a watchdog started
* When a watchdog timeout expires
* Then the device is restarted
*/
void test_simple_reset();
/** Test watchdog reset in sleep mode
*
* Given a device supporting sleep mode, with a watchdog started
* When the device is in sleep mode and watchdog timeout expires
* Then the device is restarted
*/
void test_sleep_reset();
/** Test watchdog reset in deepsleep mode
*
* Given a device supporting deepsleep mode, with watchdog started
* When the device is in deepsleep mode and watchdog timeout expires
* Then the device is restarted
*/
void test_deepsleep_reset();
/** Test stopped watchdog can be started again and reset the device
*
* Given a device supporting 'disable_watchdog' feature, with watchdog started
* When the watchdog is stopped before timeout expires
* Then the device is not restarted
* When the watchdog is started again and it's timeout expires
* Then the device is restarted
*/
void test_restart_reset();
/** Test kicking the watchdog prevents reset
*
* Given a device with watchdog started
* When the watchdog is kicked before timeout expires
* Then the device restart is prevented
* When the watchdog is *NOT* kicked again before next timeout expires
* Then the device is restarted
*
*/
void test_kick_reset();
#endif
#endif
/** @}*/

285
TESTS/mbed_drivers/watchdog_reset/main.cpp Normal file
View File

@ -0,0 +1,285 @@
/* mbed Microcontroller Library
* Copyright (c) 2018 ARM Limited
*
* 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.
*/
#if !DEVICE_WATCHDOG
#error [NOT_SUPPORTED] Watchdog not supported for this target
#endif
#include "greentea-client/test_env.h"
#include "utest/utest.h"
#include "unity/unity.h"
#include "drivers/Watchdog.h"
#include "Watchdog_reset_tests.h"
#include "mbed.h"
#define TIMEOUT_MS 500UL
#define TIMEOUT_DELTA_MS 50UL
#define MSG_VALUE_DUMMY "0"
#define CASE_DATA_INVALID 0xffffffffUL
#define CASE_DATA_PHASE2_OK 0xfffffffeUL
#define MSG_VALUE_LEN 24
#define MSG_KEY_LEN 24
#define MSG_KEY_DEVICE_READY "ready"
#define MSG_KEY_START_CASE "start_case"
#define MSG_KEY_DEVICE_RESET "dev_reset"
using utest::v1::Case;
using utest::v1::Specification;
using utest::v1::Harness;
struct testcase_data {
int index;
int start_index;
uint32_t received_data;
};
void release_sem(Semaphore *sem)
{
sem->release();
}
testcase_data current_case;
bool send_reset_notification(testcase_data * tcdata, uint32_t delay_ms)
{
char msg_value[12];
int str_len = snprintf(msg_value, sizeof msg_value, "%02x,%08lx", tcdata->start_index + tcdata->index, delay_ms);
if (str_len != (sizeof msg_value) - 1) {
utest_printf("Failed to compose a value string to be sent to host.");
return false;
}
greentea_send_kv(MSG_KEY_DEVICE_RESET, msg_value);
return true;
}
void test_simple_reset()
{
// Phase 2. -- verify the test results.
// Verify if this test case passed based on data received from host.
if (current_case.received_data != CASE_DATA_INVALID) {
TEST_ASSERT_EQUAL(CASE_DATA_PHASE2_OK, current_case.received_data);
current_case.received_data = CASE_DATA_INVALID;
return;
}
// Phase 1. -- run the test code.
// Init the watchdog and wait for a device reset.
Watchdog watchdog;
if (send_reset_notification(&current_case, TIMEOUT_MS + TIMEOUT_DELTA_MS) == false) {
TEST_ASSERT_MESSAGE(0, "Dev-host communication error.");
return;
}
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, watchdog.start(TIMEOUT_MS));
wait_ms(TIMEOUT_MS + TIMEOUT_DELTA_MS); // Device reset expected.
// Watchdog reset should have occurred during wait_ms() above;
watchdog.kick(); // Just to buy some time for testsuite failure handling.
TEST_ASSERT_MESSAGE(0, "Watchdog did not reset the device as expected.");
}
#if DEVICE_SLEEP
void test_sleep_reset()
{
// Phase 2. -- verify the test results.
if (current_case.received_data != CASE_DATA_INVALID) {
TEST_ASSERT_EQUAL(CASE_DATA_PHASE2_OK, current_case.received_data);
current_case.received_data = CASE_DATA_INVALID;
return;
}
// Phase 1. -- run the test code.
Watchdog watchdog;
Semaphore sem(0, 1);
Timeout timeout;
if (send_reset_notification(&current_case, TIMEOUT_MS + TIMEOUT_DELTA_MS) == false) {
TEST_ASSERT_MESSAGE(0, "Dev-host communication error.");
return;
}
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, watchdog.start(TIMEOUT_MS));
sleep_manager_lock_deep_sleep();
timeout.attach_us(mbed::callback(release_sem, &sem), 1000ULL * (TIMEOUT_MS + TIMEOUT_DELTA_MS));
if (sleep_manager_can_deep_sleep()) {
TEST_ASSERT_MESSAGE(0, "Deepsleep should be disallowed.");
return;
}
while (sem.wait(0) != 1) {
sleep(); // Device reset expected.
}
sleep_manager_unlock_deep_sleep();
// Watchdog reset should have occurred during sleep() above;
watchdog.kick(); // Just to buy some time for testsuite failure handling.
TEST_ASSERT_MESSAGE(0, "Watchdog did not reset the device as expected.");
}
#if DEVICE_LOWPOWERTIMER
void test_deepsleep_reset()
{
// Phase 2. -- verify the test results.
if (current_case.received_data != CASE_DATA_INVALID) {
TEST_ASSERT_EQUAL(CASE_DATA_PHASE2_OK, current_case.received_data);
current_case.received_data = CASE_DATA_INVALID;
return;
}
// Phase 1. -- run the test code.
Watchdog watchdog;
Semaphore sem(0, 1);
LowPowerTimeout lp_timeout;
if (send_reset_notification(&current_case, TIMEOUT_MS + TIMEOUT_DELTA_MS) == false) {
TEST_ASSERT_MESSAGE(0, "Dev-host communication error.");
return;
}
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, watchdog.start(TIMEOUT_MS));
lp_timeout.attach_us(mbed::callback(release_sem, &sem), 1000ULL * (TIMEOUT_MS + TIMEOUT_DELTA_MS));
wait_ms(10); // Wait for the serial buffers to flush.
if (!sleep_manager_can_deep_sleep()) {
TEST_ASSERT_MESSAGE(0, "Deepsleep should be allowed.");
}
while (sem.wait(0) != 1) {
sleep(); // Device reset expected.
}
// Watchdog reset should have occurred during that sleep() above;
watchdog.kick(); // Just to buy some time for testsuite failure handling.
TEST_ASSERT_MESSAGE(0, "Watchdog did not reset the device as expected.");
}
#endif
#endif
void test_restart_reset()
{
Watchdog watchdog;
if (watchdog.stop() == WATCHDOG_STATUS_NOT_SUPPORTED) {
TEST_IGNORE_MESSAGE("Disabling watchdog not supported for this platform");
return;
}
// Phase 2. -- verify the test results.
if (current_case.received_data != CASE_DATA_INVALID) {
TEST_ASSERT_EQUAL(CASE_DATA_PHASE2_OK, current_case.received_data);
current_case.received_data = CASE_DATA_INVALID;
return;
}
// Phase 1. -- run the test code.
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, watchdog.start(TIMEOUT_MS));
wait_ms(TIMEOUT_MS / 2UL);
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, watchdog.stop());
// Check that stopping the watchdog prevents a device reset.
wait_ms(TIMEOUT_MS / 2UL + TIMEOUT_DELTA_MS);
if (send_reset_notification(&current_case, TIMEOUT_MS + TIMEOUT_DELTA_MS) == false) {
TEST_ASSERT_MESSAGE(0, "Dev-host communication error.");
return;
}
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, watchdog.start(TIMEOUT_MS));
wait_ms(TIMEOUT_MS + TIMEOUT_DELTA_MS); // Device reset expected.
// Watchdog reset should have occurred during that wait() above;
watchdog.kick(); // Just to buy some time for testsuite failure handling.
TEST_ASSERT_MESSAGE(0, "Watchdog did not reset the device as expected.");
}
void test_kick_reset()
{
// Phase 2. -- verify the test results.
if (current_case.received_data != CASE_DATA_INVALID) {
TEST_ASSERT_EQUAL(CASE_DATA_PHASE2_OK, current_case.received_data);
current_case.received_data = CASE_DATA_INVALID;
return;
}
// Phase 1. -- run the test code.
Watchdog watchdog;
TEST_ASSERT_EQUAL(WATCHDOG_STATUS_OK, watchdog.start(TIMEOUT_MS));
for (int i = 3; i; i--) {
wait_ms(TIMEOUT_MS / 2UL);
watchdog.kick();
}
if (send_reset_notification(&current_case, TIMEOUT_MS + TIMEOUT_DELTA_MS) == false) {
TEST_ASSERT_MESSAGE(0, "Dev-host communication error.");
return;
}
wait_ms(TIMEOUT_MS + TIMEOUT_DELTA_MS); // Device reset expected.
// Watchdog reset should have occurred during that wait() above;
watchdog.kick(); // Just to buy some time for testsuite failure handling.
TEST_ASSERT_MESSAGE(0, "Watchdog did not reset the device as expected.");
}
utest::v1::status_t case_setup(const Case * const source, const size_t index_of_case)
{
current_case.index = index_of_case;
return utest::v1::greentea_case_setup_handler(source, index_of_case);
}
int testsuite_setup(const size_t number_of_cases)
{
GREENTEA_SETUP(90, "watchdog_reset");
utest::v1::status_t status = utest::v1::greentea_test_setup_handler(number_of_cases);
if (status != utest::v1::STATUS_CONTINUE) {
return status;
}
char key[MSG_KEY_LEN + 1] = { };
char value[MSG_VALUE_LEN + 1] = { };
greentea_send_kv(MSG_KEY_DEVICE_READY, MSG_VALUE_DUMMY);
greentea_parse_kv(key, value, MSG_KEY_LEN, MSG_VALUE_LEN);
if (strcmp(key, MSG_KEY_START_CASE) != 0) {
utest_printf("Invalid message key.\n");
return utest::v1::STATUS_ABORT;
}
int num_args = sscanf(value, "%02x,%08lx", &(current_case.start_index), &(current_case.received_data));
if (num_args == 0 || num_args == EOF) {
utest_printf("Invalid data received from host\n");
return utest::v1::STATUS_ABORT;
}
utest_printf("This test suite is composed of %i test cases. Starting at index %i.\n", number_of_cases,
current_case.start_index);
return current_case.start_index;
}
Case cases[] = {
Case("Watchdog reset", case_setup, test_simple_reset),
#if DEVICE_SLEEP
Case("Watchdog reset in sleep mode", case_setup, test_sleep_reset),
#if DEVICE_LOWPOWERTIMER
Case("Watchdog reset in deepsleep mode", case_setup, test_deepsleep_reset),
#endif
#endif
Case("Watchdog started again", case_setup, test_restart_reset),
Case("Kicking the watchdog prevents reset", case_setup, test_kick_reset),
};
Specification specification((utest::v1::test_setup_handler_t) testsuite_setup, cases);
int main()
{
// Harness will start with a test case index provided by host script.
return !Harness::run(specification);
}