unittest: move watchdog files to drivers

Test VirtualWatchdog and Watchdog

UNITTESTS/drivers/VirtualWatchdog/test_virtualwatchdog.cpp

@@ -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;
+}

UNITTESTS/drivers/VirtualWatchdog/unittest.cmake

@@ -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")

UNITTESTS/drivers/Watchdog/test_watchdog.cpp

@@ -16,123 +16,53 @@
  */
 #include "gtest/gtest.h"
 #include "gmock/gmock.h"
-#include "drivers/VirtualWatchdog.h"
+#include "Watchdog.h"
 
-class TestWatchdog : public testing::Test {
+using namespace mbed;
-public:
+extern bool testcase;
-    static uint32_t expect_assert_count;
+// AStyle ignored as the definition is not clear due to preprocessor usage
-    static uint32_t expect_reset_count;
+// *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;
+TEST_F(TestMbedVirtualWatchdog, test_watchdog_start_pass)
-uint32_t TestWatchdog::expect_reset_count = 0;
-
-void mbed_assert_internal(const char *expr, const char *file, int line)
 {
-    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);
+    EXPECT_TRUE(Watchdog::get_instance().stop());
-    mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
 }
 
-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");
+    EXPECT_EQ(0xFFFFFFFF, Watchdog::get_instance().get_max_timeout());
-    watchdog.start();
-    watchdog.stop();
-    EXPECT_EQ(0, TestWatchdog::expect_assert_count);
 }
 
-TEST_F(TestWatchdog, wdog_kick_pass)
+
+TEST_F(TestMbedVirtualWatchdog, test_mbed_wdog_manager_get_timeout)
 {
-    mbed::VirtualWatchdog watchdog(500, "watchdog_unittest");
+    EXPECT_EQ(500, Watchdog::get_instance().get_timeout());
-    watchdog.start();
-    watchdog.kick();
-    watchdog.stop();
-    EXPECT_EQ(0, TestWatchdog::expect_assert_count);
 }
 
-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;
-}

UNITTESTS/platform/mbed_watchdog_mgr/test_mbed_watchdog_mgr.cpp

@@ -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());
-}
-