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

Merge pull request #6082 from AriParkkila/master 

Mbed OS cellular connectivity
pull/6267/merge
Anna Bridge 2018-03-02 18:36:48 +00:00 committed by GitHub
parent f0bda6c4cd f91cc33fca
commit a6e27b1b86
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
178 changed files with 19123 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.travis.yml
View File

@ -111,7 +111,7 @@ matrix:
- python tools/make.py -t GCC_ARM -m K64F --source=. --build=BUILD/K64F/GCC_ARM -j0
# Check that example compiles without rtos
- sed -n '/``` cpp/,/```/{/```$/Q;/```/d;p;}' $EVENTS/README.md > main.cpp
- rm -r rtos features/netsocket features/frameworks BUILD
- rm -r rtos features/cellular features/netsocket features/frameworks BUILD
- python tools/make.py -t GCC_ARM -m DISCO_F401VC --source=. --build=BUILD/DISCO_F401VC/GCC_ARM -j0
# Run local equeue tests
- make -C $EVENTS/equeue test

12
features/cellular/.gitignore vendored Normal file
View File

@ -0,0 +1,12 @@
lcov/
results/
coverages/
gcov/
*.exe
*.o
*.d
*.a
*.gcda
*.gcno
cpputest_*.xml
*_unit_tests*

1
features/cellular/.mbedignore Normal file
View File

@ -0,0 +1 @@
UNITTESTS/*

56
features/cellular/Makefile.test Normal file
View File

@ -0,0 +1,56 @@
#
# Makefile.test for CIot library unit tests
#
# List of subdirectories to build
TEST_FOLDER_NAME := UNITTESTS
TEST_FOLDER := ./UNITTESTS/
# List of unit test directories for libraries
UNITTESTS := $(sort $(dir $(wildcard $(TEST_FOLDER)*)))
TESTDIRS := $(UNITTESTS:%=build-%)
CLEANTESTDIRS := $(UNITTESTS:%=clean-%)
COVERAGEFILE := ./lcov/coverage.info
.PHONY: test
test: $(TESTDIRS)
@rm -rf ./lcov
@rm -rf ./coverage
@mkdir -p lcov
@mkdir -p lcov/results
@mkdir coverage
@find $(TEST_FOLDER) -name '*.xml' | xargs cp -t ./lcov/results/
@rm -f lcov/index.xml
@./xsl_script.sh
@cp junit_xsl.xslt lcov/.
@xsltproc -o lcov/testresults.html lcov/junit_xsl.xslt lcov/index.xml
@rm -f lcov/junit_xsl.xslt
@rm -f lcov/index.xml
@find ./ -name '*.gcno' | xargs cp --backup=numbered -t ./coverage/
@find ./ -name '*.gcda' | xargs cp --backup=numbered -t ./coverage/
@gcovr --object-directory ./coverage --exclude-unreachable-branches -e '.*/builds/.*' -e '.*/$(TEST_FOLDER_NAME)/.*' -e '.*/yotta_modules/.*' -e '.*/stubs/.*' -e '.*/mbed-coap/.*' -x -o ./lcov/gcovr.xml
@lcov -d $(TEST_FOLDER_NAME)/. -c -o $(COVERAGEFILE)
@lcov -q -r $(COVERAGEFILE) "/usr*" -o $(COVERAGEFILE)
@lcov -q -r $(COVERAGEFILE) "/$(TEST_FOLDER_NAME)*" -o $(COVERAGEFILE)
@lcov -q -r $(COVERAGEFILE) "/mbed-client-libservice*" -o $(COVERAGEFILE)
@lcov -q -r $(COVERAGEFILE) "/mbed-client*" -o $(COVERAGEFILE)
@lcov -q -r $(COVERAGEFILE) "/mbed-os/events*" -o $(COVERAGEFILE)
@lcov -q -r $(COVERAGEFILE) "/mbed-os/features/netsocket*" -o $(COVERAGEFILE)
@lcov -q -r $(COVERAGEFILE) "/mbed-os/platform*" -o $(COVERAGEFILE)
@genhtml -q $(COVERAGEFILE) --output-directory lcov/html
@echo mbed-ciot module unit tests built
$(TESTDIRS):
@make -C $(@:build-%=%)
$(CLEANDIRS):
@make -C $(@:clean-%=%) clean
$(CLEANTESTDIRS):
@make -C $(@:clean-%=%) clean
# Extend default clean rule
clean: clean-extra
clean-extra: $(CLEANDIRS) \
$(CLEANTESTDIRS)

73
features/cellular/README.md Normal file
View File

@ -0,0 +1,73 @@
# Mbed cellular connectivity
This is the Github repo for Mbed cellular connectivity:
easy_cellular/
EasyCellularConnection Simplified cellular usage based on `CellularBase.h`
CellularConnectionUtil A utility class for cellular connection
framework/
API Application Programming Interface for cellular connectivity
AT AT implementation based on 3GPP TS 27.007 specification
common Common and utility sources
targets Vendor specific cellular module adaptations
## Known limitations
**Please note that this is a first release of Cellular framework and is subject to further development in future.**
Only UDP is supported when using AT commands to control sockets in an IP stack built into the cellular modem. If TCP is required, use the PPP/LWIP stack.
## Supported modules
You can find currently supported cellular modules in the `framework/targets/` folder, where we also add support for new cellular modules.
## Cellular configuration
You can change cellular defaults in the `mbed_app.json` configuration file:
"config": {
"cellular_plmn": {
"help": "PLMN selection, 0=auto",
"value": 0
},
"apn": {
"help": "Access point name, e.g. internet",
"value": "\"internet\""
},
"cellular_sim_pin": {
"help": "PIN code",
"value": "\"1234\""
}
}
## Debug traces
You can define the debug tracing level in the `mbed_app.json` configuration file:
"target_overrides": {
"*": {
"target.features_add": ["COMMON_PAL"],
"mbed-trace.enable": true,
"platform.stdio-convert-newlines": true,
"platform.stdio-baud-rate": 115200,
"platform.default-serial-baud-rate": 115200
}
},
"config": {
"trace-level": {
"help": "Options are TRACE_LEVEL_ERROR,TRACE_LEVEL_WARN,TRACE_LEVEL_INFO,TRACE_LEVEL_DEBUG",
"macro_name": "MBED_TRACE_MAX_LEVEL",
"value": "TRACE_LEVEL_INFO"
}
}
## Unit tests
The `UNITTESTS` folder contains unit tests for cellular specific classes. Unit tests are based on the stubbing method.
You can run those tests locally by running `./run_tests` script under the `UNITTESTS/` folder.
You need the following applications: `cpputest`, `gcov` and `lcov` (genhtml) for running the tests.
After you have run the `run_tests` script, you can find test results under `UNITTESTS/results` folder and line and function coverages under the `UNITTESTS/coverages` folder.

82
features/cellular/TESTS/cellular/cellular_all/CellularTests.h Normal file
View File

@ -0,0 +1,82 @@
/*
* 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 CELLULAR_TESTS_H
#define CELLULAR_TESTS_H
#include "CellularUtil.h" // for CELLULAR_ helper macros
#include "CellularTargets.h"
#ifdef CELLULAR_DEVICE
#include "mbed_events.h"
#include "greentea-client/test_env.h"
#include "unity.h"
#include "utest.h"
#include "CellularLog.h"
#include CELLULAR_STRINGIFY(CELLULAR_DEVICE.h)
extern EventQueue queue;
extern CELLULAR_DEVICE cellularDevice;
extern UARTSerial serial;
extern CellularNetwork *network;
extern CellularSMS *sms;
extern CellularPower *pwr;
extern CellularSIM *sim;
/**
* TEST CASES DEFINED HERE AND in main.cpp
*/
// power
void test_create_power(void);
// SIM
void test_get_sim_state(void);
void test_set_pin(void);
void test_change_pin(void);
// sms
void test_sms_init(void);
// network
void test_attach(void);
void test_connect(void);
void test_get_ip_address(void);
void test_disconnect(void);
// stack
void test_socket_open(void);
void test_socket_bind(void);
/*
void test_socket_set_blocking();
void test_socket_send_receive_blocking();
*/
void test_socket_set_non_blocking();
void test_socket_send_receive_non_blocking();
void test_socket_close(void);
// Test closing all interface via device
void test_close_interfaces(void);
#endif // CELLULAR_DEVICE
#endif // CELLULAR_TESTS_H

107
features/cellular/TESTS/cellular/cellular_all/main.cpp Normal file
View File

@ -0,0 +1,107 @@
/*
* 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 "CellularTests.h"
#if !defined(MBED_CONF_NSAPI_PRESENT)
#error [NOT_SUPPORTED] A json configuration file is needed. Skipping this build.
#endif
#ifndef CELLULAR_DEVICE
#error [NOT_SUPPORTED] CELLULAR_DEVICE must be defined for this test
#endif
EventQueue queue(32 * EVENTS_EVENT_SIZE);
Thread t;
CELLULAR_DEVICE cellularDevice(queue);
UARTSerial serial(MDMTXD, MDMRXD, MBED_CONF_PLATFORM_DEFAULT_SERIAL_BAUD_RATE);
CellularNetwork *network = NULL;
CellularPower *pwr = NULL;
CellularSIM *sim = NULL;
CellularSMS *sms = NULL;
using namespace utest::v1;
// using namespace mbed;
utest::v1::status_t greentea_failure_handler(const Case *const source, const failure_t reason)
{
greentea_case_failure_abort_handler(source, reason);
return STATUS_CONTINUE;
}
Case cases[] = {
// power test
Case("Create power", test_create_power, greentea_failure_handler),
#ifdef MBED_CONF_APP_CELLULAR_SIM_PIN
// sim test
Case("test get SIM state", test_get_sim_state, greentea_failure_handler),
Case("SIM set pin", test_set_pin, greentea_failure_handler),
Case("SIM change pin", test_change_pin, greentea_failure_handler),
#endif
// network tests
Case("attach", test_attach, greentea_failure_handler),
// SMS tests
Case("SMS init", test_sms_init, greentea_failure_handler),
// network tests
Case("connect", test_connect, greentea_failure_handler),
Case("get_ip_address", test_get_ip_address, greentea_failure_handler),
// stack tests
Case("open", test_socket_open, greentea_failure_handler),
Case("bind", test_socket_bind, greentea_failure_handler),
// Case("set socket blocking", test_socket_set_blocking, greentea_failure_handler),
// Case("socket send receive in blocking mode", test_socket_send_receive_blocking, greentea_failure_handler),
Case("set socket non blocking", test_socket_set_non_blocking, greentea_failure_handler),
Case("socket send receive in non blocking mode", test_socket_send_receive_non_blocking, greentea_failure_handler),
Case("close", test_socket_close, greentea_failure_handler),
// network tests
Case("disconnect", test_disconnect, greentea_failure_handler),
// test closing of all interface, must be the last test case
Case("Close all Interfaces", test_close_interfaces, greentea_failure_handler)
};
utest::v1::status_t test_setup(const size_t number_of_cases)
{
GREENTEA_SETUP(300, "default_auto");
return verbose_test_setup_handler(number_of_cases);
}
Specification specification(test_setup, cases);
void test_close_interfaces()
{
// SMS is already closed in it's test
cellularDevice.close_network();
cellularDevice.close_sim();
cellularDevice.close_power();
}
int main()
{
#if defined (MDMRTS) && defined (MDMCTS)
serial.set_flow_control(SerialBase::RTSCTS, MDMRTS, MDMCTS);
#endif
pwr = cellularDevice.open_power(&serial);
sim = cellularDevice.open_sim(&serial);
sms = cellularDevice.open_sms(&serial);
network = cellularDevice.open_network(&serial);
t.start(callback(&queue, &EventQueue::dispatch_forever));
return Harness::run(specification);
}

103
features/cellular/TESTS/cellular/cellular_all/network.cpp Normal file
View File

@ -0,0 +1,103 @@
/*
* 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 "CellularTests.h"
#ifdef CELLULAR_DEVICE
using namespace mbed;
static bool wait_register()
{
tr_info("Try registering to network...");
if (network->set_registration() != NSAPI_ERROR_OK) {
tr_error("Network registration request failed.");
return false;
}
CellularNetwork::RegistrationStatus status;
for (int i=0; i<180; i++) {
tr_info("Register to network %d...", i);
for (int type = 0; type < CellularNetwork::C_MAX; type++) {
if (network->get_registration_status((CellularNetwork::RegistrationType)type, status) == NSAPI_ERROR_OK) {
tr_info("status %d...", status);
switch (status) {
case CellularNetwork::RegisteredRoaming:
// fall-through
case CellularNetwork::RegisteredHomeNetwork:
tr_info("Registered to network.");
return true;
case CellularNetwork::RegisteredSMSOnlyRoaming:
// fall-through
case CellularNetwork::RegisteredSMSOnlyHome:
tr_warn("SMS only network registration!");
return true;
case CellularNetwork::RegisteredCSFBNotPreferredRoaming:
// fall-through
case CellularNetwork::RegisteredCSFBNotPreferredHome:
tr_warn("Not preferred network registration!");
return true;
case CellularNetwork::AttachedEmergencyOnly:
tr_warn("Emergency only network registration!");
return true;
case CellularNetwork::RegistrationDenied:
tr_warn("Network registration denied!");
wait(i);
break;
case CellularNetwork::NotRegistered:
case CellularNetwork::Unknown:
case CellularNetwork::SearchingNetwork:
default:
break;
}
}
}
wait(1);
}
return false;
}
void test_attach()
{
tr_info("Register to network.");
TEST_ASSERT(wait_register());
tr_info("Attach to network.");
nsapi_error_t err = network->set_attach();
TEST_ASSERT(!err);
CellularNetwork::AttachStatus status;
err = network->get_attach(status);
TEST_ASSERT(!err);
}
void test_connect()
{
nsapi_error_t err = network->connect();
TEST_ASSERT(!err);
}
void test_get_ip_address()
{
const char *ip = network->get_ip_address();
TEST_ASSERT(ip && ip[0]);
tr_info("IP: %s\r\n", ip);
}
void test_disconnect()
{
nsapi_error_t err = network->disconnect();
TEST_ASSERT(!err);
}
#endif // CELLULAR_DEVICE

52
features/cellular/TESTS/cellular/cellular_all/power.cpp Normal file
View File

@ -0,0 +1,52 @@
/*
* 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 "CellularTests.h"
#ifdef CELLULAR_DEVICE
using namespace mbed;
static bool start_cellular_at(CellularPower *pwr)
{
nsapi_error_t err = pwr->off();
if (err != NSAPI_ERROR_OK && err != NSAPI_ERROR_UNSUPPORTED) {
return false;
}
err = pwr->on();
if (err != NSAPI_ERROR_OK && err != NSAPI_ERROR_UNSUPPORTED) {
return false;
}
tr_info("Wait for cellular device 180 seconds...");
for (int i = 0; i < 180; i++) {
if (pwr->set_at_mode() == NSAPI_ERROR_OK) {
return true;
}
wait(1);
}
return false;
}
void test_create_power()
{
TEST_ASSERT(start_cellular_at(pwr));
tr_info("Cellular device is ready!");
}
// TODO: tests still missing for off, sleep, opt_power_save_mode, opt_receive_period
#endif // CELLULAR_DEVICE

90
features/cellular/TESTS/cellular/cellular_all/sim.cpp Normal file
View File

@ -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 "CellularTests.h"
#ifdef CELLULAR_DEVICE
#ifdef MBED_CONF_APP_CELLULAR_SIM_PIN
using namespace mbed;
void test_get_sim_state()
{
wait(1);
CellularSIM::SimState state = CellularSIM::SimStateUnknown;
tr_info("Wait SIM for 180 seconds...");
for (int i = 0; i < 180; i++) {
CellularSIM::SimState tmp_state;
if ((sim->get_sim_state(tmp_state) == NSAPI_ERROR_OK) && tmp_state != CellularSIM::SimStateUnknown) {
state = tmp_state;
break;
}
}
TEST_ASSERT_MESSAGE(state == CellularSIM::SimStateReady || state == CellularSIM::SimStatePinNeeded ||
state == CellularSIM::SimStatePukNeeded, "Invalid SIM state");
}
// creates PIN which is different than one defined in MBED_CONF_APP_CELLULAR_SIM_PIN
static void create_random_pin(char* random_pin)
{
char s[11];
do {
sprintf(s,"%d", rand());
} while (strncmp(s, MBED_CONF_APP_CELLULAR_SIM_PIN, 4) == 0);
strncpy(random_pin, s, 4);
random_pin[4] = '\0';
}
void test_set_pin()
{
// run test only if sim is not in ready state as then sim interface will return NSAPI_ERROR_OK
nsapi_error_t err;
CellularSIM::SimState state = CellularSIM::SimStateUnknown;
if ((sim->get_sim_state(state) == NSAPI_ERROR_OK) && (state != CellularSIM::SimStateReady)) {
char random_pin[5];
create_random_pin(random_pin);
err = sim->set_pin(random_pin);
TEST_ASSERT_MESSAGE(err != 0, "Setting random pin should fail");
}
err = sim->set_pin(MBED_CONF_APP_CELLULAR_SIM_PIN);
char err_msg[60];
sprintf(err_msg, "Setting correct pin: %s failed with: %d", MBED_CONF_APP_CELLULAR_SIM_PIN, err);
TEST_ASSERT_MESSAGE(err == 0, err_msg);
}
void test_change_pin()
{
char random_pin[5];
create_random_pin(random_pin);
nsapi_error_t err = sim->change_pin(MBED_CONF_APP_CELLULAR_SIM_PIN, random_pin);
char err_msg[60];
sprintf(err_msg, "Change from original pin failed with: %d", err);
TEST_ASSERT_MESSAGE(err == NSAPI_ERROR_OK, err_msg);
err = sim->change_pin(random_pin, MBED_CONF_APP_CELLULAR_SIM_PIN);
sprintf(err_msg, "Change back original pin failed with: %d", err);
TEST_ASSERT_MESSAGE(err == NSAPI_ERROR_OK, err_msg);
}
#endif
#endif // CELLULAR_DEVICE

46
features/cellular/TESTS/cellular/cellular_all/sms.cpp Normal file
View File

@ -0,0 +1,46 @@
/*
* 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 "CellularTests.h"
#ifdef CELLULAR_DEVICE
using namespace mbed;
void test_sms_init()
{
// for some weird reason if we don't wait for few seconds we get SIM Busy error in initialize even is SIM is ready...
wait(3);
// check SIM state as we have tested sim and it might not be ready
for (int i = 0; i < MAX_SIM_READY_WAITING_TIME; i++) {
CellularSIM::SimState state;
if (sim->get_sim_state(state) == NSAPI_ERROR_OK && state == CellularSIM::SimStateReady) {
break;
}
wait(1);
}
nsapi_error_t err = sms->initialize(CellularSMS::CellularSMSMmodeText);
char err_msg[60];
sprintf(err_msg, "SMS initialize failed with: %d", err);
cellularDevice.close_sms();
sms = NULL;
TEST_ASSERT_MESSAGE(!err, err_msg);
}
#endif // CELLULAR_DEVICE

120
features/cellular/TESTS/cellular/cellular_all/stack.cpp Normal file
View File

@ -0,0 +1,120 @@
/*
* 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 "CellularTests.h"
#ifdef CELLULAR_DEVICE
using namespace mbed;
static UDPSocket socket;
#define SERVER_IP_ADDR "52.215.34.155"
#define SERVER_UDP_PORT 7
static rtos::Semaphore sock_event;
void test_socket_open()
{
nsapi_error_t err = socket.open(network);
TEST_ASSERT(err == NSAPI_ERROR_OK);
}
void test_socket_bind()
{
nsapi_error_t err = socket.bind(3030);
TEST_ASSERT(!err);
}
/*
void test_socket_set_blocking()
{
//socket.set_blocking(true);
socket.set_timeout(5000);
}
void test_socket_send_receive_blocking()
{
char receive_buffer[CELLULAR_MTU] = {0};
char send_buffer[] = { 'H', 'e', 'l', 'l', 'u', 'l', 'a', 'r', '!' };
int send_count = 0;
int send_tries = 1;
int max_send_tries = 3;
// Send to echo server
while (send_tries <= max_send_tries) {
tr_info("ONE!!!");
send_count = socket.sendto(SERVER_IP_ADDR, SERVER_UDP_PORT, send_buffer, sizeof(send_buffer));
TEST_ASSERT_MESSAGE(send_count == sizeof(send_buffer), "Sent count doesnt match sent buffer!");
send_tries++;
// Read response
SocketAddress address;
int receive_count = 0;
// 2 tries. First recv attempt should be blocked and wait for a max 5 seconds for socket read flag
int recv_tries = 2;
while (recv_tries >= 0) {
tr_info("RECV!!!");
receive_count = socket.recvfrom(&address, receive_buffer, sizeof(receive_buffer));
if (receive_count > 0) {
break;
}
recv_tries--;
wait(1);
}
TEST_ASSERT_MESSAGE(receive_count == send_count, "Receive and Sent count dont match!");
TEST_ASSERT_MESSAGE(strncmp(send_buffer, receive_buffer, send_count) == 0, "Sent data doesn't match received data while in ECHO");
}
}
*/
static void socket_sigio_cb()
{
sock_event.release();
}
void test_socket_set_non_blocking()
{
socket.set_blocking(false);
socket.sigio(socket_sigio_cb);
}
void test_socket_send_receive_non_blocking()
{
char receive_buffer[1500] = {0};
char send_buffer[] = { 'H', 'e', 'l', 'l', 'u', 'l', 'a', 'r', '!' };
// Send to echo server
int send_count = socket.sendto(SERVER_IP_ADDR, SERVER_UDP_PORT, send_buffer, sizeof(send_buffer));
TEST_ASSERT(send_count == sizeof(send_buffer));
int32_t event;
event = sock_event.wait(10000);
TEST_ASSERT_MESSAGE( event>=1, "No Socket event within 10 seconds");
// Read response
SocketAddress address;
int receive_count = socket.recvfrom(&address, receive_buffer, sizeof(receive_buffer));
TEST_ASSERT_MESSAGE(receive_count == send_count, "Receive and Sent count dont match!");
TEST_ASSERT_MESSAGE(strncmp(send_buffer, receive_buffer, send_count) == 0, "Sent data doesn't match received data while in ECHO");
}
void test_socket_close()
{
nsapi_error_t err = socket.close();
TEST_ASSERT(!err);
}
#endif // CELLULAR_DEVICE

