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

unittest: move watchdog files to drivers 

Test VirtualWatchdog and Watchdog
pull/10857/head
Martin Kojtal 2019-06-28 12:15:50 +01:00
parent 8bbba26842
commit 4549a22566
6 changed files with 193 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
UNITTESTS/drivers/VirtualWatchdog/test_virtualwatchdog.cpp Normal file
View File

@ -0,0 +1,138 @@
/*
* Copyright (c) 2018, Arm Limited and affiliates.
* SPDX-License-Identifier: Apache-2.0
*
* 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 "gtest/gtest.h"
#include "gmock/gmock.h"
#include "drivers/VirtualWatchdog.h"
class TestVirtualWatchdog : public testing::Test {
public:
static uint32_t expect_assert_count;
static uint32_t expect_reset_count;
protected:
virtual void SetUp() {}
virtual void TearDown() {}
};
uint32_t TestVirtualWatchdog::expect_assert_count = 0;
uint32_t TestVirtualWatchdog::expect_reset_count = 0;
void mbed_assert_internal(const char *expr, const char *file, int line)
{
TestVirtualWatchdog::expect_assert_count++;
}
void mock_system_reset()
{
TestVirtualWatchdog::expect_reset_count++;
}
TEST_F(TestVirtualWatchdog, virtualwdog_constructor)
{
EXPECT_LE(sizeof(mbed::VirtualWatchdog), 1024);
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
}
TEST_F(TestVirtualWatchdog, virtualwdog_constructor_with_default_value)
{
mbed::VirtualWatchdog watchdog;
}
TEST_F(TestVirtualWatchdog, virtualwdog_start_pass)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
watchdog.start();
watchdog.stop();
EXPECT_EQ(0, TestVirtualWatchdog::expect_assert_count);
}
TEST_F(TestVirtualWatchdog, virtualwdog_kick_pass)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
watchdog.start();
watchdog.kick();
watchdog.stop();
EXPECT_EQ(0, TestVirtualWatchdog::expect_assert_count);
}
TEST_F(TestVirtualWatchdog, virtualwdog_stop_fail)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
watchdog.start();
watchdog.stop();
watchdog.stop();
EXPECT_EQ(1, TestVirtualWatchdog::expect_assert_count);
TestVirtualWatchdog::expect_assert_count = 0;
}
TEST_F(TestVirtualWatchdog, virtualwdog_kick_fail)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
watchdog.kick();
EXPECT_EQ(1, TestVirtualWatchdog::expect_assert_count);
TestVirtualWatchdog::expect_assert_count = 0;
}
TEST_F(TestVirtualWatchdog, virtualwdog_start_kick_pass)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
mbed::VirtualWatchdog watchdog1(600, "watchdog_unittest_1");
mbed::VirtualWatchdog watchdog2(700, "watchdog_unittest_2");
watchdog.start();
watchdog1.start();
watchdog2.start();
watchdog1.kick();
watchdog.kick();
watchdog2.kick();
watchdog1.stop();
watchdog.stop();
watchdog2.stop();
EXPECT_EQ(0, TestVirtualWatchdog::expect_assert_count);
EXPECT_EQ(0, TestVirtualWatchdog::expect_reset_count);
}
TEST_F(TestVirtualWatchdog, virtualwdog_start_process_pass)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
watchdog.start();
watchdog.kick();
watchdog.stop();
EXPECT_EQ(0, TestVirtualWatchdog::expect_assert_count);
EXPECT_EQ(0, TestVirtualWatchdog::expect_reset_count);
}
TEST_F(TestVirtualWatchdog, virtualwdog_start_process_fail)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
mbed::VirtualWatchdog watchdog1(500, "watchdog_unittest-1");
watchdog.start();
watchdog1.start();
watchdog1.kick();
watchdog.stop();
watchdog1.stop();
EXPECT_EQ(0, TestVirtualWatchdog::expect_assert_count);
EXPECT_EQ(1, TestVirtualWatchdog::expect_reset_count);
TestVirtualWatchdog::expect_reset_count = 0;
}
TEST_F(TestVirtualWatchdog, virtualwdog_start_fail)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
watchdog.start();
watchdog.start();
watchdog.stop();
EXPECT_EQ(1, TestVirtualWatchdog::expect_assert_count);
TestVirtualWatchdog::expect_assert_count = 0;
}

27
UNITTESTS/drivers/VirtualWatchdog/unittest.cmake Normal file
View File

@ -0,0 +1,27 @@
####################
# UNIT TESTS
####################
set(TEST_SUITE_NAME "VirtualWatchdog")
# Add test specific include paths
set(unittest-includes ${unittest-includes}
.
../hal
)
# Source files
set(unittest-sources
../drivers/VirtualWatchdog.cpp
)
# Test files
set(unittest-test-sources
drivers/Watchdog/test_virtualwatchdog.cpp
stubs/mbed_critical_stub.c
)
# defines
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DDEVICE_WATCHDOG -DMBED_WDOG_ASSERT=1")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DDEVICE_WATCHDOG -DMBED_WDOG_ASSERT=1")

126
UNITTESTS/drivers/Watchdog/test_watchdog.cpp
View File

@ -16,123 +16,53 @@
*/
#include "gtest/gtest.h"
#include "gmock/gmock.h"
#include "drivers/VirtualWatchdog.h"
#include "Watchdog.h"
class TestWatchdog : public testing::Test {
public:
static uint32_t expect_assert_count;
static uint32_t expect_reset_count;
using namespace mbed;
extern bool testcase;
// AStyle ignored as the definition is not clear due to preprocessor usage
// *INDENT-OFF*
class TestMbedVirtualWatchdog : public testing::Test {
protected:
virtual void SetUp() {}
virtual void TearDown() {}
void SetUp()
{
}
void TearDown()
{
}
};
// *INDENT-ON*
uint32_t TestWatchdog::expect_assert_count = 0;
uint32_t TestWatchdog::expect_reset_count = 0;
void mbed_assert_internal(const char *expr, const char *file, int line)
TEST_F(TestMbedVirtualWatchdog, test_watchdog_start_pass)
{
TestWatchdog::expect_assert_count++;
EXPECT_TRUE(Watchdog::get_instance().start());
}
void mock_system_reset()
TEST_F(TestMbedVirtualWatchdog, test_watchdog_start_fail)
{
TestWatchdog::expect_reset_count++;
EXPECT_FALSE(Watchdog::get_instance().start());
}
TEST_F(TestWatchdog, wdog_constructor)
TEST_F(TestMbedVirtualWatchdog, test_watchdog_stop_pass)
{
EXPECT_LE(sizeof(mbed::VirtualWatchdog), 1024);
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
EXPECT_TRUE(Watchdog::get_instance().stop());
}
TEST_F(TestWatchdog, wdog_constructor_with_default_value)
TEST_F(TestMbedVirtualWatchdog, test_watchdog_stop_fail)
{
mbed::VirtualWatchdog watchdog;
EXPECT_FALSE(Watchdog::get_instance().stop());
}
TEST_F(TestWatchdog, wdog_start_pass)
TEST_F(TestMbedVirtualWatchdog, test_mbed_wdog_manager_get_max_timeout)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
watchdog.start();
watchdog.stop();
EXPECT_EQ(0, TestWatchdog::expect_assert_count);
EXPECT_EQ(0xFFFFFFFF, Watchdog::get_instance().get_max_timeout());
}
TEST_F(TestWatchdog, wdog_kick_pass)
TEST_F(TestMbedVirtualWatchdog, test_mbed_wdog_manager_get_timeout)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
watchdog.start();
watchdog.kick();
watchdog.stop();
EXPECT_EQ(0, TestWatchdog::expect_assert_count);
EXPECT_EQ(500, Watchdog::get_instance().get_timeout());
}
TEST_F(TestWatchdog, wdog_stop_fail)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
watchdog.start();
watchdog.stop();
watchdog.stop();
EXPECT_EQ(1, TestWatchdog::expect_assert_count);
TestWatchdog::expect_assert_count = 0;
}
TEST_F(TestWatchdog, wdog_kick_fail)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
watchdog.kick();
EXPECT_EQ(1, TestWatchdog::expect_assert_count);
TestWatchdog::expect_assert_count = 0;
}
TEST_F(TestWatchdog, wdog_start_kick_pass)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
mbed::VirtualWatchdog watchdog1(600, "watchdog_unittest_1");
mbed::VirtualWatchdog watchdog2(700, "watchdog_unittest_2");
watchdog.start();
watchdog1.start();
watchdog2.start();
watchdog1.kick();
watchdog.kick();
watchdog2.kick();
watchdog1.stop();
watchdog.stop();
watchdog2.stop();
EXPECT_EQ(0, TestWatchdog::expect_assert_count);
EXPECT_EQ(0, TestWatchdog::expect_reset_count);
}
TEST_F(TestWatchdog, wdog_start_process_pass)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
watchdog.start();
watchdog.kick();
watchdog.stop();
EXPECT_EQ(0, TestWatchdog::expect_assert_count);
EXPECT_EQ(0, TestWatchdog::expect_reset_count);
}
TEST_F(TestWatchdog, wdog_start_process_fail)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
mbed::VirtualWatchdog watchdog1(500, "watchdog_unittest-1");
watchdog.start();
watchdog1.start();
watchdog1.kick();
watchdog.stop();
watchdog1.stop();
EXPECT_EQ(0, TestWatchdog::expect_assert_count);
EXPECT_EQ(1, TestWatchdog::expect_reset_count);
TestWatchdog::expect_reset_count = 0;
}
TEST_F(TestWatchdog, wdog_start_fail)
{
mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
watchdog.start();
watchdog.start();
watchdog.stop();
EXPECT_EQ(1, TestWatchdog::expect_assert_count);
TestWatchdog::expect_assert_count = 0;
}

