test_m2mnsdlinterface.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_m2mnsdlinterface.h"
00018 #include "common_stub.h"
00019 #include "m2msecurity_stub.h"
00020 #include "m2mnsdlobserver.h"
00021 #include "m2mobject_stub.h"
00022 #include "m2mobjectinstance_stub.h"
00023 #include "m2mresource_stub.h"
00024 #include "m2mresourceinstance_stub.h"
00025 #include "m2mresource.h"
00026 #include "m2mbase_stub.h"
00027 #include "m2mserver.h"
00028 #include "m2msecurity.h"
00029 #include "m2mtlvdeserializer_stub.h"
00030 class TestObserver : public M2MNsdlObserver {
00031 
00032 public:
00033     TestObserver(){}
00034     virtual ~TestObserver(){}
00035     void coap_message_ready(uint8_t *,
00036                             uint16_t,
00037                             sn_nsdl_addr_s *){
00038         message_ready = true;
00039     }
00040 
00041     void client_registered(M2MServer *){
00042         registered = true;
00043     }
00044 
00045     void registration_updated(const M2MServer &){
00046         register_updated = true;
00047     }
00048 
00049     void registration_error(uint8_t, bool retry = false){
00050         register_error = true;
00051     }
00052 
00053     void client_unregistered(){
00054         unregistered = true;
00055     }
00056 
00057     void bootstrap_done(M2MSecurity *sec){
00058         if(sec) {
00059             boot_done = true;
00060             delete sec;
00061             sec = NULL;
00062         }
00063     }
00064 
00065     void bootstrap_error(){
00066         boot_error = true;
00067     }
00068 
00069     void coap_data_processed(){
00070         data_processed = true;
00071     }
00072 
00073     void value_updated(M2MBase *){
00074         value_update = true;
00075     }
00076 
00077     bool register_error;
00078     bool boot_error;
00079     bool boot_done;
00080     bool registered;
00081     bool register_updated;
00082     bool data_processed;
00083     bool unregistered;
00084     bool message_ready;
00085     bool value_update;
00086 };
00087 
00088 struct nsdl_s {
00089     struct grs_s *grs;
00090 
00091     uint8_t *oma_bs_address_ptr;                                                /* Bootstrap address pointer. If null, no bootstrap in use */
00092     uint8_t oma_bs_address_len;                                                 /* Bootstrap address length */
00093     uint16_t oma_bs_port;                                                       /* Bootstrap port */
00094     void (*sn_nsdl_oma_bs_done_cb)(sn_nsdl_oma_server_info_t *server_info_ptr); /* Callback to inform application when bootstrap is done */
00095     sn_nsdl_ep_parameters_s *ep_information_ptr;    // Endpoint parameters, Name, Domain etc..
00096     sn_nsdl_oma_server_info_t *nsp_address_ptr;     // NSP server address information
00097     uint8_t sn_nsdl_endpoint_registered;
00098 
00099     uint16_t register_msg_id;
00100     uint16_t unregister_msg_id;
00101 
00102     void *(*sn_nsdl_alloc)(uint16_t);
00103     void (*sn_nsdl_free)(void *);
00104     uint8_t (*sn_nsdl_tx_callback)(struct nsdl_s *, sn_nsdl_capab_e , uint8_t *, uint16_t, sn_nsdl_addr_s *);
00105     uint8_t (*sn_nsdl_rx_callback)(struct nsdl_s *, sn_coap_hdr_s *, sn_nsdl_addr_s *);
00106     void (*sn_nsdl_oma_bs_done_cb_handle)(sn_nsdl_oma_server_info_t *server_info_ptr,
00107                                           struct nsdl_s *handle); /* Callback to inform application when bootstrap is done with nsdl handle */
00108     uint16_t update_register_msg_id;
00109     uint16_t register_msg_len;
00110     uint16_t update_register_msg_len;
00111     uint16_t bootstrap_msg_id;
00112     bool handle_bootstrap_msg;
00113 };
00114 
00115 Test_M2MNsdlInterface::Test_M2MNsdlInterface()
00116 {
00117     observer = new TestObserver();
00118     nsdl = new M2MNsdlInterface(*observer);
00119     //nsdl->_server = new M2MServer();
00120 }
00121 
00122 Test_M2MNsdlInterface:: ~Test_M2MNsdlInterface()
00123 {
00124     delete nsdl;
00125     nsdl = NULL;
00126     delete observer;
00127     observer = NULL;
00128 }
00129 
00130 void Test_M2MNsdlInterface::test_create_endpoint()
00131 {
00132     u_int8_t value[]  = {"120"};
00133     if( nsdl->_endpoint == NULL){
00134         nsdl->_endpoint = (sn_nsdl_ep_parameters_s*)nsdl->memory_alloc(sizeof(sn_nsdl_ep_parameters_s));
00135     }
00136 
00137     nsdl->create_endpoint("name", "type",120,"domain",100,"context");
00138     CHECK(nsdl->_endpoint->lifetime_len == 3);
00139     CHECK(*nsdl->_endpoint->lifetime_ptr == *value);
00140 }
00141 
00142 void Test_M2MNsdlInterface::test_delete_endpoint()
00143 {
00144     if( nsdl->_endpoint == NULL){
00145         nsdl->_endpoint = (sn_nsdl_ep_parameters_s*)nsdl->memory_alloc(sizeof(sn_nsdl_ep_parameters_s));
00146     }
00147     nsdl->_endpoint->lifetime_ptr = (uint8_t*)malloc(sizeof(uint8_t));
00148 
00149     nsdl->delete_endpoint();
00150     CHECK(nsdl->_endpoint == NULL);
00151 }
00152 
00153 void Test_M2MNsdlInterface::test_create_nsdl_list_structure()
00154 {
00155     String *name = new String("name");
00156     common_stub::int_value = 0;
00157     m2mbase_stub::int_value = 0;
00158     M2MObject *object = new M2MObject(*name);
00159     M2MObjectInstance* instance = new M2MObjectInstance(*name,*object);
00160 
00161     M2MResource* create_resource = new M2MResource(*instance,
00162                                                    *name,
00163                                                    *name,
00164                                                    M2MResourceInstance::INTEGER,
00165                                                    M2MResource::Dynamic,
00166                                                    false);
00167 
00168     M2MResourceInstance* res_instance = new M2MResourceInstance(*name,
00169                                                                 *name,
00170                                                                 M2MResourceInstance::INTEGER,
00171                                                                 *instance);
00172 
00173     m2mobject_stub::instance_list.clear();
00174     m2mobject_stub::instance_list.push_back(instance);
00175 
00176     m2mobjectinstance_stub::resource_list.clear();
00177     m2mobjectinstance_stub::resource_list.push_back(create_resource);
00178 
00179     M2MObjectList list;
00180     list.push_back(object);
00181 
00182     m2mbase_stub::string_value = name;
00183     m2mbase_stub::mode_value = M2MBase::Static;
00184 
00185     CHECK(nsdl->create_nsdl_list_structure(list)== true);
00186 
00187     m2mresource_stub::bool_value = true;
00188     m2mbase_stub::mode_value = M2MBase::Dynamic;
00189 
00190     m2mresource_stub::list.push_back(res_instance);
00191 
00192     CHECK(nsdl->create_nsdl_list_structure(list)== true);
00193 
00194     nsdl->_resource->path = ((uint8_t*)nsdl->memory_alloc(3));
00195     m2mbase_stub::mode_value = M2MBase::Directory;
00196     CHECK(nsdl->create_nsdl_list_structure(list)== true);
00197 
00198     list.clear();
00199     delete object;
00200     delete name;
00201     name = NULL;
00202     m2mobject_stub::instance_list.clear();
00203     delete instance;
00204     instance = NULL;
00205     m2mobjectinstance_stub::resource_list.clear();
00206     delete create_resource;
00207     create_resource = NULL;
00208 
00209     m2mresource_stub::list.clear();
00210     delete res_instance;
00211     res_instance = NULL;
00212 }
00213 
00214 void Test_M2MNsdlInterface::test_delete_nsdl_resource()
00215 {
00216     common_stub::int_value = -1;
00217 
00218     CHECK(nsdl->delete_nsdl_resource("name") == false);
00219 
00220     common_stub::int_value = 0;
00221 
00222     CHECK(nsdl->delete_nsdl_resource("name") == true);
00223 }
00224 
00225 void Test_M2MNsdlInterface::test_create_bootstrap_resource()
00226 {
00227     common_stub::uint_value = 11;
00228     CHECK(nsdl->create_bootstrap_resource(NULL, "") == true);
00229 
00230     common_stub::uint_value = 0;
00231     CHECK(nsdl->create_bootstrap_resource(NULL, "") == false);
00232 }
00233 
00234 void Test_M2MNsdlInterface::test_send_register_message()
00235 {
00236     common_stub::uint_value = 12;
00237     CHECK(nsdl->send_register_message(NULL,100,SN_NSDL_ADDRESS_TYPE_IPV6) == true);
00238 
00239     common_stub::uint_value = 0;
00240     CHECK(nsdl->send_register_message(NULL,100,SN_NSDL_ADDRESS_TYPE_IPV6) == false);
00241 }
00242 
00243 void Test_M2MNsdlInterface::test_send_update_registration()
00244 {
00245     common_stub::uint_value = 23;
00246     nsdl->_nsdl_handle = (nsdl_s*)malloc(sizeof(1));
00247     CHECK(nsdl->send_update_registration(120) == true);
00248 
00249     /* Update already in progress */
00250     common_stub::uint_value = 0;
00251     CHECK(nsdl->send_update_registration(120) == true);
00252 
00253     /* Update lifetime value */
00254     nsdl->_update_register_ongoing = false;
00255     common_stub::uint_value = 1;
00256     CHECK(nsdl->send_update_registration(100) == true);
00257 
00258     /* Lifetime value is 0, don't change the existing lifetime value */
00259     nsdl->_update_register_ongoing = false;
00260     common_stub::uint_value = 1;
00261     CHECK(nsdl->send_update_registration(0) == true);
00262 
00263     free(nsdl->_nsdl_handle);
00264 }
00265 
00266 void Test_M2MNsdlInterface::test_send_unregister_message()
00267 {
00268     common_stub::uint_value = 22;
00269     CHECK(nsdl->send_unregister_message() == true);
00270 
00271     /* Unreg already in progress */
00272     common_stub::uint_value = 0;
00273     CHECK(nsdl->send_unregister_message() == true);
00274 }
00275 
00276 void Test_M2MNsdlInterface::test_memory_alloc()
00277 {
00278     CHECK(nsdl->memory_alloc(0) == 0);
00279     uint8_t *ptr = 0;
00280     ptr = (uint8_t*)nsdl->memory_alloc(sizeof(uint8_t));
00281     CHECK(ptr != NULL);
00282     nsdl->memory_free(ptr);
00283 }
00284 
00285 void Test_M2MNsdlInterface::test_memory_free()
00286 {
00287     uint8_t *ptr = (uint8_t*)nsdl->memory_alloc(sizeof(uint8_t));
00288     nsdl->memory_free((void*)ptr);
00289     //memory leak test will fail, if there is a leak, so no need for CHECK
00290 }
00291 
00292 void Test_M2MNsdlInterface::test_send_to_server_callback()
00293 {
00294   uint8_t *data_ptr = (uint8_t*)malloc(sizeof(uint8_t));
00295   uint16_t data_len = sizeof(uint8_t);
00296   sn_nsdl_addr_s *address = (sn_nsdl_addr_s *)malloc(sizeof(sn_nsdl_addr_s));
00297 
00298   nsdl->send_to_server_callback(NULL, SN_NSDL_PROTOCOL_COAP, data_ptr,data_len,address);
00299   CHECK(observer->message_ready == true);
00300 
00301   free(data_ptr);
00302   free(address);
00303 }
00304 
00305 void Test_M2MNsdlInterface::test_received_from_server_callback()
00306 {
00307     nsdl_s* handle = (nsdl_s*)malloc(sizeof(nsdl_s));
00308     memset(handle,0,sizeof(nsdl_s));
00309 
00310     sn_coap_hdr_s *coap_header = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00311     memset(coap_header, 0, sizeof(sn_coap_hdr_s));
00312     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
00313 
00314 
00315     coap_header->options_list_ptr = (sn_coap_options_list_s *)malloc(sizeof(sn_coap_options_list_s));
00316     memset(coap_header->options_list_ptr, 0, sizeof(sn_coap_options_list_s));
00317 
00318     coap_header->options_list_ptr->max_age_len = 2;
00319     coap_header->options_list_ptr->max_age_ptr = (uint8_t *)malloc(sizeof(coap_header->options_list_ptr->max_age_len));
00320     memset(coap_header->options_list_ptr->max_age_ptr, 0, sizeof(coap_header->options_list_ptr->max_age_len));
00321 
00322     coap_header->options_list_ptr->location_path_len = 2;
00323     coap_header->options_list_ptr->location_path_ptr = (uint8_t *)malloc(sizeof(coap_header->options_list_ptr->location_path_len));
00324     memset(coap_header->options_list_ptr->location_path_ptr, 0, sizeof(coap_header->options_list_ptr->location_path_len));
00325 
00326     observer->data_processed = false;
00327     observer->registered = false;
00328     nsdl->received_from_server_callback(handle,coap_header,NULL);
00329     CHECK(observer->data_processed == true);
00330     CHECK(observer->registered == true);
00331 
00332     free(nsdl->_endpoint->lifetime_ptr);
00333     nsdl->_endpoint->lifetime_ptr = NULL;
00334 
00335     free(nsdl->_endpoint->location_ptr);
00336     nsdl->_endpoint->location_ptr = NULL;
00337 
00338     uint8_t life1[] = {"120"};
00339     nsdl->_endpoint->lifetime_ptr = (uint8_t*)malloc(sizeof(life1));
00340     memcpy(nsdl->_endpoint->lifetime_ptr,life1,sizeof(life1));
00341     nsdl->_endpoint->lifetime_len = (uint8_t)sizeof(life1);
00342 
00343     observer->data_processed = false;
00344     observer->registered = false;
00345     nsdl->received_from_server_callback(handle,coap_header,NULL);
00346     CHECK(observer->data_processed == true);
00347     CHECK(observer->registered == true);
00348 
00349     free(coap_header->options_list_ptr->max_age_ptr);
00350     coap_header->options_list_ptr->max_age_ptr = NULL;
00351 
00352     free(coap_header->options_list_ptr->location_path_ptr);
00353     coap_header->options_list_ptr->location_path_ptr = NULL;
00354 
00355     free(coap_header->options_list_ptr);
00356     coap_header->options_list_ptr = NULL;
00357 
00358     free(nsdl->_endpoint->lifetime_ptr);
00359     nsdl->_endpoint->lifetime_ptr = NULL;
00360 
00361     uint8_t life[] = {"120"};
00362     nsdl->_endpoint->lifetime_ptr = (uint8_t*)malloc(sizeof(life));
00363     memcpy(nsdl->_endpoint->lifetime_ptr,life,sizeof(life));
00364     nsdl->_endpoint->lifetime_len = (uint8_t)sizeof(life);
00365 
00366     observer->data_processed = false;
00367     observer->registered = false;
00368 
00369     nsdl->received_from_server_callback(handle,coap_header,NULL);
00370     CHECK(observer->data_processed == true);
00371     CHECK(observer->registered == true);
00372     free(nsdl->_endpoint->lifetime_ptr);
00373     nsdl->_endpoint->lifetime_ptr = NULL;
00374 
00375     uint8_t big_life[] = {"4000"};
00376     nsdl->_endpoint->lifetime_ptr = (uint8_t*)malloc(sizeof(big_life));
00377     memcpy(nsdl->_endpoint->lifetime_ptr,big_life,sizeof(big_life));
00378     nsdl->_endpoint->lifetime_len = (uint8_t)sizeof(big_life);
00379     observer->data_processed = false;
00380     observer->registered = false;
00381     nsdl->received_from_server_callback(handle,coap_header,NULL);
00382     CHECK(observer->data_processed == true);
00383     CHECK(observer->registered == true);
00384 
00385     free(nsdl->_endpoint->lifetime_ptr);
00386     nsdl->_endpoint->lifetime_ptr = NULL;
00387 
00388     observer->data_processed = false;
00389     observer->registered = false;
00390 
00391     uint8_t less_life[] = {"30"};
00392     nsdl->_endpoint->lifetime_ptr = (uint8_t*)malloc(sizeof(less_life));
00393     memcpy(nsdl->_endpoint->lifetime_ptr,less_life,sizeof(less_life));
00394     nsdl->_endpoint->lifetime_len = (uint8_t)sizeof(less_life);
00395 
00396     nsdl->received_from_server_callback(handle,coap_header,NULL);
00397     CHECK(observer->data_processed == true);
00398     CHECK(observer->registered == true);
00399 
00400     observer->data_processed = false;
00401     observer->registered = false;
00402     observer->unregistered = false;
00403     observer->register_error = false;
00404 
00405     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST;
00406     nsdl->received_from_server_callback(handle,coap_header,NULL);
00407     CHECK(observer->data_processed == true);
00408     CHECK(observer->register_error == true);
00409 
00410     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_BAD_OPTION;
00411     nsdl->received_from_server_callback(handle,coap_header,NULL);
00412     CHECK(observer->data_processed == true);
00413     CHECK(observer->register_error == true);
00414 
00415     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_REQUEST_ENTITY_INCOMPLETE;
00416     nsdl->received_from_server_callback(handle,coap_header,NULL);
00417     CHECK(observer->data_processed == true);
00418     CHECK(observer->register_error == true);
00419 
00420     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_PRECONDITION_FAILED;
00421     nsdl->received_from_server_callback(handle,coap_header,NULL);
00422     CHECK(observer->data_processed == true);
00423     CHECK(observer->register_error == true);
00424 
00425     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_REQUEST_ENTITY_TOO_LARGE;
00426     nsdl->received_from_server_callback(handle,coap_header,NULL);
00427     CHECK(observer->data_processed == true);
00428     CHECK(observer->register_error == true);
00429 
00430     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_UNSUPPORTED_CONTENT_FORMAT;
00431     nsdl->received_from_server_callback(handle,coap_header,NULL);
00432     CHECK(observer->data_processed == true);
00433     CHECK(observer->register_error == true);
00434 
00435     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_UNAUTHORIZED;
00436     nsdl->received_from_server_callback(handle,coap_header,NULL);
00437     CHECK(observer->data_processed == true);
00438     CHECK(observer->register_error == true);
00439 
00440     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_FORBIDDEN;
00441     nsdl->received_from_server_callback(handle,coap_header,NULL);
00442     CHECK(observer->data_processed == true);
00443     CHECK(observer->register_error == true);
00444 
00445     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_NOT_FOUND;
00446     nsdl->received_from_server_callback(handle,coap_header,NULL);
00447     CHECK(observer->data_processed == true);
00448     CHECK(observer->register_error == true);
00449 
00450     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED;
00451     nsdl->received_from_server_callback(handle,coap_header,NULL);
00452     CHECK(observer->data_processed == true);
00453     CHECK(observer->register_error == true);
00454 
00455     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_BAD_GATEWAY;
00456     coap_header->coap_status = COAP_STATUS_BUILDER_MESSAGE_SENDING_FAILED;
00457     nsdl->received_from_server_callback(handle,coap_header,NULL);
00458     CHECK(observer->data_processed == true);
00459     CHECK(observer->register_error == true);
00460 
00461 
00462     coap_header->msg_id = 8;
00463     handle->unregister_msg_id = 8;
00464 
00465     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_DELETED;
00466     observer->register_error = false;
00467     nsdl->received_from_server_callback(handle,coap_header,NULL);
00468     CHECK(observer->unregistered == true);
00469 
00470     observer->register_error = false;
00471     handle->unregister_msg_id = 8;
00472     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
00473 
00474     nsdl->received_from_server_callback(handle,coap_header,NULL);
00475     CHECK(observer->register_error == true);
00476 
00477     observer->register_error = false;
00478     handle->unregister_msg_id = 8;
00479     coap_header->coap_status = COAP_STATUS_BUILDER_MESSAGE_SENDING_FAILED;
00480     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST;
00481     nsdl->received_from_server_callback(handle,coap_header,NULL);
00482     CHECK(observer->register_error == true);
00483 
00484     observer->register_error = false;
00485     handle->unregister_msg_id = 8;
00486     coap_header->coap_status = COAP_STATUS_PARSER_ERROR_IN_HEADER;
00487     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED;
00488     nsdl->received_from_server_callback(handle,coap_header,NULL);
00489     CHECK(observer->register_error == true);
00490 
00491     observer->register_error = false;
00492     handle->unregister_msg_id = 8;
00493     coap_header->coap_status = COAP_STATUS_PARSER_ERROR_IN_HEADER;
00494     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_GATEWAY_TIMEOUT;
00495     nsdl->received_from_server_callback(handle,coap_header,NULL);
00496     CHECK(observer->register_error == true);
00497 
00498     handle->unregister_msg_id = 0;
00499     observer->boot_error = false;
00500     nsdl->_bootstrap_id = 8;
00501     handle->bootstrap_msg_id = 8;
00502     coap_header->coap_status = COAP_STATUS_BUILDER_MESSAGE_SENDING_FAILED;
00503     nsdl->received_from_server_callback(handle,coap_header,NULL);
00504     CHECK(observer->boot_error == true);
00505 
00506     //_update_id == msg_id
00507     handle->update_register_msg_id = 10;
00508     coap_header->msg_id = 10;
00509     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_CHANGED;
00510     nsdl->received_from_server_callback(handle,coap_header,NULL);
00511     CHECK(nsdl->_update_register_ongoing == false);
00512     CHECK(observer->register_updated == true);
00513 
00514     coap_header->msg_id = 10;
00515     coap_header->msg_code = COAP_MSG_CODE_RESPONSE_FORBIDDEN;
00516     coap_header->coap_status = COAP_STATUS_OK;
00517     nsdl->received_from_server_callback(handle,coap_header,NULL);
00518     CHECK(nsdl->_register_ongoing == true);
00519     CHECK(observer->register_error == true);
00520 
00521     coap_header->msg_id = 11;
00522     CHECK( 0== nsdl->received_from_server_callback(handle,coap_header,NULL) );
00523 
00524     handle->update_register_msg_id = 0;
00525     handle->register_msg_id = 0;
00526     handle->unregister_msg_id = 0;
00527     coap_header->msg_id = 10;
00528     coap_header->msg_code = COAP_MSG_CODE_REQUEST_POST;
00529 
00530     uint8_t object[] = {"name"};
00531 
00532     coap_header->uri_path_ptr = object;
00533     coap_header->uri_path_len = sizeof(object);
00534 
00535     CHECK(0== nsdl->received_from_server_callback(handle,coap_header,NULL));
00536 
00537     uint8_t object_instance[] = {"name/0"};
00538 
00539     coap_header->uri_path_ptr = object_instance;
00540     coap_header->uri_path_len = sizeof(object_instance);
00541 
00542     coap_header->payload_ptr = (uint8_t*)malloc(1);
00543     m2mobjectinstance_stub::bool_value = true;
00544     CHECK(0== nsdl->received_from_server_callback(handle,coap_header,NULL));
00545 
00546     M2MObject *obj = new M2MObject("name");
00547 
00548     m2mbase_stub::string_value = new String("name");
00549 
00550     nsdl->_object_list.push_back(obj);
00551 
00552     m2mobject_stub::inst = new M2MObjectInstance("name",*obj);
00553 
00554     m2mobject_stub::header = (sn_coap_hdr_s*) malloc(sizeof(sn_coap_hdr_s));
00555     memset(m2mobject_stub::header,0,sizeof(sn_coap_hdr_s));
00556 
00557     m2mobjectinstance_stub::header =  (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00558     memset(m2mobjectinstance_stub::header, 0, sizeof(sn_coap_hdr_s));
00559     m2mobjectinstance_stub::header->msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST;
00560     common_stub::coap_header = NULL;
00561 
00562     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,NULL));
00563     m2mobjectinstance_stub::header = NULL;
00564 
00565     m2mobjectinstance_stub::header =  (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00566     memset(m2mobjectinstance_stub::header, 0, sizeof(sn_coap_hdr_s));
00567 
00568     m2mobjectinstance_stub::header->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
00569     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,NULL));
00570 
00571     m2mobjectinstance_stub::header = NULL;
00572 
00573     free(coap_header->payload_ptr);
00574     coap_header->payload_ptr = NULL;
00575 
00576     CHECK(0== nsdl->received_from_server_callback(handle,coap_header,NULL));
00577 
00578     delete m2mobject_stub::inst;
00579     delete m2mbase_stub::string_value;
00580     m2mbase_stub::string_value = NULL;
00581     nsdl->_object_list.clear();
00582     delete obj;
00583 
00584     free(coap_header->payload_ptr);
00585     free(m2mobject_stub::header);
00586     m2mobject_stub::header = NULL;
00587 
00588     uint8_t object_instance1[] = {"name/65536"};
00589 
00590     coap_header->uri_path_ptr = object_instance1;
00591     coap_header->uri_path_len = sizeof(object_instance1);
00592 
00593     obj = new M2MObject("name");
00594 
00595     m2mbase_stub::string_value = new String("name");
00596 
00597     nsdl->_object_list.push_back(obj);
00598 
00599     m2mobject_stub::inst = new M2MObjectInstance("name",*obj);
00600 
00601     m2mobject_stub::header = (sn_coap_hdr_s*) malloc(sizeof(sn_coap_hdr_s));
00602     memset(m2mobject_stub::header,0,sizeof(sn_coap_hdr_s));
00603 
00604     CHECK(0== nsdl->received_from_server_callback(handle,coap_header,NULL));
00605 
00606     delete m2mobject_stub::inst;
00607     delete m2mbase_stub::string_value;
00608     m2mbase_stub::string_value = NULL;
00609     nsdl->_object_list.clear();
00610     delete obj;
00611 
00612     free(m2mobject_stub::header);
00613 
00614     uint8_t resource[] = {"name/0/resource"};
00615 
00616     coap_header->uri_path_ptr = resource;
00617     coap_header->uri_path_len = sizeof(resource);
00618 
00619     CHECK(0== nsdl->received_from_server_callback(handle,coap_header,NULL));
00620 
00621     common_stub::coap_header = (sn_coap_hdr_s *) malloc(sizeof(sn_coap_hdr_s));
00622     sn_nsdl_addr_s *address = (sn_nsdl_addr_s *)malloc(sizeof(sn_nsdl_addr_s));
00623     memset(address, 0, sizeof(sn_nsdl_addr_s));
00624     address->addr_len = 1;
00625     address->addr_ptr = (uint8_t *)malloc(1);
00626     address->addr_ptr[0] = 1;
00627     address->port = 5683;
00628     handle->oma_bs_address_len = 1;
00629     handle->oma_bs_port = 5683;
00630     handle->oma_bs_address_ptr = (uint8_t *)malloc(1);
00631     handle->oma_bs_address_ptr[0] = 1;
00632     coap_header->msg_code = COAP_MSG_CODE_REQUEST_PUT;
00633 
00634     observer->boot_error = false;
00635     CHECK(0== nsdl->received_from_server_callback(handle,coap_header,address));
00636     CHECK(observer->boot_error == true);
00637 
00638     obj = new M2MObject("0");
00639     m2mbase_stub::string_value = new String("0");
00640     nsdl->_object_list.push_back(obj);
00641     m2mobject_stub::inst = new M2MObjectInstance("name",*obj);
00642     uint8_t security[] = {"0"};
00643     coap_header->uri_path_ptr = security;
00644     coap_header->uri_path_len = sizeof(security);
00645 
00646 
00647     M2MResource res(*m2mobject_stub::inst,"test","test",M2MResourceInstance::STRING,M2MBase::Dynamic);
00648 
00649     m2mobjectinstance_stub::resource_list.push_back(&res);
00650     observer->boot_error = false;
00651     m2msecurity_stub::resource = new M2MResource(*m2mobject_stub::inst,"1","type",M2MResourceInstance::STRING,M2MBase::Dynamic);
00652     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00653     CHECK(observer->boot_error == true);
00654 
00655     coap_header->token_ptr = String::convert_integer_to_array(1,coap_header->token_len);
00656     observer->boot_error = false;
00657     m2mtlvdeserializer_stub::is_object_bool_value = true;
00658     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00659     CHECK(observer->boot_error == true);
00660 
00661     coap_header->content_type_ptr = String::convert_integer_to_array(99,coap_header->content_type_len);
00662     observer->boot_error = false;
00663     observer->boot_done = false;
00664     m2mtlvdeserializer_stub::is_object_bool_value = true;
00665     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00666     CHECK(observer->boot_error == false);
00667 
00668     observer->boot_error = false;
00669     observer->boot_done = false;
00670     m2mtlvdeserializer_stub::is_object_bool_value = false;
00671     m2mtlvdeserializer_stub::bool_value = true;
00672     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00673     CHECK(observer->boot_error == false);
00674 
00675     observer->boot_error = false;
00676     observer->boot_done = false;
00677     m2mtlvdeserializer_stub::is_object_bool_value = false;
00678     m2mtlvdeserializer_stub::bool_value = true;
00679     m2mtlvdeserializer_stub::error = M2MTLVDeserializer::NotAllowed;
00680     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00681     CHECK(observer->boot_error == true);
00682 
00683 
00684     delete m2mobject_stub::inst;
00685     delete m2mbase_stub::string_value;
00686     m2mbase_stub::string_value = NULL;
00687     nsdl->_object_list.clear();
00688     delete obj;
00689 
00690     obj = new M2MObject("1");
00691     m2mbase_stub::string_value = new String("1");
00692     nsdl->_object_list.push_back(obj);
00693     m2mobject_stub::inst = new M2MObjectInstance("name",*obj);
00694     uint8_t server[] = {"1"};
00695     coap_header->uri_path_ptr = server;
00696     coap_header->uri_path_len = 1;
00697 
00698     observer->boot_error = false;
00699     observer->boot_done = false;
00700     m2mtlvdeserializer_stub::is_object_bool_value = false;
00701     m2mtlvdeserializer_stub::bool_value = true;
00702     m2mtlvdeserializer_stub::error = M2MTLVDeserializer::None;
00703     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00704     CHECK(observer->boot_error == false);
00705 
00706     observer->boot_error = false;
00707     observer->boot_done = false;
00708     m2mtlvdeserializer_stub::is_object_bool_value = true;
00709     m2mtlvdeserializer_stub::bool_value = false;
00710     m2mtlvdeserializer_stub::error = M2MTLVDeserializer::None;
00711     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00712     CHECK(observer->boot_error == false);
00713 
00714     observer->boot_error = false;
00715     observer->boot_done = false;
00716     m2mtlvdeserializer_stub::is_object_bool_value = false;
00717     m2mtlvdeserializer_stub::bool_value = false;
00718     m2mtlvdeserializer_stub::error = M2MTLVDeserializer::None;
00719     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00720     CHECK(observer->boot_error == true);
00721     CHECK(nsdl->_security == NULL);
00722 
00723     nsdl->_security = new M2MSecurity(M2MSecurity::M2MServer);
00724     observer->boot_error = false;
00725     observer->boot_done = false;
00726     coap_header->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
00727     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00728     CHECK(observer->boot_error == false);
00729 
00730     free(common_stub::coap_header);
00731     common_stub::coap_header = NULL;
00732     observer->boot_error = false;
00733     observer->boot_done = false;
00734     coap_header->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
00735     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00736     CHECK(observer->boot_error == true);
00737     CHECK(nsdl->_security == NULL);
00738 
00739     free(common_stub::coap_header);
00740     common_stub::coap_header = NULL;
00741     uint8_t object_name[] = {"0/0"};
00742     coap_header->uri_path_ptr = object_name;
00743     coap_header->uri_path_len = 3;
00744     observer->boot_error = false;
00745     observer->boot_done = false;
00746     coap_header->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
00747     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00748     CHECK(observer->boot_error == true);
00749     CHECK(nsdl->_security == NULL);
00750 
00751     free(common_stub::coap_header);
00752     common_stub::coap_header = NULL;
00753     uint8_t invalid[] = {"0/0/1"};
00754     coap_header->uri_path_ptr = invalid;
00755     coap_header->uri_path_len = 5;
00756     observer->boot_error = false;
00757     observer->boot_done = false;
00758     coap_header->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
00759     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00760     CHECK(observer->boot_error == true);
00761     CHECK(nsdl->_security == NULL);
00762 
00763     coap_header->uri_path_ptr = server;
00764     coap_header->uri_path_len = 1;
00765     nsdl->_security = new M2MSecurity(M2MSecurity::M2MServer);
00766     observer->boot_error = false;
00767     observer->boot_done = false;
00768     coap_header->msg_code = COAP_MSG_CODE_REQUEST_POST;
00769     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00770     CHECK(observer->boot_error == true);
00771     CHECK(nsdl->_security == NULL);
00772 
00773     nsdl->_security = new M2MSecurity(M2MSecurity::M2MServer);
00774     common_stub::coap_header = (sn_coap_hdr_s *) malloc(sizeof(sn_coap_hdr_s));
00775     m2msecurity_stub::string_value = new String("coaps://");
00776     observer->boot_error = false;
00777     observer->boot_done = false;
00778     coap_header->msg_code = COAP_MSG_CODE_REQUEST_POST;
00779     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00780     CHECK(observer->boot_error == true);
00781     CHECK(nsdl->_security == NULL);
00782 
00783 
00784     nsdl->_security = new M2MSecurity(M2MSecurity::M2MServer);
00785     m2msecurity_stub::sec_mode = M2MSecurity::NoSecurity;
00786     m2msecurity_stub::int_value = true;
00787     m2msecurity_stub::bool_value = false;
00788     observer->boot_error = false;
00789     observer->boot_done = false;
00790     coap_header->uri_path_ptr = (uint8_t*)malloc(2);
00791     coap_header->uri_path_len = 2;
00792     coap_header->uri_path_ptr[0] = 'b';
00793     coap_header->uri_path_ptr[1] = 's';
00794     coap_header->msg_code = COAP_MSG_CODE_REQUEST_POST;
00795     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00796     CHECK(observer->boot_error == false);
00797     CHECK(observer->boot_done == true);
00798 
00799     nsdl->_security = new M2MSecurity(M2MSecurity::M2MServer);
00800     m2msecurity_stub::sec_mode = M2MSecurity::Certificate;
00801     m2mresourceinstance_stub::int_value = 10;
00802     m2msecurity_stub::int_value = true;
00803     m2msecurity_stub::bool_value = false;
00804     observer->boot_error = false;
00805     observer->boot_done = false;
00806     coap_header->msg_code = COAP_MSG_CODE_REQUEST_POST;
00807 
00808     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00809     CHECK(observer->boot_error == false);
00810     CHECK(observer->boot_done == true);
00811 
00812     nsdl->_security = new M2MSecurity(M2MSecurity::M2MServer);
00813     m2msecurity_stub::sec_mode = M2MSecurity::Psk;
00814     m2msecurity_stub::int_value = true;
00815     m2msecurity_stub::bool_value = false;
00816     observer->boot_error = false;
00817     observer->boot_done = false;
00818     coap_header->msg_code = COAP_MSG_CODE_REQUEST_POST;
00819     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00820     CHECK(observer->boot_error == true);
00821     CHECK(observer->boot_done == false);
00822 
00823     nsdl->_security = new M2MSecurity(M2MSecurity::M2MServer);
00824     m2msecurity_stub::sec_mode = M2MSecurity::Certificate;
00825     m2msecurity_stub::int_value = true;
00826     m2msecurity_stub::bool_value = true;
00827     observer->boot_error = false;
00828     observer->boot_done = false;
00829     coap_header->msg_code = COAP_MSG_CODE_REQUEST_POST;
00830     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00831     CHECK(observer->boot_error == true);
00832     CHECK(observer->boot_done == false);
00833 
00834     nsdl->_security = new M2MSecurity(M2MSecurity::M2MServer);
00835     m2msecurity_stub::sec_mode = M2MSecurity::Certificate;
00836     m2msecurity_stub::int_value = false;
00837     m2msecurity_stub::bool_value = false;
00838     m2mresourceinstance_stub::int_value = 0;
00839     observer->boot_error = false;
00840     observer->boot_done = false;
00841     coap_header->msg_code = COAP_MSG_CODE_REQUEST_POST;
00842     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00843     CHECK(observer->boot_error == true);
00844     CHECK(observer->boot_done == false);
00845 
00846     nsdl->_security = new M2MSecurity(M2MSecurity::M2MServer);
00847     free(coap_header->uri_path_ptr);
00848     coap_header->uri_path_ptr = (uint8_t*)malloc(4);
00849     coap_header->uri_path_len = 4;
00850     coap_header->uri_path_ptr[0] = 'b';
00851     coap_header->uri_path_ptr[1] = 's';
00852     coap_header->uri_path_ptr[2] = 's';
00853     coap_header->uri_path_ptr[3] = 's';
00854     m2msecurity_stub::sec_mode = M2MSecurity::Certificate;
00855     m2msecurity_stub::int_value = true;
00856     m2msecurity_stub::bool_value = false;
00857     observer->boot_error = false;
00858     observer->boot_done = false;
00859     coap_header->msg_code = COAP_MSG_CODE_REQUEST_POST;
00860     CHECK(0 == nsdl->received_from_server_callback(handle,coap_header,address));
00861     CHECK(observer->boot_error == true);
00862     CHECK(observer->boot_done == false);
00863 
00864     delete m2mobject_stub::inst;
00865     delete m2mbase_stub::string_value;
00866     m2mbase_stub::string_value = NULL;
00867     nsdl->_object_list.clear();
00868     m2mobjectinstance_stub::resource_list.clear();
00869     delete obj;
00870     delete m2msecurity_stub::string_value;
00871     delete m2msecurity_stub::resource;
00872     free(common_stub::coap_header);
00873     free(address->addr_ptr);
00874     free(address);
00875     free(coap_header->content_type_ptr);
00876     free(coap_header->token_ptr);
00877     free(coap_header->uri_path_ptr);
00878     free(coap_header);
00879     free(handle->oma_bs_address_ptr);
00880     free(handle);
00881 }
00882 
00883 void Test_M2MNsdlInterface::test_resource_callback()
00884 {
00885     uint8_t value[] = {"name"};
00886     sn_coap_hdr_s *coap_header = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00887     memset(coap_header,0,sizeof(sn_coap_hdr_s));
00888     sn_nsdl_addr_s *address = (sn_nsdl_addr_s *)malloc(sizeof(sn_nsdl_addr_s));
00889     memset(address,0,sizeof(sn_nsdl_addr_s));
00890 
00891     common_stub::coap_header = (sn_coap_hdr_ *)malloc(sizeof(sn_coap_hdr_));
00892     memset(common_stub::coap_header,0,sizeof(sn_coap_hdr_));
00893 
00894     common_stub::coap_header->payload_ptr =(uint8_t*)malloc(1);
00895     common_stub::coap_header->payload_len = 1;
00896 
00897     coap_header->uri_path_ptr = value;
00898     coap_header->uri_path_len = sizeof(value);
00899 
00900     common_stub::int_value = 0;
00901 
00902     coap_header->msg_code = COAP_MSG_CODE_REQUEST_GET;
00903 
00904     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) ==0);
00905 
00906     common_stub::int_value = 0;
00907     m2mbase_stub::string_value = new String("name");
00908     M2MObject *object = new M2MObject("name");
00909     m2mbase_stub::int_value = 0;
00910     m2mobject_stub::int_value = 1;
00911 
00912     nsdl->_object_list.push_back(object);
00913 
00914     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_COAP) ==0);
00915 
00916     coap_header->msg_code = COAP_MSG_CODE_REQUEST_PUT;
00917     m2mobject_stub::bool_value = true;
00918     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_COAP) ==0);
00919 
00920     coap_header->msg_code = COAP_MSG_CODE_REQUEST_POST;
00921 
00922     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_COAP) ==0);
00923 
00924 
00925     delete object;
00926     delete m2mbase_stub::string_value;
00927     m2mbase_stub::string_value = NULL;
00928 
00929     free(common_stub::coap_header);
00930     free(address);
00931     free(coap_header);
00932 }
00933 
00934 void Test_M2MNsdlInterface::test_resource_callback_get()
00935 {
00936 }
00937 
00938 void Test_M2MNsdlInterface::test_resource_callback_put()
00939 {
00940     uint8_t value[] = {"name/0/resource"};
00941     sn_coap_hdr_s *coap_header = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00942     memset(coap_header,0,sizeof(sn_coap_hdr_s));
00943     sn_nsdl_addr_s *address = (sn_nsdl_addr_s *)malloc(sizeof(sn_nsdl_addr_s));
00944     memset(address,0,sizeof(sn_nsdl_addr_s));
00945 
00946     coap_header->uri_path_ptr = value;
00947     coap_header->uri_path_len = sizeof(value);
00948 
00949     coap_header->msg_code = COAP_MSG_CODE_REQUEST_PUT;
00950 
00951     String *name = new String("name");
00952     String *res_name = new String("res");
00953     common_stub::int_value = 0;
00954     m2mbase_stub::string_value = name;
00955 
00956     M2MObject *object = new M2MObject(*name);
00957     M2MObjectInstance* instance = new M2MObjectInstance(*name,*object);
00958     M2MResource* create_resource = new M2MResource(*instance,
00959                                                    *res_name,
00960                                                    *res_name,
00961                                                    M2MResourceInstance::INTEGER,
00962                                                    false);
00963     m2mobject_stub::int_value = 2;
00964     m2mobject_stub::instance_list.push_back(instance);
00965 
00966     m2mobjectinstance_stub::resource_list.push_back(create_resource);
00967     m2mobjectinstance_stub::int_value = 1;
00968 
00969     nsdl->_object_list.push_back(object);
00970 
00971     m2mbase_stub::operation = M2MBase::PUT_ALLOWED;
00972 
00973     coap_header->options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00974 
00975     uint8_t query[] = {"pmax=200&pmin=120"};
00976     coap_header->options_list_ptr->uri_query_ptr = (uint8_t*)malloc(sizeof(query));
00977     coap_header->options_list_ptr->uri_query_len = sizeof(query);
00978 
00979     m2mbase_stub::bool_value = true;
00980 
00981     common_stub::coap_header = (sn_coap_hdr_ *)malloc(sizeof(sn_coap_hdr_));
00982     memset(common_stub::coap_header,0,sizeof(sn_coap_hdr_));
00983 
00984     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) ==0);
00985 
00986     m2mobject_stub::base_type = M2MBase::Resource;
00987     m2mbase_stub::base_type = M2MBase::Resource;
00988     m2mobject_stub::bool_value = true;
00989     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) ==0);
00990 
00991     m2mobject_stub::base_type = M2MBase::ObjectInstance;
00992     m2mbase_stub::base_type = M2MBase::ObjectInstance;
00993     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) ==0);
00994 
00995     m2mbase_stub::base_type = M2MBase::Object;
00996     m2mbase_stub::bool_value = false;
00997 
00998     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) ==0);
00999 
01000     delete object;
01001     m2mobject_stub::instance_list.clear();
01002     delete instance;
01003 //    m2mobjectinstance_stub::resource_list.clear();
01004     delete create_resource;
01005 
01006     free(coap_header->options_list_ptr->uri_query_ptr);
01007     free(coap_header->options_list_ptr);
01008     if(common_stub::coap_header){
01009         if( common_stub::coap_header->content_type_ptr ){
01010             free(common_stub::coap_header->content_type_ptr);
01011             common_stub::coap_header->content_type_ptr = NULL;
01012         }
01013         if( common_stub::coap_header->options_list_ptr){
01014             free(common_stub::coap_header->options_list_ptr);
01015             common_stub::coap_header->options_list_ptr = NULL;
01016         }
01017         free(common_stub::coap_header);
01018         common_stub::coap_header = NULL;
01019     }
01020     free(coap_header);
01021     free(address);
01022 
01023     delete name;
01024     delete res_name;
01025     name = NULL;
01026 
01027     m2mbase_stub::clear();
01028     common_stub::clear();
01029     m2mobject_stub::clear();
01030     m2mobjectinstance_stub::clear();
01031 }
01032 
01033 void Test_M2MNsdlInterface::test_resource_callback_post()
01034 {
01035     uint8_t value[] = {"name/0/name"};
01036     sn_coap_hdr_s *coap_header = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01037     memset(coap_header,0,sizeof(sn_coap_hdr_s));
01038     sn_nsdl_addr_s *address = (sn_nsdl_addr_s *)malloc(sizeof(sn_nsdl_addr_s));
01039     memset(address,0,sizeof(sn_nsdl_addr_s));
01040 
01041     coap_header->uri_path_ptr = value;
01042     coap_header->uri_path_len = sizeof(value);
01043 
01044     coap_header->msg_code = COAP_MSG_CODE_REQUEST_POST;
01045 
01046     String *name = new String("name");
01047     common_stub::int_value = 0;
01048     m2mbase_stub::string_value = name;
01049     m2mbase_stub::bool_value = false;
01050     M2MObject *object = new M2MObject(*name);
01051     M2MObjectInstance* instance = new M2MObjectInstance(*name,*object);
01052     M2MResource* create_resource = new M2MResource(*instance,
01053                                                    *name,
01054                                                    *name,
01055                                                    M2MResourceInstance::INTEGER,
01056                                                    M2MResource::Dynamic,false);
01057     m2mobject_stub::int_value = 2;
01058     m2mobject_stub::instance_list.push_back(instance);
01059 
01060     m2mobjectinstance_stub::resource_list.push_back(create_resource);
01061     m2mobjectinstance_stub::int_value = 1;
01062 
01063     nsdl->_object_list.push_back(object);
01064 
01065     m2mbase_stub::operation = M2MBase::POST_ALLOWED;
01066 
01067     coap_header->options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01068 
01069     uint8_t query[] = {"pmax=200&pmin=120"};
01070     coap_header->options_list_ptr->uri_query_ptr = (uint8_t*)malloc(sizeof(query));
01071     coap_header->options_list_ptr->uri_query_len = sizeof(query);
01072 
01073     m2mbase_stub::bool_value = true;
01074 
01075     common_stub::coap_header = (sn_coap_hdr_ *)malloc(sizeof(sn_coap_hdr_));
01076     memset(common_stub::coap_header,0,sizeof(sn_coap_hdr_));
01077 
01078     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) ==0);
01079 
01080     m2mobject_stub::base_type = M2MBase::Resource;
01081     m2mbase_stub::base_type = M2MBase::Resource;
01082     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) ==0);
01083 
01084     m2mobject_stub::base_type = M2MBase::ResourceInstance;
01085     m2mbase_stub::base_type = M2MBase::ResourceInstance;
01086     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) ==0);
01087 
01088     m2mobject_stub::base_type = M2MBase::ObjectInstance;
01089     m2mbase_stub::base_type = M2MBase::ObjectInstance;
01090     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) ==0);
01091 
01092     m2mbase_stub::base_type = M2MBase::Object;
01093     m2mbase_stub::bool_value = false;
01094 
01095     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) ==0);
01096 
01097     delete object;
01098     m2mobject_stub::instance_list.clear();
01099     delete instance;
01100     m2mobjectinstance_stub::resource_list.clear();
01101     delete create_resource;
01102 
01103     free(coap_header->options_list_ptr->uri_query_ptr);
01104     free(coap_header->options_list_ptr);
01105     if(common_stub::coap_header){
01106         if( common_stub::coap_header->content_type_ptr ){
01107             free(common_stub::coap_header->content_type_ptr);
01108             common_stub::coap_header->content_type_ptr = NULL;
01109         }
01110         if( common_stub::coap_header->options_list_ptr){
01111             free(common_stub::coap_header->options_list_ptr);
01112             common_stub::coap_header->options_list_ptr = NULL;
01113         }
01114         free(common_stub::coap_header);
01115         common_stub::coap_header = NULL;
01116     }
01117     free(coap_header);
01118     free(address);
01119 
01120     delete name;
01121     name = NULL;
01122 
01123     m2mbase_stub::clear();
01124     common_stub::clear();
01125     m2mobject_stub::clear();
01126     m2mobjectinstance_stub::clear();
01127 }
01128 
01129 void Test_M2MNsdlInterface::test_resource_callback_delete()
01130 {
01131     uint8_t value[] = {"name/0"};
01132     sn_coap_hdr_s *coap_header = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01133     memset(coap_header,0,sizeof(sn_coap_hdr_s));
01134     sn_nsdl_addr_s *address = (sn_nsdl_addr_s *)malloc(sizeof(sn_nsdl_addr_s));
01135     memset(address,0,sizeof(sn_nsdl_addr_s));
01136 
01137     common_stub::coap_header = (sn_coap_hdr_ *)malloc(sizeof(sn_coap_hdr_));
01138     memset(common_stub::coap_header,0,sizeof(sn_coap_hdr_));
01139 
01140     coap_header->uri_path_ptr = value;
01141     coap_header->uri_path_len = sizeof(value);
01142 
01143     coap_header->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
01144 
01145     common_stub::int_value = 0;
01146 
01147     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) ==0);
01148 
01149     String *name = new String("name");
01150     common_stub::int_value = 0;
01151     m2mbase_stub::string_value = new String("name");
01152     M2MObject *object = new M2MObject(*name);
01153     M2MObjectInstance* instance = new M2MObjectInstance(*name,*object);
01154     m2mbase_stub::int_value = 0;
01155     m2mobject_stub::int_value = 1;
01156     m2mobject_stub::bool_value = true;
01157     m2mobject_stub::instance_list.push_back(instance);
01158 
01159     nsdl->_object_list.push_back(object);
01160 
01161     m2mbase_stub::operation = M2MBase::DELETE_ALLOWED;
01162     m2mobjectinstance_stub::base_type = M2MBase::ObjectInstance;
01163 
01164     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) ==0);
01165 
01166     m2mobjectinstance_stub::base_type = M2MBase::Object;
01167     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) ==0);
01168 
01169     delete instance;
01170     delete object;
01171     delete name;
01172     delete m2mbase_stub::string_value;
01173     m2mbase_stub::string_value = NULL;
01174 
01175     free(common_stub::coap_header);
01176     free(address);
01177     free(coap_header);
01178     m2mobject_stub::instance_list.clear();
01179 }
01180 
01181 void Test_M2MNsdlInterface::test_resource_callback_reset()
01182 {
01183     uint8_t value[] = {"name"};
01184     sn_coap_hdr_s *coap_header = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01185     memset(coap_header,0,sizeof(sn_coap_hdr_s));
01186     sn_nsdl_addr_s *address = (sn_nsdl_addr_s *)malloc(sizeof(sn_nsdl_addr_s));
01187     memset(address,0,sizeof(sn_nsdl_addr_s));
01188 
01189     coap_header->uri_path_ptr = value;
01190     coap_header->uri_path_len = sizeof(value);
01191 
01192     coap_header->msg_type = COAP_MSG_TYPE_RESET;
01193     m2mobjectinstance_stub::base_type = M2MBase::Object;
01194     String *name = new String("name");
01195     common_stub::int_value = 0;
01196     m2mbase_stub::string_value = name;
01197     M2MObject *object = new M2MObject(*name);
01198     M2MObjectInstance* instance = new M2MObjectInstance(*name,*object);
01199     M2MResource* create_resource = new M2MResource(*instance,
01200                                                    *name,
01201                                                    *name,
01202                                                    M2MResourceInstance::INTEGER,
01203                                                    M2MResource::Dynamic,false);
01204     m2mobject_stub::int_value = 2;
01205     m2mobject_stub::instance_list.push_back(instance);
01206 
01207     m2mobjectinstance_stub::resource_list.push_back(create_resource);
01208     m2mobjectinstance_stub::int_value = 1;
01209 
01210     nsdl->_object_list.push_back(object);
01211     // No response for RESET message
01212     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) == 1);
01213 
01214 
01215     m2mobject_stub::base_type = M2MBase::ObjectInstance;
01216     // No response for RESET message
01217     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) == 1);
01218 
01219     m2mobject_stub::base_type = M2MBase::Resource;
01220     // No response for RESET message
01221     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) == 1);
01222 
01223     delete instance;
01224     delete object;
01225     delete name;
01226     delete create_resource;
01227     free(address);
01228     free(coap_header);
01229     m2mobject_stub::instance_list.clear();
01230     m2mobjectinstance_stub::resource_list.clear();
01231     //nsdl->_object_list.clear();
01232     /*uint8_t value[] = {"name"};
01233     sn_coap_hdr_s *coap_header = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01234     memset(coap_header,0,sizeof(sn_coap_hdr_s));
01235     sn_nsdl_addr_s *address = (sn_nsdl_addr_s *)malloc(sizeof(sn_nsdl_addr_s));
01236     memset(address,0,sizeof(sn_nsdl_addr_s));
01237     common_stub::coap_header = (sn_coap_hdr_ *)malloc(sizeof(sn_coap_hdr_));
01238     memset(common_stub::coap_header,0,sizeof(sn_coap_hdr_));
01239     coap_header->uri_path_ptr = value;
01240     coap_header->uri_path_len = sizeof(value);
01241     coap_header->msg_type = COAP_MSG_TYPE_RESET;
01242 
01243     String *name = new String("name");
01244     common_stub::int_value = 0;
01245     m2mbase_stub::string_value = new String("name");
01246     M2MObject *object = new M2MObject(*name);
01247     nsdl->_object_list.push_back(object);
01248     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) == 0);
01249 
01250     uint8_t value2[] = {"name/0"};
01251     coap_header->uri_path_ptr = value2;
01252     coap_header->uri_path_len = sizeof(value2);
01253     M2MObjectInstance* instance = new M2MObjectInstance(*name,*object);
01254     m2mbase_stub::int_value = 0;
01255     m2mobject_stub::int_value = 1;
01256     m2mobject_stub::bool_value = true;
01257     m2mobject_stub::instance_list.push_back(instance);
01258     m2mobjectinstance_stub::base_type = M2MBase::ObjectInstance;
01259     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) == 0);
01260 
01261     uint8_t value3[] = {"name/0/1"};
01262     coap_header->uri_path_ptr = value3;
01263     coap_header->uri_path_len = sizeof(value3);
01264     M2MResource *res = new M2MResource(*instance,
01265                                        "1","1",
01266                                        M2MResourceInstance::INTEGER,
01267                                        false);
01268     nsdl->_object_list.clear();
01269     nsdl->_object_list.push_back(object);
01270     m2mbase_stub::int_value = 0;
01271     m2mobject_stub::int_value = 1;
01272     m2mobject_stub::bool_value = true;
01273     m2mobjectinstance_stub::resource_list.push_back(res);
01274     m2mobjectinstance_stub::int_value = 0;
01275     CHECK(nsdl->resource_callback(NULL,coap_header,address,SN_NSDL_PROTOCOL_HTTP) == 0);
01276 
01277     delete instance;
01278     delete object;
01279     delete name;
01280     delete res;
01281     delete m2mbase_stub::string_value;
01282     m2mbase_stub::string_value = NULL;
01283 
01284     free(common_stub::coap_header);
01285     free(address);
01286     free(coap_header);*/
01287 }
01288 
01289 
01290 
01291 void Test_M2MNsdlInterface::test_process_received_data()
01292 {
01293     uint8_t *data = (uint8_t*)malloc(sizeof(uint8_t));
01294     uint16_t data_size = sizeof(uint16_t);
01295     sn_nsdl_addr_s *address = (sn_nsdl_addr_s *)malloc(sizeof(sn_nsdl_addr_s));
01296 
01297     common_stub::int_value = 0;
01298 
01299     CHECK(nsdl->process_received_data(data,data_size,address) == true);
01300 
01301     common_stub::int_value = -1;
01302 
01303     CHECK(nsdl->process_received_data(data,data_size,address) == false);
01304 
01305     free(address);
01306     free(data);
01307     common_stub::clear();
01308 }
01309 
01310 void Test_M2MNsdlInterface::test_stop_timers()
01311 {
01312     // Check if there is no memory leak or crash
01313     nsdl->stop_timers();
01314 }
01315 
01316 void Test_M2MNsdlInterface::test_timer_expired()
01317 {
01318     nsdl->timer_expired(M2MTimerObserver::NsdlExecution);
01319     CHECK(nsdl->_counter_for_nsdl == 1);
01320 
01321     if( nsdl->_endpoint == NULL){
01322         nsdl->_endpoint = (sn_nsdl_ep_parameters_s*)nsdl->memory_alloc(sizeof(sn_nsdl_ep_parameters_s));
01323     }
01324     nsdl->_endpoint->lifetime_ptr = (uint8_t*)malloc(sizeof(uint8_t));
01325 
01326     // For checking the registration update
01327     nsdl->timer_expired(M2MTimerObserver::Registration);
01328 
01329     nsdl->delete_endpoint();
01330     CHECK(nsdl->_endpoint == NULL);
01331 }
01332 
01333 void Test_M2MNsdlInterface::test_observation_to_be_sent()
01334 {
01335     Vector<uint16_t> instance_list_ids;
01336     M2MObject *object = new M2MObject("name");
01337     M2MObjectInstance* instance = new M2MObjectInstance("name",*object);
01338     M2MResource *res = new M2MResource(*instance,
01339                                        "name","name",
01340                                        M2MResourceInstance::INTEGER,
01341                                        false,true);
01342 
01343     M2MResource *res2 = new M2MResource(*instance,
01344                                            "res2","res2",
01345                                            M2MResourceInstance::INTEGER,
01346                                            false,true);
01347 
01348     M2MResourceInstance* res_instance = new M2MResourceInstance("res2","res2",
01349                                                                 M2MResourceInstance::INTEGER,
01350                                                                 *instance);
01351     M2MResourceInstance* res_instance_1 = new M2MResourceInstance("res2","res2",
01352                                                                 M2MResourceInstance::INTEGER,
01353                                                                 *instance);
01354     m2mresource_stub::list.clear();
01355     m2mresource_stub::list.push_back(res_instance);
01356     m2mresource_stub::list.push_back(res_instance_1);
01357     m2mresource_stub::int_value = 2;
01358     instance_list_ids.push_back(0);
01359 
01360     uint8_t value[] = {"value"};
01361     m2mresourceinstance_stub::value = (uint8_t *)malloc(sizeof(value));
01362     memset( m2mresourceinstance_stub::value, 0, sizeof(value));
01363     memcpy(m2mresourceinstance_stub::value,value,sizeof(value));
01364     m2mresourceinstance_stub::int_value = sizeof(value);
01365 
01366     m2mbase_stub::uint16_value = 321;
01367     String *owned = new String("token");
01368     m2mbase_stub::string_value = owned;
01369 
01370     m2mresourceinstance_stub::base_type = M2MBase::Resource;
01371 
01372     nsdl->_nsdl_handle = (nsdl_s*)malloc(sizeof(nsdl_s));
01373     memset(nsdl->_nsdl_handle,0,sizeof(nsdl_s));
01374     sn_nsdl_oma_server_info_t * nsp_address = (sn_nsdl_oma_server_info_t *)malloc(sizeof(sn_nsdl_oma_server_info_t));
01375     memset(nsp_address,0,sizeof(sn_nsdl_oma_server_info_t));
01376     sn_nsdl_addr_s* address = (sn_nsdl_addr_s*)malloc(sizeof(sn_nsdl_addr_s));
01377     memset(address,0,sizeof(sn_nsdl_addr_s));
01378 
01379     nsdl->_nsdl_handle->nsp_address_ptr = nsp_address;
01380     memset(nsdl->_nsdl_handle->nsp_address_ptr,0,sizeof(sn_nsdl_oma_server_info_t));
01381     nsdl->_nsdl_handle->nsp_address_ptr->omalw_address_ptr = address;
01382 
01383     //CHECK if nothing crashes
01384     nsdl->observation_to_be_sent(res2, 1, instance_list_ids);
01385 
01386     m2mresourceinstance_stub::resource_type = M2MResource::OPAQUE;
01387 
01388     //CHECK if nothing crashes
01389     nsdl->observation_to_be_sent(res2, 1, instance_list_ids);
01390 
01391     m2mresource_stub::list.clear();
01392     m2mresource_stub::int_value = 0;
01393 
01394     //CHECK if nothing crashes
01395     nsdl->observation_to_be_sent(res, 500, instance_list_ids);
01396 
01397     M2MObjectInstance *object_instance = new M2MObjectInstance("name",*object);
01398     m2mobject_stub::int_value = 1;
01399     m2mobject_stub::base_type = M2MBase::Object;
01400     m2mobject_stub::inst = object_instance;
01401     m2mobjectinstance_stub::resource_list.push_back(res);
01402     nsdl->_object_list.push_back(object);
01403     instance_list_ids.push_back(1);
01404     //CHECK if nothing crashes
01405     nsdl->observation_to_be_sent(object, 1, instance_list_ids);
01406     nsdl->observation_to_be_sent(object, 500, instance_list_ids, true);
01407 
01408     //CHECK if nothing crashes
01409     nsdl->observation_to_be_sent(object_instance, 1, instance_list_ids);
01410     nsdl->observation_to_be_sent(object_instance, 500, instance_list_ids);
01411 
01412     delete owned;
01413     owned = NULL;
01414 
01415     free(m2mresourceinstance_stub::value);
01416     m2mresourceinstance_stub::value = NULL;
01417 
01418     m2mbase_stub::clear();
01419     m2mresourceinstance_stub::clear();
01420     m2mobjectinstance_stub::clear();
01421     m2mobject_stub::clear();
01422     m2mresource_stub::list.clear();
01423     delete res;
01424     res = NULL;
01425 
01426     delete res2;
01427     res2 = NULL;
01428 
01429     delete res_instance;
01430     res_instance = NULL;
01431 
01432     delete res_instance_1;
01433     res_instance_1 = NULL;
01434 
01435 
01436     delete object_instance;
01437     object_instance = NULL;
01438 
01439     delete object;
01440     object = NULL;
01441 
01442     delete instance;
01443     instance = NULL;
01444 
01445     free(nsp_address);
01446     free(address);
01447     free(nsdl->_nsdl_handle);
01448 }
01449 
01450 void Test_M2MNsdlInterface::test_resource_to_be_deleted()
01451 {
01452     //Checking coverage for the code
01453     nsdl->resource_to_be_deleted("name");
01454 }
01455 
01456 void Test_M2MNsdlInterface::test_value_updated()
01457 {
01458     M2MObject *object = new M2MObject("name");
01459     M2MObjectInstance *object_instance = new M2MObjectInstance("name",*object);
01460     M2MResource *resource = new M2MResource(*object_instance,
01461                                             "resource_name",
01462                                             "resource_type",
01463                                             M2MResourceInstance::INTEGER,
01464                                             false);
01465 
01466     M2MResourceInstance *resource_instance = new M2MResourceInstance("resource_name",
01467                                                                      "resource_type",
01468                                                                      M2MResourceInstance::INTEGER,
01469                                                                      *object_instance);
01470 
01471 
01472     m2mobject_stub::base_type = M2MBase::Object;
01473     m2mbase_stub::string_value = new String("name");
01474     m2mbase_stub::operation = M2MBase::GET_ALLOWED;
01475     nsdl->value_updated(object,"name");
01476     CHECK(observer->value_update == true);
01477     observer->value_update = false;
01478 
01479     m2mobjectinstance_stub::base_type = M2MBase::ObjectInstance;
01480 
01481     nsdl->value_updated(object_instance,"name/0");
01482     CHECK(observer->value_update == true);
01483     observer->value_update = false;
01484 
01485     common_stub::resource = (sn_nsdl_resource_info_s*)malloc(sizeof(sn_nsdl_resource_info_s));
01486     memset(common_stub::resource,0, sizeof(sn_nsdl_resource_info_s));
01487     common_stub::resource->resource = (uint8_t*)malloc(2);
01488     memset(common_stub::resource->resource,0, 2);
01489 
01490     common_stub::resource->mode = SN_GRS_STATIC;
01491     m2mbase_stub::mode_value = M2MBase::Static;
01492 
01493     common_stub::resource->resource_parameters_ptr = (sn_nsdl_resource_parameters_s*)malloc(sizeof(sn_nsdl_resource_parameters_s));
01494     memset(common_stub::resource->resource_parameters_ptr,0, sizeof(sn_nsdl_resource_parameters_s));
01495 
01496     common_stub::resource->resource_parameters_ptr->observable = false;
01497     m2mbase_stub::bool_value = true;
01498 
01499     m2mresourceinstance_stub::int_value = 2;
01500     uint8_t value[] = "1";
01501     m2mresourceinstance_stub::value = value;
01502 
01503     m2mresourceinstance_stub::base_type = M2MBase::Resource;
01504 
01505     nsdl->value_updated(resource,"name/0/name");
01506     CHECK(observer->value_update == true);
01507     observer->value_update = false;
01508 
01509     m2mresourceinstance_stub::clear();
01510     free(common_stub::resource->resource_parameters_ptr);
01511     free(common_stub::resource->resource);
01512     free(common_stub::resource);
01513     common_stub::resource = NULL;
01514     common_stub::clear();
01515 
01516     m2mresourceinstance_stub::base_type = M2MBase::ResourceInstance;
01517 
01518     common_stub::resource = (sn_nsdl_resource_info_s*)malloc(sizeof(sn_nsdl_resource_info_s));
01519     memset(common_stub::resource,0, sizeof(sn_nsdl_resource_info_s));
01520     common_stub::resource->resource = (uint8_t*)malloc(2);
01521     memset(common_stub::resource->resource,0, 2);
01522 
01523     common_stub::resource->mode = SN_GRS_STATIC;
01524     m2mbase_stub::mode_value = M2MBase::Static;
01525 
01526     m2mresourceinstance_stub::int_value = 2;
01527     m2mresourceinstance_stub::value = value;
01528 
01529     nsdl->value_updated(resource_instance,"name/0/name/0");
01530     CHECK(observer->value_update == true);
01531     observer->value_update = false;
01532 
01533     m2mbase_stub::is_value_updated_function_set = true;
01534     nsdl->value_updated(resource_instance,"name/0/name/0");
01535     CHECK(observer->value_update == false);
01536     observer->value_update = false;
01537 
01538     delete m2mbase_stub::string_value;
01539     m2mbase_stub::string_value = NULL;
01540 
01541     m2mobject_stub::clear();
01542     m2mobjectinstance_stub::clear();
01543 
01544     m2mresourceinstance_stub::clear();
01545 
01546     free(common_stub::resource->resource);
01547     free(common_stub::resource);
01548 
01549     common_stub::resource = NULL;
01550     common_stub::clear();
01551 
01552     delete resource_instance;
01553     delete resource;
01554     delete object_instance;
01555     delete object;
01556 }
01557 
01558 void Test_M2MNsdlInterface::test_find_resource()
01559 {
01560     m2mbase_stub::string_value = new String("name");
01561     M2MObject *object = new M2MObject("name");
01562     M2MObjectInstance *object_instance = new M2MObjectInstance("name",*object);
01563     M2MResource *resource = new M2MResource(*object_instance,
01564                                             "resource_name",
01565                                             "resource_type",
01566                                             M2MResourceInstance::INTEGER,
01567                                             false);
01568 
01569     M2MResourceInstance *resource_instance = new M2MResourceInstance("name",
01570                                                                      "resource_type",
01571                                                                       M2MResourceInstance::INTEGER,
01572                                                                      *object_instance);
01573 
01574 
01575     m2mobject_stub::instance_list.push_back(object_instance);
01576     m2mobjectinstance_stub::resource_list.push_back(resource);
01577     m2mresource_stub::list.push_back(resource_instance);
01578 
01579     m2mobject_stub::base_type = M2MBase::Object;
01580 
01581     nsdl->_object_list.push_back(object);
01582 
01583     CHECK(nsdl->find_resource("name") != NULL);
01584 
01585     m2mbase_stub::int_value  = 0;
01586 
01587     CHECK(nsdl->find_resource("name/0") != NULL);
01588 
01589     CHECK(nsdl->find_resource("name/0/name") != NULL);
01590 
01591     m2mresource_stub::bool_value = true;
01592 
01593     CHECK(nsdl->find_resource("name/0/name/0") != NULL);
01594 
01595     CHECK(nsdl->find_resource("name1") == NULL);
01596     CHECK(nsdl->find_resource("name/1") == NULL);
01597     CHECK(nsdl->find_resource("name/0/name1") == NULL);
01598     CHECK(nsdl->find_resource("name/0/name/1") == NULL);
01599 
01600     delete m2mbase_stub::string_value;
01601     m2mbase_stub::string_value = NULL;
01602 
01603     m2mobject_stub::clear();
01604     m2mobjectinstance_stub::clear();
01605 
01606     m2mresourceinstance_stub::clear();
01607     m2mresource_stub::clear();
01608     m2mobjectinstance_stub::clear();
01609     m2mobject_stub::clear();
01610 
01611     delete resource_instance;
01612     delete resource;
01613     delete object_instance;
01614     delete object;
01615 }
01616 
01617 void Test_M2MNsdlInterface::test_remove_object()
01618 {
01619     String name = "name";
01620     M2MObject *obj = new M2MObject(name);
01621     nsdl->_object_list.push_back(obj);
01622 
01623     nsdl->remove_object((M2MBase*)obj);
01624 
01625     CHECK(nsdl->_object_list.empty() == true);
01626 
01627     nsdl->_object_list.clear();
01628     delete obj;
01629 }
01630 
01631 void Test_M2MNsdlInterface::test_add_object_to_list()
01632 {
01633     M2MObject *obj = new M2MObject("name");
01634     nsdl->_object_list.push_back(obj);
01635 
01636     nsdl->add_object_to_list(obj);
01637     CHECK(nsdl->_object_list.size() == 1);
01638 
01639     nsdl->_object_list.clear();
01640     delete obj;
01641 }
01642 
01643 void Test_M2MNsdlInterface::test_send_delayed_response()
01644 {
01645     String *name = new String("name");
01646     common_stub::int_value = 0;
01647     m2mbase_stub::int_value = 0;
01648 
01649     M2MObject *object = new M2MObject(*name);
01650     M2MObjectInstance* instance = new M2MObjectInstance(*name,*object);
01651     nsdl->_nsdl_handle = (nsdl_s*)malloc(sizeof(nsdl_s));
01652     memset(nsdl->_nsdl_handle,0,sizeof(nsdl_s));
01653 
01654     sn_nsdl_oma_server_info_t * nsp_address = (sn_nsdl_oma_server_info_t *)malloc(sizeof(sn_nsdl_oma_server_info_t));
01655     memset(nsp_address,0,sizeof(sn_nsdl_oma_server_info_t));
01656     sn_nsdl_addr_s* address = (sn_nsdl_addr_s*)malloc(sizeof(sn_nsdl_addr_s));
01657     memset(address,0,sizeof(sn_nsdl_addr_s));
01658 
01659     M2MResource* resource = new M2MResource(*instance,
01660                                             *name,
01661                                             *name,
01662                                             M2MResourceInstance::INTEGER,
01663                                             M2MResource::Dynamic,
01664                                             false);
01665 
01666     uint8_t val[] = {"name"};
01667     m2mresource_stub::delayed_token = (uint8_t*)malloc(sizeof(val));
01668     memcpy(m2mresource_stub::delayed_token,val,sizeof(val));
01669     m2mresource_stub::delayed_token_len = sizeof(val);
01670 
01671     m2mresourceinstance_stub::base_type = M2MBase::Resource;
01672 
01673     nsdl->_nsdl_handle->nsp_address_ptr = nsp_address;
01674     memset(nsdl->_nsdl_handle->nsp_address_ptr,0,sizeof(sn_nsdl_oma_server_info_t));
01675     nsdl->_nsdl_handle->nsp_address_ptr->omalw_address_ptr = address;
01676 
01677     nsdl->send_delayed_response(resource);
01678 
01679     free(nsp_address);
01680     free(address);
01681     free(nsdl->_nsdl_handle);
01682 
01683     delete object;
01684     delete name;
01685     name = NULL;
01686     delete instance;
01687     instance = NULL;
01688     delete resource;
01689     resource = NULL;
01690     free(m2mresource_stub::delayed_token);
01691     m2mresource_stub::delayed_token = NULL;
01692     m2mresource_stub::delayed_token_len = 0;
01693 }
01694 
01695 void Test_M2MNsdlInterface::test_get_nsdl_handle()
01696 {
01697     CHECK(nsdl->get_nsdl_handle() == nsdl->_nsdl_handle);
01698 }
01699 
01700 void Test_M2MNsdlInterface::test_endpoint_name()
01701 {
01702     String endpoint = "test";
01703     nsdl->_endpoint_name = endpoint;
01704     CHECK(nsdl->endpoint_name() == endpoint);
01705 }