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(CA_ADAPTER_IP);
  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_t 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_t 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_t 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_t 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     if (currData)
 217     {
 218         size_t fullPayload = 0;
 219         CAPayload_t payload = CAGetPayloadFromBlockDataList(currData->blockDataId,
 220                                                             &fullPayload);
 221
 222         size_t payloadLen = (payload != NULL) ? strlen((const char*) payload) : 0;
 223         EXPECT_TRUE(fullPayload == payloadLen);
 224
 225         CARemoveBlockDataFromList(currData->blockDataId);
 226     }
 227
 228     CADestroyDataSet(cadata);
 229     coap_delete_list(options);
 230     coap_delete_pdu(pdu);
 231
 232     CADestroyToken(tempToken);
 233     CADestroyEndpoint(tempRep);
 234     free(requestData.payload);
 235 }
 236
 237 // request and block option1
 238 TEST_F(CABlockTransferTests, CAAddBlockOptionTest)
 239 {
 240     CAEndpoint_t* tempRep = NULL;
 241     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 242
 243     coap_pdu_t *pdu = NULL;
 244     coap_list_t *options = NULL;
 245     coap_transport_t transport = COAP_UDP;
 246
 247     CAToken_t tempToken = NULL;
 248     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 249
 250     CAInfo_t requestData;
 251     memset(&requestData, 0, sizeof(CAInfo_t));
 252     requestData.token = tempToken;
 253     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 254
 255     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 256     if(!requestData.payload)
 257     {
 258         CADestroyToken(tempToken);
 259         FAIL() << "requestData.payload allocation failed";
 260     }
 261     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
 262     requestData.payloadSize = sizeof(requestData.payload);
 263     requestData.type = CA_MSG_NONCONFIRM;
 264
 265     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 266
 267     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption(&pdu, &requestData, tempRep, &options));
 268
 269     coap_delete_list(options);
 270     coap_delete_pdu(pdu);
 271
 272     CADestroyToken(tempToken);
 273     CADestroyEndpoint(tempRep);
 274     free(requestData.payload);
 275 }
 276
 277 // request and block option1
 278 TEST_F(CABlockTransferTests, CAAddBlockOption1InRequest)
 279 {
 280     CAEndpoint_t* tempRep = NULL;
 281     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 282
 283     coap_pdu_t *pdu = NULL;
 284     coap_list_t *options = NULL;
 285     coap_transport_t transport = COAP_UDP;
 286
 287     CAToken_t tempToken = NULL;
 288     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 289
 290     CAInfo_t requestData;
 291     memset(&requestData, 0, sizeof(CAInfo_t));
 292     requestData.token = tempToken;
 293     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 294
 295     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 296     if(!requestData.payload)
 297     {
 298         CADestroyToken(tempToken);
 299         FAIL() << "requestData.payload allocation failed";
 300     }
 301     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
 302     requestData.payloadSize = sizeof(requestData.payload);
 303     requestData.type = CA_MSG_NONCONFIRM;
 304
 305     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 306
 307     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 308     EXPECT_TRUE(cadata != NULL);
 309
 310     CABlockData_t *currData = CACreateNewBlockData(cadata);
 311     EXPECT_TRUE(currData != NULL);
 312
 313     if (currData)
 314     {
 315         EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
 316                                                         COAP_OPTION_BLOCK1));
 317
 318         EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption1(&pdu, &requestData,
 319                                                   requestData.payloadSize,
 320                                                   currData->blockDataId, &options));
 321     }
 322
 323     CADestroyDataSet(cadata);
 324     coap_delete_list(options);
 325     coap_delete_pdu(pdu);
 326
 327     CADestroyToken(tempToken);
 328     CADestroyEndpoint(tempRep);
 329     free(requestData.payload);
 330 }
 331
 332 // response and block option1
 333 TEST_F(CABlockTransferTests, CAAddBlockOption1InResponse)
 334 {
 335     CAEndpoint_t* tempRep = NULL;
 336     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 337
 338     coap_pdu_t *pdu = NULL;
 339     coap_list_t *options = NULL;
 340     coap_transport_t transport = COAP_UDP;
 341
 342     CAToken_t tempToken = NULL;
 343     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 344
 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;
 351
 352     responseData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 353     if(!responseData.payload)
 354     {
 355         CADestroyToken(tempToken);
 356         FAIL() << "requestData.payload allocation failed";
 357     }
 358     memset(responseData.payload, '1', sizeof(responseData.payload) - 1);
 359     responseData.payloadSize = sizeof(responseData.payload);
 360
 361     pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
 362
 363     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 364     EXPECT_TRUE(cadata != NULL);
 365
 366     CABlockData_t *currData = CACreateNewBlockData(cadata);
 367     EXPECT_TRUE(currData != NULL);
 368
 369     if (currData)
 370     {
 371         EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
 372                                                         COAP_OPTION_BLOCK1));
 373
 374         EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption1(&pdu, &responseData,
 375                                                   responseData.payloadSize,
 376                                                   currData->blockDataId, &options));
 377     }
 378
 379     CADestroyDataSet(cadata);
 380     coap_delete_list(options);
 381     coap_delete_pdu(pdu);
 382
 383     CADestroyToken(tempToken);
 384     CADestroyEndpoint(tempRep);
 385     free(responseData.payload);
 386 }
 387
 388 // response and block option2
 389 TEST_F(CABlockTransferTests, CAAddBlockOption2InResponse)
 390 {
 391     CAEndpoint_t* tempRep = NULL;
 392     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 393
 394     coap_pdu_t *pdu = NULL;
 395     coap_list_t *options = NULL;
 396     coap_transport_t transport = COAP_UDP;
 397
 398     CAToken_t tempToken = NULL;
 399     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 400
 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;
 407
 408     responseData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 409     if(!responseData.payload)
 410     {
 411         CADestroyToken(tempToken);
 412         FAIL() << "requestData.payload allocation failed";
 413     }
 414     memset(responseData.payload, '1', sizeof(responseData.payload) - 1);
 415     responseData.payloadSize = sizeof(responseData.payload);
 416
 417     pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
 418
 419     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 420     EXPECT_TRUE(cadata != NULL);
 421
 422     CABlockData_t *currData = CACreateNewBlockData(cadata);
 423     EXPECT_TRUE(currData != NULL);
 424
 425     if (currData)
 426     {
 427         EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
 428                                                         COAP_OPTION_BLOCK2));
 429
 430         EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption2(&pdu, &responseData,
 431                                                   responseData.payloadSize,
 432                                                   currData->blockDataId, &options));
 433     }
 434
 435     CADestroyDataSet(cadata);
 436     coap_delete_list(options);
 437     coap_delete_pdu(pdu);
 438
 439     CADestroyToken(tempToken);
 440     CADestroyEndpoint(tempRep);
 441     free(responseData.payload);
 442 }
 443
 444 // request and block option1
 445 TEST_F(CABlockTransferTests, CAAddBlockOption2InRequest)
 446 {
 447     CAEndpoint_t* tempRep = NULL;
 448     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 449
 450     coap_pdu_t *pdu = NULL;
 451     coap_list_t *options = NULL;
 452     coap_transport_t transport = COAP_UDP;
 453
 454     CAToken_t tempToken = NULL;
 455     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 456
 457     CAInfo_t requestData;
 458     memset(&requestData, 0, sizeof(CAInfo_t));
 459     requestData.token = tempToken;
 460     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 461
 462     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 463     if(!requestData.payload)
 464     {
 465         CADestroyToken(tempToken);
 466         FAIL() << "requestData.payload allocation failed";
 467     }
 468     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
 469     requestData.payloadSize = sizeof(requestData.payload);
 470     requestData.type = CA_MSG_NONCONFIRM;
 471
 472     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 473
 474     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 475     EXPECT_TRUE(cadata != NULL);
 476
 477     CABlockData_t *currData = CACreateNewBlockData(cadata);
 478     EXPECT_TRUE(currData != NULL);
 479
 480     if (currData)
 481     {
 482         EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
 483                                                         COAP_OPTION_BLOCK2));
 484
 485         EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption2(&pdu, &requestData,
 486                                                   requestData.payloadSize,
 487                                                   currData->blockDataId, &options));
 488     }
 489
 490     CADestroyDataSet(cadata);
 491     coap_delete_list(options);
 492     coap_delete_pdu(pdu);
 493
 494     CADestroyToken(tempToken);
 495     CADestroyEndpoint(tempRep);
 496     free(requestData.payload);
 497 }
 498
 499 TEST_F(CABlockTransferTests, CAGetBlockSizeOptionFromPduTest)
 500 {
 501     CAEndpoint_t* tempRep = NULL;
 502     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 503
 504     coap_pdu_t *pdu = NULL;
 505     coap_list_t *options = NULL;
 506     coap_transport_t transport = COAP_UDP;
 507
 508     CAToken_t tempToken = NULL;
 509     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 510
 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;
 516
 517     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 518
 519     size_t totalPayloadLen = 0;
 520     EXPECT_FALSE(CAIsPayloadLengthInPduWithBlockSizeOption(pdu, COAP_OPTION_SIZE1,
 521                                                            &totalPayloadLen));
 522
 523     coap_delete_list(options);
 524     coap_delete_pdu(pdu);
 525
 526     CADestroyToken(tempToken);
 527     CADestroyEndpoint(tempRep);
 528     free(requestData.payload);
 529 }
 530
 531 TEST_F(CABlockTransferTests, CASetNextBlockOption1WithRequest)
 532 {
 533     CAEndpoint_t* tempRep = NULL;
 534     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 535
 536     coap_pdu_t *pdu = NULL;
 537     coap_list_t *options = NULL;
 538     coap_transport_t transport = COAP_UDP;
 539
 540     CAToken_t tempToken = NULL;
 541     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 542
 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;
 548
 549     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 550
 551     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 552     EXPECT_TRUE(cadata != NULL);
 553
 554     CABlockData_t *currData = CACreateNewBlockData(cadata);
 555     EXPECT_TRUE(currData != NULL);
 556
 557     coap_block_t block = {0, 0, 0};
 558     EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption1(pdu, tempRep, cadata, block, pdu->length));
 559
 560     CADestroyDataSet(cadata);
 561     coap_delete_list(options);
 562     coap_delete_pdu(pdu);
 563
 564     CADestroyToken(tempToken);
 565     CADestroyEndpoint(tempRep);
 566     free(requestData.payload);
 567 }
 568
 569 TEST_F(CABlockTransferTests, CASetNextBlockOption1WithResponse)
 570 {
 571     CAEndpoint_t* tempRep = NULL;
 572     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 573
 574     coap_pdu_t *pdu = NULL;
 575     coap_list_t *options = NULL;
 576     coap_transport_t transport = COAP_UDP;
 577
 578     CAToken_t tempToken = NULL;
 579     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 580
 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;
 587
 588     pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
 589
 590     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 591     EXPECT_TRUE(cadata != NULL);
 592
 593     CABlockData_t *currData = CACreateNewBlockData(cadata);
 594     EXPECT_TRUE(currData != NULL);
 595
 596     coap_block_t block = {0, 0, 0};
 597     EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption1(pdu, tempRep, cadata, block, pdu->length));
 598
 599     CADestroyDataSet(cadata);
 600     coap_delete_list(options);
 601     coap_delete_pdu(pdu);
 602
 603     CADestroyToken(tempToken);
 604     CADestroyEndpoint(tempRep);
 605     free(responseData.payload);
 606 }
 607
 608 TEST_F(CABlockTransferTests, CASetNextBlockOption2WithRequest)
 609 {
 610     CAEndpoint_t* tempRep = NULL;
 611     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 612
 613     coap_pdu_t *pdu = NULL;
 614     coap_list_t *options = NULL;
 615     coap_transport_t transport = COAP_UDP;
 616
 617     CAToken_t tempToken = NULL;
 618     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 619
 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;
 625
 626     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 627
 628     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 629     EXPECT_TRUE(cadata != NULL);
 630
 631     CABlockData_t *currData = CACreateNewBlockData(cadata);
 632     EXPECT_TRUE(currData != NULL);
 633
 634     coap_block_t block = {0, 0, 0};
 635     EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption2(pdu, tempRep, cadata, block, pdu->length));
 636
 637     CADestroyDataSet(cadata);
 638     coap_delete_list(options);
 639     coap_delete_pdu(pdu);
 640
 641     CADestroyToken(tempToken);
 642     CADestroyEndpoint(tempRep);
 643     free(requestData.payload);
 644 }
 645
 646 TEST_F(CABlockTransferTests, CASetNextBlockOption2WithResponse)
 647 {
 648     CAEndpoint_t* tempRep = NULL;
 649     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 650
 651     coap_pdu_t *pdu = NULL;
 652     coap_list_t *options = NULL;
 653     coap_transport_t transport = COAP_UDP;
 654
 655     CAToken_t tempToken = NULL;
 656     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 657
 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;
 664
 665     pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
 666
 667     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 668     EXPECT_TRUE(cadata != NULL);
 669
 670     CABlockData_t *currData = CACreateNewBlockData(cadata);
 671     EXPECT_TRUE(currData != NULL);
 672
 673     coap_block_t block = {0, 0, 0};
 674     EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption2(pdu, tempRep, cadata, block, pdu->length));
 675
 676     CADestroyDataSet(cadata);
 677     coap_delete_list(options);
 678     coap_delete_pdu(pdu);
 679
 680     CADestroyToken(tempToken);
 681     CADestroyEndpoint(tempRep);
 682     free(responseData.payload);
 683 }
 684
 685 TEST_F(CABlockTransferTests, CAUpdatePayloadToCADataWithRequest)
 686 {
 687     CAEndpoint_t* tempRep = NULL;
 688     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 689
 690     CAToken_t tempToken = NULL;
 691     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 692
 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;
 700
 701     CARequestInfo_t requestInfo;
 702     requestInfo.method = CA_GET;
 703     requestInfo.info = requestData;
 704     requestInfo.isMulticast = false;
 705
 706     CAData_t cadata;
 707     cadata.type = SEND_TYPE_UNICAST;
 708     cadata.remoteEndpoint = tempRep;
 709     cadata.requestInfo = &requestInfo;
 710     cadata.dataType = CA_REQUEST_DATA;
 711
 712     CAPayload_t payload = (CAPayload_t) "requestPayload";
 713     size_t payloadLen = strlen((const char*) payload) + 1;
 714
 715     EXPECT_EQ(CA_STATUS_OK, CAUpdatePayloadToCAData(&cadata, payload, payloadLen));
 716
 717     EXPECT_STREQ((const char*) payload, (const char*) cadata.requestInfo->info.payload);
 718 }
 719
 720 TEST_F(CABlockTransferTests, CAUpdatePayloadToCADataWithResponse)
 721 {
 722     CAEndpoint_t* tempRep = NULL;
 723     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 724
 725     CAToken_t tempToken = NULL;
 726     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 727
 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;
 735
 736     CAResponseInfo_t responseInfo;
 737     responseInfo.result = CA_VALID;
 738     responseInfo.info = responseData;
 739
 740     CAData_t cadata;
 741     cadata.type = SEND_TYPE_UNICAST;
 742     cadata.remoteEndpoint = tempRep;
 743     cadata.responseInfo = &responseInfo;
 744     cadata.dataType = CA_RESPONSE_DATA;
 745
 746     CAPayload_t payload = (CAPayload_t) "responsePayload";
 747     size_t payloadLen = strlen((const char*) payload) + 1;
 748
 749     EXPECT_EQ(CA_STATUS_OK, CAUpdatePayloadToCAData(&cadata, payload, payloadLen));
 750
 751     EXPECT_STREQ((const char*) payload, (const char*) cadata.responseInfo->info.payload);
 752 }