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 }