31
features/cellular/TESTS/cellular/cellular_all/template_mbed_app.json.txt Normal file
View File

@ -0,0 +1,31 @@
{
"config": {
"sock-type": "UDP",
"network-interface":{
"help": "Options are ETHERNET,CELLULAR",
"value": "CELLULAR"
},
"cellular_sim_pin": {
"help": "PIN code",
"value": "\"1234\""
},
"trace-level": {
"help": "Options are TRACE_LEVEL_ERROR,TRACE_LEVEL_WARN,TRACE_LEVEL_INFO,TRACE_LEVEL_DEBUG",
"macro_name": "MBED_TRACE_MAX_LEVEL",
"value": "TRACE_LEVEL_INFO"
}
},
"target_overrides": {
"*": {
"target.features_add": ["LWIP", "COMMON_PAL"],
"mbed-trace.enable": true,
"lwip.ipv4-enabled": true,
"lwip.ethernet-enabled": false,
"lwip.ppp-enabled": true,
"lwip.tcp-enabled": true,
"platform.stdio-convert-newlines": true,
"platform.stdio-baud-rate": 115200,
"platform.default-serial-baud-rate": 115200
}
}
}

19
features/cellular/UNITTESTS/Makefile Executable file
View File

@ -0,0 +1,19 @@
#scan for folders having "Makefile" in them and remove 'this' to prevent loop
DIRS := $(filter-out ./, $(sort $(dir $(shell find . -name 'Makefile'))))
all:
for dir in $(DIRS); do \
cd $$dir; make gcov; cd ..; cd ..;\
done
clean:
for dir in $(DIRS); do \
cd $$dir; make clean; cd ..; cd ..;\
done
rm -rf ../source/*gcov ../source/*gcda ../source/*o
rm -rf stubs/*gcov stubs/*gcda stubs/*o
rm -rf results/*
rm -rf coverages/*
rm -rf results
rm -rf coverages

562
features/cellular/UNITTESTS/MakefileWorker.mk Executable file
View File

@ -0,0 +1,562 @@
#---------
#
# MakefileWorker.mk
#
# Include this helper file in your makefile
# It makes
# A static library
# A test executable
#
# See this example for parameter settings
# examples/Makefile
#
#----------
# Inputs - these variables describe what to build
#
# INCLUDE_DIRS - Directories used to search for include files.
# This generates a -I for each directory
# SRC_DIRS - Directories containing source file to built into the library
# SRC_FILES - Specific source files to build into library. Helpful when not all code
# in a directory can be built for test (hopefully a temporary situation)
# TEST_SRC_DIRS - Directories containing unit test code build into the unit test runner
# These do not go in a library. They are explicitly included in the test runner
# TEST_SRC_FILES - Specific source files to build into the unit test runner
# These do not go in a library. They are explicitly included in the test runner
# MOCKS_SRC_DIRS - Directories containing mock source files to build into the test runner
# These do not go in a library. They are explicitly included in the test runner
#----------
# You can adjust these variables to influence how to build the test target
# and where to put and name outputs
# See below to determine defaults
# COMPONENT_NAME - the name of the thing being built
# TEST_TARGET - name the test executable. By default it is
# $(COMPONENT_NAME)_tests
# Helpful if you want 1 > make files in the same directory with different
# executables as output.
# CPPUTEST_HOME - where CppUTest home dir found
# TARGET_PLATFORM - Influences how the outputs are generated by modifying the
# CPPUTEST_OBJS_DIR and CPPUTEST_LIB_DIR to use a sub-directory under the
# normal objs and lib directories. Also modifies where to search for the
# CPPUTEST_LIB to link against.
# CPPUTEST_OBJS_DIR - a directory where o and d files go
# CPPUTEST_LIB_DIR - a directory where libs go
# CPPUTEST_ENABLE_DEBUG - build for debug
# CPPUTEST_USE_MEM_LEAK_DETECTION - Links with overridden new and delete
# CPPUTEST_USE_STD_CPP_LIB - Set to N to keep the standard C++ library out
# of the test harness
# CPPUTEST_USE_GCOV - Turn on coverage analysis
# Clean then build with this flag set to Y, then 'make gcov'
# CPPUTEST_MAPFILE - generate a map file
# CPPUTEST_WARNINGFLAGS - overly picky by default
# OTHER_MAKEFILE_TO_INCLUDE - a hook to use this makefile to make
# other targets. Like CSlim, which is part of fitnesse
# CPPUTEST_USE_VPATH - Use Make's VPATH functionality to support user
# specification of source files and directories that aren't below
# the user's Makefile in the directory tree, like:
# SRC_DIRS += ../../lib/foo
# It defaults to N, and shouldn't be necessary except in the above case.
#----------
#
# Other flags users can initialize to sneak in their settings
# CPPUTEST_CXXFLAGS - flags for the C++ compiler
# CPPUTEST_CPPFLAGS - flags for the C++ AND C preprocessor
# CPPUTEST_CFLAGS - flags for the C complier
# CPPUTEST_LDFLAGS - Linker flags
#----------
# Some behavior is weird on some platforms. Need to discover the platform.
# Platforms
UNAME_OUTPUT = "$(shell uname -a)"
MACOSX_STR = Darwin
MINGW_STR = MINGW
CYGWIN_STR = CYGWIN
LINUX_STR = Linux
SUNOS_STR = SunOS
UNKNWOWN_OS_STR = Unknown
# Compilers
CC_VERSION_OUTPUT ="$(shell $(CXX) -v 2>&1)"
CLANG_STR = clang
SUNSTUDIO_CXX_STR = SunStudio
UNAME_OS = $(UNKNWOWN_OS_STR)
ifeq ($(findstring $(MINGW_STR),$(UNAME_OUTPUT)),$(MINGW_STR))
UNAME_OS = $(MINGW_STR)
endif
ifeq ($(findstring $(CYGWIN_STR),$(UNAME_OUTPUT)),$(CYGWIN_STR))
UNAME_OS = $(CYGWIN_STR)
endif
ifeq ($(findstring $(LINUX_STR),$(UNAME_OUTPUT)),$(LINUX_STR))
UNAME_OS = $(LINUX_STR)
endif
ifeq ($(findstring $(MACOSX_STR),$(UNAME_OUTPUT)),$(MACOSX_STR))
UNAME_OS = $(MACOSX_STR)
#lion has a problem with the 'v' part of -a
UNAME_OUTPUT = "$(shell uname -pmnrs)"
endif
ifeq ($(findstring $(SUNOS_STR),$(UNAME_OUTPUT)),$(SUNOS_STR))
UNAME_OS = $(SUNOS_STR)
SUNSTUDIO_CXX_ERR_STR = CC -flags
ifeq ($(findstring $(SUNSTUDIO_CXX_ERR_STR),$(CC_VERSION_OUTPUT)),$(SUNSTUDIO_CXX_ERR_STR))
CC_VERSION_OUTPUT ="$(shell $(CXX) -V 2>&1)"
COMPILER_NAME = $(SUNSTUDIO_CXX_STR)
endif
endif
ifeq ($(findstring $(CLANG_STR),$(CC_VERSION_OUTPUT)),$(CLANG_STR))
COMPILER_NAME = $(CLANG_STR)
endif
#Kludge for mingw, it does not have cc.exe, but gcc.exe will do
ifeq ($(UNAME_OS),$(MINGW_STR))
CC := gcc
endif
#And another kludge. Exception handling in gcc 4.6.2 is broken when linking the
# Standard C++ library as a shared library. Unbelievable.
ifeq ($(UNAME_OS),$(MINGW_STR))
CPPUTEST_LDFLAGS += -static
endif
ifeq ($(UNAME_OS),$(CYGWIN_STR))
CPPUTEST_LDFLAGS += -static
endif
#Kludge for MacOsX gcc compiler on Darwin9 who can't handle pendantic
ifeq ($(UNAME_OS),$(MACOSX_STR))
ifeq ($(findstring Version 9,$(UNAME_OUTPUT)),Version 9)
CPPUTEST_PEDANTIC_ERRORS = N
endif
endif
ifndef COMPONENT_NAME
COMPONENT_NAME = name_this_in_the_makefile
endif
# Debug on by default
ifndef CPPUTEST_ENABLE_DEBUG
CPPUTEST_ENABLE_DEBUG = Y
endif
# new and delete for memory leak detection on by default
ifndef CPPUTEST_USE_MEM_LEAK_DETECTION
CPPUTEST_USE_MEM_LEAK_DETECTION = Y
endif
# Use the standard C library
ifndef CPPUTEST_USE_STD_C_LIB
CPPUTEST_USE_STD_C_LIB = Y
endif
# Use the standard C++ library
ifndef CPPUTEST_USE_STD_CPP_LIB
CPPUTEST_USE_STD_CPP_LIB = Y
endif
# Use gcov, off by default
ifndef CPPUTEST_USE_GCOV
CPPUTEST_USE_GCOV = N
endif
ifndef CPPUTEST_PEDANTIC_ERRORS
CPPUTEST_PEDANTIC_ERRORS = Y
endif
# Default warnings
ifndef CPPUTEST_WARNINGFLAGS
CPPUTEST_WARNINGFLAGS = -Wall -Wextra -Wshadow -Wswitch-default -Wswitch-enum -Wconversion
ifeq ($(CPPUTEST_PEDANTIC_ERRORS), Y)
# CPPUTEST_WARNINGFLAGS += -pedantic-errors
CPPUTEST_WARNINGFLAGS += -pedantic
endif
ifeq ($(UNAME_OS),$(LINUX_STR))
CPPUTEST_WARNINGFLAGS += -Wsign-conversion
endif
CPPUTEST_CXX_WARNINGFLAGS = -Woverloaded-virtual
CPPUTEST_C_WARNINGFLAGS = -Wstrict-prototypes
endif
#Wonderful extra compiler warnings with clang
ifeq ($(COMPILER_NAME),$(CLANG_STR))
# -Wno-disabled-macro-expansion -> Have to disable the macro expansion warning as the operator new overload warns on that.
# -Wno-padded -> I sort-of like this warning but if there is a bool at the end of the class, it seems impossible to remove it! (except by making padding explicit)
# -Wno-global-constructors Wno-exit-time-destructors -> Great warnings, but in CppUTest it is impossible to avoid as the automatic test registration depends on the global ctor and dtor
# -Wno-weak-vtables -> The TEST_GROUP macro declares a class and will automatically inline its methods. Thats ok as they are only in one translation unit. Unfortunately, the warning can't detect that, so it must be disabled.
CPPUTEST_CXX_WARNINGFLAGS += -Weverything -Wno-disabled-macro-expansion -Wno-padded -Wno-global-constructors -Wno-exit-time-destructors -Wno-weak-vtables
CPPUTEST_C_WARNINGFLAGS += -Weverything -Wno-padded
endif
# Uhm. Maybe put some warning flags for SunStudio here?
ifeq ($(COMPILER_NAME),$(SUNSTUDIO_CXX_STR))
CPPUTEST_CXX_WARNINGFLAGS =
CPPUTEST_C_WARNINGFLAGS =
endif
# Default dir for temporary files (d, o)
ifndef CPPUTEST_OBJS_DIR
ifndef TARGET_PLATFORM
CPPUTEST_OBJS_DIR = objs
else
CPPUTEST_OBJS_DIR = objs/$(TARGET_PLATFORM)
endif
endif
# Default dir for the outout library
ifndef CPPUTEST_LIB_DIR
ifndef TARGET_PLATFORM
CPPUTEST_LIB_DIR = lib
else
CPPUTEST_LIB_DIR = lib/$(TARGET_PLATFORM)
endif
endif
# No map by default
ifndef CPPUTEST_MAP_FILE
CPPUTEST_MAP_FILE = N
endif
# No extentions is default
ifndef CPPUTEST_USE_EXTENSIONS
CPPUTEST_USE_EXTENSIONS = N
endif
# No VPATH is default
ifndef CPPUTEST_USE_VPATH
CPPUTEST_USE_VPATH := N
endif
# Make empty, instead of 'N', for usage in $(if ) conditionals
ifneq ($(CPPUTEST_USE_VPATH), Y)
CPPUTEST_USE_VPATH :=
endif
ifndef TARGET_PLATFORM
#CPPUTEST_LIB_LINK_DIR = $(CPPUTEST_HOME)/lib
CPPUTEST_LIB_LINK_DIR = /usr/lib/x86_64-linux-gnu
else
CPPUTEST_LIB_LINK_DIR = $(CPPUTEST_HOME)/lib/$(TARGET_PLATFORM)
endif
# --------------------------------------
# derived flags in the following area
# --------------------------------------
# Without the C library, we'll need to disable the C++ library and ...
ifeq ($(CPPUTEST_USE_STD_C_LIB), N)
CPPUTEST_USE_STD_CPP_LIB = N
CPPUTEST_USE_MEM_LEAK_DETECTION = N
CPPUTEST_CPPFLAGS += -DCPPUTEST_STD_C_LIB_DISABLED
CPPUTEST_CPPFLAGS += -nostdinc
endif
CPPUTEST_CPPFLAGS += -DCPPUTEST_COMPILATION
ifeq ($(CPPUTEST_USE_MEM_LEAK_DETECTION), N)
CPPUTEST_CPPFLAGS += -DCPPUTEST_MEM_LEAK_DETECTION_DISABLED
else
ifndef CPPUTEST_MEMLEAK_DETECTOR_NEW_MACRO_FILE
CPPUTEST_MEMLEAK_DETECTOR_NEW_MACRO_FILE = -include $(CPPUTEST_HOME)/include/CppUTest/MemoryLeakDetectorNewMacros.h
endif
ifndef CPPUTEST_MEMLEAK_DETECTOR_MALLOC_MACRO_FILE
CPPUTEST_MEMLEAK_DETECTOR_MALLOC_MACRO_FILE = -include $(CPPUTEST_HOME)/include/CppUTest/MemoryLeakDetectorMallocMacros.h
endif
endif
ifeq ($(CPPUTEST_ENABLE_DEBUG), Y)
CPPUTEST_CXXFLAGS += -g
CPPUTEST_CFLAGS += -g
CPPUTEST_LDFLAGS += -g
endif
ifeq ($(CPPUTEST_USE_STD_CPP_LIB), N)
CPPUTEST_CPPFLAGS += -DCPPUTEST_STD_CPP_LIB_DISABLED
ifeq ($(CPPUTEST_USE_STD_C_LIB), Y)
CPPUTEST_CXXFLAGS += -nostdinc++
endif
endif
ifdef $(GMOCK_HOME)
GTEST_HOME = $(GMOCK_HOME)/gtest
CPPUTEST_CPPFLAGS += -I$(GMOCK_HOME)/include
GMOCK_LIBRARY = $(GMOCK_HOME)/lib/.libs/libgmock.a
LD_LIBRARIES += $(GMOCK_LIBRARY)
CPPUTEST_CPPFLAGS += -DINCLUDE_GTEST_TESTS
CPPUTEST_WARNINGFLAGS =
CPPUTEST_CPPFLAGS += -I$(GTEST_HOME)/include -I$(GTEST_HOME)
GTEST_LIBRARY = $(GTEST_HOME)/lib/.libs/libgtest.a
LD_LIBRARIES += $(GTEST_LIBRARY)
endif
ifeq ($(CPPUTEST_USE_GCOV), Y)
CPPUTEST_CXXFLAGS += -fprofile-arcs -ftest-coverage
CPPUTEST_CFLAGS += -fprofile-arcs -ftest-coverage
endif
CPPUTEST_CXXFLAGS += $(CPPUTEST_WARNINGFLAGS) $(CPPUTEST_CXX_WARNINGFLAGS)
CPPUTEST_CPPFLAGS += $(CPPUTEST_WARNINGFLAGS)
CPPUTEST_CXXFLAGS += $(CPPUTEST_MEMLEAK_DETECTOR_NEW_MACRO_FILE)
CPPUTEST_CPPFLAGS += $(CPPUTEST_MEMLEAK_DETECTOR_MALLOC_MACRO_FILE)
CPPUTEST_CFLAGS += $(CPPUTEST_C_WARNINGFLAGS)
TARGET_MAP = $(COMPONENT_NAME).map.txt
ifeq ($(CPPUTEST_MAP_FILE), Y)
CPPUTEST_LDFLAGS += -Wl,-map,$(TARGET_MAP)
endif
# Link with CppUTest lib
CPPUTEST_LIB = $(CPPUTEST_LIB_LINK_DIR)/libCppUTest.a
ifeq ($(CPPUTEST_USE_EXTENSIONS), Y)
CPPUTEST_LIB += $(CPPUTEST_LIB_LINK_DIR)/libCppUTestExt.a
endif
ifdef CPPUTEST_STATIC_REALTIME
LD_LIBRARIES += -lrt
endif
TARGET_LIB = \
$(CPPUTEST_LIB_DIR)/lib$(COMPONENT_NAME).a
ifndef TEST_TARGET
ifndef TARGET_PLATFORM
TEST_TARGET = $(COMPONENT_NAME)_tests
else
TEST_TARGET = $(COMPONENT_NAME)_$(TARGET_PLATFORM)_tests
endif
endif
#Helper Functions
get_src_from_dir = $(wildcard $1/*.cpp) $(wildcard $1/*.cc) $(wildcard $1/*.c)
get_dirs_from_dirspec = $(wildcard $1)
get_src_from_dir_list = $(foreach dir, $1, $(call get_src_from_dir,$(dir)))
__src_to = $(subst .c,$1, $(subst .cc,$1, $(subst .cpp,$1,$(if $(CPPUTEST_USE_VPATH),$(notdir $2),$2))))
src_to = $(addprefix $(CPPUTEST_OBJS_DIR)/,$(call __src_to,$1,$2))
src_to_o = $(call src_to,.o,$1)
src_to_d = $(call src_to,.d,$1)
src_to_gcda = $(call src_to,.gcda,$1)
src_to_gcno = $(call src_to,.gcno,$1)
time = $(shell date +%s)
delta_t = $(eval minus, $1, $2)
debug_print_list = $(foreach word,$1,echo " $(word)";) echo;
#Derived
STUFF_TO_CLEAN += $(TEST_TARGET) $(TEST_TARGET).exe $(TARGET_LIB) $(TARGET_MAP)
SRC += $(call get_src_from_dir_list, $(SRC_DIRS)) $(SRC_FILES)
OBJ = $(call src_to_o,$(SRC))
STUFF_TO_CLEAN += $(OBJ)
TEST_SRC += $(call get_src_from_dir_list, $(TEST_SRC_DIRS)) $(TEST_SRC_FILES)
TEST_OBJS = $(call src_to_o,$(TEST_SRC))
STUFF_TO_CLEAN += $(TEST_OBJS)
MOCKS_SRC += $(call get_src_from_dir_list, $(MOCKS_SRC_DIRS))
MOCKS_OBJS = $(call src_to_o,$(MOCKS_SRC))
STUFF_TO_CLEAN += $(MOCKS_OBJS)
ALL_SRC = $(SRC) $(TEST_SRC) $(MOCKS_SRC)
# If we're using VPATH
ifeq ($(CPPUTEST_USE_VPATH), Y)
# gather all the source directories and add them
VPATH += $(sort $(dir $(ALL_SRC)))
# Add the component name to the objs dir path, to differentiate between same-name objects
CPPUTEST_OBJS_DIR := $(addsuffix /$(COMPONENT_NAME),$(CPPUTEST_OBJS_DIR))
endif
#Test coverage with gcov
GCOV_OUTPUT = gcov_output.txt
GCOV_REPORT = gcov_report.txt
GCOV_ERROR = gcov_error.txt
GCOV_GCDA_FILES = $(call src_to_gcda, $(ALL_SRC))
GCOV_GCNO_FILES = $(call src_to_gcno, $(ALL_SRC))
TEST_OUTPUT = $(TEST_TARGET).txt
STUFF_TO_CLEAN += \
$(GCOV_OUTPUT)\
$(GCOV_REPORT)\
$(GCOV_REPORT).html\
$(GCOV_ERROR)\
$(GCOV_GCDA_FILES)\
$(GCOV_GCNO_FILES)\
$(TEST_OUTPUT)
#The gcda files for gcov need to be deleted before each run
#To avoid annoying messages.
GCOV_CLEAN = $(SILENCE)rm -f $(GCOV_GCDA_FILES) $(GCOV_OUTPUT) $(GCOV_REPORT) $(GCOV_ERROR)
RUN_TEST_TARGET = $(SILENCE) $(GCOV_CLEAN) ; echo "Running $(TEST_TARGET)"; ./$(TEST_TARGET) $(CPPUTEST_EXE_FLAGS) -ojunit
ifeq ($(CPPUTEST_USE_GCOV), Y)
ifeq ($(COMPILER_NAME),$(CLANG_STR))
LD_LIBRARIES += --coverage
else
LD_LIBRARIES += -lgcov
endif
endif
INCLUDES_DIRS_EXPANDED = $(call get_dirs_from_dirspec, $(INCLUDE_DIRS))
INCLUDES += $(foreach dir, $(INCLUDES_DIRS_EXPANDED), -I$(dir))
MOCK_DIRS_EXPANDED = $(call get_dirs_from_dirspec, $(MOCKS_SRC_DIRS))
INCLUDES += $(foreach dir, $(MOCK_DIRS_EXPANDED), -I$(dir))
CPPUTEST_CPPFLAGS += $(INCLUDES) $(CPPUTESTFLAGS)
DEP_FILES = $(call src_to_d, $(ALL_SRC))
STUFF_TO_CLEAN += $(DEP_FILES) $(PRODUCTION_CODE_START) $(PRODUCTION_CODE_END)
STUFF_TO_CLEAN += $(STDLIB_CODE_START) $(MAP_FILE) cpputest_*.xml junit_run_output
# We'll use the CPPUTEST_CFLAGS etc so that you can override AND add to the CppUTest flags
CFLAGS = $(CPPUTEST_CFLAGS) $(CPPUTEST_ADDITIONAL_CFLAGS)
CPPFLAGS = $(CPPUTEST_CPPFLAGS) $(CPPUTEST_ADDITIONAL_CPPFLAGS)
CXXFLAGS = $(CPPUTEST_CXXFLAGS) $(CPPUTEST_ADDITIONAL_CXXFLAGS)
LDFLAGS = $(CPPUTEST_LDFLAGS) $(CPPUTEST_ADDITIONAL_LDFLAGS)
# Don't consider creating the archive a warning condition that does STDERR output
ARFLAGS := $(ARFLAGS)c
DEP_FLAGS=-MMD -MP
# Some macros for programs to be overridden. For some reason, these are not in Make defaults
RANLIB = ranlib
# Targets
.PHONY: all
all: start $(TEST_TARGET)
$(RUN_TEST_TARGET)
.PHONY: start
start: $(TEST_TARGET)
$(SILENCE)START_TIME=$(call time)
.PHONY: all_no_tests
all_no_tests: $(TEST_TARGET)
.PHONY: flags
flags:
@echo
@echo "OS ${UNAME_OS}"
@echo "Compile C and C++ source with CPPFLAGS:"
@$(call debug_print_list,$(CPPFLAGS))
@echo "Compile C++ source with CXXFLAGS:"
@$(call debug_print_list,$(CXXFLAGS))
@echo "Compile C source with CFLAGS:"
@$(call debug_print_list,$(CFLAGS))
@echo "Link with LDFLAGS:"
@$(call debug_print_list,$(LDFLAGS))
@echo "Link with LD_LIBRARIES:"
@$(call debug_print_list,$(LD_LIBRARIES))
@echo "Create libraries with ARFLAGS:"
@$(call debug_print_list,$(ARFLAGS))
TEST_DEPS = $(TEST_OBJS) $(MOCKS_OBJS) $(PRODUCTION_CODE_START) $(TARGET_LIB) $(USER_LIBS) $(PRODUCTION_CODE_END) $(CPPUTEST_LIB) $(STDLIB_CODE_START)
test-deps: $(TEST_DEPS)
$(TEST_TARGET): $(TEST_DEPS)
@echo Linking $@
$(SILENCE)$(CXX) -o $@ $^ $(LD_LIBRARIES) $(LDFLAGS)
$(TARGET_LIB): $(OBJ)
@echo Building archive $@
$(SILENCE)mkdir -p $(dir $@)
$(SILENCE)$(AR) $(ARFLAGS) $@ $^
$(SILENCE)$(RANLIB) $@
test: $(TEST_TARGET)
$(RUN_TEST_TARGET) | tee $(TEST_OUTPUT)
vtest: $(TEST_TARGET)
$(RUN_TEST_TARGET) -v | tee $(TEST_OUTPUT)
$(CPPUTEST_OBJS_DIR)/%.o: %.cc
@echo compiling $(notdir $<)
$(SILENCE)mkdir -p $(dir $@)
$(SILENCE)$(COMPILE.cpp) $(DEP_FLAGS) $(OUTPUT_OPTION) $<
$(CPPUTEST_OBJS_DIR)/%.o: %.cpp
@echo compiling $(notdir $<)
$(SILENCE)mkdir -p $(dir $@)
$(SILENCE)$(COMPILE.cpp) $(DEP_FLAGS) $(OUTPUT_OPTION) $<
$(CPPUTEST_OBJS_DIR)/%.o: %.c
@echo compiling $(notdir $<)
$(SILENCE)mkdir -p $(dir $@)
$(SILENCE)$(COMPILE.c) $(DEP_FLAGS) $(OUTPUT_OPTION) $<
ifneq "$(MAKECMDGOALS)" "clean"
-include $(DEP_FILES)
endif
.PHONY: clean
clean:
@echo Making clean
$(SILENCE)$(RM) $(STUFF_TO_CLEAN)
$(SILENCE)rm -rf gcov objs #$(CPPUTEST_OBJS_DIR)
$(SILENCE)rm -rf $(CPPUTEST_LIB_DIR)
$(SILENCE)find . -name "*.gcno" | xargs rm -f
$(SILENCE)find . -name "*.gcda" | xargs rm -f
#realclean gets rid of all gcov, o and d files in the directory tree
#not just the ones made by this makefile
.PHONY: realclean
realclean: clean
$(SILENCE)rm -rf gcov
$(SILENCE)find . -name "*.gdcno" | xargs rm -f
$(SILENCE)find . -name "*.[do]" | xargs rm -f
gcov: test
ifeq ($(CPPUTEST_USE_VPATH), Y)
$(SILENCE)gcov --object-directory $(CPPUTEST_OBJS_DIR) $(SRC) >> $(GCOV_OUTPUT) 2>> $(GCOV_ERROR)
else
$(SILENCE)for d in $(SRC_DIRS) ; do \
gcov --object-directory $(CPPUTEST_OBJS_DIR)/$$d $$d/*.c $$d/*.cpp >> $(GCOV_OUTPUT) 2>>$(GCOV_ERROR) ; \
done
$(SILENCE)for f in $(SRC_FILES) ; do \
gcov --object-directory $(CPPUTEST_OBJS_DIR)/$$f $$f >> $(GCOV_OUTPUT) 2>>$(GCOV_ERROR) ; \
done
endif
# $(CPPUTEST_HOME)/scripts/filterGcov.sh $(GCOV_OUTPUT) $(GCOV_ERROR) $(GCOV_REPORT) $(TEST_OUTPUT)
/usr/share/cpputest/scripts/filterGcov.sh $(GCOV_OUTPUT) $(GCOV_ERROR) $(GCOV_REPORT) $(TEST_OUTPUT)
$(SILENCE)cat $(GCOV_REPORT)
$(SILENCE)mkdir -p gcov
$(SILENCE)mv *.gcov gcov
$(SILENCE)mv gcov_* gcov
@echo "See gcov directory for details"
.PHONEY: format
format:
$(CPPUTEST_HOME)/scripts/reformat.sh $(PROJECT_HOME_DIR)
.PHONEY: debug
debug:
@echo
@echo "Target Source files:"
@$(call debug_print_list,$(SRC))
@echo "Target Object files:"
@$(call debug_print_list,$(OBJ))
@echo "Test Source files:"
@$(call debug_print_list,$(TEST_SRC))
@echo "Test Object files:"
@$(call debug_print_list,$(TEST_OBJS))
@echo "Mock Source files:"
@$(call debug_print_list,$(MOCKS_SRC))
@echo "Mock Object files:"
@$(call debug_print_list,$(MOCKS_OBJS))
@echo "All Input Dependency files:"
@$(call debug_print_list,$(DEP_FILES))
@echo Stuff to clean:
@$(call debug_print_list,$(STUFF_TO_CLEAN))
@echo Includes:
@$(call debug_print_list,$(INCLUDES))
-include $(OTHER_MAKEFILE_TO_INCLUDE)

21
features/cellular/UNITTESTS/at/at_cellularbase/Makefile Normal file
View File

@ -0,0 +1,21 @@
include ../../makefile_defines.txt
COMPONENT_NAME = AT_CellularBase_unit
#This must be changed manually
SRC_FILES = \
../../../framework/AT/AT_CellularBase.cpp
TEST_SRC_FILES = \
main.cpp \
at_cellularbasetest.cpp \
test_at_cellularbase.cpp \
../../stubs/ATHandler_stub.cpp \
../../stubs/EventQueue_stub.cpp \
../../stubs/FileHandle_stub.cpp \
../../stubs/mbed_assert_stub.cpp \
include ../../MakefileWorker.mk
CPPUTESTFLAGS += -DFEA_TRACE_SUPPORT

50
features/cellular/UNITTESTS/at/at_cellularbase/at_cellularbasetest.cpp Normal file
View File

@ -0,0 +1,50 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellularbase.h"
#include "AT_CellularBase.h"
TEST_GROUP(AT_CellularBase)
{
Test_AT_CellularBase* unit;
void setup()
{
unit = new Test_AT_CellularBase();
}
void teardown()
{
delete unit;
}
};
TEST(AT_CellularBase, Create)
{
CHECK(unit != NULL);
}
TEST(AT_CellularBase, test_AT_CellularBase_get_at_handler)
{
unit->test_AT_CellularBase_get_at_handler();
}
TEST(AT_CellularBase, test_AT_CellularBase_get_device_error)
{
unit->test_AT_CellularBase_get_device_error();
}

28
features/cellular/UNITTESTS/at/at_cellularbase/main.cpp Normal file
View File

@ -0,0 +1,28 @@
/*
* 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 "CppUTest/CommandLineTestRunner.h"
#include "CppUTest/TestPlugin.h"
#include "CppUTest/TestRegistry.h"
#include "CppUTestExt/MockSupportPlugin.h"
int main(int ac, char** av)
{
return CommandLineTestRunner::RunAllTests(ac, av);
}
IMPORT_TEST_GROUP(AT_CellularBase);

59
features/cellular/UNITTESTS/at/at_cellularbase/test_at_cellularbase.cpp Normal file
View File

@ -0,0 +1,59 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellularbase.h"
#include "EventQueue.h"
#include "AT_CellularBase.h"
#include "ATHandler_stub.h"
#include "FileHandle_stub.h"
#include <string.h>
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);
CHECK(&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;
CHECK_EQUAL(8, at.get_device_error().errCode);
ATHandler_stub::device_err_value.errCode = 0;
}

33
features/cellular/UNITTESTS/at/at_cellularbase/test_at_cellularbase.h Normal file
View File

@ -0,0 +1,33 @@
/*
* 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.
*/
#ifndef TEST_AT_CELLULARBASE_H
#define TEST_AT_CELLULARBASE_H
class Test_AT_CellularBase
{
public:
Test_AT_CellularBase();
virtual ~Test_AT_CellularBase();
void test_AT_CellularBase_get_at_handler();
void test_AT_CellularBase_get_device_error();
};
#endif // TEST_AT_CELLULARBASE_H

