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