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 "cautilinterface.h"
  24 #include "cacommon.h"
  25
  26 #define CA_TRANSPORT_ADAPTER_SCOPE  1000
  27
  28 class CATests : public testing::Test {
  29     protected:
  30     virtual void SetUp() {
  31         CAInitialize();
  32     }
  33
  34     virtual void TearDown()
  35     {
  36         CATerminate();
  37     }
  38 };
  39
  40 void request_handler(CAEndpoint_t* object, CARequestInfo_t* requestInfo);
  41 void response_handler(CAEndpoint_t* object, CAResponseInfo_t* responseInfo);
  42 void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo);
  43 void adapter_handler(CATransportAdapter_t adapter, bool enabled);
  44 void connection_handler(CATransportAdapter_t adapter, const char *remote_address, bool connected);
  45 CAResult_t checkGetNetworkInfo();
  46 CAResult_t checkSelectNetwork();
  47
  48 void request_handler(const CAEndpoint_t * /*object*/,
  49                      const CARequestInfo_t * /*requestInfo*/)
  50 {
  51
  52 }
  53
  54 void response_handler(const CAEndpoint_t * /*object*/,
  55                       const CAResponseInfo_t * /*responseInfo*/)
  56 {
  57
  58 }
  59
  60 void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo)
  61 {
  62     if(!object || !errorInfo)
  63     {
  64         return;
  65     }
  66
  67     //error handling shall be added
  68     return;
  69 }
  70
  71 void adapter_handler(CATransportAdapter_t adapter,
  72                      bool enabled)
  73 {
  74
  75 }
  76
  77 void connection_handler(CATransportAdapter_t adapter,
  78                         const char *remote_address,
  79                         bool connected)
  80 {
  81
  82 }
  83
  84 static char* addr = NULL;
  85 static CAEndpoint_t* tempRep = NULL;
  86 static CARequestInfo_t requestInfo;
  87 static CAInfo_t requestData;
  88 static CAInfo_t responseData;
  89 static CAResponseInfo_t responseInfo;
  90 static CAToken_t tempToken = NULL;
  91 static uint8_t tokenLength = CA_MAX_TOKEN_LEN;
  92 static const char ADDRESS[] = "10.11.12.13";
  93 static const uint16_t PORT = 4545;
  94
  95 static const char NORMAL_INFO_DATA[] =
  96                                     "{\"oc\":[{\"href\":\"%s\",\"prop\":{\"rt\":[\"core.led\"],"
  97                                      "\"if\":[\"oc.mi.def\"],\"obs\":1}}]}";
  98
  99 #ifdef __WITH_DTLS__
 100
 101 // Iotivity Device Identity.
 102 const unsigned char IDENTITY[] = ("1111111111111111");
 103
 104 // PSK between this device and peer device.
 105 const unsigned char RS_CLIENT_PSK[] = ("AAAAAAAAAAAAAAAA");
 106
 107 // Internal API. Invoked by CA stack to retrieve credentials from this module
 108 int32_t CAGetDtlsPskCredentials( CADtlsPskCredType_t type,
 109               const unsigned char *desc, size_t desc_len,
 110               unsigned char *result, size_t result_length)
 111 {
 112     printf("CAGetDtlsPskCredentials IN\n");
 113
 114     int32_t ret = -1;
 115
 116     if (NULL == result)
 117     {
 118         return ret;
 119     }
 120
 121     switch (type)
 122     {
 123         case CA_DTLS_PSK_HINT:
 124         case CA_DTLS_PSK_IDENTITY:
 125
 126             if (result_length < sizeof(IDENTITY))
 127             {
 128                 printf("ERROR : Wrong value for result for storing IDENTITY");
 129                 return ret;
 130             }
 131
 132             memcpy(result, IDENTITY, sizeof(IDENTITY));
 133             ret = sizeof(IDENTITY);
 134             break;
 135
 136         case CA_DTLS_PSK_KEY:
 137
 138             if ((desc_len == sizeof(IDENTITY)) &&
 139                 memcmp(desc, IDENTITY, sizeof(IDENTITY)) == 0)
 140             {
 141                 if (result_length < sizeof(RS_CLIENT_PSK))
 142                 {
 143                     printf("ERROR : Wrong value for result for storing RS_CLIENT_PSK");
 144                     return ret;
 145                 }
 146
 147                 memcpy(result, RS_CLIENT_PSK, sizeof(RS_CLIENT_PSK));
 148                 ret = sizeof(RS_CLIENT_PSK);
 149             }
 150             break;
 151
 152         default:
 153
 154             printf("Wrong value passed for PSK_CRED_TYPE.");
 155             ret = -1;
 156     }
 157
 158
 159     printf("CAGetDtlsPskCredentials OUT\n");
 160     return ret;
 161 }
 162 #endif  //__WITH_DTLS__
 163
 164 int main(int argc, char **argv)
 165 {
 166     testing::InitGoogleTest(&argc, argv);
 167     return RUN_ALL_TESTS();
 168 }
 169
 170 // CAInitialize TC
 171 // check return value
 172 TEST(InitializeTest, TC_01_Positive_01)
 173 {
 174     EXPECT_EQ(CA_STATUS_OK, CAInitialize());
 175     CATerminate();
 176 }
 177
 178 //CATerminate TC
 179 TEST_F(CATests, TerminateTest)
 180 {
 181     CATerminate();
 182
 183     char* check = (char *) "terminate success";
 184     EXPECT_STREQ(check, "terminate success");
 185
 186     CAInitialize();
 187 }
 188 // CAStartListeningServer TC
 189 // check return value
 190 TEST(StartListeningServerTest, DISABLED_TC_03_Positive_01)
 191 {
 192     CASelectNetwork(CA_ADAPTER_IP);
 193     EXPECT_EQ(CA_STATUS_OK, CAStartListeningServer());
 194 }
 195
 196 // CAStartDiscoveryServer TC
 197 // check return value
 198 TEST(StartDiscoveryServerTest, DISABLED_TC_04_Positive_01)
 199 {
 200     EXPECT_EQ(CA_STATUS_OK, CAStartDiscoveryServer());
 201 }
 202
 203 // CARegisterHandlerTest TC
 204 // check return value
 205 TEST_F(CATests, RegisterHandlerTest)
 206 {
 207     CARegisterHandler(request_handler, response_handler, error_handler);
 208     char* check = (char *) "registerHandler success";
 209     EXPECT_STREQ(check, "registerHandler success");
 210 }
 211
 212 // CACreateRemoteEndpoint TC
 213 // check return value
 214 TEST_F(CATests, CreateRemoteEndpointTestGood)
 215 {
 216     addr = (char *) ADDRESS;
 217
 218     EXPECT_EQ(CA_STATUS_OK, CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr,
 219                                              PORT, &tempRep));
 220
 221     CADestroyEndpoint(tempRep);
 222     tempRep = NULL;
 223 }
 224
 225 // check remoteEndpoint and values of remoteEndpoint
 226 TEST_F(CATests, CreateRemoteEndpointTestValues)
 227 {
 228     addr = (char *) ADDRESS;
 229
 230     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
 231
 232     EXPECT_TRUE(tempRep != NULL);
 233
 234     CADestroyEndpoint(tempRep);
 235     tempRep = NULL;
 236 }
 237
 238 // CAGerateToken TC
 239 // check return value
 240 TEST_F(CATests, GenerateTokenTestGood)
 241 {
 242     EXPECT_EQ(CA_STATUS_OK, CAGenerateToken(&tempToken, tokenLength));
 243
 244     CADestroyToken(tempToken);
 245 }
 246
 247 // check return value when CAGenerateToken is passed a NULL instead a valid pointer
 248 TEST_F(CATests, GenerateTokenTestBad)
 249 {
 250     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CAGenerateToken(NULL, tokenLength));
 251 }
 252
 253 // CADestroyToken TC
 254 // check destroyed token
 255 TEST_F(CATests, DestroyTokenTest)
 256 {
 257     CAGenerateToken(&tempToken, tokenLength);
 258     CADestroyToken(tempToken);
 259
 260     char * check = (char *) "destroy success";
 261     EXPECT_STREQ(check, "destroy success");
 262 }
 263
 264 // CASendRequest TC
 265 // check return value
 266 TEST(SendRequestTest, DISABLED_TC_16_Positive_01)
 267 {
 268     addr = (char *) ADDRESS;
 269     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
 270
 271     memset(&requestData, 0, sizeof(CAInfo_t));
 272     CAGenerateToken(&tempToken, tokenLength);
 273     requestData.token = tempToken;
 274     requestData.tokenLength = tokenLength;
 275
 276     int length = strlen(NORMAL_INFO_DATA) + strlen("a/light");
 277     requestData.payload = (CAPayload_t) calloc(length, sizeof(char));
 278     if(!requestData.payload)
 279     {
 280         CADestroyToken(tempToken);
 281         FAIL() << "requestData.payload allocation failed";
 282     }
 283     snprintf((char*)requestData.payload, length, NORMAL_INFO_DATA, "a/light");
 284     requestData.payloadSize = length + 1;
 285     requestData.type = CA_MSG_NONCONFIRM;
 286
 287     memset(&requestInfo, 0, sizeof(CARequestInfo_t));
 288     requestInfo.method = CA_GET;
 289     requestInfo.info = requestData;
 290
 291     EXPECT_EQ(CA_STATUS_OK, CASendRequest(tempRep, &requestInfo));
 292
 293     CADestroyToken(tempToken);
 294     CADestroyEndpoint(tempRep);
 295     free(requestData.payload);
 296     tempRep = NULL;
 297 }
 298
 299 // check return value when a NULL is passed instead of a valid CARequestInfo_t address
 300 TEST_F(CATests, SendRequestTestWithNullAddr)
 301 {
 302     addr = (char *) ADDRESS;
 303     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
 304
 305     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendRequest(tempRep, NULL));
 306
 307     CADestroyEndpoint(tempRep);
 308     tempRep = NULL;
 309 }
 310
 311 // CASendResponse TC
 312 // check return value
 313 TEST(SendResponseTest, DISABLED_TC_19_Positive_01)
 314 {
 315     addr = (char *) ADDRESS;
 316     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
 317
 318     memset(&responseData, 0, sizeof(CAInfo_t));
 319     responseData.type = CA_MSG_NONCONFIRM;
 320     responseData.messageId = 1;
 321     responseData.payload = (CAPayload_t)malloc(sizeof("response payload"));
 322
 323     EXPECT_TRUE(responseData.payload != NULL);
 324     if(!responseData.payload)
 325     {
 326         CADestroyEndpoint(tempRep);
 327         return;
 328     }
 329
 330     memcpy(responseData.payload, "response payload", sizeof("response payload"));
 331     responseData.payloadSize = sizeof("response payload");
 332
 333     CAGenerateToken(&tempToken, tokenLength);
 334     requestData.token = tempToken;
 335     requestData.tokenLength = tokenLength;
 336
 337     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 338     responseInfo.result = CA_CONTENT;
 339     responseInfo.info = responseData;
 340
 341     EXPECT_EQ(CA_STATUS_OK, CASendResponse(tempRep, &responseInfo));
 342
 343     CADestroyToken(tempToken);
 344     CADestroyEndpoint(tempRep);
 345     free(responseData.payload);
 346     tempRep = NULL;
 347 }
 348
 349 // check return value when address is NULL as multicast
 350 TEST(SendResponseTest, DISABLED_TC_20_Negative_01)
 351 {
 352     addr = NULL;
 353     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, 0, &tempRep);
 354
 355     memset(&responseData, 0, sizeof(CAInfo_t));
 356     responseData.type = CA_MSG_NONCONFIRM;
 357     responseData.messageId = 1;
 358     responseData.payload = (CAPayload_t)malloc(sizeof("response payload"));
 359     EXPECT_TRUE(responseData.payload != NULL);
 360
 361     if(!responseData.payload)
 362     {
 363         CADestroyEndpoint(tempRep);
 364         return;
 365     }
 366
 367     memcpy(responseData.payload, "response payload", sizeof("response payload"));
 368     responseData.payloadSize = sizeof("response payload");
 369
 370     CAGenerateToken(&tempToken, tokenLength);
 371     requestData.token = tempToken;
 372     requestData.tokenLength = tokenLength;
 373
 374     memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 375     responseInfo.result = CA_CONTENT;
 376     responseInfo.info = responseData;
 377
 378     EXPECT_EQ(CA_STATUS_OK, CASendResponse(tempRep, &responseInfo));
 379
 380     CADestroyToken(tempToken);
 381     CADestroyEndpoint(tempRep);
 382     free (responseData.payload);
 383     tempRep = NULL;
 384 }
 385
 386 // check return value NULL is passed instead of a valid CAResponseInfo_t address
 387 TEST_F(CATests, SendResponseTest)
 388 {
 389     addr = (char *) ADDRESS;
 390     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
 391
 392     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendResponse(tempRep, NULL));
 393
 394     CADestroyEndpoint(tempRep);
 395     tempRep = NULL;
 396 }
 397
 398 // CASelectNewwork TC
 399 // check return value
 400 TEST_F(CATests, SelectNetworkTestGood)
 401 {
 402     EXPECT_EQ(CA_STATUS_OK, checkSelectNetwork());
 403 }
 404
 405 CAResult_t checkSelectNetwork()
 406 {
 407     CAResult_t res = CASelectNetwork(CA_ADAPTER_IP);
 408
 409     if (CA_STATUS_OK == res)
 410     {
 411         EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_IP));
 412         return CA_STATUS_OK;
 413     }
 414     if (CA_NOT_SUPPORTED == res)
 415     {
 416         EXPECT_EQ(CA_STATUS_FAILED, CAUnSelectNetwork(CA_ADAPTER_IP));
 417         return CA_STATUS_OK;
 418     }
 419
 420     return res;
 421 }
 422
 423 // check return value when selected network is disable
 424 TEST_F(CATests, SelectNetworkTestBad)
 425 {
 426     //Select disable network
 427     EXPECT_EQ(CA_NOT_SUPPORTED, CASelectNetwork((CATransportAdapter_t)
 428                                                 CA_TRANSPORT_ADAPTER_SCOPE));
 429 }
 430
 431 // check return value when selected network is disable
 432 TEST_F(CATests, UnSelectNetworkTest)
 433 {
 434     //UnSelect disable network
 435     EXPECT_EQ(CA_STATUS_FAILED, CAUnSelectNetwork((CATransportAdapter_t)
 436                                                   CA_TRANSPORT_ADAPTER_SCOPE));
 437 }
 438
 439 // CAHandlerRequestResponse TC
 440 // check return value
 441 TEST_F(CATests, HandlerRequestResponseTest)
 442 {
 443     EXPECT_EQ(CA_STATUS_OK, CAHandleRequestResponse());
 444 }
 445
 446 // CAGetNetworkInformation TC
 447 // check return value
 448 TEST_F (CATests, GetNetworkInformationTestGood)
 449 {
 450     EXPECT_EQ(CA_STATUS_OK, checkGetNetworkInfo());
 451 }
 452
 453 TEST_F(CATests, RegisterDTLSCredentialsHandlerTest)
 454 {
 455 #ifdef __WITH_DTLS__
 456     EXPECT_EQ(CA_STATUS_OK, CARegisterDTLSCredentialsHandler(CAGetDtlsPskCredentials));
 457 #endif
 458 }
 459
 460 // CARegisterNetworkMonitorHandler TC
 461 // check return value
 462 TEST_F(CATests, RegisterNetworkMonitorHandler)
 463 {
 464 #ifdef LE_ADAPTER
 465     EXPECT_EQ(CA_STATUS_OK, CARegisterNetworkMonitorHandler(adapter_handler,
 466                                                             connection_handler));
 467 #else
 468     EXPECT_EQ(CA_NOT_SUPPORTED, CARegisterNetworkMonitorHandler(adapter_handler,
 469                                                                 connection_handler));
 470 #endif
 471 }
 472
 473 // CASetAutoConnectionDeviceInfo TC
 474 // check return value
 475 TEST_F(CATests, SetAutoConnectionDeviceInfo)
 476 {
 477     addr = (char *) ADDRESS;
 478
 479 #if defined(__ANDROID__) && defined(LE_ADAPTER)
 480     EXPECT_EQ(CA_STATUS_OK, CASetAutoConnectionDeviceInfo(addr));
 481 #else
 482     EXPECT_EQ(CA_NOT_SUPPORTED, CASetAutoConnectionDeviceInfo(addr));
 483 #endif
 484 }
 485
 486 // CAUnsetAutoConnectionDeviceInfo TC
 487 // check return value
 488 TEST_F(CATests, UnsetAutoConnectionDeviceInfo)
 489 {
 490     addr = (char *) ADDRESS;
 491
 492 #if defined(__ANDROID__) && defined(LE_ADAPTER)
 493     EXPECT_EQ(CA_STATUS_OK, CAUnsetAutoConnectionDeviceInfo(addr));
 494 #else
 495     EXPECT_EQ(CA_NOT_SUPPORTED, CAUnsetAutoConnectionDeviceInfo(addr));
 496 #endif
 497 }
 498
 499 CAResult_t checkGetNetworkInfo()
 500 {
 501     CAEndpoint_t *tempInfo = NULL;
 502     uint32_t tempSize = 0;
 503
 504     CAResult_t res = CAGetNetworkInformation(&tempInfo, &tempSize);
 505
 506     free(tempInfo);
 507
 508     if (CA_STATUS_OK == res || CA_ADAPTER_NOT_ENABLED == res ||
 509             CA_NOT_SUPPORTED == res)
 510     {
 511         return CA_STATUS_OK;
 512     }
 513     else
 514     {
 515         return CA_STATUS_FAILED;
 516     }
 517 }