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