29
features/cellular/UNITTESTS/at/at_cellulardevice/Makefile Normal file
View File

@ -0,0 +1,29 @@
include ../../makefile_defines.txt
COMPONENT_NAME = AT_CellularDevice_unit
#This must be changed manually
SRC_FILES = \
../../../framework/AT/AT_CellularDevice.cpp
TEST_SRC_FILES = \
main.cpp \
at_cellulardevicetest.cpp \
test_at_cellulardevice.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 \
include ../../MakefileWorker.mk
CPPUTESTFLAGS += -DFEA_TRACE_SUPPORT

99
features/cellular/UNITTESTS/at/at_cellulardevice/at_cellulardevicetest.cpp Normal file
View File

@ -0,0 +1,99 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellulardevice.h"
TEST_GROUP(AT_CellularDevice)
{
Test_AT_CellularDevice* unit;
void setup()
{
unit = new Test_AT_CellularDevice();
}
void teardown()
{
delete unit;
}
};
TEST(AT_CellularDevice, Create)
{
CHECK(unit != NULL);
}
TEST(AT_CellularDevice, test_AT_CellularDevice_constructor)
{
unit->test_AT_CellularDevice_constructor();
}
TEST(AT_CellularDevice, test_AT_CellularDevice_get_at_handler)
{
unit->test_AT_CellularDevice_get_at_handler();
}
TEST(AT_CellularDevice, test_AT_CellularDevice_open_network)
{
unit->test_AT_CellularDevice_open_network();
}
TEST(AT_CellularDevice, test_AT_CellularDevice_open_sms)
{
unit->test_AT_CellularDevice_open_sms();
}
TEST(AT_CellularDevice, test_AT_CellularDevice_open_power)
{
unit->test_AT_CellularDevice_open_power();
}
TEST(AT_CellularDevice, test_AT_CellularDevice_open_sim)
{
unit->test_AT_CellularDevice_open_sim();
}
TEST(AT_CellularDevice, test_AT_CellularDevice_open_information)
{
unit->test_AT_CellularDevice_open_information();
}
TEST(AT_CellularDevice, test_AT_CellularDevice_close_network)
{
unit->test_AT_CellularDevice_close_network();
}
TEST(AT_CellularDevice, test_AT_CellularDevice_close_sms)
{
unit->test_AT_CellularDevice_close_sms();
}
TEST(AT_CellularDevice, test_AT_CellularDevice_close_power)
{
unit->test_AT_CellularDevice_close_power();
}
TEST(AT_CellularDevice, test_AT_CellularDevice_close_sim)
{
unit->test_AT_CellularDevice_close_sim();
}
TEST(AT_CellularDevice, test_AT_CellularDevice_close_information)
{
unit->test_AT_CellularDevice_close_information();
}

