at_cellularpowertest.cpp

00001 /*
00002  * Copyright (c) 2018, Arm Limited and affiliates.
00003  * SPDX-License-Identifier: Apache-2.0
00004  *
00005  * Licensed under the Apache License, Version 2.0 (the "License");
00006  * you may not use this file except in compliance with the License.
00007  * You may obtain a copy of the License at
00008  *
00009  *     http://www.apache.org/licenses/LICENSE-2.0
00010  *
00011  * Unless required by applicable law or agreed to in writing, software
00012  * distributed under the License is distributed on an "AS IS" BASIS,
00013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00014  * See the License for the specific language governing permissions and
00015  * limitations under the License.
00016  */
00017 #include "gtest/gtest.h"
00018 #include <string.h>
00019 #include "AT_CellularNetwork.h"
00020 #include "EventQueue.h"
00021 #include "ATHandler.h"
00022 #include "AT_CellularPower.h"
00023 #include "FileHandle_stub.h"
00024 #include "ATHandler_stub.h"
00025 
00026 using namespace mbed;
00027 using namespace events;
00028 
00029 // AStyle ignored as the definition is not clear due to preprocessor usage
00030 // *INDENT-OFF*
00031 class TestAT_CellularPower : public testing::Test {
00032 protected:
00033 
00034     void SetUp() {
00035         ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00036     }
00037 
00038     void TearDown() {
00039     }
00040 };
00041 // *INDENT-ON*
00042 
00043 
00044 static void device_ready_cb()
00045 {
00046 }
00047 
00048 TEST_F(TestAT_CellularPower, Create)
00049 {
00050 
00051     EventQueue que;
00052     FileHandle_stub fh1;
00053     ATHandler at(&fh1, que, 0, ",");
00054 
00055     AT_CellularPower *pow = new AT_CellularPower(at);
00056 
00057     EXPECT_TRUE(pow != NULL);
00058 
00059     delete pow;
00060 }
00061 
00062 TEST_F(TestAT_CellularPower, test_AT_CellularPower_on)
00063 {
00064     EventQueue que;
00065     FileHandle_stub fh1;
00066     ATHandler at(&fh1, que, 0, ",");
00067 
00068     AT_CellularPower pow(at);
00069     EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED  == pow.on());
00070 }
00071 
00072 TEST_F(TestAT_CellularPower, test_AT_CellularPower_off)
00073 {
00074     EventQueue que;
00075     FileHandle_stub fh1;
00076     ATHandler at(&fh1, que, 0, ",");
00077 
00078     AT_CellularPower pow(at);
00079     EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED  == pow.off());
00080 }
00081 
00082 TEST_F(TestAT_CellularPower, test_AT_CellularPower_set_at_mode)
00083 {
00084     EventQueue que;
00085     FileHandle_stub fh1;
00086     ATHandler at(&fh1, que, 0, ",");
00087 
00088     AT_CellularPower pow(at);
00089     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00090     EXPECT_TRUE(NSAPI_ERROR_OK  == pow.set_at_mode());
00091 
00092     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ;
00093     EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR  == pow.set_at_mode());
00094 }
00095 
00096 TEST_F(TestAT_CellularPower, test_AT_CellularPower_set_power_level)
00097 {
00098     EventQueue que;
00099     FileHandle_stub fh1;
00100     ATHandler at(&fh1, que, 0, ",");
00101 
00102     AT_CellularPower pow(at);
00103     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00104     EXPECT_TRUE(NSAPI_ERROR_OK  == pow.set_power_level(6));
00105     EXPECT_TRUE(NSAPI_ERROR_OK  == pow.set_power_level(1, 1));
00106     EXPECT_TRUE(NSAPI_ERROR_OK  == pow.set_power_level(1, 0));
00107 
00108     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ;
00109     EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR  == pow.set_power_level(6));
00110 }
00111 
00112 TEST_F(TestAT_CellularPower, test_AT_CellularPower_reset)
00113 {
00114     EventQueue que;
00115     FileHandle_stub fh1;
00116     ATHandler at(&fh1, que, 0, ",");
00117 
00118     AT_CellularPower pow(at);
00119     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00120     EXPECT_TRUE(NSAPI_ERROR_OK  == pow.reset());
00121 
00122     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ;
00123     EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR  == pow.reset());
00124 }
00125 
00126 TEST_F(TestAT_CellularPower, test_AT_CellularPower_opt_power_save_mode)
00127 {
00128     EventQueue que;
00129     FileHandle_stub fh1;
00130     ATHandler at(&fh1, que, 0, ",");
00131 
00132     AT_CellularPower pow(at);
00133     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00134     EXPECT_TRUE(NSAPI_ERROR_OK  == pow.opt_power_save_mode(0, 0));
00135 
00136     EXPECT_TRUE(NSAPI_ERROR_OK  == pow.opt_power_save_mode(10, 0));
00137 
00138     EXPECT_TRUE(NSAPI_ERROR_OK  == pow.opt_power_save_mode(912, 0));
00139 
00140     EXPECT_TRUE(NSAPI_ERROR_OK  == pow.opt_power_save_mode(1834, 1834));
00141 
00142     EXPECT_TRUE(NSAPI_ERROR_OK  == pow.opt_power_save_mode(18345, 18345));
00143 
00144     EXPECT_TRUE(NSAPI_ERROR_OK  == pow.opt_power_save_mode(101234, 101234));
00145 
00146     EXPECT_TRUE(NSAPI_ERROR_OK  == pow.opt_power_save_mode(1012345, 1012345));
00147 
00148     EXPECT_TRUE(NSAPI_ERROR_OK  == pow.opt_power_save_mode(39612345, 39612345));
00149 
00150     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ;
00151     EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR  == pow.opt_power_save_mode(0, 0));
00152 }
00153 
00154 TEST_F(TestAT_CellularPower, test_AT_CellularPower_opt_receive_period)
00155 {
00156     EventQueue que;
00157     FileHandle_stub fh1;
00158     ATHandler at(&fh1, que, 0, ",");
00159 
00160     AT_CellularPower pow(at);
00161     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK ;
00162     EXPECT_TRUE(NSAPI_ERROR_OK  == pow.opt_receive_period(1, CellularPower::EDRXUTRAN_Iu_mode, 3));
00163 
00164     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_DEVICE_ERROR ;
00165     EXPECT_TRUE(NSAPI_ERROR_DEVICE_ERROR  == pow.opt_receive_period(1, CellularPower::EDRXUTRAN_Iu_mode, 3));
00166 }
00167 
00168 TEST_F(TestAT_CellularPower, test_AT_CellularPower_is_device_ready)
00169 {
00170     EventQueue que;
00171     FileHandle_stub fh1;
00172     ATHandler at(&fh1, que, 0, ",");
00173 
00174     AT_CellularPower pow(at);
00175     ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE ;
00176     EXPECT_TRUE(NSAPI_ERROR_AUTH_FAILURE  == pow.is_device_ready());
00177 }
00178 
00179 TEST_F(TestAT_CellularPower, test_AT_CellularPower_set_device_ready_urc_cb)
00180 {
00181     EventQueue que;
00182     FileHandle_stub fh1;
00183     ATHandler at(&fh1, que, 0, ",");
00184 
00185     AT_CellularPower pow(at);
00186     EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED  == pow.set_device_ready_urc_cb(&device_ready_cb));
00187     EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED  == pow.set_device_ready_urc_cb(NULL));
00188 }
00189 
00190 TEST_F(TestAT_CellularPower, test_AT_CellularPower_remove_device_ready_urc_cb)
00191 {
00192     EventQueue que;
00193     FileHandle_stub fh1;
00194     ATHandler at(&fh1, que, 0, ",");
00195 
00196     AT_CellularPower pow(at);
00197     EXPECT_TRUE(NSAPI_ERROR_UNSUPPORTED  == pow.set_device_ready_urc_cb(&device_ready_cb));
00198 
00199     pow.remove_device_ready_urc_cb(NULL);
00200     pow.remove_device_ready_urc_cb(&device_ready_cb);
00201 }