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         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, CAGetBlockDataFromBlockDataListTest)
  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     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 115
 116     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 117     EXPECT_TRUE(cadata != NULL);
 118
 119     CABlockData_t *currData = CACreateNewBlockData(cadata);
 120     EXPECT_TRUE(currData != NULL);
 121
 122     if (currData)
 123     {
 124         CABlockData_t *data = CAGetBlockDataFromBlockDataList(currData->blockDataId);
 125         EXPECT_TRUE(data != NULL);
 126
 127         CARemoveBlockDataFromList(currData->blockDataId);
 128     }
 129
 130     CADestroyDataSet(cadata);
 131     coap_delete_list(options);
 132     coap_delete_pdu(pdu);
 133
 134     CADestroyToken(tempToken);
 135     CADestroyEndpoint(tempRep);
 136     free(requestData.payload);
 137 }
 138
 139 TEST_F(CABlockTransferTests, CAGetPayloadFromBlockDataListTest)
 140 {
 141     CAEndpoint_t* tempRep = NULL;
 142     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 143
 144     coap_pdu_t *pdu = NULL;
 145     coap_list_t *options = NULL;
 146     coap_transport_type transport = coap_udp;
 147
 148     CAToken_t tempToken = NULL;
 149     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 150
 151     CAInfo_t requestData;
 152     memset(&requestData, 0, sizeof(CAInfo_t));
 153     requestData.token = tempToken;
 154     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 155     requestData.type = CA_MSG_NONCONFIRM;
 156
 157     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 158
 159     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 160     EXPECT_TRUE(cadata != NULL);
 161
 162     CABlockData_t *currData = CACreateNewBlockData(cadata);
 163     EXPECT_TRUE(currData != NULL);
 164
 165     size_t fullPayload = 0;
 166     CAPayload_t payload = CAGetPayloadFromBlockDataList(currData->blockDataId,
 167                                                         &fullPayload);
 168
 169     size_t payloadLen = (payload != NULL) ? strlen((const char*) payload) : 0;
 170     EXPECT_TRUE(fullPayload == payloadLen);
 171
 172     CARemoveBlockDataFromList(currData->blockDataId);
 173     CADestroyDataSet(cadata);
 174     coap_delete_list(options);
 175     coap_delete_pdu(pdu);
 176
 177     CADestroyToken(tempToken);
 178     CADestroyEndpoint(tempRep);
 179     free(requestData.payload);
 180 }
 181
 182 // request and block option1
 183 TEST_F(CABlockTransferTests, CAAddBlockOptionTest)
 184 {
 185     CAEndpoint_t* tempRep = NULL;
 186     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 187
 188     coap_pdu_t *pdu = NULL;
 189     coap_list_t *options = NULL;
 190     coap_transport_type transport = coap_udp;
 191
 192     CAToken_t tempToken = NULL;
 193     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 194
 195     CAInfo_t requestData;
 196     memset(&requestData, 0, sizeof(CAInfo_t));
 197     requestData.token = tempToken;
 198     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 199
 200     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 201     if(!requestData.payload)
 202     {
 203         CADestroyToken(tempToken);
 204         FAIL() << "requestData.payload allocation failed";
 205     }
 206     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
 207     requestData.payloadSize = sizeof(requestData.payload);
 208     requestData.type = CA_MSG_NONCONFIRM;
 209
 210     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 211
 212     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption(&pdu, &requestData, tempRep, &options));
 213
 214     coap_delete_list(options);
 215     coap_delete_pdu(pdu);
 216
 217     CADestroyToken(tempToken);
 218     CADestroyEndpoint(tempRep);
 219     free(requestData.payload);
 220 }
 221
 222 // request and block option1
 223 TEST_F(CABlockTransferTests, CAAddBlockOption1InRequest)
 224 {
 225     CAEndpoint_t* tempRep = NULL;
 226     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 227
 228     coap_pdu_t *pdu = NULL;
 229     coap_list_t *options = NULL;
 230     coap_transport_type transport = coap_udp;
 231
 232     CAToken_t tempToken = NULL;
 233     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 234
 235     CAInfo_t requestData;
 236     memset(&requestData, 0, sizeof(CAInfo_t));
 237     requestData.token = tempToken;
 238     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 239
 240     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 241     if(!requestData.payload)
 242     {
 243         CADestroyToken(tempToken);
 244         FAIL() << "requestData.payload allocation failed";
 245     }
 246     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
 247     requestData.payloadSize = sizeof(requestData.payload);
 248     requestData.type = CA_MSG_NONCONFIRM;
 249
 250     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 251
 252     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 253     EXPECT_TRUE(cadata != NULL);
 254
 255     CABlockData_t *currData = CACreateNewBlockData(cadata);
 256     EXPECT_TRUE(currData != NULL);
 257
 258     EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
 259                                                     COAP_OPTION_BLOCK1));
 260
 261     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption1(&pdu, &requestData,
 262                                               requestData.payloadSize,
 263                                               currData->blockDataId, &options));
 264
 265     CADestroyDataSet(cadata);
 266     coap_delete_list(options);
 267     coap_delete_pdu(pdu);
 268
 269     CADestroyToken(tempToken);
 270     CADestroyEndpoint(tempRep);
 271     free(requestData.payload);
 272 }
 273
 274 // response and block option1
 275 TEST_F(CABlockTransferTests, CAAddBlockOption1InResponse)
 276 {
 277     CAEndpoint_t* tempRep = NULL;
 278     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 279
 280     coap_pdu_t *pdu = NULL;
 281     coap_list_t *options = NULL;
 282     coap_transport_type transport = coap_udp;
 283
 284     CAToken_t tempToken = NULL;
 285     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 286
 287     CAInfo_t responseData;
 288     memset(&responseData, 0, sizeof(CAInfo_t));
 289     responseData.token = tempToken;
 290     responseData.tokenLength = CA_MAX_TOKEN_LEN;
 291     responseData.type = CA_MSG_NONCONFIRM;
 292     responseData.messageId = 1;
 293
 294     responseData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 295     if(!responseData.payload)
 296     {
 297         CADestroyToken(tempToken);
 298         FAIL() << "requestData.payload allocation failed";
 299     }
 300     memset(responseData.payload, '1', sizeof(responseData.payload) - 1);
 301     responseData.payloadSize = sizeof(responseData.payload);
 302
 303     pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
 304
 305     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 306     EXPECT_TRUE(cadata != NULL);
 307
 308     CABlockData_t *currData = CACreateNewBlockData(cadata);
 309     EXPECT_TRUE(currData != NULL);
 310
 311     EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
 312                                                     COAP_OPTION_BLOCK1));
 313
 314     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption1(&pdu, &responseData,
 315                                               responseData.payloadSize,
 316                                               currData->blockDataId, &options));
 317
 318     CADestroyDataSet(cadata);
 319     coap_delete_list(options);
 320     coap_delete_pdu(pdu);
 321
 322     CADestroyToken(tempToken);
 323     CADestroyEndpoint(tempRep);
 324     free(responseData.payload);
 325 }
 326
 327 // response and block option2
 328 TEST_F(CABlockTransferTests, CAAddBlockOption2InResponse)
 329 {
 330     CAEndpoint_t* tempRep = NULL;
 331     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 332
 333     coap_pdu_t *pdu = NULL;
 334     coap_list_t *options = NULL;
 335     coap_transport_type transport = coap_udp;
 336
 337     CAToken_t tempToken = NULL;
 338     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 339
 340     CAInfo_t responseData;
 341     memset(&responseData, 0, sizeof(CAInfo_t));
 342     responseData.token = tempToken;
 343     responseData.tokenLength = CA_MAX_TOKEN_LEN;
 344     responseData.type = CA_MSG_NONCONFIRM;
 345     responseData.messageId = 1;
 346
 347     responseData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 348     if(!responseData.payload)
 349     {
 350         CADestroyToken(tempToken);
 351         FAIL() << "requestData.payload allocation failed";
 352     }
 353     memset(responseData.payload, '1', sizeof(responseData.payload) - 1);
 354     responseData.payloadSize = sizeof(responseData.payload);
 355
 356     pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
 357
 358     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 359     EXPECT_TRUE(cadata != NULL);
 360
 361     CABlockData_t *currData = CACreateNewBlockData(cadata);
 362     EXPECT_TRUE(currData != NULL);
 363
 364     EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
 365                                                     COAP_OPTION_BLOCK2));
 366
 367     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption2(&pdu, &responseData,
 368                                               responseData.payloadSize,
 369                                               currData->blockDataId, &options));
 370
 371     CADestroyDataSet(cadata);
 372     coap_delete_list(options);
 373     coap_delete_pdu(pdu);
 374
 375     CADestroyToken(tempToken);
 376     CADestroyEndpoint(tempRep);
 377     free(responseData.payload);
 378 }
 379
 380 // request and block option1
 381 TEST_F(CABlockTransferTests, CAAddBlockOption2InRequest)
 382 {
 383     CAEndpoint_t* tempRep = NULL;
 384     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 385
 386     coap_pdu_t *pdu = NULL;
 387     coap_list_t *options = NULL;
 388     coap_transport_type transport = coap_udp;
 389
 390     CAToken_t tempToken = NULL;
 391     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 392
 393     CAInfo_t requestData;
 394     memset(&requestData, 0, sizeof(CAInfo_t));
 395     requestData.token = tempToken;
 396     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 397
 398     requestData.payload = (CAPayload_t) calloc(LARGE_PAYLOAD_LENGTH, sizeof(char));
 399     if(!requestData.payload)
 400     {
 401         CADestroyToken(tempToken);
 402         FAIL() << "requestData.payload allocation failed";
 403     }
 404     memset(requestData.payload, '1', sizeof(requestData.payload) - 1);
 405     requestData.payloadSize = sizeof(requestData.payload);
 406     requestData.type = CA_MSG_NONCONFIRM;
 407
 408     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 409
 410     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 411     EXPECT_TRUE(cadata != NULL);
 412
 413     CABlockData_t *currData = CACreateNewBlockData(cadata);
 414     EXPECT_TRUE(currData != NULL);
 415
 416     EXPECT_EQ(CA_STATUS_OK, CAUpdateBlockOptionType(currData->blockDataId,
 417                                                     COAP_OPTION_BLOCK2));
 418
 419     EXPECT_EQ(CA_STATUS_OK, CAAddBlockOption2(&pdu, &requestData,
 420                                               requestData.payloadSize,
 421                                               currData->blockDataId, &options));
 422
 423     CARemoveBlockDataFromList(currData->blockDataId);
 424     CADestroyDataSet(cadata);
 425     coap_delete_list(options);
 426     coap_delete_pdu(pdu);
 427
 428     CADestroyToken(tempToken);
 429     CADestroyEndpoint(tempRep);
 430     free(requestData.payload);
 431 }
 432
 433 TEST_F(CABlockTransferTests, CAGetBlockSizeOptionFromPduTest)
 434 {
 435     CAEndpoint_t* tempRep = NULL;
 436     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 437
 438     coap_pdu_t *pdu = NULL;
 439     coap_list_t *options = NULL;
 440     coap_transport_type transport = coap_udp;
 441
 442     CAToken_t tempToken = NULL;
 443     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 444
 445     CAInfo_t requestData;
 446     memset(&requestData, 0, sizeof(CAInfo_t));
 447     requestData.token = tempToken;
 448     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 449     requestData.type = CA_MSG_NONCONFIRM;
 450
 451     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 452
 453     size_t totalPayloadLen = 0;
 454     EXPECT_FALSE(CAIsPayloadLengthInPduWithBlockSizeOption(pdu, COAP_OPTION_SIZE1,
 455                                                            &totalPayloadLen));
 456
 457     coap_delete_list(options);
 458     coap_delete_pdu(pdu);
 459
 460     CADestroyToken(tempToken);
 461     CADestroyEndpoint(tempRep);
 462     free(requestData.payload);
 463 }
 464
 465 TEST_F(CABlockTransferTests, CASetNextBlockOption1Test)
 466 {
 467     CAEndpoint_t* tempRep = NULL;
 468     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 469
 470     coap_pdu_t *pdu = NULL;
 471     coap_list_t *options = NULL;
 472     coap_transport_type transport = coap_udp;
 473
 474     CAToken_t tempToken = NULL;
 475     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 476
 477     CAInfo_t responseData;
 478     memset(&responseData, 0, sizeof(CAInfo_t));
 479     responseData.token = tempToken;
 480     responseData.tokenLength = CA_MAX_TOKEN_LEN;
 481     responseData.type = CA_MSG_NONCONFIRM;
 482     responseData.messageId = 1;
 483
 484     pdu = CAGeneratePDU(CA_CREATED, &responseData, tempRep, &options, &transport);
 485
 486     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 487     EXPECT_TRUE(cadata != NULL);
 488
 489     CABlockData_t *currData = CACreateNewBlockData(cadata);
 490     EXPECT_TRUE(currData != NULL);
 491
 492     coap_block_t block = {0, 0, 0};
 493     EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption1(pdu, tempRep, cadata, block, pdu->length));
 494
 495     EXPECT_EQ(CA_STATUS_OK, CAHandleRequestResponse());
 496
 497     CADestroyDataSet(cadata);
 498     coap_delete_list(options);
 499     coap_delete_pdu(pdu);
 500
 501     CADestroyToken(tempToken);
 502     CADestroyEndpoint(tempRep);
 503     free(responseData.payload);
 504 }
 505
 506 TEST_F(CABlockTransferTests, CASetNextBlockOption2Test)
 507 {
 508     CAEndpoint_t* tempRep = NULL;
 509     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "127.0.0.1", 5683, &tempRep);
 510
 511     coap_pdu_t *pdu = NULL;
 512     coap_list_t *options = NULL;
 513     coap_transport_type transport = coap_udp;
 514
 515     CAToken_t tempToken = NULL;
 516     CAGenerateToken(&tempToken, CA_MAX_TOKEN_LEN);
 517
 518     CAInfo_t requestData;
 519     memset(&requestData, 0, sizeof(CAInfo_t));
 520     requestData.token = tempToken;
 521     requestData.tokenLength = CA_MAX_TOKEN_LEN;
 522     requestData.type = CA_MSG_NONCONFIRM;
 523
 524     pdu = CAGeneratePDU(CA_GET, &requestData, tempRep, &options, &transport);
 525
 526     CAData_t *cadata = CACreateNewDataSet(pdu, tempRep);
 527     EXPECT_TRUE(cadata != NULL);
 528
 529     CABlockData_t *currData = CACreateNewBlockData(cadata);
 530     EXPECT_TRUE(currData != NULL);
 531
 532     coap_block_t block = {0, 0, 0};
 533     EXPECT_EQ(CA_STATUS_OK, CASetNextBlockOption2(pdu, tempRep, cadata, block, pdu->length));
 534
 535     CADestroyDataSet(cadata);
 536     coap_delete_list(options);
 537     coap_delete_pdu(pdu);
 538
 539     CADestroyToken(tempToken);
 540     CADestroyEndpoint(tempRep);
 541     free(requestData.payload);
 542 }