From 9f9aa4a21090fa6d900899b4ed95d8b70e2faa9c Mon Sep 17 00:00:00 2001 From: Antti Kauppila Date: Thu, 30 Aug 2018 13:29:42 +0300 Subject: [PATCH] cellular unittests ported to googletest framework --- UNITTESTS/CMakeLists.txt | 21 +- .../AT_CellularBase/at_cellularbasetest.cpp | 49 - .../AT_CellularBase/test_at_cellularbase.cpp | 59 - .../at_cellularbase/at_cellularbasetest.cpp | 137 ++ .../unittest.cmake | 3 +- .../at_cellulardevicetest.cpp | 261 ++++ .../AT/at_cellulardevice/unittest.cmake | 38 + .../at_cellularinformationtest.cpp | 155 +++ .../AT/at_cellularinformation/unittest.cmake | 31 + .../at_cellularnetworktest.cpp | 1167 +++++++++++++++++ .../AT/at_cellularnetwork/unittest.cmake | 37 + .../at_cellularpower/at_cellularpowertest.cpp | 201 +++ .../AT/at_cellularpower/unittest.cmake | 31 + .../AT/at_cellularsim/at_cellularsimtest.cpp | 204 +++ .../AT/at_cellularsim/unittest.cmake | 32 + .../AT/at_cellularsms/at_cellularsmstest.cpp | 203 +++ .../AT/at_cellularsms/unittest.cmake | 33 + .../at_cellularstack/at_cellularstacktest.cpp | 377 ++++++ .../AT/at_cellularstack/unittest.cmake | 34 + .../framework/AT/athandler/athandlertest.cpp | 1022 +++++++++++++++ .../framework/AT/athandler/unittest.cmake | 41 + .../framework/common/util/test_util.cpp | 179 --- .../framework/common/util/unittest.cmake | 3 +- .../framework/common/util/utiltest.cpp | 162 ++- UNITTESTS/stubs/ATCmdParser_stub.cpp | 420 ++++++ UNITTESTS/stubs/ATHandler_stub.cpp | 82 +- UNITTESTS/stubs/ATHandler_stub.h | 22 +- UNITTESTS/stubs/AT_CellularBase_stub.cpp | 48 + UNITTESTS/stubs/AT_CellularBase_stub.h | 25 + UNITTESTS/stubs/AT_CellularDevice_stub.cpp | 91 ++ .../stubs/AT_CellularInformation_stub.cpp | 49 + .../stubs/AT_CellularMultiplexer_stub.cpp | 35 + UNITTESTS/stubs/AT_CellularNetwork_stub.cpp | 256 ++++ UNITTESTS/stubs/AT_CellularPower_stub.cpp | 81 ++ UNITTESTS/stubs/AT_CellularSIM_stub.cpp | 59 + UNITTESTS/stubs/AT_CellularSMS_stub.cpp | 190 +++ UNITTESTS/stubs/AT_CellularStack_stub.cpp | 90 ++ UNITTESTS/stubs/BufferedBlockDevice_stub.cpp | 104 ++ UNITTESTS/stubs/CellularUtil_stub.cpp | 113 ++ UNITTESTS/stubs/ChainingBlockDevice_stub.cpp | 88 ++ UNITTESTS/stubs/EventFlags_stub.cpp | 1 + .../stubs/ExhaustibleBlockDevice_stub.cpp | 88 ++ UNITTESTS/stubs/FlashSimBlockDevice_stub.cpp | 97 ++ UNITTESTS/stubs/HeapBlockDevice_stub.cpp | 82 ++ UNITTESTS/stubs/Kernel_stub.cpp | 25 + UNITTESTS/stubs/MBRBlockDevice_stub.cpp | 156 +++ UNITTESTS/stubs/NetworkInterface_stub.cpp | 89 ++ UNITTESTS/stubs/NetworkStack_stub.cpp | 95 ++ UNITTESTS/stubs/ObservingBlockDevice_stub.cpp | 100 ++ UNITTESTS/stubs/ProfilingBlockDevice_stub.cpp | 101 ++ UNITTESTS/stubs/ReadOnlyBlockDevice_stub.cpp | 95 ++ UNITTESTS/stubs/Semaphore_stub.cpp | 57 + UNITTESTS/stubs/SlicingBlockDevice_stub.cpp | 83 ++ UNITTESTS/stubs/SocketAddress_stub.cpp | 145 ++ UNITTESTS/stubs/Thread_stub.cpp | 27 + UNITTESTS/stubs/Timer_stub.cpp | 74 ++ UNITTESTS/stubs/Timer_stub.h | 24 + UNITTESTS/stubs/equeue_stub.c | 85 +- UNITTESTS/stubs/mbed_assert_stub.cpp | 24 + UNITTESTS/stubs/mbed_critical_stub.c | 115 ++ .../mbed_poll_stub.cpp} | 23 +- UNITTESTS/stubs/mbed_poll_stub.h | 27 + UNITTESTS/stubs/mbed_wait_api_stub.cpp | 30 + UNITTESTS/stubs/randLIB_stub.cpp | 27 + UNITTESTS/stubs/us_ticker_stub.cpp | 54 + UNITTESTS/target_h/ATCmdParser.h | 33 + UNITTESTS/target_h/arm_math.h | 16 + UNITTESTS/target_h/cmsis.h | 16 + UNITTESTS/target_h/cmsis_compiler.h | 16 + .../util/test_util.h => target_h/cmsis_os.h} | 25 +- UNITTESTS/target_h/cmsis_os2.h | 78 ++ UNITTESTS/target_h/mbed.h | 3 +- UNITTESTS/target_h/mbed_rtos1_types.h | 1 + UNITTESTS/target_h/mbed_rtos_storage.h | 16 +- UNITTESTS/target_h/mbed_rtx.h | 16 + UNITTESTS/target_h/mbed_rtx_conf.h | 20 + UNITTESTS/target_h/nsapi_ppp.h | 16 + UNITTESTS/target_h/platform/mbed_power_mgmt.h | 17 + UNITTESTS/target_h/platform/mbed_retarget.h | 79 ++ UNITTESTS/target_h/randLIB.h | 27 + UNITTESTS/target_h/rtos/Mutex.h | 48 + UNITTESTS/target_h/rtos/Semaphore.h | 18 + UNITTESTS/target_h/rtx_lib.h | 25 + UNITTESTS/target_h/rtx_os.h | 70 + UNITTESTS/target_h/sys/syslimits.h | 17 + 85 files changed, 8140 insertions(+), 374 deletions(-) delete mode 100644 UNITTESTS/features/cellular/framework/AT/AT_CellularBase/at_cellularbasetest.cpp delete mode 100644 UNITTESTS/features/cellular/framework/AT/AT_CellularBase/test_at_cellularbase.cpp create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellularbase/at_cellularbasetest.cpp rename UNITTESTS/features/cellular/framework/AT/{AT_CellularBase => at_cellularbase}/unittest.cmake (84%) create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellulardevice/at_cellulardevicetest.cpp create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellulardevice/unittest.cmake create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellularinformation/at_cellularinformationtest.cpp create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellularinformation/unittest.cmake create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellularnetwork/at_cellularnetworktest.cpp create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellularnetwork/unittest.cmake create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellularpower/at_cellularpowertest.cpp create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellularpower/unittest.cmake create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellularsim/at_cellularsimtest.cpp create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellularsim/unittest.cmake create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellularsms/at_cellularsmstest.cpp create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellularsms/unittest.cmake create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellularstack/at_cellularstacktest.cpp create mode 100644 UNITTESTS/features/cellular/framework/AT/at_cellularstack/unittest.cmake create mode 100644 UNITTESTS/features/cellular/framework/AT/athandler/athandlertest.cpp create mode 100644 UNITTESTS/features/cellular/framework/AT/athandler/unittest.cmake delete mode 100644 UNITTESTS/features/cellular/framework/common/util/test_util.cpp create mode 100644 UNITTESTS/stubs/ATCmdParser_stub.cpp create mode 100644 UNITTESTS/stubs/AT_CellularBase_stub.cpp create mode 100644 UNITTESTS/stubs/AT_CellularBase_stub.h create mode 100644 UNITTESTS/stubs/AT_CellularDevice_stub.cpp create mode 100644 UNITTESTS/stubs/AT_CellularInformation_stub.cpp create mode 100644 UNITTESTS/stubs/AT_CellularMultiplexer_stub.cpp create mode 100644 UNITTESTS/stubs/AT_CellularNetwork_stub.cpp create mode 100644 UNITTESTS/stubs/AT_CellularPower_stub.cpp create mode 100644 UNITTESTS/stubs/AT_CellularSIM_stub.cpp create mode 100644 UNITTESTS/stubs/AT_CellularSMS_stub.cpp create mode 100644 UNITTESTS/stubs/AT_CellularStack_stub.cpp create mode 100644 UNITTESTS/stubs/BufferedBlockDevice_stub.cpp create mode 100644 UNITTESTS/stubs/CellularUtil_stub.cpp create mode 100644 UNITTESTS/stubs/ChainingBlockDevice_stub.cpp create mode 100644 UNITTESTS/stubs/ExhaustibleBlockDevice_stub.cpp create mode 100644 UNITTESTS/stubs/FlashSimBlockDevice_stub.cpp create mode 100644 UNITTESTS/stubs/HeapBlockDevice_stub.cpp create mode 100644 UNITTESTS/stubs/Kernel_stub.cpp create mode 100644 UNITTESTS/stubs/MBRBlockDevice_stub.cpp create mode 100644 UNITTESTS/stubs/NetworkInterface_stub.cpp create mode 100644 UNITTESTS/stubs/NetworkStack_stub.cpp create mode 100644 UNITTESTS/stubs/ObservingBlockDevice_stub.cpp create mode 100644 UNITTESTS/stubs/ProfilingBlockDevice_stub.cpp create mode 100644 UNITTESTS/stubs/ReadOnlyBlockDevice_stub.cpp create mode 100644 UNITTESTS/stubs/Semaphore_stub.cpp create mode 100644 UNITTESTS/stubs/SlicingBlockDevice_stub.cpp create mode 100644 UNITTESTS/stubs/SocketAddress_stub.cpp create mode 100644 UNITTESTS/stubs/Thread_stub.cpp create mode 100644 UNITTESTS/stubs/Timer_stub.cpp create mode 100644 UNITTESTS/stubs/Timer_stub.h create mode 100644 UNITTESTS/stubs/mbed_assert_stub.cpp create mode 100644 UNITTESTS/stubs/mbed_critical_stub.c rename UNITTESTS/{features/cellular/framework/AT/AT_CellularBase/test_at_cellularbase.h => stubs/mbed_poll_stub.cpp} (63%) create mode 100644 UNITTESTS/stubs/mbed_poll_stub.h create mode 100644 UNITTESTS/stubs/mbed_wait_api_stub.cpp create mode 100644 UNITTESTS/stubs/randLIB_stub.cpp create mode 100644 UNITTESTS/stubs/us_ticker_stub.cpp create mode 100644 UNITTESTS/target_h/ATCmdParser.h create mode 100644 UNITTESTS/target_h/arm_math.h create mode 100644 UNITTESTS/target_h/cmsis.h create mode 100644 UNITTESTS/target_h/cmsis_compiler.h rename UNITTESTS/{features/cellular/framework/common/util/test_util.h => target_h/cmsis_os.h} (61%) create mode 100644 UNITTESTS/target_h/cmsis_os2.h create mode 100644 UNITTESTS/target_h/mbed_rtx.h create mode 100644 UNITTESTS/target_h/mbed_rtx_conf.h create mode 100644 UNITTESTS/target_h/nsapi_ppp.h create mode 100644 UNITTESTS/target_h/platform/mbed_power_mgmt.h create mode 100644 UNITTESTS/target_h/randLIB.h create mode 100644 UNITTESTS/target_h/rtos/Mutex.h create mode 100644 UNITTESTS/target_h/rtos/Semaphore.h create mode 100644 UNITTESTS/target_h/rtx_lib.h create mode 100644 UNITTESTS/target_h/rtx_os.h create mode 100644 UNITTESTS/target_h/sys/syslimits.h diff --git a/UNITTESTS/CMakeLists.txt b/UNITTESTS/CMakeLists.txt index 5b28cd46b6..76a0fddf4a 100644 --- a/UNITTESTS/CMakeLists.txt +++ b/UNITTESTS/CMakeLists.txt @@ -90,17 +90,35 @@ endif(COVERAGE) set(unittest-includes-base "${PROJECT_SOURCE_DIR}/target_h" "${PROJECT_SOURCE_DIR}/target_h/events" + "${PROJECT_SOURCE_DIR}/target_h/events/equeue" + "${PROJECT_SOURCE_DIR}/target_h/platform" "${PROJECT_SOURCE_DIR}/stubs" "${PROJECT_SOURCE_DIR}/.." "${PROJECT_SOURCE_DIR}/../features" + "${PROJECT_SOURCE_DIR}/../features/netsocket" "${PROJECT_SOURCE_DIR}/../platform" "${PROJECT_SOURCE_DIR}/../drivers" "${PROJECT_SOURCE_DIR}/../hal" "${PROJECT_SOURCE_DIR}/../events" + "${PROJECT_SOURCE_DIR}/../events/equeue" + "${PROJECT_SOURCE_DIR}/../rtos" "${PROJECT_SOURCE_DIR}/../rtos/TARGET_CORTEX" "${PROJECT_SOURCE_DIR}/../rtos/TARGET_CORTEX/rtx5/Include" "${PROJECT_SOURCE_DIR}/../cmsis" - "${PROJECT_SOURCE_DIR}/../features/frameworks/nanostack-libservice/mbed-client-libservice/" + "${PROJECT_SOURCE_DIR}/../features/frameworks" + "${PROJECT_SOURCE_DIR}/../features/frameworks/mbed-trace" + "${PROJECT_SOURCE_DIR}/../features/frameworks/nanostack-libservice" + "${PROJECT_SOURCE_DIR}/../features/frameworks/nanostack-libservice/mbed-client-libservice" + "${PROJECT_SOURCE_DIR}/../features/filesystem/fat" + "${PROJECT_SOURCE_DIR}/../features/filesystem/fat/ChaN" + "${PROJECT_SOURCE_DIR}/../features/filesystem/bd" + "${PROJECT_SOURCE_DIR}/../features/filesystem/" + "${PROJECT_SOURCE_DIR}/../features/filesystem/littlefs" + "${PROJECT_SOURCE_DIR}/../features/filesystem/littlefs/littlefs" + "${PROJECT_SOURCE_DIR}/../features/cellular/framework/API" + "${PROJECT_SOURCE_DIR}/../features/cellular/framework/AT" + "${PROJECT_SOURCE_DIR}/../features/cellular/framework" + "${PROJECT_SOURCE_DIR}/../features/cellular/framework/common" ) # Create a list for test suites. @@ -168,3 +186,4 @@ foreach(testfile ${unittest-file-list}) message(WARNING "No test source files found for ${TEST_SUITE_NAME}.\n") endif(unittest-test-sources) endforeach(testfile) + diff --git a/UNITTESTS/features/cellular/framework/AT/AT_CellularBase/at_cellularbasetest.cpp b/UNITTESTS/features/cellular/framework/AT/AT_CellularBase/at_cellularbasetest.cpp deleted file mode 100644 index 08ec439c7f..0000000000 --- a/UNITTESTS/features/cellular/framework/AT/AT_CellularBase/at_cellularbasetest.cpp +++ /dev/null @@ -1,49 +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 "test_at_cellularbase.h" -#include "AT_CellularBase.h" - -class TestAT_CellularBase : public testing::Test { -protected: - Test_AT_CellularBase *unit; - - virtual void SetUp() - { - unit = new Test_AT_CellularBase(); - } - - virtual void TearDown() - { - delete unit; - } -}; - -TEST_F(TestAT_CellularBase, Create) -{ - EXPECT_TRUE(unit); -} - -TEST_F(TestAT_CellularBase, test_AT_CellularBase_get_at_handler) -{ - unit->test_AT_CellularBase_get_at_handler(); -} - -TEST_F(TestAT_CellularBase, test_AT_CellularBase_get_device_error) -{ - unit->test_AT_CellularBase_get_device_error(); -} diff --git a/UNITTESTS/features/cellular/framework/AT/AT_CellularBase/test_at_cellularbase.cpp b/UNITTESTS/features/cellular/framework/AT/AT_CellularBase/test_at_cellularbase.cpp deleted file mode 100644 index 11d28a225c..0000000000 --- a/UNITTESTS/features/cellular/framework/AT/AT_CellularBase/test_at_cellularbase.cpp +++ /dev/null @@ -1,59 +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 "test_at_cellularbase.h" -#include "EventQueue.h" -#include "AT_CellularBase.h" -#include "ATHandler_stub.h" -#include "FileHandle_stub.h" -#include - -using namespace mbed; -using namespace events; - -Test_AT_CellularBase::Test_AT_CellularBase() -{ - -} - -Test_AT_CellularBase::~Test_AT_CellularBase() -{ -} - -void Test_AT_CellularBase::test_AT_CellularBase_get_at_handler() -{ - EventQueue eq; - FileHandle_stub fh; - ATHandler ah(&fh, eq, 100, ","); - AT_CellularBase at(ah); - - EXPECT_EQ(&ah, &at.get_at_handler()); -} - -void Test_AT_CellularBase::test_AT_CellularBase_get_device_error() -{ - EventQueue eq; - FileHandle_stub fh; - ATHandler ah(&fh, eq, 0, ","); - AT_CellularBase at(ah); - - ATHandler_stub::device_err_value.errCode = 8; - - EXPECT_EQ(8, at.get_device_error().errCode); - - ATHandler_stub::device_err_value.errCode = 0; -} diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularbase/at_cellularbasetest.cpp b/UNITTESTS/features/cellular/framework/AT/at_cellularbase/at_cellularbasetest.cpp new file mode 100644 index 0000000000..3537aa9c8a --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellularbase/at_cellularbasetest.cpp @@ -0,0 +1,137 @@ +/* + * 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 "AT_CellularBase.h" +#include "EventQueue.h" +#include "AT_CellularBase.h" +#include "ATHandler_stub.h" +#include "FileHandle_stub.h" +#include + +using namespace mbed; +using namespace events; + +class my_base : public AT_CellularBase { +public: + my_base(ATHandler &at) : AT_CellularBase(at) + { + } + bool check_not_supported() + { + static const AT_CellularBase::SupportedFeature unsupported_features[] = { + AT_CellularBase::AT_CGSN_WITH_TYPE, + AT_CellularBase::SUPPORTED_FEATURE_END_MARK + }; + set_unsupported_features(unsupported_features); + return is_supported(AT_CGSN_WITH_TYPE); + } + + bool check_supported() + { + set_unsupported_features(NULL); + return is_supported(AT_CGSN_WITH_TYPE); + } + + bool check_supported_not_found() + { + static const AT_CellularBase::SupportedFeature unsupported_features[] = { + AT_CellularBase::AT_CGSN_WITH_TYPE, + AT_CellularBase::SUPPORTED_FEATURE_END_MARK + }; + set_unsupported_features(unsupported_features); + return is_supported(SUPPORTED_FEATURE_END_MARK); + } +}; + +// AStyle ignored as the definition is not clear due to preprocessor usage +// *INDENT-OFF* +class TestAT_CellularBase : public testing::Test { +protected: + + void SetUp() + { + } + + void TearDown() + { + } +}; +// *INDENT-ON* + +TEST_F(TestAT_CellularBase, Create) +{ + EventQueue eq; + FileHandle_stub fh; + ATHandler ah(&fh, eq, 100, ","); + AT_CellularBase *unit = new AT_CellularBase(ah); + + EXPECT_TRUE(unit != NULL); + + delete unit; +} + +TEST_F(TestAT_CellularBase, test_AT_CellularBase_get_at_handler) +{ + EventQueue eq; + FileHandle_stub fh; + ATHandler ah(&fh, eq, 100, ","); + AT_CellularBase at(ah); + + EXPECT_TRUE(&ah == &at.get_at_handler()); +} + +TEST_F(TestAT_CellularBase, test_AT_CellularBase_get_device_error) +{ + EventQueue eq; + FileHandle_stub fh; + ATHandler ah(&fh, eq, 0, ","); + AT_CellularBase at(ah); + + ATHandler_stub::device_err_value.errCode = 8; + + EXPECT_EQ(8, at.get_device_error().errCode); + + ATHandler_stub::device_err_value.errCode = 0; +} + +TEST_F(TestAT_CellularBase, test_AT_CellularBase_set_unsupported_features) +{ + EventQueue eq; + FileHandle_stub fh; + ATHandler ah(&fh, eq, 0, ","); + AT_CellularBase at(ah); + + static const AT_CellularBase::SupportedFeature unsupported_features[] = { + AT_CellularBase::AT_CGSN_WITH_TYPE, + AT_CellularBase::SUPPORTED_FEATURE_END_MARK + }; + + at.set_unsupported_features(unsupported_features); +} + +TEST_F(TestAT_CellularBase, test_AT_CellularBase_is_supported) +{ + EventQueue eq; + FileHandle_stub fh; + ATHandler ah(&fh, eq, 0, ","); + my_base my_at(ah); + + EXPECT_TRUE(true == my_at.check_supported()); + EXPECT_TRUE(true == my_at.check_supported_not_found()); + EXPECT_TRUE(false == my_at.check_not_supported()); +} diff --git a/UNITTESTS/features/cellular/framework/AT/AT_CellularBase/unittest.cmake b/UNITTESTS/features/cellular/framework/AT/at_cellularbase/unittest.cmake similarity index 84% rename from UNITTESTS/features/cellular/framework/AT/AT_CellularBase/unittest.cmake rename to UNITTESTS/features/cellular/framework/AT/at_cellularbase/unittest.cmake index 8229144a79..b842f53743 100644 --- a/UNITTESTS/features/cellular/framework/AT/AT_CellularBase/unittest.cmake +++ b/UNITTESTS/features/cellular/framework/AT/at_cellularbase/unittest.cmake @@ -23,10 +23,9 @@ set(unittest-sources # Test files set(unittest-test-sources + features/cellular/framework/AT/at_cellularbase/at_cellularbasetest.cpp stubs/mbed_assert_stub.c stubs/ATHandler_stub.cpp stubs/EventQueue_stub.cpp stubs/FileHandle_stub.cpp - features/cellular/framework/AT/AT_CellularBase/test_at_cellularbase.cpp - features/cellular/framework/AT/AT_CellularBase/at_cellularbasetest.cpp ) diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellulardevice/at_cellulardevicetest.cpp b/UNITTESTS/features/cellular/framework/AT/at_cellulardevice/at_cellulardevicetest.cpp new file mode 100644 index 0000000000..98eae84cd7 --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellulardevice/at_cellulardevicetest.cpp @@ -0,0 +1,261 @@ +/* + * 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 "AT_CellularDevice.h" +#include "ATHandler_stub.h" +#include "AT_CellularBase_stub.h" +#include + +using namespace mbed; +using namespace events; + +class TestAT_CellularDevice : public testing::Test { +protected: + + void SetUp() { + } + + void TearDown() { + } +}; + +TEST_F(TestAT_CellularDevice, Create) +{ + EventQueue que; + AT_CellularDevice dev(que); + + CellularDevice *dev2 = new AT_CellularDevice(que); + + EXPECT_TRUE(dev2 != NULL); + delete dev2; +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_get_at_handler) +{ + EventQueue que; + AT_CellularDevice dev(que); + FileHandle_stub fh1; + FileHandle_stub fh2; + FileHandle_stub fh3; + + EXPECT_TRUE(dev.open_network(&fh1)); + EXPECT_TRUE(dev.open_sms(&fh2)); + AT_CellularBase_stub::handler_value = AT_CellularBase_stub::handler_at_constructor_value; + EXPECT_TRUE(dev.open_sim(&fh3)); + ATHandler_stub::fh_value = &fh1; + EXPECT_TRUE(dev.open_power(&fh1)); + + ATHandler_stub::fh_value = NULL; +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_open_network) +{ + EventQueue que; + AT_CellularDevice dev(que); + FileHandle_stub fh1; + + EXPECT_TRUE(!dev.open_network(NULL)); + EXPECT_TRUE(dev.open_network(&fh1)); +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_open_sms) +{ + EventQueue que; + AT_CellularDevice dev(que); + FileHandle_stub fh1; + + EXPECT_TRUE(!dev.open_sms(NULL)); + EXPECT_TRUE(dev.open_sms(&fh1)); +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_open_power) +{ + EventQueue que; + AT_CellularDevice dev(que); + FileHandle_stub fh1; + + EXPECT_TRUE(!dev.open_power(NULL)); + EXPECT_TRUE(dev.open_power(&fh1)); +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_open_sim) +{ + EventQueue que; + AT_CellularDevice dev(que); + FileHandle_stub fh1; + + EXPECT_TRUE(! dev.open_sim(NULL)); + EXPECT_TRUE(dev.open_sim(&fh1)); +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_open_information) +{ + EventQueue que; + AT_CellularDevice dev(que); + FileHandle_stub fh1; + + EXPECT_TRUE(!dev.open_information(NULL)); + EXPECT_TRUE(dev.open_information(&fh1)); +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_close_network) +{ + EventQueue que; + AT_CellularDevice dev(que); + FileHandle_stub fh1; + ATHandler_stub::ref_count = 0; + + EXPECT_TRUE(dev.open_network(&fh1)); + EXPECT_TRUE(ATHandler_stub::ref_count == 1); + + dev.close_network(); + EXPECT_TRUE(ATHandler_stub::ref_count == 0); +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_close_sms) +{ + EventQueue que; + AT_CellularDevice dev(que); + FileHandle_stub fh1; + ATHandler_stub::ref_count = 0; + + EXPECT_TRUE(dev.open_sms(&fh1)); + EXPECT_TRUE(ATHandler_stub::ref_count == 1); + + dev.close_sms(); + EXPECT_TRUE(ATHandler_stub::ref_count == 0); +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_close_power) +{ + EventQueue que; + AT_CellularDevice dev(que); + FileHandle_stub fh1; + ATHandler_stub::ref_count = 0; + + EXPECT_TRUE(dev.open_power(&fh1)); + EXPECT_TRUE(ATHandler_stub::ref_count == 1); + + dev.close_power(); + EXPECT_TRUE(ATHandler_stub::ref_count == 0); +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_close_sim) +{ + EventQueue que; + AT_CellularDevice dev(que); + FileHandle_stub fh1; + ATHandler_stub::ref_count = 0; + + + EXPECT_TRUE(dev.open_sim(&fh1)); + dev.close_sms(); // this should not affect to refcount as it's not opened + EXPECT_TRUE(ATHandler_stub::ref_count == 1); + + dev.close_sim(); + EXPECT_TRUE(ATHandler_stub::ref_count == 0); +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_close_information) +{ + EventQueue que; + AT_CellularDevice dev(que); + FileHandle_stub fh1; + ATHandler_stub::int_value = 0; + + EXPECT_TRUE(dev.open_information(&fh1)); + + ATHandler_stub::fh_value = NULL; + AT_CellularBase_stub::handler_value = NULL; + dev.close_information(); + + ATHandler_stub::fh_value = &fh1; + ATHandler at(&fh1, que, 0, ","); + AT_CellularBase_stub::handler_value = &at; + + EXPECT_TRUE(dev.open_information(&fh1)); + AT_CellularBase_stub::handler_value = AT_CellularBase_stub::handler_at_constructor_value; + + dev.close_information(); + + ATHandler_stub::fh_value = NULL; +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_set_timeout) +{ + EventQueue que; + AT_CellularDevice dev(que); + FileHandle_stub fh1; + ATHandler_stub::timeout = 0; + ATHandler_stub::default_timeout = false; + + // no interfaces open so settings timeout should not change anything + dev.set_timeout(5000); + EXPECT_TRUE(ATHandler_stub::timeout == 0); + EXPECT_TRUE(ATHandler_stub::default_timeout == false); + + EXPECT_TRUE(dev.open_sim(&fh1)); + EXPECT_TRUE(ATHandler_stub::ref_count == 1); + + dev.set_timeout(5000); + EXPECT_TRUE(ATHandler_stub::timeout == 5000); + EXPECT_TRUE(ATHandler_stub::default_timeout == true); + + dev.close_sim(); +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_modem_debug_on) +{ + EventQueue que; + AT_CellularDevice dev(que); + FileHandle_stub fh1; + ATHandler_stub::debug_on = false; + + // no interfaces open so debug toggling should not affect + dev.modem_debug_on(true); + EXPECT_TRUE(ATHandler_stub::debug_on == false); + + EXPECT_TRUE(dev.open_sim(&fh1)); + EXPECT_TRUE(ATHandler_stub::ref_count == 1); + + dev.modem_debug_on(true); + EXPECT_TRUE(ATHandler_stub::debug_on == true); + + dev.close_sim(); +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_get_stack) +{ + EventQueue que; + AT_CellularDevice dev(que); + FileHandle_stub fh1; + + NetworkStack *stack = dev.get_stack(); + EXPECT_TRUE(stack == NULL); + + EXPECT_TRUE(dev.open_network(&fh1)); + + stack = dev.get_stack(); + EXPECT_TRUE(stack == NULL); // Not in PPP so also null but this is got from the network class +} + +TEST_F(TestAT_CellularDevice, test_AT_CellularDevice_get_send_delay) +{ + EventQueue que; + AT_CellularDevice dev(que); + EXPECT_TRUE(0 == dev.get_send_delay()); +} diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellulardevice/unittest.cmake b/UNITTESTS/features/cellular/framework/AT/at_cellulardevice/unittest.cmake new file mode 100644 index 0000000000..36b69e0dbe --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellulardevice/unittest.cmake @@ -0,0 +1,38 @@ + +#################### +# UNIT TESTS +#################### + +# Unit test suite name +set(TEST_SUITE_NAME "at_cellular_device_unit") + +# Add test specific include paths +set(unittest-includes ${unittest-includes} + features/cellular/framework/common/util + ../features/cellular/framework/common + ../features/cellular/framework/AT + ../features/frameworks/mbed-client-randlib/mbed-client-randlib +) + +# Source files +set(unittest-sources + stubs/randLIB_stub.c + ../features/cellular/framework/AT/AT_CellularDevice.cpp +) + +# Test files +set(unittest-test-sources + features/cellular/framework/AT/at_cellulardevice/at_cellulardevicetest.cpp + stubs/AT_CellularNetwork_stub.cpp + stubs/ATHandler_stub.cpp + stubs/AT_CellularSMS_stub.cpp + stubs/AT_CellularSIM_stub.cpp + stubs/AT_CellularPower_stub.cpp + stubs/AT_CellularInformation_stub.cpp + stubs/CellularUtil_stub.cpp + stubs/AT_CellularBase_stub.cpp + stubs/NetworkInterface_stub.cpp + stubs/EventQueue_stub.cpp + stubs/FileHandle_stub.cpp + stubs/mbed_assert_stub.cpp +) diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularinformation/at_cellularinformationtest.cpp b/UNITTESTS/features/cellular/framework/AT/at_cellularinformation/at_cellularinformationtest.cpp new file mode 100644 index 0000000000..4f2be58fbe --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellularinformation/at_cellularinformationtest.cpp @@ -0,0 +1,155 @@ +/* + * 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 +#include "ATHandler_stub.h" +#include "EventQueue.h" +#include "FileHandle_stub.h" +#include "AT_CellularBase_stub.h" +#include "ATHandler.h" +#include "AT_CellularInformation.h" +#include "AT_CellularBase.h" + +using namespace mbed; +using namespace events; + +// AStyle ignored as the definition is not clear due to preprocessor usage +// *INDENT-OFF* +class TestAT_CellularInformation : public testing::Test { +protected: + + void SetUp() + { + } + + void TearDown() + { + } +}; +// *INDENT-ON* + +TEST_F(TestAT_CellularInformation, Create) +{ + EventQueue eq; + FileHandle_stub fh; + ATHandler ah(&fh, eq, 0, ","); + AT_CellularInformation *unit = new AT_CellularInformation(ah); + EXPECT_TRUE(unit != NULL); + delete unit; +} + +TEST_F(TestAT_CellularInformation, test_AT_CellularInformation_get_manufacturer) +{ + EventQueue eq; + FileHandle_stub fh; + ATHandler ah(&fh, eq, 0, ","); + AT_CellularInformation aci(ah); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::read_string_value = "some"; + ATHandler_stub::ssize_value = 4; + + char buf[8]; + EXPECT_TRUE(NSAPI_ERROR_OK == aci.get_manufacturer(buf, 8)); + EXPECT_TRUE(strcmp("some", buf) == 0); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + ATHandler_stub::ssize_value = -1; + buf[0] = 0; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == aci.get_manufacturer(buf, 8)); + EXPECT_TRUE(strlen(buf) == 0); +} + +TEST_F(TestAT_CellularInformation, test_AT_CellularInformation_get_model) +{ + EventQueue eq; + FileHandle_stub fh; + ATHandler ah(&fh, eq, 0, ","); + AT_CellularInformation aci(ah); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::read_string_value = "model"; + ATHandler_stub::ssize_value = 5; + char buf[8]; + EXPECT_TRUE(NSAPI_ERROR_OK == aci.get_model(buf, 8)); + EXPECT_TRUE(strcmp("model", buf) == 0); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + ATHandler_stub::ssize_value = -1; + buf[0] = 0; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == aci.get_model(buf, 8)); + EXPECT_TRUE(strlen(buf) == 0); +} + +TEST_F(TestAT_CellularInformation, test_AT_CellularInformation_get_revision) +{ + EventQueue eq; + FileHandle_stub fh; + ATHandler ah(&fh, eq, 0, ","); + + //Used heap var here to visit heap constructor + AT_CellularInformation *aci = new AT_CellularInformation(ah); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::read_string_value = "revision"; + ATHandler_stub::ssize_value = 8; + + char buf[9]; + EXPECT_TRUE(NSAPI_ERROR_OK == aci->get_revision(buf, 9)); + EXPECT_TRUE(strcmp("revision", buf) == 0); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + ATHandler_stub::ssize_value = -1; + buf[0] = 0; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == aci->get_revision(buf, 8)); + EXPECT_TRUE(strlen(buf) == 0); + + delete aci; +} + +TEST_F(TestAT_CellularInformation, test_AT_CellularInformation_get_serial_number) +{ + EventQueue eq; + FileHandle_stub fh; + ATHandler ah(&fh, eq, 0, ","); + AT_CellularInformation aci(ah); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::read_string_value = "1234567"; + ATHandler_stub::ssize_value = 7; + char buf[8]; + + EXPECT_TRUE(NSAPI_ERROR_OK == aci.get_serial_number(buf, 8, CellularInformation::SN)); + EXPECT_TRUE(strcmp("1234567", buf) == 0); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + ATHandler_stub::ssize_value = -1; + buf[0] = 0; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == aci.get_serial_number(buf, 8, CellularInformation::SN)); + EXPECT_TRUE(strlen(buf) == 0); + + AT_CellularBase_stub::supported_bool = false; + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == aci.get_serial_number(buf, 8, CellularInformation::IMEI)); + EXPECT_TRUE(strlen(buf) == 0); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::read_string_value = "1234567"; + ATHandler_stub::ssize_value = 7; + AT_CellularBase_stub::supported_bool = true; + EXPECT_TRUE(NSAPI_ERROR_OK == aci.get_serial_number(buf, 8, CellularInformation::IMEI)); + EXPECT_TRUE(strcmp("1234567", buf) == 0); +} diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularinformation/unittest.cmake b/UNITTESTS/features/cellular/framework/AT/at_cellularinformation/unittest.cmake new file mode 100644 index 0000000000..0a64cf5242 --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellularinformation/unittest.cmake @@ -0,0 +1,31 @@ + +#################### +# UNIT TESTS +#################### + +# Unit test suite name +set(TEST_SUITE_NAME "at_cellular_information_unit") + +# Add test specific include paths +set(unittest-includes ${unittest-includes} + features/cellular/framework/common/util + ../features/cellular/framework/common + ../features/cellular/framework/AT + ../features/frameworks/mbed-client-randlib/mbed-client-randlib +) + +# Source files +set(unittest-sources + stubs/randLIB_stub.c + ../features/cellular/framework/AT/AT_CellularInformation.cpp +) + +# Test files +set(unittest-test-sources + features/cellular/framework/AT//at_cellularinformation/at_cellularinformationtest.cpp + stubs/ATHandler_stub.cpp + stubs/AT_CellularBase_stub.cpp + stubs/EventQueue_stub.cpp + stubs/FileHandle_stub.cpp + stubs/mbed_assert_stub.cpp +) diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularnetwork/at_cellularnetworktest.cpp b/UNITTESTS/features/cellular/framework/AT/at_cellularnetwork/at_cellularnetworktest.cpp new file mode 100644 index 0000000000..4ff0837b16 --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellularnetwork/at_cellularnetworktest.cpp @@ -0,0 +1,1167 @@ +/* + * 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 +#include "AT_CellularNetwork.h" +#include "EventQueue.h" +#include "ATHandler.h" +#include "AT_CellularDevice.h" +#include "FileHandle_stub.h" +#include "CellularLog.h" +#include "ATHandler_stub.h" +#include "AT_CellularStack.h" + +using namespace mbed; +using namespace events; + +// AStyle ignored as the definition is not clear due to preprocessor usage +// *INDENT-OFF* +class TestAT_CellularNetwork : public testing::Test { +protected: + + void SetUp() + { + ATHandler_stub::int_count = kRead_int_table_size; + ATHandler_stub::read_string_index = kRead_string_table_size; + ATHandler_stub::resp_stop_success_count = kResp_stop_count_default; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::int_value = -1; + } + + void TearDown() + { + } +}; +// *INDENT-ON* +class my_stack : public AT_CellularStack { +public: + my_stack(ATHandler &atHandler) : AT_CellularStack(atHandler, 1, IPV4_STACK) {} + virtual int get_max_socket_count() + { + return 1; + } + virtual int get_max_packet_size() + { + return 200; + } + virtual bool is_protocol_supported(nsapi_protocol_t protocol) + { + return true; + } + virtual nsapi_error_t socket_close_impl(int sock_id) + { + return NSAPI_ERROR_OK; + } + virtual nsapi_error_t create_socket_impl(CellularSocket *socket) + { + return NSAPI_ERROR_OK; + } + virtual nsapi_size_or_error_t socket_sendto_impl(CellularSocket *socket, const SocketAddress &address, + const void *data, nsapi_size_t size) + { + return 100; + } + virtual nsapi_size_or_error_t socket_recvfrom_impl(CellularSocket *socket, SocketAddress *address, + void *buffer, nsapi_size_t size) + { + return 100; + } +}; + +class my_AT_CN : public AT_CellularNetwork { +public: + my_AT_CN(ATHandler &atHandler) : AT_CellularNetwork(atHandler) {} + virtual ~my_AT_CN() {} + NetworkStack *get_stack() + { + if (!_stack) { + return new my_stack(get_at_handler()); + } else { + return _stack; + } + } + virtual AT_CellularNetwork::RegistrationMode has_registration(RegistrationType reg_type) + { + if (reg_type == C_GREG) { + return RegistrationModeDisable; + } + return RegistrationModeEnable; + } + virtual nsapi_error_t set_access_technology_impl(RadioAccessTechnology op_rat) + { + return NSAPI_ERROR_OK; + } + virtual bool get_modem_stack_type(nsapi_ip_stack_t requested_stack) + { + if (requested_stack == IPV4_STACK || requested_stack == DEFAULT_STACK) { + return true; + } + return false; + } +}; + +class my_AT_CNipv6 : public AT_CellularNetwork { +public: + my_AT_CNipv6(ATHandler &atHandler) : AT_CellularNetwork(atHandler) {} + virtual ~my_AT_CNipv6() {} + NetworkStack *get_stack() + { + if (!_stack) { + return new my_stack(get_at_handler()); + } else { + return _stack; + } + } + virtual AT_CellularNetwork::RegistrationMode has_registration(RegistrationType reg_type) + { + if (reg_type == C_GREG) { + return RegistrationModeDisable; + } + return RegistrationModeEnable; + } + virtual nsapi_error_t set_access_technology_impl(RadioAccessTechnology op_rat) + { + return NSAPI_ERROR_OK; + } + virtual bool get_modem_stack_type(nsapi_ip_stack_t requested_stack) + { + if (requested_stack == IPV6_STACK || requested_stack == DEFAULT_STACK) { + return true; + } + return false; + } +}; + +static int network_cb_count; +static void network_cb(nsapi_event_t ev, intptr_t intptr) +{ + network_cb_count++; +} + +TEST_F(TestAT_CellularNetwork, Create) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork *cn = new AT_CellularNetwork(at); + EXPECT_TRUE(cn != NULL); + delete cn; +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_init) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + AT_CellularNetwork cn(at); + + EXPECT_TRUE(NSAPI_ERROR_OK == cn.init()); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_NO_MEMORY; + EXPECT_TRUE(NSAPI_ERROR_NO_MEMORY == cn.init()); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_set_credentials) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork *cnn = new AT_CellularNetwork(at); + delete cnn; + + AT_CellularNetwork cn(at); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn")); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP)); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, NULL)); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, NULL, NULL)); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, NULL, "passwd")); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, "user", NULL)); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, "user")); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, "user", "passwd")); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", NULL)); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", NULL, NULL)); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", NULL, "passwd")); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", "user", NULL)); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", "user")); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", "user", "passwd")); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_activate_context) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + my_AT_CN my_cn(at); + my_AT_CNipv6 my_cnipv6(at); + + // get_context return true and new context created. But now stack and so error. + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.activate_context()); + + // get_context return true and new context created, also do_user_authentication called with success. + // But now stack and so error. + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, "user", "passwd")); + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.activate_context()); + + // get_context return true and new context created, also do_user_authentication called with failure. + ATHandler_stub::resp_stop_success_count = 2; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP, "user", "passwd")); + EXPECT_TRUE(NSAPI_ERROR_AUTH_FAILURE == cn.activate_context()); + + + // get_context return true and new context created, also do_user_authentication called with success. + // Now there is stack. + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + ATHandler_stub::resp_stop_success_count = kResp_stop_count_default; + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials("apn", CellularNetwork::CHAP, "user", "passwd")); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.activate_context()); + + // get_context return true and new context created, test delete context + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + ATHandler_stub::resp_stop_success_count = kResp_stop_count_default; + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials("apn", CellularNetwork::CHAP, "user", "passwd")); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.activate_context()); + + + + // get_context pdp type gives zero len, fails with no stack + ATHandler_stub::resp_info_true_counter = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + ATHandler_stub::read_string_index = 1; + ATHandler_stub::read_string_table[0] = ""; + ATHandler_stub::int_value = 1; + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.activate_context()); + + // get_context pdp type gives proper type, apn reading fails + ATHandler_stub::resp_info_true_counter = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + ATHandler_stub::read_string_index = 1; + ATHandler_stub::read_string_table[0] = "IPV6"; + ATHandler_stub::int_value = 1; + EXPECT_TRUE(NSAPI_ERROR_NO_CONNECTION == cn.activate_context()); + + // get_context pdp type gives proper type, apn does not match, now other contexts so new one created + ATHandler_stub::resp_info_true_counter = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + ATHandler_stub::read_string_index = 2; + ATHandler_stub::read_string_table[0] = "internet"; + ATHandler_stub::read_string_table[1] = "IP"; + ATHandler_stub::int_value = 1; + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials("apn", CellularNetwork::CHAP, "user", "passwd")); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.activate_context()); + + // get_context pdp type gives proper type, apn match + ATHandler_stub::resp_info_true_counter = 2; // set to 2 so cgact will give that this context is active + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + ATHandler_stub::read_string_index = 2; + ATHandler_stub::read_string_table[0] = "internet"; + ATHandler_stub::read_string_table[1] = "IPV4V6"; + ATHandler_stub::int_value = 1; + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_stack_type(IPV4_STACK)); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials("internet")); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.activate_context()); + + // get_context pdp type gives proper type, apn match + ATHandler_stub::resp_info_true_counter = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + ATHandler_stub::read_string_index = 2; + ATHandler_stub::read_string_table[0] = "internet"; + ATHandler_stub::read_string_table[1] = "IPV6"; + ATHandler_stub::int_value = 1; + EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.set_stack_type(IPV6_STACK)); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.set_credentials("internet")); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.activate_context()); + + // get_context pdp type gives proper type, apn match + ATHandler_stub::resp_info_true_counter = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + ATHandler_stub::read_string_index = 2; + ATHandler_stub::read_string_table[0] = "internet"; + ATHandler_stub::read_string_table[1] = "IPV4V6"; + ATHandler_stub::int_value = 1; + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_stack_type(DEFAULT_STACK)); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials("internet")); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.activate_context()); + + // get_context pdp type gives proper type, apn match + ATHandler_stub::resp_info_true_counter = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + ATHandler_stub::read_string_index = 2; + ATHandler_stub::read_string_table[0] = "internet"; + ATHandler_stub::read_string_table[1] = "IPV4V6"; + ATHandler_stub::int_value = 1; + EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.set_stack_type(DEFAULT_STACK)); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.set_credentials("internet")); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.activate_context()); + + // get_context pdp type gives proper type, apn match + ATHandler_stub::resp_info_true_counter = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + ATHandler_stub::read_string_index = 2; + ATHandler_stub::read_string_table[0] = "internet"; + ATHandler_stub::read_string_table[1] = "IPV6"; + ATHandler_stub::int_value = 1; + EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.set_stack_type(DEFAULT_STACK)); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.set_credentials("internet")); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cnipv6.activate_context()); + + // get_context pdp type gives proper type, apn match + ATHandler_stub::resp_info_true_counter = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + ATHandler_stub::read_string_index = 2; + ATHandler_stub::read_string_table[0] = "internet"; + ATHandler_stub::read_string_table[1] = "IP"; + ATHandler_stub::int_value = 1; + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_stack_type(DEFAULT_STACK)); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials("internet")); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.activate_context()); + + // get_context pdp type gives proper type, apn match. Test Delete the created context. + ATHandler_stub::resp_info_true_counter = 0; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + ATHandler_stub::int_value = 1; + //ATHandler_stub::nsapi_error_ok_counter = 2; + ATHandler_stub::resp_stop_success_count = 2; + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_credentials(NULL, NULL, NULL)); + EXPECT_TRUE(NSAPI_ERROR_NO_CONNECTION == my_cn.activate_context()); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_connect) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + // no stack so will fail + cn.attach(&network_cb); + network_cb_count = 0; + + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.connect("APN", "a", "b")); + EXPECT_TRUE(NSAPI_STATUS_DISCONNECTED == cn.get_connection_status()); + EXPECT_TRUE(network_cb_count == 2); + + network_cb_count = 0; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_NO_CONNECTION == cn.connect("APN")); + EXPECT_TRUE(network_cb_count == 2); + EXPECT_TRUE(NSAPI_STATUS_DISCONNECTED == cn.get_connection_status()); + + my_AT_CN my_cn(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + cn.set_stack_type(IPV4_STACK); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.connect()); + EXPECT_TRUE(network_cb_count == 2); + EXPECT_TRUE(NSAPI_STATUS_GLOBAL_UP == my_cn.get_connection_status()); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_disconnect) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.disconnect()); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_stack) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + my_AT_CN my_cn(at); + my_stack *mystack = (my_stack *)my_cn.get_stack(); + EXPECT_TRUE(mystack); + delete mystack; +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_set_registration) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration()); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration()); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration("12345")); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration("12345")); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_registration_status) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::int_value = 3; + CellularNetwork::RegistrationStatus stat = CellularNetwork::NotRegistered; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_registration_status(CellularNetwork::C_EREG, stat)); + EXPECT_TRUE(stat == CellularNetwork::RegistrationDenied); + stat = CellularNetwork::NotRegistered; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_registration_status(CellularNetwork::C_GREG, stat)); + EXPECT_TRUE(stat == CellularNetwork::RegistrationDenied); + + my_AT_CN nw(at); + stat = CellularNetwork::NotRegistered; + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == nw.get_registration_status(CellularNetwork::C_GREG, stat)); + EXPECT_TRUE(stat == CellularNetwork::NotRegistered); + EXPECT_TRUE(NSAPI_ERROR_OK == nw.get_registration_status(CellularNetwork::C_EREG, stat)); + EXPECT_TRUE(stat == CellularNetwork::RegistrationDenied); + + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + stat = CellularNetwork::NotRegistered; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_registration_status(CellularNetwork::C_EREG, stat)); + EXPECT_TRUE(stat == -1); + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_registration_status(CellularNetwork::C_GREG, stat)); + EXPECT_TRUE(stat == -1); + + stat = CellularNetwork::NotRegistered; + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == nw.get_registration_status(CellularNetwork::C_GREG, stat)); + EXPECT_TRUE(stat == CellularNetwork::NotRegistered); + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == nw.get_registration_status(CellularNetwork::C_EREG, stat)); + EXPECT_TRUE(stat == -1); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_network_registering_mode) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + + ATHandler_stub::int_value = 0; + CellularNetwork::NWRegisteringMode mode = CellularNetwork::NWModeManual; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_network_registering_mode(mode)); + EXPECT_TRUE(mode == CellularNetwork::NWModeAutomatic); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + mode = CellularNetwork::NWModeManual; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_network_registering_mode(mode)); + EXPECT_TRUE(mode == -1); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_set_registration_urc) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + + CellularNetwork::RegistrationType type = CellularNetwork::C_EREG; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration_urc(type, true)); + type = CellularNetwork::C_GREG; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration_urc(type, true)); + type = CellularNetwork::C_REG; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration_urc(type, true)); + + my_AT_CN nw(at); + type = CellularNetwork::C_EREG; + EXPECT_TRUE(NSAPI_ERROR_OK == nw.set_registration_urc(type, true)); + type = CellularNetwork::C_GREG; + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == nw.set_registration_urc(type, true)); + type = CellularNetwork::C_REG; + EXPECT_TRUE(NSAPI_ERROR_OK == nw.set_registration_urc(type, true)); + + type = CellularNetwork::C_EREG; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration_urc(type, false)); + type = CellularNetwork::C_GREG; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration_urc(type, false)); + type = CellularNetwork::C_REG; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_registration_urc(type, false)); + + type = CellularNetwork::C_EREG; + EXPECT_TRUE(NSAPI_ERROR_OK == nw.set_registration_urc(type, false)); + type = CellularNetwork::C_GREG; + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == nw.set_registration_urc(type, false)); + type = CellularNetwork::C_REG; + EXPECT_TRUE(NSAPI_ERROR_OK == nw.set_registration_urc(type, false)); + + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + type = CellularNetwork::C_EREG; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration_urc(type, true)); + type = CellularNetwork::C_GREG; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration_urc(type, true)); + type = CellularNetwork::C_REG; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration_urc(type, true)); + + type = CellularNetwork::C_EREG; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == nw.set_registration_urc(type, true)); + type = CellularNetwork::C_GREG; + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == nw.set_registration_urc(type, true)); + type = CellularNetwork::C_REG; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == nw.set_registration_urc(type, true)); + + type = CellularNetwork::C_EREG; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration_urc(type, false)); + type = CellularNetwork::C_GREG; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration_urc(type, false)); + type = CellularNetwork::C_REG; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_registration_urc(type, false)); + + type = CellularNetwork::C_EREG; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == nw.set_registration_urc(type, false)); + type = CellularNetwork::C_GREG; + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == nw.set_registration_urc(type, false)); + type = CellularNetwork::C_REG; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == nw.set_registration_urc(type, false)); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_set_attach) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + ATHandler_stub::int_value = 0; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_attach()); + ATHandler_stub::int_value = 1; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_attach()); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_attach()); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_attach) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + CellularNetwork::AttachStatus stat = CellularNetwork::Detached; + ATHandler_stub::int_value = 1; + ATHandler_stub::bool_value = true; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_attach(stat)); + EXPECT_TRUE(stat == CellularNetwork::Attached); + + ATHandler_stub::int_value = 0; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_attach(stat)); + EXPECT_TRUE(stat == CellularNetwork::Detached); + + stat = CellularNetwork::Attached; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_attach(stat)); + EXPECT_TRUE(stat == CellularNetwork::Detached); + + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_attach(stat)); + EXPECT_TRUE(stat == CellularNetwork::Detached); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + ATHandler_stub::bool_value = false; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_attach(stat)); + EXPECT_TRUE(stat == CellularNetwork::Detached); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_detach) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + my_AT_CN cn(at); + + EXPECT_TRUE(NSAPI_ERROR_OK == cn.detach()); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.detach()); + + // connect so we can test callback in detach + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + cn.set_stack_type(IPV4_STACK); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.connect()); + EXPECT_TRUE(NSAPI_STATUS_GLOBAL_UP == cn.get_connection_status()); + // attach callback + cn.attach(&network_cb); + network_cb_count = 0; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.detach()); + EXPECT_TRUE(network_cb_count == 1); + EXPECT_TRUE(NSAPI_STATUS_DISCONNECTED == cn.get_connection_status()); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_rate_control) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + int ur = -1; + CellularNetwork::RateControlExceptionReports reports = CellularNetwork::NotAllowedToBeSent; + CellularNetwork::RateControlUplinkTimeUnit timeUnit = CellularNetwork::Unrestricted; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_rate_control(reports, timeUnit, ur)); + EXPECT_TRUE(reports == CellularNetwork::NotAllowedToBeSent); + EXPECT_TRUE(timeUnit == CellularNetwork::Unrestricted); + EXPECT_TRUE(ur == -1); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::int_value = 1; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_rate_control(reports, timeUnit, ur)); + EXPECT_TRUE(reports == CellularNetwork::AllowedToBeSent); + EXPECT_TRUE(timeUnit == CellularNetwork::Minute); + EXPECT_TRUE(ur == 1); + + // test second if in get_rate_control + reports = CellularNetwork::NotAllowedToBeSent; + timeUnit = CellularNetwork::Unrestricted; + ur = -1; + + ATHandler_stub::int_count = 1; + ATHandler_stub::int_valid_count_table[0] = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_rate_control(reports, timeUnit, ur)); + EXPECT_TRUE(reports == CellularNetwork::NotAllowedToBeSent); + EXPECT_TRUE(timeUnit == CellularNetwork::Unrestricted); + EXPECT_TRUE(ur == -1); + + // test second if in get_rate_control + ATHandler_stub::int_count = 2; + ATHandler_stub::int_valid_count_table[0] = 1; + ATHandler_stub::int_valid_count_table[1] = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_rate_control(reports, timeUnit, ur)); + EXPECT_TRUE(reports == CellularNetwork::AllowedToBeSent); + EXPECT_TRUE(timeUnit == CellularNetwork::Unrestricted); + EXPECT_TRUE(ur == -1); + + // test third if in get_rate_control + ATHandler_stub::int_count = 3; + ATHandler_stub::int_valid_count_table[0] = 3; + ATHandler_stub::int_valid_count_table[1] = 1; + ATHandler_stub::int_valid_count_table[2] = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_rate_control(reports, timeUnit, ur)); + EXPECT_TRUE(reports == CellularNetwork::AllowedToBeSent); + EXPECT_TRUE(timeUnit == CellularNetwork::Day); + EXPECT_TRUE(ur == -1); + + ATHandler_stub::int_count = 4; + ATHandler_stub::int_valid_count_table[0] = 5; + ATHandler_stub::int_valid_count_table[1] = 3; + ATHandler_stub::int_valid_count_table[2] = 1; + ATHandler_stub::int_valid_count_table[3] = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_rate_control(reports, timeUnit, ur)); + EXPECT_TRUE(reports == CellularNetwork::AllowedToBeSent); + EXPECT_TRUE(timeUnit == CellularNetwork::Day); + EXPECT_TRUE(ur == 5); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_apn_backoff_timer) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + int time = -1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_PARAMETER == cn.get_apn_backoff_timer(time)); + EXPECT_TRUE(time == -1); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_PARAMETER == cn.get_apn_backoff_timer(time)); + EXPECT_TRUE(time == -1); + + ATHandler_stub::resp_info_true_counter = 0; + ATHandler_stub::bool_value = false; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + cn.set_credentials("internet", NULL, NULL); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_apn_backoff_timer(time)); + EXPECT_TRUE(time == -1); + + ATHandler_stub::resp_info_true_counter = 0; + ATHandler_stub::bool_value = true; + ATHandler_stub::int_value = 55; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + cn.set_credentials("internet", NULL, NULL); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_apn_backoff_timer(time)); + EXPECT_TRUE(time == 55); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_ip_address) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + EXPECT_TRUE(!cn.get_ip_address()); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_set_access_technology) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.set_access_technology(CellularNetwork::RAT_UNKNOWN)); + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.set_access_technology(CellularNetwork::RAT_GSM_COMPACT)); + + my_AT_CN my_cn(at); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_access_technology(CellularNetwork::RAT_GSM_COMPACT)); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_access_technology) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + CellularNetwork::RadioAccessTechnology rat; + + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_access_technology(rat)); + EXPECT_TRUE(CellularNetwork::RAT_UNKNOWN == rat); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_scan_plmn) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + int c = -1; + CellularNetwork::operList_t ops; + ATHandler_stub::bool_value = false; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.scan_plmn(ops, c)); + EXPECT_TRUE(c == 0); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.scan_plmn(ops, c)); + EXPECT_TRUE(c == 0); + + + ATHandler_stub::read_string_index = 3; + ATHandler_stub::read_string_table[0] = "44444"; + ATHandler_stub::read_string_table[1] = "33333"; + ATHandler_stub::read_string_table[2] = "12345"; + ATHandler_stub::int_value = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::info_elem_true_counter = 1; + ATHandler_stub::bool_value = false; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.scan_plmn(ops, c)); + EXPECT_TRUE(c == 1); + EXPECT_TRUE(ops.get_head() != NULL); + CellularNetwork::operator_t *op = ops.get_head(); + EXPECT_TRUE(op->op_status == CellularNetwork::operator_t::Available); + EXPECT_TRUE(strcmp(op->op_long, "12345") == 0); + EXPECT_TRUE(strcmp(op->op_short, "33333") == 0); + EXPECT_TRUE(strcmp(op->op_num, "44444") == 0); + ops.delete_all(); + + ATHandler_stub::read_string_index = 3; + ATHandler_stub::int_value = 6; // RAT_HSDPA_HSUPA + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::info_elem_true_counter = 1; + ATHandler_stub::bool_value = false; + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.set_access_technology(CellularNetwork::RAT_UTRAN)); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.scan_plmn(ops, c)); + EXPECT_TRUE(c == 0); + EXPECT_TRUE(ops.get_head() == NULL); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_set_ciot_optimization_config) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_ciot_optimization_config(CellularNetwork::SUPPORTED_UE_OPT_NO_SUPPORT, CellularNetwork::PREFERRED_UE_OPT_NO_PREFERENCE)); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.set_ciot_optimization_config(CellularNetwork::SUPPORTED_UE_OPT_NO_SUPPORT, CellularNetwork::PREFERRED_UE_OPT_NO_PREFERENCE)); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_ciot_optimization_config) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + CellularNetwork::Supported_UE_Opt sup = CellularNetwork::SUPPORTED_UE_OPT_NO_SUPPORT; + CellularNetwork::Preferred_UE_Opt pref = CellularNetwork::PREFERRED_UE_OPT_NO_PREFERENCE; + ATHandler_stub::int_value = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_ciot_optimization_config(sup, pref)); + EXPECT_TRUE(sup == CellularNetwork::SUPPORTED_UE_OPT_CONTROL_PLANE); + EXPECT_TRUE(pref == CellularNetwork::PREFERRED_UE_OPT_CONTROL_PLANE); + + sup = CellularNetwork::SUPPORTED_UE_OPT_NO_SUPPORT; + pref = CellularNetwork::PREFERRED_UE_OPT_NO_PREFERENCE; + ATHandler_stub::int_value = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_ciot_optimization_config(sup, pref)); + EXPECT_TRUE(sup == CellularNetwork::SUPPORTED_UE_OPT_NO_SUPPORT); + EXPECT_TRUE(pref == CellularNetwork::PREFERRED_UE_OPT_NO_PREFERENCE); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_set_stack_type) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + EXPECT_TRUE(NSAPI_ERROR_PARAMETER == cn.set_stack_type(IPV4_STACK)); + + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_stack_type(DEFAULT_STACK)); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_stack_type) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + EXPECT_TRUE(DEFAULT_STACK == cn.get_stack_type()); + + my_AT_CN my_cn(at); + EXPECT_TRUE(DEFAULT_STACK == my_cn.get_stack_type()); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.set_stack_type(IPV4_STACK)); + EXPECT_TRUE(DEFAULT_STACK == my_cn.get_stack_type()); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_pdpcontext_params) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + CellularNetwork::pdpContextList_t list; + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_pdpcontext_params(list)); + + // don't got to while loop + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + ATHandler_stub::resp_info_true_counter = 0; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_pdpcontext_params(list)); + EXPECT_TRUE(NULL == list.get_head()); + + // go to while loop and check values + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::resp_info_true_counter = 1; + ATHandler_stub::int_count = 9; + ATHandler_stub::int_valid_count_table[8] = 1; + ATHandler_stub::int_valid_count_table[7] = 2; + ATHandler_stub::int_valid_count_table[6] = 3; + ATHandler_stub::int_valid_count_table[5] = 4; + ATHandler_stub::int_valid_count_table[4] = 5; + ATHandler_stub::int_valid_count_table[3] = 6; + ATHandler_stub::int_valid_count_table[2] = 7; + ATHandler_stub::int_valid_count_table[1] = 8; + ATHandler_stub::int_valid_count_table[0] = 9; + + ATHandler_stub::read_string_index = 7; + ATHandler_stub::read_string_table[6] = "internet"; + ATHandler_stub::read_string_table[5] = "1.2.3.4.5.6.7.8.9.10.11.112.13.14.15.16.1.2.3.44.55.6.7.8.9.10.11.12.13.14.15.16"; + ATHandler_stub::read_string_table[4] = "23.33.44.1.2.3.55.123.225.34.11.1.0.0.123.234"; + ATHandler_stub::read_string_table[3] = "1.2.3.4"; + ATHandler_stub::read_string_table[2] = "0.255.0.255"; + ATHandler_stub::read_string_table[1] = "25.66.77.88"; + ATHandler_stub::read_string_table[0] = "004.003.002.001"; + + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_pdpcontext_params(list)); + CellularNetwork::pdpcontext_params_t *params = list.get_head(); + EXPECT_TRUE(params != NULL); + EXPECT_TRUE(params->next == NULL); + EXPECT_TRUE(params->cid == 1); + EXPECT_TRUE(params->bearer_id == 2); + EXPECT_TRUE(params->im_signalling_flag == 3); + EXPECT_TRUE(params->lipa_indication == 4); + EXPECT_TRUE(params->ipv4_mtu == 5); + EXPECT_TRUE(params->wlan_offload == 6); + EXPECT_TRUE(params->local_addr_ind == 7); + EXPECT_TRUE(params->non_ip_mtu == 8); + EXPECT_TRUE(params->serving_plmn_rate_control_value == 9); + EXPECT_TRUE(strcmp(params->apn, "internet") == 0); + EXPECT_TRUE(strcmp(params->local_addr, "102:304:506:708:90A:B70:D0E:F10") == 0); + EXPECT_TRUE(strcmp(params->local_subnet_mask, "102:32C:3706:708:90A:B0C:D0E:F10") == 0); + EXPECT_TRUE(strcmp(params->gateway_addr, "1721:2C01:203:377B:E122:B01:000:7BEA") == 0); + EXPECT_TRUE(strcmp(params->dns_primary_addr, "1.2.3.4") == 0); + EXPECT_TRUE(strcmp(params->dns_secondary_addr, "0.255.0.255") == 0); + EXPECT_TRUE(strcmp(params->p_cscf_prim_addr, "25.66.77.88") == 0); + EXPECT_TRUE(strcmp(params->p_cscf_sec_addr, "004.003.002.001") == 0); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_extended_signal_quality) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + int rx = -1, be = -1, rs = -1, ec = -1, rsrq = -1, rsrp = -1; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_extended_signal_quality(rx, be, rs, ec, rsrq, rsrp)); + EXPECT_TRUE(rx == -1 && be == -1 && rs == -1 && ec == -1 && rsrq == -1 && rsrp == -1); + + ATHandler_stub::int_value = 5; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_extended_signal_quality(rx, be, rs, ec, rsrq, rsrp)); + EXPECT_TRUE(rx == 5 && be == 5 && rs == 5 && ec == 5 && rsrq == 5 && rsrp == 5); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_signal_quality) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + int rs = -1, ber = -1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_signal_quality(rs, ber)); + EXPECT_TRUE(rs == -1 && ber == -1); + + ATHandler_stub::int_value = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_signal_quality(rs, ber)); + EXPECT_TRUE(rs == 1 && ber == 1); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_cell_id) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + int id = 0; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_cell_id(id)); + EXPECT_TRUE(id == -1); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_cell_id(id)); + EXPECT_TRUE(id == -1); + + ATHandler_stub::read_string_index = 2; + ATHandler_stub::read_string_table[1] = "00C3"; + ATHandler_stub::read_string_table[0] = "1234FFC1"; //== cellid and in dec: 305463233 + ATHandler_stub::int_value = 1; + // Get registration status to modify cell_id + CellularNetwork::RegistrationType type; + CellularNetwork::RegistrationStatus status; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_registration_status(CellularNetwork::C_EREG, status)); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_cell_id(id)); + EXPECT_TRUE(id == 305463233); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_3gpp_error) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + ATHandler_stub::int_value = 8; + EXPECT_TRUE(8 == cn.get_3gpp_error()); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_operator_params) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + int format; + CellularNetwork::operator_t ops; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_operator_params(format, ops)); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::int_value = 0; + ATHandler_stub::read_string_index = 1; + ATHandler_stub::read_string_table[0] = "12345"; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_operator_params(format, ops)); + EXPECT_TRUE(format == 0); + EXPECT_TRUE(strcmp(ops.op_long, "12345") == 0); + EXPECT_TRUE(strlen(ops.op_short) == 0); + EXPECT_TRUE(strlen(ops.op_num) == 0); + EXPECT_TRUE(ops.op_rat == CellularNetwork::RAT_GSM); + + ops.op_long[0] = 0; + ATHandler_stub::int_value = 1; + ATHandler_stub::read_string_index = 1; + ATHandler_stub::read_string_table[0] = "12345"; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_operator_params(format, ops)); + EXPECT_TRUE(format == 1); + EXPECT_TRUE(strlen(ops.op_long) == 0); + EXPECT_TRUE(strcmp(ops.op_short, "12345") == 0); + EXPECT_TRUE(strlen(ops.op_num) == 0); + EXPECT_TRUE(ops.op_rat == CellularNetwork::RAT_GSM_COMPACT); + + ops.op_short[0] = 0; + ATHandler_stub::int_value = 2; + ATHandler_stub::read_string_index = 1; + ATHandler_stub::read_string_table[0] = "12345"; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_operator_params(format, ops)); + EXPECT_TRUE(format == 2); + EXPECT_TRUE(strlen(ops.op_long) == 0); + EXPECT_TRUE(strlen(ops.op_short) == 0); + EXPECT_TRUE(strcmp(ops.op_num, "12345") == 0); + EXPECT_TRUE(ops.op_rat == CellularNetwork::RAT_UTRAN); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_get_operator_names) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + CellularNetwork::operator_names_list name_list; + + ATHandler_stub::resp_info_true_counter = 0; + ATHandler_stub::bool_value = false; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_operator_names(name_list)); + EXPECT_TRUE(name_list.get_head() == NULL); + + ATHandler_stub::resp_info_true_counter = 1; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == cn.get_operator_names(name_list)); + EXPECT_TRUE(name_list.get_head() != NULL); + EXPECT_TRUE(name_list.get_head()->next == NULL); + + ATHandler_stub::resp_info_true_counter = 1; + ATHandler_stub::bool_value = false; + ATHandler_stub::read_string_index = 2; + ATHandler_stub::read_string_table[1] = "12345"; + ATHandler_stub::read_string_table[0] = "56789"; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + name_list.delete_all(); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.get_operator_names(name_list)); + CellularNetwork::operator_names_t *op_names = name_list.get_head(); + EXPECT_TRUE(op_names != NULL); + EXPECT_TRUE(op_names->next == NULL); + EXPECT_TRUE(strcmp(op_names->numeric, "12345") == 0); + EXPECT_TRUE(strcmp(op_names->alpha, "56789") == 0); +} + +TEST_F(TestAT_CellularNetwork, test_AT_CellularNetwork_attach) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + network_cb_count = 0; + cn.attach(&network_cb); + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.connect()); + EXPECT_TRUE(network_cb_count == 2); // check that attached callback was called twice +} + +TEST_F(TestAT_CellularNetwork, test_get_connection_status) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + network_cb_count = 0; + cn.attach(&network_cb); + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == cn.connect()); + EXPECT_TRUE(network_cb_count == 2); // check that attached callback was called twice + EXPECT_TRUE(NSAPI_STATUS_DISCONNECTED == cn.get_connection_status()); + + my_AT_CN my_cn(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::bool_value = false; + cn.set_stack_type(IPV4_STACK); + EXPECT_TRUE(NSAPI_ERROR_OK == my_cn.connect()); + EXPECT_TRUE(network_cb_count == 2); + EXPECT_TRUE(NSAPI_STATUS_GLOBAL_UP == my_cn.get_connection_status()); +} + +TEST_F(TestAT_CellularNetwork, test_set_blocking) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularNetwork cn(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_blocking(false)); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_blocking(true)); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_blocking(false)); + EXPECT_TRUE(NSAPI_ERROR_OK == cn.set_blocking(true)); +} + diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularnetwork/unittest.cmake b/UNITTESTS/features/cellular/framework/AT/at_cellularnetwork/unittest.cmake new file mode 100644 index 0000000000..e41cf3c6de --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellularnetwork/unittest.cmake @@ -0,0 +1,37 @@ + +#################### +# UNIT TESTS +#################### + +# Unit test suite name +set(TEST_SUITE_NAME "at_cellular_network_unit") + +# Add test specific include paths +set(unittest-includes ${unittest-includes} + features/cellular/framework/common/util + ../features/cellular/framework/common + ../features/cellular/framework/AT + ../features/frameworks/mbed-client-randlib/mbed-client-randlib +) + +# Source files +set(unittest-sources + ../features/cellular/framework/AT/AT_CellularNetwork.cpp + ../features/cellular/framework/AT/AT_CellularStack.cpp + ../features/cellular/framework/common/CellularUtil.cpp +) + +# Test files +set(unittest-test-sources + features/cellular/framework/AT/at_cellularnetwork/at_cellularnetworktest.cpp + stubs/ATHandler_stub.cpp + stubs/AT_CellularBase_stub.cpp + stubs/EventQueue_stub.cpp + stubs/FileHandle_stub.cpp + stubs/NetworkInterface_stub.cpp + stubs/NetworkStack_stub.cpp + stubs/us_ticker_stub.cpp + stubs/mbed_assert_stub.cpp + stubs/SocketAddress_stub.cpp + stubs/randLIB_stub.cpp +) diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularpower/at_cellularpowertest.cpp b/UNITTESTS/features/cellular/framework/AT/at_cellularpower/at_cellularpowertest.cpp new file mode 100644 index 0000000000..48b67abd2f --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellularpower/at_cellularpowertest.cpp @@ -0,0 +1,201 @@ +/* + * 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 +#include "AT_CellularNetwork.h" +#include "EventQueue.h" +#include "ATHandler.h" +#include "AT_CellularPower.h" +#include "FileHandle_stub.h" +#include "ATHandler_stub.h" + +using namespace mbed; +using namespace events; + +// AStyle ignored as the definition is not clear due to preprocessor usage +// *INDENT-OFF* +class TestAT_CellularPower : public testing::Test { +protected: + + void SetUp() { + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + } + + void TearDown() { + } +}; +// *INDENT-ON* + + +static void device_ready_cb() +{ +} + +TEST_F(TestAT_CellularPower, Create) +{ + + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularPower *pow = new AT_CellularPower(at); + + EXPECT_TRUE(pow != NULL); + + delete pow; +} + +TEST_F(TestAT_CellularPower, test_AT_CellularPower_on) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularPower pow(at); + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == pow.on()); +} + +TEST_F(TestAT_CellularPower, test_AT_CellularPower_off) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularPower pow(at); + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == pow.off()); +} + +TEST_F(TestAT_CellularPower, test_AT_CellularPower_set_at_mode) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularPower pow(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == pow.set_at_mode()); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == pow.set_at_mode()); +} + +TEST_F(TestAT_CellularPower, test_AT_CellularPower_set_power_level) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularPower pow(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == pow.set_power_level(6)); + EXPECT_TRUE(NSAPI_ERROR_OK == pow.set_power_level(1, 1)); + EXPECT_TRUE(NSAPI_ERROR_OK == pow.set_power_level(1, 0)); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == pow.set_power_level(6)); +} + +TEST_F(TestAT_CellularPower, test_AT_CellularPower_reset) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularPower pow(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == pow.reset()); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == pow.reset()); +} + +TEST_F(TestAT_CellularPower, test_AT_CellularPower_opt_power_save_mode) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularPower pow(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == pow.opt_power_save_mode(0, 0)); + + EXPECT_TRUE(NSAPI_ERROR_OK == pow.opt_power_save_mode(10, 0)); + + EXPECT_TRUE(NSAPI_ERROR_OK == pow.opt_power_save_mode(912, 0)); + + EXPECT_TRUE(NSAPI_ERROR_OK == pow.opt_power_save_mode(1834, 1834)); + + EXPECT_TRUE(NSAPI_ERROR_OK == pow.opt_power_save_mode(18345, 18345)); + + EXPECT_TRUE(NSAPI_ERROR_OK == pow.opt_power_save_mode(101234, 101234)); + + EXPECT_TRUE(NSAPI_ERROR_OK == pow.opt_power_save_mode(1012345, 1012345)); + + EXPECT_TRUE(NSAPI_ERROR_OK == pow.opt_power_save_mode(39612345, 39612345)); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == pow.opt_power_save_mode(0, 0)); +} + +TEST_F(TestAT_CellularPower, test_AT_CellularPower_opt_receive_period) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularPower pow(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == pow.opt_receive_period(1, CellularPower::EDRXUTRAN_Iu_mode, 3)); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == pow.opt_receive_period(1, CellularPower::EDRXUTRAN_Iu_mode, 3)); +} + +TEST_F(TestAT_CellularPower, test_AT_CellularPower_is_device_ready) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularPower pow(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE; + EXPECT_TRUE(NSAPI_ERROR_AUTH_FAILURE == pow.is_device_ready()); +} + +TEST_F(TestAT_CellularPower, test_AT_CellularPower_set_device_ready_urc_cb) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularPower pow(at); + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == pow.set_device_ready_urc_cb(&device_ready_cb)); + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == pow.set_device_ready_urc_cb(NULL)); +} + +TEST_F(TestAT_CellularPower, test_AT_CellularPower_remove_device_ready_urc_cb) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularPower pow(at); + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == pow.set_device_ready_urc_cb(&device_ready_cb)); + + pow.remove_device_ready_urc_cb(NULL); + pow.remove_device_ready_urc_cb(&device_ready_cb); +} diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularpower/unittest.cmake b/UNITTESTS/features/cellular/framework/AT/at_cellularpower/unittest.cmake new file mode 100644 index 0000000000..118bdac47c --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellularpower/unittest.cmake @@ -0,0 +1,31 @@ + +#################### +# UNIT TESTS +#################### + +# Unit test suite name +set(TEST_SUITE_NAME "at_cellular_power_unit") + +# Add test specific include paths +set(unittest-includes ${unittest-includes} + features/cellular/framework/common/util + ../features/cellular/framework/common + ../features/cellular/framework/AT + ../features/frameworks/mbed-client-randlib/mbed-client-randlib +) + +# Source files +set(unittest-sources + ../features/cellular/framework/AT/AT_CellularPower.cpp +) + +# Test files +set(unittest-test-sources + features/cellular/framework/AT/at_cellularpower/at_cellularpowertest.cpp + stubs/ATHandler_stub.cpp + stubs/AT_CellularBase_stub.cpp + stubs/EventQueue_stub.cpp + stubs/FileHandle_stub.cpp + stubs/CellularUtil_stub.cpp + stubs/mbed_assert_stub.cpp +) diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularsim/at_cellularsimtest.cpp b/UNITTESTS/features/cellular/framework/AT/at_cellularsim/at_cellularsimtest.cpp new file mode 100644 index 0000000000..eb82bc6c9a --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellularsim/at_cellularsimtest.cpp @@ -0,0 +1,204 @@ +/* + * 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 "ATHandler_stub.h" +#include +#include "AT_CellularNetwork.h" +#include "EventQueue.h" +#include "ATHandler.h" +#include "AT_CellularSIM.h" +#include "FileHandle_stub.h" +#include "CellularLog.h" +#include "ATHandler_stub.h" + +using namespace mbed; +using namespace events; + +// AStyle ignored as the definition is not clear due to preprocessor usage +// *INDENT-OFF* +class TestAT_CellularSIM : public testing::Test { +protected: + + void SetUp() + { + ATHandler_stub::read_string_index = kRead_string_table_size; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::read_string_value = NULL; + ATHandler_stub::ssize_value = 0; + } + + void TearDown() + { + } +}; +// *INDENT-ON* + +TEST_F(TestAT_CellularSIM, Create) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSIM *sim = new AT_CellularSIM(at); + + EXPECT_TRUE(sim != NULL); + delete sim; +} + +TEST_F(TestAT_CellularSIM, test_AT_CellularSIM_set_pin) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSIM sim(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == sim.set_pin("12")); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == sim.set_pin("12")); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::read_string_value = "READY"; + ATHandler_stub::ssize_value = 5; + EXPECT_TRUE(NSAPI_ERROR_OK == sim.set_pin("12")); + + EXPECT_TRUE(NSAPI_ERROR_OK == sim.set_pin(NULL)); +} + +TEST_F(TestAT_CellularSIM, test_AT_CellularSIM_change_pin) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSIM sim(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == sim.change_pin("12", "34")); + EXPECT_TRUE(NSAPI_ERROR_OK == sim.change_pin(NULL, "34")); + EXPECT_TRUE(NSAPI_ERROR_OK == sim.change_pin("12", NULL)); + EXPECT_TRUE(NSAPI_ERROR_OK == sim.change_pin(NULL, NULL)); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == sim.change_pin("12", "34")); +} + +TEST_F(TestAT_CellularSIM, test_AT_CellularSIM_set_pin_query) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSIM sim(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == sim.set_pin_query("12", true)); + EXPECT_TRUE(NSAPI_ERROR_OK == sim.set_pin_query(NULL, true)); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == sim.set_pin_query("12", false)); + EXPECT_TRUE(NSAPI_ERROR_OK == sim.set_pin_query(NULL, false)); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == sim.set_pin_query("12", false)); + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == sim.set_pin_query("12", true)); +} + +TEST_F(TestAT_CellularSIM, test_AT_CellularSIM_get_sim_state) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSIM sim(at); + CellularSIM::SimState state; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::ssize_value = -1; + ATHandler_stub::read_string_value = NULL; + EXPECT_TRUE(NSAPI_ERROR_OK == sim.get_sim_state(state)); + EXPECT_TRUE(CellularSIM::SimStateUnknown == state); + + ATHandler_stub::read_string_value = "READY"; + ATHandler_stub::ssize_value = 5; + EXPECT_TRUE(NSAPI_ERROR_OK == sim.get_sim_state(state)); + EXPECT_TRUE(CellularSIM::SimStateReady == state); + + ATHandler_stub::read_string_value = "SIM PIN"; + ATHandler_stub::ssize_value = 7; + EXPECT_TRUE(NSAPI_ERROR_OK == sim.get_sim_state(state)); + EXPECT_TRUE(CellularSIM::SimStatePinNeeded == state); + + ATHandler_stub::read_string_value = "SIM PUK"; + ATHandler_stub::ssize_value = 7; + EXPECT_TRUE(NSAPI_ERROR_OK == sim.get_sim_state(state)); + EXPECT_TRUE(CellularSIM::SimStatePukNeeded == state); + + ATHandler_stub::read_string_value = "SOME CRAP"; + ATHandler_stub::ssize_value = 9; + EXPECT_TRUE(NSAPI_ERROR_OK == sim.get_sim_state(state)); + EXPECT_TRUE(CellularSIM::SimStateUnknown == state); +} + +TEST_F(TestAT_CellularSIM, test_AT_CellularSIM_get_imsi) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + char imsi[16]; + AT_CellularSIM sim(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::read_string_value = "123456789012345"; + ATHandler_stub::ssize_value = 15; + EXPECT_TRUE(NSAPI_ERROR_OK == sim.get_imsi(imsi)); + EXPECT_TRUE(strcmp(ATHandler_stub::read_string_value, imsi) == 0); + + ATHandler_stub::read_string_value = NULL; + ATHandler_stub::ssize_value = -1; + ATHandler_stub::read_string_index = -1; + imsi[0] = 0; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == sim.get_imsi(imsi)); + EXPECT_TRUE(strlen(imsi) == 0); + + EXPECT_TRUE(NSAPI_ERROR_PARAMETER == sim.get_imsi(NULL)); + + // this would fail as get_imsi should take another param which is the size of the buffer which we could use for validation. + // Now we have improved documentation that that the given imsi buffer size must be over 15. + //char imsi2[5]; + //EXPECT_TRUE(NSAPI_ERROR_PARAMETER == sim.get_imsi(imsi2)); +} + +TEST_F(TestAT_CellularSIM, test_AT_CellularSIM_get_iccid) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + char buf[16]; + AT_CellularSIM sim(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::read_string_value = "123456789012345"; + ATHandler_stub::ssize_value = 15; + EXPECT_TRUE(NSAPI_ERROR_OK == sim.get_iccid(buf, 16)); + EXPECT_TRUE(strcmp(ATHandler_stub::read_string_value, buf) == 0); + + buf[0] = 0; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + ATHandler_stub::read_string_value = NULL; + ATHandler_stub::ssize_value = -1; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == sim.get_iccid(buf, 16)); + EXPECT_TRUE(strlen(buf) == 0); +} diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularsim/unittest.cmake b/UNITTESTS/features/cellular/framework/AT/at_cellularsim/unittest.cmake new file mode 100644 index 0000000000..ab4f3c0763 --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellularsim/unittest.cmake @@ -0,0 +1,32 @@ + +#################### +# UNIT TESTS +#################### + +# Unit test suite name +set(TEST_SUITE_NAME "at_cellular_sim_unit") + +# Add test specific include paths +set(unittest-includes ${unittest-includes} + features/cellular/framework/common/util + ../features/cellular/framework/common + ../features/cellular/framework/AT + ../features/frameworks/mbed-client-randlib/mbed-client-randlib +) + +# Source files +set(unittest-sources + ../features/cellular/framework/AT/AT_CellularSIM.cpp +) + +# Test files +set(unittest-test-sources + features/cellular/framework/AT/at_cellularsim/at_cellularsimtest.cpp + stubs/ATHandler_stub.cpp + stubs/AT_CellularBase_stub.cpp + stubs/EventQueue_stub.cpp + stubs/FileHandle_stub.cpp + stubs/CellularUtil_stub.cpp + stubs/us_ticker_stub.cpp + stubs/mbed_assert_stub.cpp +) diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularsms/at_cellularsmstest.cpp b/UNITTESTS/features/cellular/framework/AT/at_cellularsms/at_cellularsmstest.cpp new file mode 100644 index 0000000000..a586c2e652 --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellularsms/at_cellularsmstest.cpp @@ -0,0 +1,203 @@ +/* + * 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 +#include "AT_CellularNetwork.h" +#include "EventQueue.h" +#include "ATHandler.h" +#include "ATHandler_stub.h" +#include "AT_CellularSMS.h" +#include "FileHandle_stub.h" +#include "CellularLog.h" + +using namespace mbed; +using namespace events; + +// AStyle ignored as the definition is not clear due to preprocessor usage +// *INDENT-OFF* +class TestAT_CellularSMS : public testing::Test { +protected: + + void SetUp() + { + ATHandler_stub::return_given_size = false; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + } + + void TearDown() + { + } +}; +// *INDENT-ON* + +TEST_F(TestAT_CellularSMS, Create) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSMS *sms = new AT_CellularSMS(at); + + EXPECT_TRUE(sms != NULL); + delete sms; +} + +TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_initialize) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSMS sms(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE; + EXPECT_TRUE(NSAPI_ERROR_NO_MEMORY == sms.initialize(CellularSMS::CellularSMSMmodeText)); +} + +TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_send_sms) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSMS sms(at); + EXPECT_EQ(NSAPI_ERROR_PARAMETER, sms.send_sms(NULL, "2", 1)); + + sms.initialize(CellularSMS::CellularSMSMmodeText); + ATHandler_stub::size_value = 1; + EXPECT_EQ(1, sms.send_sms("1", "22", 2)); + + ATHandler_stub::size_value = 2; + EXPECT_EQ(2, sms.send_sms("1", "22", 2)); + + ATHandler_stub::return_given_size = true; // PDU mode write is much longer than than msg len + sms.initialize(CellularSMS::CellularSMSMmodePDU); + EXPECT_EQ(2, sms.send_sms("1", "23", 2));; + + ATHandler_stub::nsapi_error_ok_counter = 1; + ATHandler_stub::size_value = 32; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE; + EXPECT_EQ(NSAPI_ERROR_AUTH_FAILURE, sms.send_sms("1", "23232323", 8)); + + ATHandler_stub::nsapi_error_ok_counter = 2; + ATHandler_stub::size_value = 32; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE; + EXPECT_EQ(NSAPI_ERROR_AUTH_FAILURE, sms.send_sms("1", "23232323", 8)); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + char table[] = "232323232323232323232323232323232323232323232323232323\ + 232323232323232323232323232323232323232323232323232323\ + 232323232323232323232323232323232323232323232323232323\ + 23232323232323232323232323232323232323\0"; + + EXPECT_EQ(strlen(table), sms.send_sms("1", table, strlen(table))); + EXPECT_EQ(strlen(table), sms.send_sms("12", table, strlen(table))); +} + +TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_get_sms) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSMS sms(at); + char buf[16]; + char phone[21]; + char stamp[21]; + int size; + EXPECT_TRUE(NSAPI_ERROR_PARAMETER == sms.get_sms(NULL, 16, phone, 21, stamp, 21, &size)); + + ATHandler_stub::resp_info_true_counter = 1; + ATHandler_stub::int_value = 0; + EXPECT_TRUE(-1 == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size)); + + ATHandler_stub::resp_info_true_counter = 2; + ATHandler_stub::int_value = 11; + EXPECT_TRUE(0 == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size)); + //TODO: Should make add_info to happen, before calling get_sms! + + ATHandler_stub::resp_info_true_counter = 2; + ATHandler_stub::int_value = 11; + sms.initialize(CellularSMS::CellularSMSMmodePDU); + EXPECT_TRUE(0 == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size)); + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE; + EXPECT_TRUE(NSAPI_ERROR_AUTH_FAILURE == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size)); +} + +TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_set_sms_callback) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSMS sms(at); + sms.set_sms_callback(NULL); +} + +TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_set_cpms) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSMS sms(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE; + EXPECT_TRUE(NSAPI_ERROR_AUTH_FAILURE == sms.set_cpms("2", "3", "4")); +} + +TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_set_csca) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSMS sms(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE; + EXPECT_TRUE(NSAPI_ERROR_AUTH_FAILURE == sms.set_csca("2", 1)); +} + +TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_set_cscs) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSMS sms(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE; + EXPECT_TRUE(NSAPI_ERROR_AUTH_FAILURE == sms.set_cscs("2")); +} + +TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_delete_all_messages) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSMS sms(at); + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE; + EXPECT_TRUE(NSAPI_ERROR_AUTH_FAILURE == sms.delete_all_messages()); +} + +TEST_F(TestAT_CellularSMS, test_AT_CellularSMS_set_extra_sim_wait_time) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + AT_CellularSMS sms(at); + sms.set_extra_sim_wait_time(56); +} diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularsms/unittest.cmake b/UNITTESTS/features/cellular/framework/AT/at_cellularsms/unittest.cmake new file mode 100644 index 0000000000..ba6c5b52c8 --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellularsms/unittest.cmake @@ -0,0 +1,33 @@ + +#################### +# UNIT TESTS +#################### + +# Unit test suite name +set(TEST_SUITE_NAME "at_cellular_sms_unit") + +# Add test specific include paths +set(unittest-includes ${unittest-includes} + features/cellular/framework/common/util + ../features/cellular/framework/common + ../features/cellular/framework/AT + ../features/frameworks/mbed-client-randlib/mbed-client-randlib +) + +# Source files +set(unittest-sources + ../features/cellular/framework/AT/AT_CellularSMS.cpp +) + +# Test files +set(unittest-test-sources + features/cellular/framework/AT/at_cellularsms/at_cellularsmstest.cpp + stubs/ATHandler_stub.cpp + stubs/AT_CellularBase_stub.cpp + stubs/EventQueue_stub.cpp + stubs/FileHandle_stub.cpp + stubs/CellularUtil_stub.cpp + stubs/us_ticker_stub.cpp + stubs/mbed_assert_stub.cpp + stubs/mbed_wait_api_stub.cpp +) diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularstack/at_cellularstacktest.cpp b/UNITTESTS/features/cellular/framework/AT/at_cellularstack/at_cellularstacktest.cpp new file mode 100644 index 0000000000..40e2aebe9c --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellularstack/at_cellularstacktest.cpp @@ -0,0 +1,377 @@ +/* + * 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 "AT_CellularStack.h" +#include +#include "AT_CellularNetwork.h" +#include "EventQueue.h" +#include "ATHandler.h" +#include "AT_CellularStack.h" +#include "FileHandle_stub.h" +#include "CellularLog.h" +#include "ATHandler_stub.h" +#include "SocketAddress.h" + +using namespace mbed; +using namespace events; + +class MyStack : public AT_CellularStack { +public: + bool bool_value; + bool max_sock_value; + nsapi_error_t create_error; + CellularSocket socket; + + MyStack(ATHandler &atr, int cid, nsapi_ip_stack_t typ) : AT_CellularStack(atr, cid, typ) + { + bool_value = false; + max_sock_value = 0; + create_error = NSAPI_ERROR_OK; + } + + virtual int get_max_socket_count() + { + return max_sock_value; + } + + virtual bool is_protocol_supported(nsapi_protocol_t protocol) + { + return bool_value; + } + + virtual nsapi_error_t socket_close_impl(int sock_id) + { + return NSAPI_ERROR_OK; + } + + virtual nsapi_error_t create_socket_impl(CellularSocket *socket) + { + return create_error; + } + + virtual nsapi_size_or_error_t socket_sendto_impl(CellularSocket *socket, const SocketAddress &address, + const void *data, nsapi_size_t size) + { + return NSAPI_ERROR_OK; + } + + virtual nsapi_size_or_error_t socket_recvfrom_impl(CellularSocket *socket, SocketAddress *address, + void *buffer, nsapi_size_t size) + { + return NSAPI_ERROR_OK; + } + + virtual nsapi_error_t socket_open(nsapi_socket_t *handle, nsapi_protocol_t proto) + { + return AT_CellularStack::socket_open(handle, proto); + } + + virtual nsapi_error_t socket_close(nsapi_socket_t handle) + { + return AT_CellularStack::socket_close(handle); + } + + virtual nsapi_error_t socket_bind(nsapi_socket_t handle, const SocketAddress &address) + { + return AT_CellularStack::socket_bind(handle, address); + } + + virtual nsapi_error_t socket_listen(nsapi_socket_t handle, int backlog) + { + return AT_CellularStack::socket_listen(handle, backlog); + } + + virtual nsapi_error_t socket_connect(nsapi_socket_t handle, const SocketAddress &address) + { + return AT_CellularStack::socket_connect(handle, address); + } + + virtual nsapi_error_t socket_accept(nsapi_socket_t server, + nsapi_socket_t *handle, SocketAddress *address = 0) + { + return AT_CellularStack::socket_accept(server, handle, address); + } + + virtual nsapi_size_or_error_t socket_send(nsapi_socket_t handle, + const void *data, nsapi_size_t size) + { + return AT_CellularStack::socket_send(handle, data, size); + } + + virtual nsapi_size_or_error_t socket_recv(nsapi_socket_t handle, + void *data, nsapi_size_t size) + { + return AT_CellularStack::socket_recv(handle, data, size); + } + + virtual nsapi_size_or_error_t socket_sendto(nsapi_socket_t handle, const SocketAddress &address, + const void *data, nsapi_size_t size) + { + return AT_CellularStack::socket_sendto(handle, address, data, size); + } + + virtual nsapi_size_or_error_t socket_recvfrom(nsapi_socket_t handle, SocketAddress *address, + void *buffer, nsapi_size_t size) + { + return AT_CellularStack::socket_recvfrom(handle, address, buffer, size); + } + + virtual void socket_attach(nsapi_socket_t handle, void (*callback)(void *), void *data) + { + return AT_CellularStack::socket_attach(handle, callback, data); + } +}; + +// AStyle ignored as the definition is not clear due to preprocessor usage +// *INDENT-OFF* +class TestAT_CellularStack : public testing::Test { +protected: + + void SetUp() + { + ATHandler_stub::return_given_size = false; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK; + ATHandler_stub::ssize_value = 0; + ATHandler_stub::bool_value = false; + ATHandler_stub::read_string_value = NULL; + } + + void TearDown() + { + } +}; +// *INDENT-ON* + +TEST_F(TestAT_CellularStack, Create) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + MyStack *st = new MyStack(at, 0, IPV4_STACK); + + EXPECT_TRUE(st != NULL); + delete st; +} + +TEST_F(TestAT_CellularStack, test_AT_CellularStack_get_ip_address) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + MyStack st(at, 0, IPV6_STACK); + EXPECT_TRUE(0 == strlen(st.get_ip_address())); + + char table[] = "1.2.3.4.5.65.7.8.9.10.11\0"; + ATHandler_stub::ssize_value = -1; + ATHandler_stub::bool_value = true; + ATHandler_stub::read_string_value = table; + EXPECT_TRUE(NULL == st.get_ip_address()); + + ATHandler_stub::ssize_value = strlen(table); + ATHandler_stub::bool_value = true; + ATHandler_stub::read_string_value = table; + EXPECT_TRUE(st.get_ip_address()); +} + +TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_open) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + MyStack st(at, 0, IPV6_STACK); + st.bool_value = false; + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == st.socket_open(NULL, NSAPI_TCP)); + + st.bool_value = true; + st.max_sock_value = 0; + nsapi_socket_t sock = &st.socket; + EXPECT_TRUE(NSAPI_ERROR_NO_SOCKET == st.socket_open(&sock, NSAPI_TCP)); + + MyStack st2(at, 0, IPV6_STACK); + st2.bool_value = true; + st2.max_sock_value = 1; + sock = &st2.socket; + EXPECT_TRUE(NSAPI_ERROR_OK == st2.socket_open(&sock, NSAPI_TCP)); +} + +TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_close) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + MyStack st(at, 0, IPV6_STACK); + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == st.socket_close(&st.socket)); + + nsapi_socket_t sock = &st.socket; + st.bool_value = true; + st.max_sock_value = 1; + EXPECT_TRUE(NSAPI_ERROR_OK == st.socket_open(&sock, NSAPI_TCP)); + st.max_sock_value = 0; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == st.socket_close(sock)); + + MyStack st2(at, 0, IPV6_STACK); + st2.max_sock_value = 1; + st2.bool_value = true; + sock = &st2.socket; + EXPECT_TRUE(NSAPI_ERROR_OK == st2.socket_open(&sock, NSAPI_TCP)); + EXPECT_TRUE(NSAPI_ERROR_OK == st2.socket_close(sock)); +} + +TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_bind) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + MyStack st(at, 0, IPV6_STACK); + SocketAddress addr; + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_ALREADY; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == st.socket_bind(NULL, addr)); + + EXPECT_TRUE(NSAPI_ERROR_ALREADY == st.socket_bind(&st.socket, addr)); +} + +TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_listen) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + MyStack st(at, 0, IPV6_STACK); + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == st.socket_listen(&st.socket, 4)); +} + +TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_connect) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + MyStack st(at, 0, IPV6_STACK); + SocketAddress addr; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == st.socket_connect(NULL, addr)); + + EXPECT_TRUE(NSAPI_ERROR_OK == st.socket_connect(&st.socket, addr)); +} + +TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_accept) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + MyStack st(at, 0, IPV6_STACK); + nsapi_socket_t sock = &st.socket; + EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED == st.socket_accept(NULL, &sock)); +} + +TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_send) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + MyStack st(at, 0, IPV6_STACK); + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == st.socket_send(NULL, "addr", 4)); + + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == st.socket_send(&st.socket, "addr", 4)); + + SocketAddress addr; + st.max_sock_value = 1; + st.bool_value = true; + nsapi_socket_t sock = &st.socket; + st.socket_open(&sock, NSAPI_TCP); + st.socket_connect(sock, addr); + EXPECT_TRUE(NSAPI_ERROR_OK == st.socket_send(sock, "addr", 4)); +} + +TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_sendto) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + MyStack st(at, 0, IPV6_STACK); + + SocketAddress addr; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == st.socket_sendto(NULL, addr, "addr", 4)); + + st.max_sock_value = 1; + st.bool_value = true; + nsapi_socket_t sock = &st.socket; + st.socket_open(&sock, NSAPI_TCP); + st.socket_connect(sock, addr); + st.create_error = NSAPI_ERROR_CONNECTION_LOST; + EXPECT_TRUE(NSAPI_ERROR_CONNECTION_LOST == st.socket_sendto(sock, addr, "addr", 4)); + + st.create_error = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == st.socket_sendto(sock, addr, "addr", 4)); +} + +TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_recv) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + MyStack st(at, 0, IPV6_STACK); + char table[4]; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == st.socket_recv(NULL, table, 4)); +} + +TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_recvfrom) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + MyStack st(at, 0, IPV6_STACK); + char table[4]; + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == st.socket_recvfrom(NULL, NULL, table, 4)); + + SocketAddress addr; + st.max_sock_value = 1; + st.bool_value = true; + nsapi_socket_t sock = &st.socket; + st.socket_open(&sock, NSAPI_TCP); + st.socket_connect(sock, addr); + st.create_error = NSAPI_ERROR_CONNECTION_LOST; + EXPECT_TRUE(NSAPI_ERROR_CONNECTION_LOST == st.socket_recvfrom(sock, &addr, table, 4)); + + st.create_error = NSAPI_ERROR_OK; + EXPECT_TRUE(NSAPI_ERROR_OK == st.socket_recvfrom(sock, &addr, table, 4)); +} + +TEST_F(TestAT_CellularStack, test_AT_CellularStack_socket_attach) +{ + EventQueue que; + FileHandle_stub fh1; + ATHandler at(&fh1, que, 0, ","); + + MyStack st(at, 0, IPV6_STACK); + + st.socket_attach(NULL, NULL, NULL); + st.max_sock_value = 1; + st.bool_value = true; + nsapi_socket_t sock = &st.socket; + st.socket_open(&sock, NSAPI_TCP); + st.socket_attach(sock, NULL, NULL); +} diff --git a/UNITTESTS/features/cellular/framework/AT/at_cellularstack/unittest.cmake b/UNITTESTS/features/cellular/framework/AT/at_cellularstack/unittest.cmake new file mode 100644 index 0000000000..32ed822154 --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/at_cellularstack/unittest.cmake @@ -0,0 +1,34 @@ + +#################### +# UNIT TESTS +#################### + +# Unit test suite name +set(TEST_SUITE_NAME "at_cellular_stack_unit") + +# Add test specific include paths +set(unittest-includes ${unittest-includes} + features/cellular/framework/common/util + ../features/cellular/framework/common + ../features/cellular/framework/AT + ../features/frameworks/mbed-client-randlib/mbed-client-randlib +) + +# Source files +set(unittest-sources + ../features/cellular/framework/AT/AT_CellularStack.cpp +) + +# Test files +set(unittest-test-sources + features/cellular/framework/AT/at_cellularstack/at_cellularstacktest.cpp + stubs/ATHandler_stub.cpp + stubs/AT_CellularBase_stub.cpp + stubs/EventQueue_stub.cpp + stubs/FileHandle_stub.cpp + stubs/CellularUtil_stub.cpp + stubs/us_ticker_stub.cpp + stubs/NetworkStack_stub.cpp + stubs/SocketAddress_stub.cpp + stubs/mbed_assert_stub.cpp +) diff --git a/UNITTESTS/features/cellular/framework/AT/athandler/athandlertest.cpp b/UNITTESTS/features/cellular/framework/AT/athandler/athandlertest.cpp new file mode 100644 index 0000000000..df0780cfc5 --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/athandler/athandlertest.cpp @@ -0,0 +1,1022 @@ +/* + * 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 +#include "AT_CellularNetwork.h" +#include "EventQueue.h" +#include "ATHandler.h" +#include "AT_CellularStack.h" +#include "FileHandle_stub.h" +#include "CellularLog.h" +#include "mbed_poll_stub.h" + +#include "Timer_stub.h" + +using namespace mbed; +using namespace events; + +void urc_callback() +{ +} + +// AStyle ignored as the definition is not clear due to preprocessor usage +// *INDENT-OFF* +class TestATHandler : public testing::Test { +protected: + + void SetUp() + { + } + + void TearDown() + { + } +}; +// *INDENT-ON* + +TEST_F(TestATHandler, Create) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler *at = new ATHandler(&fh1, que, 0, ","); + + delete at; + + at = new ATHandler(&fh1, que, 0, NULL); + + EXPECT_TRUE(at != NULL); + delete at; +} + +TEST_F(TestATHandler, test_ATHandler_get_file_handle) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + EXPECT_EQ(&fh1, at.get_file_handle()); +} + +TEST_F(TestATHandler, test_ATHandler_set_file_handle) +{ + EventQueue que; + FileHandle_stub fh1, fh2; + + ATHandler at(&fh1, que, 0, ","); + + at.set_file_handle(&fh2); +} + +TEST_F(TestATHandler, test_ATHandler_lock) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + + at.lock(); +} + +TEST_F(TestATHandler, test_ATHandler_unlock) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + filehandle_stub_short_value_counter = 1; + fh1.short_value = POLLIN; + at.unlock(); +} + +TEST_F(TestATHandler, test_ATHandler_unlock_return_error) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + EXPECT_TRUE(NSAPI_ERROR_OK == at.unlock_return_error()); +} + +TEST_F(TestATHandler, test_ATHandler_set_urc_handler) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + const char ch[] = "testtesttesttest"; + at.set_urc_handler(ch, &urc_callback); +} + +TEST_F(TestATHandler, test_ATHandler_get_last_error) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + EXPECT_TRUE(NSAPI_ERROR_OK == at.get_last_error()); +} + +TEST_F(TestATHandler, test_ATHandler_get_last_device_error) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + EXPECT_TRUE(0 == at.get_last_device_error().errCode); +} + +TEST_F(TestATHandler, test_ATHandler_inc_ref_count) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + at.inc_ref_count(); +} + +TEST_F(TestATHandler, test_ATHandler_dec_ref_count) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + at.dec_ref_count(); +} + +TEST_F(TestATHandler, test_ATHandler_get_ref_count) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + EXPECT_TRUE(1 == at.get_ref_count()); + + at.inc_ref_count(); + EXPECT_TRUE(2 == at.get_ref_count()); + + at.inc_ref_count(); + EXPECT_TRUE(3 == at.get_ref_count()); + + at.dec_ref_count(); + at.dec_ref_count(); + EXPECT_TRUE(1 == at.get_ref_count()); +} + +TEST_F(TestATHandler, test_ATHandler_set_at_timeout) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + at.set_at_timeout(8); + + at.set_at_timeout(80, true); +} + +TEST_F(TestATHandler, test_ATHandler_restore_at_timeout) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + at.set_at_timeout(80, true); + at.set_at_timeout(800); + at.restore_at_timeout(); +} + +TEST_F(TestATHandler, test_ATHandler_clear_error) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + at.clear_error(); +} + +TEST_F(TestATHandler, test_ATHandler_process_oob) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + filehandle_stub_short_value_counter = 1; + fh1.short_value = POLLIN; + at.set_urc_handler("s", &urc_callback); + at.process_oob(); + + filehandle_stub_short_value_counter = 2; + at.process_oob(); + + //at.fill_buffer(); + uint8_t buf[5]; + at.clear_error(); + char table[] = "ssssssssssssssssssssssssssssssss\0"; + filehandle_stub_table = table; + filehandle_stub_table_pos = 0; + at.read_bytes(buf, 5); + + filehandle_stub_short_value_counter = 2; + at.process_oob(); + + at.clear_error(); + timer_stub_value = 0; + filehandle_stub_table_pos = 0; + at.read_bytes(buf, 5); + + filehandle_stub_short_value_counter = 1; + at.process_oob(); + + char table2[4]; + table2[0] = '\r'; + table2[1] = '\r'; + table2[2] = '\n'; + table2[3] = 0; + filehandle_stub_table = table2; + + at.clear_error(); + timer_stub_value = 0; + filehandle_stub_table_pos = 0; + at.read_bytes(buf, 1); + + filehandle_stub_short_value_counter = 1; + at.process_oob(); + + + filehandle_stub_table = table; + + + filehandle_stub_short_value_counter = 0; + filehandle_stub_table_pos = 0; + filehandle_stub_table = NULL; +} + +TEST_F(TestATHandler, test_ATHandler_set_filehandle_sigio) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + at.set_filehandle_sigio(); +} + +TEST_F(TestATHandler, test_ATHandler_flush) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + filehandle_stub_short_value_counter = 1; + fh1.short_value = POLLIN; + at.flush(); +} + +TEST_F(TestATHandler, test_ATHandler_cmd_start) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + mbed_poll_stub::revents_value = POLLOUT; + mbed_poll_stub::int_value = 1; + fh1.size_value = 3; + at.cmd_start("s"); + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 0; + + at.cmd_start("s"); + + at.cmd_start("s"); +} + +TEST_F(TestATHandler, test_ATHandler_write_int) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + fh1.size_value = -1; + at.write_int(4); + + at.clear_error(); + mbed_poll_stub::revents_value = POLLOUT; + mbed_poll_stub::int_value = 1; + fh1.size_value = 6; + at.write_int(4); + + at.write_int(2147483647); + + at.write_int(2147483647 + 1); + +// at.at_error(0, DeviceErrorType(0)); +// at.write_int(4); +} + +TEST_F(TestATHandler, test_ATHandler_write_string) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + fh1.size_value = -1; + at.write_string("help"); + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == at.get_last_error()); + + at.clear_error(); + mbed_poll_stub::revents_value = POLLOUT; + mbed_poll_stub::int_value = 1; + fh1.size_value = -1; + at.cmd_start("s"); + at.write_string("help", true); + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == at.get_last_error()); + + at.clear_error(); + mbed_poll_stub::revents_value = POLLOUT; + mbed_poll_stub::int_value = 1; + fh1.size_value = -1; + at.write_string("help", true); + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == at.get_last_error()); + + at.clear_error(); + mbed_poll_stub::revents_value = POLLOUT; + mbed_poll_stub::int_value = 1; + fh1.size_value = 7; + at.write_string("help", true); + EXPECT_TRUE(NSAPI_ERROR_OK == at.get_last_error()); +} + +TEST_F(TestATHandler, test_ATHandler_cmd_stop) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + fh1.size_value = -1; + at.cmd_stop(); + + at.write_string("help", true); + + at.cmd_stop(); + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == at.get_last_error()); +} + +TEST_F(TestATHandler, test_ATHandler_write_bytes) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + fh1.size_value = -1; + uint8_t data[] = "data"; + at.write_bytes(data, 4); + + at.write_bytes(data, 4); + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == at.get_last_error()); +} + +TEST_F(TestATHandler, test_ATHandler_set_stop_tag) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + at.set_stop_tag("s"); +} + +TEST_F(TestATHandler, test_ATHandler_set_delimiter) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + at.set_delimiter('+'); +} + +TEST_F(TestATHandler, test_ATHandler_skip_param) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + at.skip_param(); + + char table[] = "ssssssssssssssssssssssssssssOK\r\n\0"; + filehandle_stub_table = table; + filehandle_stub_table_pos = 0; + + at.flush(); + at.clear_error(); + at.resp_start(); + at.skip_param(); + EXPECT_TRUE(at.get_last_error() == NSAPI_ERROR_DEVICE_ERROR); + + char table1[] = "ss,sssssssssssss,sssssssssssOK\r\n\0"; + filehandle_stub_table = table1; + filehandle_stub_table_pos = 0; + + at.flush(); + at.clear_error(); + at.resp_start(); + at.skip_param(); + + char table2[] = "sssOK\r\n\0"; + filehandle_stub_table = table2; + filehandle_stub_table_pos = 0; + + at.flush(); + at.clear_error(); + at.resp_start(); + at.skip_param(); + + char table3[] = "sssssssOK\nssss\0"; + filehandle_stub_table = table3; + filehandle_stub_table_pos = 0; + + //Need to create a new instance because stop tag already found + ATHandler at2(&fh1, que, 0, ","); + at2.flush(); + at2.clear_error(); + at2.resp_start(); + at2.skip_param(); + + at2.skip_param(4, 3); + + filehandle_stub_table = table3; + filehandle_stub_table_pos = 0; + + at2.flush(); + at2.clear_error(); + at2.resp_start(); + at2.skip_param(4, 3); + + filehandle_stub_table = table3; + filehandle_stub_table_pos = 0; + + at2.flush(); + at2.clear_error(); + at2.resp_start(); + at2.skip_param(24, 17); +} + +TEST_F(TestATHandler, test_ATHandler_read_bytes) +{ + EventQueue que; + FileHandle_stub fh1; + filehandle_stub_table = NULL; + filehandle_stub_table_pos = 0; + + ATHandler at(&fh1, que, 0, ","); + uint8_t buf[5]; + + // TEST EMPTY BUFFER + // Shouldn't read any byte since buffer is empty + EXPECT_TRUE(-1 == at.read_bytes(buf, 1)); + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == at.get_last_error()); + // Return error due to error set to at handler by the above call on empty buffer + EXPECT_TRUE(-1 == at.read_bytes(buf, 1)); + + // TEST DATA IN BUFFER + at.clear_error(); + char table1[] = "1234512345678OK\r\n\0"; + filehandle_stub_table = table1; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1;; + + // Read 5 bytes + EXPECT_TRUE(5 == at.read_bytes(buf, 5)); + EXPECT_TRUE(!memcmp(buf, table1, 5)); + // get_char triggered above should have filled in the whole reading buffer(fill_buffer()) + EXPECT_TRUE(filehandle_stub_table_pos == (strlen(table1) - 1)); + // Read another 8 bytes + EXPECT_TRUE(8 == at.read_bytes(buf, 8) && !memcmp(buf, table1 + 5, 8)); + // Reading more than the 4 bytes left -> ERROR + EXPECT_TRUE(-1 == at.read_bytes(buf, 5)); + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == at.get_last_error()); +} + +TEST_F(TestATHandler, test_ATHandler_read_string) +{ + EventQueue que; + FileHandle_stub fh1; + filehandle_stub_table = NULL; + filehandle_stub_table_pos = 0; + + ATHandler at(&fh1, que, 0, ","); + + // *** EMPTY *** + at.clear_error(); + char table1[] = ""; + at.flush(); + filehandle_stub_table = table1; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1; + char buf1[1]; + // No _stop_tag set without resp_start + EXPECT_TRUE(-1 == at.read_string(buf1, 1)); + at.clear_error(); + // Set _stop_tag to resp_stop(OKCRLF) + at.resp_start(); + // Device error because buffer is empty + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == at.get_last_error()); + at.clear_error(); + // Device error because empty buffer and attempt to fill_buffer by consume_char('\"') + EXPECT_TRUE(-1 == at.read_string(buf1, 1)); + + // *** 1 BYTE *** + at.clear_error(); + char table2[] = "s\0"; + at.flush(); + filehandle_stub_table = table2; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1; + char buf2[1]; + // Set _stop_tag to resp_stop(OKCRLF) + at.resp_start(); + // Device error because no CRLF and no more data to read + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == at.get_last_error()); + at.clear_error(); + EXPECT_TRUE(0 == at.read_string(buf2, 1)); + + // *** CRLF *** + at.clear_error(); + char table3[] = "\r\ns\r\n\0"; + at.flush(); + filehandle_stub_table = table3; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1; + char buf3[1]; + // Set _stop_tag to resp_stop(OKCRLF) + at.resp_start(); + // OK because after CRLF matched there is more data to read ending in CRLF + EXPECT_TRUE(NSAPI_ERROR_OK == at.get_last_error()); + // To read 0 bytes from: s\r\n + EXPECT_TRUE(0 == at.read_string(buf3, 0 + 1/*for NULL*/)); + // To read 1 byte from: s\r\n -> read s + EXPECT_TRUE(1 == at.read_string(buf3, 1 + 1/*for NULL*/)); + + // *** Reading more than available in buffer *** + at.clear_error(); + char table4[] = "\"s,\"OK\r\n\0"; + at.flush(); + filehandle_stub_table = table4; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1; + char buf4[7]; + uint8_t buf5[5]; + // NO prefix, NO OK, NO ERROR and NO URC match, CRLF found -> return so buffer could be read + at.resp_start(); + // TO read 5 bytes from: "s,"OK\r\n -> read "s,"O + at.read_bytes(buf5, 5); + // K\r\n left to be read -> reading more than 3 + 1(for NULL) -> ERROR + EXPECT_TRUE(-1 == at.read_string(buf4, 4 + 1/*for NULL*/)); + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == at.get_last_error()); + + // *** Encountering delimiter after reading 1 byte *** + at.clear_error(); + at.flush(); + filehandle_stub_table = table4; + filehandle_stub_table_pos = 0; + // NO prefix, NO OK, NO ERROR and NO URC match, CRLF found -> return so buffer could be read + at.resp_start(); + // TO read 1 byte from: "s,"OK\r\n -> read " + at.read_bytes(buf5, 1); + // TO read max 4 from: s,"OK\r\n -> read s and stop on , + EXPECT_TRUE(1 == at.read_string(buf4, 4 + 1/*for NULL*/)); + + // *** Encountering delimiter as first char in buffer *** + at.clear_error(); + at.flush(); + filehandle_stub_table = table4; + filehandle_stub_table_pos = 0; + // NO prefix, NO OK, NO ERROR and NO URC match, CRLF found -> return so buffer could be read + at.resp_start(); + // TO read 2 bytes from: "s,"OK\r\n -> read "s + at.read_bytes(buf5, 2); + // TO read max 4 bytes from: ,"OK\r\n -> stop on , + EXPECT_TRUE(0 == at.read_string(buf4, 4 + 1/*for NULL*/)); + + // *** Read as much as buffer size is without encountering any delimiter " or OKCRLF *** + at.clear_error(); + char table5[] = "\"s\"OK\r\nabcd\0"; + at.flush(); + filehandle_stub_table = table5; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1; + // NO prefix, NO OK, NO ERROR and NO URC match, CRLF found -> return so buffer could be read + at.resp_start(); + // TO read 1 byte from: "s"OK\r\n -> read " + at.read_bytes(buf5, 1); + // TO read max 1 byte from: s"OK\r\n -> read s + EXPECT_TRUE(1 == at.read_string(buf4, 1 + 1/*for NULL*/)); + + // *** Consume " and run into OKCRLF *** + // TO read max 1 byte from: "OK\r\n -> consume " and find stop tag OKCRLF + EXPECT_TRUE(0 == at.read_string(buf4, 1 + 1/*for NULL*/)); + + // *** Try to read after stop tag was found *** + // stop tag found do not read further + EXPECT_TRUE(-1 == at.read_string(buf4, 1 + 1/*for NULL*/)); + + // *** Try to read after stop tag was found when parameter allows it *** + // stop tag found but flag indicates to read despite stop_tag found + EXPECT_TRUE(4 == at.read_string(buf4, 4 + 1/*for NULL*/, true)); + + // *** Read as much as buffer size is without encountering any delimiter " or OKCRLF *** + at.clear_error(); + char table6[] = "sss\rsss\0"; + at.flush(); + filehandle_stub_table = table6; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1; + at.resp_start("s"); + // TO read from: ss\rsss -> read all 6 chars ss\rsss + EXPECT_TRUE(6 == at.read_string(buf4, 6 + 1/*for NULL*/)); + + // *** Reading when buffer only has " *** + at.clear_error(); + char table7[] = "s\"\0"; + at.flush(); + filehandle_stub_table = table7; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1; + at.resp_start("s"); + // TO read from buffer having only " -> consume " -> trying to read when nothing in buffer + EXPECT_TRUE(-1 == at.read_string(buf4, 5)); + EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR == at.get_last_error()); + + // *** Reading through partially matching stop tag *** + at.clear_error(); + char table8[] = "\"s\"OK\rabcd\r\n\0"; + at.flush(); + filehandle_stub_table = table8; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1; + char buf8[9]; + // NO prefix, NO OK, NO ERROR and NO URC match, CRLF found -> return so buffer could be read + at.resp_start(); + // TO read from + EXPECT_TRUE(8 == at.read_string(buf8, 8 + 1/*for NULL*/)); + + // *** Reading through partially matching stop tag *** + at.clear_error(); + char table9[] = "\"s\"Oabcd\r\n\0"; + at.flush(); + filehandle_stub_table = table9; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1; + char buf9[5]; + + // NO prefix, NO OK, NO ERROR and NO URC match, CRLF found -> return so buffer could be read + at.resp_start(); + // TO read from + EXPECT_TRUE(6 == at.read_string(buf9, 6 + 1/*for NULL*/)); + + // *** CRLF part of the string *** + at.clear_error(); + char table10[] = "\"s\"\r\nOK\r\n\0"; + at.flush(); + filehandle_stub_table = table10; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1; + char buf10[10]; + + // NO prefix, NO OK, NO ERROR and NO URC match, CRLF found -> return so buffer could be read + at.resp_start(); + // TO read from + EXPECT_TRUE(3 == at.read_string(buf10, 9 + 1/*for NULL*/)); +} + +TEST_F(TestATHandler, test_ATHandler_read_hex_string) +{ + EventQueue que; + FileHandle_stub fh1; + filehandle_stub_table = NULL; + filehandle_stub_table_pos = 0; + + ATHandler at(&fh1, que, 0, ","); + + // *** Read up to delimiter, even length *** + at.clear_error(); + char table1[] = "68656C6C6F,"; + at.flush(); + filehandle_stub_table = table1; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1; + char buf1[10]; + // Set _stop_tag to resp_stop(OKCRLF) + at.resp_start(); + EXPECT_TRUE(5 == at.read_hex_string(buf1, 5)); + EXPECT_TRUE(!strncmp(buf1, "hello", 5)); + + // *** Read up to delimiter, odd length *** + at.clear_error(); + char table2[] = "68656C6C6F7,"; + at.flush(); + filehandle_stub_table = table2; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1; + char buf2[10]; + // Set _stop_tag to resp_stop(OKCRLF) + at.resp_start(); + EXPECT_TRUE(5 == at.read_hex_string(buf2, 6)); + EXPECT_TRUE(!strncmp(buf2, "hello", 5)); + + // *** Read with stop tag, even length *** + at.clear_error(); + char table3[] = "6865OK\r\n"; + at.flush(); + filehandle_stub_table = table3; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1; + char buf3[6]; + // Set _stop_tag to resp_stop(OKCRLF) + at.resp_start(); + EXPECT_TRUE(2 == at.read_hex_string(buf3, 2 + 1/*get to stop tag match*/)); + EXPECT_TRUE(!strncmp(buf3, "he", 2)); + at.resp_stop(); + + // *** Read with stop tag, odd length *** + at.clear_error(); + char table4[] = "686OK\r\n"; + at.flush(); + filehandle_stub_table = table4; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = 1; + char buf4[6]; + // Set _stop_tag to resp_stop(OKCRLF) + at.resp_start(); + EXPECT_TRUE(1 == at.read_hex_string(buf4, 2 + 1/*get to stop tag match*/)); + EXPECT_TRUE(!strncmp(buf4, "h", 1)); +} + +TEST_F(TestATHandler, test_ATHandler_read_int) +{ + EventQueue que; + FileHandle_stub fh1; + filehandle_stub_table = NULL; + filehandle_stub_table_pos = 0; + + ATHandler at(&fh1, que, 0, ","); + + int32_t ret = at.read_int(); + EXPECT_TRUE(-1 == ret); + at.clear_error(); + + char table[] = "\",\"OK\r\n\0"; + filehandle_stub_table = table; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = strlen(table); + + at.resp_start(); + + ret = at.read_int(); + EXPECT_TRUE(-1 == ret); + at.flush(); + at.clear_error(); + + char table2[] = "\"2,\"OK\r\n\0"; + filehandle_stub_table = table2; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = strlen(table2); + + at.resp_start(); + + ret = at.read_int(); + EXPECT_TRUE(2 == ret); +} + +TEST_F(TestATHandler, test_ATHandler_resp_start) +{ + EventQueue que; + FileHandle_stub fh1; + + filehandle_stub_table = NULL; + filehandle_stub_table_pos = 0; + + ATHandler at(&fh1, que, 0, ","); + at.resp_start(); + at.resp_start(); + + char table2[] = "\"2,\"OK\r\n\0"; + filehandle_stub_table = table2; + filehandle_stub_table_pos = 0; + + at.flush(); + at.clear_error(); + at.resp_start("ssssaaaassssaaaassss"); //too long prefix + + char table3[] = "+CME ERROR: 108\0"; + filehandle_stub_table = table3; + filehandle_stub_table_pos = 0; + + at.flush(); + at.clear_error(); + at.resp_start(); + + filehandle_stub_table_pos = 0; + + at.flush(); + at.clear_error(); + at.resp_start(); + + char table4[] = "+CMS ERROR: 6\0"; + filehandle_stub_table = table4; + filehandle_stub_table_pos = 0; + + at.flush(); + at.clear_error(); + at.resp_start(); + + char table5[] = "ERROR\r\n\0"; + filehandle_stub_table = table5; + filehandle_stub_table_pos = 0; + + at.flush(); + at.clear_error(); + at.resp_start(); + + char table6[] = "OK\r\n\0"; + filehandle_stub_table = table6; + filehandle_stub_table_pos = 0; + + at.flush(); + at.clear_error(); + at.resp_start(); + + char table7[] = "ssssss\0"; + filehandle_stub_table = table7; + filehandle_stub_table_pos = 0; + + at.flush(); + at.clear_error(); + at.set_urc_handler("ss", NULL); + at.resp_start(); +} + +TEST_F(TestATHandler, test_ATHandler_resp_stop) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + + char table[] = "21 OK\r\n\0"; + filehandle_stub_table = table; + filehandle_stub_table_pos = 0; + + at.info_elem('2'); + at.set_stop_tag("OK\r\n"); + at.resp_stop(); + + char table3[] = "+CME ERROR: 108\0"; + filehandle_stub_table = table3; + filehandle_stub_table_pos = 0; + + at.flush(); + at.clear_error(); + at.resp_start(); + + at.resp_stop(); + + char table7[] = "ssssss\0"; + filehandle_stub_table = table7; + filehandle_stub_table_pos = 0; + + at.flush(); + at.clear_error(); + at.resp_start("ss", false); + at.resp_stop(); +} + +TEST_F(TestATHandler, test_ATHandler_info_resp) +{ + EventQueue que; + FileHandle_stub fh1; + + filehandle_stub_table = NULL; + + ATHandler at(&fh1, que, 0, ","); + EXPECT_TRUE(at.info_resp()); + + at.resp_start(); + EXPECT_TRUE(!at.info_resp()); + + at.flush(); + at.clear_error(); + + char table2[] = "21 OK\r\n\0"; + filehandle_stub_table = table2; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = strlen(table2); + + at.resp_start("21"); + EXPECT_TRUE(at.info_resp()); + + EXPECT_TRUE(!at.info_resp()); + + at.flush(); + at.clear_error(); + + char table3[] = "21 OK\r\n\0"; + filehandle_stub_table = table3; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = strlen(table3); + + EXPECT_TRUE(at.info_resp()); +} + +TEST_F(TestATHandler, test_ATHandler_info_elem) +{ + EventQueue que; + FileHandle_stub fh1; + + char table[] = "21 OK\r\n\0"; + filehandle_stub_table = table; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = strlen(table); + + ATHandler at(&fh1, que, 0, ","); + EXPECT_TRUE(!at.info_elem('O')); + at.flush(); + + char table2[] = "21 OK\r\n\0"; + filehandle_stub_table = table2; + filehandle_stub_table_pos = 0; + mbed_poll_stub::revents_value = POLLIN; + mbed_poll_stub::int_value = strlen(table2); + + at.clear_error(); + at.resp_start("21"); + EXPECT_TRUE(at.info_elem('O')); + at.flush(); + + filehandle_stub_table = NULL; + filehandle_stub_table_pos = 0; + + at.clear_error(); + at.resp_start("21"); + EXPECT_TRUE(!at.info_elem('2')); +} + +TEST_F(TestATHandler, test_ATHandler_consume_to_stop_tag) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + EXPECT_TRUE(at.consume_to_stop_tag()); +} + +TEST_F(TestATHandler, test_ATHandler_set_debug) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + at.set_debug(true); + + at.set_debug(false); +} + +TEST_F(TestATHandler, test_ATHandler_get_3gpp_error) +{ + EventQueue que; + FileHandle_stub fh1; + + ATHandler at(&fh1, que, 0, ","); + at.get_3gpp_error(); +} diff --git a/UNITTESTS/features/cellular/framework/AT/athandler/unittest.cmake b/UNITTESTS/features/cellular/framework/AT/athandler/unittest.cmake new file mode 100644 index 0000000000..6f9c05df34 --- /dev/null +++ b/UNITTESTS/features/cellular/framework/AT/athandler/unittest.cmake @@ -0,0 +1,41 @@ + +#################### +# UNIT TESTS +#################### + +# Unit test suite name +set(TEST_SUITE_NAME "at_handler_unit") + +# Add test specific include paths +set(unittest-includes ${unittest-includes} + features/cellular/framework/common/util + ../features/cellular/framework/common + ../features/cellular/framework/AT + ../features/frameworks/mbed-client-randlib/mbed-client-randlib +) + +# Source files +set(unittest-sources + ../features/cellular/framework/AT/ATHandler.cpp + ../features/cellular/framework/common/CellularUtil.cpp +) + +# Test files +set(unittest-test-sources + features/cellular/framework/AT/athandler/athandlertest.cpp + stubs/AT_CellularBase_stub.cpp + stubs/EventQueue_stub.cpp + stubs/FileHandle_stub.cpp + stubs/us_ticker_stub.cpp + stubs/mbed_wait_api_stub.cpp + stubs/mbed_assert_stub.cpp + stubs/mbed_poll_stub.cpp + stubs/Timer_stub.cpp + stubs/equeue_stub.c + stubs/Kernel_stub.cpp + stubs/Thread_stub.cpp + stubs/randLIB_stub.cpp +) + +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DMBED_CONF_CELLULAR_DEBUG_AT=true -DOS_STACK_SIZE=2048") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMBED_CONF_CELLULAR_DEBUG_AT=true -DOS_STACK_SIZE=2048") diff --git a/UNITTESTS/features/cellular/framework/common/util/test_util.cpp b/UNITTESTS/features/cellular/framework/common/util/test_util.cpp deleted file mode 100644 index 49aebf90b0..0000000000 --- a/UNITTESTS/features/cellular/framework/common/util/test_util.cpp +++ /dev/null @@ -1,179 +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 "test_util.h" -#include -#include "CellularUtil.h" -#include - -using namespace mbed_cellular_util; - -Test_util::Test_util() -{ - -} - -Test_util::~Test_util() -{ -} - -void Test_util::test_util_uint_to_binary_string() -{ - char str[33]; - uint_to_binary_str(15, str, 33, 32); - str[32] = '\0'; - // 15 is "1111" in binary but we ask all 32 bits so it should return "00000000000000000000000000001111" - EXPECT_STREQ("00000000000000000000000000001111", str); - - // test NULL pointer - uint_to_binary_str(15, NULL, 0, 32); - - // test give too small buffer - char too_small[5]; - uint_to_binary_str(15, too_small, 5, 6); -} - -void Test_util::test_util_char_str_to_hex() -{ - // basic conversion test, happy days - char hex_buf[50]; - uint16_t number_of_hex_chars = char_str_to_hex_str("1234", 4, hex_buf); - hex_buf[number_of_hex_chars] = '\0'; - EXPECT_STREQ("31323334", hex_buf); - EXPECT_EQ(8, number_of_hex_chars); - - number_of_hex_chars = char_str_to_hex_str("wuhuu", 5, hex_buf); - hex_buf[number_of_hex_chars] = '\0'; - EXPECT_STREQ("7775687575", hex_buf); - EXPECT_EQ(10, number_of_hex_chars); - - // First don't omit the leading zero and then omit and check that leading zero is missing - number_of_hex_chars = char_str_to_hex_str("\nwuhuu", 6, hex_buf); - hex_buf[number_of_hex_chars] = '\0'; - EXPECT_STREQ("0A7775687575", hex_buf); - EXPECT_EQ(12, number_of_hex_chars); - - number_of_hex_chars = char_str_to_hex_str("\nwuhuu", 6, hex_buf, true); - hex_buf[number_of_hex_chars] = '\0'; - EXPECT_STREQ("A7775687575", hex_buf); - EXPECT_EQ(11, number_of_hex_chars); - - // test giving a null pointer - number_of_hex_chars = char_str_to_hex_str(NULL, 4, hex_buf); - EXPECT_EQ(0, number_of_hex_chars); - number_of_hex_chars = char_str_to_hex_str("1234", 4, NULL); - EXPECT_EQ(0, number_of_hex_chars); -} - -void Test_util::test_util_convert_ipv6() -{ - // leading zeros omitted - char ipv6[64]; - strncpy(ipv6, "1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1", 64); - convert_ipv6(ipv6); - EXPECT_STREQ("101:101:101:101:101:101:101:101", ipv6); - EXPECT_EQ(31, strlen(ipv6)); - - // some omitted and some not so much - strncpy(ipv6, "255.1.120.2.244.12.55.45.201.110.11.2.233.154.85.96", 64); - convert_ipv6(ipv6); - EXPECT_STREQ("FF01:7802:F40C:372D:C96E:B02:E99A:5560", ipv6); - EXPECT_EQ(38, strlen(ipv6)); - - // test giving a null pointer - convert_ipv6(NULL); -} - -void Test_util::test_util_prefer_ipv6() -{ - char tt[20] = "62.241.198.246"; - char temp[64] = "2001:14B8:1000:000:000:000:000:002"; - - // not enough space to swap, arrays should stay the same - prefer_ipv6(tt, sizeof(tt), temp, sizeof(temp)); - EXPECT_STREQ("62.241.198.246", tt); - EXPECT_STREQ("2001:14B8:1000:000:000:000:000:002", temp); - - // should swap as first one was ip4 and later was ipv6 and enough space - char tt2[64] = "62.241.198.246"; - prefer_ipv6(tt2, sizeof(tt2), temp, sizeof(temp)); - EXPECT_STREQ("62.241.198.246", temp); - EXPECT_STREQ("2001:14B8:1000:000:000:000:000:002", tt2); -} - -void Test_util::test_util_separate_ip_addresses() -{ - char *s = (char *)calloc(128, 1); - - char ip[64] = {0}; - char subnet[64] = {0}; - - strncpy(s, "32.1.20.187.1.112.139.245.251.136.232.110.123.51.230.138.0.1.2.3.4.5.6.7.8.9.10.11.12.13.14.15", 94); - separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); - EXPECT_STREQ("2001:14BB:170:8BF5:FB88:E86E:7B33:E68A", ip); - EXPECT_STREQ("001:203:405:607:809:A0B:C0D:E0F", subnet); - - strncpy(s, "32:1:20:187:1:112:139:245:251:136:232:110:123:51:230:138 0:1:2:3:4:5:6:7:8:9:10:11:12:13:14:15", 94); - separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); - EXPECT_STREQ("32:1:20:187:1:112:139:245:251:136:232:110:123:51:230:138", ip); - EXPECT_STREQ("0:1:2:3:4:5:6:7:8:9:10:11:12:13:14:15", subnet); - - ip[0] = '\0'; - subnet[0] = '\0'; - strncpy(s, "1.2.3.4\0", 8); - separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); - EXPECT_STREQ("1.2.3.4", ip); - EXPECT_STREQ("", subnet); - - ip[0] = '\0'; - subnet[0] = '\0'; - strncpy(s, "1.2.3.4.5.6.7.8\0", 16); - separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); - EXPECT_STREQ("1.2.3.4", ip); - EXPECT_STREQ("5.6.7.8", subnet); - - ip[0] = '\0'; - subnet[0] = '\0'; - strncpy(s, "1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16\0", 39); - separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); - EXPECT_STREQ("102:304:506:708:90A:B0C:D0E:F10", ip); - EXPECT_STREQ("", subnet); - - ip[0] = '\0'; - subnet[0] = '\0'; - strncpy(s, "32:1:20:187:1:112:139:245:251:136:232:110:123:51:230:138\0", 57); - separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); - EXPECT_STREQ("32:1:20:187:1:112:139:245:251:136:232:110:123:51:230:138", ip); - EXPECT_STREQ("", subnet); - - ip[0] = '\0'; - subnet[0] = '\0'; - strncpy(s, "1.2.3.4 32:1:20:187:1:112:139:245:251:136:232:110:123:51:230:138\0", 65); - separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); - EXPECT_STREQ("1.2.3.4", ip); - EXPECT_STREQ("32:1:20:187:1:112:139:245:251:136:232:110:123:51:230:138", subnet); - - ip[0] = '\0'; - subnet[0] = '\0'; - strncpy(s, "1.2.3.4 5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20\0", 51); - separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); - EXPECT_STREQ("1.2.3.4", ip); - EXPECT_STREQ("506:708:90A:B0C:D0E:F10:1112:1314", subnet); - EXPECT_STREQ("1.2.3.4 5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20", s); - - free(s); -} diff --git a/UNITTESTS/features/cellular/framework/common/util/unittest.cmake b/UNITTESTS/features/cellular/framework/common/util/unittest.cmake index b1d43bac34..cefe41bb1c 100644 --- a/UNITTESTS/features/cellular/framework/common/util/unittest.cmake +++ b/UNITTESTS/features/cellular/framework/common/util/unittest.cmake @@ -20,7 +20,6 @@ set(unittest-sources # Test files set(unittest-test-sources - stubs/randLIB_stub.c - features/cellular/framework/common/util/test_util.cpp features/cellular/framework/common/util/utiltest.cpp + stubs/randLIB_stub.cpp ) diff --git a/UNITTESTS/features/cellular/framework/common/util/utiltest.cpp b/UNITTESTS/features/cellular/framework/common/util/utiltest.cpp index deaa0c5690..237316608b 100644 --- a/UNITTESTS/features/cellular/framework/common/util/utiltest.cpp +++ b/UNITTESTS/features/cellular/framework/common/util/utiltest.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, Arm Limited and affiliates + * Copyright (c) 2018, Arm Limited and affiliates. * SPDX-License-Identifier: Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -15,49 +15,167 @@ * limitations under the License. */ #include "gtest/gtest.h" -#include "test_util.h" +#include +#include "CellularUtil.h" -class TestUtil : public testing::Test { +using namespace mbed_cellular_util; + +// AStyle ignored as the definition is not clear due to preprocessor usage +// *INDENT-OFF* +class Testutil : public testing::Test { protected: - Test_util *unit; - virtual void SetUp() + void SetUp() { - unit = new Test_util(); } - virtual void TearDown() + void TearDown() { - delete unit; } }; +// *INDENT-ON* -TEST_F(TestUtil, Create) +TEST_F(Testutil, test_util_uint_to_binary_string) { - EXPECT_TRUE(unit); + char str[33]; + uint_to_binary_str(15, str, 33, 32); + str[32] = '\0'; + // 15 is "1111" in binary but we ask all 32 bits so it should return "00000000000000000000000000001111" + EXPECT_STREQ("00000000000000000000000000001111", str); + + // test NULL pointer + uint_to_binary_str(15, NULL, 0, 32); + + // test give too small buffer + char too_small[5]; + uint_to_binary_str(15, too_small, 5, 6); } -TEST_F(TestUtil, test_util_uint_to_binary_string) +TEST_F(Testutil, char_str_to_hex) { - unit->test_util_uint_to_binary_string(); + // basic conversion test, happy days + char hex_buf[50]; + uint16_t number_of_hex_chars = char_str_to_hex_str("1234", 4, hex_buf); + hex_buf[number_of_hex_chars] = '\0'; + EXPECT_STREQ("31323334", hex_buf); + EXPECT_EQ(8, number_of_hex_chars); + + number_of_hex_chars = char_str_to_hex_str("wuhuu", 5, hex_buf); + hex_buf[number_of_hex_chars] = '\0'; + EXPECT_STREQ("7775687575", hex_buf); + EXPECT_EQ(10, number_of_hex_chars); + + // First don't omit the leading zero and then omit and check that leading zero is missing + number_of_hex_chars = char_str_to_hex_str("\nwuhuu", 6, hex_buf); + hex_buf[number_of_hex_chars] = '\0'; + EXPECT_STREQ("0A7775687575", hex_buf); + EXPECT_EQ(12, number_of_hex_chars); + + number_of_hex_chars = char_str_to_hex_str("\nwuhuu", 6, hex_buf, true); + hex_buf[number_of_hex_chars] = '\0'; + EXPECT_STREQ("A7775687575", hex_buf); + EXPECT_EQ(11, number_of_hex_chars); + + // test giving a null pointer + number_of_hex_chars = char_str_to_hex_str(NULL, 4, hex_buf); + EXPECT_EQ(0, number_of_hex_chars); + number_of_hex_chars = char_str_to_hex_str("1234", 4, NULL); + EXPECT_EQ(0, number_of_hex_chars); } -TEST_F(TestUtil, char_str_to_hex) +TEST_F(Testutil, convert_ipv6) { - unit->test_util_char_str_to_hex(); + // leading zeros omitted + char ipv6[64]; + strncpy(ipv6, "1.1.1.1.1.1.1.1.1.1.1.1.1.1.1.1", 64); + convert_ipv6(ipv6); + EXPECT_STREQ("101:101:101:101:101:101:101:101", ipv6); + EXPECT_EQ(31, strlen(ipv6)); + + // some omitted and some not so much + strncpy(ipv6, "255.1.120.2.244.12.55.45.201.110.11.2.233.154.85.96", 64); + convert_ipv6(ipv6); + EXPECT_STREQ("FF01:7802:F40C:372D:C96E:B02:E99A:5560", ipv6); + EXPECT_EQ(38, strlen(ipv6)); + + // test giving a null pointer + convert_ipv6(NULL); } -TEST_F(TestUtil, convert_ipv6) +TEST_F(Testutil, prefer_ipv6) { - unit->test_util_convert_ipv6(); + char tt[20] = "62.241.198.246"; + char temp[64] = "2001:14B8:1000:000:000:000:000:002"; + + // not enough space to swap, arrays should stay the same + prefer_ipv6(tt, sizeof(tt), temp, sizeof(temp)); + EXPECT_STREQ("62.241.198.246", tt); + EXPECT_STREQ("2001:14B8:1000:000:000:000:000:002", temp); + + // should swap as first one was ip4 and later was ipv6 and enough space + char tt2[64] = "62.241.198.246"; + prefer_ipv6(tt2, sizeof(tt2), temp, sizeof(temp)); + EXPECT_STREQ("62.241.198.246", temp); + EXPECT_STREQ("2001:14B8:1000:000:000:000:000:002", tt2); } -TEST_F(TestUtil, prefer_ipv6) +TEST_F(Testutil, separate_ip_addresses) { - unit->test_util_prefer_ipv6(); -} + char *s = (char *)malloc(128); -TEST_F(TestUtil, separate_ip_addresses) -{ - unit->test_util_separate_ip_addresses(); + char ip[64] = {0}; + char subnet[64] = {0}; + + strncpy(s, "32.1.20.187.1.112.139.245.251.136.232.110.123.51.230.138.0.1.2.3.4.5.6.7.8.9.10.11.12.13.14.15", 94); + separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); + EXPECT_STREQ("2001:14BB:170:8BF5:FB88:E86E:7B33:E68A", ip); + EXPECT_STREQ("001:203:405:607:809:A0B:C0D:E0F", subnet); + + strncpy(s, "32:1:20:187:1:112:139:245:251:136:232:110:123:51:230:138 0:1:2:3:4:5:6:7:8:9:10:11:12:13:14:15", 94); + separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); + EXPECT_STREQ("32:1:20:187:1:112:139:245:251:136:232:110:123:51:230:138", ip); + EXPECT_STREQ("0:1:2:3:4:5:6:7:8:9:10:11:12:13:14:15", subnet); + + ip[0] = '\0'; + subnet[0] = '\0'; + strncpy(s, "1.2.3.4\0", 8); + separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); + EXPECT_STREQ("1.2.3.4", ip); + EXPECT_STREQ("", subnet); + + ip[0] = '\0'; + subnet[0] = '\0'; + strncpy(s, "1.2.3.4.5.6.7.8\0", 16); + separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); + EXPECT_STREQ("1.2.3.4", ip); + EXPECT_STREQ("5.6.7.8", subnet); + + ip[0] = '\0'; + subnet[0] = '\0'; + strncpy(s, "1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16\0", 39); + separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); + EXPECT_STREQ("102:304:506:708:90A:B0C:D0E:F10", ip); + EXPECT_STREQ("", subnet); + + ip[0] = '\0'; + subnet[0] = '\0'; + strncpy(s, "32:1:20:187:1:112:139:245:251:136:232:110:123:51:230:138\0", 57); + separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); + EXPECT_STREQ("32:1:20:187:1:112:139:245:251:136:232:110:123:51:230:138", ip); + EXPECT_STREQ("", subnet); + + ip[0] = '\0'; + subnet[0] = '\0'; + strncpy(s, "1.2.3.4 32:1:20:187:1:112:139:245:251:136:232:110:123:51:230:138\0", 65); + separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); + EXPECT_STREQ("1.2.3.4", ip); + EXPECT_STREQ("32:1:20:187:1:112:139:245:251:136:232:110:123:51:230:138", subnet); + + ip[0] = '\0'; + subnet[0] = '\0'; + strncpy(s, "1.2.3.4 5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20\0", 51); + separate_ip_addresses(s, ip, sizeof(ip), subnet, sizeof(subnet)); + EXPECT_STREQ("1.2.3.4", ip); + EXPECT_STREQ("506:708:90A:B0C:D0E:F10:1112:1314", subnet); + EXPECT_STREQ("1.2.3.4 5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20", s); } diff --git a/UNITTESTS/stubs/ATCmdParser_stub.cpp b/UNITTESTS/stubs/ATCmdParser_stub.cpp new file mode 100644 index 0000000000..d9157ec848 --- /dev/null +++ b/UNITTESTS/stubs/ATCmdParser_stub.cpp @@ -0,0 +1,420 @@ +/* + * Copyright (c) 2017, 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 "ATCmdParser.h" +#include "mbed_poll.h" +#include "mbed_debug.h" + +#ifdef LF +#undef LF +#define LF 10 +#else +#define LF 10 +#endif + +#ifdef CR +#undef CR +#define CR 13 +#else +#define CR 13 +#endif + +// getc/putc handling with timeouts +int ATCmdParser::putc(char c) +{ + pollfh fhs; + fhs.fh = _fh; + fhs.events = POLLOUT; + + int count = poll(&fhs, 1, _timeout); + if (count > 0 && (fhs.revents & POLLOUT)) { + return _fh->write(&c, 1) == 1 ? 0 : -1; + } else { + return -1; + } +} + +int ATCmdParser::getc() +{ + pollfh fhs; + fhs.fh = _fh; + fhs.events = POLLIN; + + int count = poll(&fhs, 1, _timeout); + if (count > 0 && (fhs.revents & POLLIN)) { + unsigned char ch; + return _fh->read(&ch, 1) == 1 ? ch : -1; + } else { + return -1; + } +} + +void ATCmdParser::flush() +{ + while (_fh->readable()) { + unsigned char ch; + _fh->read(&ch, 1); + } +} + + +// read/write handling with timeouts +int ATCmdParser::write(const char *data, int size) +{ + int i = 0; + for (; i < size; i++) { + if (putc(data[i]) < 0) { + return -1; + } + } + return i; +} + +int ATCmdParser::read(char *data, int size) +{ + int i = 0; + for (; i < size; i++) { + int c = getc(); + if (c < 0) { + return -1; + } + data[i] = c; + } + return i; +} + + +// printf/scanf handling +int ATCmdParser::vprintf(const char *format, va_list args) +{ + + if (vsprintf(_buffer, format, args) < 0) { + return false; + } + + int i = 0; + for (; _buffer[i]; i++) { + if (putc(_buffer[i]) < 0) { + return -1; + } + } + return i; +} + +int ATCmdParser::vscanf(const char *format, va_list args) +{ + // Since format is const, we need to copy it into our buffer to + // add the line's null terminator and clobber value-matches with asterisks. + // + // We just use the beginning of the buffer to avoid unnecessary allocations. + int i = 0; + int offset = 0; + + while (format[i]) { + if (format[i] == '%' && format[i + 1] != '%' && format[i + 1] != '*') { + _buffer[offset++] = '%'; + _buffer[offset++] = '*'; + i++; + } else { + _buffer[offset++] = format[i++]; + } + } + + // Scanf has very poor support for catching errors + // fortunately, we can abuse the %n specifier to determine + // if the entire string was matched. + _buffer[offset++] = '%'; + _buffer[offset++] = 'n'; + _buffer[offset++] = 0; + + // To workaround scanf's lack of error reporting, we actually + // make two passes. One checks the validity with the modified + // format string that only stores the matched characters (%n). + // The other reads in the actual matched values. + // + // We keep trying the match until we succeed or some other error + // derails us. + int j = 0; + + while (true) { + // Ran out of space + if (j + 1 >= _buffer_size - offset) { + return false; + } + // Recieve next character + int c = getc(); + if (c < 0) { + return -1; + } + _buffer[offset + j++] = c; + _buffer[offset + j] = 0; + + // Check for match + int count = -1; + sscanf(_buffer + offset, _buffer, &count); + + // We only succeed if all characters in the response are matched + if (count == j) { + // Store the found results + vsscanf(_buffer + offset, format, args); + return j; + } + } +} + + +// Command parsing with line handling +bool ATCmdParser::vsend(const char *command, va_list args) +{ + // Create and send command + if (vsprintf(_buffer, command, args) < 0) { + return false; + } + + for (int i = 0; _buffer[i]; i++) { + if (putc(_buffer[i]) < 0) { + return false; + } + } + + // Finish with newline + for (size_t i = 0; _output_delimiter[i]; i++) { + if (putc(_output_delimiter[i]) < 0) { + return false; + } + } + + debug_if(_dbg_on, "AT> %s\n", _buffer); + return true; +} + +bool ATCmdParser::vrecv(const char *response, va_list args) +{ +restart: + _aborted = false; + // Iterate through each line in the expected response + while (response[0]) { + // Since response is const, we need to copy it into our buffer to + // add the line's null terminator and clobber value-matches with asterisks. + // + // We just use the beginning of the buffer to avoid unnecessary allocations. + int i = 0; + int offset = 0; + bool whole_line_wanted = false; + + while (response[i]) { + if (response[i] == '%' && response[i + 1] != '%' && response[i + 1] != '*') { + _buffer[offset++] = '%'; + _buffer[offset++] = '*'; + i++; + } else { + _buffer[offset++] = response[i++]; + // Find linebreaks, taking care not to be fooled if they're in a %[^\n] conversion specification + if (response[i - 1] == '\n' && !(i >= 3 && response[i - 3] == '[' && response[i - 2] == '^')) { + whole_line_wanted = true; + break; + } + } + } + + // Scanf has very poor support for catching errors + // fortunately, we can abuse the %n specifier to determine + // if the entire string was matched. + _buffer[offset++] = '%'; + _buffer[offset++] = 'n'; + _buffer[offset++] = 0; + + debug_if(_dbg_on, "AT? %s\n", _buffer); + // To workaround scanf's lack of error reporting, we actually + // make two passes. One checks the validity with the modified + // format string that only stores the matched characters (%n). + // The other reads in the actual matched values. + // + // We keep trying the match until we succeed or some other error + // derails us. + int j = 0; + + while (true) { + // Receive next character + int c = getc(); + if (c < 0) { + debug_if(_dbg_on, "AT(Timeout)\n"); + return false; + } + // Simplify newlines (borrowed from retarget.cpp) + if ((c == CR && _in_prev != LF) || + (c == LF && _in_prev != CR)) { + _in_prev = c; + c = '\n'; + } else if ((c == CR && _in_prev == LF) || + (c == LF && _in_prev == CR)) { + _in_prev = c; + // onto next character + continue; + } else { + _in_prev = c; + } + _buffer[offset + j++] = c; + _buffer[offset + j] = 0; + + // Check for oob data + for (struct oob *oob = _oobs; oob; oob = oob->next) { + if ((unsigned)j == oob->len && memcmp( + oob->prefix, _buffer + offset, oob->len) == 0) { + debug_if(_dbg_on, "AT! %s\n", oob->prefix); + oob->cb(); + + if (_aborted) { + debug_if(_dbg_on, "AT(Aborted)\n"); + return false; + } + // oob may have corrupted non-reentrant buffer, + // so we need to set it up again + goto restart; + } + } + + // Check for match + int count = -1; + if (whole_line_wanted && c != '\n') { + // Don't attempt scanning until we get delimiter if they included it in format + // This allows recv("Foo: %s\n") to work, and not match with just the first character of a string + // (scanf does not itself match whitespace in its format string, so \n is not significant to it) + } else { + sscanf(_buffer + offset, _buffer, &count); + } + + // We only succeed if all characters in the response are matched + if (count == j) { + debug_if(_dbg_on, "AT= %s\n", _buffer + offset); + // Reuse the front end of the buffer + memcpy(_buffer, response, i); + _buffer[i] = 0; + + // Store the found results + vsscanf(_buffer + offset, _buffer, args); + + // Jump to next line and continue parsing + response += i; + break; + } + + // Clear the buffer when we hit a newline or ran out of space + // running out of space usually means we ran into binary data + if (c == '\n' || j + 1 >= _buffer_size - offset) { + debug_if(_dbg_on, "AT< %s", _buffer + offset); + j = 0; + } + } + } + + return true; +} + +// Mapping to vararg functions +int ATCmdParser::printf(const char *format, ...) +{ + va_list args; + va_start(args, format); + int res = vprintf(format, args); + va_end(args); + return res; +} + +int ATCmdParser::scanf(const char *format, ...) +{ + va_list args; + va_start(args, format); + int res = vscanf(format, args); + va_end(args); + return res; +} + +bool ATCmdParser::send(const char *command, ...) +{ + va_list args; + va_start(args, command); + bool res = vsend(command, args); + va_end(args); + return res; +} + +bool ATCmdParser::recv(const char *response, ...) +{ + va_list args; + va_start(args, response); + bool res = vrecv(response, args); + va_end(args); + return res; +} + +// oob registration +void ATCmdParser::oob(const char *prefix, Callback cb) +{ + struct oob *oob = new struct oob; + oob->len = strlen(prefix); + oob->prefix = prefix; + oob->cb = cb; + oob->next = _oobs; + _oobs = oob; +} + +void ATCmdParser::abort() +{ + _aborted = true; +} + +bool ATCmdParser::process_oob() +{ + if (!_fh->readable()) { + return false; + } + + int i = 0; + while (true) { + // Receive next character + int c = getc(); + if (c < 0) { + return false; + } + _buffer[i++] = c; + _buffer[i] = 0; + + // Check for oob data + struct oob *oob = _oobs; + while (oob) { + if (i == (int)oob->len && memcmp( + oob->prefix, _buffer, oob->len) == 0) { + debug_if(_dbg_on, "AT! %s\r\n", oob->prefix); + oob->cb(); + return true; + } + oob = oob->next; + } + + // Clear the buffer when we hit a newline or ran out of space + // running out of space usually means we ran into binary data + if (i + 1 >= _buffer_size || + strcmp(&_buffer[i - _output_delim_size], _output_delimiter) == 0) { + + debug_if(_dbg_on, "AT< %s", _buffer); + i = 0; + } + } +} + + diff --git a/UNITTESTS/stubs/ATHandler_stub.cpp b/UNITTESTS/stubs/ATHandler_stub.cpp index cee8e30579..3daf8da115 100644 --- a/UNITTESTS/stubs/ATHandler_stub.cpp +++ b/UNITTESTS/stubs/ATHandler_stub.cpp @@ -31,6 +31,10 @@ const int DEFAULT_AT_TIMEOUT = 1000; // at default timeout in milliseconds nsapi_error_t ATHandler_stub::nsapi_error_value = 0; uint8_t ATHandler_stub::nsapi_error_ok_counter = 0; int ATHandler_stub::int_value = -1; +int ATHandler_stub::ref_count = 0; +int ATHandler_stub::timeout = 0; +bool ATHandler_stub::default_timeout = 0; +bool ATHandler_stub::debug_on = 0; ssize_t ATHandler_stub::ssize_value = 0; char *ATHandler_stub::read_string_value = NULL; size_t ATHandler_stub::size_value = 0; @@ -41,28 +45,45 @@ FileHandle_stub *ATHandler_stub::fh_value = NULL; device_err_t ATHandler_stub::device_err_value; Callback ATHandler_stub::callback = NULL; uint8_t ATHandler_stub::resp_info_true_counter = false; +uint8_t ATHandler_stub::info_elem_true_counter = false; +int ATHandler_stub::int_valid_count_table[kRead_int_table_size]; +int ATHandler_stub::int_count = kRead_int_table_size; -ATHandler::ATHandler(FileHandle *fh, EventQueue &queue, int timeout, const char *output_delimiter, uint16_t send_delay) : _nextATHandler(0), +int ATHandler_stub::read_string_index = kRead_string_table_size; +char *ATHandler_stub::read_string_table[kRead_string_table_size]; +int ATHandler_stub::resp_stop_success_count = kResp_stop_count_default; + +ATHandler::ATHandler(FileHandle *fh, EventQueue &queue, int timeout, const char *output_delimiter, uint16_t send_delay) : + _nextATHandler(0), _fileHandle(fh), _queue(queue) { + ATHandler_stub::ref_count = 1; +} + +void ATHandler::set_debug(bool debug_on) +{ + ATHandler_stub::debug_on = debug_on; } ATHandler::~ATHandler() { + ATHandler_stub::ref_count = -909; } void ATHandler::inc_ref_count() { + ATHandler_stub::ref_count++; } void ATHandler::dec_ref_count() { + ATHandler_stub::ref_count--; } int ATHandler::get_ref_count() { - return ATHandler_stub::int_value; + return ATHandler_stub::ref_count; } FileHandle *ATHandler::get_file_handle() @@ -77,7 +98,7 @@ void ATHandler::set_file_handle(FileHandle *fh) nsapi_error_t ATHandler::set_urc_handler(const char *urc, mbed::Callback cb) { ATHandler_stub::callback = cb; - return NSAPI_ERROR_OK; + return ATHandler_stub::nsapi_error_value; } void ATHandler::remove_urc_handler(const char *prefix, mbed::Callback callback) @@ -108,6 +129,8 @@ nsapi_error_t ATHandler::unlock_return_error() void ATHandler::set_at_timeout(uint32_t timeout_milliseconds, bool default_timeout) { + ATHandler_stub::timeout = timeout_milliseconds; + ATHandler_stub::default_timeout = default_timeout; } void ATHandler::restore_at_timeout() @@ -120,10 +143,12 @@ void ATHandler::process_oob() void ATHandler::clear_error() { + ATHandler_stub::nsapi_error_ok_counter++; } void ATHandler::skip_param(uint32_t count) { + } void ATHandler::skip_param(ssize_t len, uint32_t count) @@ -137,15 +162,44 @@ ssize_t ATHandler::read_bytes(uint8_t *buf, size_t len) ssize_t ATHandler::read_string(char *buf, size_t size, bool read_even_stop_tag) { - if (ATHandler_stub::read_string_value && ATHandler_stub::ssize_value >= 0) { - memcpy(buf, ATHandler_stub::read_string_value, ATHandler_stub::ssize_value); + + if (ATHandler_stub::read_string_index == kRead_string_table_size) { + if (ATHandler_stub::read_string_value && ATHandler_stub::ssize_value >= 0) { + memcpy(buf, ATHandler_stub::read_string_value, ATHandler_stub::ssize_value + 1); + } + return ATHandler_stub::ssize_value; } - return ATHandler_stub::ssize_value; + + ATHandler_stub::read_string_index--; + if (ATHandler_stub::read_string_index >= 0) { + char *tmp = ATHandler_stub::read_string_table[ATHandler_stub::read_string_index]; + ssize_t len = strlen(tmp); + memcpy(buf, tmp, len + 1); + return len; + } + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + return -1; } -int ATHandler::read_int() +int32_t ATHandler::read_int() { - return ATHandler_stub::int_value; + if (ATHandler_stub::nsapi_error_value != NSAPI_ERROR_OK) { + return -1; + } + + if (ATHandler_stub::int_count == kRead_int_table_size) { + return ATHandler_stub::int_value; + } + + //printf("ATHandler_stub::int_count: %d", ATHandler_stub::int_count); + ATHandler_stub::int_count--; + if (ATHandler_stub::int_count < kRead_int_table_size && ATHandler_stub::int_count >= 0) { + return ATHandler_stub::int_valid_count_table[ATHandler_stub::int_count]; + } + + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; + return -1; } void ATHandler::set_delimiter(char delimiter) @@ -180,6 +234,10 @@ bool ATHandler::info_resp() bool ATHandler::info_elem(char start_tag) { + if (ATHandler_stub::info_elem_true_counter) { + ATHandler_stub::info_elem_true_counter--; + return true; + } return ATHandler_stub::bool_value; } @@ -190,13 +248,18 @@ bool ATHandler::consume_to_stop_tag() void ATHandler::resp_stop() { + if (ATHandler_stub::resp_stop_success_count > 0) { + ATHandler_stub::resp_stop_success_count--; + return; + } + ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR; } void ATHandler::cmd_start(const char *cmd) { } -void ATHandler::write_int(int param) +void ATHandler::write_int(int32_t param) { } @@ -223,4 +286,5 @@ device_err_t ATHandler::get_last_device_error() const void ATHandler::flush() { + } diff --git a/UNITTESTS/stubs/ATHandler_stub.h b/UNITTESTS/stubs/ATHandler_stub.h index 6ea956601a..d259938488 100644 --- a/UNITTESTS/stubs/ATHandler_stub.h +++ b/UNITTESTS/stubs/ATHandler_stub.h @@ -23,21 +23,37 @@ #include "FileHandle_stub.h" #include "Callback.h" -namespace ATHandler_stub -{ +#ifndef __AT_HANDLER_STUB_H__ +#define __AT_HANDLER_STUB_H__ +static const int kRead_string_table_size = 100; +static const int kRead_int_table_size = 100; +static const int kResp_stop_count_default = 100; + +namespace ATHandler_stub { extern nsapi_error_t nsapi_error_value; extern uint8_t nsapi_error_ok_counter; extern int int_value; +extern int ref_count; +extern int timeout; +extern bool default_timeout; +extern bool debug_on; extern ssize_t ssize_value; extern char *read_string_value; extern size_t size_value; extern size_t return_given_size; extern bool bool_value; extern uint8_t resp_info_true_counter; +extern uint8_t info_elem_true_counter; extern uint8_t uint8_value; extern mbed::FileHandle_stub *fh_value; extern mbed::device_err_t device_err_value; extern mbed::Callback callback; +extern char *read_string_table[kRead_string_table_size]; +extern int read_string_index; +extern int int_valid_count_table[kRead_int_table_size]; +extern int int_count; +extern int resp_stop_success_count; +} -} // namespace ATHandler_stub +#endif diff --git a/UNITTESTS/stubs/AT_CellularBase_stub.cpp b/UNITTESTS/stubs/AT_CellularBase_stub.cpp new file mode 100644 index 0000000000..e1f8526f5f --- /dev/null +++ b/UNITTESTS/stubs/AT_CellularBase_stub.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2017, 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 "nsapi_types.h" +#include "AT_CellularBase.h" +#include "AT_CellularBase_stub.h" + + +using namespace mbed; + +ATHandler *AT_CellularBase_stub::handler_value = NULL; +ATHandler *AT_CellularBase_stub::handler_at_constructor_value = NULL; +device_err_t AT_CellularBase_stub::device_err_value; +bool AT_CellularBase_stub::supported_bool = true; + +AT_CellularBase::AT_CellularBase(ATHandler &at) : _at(at) +{ + AT_CellularBase_stub::handler_at_constructor_value = &_at; +} + +ATHandler &AT_CellularBase::get_at_handler() +{ + return *AT_CellularBase_stub::handler_value; +} + +device_err_t AT_CellularBase::get_device_error() const +{ + return AT_CellularBase_stub::device_err_value; +} + +bool AT_CellularBase::is_supported(SupportedFeature feature) +{ + return AT_CellularBase_stub::supported_bool; +} diff --git a/UNITTESTS/stubs/AT_CellularBase_stub.h b/UNITTESTS/stubs/AT_CellularBase_stub.h new file mode 100644 index 0000000000..f7d117d192 --- /dev/null +++ b/UNITTESTS/stubs/AT_CellularBase_stub.h @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2017, 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 "ATHandler.h" + +namespace AT_CellularBase_stub { +extern mbed::ATHandler *handler_value; +extern mbed::ATHandler *handler_at_constructor_value; +extern mbed::device_err_t device_err_value; +extern bool supported_bool; +} diff --git a/UNITTESTS/stubs/AT_CellularDevice_stub.cpp b/UNITTESTS/stubs/AT_CellularDevice_stub.cpp new file mode 100644 index 0000000000..2010018ced --- /dev/null +++ b/UNITTESTS/stubs/AT_CellularDevice_stub.cpp @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2017, 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 "AT_CellularDevice.h" + +AT_CellularDevice::AT_CellularDevice(EventQueue &queue) : + _atHandlers(0), _network(0), _sms(0), _sim(0), _power(0), _multiplexer(0), _information(0), _queue(queue) +{ +} + +AT_CellularDevice::~AT_CellularDevice() +{ +} + +ATHandler *AT_CellularDevice::get_at_handler(FileHandle *fileHandle) +{ + return NULL; +} + +void AT_CellularDevice::release_at_handler(ATHandler *at_handler) +{ + +} + +CellularNetwork *AT_CellularDevice::open_network(FileHandle *fh) +{ + return NULL; +} + +CellularSMS *AT_CellularDevice::open_sms(FileHandle *fh) +{ + return NULL; +} + +CellularSIM *AT_CellularDevice::open_sim(FileHandle *fh) +{ + return NULL; +} + +CellularPower *AT_CellularDevice::open_power(FileHandle *fh) +{ + return NULL; +} + +CellularMultiplexer *AT_CellularDevice::open_multiplexer(FileHandle *fh) +{ + return NULL; +} + +CellularInformation *AT_CellularDevice::open_information(FileHandle *fh) +{ + return NULL; +} + +void AT_CellularDevice::close_network() +{ +} + +void AT_CellularDevice::close_sms() +{ +} + +void AT_CellularDevice::close_power() +{ +} + +void AT_CellularDevice::close_sim() +{ +} + +void AT_CellularDevice::close_multiplexer() +{ +} + +void AT_CellularDevice::close_information() +{ +} diff --git a/UNITTESTS/stubs/AT_CellularInformation_stub.cpp b/UNITTESTS/stubs/AT_CellularInformation_stub.cpp new file mode 100644 index 0000000000..a41b3080d5 --- /dev/null +++ b/UNITTESTS/stubs/AT_CellularInformation_stub.cpp @@ -0,0 +1,49 @@ +/* + * 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 "AT_CellularInformation.h" +#include "nsapi_types.h" + +using namespace mbed; + +AT_CellularInformation::AT_CellularInformation(ATHandler &at) : AT_CellularBase(at) +{ +} + +AT_CellularInformation::~AT_CellularInformation() +{ +} + +nsapi_error_t AT_CellularInformation::get_manufacturer(char *buf, size_t buf_size) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularInformation::get_model(char *buf, size_t buf_size) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularInformation::get_revision(char *buf, size_t buf_size) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularInformation::get_serial_number(char *buf, size_t buf_size, SerialNumberType type) +{ + return NSAPI_ERROR_OK; +} diff --git a/UNITTESTS/stubs/AT_CellularMultiplexer_stub.cpp b/UNITTESTS/stubs/AT_CellularMultiplexer_stub.cpp new file mode 100644 index 0000000000..c397d5fb38 --- /dev/null +++ b/UNITTESTS/stubs/AT_CellularMultiplexer_stub.cpp @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2017, 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 "AT_CellularMultiplexer.h" +#include "CellularLog.h" +#include "nsapi_types.h" + +using namespace mbed; + +AT_CellularMultiplexer::AT_CellularMultiplexer(ATHandler &at) : AT_CellularBase(at) +{ +} + +AT_CellularMultiplexer::~AT_CellularMultiplexer() +{ +} + +nsapi_error_t AT_CellularMultiplexer::multiplexer_mode_start() +{ + return 0; +} diff --git a/UNITTESTS/stubs/AT_CellularNetwork_stub.cpp b/UNITTESTS/stubs/AT_CellularNetwork_stub.cpp new file mode 100644 index 0000000000..c4ba878439 --- /dev/null +++ b/UNITTESTS/stubs/AT_CellularNetwork_stub.cpp @@ -0,0 +1,256 @@ +/* + * Copyright (c) 2017, 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 "AT_CellularNetwork.h" +#include "CellularNetwork.h" +#include "CellularUtil.h" +#include "CellularLog.h" +#include "FileHandle.h" +#include "nsapi_types.h" + +using namespace mbed; +using namespace mbed_cellular_util; + +AT_CellularNetwork::AT_CellularNetwork(ATHandler &atHandler) : AT_CellularBase(atHandler) +{ +} + +AT_CellularNetwork::~AT_CellularNetwork() +{ +} + +nsapi_error_t AT_CellularNetwork::init() +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::set_credentials(const char *apn, + const char *username, const char *password) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::set_credentials(const char *apn, + AuthenticationType type, const char *username, const char *password) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::connect(const char *apn, + const char *username, const char *password) +{ + return connect(); +} + +nsapi_error_t AT_CellularNetwork::connect() +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::activate_context() +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::open_data_channel() +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::disconnect() +{ + return NSAPI_ERROR_OK; +} + +void AT_CellularNetwork::attach(Callback status_cb) +{ +} + +nsapi_connection_status_t AT_CellularNetwork::get_connection_status() const +{ + return NSAPI_STATUS_LOCAL_UP; +} + +nsapi_error_t AT_CellularNetwork::set_blocking(bool blocking) +{ + return NSAPI_ERROR_OK;; +} + +nsapi_ip_stack_t AT_CellularNetwork::string_to_stack_type(const char *pdp_type) +{ + return IPV4_STACK; +} + +nsapi_error_t AT_CellularNetwork::set_registration_urc(RegistrationType type, bool urc_on) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::get_network_registering_mode(NWRegisteringMode &mode) +{ + mode = NWModeAutomatic; + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::set_registration(const char *plmn) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::get_registration_status(RegistrationType type, RegistrationStatus &status) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::get_cell_id(int &cell_id) +{ + return NSAPI_ERROR_OK; +} + +AT_CellularNetwork::RegistrationMode AT_CellularNetwork::has_registration(RegistrationType reg_type) +{ + return RegistrationModeDisable; +} + +nsapi_error_t AT_CellularNetwork::set_attach(int timeout) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::get_attach(AttachStatus &status) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::detach() +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::get_apn_backoff_timer(int &backoffTime) +{ + return NSAPI_ERROR_OK; +} + +NetworkStack *AT_CellularNetwork::get_stack() +{ + return NULL; +} + +const char *AT_CellularNetwork::get_ip_address() +{ + return NULL; +} + +nsapi_error_t AT_CellularNetwork::set_stack_type(nsapi_ip_stack_t stack_type) +{ + return NSAPI_ERROR_OK; +} + +nsapi_ip_stack_t AT_CellularNetwork::get_stack_type() +{ + return IPV4_STACK; +} + +bool AT_CellularNetwork::get_modem_stack_type(nsapi_ip_stack_t requested_stack) +{ + return false; +} + +void AT_CellularNetwork::urc_no_carrier() +{ + +} + +nsapi_error_t AT_CellularNetwork::set_access_technology_impl(RadioAccessTechnology opsAct) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::set_access_technology(RadioAccessTechnology opAct) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::get_access_technology(RadioAccessTechnology &rat) +{ + rat = RAT_CATM1; + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::scan_plmn(operList_t &operators, int &opsCount) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::set_ciot_optimization_config(Supported_UE_Opt supported_opt, + Preferred_UE_Opt preferred_opt) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::get_ciot_optimization_config(Supported_UE_Opt &supported_opt, + Preferred_UE_Opt &preferred_opt) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::get_rate_control( + CellularNetwork::RateControlExceptionReports &reports, + CellularNetwork::RateControlUplinkTimeUnit &timeUnit, int &uplinkRate) +{ + return NSAPI_ERROR_OK; +} + + +nsapi_error_t AT_CellularNetwork::get_pdpcontext_params(pdpContextList_t ¶ms_list) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::get_extended_signal_quality(int &rxlev, int &ber, int &rscp, int &ecno, int &rsrq, int &rsrp) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::get_signal_quality(int &rssi, int &ber) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::get_operator_params(int &format, operator_t &operator_params) +{ + return NSAPI_ERROR_OK; +} + +int AT_CellularNetwork::get_3gpp_error() +{ + return 0; +} + +nsapi_error_t AT_CellularNetwork::get_operator_names(operator_names_list &op_names) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularNetwork::do_user_authentication() +{ + return NSAPI_ERROR_OK; +} + + + diff --git a/UNITTESTS/stubs/AT_CellularPower_stub.cpp b/UNITTESTS/stubs/AT_CellularPower_stub.cpp new file mode 100644 index 0000000000..3459088ce5 --- /dev/null +++ b/UNITTESTS/stubs/AT_CellularPower_stub.cpp @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2017, 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 "AT_CellularPower.h" +#include "CellularUtil.h" +#include "CellularLog.h" + +using namespace mbed_cellular_util; +using namespace mbed; + +AT_CellularPower::AT_CellularPower(ATHandler &at) : AT_CellularBase(at) +{ +} + +AT_CellularPower::~AT_CellularPower() +{ +} + +nsapi_error_t AT_CellularPower::on() +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularPower::off() +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularPower::set_at_mode() +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularPower::set_power_level(int func_level, int do_reset) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularPower::reset() +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularPower::opt_power_save_mode(int periodic_time, int active_time) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularPower::opt_receive_period(int mode, EDRXAccessTechnology act_type, uint8_t edrx_value) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularPower::set_device_ready_urc_cb(mbed::Callback callback) +{ + return NSAPI_ERROR_OK; +} + +void AT_CellularPower::remove_device_ready_urc_cb(mbed::Callback callback) +{ + +} + +nsapi_error_t AT_CellularPower::is_device_ready() +{ + return NSAPI_ERROR_OK; +} diff --git a/UNITTESTS/stubs/AT_CellularSIM_stub.cpp b/UNITTESTS/stubs/AT_CellularSIM_stub.cpp new file mode 100644 index 0000000000..fc4be35b94 --- /dev/null +++ b/UNITTESTS/stubs/AT_CellularSIM_stub.cpp @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2017, 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 "AT_CellularSIM.h" +#include "CellularLog.h" + +using namespace mbed; + +AT_CellularSIM::AT_CellularSIM(ATHandler &at) : AT_CellularBase(at) +{ +} + +AT_CellularSIM::~AT_CellularSIM() +{ +} + +nsapi_error_t AT_CellularSIM::get_sim_state(SimState &state) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularSIM::set_pin(const char *sim_pin) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularSIM::change_pin(const char *sim_pin, const char *new_pin) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularSIM::set_pin_query(const char *sim_pin, bool query_pin) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularSIM::get_imsi(char *imsi) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularSIM::get_iccid(char *buf, size_t buf_size) +{ + return NSAPI_ERROR_OK; +} diff --git a/UNITTESTS/stubs/AT_CellularSMS_stub.cpp b/UNITTESTS/stubs/AT_CellularSMS_stub.cpp new file mode 100644 index 0000000000..66456d7295 --- /dev/null +++ b/UNITTESTS/stubs/AT_CellularSMS_stub.cpp @@ -0,0 +1,190 @@ +/* + * Copyright (c) 2017, 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 +#include "AT_CellularSMS.h" +#include "CellularLog.h" + +using namespace mbed; + +#define CTRL_Z "\x1a" +#define ESC "\x1b" + +const int SMS_STATUS_SIZE = 12 + 1; +const int FIRST_OCTET_DELIVER_SUBMIT = 17; +const int TP_VALIDITY_PERIOD_24_HOURS = 167; +const int TP_PROTOCOL_IDENTIFIER = 0; +const int SMS_DATA_CODING_SCHEME = 0; + +const uint16_t SMS_MAX_8BIT_CONCATENATED_SINGLE_SMS_SIZE = 134; +const uint16_t SMS_MAX_GSM7_CONCATENATED_SINGLE_SMS_SIZE = 153; + + +AT_CellularSMS::AT_CellularSMS(ATHandler &at) : AT_CellularBase(at), _cb(0), _mode(CellularSMSMmodeText), + _use_8bit_encoding(false), _sim_wait_time(0), _sms_message_ref_number(1), _sms_info(NULL) +{ +} + +AT_CellularSMS::~AT_CellularSMS() +{ +} + +void AT_CellularSMS::cmt_urc() +{ +} + +void AT_CellularSMS::cmti_urc() +{ +} + +nsapi_error_t AT_CellularSMS::set_cnmi() +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularSMS::set_cmgf(int msg_format) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularSMS::set_csmp(int fo, int vp, int pid, int dcs) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularSMS::set_csdh(int show_header) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularSMS::initialize(CellularSMSMmode mode) +{ + return NSAPI_ERROR_OK; +} + +void AT_CellularSMS::set_extra_sim_wait_time(int sim_wait_time) +{ +} + +char *AT_CellularSMS::create_pdu(const char *phone_number, const char *message, uint8_t message_length, uint8_t msg_parts, + uint8_t msg_part_number, uint8_t &header_size) +{ + return NULL; +} + +nsapi_size_or_error_t AT_CellularSMS::send_sms(const char *phone_number, const char *message, int msg_len) +{ + return NSAPI_ERROR_OK; +} + +void AT_CellularSMS::set_sms_callback(Callback func) +{ +} + +nsapi_error_t AT_CellularSMS::set_cpms(const char *memr, const char *memw, const char *mems) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularSMS::set_csca(const char *sca, int type) +{ + return NSAPI_ERROR_OK; +} + +nsapi_size_or_error_t AT_CellularSMS::set_cscs(const char *chr_set) +{ + return NSAPI_ERROR_OK; +} + +//nsapi_error_t AT_CellularSMS::set_csms(int msg_service) +//{ +// return NSAPI_ERROR_OK; +//} + +nsapi_error_t AT_CellularSMS::delete_sms(sms_info_t *sms) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularSMS::delete_all_messages() +{ + return NSAPI_ERROR_OK; +} + +nsapi_size_or_error_t AT_CellularSMS::read_sms_from_index(int msg_index, char *buf, uint16_t len, char *phone_num, char *time_stamp) +{ + return NSAPI_ERROR_OK; +} + +// read msg in PDU mode +nsapi_size_or_error_t AT_CellularSMS::read_sms(sms_info_t *sms, char *buf, char *phone_num, char *time_stamp) +{ + return NSAPI_ERROR_OK; +} + +nsapi_size_or_error_t AT_CellularSMS::get_sms(char *buf, uint16_t len, char *phone_num, uint16_t phone_len, + char *time_stamp, uint16_t time_len, int *buf_size) +{ + return NSAPI_ERROR_OK; +} + +nsapi_size_or_error_t AT_CellularSMS::get_data_from_pdu(const char *pdu, sms_info_t *info, int *part_number, char *phone_number, char *msg) +{ + return NSAPI_ERROR_OK; +} + +// read params from User DEfined Header +int AT_CellularSMS::read_udh_from_pdu(const char *pdu, sms_info_t *info, int &part_number, int &padding_bits) +{ + return 0; +} + +nsapi_size_or_error_t AT_CellularSMS::read_pdu_payload(const char *pdu, int msg_len, int scheme, char *msg, int padding_bits) +{ + return NSAPI_ERROR_OK; +} + +void AT_CellularSMS::free_linked_list() +{ +} + +void AT_CellularSMS::add_info(sms_info_t *info, int index, int part_number) +{ +} + +// reads all the messages to the linked list AT_CellularSMS::_sms_info +nsapi_error_t AT_CellularSMS::list_messages() +{ + return NSAPI_ERROR_OK; +} + +AT_CellularSMS::sms_info_t *AT_CellularSMS::get_oldest_sms_index() +{ + return NULL; +} + +// if time_string_1 is greater (more fresh date) then return 1, same 0, smaller -1. Error -2 +int AT_CellularSMS::compare_time_strings(const char *time_string_1, const char *time_string_2) +{ + return 0; +} + +bool AT_CellularSMS::create_time(const char *time_string, time_t *time) +{ + return 0; +} + diff --git a/UNITTESTS/stubs/AT_CellularStack_stub.cpp b/UNITTESTS/stubs/AT_CellularStack_stub.cpp new file mode 100644 index 0000000000..640d8c1b68 --- /dev/null +++ b/UNITTESTS/stubs/AT_CellularStack_stub.cpp @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2017, 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 "AT_CellularStack.h" +#include "CellularUtil.h" +#include "CellularLog.h" + +using namespace mbed_cellular_util; + +AT_CellularStack::AT_CellularStack(ATHandler &atHandler, int cid, nsapi_ip_stack_t stack_type) : _at(atHandler), _socket(NULL), _cid(cid), _stack_type(stack_type) +{ +} + +AT_CellularStack::~AT_CellularStack() +{ +} + +const char *AT_CellularStack::get_ip_address() +{ + return NULL; +} + +nsapi_error_t AT_CellularStack::socket_open(nsapi_socket_t *handle, nsapi_protocol_t proto) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularStack::socket_close(nsapi_socket_t handle) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularStack::socket_bind(nsapi_socket_t handle, const SocketAddress &addr) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularStack::socket_listen(nsapi_socket_t handle, int backlog) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularStack::socket_connect(nsapi_socket_t handle, const SocketAddress &addr) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t AT_CellularStack::socket_accept(void *server, void **socket, SocketAddress *addr) +{ + return NSAPI_ERROR_OK; +} + +nsapi_size_or_error_t AT_CellularStack::socket_send(nsapi_socket_t handle, const void *data, unsigned size) +{ + return NSAPI_ERROR_OK; +} + +nsapi_size_or_error_t AT_CellularStack::socket_sendto(nsapi_socket_t handle, const SocketAddress &addr, const void *data, unsigned size) +{ + return NSAPI_ERROR_OK; +} + +nsapi_size_or_error_t AT_CellularStack::socket_recv(nsapi_socket_t handle, void *data, unsigned size) +{ + return NSAPI_ERROR_OK; +} + +nsapi_size_or_error_t AT_CellularStack::socket_recvfrom(nsapi_socket_t handle, SocketAddress *addr, void *buffer, unsigned size) +{ + return NSAPI_ERROR_OK; +} + +void AT_CellularStack::socket_attach(nsapi_socket_t handle, void (*callback)(void *), void *data) +{ +} + diff --git a/UNITTESTS/stubs/BufferedBlockDevice_stub.cpp b/UNITTESTS/stubs/BufferedBlockDevice_stub.cpp new file mode 100644 index 0000000000..9c9fabea1f --- /dev/null +++ b/UNITTESTS/stubs/BufferedBlockDevice_stub.cpp @@ -0,0 +1,104 @@ +/* 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. + */ + +#include "BufferedBlockDevice.h" +#include "mbed_assert.h" +#include "mbed_critical.h" +#include +#include + +static inline uint32_t align_down(bd_size_t val, bd_size_t size) +{ + return 0; +} + +BufferedBlockDevice::BufferedBlockDevice(BlockDevice *bd) +{ +} + +BufferedBlockDevice::~BufferedBlockDevice() +{ +} + +int BufferedBlockDevice::init() +{ + return 0; +} + +int BufferedBlockDevice::deinit() +{ + return 0; +} + +int BufferedBlockDevice::flush() +{ + return 0; +} + +int BufferedBlockDevice::sync() +{ + return 0; +} + +int BufferedBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int BufferedBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int BufferedBlockDevice::erase(bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int BufferedBlockDevice::trim(bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +bd_size_t BufferedBlockDevice::get_read_size() const +{ + return 1; +} + +bd_size_t BufferedBlockDevice::get_program_size() const +{ + return 1; +} + +bd_size_t BufferedBlockDevice::get_erase_size() const +{ + return 0; +} + +bd_size_t BufferedBlockDevice::get_erase_size(bd_addr_t addr) const +{ + return 0; +} + +int BufferedBlockDevice::get_erase_value() const +{ + return 0; +} + +bd_size_t BufferedBlockDevice::size() const +{ + return 0; +} diff --git a/UNITTESTS/stubs/CellularUtil_stub.cpp b/UNITTESTS/stubs/CellularUtil_stub.cpp new file mode 100644 index 0000000000..d4bcaf4916 --- /dev/null +++ b/UNITTESTS/stubs/CellularUtil_stub.cpp @@ -0,0 +1,113 @@ +/* + * Copyright (c) , 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 "CellularUtil.h" +#include +#include +#include + +namespace mbed_cellular_util { + +#define MAX_STRING_LEN 200 + +void str_copy_skip_char(char *dest, uint16_t dest_size, const char *src, char c) +{ +} + +void str_remove_char(char *src, char c) +{ +} + +void uint_to_binary_str(uint32_t num, char *str, uint8_t str_size, uint8_t bit_cnt) +{ +} + +// converts the given str to hex string to buf +uint16_t char_str_to_hex(const char *str, uint16_t len, char *buf, bool omit_leading_zero) +{ + return 0; +} + +void convert_ipv6(char *ip) +{ + +} + +char *find_dot_number(char *str, int dot_number) +{ + return NULL; +} + +void separate_ip4like_addresses(char *orig, char *ip, size_t ip_size, char *ip2, size_t ip2_size) +{ +} + +void separate_ip_addresses(char *orig, char *ip, size_t ip_size, char *ip2, size_t ip2_size) +{ +} + +void prefer_ipv6(char *ip, size_t ip_size, char *ip2, size_t ip2_size) +{ +} + +void int_to_hex_str(uint8_t num, char *buf) +{ + buf[0] = '0'; + buf[1] = '2'; +} + +int hex_str_to_int(const char *hex_string, int hex_string_length) +{ + return 0; +} + +int hex_str_to_char_str(const char *str, uint16_t len, char *buf) +{ + return 0; +} + +void uint_to_binary_str(uint32_t num, char *str, int str_size, int bit_cnt) +{ + +} + +int char_str_to_hex_str(const char *str, uint16_t len, char *buf, bool omit_leading_zero) +{ + //The code is dependent on this, so this is easiest just to put here + if (!str || !buf) { + return 0; + } + + char *ptr = buf; + int i = 0; + while (i < len) { + if (omit_leading_zero == true && i == 0 && !(str[i] >> 4 & 0x0F)) { + *ptr++ = hex_values[(str[i]) & 0x0F]; + } else { + *ptr++ = hex_values[((str[i]) >> 4) & 0x0F]; + *ptr++ = hex_values[(str[i]) & 0x0F]; + } + i++; + } + return ptr - buf; +} + +uint16_t get_dynamic_ip_port() +{ + return 0; +} + +} // namespace mbed_cellular_util diff --git a/UNITTESTS/stubs/ChainingBlockDevice_stub.cpp b/UNITTESTS/stubs/ChainingBlockDevice_stub.cpp new file mode 100644 index 0000000000..51134b3553 --- /dev/null +++ b/UNITTESTS/stubs/ChainingBlockDevice_stub.cpp @@ -0,0 +1,88 @@ +/* mbed Microcontroller Library + * Copyright (c) 2017 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. + */ + +#include "ChainingBlockDevice.h" +#include "mbed_critical.h" + + +ChainingBlockDevice::ChainingBlockDevice(BlockDevice **bds, size_t bd_count) +{ +} + +static bool is_aligned(uint64_t x, uint64_t alignment) +{ + return true; +} + +int ChainingBlockDevice::init() +{ + return 0; +} + +int ChainingBlockDevice::deinit() +{ + return 0; +} + +int ChainingBlockDevice::sync() +{ + return 0; +} + +int ChainingBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int ChainingBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int ChainingBlockDevice::erase(bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +bd_size_t ChainingBlockDevice::get_read_size() const +{ + return 0; +} + +bd_size_t ChainingBlockDevice::get_program_size() const +{ + return 0; +} + +bd_size_t ChainingBlockDevice::get_erase_size() const +{ + return 0; +} + +bd_size_t ChainingBlockDevice::get_erase_size(bd_addr_t addr) const +{ + return 0; +} + +int ChainingBlockDevice::get_erase_value() const +{ + return 0; +} + +bd_size_t ChainingBlockDevice::size() const +{ + return 0; +} diff --git a/UNITTESTS/stubs/EventFlags_stub.cpp b/UNITTESTS/stubs/EventFlags_stub.cpp index 95762b8b83..5e5b0736e5 100644 --- a/UNITTESTS/stubs/EventFlags_stub.cpp +++ b/UNITTESTS/stubs/EventFlags_stub.cpp @@ -15,6 +15,7 @@ * limitations under the License. */ +#include #include "rtos/EventFlags.h" rtos::EventFlags::EventFlags() {} diff --git a/UNITTESTS/stubs/ExhaustibleBlockDevice_stub.cpp b/UNITTESTS/stubs/ExhaustibleBlockDevice_stub.cpp new file mode 100644 index 0000000000..36cdb1cfac --- /dev/null +++ b/UNITTESTS/stubs/ExhaustibleBlockDevice_stub.cpp @@ -0,0 +1,88 @@ +/* mbed Microcontroller Library + * Copyright (c) 2017 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. + */ + +#include "ExhaustibleBlockDevice.h" +#include "mbed.h" +#include "mbed_critical.h" + + +ExhaustibleBlockDevice::ExhaustibleBlockDevice(BlockDevice *bd, uint32_t erase_cycles) +{ +} + +ExhaustibleBlockDevice::~ExhaustibleBlockDevice() +{ +} + +int ExhaustibleBlockDevice::init() +{ + return 0; +} + +int ExhaustibleBlockDevice::deinit() +{ + return 0; +} + +int ExhaustibleBlockDevice::sync() +{ + return 0; +} + +int ExhaustibleBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int ExhaustibleBlockDevice::program(const void *buffer, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int ExhaustibleBlockDevice::erase(bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +bd_size_t ExhaustibleBlockDevice::get_read_size() const +{ + return 0; +} + +bd_size_t ExhaustibleBlockDevice::get_program_size() const +{ + return 0; +} + +bd_size_t ExhaustibleBlockDevice::get_erase_size() const +{ + return 0; +} + +bd_size_t ExhaustibleBlockDevice::get_erase_size(bd_addr_t addr) const +{ + return 0; +} + +int ExhaustibleBlockDevice::get_erase_value() const +{ + return 0; +} + +bd_size_t ExhaustibleBlockDevice::size() const +{ + return 0; +} diff --git a/UNITTESTS/stubs/FlashSimBlockDevice_stub.cpp b/UNITTESTS/stubs/FlashSimBlockDevice_stub.cpp new file mode 100644 index 0000000000..bbc9db57ce --- /dev/null +++ b/UNITTESTS/stubs/FlashSimBlockDevice_stub.cpp @@ -0,0 +1,97 @@ +/* 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. + */ + +#include "FlashSimBlockDevice.h" +#include "mbed_assert.h" +#include "mbed_critical.h" +#include +#include +#include + +static const bd_size_t min_blank_buf_size = 32; + +static inline uint32_t align_up(bd_size_t val, bd_size_t size) +{ + return (((val - 1) / size) + 1) * size; +} + +FlashSimBlockDevice::FlashSimBlockDevice(BlockDevice *bd, uint8_t erase_value) +{ +} + +FlashSimBlockDevice::~FlashSimBlockDevice() +{ +} + +int FlashSimBlockDevice::init() +{ + return 0; +} + +int FlashSimBlockDevice::deinit() +{ + return 0; +} + +int FlashSimBlockDevice::sync() +{ + return 0; +} + +bd_size_t FlashSimBlockDevice::get_read_size() const +{ + return 0; +} + +bd_size_t FlashSimBlockDevice::get_program_size() const +{ + return 0; +} + +bd_size_t FlashSimBlockDevice::get_erase_size() const +{ + return 0; +} + +bd_size_t FlashSimBlockDevice::get_erase_size(bd_addr_t addr) const +{ + return 0; +} + +bd_size_t FlashSimBlockDevice::size() const +{ + return 0; +} + +int FlashSimBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int FlashSimBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int FlashSimBlockDevice::erase(bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int FlashSimBlockDevice::get_erase_value() const +{ + return 0; +} diff --git a/UNITTESTS/stubs/HeapBlockDevice_stub.cpp b/UNITTESTS/stubs/HeapBlockDevice_stub.cpp new file mode 100644 index 0000000000..afa6e9bbbc --- /dev/null +++ b/UNITTESTS/stubs/HeapBlockDevice_stub.cpp @@ -0,0 +1,82 @@ +/* mbed Microcontroller Library + * Copyright (c) 2017 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. + */ + +#include "HeapBlockDevice.h" +#include "mbed_critical.h" + + +HeapBlockDevice::HeapBlockDevice(bd_size_t size, bd_size_t block) +{ +} + +HeapBlockDevice::HeapBlockDevice(bd_size_t size, bd_size_t read, bd_size_t program, bd_size_t erase) +{ +} + +HeapBlockDevice::~HeapBlockDevice() +{ +} + +int HeapBlockDevice::init() +{ + return 0; +} + +int HeapBlockDevice::deinit() +{ + return 0; +} + +bd_size_t HeapBlockDevice::get_read_size() const +{ + return 0; +} + +bd_size_t HeapBlockDevice::get_program_size() const +{ + return 0; +} + +bd_size_t HeapBlockDevice::get_erase_size() const +{ + return 0; +} + +bd_size_t HeapBlockDevice::get_erase_size(bd_addr_t addr) const +{ + return 0; +} + +bd_size_t HeapBlockDevice::size() const +{ + return 0; +} + +int HeapBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int HeapBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int HeapBlockDevice::erase(bd_addr_t addr, bd_size_t size) +{ + return 0; +} + diff --git a/UNITTESTS/stubs/Kernel_stub.cpp b/UNITTESTS/stubs/Kernel_stub.cpp new file mode 100644 index 0000000000..ecfa1d80af --- /dev/null +++ b/UNITTESTS/stubs/Kernel_stub.cpp @@ -0,0 +1,25 @@ +/* + * Copyright (c) , 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 "Kernel.h" + +namespace rtos { + +uint64_t Kernel::get_ms_count() +{ + return 20; +} +} diff --git a/UNITTESTS/stubs/MBRBlockDevice_stub.cpp b/UNITTESTS/stubs/MBRBlockDevice_stub.cpp new file mode 100644 index 0000000000..1e12f59cee --- /dev/null +++ b/UNITTESTS/stubs/MBRBlockDevice_stub.cpp @@ -0,0 +1,156 @@ +/* mbed Microcontroller Library + * Copyright (c) 2017 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. + */ + +#include "MBRBlockDevice.h" +#include "mbed_critical.h" +#include + + +// On disk structures, all entries are little endian +MBED_PACKED(struct) mbr_entry { + uint8_t status; + uint8_t chs_start[3]; + uint8_t type; + uint8_t chs_stop[3]; + uint32_t lba_offset; + uint32_t lba_size; +}; + +MBED_PACKED(struct) mbr_table { + struct mbr_entry entries[4]; + uint8_t signature[2]; +}; + +// Little-endian conversion, should compile to noop +// if system is little-endian +static inline uint32_t tole32(uint32_t a) +{ + return 0; +} + +static inline uint32_t fromle32(uint32_t a) +{ + return 0; +} + +static void tochs(uint32_t lba, uint8_t chs[3]) +{ +} + + +// Partition after address are turned into absolute +// addresses, assumes bd is initialized +static int partition_absolute( + BlockDevice *bd, int part, uint8_t type, + bd_size_t offset, bd_size_t size) +{ + return 0; +} + +int MBRBlockDevice::partition(BlockDevice *bd, int part, uint8_t type, bd_addr_t start) +{ + return 0; +} + +int MBRBlockDevice::partition(BlockDevice *bd, int part, uint8_t type, + bd_addr_t start, bd_addr_t stop) +{ + return 0; +} + +MBRBlockDevice::MBRBlockDevice(BlockDevice *bd, int part) +{ +} + +int MBRBlockDevice::init() +{ + return 0; +} + +int MBRBlockDevice::deinit() +{ + return 0; +} + +int MBRBlockDevice::sync() +{ + return 0; +} + +int MBRBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int MBRBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int MBRBlockDevice::erase(bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +bd_size_t MBRBlockDevice::get_read_size() const +{ + return 0; +} + +bd_size_t MBRBlockDevice::get_program_size() const +{ + return 0; +} + +bd_size_t MBRBlockDevice::get_erase_size() const +{ + return 0; +} + +bd_size_t MBRBlockDevice::get_erase_size(bd_addr_t addr) const +{ + return 0; +} + +int MBRBlockDevice::get_erase_value() const +{ + return 0; +} + +bd_size_t MBRBlockDevice::size() const +{ + return 0; +} + +bd_size_t MBRBlockDevice::get_partition_start() const +{ + return 0; +} + +bd_size_t MBRBlockDevice::get_partition_stop() const +{ + return 0; +} + +uint8_t MBRBlockDevice::get_partition_type() const +{ + return 0; +} + +int MBRBlockDevice::get_partition_number() const +{ + return 0; +} diff --git a/UNITTESTS/stubs/NetworkInterface_stub.cpp b/UNITTESTS/stubs/NetworkInterface_stub.cpp new file mode 100644 index 0000000000..0e8eaa15a9 --- /dev/null +++ b/UNITTESTS/stubs/NetworkInterface_stub.cpp @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2015, 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 "netsocket/NetworkInterface.h" +#include "netsocket/NetworkStack.h" +#include + + +// Default network-interface state +const char *NetworkInterface::get_mac_address() +{ + return 0; +} + +const char *NetworkInterface::get_ip_address() +{ + return 0; +} + +const char *NetworkInterface::get_netmask() +{ + return 0; +} + +const char *NetworkInterface::get_gateway() +{ + return 0; +} + +nsapi_error_t NetworkInterface::set_network(const char *ip_address, const char *netmask, const char *gateway) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + +nsapi_error_t NetworkInterface::set_dhcp(bool dhcp) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + +// DNS operations go through the underlying stack by default +nsapi_error_t NetworkInterface::gethostbyname(const char *name, SocketAddress *address, nsapi_version_t version) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + +nsapi_error_t NetworkInterface::add_dns_server(const SocketAddress &address) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + +void NetworkInterface::attach(mbed::Callback status_cb) +{ + +} + +nsapi_connection_status_t NetworkInterface::get_connection_status() const +{ + return NSAPI_STATUS_LOCAL_UP; +} + +nsapi_error_t NetworkInterface::set_blocking(bool blocking) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + +nsapi_value_or_error_t NetworkInterface::gethostbyname_async(char const *, mbed::Callback, nsapi_version) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + +nsapi_error_t NetworkInterface::gethostbyname_async_cancel(int id) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + diff --git a/UNITTESTS/stubs/NetworkStack_stub.cpp b/UNITTESTS/stubs/NetworkStack_stub.cpp new file mode 100644 index 0000000000..372812effb --- /dev/null +++ b/UNITTESTS/stubs/NetworkStack_stub.cpp @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2015, 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 "NetworkStack.h" +#include "nsapi_dns.h" +#include "mbed.h" +#include "stddef.h" +#include + +// Default NetworkStack operations +nsapi_error_t NetworkStack::gethostbyname(const char *name, SocketAddress *address, nsapi_version_t version) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t NetworkStack::add_dns_server(const SocketAddress &address) +{ + return NSAPI_ERROR_OK; +} + +nsapi_error_t NetworkStack::get_dns_server(int index, SocketAddress *address) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + +nsapi_error_t NetworkStack::setstackopt(int level, int optname, const void *optval, unsigned optlen) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + +nsapi_error_t NetworkStack::getstackopt(int level, int optname, void *optval, unsigned *optlen) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + +nsapi_error_t NetworkStack::setsockopt(void *handle, int level, int optname, const void *optval, unsigned optlen) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + +nsapi_error_t NetworkStack::getsockopt(void *handle, int level, int optname, void *optval, unsigned *optlen) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + +// Conversion function for network stacks +NetworkStack *nsapi_create_stack(nsapi_stack_t *stack) +{ + return NULL; +} + +NetworkStack *nsapi_create_stack(NetworkStack *stack) +{ + return NULL; +} + +nsapi_value_or_error_t NetworkStack::gethostbyname_async(const char *host, hostbyname_cb_t callback, + nsapi_version_t version) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + +nsapi_error_t NetworkStack::gethostbyname_async_cancel(int id) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + +call_in_callback_cb_t NetworkStack::get_call_in_callback() +{ + return NULL; +} + +nsapi_error_t NetworkStack::call_in(int delay, mbed::Callback func) +{ + return NSAPI_ERROR_UNSUPPORTED; +} + +const char *NetworkStack::get_ip_address() +{ + return NULL; +} diff --git a/UNITTESTS/stubs/ObservingBlockDevice_stub.cpp b/UNITTESTS/stubs/ObservingBlockDevice_stub.cpp new file mode 100644 index 0000000000..ffd9450a83 --- /dev/null +++ b/UNITTESTS/stubs/ObservingBlockDevice_stub.cpp @@ -0,0 +1,100 @@ +/* mbed Microcontroller Library + * Copyright (c) 2017-2017 ARM Limited + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "ObservingBlockDevice.h" +#include "ReadOnlyBlockDevice.h" +#include "mbed.h" + + +ObservingBlockDevice::ObservingBlockDevice(BlockDevice *bd) +{ + // Does nothing +} + +ObservingBlockDevice::~ObservingBlockDevice() +{ + // Does nothing +} + +void ObservingBlockDevice::attach(Callback cb) +{ +} + +int ObservingBlockDevice::init() +{ + return 0; +} + +int ObservingBlockDevice::deinit() +{ + return 0; +} + +int ObservingBlockDevice::sync() +{ + return 0; +} + +int ObservingBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int ObservingBlockDevice::program(const void *buffer, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int ObservingBlockDevice::erase(bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +bd_size_t ObservingBlockDevice::get_read_size() const +{ + return 0; +} + +bd_size_t ObservingBlockDevice::get_program_size() const +{ + return 0; +} + +bd_size_t ObservingBlockDevice::get_erase_size() const +{ + return 0; +} + +bd_size_t ObservingBlockDevice::get_erase_size(bd_addr_t addr) const +{ + return 0; +} + +int ObservingBlockDevice::get_erase_value() const +{ + return 0; +} + +bd_size_t ObservingBlockDevice::size() const +{ + return 0; +} diff --git a/UNITTESTS/stubs/ProfilingBlockDevice_stub.cpp b/UNITTESTS/stubs/ProfilingBlockDevice_stub.cpp new file mode 100644 index 0000000000..df41cb1da5 --- /dev/null +++ b/UNITTESTS/stubs/ProfilingBlockDevice_stub.cpp @@ -0,0 +1,101 @@ +/* mbed Microcontroller Library + * Copyright (c) 2017 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. + */ + +#include "ProfilingBlockDevice.h" + + +ProfilingBlockDevice::ProfilingBlockDevice(BlockDevice *bd) +{ +} + +int ProfilingBlockDevice::init() +{ + return 0; +} + +int ProfilingBlockDevice::deinit() +{ + return 0; +} + +int ProfilingBlockDevice::sync() +{ + return 0; +} + +int ProfilingBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int ProfilingBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int ProfilingBlockDevice::erase(bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +bd_size_t ProfilingBlockDevice::get_read_size() const +{ + return 0; +} + +bd_size_t ProfilingBlockDevice::get_program_size() const +{ + return 0; +} + +bd_size_t ProfilingBlockDevice::get_erase_size() const +{ + return 0; +} + +bd_size_t ProfilingBlockDevice::get_erase_size(bd_addr_t addr) const +{ + return 0; +} + +int ProfilingBlockDevice::get_erase_value() const +{ + return 0; +} + +bd_size_t ProfilingBlockDevice::size() const +{ + return 0; +} + +void ProfilingBlockDevice::reset() +{ +} + +bd_size_t ProfilingBlockDevice::get_read_count() const +{ + return 0; +} + +bd_size_t ProfilingBlockDevice::get_program_count() const +{ + return 0; +} + +bd_size_t ProfilingBlockDevice::get_erase_count() const +{ + return 0; +} diff --git a/UNITTESTS/stubs/ReadOnlyBlockDevice_stub.cpp b/UNITTESTS/stubs/ReadOnlyBlockDevice_stub.cpp new file mode 100644 index 0000000000..13e20d934e --- /dev/null +++ b/UNITTESTS/stubs/ReadOnlyBlockDevice_stub.cpp @@ -0,0 +1,95 @@ +/* mbed Microcontroller Library + * Copyright (c) 2017-2017 ARM Limited + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "ReadOnlyBlockDevice.h" +#include "mbed_error.h" + + +ReadOnlyBlockDevice::ReadOnlyBlockDevice(BlockDevice *bd) +{ + // Does nothing +} + +ReadOnlyBlockDevice::~ReadOnlyBlockDevice() +{ + // Does nothing +} + +int ReadOnlyBlockDevice::init() +{ + return 0; +} + +int ReadOnlyBlockDevice::deinit() +{ + return 0; +} + +int ReadOnlyBlockDevice::sync() +{ + return 0; +} + +int ReadOnlyBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int ReadOnlyBlockDevice::program(const void *buffer, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int ReadOnlyBlockDevice::erase(bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +bd_size_t ReadOnlyBlockDevice::get_read_size() const +{ + return 0; +} + +bd_size_t ReadOnlyBlockDevice::get_program_size() const +{ + return 0; +} + +bd_size_t ReadOnlyBlockDevice::get_erase_size() const +{ + return 0; +} + +bd_size_t ReadOnlyBlockDevice::get_erase_size(bd_addr_t addr) const +{ + return 0; +} + +int ReadOnlyBlockDevice::get_erase_value() const +{ + return 0; +} + +bd_size_t ReadOnlyBlockDevice::size() const +{ + return 0; +} diff --git a/UNITTESTS/stubs/Semaphore_stub.cpp b/UNITTESTS/stubs/Semaphore_stub.cpp new file mode 100644 index 0000000000..ada09df114 --- /dev/null +++ b/UNITTESTS/stubs/Semaphore_stub.cpp @@ -0,0 +1,57 @@ +/* + * Copyright (c) , 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 "Semaphore.h" + +namespace rtos { + +Semaphore::Semaphore(int32_t count) +{ + +} + +Semaphore::Semaphore(int32_t count, uint16_t max_count) +{ + +} + +void Semaphore::constructor(int32_t count, uint16_t max_count) +{ + +} + +int32_t Semaphore::wait(uint32_t millisec) +{ + return 0; +} + +int32_t Semaphore::wait_until(uint64_t millisec) +{ + return 0; +} + +osStatus Semaphore::release(void) +{ + return 0; +} + +Semaphore::~Semaphore() +{ + +} + +} diff --git a/UNITTESTS/stubs/SlicingBlockDevice_stub.cpp b/UNITTESTS/stubs/SlicingBlockDevice_stub.cpp new file mode 100644 index 0000000000..6b4fbabdcf --- /dev/null +++ b/UNITTESTS/stubs/SlicingBlockDevice_stub.cpp @@ -0,0 +1,83 @@ +/* mbed Microcontroller Library + * Copyright (c) 2017 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. + */ + +#include "SlicingBlockDevice.h" + + +SlicingBlockDevice::SlicingBlockDevice(BlockDevice *bd, bd_addr_t start, bd_addr_t stop) +{ + +} + +int SlicingBlockDevice::init() +{ + return 0; +} + +int SlicingBlockDevice::deinit() +{ + return 0; +} + +int SlicingBlockDevice::sync() +{ + return 0; +} + +int SlicingBlockDevice::read(void *b, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int SlicingBlockDevice::program(const void *b, bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +int SlicingBlockDevice::erase(bd_addr_t addr, bd_size_t size) +{ + return 0; +} + +bd_size_t SlicingBlockDevice::get_read_size() const +{ + return 0; +} + +bd_size_t SlicingBlockDevice::get_program_size() const +{ + return 0; +} + +bd_size_t SlicingBlockDevice::get_erase_size() const +{ + return 0; +} + +bd_size_t SlicingBlockDevice::get_erase_size(bd_addr_t addr) const +{ + return 0; +} + +int SlicingBlockDevice::get_erase_value() const +{ + return 0; +} + +bd_size_t SlicingBlockDevice::size() const +{ + return 0; +} diff --git a/UNITTESTS/stubs/SocketAddress_stub.cpp b/UNITTESTS/stubs/SocketAddress_stub.cpp new file mode 100644 index 0000000000..76e02aa12b --- /dev/null +++ b/UNITTESTS/stubs/SocketAddress_stub.cpp @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2015, 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 "SocketAddress.h" +#include "NetworkInterface.h" +#include "NetworkStack.h" +#include +#include "mbed.h" + + +static bool ipv4_is_valid(const char *addr) +{ + return false; +} + +static bool ipv6_is_valid(const char *addr) +{ + return false; +} + +static void ipv4_from_address(uint8_t *bytes, const char *addr) +{ + +} + +static int ipv6_scan_chunk(uint16_t *shorts, const char *chunk) +{ + return 0; +} + +static void ipv6_from_address(uint8_t *bytes, const char *addr) +{ + +} + +static void ipv4_to_address(char *addr, const uint8_t *bytes) +{ + +} + +static void ipv6_to_address(char *addr, const uint8_t *bytes) +{ +} + + +SocketAddress::SocketAddress(nsapi_addr_t addr, uint16_t port) +{ +} + +SocketAddress::SocketAddress(const char *addr, uint16_t port) +{ +} + +SocketAddress::SocketAddress(const void *bytes, nsapi_version_t version, uint16_t port) +{ +} + +SocketAddress::SocketAddress(const SocketAddress &addr) +{ +} + +SocketAddress::~SocketAddress() +{ +} + +bool SocketAddress::set_ip_address(const char *addr) +{ + return false; +} + +void SocketAddress::set_ip_bytes(const void *bytes, nsapi_version_t version) +{ +} + +void SocketAddress::set_addr(nsapi_addr_t addr) +{ +} + +void SocketAddress::set_port(uint16_t port) +{ +} + +const char *SocketAddress::get_ip_address() const +{ + return NULL; +} + +const void *SocketAddress::get_ip_bytes() const +{ + return NULL; +} + +nsapi_version_t SocketAddress::get_ip_version() const +{ + nsapi_version_t ver = NSAPI_IPv6; + return ver; +} + +nsapi_addr_t SocketAddress::get_addr() const +{ + nsapi_addr_t addr; + addr.version = NSAPI_IPv6; + return _addr; +} + +uint16_t SocketAddress::get_port() const +{ + return 0; +} + +SocketAddress::operator bool() const +{ + return false; +} + +SocketAddress &SocketAddress::operator=(const SocketAddress &addr) +{ + set_addr(addr.get_addr()); + set_port(addr.get_port()); + return *this; +} + +bool operator==(const SocketAddress &a, const SocketAddress &b) +{ + return false; +} + +bool operator!=(const SocketAddress &a, const SocketAddress &b) +{ + return false; +} diff --git a/UNITTESTS/stubs/Thread_stub.cpp b/UNITTESTS/stubs/Thread_stub.cpp new file mode 100644 index 0000000000..8eed1e7f2a --- /dev/null +++ b/UNITTESTS/stubs/Thread_stub.cpp @@ -0,0 +1,27 @@ +/* + * Copyright (c) , 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 "Thread.h" + +namespace rtos { + +osStatus Thread::wait_until(uint64_t millisec) +{ + return 0; +} + +} diff --git a/UNITTESTS/stubs/Timer_stub.cpp b/UNITTESTS/stubs/Timer_stub.cpp new file mode 100644 index 0000000000..2e20c161ae --- /dev/null +++ b/UNITTESTS/stubs/Timer_stub.cpp @@ -0,0 +1,74 @@ +/* + * Copyright (c) , 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 "Timer.h" +#include "Timer_stub.h" + +namespace mbed { + +Timer::Timer() +{ +} + +Timer::Timer(const ticker_data_t *data) +{ +} + +Timer::~Timer() +{ +} + +void Timer::start() +{ +} + +void Timer::stop() +{ + ; +} + +int Timer::read_us() +{ + return 0; +} + +float Timer::read() +{ + return 0; +} + +int Timer::read_ms() +{ + timer_stub_value += timer_stub_step; + return timer_stub_value; +} + +us_timestamp_t Timer::read_high_resolution_us() +{ + return 0; +} + +void Timer::reset() +{ +} + +Timer::operator float() +{ + return 0; +} + +} // namespace mbed diff --git a/UNITTESTS/stubs/Timer_stub.h b/UNITTESTS/stubs/Timer_stub.h new file mode 100644 index 0000000000..699fdd0c53 --- /dev/null +++ b/UNITTESTS/stubs/Timer_stub.h @@ -0,0 +1,24 @@ +/* + * Copyright (c) , 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. + */ +#ifndef TIMER_STUB_H +#define TIMER_STUB_H + + +static uint16_t timer_stub_value = 0; +static uint16_t timer_stub_step = 20; + +#endif diff --git a/UNITTESTS/stubs/equeue_stub.c b/UNITTESTS/stubs/equeue_stub.c index bd9852bec2..55a52174e7 100644 --- a/UNITTESTS/stubs/equeue_stub.c +++ b/UNITTESTS/stubs/equeue_stub.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Arm Limited and affiliates. + * Copyright (c) , Arm Limited and affiliates. * SPDX-License-Identifier: Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -15,25 +15,90 @@ * limitations under the License. */ -#include "equeue/equeue.h" +#include "equeue.h" -void *equeue_alloc(equeue_t *q, size_t size) -{ -} - -int equeue_post(equeue_t *q, void (*cb)(void *), void *p) +int equeue_create(equeue_t *queue, size_t size) { return 0; } -void equeue_event_delay(void *p, int ms) +int equeue_create_inplace(equeue_t *queue, size_t size, void *buffer) { + return 0; } -void equeue_event_period(void *p, int ms) +void equeue_destroy(equeue_t *queue) { + } -void equeue_event_dtor(void *p, void (*dtor)(void *)) +void equeue_dispatch(equeue_t *queue, int ms) { + +} + +void equeue_break(equeue_t *queue) +{ + +} + +int equeue_call(equeue_t *queue, void (*cb)(void *), void *data) +{ + return 0; +} + +int equeue_call_in(equeue_t *queue, int ms, void (*cb)(void *), void *data) +{ + return 0; +} + +int equeue_call_every(equeue_t *queue, int ms, void (*cb)(void *), void *data) +{ + return 0; +} + +void *equeue_alloc(equeue_t *queue, size_t size) +{ + return NULL; +} + +void equeue_dealloc(equeue_t *queue, void *event) +{ + +} + +void equeue_event_delay(void *event, int ms) +{ + +} + +void equeue_event_period(void *event, int ms) +{ + +} + +void equeue_event_dtor(void *event, void (*dtor)(void *)) +{ + +} + +int equeue_post(equeue_t *queue, void (*cb)(void *), void *event) +{ + return 0; +} + +void equeue_cancel(equeue_t *queue, int id) +{ + +} + +void equeue_background(equeue_t *queue, + void (*update)(void *timer, int ms), void *timer) +{ + +} + +void equeue_chain(equeue_t *queue, equeue_t *target) +{ + } diff --git a/UNITTESTS/stubs/mbed_assert_stub.cpp b/UNITTESTS/stubs/mbed_assert_stub.cpp new file mode 100644 index 0000000000..341881a7f5 --- /dev/null +++ b/UNITTESTS/stubs/mbed_assert_stub.cpp @@ -0,0 +1,24 @@ +/* + * Copyright (c) , 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 "mbed_assert.h" + +void mbed_assert_internal(const char *expr, const char *file, int line) +{ + +} + diff --git a/UNITTESTS/stubs/mbed_critical_stub.c b/UNITTESTS/stubs/mbed_critical_stub.c new file mode 100644 index 0000000000..f812764382 --- /dev/null +++ b/UNITTESTS/stubs/mbed_critical_stub.c @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2015-2016, ARM Limited, All Rights Reserved + * 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. + */ + +/* Declare __STDC_LIMIT_MACROS so stdint.h defines UINT32_MAX when using C++ */ +#define __STDC_LIMIT_MACROS +#include "hal/critical_section_api.h" + +#include "cmsis.h" +#include "platform/mbed_assert.h" +#include "platform/mbed_critical.h" +#include "platform/mbed_toolchain.h" + +static volatile uint32_t critical_section_reentrancy_counter = 0; + +bool core_util_are_interrupts_enabled(void) +{ + return false; +} + +bool core_util_is_isr_active(void) +{ + return false; +} + +bool core_util_in_critical_section(void) +{ + return false; +} + +void core_util_critical_section_enter(void) +{ +} + +void core_util_critical_section_exit(void) +{ +} + +bool core_util_atomic_cas_u8(volatile uint8_t *ptr, uint8_t *expectedCurrentValue, uint8_t desiredValue) +{ + return false; +} + +bool core_util_atomic_cas_u16(volatile uint16_t *ptr, uint16_t *expectedCurrentValue, uint16_t desiredValue) +{ + return false; +} + + +bool core_util_atomic_cas_u32(volatile uint32_t *ptr, uint32_t *expectedCurrentValue, uint32_t desiredValue) +{ + return false; +} + + +uint8_t core_util_atomic_incr_u8(volatile uint8_t *valuePtr, uint8_t delta) +{ + return 0; +} + +uint16_t core_util_atomic_incr_u16(volatile uint16_t *valuePtr, uint16_t delta) +{ + return 0; +} + +uint32_t core_util_atomic_incr_u32(volatile uint32_t *valuePtr, uint32_t delta) +{ + return 0; +} + + +uint8_t core_util_atomic_decr_u8(volatile uint8_t *valuePtr, uint8_t delta) +{ + return 0; +} + +uint16_t core_util_atomic_decr_u16(volatile uint16_t *valuePtr, uint16_t delta) +{ + return 0; +} + +uint32_t core_util_atomic_decr_u32(volatile uint32_t *valuePtr, uint32_t delta) +{ + return 0; +} + + +bool core_util_atomic_cas_ptr(void *volatile *ptr, void **expectedCurrentValue, void *desiredValue) +{ + return false; +} + +void *core_util_atomic_incr_ptr(void *volatile *valuePtr, ptrdiff_t delta) +{ + return NULL; +} + +void *core_util_atomic_decr_ptr(void *volatile *valuePtr, ptrdiff_t delta) +{ + return NULL; +} + diff --git a/UNITTESTS/features/cellular/framework/AT/AT_CellularBase/test_at_cellularbase.h b/UNITTESTS/stubs/mbed_poll_stub.cpp similarity index 63% rename from UNITTESTS/features/cellular/framework/AT/AT_CellularBase/test_at_cellularbase.h rename to UNITTESTS/stubs/mbed_poll_stub.cpp index 3091dadb83..1914399d2a 100644 --- a/UNITTESTS/features/cellular/framework/AT/AT_CellularBase/test_at_cellularbase.h +++ b/UNITTESTS/stubs/mbed_poll_stub.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, Arm Limited and affiliates. + * Copyright (c) , Arm Limited and affiliates. * SPDX-License-Identifier: Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -14,18 +14,19 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef TEST_AT_CELLULARBASE_H -#define TEST_AT_CELLULARBASE_H -class Test_AT_CellularBase { -public: - Test_AT_CellularBase(); +#include "mbed_poll.h" +#include "mbed_poll_stub.h" - virtual ~Test_AT_CellularBase(); +int mbed_poll_stub::revents_value = POLLOUT; +int mbed_poll_stub::int_value = 0; - void test_AT_CellularBase_get_at_handler(); +namespace mbed { - void test_AT_CellularBase_get_device_error(); -}; +int poll(pollfh fhs[], unsigned nfhs, int timeout) +{ + fhs->revents = mbed_poll_stub::revents_value; + return mbed_poll_stub::int_value; +} -#endif // TEST_AT_CELLULARBASE_H +} diff --git a/UNITTESTS/stubs/mbed_poll_stub.h b/UNITTESTS/stubs/mbed_poll_stub.h new file mode 100644 index 0000000000..6c0a4327a9 --- /dev/null +++ b/UNITTESTS/stubs/mbed_poll_stub.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) , 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. + */ +#ifndef __MBED_POLL_STUB_H__ +#define __MBED_POLL_STUB_H__ + +#include + +namespace mbed_poll_stub { +extern int revents_value; +extern int int_value; +} + +#endif diff --git a/UNITTESTS/stubs/mbed_wait_api_stub.cpp b/UNITTESTS/stubs/mbed_wait_api_stub.cpp new file mode 100644 index 0000000000..f8b240544d --- /dev/null +++ b/UNITTESTS/stubs/mbed_wait_api_stub.cpp @@ -0,0 +1,30 @@ +/* + * Copyright (c) , 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 "mbed_wait_api.h" + +void wait(float s) +{ +} + +void wait_ms(int ms) +{ +} + +void wait_us(int us) +{ +} diff --git a/UNITTESTS/stubs/randLIB_stub.cpp b/UNITTESTS/stubs/randLIB_stub.cpp new file mode 100644 index 0000000000..61cd893d0e --- /dev/null +++ b/UNITTESTS/stubs/randLIB_stub.cpp @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2017, 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 "randLIB.h" + +void randLIB_seed_random(void) +{ +} + +uint16_t randLIB_get_random_in_range(uint16_t min, uint16_t max) +{ + return min; +} + diff --git a/UNITTESTS/stubs/us_ticker_stub.cpp b/UNITTESTS/stubs/us_ticker_stub.cpp new file mode 100644 index 0000000000..69c96accee --- /dev/null +++ b/UNITTESTS/stubs/us_ticker_stub.cpp @@ -0,0 +1,54 @@ +/* + * Copyright (c) , 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 "stdlib.h" +#include "us_ticker_api.h" + +const ticker_data_t *get_us_ticker_data(void) +{ + return NULL; +} + +void us_ticker_irq_handler(void) +{ +} + +void us_ticker_init(void) +{ +} + +uint32_t us_ticker_read(void) +{ + return 0; +} + +void us_ticker_set_interrupt(timestamp_t timestamp) +{ +} + +void us_ticker_disable_interrupt(void) +{ +} + +void us_ticker_clear_interrupt(void) +{ +} + +void us_ticker_fire_interrupt(void) +{ +} diff --git a/UNITTESTS/target_h/ATCmdParser.h b/UNITTESTS/target_h/ATCmdParser.h new file mode 100644 index 0000000000..c1994cc2af --- /dev/null +++ b/UNITTESTS/target_h/ATCmdParser.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) , 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. + */ +#ifndef __AT_CMD_PARSER_H__ +#define __AT_CMD_PARSER_H__ + +#include "mbed.h" +#include +#include "FileHandle.h" + +class ATCmdParser { +public: + ATCmdParser(mbed::FileHandle *fh, const char *output_delimiter = "\r", + int buffer_size = 256, int timeout = 8000, bool debug = false) {} + + ~ATCmdParser() {} +}; + +#endif //__AT_CMD_PARSER_H__ + diff --git a/UNITTESTS/target_h/arm_math.h b/UNITTESTS/target_h/arm_math.h new file mode 100644 index 0000000000..a431b392e7 --- /dev/null +++ b/UNITTESTS/target_h/arm_math.h @@ -0,0 +1,16 @@ +/* + * Copyright (c) , 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. + */ diff --git a/UNITTESTS/target_h/cmsis.h b/UNITTESTS/target_h/cmsis.h new file mode 100644 index 0000000000..a431b392e7 --- /dev/null +++ b/UNITTESTS/target_h/cmsis.h @@ -0,0 +1,16 @@ +/* + * Copyright (c) , 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. + */ diff --git a/UNITTESTS/target_h/cmsis_compiler.h b/UNITTESTS/target_h/cmsis_compiler.h new file mode 100644 index 0000000000..a431b392e7 --- /dev/null +++ b/UNITTESTS/target_h/cmsis_compiler.h @@ -0,0 +1,16 @@ +/* + * Copyright (c) , 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. + */ diff --git a/UNITTESTS/features/cellular/framework/common/util/test_util.h b/UNITTESTS/target_h/cmsis_os.h similarity index 61% rename from UNITTESTS/features/cellular/framework/common/util/test_util.h rename to UNITTESTS/target_h/cmsis_os.h index bb968ef5f4..a40ab9e73b 100644 --- a/UNITTESTS/features/cellular/framework/common/util/test_util.h +++ b/UNITTESTS/target_h/cmsis_os.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018, Arm Limited and affiliates. + * Copyright (c) , Arm Limited and affiliates. * SPDX-License-Identifier: Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -14,24 +14,17 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef TEST_UTIL_H -#define TEST_UTIL_H -class Test_util { -public: - Test_util(); +#ifndef CMSIS_OS_H_ +#define CMSIS_OS_H_ - virtual ~Test_util(); +#include "cmsis_os2.h" - void test_util_uint_to_binary_string(); +#define osPriority osPriority_t - void test_util_char_str_to_hex(); +#define osThreadId osThreadId_t - void test_util_convert_ipv6(); +typedef struct { +} osEvent; - void test_util_prefer_ipv6(); - - void test_util_separate_ip_addresses(); -}; - -#endif // TEST_UTIL_H +#endif diff --git a/UNITTESTS/target_h/cmsis_os2.h b/UNITTESTS/target_h/cmsis_os2.h new file mode 100644 index 0000000000..c2a601fb16 --- /dev/null +++ b/UNITTESTS/target_h/cmsis_os2.h @@ -0,0 +1,78 @@ +/* + * Copyright (c) , 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. + */ + +#ifndef __CMSIS_OS2_H__ +#define __CMSIS_OS2_H__ + +#include + +//If conflicts, then remove these, copied from cmsis_os.h +typedef int32_t osStatus; + +#define osOK 0 + + + +//These are from cmsis_os2.h +typedef void *osSemaphoreId_t; + +typedef struct { + const char *name; ///< name of the semaphore + uint32_t attr_bits; ///< attribute bits + void *cb_mem; ///< memory for control block + uint32_t cb_size; ///< size of provided memory for control block +} osSemaphoreAttr_t; + +//Thread +typedef enum { + osPriorityNormal = 24 ///< Priority: normal +} osPriority_t; + +typedef void *osThreadId_t; + +typedef void *osEventFlagsId_t; + +/// Attributes structure for thread. +typedef struct { +} osThreadAttr_t; + +#define osWaitForever 0xFFFFFFFFU ///< Wait forever timeout value. + +// Flags options (\ref osThreadFlagsWait and \ref osEventFlagsWait). +#define osFlagsWaitAny 0x00000000U ///< Wait for any flag (default). +#define osFlagsWaitAll 0x00000001U ///< Wait for all flags. +#define osFlagsNoClear 0x00000002U ///< Do not clear flags which have been specified to wait for. + +// Flags errors (returned by osThreadFlagsXxxx and osEventFlagsXxxx). +#define osFlagsError 0x80000000U ///< Error indicator. +#define osFlagsErrorUnknown 0xFFFFFFFFU ///< osError (-1). +#define osFlagsErrorTimeout 0xFFFFFFFEU ///< osErrorTimeout (-2). +#define osFlagsErrorResource 0xFFFFFFFDU ///< osErrorResource (-3). +#define osFlagsErrorParameter 0xFFFFFFFCU ///< osErrorParameter (-4). +#define osFlagsErrorISR 0xFFFFFFFAU ///< osErrorISR (-6). + +// Thread attributes (attr_bits in \ref osThreadAttr_t). +#define osThreadDetached 0x00000000U ///< Thread created in detached mode (default) +#define osThreadJoinable 0x00000001U ///< Thread created in joinable mode + +// Mutex attributes (attr_bits in \ref osMutexAttr_t). +#define osMutexRecursive 0x00000001U ///< Recursive mutex. +#define osMutexPrioInherit 0x00000002U ///< Priority inherit protocol. +#define osMutexRobust 0x00000008U ///< Robust mutex. + + +#endif diff --git a/UNITTESTS/target_h/mbed.h b/UNITTESTS/target_h/mbed.h index 1f88324deb..276aebc58b 100644 --- a/UNITTESTS/target_h/mbed.h +++ b/UNITTESTS/target_h/mbed.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Arm Limited and affiliates. + * Copyright (c) 2018, Arm Limited and affiliates. * SPDX-License-Identifier: Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -22,6 +22,7 @@ #include #include "events/mbed_events.h" +#include "events/mbed_shared_queues.h" namespace mbed { #include "platform/Callback.h" diff --git a/UNITTESTS/target_h/mbed_rtos1_types.h b/UNITTESTS/target_h/mbed_rtos1_types.h index e200f189f2..4ff0189351 100644 --- a/UNITTESTS/target_h/mbed_rtos1_types.h +++ b/UNITTESTS/target_h/mbed_rtos1_types.h @@ -18,6 +18,7 @@ #ifndef MBED_RTOS1_TYPES_H #define MBED_RTOS1_TYPES_H +#include "cmsis_os.h" #include "mbed_rtos_storage.h" #endif // MBED_RTOS1_TYPES_H diff --git a/UNITTESTS/target_h/mbed_rtos_storage.h b/UNITTESTS/target_h/mbed_rtos_storage.h index 48923f2a23..e1b1276138 100644 --- a/UNITTESTS/target_h/mbed_rtos_storage.h +++ b/UNITTESTS/target_h/mbed_rtos_storage.h @@ -23,17 +23,13 @@ extern "C" { #endif #include "cmsis_os2.h" +#include "rtx_os.h" +#include "rtx_lib.h" +#include "mbed_rtx_conf.h" -typedef osMutexId_t mbed_rtos_storage_mutex_t; -typedef osSemaphoreId_t mbed_rtos_storage_semaphore_t; -typedef osThreadId_t mbed_rtos_storage_thread_t; -typedef osThreadId_t osThreadId; -typedef osMemoryPoolId_t mbed_rtos_storage_mem_pool_t; -typedef osMessageQueueId_t mbed_rtos_storage_msg_queue_t; -typedef osEventFlagsId_t mbed_rtos_storage_event_flags_t; -typedef void *mbed_rtos_storage_message_t; -typedef osTimerId_t mbed_rtos_storage_timer_t; -typedef osStatus_t osStatus; +typedef os_semaphore_t mbed_rtos_storage_semaphore_t; +typedef os_thread_t mbed_rtos_storage_thread_t; +typedef osRtxEventFlags_t mbed_rtos_storage_event_flags_t; #ifdef __cplusplus } diff --git a/UNITTESTS/target_h/mbed_rtx.h b/UNITTESTS/target_h/mbed_rtx.h new file mode 100644 index 0000000000..a431b392e7 --- /dev/null +++ b/UNITTESTS/target_h/mbed_rtx.h @@ -0,0 +1,16 @@ +/* + * Copyright (c) , 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. + */ diff --git a/UNITTESTS/target_h/mbed_rtx_conf.h b/UNITTESTS/target_h/mbed_rtx_conf.h new file mode 100644 index 0000000000..17620e86e8 --- /dev/null +++ b/UNITTESTS/target_h/mbed_rtx_conf.h @@ -0,0 +1,20 @@ +/* + * Copyright (c) , 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. + */ + +#ifndef OS_STACK_SIZE +#define OS_STACK_SIZE 0 +#endif diff --git a/UNITTESTS/target_h/nsapi_ppp.h b/UNITTESTS/target_h/nsapi_ppp.h new file mode 100644 index 0000000000..a431b392e7 --- /dev/null +++ b/UNITTESTS/target_h/nsapi_ppp.h @@ -0,0 +1,16 @@ +/* + * Copyright (c) , 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. + */ diff --git a/UNITTESTS/target_h/platform/mbed_power_mgmt.h b/UNITTESTS/target_h/platform/mbed_power_mgmt.h new file mode 100644 index 0000000000..2810b22dae --- /dev/null +++ b/UNITTESTS/target_h/platform/mbed_power_mgmt.h @@ -0,0 +1,17 @@ +/* + * Copyright (c) , 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. + */ + diff --git a/UNITTESTS/target_h/platform/mbed_retarget.h b/UNITTESTS/target_h/platform/mbed_retarget.h index 0c513f53e3..b379eb0de3 100644 --- a/UNITTESTS/target_h/platform/mbed_retarget.h +++ b/UNITTESTS/target_h/platform/mbed_retarget.h @@ -18,7 +18,15 @@ #ifndef RETARGET_H #define RETARGET_H +#include #include +#include + +#include + +namespace mbed { + +#define NAME_MAX 255 #undef EPERM #define EPERM 1 /* Operation not permitted */ @@ -283,4 +291,75 @@ #undef ENOTRECOVERABLE #define ENOTRECOVERABLE 131 /* State not recoverable */ +#define _IFMT 0170000 //< type of file +#define _IFSOCK 0140000 //< socket +#define _IFLNK 0120000 //< symbolic link +#define _IFREG 0100000 //< regular +#define _IFBLK 0060000 //< block special +#define _IFDIR 0040000 //< directory +#define _IFCHR 0020000 //< character special +#define _IFIFO 0010000 //< fifo special + + +#define O_RDONLY 0 ///< Open for reading +#define O_WRONLY 1 ///< Open for writing +#define O_RDWR 2 ///< Open for reading and writing +#define O_NONBLOCK 0x0004 ///< Non-blocking mode +#define O_APPEND 0x0008 ///< Set file offset to end of file prior to each write +#define O_CREAT 0x0200 ///< Create file if it does not exist +#define O_TRUNC 0x0400 ///< Truncate file to zero length +#define O_EXCL 0x0800 ///< Fail if file exists +#define O_BINARY 0x8000 ///< Open file in binary mode + +#define O_ACCMODE (O_RDONLY|O_WRONLY|O_RDWR) + +#define NAME_MAX 255 ///< Maximum size of a name in a file path + +#define STDIN_FILENO 0 +#define STDOUT_FILENO 1 +#define STDERR_FILENO 2 + + +struct statvfs { + unsigned long f_bsize; ///< Filesystem block size + unsigned long f_frsize; ///< Fragment size (block size) + + fsblkcnt_t f_blocks; ///< Number of blocks + fsblkcnt_t f_bfree; ///< Number of free blocks + fsblkcnt_t f_bavail; ///< Number of free blocks for unprivileged users + + unsigned long f_fsid; ///< Filesystem ID + + unsigned long f_namemax; ///< Maximum filename length +}; + + +struct dirent { + char d_name[NAME_MAX + 1]; ///< Name of file + uint8_t d_type; ///< Type of file +}; + +enum { + DT_UNKNOWN, ///< The file type could not be determined. + DT_FIFO, ///< This is a named pipe (FIFO). + DT_CHR, ///< This is a character device. + DT_DIR, ///< This is a directory. + DT_BLK, ///< This is a block device. + DT_REG, ///< This is a regular file. + DT_LNK, ///< This is a symbolic link. + DT_SOCK, ///< This is a UNIX domain socket. +}; + +/* fcntl.h defines */ +#define F_GETFL 3 +#define F_SETFL 4 + +struct pollfd { + int fd; + short events; + short revents; +}; + +} + #endif //RETARGET_H diff --git a/UNITTESTS/target_h/randLIB.h b/UNITTESTS/target_h/randLIB.h new file mode 100644 index 0000000000..a621be3688 --- /dev/null +++ b/UNITTESTS/target_h/randLIB.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2017, 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. + */ +#ifndef FEATURES_CELLULAR_UNITTESTS_TARGET_H_RANDLIB_H_ +#define FEATURES_CELLULAR_UNITTESTS_TARGET_H_RANDLIB_H_ + +#include + +extern void randLIB_seed_random(void); + +uint16_t randLIB_get_random_in_range(uint16_t min, uint16_t max); + + +#endif /* FEATURES_CELLULAR_UNITTESTS_TARGET_H_RANDLIB_H_ */ diff --git a/UNITTESTS/target_h/rtos/Mutex.h b/UNITTESTS/target_h/rtos/Mutex.h new file mode 100644 index 0000000000..a804e17212 --- /dev/null +++ b/UNITTESTS/target_h/rtos/Mutex.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) , 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. + */ +#ifndef __MUTEX_H__ +#define __MUTEX_H__ + +#include +#include "cmsis_os2.h" + +namespace rtos { + +class Mutex { +public: + Mutex(); + + Mutex(const char *name); + + osStatus lock(uint32_t millisec=osWaitForever); + + bool trylock(); + + bool trylock_for(uint32_t millisec); + + bool trylock_until(uint64_t millisec); + + osStatus unlock(); + + osThreadId_t get_owner(); + + ~Mutex(); +}; + +} + +#endif diff --git a/UNITTESTS/target_h/rtos/Semaphore.h b/UNITTESTS/target_h/rtos/Semaphore.h new file mode 100644 index 0000000000..34e472dea6 --- /dev/null +++ b/UNITTESTS/target_h/rtos/Semaphore.h @@ -0,0 +1,18 @@ +/* + * Copyright (c) , 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. + */ + +typedef void *Semaphore; diff --git a/UNITTESTS/target_h/rtx_lib.h b/UNITTESTS/target_h/rtx_lib.h new file mode 100644 index 0000000000..2b2368f0a6 --- /dev/null +++ b/UNITTESTS/target_h/rtx_lib.h @@ -0,0 +1,25 @@ +/* + * Copyright (c) , 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. + */ +#ifndef __RTX_LIB_H__ +#define __RTX_LIB_H__ + +#include "rtx_os.h" + +#define os_semaphore_t osRtxSemaphore_t +#define os_thread_t osRtxThread_t + +#endif diff --git a/UNITTESTS/target_h/rtx_os.h b/UNITTESTS/target_h/rtx_os.h new file mode 100644 index 0000000000..dfa7082fa1 --- /dev/null +++ b/UNITTESTS/target_h/rtx_os.h @@ -0,0 +1,70 @@ +/* + * Copyright (c) , 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. + */ + +#ifndef __RTX_OS__ +#define __RTX_OS__ + +#include "inttypes.h" + +typedef struct osRtxSemaphore_s { + uint8_t id; ///< Object Identifier + uint8_t state; ///< Object State + uint8_t flags; ///< Object Flags + uint8_t reserved; + const char *name; ///< Object Name + uint16_t tokens; ///< Current number of tokens + uint16_t max_tokens; ///< Maximum number of tokens +} osRtxSemaphore_t; + +typedef struct osRtxThread_s { + uint8_t id; ///< Object Identifier + uint8_t state; ///< Object State + uint8_t flags; ///< Object Flags + uint8_t attr; ///< Object Attributes + const char *name; ///< Object Name + struct osRtxThread_s *thread_next; ///< Link pointer to next Thread in Object list + struct osRtxThread_s *thread_prev; ///< Link pointer to previous Thread in Object list + struct osRtxThread_s *delay_next; ///< Link pointer to next Thread in Delay list + struct osRtxThread_s *delay_prev; ///< Link pointer to previous Thread in Delay list + struct osRtxThread_s *thread_join; ///< Thread waiting to Join + uint32_t delay; ///< Delay Time + int8_t priority; ///< Thread Priority + int8_t priority_base; ///< Base Priority + uint8_t stack_frame; ///< Stack Frame (EXC_RETURN[7..0]) + uint8_t flags_options; ///< Thread/Event Flags Options + uint32_t wait_flags; ///< Waiting Thread/Event Flags + uint32_t thread_flags; ///< Thread Flags + struct osRtxMutex_s *mutex_list; ///< Link pointer to list of owned Mutexes + void *stack_mem; ///< Stack Memory + uint32_t stack_size; ///< Stack Size + uint32_t sp; ///< Current Stack Pointer + uint32_t thread_addr; ///< Thread entry address + uint32_t tz_memory; ///< TrustZone Memory Identifier + void *context; ///< Context for OsEventObserver objects +} osRtxThread_t; + +typedef struct { + uint8_t id; ///< Object Identifier + uint8_t state; ///< Object State + uint8_t flags; ///< Object Flags + uint8_t reserved; + const char *name; ///< Object Name + osRtxThread_t *thread_list; ///< Waiting Threads List + uint32_t event_flags; ///< Event Flags +} osRtxEventFlags_t; + +#endif diff --git a/UNITTESTS/target_h/sys/syslimits.h b/UNITTESTS/target_h/sys/syslimits.h new file mode 100644 index 0000000000..5c90b373f1 --- /dev/null +++ b/UNITTESTS/target_h/sys/syslimits.h @@ -0,0 +1,17 @@ +/* + * Copyright (c) , 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. + */ +#define NAME_MAX 255