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         CAInitialize();
  34     }
  35
  36     virtual void TearDown()
  37     {
  38         CATerminate();
  39     }
  40 };
  41
  42 TEST_F(CABlockTransferTests, CACreateNewDataSetTest)
  43 {
  44     CAEndpoint_t* tempRep = NULL;
  45     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
  46
  47     coap_pdu_t *pdu = NULL;
  48     coap_list_t *options = NULL;
  49     coap_transport_type transport = coap_udp;
  50
  51     CAToken_t tempToken = NULL;
  52     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
  53
  54     CAInfo_t requestData;
  55     memset(&requestData, 0, sizeof(CAInfo_t));
  56     requestData.token = tempToken;
  57     requestData.tokenLength = CA_MAX_TOKEN_LEN;
  58     requestData.type = CA_MSG_NONCONFIRM;
  59
  60     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
  61     if (!requestData.payload)
  62     {
  63         CADestroyToken(tempToken);
  64         FAIL() << "requestData.payload allocation failed";
  65     }
  66     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
  67     requestData.payloadSize = sizeof(requestData.payload);
  68     requestData.type = CA_MSG_NONCONFIRM;
  69
  70     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
  71
  72     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
  73     EXPECT_TRUE(cadata != NULL);
  74
  75     CABlockData_t *currData = CACreateNewBlockData(cadata);
  76     EXPECT_TRUE(currData != NULL);
  77
  78     if (currData)
  79     {
  80         CAData_t *getData = CAGetDataSetFromBlockDataList(currData->blockDataId);
  81         EXPECT_TRUE(getData != NULL);
  82
  83         CARemoveBlockDataFromList(currData->blockDataId);
  84     }
  85
  86     CADestroyDataSet(cadata);
  87     coap_delete_list(options);
  88     coap_delete_pdu(pdu);
  89
  90     CADestroyToken(tempToken);
  91     CADestroyEndpoint(tempRep);
  92     free(requestData.payload);
  93 }
  94
  95 TEST_F(CABlockTransferTests, CAGetBlockDataFromBlockDataListTest)
  96 {
  97     CAEndpoint_t* tempRep = NULL;
  98     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
  99
 100     coap_pdu_t *pdu = NULL;
 101     coap_list_t *options = NULL;
 102     coap_transport_type transport = coap_udp;
 103
 104     CAToken_t tempToken = NULL;
 105     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 106
 107     CAInfo_t requestData;
 108     memset(&requestData, 0, sizeof(CAInfo_t));
 109     requestData.token = tempToken;
 110     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 111     requestData.type = CA_MSG_NONCONFIRM;
 112
 113     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 114
 115     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 116     EXPECT_TRUE(cadata != NULL);
 117
 118     CABlockData_t *currData = CACreateNewBlockData(cadata);
 119     EXPECT_TRUE(currData != NULL);
 120
 121     if (currData)
 122     {
 123         CABlockData_t *data = CAGetBlockDataFromBlockDataList(currData->blockDataId);
 124         EXPECT_TRUE(data != NULL);
 125
 126         CARemoveBlockDataFromList(currData->blockDataId);
 127     }
 128
 129     CADestroyDataSet(cadata);
 130     coap_delete_list(options);
 131     coap_delete_pdu(pdu);
 132
 133     CADestroyToken(tempToken);
 134     CADestroyEndpoint(tempRep);
 135     free(requestData.payload);
 136 }
 137
 138 TEST_F(CABlockTransferTests, CAGetPayloadFromBlockDataListTest)
 139 {
 140     CAEndpoint_t* tempRep = NULL;
 141     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 142
 143     coap_pdu_t *pdu = NULL;
 144     coap_list_t *options = NULL;
 145     coap_transport_type transport = coap_udp;
 146
 147     CAToken_t tempToken = NULL;
 148     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 149
 150     CAInfo_t requestData;
 151     memset(&requestData, 0, sizeof(CAInfo_t));
 152     requestData.token = tempToken;
 153     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 154     requestData.type = CA_MSG_NONCONFIRM;
 155
 156     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 157
 158     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 159     EXPECT_TRUE(cadata != NULL);
 160
 161     CABlockData_t *currData = CACreateNewBlockData(cadata);
 162     EXPECT_TRUE(currData != NULL);
 163
 164     size_t fullPayload = 0;
 165     CAPayload_t payload = CAGetPayloadFromBlockDataList(currData->blockDataId,
 166                                                         &fullPayload);
 167
 168     size_t payloadLen = (payload != NULL) ? strlen((const char*) payload) : 0;
 169     EXPECT_TRUE(fullPayload == payloadLen);
 170
 171     CARemoveBlockDataFromList(currData->blockDataId);
 172     CADestroyDataSet(cadata);
 173     coap_delete_list(options);
 174     coap_delete_pdu(pdu);
 175
 176     CADestroyToken(tempToken);
 177     CADestroyEndpoint(tempRep);
 178     free(requestData.payload);
 179 }
 180
 181 // request and block option1
 182 TEST_F(CABlockTransferTests, CAAddBlockOptionTest)
 183 {
 184     CAEndpoint_t* tempRep = NULL;
 185     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 186
 187     coap_pdu_t *pdu = NULL;
 188     coap_list_t *options = NULL;
 189     coap_transport_type transport = coap_udp;
 190
 191     CAToken_t tempToken = NULL;
 192     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 193
 194     CAInfo_t requestData;
 195     memset(&requestData, 0, sizeof(CAInfo_t));
 196     requestData.token = tempToken;
 197     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 198
 199     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 200     if(!requestData.payload)
 201     {
 202         CADestroyToken(tempToken);
 203         FAIL() << "requestData.payload allocation failed";
 204     }
 205     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
 206     requestData.payloadSize = sizeof(requestData.payload);
 207     requestData.type = CA_MSG_NONCONFIRM;
 208
 209     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 210
 211     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption(&pdu, &requestData, tempRep, &options));
 212
 213     coap_delete_list(options);
 214     coap_delete_pdu(pdu);
 215
 216     CADestroyToken(tempToken);
 217     CADestroyEndpoint(tempRep);
 218     free(requestData.payload);
 219 }
 220
 221 // request and block option1
 222 TEST_F(CABlockTransferTests, CAAddBlockOption1InRequest)
 223 {
 224     CAEndpoint_t* tempRep = NULL;
 225     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 226
 227     coap_pdu_t *pdu = NULL;
 228     coap_list_t *options = NULL;
 229     coap_transport_type transport = coap_udp;
 230
 231     CAToken_t tempToken = NULL;
 232     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 233
 234     CAInfo_t requestData;
 235     memset(&requestData, 0, sizeof(CAInfo_t));
 236     requestData.token = tempToken;
 237     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 238
 239     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 240     if(!requestData.payload)
 241     {
 242         CADestroyToken(tempToken);
 243         FAIL() << "requestData.payload allocation failed";
 244     }
 245     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
 246     requestData.payloadSize = sizeof(requestData.payload);
 247     requestData.type = CA_MSG_NONCONFIRM;
 248
 249     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 250
 251     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 252     EXPECT_TRUE(cadata != NULL);
 253
 254     CABlockData_t *currData = CACreateNewBlockData(cadata);
 255     EXPECT_TRUE(currData != NULL);
 256
 257     EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
 258                                                     COAP_OPTION_BLOCK1));
 259
 260     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption1(&pdu, &requestData,
 261                                               requestData.payloadSize,
 262                                               currData->blockDataId, &options));
 263
 264     CADestroyDataSet(cadata);
 265     coap_delete_list(options);
 266     coap_delete_pdu(pdu);
 267
 268     CADestroyToken(tempToken);
 269     CADestroyEndpoint(tempRep);
 270     free(requestData.payload);
 271 }
 272
 273 // response and block option1
 274 TEST_F(CABlockTransferTests, CAAddBlockOption1InResponse)
 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 responseData;
 287     memset(&responseData, 0, sizeof(CAInfo_t));
 288     responseData.token = tempToken;
 289     responseData.tokenLength = CA_MAX_TOKEN_LEN;
 290     responseData.type = CA_MSG_NONCONFIRM;
 291     responseData.messageId = 1;
 292
 293     responseData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 294     if(!responseData.payload)
 295     {
 296         CADestroyToken(tempToken);
 297         FAIL() << "requestData.payload allocation failed";
 298     }
 299     memset(responseData.payload, '1', sizeof(responseData.payload) - 1);
 300     responseData.payloadSize = sizeof(responseData.payload);
 301
 302     pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
 303
 304     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 305     EXPECT_TRUE(cadata != NULL);
 306
 307     CABlockData_t *currData = CACreateNewBlockData(cadata);
 308     EXPECT_TRUE(currData != NULL);
 309
 310     EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
 311                                                     COAP_OPTION_BLOCK1));
 312
 313     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption1(&pdu, &responseData,
 314                                               responseData.payloadSize,
 315                                               currData->blockDataId, &options));
 316
 317     CADestroyDataSet(cadata);
 318     coap_delete_list(options);
 319     coap_delete_pdu(pdu);
 320
 321     CADestroyToken(tempToken);
 322     CADestroyEndpoint(tempRep);
 323     free(responseData.payload);
 324 }
 325
 326 // response and block option2
 327 TEST_F(CABlockTransferTests, CAAddBlockOption2InResponse)
 328 {
 329     CAEndpoint_t* tempRep = NULL;
 330     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 331
 332     coap_pdu_t *pdu = NULL;
 333     coap_list_t *options = NULL;
 334     coap_transport_type transport = coap_udp;
 335
 336     CAToken_t tempToken = NULL;
 337     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 338
 339     CAInfo_t responseData;
 340     memset(&responseData, 0, sizeof(CAInfo_t));
 341     responseData.token = tempToken;
 342     responseData.tokenLength = CA_MAX_TOKEN_LEN;
 343     responseData.type = CA_MSG_NONCONFIRM;
 344     responseData.messageId = 1;
 345
 346     responseData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 347     if(!responseData.payload)
 348     {
 349         CADestroyToken(tempToken);
 350         FAIL() << "requestData.payload allocation failed";
 351     }
 352     memset(responseData.payload, '1', sizeof(responseData.payload) - 1);
 353     responseData.payloadSize = sizeof(responseData.payload);
 354
 355     pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
 356
 357     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 358     EXPECT_TRUE(cadata != NULL);
 359
 360     CABlockData_t *currData = CACreateNewBlockData(cadata);
 361     EXPECT_TRUE(currData != NULL);
 362
 363     EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
 364                                                     COAP_OPTION_BLOCK2));
 365
 366     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption2(&pdu, &responseData,
 367                                               responseData.payloadSize,
 368                                               currData->blockDataId, &options));
 369
 370     CADestroyDataSet(cadata);
 371     coap_delete_list(options);
 372     coap_delete_pdu(pdu);
 373
 374     CADestroyToken(tempToken);
 375     CADestroyEndpoint(tempRep);
 376     free(responseData.payload);
 377 }
 378
 379 // request and block option1
 380 TEST_F(CABlockTransferTests, CAAddBlockOption2InRequest)
 381 {
 382     CAEndpoint_t* tempRep = NULL;
 383     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 384
 385     coap_pdu_t *pdu = NULL;
 386     coap_list_t *options = NULL;
 387     coap_transport_type transport = coap_udp;
 388
 389     CAToken_t tempToken = NULL;
 390     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 391
 392     CAInfo_t requestData;
 393     memset(&requestData, 0, sizeof(CAInfo_t));
 394     requestData.token = tempToken;
 395     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 396
 397     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 398     if(!requestData.payload)
 399     {
 400         CADestroyToken(tempToken);
 401         FAIL() << "requestData.payload allocation failed";
 402     }
 403     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
 404     requestData.payloadSize = sizeof(requestData.payload);
 405     requestData.type = CA_MSG_NONCONFIRM;
 406
 407     pdu = CAGeneratePDU(CA_GET, &requestData, 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, &requestData,
 419                                               requestData.payloadSize,
 420                                               currData->blockDataId, &options));
 421
 422     CARemoveBlockDataFromList(currData->blockDataId);
 423     CADestroyDataSet(cadata);
 424     coap_delete_list(options);
 425     coap_delete_pdu(pdu);
 426
 427     CADestroyToken(tempToken);
 428     CADestroyEndpoint(tempRep);
 429     free(requestData.payload);
 430 }
 431
 432 TEST_F(CABlockTransferTests, CAGetBlockSizeOptionFromPduTest)
 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     requestData.type = CA_MSG_NONCONFIRM;
 449
 450     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 451
 452     size_t totalPayloadLen = 0;
 453     EXPECT_FALSE(CAIsPayloadLengthInPduWithBlockSizeOption(pdu, COAP_OPTION_SIZE1,
 454                                                            &totalPayloadLen));
 455
 456     coap_delete_list(options);
 457     coap_delete_pdu(pdu);
 458
 459     CADestroyToken(tempToken);
 460     CADestroyEndpoint(tempRep);
 461     free(requestData.payload);
 462 }
 463
 464 TEST_F(CABlockTransferTests, CASetNextBlockOption1Test)
 465 {
 466     CAEndpoint_t* tempRep = NULL;
 467     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 468
 469     coap_pdu_t *pdu = NULL;
 470     coap_list_t *options = NULL;
 471     coap_transport_type transport = coap_udp;
 472
 473     CAToken_t tempToken = NULL;
 474     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 475
 476     CAInfo_t responseData;
 477     memset(&responseData, 0, sizeof(CAInfo_t));
 478     responseData.token = tempToken;
 479     responseData.tokenLength = CA_MAX_TOKEN_LEN;
 480     responseData.type = CA_MSG_NONCONFIRM;
 481     responseData.messageId = 1;
 482
 483     pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
 484
 485     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 486     EXPECT_TRUE(cadata != NULL);
 487
 488     CABlockData_t *currData = CACreateNewBlockData(cadata);
 489     EXPECT_TRUE(currData != NULL);
 490
 491     coap_block_t block = {0, 0, 0};
 492     EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption1(pdu, tempRep, cadata, block, pdu->length));
 493
 494     EXPECT_EQ(CA_STATUS_OK, CAHandleRequestResponse());
 495
 496     CADestroyDataSet(cadata);
 497     coap_delete_list(options);
 498     coap_delete_pdu(pdu);
 499
 500     CADestroyToken(tempToken);
 501     CADestroyEndpoint(tempRep);
 502     free(responseData.payload);
 503 }
 504
 505 TEST_F(CABlockTransferTests, CASetNextBlockOption2Test)
 506 {
 507     CAEndpoint_t* tempRep = NULL;
 508     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 509
 510     coap_pdu_t *pdu = NULL;
 511     coap_list_t *options = NULL;
 512     coap_transport_type transport = coap_udp;
 513
 514     CAToken_t tempToken = NULL;
 515     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 516
 517     CAInfo_t requestData;
 518     memset(&requestData, 0, sizeof(CAInfo_t));
 519     requestData.token = tempToken;
 520     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 521     requestData.type = CA_MSG_NONCONFIRM;
 522
 523     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 524
 525     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 526     EXPECT_TRUE(cadata != NULL);
 527
 528     CABlockData_t *currData = CACreateNewBlockData(cadata);
 529     EXPECT_TRUE(currData != NULL);
 530
 531     coap_block_t block = {0, 0, 0};
 532     EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption2(pdu, tempRep, cadata, block, pdu->length));
 533
 534     CADestroyDataSet(cadata);
 535     coap_delete_list(options);
 536     coap_delete_pdu(pdu);
 537
 538     CADestroyToken(tempToken);
 539     CADestroyEndpoint(tempRep);
 540     free(requestData.payload);
 541 }