0
UNITTESTS/platform/mbed_watchdog_mgr/VirtualWatchdog.cpp → UNITTESTS/platform/Watchdog/VirtualWatchdog.cpp
View File

0
UNITTESTS/platform/mbed_watchdog_mgr/unittest.cmake → UNITTESTS/platform/Watchdog/unittest.cmake
View File

68
UNITTESTS/platform/mbed_watchdog_mgr/test_mbed_watchdog_mgr.cpp
View File

@ -1,68 +0,0 @@
/*
* Copyright (c) 2018, Arm Limited and affiliates.
* SPDX-License-Identifier: Apache-2.0
*
* 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 "gtest/gtest.h"
#include "gmock/gmock.h"
#include "mbed_watchdog_mgr.h"
using namespace mbed;
extern bool testcase;
// AStyle ignored as the definition is not clear due to preprocessor usage
// *INDENT-OFF*
class TestMbedWatchdogMgr : public testing::Test {
protected:
void SetUp()
{
}
void TearDown()
{
}
};
// *INDENT-ON*
TEST_F(TestMbedWatchdogMgr, test_mbed_watchdog_mgr_start_pass)
{
EXPECT_TRUE(mbed_wdog_manager_start());
}
TEST_F(TestMbedWatchdogMgr, test_mbed_watchdog_mgr_start_fail)
{
EXPECT_FALSE(mbed_wdog_manager_start());
}
TEST_F(TestMbedWatchdogMgr, test_mbed_watchdog_mgr_stop_pass)
{
EXPECT_TRUE(mbed_wdog_manager_stop());
}
TEST_F(TestMbedWatchdogMgr, test_mbed_watchdog_mgr_stop_fail)
{
EXPECT_FALSE(mbed_wdog_manager_stop());
}
TEST_F(TestMbedWatchdogMgr, test_mbed_wdog_manager_get_max_timeout)
{
EXPECT_EQ(0xFFFFFFFF, mbed_wdog_manager_get_max_timeout());
}
TEST_F(TestMbedWatchdogMgr, test_mbed_wdog_manager_get_timeout)
{
EXPECT_EQ(500, mbed_wdog_manager_get_timeout());
}