resource/csdk/connectivity/test/ca_api_unittest.cpp

   1 /* ****************************************************************
   2  *
   3  * Copyright 2014 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 "cacommon.h"
  24 #include <string.h>
  25
  26
  27 void request_handler(CARemoteEndpoint_t* object, CARequestInfo_t* requestInfo);
  28 void response_handler(CARemoteEndpoint_t* object, CAResponseInfo_t* responseInfo);
  29
  30 void request_handler(const CARemoteEndpoint_t *object, const CARequestInfo_t *requestInfo)
  31 {
  32
  33 }
  34
  35 void response_handler(const CARemoteEndpoint_t *object, const CAResponseInfo_t *responseInfo)
  36 {
  37
  38 }
  39
  40 static char* uri = NULL;
  41 static CARemoteEndpoint_t* tempRep = NULL;
  42 static CARequestInfo_t requestInfo;
  43 static CAInfo_t requestData;
  44 static CAInfo_t responseData;
  45 static CAResponseInfo_t responseInfo;
  46 static CAToken_t tempToken = NULL;
  47 uint8_t tokenLength = CA_MAX_TOKEN_LEN;
  48 static const char URI[] = "coap://10.11.12.13:4545/a/light";
  49 static const char RESOURCE_URI[] = "/a/light";
  50
  51 static const char SECURE_INFO_DATA[] =
  52                                     "{\"oc\":[{\"href\":\"%s\",\"prop\":{\"rt\":[\"core.led\"],"
  53                                      "\"if\":[\"oc.mi.def\"],\"obs\":1,\"sec\":1,\"port\":%d}}]}";
  54 static const char NORMAL_INFO_DATA[] =
  55                                     "{\"oc\":[{\"href\":\"%s\",\"prop\":{\"rt\":[\"core.led\"],"
  56                                      "\"if\":[\"oc.mi.def\"],\"obs\":1}}]}";
  57
  58 #ifdef __WITH_DTLS__
  59 static OCDtlsPskCredsBlob *pskCredsBlob = NULL;
  60
  61 void clearDtlsCredentialInfo()
  62 {
  63     printf("clearDtlsCredentialInfo IN\n");
  64     if (pskCredsBlob)
  65     {
  66         // Initialize sensitive data to zeroes before freeing.
  67         memset(pskCredsBlob->creds, 0, sizeof(OCDtlsPskCreds) * (pskCredsBlob->num));
  68         free(pskCredsBlob->creds);
  69
  70         memset(pskCredsBlob, 0, sizeof(OCDtlsPskCredsBlob));
  71         free(pskCredsBlob);
  72         pskCredsBlob = NULL;
  73     }
  74     printf("clearDtlsCredentialInfo OUT\n");
  75 }
  76
  77 // Internal API. Invoked by OC stack to retrieve credentials from this module
  78 void CAGetDtlsPskCredentials(OCDtlsPskCredsBlob **credInfo)
  79 {
  80     printf("CAGetDtlsPskCredentials IN\n");
  81
  82     if (pskCredsBlob != NULL)
  83     {
  84         *credInfo = pskCredsBlob;
  85     }
  86
  87     printf("CAGetDtlsPskCredentials OUT\n");
  88 }
  89
  90 int32_t SetCredentials()
  91 {
  92     printf("SetCredentials IN\n");
  93     pskCredsBlob = (OCDtlsPskCredsBlob *)malloc(sizeof(OCDtlsPskCredsBlob));
  94
  95     memset(pskCredsBlob, 0x0, sizeof(OCDtlsPskCredsBlob));
  96     memcpy(pskCredsBlob->identity, IDENTITY, DTLS_PSK_ID_LEN);
  97
  98     pskCredsBlob->num = 1;
  99
 100     pskCredsBlob->creds = (OCDtlsPskCreds *)malloc(sizeof(OCDtlsPskCreds) * (pskCredsBlob->num));
 101
 102     memcpy(pskCredsBlob->creds[0].id, IDENTITY, DTLS_PSK_ID_LEN);
 103     memcpy(pskCredsBlob->creds[0].psk, RS_CLIENT_PSK, DTLS_PSK_PSK_LEN);
 104
 105     printf("SetCredentials OUT\n");
 106     return 1;
 107 }
 108 #endif
 109
 110 int main(int argc, char **argv)
 111 {
 112     testing::InitGoogleTest(&argc, argv);
 113     return RUN_ALL_TESTS();
 114 }
 115
 116 // CAInitialize TC
 117 // check return value
 118 TEST(InitializeTest, TC_01_Positive_01)
 119 {
 120     EXPECT_EQ(CA_STATUS_OK, CAInitialize());
 121 }
 122
 123 //CATerminate TC
 124 TEST(TerminateTest, TC_02_Positive_01)
 125 {
 126     CATerminate();
 127
 128     char* check = (char *) "terminate success";
 129     EXPECT_STREQ(check, "terminate success");
 130
 131     CAInitialize();
 132 }
 133 // CAStartListeningServer TC
 134 // check return value
 135 TEST(StartListeningServerTest, TC_03_Positive_01)
 136 {
 137     CASelectNetwork(CA_WIFI);
 138     EXPECT_EQ(CA_STATUS_OK, CAStartListeningServer());
 139 }
 140
 141 // CAStartDiscoveryServer TC
 142 // check return value
 143 TEST(StartDiscoveryServerTest, TC_04_Positive_01)
 144 {
 145     EXPECT_EQ(CA_STATUS_OK, CAStartDiscoveryServer());
 146 }
 147
 148 // CARegisterHandlerTest TC
 149 // check return value
 150 TEST(RegisterHandlerTest, TC_05_Positive_01)
 151 {
 152     CARegisterHandler(request_handler, response_handler);
 153     char* check = (char *) "registerHandler success";
 154     EXPECT_STREQ(check, "registerHandler success");
 155 }
 156
 157 // CACreateRemoteEndpoint TC
 158 // check return value
 159 TEST(CreateRemoteEndpointTest, TC_06_Positive_01)
 160 {
 161     uri = (char *) URI;
 162
 163     EXPECT_EQ(CA_STATUS_OK, CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep));
 164
 165     CADestroyRemoteEndpoint(tempRep);
 166     tempRep = NULL;
 167 }
 168
 169 // check remoteEndpoint and values of remoteEndpoint
 170 TEST(CreateRemoteEndpointTest, TC_07_Positive_02)
 171 {
 172     uri = (char *) URI;
 173
 174     CACreateRemoteEndpoint(uri, CA_WIFI, &tempRep);
 175
 176     EXPECT_TRUE(tempRep != NULL);
 177
 178     if (tempRep != NULL)
 179     {
 180         EXPECT_STRNE(NULL, tempRep->resourceUri);
 181     }
 182
 183     CADestroyRemoteEndpoint(tempRep);
 184     tempRep = NULL;
 185 }
 186
 187 // check return value when uri is NULL
 188 TEST(CreateRemoteEndpointTest, TC_08_Negative_01)
 189 {
 190     uri = NULL;
 191
 192     EXPECT_EQ(CA_STATUS_FAILED, CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep));
 193
 194     if (tempRep != NULL)
 195     {
 196         CADestroyRemoteEndpoint(tempRep);
 197         tempRep = NULL;
 198     }
 199 }
 200
 201 // check values of remoteEndpoint when uri is NULL
 202 TEST(CreateRemoteEndpointTest, TC_09_Negative_02)
 203 {
 204     uri = NULL;
 205     CACreateRemoteEndpoint(uri, CA_WIFI, &tempRep);
 206
 207     if (tempRep != NULL)
 208     {
 209         EXPECT_STREQ(NULL, tempRep->resourceUri);
 210
 211     }
 212
 213     if (tempRep != NULL)
 214     {
 215         CADestroyRemoteEndpoint(tempRep);
 216         tempRep = NULL;
 217     }
 218 }
 219
 220 // CADestroyRemoteEndpoint TC
 221 // check destroyed remoteEndpoint
 222 TEST(DestroyRemoteEndpointTest, TC_10_Positive_01)
 223 {
 224     uri = (char *) URI;
 225     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 226
 227     CADestroyRemoteEndpoint(tempRep);
 228     tempRep = NULL;
 229
 230     char * check = (char *) "destroy success";
 231     EXPECT_STREQ(check, "destroy success");
 232 }
 233
 234 // CAGerateToken TC
 235 // check return value
 236 TEST(GenerateTokenTest, TC_11_Positive_01)
 237 {
 238     EXPECT_EQ(CA_STATUS_OK, CAGenerateToken(&tempToken, tokenLength));
 239
 240     CADestroyToken(tempToken);
 241 }
 242
 243 // check return value when CAGenerateToken is passed a NULL instead a valid pointer
 244 TEST(GenerateTokenTest, TC_12_Negative_01)
 245 {
 246     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CAGenerateToken(NULL, tokenLength));
 247 }
 248
 249 // CADestroyToken TC
 250 // check destroyed token
 251 TEST(DestroyTokenTest, TC_13_Positive_01)
 252 {
 253     CAGenerateToken(&tempToken, tokenLength);
 254     CADestroyToken(tempToken);
 255
 256     char * check = (char *) "destroy success";
 257     EXPECT_STREQ(check, "destroy success");
 258 }
 259
 260 // CAFindResource TC
 261 // check return value
 262 TEST(FindResourceTest, TC_14_Positive_01)
 263 {
 264     uri = (char *) RESOURCE_URI;
 265
 266     CAGenerateToken(&tempToken, tokenLength);
 267     EXPECT_EQ(CA_STATUS_OK, CAFindResource(uri, tempToken, tokenLength));
 268     CADestroyToken(tempToken);
 269 }
 270
 271 // check return value when uri is NULL
 272 TEST(FindResourceTest, TC_15_Negative_01)
 273 {
 274     uri = NULL;
 275     CAGenerateToken(&tempToken, tokenLength);
 276     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CAFindResource(uri, tempToken, tokenLength));
 277     CADestroyToken(tempToken);
 278 }
 279
 280 // CASendRequest TC
 281 // check return value
 282 TEST(SendRequestTest, TC_16_Positive_01)
 283 {
 284     uri = (char *) URI;
 285     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 286
 287     memset(&requestData, 0, sizeof(CAInfo_t));
 288     CAGenerateToken(&tempToken, tokenLength);
 289     requestData.token = tempToken;
 290     requestData.tokenLength = tokenLength;
 291
 292     int length = strlen(NORMAL_INFO_DATA) + strlen("a/light");
 293     requestData.payload = (CAPayload_t) calloc(length, sizeof(char));
 294     snprintf(requestData.payload, length, NORMAL_INFO_DATA, "a/light");
 295     requestData.type = CA_MSG_NONCONFIRM;
 296
 297     memset(&requestInfo, 0, sizeof(CARequestInfo_t));
 298     requestInfo.method = CA_GET;
 299     requestInfo.info = requestData;
 300
 301     EXPECT_EQ(CA_STATUS_OK, CASendRequest(tempRep, &requestInfo));
 302
 303     CADestroyToken(tempToken);
 304
 305     free(requestData.payload);
 306
 307     CADestroyRemoteEndpoint(tempRep);
 308     tempRep = NULL;
 309
 310 }
 311
 312 // check return value when uri is NULL
 313 TEST(SendRequestTest, DISABLED_TC_17_Negative_01)
 314 {
 315     uri = NULL;
 316     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 317
 318     memset(&requestData, 0, sizeof(CAInfo_t));
 319     CAGenerateToken(&tempToken, tokenLength);
 320     requestData.token = tempToken;
 321     requestData.tokenLength = tokenLength;
 322
 323     int length = strlen(NORMAL_INFO_DATA) + strlen("a/light");
 324     requestData.payload = (CAPayload_t) calloc(length, sizeof(char));
 325     snprintf(requestData.payload, length, NORMAL_INFO_DATA, "a/light");
 326     requestData.type = CA_MSG_NONCONFIRM;
 327
 328     memset(&requestInfo, 0, sizeof(CARequestInfo_t));
 329     requestInfo.method = CA_GET;
 330     requestInfo.info = requestData;
 331
 332     EXPECT_EQ(CA_STATUS_FAILED, CASendRequest(tempRep, &requestInfo));
 333
 334     CADestroyToken(tempToken);
 335
 336     free(requestData.payload);
 337
 338     if (tempRep != NULL)
 339     {
 340         CADestroyRemoteEndpoint(tempRep);
 341         tempRep = NULL;
 342     }
 343 }
 344
 345 // check return value when a NULL is passed instead of a valid CARequestInfo_t address
 346 TEST(SendRequestTest, TC_18_Negative_02)
 347 {
 348     uri = (char *) URI;
 349     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 350
 351     memset(&requestData, 0, sizeof(CAInfo_t));
 352     CAGenerateToken(&tempToken, tokenLength);
 353     requestData.token = tempToken;
 354     requestData.tokenLength = tokenLength;
 355
 356     int length = strlen(NORMAL_INFO_DATA) + strlen("a/light");
 357     requestData.payload = (CAPayload_t) calloc(length, sizeof(char));
 358     snprintf(requestData.payload, length, NORMAL_INFO_DATA, "a/light");
 359     requestData.type = CA_MSG_NONCONFIRM;
 360
 361     memset(&requestInfo, 0, sizeof(CARequestInfo_t));
 362     requestInfo.method = CA_GET;
 363     requestInfo.info = requestData;
 364
 365     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendRequest(tempRep, NULL));
 366
 367     CADestroyToken(tempToken);
 368
 369     free(requestData.payload);
 370
 371     if (tempRep != NULL)
 372     {
 373         CADestroyRemoteEndpoint(tempRep);
 374         tempRep = NULL;
 375     }
 376 }
 377
 378 // CASendResponse TC
 379 // check return value
 380 TEST(SendResponseTest, TC_19_Positive_01)
 381 {
 382     uri = (char *) URI;
 383     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 384
 385     memset(&responseData, 0, sizeof(CAInfo_t));
 386     responseData.type = CA_MSG_NONCONFIRM;
 387     responseData.messageId = 1;
 388     responseData.payload = (char *) "response payload";
 389
 390     CAGenerateToken(&tempToken, tokenLength);
 391     requestData.token = tempToken;
 392     requestData.tokenLength = tokenLength;
 393
 394     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 395     responseInfo.result = CA_SUCCESS;
 396     responseInfo.info = responseData;
 397
 398     EXPECT_EQ(CA_STATUS_OK, CASendResponse(tempRep, &responseInfo));
 399
 400     CADestroyToken(tempToken);
 401     CADestroyRemoteEndpoint(tempRep);
 402     tempRep = NULL;
 403 }
 404
 405 // check return value when uri is NULL
 406 TEST(SendResponseTest, DISABLED_TC_20_Negative_01)
 407 {
 408     uri = NULL;
 409     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 410
 411     memset(&responseData, 0, sizeof(CAInfo_t));
 412     responseData.type = CA_MSG_NONCONFIRM;
 413     responseData.messageId = 1;
 414     responseData.payload = (char *) "response payload";
 415
 416     CAGenerateToken(&tempToken, tokenLength);
 417     requestData.token = tempToken;
 418     requestData.tokenLength = tokenLength;
 419
 420     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 421     responseInfo.result = CA_SUCCESS;
 422     responseInfo.info = responseData;
 423
 424     EXPECT_EQ(CA_STATUS_FAILED, CASendResponse(tempRep, &responseInfo));
 425
 426     CADestroyToken(tempToken);
 427     if (tempRep != NULL)
 428     {
 429         CADestroyRemoteEndpoint(tempRep);
 430         tempRep = NULL;
 431     }
 432 }
 433
 434 // check return value NULL is passed instead of a valid CAResponseInfo_t address
 435 TEST(SendResponseTest, TC_21_Negative_02)
 436 {
 437     uri = (char *) URI;
 438     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 439
 440     memset(&responseData, 0, sizeof(CAInfo_t));
 441     responseData.type = CA_MSG_NONCONFIRM;
 442     responseData.messageId = 1;
 443     responseData.payload = (char *) "response payload";
 444
 445     CAGenerateToken(&tempToken, tokenLength);
 446     requestData.token = tempToken;
 447     requestData.tokenLength = tokenLength;
 448
 449     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 450     responseInfo.result = CA_SUCCESS;
 451     responseInfo.info = responseData;
 452
 453     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendResponse(tempRep, NULL));
 454
 455     CADestroyToken(tempToken);
 456     if (tempRep != NULL)
 457     {
 458         CADestroyRemoteEndpoint(tempRep);
 459         tempRep = NULL;
 460     }
 461 }
 462
 463 // CASendNotification TC
 464 // check return value
 465 TEST(SendNotificationTest, TC_22_Positive_01)
 466 {
 467     uri = (char *) URI;
 468     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 469
 470     memset(&responseData, 0, sizeof(CAInfo_t));
 471     responseData.type = CA_MSG_NONCONFIRM;
 472     responseData.payload = (char *) "Temp Notification Data";
 473
 474     CAGenerateToken(&tempToken, tokenLength);
 475     requestData.token = tempToken;
 476     requestData.tokenLength = tokenLength;
 477
 478     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 479     responseInfo.result = CA_SUCCESS;
 480     responseInfo.info = responseData;
 481
 482     EXPECT_EQ(CA_STATUS_OK, CASendNotification(tempRep, &responseInfo));
 483
 484     CADestroyToken(tempToken);
 485     if (tempRep != NULL)
 486     {
 487         CADestroyRemoteEndpoint(tempRep);
 488         tempRep = NULL;
 489     }
 490 }
 491
 492 // check return value when uri is NULL
 493 TEST(SendNotificationTest, DISABLED_TC_23_Negative_01)
 494 {
 495     uri = NULL;
 496     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 497
 498     memset(&responseData, 0, sizeof(CAInfo_t));
 499     responseData.type = CA_MSG_NONCONFIRM;
 500     responseData.payload = (char *) "Temp Notification Data";
 501
 502     CAGenerateToken(&tempToken, tokenLength);
 503     requestData.token = tempToken;
 504     requestData.tokenLength = tokenLength;
 505
 506     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 507     responseInfo.result = CA_SUCCESS;
 508     responseInfo.info = responseData;
 509
 510     EXPECT_EQ(CA_STATUS_FAILED, CASendNotification(tempRep, &responseInfo));
 511
 512     CADestroyToken(tempToken);
 513     if (tempRep != NULL)
 514     {
 515         CADestroyRemoteEndpoint(tempRep);
 516         tempRep = NULL;
 517     }
 518 }
 519
 520 // CAAdvertiseResource TC
 521 // check return value
 522 TEST(AdvertiseResourceTest, TC_24_Positive_01)
 523 {
 524     uri = (char *) RESOURCE_URI;
 525     int optionNum = 2;
 526
 527     CAHeaderOption_t* headerOpt;
 528     headerOpt = (CAHeaderOption_t *) calloc(1, optionNum * sizeof(CAHeaderOption_t));
 529
 530     char* tmpOptionData1 = (char *) "Hello";
 531     size_t tmpOptionDataLen = (strlen(tmpOptionData1) < CA_MAX_HEADER_OPTION_DATA_LENGTH) ?
 532             strlen(tmpOptionData1) : CA_MAX_HEADER_OPTION_DATA_LENGTH - 1;
 533     headerOpt[0].optionID = 3000;
 534     memcpy(headerOpt[0].optionData, tmpOptionData1, tmpOptionDataLen);
 535     headerOpt[0].optionLength = (uint16_t) tmpOptionDataLen;
 536
 537     char* tmpOptionData2 = (char *) "World";
 538     tmpOptionDataLen = (strlen(tmpOptionData2) < CA_MAX_HEADER_OPTION_DATA_LENGTH) ?
 539                 strlen(tmpOptionData2) : CA_MAX_HEADER_OPTION_DATA_LENGTH - 1;
 540     headerOpt[1].optionID = 3001;
 541     memcpy(headerOpt[1].optionData, tmpOptionData2, tmpOptionDataLen);
 542     headerOpt[1].optionLength = (uint16_t) tmpOptionDataLen;
 543
 544     CAGenerateToken(&tempToken, tokenLength);
 545
 546     EXPECT_EQ(CA_STATUS_OK, CAAdvertiseResource(uri, tempToken, tokenLength, headerOpt, (uint8_t )optionNum));
 547
 548     CADestroyToken(tempToken);
 549
 550     free(headerOpt);
 551 }
 552
 553 // check return value when uri is NULL
 554 TEST(AdvertiseResourceTest, TC_25_Negative_01)
 555 {
 556     uri = NULL;
 557     int optionNum = 2;
 558
 559     CAHeaderOption_t* headerOpt;
 560     headerOpt = (CAHeaderOption_t *) calloc(1, optionNum * sizeof(CAHeaderOption_t));
 561
 562     char* tmpOptionData1 = (char *) "Hello";
 563     size_t tmpOptionDataLen = (strlen(tmpOptionData1) < CA_MAX_HEADER_OPTION_DATA_LENGTH) ?
 564             strlen(tmpOptionData1) : CA_MAX_HEADER_OPTION_DATA_LENGTH - 1;
 565     headerOpt[0].optionID = 3000;
 566     memcpy(headerOpt[0].optionData, tmpOptionData1, tmpOptionDataLen);
 567     headerOpt[0].optionLength = (uint16_t) tmpOptionDataLen;
 568
 569     char* tmpOptionData2 = (char *) "World";
 570     tmpOptionDataLen = (strlen(tmpOptionData2) < CA_MAX_HEADER_OPTION_DATA_LENGTH) ?
 571                 strlen(tmpOptionData2) : CA_MAX_HEADER_OPTION_DATA_LENGTH - 1;
 572     headerOpt[1].optionID = 3001;
 573     memcpy(headerOpt[1].optionData, tmpOptionData2, tmpOptionDataLen);
 574     headerOpt[1].optionLength = (uint16_t) tmpOptionDataLen;
 575
 576     CAGenerateToken(&tempToken, tokenLength);
 577
 578     EXPECT_EQ(CA_STATUS_INVALID_PARAM,
 579             CAAdvertiseResource(uri, tempToken, tokenLength, headerOpt, (uint8_t )optionNum));
 580
 581     CADestroyToken(tempToken);
 582
 583     free(headerOpt);
 584 }
 585
 586 // CASelectNewwork TC
 587 // check return value
 588  TEST(SelectNetworkTest, TC_26_Positive_01)
 589 {
 590     //Select wifi network
 591     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_WIFI));
 592 }
 593
 594 // check return value when selected network is disable
 595 TEST(SelectNetworkTest, TC_27_Negative_01)
 596 {
 597     //Select disable network
 598     EXPECT_EQ(CA_NOT_SUPPORTED, CASelectNetwork(1000));
 599 }
 600
 601 // CAUnSelectNewwork TC
 602 // check return value
 603 TEST(UnSelectNetworkTest, TC_28_Positive_01)
 604 {
 605     //Unselect wifi network
 606     EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_WIFI));
 607 }
 608
 609 // check return value when selected network is disable
 610 TEST(UnSelectNetworkTest, TC_29_Negative_01)
 611 {
 612     //UnSelect disable network
 613     EXPECT_EQ(CA_STATUS_FAILED, CAUnSelectNetwork(1000));
 614 }
 615
 616 // CAHandlerRequestResponse TC
 617 // check return value
 618 TEST (HandlerRequestResponseTest, TC_30_Positive_01)
 619 {
 620     EXPECT_EQ(CA_STATUS_OK, CAHandleRequestResponse());
 621 }
 622
 623 // CASendRequestToAll TC
 624 // check return value
 625 TEST (SendRequestToAllTest, TC_31_Positive_01)
 626 {
 627     uri = (char *) RESOURCE_URI;
 628     CACreateRemoteEndpoint(uri, CA_ETHERNET, &tempRep);
 629     CAGroupEndpoint_t *group = NULL;
 630     group = (CAGroupEndpoint_t *) malloc(sizeof(CAGroupEndpoint_t));
 631     group->connectivityType = tempRep->connectivityType;
 632     group->resourceUri = tempRep->resourceUri;
 633
 634     memset(&requestData, 0, sizeof(CAInfo_t));
 635     CAGenerateToken(&tempToken, tokenLength);
 636     requestData.token = tempToken;
 637     requestData.tokenLength = tokenLength;
 638
 639     requestData.payload = (char *) "Temp Json Payload";
 640     requestData.type = CA_MSG_NONCONFIRM;
 641     memset(&requestInfo, 0, sizeof(CARequestInfo_t));
 642     requestInfo.method = CA_GET;
 643     requestInfo.info = requestData;
 644
 645     EXPECT_EQ(CA_STATUS_OK, CASendRequestToAll(group, &requestInfo));
 646
 647     CADestroyToken(tempToken);
 648
 649     CADestroyRemoteEndpoint(tempRep);
 650     tempRep = NULL;
 651
 652     free(group);
 653 }
 654
 655 // check return value when group->resourceUri is NULL
 656 TEST (SendRequestToAllTest, TC_32_Negative_01)
 657 {
 658     uri = (char *) RESOURCE_URI;
 659     CAGroupEndpoint_t *group = NULL;
 660
 661     memset(&requestData, 0, sizeof(CAInfo_t));
 662     CAGenerateToken(&tempToken, tokenLength);
 663     requestData.token = tempToken;
 664     requestData.tokenLength = tokenLength;
 665
 666     requestData.payload = (char *) "Temp Json Payload";
 667     requestData.type = CA_MSG_NONCONFIRM;
 668     memset(&requestInfo, 0, sizeof(CARequestInfo_t));
 669     requestInfo.method = CA_GET;
 670     requestInfo.info = requestData;
 671
 672     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendRequestToAll(group, &requestInfo));
 673
 674     CADestroyToken(tempToken);
 675 }
 676
 677 // CAGetNetworkInformation TC
 678 // check return value
 679 TEST (GetNetworkInformationTest, TC_33_Positive_01)
 680 {
 681     CALocalConnectivity_t *tempInfo = NULL;
 682     uint32_t tempSize = 0;
 683
 684     EXPECT_EQ(CA_STATUS_OK, CAGetNetworkInformation(&tempInfo, &tempSize));
 685 }
 686
 687 TEST(RegisterDTLSCredentialsHandlerTest, TC_34_positive_01)
 688 {
 689 #ifdef __WITH_DTLS__
 690     if (SetCredentials() == 0)
 691     {
 692         printf("SetCredentials failed\n");
 693         return 0;
 694     }
 695
 696     res = CARegisterDTLSCredentialsHandler(CAGetDtlsPskCredentials);
 697     EXPECT_EQ(CA_STATUS_OK, CARegisterDTLSCredentialsHandler(CAGetDtlsPskCredentials));
 698 #endif
 699 }
 700