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