28
features/cellular/UNITTESTS/at/at_cellulardevice/main.cpp Normal file
View File

@ -0,0 +1,28 @@
/*
* 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 "CppUTest/CommandLineTestRunner.h"
#include "CppUTest/TestPlugin.h"
#include "CppUTest/TestRegistry.h"
#include "CppUTestExt/MockSupportPlugin.h"
int main(int ac, char** av)
{
return CommandLineTestRunner::RunAllTests(ac, av);
}
IMPORT_TEST_GROUP(AT_CellularDevice);

157
features/cellular/UNITTESTS/at/at_cellulardevice/test_at_cellulardevice.cpp Normal file
View File

@ -0,0 +1,157 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellulardevice.h"
#include "AT_CellularDevice.h"
#include "ATHandler_stub.h"
#include "AT_CellularBase_stub.h"
#include <string.h>
using namespace mbed;
using namespace events;
Test_AT_CellularDevice::Test_AT_CellularDevice()
{
}
Test_AT_CellularDevice::~Test_AT_CellularDevice()
{
}
void Test_AT_CellularDevice::test_AT_CellularDevice_constructor()
{
EventQueue que;
AT_CellularDevice dev(que);
CellularDevice *dev2 = new AT_CellularDevice(que);
delete dev2;
}
void Test_AT_CellularDevice::test_AT_CellularDevice_get_at_handler()
{
EventQueue que;
AT_CellularDevice dev(que);
FileHandle_stub fh1;
FileHandle_stub fh2;
FileHandle_stub fh3;
dev.open_network(&fh1);
dev.open_sms(&fh2);
AT_CellularBase_stub::handler_value = AT_CellularBase_stub::handler_at_constructor_value;
dev.open_sim(&fh3);
ATHandler_stub::fh_value = &fh1;
dev.open_power(&fh1);
ATHandler_stub::fh_value = NULL;
}
void Test_AT_CellularDevice::test_AT_CellularDevice_open_network()
{
EventQueue que;
AT_CellularDevice dev(que);
FileHandle_stub fh1;
CHECK(!dev.open_network(NULL));
CHECK(dev.open_network(&fh1));
}
void Test_AT_CellularDevice::test_AT_CellularDevice_open_sms()
{
EventQueue que;
AT_CellularDevice dev(que);
FileHandle_stub fh1;
CHECK(!dev.open_sms(NULL));
CHECK(dev.open_sms(&fh1));
}
void Test_AT_CellularDevice::test_AT_CellularDevice_open_power()
{
EventQueue que;
AT_CellularDevice dev(que);
FileHandle_stub fh1;
CHECK(!dev.open_power(NULL));
CHECK(dev.open_power(&fh1));
}
void Test_AT_CellularDevice::test_AT_CellularDevice_open_sim()
{
EventQueue que;
AT_CellularDevice dev(que);
FileHandle_stub fh1;
CHECK(! dev.open_sim(NULL));
CHECK(dev.open_sim(&fh1));
}
void Test_AT_CellularDevice::test_AT_CellularDevice_open_information()
{
EventQueue que;
AT_CellularDevice dev(que);
FileHandle_stub fh1;
CHECK(!dev.open_information(NULL));
CHECK(dev.open_information(&fh1));
}
void Test_AT_CellularDevice::test_AT_CellularDevice_close_network()
{
}
void Test_AT_CellularDevice::test_AT_CellularDevice_close_sms()
{
}
void Test_AT_CellularDevice::test_AT_CellularDevice_close_power()
{
}
void Test_AT_CellularDevice::test_AT_CellularDevice_close_sim()
{
}
void Test_AT_CellularDevice::test_AT_CellularDevice_close_information()
{
EventQueue que;
AT_CellularDevice dev(que);
FileHandle_stub fh1;
ATHandler_stub::int_value = 0;
CHECK(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;
CHECK(dev.open_information(&fh1));
AT_CellularBase_stub::handler_value = AT_CellularBase_stub::handler_at_constructor_value;
dev.close_information();
ATHandler_stub::fh_value = NULL;
}

53
features/cellular/UNITTESTS/at/at_cellulardevice/test_at_cellulardevice.h Normal file
View File

@ -0,0 +1,53 @@
/*
* 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.
*/
#ifndef TEST_AT_CELLULARDEVICE_H
#define TEST_AT_CELLULARDEVICE_H
class Test_AT_CellularDevice
{
public:
Test_AT_CellularDevice();
virtual ~Test_AT_CellularDevice();
void test_AT_CellularDevice_constructor();
void test_AT_CellularDevice_get_at_handler(); //tests also releasing of those
void test_AT_CellularDevice_open_network();
void test_AT_CellularDevice_open_sms();
void test_AT_CellularDevice_open_power();
void test_AT_CellularDevice_open_sim();
void test_AT_CellularDevice_open_information();
void test_AT_CellularDevice_close_network();
void test_AT_CellularDevice_close_sms();
void test_AT_CellularDevice_close_power();
void test_AT_CellularDevice_close_sim();
void test_AT_CellularDevice_close_information();
};
#endif // TEST_AT_CELLULARDEVICE_H

22
features/cellular/UNITTESTS/at/at_cellularinformation/Makefile Normal file
View File

@ -0,0 +1,22 @@
include ../../makefile_defines.txt
COMPONENT_NAME = AT_CellularInformation_unit
#This must be changed manually
SRC_FILES = \
../../../framework/AT/AT_CellularInformation.cpp
TEST_SRC_FILES = \
main.cpp \
at_cellularinformationtest.cpp \
test_at_cellularinformation.cpp \
../../stubs/ATHandler_stub.cpp \
../../stubs/AT_CellularBase_stub.cpp \
../../stubs/EventQueue_stub.cpp \
../../stubs/FileHandle_stub.cpp \
../../stubs/mbed_assert_stub.cpp \
include ../../MakefileWorker.mk
CPPUTESTFLAGS += -DFEA_TRACE_SUPPORT

54
features/cellular/UNITTESTS/at/at_cellularinformation/at_cellularinformationtest.cpp Normal file
View File

@ -0,0 +1,54 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellularinformation.h"
TEST_GROUP(AT_CellularInformation)
{
Test_AT_CellularInformation* unit;
void setup()
{
unit = new Test_AT_CellularInformation();
}
void teardown()
{
delete unit;
}
};
TEST(AT_CellularInformation, Create)
{
CHECK(unit != NULL);
}
TEST(AT_CellularInformation, test_AT_CellularInformation_get_manufacturer)
{
unit->test_AT_CellularInformation_get_manufacturer();
}
TEST(AT_CellularInformation, test_AT_CellularInformation_get_model)
{
unit->test_AT_CellularInformation_get_model();
}
TEST(AT_CellularInformation, test_AT_CellularInformation_get_revision)
{
unit->test_AT_CellularInformation_get_revision();
}

28
features/cellular/UNITTESTS/at/at_cellularinformation/main.cpp Normal file
View File

@ -0,0 +1,28 @@
/*
* 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 "CppUTest/CommandLineTestRunner.h"
#include "CppUTest/TestPlugin.h"
#include "CppUTest/TestRegistry.h"
#include "CppUTestExt/MockSupportPlugin.h"
int main(int ac, char** av)
{
return CommandLineTestRunner::RunAllTests(ac, av);
}
IMPORT_TEST_GROUP(AT_CellularInformation);

81
features/cellular/UNITTESTS/at/at_cellularinformation/test_at_cellularinformation.cpp Normal file
View File

@ -0,0 +1,81 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellularinformation.h"
#include <string.h>
#include "ATHandler_stub.h"
#include "EventQueue.h"
#include "FileHandle_stub.h"
#include "ATHandler.h"
#include "AT_CellularInformation.h"
#include "AT_CellularBase.h"
using namespace mbed;
using namespace events;
Test_AT_CellularInformation::Test_AT_CellularInformation()
{
}
Test_AT_CellularInformation::~Test_AT_CellularInformation()
{
}
void Test_AT_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 = 8;
char buf[8];
CHECK(8 == aci.get_manufacturer(buf, 8));
}
void Test_AT_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 = 7;
char buf[8];
CHECK(7 == aci.get_model(buf, 8));
}
void Test_AT_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 = 6;
char buf[8];
CHECK(6 == aci->get_revision(buf, 8));
delete aci;
}

35
features/cellular/UNITTESTS/at/at_cellularinformation/test_at_cellularinformation.h Normal file
View File

@ -0,0 +1,35 @@
/*
* 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.
*/
#ifndef TEST_AT_CELLULARINFORMATION_H
#define TEST_AT_CELLULARINFORMATION_H
class Test_AT_CellularInformation
{
public:
Test_AT_CellularInformation();
virtual ~Test_AT_CellularInformation();
void test_AT_CellularInformation_get_manufacturer();
void test_AT_CellularInformation_get_model();
void test_AT_CellularInformation_get_revision();
};
#endif // TEST_AT_CELLULARINFORMATION_H

25
features/cellular/UNITTESTS/at/at_cellularnetwork/Makefile Normal file
View File

@ -0,0 +1,25 @@
include ../../makefile_defines.txt
COMPONENT_NAME = AT_CellularNetwork_unit
#This must be changed manually
SRC_FILES = \
../../../framework/AT/AT_CellularNetwork.cpp
TEST_SRC_FILES = \
main.cpp \
at_cellularnetworktest.cpp \
test_at_cellularnetwork.cpp \
../../stubs/ATHandler_stub.cpp \
../../stubs/AT_CellularBase_stub.cpp \
../../stubs/EventQueue_stub.cpp \
../../stubs/FileHandle_stub.cpp \
../../stubs/NetworkInterface_stub.cpp \
../../stubs/CellularUtil_stub.cpp \
../../stubs/us_ticker_stub.cpp \
../../stubs/mbed_assert_stub.cpp \
include ../../MakefileWorker.mk
CPPUTESTFLAGS += -DFEA_TRACE_SUPPORT

159
features/cellular/UNITTESTS/at/at_cellularnetwork/at_cellularnetworktest.cpp Normal file
View File

@ -0,0 +1,159 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellularnetwork.h"
TEST_GROUP(AT_CellularNetwork)
{
Test_AT_CellularNetwork* unit;
void setup()
{
unit = new Test_AT_CellularNetwork();
}
void teardown()
{
delete unit;
}
};
TEST(AT_CellularNetwork, Create)
{
CHECK(unit != NULL);
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_constructor)
{
unit->test_AT_CellularNetwork_constructor();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_set_credentials)
{
unit->test_AT_CellularNetwork_set_credentials();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_connect)
{
unit->test_AT_CellularNetwork_connect();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_disconnect)
{
unit->test_AT_CellularNetwork_disconnect();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_stack)
{
unit->test_AT_CellularNetwork_get_stack();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_set_registration)
{
unit->test_AT_CellularNetwork_set_registration();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_registration_status)
{
unit->test_AT_CellularNetwork_get_registration_status();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_set_attach)
{
unit->test_AT_CellularNetwork_set_attach();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_attach)
{
unit->test_AT_CellularNetwork_get_attach();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_rate_control)
{
unit->test_AT_CellularNetwork_get_rate_control();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_apn_backoff_timer)
{
unit->test_AT_CellularNetwork_get_apn_backoff_timer();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_ip_address)
{
unit->test_AT_CellularNetwork_get_ip_address();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_set_access_technology)
{
unit->test_AT_CellularNetwork_set_access_technology();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_scan_plmn)
{
unit->test_AT_CellularNetwork_scan_plmn();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_set_ciot_optimization_config)
{
unit->test_AT_CellularNetwork_set_ciot_optimization_config();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_ciot_optimization_config)
{
unit->test_AT_CellularNetwork_get_ciot_optimization_config();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_set_stack_type)
{
unit->test_AT_CellularNetwork_set_stack_type();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_stack_type)
{
unit->test_AT_CellularNetwork_get_stack_type();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_pdpcontext_params)
{
unit->test_AT_CellularNetwork_get_pdpcontext_params();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_extended_signal_quality)
{
unit->test_AT_CellularNetwork_get_extended_signal_quality();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_signal_quality)
{
unit->test_AT_CellularNetwork_get_signal_quality();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_cell_id)
{
unit->test_AT_CellularNetwork_get_cell_id();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_3gpp_error)
{
unit->test_AT_CellularNetwork_get_3gpp_error();
}
TEST(AT_CellularNetwork, test_AT_CellularNetwork_get_operator_params)
{
unit->test_AT_CellularNetwork_get_operator_params();
}

28
features/cellular/UNITTESTS/at/at_cellularnetwork/main.cpp Normal file
View File

