test_m2minterfaceimpl.cpp

00001 /*
00002  * Copyright (c) 2015 ARM Limited. All rights reserved.
00003  * SPDX-License-Identifier: Apache-2.0
00004  * Licensed under the Apache License, Version 2.0 (the License); you may
00005  * not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  * http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
00012  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 #include "CppUTest/TestHarness.h"
00017 #include "test_m2minterfaceimpl.h"
00018 #include "m2minterfaceobserver.h"
00019 #include "m2mconnectionhandler_stub.h"
00020 #include "m2msecurity_stub.h"
00021 #include "m2mnsdlinterface_stub.h"
00022 #include "m2mobject_stub.h"
00023 #include "m2mobjectinstance_stub.h"
00024 #include "m2mbase.h"
00025 
00026 entropy_cb ent_cb;
00027 
00028 class TestObserver : public M2MInterfaceObserver {
00029 
00030 public:
00031     TestObserver() : val_updated(false), error_occured(false),
00032             registered(false), unregistered(false), bootstrapped(false)
00033     {
00034     }
00035 
00036     virtual ~TestObserver(){}
00037     void bootstrap_done(M2MSecurity */*server_object*/){
00038         bootstrapped = true;
00039     }
00040 
00041     void object_registered(M2MSecurity */*security_object*/,
00042                            const M2MServer &/*server_object*/) {
00043         registered = true;
00044     }
00045 
00046     void object_unregistered(M2MSecurity */*server_object*/){
00047         unregistered = true;
00048     }
00049 
00050     void registration_updated(M2MSecurity */*security_object*/,
00051                               const M2MServer &/*server_object*/){
00052         registered = true;
00053     }
00054 
00055     void error(M2MInterface::Error /*error*/){
00056         error_occured = true;
00057     }
00058 
00059     void value_updated(M2MBase *, M2MBase::BaseType ){
00060         val_updated = true;
00061     }
00062 
00063     bool val_updated;
00064     bool error_occured;
00065     bool registered;
00066     bool unregistered;
00067     bool bootstrapped;
00068 };
00069 
00070 class M2MBaseTest : public M2MBase
00071 {
00072 public:
00073     M2MBaseTest() : M2MBase("a", M2MBase::Static, "type","a",false){}
00074 };
00075 
00076 Test_M2MInterfaceImpl::Test_M2MInterfaceImpl()
00077 {
00078     observer = new TestObserver();
00079     impl = new M2MInterfaceImpl(*observer,
00080                                 "endpoint_name",
00081                                 "endpoint_type",
00082                                 120,
00083                                 8000,
00084                                 "domain");
00085 }
00086 
00087 Test_M2MInterfaceImpl:: ~Test_M2MInterfaceImpl()
00088 {
00089     delete observer;
00090     delete impl;
00091 }
00092 
00093 void Test_M2MInterfaceImpl::test_constructor()
00094 {
00095     TestObserver obs;
00096 
00097     M2MInterfaceImpl* obj = new M2MInterfaceImpl(obs,
00098                                             "endpoint_name",
00099                                             "endpoint_type",
00100                                             120,
00101                                             8000,
00102                                             "domain",
00103                                             M2MInterface::TCP);
00104     CHECK(obj->_current_state == 0);
00105     //TODO: Check rest of variables
00106     delete obj;
00107     obj = new M2MInterfaceImpl(obs,
00108                                             "endpoint_name",
00109                                             "endpoint_type",
00110                                             120,
00111                                             8000,
00112                                             "domain",
00113                                             M2MInterface::TCP_QUEUE);
00114     delete obj;
00115 }
00116 
00117 void Test_M2MInterfaceImpl::test_bootstrap()
00118 {
00119     M2MSecurity *sec = new M2MSecurity(M2MSecurity::Bootstrap);
00120     m2msecurity_stub::int_value = 2;
00121     String *val = new String("coaps://[2001:12:12:23::23:FF]:5685");
00122 
00123     m2msecurity_stub::string_value = val;
00124     m2mnsdlinterface_stub::bool_value = true;
00125     m2mconnectionhandler_stub::bool_value = true;
00126 
00127 
00128     impl->bootstrap(NULL);
00129     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00130 
00131     impl->bootstrap(sec);
00132 
00133     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_BOOTSTRAP);
00134 
00135     delete val;
00136 
00137     val = new String("coaps://[10.45.3.83:5685");
00138 
00139     impl->_current_state = M2MInterfaceImpl::STATE_IDLE;
00140 
00141     m2msecurity_stub::string_value = val;
00142     m2mnsdlinterface_stub::bool_value = true;
00143     m2mconnectionhandler_stub::bool_value = true;
00144     impl->_security = NULL;
00145     impl->bootstrap(sec);
00146     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00147 
00148     delete val;
00149 
00150     val = new String("coaps://10.45.3.83]:5685");
00151 
00152     impl->_current_state = M2MInterfaceImpl::STATE_IDLE;
00153 
00154     m2msecurity_stub::string_value = val;
00155     m2mnsdlinterface_stub::bool_value = true;
00156     m2mconnectionhandler_stub::bool_value = true;
00157     impl->_security = NULL;
00158     impl->bootstrap(sec);
00159 
00160     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00161 
00162     delete val;
00163 
00164     val = new String("coap://10.45.3.83:5685");
00165 
00166     impl->_current_state = M2MInterfaceImpl::STATE_IDLE;
00167     impl->_security = NULL;
00168     m2msecurity_stub::string_value = val;
00169     m2mnsdlinterface_stub::bool_value = true;
00170     m2mconnectionhandler_stub::bool_value = true;
00171     impl->bootstrap(sec);
00172 
00173     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_BOOTSTRAP);
00174 
00175     delete val;
00176 
00177     val = new String("coap://10.45.3.83:5685");
00178     impl->_current_state = M2MInterfaceImpl::STATE_IDLE;
00179     m2msecurity_stub::string_value = val;
00180     m2mnsdlinterface_stub::bool_value = true;
00181     m2mconnectionhandler_stub::bool_value = true;
00182     impl->bootstrap(sec);
00183 
00184     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_BOOTSTRAP);
00185 
00186     delete val;
00187 
00188     val = new String("coap://10.45.3.83:5685");
00189     m2msecurity_stub::string_value = val;
00190     m2mconnectionhandler_stub::bool_value = true;
00191 
00192     impl->bootstrap(sec);
00193 
00194     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_BOOTSTRAP);
00195 
00196     impl->_current_state =  M2MInterfaceImpl::STATE_IDLE;
00197     m2mconnectionhandler_stub::bool_value = false;
00198 
00199     // Ignore the event.
00200     impl->_current_state =  M2MInterfaceImpl::STATE_WAITING;
00201     impl->bootstrap(sec);
00202 
00203     m2mconnectionhandler_stub::bool_value = true;
00204 
00205     impl->bootstrap(sec);
00206 
00207     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_WAITING);
00208     CHECK(observer->error_occured == true);
00209 
00210     delete val;
00211     val = NULL;
00212 
00213     delete sec;
00214 }
00215 
00216 void Test_M2MInterfaceImpl::test_cancel_bootstrap()
00217 {
00218     // Check for coverage, currently no implementation
00219     impl->cancel_bootstrap();
00220 }
00221 
00222 void Test_M2MInterfaceImpl::test_register_object()
00223 {
00224     M2MSecurity *sec = new M2MSecurity(M2MSecurity::M2MServer);
00225     m2msecurity_stub::int_value = 2;
00226 
00227     M2MObject *object = new M2MObject("test", "test");
00228     M2MObjectInstance *ins = object->create_object_instance();
00229     ins->create_dynamic_resource("test","type",M2MResourceInstance::STRING,false,false);
00230 
00231     M2MObjectList list;
00232     list.push_back(object);
00233 
00234     String *val = new String("coaps://[2001:12:12:23::23:FF]:5685");
00235     m2msecurity_stub::string_value = val;
00236     m2mnsdlinterface_stub::bool_value = true;
00237     m2mconnectionhandler_stub::bool_value = true;
00238 
00239     impl->register_object(NULL,list);
00240     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00241 
00242     impl->register_object(sec,list);
00243     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_REGISTER);
00244 
00245     impl->_current_state = M2MInterfaceImpl::STATE_IDLE;
00246     impl->register_object(sec,list);
00247     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_REGISTER);
00248 
00249     delete val;
00250     val = new String("coaps://[10.45.3.83:5685");
00251     impl->_current_state = M2MInterfaceImpl::STATE_IDLE;
00252     m2msecurity_stub::string_value = val;
00253     m2mnsdlinterface_stub::bool_value = true;
00254     m2mconnectionhandler_stub::bool_value = true;
00255 
00256     delete impl->_security;
00257     impl->_security = NULL;
00258     sec = new M2MSecurity(M2MSecurity::M2MServer);
00259     impl->register_object(sec,list);
00260 
00261     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00262     CHECK(observer->error_occured == true);
00263     observer->error_occured = false;
00264     delete val;
00265     val = new String("coaps://10.45.3.83]:5685");
00266 
00267     impl->_current_state = M2MInterfaceImpl::STATE_IDLE;
00268 
00269     m2msecurity_stub::string_value = val;
00270     m2mnsdlinterface_stub::bool_value = true;
00271     m2mconnectionhandler_stub::bool_value = true;
00272 
00273     delete impl->_security;
00274     impl->_security = NULL;
00275     sec = new M2MSecurity(M2MSecurity::M2MServer);
00276     impl->register_object(sec,list);
00277 
00278     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00279     CHECK(observer->error_occured == true);
00280 
00281     observer->error_occured = false;
00282     delete val;
00283     val = new String("coaps://10.45.3.83:5685");
00284     delete impl->_security;
00285     impl->_security = NULL;
00286     sec = new M2MSecurity(M2MSecurity::M2MServer);
00287 
00288     impl->_current_state = M2MInterfaceImpl::STATE_IDLE;
00289 
00290     m2msecurity_stub::string_value = val;
00291     m2mnsdlinterface_stub::bool_value = true;
00292     m2mconnectionhandler_stub::bool_value = true;
00293 
00294     impl->register_object(sec,list);
00295 
00296     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_REGISTER);
00297 
00298     observer->error_occured = false;
00299     delete val;
00300     val = new String("coap://10.45.3.83:5685");
00301     delete impl->_security;
00302     impl->_security = NULL;
00303     sec = new M2MSecurity(M2MSecurity::M2MServer);
00304 
00305     impl->_current_state = M2MInterfaceImpl::STATE_IDLE;
00306 
00307     m2msecurity_stub::string_value = val;
00308     m2mnsdlinterface_stub::bool_value = true;
00309     m2mconnectionhandler_stub::bool_value = true;
00310 
00311     impl->register_object(sec,list);
00312 
00313     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_REGISTER);
00314 
00315     delete val;
00316     val = new String("coap://10.45.3.83:5685");
00317     impl->register_object(sec,list);
00318     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_REGISTER);
00319 
00320 
00321     impl->_current_state =  M2MInterfaceImpl::STATE_IDLE;
00322     m2mconnectionhandler_stub::bool_value = true;
00323     m2mnsdlinterface_stub::bool_value = false;
00324 
00325     delete impl->_security;
00326     impl->_security = NULL;
00327     sec = new M2MSecurity(M2MSecurity::M2MServer);
00328     impl->register_object(sec,list);
00329 
00330     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00331     CHECK(observer->error_occured == true);
00332 
00333     impl->_current_state =  M2MInterfaceImpl::STATE_BOOTSTRAP;
00334     m2mconnectionhandler_stub::bool_value = true;
00335     m2mnsdlinterface_stub::bool_value = true;
00336 
00337     impl->register_object(sec,list);
00338 
00339     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_BOOTSTRAP);
00340     CHECK(observer->error_occured == true);
00341 
00342     impl->_current_state =  M2MInterfaceImpl::STATE_BOOTSTRAP;
00343     m2mconnectionhandler_stub::bool_value = true;
00344     m2mnsdlinterface_stub::bool_value = true;
00345 
00346     impl->register_object(sec,list);
00347 
00348     CHECK(observer->error_occured == true);
00349 
00350 
00351     delete val;
00352     val = NULL;
00353 
00354     list.clear();
00355     delete object;
00356     delete sec;
00357 }
00358 
00359 void Test_M2MInterfaceImpl::test_update_registration()
00360 {
00361     impl->_current_state = M2MInterfaceImpl::STATE_REGISTERED;
00362     m2mnsdlinterface_stub::bool_value = true;
00363     impl->update_registration(NULL,120);
00364 
00365     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_UPDATE_REGISTRATION);
00366 
00367     impl->_current_state = M2MInterfaceImpl::STATE_REGISTERED;
00368     m2mnsdlinterface_stub::bool_value = false;
00369     impl->update_registration(NULL,120);
00370 
00371     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_UPDATE_REGISTRATION);
00372 
00373     impl->_current_state = M2MInterfaceImpl::STATE_IDLE;
00374     impl->update_registration(NULL,120);
00375 
00376     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00377     CHECK(observer->error_occured == true);
00378 
00379     impl->_current_state = M2MInterfaceImpl::STATE_BOOTSTRAP;
00380     impl->update_registration(NULL,120);
00381 
00382     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_BOOTSTRAP);
00383     CHECK(observer->error_occured == true);
00384 
00385     impl->update_registration(NULL,30);
00386     CHECK(observer->error_occured == true);
00387 
00388     impl->update_registration(NULL,120);
00389     CHECK(observer->error_occured == true);
00390 
00391 
00392     M2MObject *object = new M2MObject("test", "test");
00393     M2MObjectInstance *ins = object->create_object_instance();
00394     ins->create_dynamic_resource("test","type",M2MResourceInstance::STRING,false,false);
00395 
00396     M2MObjectList list;
00397     list.push_back(object);
00398     impl->_current_state = M2MInterfaceImpl::STATE_REGISTERED;
00399     m2mnsdlinterface_stub::bool_value = false;
00400     impl->update_registration(NULL, list);
00401 
00402     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_UPDATE_REGISTRATION);
00403     list.clear();
00404 
00405     impl->_current_state = M2MInterfaceImpl::STATE_REGISTERED;
00406     m2mnsdlinterface_stub::bool_value = false;
00407     impl->update_registration(NULL, list);
00408 
00409     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_UPDATE_REGISTRATION);
00410     delete object;
00411 
00412 }
00413 
00414 void Test_M2MInterfaceImpl::test_unregister_object()
00415 {
00416     impl->_current_state = M2MInterfaceImpl::STATE_REGISTERED;
00417     m2mnsdlinterface_stub::bool_value = true;
00418 
00419     impl->unregister_object(NULL);
00420 
00421     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_WAITING);
00422 
00423     impl->_current_state = M2MInterfaceImpl::STATE_REGISTERED;
00424     m2mnsdlinterface_stub::bool_value = false;
00425 
00426     impl->unregister_object(NULL);
00427 
00428     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00429     CHECK(observer->error_occured == true);
00430 
00431     impl->_current_state = M2MInterfaceImpl::STATE_IDLE;
00432 
00433     impl->unregister_object(NULL);
00434     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00435     CHECK(observer->error_occured == true);
00436 }
00437 
00438 void Test_M2MInterfaceImpl::test_set_queue_sleep_handler()
00439 {
00440     callback_handler cb(this,&Test_M2MInterfaceImpl::test_callback_handler);
00441     impl->set_queue_sleep_handler(cb);
00442     CHECK(impl->_callback_handler != NULL);
00443 
00444     callback_handler cb1(NULL);
00445     impl->set_queue_sleep_handler(cb1);
00446     CHECK(impl->_callback_handler == NULL);
00447 }
00448 
00449 
00450 void Test_M2MInterfaceImpl::test_set_random_number_callback()
00451 {
00452     random_number_cb cb(&test_random_callback);
00453     impl->set_random_number_callback(cb);
00454 }
00455 
00456 void Test_M2MInterfaceImpl::test_set_entropy_callback()
00457 {
00458     impl->set_entropy_callback(ent_cb);
00459 }
00460 
00461 void Test_M2MInterfaceImpl::test_set_platform_network_handler()
00462 {
00463     void *test = NULL;
00464     impl->set_platform_network_handler(test);
00465 }
00466 
00467 void Test_M2MInterfaceImpl::test_coap_message_ready()
00468 {
00469     m2mconnectionhandler_stub::bool_value = true;
00470     uint8_t *data_ptr = (uint8_t *)malloc(sizeof(uint8_t));
00471     uint16_t data_len = sizeof(uint8_t);
00472     sn_nsdl_addr_s *address_ptr = (sn_nsdl_addr_s*)malloc(sizeof(sn_nsdl_addr_s));
00473 
00474     impl->coap_message_ready(data_ptr,data_len,address_ptr);
00475     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00476 
00477     impl->_current_state = M2MInterfaceImpl::STATE_WAITING;
00478     impl->coap_message_ready(data_ptr,data_len,address_ptr);
00479     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_WAITING);
00480 
00481     m2mconnectionhandler_stub::bool_value = false;
00482     impl->coap_message_ready(data_ptr,data_len,address_ptr);
00483 
00484     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00485     CHECK(observer->error_occured == true);
00486 
00487     free(address_ptr);
00488     free(data_ptr);
00489 }
00490 
00491 void Test_M2MInterfaceImpl::test_client_registered()
00492 {
00493     impl->client_registered(NULL);
00494 
00495     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_REGISTERED);
00496     CHECK(observer->registered == true);
00497 }
00498 
00499 void Test_M2MInterfaceImpl::test_registration_updated()
00500 {
00501     M2MServer *server = NULL;
00502     impl->registration_updated(*server);
00503 
00504     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_REGISTERED);
00505     CHECK(observer->registered == true);
00506 }
00507 
00508 void Test_M2MInterfaceImpl::test_registration_error()
00509 {
00510     impl->registration_error(1);
00511     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00512     CHECK(observer->error_occured == true);
00513 
00514     observer->error_occured = false;
00515     impl->registration_error(1, true);
00516     CHECK(observer->error_occured == false);
00517 }
00518 
00519 void Test_M2MInterfaceImpl::test_client_unregistered()
00520 {
00521     impl->client_unregistered();
00522 
00523     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00524     CHECK(observer->unregistered == true);
00525 }
00526 
00527 void Test_M2MInterfaceImpl::test_bootstrap_wait()
00528 {
00529     M2MSecurity *sec = new M2MSecurity(M2MSecurity::M2MServer);
00530     impl->bootstrap_wait(sec);
00531 
00532     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_BOOTSTRAP_WAIT);
00533     CHECK(impl->_security == sec);
00534     CHECK(observer->bootstrapped == false);
00535 
00536     delete sec;
00537 }
00538 
00539 
00540 void Test_M2MInterfaceImpl::test_bootstrap_done()
00541 {
00542     M2MSecurity *sec = new M2MSecurity(M2MSecurity::M2MServer);
00543     impl->bootstrap_done(sec);
00544 
00545     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_BOOTSTRAPPED);
00546     CHECK(observer->bootstrapped == true);
00547 
00548     delete sec;
00549 }
00550 
00551 void Test_M2MInterfaceImpl::test_bootstrap_error()
00552 {
00553     impl->bootstrap_error();
00554 
00555     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00556     CHECK(observer->error_occured == true);
00557 }
00558 
00559 void Test_M2MInterfaceImpl::test_coap_data_processed()
00560 {
00561     impl->coap_data_processed();
00562     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_WAITING);
00563 }
00564 
00565 void Test_M2MInterfaceImpl::test_value_updated()
00566 {
00567     impl->value_updated(NULL);
00568     CHECK(observer->val_updated == false);
00569 
00570     M2MBaseTest b;
00571     impl->value_updated(&b);
00572     CHECK(observer->val_updated == true);
00573 }
00574 
00575 void Test_M2MInterfaceImpl::test_data_available()
00576 {
00577     uint8_t* data = (uint8_t*)malloc(sizeof(uint8_t));
00578     uint16_t data_size = sizeof(uint8_t);
00579     M2MConnectionObserver::SocketAddress *address = (M2MConnectionObserver::SocketAddress*)
00580                                                     malloc(sizeof(M2MConnectionObserver::SocketAddress));
00581 
00582     address->_stack = M2MInterface::LwIP_IPv4;
00583     m2mnsdlinterface_stub::bool_value = true;
00584 
00585     impl->data_available(data,data_size,*address);
00586 
00587     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_WAITING);
00588 
00589     address->_stack = M2MInterface::LwIP_IPv6;
00590     m2mnsdlinterface_stub::bool_value = true;
00591 
00592     impl->data_available(data,data_size,*address);
00593 
00594     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_WAITING);
00595 
00596     address->_stack = M2MInterface::LwIP_IPv4;
00597     m2mnsdlinterface_stub::bool_value = false;
00598 
00599     impl->data_available(data,data_size,*address);
00600 
00601     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_WAITING);
00602     CHECK(observer->error_occured == true);
00603 
00604     free(data);
00605     free(address);
00606 }
00607 
00608 void Test_M2MInterfaceImpl::test_socket_error()
00609 {
00610     for (int i = 0; i <= MBED_CLIENT_RECONNECTION_COUNT; i++) {
00611         impl->socket_error(M2MConnectionHandler::SSL_CONNECTION_ERROR);
00612         impl->_retry_timer_expired = true;
00613     }
00614     CHECK(observer->error_occured == true);
00615 
00616     observer->error_occured = false;
00617     impl->socket_error(M2MConnectionHandler::SOCKET_READ_ERROR, false);
00618     CHECK(observer->error_occured == true);
00619     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00620 
00621     observer->error_occured = false;
00622     impl->socket_error(M2MConnectionHandler::DNS_RESOLVING_ERROR, false);
00623     CHECK(observer->error_occured == true);
00624     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00625 
00626     observer->error_occured = false;
00627     impl->socket_error(M2MConnectionHandler::SOCKET_SEND_ERROR, false);
00628     CHECK(observer->error_occured == true);
00629     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00630 
00631     observer->error_occured = false;
00632     impl->socket_error(M2MConnectionHandler::SSL_HANDSHAKE_ERROR, false);
00633     CHECK(observer->error_occured == true);
00634     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00635 
00636     observer->error_occured = false;
00637     impl->socket_error(M2MConnectionHandler::SOCKET_ABORT, false);
00638     CHECK(observer->error_occured == true);
00639     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00640 
00641     observer->error_occured = false;
00642     impl->socket_error(M2MConnectionHandler::ERROR_NONE, false);
00643     CHECK(observer->error_occured == false);
00644     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00645 }
00646 
00647 void Test_M2MInterfaceImpl::test_address_ready()
00648 {
00649     M2MConnectionObserver::SocketAddress *address =
00650         (M2MConnectionObserver::SocketAddress*) malloc(sizeof(M2MConnectionObserver::SocketAddress));
00651     M2MConnectionObserver::ServerType server_type = M2MConnectionObserver::Bootstrap;
00652     uint16_t server_port = 5685;
00653 
00654     address->_stack = M2MInterface::LwIP_IPv6;
00655     m2mnsdlinterface_stub::bool_value = true;
00656 
00657     impl->address_ready(*address,server_type,server_port);
00658     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_BOOTSTRAP_RESOURCE_CREATED);
00659 
00660     address->_stack = M2MInterface::LwIP_IPv4;
00661     m2mnsdlinterface_stub::bool_value = true;
00662 
00663     impl->address_ready(*address,server_type,server_port);
00664     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_BOOTSTRAP_RESOURCE_CREATED);
00665 
00666 
00667     address->_stack = M2MInterface::LwIP_IPv6;
00668     m2mnsdlinterface_stub::bool_value = false;
00669 
00670     impl->address_ready(*address,server_type,server_port);
00671     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00672     CHECK(observer->error_occured == true);
00673 
00674     // Test for Address resolving for LWM2M server
00675     server_type = M2MConnectionObserver::LWM2MServer;
00676 
00677     address->_stack = M2MInterface::LwIP_IPv4;
00678     m2mnsdlinterface_stub::bool_value = true;
00679 
00680     impl->address_ready(*address,server_type,server_port);
00681     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_REGISTER_ADDRESS_RESOLVED);
00682 
00683     impl->address_ready(*address,server_type,server_port);
00684     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_REGISTER_ADDRESS_RESOLVED);
00685 
00686     address->_stack = M2MInterface::LwIP_IPv6;
00687     m2mnsdlinterface_stub::bool_value = false;
00688 
00689     impl->address_ready(*address,server_type,server_port);
00690     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE);
00691     CHECK(observer->error_occured == true);
00692 
00693     free(address);
00694 }
00695 
00696 void Test_M2MInterfaceImpl::test_data_sent()
00697 {
00698     m2mconnectionhandler_stub::bool_value = true;
00699 
00700     impl->data_sent();
00701 
00702     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_WAITING);
00703 
00704     m2mconnectionhandler_stub::bool_value = false;
00705 
00706     impl->data_sent();
00707 
00708     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_WAITING);
00709     CHECK(observer->error_occured == false);
00710 
00711     impl->_callback_handler = callback_handler(this, &Test_M2MInterfaceImpl::test_callback_handler);
00712 
00713     m2mconnectionhandler_stub::bool_value = true;
00714 
00715     impl->_binding_mode = M2MInterface::UDP_QUEUE;
00716     impl->data_sent();
00717     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_WAITING);
00718 
00719     impl->_binding_mode = M2MInterface::TCP_QUEUE;
00720     impl->data_sent();
00721     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_WAITING);
00722 
00723     impl->_binding_mode = M2MInterface::SMS_QUEUE;
00724     impl->data_sent();
00725     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_WAITING);
00726 
00727     impl->_binding_mode = M2MInterface::UDP_SMS_QUEUE;
00728     impl->data_sent();
00729     CHECK(impl->_current_state == M2MInterfaceImpl::STATE_WAITING);
00730 }
00731 
00732 void Test_M2MInterfaceImpl::test_timer_expired()
00733 {
00734     visited = false;
00735     impl->_callback_handler = NULL;
00736     impl->timer_expired(M2MTimerObserver::QueueSleep);
00737     CHECK(visited == false);
00738 
00739     impl->_callback_handler = callback_handler(this, &Test_M2MInterfaceImpl::test_callback_handler);
00740 
00741     visited = false;
00742     impl->timer_expired(M2MTimerObserver::QueueSleep);
00743     CHECK(visited == true);
00744     visited = false;
00745 
00746     impl->_bootstrapped = true;
00747     impl->timer_expired(M2MTimerObserver::RetryTimer);
00748     CHECK(impl->_retry_timer_expired == true);
00749 
00750     impl->_bootstrapped = false;
00751     impl->timer_expired(M2MTimerObserver::RetryTimer);
00752     CHECK(impl->_retry_timer_expired == true);
00753 
00754     observer->error_occured = false;
00755     impl->timer_expired(M2MTimerObserver::BootstrapTimer);
00756     CHECK(observer->error_occured == true);
00757 }
00758 
00759 void Test_M2MInterfaceImpl::test_callback_handler()
00760 {
00761     visited = true;
00762 }
00763 
00764 uint32_t test_random_callback(void)
00765 {
00766     return 1;
00767 }