1 /* ****************************************************************
3 * Copyright 2016 Samsung Electronics All Rights Reserved.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 ******************************************************************/
21 #include "gtest/gtest.h"
22 #include "cainterface.h"
23 #include "cautilinterface.h"
25 #include "caprotocolmessage.h"
26 #include "cablockwisetransfer.h"
28 #define LARGE_PAYLOAD_LENGTH 1024
30 class CABlockTransferTests : public testing::Test {
34 CAInitialize(CA_ADAPTER_IP);
37 virtual void TearDown()
43 TEST_F(CABlockTransferTests, CACreateNewDataSetTest)
45 CAEndpoint_t* tempRep = NULL;
46 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
48 coap_pdu_t *pdu = NULL;
49 coap_list_t *options = NULL;
50 coap_transport_t transport = COAP_UDP;
52 CAToken_t tempToken = NULL;
53 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
56 memset(&requestData, 0, sizeof(CAInfo_t));
57 requestData.token = tempToken;
58 requestData.tokenLength = CA_MAX_TOKEN_LEN;
59 requestData.type = CA_MSG_NONCONFIRM;
61 requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
62 if (!requestData.payload)
64 CADestroyToken(tempToken);
65 FAIL() << "requestData.payload allocation failed";
67 memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
68 requestData.payloadSize = sizeof(requestData.payload);
69 requestData.type = CA_MSG_NONCONFIRM;
71 pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
73 CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
74 EXPECT_TRUE(cadata != NULL);
76 CABlockData_t *currData = CACreateNewBlockData(cadata);
77 EXPECT_TRUE(currData != NULL);
81 CAData_t *getData = CAGetDataSetFromBlockDataList(currData->blockDataId);
82 EXPECT_TRUE(getData != NULL);
84 EXPECT_EQ(CA_STATUS_OK, CARemoveBlockDataFromList(currData->blockDataId));
87 CADestroyDataSet(cadata);
88 coap_delete_list(options);
91 CADestroyToken(tempToken);
92 CADestroyEndpoint(tempRep);
93 free(requestData.payload);
96 TEST_F(CABlockTransferTests, CARemoveBlockDataFromListWithSeed)
98 CAEndpoint_t* tempRep = NULL;
99 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
101 coap_pdu_t *pdu = NULL;
102 coap_list_t *options = NULL;
103 coap_transport_t transport = COAP_UDP;
105 CAToken_t tempToken = NULL;
106 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
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;
114 requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
115 if (!requestData.payload)
117 CADestroyToken(tempToken);
118 FAIL() << "requestData.payload allocation failed";
120 memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
121 requestData.payloadSize = sizeof(requestData.payload);
122 requestData.type = CA_MSG_NONCONFIRM;
124 pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
126 CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
127 EXPECT_TRUE(cadata != NULL);
129 CABlockData_t *currData = CACreateNewBlockData(cadata);
130 EXPECT_TRUE(currData != NULL);
134 EXPECT_EQ(CA_STATUS_OK, CARemoveBlockDataFromListWithSeed(tempToken,
135 CA_MAX_TOKEN_LEN, 5683));
138 CADestroyDataSet(cadata);
139 coap_delete_list(options);
140 coap_delete_pdu(pdu);
142 CADestroyToken(tempToken);
143 CADestroyEndpoint(tempRep);
144 free(requestData.payload);
147 TEST_F(CABlockTransferTests, CAGetBlockDataFromBlockDataListTest)
149 CAEndpoint_t* tempRep = NULL;
150 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
152 coap_pdu_t *pdu = NULL;
153 coap_list_t *options = NULL;
154 coap_transport_t transport = COAP_UDP;
156 CAToken_t tempToken = NULL;
157 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
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;
165 pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
167 CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
168 EXPECT_TRUE(cadata != NULL);
170 CABlockData_t *currData = CACreateNewBlockData(cadata);
171 EXPECT_TRUE(currData != NULL);
175 CABlockData_t *data = CAGetBlockDataFromBlockDataList(currData->blockDataId);
176 EXPECT_TRUE(data != NULL);
178 EXPECT_EQ(CA_STATUS_OK, CARemoveBlockDataFromList(currData->blockDataId));
181 CADestroyDataSet(cadata);
182 coap_delete_list(options);
183 coap_delete_pdu(pdu);
185 CADestroyToken(tempToken);
186 CADestroyEndpoint(tempRep);
187 free(requestData.payload);
190 TEST_F(CABlockTransferTests, CAGetPayloadFromBlockDataListTest)
192 CAEndpoint_t* tempRep = NULL;
193 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
195 coap_pdu_t *pdu = NULL;
196 coap_list_t *options = NULL;
197 coap_transport_t transport = COAP_UDP;
199 CAToken_t tempToken = NULL;
200 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
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;
208 pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
210 CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
211 EXPECT_TRUE(cadata != NULL);
213 CABlockData_t *currData = CACreateNewBlockData(cadata);
214 EXPECT_TRUE(currData != NULL);
218 size_t fullPayload = 0;
219 CAPayload_t payload = CAGetPayloadFromBlockDataList(currData->blockDataId,
222 size_t payloadLen = (payload != NULL) ? strlen((const char*) payload) : 0;
223 EXPECT_TRUE(fullPayload == payloadLen);
225 CARemoveBlockDataFromList(currData->blockDataId);
228 CADestroyDataSet(cadata);
229 coap_delete_list(options);
230 coap_delete_pdu(pdu);
232 CADestroyToken(tempToken);
233 CADestroyEndpoint(tempRep);
234 free(requestData.payload);
237 // request and block option1
238 TEST_F(CABlockTransferTests, CAAddBlockOptionTest)
240 CAEndpoint_t* tempRep = NULL;
241 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
243 coap_pdu_t *pdu = NULL;
244 coap_list_t *options = NULL;
245 coap_transport_t transport = COAP_UDP;
247 CAToken_t tempToken = NULL;
248 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
250 CAInfo_t requestData;
251 memset(&requestData, 0, sizeof(CAInfo_t));
252 requestData.token = tempToken;
253 requestData.tokenLength = CA_MAX_TOKEN_LEN;
255 requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
256 if(!requestData.payload)
258 CADestroyToken(tempToken);
259 FAIL() << "requestData.payload allocation failed";
261 memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
262 requestData.payloadSize = sizeof(requestData.payload);
263 requestData.type = CA_MSG_NONCONFIRM;
265 pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
267 EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption(&pdu, &requestData, tempRep, &options));
269 coap_delete_list(options);
270 coap_delete_pdu(pdu);
272 CADestroyToken(tempToken);
273 CADestroyEndpoint(tempRep);
274 free(requestData.payload);
277 // request and block option1
278 TEST_F(CABlockTransferTests, CAAddBlockOption1InRequest)
280 CAEndpoint_t* tempRep = NULL;
281 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
283 coap_pdu_t *pdu = NULL;
284 coap_list_t *options = NULL;
285 coap_transport_t transport = COAP_UDP;
287 CAToken_t tempToken = NULL;
288 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
290 CAInfo_t requestData;
291 memset(&requestData, 0, sizeof(CAInfo_t));
292 requestData.token = tempToken;
293 requestData.tokenLength = CA_MAX_TOKEN_LEN;
295 requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
296 if(!requestData.payload)
298 CADestroyToken(tempToken);
299 FAIL() << "requestData.payload allocation failed";
301 memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
302 requestData.payloadSize = sizeof(requestData.payload);
303 requestData.type = CA_MSG_NONCONFIRM;
305 pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
307 CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
308 EXPECT_TRUE(cadata != NULL);
310 CABlockData_t *currData = CACreateNewBlockData(cadata);
311 EXPECT_TRUE(currData != NULL);
315 EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
316 COAP_OPTION_BLOCK1));
318 EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption1(&pdu, &requestData,
319 requestData.payloadSize,
320 currData->blockDataId, &options));
323 CADestroyDataSet(cadata);
324 coap_delete_list(options);
325 coap_delete_pdu(pdu);
327 CADestroyToken(tempToken);
328 CADestroyEndpoint(tempRep);
329 free(requestData.payload);
332 // response and block option1
333 TEST_F(CABlockTransferTests, CAAddBlockOption1InResponse)
335 CAEndpoint_t* tempRep = NULL;
336 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
338 coap_pdu_t *pdu = NULL;
339 coap_list_t *options = NULL;
340 coap_transport_t transport = COAP_UDP;
342 CAToken_t tempToken = NULL;
343 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
345 CAInfo_t responseData;
346 memset(&responseData, 0, sizeof(CAInfo_t));
347 responseData.token = tempToken;
348 responseData.tokenLength = CA_MAX_TOKEN_LEN;
349 responseData.type = CA_MSG_NONCONFIRM;
350 responseData.messageId = 1;
352 responseData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
353 if(!responseData.payload)
355 CADestroyToken(tempToken);
356 FAIL() << "requestData.payload allocation failed";
358 memset(responseData.payload, '1', sizeof(responseData.payload) - 1);
359 responseData.payloadSize = sizeof(responseData.payload);
361 pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
363 CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
364 EXPECT_TRUE(cadata != NULL);
366 CABlockData_t *currData = CACreateNewBlockData(cadata);
367 EXPECT_TRUE(currData != NULL);
371 EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
372 COAP_OPTION_BLOCK1));
374 EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption1(&pdu, &responseData,
375 responseData.payloadSize,
376 currData->blockDataId, &options));
379 CADestroyDataSet(cadata);
380 coap_delete_list(options);
381 coap_delete_pdu(pdu);
383 CADestroyToken(tempToken);
384 CADestroyEndpoint(tempRep);
385 free(responseData.payload);
388 // response and block option2
389 TEST_F(CABlockTransferTests, CAAddBlockOption2InResponse)
391 CAEndpoint_t* tempRep = NULL;
392 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
394 coap_pdu_t *pdu = NULL;
395 coap_list_t *options = NULL;
396 coap_transport_t transport = COAP_UDP;
398 CAToken_t tempToken = NULL;
399 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
401 CAInfo_t responseData;
402 memset(&responseData, 0, sizeof(CAInfo_t));
403 responseData.token = tempToken;
404 responseData.tokenLength = CA_MAX_TOKEN_LEN;
405 responseData.type = CA_MSG_NONCONFIRM;
406 responseData.messageId = 1;
408 responseData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
409 if(!responseData.payload)
411 CADestroyToken(tempToken);
412 FAIL() << "requestData.payload allocation failed";
414 memset(responseData.payload, '1', sizeof(responseData.payload) - 1);
415 responseData.payloadSize = sizeof(responseData.payload);
417 pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
419 CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
420 EXPECT_TRUE(cadata != NULL);
422 CABlockData_t *currData = CACreateNewBlockData(cadata);
423 EXPECT_TRUE(currData != NULL);
427 EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
428 COAP_OPTION_BLOCK2));
430 EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption2(&pdu, &responseData,
431 responseData.payloadSize,
432 currData->blockDataId, &options));
435 CADestroyDataSet(cadata);
436 coap_delete_list(options);
437 coap_delete_pdu(pdu);
439 CADestroyToken(tempToken);
440 CADestroyEndpoint(tempRep);
441 free(responseData.payload);
444 // request and block option1
445 TEST_F(CABlockTransferTests, CAAddBlockOption2InRequest)
447 CAEndpoint_t* tempRep = NULL;
448 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
450 coap_pdu_t *pdu = NULL;
451 coap_list_t *options = NULL;
452 coap_transport_t transport = COAP_UDP;
454 CAToken_t tempToken = NULL;
455 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
457 CAInfo_t requestData;
458 memset(&requestData, 0, sizeof(CAInfo_t));
459 requestData.token = tempToken;
460 requestData.tokenLength = CA_MAX_TOKEN_LEN;
462 requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
463 if(!requestData.payload)
465 CADestroyToken(tempToken);
466 FAIL() << "requestData.payload allocation failed";
468 memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
469 requestData.payloadSize = sizeof(requestData.payload);
470 requestData.type = CA_MSG_NONCONFIRM;
472 pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
474 CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
475 EXPECT_TRUE(cadata != NULL);
477 CABlockData_t *currData = CACreateNewBlockData(cadata);
478 EXPECT_TRUE(currData != NULL);
482 EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
483 COAP_OPTION_BLOCK2));
485 EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption2(&pdu, &requestData,
486 requestData.payloadSize,
487 currData->blockDataId, &options));
490 CADestroyDataSet(cadata);
491 coap_delete_list(options);
492 coap_delete_pdu(pdu);
494 CADestroyToken(tempToken);
495 CADestroyEndpoint(tempRep);
496 free(requestData.payload);
499 TEST_F(CABlockTransferTests, CAGetBlockSizeOptionFromPduTest)
501 CAEndpoint_t* tempRep = NULL;
502 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
504 coap_pdu_t *pdu = NULL;
505 coap_list_t *options = NULL;
506 coap_transport_t transport = COAP_UDP;
508 CAToken_t tempToken = NULL;
509 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
511 CAInfo_t requestData;
512 memset(&requestData, 0, sizeof(CAInfo_t));
513 requestData.token = tempToken;
514 requestData.tokenLength = CA_MAX_TOKEN_LEN;
515 requestData.type = CA_MSG_NONCONFIRM;
517 pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
519 size_t totalPayloadLen = 0;
520 EXPECT_FALSE(CAIsPayloadLengthInPduWithBlockSizeOption(pdu, COAP_OPTION_SIZE1,
523 coap_delete_list(options);
524 coap_delete_pdu(pdu);
526 CADestroyToken(tempToken);
527 CADestroyEndpoint(tempRep);
528 free(requestData.payload);
531 TEST_F(CABlockTransferTests, CASetNextBlockOption1WithRequest)
533 CAEndpoint_t* tempRep = NULL;
534 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
536 coap_pdu_t *pdu = NULL;
537 coap_list_t *options = NULL;
538 coap_transport_t transport = COAP_UDP;
540 CAToken_t tempToken = NULL;
541 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
543 CAInfo_t requestData;
544 memset(&requestData, 0, sizeof(CAInfo_t));
545 requestData.token = tempToken;
546 requestData.tokenLength = CA_MAX_TOKEN_LEN;
547 requestData.type = CA_MSG_NONCONFIRM;
549 pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
551 CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
552 EXPECT_TRUE(cadata != NULL);
554 CABlockData_t *currData = CACreateNewBlockData(cadata);
555 EXPECT_TRUE(currData != NULL);
557 coap_block_t block = {0, 0, 0};
558 EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption1(pdu, tempRep, cadata, block, pdu->length));
560 CADestroyDataSet(cadata);
561 coap_delete_list(options);
562 coap_delete_pdu(pdu);
564 CADestroyToken(tempToken);
565 CADestroyEndpoint(tempRep);
566 free(requestData.payload);
569 TEST_F(CABlockTransferTests, CASetNextBlockOption1WithResponse)
571 CAEndpoint_t* tempRep = NULL;
572 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
574 coap_pdu_t *pdu = NULL;
575 coap_list_t *options = NULL;
576 coap_transport_t transport = COAP_UDP;
578 CAToken_t tempToken = NULL;
579 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
581 CAInfo_t responseData;
582 memset(&responseData, 0, sizeof(CAInfo_t));
583 responseData.token = tempToken;
584 responseData.tokenLength = CA_MAX_TOKEN_LEN;
585 responseData.type = CA_MSG_NONCONFIRM;
586 responseData.messageId = 1;
588 pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
590 CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
591 EXPECT_TRUE(cadata != NULL);
593 CABlockData_t *currData = CACreateNewBlockData(cadata);
594 EXPECT_TRUE(currData != NULL);
596 coap_block_t block = {0, 0, 0};
597 EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption1(pdu, tempRep, cadata, block, pdu->length));
599 CADestroyDataSet(cadata);
600 coap_delete_list(options);
601 coap_delete_pdu(pdu);
603 CADestroyToken(tempToken);
604 CADestroyEndpoint(tempRep);
605 free(responseData.payload);
608 TEST_F(CABlockTransferTests, CASetNextBlockOption2WithRequest)
610 CAEndpoint_t* tempRep = NULL;
611 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
613 coap_pdu_t *pdu = NULL;
614 coap_list_t *options = NULL;
615 coap_transport_t transport = COAP_UDP;
617 CAToken_t tempToken = NULL;
618 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
620 CAInfo_t requestData;
621 memset(&requestData, 0, sizeof(CAInfo_t));
622 requestData.token = tempToken;
623 requestData.tokenLength = CA_MAX_TOKEN_LEN;
624 requestData.type = CA_MSG_NONCONFIRM;
626 pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
628 CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
629 EXPECT_TRUE(cadata != NULL);
631 CABlockData_t *currData = CACreateNewBlockData(cadata);
632 EXPECT_TRUE(currData != NULL);
634 coap_block_t block = {0, 0, 0};
635 EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption2(pdu, tempRep, cadata, block, pdu->length));
637 CADestroyDataSet(cadata);
638 coap_delete_list(options);
639 coap_delete_pdu(pdu);
641 CADestroyToken(tempToken);
642 CADestroyEndpoint(tempRep);
643 free(requestData.payload);
646 TEST_F(CABlockTransferTests, CASetNextBlockOption2WithResponse)
648 CAEndpoint_t* tempRep = NULL;
649 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
651 coap_pdu_t *pdu = NULL;
652 coap_list_t *options = NULL;
653 coap_transport_t transport = COAP_UDP;
655 CAToken_t tempToken = NULL;
656 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
658 CAInfo_t responseData;
659 memset(&responseData, 0, sizeof(CAInfo_t));
660 responseData.token = tempToken;
661 responseData.tokenLength = CA_MAX_TOKEN_LEN;
662 responseData.type = CA_MSG_NONCONFIRM;
663 responseData.messageId = 1;
665 pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
667 CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
668 EXPECT_TRUE(cadata != NULL);
670 CABlockData_t *currData = CACreateNewBlockData(cadata);
671 EXPECT_TRUE(currData != NULL);
673 coap_block_t block = {0, 0, 0};
674 EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption2(pdu, tempRep, cadata, block, pdu->length));
676 CADestroyDataSet(cadata);
677 coap_delete_list(options);
678 coap_delete_pdu(pdu);
680 CADestroyToken(tempToken);
681 CADestroyEndpoint(tempRep);
682 free(responseData.payload);
685 TEST_F(CABlockTransferTests, CAUpdatePayloadToCADataWithRequest)
687 CAEndpoint_t* tempRep = NULL;
688 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
690 CAToken_t tempToken = NULL;
691 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
693 CAInfo_t requestData;
694 requestData.type = CA_MSG_NONCONFIRM;
695 requestData.token = tempToken;
696 requestData.tokenLength = CA_MAX_TOKEN_LEN;
697 requestData.options = NULL;
698 requestData.payload = NULL;
699 requestData.payloadSize = 0;
701 CARequestInfo_t requestInfo;
702 requestInfo.method = CA_GET;
703 requestInfo.info = requestData;
704 requestInfo.isMulticast = false;
707 cadata.type = SEND_TYPE_UNICAST;
708 cadata.remoteEndpoint = tempRep;
709 cadata.requestInfo = &requestInfo;
710 cadata.dataType = CA_REQUEST_DATA;
712 CAPayload_t payload = (CAPayload_t) "requestPayload";
713 size_t payloadLen = strlen((const char*) payload) + 1;
715 EXPECT_EQ(CA_STATUS_OK, CAUpdatePayloadToCAData(&cadata, payload, payloadLen));
717 EXPECT_STREQ((const char*) payload, (const char*) cadata.requestInfo->info.payload);
720 TEST_F(CABlockTransferTests, CAUpdatePayloadToCADataWithResponse)
722 CAEndpoint_t* tempRep = NULL;
723 CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
725 CAToken_t tempToken = NULL;
726 CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
728 CAInfo_t responseData;
729 responseData.type = CA_MSG_NONCONFIRM;
730 responseData.token = tempToken;
731 responseData.tokenLength = CA_MAX_TOKEN_LEN;
732 responseData.options = NULL;
733 responseData.payload = NULL;
734 responseData.payloadSize = 0;
736 CAResponseInfo_t responseInfo;
737 responseInfo.result = CA_VALID;
738 responseInfo.info = responseData;
741 cadata.type = SEND_TYPE_UNICAST;
742 cadata.remoteEndpoint = tempRep;
743 cadata.responseInfo = &responseInfo;
744 cadata.dataType = CA_RESPONSE_DATA;
746 CAPayload_t payload = (CAPayload_t) "responsePayload";
747 size_t payloadLen = strlen((const char*) payload) + 1;
749 EXPECT_EQ(CA_STATUS_OK, CAUpdatePayloadToCAData(&cadata, payload, payloadLen));
751 EXPECT_STREQ((const char*) payload, (const char*) cadata.responseInfo->info.payload);