@ -0,0 +1,28 @@
/*
* 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 "CppUTest/CommandLineTestRunner.h"
#include "CppUTest/TestPlugin.h"
#include "CppUTest/TestRegistry.h"
#include "CppUTestExt/MockSupportPlugin.h"
int main(int ac, char** av)
{
return CommandLineTestRunner::RunAllTests(ac, av);
}
IMPORT_TEST_GROUP(AT_CellularNetwork);

336
features/cellular/UNITTESTS/at/at_cellularnetwork/test_at_cellularnetwork.cpp Normal file
View File

@ -0,0 +1,336 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellularnetwork.h"
#include <string.h>
#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"
using namespace mbed;
using namespace events;
class my_AT_CN : public AT_CellularNetwork {
public:
my_AT_CN(ATHandler &atHandler) : AT_CellularNetwork(atHandler) {}
virtual ~my_AT_CN() {}
NetworkStack *get_stack() {return AT_CellularNetwork::get_stack();}
};
void conn_stat_cb(nsapi_error_t error)
{
}
Test_AT_CellularNetwork::Test_AT_CellularNetwork()
{
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
ATHandler_stub::int_value = -1;
}
Test_AT_CellularNetwork::~Test_AT_CellularNetwork()
{
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_constructor()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork *cn = new AT_CellularNetwork(at);
delete cn;
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_set_credentials()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
CHECK(NSAPI_ERROR_OK == cn.set_credentials("apn", CellularNetwork::CHAP));
CHECK(NSAPI_ERROR_OK == cn.set_credentials("apn"));
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_connect()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
cn.set_stack_type(IPV4V6_STACK);
CHECK(NSAPI_ERROR_NO_CONNECTION == cn.connect("APN", "a", "b"));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST;
CHECK(NSAPI_ERROR_NO_CONNECTION == cn.connect("APN"));
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_disconnect()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
CHECK(NSAPI_ERROR_OK == cn.disconnect());
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_stack()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
my_AT_CN cn(at);
CHECK(!cn.get_stack());
}
void Test_AT_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_CONNECTION_LOST;
CHECK(NSAPI_ERROR_CONNECTION_LOST == cn.set_registration());
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_registration_status()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
CellularNetwork::RegistrationStatus stat;
CHECK(NSAPI_ERROR_OK == cn.get_registration_status(CellularNetwork::C_EREG, stat));
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_set_attach()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST;
CHECK(NSAPI_ERROR_CONNECTION_LOST == cn.set_attach());
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_attach()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
CellularNetwork::AttachStatus stat;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST;
CHECK(NSAPI_ERROR_CONNECTION_LOST == cn.get_attach(stat));
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_rate_control()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
int ur;
CellularNetwork::RateControlExceptionReports reports;
CellularNetwork::RateControlUplinkTimeUnit timeUnit;
CHECK(NSAPI_ERROR_OK == cn.get_rate_control(reports, timeUnit, ur));
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_apn_backoff_timer()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
int time;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST;
CHECK(NSAPI_ERROR_CONNECTION_LOST == cn.get_apn_backoff_timer(time));
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_ip_address()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
CHECK(!cn.get_ip_address());
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_set_access_technology()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
CHECK(NSAPI_ERROR_UNSUPPORTED == cn.set_access_technology(CellularNetwork::operator_t::RAT_UNKNOWN));
CHECK(NSAPI_ERROR_UNSUPPORTED == cn.set_access_technology(CellularNetwork::operator_t::RAT_GSM_COMPACT));
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_scan_plmn()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
int c;
CellularNetwork::operList_t ops;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST;
CHECK(NSAPI_ERROR_CONNECTION_LOST == cn.scan_plmn(ops, c));
}
void Test_AT_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_CONNECTION_LOST;
CHECK(NSAPI_ERROR_CONNECTION_LOST == cn.set_ciot_optimization_config(CellularNetwork::SUPPORTED_UE_OPT_NO_SUPPORT, CellularNetwork::PREFERRED_UE_OPT_NO_PREFERENCE));
}
void Test_AT_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::Preferred_UE_Opt pref;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST;
CHECK(NSAPI_ERROR_CONNECTION_LOST == cn.get_ciot_optimization_config(sup, pref));
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_set_stack_type()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
CHECK(NSAPI_ERROR_PARAMETER == cn.set_stack_type(IPV4_STACK));
CHECK(NSAPI_ERROR_OK == cn.set_stack_type(DEFAULT_STACK));
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_stack_type()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
CHECK(DEFAULT_STACK == cn.get_stack_type());
}
void Test_AT_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_CONNECTION_LOST;
CHECK(NSAPI_ERROR_CONNECTION_LOST == cn.get_pdpcontext_params(list));
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_extended_signal_quality()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
int rx,be,rs,ec,rsrq,rsrp;
CHECK(NSAPI_ERROR_DEVICE_ERROR == cn.get_extended_signal_quality(rx, be,rs,ec,rsrq, rsrp));
ATHandler_stub::int_value = 1;
CHECK(NSAPI_ERROR_OK == cn.get_extended_signal_quality(rx, be,rs,ec,rsrq, rsrp));
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_signal_quality()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
int rs,ber;
CHECK(NSAPI_ERROR_DEVICE_ERROR == cn.get_signal_quality(rs,ber));
ATHandler_stub::int_value = 1;
CHECK(NSAPI_ERROR_OK == cn.get_signal_quality(rs,ber));
}
void Test_AT_CellularNetwork::test_AT_CellularNetwork_get_cell_id()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularNetwork cn(at);
int id;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_CONNECTION_LOST;
CHECK(NSAPI_ERROR_CONNECTION_LOST == cn.get_cell_id(id));
}
void Test_AT_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;
CHECK(8 == cn.get_3gpp_error());
}
void Test_AT_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_CONNECTION_LOST;
CHECK(NSAPI_ERROR_CONNECTION_LOST == cn.get_operator_params(format, ops));
}

77
features/cellular/UNITTESTS/at/at_cellularnetwork/test_at_cellularnetwork.h Normal file
View File

@ -0,0 +1,77 @@
/*
* 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.
*/
#ifndef TEST_AT_CELLULARNETWORK_H
#define TEST_AT_CELLULARNETWORK_H
class Test_AT_CellularNetwork
{
public:
Test_AT_CellularNetwork();
virtual ~Test_AT_CellularNetwork();
void test_AT_CellularNetwork_constructor();
void test_AT_CellularNetwork_set_credentials();
void test_AT_CellularNetwork_connect();
void test_AT_CellularNetwork_disconnect();
void test_AT_CellularNetwork_get_stack();
void test_AT_CellularNetwork_set_registration();
void test_AT_CellularNetwork_get_registration_status();
void test_AT_CellularNetwork_set_attach();
void test_AT_CellularNetwork_get_attach();
void test_AT_CellularNetwork_get_rate_control();
void test_AT_CellularNetwork_get_apn_backoff_timer();
void test_AT_CellularNetwork_get_ip_address();
void test_AT_CellularNetwork_set_access_technology();
void test_AT_CellularNetwork_scan_plmn();
void test_AT_CellularNetwork_set_ciot_optimization_config();
void test_AT_CellularNetwork_get_ciot_optimization_config();
void test_AT_CellularNetwork_set_stack_type();
void test_AT_CellularNetwork_get_stack_type();
void test_AT_CellularNetwork_get_pdpcontext_params();
void test_AT_CellularNetwork_get_extended_signal_quality();
void test_AT_CellularNetwork_get_signal_quality();
void test_AT_CellularNetwork_get_cell_id();
void test_AT_CellularNetwork_get_3gpp_error();
void test_AT_CellularNetwork_get_operator_params();
};
#endif // TEST_AT_CELLULARNETWORK_H

23
features/cellular/UNITTESTS/at/at_cellularpower/Makefile Normal file
View File

@ -0,0 +1,23 @@
include ../../makefile_defines.txt
COMPONENT_NAME = AT_CellularPower_unit
#This must be changed manually
SRC_FILES = \
../../../framework/AT/AT_CellularPower.cpp
TEST_SRC_FILES = \
main.cpp \
at_cellularpowertest.cpp \
test_at_cellularpower.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 \
include ../../MakefileWorker.mk
CPPUTESTFLAGS += -DFEA_TRACE_SUPPORT

79
features/cellular/UNITTESTS/at/at_cellularpower/at_cellularpowertest.cpp Normal file
View File

@ -0,0 +1,79 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellularpower.h"
TEST_GROUP(AT_CellularPower)
{
Test_AT_CellularPower* unit;
void setup()
{
unit = new Test_AT_CellularPower();
}
void teardown()
{
delete unit;
}
};
TEST(AT_CellularPower, Create)
{
CHECK(unit != NULL);
}
TEST(AT_CellularPower, test_AT_CellularPower_constructor)
{
unit->test_AT_CellularPower_constructor();
}
TEST(AT_CellularPower, test_AT_CellularPower_on)
{
unit->test_AT_CellularPower_on();
}
TEST(AT_CellularPower, test_AT_CellularPower_off)
{
unit->test_AT_CellularPower_off();
}
TEST(AT_CellularPower, test_AT_CellularPower_set_at_mode)
{
unit->test_AT_CellularPower_set_at_mode();
}
TEST(AT_CellularPower, test_AT_CellularPower_set_power_level)
{
unit->test_AT_CellularPower_set_power_level();
}
TEST(AT_CellularPower, test_AT_CellularPower_reset)
{
unit->test_AT_CellularPower_reset();
}
TEST(AT_CellularPower, test_AT_CellularPower_opt_power_save_mode)
{
unit->test_AT_CellularPower_opt_power_save_mode();
}
TEST(AT_CellularPower, test_AT_CellularPower_opt_receive_period)
{
unit->test_AT_CellularPower_opt_receive_period();
}

28
features/cellular/UNITTESTS/at/at_cellularpower/main.cpp Normal file
View File

@ -0,0 +1,28 @@
/*
* 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 "CppUTest/CommandLineTestRunner.h"
#include "CppUTest/TestPlugin.h"
#include "CppUTest/TestRegistry.h"
#include "CppUTestExt/MockSupportPlugin.h"
int main(int ac, char** av)
{
return CommandLineTestRunner::RunAllTests(ac, av);
}
IMPORT_TEST_GROUP(AT_CellularPower);

138
features/cellular/UNITTESTS/at/at_cellularpower/test_at_cellularpower.cpp Normal file
View File

@ -0,0 +1,138 @@
/*
* Copyright (c) 2018, Arm Limited and affiliates.
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "CppUTest/TestHarness.h"
#include "test_at_cellularpower.h"
#include <string.h>
#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;
Test_AT_CellularPower::Test_AT_CellularPower()
{
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
}
Test_AT_CellularPower::~Test_AT_CellularPower()
{
}
void Test_AT_CellularPower::test_AT_CellularPower_constructor()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularPower *pow = new AT_CellularPower(at);
delete pow;
}
void Test_AT_CellularPower::test_AT_CellularPower_on()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularPower pow(at);
CHECK(NSAPI_ERROR_UNSUPPORTED == pow.on())
}
void Test_AT_CellularPower::test_AT_CellularPower_off()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularPower pow(at);
CHECK(NSAPI_ERROR_UNSUPPORTED == pow.off())
}
void Test_AT_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_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.set_at_mode())
}
void Test_AT_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_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.set_power_level(6));
}
void Test_AT_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_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.reset());
}
void Test_AT_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_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_power_save_mode(0,0));
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_power_save_mode(10,0));
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_power_save_mode(912,0));
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_power_save_mode(1834,1834));
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_power_save_mode(18345,18345));
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_power_save_mode(101234,101234));
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_power_save_mode(1012345,1012345));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
CHECK(NSAPI_ERROR_OK == pow.opt_power_save_mode(39612345,39612345));
}
void Test_AT_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_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == pow.opt_receive_period(1, CellularPower::EDRXUTRAN_Iu_mode, 3));
}

45
features/cellular/UNITTESTS/at/at_cellularpower/test_at_cellularpower.h Normal file
View File

@ -0,0 +1,45 @@
/*
* 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.
*/
#ifndef TEST_AT_CELLULARPOWER_H
#define TEST_AT_CELLULARPOWER_H
class Test_AT_CellularPower
{
public:
Test_AT_CellularPower();
virtual ~Test_AT_CellularPower();
void test_AT_CellularPower_constructor();
void test_AT_CellularPower_on();
void test_AT_CellularPower_off();
void test_AT_CellularPower_set_at_mode();
void test_AT_CellularPower_set_power_level();
void test_AT_CellularPower_reset();
void test_AT_CellularPower_opt_power_save_mode();
void test_AT_CellularPower_opt_receive_period();
};
#endif // TEST_AT_CELLULARPOWER_H

24
features/cellular/UNITTESTS/at/at_cellularsim/Makefile Normal file
View File

@ -0,0 +1,24 @@
include ../../makefile_defines.txt
COMPONENT_NAME = AT_CellularSIM_unit
#This must be changed manually
SRC_FILES = \
../../../framework/AT/AT_CellularSIM.cpp
TEST_SRC_FILES = \
main.cpp \
at_cellularsimtest.cpp \
test_at_cellularsim.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 \
include ../../MakefileWorker.mk
CPPUTESTFLAGS += -DFEA_TRACE_SUPPORT

64
features/cellular/UNITTESTS/at/at_cellularsim/at_cellularsimtest.cpp Normal file
View File

@ -0,0 +1,64 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellularsim.h"
TEST_GROUP(AT_CellularSIM)
{
Test_AT_CellularSIM* unit;
void setup()
{
unit = new Test_AT_CellularSIM();
}
void teardown()
{
delete unit;
}
};
TEST(AT_CellularSIM, Create)
{
CHECK(unit != NULL);
}
TEST(AT_CellularSIM, test_AT_CellularSIM_constructor)
{
unit->test_AT_CellularSIM_constructor();
}
TEST(AT_CellularSIM, test_AT_CellularSIM_set_pin)
{
unit->test_AT_CellularSIM_set_pin();
}
TEST(AT_CellularSIM, test_AT_CellularSIM_change_pin)
{
unit->test_AT_CellularSIM_change_pin();
}
TEST(AT_CellularSIM, test_AT_CellularSIM_set_pin_query)
{
unit->test_AT_CellularSIM_set_pin_query();
}
TEST(AT_CellularSIM, test_AT_CellularSIM_get_sim_state)
{
unit->test_AT_CellularSIM_get_sim_state();
}

28
features/cellular/UNITTESTS/at/at_cellularsim/main.cpp Normal file
View File

@ -0,0 +1,28 @@
/*
* 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 "CppUTest/CommandLineTestRunner.h"
#include "CppUTest/TestPlugin.h"
#include "CppUTest/TestRegistry.h"
#include "CppUTestExt/MockSupportPlugin.h"
int main(int ac, char** av)
{
return CommandLineTestRunner::RunAllTests(ac, av);
}
IMPORT_TEST_GROUP(AT_CellularSIM);

131
features/cellular/UNITTESTS/at/at_cellularsim/test_at_cellularsim.cpp Normal file
View File

@ -0,0 +1,131 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellularsim.h"
#include <string.h>
#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;
Test_AT_CellularSIM::Test_AT_CellularSIM()
{
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
ATHandler_stub::read_string_value = NULL;
ATHandler_stub::ssize_value = 0;
}
Test_AT_CellularSIM::~Test_AT_CellularSIM()
{
}
void Test_AT_CellularSIM::test_AT_CellularSIM_constructor()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularSIM *sim = new AT_CellularSIM(at);
delete sim;
}
void Test_AT_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_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.set_pin("12"));
char table2[] = "READY";
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
ATHandler_stub::read_string_value = table2;
ATHandler_stub::ssize_value = 5;
CHECK(NSAPI_ERROR_OK == sim.set_pin("12"));
}
void Test_AT_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_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.change_pin("12", "34"));
}
void Test_AT_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_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.set_pin_query("12", true));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.set_pin_query("12", false));
}
void Test_AT_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_AUTH_FAILURE;
ATHandler_stub::ssize_value = -1;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
CHECK(CellularSIM::SimStateUnknown == state);
char table2[] = "READY";
ATHandler_stub::read_string_value = table2;
ATHandler_stub::ssize_value = 5;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
CHECK(CellularSIM::SimStateReady == state);
char table3[] = "SIM PIN";
ATHandler_stub::read_string_value = table3;
ATHandler_stub::ssize_value = 7;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
CHECK(CellularSIM::SimStatePinNeeded == state);
char table4[] = "SIM PUK";
ATHandler_stub::read_string_value = table4;
ATHandler_stub::ssize_value = 7;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
CHECK(CellularSIM::SimStatePukNeeded == state);
char table5[] = "SOME CRAP";
ATHandler_stub::read_string_value = table5;
ATHandler_stub::ssize_value = 9;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sim.get_sim_state(state));
CHECK(CellularSIM::SimStateUnknown == state);
}

39
features/cellular/UNITTESTS/at/at_cellularsim/test_at_cellularsim.h Normal file
View File

@ -0,0 +1,39 @@
/*
* 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.
*/
#ifndef TEST_AT_CELLULARSIM_H
#define TEST_AT_CELLULARSIM_H
class Test_AT_CellularSIM
{
public:
Test_AT_CellularSIM();
virtual ~Test_AT_CellularSIM();
void test_AT_CellularSIM_constructor();
void test_AT_CellularSIM_set_pin();
void test_AT_CellularSIM_change_pin();
void test_AT_CellularSIM_set_pin_query();
void test_AT_CellularSIM_get_sim_state();
};
#endif // TEST_AT_CELLULARSIM_H

25
features/cellular/UNITTESTS/at/at_cellularsms/Makefile Normal file
View File

@ -0,0 +1,25 @@
include ../../makefile_defines.txt
COMPONENT_NAME = AT_CellularSMS_unit
#This must be changed manually
SRC_FILES = \
../../../framework/AT/AT_CellularSMS.cpp
TEST_SRC_FILES = \
main.cpp \
at_cellularsmstest.cpp \
test_at_cellularsms.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 \
include ../../MakefileWorker.mk
CPPUTESTFLAGS += -DFEA_TRACE_SUPPORT

88
features/cellular/UNITTESTS/at/at_cellularsms/at_cellularsmstest.cpp Normal file
View File

