Refactored Connectivity Abstraction code
[platform/upstream/iotivity.git] / resource / csdk / connectivity / test / cablocktransfertest.cpp
1 /* ****************************************************************
2  *
3  * Copyright 2016 Samsung Electronics All Rights Reserved.
4  *
5  *
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  ******************************************************************/
20
21 #include "gtest/gtest.h"
22 #include "cainterface.h"
23 #include "cautilinterface.h"
24 #include "cacommon.h"
25 #include "caprotocolmessage.h"
26 #include "cablockwisetransfer.h"
27
28 #define LARGE_PAYLOAD_LENGTH    1024
29
30 class CABlockTransferTests : public testing::Test {
31     protected:
32     virtual void SetUp()
33     {
34         CAInitialize();
35     }
36
37     virtual void TearDown()
38     {
39         CATerminate();
40     }
41 };
42
43 TEST_F(CABlockTransferTests, CACreateNewDataSetTest)
44 {
45     CAEndpoint_t* tempRep = NULL;
46     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
47
48     coap_pdu_t *pdu = NULL;
49     coap_list_t *options = NULL;
50     coap_transport_type transport = coap_udp;
51
52     CAToken_t tempToken = NULL;
53     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
54
55     CAInfo_t requestData;
56     memset(&requestData, 0, sizeof(CAInfo_t));
57     requestData.token = tempToken;
58     requestData.tokenLength = CA_MAX_TOKEN_LEN;
59     requestData.type = CA_MSG_NONCONFIRM;
60
61     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
62     if (!requestData.payload)
63     {
64         CADestroyToken(tempToken);
65         FAIL() << "requestData.payload allocation failed";
66     }
67     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
68     requestData.payloadSize = sizeof(requestData.payload);
69     requestData.type = CA_MSG_NONCONFIRM;
70
71     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
72
73     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
74     EXPECT_TRUE(cadata != NULL);
75
76     CABlockData_t *currData = CACreateNewBlockData(cadata);
77     EXPECT_TRUE(currData != NULL);
78
79     if (currData)
80     {
81         CAData_t *getData = CAGetDataSetFromBlockDataList(currData->blockDataId);
82         EXPECT_TRUE(getData != NULL);
83
84         EXPECT_EQ(CA_STATUS_OK, CARemoveBlockDataFromList(currData->blockDataId));
85     }
86
87     CADestroyDataSet(cadata);
88     coap_delete_list(options);
89     coap_delete_pdu(pdu);
90
91     CADestroyToken(tempToken);
92     CADestroyEndpoint(tempRep);
93     free(requestData.payload);
94 }
95
96 TEST_F(CABlockTransferTests, CARemoveBlockDataFromListWithSeed)
97 {
98     CAEndpoint_t* tempRep = NULL;
99     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
100
101     coap_pdu_t *pdu = NULL;
102     coap_list_t *options = NULL;
103     coap_transport_type transport = coap_udp;
104
105     CAToken_t tempToken = NULL;
106     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
107
108     CAInfo_t requestData;
109     memset(&requestData, 0, sizeof(CAInfo_t));
110     requestData.token = tempToken;
111     requestData.tokenLength = CA_MAX_TOKEN_LEN;
112     requestData.type = CA_MSG_NONCONFIRM;
113
114     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
115     if (!requestData.payload)
116     {
117         CADestroyToken(tempToken);
118         FAIL() << "requestData.payload allocation failed";
119     }
120     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
121     requestData.payloadSize = sizeof(requestData.payload);
122     requestData.type = CA_MSG_NONCONFIRM;
123
124     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
125
126     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
127     EXPECT_TRUE(cadata != NULL);
128
129     CABlockData_t *currData = CACreateNewBlockData(cadata);
130     EXPECT_TRUE(currData != NULL);
131
132     if (currData)
133     {
134         EXPECT_EQ(CA_STATUS_OK, CARemoveBlockDataFromListWithSeed(tempToken,
135                                                                   CA_MAX_TOKEN_LEN, 5683));
136     }
137
138     CADestroyDataSet(cadata);
139     coap_delete_list(options);
140     coap_delete_pdu(pdu);
141
142     CADestroyToken(tempToken);
143     CADestroyEndpoint(tempRep);
144     free(requestData.payload);
145 }
146
147 TEST_F(CABlockTransferTests, CAGetBlockDataFromBlockDataListTest)
148 {
149     CAEndpoint_t* tempRep = NULL;
150     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
151
152     coap_pdu_t *pdu = NULL;
153     coap_list_t *options = NULL;
154     coap_transport_type transport = coap_udp;
155
156     CAToken_t tempToken = NULL;
157     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
158
159     CAInfo_t requestData;
160     memset(&requestData, 0, sizeof(CAInfo_t));
161     requestData.token = tempToken;
162     requestData.tokenLength = CA_MAX_TOKEN_LEN;
163     requestData.type = CA_MSG_NONCONFIRM;
164
165     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
166
167     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
168     EXPECT_TRUE(cadata != NULL);
169
170     CABlockData_t *currData = CACreateNewBlockData(cadata);
171     EXPECT_TRUE(currData != NULL);
172
173     if (currData)
174     {
175         CABlockData_t *data = CAGetBlockDataFromBlockDataList(currData->blockDataId);
176         EXPECT_TRUE(data != NULL);
177
178         EXPECT_EQ(CA_STATUS_OK, CARemoveBlockDataFromList(currData->blockDataId));
179     }
180
181     CADestroyDataSet(cadata);
182     coap_delete_list(options);
183     coap_delete_pdu(pdu);
184
185     CADestroyToken(tempToken);
186     CADestroyEndpoint(tempRep);
187     free(requestData.payload);
188 }
189
190 TEST_F(CABlockTransferTests, CAGetPayloadFromBlockDataListTest)
191 {
192     CAEndpoint_t* tempRep = NULL;
193     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
194
195     coap_pdu_t *pdu = NULL;
196     coap_list_t *options = NULL;
197     coap_transport_type transport = coap_udp;
198
199     CAToken_t tempToken = NULL;
200     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
201
202     CAInfo_t requestData;
203     memset(&requestData, 0, sizeof(CAInfo_t));
204     requestData.token = tempToken;
205     requestData.tokenLength = CA_MAX_TOKEN_LEN;
206     requestData.type = CA_MSG_NONCONFIRM;
207
208     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
209
210     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
211     EXPECT_TRUE(cadata != NULL);
212
213     CABlockData_t *currData = CACreateNewBlockData(cadata);
214     EXPECT_TRUE(currData != NULL);
215
216     size_t fullPayload = 0;
217     CAPayload_t payload = CAGetPayloadFromBlockDataList(currData->blockDataId,
218                                                         &fullPayload);
219
220     size_t payloadLen = (payload != NULL) ? strlen((const char*) payload) : 0;
221     EXPECT_TRUE(fullPayload == payloadLen);
222
223     CARemoveBlockDataFromList(currData->blockDataId);
224     CADestroyDataSet(cadata);
225     coap_delete_list(options);
226     coap_delete_pdu(pdu);
227
228     CADestroyToken(tempToken);
229     CADestroyEndpoint(tempRep);
230     free(requestData.payload);
231 }
232
233 // request and block option1
234 TEST_F(CABlockTransferTests, CAAddBlockOptionTest)
235 {
236     CAEndpoint_t* tempRep = NULL;
237     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
238
239     coap_pdu_t *pdu = NULL;
240     coap_list_t *options = NULL;
241     coap_transport_type transport = coap_udp;
242
243     CAToken_t tempToken = NULL;
244     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
245
246     CAInfo_t requestData;
247     memset(&requestData, 0, sizeof(CAInfo_t));
248     requestData.token = tempToken;
249     requestData.tokenLength = CA_MAX_TOKEN_LEN;
250
251     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
252     if(!requestData.payload)
253     {
254         CADestroyToken(tempToken);
255         FAIL() << "requestData.payload allocation failed";
256     }
257     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
258     requestData.payloadSize = sizeof(requestData.payload);
259     requestData.type = CA_MSG_NONCONFIRM;
260
261     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
262
263     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption(&pdu, &requestData, tempRep, &options));
264
265     coap_delete_list(options);
266     coap_delete_pdu(pdu);
267
268     CADestroyToken(tempToken);
269     CADestroyEndpoint(tempRep);
270     free(requestData.payload);
271 }
272
273 // request and block option1
274 TEST_F(CABlockTransferTests, CAAddBlockOption1InRequest)
275 {
276     CAEndpoint_t* tempRep = NULL;
277     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
278
279     coap_pdu_t *pdu = NULL;
280     coap_list_t *options = NULL;
281     coap_transport_type transport = coap_udp;
282
283     CAToken_t tempToken = NULL;
284     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
285
286     CAInfo_t requestData;
287     memset(&requestData, 0, sizeof(CAInfo_t));
288     requestData.token = tempToken;
289     requestData.tokenLength = CA_MAX_TOKEN_LEN;
290
291     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
292     if(!requestData.payload)
293     {
294         CADestroyToken(tempToken);
295         FAIL() << "requestData.payload allocation failed";
296     }
297     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
298     requestData.payloadSize = sizeof(requestData.payload);
299     requestData.type = CA_MSG_NONCONFIRM;
300
301     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
302
303     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
304     EXPECT_TRUE(cadata != NULL);
305
306     CABlockData_t *currData = CACreateNewBlockData(cadata);
307     EXPECT_TRUE(currData != NULL);
308
309     EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
310                                                     COAP_OPTION_BLOCK1));
311
312     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption1(&pdu, &requestData,
313                                               requestData.payloadSize,
314                                               currData->blockDataId, &options));
315
316     CADestroyDataSet(cadata);
317     coap_delete_list(options);
318     coap_delete_pdu(pdu);
319
320     CADestroyToken(tempToken);
321     CADestroyEndpoint(tempRep);
322     free(requestData.payload);
323 }
324
325 // response and block option1
326 TEST_F(CABlockTransferTests, CAAddBlockOption1InResponse)
327 {
328     CAEndpoint_t* tempRep = NULL;
329     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
330
331     coap_pdu_t *pdu = NULL;
332     coap_list_t *options = NULL;
333     coap_transport_type transport = coap_udp;
334
335     CAToken_t tempToken = NULL;
336     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
337
338     CAInfo_t responseData;
339     memset(&responseData, 0, sizeof(CAInfo_t));
340     responseData.token = tempToken;
341     responseData.tokenLength = CA_MAX_TOKEN_LEN;
342     responseData.type = CA_MSG_NONCONFIRM;
343     responseData.messageId = 1;
344
345     responseData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
346     if(!responseData.payload)
347     {
348         CADestroyToken(tempToken);
349         FAIL() << "requestData.payload allocation failed";
350     }
351     memset(responseData.payload, '1', sizeof(responseData.payload) - 1);
352     responseData.payloadSize = sizeof(responseData.payload);
353
354     pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
355
356     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
357     EXPECT_TRUE(cadata != NULL);
358
359     CABlockData_t *currData = CACreateNewBlockData(cadata);
360     EXPECT_TRUE(currData != NULL);
361
362     EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
363                                                     COAP_OPTION_BLOCK1));
364
365     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption1(&pdu, &responseData,
366                                               responseData.payloadSize,
367                                               currData->blockDataId, &options));
368
369     CADestroyDataSet(cadata);
370     coap_delete_list(options);
371     coap_delete_pdu(pdu);
372
373     CADestroyToken(tempToken);
374     CADestroyEndpoint(tempRep);
375     free(responseData.payload);
376 }
377
378 // response and block option2
379 TEST_F(CABlockTransferTests, CAAddBlockOption2InResponse)
380 {
381     CAEndpoint_t* tempRep = NULL;
382     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
383
384     coap_pdu_t *pdu = NULL;
385     coap_list_t *options = NULL;
386     coap_transport_type transport = coap_udp;
387
388     CAToken_t tempToken = NULL;
389     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
390
391     CAInfo_t responseData;
392     memset(&responseData, 0, sizeof(CAInfo_t));
393     responseData.token = tempToken;
394     responseData.tokenLength = CA_MAX_TOKEN_LEN;
395     responseData.type = CA_MSG_NONCONFIRM;
396     responseData.messageId = 1;
397
398     responseData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
399     if(!responseData.payload)
400     {
401         CADestroyToken(tempToken);
402         FAIL() << "requestData.payload allocation failed";
403     }
404     memset(responseData.payload, '1', sizeof(responseData.payload) - 1);
405     responseData.payloadSize = sizeof(responseData.payload);
406
407     pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
408
409     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
410     EXPECT_TRUE(cadata != NULL);
411
412     CABlockData_t *currData = CACreateNewBlockData(cadata);
413     EXPECT_TRUE(currData != NULL);
414
415     EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
416                                                     COAP_OPTION_BLOCK2));
417
418     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption2(&pdu, &responseData,
419                                               responseData.payloadSize,
420                                               currData->blockDataId, &options));
421
422     CADestroyDataSet(cadata);
423     coap_delete_list(options);
424     coap_delete_pdu(pdu);
425
426     CADestroyToken(tempToken);
427     CADestroyEndpoint(tempRep);
428     free(responseData.payload);
429 }
430
431 // request and block option1
432 TEST_F(CABlockTransferTests, CAAddBlockOption2InRequest)
433 {
434     CAEndpoint_t* tempRep = NULL;
435     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
436
437     coap_pdu_t *pdu = NULL;
438     coap_list_t *options = NULL;
439     coap_transport_type transport = coap_udp;
440
441     CAToken_t tempToken = NULL;
442     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
443
444     CAInfo_t requestData;
445     memset(&requestData, 0, sizeof(CAInfo_t));
446     requestData.token = tempToken;
447     requestData.tokenLength = CA_MAX_TOKEN_LEN;
448
449     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
450     if(!requestData.payload)
451     {
452         CADestroyToken(tempToken);
453         FAIL() << "requestData.payload allocation failed";
454     }
455     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
456     requestData.payloadSize = sizeof(requestData.payload);
457     requestData.type = CA_MSG_NONCONFIRM;
458
459     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
460
461     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
462     EXPECT_TRUE(cadata != NULL);
463
464     CABlockData_t *currData = CACreateNewBlockData(cadata);
465     EXPECT_TRUE(currData != NULL);
466
467     EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
468                                                     COAP_OPTION_BLOCK2));
469
470     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption2(&pdu, &requestData,
471                                               requestData.payloadSize,
472                                               currData->blockDataId, &options));
473
474     CARemoveBlockDataFromList(currData->blockDataId);
475     CADestroyDataSet(cadata);
476     coap_delete_list(options);
477     coap_delete_pdu(pdu);
478
479     CADestroyToken(tempToken);
480     CADestroyEndpoint(tempRep);
481     free(requestData.payload);
482 }
483
484 TEST_F(CABlockTransferTests, CAGetBlockSizeOptionFromPduTest)
485 {
486     CAEndpoint_t* tempRep = NULL;
487     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
488
489     coap_pdu_t *pdu = NULL;
490     coap_list_t *options = NULL;
491     coap_transport_type transport = coap_udp;
492
493     CAToken_t tempToken = NULL;
494     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
495
496     CAInfo_t requestData;
497     memset(&requestData, 0, sizeof(CAInfo_t));
498     requestData.token = tempToken;
499     requestData.tokenLength = CA_MAX_TOKEN_LEN;
500     requestData.type = CA_MSG_NONCONFIRM;
501
502     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
503
504     size_t totalPayloadLen = 0;
505     EXPECT_FALSE(CAIsPayloadLengthInPduWithBlockSizeOption(pdu, COAP_OPTION_SIZE1,
506                                                            &totalPayloadLen));
507
508     coap_delete_list(options);
509     coap_delete_pdu(pdu);
510
511     CADestroyToken(tempToken);
512     CADestroyEndpoint(tempRep);
513     free(requestData.payload);
514 }
515
516 TEST_F(CABlockTransferTests, CASetNextBlockOption1WithRequest)
517 {
518     CAEndpoint_t* tempRep = NULL;
519     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
520
521     coap_pdu_t *pdu = NULL;
522     coap_list_t *options = NULL;
523     coap_transport_type transport = coap_udp;
524
525     CAToken_t tempToken = NULL;
526     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
527
528     CAInfo_t requestData;
529     memset(&requestData, 0, sizeof(CAInfo_t));
530     requestData.token = tempToken;
531     requestData.tokenLength = CA_MAX_TOKEN_LEN;
532     requestData.type = CA_MSG_NONCONFIRM;
533
534     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
535
536     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
537     EXPECT_TRUE(cadata != NULL);
538
539     CABlockData_t *currData = CACreateNewBlockData(cadata);
540     EXPECT_TRUE(currData != NULL);
541
542     coap_block_t block = {0, 0, 0};
543     EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption1(pdu, tempRep, cadata, block, pdu->length));
544
545     CADestroyDataSet(cadata);
546     coap_delete_list(options);
547     coap_delete_pdu(pdu);
548
549     CADestroyToken(tempToken);
550     CADestroyEndpoint(tempRep);
551     free(requestData.payload);
552 }
553
554 TEST_F(CABlockTransferTests, CASetNextBlockOption1WithResponse)
555 {
556     CAEndpoint_t* tempRep = NULL;
557     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
558
559     coap_pdu_t *pdu = NULL;
560     coap_list_t *options = NULL;
561     coap_transport_type transport = coap_udp;
562
563     CAToken_t tempToken = NULL;
564     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
565
566     CAInfo_t responseData;
567     memset(&responseData, 0, sizeof(CAInfo_t));
568     responseData.token = tempToken;
569     responseData.tokenLength = CA_MAX_TOKEN_LEN;
570     responseData.type = CA_MSG_NONCONFIRM;
571     responseData.messageId = 1;
572
573     pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
574
575     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
576     EXPECT_TRUE(cadata != NULL);
577
578     CABlockData_t *currData = CACreateNewBlockData(cadata);
579     EXPECT_TRUE(currData != NULL);
580
581     coap_block_t block = {0, 0, 0};
582     EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption1(pdu, tempRep, cadata, block, pdu->length));
583
584     CADestroyDataSet(cadata);
585     coap_delete_list(options);
586     coap_delete_pdu(pdu);
587
588     CADestroyToken(tempToken);
589     CADestroyEndpoint(tempRep);
590     free(responseData.payload);
591 }
592
593 TEST_F(CABlockTransferTests, CASetNextBlockOption2WithRequest)
594 {
595     CAEndpoint_t* tempRep = NULL;
596     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
597
598     coap_pdu_t *pdu = NULL;
599     coap_list_t *options = NULL;
600     coap_transport_type transport = coap_udp;
601
602     CAToken_t tempToken = NULL;
603     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
604
605     CAInfo_t requestData;
606     memset(&requestData, 0, sizeof(CAInfo_t));
607     requestData.token = tempToken;
608     requestData.tokenLength = CA_MAX_TOKEN_LEN;
609     requestData.type = CA_MSG_NONCONFIRM;
610
611     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
612
613     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
614     EXPECT_TRUE(cadata != NULL);
615
616     CABlockData_t *currData = CACreateNewBlockData(cadata);
617     EXPECT_TRUE(currData != NULL);
618
619     coap_block_t block = {0, 0, 0};
620     EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption2(pdu, tempRep, cadata, block, pdu->length));
621
622     CADestroyDataSet(cadata);
623     coap_delete_list(options);
624     coap_delete_pdu(pdu);
625
626     CADestroyToken(tempToken);
627     CADestroyEndpoint(tempRep);
628     free(requestData.payload);
629 }
630
631 TEST_F(CABlockTransferTests, CASetNextBlockOption2WithResponse)
632 {
633     CAEndpoint_t* tempRep = NULL;
634     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
635
636     coap_pdu_t *pdu = NULL;
637     coap_list_t *options = NULL;
638     coap_transport_type transport = coap_udp;
639
640     CAToken_t tempToken = NULL;
641     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
642
643     CAInfo_t responseData;
644     memset(&responseData, 0, sizeof(CAInfo_t));
645     responseData.token = tempToken;
646     responseData.tokenLength = CA_MAX_TOKEN_LEN;
647     responseData.type = CA_MSG_NONCONFIRM;
648     responseData.messageId = 1;
649
650     pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
651
652     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
653     EXPECT_TRUE(cadata != NULL);
654
655     CABlockData_t *currData = CACreateNewBlockData(cadata);
656     EXPECT_TRUE(currData != NULL);
657
658     coap_block_t block = {0, 0, 0};
659     EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption2(pdu, tempRep, cadata, block, pdu->length));
660
661     CADestroyDataSet(cadata);
662     coap_delete_list(options);
663     coap_delete_pdu(pdu);
664
665     CADestroyToken(tempToken);
666     CADestroyEndpoint(tempRep);
667     free(responseData.payload);
668 }
669
670 TEST_F(CABlockTransferTests, CAUpdatePayloadToCADataWithRequest)
671 {
672     CAEndpoint_t* tempRep = NULL;
673     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
674
675     CAToken_t tempToken = NULL;
676     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
677
678     CAInfo_t requestData;
679     requestData.type = CA_MSG_NONCONFIRM;
680     requestData.token = tempToken;
681     requestData.tokenLength = CA_MAX_TOKEN_LEN;
682     requestData.options = NULL;
683     requestData.payload = NULL;
684     requestData.payloadSize = 0;
685
686     CARequestInfo_t requestInfo;
687     requestInfo.method = CA_GET;
688     requestInfo.info = requestData;
689     requestInfo.isMulticast = false;
690
691     CAData_t cadata;
692     cadata.type = SEND_TYPE_UNICAST;
693     cadata.remoteEndpoint = tempRep;
694     cadata.requestInfo = &requestInfo;
695     cadata.dataType = CA_REQUEST_DATA;
696
697     CAPayload_t payload = (CAPayload_t) "requestPayload";
698     size_t payloadLen = strlen((const char*) payload) + 1;
699
700     EXPECT_EQ(CA_STATUS_OK, CAUpdatePayloadToCAData(&cadata, payload, payloadLen));
701
702     EXPECT_STREQ((const char*) payload, (const char*) cadata.requestInfo->info.payload);
703 }
704
705 TEST_F(CABlockTransferTests, CAUpdatePayloadToCADataWithResponse)
706 {
707     CAEndpoint_t* tempRep = NULL;
708     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
709
710     CAToken_t tempToken = NULL;
711     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
712
713     CAInfo_t responseData;
714     responseData.type = CA_MSG_NONCONFIRM;
715     responseData.token = tempToken;
716     responseData.tokenLength = CA_MAX_TOKEN_LEN;
717     responseData.options = NULL;
718     responseData.payload = NULL;
719     responseData.payloadSize = 0;
720
721     CAResponseInfo_t responseInfo;
722     responseInfo.result = CA_VALID;
723     responseInfo.info = responseData;
724
725     CAData_t cadata;
726     cadata.type = SEND_TYPE_UNICAST;
727     cadata.remoteEndpoint = tempRep;
728     cadata.responseInfo = &responseInfo;
729     cadata.dataType = CA_RESPONSE_DATA;
730
731     CAPayload_t payload = (CAPayload_t) "responsePayload";
732     size_t payloadLen = strlen((const char*) payload) + 1;
733
734     EXPECT_EQ(CA_STATUS_OK, CAUpdatePayloadToCAData(&cadata, payload, payloadLen));
735
736     EXPECT_STREQ((const char*) payload, (const char*) cadata.responseInfo->info.payload);
737 }