libCoap_protocol_test.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 <string.h>
00018 #include <math.h>
00019 #include <stdint.h>
00020 #include "sn_nsdl.h"
00021 #include "sn_coap_protocol.h"
00022 #include "sn_nsdl_lib.h"
00023 #include "sn_coap_header_internal.h"
00024 #include "sn_coap_protocol_internal.h"
00025 
00026 #include "sn_coap_builder_stub.h"
00027 #include "sn_coap_parser_stub.h"
00028 #include "sn_coap_header_check_stub.h"
00029 
00030 int retCounter = 0;
00031 static coap_s *coap_handle = NULL;
00032 void myFree(void* addr);
00033 void* myMalloc(uint16_t size);
00034 uint8_t null_tx_cb(uint8_t *a, uint16_t b, sn_nsdl_addr_s *c, void *d);
00035 
00036 TEST_GROUP(libCoap_protocol)
00037 {
00038     void setup() {
00039         retCounter = 1;
00040         coap_handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
00041     }
00042 
00043     void teardown() {
00044         retCounter = 0;
00045         sn_coap_protocol_destroy(coap_handle);
00046     }
00047 };
00048 
00049 void* myMalloc(uint16_t size)
00050 {
00051     if( retCounter > 0 ){
00052         retCounter--;
00053         return malloc(size);
00054     }else {
00055         return NULL;
00056     }
00057 }
00058 
00059 void myFree(void* addr){
00060     if( addr ){
00061         free(addr);
00062     }
00063 }
00064 
00065 uint8_t null_tx_cb(uint8_t *a, uint16_t b, sn_nsdl_addr_s *c, void *d)
00066 {
00067     return 0;
00068 }
00069 
00070 int8_t null_rx_cb(sn_coap_hdr_s *a, sn_nsdl_addr_s *b, void *c)
00071 {
00072 
00073 }
00074 
00075 TEST(libCoap_protocol, sn_coap_protocol_destroy)
00076 {
00077     CHECK( -1 == sn_coap_protocol_destroy(NULL));
00078     int temp = sizeof(struct coap_s);
00079     struct coap_s *handle = (struct coap_s *)malloc(sizeof(struct coap_s));
00080     handle->sn_coap_protocol_free = &myFree;
00081     handle->sn_coap_protocol_malloc = &myMalloc;
00082     ns_list_init(&handle->linked_list_resent_msgs);
00083     ns_list_init(&handle->linked_list_duplication_msgs);
00084     ns_list_init(&handle->linked_list_blockwise_sent_msgs);
00085     ns_list_init(&handle->linked_list_blockwise_received_payloads);
00086     CHECK( 0 == sn_coap_protocol_destroy(handle));
00087 }
00088 
00089 TEST(libCoap_protocol, sn_coap_protocol_init_null_func_ptrs)
00090 {
00091     POINTERS_EQUAL(NULL, sn_coap_protocol_init(NULL, NULL, NULL, NULL));
00092 }
00093 
00094 TEST(libCoap_protocol, sn_coap_protocol_init_null_malloc)
00095 {
00096     POINTERS_EQUAL(NULL, sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL));
00097 
00098     retCounter = 1;
00099     struct coap_s * handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
00100     CHECK(NULL != handle);
00101 
00102     sn_coap_protocol_destroy(handle);
00103 }
00104 
00105 TEST(libCoap_protocol, sn_coap_protocol_set_block_size)
00106 {
00107 #if SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE
00108     CHECK( 0 == sn_coap_protocol_set_block_size(coap_handle,16) );
00109     CHECK( -1 == sn_coap_protocol_set_block_size(NULL,1) );
00110 #endif
00111     CHECK( -1 == sn_coap_protocol_set_block_size(coap_handle,1) );
00112 }
00113 
00114 TEST(libCoap_protocol, sn_coap_protocol_set_duplicate_buffer_size)
00115 {
00116 #if SN_COAP_DUPLICATION_MAX_MSGS_COUNT
00117     CHECK( 0 == sn_coap_protocol_set_duplicate_buffer_size(coap_handle,3));
00118     CHECK( -1 == sn_coap_protocol_set_duplicate_buffer_size(NULL,3));
00119 #endif
00120     CHECK( -1 == sn_coap_protocol_set_duplicate_buffer_size(coap_handle,999));
00121 }
00122 
00123 TEST(libCoap_protocol, sn_coap_protocol_set_retransmission_parameters)
00124 {
00125 #if ENABLE_RESENDINGS
00126     CHECK( 0 == sn_coap_protocol_set_retransmission_parameters(coap_handle,3,0) );
00127     CHECK( 0 == sn_coap_protocol_set_retransmission_parameters(coap_handle,3, 10) );
00128     CHECK( -1 == sn_coap_protocol_set_retransmission_parameters(NULL,3,0) );
00129 #endif
00130     CHECK( -1 == sn_coap_protocol_set_retransmission_parameters(coap_handle,999,0) )
00131 }
00132 
00133 TEST(libCoap_protocol, sn_coap_protocol_set_retransmission_buffer)
00134 {
00135 #if ENABLE_RESENDINGS
00136     CHECK( 0 == sn_coap_protocol_set_retransmission_buffer(coap_handle,3,3) );
00137     CHECK( -1 == sn_coap_protocol_set_retransmission_buffer(NULL,3,3) );
00138 #endif
00139     CHECK( -1 == sn_coap_protocol_set_retransmission_buffer(coap_handle,3,999) );
00140 }
00141 
00142 //TEST(libCoap_protocol, sn_coap_protocol_clear_retransmission_buffer)
00143 //{
00144 //    sn_coap_protocol_clear_retransmission_buffer();
00145 //}
00146 
00147 #include <stdio.h>
00148 
00149 TEST(libCoap_protocol, sn_coap_protocol_build)
00150 {
00151     retCounter = 1;
00152     struct coap_s * handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
00153     sn_nsdl_addr_s addr;
00154     memset(&addr, 0, sizeof(sn_nsdl_addr_s));
00155     sn_coap_hdr_s hdr;
00156     memset(&hdr, 0, sizeof(sn_coap_hdr_s));
00157 
00158     uint8_t* dst_packet_data_ptr = (uint8_t*)malloc(5);
00159     memset(dst_packet_data_ptr, '1', 5);
00160 
00161     CHECK( -2 == sn_coap_protocol_build(NULL, NULL, NULL, NULL, NULL));
00162 
00163     CHECK( -2 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00164 
00165     hdr.msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00166     hdr.msg_id = 0;
00167 
00168     addr.addr_ptr = (uint8_t*)malloc(5);
00169     memset(addr.addr_ptr, '1', 5);
00170 
00171     sn_coap_builder_stub.expectedInt16 = 0;
00172 
00173     CHECK( 0 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00174 
00175     hdr.payload_ptr = (uint8_t*)malloc(SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20);
00176     memset(hdr.payload_ptr, '1', SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20);
00177     hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00178 
00179     sn_coap_builder_stub.expectedInt16 = -3;
00180     CHECK( -2 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00181 
00182     retCounter = 0;
00183     hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00184     memset(hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
00185     hdr.options_list_ptr->block1_ptr = (uint8_t*)malloc(3);
00186     CHECK( -2 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00187     hdr.options_list_ptr = NULL;
00188 
00189     retCounter = 2;
00190     CHECK( -3 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00191 
00192     free(hdr.options_list_ptr->block1_ptr);
00193     hdr.options_list_ptr->block1_ptr = NULL;
00194     free(hdr.options_list_ptr);
00195     hdr.options_list_ptr = NULL;
00196 
00197     hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00198     hdr.msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST;
00199     hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00200     memset(hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
00201     hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
00202     retCounter = 0;
00203     CHECK( -2 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00204     hdr.options_list_ptr = NULL;
00205 
00206     free(hdr.payload_ptr);
00207     hdr.payload_ptr = NULL;
00208     hdr.payload_len = 0;
00209 
00210     //Test variations of sn_coap_convert_block_size here -->
00211     for( int i=0; i < 8; i++ ){
00212         uint16_t multiplier = 16*pow(2, i);
00213         sn_coap_protocol_set_block_size(handle,multiplier);
00214         hdr.payload_ptr = (uint8_t*)malloc(multiplier + 20);
00215         memset(hdr.payload_ptr, '1', multiplier + 20);
00216         hdr.payload_len = multiplier + 20;
00217         retCounter = 2;
00218         hdr.msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST;
00219         CHECK( -3 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00220         hdr.msg_code = COAP_MSG_CODE_EMPTY;
00221 
00222         free(hdr.options_list_ptr->block2_ptr);
00223         free(hdr.options_list_ptr->size2_ptr);
00224         hdr.options_list_ptr->block2_ptr = NULL;
00225         free(hdr.options_list_ptr);
00226         hdr.options_list_ptr = NULL;
00227 
00228         free(hdr.payload_ptr);
00229         hdr.payload_ptr = NULL;
00230         hdr.payload_len = 0;
00231     }
00232     sn_coap_protocol_set_block_size(handle,SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE);
00233 
00234     // <-- Test variations of sn_coap_convert_block_size here
00235 
00236     retCounter = 1;
00237     sn_coap_builder_stub.expectedInt16 = -1;
00238     CHECK( -1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00239 
00240     retCounter = 1;
00241     sn_coap_builder_stub.expectedInt16 = 1;
00242     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00243 
00244     hdr.msg_code = COAP_MSG_CODE_EMPTY;
00245 
00246     retCounter = 2;
00247     sn_coap_builder_stub.expectedInt16 = 1;
00248     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00249 
00250     retCounter = 3;
00251     sn_coap_builder_stub.expectedInt16 = 1;
00252     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00253 
00254     retCounter = 4;
00255     sn_coap_builder_stub.expectedInt16 = 1;
00256     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00257 
00258     retCounter = 5;
00259     sn_coap_builder_stub.expectedInt16 = 1;
00260     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00261 
00262     // Test second SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE -->
00263     hdr.payload_ptr = (uint8_t*)malloc(SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20);
00264     memset(hdr.payload_ptr, '1', SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20);
00265     hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00266 
00267     retCounter = 2;
00268     sn_coap_builder_stub.expectedInt16 = 1;
00269     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00270     free(hdr.payload_ptr);
00271 
00272     hdr.payload_ptr = (uint8_t*)malloc(SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20);
00273     memset(hdr.payload_ptr, '1', SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20);
00274     hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00275 
00276     retCounter = 6;
00277     sn_coap_builder_stub.expectedInt16 = 1;
00278     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00279 
00280     free(hdr.payload_ptr);
00281     hdr.payload_ptr = (uint8_t*)malloc(UINT16_MAX);
00282     memset(hdr.payload_ptr, '1', UINT16_MAX);
00283     hdr.payload_len = UINT16_MAX;
00284 
00285     retCounter = 6;
00286     sn_coap_builder_stub.expectedInt16 = 1;
00287     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00288 
00289     free(hdr.payload_ptr);
00290     hdr.payload_ptr = (uint8_t*)malloc(UINT16_MAX - 1);
00291     memset(hdr.payload_ptr, '1', UINT16_MAX - 1);
00292     hdr.payload_len = UINT16_MAX - 1;
00293 
00294     retCounter = 6;
00295     sn_coap_builder_stub.expectedInt16 = 1;
00296     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00297 
00298     sn_coap_protocol_destroy(handle);
00299     handle = NULL;
00300     retCounter = 1;
00301     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
00302     free(hdr.options_list_ptr->block1_ptr);
00303     hdr.options_list_ptr->block1_ptr = NULL;
00304     free(hdr.options_list_ptr->size1_ptr);
00305     hdr.options_list_ptr->size1_ptr = NULL;
00306     free(hdr.options_list_ptr);
00307     hdr.options_list_ptr = NULL;
00308     //Test sn_coap_protocol_copy_header here -->
00309     retCounter = 9;
00310     sn_coap_builder_stub.expectedInt16 = 1;
00311     hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00312     CHECK( -2 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00313 
00314     free(hdr.options_list_ptr->block1_ptr);
00315     hdr.options_list_ptr->block1_ptr = NULL;
00316     free(hdr.options_list_ptr->size1_ptr);
00317     hdr.options_list_ptr->size1_ptr = NULL;
00318     free(hdr.options_list_ptr);
00319     hdr.options_list_ptr = NULL;
00320 
00321     sn_coap_hdr_s* hdr2 = (sn_coap_hdr_s*)malloc(sizeof(sn_coap_hdr_s));
00322     memset(hdr2, 0, sizeof(sn_coap_hdr_s));
00323     hdr2->msg_type = COAP_MSG_TYPE_NON_CONFIRMABLE;
00324     hdr2->uri_path_ptr = (uint8_t*)malloc(3);
00325     hdr2->uri_path_len = 3;
00326     hdr2->token_ptr = (uint8_t*)malloc(3);
00327     hdr2->token_len = 3;
00328     hdr2->content_type_ptr = (uint8_t*)malloc(3);
00329     hdr2->content_type_len = 3;
00330 
00331     hdr2->options_list_ptr = (sn_coap_options_list_s *)malloc(sizeof(sn_coap_options_list_s));
00332     memset(hdr2->options_list_ptr, 0, sizeof(sn_coap_options_list_s));
00333     hdr2->options_list_ptr->accept_ptr = (uint8_t*)malloc(3);
00334     hdr2->options_list_ptr->accept_len = 3;
00335     hdr2->options_list_ptr->block1_ptr = (uint8_t*)malloc(3);
00336     hdr2->options_list_ptr->block1_len = 3;
00337 
00338     hdr2->options_list_ptr->block2_ptr = (uint8_t*)malloc(3);
00339     hdr2->options_list_ptr->block2_len = 3;
00340     hdr2->options_list_ptr->etag_ptr = (uint8_t*)malloc(3);
00341     hdr2->options_list_ptr->etag_len = 3;
00342     hdr2->options_list_ptr->location_path_ptr = (uint8_t*)malloc(3);
00343     hdr2->options_list_ptr->location_path_len = 3;
00344     hdr2->options_list_ptr->location_query_ptr = (uint8_t*)malloc(3);
00345     hdr2->options_list_ptr->location_query_len = 3;
00346     hdr2->options_list_ptr->max_age_ptr = (uint8_t*)malloc(3);
00347     hdr2->options_list_ptr->max_age_len = 3;
00348     hdr2->options_list_ptr->observe_ptr = (uint8_t*)malloc(3);
00349     hdr2->options_list_ptr->observe_len = 3;
00350     hdr2->options_list_ptr->proxy_uri_ptr = (uint8_t*)malloc(3);
00351     hdr2->options_list_ptr->proxy_uri_len = 3;
00352     hdr2->options_list_ptr->uri_host_ptr = (uint8_t*)malloc(3);
00353     hdr2->options_list_ptr->uri_host_len = 3;
00354     hdr2->options_list_ptr->uri_port_ptr = (uint8_t*)malloc(3);
00355     hdr2->options_list_ptr->uri_port_len = 3;
00356     hdr2->options_list_ptr->uri_query_ptr = (uint8_t*)malloc(3);
00357     hdr2->options_list_ptr->uri_query_len = 3;
00358     hdr2->options_list_ptr->size1_ptr = (uint8_t*)malloc(3);
00359     hdr2->options_list_ptr->size1_len = 3;
00360 
00361     hdr2->payload_ptr = (uint8_t*)malloc(3);
00362 
00363     for( int i=0; i < 17; i++ ){
00364         retCounter = 3 + i;
00365         sn_coap_builder_stub.expectedInt16 = 1;
00366         hdr2->payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00367         int8_t rett = sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, hdr2, NULL);
00368         CHECK( -2 == rett );
00369     }
00370 
00371     retCounter = 20;
00372     sn_coap_builder_stub.expectedInt16 = 1;
00373     hdr2->payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00374     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, hdr2, NULL));
00375 
00376     retCounter = 20;
00377     sn_coap_builder_stub.expectedInt16 = 1;
00378     hdr2->payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00379     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, hdr2, NULL));
00380 
00381     free(hdr2->payload_ptr);
00382     sn_coap_parser_release_allocated_coap_msg_mem(handle, hdr2);
00383     hdr2 = NULL;
00384 
00385     //<-- Test sn_coap_protocol_copy_header here
00386 
00387     hdr.msg_code = COAP_MSG_CODE_REQUEST_GET;
00388     retCounter = 5;
00389     sn_coap_builder_stub.expectedInt16 = 1;
00390     hdr.payload_len = 0;
00391     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00392 
00393     sn_coap_protocol_destroy(handle);
00394     handle = NULL;
00395     retCounter = 1;
00396     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
00397 
00398     retCounter = 6;
00399     sn_coap_builder_stub.expectedInt16 = 1;
00400     hdr.payload_len = 0;
00401     CHECK( -2 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00402 
00403     retCounter = 7;
00404     sn_coap_builder_stub.expectedInt16 = 1;
00405     hdr.payload_len = 0;
00406     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00407 
00408     free(hdr.payload_ptr);
00409     hdr.payload_ptr = NULL;
00410     hdr.payload_len = 0;
00411 
00412     hdr.msg_code = COAP_MSG_CODE_EMPTY;
00413 
00414     // <-- Test second SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE
00415 
00416     free(addr.addr_ptr);
00417     free(dst_packet_data_ptr);
00418     sn_coap_protocol_destroy(handle);
00419 }
00420 
00421 TEST(libCoap_protocol, sn_coap_protocol_parse)
00422 {
00423     CHECK( NULL == sn_coap_protocol_parse(NULL, NULL, 0, NULL, NULL) );
00424 
00425     retCounter = 1;
00426     struct coap_s * handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
00427 
00428     sn_nsdl_addr_s* addr = (sn_nsdl_addr_s*)malloc(sizeof(sn_nsdl_addr_s));
00429     memset(addr, 0, sizeof(sn_nsdl_addr_s));
00430 
00431     addr->addr_ptr = (uint8_t*)malloc(5);
00432 
00433     uint8_t *packet_data_ptr = (uint8_t*)malloc(5);
00434     uint16_t packet_data_len = 5;
00435 
00436     sn_coap_parser_stub.expectedHeader = NULL;
00437     CHECK( NULL == sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL) );
00438 
00439     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00440     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00441     sn_coap_header_check_stub.expectedInt8 = 1;
00442     sn_coap_parser_stub.expectedHeader->coap_status = COAP_STATUS_PARSER_ERROR_IN_HEADER;
00443     CHECK( NULL == sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL) );
00444 
00445     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00446     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00447     sn_coap_header_check_stub.expectedInt8 = 1;
00448     sn_coap_parser_stub.expectedHeader->msg_code = sn_coap_msg_code_e(COAP_MSG_CODE_RESPONSE_PROXYING_NOT_SUPPORTED + 60);
00449 
00450     CHECK( NULL == sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL) );
00451 
00452     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00453     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00454     sn_coap_header_check_stub.expectedInt8 = 0;
00455 
00456     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00457     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_EMPTY;
00458 
00459     CHECK( NULL == sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL) );
00460 
00461     //Test sn_coap_handle_blockwise_message, block1_ptr != NULL -->
00462     sn_coap_protocol_set_duplicate_buffer_size(handle,1);
00463 
00464     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00465     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00466     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00467     sn_coap_parser_stub.expectedHeader->msg_id = 4;
00468 
00469     sn_coap_options_list_s* list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00470     memset(list, 0, sizeof(sn_coap_options_list_s));
00471     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00472     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(5);
00473     sn_coap_parser_stub.expectedHeader->msg_id = 4;
00474     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00475     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_GET;
00476 
00477     sn_coap_hdr_s *ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00478     CHECK( NULL == ret );
00479 
00480     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00481     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00482     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00483     sn_coap_parser_stub.expectedHeader->msg_id = 4;
00484 
00485     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00486     memset(list, 0, sizeof(sn_coap_options_list_s));
00487     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00488     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(5);
00489     sn_coap_parser_stub.expectedHeader->msg_id = 4;
00490     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00491     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_GET;
00492     uint8_t* payload = (uint8_t*)malloc(5);
00493     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00494     sn_coap_parser_stub.expectedHeader->payload_len = 5;
00495 
00496     retCounter = 1;
00497     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00498     CHECK( NULL == ret );
00499     free(payload);
00500 
00501     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00502     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00503     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00504     sn_coap_parser_stub.expectedHeader->msg_id = 4;
00505 
00506     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00507     memset(list, 0, sizeof(sn_coap_options_list_s));
00508     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00509     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(5);
00510     sn_coap_parser_stub.expectedHeader->msg_id = 4;
00511     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00512     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_GET;
00513     payload = (uint8_t*)malloc(5);
00514     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00515     sn_coap_parser_stub.expectedHeader->payload_len = 5;
00516 
00517     retCounter = 2;
00518     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00519     CHECK( NULL == ret );
00520     free(payload);
00521 
00522     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00523     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00524     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00525     sn_coap_parser_stub.expectedHeader->msg_id = 4;
00526 
00527     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00528     memset(list, 0, sizeof(sn_coap_options_list_s));
00529     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00530     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(5);
00531     sn_coap_parser_stub.expectedHeader->msg_id = 4;
00532     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00533     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_GET;
00534     payload = (uint8_t*)malloc(17);
00535     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00536     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00537 
00538     retCounter = 3;
00539     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00540     CHECK( COAP_STATUS_PARSER_DUPLICATED_MSG == ret->coap_status );
00541 
00542     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00543     sn_coap_parser_stub.expectedHeader->msg_id = 5;
00544 
00545     retCounter = 3;
00546     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00547     CHECK( NULL == ret );
00548     free(payload);
00549 
00550     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00551     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00552     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00553     sn_coap_parser_stub.expectedHeader->msg_id = 6;
00554 
00555     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00556     memset(list, 0, sizeof(sn_coap_options_list_s));
00557     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00558     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(5);
00559     sn_coap_parser_stub.expectedHeader->msg_id = 4;
00560     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00561     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_GET;
00562     payload = (uint8_t*)malloc(17);
00563     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00564     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00565 
00566     retCounter = 4;
00567     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00568     CHECK( NULL == ret );
00569     free(payload);
00570 
00571     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00572     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00573     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00574     sn_coap_parser_stub.expectedHeader->msg_id = 7;
00575 
00576     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00577     memset(list, 0, sizeof(sn_coap_options_list_s));
00578     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00579     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(5);
00580     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00581     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_GET;
00582     payload = (uint8_t*)malloc(17);
00583     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00584     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00585 
00586     retCounter = 5;
00587     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00588     CHECK( NULL == ret );
00589     free(payload);
00590 
00591     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00592     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00593     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00594     sn_coap_parser_stub.expectedHeader->msg_id = 8;
00595 
00596     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00597     memset(list, 0, sizeof(sn_coap_options_list_s));
00598     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00599     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(5);
00600     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00601     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_GET;
00602 
00603     retCounter = 6;
00604     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00605     CHECK( COAP_STATUS_PARSER_BLOCKWISE_MSG_RECEIVED == ret->coap_status );
00606     free(ret->payload_ptr);
00607     free(sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr);
00608     free(list);
00609     free(sn_coap_parser_stub.expectedHeader);
00610 
00611     // block1_ptr[0] == 0x08 -->
00612     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00613     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00614     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00615     sn_coap_parser_stub.expectedHeader->msg_id = 9;
00616 
00617     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00618     memset(list, 0, sizeof(sn_coap_options_list_s));
00619     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00620     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(1);
00621     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_len = 1;
00622     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[0] = 0x08;
00623     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00624     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_GET;
00625     payload = (uint8_t*)malloc(17);
00626     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00627     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00628 
00629     retCounter = 2;
00630     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00631     CHECK( NULL == ret );
00632     free(payload);
00633 
00634     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00635     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00636     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00637     sn_coap_parser_stub.expectedHeader->msg_id = 10;
00638 
00639     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00640     memset(list, 0, sizeof(sn_coap_options_list_s));
00641     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00642     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(1);
00643     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_len = 1;
00644     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[0] = 0x08;
00645     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00646     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_GET;
00647     payload = (uint8_t*)malloc(17);
00648     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00649     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00650 
00651     retCounter = 6;
00652     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00653     CHECK( NULL == ret );
00654     free(payload);
00655 
00656     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00657     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00658     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00659     sn_coap_parser_stub.expectedHeader->msg_id = 11;
00660 
00661     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00662     memset(list, 0, sizeof(sn_coap_options_list_s));
00663     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00664     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(1);
00665     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_len = 1;
00666     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[0] = 0x08;
00667     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00668     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_GET;
00669     payload = (uint8_t*)malloc(17);
00670     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00671     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00672 
00673     retCounter = 7;
00674     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00675     CHECK( NULL == ret );
00676     free(payload);
00677     free(sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr);
00678     free(list);
00679     free(sn_coap_parser_stub.expectedHeader);
00680 
00681     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00682     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00683     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00684     sn_coap_parser_stub.expectedHeader->msg_id = 12;
00685 
00686     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00687     memset(list, 0, sizeof(sn_coap_options_list_s));
00688     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00689     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(1);
00690     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_len = 1;
00691     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[0] = 0x0F;
00692     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00693     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_POST;
00694     payload = (uint8_t*)malloc(17);
00695     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00696     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00697     sn_coap_builder_stub.expectedUint16 = 1;
00698 
00699     retCounter = 8;
00700     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00701     CHECK( NULL == ret );
00702     free(payload);
00703 
00704     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00705     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00706     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00707     sn_coap_parser_stub.expectedHeader->msg_id = 13;
00708 
00709     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00710     memset(list, 0, sizeof(sn_coap_options_list_s));
00711     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00712     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(1);
00713     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_len = 1;
00714     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[0] = 0x08;
00715     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00716     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_PUT;
00717     payload = (uint8_t*)malloc(17);
00718     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00719     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00720     sn_coap_builder_stub.expectedUint16 = 1;
00721 
00722     retCounter = 9;
00723     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00724     CHECK( NULL != ret );
00725     CHECK(COAP_STATUS_PARSER_BLOCKWISE_MSG_RECEIVING == ret->coap_status);
00726     free(payload);
00727     free(sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr);
00728     free(list);
00729     free(sn_coap_parser_stub.expectedHeader);
00730 
00731     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00732     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00733     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00734     sn_coap_parser_stub.expectedHeader->msg_id = 14;
00735 
00736     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00737     memset(list, 0, sizeof(sn_coap_options_list_s));
00738     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00739     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(1);
00740     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_len = 1;
00741     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[0] = 0x08;
00742     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00743     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
00744     payload = (uint8_t*)malloc(17);
00745     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00746     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00747 
00748     retCounter = 7;
00749     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00750     CHECK( NULL == ret );
00751     free(payload);
00752     free(sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr);
00753     free(list);
00754     free(sn_coap_parser_stub.expectedHeader);
00755 
00756     /* Size is more than we can handle */
00757     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00758     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00759     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00760     sn_coap_parser_stub.expectedHeader->msg_id = 100;
00761 
00762     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00763     memset(list, 0, sizeof(sn_coap_options_list_s));
00764     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00765     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(1);
00766     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_len = 1;
00767     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[0] = 0x08;
00768     sn_coap_parser_stub.expectedHeader->options_list_ptr->size1_ptr = (uint8_t*)malloc(3);
00769     sn_coap_parser_stub.expectedHeader->options_list_ptr->size1_ptr[0] = 0xFF;
00770     sn_coap_parser_stub.expectedHeader->options_list_ptr->size1_ptr[1] = 0xFF;
00771     sn_coap_parser_stub.expectedHeader->options_list_ptr->size1_ptr[2] = 0x01;
00772     sn_coap_parser_stub.expectedHeader->options_list_ptr->size1_len = 3;
00773     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00774     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_PUT;
00775     payload = (uint8_t*)malloc(65535);
00776     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00777     sn_coap_parser_stub.expectedHeader->payload_len = 65535;
00778 
00779     retCounter = 10;
00780     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00781     CHECK( NULL != ret );
00782     free(payload);
00783     free(sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr);
00784     free(sn_coap_parser_stub.expectedHeader->options_list_ptr->size1_ptr);
00785     free(list);
00786     free(sn_coap_parser_stub.expectedHeader);
00787 
00788 
00789     // received_coap_msg_ptr->msg_code > COAP_MSG_CODE_REQUEST_DELETE -->
00790 
00791     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00792     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00793     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00794     sn_coap_parser_stub.expectedHeader->msg_id = 15;
00795 
00796     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00797     memset(list, 0, sizeof(sn_coap_options_list_s));
00798     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00799     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(1);
00800     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_len = 1;
00801     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[0] = 0x00;
00802     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00803     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
00804     payload = (uint8_t*)malloc(17);
00805     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00806     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00807 
00808     retCounter = 2;
00809     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00810     CHECK( NULL != ret );
00811     CHECK( COAP_STATUS_OK == ret->coap_status );
00812     free(payload);
00813     free(sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr);
00814     free(list);
00815     free(sn_coap_parser_stub.expectedHeader);
00816 
00817     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00818     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00819     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00820     sn_coap_parser_stub.expectedHeader->msg_id = 16;
00821 
00822     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00823     memset(list, 0, sizeof(sn_coap_options_list_s));
00824     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00825     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(1);
00826     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_len = 1;
00827     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[0] = 0x08;
00828     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00829     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
00830     payload = (uint8_t*)malloc(17);
00831     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00832     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00833 
00834 
00835     sn_nsdl_addr_s tmp_addr;
00836     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
00837     sn_coap_hdr_s tmp_hdr;
00838     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
00839 
00840     uint8_t* dst_packet_data_ptr = (uint8_t*)malloc(5);
00841     memset(dst_packet_data_ptr, '1', 5);
00842 
00843     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
00844     memset(tmp_addr.addr_ptr, '1', 5);
00845 
00846     retCounter = 21;
00847     sn_coap_builder_stub.expectedInt16 = 1;
00848     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
00849     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00850     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
00851     tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
00852     tmp_hdr.msg_id = 16;
00853     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00854     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
00855 
00856     free(tmp_hdr.options_list_ptr->block2_ptr);
00857     free(tmp_hdr.options_list_ptr->block1_ptr);
00858     free(tmp_hdr.options_list_ptr->size1_ptr);
00859     free(tmp_hdr.options_list_ptr);
00860     free(tmp_hdr.payload_ptr);
00861     free(tmp_addr.addr_ptr);
00862     free(dst_packet_data_ptr);
00863 
00864     retCounter = 2;
00865     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00866     CHECK( NULL == ret );
00867     free(payload);
00868 
00869     sn_coap_protocol_destroy(handle);
00870     retCounter = 1;
00871     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
00872 
00873     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00874     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00875     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00876     sn_coap_parser_stub.expectedHeader->msg_id = 17;
00877 
00878     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00879     memset(list, 0, sizeof(sn_coap_options_list_s));
00880     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00881     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(1);
00882     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_len = 1;
00883     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[0] = 0x08;
00884     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00885     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
00886     payload = (uint8_t*)malloc(17);
00887     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00888     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00889 
00890     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
00891     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
00892 
00893     dst_packet_data_ptr = (uint8_t*)malloc(5);
00894     memset(dst_packet_data_ptr, '1', 5);
00895 
00896     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
00897     memset(tmp_addr.addr_ptr, '1', 5);
00898 
00899     retCounter = 22;
00900     sn_coap_builder_stub.expectedInt16 = 1;
00901     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
00902     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00903     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
00904     tmp_hdr.options_list_ptr->block1_ptr = NULL;
00905     tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
00906     tmp_hdr.msg_id = 17;
00907     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00908 
00909     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
00910 
00911 
00912     free(tmp_hdr.options_list_ptr->block2_ptr);
00913     free(tmp_hdr.options_list_ptr->block1_ptr);
00914     free(tmp_hdr.options_list_ptr->size1_ptr);
00915     free(tmp_hdr.options_list_ptr);
00916     free(tmp_hdr.payload_ptr);
00917     free(tmp_addr.addr_ptr);
00918     free(dst_packet_data_ptr);
00919 
00920     retCounter = 3;
00921     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00922     CHECK( NULL == ret );
00923     free(payload);
00924 
00925     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00926     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00927     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00928     sn_coap_parser_stub.expectedHeader->msg_id = 18;
00929 
00930     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00931     memset(list, 0, sizeof(sn_coap_options_list_s));
00932     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00933     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(2);
00934     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_len = 2;
00935     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[0] = 0x08;
00936     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[1] = 0xe8;
00937     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00938     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
00939     payload = (uint8_t*)malloc(17);
00940     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00941     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00942 
00943 
00944     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
00945     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
00946 
00947     dst_packet_data_ptr = (uint8_t*)malloc(5);
00948     memset(dst_packet_data_ptr, '1', 5);
00949 
00950     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
00951     memset(tmp_addr.addr_ptr, '1', 5);
00952 
00953     retCounter = 21;
00954     sn_coap_builder_stub.expectedInt16 = 1;
00955     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
00956 //    tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00957 //    memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
00958 //    tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
00959     tmp_hdr.msg_id = 18;
00960     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
00961     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00962     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
00963 
00964     free(tmp_hdr.options_list_ptr->block2_ptr);
00965     free(tmp_hdr.options_list_ptr->block1_ptr);
00966     free(tmp_hdr.options_list_ptr->size1_ptr);
00967     free(tmp_hdr.options_list_ptr->size2_ptr);
00968     tmp_hdr.options_list_ptr->block2_ptr = NULL;
00969     tmp_hdr.options_list_ptr->block1_ptr = NULL;
00970     tmp_hdr.options_list_ptr->size1_ptr = NULL;
00971     tmp_hdr.options_list_ptr->size2_ptr = NULL;
00972     free(tmp_hdr.options_list_ptr);
00973     tmp_hdr.options_list_ptr = NULL;
00974 
00975     tmp_hdr.payload_len = UINT16_MAX;
00976     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
00977     free(tmp_hdr.options_list_ptr->block2_ptr);
00978     free(tmp_hdr.options_list_ptr->block1_ptr);
00979     free(tmp_hdr.options_list_ptr->size1_ptr);
00980     free(tmp_hdr.options_list_ptr->size2_ptr);
00981     free(tmp_hdr.options_list_ptr);
00982     free(tmp_hdr.payload_ptr);
00983     tmp_hdr.payload_ptr = NULL;
00984     free(tmp_addr.addr_ptr);
00985     free(dst_packet_data_ptr);
00986 
00987     retCounter = 3;
00988     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00989     CHECK( NULL == ret );
00990     free(payload);
00991 
00992     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00993     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00994     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00995     sn_coap_parser_stub.expectedHeader->msg_id = 19;
00996 
00997     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00998     memset(list, 0, sizeof(sn_coap_options_list_s));
00999     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01000     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(3);
01001     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_len = 3;
01002     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[0] = 0x08;
01003     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[1] = 0xe8;
01004     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[2] = 0xee;
01005     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01006     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01007     payload = (uint8_t*)malloc(17);
01008     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01009     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01010 
01011     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01012     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01013 
01014     dst_packet_data_ptr = (uint8_t*)malloc(5);
01015     memset(dst_packet_data_ptr, '1', 5);
01016 
01017     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01018     memset(tmp_addr.addr_ptr, '1', 5);
01019 
01020     retCounter = 21;
01021     sn_coap_builder_stub.expectedInt16 = 1;
01022     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01023 //    tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01024 //    memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01025 //    tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01026     tmp_hdr.msg_id = 19;
01027     tmp_hdr.msg_code = COAP_MSG_CODE_REQUEST_GET;
01028     tmp_hdr.payload_len = 1;
01029     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01030 
01031     free(tmp_hdr.options_list_ptr);
01032     free(tmp_hdr.payload_ptr);
01033     tmp_hdr.payload_ptr = NULL;
01034     free(tmp_addr.addr_ptr);
01035     free(dst_packet_data_ptr);
01036 
01037     retCounter = 2;
01038     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01039     CHECK( NULL == ret );
01040     free(payload);
01041 
01042     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01043     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01044     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01045     sn_coap_parser_stub.expectedHeader->msg_id = 20;
01046 
01047     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01048     memset(list, 0, sizeof(sn_coap_options_list_s));
01049     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01050     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(3);
01051     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_len = 3;
01052     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[0] = 0x08;
01053     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[1] = 0xe8;
01054     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr[2] = 0xee;
01055     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01056     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01057     payload = (uint8_t*)malloc(17);
01058     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01059     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01060 
01061     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01062     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01063 
01064     dst_packet_data_ptr = (uint8_t*)malloc(5);
01065     memset(dst_packet_data_ptr, '1', 5);
01066 
01067     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01068     memset(tmp_addr.addr_ptr, '1', 5);
01069 
01070     retCounter = 21;
01071     sn_coap_builder_stub.expectedInt16 = 1;
01072     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01073 //    tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01074 //    memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01075 //    tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01076     tmp_hdr.msg_id = 20;
01077     tmp_hdr.msg_code = COAP_MSG_CODE_REQUEST_GET;
01078     tmp_hdr.payload_len = 1;
01079     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01080 
01081     free(tmp_hdr.options_list_ptr);
01082     free(tmp_hdr.payload_ptr);
01083     tmp_hdr.payload_ptr = NULL;
01084     free(tmp_addr.addr_ptr);
01085     free(dst_packet_data_ptr);
01086 
01087     retCounter = 5;
01088     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01089     CHECK( NULL != ret );
01090     CHECK( COAP_STATUS_PARSER_BLOCKWISE_ACK == ret->coap_status );
01091     free(payload);
01092     sn_coap_parser_release_allocated_coap_msg_mem(handle, ret);
01093 
01094     //<-- block1_ptr[0] == 0x08
01095     //<-- Test sn_coap_handle_blockwise_message, block1_ptr != NULL
01096 
01097     sn_coap_protocol_destroy(handle);
01098     retCounter = 1;
01099     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01100 
01101     //Test sn_coap_handle_blockwise_message, block2_ptr != NULL -->
01102     sn_coap_protocol_set_duplicate_buffer_size(handle,1);
01103 
01104     // block2_ptr length == 1,2,3 -->
01105 
01106     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01107     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01108     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01109     sn_coap_parser_stub.expectedHeader->msg_id = 16;
01110 
01111     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01112     memset(list, 0, sizeof(sn_coap_options_list_s));
01113     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01114     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01115     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 1;
01116     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0x08;
01117     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01118     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
01119     payload = (uint8_t*)malloc(17);
01120     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01121     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01122 
01123     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01124     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01125 
01126     dst_packet_data_ptr = (uint8_t*)malloc(5);
01127     memset(dst_packet_data_ptr, '1', 5);
01128 
01129     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01130     memset(tmp_addr.addr_ptr, '1', 5);
01131 
01132     retCounter = 21;
01133     sn_coap_builder_stub.expectedInt16 = 1;
01134     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01135     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01136     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01137     tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01138     tmp_hdr.msg_id = 16;
01139     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01140     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01141 
01142     free(tmp_hdr.options_list_ptr->block2_ptr);
01143     free(tmp_hdr.options_list_ptr->block1_ptr);
01144     free(tmp_hdr.options_list_ptr->size1_ptr);
01145     free(tmp_hdr.options_list_ptr);
01146     free(tmp_hdr.payload_ptr);
01147     free(tmp_addr.addr_ptr);
01148     free(dst_packet_data_ptr);
01149 
01150     retCounter = 2;
01151     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01152     CHECK( NULL == ret );
01153     free(payload);
01154     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01155 
01156     sn_coap_protocol_destroy(handle);
01157     retCounter = 1;
01158     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01159 
01160     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01161     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01162     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01163     sn_coap_parser_stub.expectedHeader->msg_id = 17;
01164 
01165     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01166     memset(list, 0, sizeof(sn_coap_options_list_s));
01167     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01168     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01169     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 1;
01170     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0x08;
01171     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01172     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
01173     payload = (uint8_t*)malloc(17);
01174     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01175     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01176 
01177     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01178     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01179 
01180     dst_packet_data_ptr = (uint8_t*)malloc(5);
01181     memset(dst_packet_data_ptr, '1', 5);
01182 
01183     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01184     memset(tmp_addr.addr_ptr, '1', 5);
01185 
01186     retCounter = 22;
01187     sn_coap_builder_stub.expectedInt16 = 1;
01188     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01189     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01190     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01191     tmp_hdr.options_list_ptr->block1_ptr = NULL;
01192     tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01193     tmp_hdr.msg_id = 17;
01194     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01195 
01196     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01197 
01198 
01199     free(tmp_hdr.options_list_ptr->block2_ptr);
01200     free(tmp_hdr.options_list_ptr->block1_ptr);
01201     free(tmp_hdr.options_list_ptr->size1_ptr);
01202     free(tmp_hdr.options_list_ptr);
01203     free(tmp_hdr.payload_ptr);
01204     free(tmp_addr.addr_ptr);
01205     free(dst_packet_data_ptr);
01206 
01207     retCounter = 3;
01208     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01209     CHECK( NULL == ret );
01210     free(payload);
01211     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01212 
01213     sn_coap_protocol_destroy(handle);
01214     retCounter = 1;
01215     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01216 
01217     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01218     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01219     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01220     sn_coap_parser_stub.expectedHeader->msg_id = 18;
01221 
01222     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01223     memset(list, 0, sizeof(sn_coap_options_list_s));
01224     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01225     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(2);
01226     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 2;
01227     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0x08;
01228     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[1] = 0xe8;
01229     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01230     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
01231     payload = (uint8_t*)malloc(17);
01232     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01233     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01234 
01235 
01236     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01237     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01238 
01239     dst_packet_data_ptr = (uint8_t*)malloc(5);
01240     memset(dst_packet_data_ptr, '1', 5);
01241 
01242     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01243     memset(tmp_addr.addr_ptr, '1', 5);
01244 
01245     retCounter = 21;
01246     sn_coap_builder_stub.expectedInt16 = 1;
01247     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01248 //    tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01249 //    memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01250 //    tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01251     tmp_hdr.msg_id = 18;
01252     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01253     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01254     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01255 
01256     free(tmp_hdr.options_list_ptr->block2_ptr);
01257     free(tmp_hdr.options_list_ptr->block1_ptr);
01258     free(tmp_hdr.options_list_ptr->size1_ptr);
01259     free(tmp_hdr.options_list_ptr->size2_ptr);
01260     free(tmp_hdr.options_list_ptr);
01261     free(tmp_hdr.payload_ptr);
01262     tmp_hdr.payload_ptr = NULL;
01263     free(tmp_addr.addr_ptr);
01264     free(dst_packet_data_ptr);
01265 
01266     retCounter = 3;
01267     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01268     CHECK( NULL == ret );
01269     free(payload);
01270     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01271 
01272     sn_coap_protocol_destroy(handle);
01273     retCounter = 1;
01274     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01275 
01276     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01277     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01278     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01279     sn_coap_parser_stub.expectedHeader->msg_id = 19;
01280 
01281     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01282     memset(list, 0, sizeof(sn_coap_options_list_s));
01283     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01284     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(3);
01285     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 3;
01286     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0x08;
01287     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[1] = 0xe8;
01288     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[2] = 0xee;
01289     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01290     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
01291     payload = (uint8_t*)malloc(17);
01292     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01293     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01294 
01295     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01296     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01297 
01298     dst_packet_data_ptr = (uint8_t*)malloc(5);
01299     memset(dst_packet_data_ptr, '1', 5);
01300 
01301     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01302     memset(tmp_addr.addr_ptr, '1', 5);
01303 
01304     retCounter = 21;
01305     sn_coap_builder_stub.expectedInt16 = 1;
01306     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01307 //    tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01308 //    memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01309 //    tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01310     tmp_hdr.msg_id = 19;
01311     tmp_hdr.msg_code = COAP_MSG_CODE_REQUEST_GET;
01312     tmp_hdr.payload_len = 1;
01313     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01314 
01315     free(tmp_hdr.options_list_ptr);
01316     free(tmp_hdr.payload_ptr);
01317     tmp_hdr.payload_ptr = NULL;
01318     free(tmp_addr.addr_ptr);
01319     free(dst_packet_data_ptr);
01320 
01321     retCounter = 2;
01322     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01323     CHECK( NULL == ret );
01324     free(payload);
01325     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01326 
01327     sn_coap_protocol_destroy(handle);
01328     retCounter = 1;
01329     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01330 
01331     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01332     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01333     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01334     sn_coap_parser_stub.expectedHeader->msg_id = 200;
01335 
01336     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01337     memset(list, 0, sizeof(sn_coap_options_list_s));
01338     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01339     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(3);
01340     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 3;
01341     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0x08;
01342     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[1] = 0xe8;
01343     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[2] = 0xee;
01344     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01345     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
01346     payload = (uint8_t*)malloc(17);
01347     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01348     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01349 
01350     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01351     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01352 
01353     dst_packet_data_ptr = (uint8_t*)malloc(5);
01354     memset(dst_packet_data_ptr, '1', 5);
01355 
01356     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01357     memset(tmp_addr.addr_ptr, '1', 5);
01358 
01359     retCounter = 21;
01360     sn_coap_builder_stub.expectedInt16 = 1;
01361     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01362     tmp_hdr.msg_id = 200;
01363     tmp_hdr.msg_code = COAP_MSG_CODE_REQUEST_GET;
01364     tmp_hdr.payload_len = 1;
01365     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01366 
01367     free(tmp_hdr.options_list_ptr);
01368     free(tmp_hdr.payload_ptr);
01369     tmp_hdr.payload_ptr = NULL;
01370     free(tmp_addr.addr_ptr);
01371     free(dst_packet_data_ptr);
01372 
01373     retCounter = 3;
01374     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01375     CHECK( NULL == ret );
01376     free(payload);
01377     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01378 
01379 
01380     sn_coap_protocol_destroy(handle);
01381     retCounter = 1;
01382     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01383 
01384     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01385     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01386     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01387     sn_coap_parser_stub.expectedHeader->msg_id = 20;
01388 
01389     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01390     memset(list, 0, sizeof(sn_coap_options_list_s));
01391     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01392     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(3);
01393     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 3;
01394     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0x08;
01395     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[1] = 0xe8;
01396     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[2] = 0xee;
01397     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01398     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
01399     payload = (uint8_t*)malloc(17);
01400     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01401     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01402 
01403     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01404     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01405 
01406     dst_packet_data_ptr = (uint8_t*)malloc(5);
01407     memset(dst_packet_data_ptr, '1', 5);
01408 
01409     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01410     memset(tmp_addr.addr_ptr, '1', 5);
01411 
01412     retCounter = 21;
01413     sn_coap_builder_stub.expectedInt16 = 1;
01414     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01415 
01416     tmp_hdr.msg_id = 20;
01417     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01418     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01419     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01420 
01421     free(tmp_hdr.options_list_ptr->block2_ptr);
01422     free(tmp_hdr.options_list_ptr->size2_ptr);
01423     free(tmp_hdr.options_list_ptr);
01424     free(tmp_hdr.payload_ptr);
01425     tmp_hdr.payload_ptr = NULL;
01426     free(tmp_addr.addr_ptr);
01427     free(dst_packet_data_ptr);
01428 
01429     retCounter = 5;
01430     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01431     CHECK( NULL != ret );
01432     CHECK( COAP_STATUS_PARSER_BLOCKWISE_ACK == ret->coap_status );
01433     free(payload);
01434     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01435 
01436     //<-- block2_ptr length == 1,2,3
01437 
01438     // block2_ptr[0] == 0x08 -->
01439 
01440     sn_coap_protocol_destroy(handle);
01441     retCounter = 1;
01442     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01443 
01444     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01445     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01446     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01447 
01448     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01449     memset(list, 0, sizeof(sn_coap_options_list_s));
01450     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01451     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
01452     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0x08;
01453     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 1;
01454     sn_coap_parser_stub.expectedHeader->msg_id = 41;
01455     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01456     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01457     payload = (uint8_t*)malloc(5);
01458     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01459     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01460 
01461     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01462     CHECK( NULL == ret );
01463     free(payload);
01464 
01465     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01466     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01467     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01468 
01469     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01470     memset(list, 0, sizeof(sn_coap_options_list_s));
01471     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01472     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
01473     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0x08;
01474     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 1;
01475     sn_coap_parser_stub.expectedHeader->msg_id = 41;
01476     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01477     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01478     payload = (uint8_t*)malloc(5);
01479     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01480     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01481 
01482     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01483     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01484 
01485     dst_packet_data_ptr = (uint8_t*)malloc(5);
01486     memset(dst_packet_data_ptr, '1', 5);
01487 
01488     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01489     memset(tmp_addr.addr_ptr, '1', 5);
01490 
01491     retCounter = 21;
01492     sn_coap_builder_stub.expectedInt16 = 1;
01493     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01494     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01495     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01496     tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01497     tmp_hdr.msg_id = 41;
01498     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01499     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01500 
01501     free(tmp_hdr.options_list_ptr->block2_ptr);
01502     free(tmp_hdr.options_list_ptr->block1_ptr);
01503     free(tmp_hdr.options_list_ptr->size1_ptr);
01504     free(tmp_hdr.options_list_ptr);
01505     free(tmp_hdr.payload_ptr);
01506     free(tmp_addr.addr_ptr);
01507     free(dst_packet_data_ptr);
01508 
01509     retCounter = 0;
01510     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01511     CHECK( NULL == ret );
01512     free(payload);
01513     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01514 
01515     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01516     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01517     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01518 
01519     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01520     memset(list, 0, sizeof(sn_coap_options_list_s));
01521     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01522     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
01523     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0x08;
01524     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 1;
01525     sn_coap_parser_stub.expectedHeader->msg_id = 42;
01526     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01527     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01528     payload = (uint8_t*)malloc(5);
01529     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01530     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01531 
01532     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01533     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01534 
01535     dst_packet_data_ptr = (uint8_t*)malloc(5);
01536     memset(dst_packet_data_ptr, '1', 5);
01537 
01538     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01539     memset(tmp_addr.addr_ptr, '1', 5);
01540 
01541     retCounter = 21;
01542     sn_coap_builder_stub.expectedInt16 = 1;
01543     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01544     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01545     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01546     tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01547     tmp_hdr.msg_id = 42;
01548     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01549     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01550 
01551     free(tmp_hdr.options_list_ptr->block2_ptr);
01552     free(tmp_hdr.options_list_ptr->block1_ptr);
01553     free(tmp_hdr.options_list_ptr->size1_ptr);
01554     free(tmp_hdr.options_list_ptr);
01555     free(tmp_hdr.payload_ptr);
01556     free(tmp_addr.addr_ptr);
01557     free(dst_packet_data_ptr);
01558 
01559     retCounter = 6;
01560     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01561     CHECK( NULL == ret );
01562     free(payload);
01563 //    sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01564 
01565     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01566     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01567     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01568 
01569     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01570     memset(list, 0, sizeof(sn_coap_options_list_s));
01571     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01572     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
01573     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0x08;
01574     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 1;
01575     sn_coap_parser_stub.expectedHeader->msg_id = 43;
01576     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01577     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01578     payload = (uint8_t*)malloc(5);
01579     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01580     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01581 
01582     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01583     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01584 
01585     dst_packet_data_ptr = (uint8_t*)malloc(5);
01586     memset(dst_packet_data_ptr, '1', 5);
01587 
01588     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01589     memset(tmp_addr.addr_ptr, '1', 5);
01590 
01591     retCounter = 21;
01592     sn_coap_builder_stub.expectedInt16 = 1;
01593     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01594     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01595     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01596     tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01597     tmp_hdr.msg_id = 43;
01598     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01599     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01600 
01601     free(tmp_hdr.options_list_ptr->block2_ptr);
01602     free(tmp_hdr.options_list_ptr->block1_ptr);
01603     free(tmp_hdr.options_list_ptr->size1_ptr);
01604     free(tmp_hdr.options_list_ptr);
01605     free(tmp_hdr.payload_ptr);
01606     free(tmp_addr.addr_ptr);
01607     free(dst_packet_data_ptr);
01608 
01609     retCounter = 7;
01610     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01611     CHECK( NULL == ret );
01612     free(payload);
01613 //    sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01614 
01615     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01616     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01617     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01618 
01619     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01620     memset(list, 0, sizeof(sn_coap_options_list_s));
01621     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01622     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
01623     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0x08;
01624     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 1;
01625     sn_coap_parser_stub.expectedHeader->msg_id = 44;
01626     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01627     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01628     payload = (uint8_t*)malloc(5);
01629     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01630     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01631 
01632     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01633     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01634 
01635     dst_packet_data_ptr = (uint8_t*)malloc(5);
01636     memset(dst_packet_data_ptr, '1', 5);
01637 
01638     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01639     memset(tmp_addr.addr_ptr, '1', 5);
01640 
01641     retCounter = 21;
01642     sn_coap_builder_stub.expectedInt16 = 1;
01643     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01644     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01645     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01646     tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01647     tmp_hdr.msg_id = 44;
01648     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01649     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01650 
01651     free(tmp_hdr.options_list_ptr->block2_ptr);
01652     free(tmp_hdr.options_list_ptr->block1_ptr);
01653     free(tmp_hdr.options_list_ptr->size1_ptr);
01654     free(tmp_hdr.options_list_ptr);
01655     free(tmp_hdr.payload_ptr);
01656     free(tmp_addr.addr_ptr);
01657     free(dst_packet_data_ptr);
01658 
01659     retCounter = 8;
01660     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01661     CHECK( NULL == ret );
01662     free(payload);
01663 
01664     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01665     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01666     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01667 
01668     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01669     memset(list, 0, sizeof(sn_coap_options_list_s));
01670     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01671     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
01672     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0xa8;
01673     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[1] = 0xa8;
01674     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 2;
01675     sn_coap_parser_stub.expectedHeader->msg_id = 45;
01676     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01677     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01678     payload = (uint8_t*)malloc(5);
01679     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01680     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01681 
01682     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01683     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01684 
01685     dst_packet_data_ptr = (uint8_t*)malloc(5);
01686     memset(dst_packet_data_ptr, '1', 5);
01687 
01688     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01689     memset(tmp_addr.addr_ptr, '1', 5);
01690 
01691     retCounter = 21;
01692     sn_coap_builder_stub.expectedInt16 = 1;
01693     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01694     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01695     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01696     tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01697     tmp_hdr.msg_id = 45;
01698     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01699     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01700 
01701     free(tmp_hdr.options_list_ptr->block2_ptr);
01702     free(tmp_hdr.options_list_ptr->block1_ptr);
01703     free(tmp_hdr.options_list_ptr->size1_ptr);
01704     free(tmp_hdr.options_list_ptr);
01705     free(tmp_hdr.payload_ptr);
01706     free(tmp_addr.addr_ptr);
01707     free(dst_packet_data_ptr);
01708 
01709     sn_coap_builder_stub.expectedInt16 = -1;
01710     retCounter = 9;
01711     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01712     CHECK( NULL == ret );
01713     free(payload);
01714 
01715     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01716     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01717     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01718 
01719     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01720     memset(list, 0, sizeof(sn_coap_options_list_s));
01721     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01722     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
01723     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0xc8;
01724     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[1] = 0xc8;
01725     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[2] = 0xc8;
01726     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 3;
01727     sn_coap_parser_stub.expectedHeader->msg_id = 46;
01728     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01729     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01730     payload = (uint8_t*)malloc(5);
01731     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01732     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01733 
01734     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01735     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01736 
01737     dst_packet_data_ptr = (uint8_t*)malloc(5);
01738     memset(dst_packet_data_ptr, '1', 5);
01739 
01740     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01741     memset(tmp_addr.addr_ptr, '1', 5);
01742 
01743     retCounter = 21;
01744     sn_coap_builder_stub.expectedInt16 = 1;
01745     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01746     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01747     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01748     tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01749     tmp_hdr.msg_id = 46;
01750     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01751     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01752 
01753     free(tmp_hdr.options_list_ptr->block2_ptr);
01754     free(tmp_hdr.options_list_ptr->block1_ptr);
01755     free(tmp_hdr.options_list_ptr->size1_ptr);
01756     free(tmp_hdr.options_list_ptr);
01757     free(tmp_hdr.payload_ptr);
01758     free(tmp_addr.addr_ptr);
01759     free(dst_packet_data_ptr);
01760 
01761     sn_coap_builder_stub.expectedInt16 = 1;
01762     retCounter = 9;
01763     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01764     CHECK( NULL == ret );
01765     free(payload);
01766 
01767     sn_coap_protocol_destroy(handle);
01768     retCounter = 1;
01769     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01770 
01771     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01772     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01773     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01774 
01775     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01776     memset(list, 0, sizeof(sn_coap_options_list_s));
01777     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01778     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
01779     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0xc8;
01780     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[1] = 0xc8;
01781     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[2] = 0xc8;
01782     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 3;
01783     sn_coap_parser_stub.expectedHeader->msg_id = 47;
01784     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01785     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01786     payload = (uint8_t*)malloc(5);
01787     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01788     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01789 
01790     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01791     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01792 
01793     dst_packet_data_ptr = (uint8_t*)malloc(5);
01794     memset(dst_packet_data_ptr, '1', 5);
01795 
01796     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01797     memset(tmp_addr.addr_ptr, '1', 5);
01798 
01799     retCounter = 21;
01800     sn_coap_builder_stub.expectedInt16 = 1;
01801     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01802     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01803     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01804     tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01805     tmp_hdr.msg_id = 47;
01806     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01807     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01808 
01809     free(tmp_hdr.options_list_ptr->block2_ptr);
01810     free(tmp_hdr.options_list_ptr->block1_ptr);
01811     free(tmp_hdr.options_list_ptr->size1_ptr);
01812     free(tmp_hdr.options_list_ptr);
01813     free(tmp_hdr.payload_ptr);
01814     free(tmp_addr.addr_ptr);
01815     free(dst_packet_data_ptr);
01816 
01817     sn_coap_builder_stub.expectedInt16 = 1;
01818     retCounter = 10;
01819     sn_coap_protocol_set_retransmission_buffer(handle,0,0);
01820     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01821     CHECK( NULL != ret );
01822     free(payload);
01823     sn_coap_parser_release_allocated_coap_msg_mem(handle, ret);
01824 
01825     sn_coap_protocol_destroy(handle);
01826     retCounter = 1;
01827     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01828 
01829     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01830     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01831     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01832 
01833     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01834     memset(list, 0, sizeof(sn_coap_options_list_s));
01835     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01836     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
01837     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[0] = 0xc8;
01838     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[1] = 0xc8;
01839     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr[2] = 0xc8;
01840     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_len = 3;
01841     sn_coap_parser_stub.expectedHeader->msg_id = 47;
01842     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01843     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01844     payload = (uint8_t*)malloc(5);
01845     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01846     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01847 
01848     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01849     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01850 
01851     dst_packet_data_ptr = (uint8_t*)malloc(5);
01852     memset(dst_packet_data_ptr, '1', 5);
01853 
01854     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01855     memset(tmp_addr.addr_ptr, '1', 5);
01856 
01857     retCounter = 21;
01858     sn_coap_builder_stub.expectedInt16 = 1;
01859     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01860     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01861     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01862     tmp_hdr.options_list_ptr->block2_ptr = (uint8_t*)malloc(1);
01863     tmp_hdr.msg_id = 47;
01864     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01865     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01866 
01867     free(tmp_hdr.options_list_ptr->block2_ptr);
01868     free(tmp_hdr.options_list_ptr->block1_ptr);
01869     free(tmp_hdr.options_list_ptr->size1_ptr);
01870     free(tmp_hdr.options_list_ptr);
01871     free(tmp_hdr.payload_ptr);
01872     free(tmp_addr.addr_ptr);
01873     free(dst_packet_data_ptr);
01874 
01875     sn_coap_builder_stub.expectedInt16 = 1;
01876     retCounter = 10;
01877     sn_coap_protocol_set_retransmission_buffer(handle,2,1);
01878     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01879     CHECK( NULL != ret );
01880     free(payload);
01881     sn_coap_parser_release_allocated_coap_msg_mem(handle, ret);
01882 
01883     // <-- block2_ptr[0] == 0x08
01884 
01885     //<-- Test sn_coap_handle_blockwise_message, block2_ptr != NULL
01886 
01887     sn_coap_protocol_destroy(handle);
01888     retCounter = 1;
01889     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01890 
01891     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01892     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01893     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01894 
01895     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01896     memset(list, 0, sizeof(sn_coap_options_list_s));
01897     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01898     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
01899     sn_coap_parser_stub.expectedHeader->msg_id = 41;
01900     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01901     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01902     payload = (uint8_t*)malloc(5);
01903     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01904     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01905 
01906     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01907     CHECK( NULL == ret );
01908     free(payload);
01909     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01910 
01911     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01912     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01913     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01914 
01915     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01916     memset(list, 0, sizeof(sn_coap_options_list_s));
01917     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01918     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
01919     sn_coap_parser_stub.expectedHeader->msg_id = 42;
01920     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01921     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01922     payload = (uint8_t*)malloc(5);
01923     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01924     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01925 
01926     retCounter = 1;
01927     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01928     CHECK( NULL == ret );
01929     free(payload);
01930     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01931 
01932     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01933     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01934     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01935 
01936     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01937     memset(list, 0, sizeof(sn_coap_options_list_s));
01938     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01939     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
01940     sn_coap_parser_stub.expectedHeader->msg_id = 43;
01941     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01942     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01943     payload = (uint8_t*)malloc(5);
01944     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01945     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01946 
01947     retCounter = 2;
01948     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01949     CHECK( NULL == ret );
01950     free(payload);
01951     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01952 
01953     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01954     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01955     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01956 
01957     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01958     memset(list, 0, sizeof(sn_coap_options_list_s));
01959     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01960     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
01961     sn_coap_parser_stub.expectedHeader->msg_id = 44;
01962     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01963     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01964     payload = (uint8_t*)malloc(5);
01965     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01966     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01967 
01968     retCounter = 3;
01969     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01970     CHECK( NULL == ret );
01971     free(payload);
01972     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01973 
01974     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01975     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01976     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01977 
01978     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01979     memset(list, 0, sizeof(sn_coap_options_list_s));
01980     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01981     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
01982     sn_coap_parser_stub.expectedHeader->msg_id = 45;
01983     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01984     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01985     payload = (uint8_t*)malloc(5);
01986     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01987     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01988 
01989     retCounter = 4;
01990     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01991     CHECK( NULL == ret );
01992     free(payload);
01993     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01994 
01995     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01996     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01997     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01998 
01999     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
02000     memset(list, 0, sizeof(sn_coap_options_list_s));
02001     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
02002     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2_ptr = (uint8_t*)malloc(5);
02003     sn_coap_parser_stub.expectedHeader->msg_id = 46;
02004     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
02005     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
02006     payload = (uint8_t*)malloc(5);
02007     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
02008     sn_coap_parser_stub.expectedHeader->payload_len = 5;
02009 
02010     retCounter = 6;
02011     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
02012     CHECK( NULL != ret );
02013     free(payload);
02014     free(ret->payload_ptr);
02015     sn_coap_parser_release_allocated_coap_msg_mem(handle, ret);
02016 
02017     sn_coap_protocol_destroy(handle);
02018     retCounter = 1;
02019     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
02020 
02021     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
02022     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
02023     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
02024     sn_coap_parser_stub.expectedHeader->msg_id = 18;
02025 
02026     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
02027     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
02028 
02029     dst_packet_data_ptr = (uint8_t*)malloc(5);
02030     memset(dst_packet_data_ptr, '1', 5);
02031     dst_packet_data_ptr[2]=0;
02032     dst_packet_data_ptr[3]=18;
02033 
02034     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
02035     memset(tmp_addr.addr_ptr, '1', 5);
02036     tmp_addr.port = 0;
02037 
02038     retCounter = 21;
02039     sn_coap_builder_stub.expectedInt16 = 5;
02040     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
02041     tmp_hdr.msg_id = 18;
02042     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
02043     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
02044     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
02045 
02046     free(tmp_hdr.options_list_ptr->block2_ptr);
02047     free(tmp_hdr.options_list_ptr->size2_ptr);
02048     free(tmp_hdr.options_list_ptr);
02049     free(tmp_hdr.payload_ptr);
02050     free(tmp_addr.addr_ptr);
02051     free(dst_packet_data_ptr);
02052 
02053     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
02054     CHECK( ret != NULL );
02055     sn_coap_parser_release_allocated_coap_msg_mem(handle, ret);
02056 
02057     sn_coap_protocol_destroy(handle);
02058 
02059     retCounter = 1;
02060     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
02061 
02062     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
02063     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
02064     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_RESET;
02065     sn_coap_parser_stub.expectedHeader->msg_id = 18;
02066 
02067     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
02068     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
02069 
02070     dst_packet_data_ptr = (uint8_t*)malloc(5);
02071     memset(dst_packet_data_ptr, '1', 5);
02072     dst_packet_data_ptr[2]=0;
02073     dst_packet_data_ptr[3]=18;
02074 
02075     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
02076     memset(tmp_addr.addr_ptr, '1', 5);
02077     tmp_addr.port = 0;
02078 
02079     retCounter = 21;
02080     sn_coap_builder_stub.expectedInt16 = 5;
02081     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
02082     tmp_hdr.msg_id = 18;
02083     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
02084     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
02085     tmp_hdr.uri_path_ptr = (uint8_t*)malloc(7);
02086     snprintf((char *)tmp_hdr.uri_path_ptr, 7, "13/0/1");
02087     tmp_hdr.uri_path_len = 7;
02088 
02089     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
02090 
02091     free(tmp_hdr.uri_path_ptr);
02092     free(tmp_hdr.options_list_ptr->block2_ptr);
02093     free(tmp_hdr.options_list_ptr->size2_ptr);
02094     free(tmp_hdr.options_list_ptr);
02095     free(tmp_hdr.payload_ptr);
02096     free(tmp_addr.addr_ptr);
02097     free(dst_packet_data_ptr);
02098 
02099     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
02100     CHECK( ret != NULL );
02101     sn_coap_parser_release_allocated_coap_msg_mem(handle, ret);
02102 
02103     sn_coap_protocol_destroy(handle);
02104 
02105     retCounter = 1;
02106     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
02107 
02108     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
02109     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
02110     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
02111     sn_coap_parser_stub.expectedHeader->msg_id = 18;
02112 
02113     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
02114     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
02115 
02116     dst_packet_data_ptr = (uint8_t*)malloc(5);
02117     memset(dst_packet_data_ptr, '1', 5);
02118     dst_packet_data_ptr[2]=0;
02119     dst_packet_data_ptr[3]=185;
02120 
02121     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
02122     memset(tmp_addr.addr_ptr, '1', 5);
02123     tmp_addr.port = 0;
02124 
02125     retCounter = 21;
02126     sn_coap_builder_stub.expectedInt16 = 5;
02127     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
02128     tmp_hdr.msg_id = 18;
02129     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
02130     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
02131     tmp_hdr.uri_path_ptr = (uint8_t*)malloc(7);
02132     snprintf((char *)tmp_hdr.uri_path_ptr, 7, "13/0/1");
02133     tmp_hdr.uri_path_len = 7;
02134     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
02135 
02136     free(tmp_hdr.options_list_ptr->block2_ptr);
02137     free(tmp_hdr.options_list_ptr->size2_ptr);
02138     free(tmp_hdr.options_list_ptr);
02139     free(tmp_hdr.payload_ptr);
02140     free(tmp_addr.addr_ptr);
02141     free(dst_packet_data_ptr);
02142 
02143     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
02144     CHECK( ret != NULL );
02145     sn_coap_parser_release_allocated_coap_msg_mem(handle, ret);
02146 
02147     free(tmp_hdr.uri_path_ptr);
02148     free(packet_data_ptr);
02149     free(addr->addr_ptr);
02150     free(addr);
02151     sn_coap_protocol_destroy(handle);
02152 }
02153 
02154 TEST(libCoap_protocol, sn_coap_protocol_exec)
02155 {
02156     CHECK(-1 == sn_coap_protocol_exec(NULL, 0));
02157 
02158     retCounter = 1;
02159     struct coap_s * handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
02160 
02161     sn_nsdl_addr_s tmp_addr;
02162     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
02163     sn_coap_hdr_s tmp_hdr;
02164     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
02165 
02166     uint8_t* dst_packet_data_ptr = (uint8_t*)malloc(5);
02167     memset(dst_packet_data_ptr, '1', 5);
02168 
02169     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
02170     memset(tmp_addr.addr_ptr, '1', 5);
02171 
02172     retCounter = 21;
02173     sn_coap_builder_stub.expectedInt16 = 5;
02174     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
02175     tmp_hdr.msg_id = 18;
02176     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
02177     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
02178     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
02179 
02180     free(tmp_hdr.options_list_ptr->block2_ptr);
02181     free(tmp_hdr.options_list_ptr->size2_ptr);
02182     free(tmp_hdr.options_list_ptr);
02183     free(tmp_hdr.payload_ptr);
02184     free(tmp_addr.addr_ptr);
02185     free(dst_packet_data_ptr);
02186 
02187     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
02188     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
02189     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
02190     sn_coap_parser_stub.expectedHeader->msg_id = 7;
02191 
02192     sn_coap_options_list_s* list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
02193     memset(list, 0, sizeof(sn_coap_options_list_s));
02194     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
02195     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(5);
02196     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
02197     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_GET;
02198     uint8_t* payload = (uint8_t*)malloc(17);
02199     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
02200     sn_coap_parser_stub.expectedHeader->payload_len = 17;
02201 
02202     uint8_t *packet_data_ptr = (uint8_t*)malloc(5);
02203     uint16_t packet_data_len = 5;
02204 
02205     sn_nsdl_addr_s* addr = (sn_nsdl_addr_s*)malloc(sizeof(sn_nsdl_addr_s));
02206     memset(addr, 0, sizeof(sn_nsdl_addr_s));
02207 
02208     addr->addr_ptr = (uint8_t*)malloc(5);
02209 
02210     retCounter = 5;
02211     sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
02212     free(payload);
02213     free(packet_data_ptr);
02214     free(addr->addr_ptr);
02215     free(addr);
02216 
02217     CHECK(0 == sn_coap_protocol_exec(handle, 600));
02218 
02219     sn_coap_builder_stub.expectedInt16 = 0;
02220     retCounter = 0;
02221     sn_coap_protocol_destroy(handle);
02222 }
02223 
02224 TEST(libCoap_protocol, sn_coap_protocol_exec2)
02225 {
02226     retCounter = 1;
02227     struct coap_s * handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, null_rx_cb);
02228 
02229     sn_nsdl_addr_s tmp_addr;
02230     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
02231     sn_coap_hdr_s tmp_hdr;
02232     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
02233 
02234     uint8_t* dst_packet_data_ptr = (uint8_t*)malloc(5);
02235     memset(dst_packet_data_ptr, '1', 5);
02236 
02237     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
02238     memset(tmp_addr.addr_ptr, '1', 5);
02239 
02240     retCounter = 21;
02241     sn_coap_builder_stub.expectedInt16 = 5;
02242     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
02243     tmp_hdr.msg_id = 18;
02244     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
02245     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
02246     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
02247 
02248     free(tmp_hdr.options_list_ptr->block2_ptr);
02249     free(tmp_hdr.options_list_ptr->size2_ptr);
02250     free(tmp_hdr.options_list_ptr);
02251     free(tmp_hdr.payload_ptr);
02252     free(tmp_addr.addr_ptr);
02253     free(dst_packet_data_ptr);
02254 
02255     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
02256     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
02257     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
02258     sn_coap_parser_stub.expectedHeader->msg_id = 7;
02259 
02260     sn_coap_options_list_s* list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
02261     memset(list, 0, sizeof(sn_coap_options_list_s));
02262     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
02263     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1_ptr = (uint8_t*)malloc(5);
02264     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
02265     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_GET;
02266     uint8_t* payload = (uint8_t*)malloc(17);
02267     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
02268     sn_coap_parser_stub.expectedHeader->payload_len = 17;
02269 
02270     uint8_t *packet_data_ptr = (uint8_t*)malloc(5);
02271     uint16_t packet_data_len = 5;
02272 
02273     sn_nsdl_addr_s* addr = (sn_nsdl_addr_s*)malloc(sizeof(sn_nsdl_addr_s));
02274     memset(addr, 0, sizeof(sn_nsdl_addr_s));
02275 
02276     addr->addr_ptr = (uint8_t*)malloc(5);
02277 
02278     retCounter = 5;
02279     sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
02280     free(payload);
02281     free(packet_data_ptr);
02282     free(addr->addr_ptr);
02283     free(addr);
02284 
02285     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
02286     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
02287 
02288     sn_coap_protocol_set_retransmission_parameters(handle,0, 5);
02289     CHECK(0 == sn_coap_protocol_exec(handle, 600));
02290 
02291     sn_coap_builder_stub.expectedInt16 = 0;
02292     retCounter = 0;
02293     sn_coap_protocol_destroy(handle);
02294 }
02295