@ -0,0 +1,88 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellularsms.h"
TEST_GROUP(AT_CellularSMS)
{
Test_AT_CellularSMS* unit;
void setup()
{
unit = new Test_AT_CellularSMS();
}
void teardown()
{
delete unit;
}
};
TEST(AT_CellularSMS, Create)
{
CHECK(unit != NULL);
}
TEST(AT_CellularSMS, test_AT_CellularSMS_constructor)
{
unit->test_AT_CellularSMS_constructor();
}
TEST(AT_CellularSMS, test_AT_CellularSMS_initialize)
{
unit->test_AT_CellularSMS_initialize();
}
TEST(AT_CellularSMS, test_AT_CellularSMS_send_sms)
{
unit->test_AT_CellularSMS_send_sms();
}
TEST(AT_CellularSMS, test_AT_CellularSMS_get_sms)
{
unit->test_AT_CellularSMS_get_sms();
}
TEST(AT_CellularSMS, test_AT_CellularSMS_set_sms_callback)
{
unit->test_AT_CellularSMS_set_sms_callback();
}
TEST(AT_CellularSMS, test_AT_CellularSMS_set_cpms)
{
unit->test_AT_CellularSMS_set_cpms();
}
TEST(AT_CellularSMS, test_AT_CellularSMS_set_csca)
{
unit->test_AT_CellularSMS_set_csca();
}
TEST(AT_CellularSMS, test_AT_CellularSMS_set_cscs)
{
unit->test_AT_CellularSMS_set_cscs();
}
TEST(AT_CellularSMS, test_AT_CellularSMS_delete_all_messages)
{
unit->test_AT_CellularSMS_delete_all_messages();
}
TEST(AT_CellularSMS, test_AT_CellularSMS_set_extra_sim_wait_time)
{
unit->test_AT_CellularSMS_set_extra_sim_wait_time();
}

28
features/cellular/UNITTESTS/at/at_cellularsms/main.cpp Normal file
View File

@ -0,0 +1,28 @@
/*
* 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 "CppUTest/CommandLineTestRunner.h"
#include "CppUTest/TestPlugin.h"
#include "CppUTest/TestRegistry.h"
#include "CppUTestExt/MockSupportPlugin.h"
int main(int ac, char** av)
{
return CommandLineTestRunner::RunAllTests(ac, av);
}
IMPORT_TEST_GROUP(AT_CellularSMS);

207
features/cellular/UNITTESTS/at/at_cellularsms/test_at_cellularsms.cpp Normal file
View File

@ -0,0 +1,207 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellularsms.h"
#include <string.h>
#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;
Test_AT_CellularSMS::Test_AT_CellularSMS()
{
ATHandler_stub::return_given_size = false;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_OK;
}
Test_AT_CellularSMS::~Test_AT_CellularSMS()
{
}
void Test_AT_CellularSMS::test_AT_CellularSMS_constructor()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularSMS *sms = new AT_CellularSMS(at);
delete sms;
}
void Test_AT_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;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.initialize(CellularSMS::CellularSMSMmodeText));
}
void Test_AT_CellularSMS::test_AT_CellularSMS_send_sms()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
AT_CellularSMS sms(at);
CHECK(NSAPI_ERROR_PARAMETER == sms.send_sms(NULL, "2", 1));
sms.initialize(CellularSMS::CellularSMSMmodeText);
ATHandler_stub::size_value = 1;
CHECK(1 == sms.send_sms("1", "22", 2));
ATHandler_stub::size_value = 2;
CHECK(2 == sms.send_sms("1", "22", 2));
sms.initialize(CellularSMS::CellularSMSMmodePDU);
CHECK(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;
CHECK(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;
CHECK(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";
ATHandler_stub::size_value = 0;
ATHandler_stub::return_given_size = true;
CHECK(218 == sms.send_sms("1", table, strlen(table)));
CHECK(218 == sms.send_sms("12", table, strlen(table)));
}
void Test_AT_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;
CHECK(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;
CHECK(-1 == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size));
ATHandler_stub::resp_info_true_counter = 2;
ATHandler_stub::int_value = 11;
CHECK(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);
CHECK(0 == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size));
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_AUTH_FAILURE;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.get_sms(buf, 16, phone, 21, stamp, 21, &size));
}
void Test_AT_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);
}
void Test_AT_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;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.set_cpms("2", "3", "4"));
}
void Test_AT_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;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.set_csca("2", 1));
}
void Test_AT_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;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.set_cscs("2"));
}
void Test_AT_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;
CHECK(NSAPI_ERROR_AUTH_FAILURE == sms.delete_all_messages());
}
void Test_AT_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);
}

49
features/cellular/UNITTESTS/at/at_cellularsms/test_at_cellularsms.h Normal file
View File

@ -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.
*/
#ifndef TEST_AT_CELLULARSMS_H
#define TEST_AT_CELLULARSMS_H
class Test_AT_CellularSMS
{
public:
Test_AT_CellularSMS();
virtual ~Test_AT_CellularSMS();
void test_AT_CellularSMS_constructor();
void test_AT_CellularSMS_initialize();
void test_AT_CellularSMS_send_sms();
void test_AT_CellularSMS_get_sms();
void test_AT_CellularSMS_set_sms_callback();
void test_AT_CellularSMS_set_cpms();
void test_AT_CellularSMS_set_csca();
void test_AT_CellularSMS_set_cscs();
void test_AT_CellularSMS_delete_all_messages();
void test_AT_CellularSMS_set_extra_sim_wait_time();
};
#endif // TEST_AT_CELLULARSMS_H

26
features/cellular/UNITTESTS/at/at_cellularstack/Makefile Normal file
View File

@ -0,0 +1,26 @@
include ../../makefile_defines.txt
COMPONENT_NAME = AT_CellularStack_unit
#This must be changed manually
SRC_FILES = \
../../../framework/AT/AT_CellularStack.cpp
TEST_SRC_FILES = \
main.cpp \
at_cellularstacktest.cpp \
test_at_cellularstack.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 \
include ../../MakefileWorker.mk
CPPUTESTFLAGS += -DFEA_TRACE_SUPPORT

104
features/cellular/UNITTESTS/at/at_cellularstack/at_cellularstacktest.cpp Normal file
View File

@ -0,0 +1,104 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellularstack.h"
TEST_GROUP(AT_CellularStack)
{
Test_AT_CellularStack* unit;
void setup()
{
unit = new Test_AT_CellularStack();
}
void teardown()
{
delete unit;
}
};
TEST(AT_CellularStack, Create)
{
CHECK(unit != NULL);
}
TEST(AT_CellularStack, test_AT_CellularStack_constructor)
{
unit->test_AT_CellularStack_constructor();
}
TEST(AT_CellularStack, test_AT_CellularStack_get_ip_address)
{
unit->test_AT_CellularStack_get_ip_address();
}
TEST(AT_CellularStack, test_AT_CellularStack_socket_open)
{
unit->test_AT_CellularStack_socket_open();
}
TEST(AT_CellularStack, test_AT_CellularStack_socket_close)
{
unit->test_AT_CellularStack_socket_close();
}
TEST(AT_CellularStack, test_AT_CellularStack_socket_bind)
{
unit->test_AT_CellularStack_socket_bind();
}
TEST(AT_CellularStack, test_AT_CellularStack_socket_listen)
{
unit->test_AT_CellularStack_socket_listen();
}
TEST(AT_CellularStack, test_AT_CellularStack_socket_connect)
{
unit->test_AT_CellularStack_socket_connect();
}
TEST(AT_CellularStack, test_AT_CellularStack_socket_accept)
{
unit->test_AT_CellularStack_socket_accept();
}
TEST(AT_CellularStack, test_AT_CellularStack_socket_send)
{
unit->test_AT_CellularStack_socket_send();
}
TEST(AT_CellularStack, test_AT_CellularStack_socket_recv)
{
unit->test_AT_CellularStack_socket_recv();
}
TEST(AT_CellularStack, test_AT_CellularStack_socket_sendto)
{
unit->test_AT_CellularStack_socket_sendto();
}
TEST(AT_CellularStack, test_AT_CellularStack_socket_recvfrom)
{
unit->test_AT_CellularStack_socket_recvfrom();
}
TEST(AT_CellularStack, test_AT_CellularStack_socket_attach)
{
unit->test_AT_CellularStack_socket_attach();
}

28
features/cellular/UNITTESTS/at/at_cellularstack/main.cpp Normal file
View File

@ -0,0 +1,28 @@
/*
* 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 "CppUTest/CommandLineTestRunner.h"
#include "CppUTest/TestPlugin.h"
#include "CppUTest/TestRegistry.h"
#include "CppUTestExt/MockSupportPlugin.h"
int main(int ac, char** av)
{
return CommandLineTestRunner::RunAllTests(ac, av);
}
IMPORT_TEST_GROUP(AT_CellularStack);

325
features/cellular/UNITTESTS/at/at_cellularstack/test_at_cellularstack.cpp Normal file
View File

@ -0,0 +1,325 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_at_cellularstack.h"
#include <string.h>
#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;
int max_packet_size;
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;
max_packet_size = 0;
}
virtual int get_max_socket_count(){return max_sock_value;}
virtual int get_max_packet_size(){return max_packet_size;}
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);}
};
Test_AT_CellularStack::Test_AT_CellularStack()
{
ATHandler_stub::ssize_value = 0;
ATHandler_stub::bool_value = false;
ATHandler_stub::read_string_value = NULL;
}
Test_AT_CellularStack::~Test_AT_CellularStack()
{
}
void Test_AT_CellularStack::test_AT_CellularStack_constructor()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
MyStack *st = new MyStack(at, 0, IPV4_STACK);
delete st;
}
void Test_AT_CellularStack::test_AT_CellularStack_get_ip_address()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
MyStack st(at, 0, IPV6_STACK);
CHECK(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;
CHECK(NULL == st.get_ip_address());
ATHandler_stub::ssize_value = strlen(table);
ATHandler_stub::bool_value = true;
ATHandler_stub::read_string_value = table;
CHECK(st.get_ip_address());
}
void Test_AT_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;
CHECK(NSAPI_ERROR_UNSUPPORTED == st.socket_open(NULL, NSAPI_TCP));
st.bool_value = true;
st.max_sock_value = 0;
nsapi_socket_t sock;
CHECK(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;
nsapi_socket_t sock2;
CHECK(NSAPI_ERROR_OK == st2.socket_open(&sock2, NSAPI_TCP));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_close()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
MyStack st(at, 0, IPV6_STACK);
nsapi_socket_t soc = NULL;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_close(soc));
st.bool_value = true;
st.max_sock_value = 1;
nsapi_socket_t sock;
CHECK(NSAPI_ERROR_OK == st.socket_open(&sock, NSAPI_TCP));
st.max_sock_value = 0;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_close(sock));
MyStack st2(at, 0, IPV6_STACK);
st2.max_sock_value = 1;
st2.bool_value = true;
nsapi_socket_t sock2;
CHECK(NSAPI_ERROR_OK == st2.socket_open(&sock2, NSAPI_TCP));
CHECK(NSAPI_ERROR_OK == st2.socket_close(sock2));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_bind()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
MyStack st(at, 0, IPV6_STACK);
nsapi_socket_t sock;
SocketAddress addr;
ATHandler_stub::nsapi_error_value = NSAPI_ERROR_ALREADY;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_bind(NULL, addr));
CHECK(NSAPI_ERROR_ALREADY == st.socket_bind(sock, addr));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_listen()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
MyStack st(at, 0, IPV6_STACK);
nsapi_socket_t sock;
CHECK(0 == st.socket_listen(sock, 4));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_connect()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
MyStack st(at, 0, IPV6_STACK);
SocketAddress addr;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_connect(NULL, addr));
nsapi_socket_t sock;
CHECK(NSAPI_ERROR_OK == st.socket_connect(sock, addr));
}
void Test_AT_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;
CHECK(0 == st.socket_accept(NULL, &sock));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_send()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
MyStack st(at, 0, IPV6_STACK);
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_send(NULL, "addr", 4));
nsapi_socket_t sock;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_send(sock, "addr", 4));
SocketAddress addr;
st.max_sock_value = 1;
st.bool_value = true;
st.socket_open(&sock, NSAPI_TCP);
st.socket_connect(sock, addr);
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_send(sock, "addr", 4));
}
void Test_AT_CellularStack::test_AT_CellularStack_socket_sendto()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
MyStack st(at, 0, IPV6_STACK);
nsapi_socket_t sock;
SocketAddress addr;
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_sendto(NULL, addr, "addr", 4));
st.max_sock_value = 1;
st.bool_value = true;
st.socket_open(&sock, NSAPI_TCP);
st.socket_connect(sock, addr);
st.create_error = NSAPI_ERROR_CONNECTION_LOST;
CHECK(NSAPI_ERROR_CONNECTION_LOST == st.socket_sendto(sock, addr, "addr", 4));
st.create_error = NSAPI_ERROR_OK;
st.max_packet_size = 6;
CHECK(NSAPI_ERROR_OK == st.socket_sendto(sock, addr, "addr", 4));
}
void Test_AT_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];
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_recv(NULL, table, 4));
}
void Test_AT_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];
CHECK(NSAPI_ERROR_DEVICE_ERROR == st.socket_recvfrom(NULL, NULL, table, 4));
nsapi_socket_t sock;
SocketAddress addr;
st.max_sock_value = 1;
st.bool_value = true;
st.socket_open(&sock, NSAPI_TCP);
st.socket_connect(sock, addr);
st.create_error = NSAPI_ERROR_CONNECTION_LOST;
CHECK(NSAPI_ERROR_CONNECTION_LOST == st.socket_recvfrom(sock, &addr, table, 4));
st.create_error = NSAPI_ERROR_OK;
st.max_packet_size = 6;
CHECK(NSAPI_ERROR_OK == st.socket_recvfrom(sock, &addr, table, 4));
}
void Test_AT_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);
nsapi_socket_t sock;
st.max_sock_value = 1;
st.bool_value = true;
st.socket_open(&sock, NSAPI_TCP);
st.socket_attach(sock, NULL, NULL);
}

55
features/cellular/UNITTESTS/at/at_cellularstack/test_at_cellularstack.h Normal file
View File

@ -0,0 +1,55 @@
/*
* 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.
*/
#ifndef TEST_AT_CELLULARSTACK_H
#define TEST_AT_CELLULARSTACK_H
class Test_AT_CellularStack
{
public:
Test_AT_CellularStack();
virtual ~Test_AT_CellularStack();
void test_AT_CellularStack_constructor();
void test_AT_CellularStack_get_ip_address();
void test_AT_CellularStack_socket_open();
void test_AT_CellularStack_socket_close();
void test_AT_CellularStack_socket_bind();
void test_AT_CellularStack_socket_listen();
void test_AT_CellularStack_socket_connect();
void test_AT_CellularStack_socket_accept();
void test_AT_CellularStack_socket_send();
void test_AT_CellularStack_socket_recv();
void test_AT_CellularStack_socket_sendto();
void test_AT_CellularStack_socket_recvfrom();
void test_AT_CellularStack_socket_attach();
};
#endif // TEST_AT_CELLULARSTACK_H

27
features/cellular/UNITTESTS/at/athandler/Makefile Normal file
View File

@ -0,0 +1,27 @@
include ../../makefile_defines.txt
COMPONENT_NAME = ATHandler_unit
#This must be changed manually
SRC_FILES = \
../../../framework/AT/ATHandler.cpp
TEST_SRC_FILES = \
main.cpp \
athandlertest.cpp \
test_athandler.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_wait_api_stub.cpp \
../../stubs/mbed_assert_stub.cpp \
../../stubs/mbed_poll_stub.cpp \
../../stubs/Timer_stub.cpp \
../../stubs/equeue_stub.cpp \
include ../../MakefileWorker.mk
CPPUTESTFLAGS += -DFEA_TRACE_SUPPORT

218
features/cellular/UNITTESTS/at/athandler/athandlertest.cpp Normal file
View File

