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     hdr2->payload_ptr = (uint8_t*)malloc(3);
00388 
00389     for( int i=0; i < 8; i++ ){
00390         retCounter = 1 + i;
00391         sn_coap_builder_stub.expectedInt16 = 1;
00392         hdr2->payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00393         int8_t rett = sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, hdr2, NULL);
00394         CHECK( -2 == rett );
00395     }
00396 
00397     retCounter = 11;
00398     sn_coap_builder_stub.expectedInt16 = 1;
00399     hdr2->payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00400     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, hdr2, NULL));
00401 
00402     retCounter = 19;
00403     sn_coap_builder_stub.expectedInt16 = 1;
00404     hdr2->payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00405     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, hdr2, NULL));
00406 
00407     free(hdr2->payload_ptr);
00408     sn_coap_parser_release_allocated_coap_msg_mem(handle, hdr2);
00409     hdr2 = NULL;
00410 
00411     //<-- Test sn_coap_protocol_copy_header here
00412 
00413     hdr.msg_code = COAP_MSG_CODE_REQUEST_GET;
00414     retCounter = 5;
00415     sn_coap_builder_stub.expectedInt16 = 1;
00416     hdr.payload_len = 0;
00417     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00418 
00419     sn_coap_protocol_destroy(handle);
00420     handle = NULL;
00421     retCounter = 1;
00422     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
00423 
00424     retCounter = 6;
00425     sn_coap_builder_stub.expectedInt16 = 1;
00426     hdr.payload_len = 0;
00427     CHECK( -2 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00428 
00429     retCounter = 7;
00430     sn_coap_builder_stub.expectedInt16 = 1;
00431     hdr.payload_len = 0;
00432     CHECK( 1 == sn_coap_protocol_build(handle, &addr, dst_packet_data_ptr, &hdr, NULL));
00433 
00434     free(hdr.payload_ptr);
00435     hdr.payload_ptr = NULL;
00436     hdr.payload_len = 0;
00437 
00438     hdr.msg_code = COAP_MSG_CODE_EMPTY;
00439 
00440     // <-- Test second SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE
00441 
00442     free(addr.addr_ptr);
00443     free(dst_packet_data_ptr);
00444     sn_coap_protocol_destroy(handle);
00445 }
00446 
00447 TEST(libCoap_protocol, sn_coap_protocol_parse)
00448 {
00449     CHECK( NULL == sn_coap_protocol_parse(NULL, NULL, 0, NULL, NULL) );
00450 
00451     retCounter = 1;
00452     struct coap_s * handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
00453 
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 = 4;
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     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
00847     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00848     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
00849     tmp_hdr.options_list_ptr->block2 = 1;
00850     tmp_hdr.msg_id = 16;
00851     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00852     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
00853 
00854     free(tmp_hdr.options_list_ptr);
00855     free(tmp_hdr.payload_ptr);
00856     free(tmp_addr.addr_ptr);
00857     free(dst_packet_data_ptr);
00858 
00859     retCounter = 2;
00860     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00861     CHECK( NULL == ret );
00862     free(payload);
00863 
00864     sn_coap_protocol_destroy(handle);
00865     retCounter = 1;
00866     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
00867 
00868     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00869     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00870     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00871     sn_coap_parser_stub.expectedHeader->msg_id = 17;
00872 
00873     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00874     memset(list, 0, sizeof(sn_coap_options_list_s));
00875     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00876     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = 0x08;
00877     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00878     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
00879     payload = (uint8_t*)malloc(17);
00880     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00881     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00882 
00883     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
00884     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
00885 
00886     dst_packet_data_ptr = (uint8_t*)malloc(5);
00887     memset(dst_packet_data_ptr, '1', 5);
00888 
00889     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
00890     memset(tmp_addr.addr_ptr, '1', 5);
00891 
00892     retCounter = 21;
00893     sn_coap_builder_stub.expectedInt16 = 1;
00894     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
00895     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00896     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
00897     tmp_hdr.options_list_ptr->block1 = -1;
00898     tmp_hdr.options_list_ptr->block2 = 1;
00899     tmp_hdr.msg_id = 17;
00900     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00901 
00902     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
00903 
00904     free(tmp_hdr.options_list_ptr);
00905     free(tmp_hdr.payload_ptr);
00906     free(tmp_addr.addr_ptr);
00907     free(dst_packet_data_ptr);
00908 
00909     retCounter = 2;
00910     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00911     CHECK( NULL == ret );
00912     free(payload);
00913 
00914     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00915     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00916     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00917     sn_coap_parser_stub.expectedHeader->msg_id = 18;
00918 
00919     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00920     memset(list, 0, sizeof(sn_coap_options_list_s));
00921     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00922     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = 0xe808;
00923     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00924     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
00925     payload = (uint8_t*)malloc(17);
00926     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00927     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00928 
00929 
00930     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
00931     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
00932 
00933     dst_packet_data_ptr = (uint8_t*)malloc(5);
00934     memset(dst_packet_data_ptr, '1', 5);
00935 
00936     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
00937     memset(tmp_addr.addr_ptr, '1', 5);
00938 
00939     retCounter = 20;
00940     sn_coap_builder_stub.expectedInt16 = 1;
00941     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
00942 //    tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00943 //    memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
00944 //    tmp_hdr.options_list_ptr->block2 = 1;
00945     tmp_hdr.msg_id = 18;
00946     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
00947     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
00948     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
00949 
00950     free(tmp_hdr.options_list_ptr);
00951     tmp_hdr.options_list_ptr = NULL;
00952 
00953     tmp_hdr.payload_len = UINT16_MAX;
00954     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
00955     free(tmp_hdr.options_list_ptr);
00956     free(tmp_hdr.payload_ptr);
00957     tmp_hdr.payload_ptr = NULL;
00958     free(tmp_addr.addr_ptr);
00959     free(dst_packet_data_ptr);
00960 
00961     retCounter = 2;
00962     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
00963     CHECK( NULL == ret );
00964     free(payload);
00965 
00966     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
00967     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
00968     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
00969     sn_coap_parser_stub.expectedHeader->msg_id = 19;
00970 
00971     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00972     memset(list, 0, sizeof(sn_coap_options_list_s));
00973     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
00974     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = 0xeee808;
00975     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
00976     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
00977     payload = (uint8_t*)malloc(17);
00978     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
00979     sn_coap_parser_stub.expectedHeader->payload_len = 17;
00980 
00981     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
00982     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
00983 
00984     dst_packet_data_ptr = (uint8_t*)malloc(5);
00985     memset(dst_packet_data_ptr, '1', 5);
00986 
00987     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
00988     memset(tmp_addr.addr_ptr, '1', 5);
00989 
00990     retCounter = 21;
00991     sn_coap_builder_stub.expectedInt16 = 1;
00992     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
00993 //    tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
00994 //    memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
00995 //    tmp_hdr.options_list_ptr->block2 = 1;
00996     tmp_hdr.msg_id = 19;
00997     tmp_hdr.msg_code = COAP_MSG_CODE_REQUEST_GET;
00998     tmp_hdr.payload_len = 1;
00999     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01000 
01001     free(tmp_hdr.options_list_ptr);
01002     free(tmp_hdr.payload_ptr);
01003     tmp_hdr.payload_ptr = NULL;
01004     free(tmp_addr.addr_ptr);
01005     free(dst_packet_data_ptr);
01006 
01007     retCounter = 2;
01008     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01009     CHECK( NULL == ret );
01010     free(payload);
01011 
01012     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01013     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01014     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01015     sn_coap_parser_stub.expectedHeader->msg_id = 20;
01016 
01017     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01018     memset(list, 0, sizeof(sn_coap_options_list_s));
01019     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01020     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = 0xeee808;
01021     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01022     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01023     payload = (uint8_t*)malloc(17);
01024     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01025     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01026 
01027     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01028     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01029 
01030     dst_packet_data_ptr = (uint8_t*)malloc(5);
01031     memset(dst_packet_data_ptr, '1', 5);
01032 
01033     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01034     memset(tmp_addr.addr_ptr, '1', 5);
01035 
01036     retCounter = 21;
01037     sn_coap_builder_stub.expectedInt16 = 1;
01038     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01039 //    tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01040 //    memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01041 //    tmp_hdr.options_list_ptr->block2 = 1;
01042     tmp_hdr.msg_id = 20;
01043     tmp_hdr.msg_code = COAP_MSG_CODE_REQUEST_GET;
01044     tmp_hdr.payload_len = 1;
01045     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01046 
01047     free(tmp_hdr.options_list_ptr);
01048     free(tmp_hdr.payload_ptr);
01049     tmp_hdr.payload_ptr = NULL;
01050     free(tmp_addr.addr_ptr);
01051     free(dst_packet_data_ptr);
01052 
01053     retCounter = 5;
01054     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01055     CHECK( NULL != ret );
01056     CHECK( COAP_STATUS_PARSER_BLOCKWISE_ACK == ret->coap_status );
01057     free(payload);
01058     sn_coap_parser_release_allocated_coap_msg_mem(handle, ret);
01059 
01060     //<-- block1 == 0x08
01061     //<-- Test sn_coap_handle_blockwise_message, block1 != -1
01062 
01063     sn_coap_protocol_destroy(handle);
01064     retCounter = 1;
01065     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01066 
01067     //Test sn_coap_handle_blockwise_message, block2 != -1 -->
01068     sn_coap_protocol_set_duplicate_buffer_size(handle,1);
01069 
01070     // block2 length == 1,2,3 -->
01071 
01072     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01073     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01074     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01075     sn_coap_parser_stub.expectedHeader->msg_id = 16;
01076 
01077     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01078     memset(list, 0, sizeof(sn_coap_options_list_s));
01079     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01080     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0x08;
01081     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01082     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
01083     payload = (uint8_t*)malloc(17);
01084     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01085     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01086     sn_coap_parser_stub.expectedHeader->uri_path_ptr = NULL;
01087 
01088     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01089     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01090 
01091     dst_packet_data_ptr = (uint8_t*)malloc(5);
01092     memset(dst_packet_data_ptr, '1', 5);
01093 
01094     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01095     memset(tmp_addr.addr_ptr, '1', 5);
01096 
01097     retCounter = 20;
01098     sn_coap_builder_stub.expectedInt16 = 1;
01099     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01100     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01101     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01102     tmp_hdr.options_list_ptr->block2 = 1;
01103     tmp_hdr.msg_id = 16;
01104     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01105     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01106 
01107     free(tmp_hdr.options_list_ptr);
01108     free(tmp_hdr.payload_ptr);
01109     free(tmp_addr.addr_ptr);
01110     free(dst_packet_data_ptr);
01111 
01112     retCounter = 2;
01113     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01114     CHECK( NULL == ret );
01115     free(payload);
01116 //    sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01117 
01118     sn_coap_protocol_destroy(handle);
01119     retCounter = 1;
01120     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01121 
01122     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01123     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01124     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01125     sn_coap_parser_stub.expectedHeader->msg_id = 17;
01126 
01127     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01128     memset(list, 0, sizeof(sn_coap_options_list_s));
01129     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01130     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0x08;
01131     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01132     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
01133     payload = (uint8_t*)malloc(17);
01134     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01135     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01136 
01137     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01138     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01139 
01140     dst_packet_data_ptr = (uint8_t*)malloc(5);
01141     memset(dst_packet_data_ptr, '1', 5);
01142 
01143     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01144     memset(tmp_addr.addr_ptr, '1', 5);
01145 
01146     retCounter = 21;
01147     sn_coap_builder_stub.expectedInt16 = 1;
01148     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01149     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01150     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01151     tmp_hdr.options_list_ptr->block1 = -1;
01152     tmp_hdr.options_list_ptr->block2 = 1;
01153     tmp_hdr.msg_id = 17;
01154     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01155 
01156     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01157 
01158     free(tmp_hdr.options_list_ptr);
01159     free(tmp_hdr.payload_ptr);
01160     free(tmp_addr.addr_ptr);
01161     free(dst_packet_data_ptr);
01162 
01163     retCounter = 3;
01164     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01165     CHECK( NULL == ret );
01166     free(payload);
01167 //    sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01168 
01169     sn_coap_protocol_destroy(handle);
01170     retCounter = 1;
01171     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01172 
01173     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01174     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01175     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01176     sn_coap_parser_stub.expectedHeader->msg_id = 18;
01177 
01178     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01179     memset(list, 0, sizeof(sn_coap_options_list_s));
01180     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01181     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0xe808;
01182     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01183     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
01184     payload = (uint8_t*)malloc(17);
01185     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01186     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01187 
01188 
01189     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01190     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01191 
01192     dst_packet_data_ptr = (uint8_t*)malloc(5);
01193     memset(dst_packet_data_ptr, '1', 5);
01194 
01195     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01196     memset(tmp_addr.addr_ptr, '1', 5);
01197 
01198     retCounter = 20;
01199     sn_coap_builder_stub.expectedInt16 = 1;
01200     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01201     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01202     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01203     tmp_hdr.options_list_ptr->use_size2 = true;
01204     tmp_hdr.options_list_ptr->size2 = 0xFF01;
01205     tmp_hdr.msg_id = 18;
01206     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01207     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01208     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01209 
01210     free(tmp_hdr.options_list_ptr);
01211     free(tmp_hdr.payload_ptr);
01212     tmp_hdr.payload_ptr = NULL;
01213     free(tmp_addr.addr_ptr);
01214     free(dst_packet_data_ptr);
01215 
01216     retCounter = 3;
01217     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01218     CHECK( NULL == ret );
01219     free(payload);
01220 //    sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01221 
01222     sn_coap_protocol_destroy(handle);
01223     retCounter = 1;
01224     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01225 
01226     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01227     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01228     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01229     sn_coap_parser_stub.expectedHeader->msg_id = 19;
01230 
01231     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01232     memset(list, 0, sizeof(sn_coap_options_list_s));
01233     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01234     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0xeee808;
01235     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01236     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
01237     payload = (uint8_t*)malloc(17);
01238     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01239     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01240 
01241     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01242     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01243 
01244     dst_packet_data_ptr = (uint8_t*)malloc(5);
01245     memset(dst_packet_data_ptr, '1', 5);
01246 
01247     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01248     memset(tmp_addr.addr_ptr, '1', 5);
01249 
01250     retCounter = 21;
01251     sn_coap_builder_stub.expectedInt16 = 1;
01252     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01253 //    tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01254 //    memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01255 //    tmp_hdr.options_list_ptr->block2 = 1;
01256     tmp_hdr.msg_id = 19;
01257     tmp_hdr.msg_code = COAP_MSG_CODE_REQUEST_GET;
01258     tmp_hdr.payload_len = 1;
01259     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01260 
01261     free(tmp_hdr.options_list_ptr);
01262     free(tmp_hdr.payload_ptr);
01263     tmp_hdr.payload_ptr = NULL;
01264     free(tmp_addr.addr_ptr);
01265     free(dst_packet_data_ptr);
01266 
01267     retCounter = 2;
01268     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01269     CHECK( NULL == ret );
01270     free(payload);
01271 //    sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01272 
01273     sn_coap_protocol_destroy(handle);
01274     retCounter = 1;
01275     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01276 
01277     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01278     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01279     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01280     sn_coap_parser_stub.expectedHeader->msg_id = 200;
01281 
01282     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01283     memset(list, 0, sizeof(sn_coap_options_list_s));
01284     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01285     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0xeee808;
01286     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01287     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
01288     payload = (uint8_t*)malloc(17);
01289     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01290     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01291 
01292     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01293     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01294 
01295     dst_packet_data_ptr = (uint8_t*)malloc(5);
01296     memset(dst_packet_data_ptr, '1', 5);
01297 
01298     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01299     memset(tmp_addr.addr_ptr, '1', 5);
01300 
01301     retCounter = 21;
01302     sn_coap_builder_stub.expectedInt16 = 1;
01303     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01304     tmp_hdr.msg_id = 200;
01305     tmp_hdr.msg_code = COAP_MSG_CODE_REQUEST_GET;
01306     tmp_hdr.payload_len = 1;
01307     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01308 
01309     free(tmp_hdr.options_list_ptr);
01310     free(tmp_hdr.payload_ptr);
01311     tmp_hdr.payload_ptr = NULL;
01312     free(tmp_addr.addr_ptr);
01313     free(dst_packet_data_ptr);
01314 
01315     retCounter = 3;
01316     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01317     CHECK( NULL == ret );
01318     free(payload);
01319 //    sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01320 
01321 
01322     sn_coap_protocol_destroy(handle);
01323     retCounter = 1;
01324     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01325 
01326     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01327     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01328     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01329     sn_coap_parser_stub.expectedHeader->msg_id = 20;
01330 
01331     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01332     memset(list, 0, sizeof(sn_coap_options_list_s));
01333     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01334     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01335     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0xeee808;
01336     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01337     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_DELETE;
01338     payload = (uint8_t*)malloc(17);
01339     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01340     sn_coap_parser_stub.expectedHeader->payload_len = 17;
01341 
01342     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01343     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01344 
01345     dst_packet_data_ptr = (uint8_t*)malloc(5);
01346     memset(dst_packet_data_ptr, '1', 5);
01347 
01348     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01349     memset(tmp_addr.addr_ptr, '1', 5);
01350 
01351     retCounter = 20;
01352     sn_coap_builder_stub.expectedInt16 = 1;
01353     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01354 
01355     tmp_hdr.msg_id = 20;
01356     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01357     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01358     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01359 
01360     free(tmp_hdr.options_list_ptr);
01361     free(tmp_hdr.payload_ptr);
01362     tmp_hdr.payload_ptr = NULL;
01363     free(tmp_addr.addr_ptr);
01364     free(dst_packet_data_ptr);
01365 
01366     retCounter = 6;
01367     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01368     CHECK( NULL != ret );
01369     CHECK( COAP_STATUS_PARSER_BLOCKWISE_ACK == ret->coap_status );
01370     free(payload);
01371     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01372 
01373     //<-- block2 length == 1,2,3
01374 
01375     // block2 == 0x08 -->
01376 
01377     sn_coap_protocol_destroy(handle);
01378     retCounter = 1;
01379     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01380 
01381     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01382     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01383     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01384 
01385     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01386     memset(list, 0, sizeof(sn_coap_options_list_s));
01387     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01388     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01389     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0x08;
01390     sn_coap_parser_stub.expectedHeader->msg_id = 41;
01391     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01392     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01393     payload = (uint8_t*)malloc(5);
01394     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01395     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01396 
01397     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01398     CHECK( NULL == ret );
01399     free(payload);
01400 
01401     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01402     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01403     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01404 
01405     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01406     memset(list, 0, sizeof(sn_coap_options_list_s));
01407     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01408     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01409     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0x08;
01410     sn_coap_parser_stub.expectedHeader->msg_id = 41;
01411     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01412     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01413     payload = (uint8_t*)malloc(5);
01414     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01415     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01416 
01417     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01418     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01419 
01420     dst_packet_data_ptr = (uint8_t*)malloc(5);
01421     memset(dst_packet_data_ptr, '1', 5);
01422 
01423     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01424     memset(tmp_addr.addr_ptr, '1', 5);
01425 
01426     retCounter = 20;
01427     sn_coap_builder_stub.expectedInt16 = 1;
01428     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01429     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01430     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01431     tmp_hdr.options_list_ptr->block2 = 1;
01432     tmp_hdr.msg_id = 41;
01433     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01434     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01435 
01436     free(tmp_hdr.options_list_ptr);
01437     free(tmp_hdr.payload_ptr);
01438     free(tmp_addr.addr_ptr);
01439     free(dst_packet_data_ptr);
01440 
01441     retCounter = 0;
01442     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01443     CHECK( NULL == ret );
01444     free(payload);
01445     free(list);
01446     free(sn_coap_parser_stub.expectedHeader);
01447 
01448     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01449     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01450     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01451 
01452     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01453     memset(list, 0, sizeof(sn_coap_options_list_s));
01454     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01455     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01456     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0x08;
01457     sn_coap_parser_stub.expectedHeader->msg_id = 42;
01458     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01459     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01460     payload = (uint8_t*)malloc(5);
01461     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01462     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01463 
01464     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01465     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01466 
01467     dst_packet_data_ptr = (uint8_t*)malloc(5);
01468     memset(dst_packet_data_ptr, '1', 5);
01469 
01470     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01471     memset(tmp_addr.addr_ptr, '1', 5);
01472 
01473     retCounter = 20;
01474     sn_coap_builder_stub.expectedInt16 = 1;
01475     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01476     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01477     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01478     tmp_hdr.options_list_ptr->block2 = 1;
01479     tmp_hdr.msg_id = 42;
01480     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01481     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01482 
01483     free(tmp_hdr.options_list_ptr);
01484     free(tmp_hdr.payload_ptr);
01485     free(tmp_addr.addr_ptr);
01486     free(dst_packet_data_ptr);
01487 
01488     retCounter = 5;
01489     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01490     CHECK( NULL == ret );
01491     free(payload);
01492     free(list);
01493     free(sn_coap_parser_stub.expectedHeader);
01494 
01495     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01496     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01497     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01498 
01499     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01500     memset(list, 0, sizeof(sn_coap_options_list_s));
01501     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01502     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01503     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0x08;
01504     sn_coap_parser_stub.expectedHeader->msg_id = 43;
01505     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01506     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01507     payload = (uint8_t*)malloc(5);
01508     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01509     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01510 
01511     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01512     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01513 
01514     dst_packet_data_ptr = (uint8_t*)malloc(5);
01515     memset(dst_packet_data_ptr, '1', 5);
01516 
01517     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01518     memset(tmp_addr.addr_ptr, '1', 5);
01519 
01520     retCounter = 20;
01521     sn_coap_builder_stub.expectedInt16 = 1;
01522     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01523     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01524     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01525     tmp_hdr.options_list_ptr->block2 = 1;
01526     tmp_hdr.msg_id = 43;
01527     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01528     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01529 
01530     free(tmp_hdr.options_list_ptr);
01531     free(tmp_hdr.payload_ptr);
01532     free(tmp_addr.addr_ptr);
01533     free(dst_packet_data_ptr);
01534 
01535     retCounter = 6;
01536     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01537     CHECK( NULL == ret );
01538     free(payload);
01539 //    sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01540 
01541     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01542     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01543     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01544 
01545     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01546     memset(list, 0, sizeof(sn_coap_options_list_s));
01547     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01548     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01549     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0x08;
01550     sn_coap_parser_stub.expectedHeader->msg_id = 44;
01551     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01552     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01553     payload = (uint8_t*)malloc(5);
01554     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01555     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01556 
01557     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01558     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01559 
01560     dst_packet_data_ptr = (uint8_t*)malloc(5);
01561     memset(dst_packet_data_ptr, '1', 5);
01562 
01563     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01564     memset(tmp_addr.addr_ptr, '1', 5);
01565 
01566     retCounter = 20;
01567     sn_coap_builder_stub.expectedInt16 = 1;
01568     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01569     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01570     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01571     tmp_hdr.options_list_ptr->block2 = 1;
01572     tmp_hdr.msg_id = 44;
01573     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01574     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01575 
01576     free(tmp_hdr.options_list_ptr);
01577     free(tmp_hdr.payload_ptr);
01578     free(tmp_addr.addr_ptr);
01579     free(dst_packet_data_ptr);
01580 
01581     retCounter = 7;
01582     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01583     CHECK( NULL == ret );
01584     free(payload);
01585 
01586     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01587     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01588     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01589 
01590     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01591     memset(list, 0, sizeof(sn_coap_options_list_s));
01592     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01593     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01594     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0xa8a8;
01595     sn_coap_parser_stub.expectedHeader->msg_id = 45;
01596     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01597     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01598     payload = (uint8_t*)malloc(5);
01599     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01600     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01601 
01602     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01603     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01604 
01605     dst_packet_data_ptr = (uint8_t*)malloc(5);
01606     memset(dst_packet_data_ptr, '1', 5);
01607 
01608     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01609     memset(tmp_addr.addr_ptr, '1', 5);
01610 
01611     retCounter = 20;
01612     sn_coap_builder_stub.expectedInt16 = 1;
01613     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01614     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01615     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01616     tmp_hdr.options_list_ptr->block2 = 1;
01617     tmp_hdr.msg_id = 45;
01618     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01619     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01620 
01621     free(tmp_hdr.options_list_ptr);
01622     free(tmp_hdr.payload_ptr);
01623     free(tmp_addr.addr_ptr);
01624     free(dst_packet_data_ptr);
01625 
01626     sn_coap_builder_stub.expectedInt16 = -1;
01627     retCounter = 8;
01628     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01629     CHECK( NULL == ret );
01630     free(payload);
01631 
01632     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01633     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01634     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01635 
01636     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01637     memset(list, 0, sizeof(sn_coap_options_list_s));
01638     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01639     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01640     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0xc8c8c8;
01641     sn_coap_parser_stub.expectedHeader->msg_id = 46;
01642     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01643     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01644     payload = (uint8_t*)malloc(5);
01645     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01646     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01647 
01648     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01649     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01650 
01651     dst_packet_data_ptr = (uint8_t*)malloc(5);
01652     memset(dst_packet_data_ptr, '1', 5);
01653 
01654     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01655     memset(tmp_addr.addr_ptr, '1', 5);
01656 
01657     retCounter = 20;
01658     sn_coap_builder_stub.expectedInt16 = 1;
01659     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01660     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01661     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01662     tmp_hdr.options_list_ptr->block2 = 1;
01663     tmp_hdr.msg_id = 46;
01664     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01665     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01666 
01667     free(tmp_hdr.options_list_ptr);
01668     free(tmp_hdr.payload_ptr);
01669     free(tmp_addr.addr_ptr);
01670     free(dst_packet_data_ptr);
01671 
01672     sn_coap_builder_stub.expectedInt16 = 1;
01673     retCounter = 8;
01674     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01675     CHECK( NULL == ret );
01676     free(payload);
01677 
01678     sn_coap_protocol_destroy(handle);
01679     retCounter = 1;
01680     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01681 
01682     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01683     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01684     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01685 
01686     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01687     memset(list, 0, sizeof(sn_coap_options_list_s));
01688     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01689     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01690     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0xc8c8c8;
01691     sn_coap_parser_stub.expectedHeader->msg_id = 47;
01692     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01693     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01694     payload = (uint8_t*)malloc(5);
01695     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01696     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01697 
01698     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01699     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01700 
01701     dst_packet_data_ptr = (uint8_t*)malloc(5);
01702     memset(dst_packet_data_ptr, '1', 5);
01703 
01704     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01705     memset(tmp_addr.addr_ptr, '1', 5);
01706 
01707     retCounter = 20;
01708     sn_coap_builder_stub.expectedInt16 = 1;
01709     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01710     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01711     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01712     tmp_hdr.options_list_ptr->block2 = 1;
01713     tmp_hdr.msg_id = 47;
01714     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01715     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01716 
01717     free(tmp_hdr.options_list_ptr);
01718     free(tmp_hdr.payload_ptr);
01719     free(tmp_addr.addr_ptr);
01720     free(dst_packet_data_ptr);
01721 
01722     sn_coap_builder_stub.expectedInt16 = 1;
01723     retCounter = 9;
01724     sn_coap_protocol_set_retransmission_buffer(handle,0,0);
01725     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01726     CHECK( NULL != ret );
01727     free(payload);
01728     sn_coap_parser_release_allocated_coap_msg_mem(handle, ret);
01729 
01730     sn_coap_protocol_destroy(handle);
01731     retCounter = 1;
01732     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01733 
01734     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01735     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01736     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01737 
01738     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01739     memset(list, 0, sizeof(sn_coap_options_list_s));
01740     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01741     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01742     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 0xc8c8c8;
01743     sn_coap_parser_stub.expectedHeader->msg_id = 47;
01744     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01745     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01746     payload = (uint8_t*)malloc(5);
01747     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01748     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01749 
01750     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01751     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01752 
01753     dst_packet_data_ptr = (uint8_t*)malloc(5);
01754     memset(dst_packet_data_ptr, '1', 5);
01755 
01756     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01757     memset(tmp_addr.addr_ptr, '1', 5);
01758 
01759     retCounter = 20;
01760     sn_coap_builder_stub.expectedInt16 = 1;
01761     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01762     tmp_hdr.options_list_ptr = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01763     memset(tmp_hdr.options_list_ptr, 0, sizeof(sn_coap_options_list_s));
01764     tmp_hdr.options_list_ptr->block2 = 1;
01765     tmp_hdr.msg_id = 47;
01766     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01767     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01768 
01769     free(tmp_hdr.options_list_ptr);
01770     free(tmp_hdr.payload_ptr);
01771     free(tmp_addr.addr_ptr);
01772     free(dst_packet_data_ptr);
01773 
01774     sn_coap_builder_stub.expectedInt16 = 1;
01775     retCounter = 9;
01776     sn_coap_protocol_set_retransmission_buffer(handle,2,1);
01777     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01778     CHECK( NULL != ret );
01779     free(payload);
01780     sn_coap_parser_release_allocated_coap_msg_mem(handle, ret);
01781 
01782     // <-- block2 == 0x08
01783 
01784     //<-- Test sn_coap_handle_blockwise_message, block2 != -1
01785 
01786     sn_coap_protocol_destroy(handle);
01787     retCounter = 1;
01788     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01789 
01790     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01791     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01792     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01793 
01794     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01795     memset(list, 0, sizeof(sn_coap_options_list_s));
01796     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01797     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01798     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 1;
01799     sn_coap_parser_stub.expectedHeader->msg_id = 41;
01800     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01801     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01802     payload = (uint8_t*)malloc(5);
01803     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01804     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01805 
01806     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01807     CHECK( NULL == ret );
01808     free(payload);
01809     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01810 
01811     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01812     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01813     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01814 
01815     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01816     memset(list, 0, sizeof(sn_coap_options_list_s));
01817     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01818     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01819     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 1;
01820     sn_coap_parser_stub.expectedHeader->msg_id = 42;
01821     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01822     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01823     payload = (uint8_t*)malloc(5);
01824     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01825     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01826 
01827     retCounter = 1;
01828     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01829     CHECK( NULL == ret );
01830     free(payload);
01831     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01832 
01833     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01834     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01835     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01836 
01837     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01838     memset(list, 0, sizeof(sn_coap_options_list_s));
01839     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01840     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01841     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 1;
01842     sn_coap_parser_stub.expectedHeader->msg_id = 43;
01843     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01844     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01845     payload = (uint8_t*)malloc(5);
01846     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01847     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01848 
01849     retCounter = 2;
01850     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01851     CHECK( NULL == ret );
01852     free(payload);
01853     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01854 
01855     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01856     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01857     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01858 
01859     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01860     memset(list, 0, sizeof(sn_coap_options_list_s));
01861     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01862     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01863     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 1;
01864     sn_coap_parser_stub.expectedHeader->msg_id = 44;
01865     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01866     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01867     payload = (uint8_t*)malloc(5);
01868     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01869     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01870 
01871     retCounter = 3;
01872     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01873     CHECK( NULL == ret );
01874     free(payload);
01875     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01876 
01877     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01878     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01879     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01880 
01881     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01882     memset(list, 0, sizeof(sn_coap_options_list_s));
01883     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01884     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01885     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 1;
01886     sn_coap_parser_stub.expectedHeader->msg_id = 45;
01887     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01888     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01889     payload = (uint8_t*)malloc(5);
01890     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01891     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01892 
01893     retCounter = 4;
01894     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01895     CHECK( NULL == ret );
01896     free(payload);
01897     sn_coap_parser_release_allocated_coap_msg_mem(handle, sn_coap_parser_stub.expectedHeader);
01898 
01899     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01900     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01901     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01902 
01903     list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
01904     memset(list, 0, sizeof(sn_coap_options_list_s));
01905     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
01906     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = -1;
01907     sn_coap_parser_stub.expectedHeader->options_list_ptr->block2 = 1;
01908     sn_coap_parser_stub.expectedHeader->msg_id = 46;
01909     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
01910     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01911     payload = (uint8_t*)malloc(5);
01912     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
01913     sn_coap_parser_stub.expectedHeader->payload_len = 5;
01914 
01915     retCounter = 6;
01916     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01917     CHECK( NULL != ret );
01918     free(payload);
01919     free(ret->payload_ptr);
01920     sn_coap_parser_release_allocated_coap_msg_mem(handle, ret);
01921 
01922     sn_coap_protocol_destroy(handle);
01923     retCounter = 1;
01924     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01925 
01926     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01927     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01928     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
01929     sn_coap_parser_stub.expectedHeader->msg_id = 18;
01930 
01931     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01932     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01933 
01934     dst_packet_data_ptr = (uint8_t*)malloc(5);
01935     memset(dst_packet_data_ptr, '1', 5);
01936     dst_packet_data_ptr[2]=0;
01937     dst_packet_data_ptr[3]=18;
01938 
01939     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01940     memset(tmp_addr.addr_ptr, '1', 5);
01941     tmp_addr.port = 0;
01942 
01943     retCounter = 20;
01944     sn_coap_builder_stub.expectedInt16 = 5;
01945     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01946     tmp_hdr.msg_id = 18;
01947     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01948     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01949     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01950 
01951     free(tmp_hdr.options_list_ptr);
01952     free(tmp_hdr.payload_ptr);
01953     free(tmp_addr.addr_ptr);
01954     free(dst_packet_data_ptr);
01955 
01956     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
01957     CHECK( ret != NULL );
01958     sn_coap_parser_release_allocated_coap_msg_mem(handle, ret);
01959 
01960     sn_coap_protocol_destroy(handle);
01961 
01962     retCounter = 1;
01963     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
01964 
01965     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
01966     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
01967     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_RESET;
01968     sn_coap_parser_stub.expectedHeader->msg_id = 18;
01969 
01970     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
01971     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
01972 
01973     dst_packet_data_ptr = (uint8_t*)malloc(5);
01974     memset(dst_packet_data_ptr, '1', 5);
01975     dst_packet_data_ptr[2]=0;
01976     dst_packet_data_ptr[3]=18;
01977 
01978     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
01979     memset(tmp_addr.addr_ptr, '1', 5);
01980     tmp_addr.port = 0;
01981 
01982     retCounter = 20;
01983     sn_coap_builder_stub.expectedInt16 = 5;
01984     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
01985     tmp_hdr.msg_id = 18;
01986     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
01987     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
01988     tmp_hdr.uri_path_ptr = (uint8_t*)malloc(7);
01989     snprintf((char *)tmp_hdr.uri_path_ptr, 7, "13/0/1");
01990     tmp_hdr.uri_path_len = 7;
01991 
01992     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
01993 
01994     free(tmp_hdr.uri_path_ptr);
01995     free(tmp_hdr.options_list_ptr);
01996     free(tmp_hdr.payload_ptr);
01997     free(tmp_addr.addr_ptr);
01998     free(dst_packet_data_ptr);
01999 
02000     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
02001     CHECK( ret != NULL );
02002     sn_coap_parser_release_allocated_coap_msg_mem(handle, ret);
02003 
02004     sn_coap_protocol_destroy(handle);
02005 
02006     retCounter = 1;
02007     handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
02008 
02009     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
02010     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
02011     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
02012     sn_coap_parser_stub.expectedHeader->msg_id = 18;
02013 
02014     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
02015     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
02016 
02017     dst_packet_data_ptr = (uint8_t*)malloc(5);
02018     memset(dst_packet_data_ptr, '1', 5);
02019     dst_packet_data_ptr[2]=0;
02020     dst_packet_data_ptr[3]=185;
02021 
02022     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
02023     memset(tmp_addr.addr_ptr, '1', 5);
02024     tmp_addr.port = 0;
02025 
02026     retCounter = 20;
02027     sn_coap_builder_stub.expectedInt16 = 5;
02028     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
02029     tmp_hdr.msg_id = 18;
02030     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
02031     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
02032     tmp_hdr.uri_path_ptr = (uint8_t*)malloc(7);
02033     snprintf((char *)tmp_hdr.uri_path_ptr, 7, "13/0/1");
02034     tmp_hdr.uri_path_len = 7;
02035     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
02036 
02037     free(tmp_hdr.options_list_ptr);
02038     free(tmp_hdr.payload_ptr);
02039     free(tmp_addr.addr_ptr);
02040     free(dst_packet_data_ptr);
02041 
02042     ret = sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
02043     CHECK( ret != NULL );
02044     sn_coap_parser_release_allocated_coap_msg_mem(handle, ret);
02045 
02046     free(tmp_hdr.uri_path_ptr);
02047     free(packet_data_ptr);
02048     free(addr->addr_ptr);
02049     free(addr);
02050     sn_coap_protocol_destroy(handle);
02051 }
02052 
02053 TEST(libCoap_protocol, sn_coap_protocol_exec)
02054 {
02055     CHECK(-1 == sn_coap_protocol_exec(NULL, 0));
02056 
02057     retCounter = 1;
02058     struct coap_s * handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
02059 
02060     sn_nsdl_addr_s tmp_addr;
02061     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
02062     sn_coap_hdr_s tmp_hdr;
02063     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
02064 
02065     uint8_t* dst_packet_data_ptr = (uint8_t*)malloc(5);
02066     memset(dst_packet_data_ptr, '1', 5);
02067 
02068     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
02069     memset(tmp_addr.addr_ptr, '1', 5);
02070 
02071     retCounter = 20;
02072     sn_coap_builder_stub.expectedInt16 = 5;
02073     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
02074     tmp_hdr.msg_id = 18;
02075     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
02076     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
02077     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
02078 
02079     free(tmp_hdr.options_list_ptr);
02080     free(tmp_hdr.payload_ptr);
02081     free(tmp_addr.addr_ptr);
02082     free(dst_packet_data_ptr);
02083 
02084     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
02085     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
02086     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
02087     sn_coap_parser_stub.expectedHeader->msg_id = 7;
02088 
02089     sn_coap_options_list_s* list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
02090     memset(list, 0, sizeof(sn_coap_options_list_s));
02091     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
02092     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = 1;
02093     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
02094     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_GET;
02095     uint8_t* payload = (uint8_t*)malloc(17);
02096     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
02097     sn_coap_parser_stub.expectedHeader->payload_len = 17;
02098 
02099     uint8_t *packet_data_ptr = (uint8_t*)malloc(5);
02100     uint16_t packet_data_len = 5;
02101 
02102     sn_nsdl_addr_s* addr = (sn_nsdl_addr_s*)malloc(sizeof(sn_nsdl_addr_s));
02103     memset(addr, 0, sizeof(sn_nsdl_addr_s));
02104 
02105     addr->addr_ptr = (uint8_t*)malloc(5);
02106 
02107     retCounter = 5;
02108     sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
02109     free(payload);
02110     free(packet_data_ptr);
02111     free(addr->addr_ptr);
02112     free(addr);
02113 
02114     CHECK(0 == sn_coap_protocol_exec(handle, 600));
02115 
02116     sn_coap_builder_stub.expectedInt16 = 0;
02117     retCounter = 0;
02118     sn_coap_protocol_destroy(handle);
02119 }
02120 
02121 TEST(libCoap_protocol, sn_coap_protocol_exec2)
02122 {
02123     retCounter = 1;
02124     struct coap_s * handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, null_rx_cb);
02125 
02126     sn_nsdl_addr_s tmp_addr;
02127     memset(&tmp_addr, 0, sizeof(sn_nsdl_addr_s));
02128     sn_coap_hdr_s tmp_hdr;
02129     memset(&tmp_hdr, 0, sizeof(sn_coap_hdr_s));
02130 
02131     uint8_t* dst_packet_data_ptr = (uint8_t*)malloc(5);
02132     memset(dst_packet_data_ptr, '1', 5);
02133 
02134     tmp_addr.addr_ptr = (uint8_t*)malloc(5);
02135     memset(tmp_addr.addr_ptr, '1', 5);
02136 
02137     retCounter = 20;
02138     sn_coap_builder_stub.expectedInt16 = 5;
02139     tmp_hdr.payload_ptr = (uint8_t*)malloc(3);
02140     tmp_hdr.msg_id = 18;
02141     tmp_hdr.msg_code = COAP_MSG_CODE_RESPONSE_CREATED;
02142     tmp_hdr.payload_len = SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE + 20;
02143     sn_coap_protocol_build(handle, &tmp_addr, dst_packet_data_ptr, &tmp_hdr, NULL);
02144 
02145     free(tmp_hdr.options_list_ptr);
02146     free(tmp_hdr.payload_ptr);
02147     free(tmp_addr.addr_ptr);
02148     free(dst_packet_data_ptr);
02149 
02150     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
02151     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
02152     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
02153     sn_coap_parser_stub.expectedHeader->msg_id = 7;
02154 
02155     sn_coap_options_list_s* list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
02156     memset(list, 0, sizeof(sn_coap_options_list_s));
02157     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
02158     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = 1;
02159     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
02160     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_GET;
02161     uint8_t* payload = (uint8_t*)malloc(17);
02162     sn_coap_parser_stub.expectedHeader->payload_ptr = payload;
02163     sn_coap_parser_stub.expectedHeader->payload_len = 17;
02164 
02165     uint8_t *packet_data_ptr = (uint8_t*)malloc(5);
02166     uint16_t packet_data_len = 5;
02167 
02168     sn_nsdl_addr_s* addr = (sn_nsdl_addr_s*)malloc(sizeof(sn_nsdl_addr_s));
02169     memset(addr, 0, sizeof(sn_nsdl_addr_s));
02170 
02171     addr->addr_ptr = (uint8_t*)malloc(5);
02172 
02173     retCounter = 5;
02174     sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
02175     free(payload);
02176     free(packet_data_ptr);
02177     free(addr->addr_ptr);
02178     free(addr);
02179 
02180     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
02181     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
02182 
02183     sn_coap_protocol_set_retransmission_parameters(handle,0, 5);
02184     CHECK(0 == sn_coap_protocol_exec(handle, 600));
02185 
02186     sn_coap_builder_stub.expectedInt16 = 0;
02187     retCounter = 0;
02188     sn_coap_protocol_destroy(handle);
02189 }
02190 
02191 TEST(libCoap_protocol, sn_coap_protocol_block_remove)
02192 {
02193     sn_coap_protocol_block_remove(0,0,0,0);
02194     retCounter = 9;
02195     sn_nsdl_addr_s* addr = (sn_nsdl_addr_s*)malloc(sizeof(sn_nsdl_addr_s));
02196     memset(addr, 0, sizeof(sn_nsdl_addr_s));
02197     addr->addr_ptr = (uint8_t*)malloc(5);
02198     memset(addr->addr_ptr,'a',5);
02199     addr->addr_len = 5;
02200     struct coap_s * handle = sn_coap_protocol_init(myMalloc, myFree, null_tx_cb, NULL);
02201     uint8_t *packet_data_ptr = (uint8_t*)malloc(5);
02202     memset(packet_data_ptr,'x',5);
02203     uint16_t packet_data_len = 5;
02204     sn_coap_parser_stub.expectedHeader = NULL;
02205     sn_coap_parser_stub.expectedHeader = (sn_coap_hdr_s *)malloc(sizeof(sn_coap_hdr_s));
02206     memset(sn_coap_parser_stub.expectedHeader, 0, sizeof(sn_coap_hdr_s));
02207     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
02208     sn_coap_parser_stub.expectedHeader->msg_id = 13;
02209 
02210     sn_coap_options_list_s* list = (sn_coap_options_list_s*)malloc(sizeof(sn_coap_options_list_s));
02211     memset(list, 0, sizeof(sn_coap_options_list_s));
02212     sn_coap_parser_stub.expectedHeader->options_list_ptr = list;
02213     sn_coap_parser_stub.expectedHeader->options_list_ptr->block1 = 0x08;
02214     sn_coap_parser_stub.expectedHeader->msg_type = COAP_MSG_TYPE_CONFIRMABLE;
02215     sn_coap_parser_stub.expectedHeader->msg_code = COAP_MSG_CODE_REQUEST_PUT;
02216     uint8_t* payload = (uint8_t*)malloc(17);
02217     sn_coap_parser_stub.expectedHeader->payload_ptr = packet_data_ptr;
02218     sn_coap_parser_stub.expectedHeader->payload_len = packet_data_len;
02219     sn_coap_builder_stub.expectedUint16 = 1;
02220 
02221     // Success
02222     retCounter = 9;
02223     sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
02224     CHECK(ns_list_count(&handle->linked_list_blockwise_received_payloads) == 1);
02225     sn_coap_protocol_block_remove(handle,addr,packet_data_len,packet_data_ptr);
02226     CHECK(ns_list_count(&handle->linked_list_blockwise_received_payloads) == 0);
02227 
02228     // Ports does not match
02229     retCounter = 18;
02230     sn_coap_parser_stub.expectedHeader->msg_id = 14;
02231     addr->port = 5600;
02232     sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
02233     CHECK(ns_list_count(&handle->linked_list_blockwise_received_payloads) == 1);
02234     addr->port = 5601;
02235     sn_coap_protocol_block_remove(handle,addr,packet_data_len,packet_data_ptr);
02236     CHECK(ns_list_count(&handle->linked_list_blockwise_received_payloads) == 1);
02237 
02238     // Addresses does not match
02239     retCounter = 18;
02240     sn_coap_parser_stub.expectedHeader->msg_id = 15;
02241     sn_coap_protocol_parse(handle, addr, packet_data_len, packet_data_ptr, NULL);
02242     CHECK(ns_list_count(&handle->linked_list_blockwise_received_payloads) == 2);
02243     addr->addr_ptr[0] = 'x';
02244     sn_coap_protocol_block_remove(handle,addr,packet_data_len,packet_data_ptr);
02245     CHECK(ns_list_count(&handle->linked_list_blockwise_received_payloads) == 2);
02246 
02247     // Payload length does not match
02248     addr->addr_ptr[0] = 'a';
02249     sn_coap_protocol_block_remove(handle,addr,packet_data_len+1,packet_data_ptr);
02250     CHECK(ns_list_count(&handle->linked_list_blockwise_received_payloads) == 2);
02251 
02252     free(sn_coap_parser_stub.expectedHeader->options_list_ptr);
02253     free(sn_coap_parser_stub.expectedHeader);
02254     free(addr->addr_ptr);
02255     free(addr);
02256     free(payload);
02257     free(packet_data_ptr);
02258     sn_coap_protocol_destroy(handle);
02259 }
02260