@ -0,0 +1,218 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_athandler.h"
TEST_GROUP(ATHandler)
{
Test_ATHandler* unit;
void setup()
{
unit = new Test_ATHandler();
}
void teardown()
{
delete unit;
}
};
TEST(ATHandler, Create)
{
CHECK(unit != NULL);
}
TEST(ATHandler, test_ATHandler_constructor)
{
unit->test_ATHandler_constructor();
}
TEST(ATHandler, test_ATHandler_get_file_handle)
{
unit->test_ATHandler_get_file_handle();
}
TEST(ATHandler, test_ATHandler_set_file_handle)
{
unit->test_ATHandler_set_file_handle();
}
TEST(ATHandler, test_ATHandler_lock)
{
unit->test_ATHandler_lock();
}
TEST(ATHandler, test_ATHandler_unlock)
{
unit->test_ATHandler_unlock();
}
TEST(ATHandler, test_ATHandler_unlock_return_error)
{
unit->test_ATHandler_unlock_return_error();
}
TEST(ATHandler, test_ATHandler_set_urc_handler)
{
unit->test_ATHandler_set_urc_handler();
}
TEST(ATHandler, test_ATHandler_get_last_error)
{
unit->test_ATHandler_get_last_error();
}
TEST(ATHandler, test_ATHandler_get_last_device_error)
{
unit->test_ATHandler_get_last_device_error();
}
TEST(ATHandler, test_ATHandler_inc_ref_count)
{
unit->test_ATHandler_inc_ref_count();
}
TEST(ATHandler, test_ATHandler_dec_ref_count)
{
unit->test_ATHandler_dec_ref_count();
}
TEST(ATHandler, test_ATHandler_get_ref_count)
{
unit->test_ATHandler_get_ref_count();
}
TEST(ATHandler, test_ATHandler_set_at_timeout)
{
unit->test_ATHandler_set_at_timeout();
}
TEST(ATHandler, test_ATHandler_restore_at_timeout)
{
unit->test_ATHandler_restore_at_timeout();
}
TEST(ATHandler, test_ATHandler_clear_error)
{
unit->test_ATHandler_clear_error();
}
TEST(ATHandler, test_ATHandler_process_oob)
{
unit->test_ATHandler_process_oob();
}
TEST(ATHandler, test_ATHandler_set_filehandle_sigio)
{
unit->test_ATHandler_set_filehandle_sigio();
}
TEST(ATHandler, test_ATHandler_flush)
{
unit->test_ATHandler_flush();
}
TEST(ATHandler, test_ATHandler_cmd_start)
{
unit->test_ATHandler_cmd_start();
}
TEST(ATHandler, test_ATHandler_write_int)
{
unit->test_ATHandler_write_int();
}
TEST(ATHandler, test_ATHandler_write_string)
{
unit->test_ATHandler_write_string();
}
TEST(ATHandler, test_ATHandler_cmd_stop)
{
unit->test_ATHandler_cmd_stop();
}
TEST(ATHandler, test_ATHandler_write_bytes)
{
unit->test_ATHandler_write_bytes();
}
TEST(ATHandler, test_ATHandler_set_stop_tag)
{
unit->test_ATHandler_set_stop_tag();
}
TEST(ATHandler, test_ATHandler_set_delimiter)
{
unit->test_ATHandler_set_delimiter();
}
TEST(ATHandler, test_ATHandler_skip_param)
{
unit->test_ATHandler_skip_param();
}
TEST(ATHandler, test_ATHandler_read_bytes)
{
unit->test_ATHandler_read_bytes();
}
TEST(ATHandler, test_ATHandler_read_string)
{
unit->test_ATHandler_read_string();
}
TEST(ATHandler, test_ATHandler_read_int)
{
unit->test_ATHandler_read_int();
}
TEST(ATHandler, test_ATHandler_resp_start)
{
unit->test_ATHandler_resp_start();
}
TEST(ATHandler, test_ATHandler_resp_stop)
{
unit->test_ATHandler_resp_stop();
}
TEST(ATHandler, test_ATHandler_info_resp)
{
unit->test_ATHandler_info_resp();
}
TEST(ATHandler, test_ATHandler_info_elem)
{
unit->test_ATHandler_info_elem();
}
TEST(ATHandler, test_ATHandler_consume_to_stop_tag)
{
unit->test_ATHandler_consume_to_stop_tag();
}
TEST(ATHandler, test_ATHandler_enable_debug)
{
unit->test_ATHandler_enable_debug();
}
TEST(ATHandler, test_ATHandler_get_3gpp_error)
{
unit->test_ATHandler_get_3gpp_error();
}

28
features/cellular/UNITTESTS/at/athandler/main.cpp Normal file
View File

@ -0,0 +1,28 @@
/*
* 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 "CppUTest/CommandLineTestRunner.h"
#include "CppUTest/TestPlugin.h"
#include "CppUTest/TestRegistry.h"
#include "CppUTestExt/MockSupportPlugin.h"
int main(int ac, char** av)
{
return CommandLineTestRunner::RunAllTests(ac, av);
}
IMPORT_TEST_GROUP(ATHandler);

773
features/cellular/UNITTESTS/at/athandler/test_athandler.cpp Normal file
View File

@ -0,0 +1,773 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_athandler.h"
#include <string.h>
#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()
{
}
Test_ATHandler::Test_ATHandler()
{
}
Test_ATHandler::~Test_ATHandler()
{
}
void Test_ATHandler::test_ATHandler_constructor()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler *at = new ATHandler(&fh1, que, 0, ",");
delete at;
at = new ATHandler(&fh1, que, 0, NULL);
delete at;
}
void Test_ATHandler::test_ATHandler_get_file_handle()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
CHECK_EQUAL(&fh1, at.get_file_handle());
}
void Test_ATHandler::test_ATHandler_set_file_handle()
{
EventQueue que;
FileHandle_stub fh1, fh2;
ATHandler at(&fh1, que, 0, ",");
at.set_file_handle(&fh2);
}
void Test_ATHandler::test_ATHandler_lock()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
at.lock();
}
void Test_ATHandler::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();
}
void Test_ATHandler::test_ATHandler_unlock_return_error()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
CHECK(NSAPI_ERROR_OK == at.unlock_return_error());
}
void Test_ATHandler::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);
}
void Test_ATHandler::test_ATHandler_get_last_error()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
CHECK(NSAPI_ERROR_OK == at.get_last_error());
}
void Test_ATHandler::test_ATHandler_get_last_device_error()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
CHECK(0 == at.get_last_device_error().errCode);
}
void Test_ATHandler::test_ATHandler_inc_ref_count()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
at.inc_ref_count();
}
void Test_ATHandler::test_ATHandler_dec_ref_count()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
at.dec_ref_count();
}
void Test_ATHandler::test_ATHandler_get_ref_count()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
CHECK(1 == at.get_ref_count());
at.inc_ref_count();
CHECK(2 == at.get_ref_count());
at.inc_ref_count();
CHECK(3 == at.get_ref_count());
at.dec_ref_count();
at.dec_ref_count();
CHECK(1 == at.get_ref_count());
}
void Test_ATHandler::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);
}
void Test_ATHandler::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();
}
void Test_ATHandler::test_ATHandler_clear_error()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
at.clear_error();
}
void Test_ATHandler::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;
}
void Test_ATHandler::test_ATHandler_set_filehandle_sigio()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
at.set_filehandle_sigio();
}
void Test_ATHandler::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();
}
void Test_ATHandler::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 = 1;
at.cmd_start("s");
mbed_poll_stub::revents_value = POLLIN;
mbed_poll_stub::int_value = 0;
at.cmd_start("s");
at.cmd_start("s");
}
void Test_ATHandler::test_ATHandler_write_int()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
at.write_int(4);
at.clear_error();
mbed_poll_stub::revents_value = POLLOUT;
mbed_poll_stub::int_value = 1;
fh1.size_value = 1;
at.write_int(4);
at.write_int(2147483647);
at.write_int(2147483647+1);
// at.at_error(0, DeviceErrorType(0));
// at.write_int(4);
}
void Test_ATHandler::test_ATHandler_write_string()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
at.write_string("help");
CHECK(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);
CHECK(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 = 3;
at.write_string("help", true);
CHECK(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);
CHECK(NSAPI_ERROR_OK == at.get_last_error());
}
void Test_ATHandler::test_ATHandler_cmd_stop()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
at.cmd_stop();
at.write_string("help", true);
at.cmd_stop();
CHECK(NSAPI_ERROR_DEVICE_ERROR == at.get_last_error());
}
void Test_ATHandler::test_ATHandler_write_bytes()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
uint8_t data[] = "data";
at.write_bytes(data, 4);
at.write_bytes(data, 4);
CHECK(NSAPI_ERROR_DEVICE_ERROR == at.get_last_error());
}
void Test_ATHandler::test_ATHandler_set_stop_tag()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
at.set_stop_tag("s");
}
void Test_ATHandler::test_ATHandler_set_delimiter()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
at.set_delimiter('+');
}
void Test_ATHandler::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();
CHECK(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);
}
void Test_ATHandler::test_ATHandler_read_bytes()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
uint8_t buf[5];
CHECK(-1 == at.read_bytes(buf, 25));
CHECK(-1 == at.read_bytes(buf, 5));
char table[] = "ssssssssssssssssssssssssssssOK\r\n\0";
filehandle_stub_table = table;
filehandle_stub_table_pos = 0;
at.clear_error();
CHECK(5 == at.read_bytes(buf, 5));
}
void Test_ATHandler::test_ATHandler_read_string()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
char table[] = "\"s,\"OK\r\n\0";
filehandle_stub_table = table;
filehandle_stub_table_pos = 0;
char buf[5];
uint8_t buf2[5];
at.flush();
at.clear_error();
at.resp_start();
at.read_bytes(buf2, 5);
CHECK(-1 == at.read_string(buf, 15));
filehandle_stub_table = table;
filehandle_stub_table_pos = 0;
at.flush();
at.clear_error();
at.resp_start();
at.read_bytes(buf2, 1);
CHECK(1 == at.read_string(buf, 5, true));
char table2[] = "\"s\"OK\r\n\0";
filehandle_stub_table = table2;
filehandle_stub_table_pos = 0;
at.flush();
at.clear_error();
at.resp_start();
at.read_bytes(buf2, 1);
CHECK(1 == at.read_string(buf, 5, true));
char table3[] = "sss\rsss\0";
filehandle_stub_table = table3;
filehandle_stub_table_pos = 0;
at.flush();
at.clear_error();
at.resp_start("s");
at.read_string(buf, 5, true);
char table4[] = "\"s\"\0";
filehandle_stub_table = table4;
filehandle_stub_table_pos = 0;
at.flush();
at.clear_error();
at.resp_start("s");
at.read_string(buf, 5, true);
filehandle_stub_table = NULL;
filehandle_stub_table_pos = 0;
}
void Test_ATHandler::test_ATHandler_read_int()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
int32_t ret= at.read_int();
CHECK(-1 == ret);
char table[] = "\",\"OK\r\n\0";
filehandle_stub_table = table;
filehandle_stub_table_pos = 0;
at.flush();
at.clear_error();
at.resp_start();
ret= at.read_int();
CHECK(-1 == ret);
char table2[] = "\"2,\"OK\r\n\0";
filehandle_stub_table = table2;
filehandle_stub_table_pos = 0;
at.flush();
at.clear_error();
at.resp_start();
ret= at.read_int();
CHECK(2 == ret);
}
void Test_ATHandler::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();
}
void Test_ATHandler::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();
}
void Test_ATHandler::test_ATHandler_info_resp()
{
EventQueue que;
FileHandle_stub fh1;
filehandle_stub_table = NULL;
ATHandler at(&fh1, que, 0, ",");
CHECK(at.info_resp());
at.resp_start();
CHECK(!at.info_resp());
char table2[] = "21 OK\r\n\0";
filehandle_stub_table = table2;
filehandle_stub_table_pos = 0;
at.flush();
at.clear_error();
at.resp_start("21");
CHECK(at.info_resp());
CHECK(!at.info_resp());
char table3[] = "21 OK\r\n\0";
filehandle_stub_table = table3;
filehandle_stub_table_pos = 0;
at.flush();
at.clear_error();
CHECK(at.info_resp());
}
void Test_ATHandler::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;
ATHandler at(&fh1, que, 0, ",");
CHECK(!at.info_elem(char(79)));
char table2[] = "21 OK\r\n\0";
filehandle_stub_table = table2;
filehandle_stub_table_pos = 0;
at.flush();
at.clear_error();
at.resp_start("21");
CHECK(at.info_elem(char(79)));
CHECK(at.info_elem('2'));
filehandle_stub_table = NULL;
filehandle_stub_table_pos = 0;
at.flush();
at.clear_error();
at.resp_start("21");
CHECK(!at.info_elem('2'));
}
void Test_ATHandler::test_ATHandler_consume_to_stop_tag()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
CHECK(at.consume_to_stop_tag());
}
void Test_ATHandler::test_ATHandler_enable_debug()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
at.enable_debug(true);
at.enable_debug(false);
}
void Test_ATHandler::test_ATHandler_get_3gpp_error()
{
EventQueue que;
FileHandle_stub fh1;
ATHandler at(&fh1, que, 0, ",");
int ret = at.get_3gpp_error();
}

101
features/cellular/UNITTESTS/at/athandler/test_athandler.h Normal file
View File

@ -0,0 +1,101 @@
/*
* 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.
*/
#ifndef TEST_ATHANDLER_H
#define TEST_ATHANDLER_H
class Test_ATHandler
{
public:
Test_ATHandler();
virtual ~Test_ATHandler();
void test_ATHandler_constructor();
void test_ATHandler_get_file_handle();
void test_ATHandler_set_file_handle();
void test_ATHandler_lock();
void test_ATHandler_unlock();
void test_ATHandler_unlock_return_error();
void test_ATHandler_set_urc_handler();
void test_ATHandler_get_last_error();
void test_ATHandler_get_last_device_error();
void test_ATHandler_inc_ref_count();
void test_ATHandler_dec_ref_count();
void test_ATHandler_get_ref_count();
void test_ATHandler_set_at_timeout();
void test_ATHandler_restore_at_timeout();
void test_ATHandler_clear_error();
void test_ATHandler_process_oob();
void test_ATHandler_set_filehandle_sigio();
void test_ATHandler_flush();
void test_ATHandler_cmd_start();
void test_ATHandler_write_int();
void test_ATHandler_write_string();
void test_ATHandler_cmd_stop();
void test_ATHandler_write_bytes();
void test_ATHandler_set_stop_tag();
void test_ATHandler_set_delimiter();
void test_ATHandler_skip_param();
void test_ATHandler_read_bytes();
void test_ATHandler_read_string();
void test_ATHandler_read_int();
void test_ATHandler_resp_start();
void test_ATHandler_resp_stop();
void test_ATHandler_info_resp();
void test_ATHandler_info_elem();
void test_ATHandler_consume_to_stop_tag();
void test_ATHandler_enable_debug();
void test_ATHandler_get_3gpp_error();
};
#endif // TEST_ATHANDLER_H

17
features/cellular/UNITTESTS/common/util/Makefile Normal file
View File

@ -0,0 +1,17 @@
include ../../makefile_defines.txt
COMPONENT_NAME = util_unit
#This must be changed manually
SRC_FILES = \
../../../framework/common/CellularUtil.cpp
TEST_SRC_FILES = \
main.cpp \
utiltest.cpp \
test_util.cpp \
include ../../MakefileWorker.mk
CPPUTESTFLAGS += -DFEA_TRACE_SUPPORT

28
features/cellular/UNITTESTS/common/util/main.cpp Normal file
View File

@ -0,0 +1,28 @@
/*
* 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 "CppUTest/CommandLineTestRunner.h"
#include "CppUTest/TestPlugin.h"
#include "CppUTest/TestRegistry.h"
#include "CppUTestExt/MockSupportPlugin.h"
int main(int ac, char** av)
{
return CommandLineTestRunner::RunAllTests(ac, av);
}
IMPORT_TEST_GROUP(util);

177
features/cellular/UNITTESTS/common/util/test_util.cpp Normal file
View File

@ -0,0 +1,177 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_util.h"
#include <string.h>
#include "CellularUtil.h"
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"
STRCMP_EQUAL("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';
STRCMP_EQUAL("31323334", hex_buf);
LONGS_EQUAL(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';
STRCMP_EQUAL("7775687575", hex_buf);
LONGS_EQUAL(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';
STRCMP_EQUAL("0A7775687575", hex_buf);
LONGS_EQUAL(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';
STRCMP_EQUAL("A7775687575", hex_buf);
LONGS_EQUAL(11, number_of_hex_chars);
// test giving a null pointer
number_of_hex_chars = char_str_to_hex_str(NULL, 4, hex_buf);
LONGS_EQUAL(0, number_of_hex_chars);
number_of_hex_chars = char_str_to_hex_str("1234", 4, NULL);
LONGS_EQUAL(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);
STRCMP_EQUAL("101:101:101:101:101:101:101:101", ipv6);
LONGS_EQUAL(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);
STRCMP_EQUAL("FF01:7802:F40C:372D:C96E:B02:E99A:5560", ipv6);
LONGS_EQUAL(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));
STRCMP_EQUAL("62.241.198.246", tt);
STRCMP_EQUAL("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));
STRCMP_EQUAL("62.241.198.246", temp);
STRCMP_EQUAL("2001:14B8:1000:000:000:000:000:002", tt2);
}
void Test_util::test_util_separate_ip_addresses()
{
char* s = (char*)malloc(128);
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));
STRCMP_EQUAL("2001:14BB:170:8BF5:FB88:E86E:7B33:E68A", ip);
STRCMP_EQUAL("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));
STRCMP_EQUAL("32:1:20:187:1:112:139:245:251:136:232:110:123:51:230:138", ip);
STRCMP_EQUAL("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));
STRCMP_EQUAL("1.2.3.4", ip);
STRCMP_EQUAL("", 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));
STRCMP_EQUAL("1.2.3.4", ip);
STRCMP_EQUAL("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));
STRCMP_EQUAL("102:304:506:708:90A:B0C:D0E:F10", ip);
STRCMP_EQUAL("", 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));
STRCMP_EQUAL("32:1:20:187:1:112:139:245:251:136:232:110:123:51:230:138", ip);
STRCMP_EQUAL("", 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));
STRCMP_EQUAL("1.2.3.4", ip);
STRCMP_EQUAL("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));
STRCMP_EQUAL("1.2.3.4", ip);
STRCMP_EQUAL("506:708:90A:B0C:D0E:F10:1112:1314", subnet);
STRCMP_EQUAL("1.2.3.4 5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20", s);
}

39
features/cellular/UNITTESTS/common/util/test_util.h Normal file
View File

@ -0,0 +1,39 @@
/*
* 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.
*/
#ifndef TEST_UTIL_H
#define TEST_UTIL_H
class Test_util
{
public:
Test_util();
virtual ~Test_util();
void test_util_uint_to_binary_string();
void test_util_char_str_to_hex();
void test_util_convert_ipv6();
void test_util_prefer_ipv6();
void test_util_separate_ip_addresses();
};
#endif // TEST_UTIL_H

63
features/cellular/UNITTESTS/common/util/utiltest.cpp Normal file
View File

@ -0,0 +1,63 @@
/*
* 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 "CppUTest/TestHarness.h"
#include "test_util.h"
TEST_GROUP(util)
{
Test_util* unit;
void setup()
{
unit = new Test_util();
}
void teardown()
{
delete unit;
}
};
TEST(util, Create)
{
CHECK(unit != NULL);
}
TEST(util, test_util_uint_to_binary_string)
{
unit->test_util_uint_to_binary_string();
}
TEST(util, char_str_to_hex)
{
unit->test_util_char_str_to_hex();
}
TEST(util, convert_ipv6)
{
unit->test_util_convert_ipv6();
}
TEST(util, prefer_ipv6)
{
unit->test_util_prefer_ipv6();
}
TEST(util, separate_ip_addresses)
{
unit->test_util_separate_ip_addresses();
}

32
features/cellular/UNITTESTS/makefile_defines.txt Executable file
View File

@ -0,0 +1,32 @@
#--- Inputs ----#
CPPUTEST_HOME = /usr
CPPUTEST_USE_EXTENSIONS = Y
CPPUTEST_USE_VPATH = Y
CPPUTEST_USE_GCOV = Y
CPPUTEST_USE_MEM_LEAK_DETECTION = N
CPP_PLATFORM = gcc
INCLUDE_DIRS =\
.\
../../stubs\
../../target_h\
../../..\
../../../../../features \
../../../../../features/netsocket \
../../../../.. \
../../../../../rtos \
../../../../../rtos/TARGET_CORTEX \
../../../../../platform \
../../../../../hal \
../../../../../events \
../../../../../events/equeue \
../../../../../drivers \
../../../framework\
../../../framework/common\
../../../framework/AT\
../../../framework/API\
/usr/include\
$(CPPUTEST_HOME)/include\
CPPUTESTFLAGS = -D__thumb2__ -w -D__INLINE=__inline
CPPUTEST_CFLAGS += -std=gnu99

48
features/cellular/UNITTESTS/run_tests Executable file
View File

@ -0,0 +1,48 @@
#!/bin/bash
echo
echo Build Cellular unit tests
echo
#replace by empty string if no branch coverage is needed
#branch_cov="--rc lcov_branch_coverage=1"
branch_cov=""
#branch_data="--rc branch-coverage=1"
branch_data="--no-branch-coverage"
# Remember to add new test folder to Makefile
make clean >/dev/null 2>&1
make all
echo
echo Create results
echo
mkdir results
find ./ -name '*.xml' | xargs cp -t ./results/
echo
echo Create coverage document
echo
mkdir coverages
cd coverages
lcov -q -d ../. -c -o app.info $branch_cov
lcov -q -r app.info "/test*" -o app.info $branch_cov
lcov -q -r app.info "/usr*" -o app.info $branch_cov
lcov -q -r app.info "/UNITTESTS/common*" -o app.info $branch_cov
lcov -q -r app.info "/UNITTESTS/*" -o app.info $branch_cov
lcov -q -r app.info "/UNITTESTS/stubs*" -o app.info $branch_cov
lcov -q -r app.info "/UNITTESTS/target_h*" -o app.info $branch_cov
lcov -q -r app.info "/mbed-client*" -o app.info $branch_cov
lcov -q -r app.info "/mbed-os/events*" -o app.info $branch_cov
lcov -q -r app.info "/mbed-os/features/netsocket*" -o app.info $branch_cov
lcov -q -r app.info "/mbed-os/platform*" -o app.info $branch_cov
genhtml $branch_data app.info
cd ..
echo
echo
echo
echo Have a nice bug hunt!
echo
echo
echo

420
features/cellular/UNITTESTS/stubs/ATCmdParser.cpp Normal file
View File

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

227
features/cellular/UNITTESTS/stubs/ATHandler_stub.cpp Normal file
View File

@ -0,0 +1,227 @@
/*
* 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 <ctype.h>
#include "nsapi_types.h"
#include "ATHandler.h"
#include "EventQueue.h"
#include "ATHandler_stub.h"
using namespace mbed;
using namespace events;
#include "CellularLog.h"
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;
ssize_t ATHandler_stub::ssize_value = 0;
char* ATHandler_stub::read_string_value = NULL;
size_t ATHandler_stub::size_value = 0;
size_t ATHandler_stub::return_given_size = false;
bool ATHandler_stub::bool_value = false;
uint8_t ATHandler_stub::uint8_value = 0;
FileHandle_stub *ATHandler_stub::fh_value = NULL;
device_err_t ATHandler_stub::device_err_value;
Callback<void()> ATHandler_stub::callback = NULL;
uint8_t ATHandler_stub::resp_info_true_counter = false;
ATHandler::ATHandler(FileHandle *fh, EventQueue &queue, int timeout, const char *output_delimiter) :
_nextATHandler(0),
_fileHandle(fh),
_queue(queue)
{
}
void ATHandler::enable_debug(bool enable)
{
}
ATHandler::~ATHandler()
{
}
void ATHandler::inc_ref_count()
{
}
void ATHandler::dec_ref_count()
{
}
int ATHandler::get_ref_count()
{
return ATHandler_stub::int_value;
}
FileHandle *ATHandler::get_file_handle()
{
return ATHandler_stub::fh_value;
}
void ATHandler::set_file_handle(FileHandle *fh)
{
}
void ATHandler::set_urc_handler(const char *urc, mbed::Callback<void()> cb)
{
ATHandler_stub::callback = cb;
}
nsapi_error_t ATHandler::get_last_error() const
{
if (ATHandler_stub::nsapi_error_ok_counter) {
ATHandler_stub::nsapi_error_ok_counter--;
return NSAPI_ERROR_OK;
}
return ATHandler_stub::nsapi_error_value;
}
void ATHandler::lock()
{
}
void ATHandler::unlock()
{
}
nsapi_error_t ATHandler::unlock_return_error()
{
return ATHandler_stub::nsapi_error_value;
}
void ATHandler::set_at_timeout(uint32_t timeout_milliseconds, bool default_timeout)
{
}
void ATHandler::restore_at_timeout()
{
}
void ATHandler::process_oob()
{
}
void ATHandler::clear_error()
{
}
void ATHandler::skip_param(uint32_t count) {
}
void ATHandler::skip_param(ssize_t len, uint32_t count)
{
}
ssize_t ATHandler::read_bytes(uint8_t *buf, size_t len)
{
return ATHandler_stub::ssize_value;
}
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);
}
return ATHandler_stub::ssize_value;
}
int ATHandler::read_int()
{
return ATHandler_stub::int_value;
}
void ATHandler::set_delimiter(char delimiter)
{
}
void ATHandler::set_default_delimiter()
{
}
void ATHandler::set_stop_tag(const char *stop_tag_seq)
{
}
int ATHandler::get_3gpp_error()
{
return ATHandler_stub::int_value;
}
void ATHandler::resp_start(const char *prefix, bool stop)
{
}
bool ATHandler::info_resp()
{
if (ATHandler_stub::resp_info_true_counter) {
ATHandler_stub::resp_info_true_counter--;
return true;
}
return ATHandler_stub::bool_value;
}
bool ATHandler::info_elem(char start_tag)
{
return ATHandler_stub::bool_value;
}
bool ATHandler::consume_to_stop_tag()
{
return ATHandler_stub::bool_value;
}
void ATHandler::resp_stop()
{
}
void ATHandler::cmd_start(const char* cmd)
{
}
void ATHandler::write_int(int param)
{
}
void ATHandler::write_string(const char* param, bool useQuotations)
{
}
size_t ATHandler::write_bytes(const uint8_t* param, size_t len)
{
if (ATHandler_stub::return_given_size) {
return len;
}
return ATHandler_stub::size_value;
}
void ATHandler::cmd_stop()
{
}
device_err_t ATHandler::get_last_device_error() const
{
return ATHandler_stub::device_err_value;
}
void ATHandler::flush()
{
}

41
features/cellular/UNITTESTS/stubs/ATHandler_stub.h Normal file
View File

@ -0,0 +1,41 @@
/*
* 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 "stdint.h"
#include "stdbool.h"
#include <cstddef>
#include "nsapi_types.h"
#include "ATHandler.h"
#include "FileHandle_stub.h"
#include "Callback.h"
namespace ATHandler_stub {
extern nsapi_error_t nsapi_error_value;
extern uint8_t nsapi_error_ok_counter;
extern int int_value;
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 uint8_value;
extern mbed::FileHandle_stub *fh_value;
extern mbed::device_err_t device_err_value;
extern mbed::Callback<void()> callback;
}

43
features/cellular/UNITTESTS/stubs/AT_CellularBase_stub.cpp Normal file
View File

@ -0,0 +1,43 @@
/*
* 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;
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;
}

24
features/cellular/UNITTESTS/stubs/AT_CellularBase_stub.h Normal file
View File

@ -0,0 +1,24 @@
/*
* 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;
}

91
features/cellular/UNITTESTS/stubs/AT_CellularDevice_stub.cpp Normal file
View File

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

44
features/cellular/UNITTESTS/stubs/AT_CellularInformation_stub.cpp Normal file
View File

@ -0,0 +1,44 @@
/*
* 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 0;
}
nsapi_error_t AT_CellularInformation::get_model(char *buf, size_t buf_size)
{
return 0;
}
nsapi_error_t AT_CellularInformation::get_revision(char *buf, size_t buf_size)
{
return 0;
}

35
features/cellular/UNITTESTS/stubs/AT_CellularMultiplexer_stub.cpp Normal file
View File

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

233
features/cellular/UNITTESTS/stubs/AT_CellularNetwork_stub.cpp Normal file
View File

@ -0,0 +1,233 @@
/*
* 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::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::open_data_channel()
{
return NSAPI_ERROR_OK;
}
nsapi_error_t AT_CellularNetwork::disconnect()
{
return NSAPI_ERROR_OK;
}
void AT_CellularNetwork::attach(Callback<void(nsapi_event_t, intptr_t)> 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_error_t AT_CellularNetwork::set_context_to_be_activated()
{
return NSAPI_ERROR_OK;
}
//bool AT_CellularNetwork::set_new_context(nsapi_ip_stack_t stack, int cid)
//{
// return false;
//}
//bool AT_CellularNetwork::get_context(nsapi_ip_stack_t requested_stack)
//{
// return false;
//}
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(bool urc_on)
{
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;
}
bool AT_CellularNetwork::has_registration(RegistrationType reg_type)
{
return false;
}
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::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(operator_t::RadioAccessTechnology opsAct)
{
return NSAPI_ERROR_OK;
}
nsapi_error_t AT_CellularNetwork::set_access_technology(operator_t::RadioAccessTechnology opAct)
{
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& params_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;
}

66
features/cellular/UNITTESTS/stubs/AT_CellularPower_stub.cpp Normal file
View File

@ -0,0 +1,66 @@
/*
* 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)
{
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;
}

54
features/cellular/UNITTESTS/stubs/AT_CellularSIM_stub.cpp Normal file
View File

@ -0,0 +1,54 @@
/*
* 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;
}

190
features/cellular/UNITTESTS/stubs/AT_CellularSMS_stub.cpp Normal file
View File

@ -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 <time.h>
#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<void()> 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;
}

90
features/cellular/UNITTESTS/stubs/AT_CellularStack_stub.cpp Normal file
View File

@ -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)
{
}

113
features/cellular/UNITTESTS/stubs/CellularUtil_stub.cpp Normal file
View File

@ -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 <string.h>
#include <stdlib.h>
#include <stdint.h>
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

50
features/cellular/UNITTESTS/stubs/EventQueue_stub.cpp Normal file
View File

@ -0,0 +1,50 @@
/*
* 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 "EventQueue.h"
#include "Callback.h"
using namespace mbed;
namespace events {
EventQueue::EventQueue(unsigned event_size, unsigned char *event_pointer) {
}
EventQueue::~EventQueue() {
}
void EventQueue::dispatch(int ms) {
}
void EventQueue::break_dispatch() {
}
unsigned EventQueue::tick() {
return 0;
}
void EventQueue::cancel(int id) {
}
void EventQueue::background(Callback<void(int)> update) {
}
void EventQueue::chain(EventQueue *target) {
}
}

32
features/cellular/UNITTESTS/stubs/FileHandle_stub.cpp Normal file
View File

@ -0,0 +1,32 @@
/*
* 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 "FileHandle_stub.h"
namespace mbed {
off_t FileHandle::size()
{
return 0;
}
std::FILE *fdopen(FileHandle *fh, const char *mode)
{
return NULL;
}
}

78
features/cellular/UNITTESTS/stubs/FileHandle_stub.h Normal file
View File

@ -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 __FILE_HANDLE_STUB_H__
#define __FILE_HANDLE_STUB_H__
#include "FileHandle.h"
namespace mbed {
static uint8_t filehandle_stub_short_value_counter = 0;
static char *filehandle_stub_table = NULL;
static uint8_t filehandle_stub_table_pos = 0;
class FileHandle_stub : public FileHandle
{
public:
size_t size_value;
FileHandle_stub() {size_value = 0;}
virtual ssize_t read(void *buffer, size_t size){
if (filehandle_stub_table) {
ssize_t ret = strlen(filehandle_stub_table) - filehandle_stub_table_pos;
if (size < ret) {
ret = size;
}
memcpy(buffer, filehandle_stub_table, ret);
filehandle_stub_table_pos += ret;
return ret;
}
return 0;
}
virtual ssize_t write(const void *buffer, size_t size){
if( size_value ) {
size_value--;
return size;
}
return 0;
}
virtual off_t seek(off_t offset, int whence = SEEK_SET){return 0;}
virtual int close(){}
virtual short poll(short events) const{
if (filehandle_stub_short_value_counter) {
filehandle_stub_short_value_counter--;
return short_value;
}
return 0;
}
virtual void sigio(Callback<void()> func){func();}
short short_value;
};
}
#endif

79
features/cellular/UNITTESTS/stubs/NetworkInterface_stub.cpp Normal file
View File

@ -0,0 +1,79 @@
/*
* 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 <string.h>
// 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<void(nsapi_event_t, intptr_t)> 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;
}

66
features/cellular/UNITTESTS/stubs/NetworkStack_stub.cpp Normal file
View File

@ -0,0 +1,66 @@
/*
* 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 <new>
// 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::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;
}

57
features/cellular/UNITTESTS/stubs/Semaphore_stub.cpp Normal file
View File

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

133
features/cellular/UNITTESTS/stubs/SocketAddress_stub.cpp Normal file
View File

@ -0,0 +1,133 @@
/*
* 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 <string.h>
#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)
{
}
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;
return ver;
}
nsapi_addr_t SocketAddress::get_addr() const
{
nsapi_addr_t addr;
return _addr;
}
uint16_t SocketAddress::get_port() const
{
return 0;
}
SocketAddress::operator bool() const
{
return false;
}
bool operator==(const SocketAddress &a, const SocketAddress &b)
{
return false;
}
bool operator!=(const SocketAddress &a, const SocketAddress &b)
{
return false;
}

63
features/cellular/UNITTESTS/stubs/Timer_stub.cpp Normal file
View File

@ -0,0 +1,63 @@
/*
* 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

24
features/cellular/UNITTESTS/stubs/Timer_stub.h Normal file
View File

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

104
features/cellular/UNITTESTS/stubs/equeue_stub.c Normal file
View File

@ -0,0 +1,104 @@
/*
* 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 "equeue.h"
int equeue_create(equeue_t *queue, size_t size)
{
return 0;
}
int equeue_create_inplace(equeue_t *queue, size_t size, void *buffer)
{
return 0;
}
void equeue_destroy(equeue_t *queue)
{
}
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)
{
}

24
features/cellular/UNITTESTS/stubs/mbed_assert_stub.cpp Normal file
View File

@ -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)
{
}

32
features/cellular/UNITTESTS/stubs/mbed_poll_stub.cpp Normal file
View File

@ -0,0 +1,32 @@
/*
* 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_poll.h"
#include "mbed_poll_stub.h"
int mbed_poll_stub::revents_value = POLLOUT;
int mbed_poll_stub::int_value = 0;
namespace mbed {
int poll(pollfh fhs[], unsigned nfhs, int timeout)
{
fhs->revents = mbed_poll_stub::revents_value;
return mbed_poll_stub::int_value;
}
}

27
features/cellular/UNITTESTS/stubs/mbed_poll_stub.h Normal file
View File

@ -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 <stdint.h>
namespace mbed_poll_stub {
extern int revents_value;
extern int int_value;
}
#endif

27
features/cellular/UNITTESTS/stubs/mbed_wait_api_stub.cpp Normal file
View File

@ -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 "mbed_wait_api.h"
void wait(float s) {
}
void wait_ms(int ms) {
}
void wait_us(int us) {
}

54
features/cellular/UNITTESTS/stubs/us_ticker_stub.cpp Normal file
View File

@ -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)
{
}

34
features/cellular/UNITTESTS/target_h/ATCmdParser.h Normal file
View File

@ -0,0 +1,34 @@
/*
* 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 <cstdarg>
#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__

16
features/cellular/UNITTESTS/target_h/PeripheralNames.h Normal file
View File

@ -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.
*/

27
features/cellular/UNITTESTS/target_h/PinNames.h Normal file
View File

@ -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 __PINNAMES_H__
#define __PINNAMES_H__
typedef enum {
} PinName;
#endif

16
features/cellular/UNITTESTS/target_h/arm_math.h Normal file
View File

@ -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.
*/

Some files were not shown because too many files have changed in this diff Show More