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 "platform_features.h"
  22 #include "gtest/gtest.h"
  23 #include "cainterface.h"
  24 #include "cautilinterface.h"
  25 #include "cacommon.h"
  26 #include "oic_string.h"
  27 #include "oic_malloc.h"
  28 #include "cafragmentation.h"
  29 #include "caleinterface.h"
  30
  31 #define CA_TRANSPORT_ADAPTER_SCOPE  1000
  32 #define CA_BLE_FIRST_SEGMENT_PAYLOAD_SIZE (((CA_DEFAULT_BLE_MTU_SIZE) - (CA_BLE_HEADER_SIZE)) \
  33                                            - (CA_BLE_LENGTH_HEADER_SIZE))
  34
  35
  36 class CATests : public testing::Test {
  37     protected:
  38     virtual void SetUp()
  39     {
  40         CAInitialize(CA_DEFAULT_ADAPTER);
  41     }
  42
  43     virtual void TearDown()
  44     {
  45         CATerminate();
  46     }
  47 };
  48
  49 void request_handler(CAEndpoint_t* object, CARequestInfo_t* requestInfo);
  50 void response_handler(CAEndpoint_t* object, CAResponseInfo_t* responseInfo);
  51 void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo);
  52 void adapter_handler(CATransportAdapter_t adapter, bool enabled);
  53 void connection_handler(CATransportAdapter_t adapter, const char *remote_address, bool connected);
  54 CAResult_t checkSelectNetwork();
  55
  56 void request_handler(const CAEndpoint_t * /*object*/,
  57                      const CARequestInfo_t * /*requestInfo*/)
  58 {
  59
  60 }
  61
  62 void response_handler(const CAEndpoint_t * /*object*/,
  63                       const CAResponseInfo_t * /*responseInfo*/)
  64 {
  65
  66 }
  67
  68 void error_handler(const CAEndpoint_t *object, const CAErrorInfo_t* errorInfo)
  69 {
  70     if(!object || !errorInfo)
  71     {
  72         return;
  73     }
  74
  75     //error handling shall be added
  76     return;
  77 }
  78
  79 void adapter_handler(CATransportAdapter_t /*adapter*/,
  80                      bool /*enabled*/)
  81 {
  82 }
  83
  84 void connection_handler(const CAEndpoint_t * /*endpoint*/,
  85                         bool /*connected*/)
  86 {
  87 }
  88
  89 static char* addr = NULL;
  90 static CAEndpoint_t* tempRep = NULL;
  91 static CARequestInfo_t requestInfo;
  92 static CAInfo_t requestData;
  93 static CAInfo_t responseData;
  94 static CAResponseInfo_t responseInfo;
  95 static CAToken_t tempToken = NULL;
  96 static uint8_t tokenLength = CA_MAX_TOKEN_LEN;
  97 static const char ADDRESS[] = "10.11.12.13";
  98 static const uint16_t PORT = 4545;
  99
 100 static const char NORMAL_INFO_DATA[] =
 101                                     "{\"oc\":[{\"href\":\"%s\",\"prop\":{\"rt\":[\"core.led\"],"
 102                                      "\"if\":[\"oc.mi.def\"],\"obs\":1}}]}";
 103 #ifdef __WITH_DTLS__
 104
 105 // Iotivity Device Identity.
 106 const unsigned char IDENTITY[] = ("1111111111111111");
 107
 108 // PSK between this device and peer device.
 109 const unsigned char RS_CLIENT_PSK[] = ("AAAAAAAAAAAAAAAA");
 110
 111 // Internal API. Invoked by CA stack to retrieve credentials from this module
 112 int32_t CAGetDtlsPskCredentials( CADtlsPskCredType_t type,
 113               const unsigned char *desc, size_t desc_len,
 114               unsigned char *result, size_t result_length)
 115 {
 116     printf("CAGetDtlsPskCredentials IN\n");
 117
 118     int32_t ret = -1;
 119
 120     if (NULL == result)
 121     {
 122         return ret;
 123     }
 124
 125     switch (type)
 126     {
 127         case CA_DTLS_PSK_HINT:
 128         case CA_DTLS_PSK_IDENTITY:
 129
 130             if (result_length < sizeof(IDENTITY))
 131             {
 132                 printf("ERROR : Wrong value for result for storing IDENTITY");
 133                 return ret;
 134             }
 135
 136             memcpy(result, IDENTITY, sizeof(IDENTITY));
 137             ret = sizeof(IDENTITY);
 138             break;
 139
 140         case CA_DTLS_PSK_KEY:
 141
 142             if ((desc_len == sizeof(IDENTITY)) &&
 143                 memcmp(desc, IDENTITY, sizeof(IDENTITY)) == 0)
 144             {
 145                 if (result_length < sizeof(RS_CLIENT_PSK))
 146                 {
 147                     printf("ERROR : Wrong value for result for storing RS_CLIENT_PSK");
 148                     return ret;
 149                 }
 150
 151                 memcpy(result, RS_CLIENT_PSK, sizeof(RS_CLIENT_PSK));
 152                 ret = sizeof(RS_CLIENT_PSK);
 153             }
 154             break;
 155
 156         default:
 157
 158             printf("Wrong value passed for PSK_CRED_TYPE.");
 159             ret = -1;
 160     }
 161
 162
 163     printf("CAGetDtlsPskCredentials OUT\n");
 164     return ret;
 165 }
 166
 167 const char* our_cert = "-----BEGIN CERTIFICATE-----\n"
 168 "MIIBhTCCASugAwIBAgIJAPZ5mB94RwYHMAoGCCqGSM49BAMCMCUxIzAhBgNVBAoM\n"
 169 "GklvVGl2aXR5VGVzdFNlbGZTaWduZWROYW1lMB4XDTE2MTIxNjIxMjcyMVoXDTMw\n"
 170 "MDgyNTIxMjcyMVowITEfMB0GA1UECgwWSW9UaXZpdHlUZXN0Q2xpZW50TmFtZTBZ\n"
 171 "MBMGByqGSM49AgEGCCqGSM49AwEHA0IABF8OxpJNe01ZPEFpXUUhjUV5uwJM1TF3\n"
 172 "ZSt0tJ71lQiRZ9cbl5z31acRpsZM+fXiR+wkR4xoP7iIyDdTHHVHtkSjSDBGMBUG\n"
 173 "A1UdJQQOMAwGCisGAQQBgt58AQYwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQH\n"
 174 "EWLwaDfA+o6U4wmQKVoK9I3B/DAKBggqhkjOPQQDAgNIADBFAiAbDHQHzSjNiDeQ\n"
 175 "OaJYRMLIW2dIlabiQ5pxkW/jEaRszAIhAPzuoNdrQTRbnqCy0hmS9hFt8MxDrrBh\n"
 176 "7jHARQm/5pko\n"
 177 "-----END CERTIFICATE-----\n";
 178
 179 const char* our_key = "-----BEGIN EC PRIVATE KEY-----\n"
 180 "MHcCAQEEIOV0iG5CndNK6JhB8nDcqQjNjgRWe/LQWPNPua3w7nHToAoGCCqGSM49\n"
 181 "AwEHoUQDQgAEXw7Gkk17TVk8QWldRSGNRXm7AkzVMXdlK3S0nvWVCJFn1xuXnPfV\n"
 182 "pxGmxkz59eJH7CRHjGg/uIjIN1McdUe2RA==\n"
 183 "-----END EC PRIVATE KEY-----\n";
 184
 185 const char* our_ca = "-----BEGIN CERTIFICATE-----\n"
 186 "MIIBlzCCATygAwIBAgIJALxGf3YRERn1MAoGCCqGSM49BAMCMCUxIzAhBgNVBAoM\n"
 187 "GklvVGl2aXR5VGVzdFNlbGZTaWduZWROYW1lMB4XDTE2MTIxNjIxMjcyMVoXDTMw\n"
 188 "MDgyNTIxMjcyMVowJTEjMCEGA1UECgwaSW9UaXZpdHlUZXN0U2VsZlNpZ25lZE5h\n"
 189 "bWUwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATo/zp8PXaA/drJQKSG3TlerO0F\n"
 190 "eHkpRkmXMeLFLrImqo1w9OyLfVmrpBrCDjf83BkwLYp19bkYizL2Yk9zIQ4Do1Uw\n"
 191 "UzAhBgNVHSUEGjAYBgorBgEEAYLefAEGBgorBgEEAYLefAEHMA8GA1UdEwEB/wQF\n"
 192 "MAMBAf8wHQYDVR0OBBYEFAcRYvBoN8D6jpTjCZApWgr0jcH8MAoGCCqGSM49BAMC\n"
 193 "A0kAMEYCIQCuZb1LMTthWy9rPgy2FQgoFHB2LXUJlgRLJeO/gTFqgQIhANRvr1Py\n"
 194 "5Bp6asye5FK4VUj6tARxmRNeNLvwonLrqp2w\n"
 195 "-----END CERTIFICATE-----\n";
 196
 197 // Invoked by the CA stack to retrieve credentials from this module
 198 void provide_x509_cert_and_key(PkiInfo_t* inf)
 199 {
 200     /* PEM data must end in newline and be null terminated for IoTivity */
 201
 202     inf->crt.data = (uint8_t*) our_cert;
 203     inf->crt.len = strlen(our_cert) + 1;
 204     inf->key.data = (uint8_t*) our_key;
 205     inf->key.len = strlen(our_key) + 1;
 206     inf->ca.data = (uint8_t*) our_ca;
 207     inf->ca.len = strlen(our_ca) + 1;
 208
 209     // CRL not provided
 210     inf->crl.data = NULL;
 211     inf->crl.len = 0;
 212
 213     return;
 214 }
 215 // Empty version, for testing.
 216 void badPkixInfoHandler(PkiInfo_t* /*inf*/)
 217 {
 218     return;
 219 }
 220
 221 void provide_supported_credential_types(bool* list, const char* /*deviceId*/)
 222 {
 223     list[1] = true;
 224     /*
 225      * Note: there is a default implementation of this in credresource.c, exposed by
 226      * pkix_interface.h, called InitManufacturerCipherSuiteList.  If the cred resource
 227      * has a credential of the required type, it updates list accordingly.
 228      *
 229      * In a separate test, we could use the cred resource and APIs (credresource.h).
 230      */
 231     return;
 232 }
 233
 234 #endif  //__WITH_DTLS__
 235
 236 // CAInitialize TC
 237 TEST(InitializeTest, CAInitializeTest)
 238 {
 239     EXPECT_EQ(CA_STATUS_OK, CAInitialize(CA_DEFAULT_ADAPTER));
 240     CATerminate();
 241 }
 242
 243 //CATerminate TC
 244 TEST_F(CATests, TerminateTest)
 245 {
 246     CATerminate();
 247
 248     char* check = (char *) "terminate success";
 249     EXPECT_STREQ(check, "terminate success");
 250
 251     CAInitialize(CA_DEFAULT_ADAPTER);
 252 }
 253
 254 // CAStartListeningServer TC
 255 TEST_F(CATests, StartListeningServerTestWithNonSelect)
 256 {
 257     EXPECT_EQ(CA_STATUS_FAILED, CAStartListeningServer());
 258 }
 259
 260 // CAStartListeningServer TC
 261 TEST_F(CATests, StartListeningServerTest)
 262 {
 263     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
 264     EXPECT_EQ(CA_STATUS_OK, CAStartListeningServer());
 265 }
 266
 267 // CAStopListeningServer TC
 268 TEST_F(CATests, CAStopListeningServerTestWithNonSelect)
 269 {
 270     EXPECT_EQ(CA_STATUS_FAILED, CAStopListeningServer());
 271 }
 272
 273 // CAStopListeningServer TC
 274 TEST_F(CATests, CAStopListeningServerTest)
 275 {
 276     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
 277     EXPECT_EQ(CA_STATUS_OK, CAStopListeningServer());
 278 }
 279
 280 // CARegisterHandlerTest TC
 281 TEST_F(CATests, RegisterHandlerTest)
 282 {
 283     CARegisterHandler(request_handler, response_handler, error_handler);
 284     char* check = (char *) "registerHandler success";
 285     EXPECT_STREQ(check, "registerHandler success");
 286 }
 287
 288 // CACreateRemoteEndpoint TC
 289 TEST_F(CATests, CreateRemoteEndpointTestGood)
 290 {
 291     addr = (char *) ADDRESS;
 292
 293     EXPECT_EQ(CA_STATUS_OK, CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr,
 294                                              PORT, &tempRep));
 295
 296     CADestroyEndpoint(tempRep);
 297     tempRep = NULL;
 298 }
 299
 300 // check remoteEndpoint and values of remoteEndpoint
 301 TEST_F(CATests, CreateRemoteEndpointTestValues)
 302 {
 303     addr = (char *) ADDRESS;
 304
 305     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
 306
 307     EXPECT_TRUE(tempRep != NULL);
 308
 309     CADestroyEndpoint(tempRep);
 310     tempRep = NULL;
 311 }
 312
 313 // CAGerateToken TC
 314 TEST_F(CATests, GenerateTokenTestGood)
 315 {
 316     EXPECT_EQ(CA_STATUS_OK, CAGenerateToken(&tempToken, tokenLength));
 317
 318     CADestroyToken(tempToken);
 319 }
 320
 321 // check return value when CAGenerateToken is passed a NULL instead a valid pointer
 322 TEST_F(CATests, GenerateTokenTestBad)
 323 {
 324     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CAGenerateToken(NULL, tokenLength));
 325 }
 326
 327 // CADestroyToken TC
 328 // check destroyed token
 329 TEST_F(CATests, DestroyTokenTest)
 330 {
 331     CAGenerateToken(&tempToken, tokenLength);
 332     CADestroyToken(tempToken);
 333
 334     char * check = (char *) "destroy success";
 335     EXPECT_STREQ(check, "destroy success");
 336 }
 337
 338 TEST_F(CATests, SendRequestTestWithInvalidAddress)
 339 {
 340     CARegisterHandler(request_handler, response_handler, error_handler);
 341
 342     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
 343     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, "10.11.13.13.14", PORT, &tempRep);
 344
 345     memset(&requestData, 0, sizeof(CAInfo_t));
 346     CAGenerateToken(&tempToken, tokenLength);
 347     requestData.token = tempToken;
 348     requestData.tokenLength = tokenLength;
 349     requestData.type = CA_MSG_CONFIRM;
 350
 351     memset(&requestInfo, 0, sizeof(CARequestInfo_t));
 352     requestInfo.method = CA_GET;
 353     requestInfo.info = requestData;
 354
 355     EXPECT_EQ(CA_STATUS_OK, CASendRequest(tempRep, &requestInfo));
 356
 357     CADestroyToken(tempToken);
 358     CADestroyEndpoint(tempRep);
 359     free(requestData.payload);
 360     tempRep = NULL;
 361 }
 362
 363 #if defined(__WITH_DTLS__)
 364 TEST_F(CATests, DISABLED_PkiTest)
 365 {
 366     // @todo: this test is disabled for now, it crashes with an invalid write. Cert data
 367     // provided by the provide_x509_cert_and_key is stored as const char, but ParseChain()
 368     // (in ca_adapter_net_ssl.c) writes to it while reading.  We could change the test to
 369     // provide data on the heap, but the CA stack should not be changing data provided to it
 370     // by callbacks.
 371
 372     const char* local_addr = "127.0.0.1";
 373     uint16_t local_port = 5503;
 374     CAEndpoint_t* serverAddr = NULL;
 375
 376     CARegisterHandler(request_handler, response_handler, error_handler);
 377
 378     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
 379     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, local_addr, local_port, &serverAddr);
 380     ASSERT_TRUE(serverAddr != NULL);
 381
 382     // Register a credential types handler (tells the CA layer which creds are supported)
 383     EXPECT_EQ(CA_STATUS_OK, CAregisterGetCredentialTypesHandler(provide_supported_credential_types));
 384
 385     // Limit ourselves to 0xC0AE : TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 since it's non-PSK
 386     EXPECT_EQ(CA_STATUS_OK, CASelectCipherSuite(0xC0AE, serverAddr->adapter));
 387
 388     // Register an empty callback to provide the keys, expect failure when initializing the handshake.
 389     EXPECT_EQ(CA_STATUS_OK, CAregisterPkixInfoHandler(badPkixInfoHandler));
 390     EXPECT_EQ(CA_STATUS_FAILED, CAInitiateHandshake(serverAddr));
 391
 392     // Register a working callback to provide the keys, expect success.
 393     EXPECT_EQ(CA_STATUS_OK, CAregisterPkixInfoHandler(provide_x509_cert_and_key));
 394     EXPECT_EQ(CA_STATUS_OK, CAInitiateHandshake(serverAddr));
 395
 396     CADestroyEndpoint(serverAddr);
 397 }
 398 #endif /* defined(__WITH_DTLS__) */
 399
 400 // CASendRequest TC
 401 // check return value when a NULL is passed instead of a valid CARequestInfo_t address
 402 TEST_F(CATests, SendRequestTestWithNullAddr)
 403 {
 404     addr = (char *) ADDRESS;
 405     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
 406
 407     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendRequest(tempRep, NULL));
 408
 409     CADestroyEndpoint(tempRep);
 410     tempRep = NULL;
 411 }
 412
 413 // CASendResponse TC
 414 TEST_F(CATests, SendResponseTestWithInvalidCode)
 415 {
 416     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
 417
 418     addr = (char *) ADDRESS;
 419     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
 420
 421     memset(&responseData, 0, sizeof(CAInfo_t));
 422     responseData.type = CA_MSG_RESET;
 423     responseData.messageId = 1;
 424     responseData.payload = (CAPayload_t)OICMalloc(sizeof("response payload"));
 425     responseData.dataType = CA_RESPONSE_DATA;
 426
 427     EXPECT_TRUE(responseData.payload != NULL);
 428
 429     if (responseData.payload)
 430     {
 431         CAGenerateToken(&tempToken, tokenLength);
 432         requestData.token = tempToken;
 433         requestData.tokenLength = tokenLength;
 434
 435         memset(&responseInfo, 0, sizeof(CAResponseInfo_t));
 436         responseInfo.result = CA_CONTENT;
 437         responseInfo.info = responseData;
 438
 439         EXPECT_EQ(CA_STATUS_OK, CASendResponse(tempRep, &responseInfo));
 440
 441         CADestroyToken(tempToken);
 442         CADestroyEndpoint(tempRep);
 443         OICFree(responseData.payload);
 444         tempRep = NULL;
 445     }
 446 }
 447
 448 // check return value NULL is passed instead of a valid CAResponseInfo_t address
 449 TEST_F(CATests, SendResponseTest)
 450 {
 451     addr = (char *) ADDRESS;
 452     CACreateEndpoint(CA_DEFAULT_FLAGS, CA_ADAPTER_IP, addr, PORT, &tempRep);
 453
 454     EXPECT_EQ(CA_STATUS_INVALID_PARAM, CASendResponse(tempRep, NULL));
 455
 456     CADestroyEndpoint(tempRep);
 457     tempRep = NULL;
 458 }
 459
 460 // CASelectNewwork TC
 461 TEST_F(CATests, SelectNetworkTestGood)
 462 {
 463     EXPECT_EQ(CA_STATUS_OK, checkSelectNetwork());
 464 }
 465
 466 CAResult_t checkSelectNetwork()
 467 {
 468     CAResult_t res = CASelectNetwork(CA_ADAPTER_IP);
 469
 470     if (CA_STATUS_OK == res)
 471     {
 472         EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_IP));
 473         return CA_STATUS_OK;
 474     }
 475     if (CA_NOT_SUPPORTED == res)
 476     {
 477         EXPECT_EQ(CA_STATUS_FAILED, CAUnSelectNetwork(CA_ADAPTER_IP));
 478         return CA_STATUS_OK;
 479     }
 480
 481     return res;
 482 }
 483
 484 // check return value when selected network is disable
 485 TEST_F(CATests, SelectNetworkTestBad)
 486 {
 487     //Select disable network
 488     EXPECT_EQ(CA_NOT_SUPPORTED, CASelectNetwork((CATransportAdapter_t)
 489                                                 CA_TRANSPORT_ADAPTER_SCOPE));
 490 }
 491
 492 // check return value when selected network is disable
 493 TEST_F(CATests, UnSelectNetworkTest)
 494 {
 495     //UnSelect disable network
 496     EXPECT_EQ(CA_STATUS_FAILED, CAUnSelectNetwork((CATransportAdapter_t)
 497                                                   CA_TRANSPORT_ADAPTER_SCOPE));
 498 }
 499
 500 // CAHandlerRequestResponse TC
 501 TEST_F(CATests, HandlerRequestResponseTest)
 502 {
 503     EXPECT_EQ(CA_STATUS_OK, CAHandleRequestResponse());
 504 }
 505
 506 // CAGetNetworkInformation TC
 507 TEST_F (CATests, GetNetworkInformationTest)
 508 {
 509     size_t tempSize = 0;
 510     CAEndpoint_t *tempInfo = NULL;
 511
 512     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
 513     EXPECT_EQ(CA_STATUS_OK, CAGetNetworkInformation(&tempInfo, &tempSize));
 514
 515     for (size_t index = 0; index < tempSize; index++)
 516     {
 517         EXPECT_TRUE(tempInfo[index].adapter != 0);
 518         EXPECT_TRUE(strlen(tempInfo[index].addr) != 0);
 519     }
 520
 521     free(tempInfo);
 522 }
 523
 524 TEST_F(CATests, GetSelectedNetwork)
 525 {
 526     CATransportAdapter_t SelectedNetwork = CA_DEFAULT_ADAPTER;
 527
 528 #ifdef IP_ADAPTER
 529     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork | CA_ADAPTER_IP) ;
 530     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_IP));
 531     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 532 #endif
 533 #ifdef LE_ADAPTER
 534     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork | CA_ADAPTER_GATT_BTLE);
 535     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_GATT_BTLE));
 536     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 537 #endif
 538 #ifdef EDR_ADAPTER
 539     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork | CA_ADAPTER_RFCOMM_BTEDR);
 540     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_RFCOMM_BTEDR));
 541     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 542 #endif
 543 #ifdef TCP_ADAPTER
 544     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork | CA_ADAPTER_TCP);
 545     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_TCP));
 546     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 547 #endif
 548 #ifdef NFC_ADAPTER
 549     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork | CA_ADAPTER_NFC);
 550     EXPECT_EQ(CA_STATUS_OK, CASelectNetwork(CA_ADAPTER_NFC));
 551     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 552 #endif
 553
 554 #ifdef IP_ADAPTER
 555     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork & ~CA_ADAPTER_IP) ;
 556     EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_IP));
 557     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 558 #endif
 559 #ifdef LE_ADAPTER
 560     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork & ~CA_ADAPTER_GATT_BTLE);
 561     EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_GATT_BTLE));
 562     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 563 #endif
 564 #ifdef EDR_ADAPTER
 565     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork & ~CA_ADAPTER_RFCOMM_BTEDR);
 566     EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_RFCOMM_BTEDR));
 567     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 568 #endif
 569 #ifdef TCP_ADAPTER
 570     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork & ~CA_ADAPTER_TCP);
 571     EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_TCP));
 572     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 573 #endif
 574 #ifdef NFC_ADAPTER
 575     SelectedNetwork = (CATransportAdapter_t)(SelectedNetwork & ~CA_ADAPTER_NFC);
 576     EXPECT_EQ(CA_STATUS_OK, CAUnSelectNetwork(CA_ADAPTER_NFC));
 577     EXPECT_EQ(SelectedNetwork, CAGetSelectedNetwork());
 578 #endif
 579 }
 580
 581 TEST_F(CATests, RegisterDTLSCredentialsHandlerTest)
 582 {
 583 #ifdef __WITH_DTLS__
 584     EXPECT_EQ(CA_STATUS_OK, CAregisterPskCredentialsHandler(CAGetDtlsPskCredentials));
 585     EXPECT_EQ(CA_STATUS_OK, CAregisterPkixInfoHandler(provide_x509_cert_and_key));
 586     EXPECT_EQ(CA_STATUS_OK, CAregisterGetCredentialTypesHandler(provide_supported_credential_types));
 587 #endif
 588 }
 589
 590 // CARegisterNetworkMonitorHandler TC
 591 TEST_F(CATests, RegisterNetworkMonitorHandler)
 592 {
 593     EXPECT_EQ(CA_STATUS_OK, CARegisterNetworkMonitorHandler(adapter_handler,
 594                                                             connection_handler));
 595 }
 596
 597 // CASetAutoConnectionDeviceInfo TC
 598 TEST_F(CATests, SetAutoConnectionDeviceInfo)
 599 {
 600     addr = (char *) ADDRESS;
 601
 602 #if defined(__ANDROID__) && defined(LE_ADAPTER)
 603     EXPECT_EQ(CA_STATUS_OK, CASetAutoConnectionDeviceInfo(addr));
 604 #else
 605     EXPECT_EQ(CA_NOT_SUPPORTED, CASetAutoConnectionDeviceInfo(addr));
 606 #endif
 607 }
 608
 609 // CAUnsetAutoConnectionDeviceInfo TC
 610 TEST_F(CATests, UnsetAutoConnectionDeviceInfo)
 611 {
 612     addr = (char *) ADDRESS;
 613
 614 #if defined(__ANDROID__) && defined(LE_ADAPTER)
 615     EXPECT_EQ(CA_STATUS_OK, CAUnsetAutoConnectionDeviceInfo(addr));
 616 #else
 617     EXPECT_EQ(CA_NOT_SUPPORTED, CAUnsetAutoConnectionDeviceInfo(addr));
 618 #endif
 619 }
 620
 621 TEST(CASetPortNumberTest, CASetPortNumberToAssign)
 622 {
 623     EXPECT_EQ(CA_STATUS_OK, CASetPortNumberToAssign(CA_ADAPTER_IP, CA_IPV4, 5683));
 624     EXPECT_EQ(CA_STATUS_OK, CASetPortNumberToAssign(CA_ADAPTER_IP, CA_IPV6, 5683));
 625     EXPECT_EQ(CA_STATUS_OK,
 626               CASetPortNumberToAssign(CA_ADAPTER_IP,
 627                                       static_cast<CATransportFlags_t>(CA_IPV4|CA_SECURE), 5683));
 628     EXPECT_EQ(CA_STATUS_OK,
 629               CASetPortNumberToAssign(CA_ADAPTER_IP,
 630                                       static_cast<CATransportFlags_t>(CA_IPV6|CA_SECURE), 5683));
 631
 632 #ifdef TCP_ADAPTER
 633     EXPECT_EQ(CA_STATUS_OK, CASetPortNumberToAssign(CA_ADAPTER_TCP, CA_IPV4, 5683));
 634     EXPECT_EQ(CA_STATUS_OK, CASetPortNumberToAssign(CA_ADAPTER_TCP, CA_IPV6, 5683));
 635 #endif
 636 }
 637
 638 TEST(CAGetPortNumberTest, CAGetPortNumberToAssign)
 639 {
 640     ASSERT_EQ(static_cast<uint16_t>(0),
 641               CAGetAssignedPortNumber(CA_ADAPTER_IP, CA_IPV4));
 642     ASSERT_EQ(static_cast<uint16_t>(0),
 643               CAGetAssignedPortNumber(CA_ADAPTER_IP, CA_IPV6));
 644     ASSERT_EQ(static_cast<uint16_t>(0),
 645               CAGetAssignedPortNumber(CA_ADAPTER_IP,
 646                                       static_cast<CATransportFlags_t>(CA_IPV4|CA_SECURE)));
 647     ASSERT_EQ(static_cast<uint16_t>(0),
 648               CAGetAssignedPortNumber(CA_ADAPTER_IP,
 649                                       static_cast<CATransportFlags_t>(CA_IPV6|CA_SECURE)));
 650 #ifdef TCP_ADAPTER
 651     ASSERT_EQ(static_cast<uint16_t>(0), CAGetAssignedPortNumber(CA_ADAPTER_TCP, CA_IPV4));
 652     ASSERT_EQ(static_cast<uint16_t>(0), CAGetAssignedPortNumber(CA_ADAPTER_TCP, CA_IPV6));
 653 #endif
 654 }
 655
 656 TEST(CAfragmentationTest, FragmentTest)
 657 {
 658 #if defined(LE_ADAPTER)
 659     const size_t dataLen = 30;
 660     uint8_t *data = (uint8_t *) malloc(dataLen*sizeof(uint8_t));
 661     memset(data, 'a', dataLen);
 662
 663     uint32_t midPacketCount = 0;
 664     size_t remainingLen = 0;
 665     size_t totalLength = 0;
 666
 667     EXPECT_EQ(CA_STATUS_OK, CAGenerateVariableForFragmentation(dataLen,
 668                                                                &midPacketCount,
 669                                                                &remainingLen,
 670                                                                &totalLength,
 671                                                                CA_DEFAULT_BLE_MTU_SIZE));
 672
 673     uint8_t dataHeader[CA_BLE_HEADER_SIZE] = {0};
 674     const uint8_t tmpSourcePort = 1;
 675     const uint8_t tmpDestPort = 1;
 676
 677     EXPECT_EQ(CA_STATUS_OK, CAGenerateHeader(dataHeader,
 678                                              CA_BLE_PACKET_START,
 679                                              tmpSourcePort,
 680                                              CA_BLE_PACKET_NON_SECURE,
 681                                              tmpDestPort));
 682     EXPECT_TRUE(dataHeader != NULL);
 683
 684     uint8_t lengthHeader[CA_BLE_LENGTH_HEADER_SIZE] = {0};
 685
 686     EXPECT_EQ(CA_STATUS_OK, CAGenerateHeaderPayloadLength(lengthHeader,
 687                                                           CA_BLE_LENGTH_HEADER_SIZE,
 688                                                           dataLen));
 689     EXPECT_TRUE(lengthHeader != NULL);
 690
 691     uint8_t dataSegment[CA_SUPPORTED_BLE_MTU_SIZE] = {0};
 692
 693     EXPECT_EQ(CA_STATUS_OK, CAMakeFirstDataSegment(dataSegment,
 694                                                    data,
 695                                                    CA_BLE_FIRST_SEGMENT_PAYLOAD_SIZE,
 696                                                    dataHeader,
 697                                                    lengthHeader));
 698     EXPECT_TRUE(dataSegment != NULL);
 699
 700     EXPECT_EQ(CA_STATUS_OK, CAGenerateHeader(dataHeader,
 701                                              CA_BLE_PACKET_NOT_START,
 702                                              tmpSourcePort,
 703                                              CA_BLE_PACKET_NON_SECURE,
 704                                              tmpDestPort));
 705     EXPECT_TRUE(dataHeader != NULL);
 706
 707     EXPECT_EQ(CA_STATUS_OK, CAMakeRemainDataSegment(dataSegment,
 708                                                     remainingLen,
 709                                                     data,
 710                                                     dataLen,
 711                                                     0,
 712                                                     dataHeader,
 713                                                     CA_DEFAULT_BLE_MTU_SIZE));
 714     EXPECT_TRUE(dataSegment != NULL);
 715
 716     free(data);
 717 #endif
 718 }
 719
 720 TEST(CAfragmentationTest, DefragmentTest)
 721 {
 722 #if defined(LE_ADAPTER)
 723     const size_t dataLen = 30;
 724     uint8_t *data = (uint8_t *) malloc(dataLen*sizeof(uint8_t));
 725     memset(data, 'a', dataLen);
 726
 727     uint32_t midPacketCount = 0;
 728     size_t remainingLen = 0;
 729     size_t totalLength = 0;
 730
 731     EXPECT_EQ(CA_STATUS_OK, CAGenerateVariableForFragmentation(dataLen,
 732                                                                &midPacketCount,
 733                                                                &remainingLen,
 734                                                                &totalLength,
 735                                                                CA_SUPPORTED_BLE_MTU_SIZE));
 736
 737     uint8_t dataHeader[CA_BLE_HEADER_SIZE] = {0};
 738     const uint8_t tmpSourcePort = 1;
 739     const uint8_t tmpDestPort = 1;
 740
 741     EXPECT_EQ(CA_STATUS_OK, CAGenerateHeader(dataHeader,
 742                                              CA_BLE_PACKET_START,
 743                                              tmpSourcePort,
 744                                              CA_BLE_PACKET_NON_SECURE,
 745                                              tmpDestPort));
 746     EXPECT_TRUE(dataHeader != NULL);
 747
 748     uint8_t lengthHeader[CA_BLE_LENGTH_HEADER_SIZE] = {0};
 749
 750     EXPECT_EQ(CA_STATUS_OK, CAGenerateHeaderPayloadLength(lengthHeader,
 751                                                           CA_BLE_LENGTH_HEADER_SIZE,
 752                                                           dataLen));
 753     EXPECT_TRUE(lengthHeader != NULL);
 754
 755     uint8_t dataSegment[CA_SUPPORTED_BLE_MTU_SIZE] = {0};
 756
 757     EXPECT_EQ(CA_STATUS_OK, CAMakeFirstDataSegment(dataSegment,
 758                                                    data,
 759                                                    CA_BLE_FIRST_SEGMENT_PAYLOAD_SIZE,
 760                                                    dataHeader,
 761                                                    lengthHeader));
 762     EXPECT_TRUE(dataSegment != NULL);
 763
 764     CABLEPacketStart_t startFlag = CA_BLE_PACKET_NOT_START;
 765     CABLEPacketSecure_t secureFlag = CA_BLE_PACKET_NON_SECURE;
 766     uint16_t sourcePort = 0;
 767     uint16_t destPort = 0;
 768
 769     EXPECT_EQ(CA_STATUS_OK, CAParseHeader(dataSegment,
 770                                           &startFlag,
 771                                           &sourcePort,
 772                                           &secureFlag,
 773                                           &destPort));
 774
 775     uint32_t parseDataLength = 0;
 776
 777     EXPECT_EQ(CA_STATUS_OK, CAParseHeaderPayloadLength(dataSegment,
 778                                                        CA_BLE_LENGTH_HEADER_SIZE,
 779                                                        &parseDataLength));
 780
 781     free(data);
 782 #endif
 783 }
 784
 785 TEST(Ipv6ScopeLevel, getMulticastScope)
 786 {
 787
 788     const char interfaceLocalStart[] = "ff01::";
 789     const char linkLocalStart[]      = "ff02::";
 790     const char realmLocalStart[]     = "ff03::";
 791     const char adminLocalStart[]     = "ff04::";
 792     const char siteLocalStart[]      = "ff05::";
 793     const char orgLocalStart[]       = "ff08::";
 794     const char globalStart[]         = "ff0e::";
 795
 796     const char interfaceLocalMid[] = "ff81:0000:0000:f000:0000:0000:0000:0000";
 797     const char linkLocalMid[]      = "ff82:0000:0000:f000:0000:0000:0000:0000";
 798     const char realmLocalMid[]     = "ff83:0000:0000:f000:0000:0000:0000:0000";
 799     const char adminLocalMid[]     = "ff84:0000:0000:f000:0000:0000:0000:0000";
 800     const char siteLocalMid[]      = "ff85:0000:0000:f000:0000:0000:0000:0000";
 801     const char orgLocalMid[]       = "ff88:0000:0000:f000:0000:0000:0000:0000";
 802     const char globalMid[]         = "ff8e:0000:0000:f000:0000:0000:0000:0000";
 803
 804     const char interfaceLocalEnd[] = "fff1:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 805     const char linkLocalEnd[]      = "fff2:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 806     const char realmLocalEnd[]     = "fff3:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 807     const char adminLocalEnd[]     = "fff4:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 808     const char siteLocalEnd[]      = "fff5:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 809     const char orgLocalEnd[]       = "fff8:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 810     const char globalEnd[]         = "fffe:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 811
 812     // range start
 813     CATransportFlags_t scopeLevel = CA_DEFAULT_FLAGS;
 814     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(interfaceLocalStart, &scopeLevel));
 815     EXPECT_EQ(CA_SCOPE_INTERFACE, scopeLevel);
 816     scopeLevel = CA_DEFAULT_FLAGS;
 817
 818     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(linkLocalStart, &scopeLevel));
 819     EXPECT_EQ(CA_SCOPE_LINK, scopeLevel);
 820     scopeLevel = CA_DEFAULT_FLAGS;
 821
 822     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(realmLocalStart, &scopeLevel));
 823     EXPECT_EQ(CA_SCOPE_REALM, scopeLevel);
 824     scopeLevel = CA_DEFAULT_FLAGS;
 825
 826     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(adminLocalStart, &scopeLevel));
 827     EXPECT_EQ(CA_SCOPE_ADMIN, scopeLevel);
 828     scopeLevel = CA_DEFAULT_FLAGS;
 829
 830     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(siteLocalStart, &scopeLevel));
 831     EXPECT_EQ(CA_SCOPE_SITE, scopeLevel);
 832     scopeLevel = CA_DEFAULT_FLAGS;
 833
 834     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(orgLocalStart, &scopeLevel));
 835     EXPECT_EQ(CA_SCOPE_ORG, scopeLevel);
 836     scopeLevel = CA_DEFAULT_FLAGS;
 837
 838     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(globalStart, &scopeLevel));
 839     EXPECT_EQ(CA_SCOPE_GLOBAL, scopeLevel);
 840     scopeLevel = CA_DEFAULT_FLAGS;
 841
 842     // range mid
 843     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(interfaceLocalMid, &scopeLevel));
 844     EXPECT_EQ(CA_SCOPE_INTERFACE, scopeLevel);
 845     scopeLevel = CA_DEFAULT_FLAGS;
 846
 847     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(linkLocalMid, &scopeLevel));
 848     EXPECT_EQ(CA_SCOPE_LINK, scopeLevel);
 849     scopeLevel = CA_DEFAULT_FLAGS;
 850
 851     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(realmLocalMid, &scopeLevel));
 852     EXPECT_EQ(CA_SCOPE_REALM, scopeLevel);
 853     scopeLevel = CA_DEFAULT_FLAGS;
 854
 855     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(adminLocalMid, &scopeLevel));
 856     EXPECT_EQ(CA_SCOPE_ADMIN, scopeLevel);
 857     scopeLevel = CA_DEFAULT_FLAGS;
 858
 859     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(siteLocalMid, &scopeLevel));
 860     EXPECT_EQ(CA_SCOPE_SITE, scopeLevel);
 861     scopeLevel = CA_DEFAULT_FLAGS;
 862
 863     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(orgLocalMid, &scopeLevel));
 864     EXPECT_EQ(CA_SCOPE_ORG, scopeLevel);
 865     scopeLevel = CA_DEFAULT_FLAGS;
 866
 867     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(globalMid, &scopeLevel));
 868     EXPECT_EQ(CA_SCOPE_GLOBAL, scopeLevel);
 869     scopeLevel = CA_DEFAULT_FLAGS;
 870
 871     // range end
 872     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(interfaceLocalEnd, &scopeLevel));
 873     EXPECT_EQ(CA_SCOPE_INTERFACE, scopeLevel);
 874     scopeLevel = CA_DEFAULT_FLAGS;
 875
 876     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(linkLocalEnd, &scopeLevel));
 877     EXPECT_EQ(CA_SCOPE_LINK, scopeLevel);
 878     scopeLevel = CA_DEFAULT_FLAGS;
 879
 880     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(realmLocalEnd, &scopeLevel));
 881     EXPECT_EQ(CA_SCOPE_REALM, scopeLevel);
 882     scopeLevel = CA_DEFAULT_FLAGS;
 883
 884     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(adminLocalEnd, &scopeLevel));
 885     EXPECT_EQ(CA_SCOPE_ADMIN, scopeLevel);
 886     scopeLevel = CA_DEFAULT_FLAGS;
 887
 888     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(siteLocalEnd, &scopeLevel));
 889     EXPECT_EQ(CA_SCOPE_SITE, scopeLevel);
 890     scopeLevel = CA_DEFAULT_FLAGS;
 891
 892     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(orgLocalEnd, &scopeLevel));
 893     EXPECT_EQ(CA_SCOPE_ORG, scopeLevel);
 894     scopeLevel = CA_DEFAULT_FLAGS;
 895
 896     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(globalEnd, &scopeLevel));
 897     EXPECT_EQ(CA_SCOPE_GLOBAL, scopeLevel);
 898     scopeLevel = CA_DEFAULT_FLAGS;
 899 }
 900
 901 TEST(Ipv6ScopeLevel, getUnicastScope)
 902 {
 903     const char linkLocalLoopBack[]  = "::1";
 904
 905     const char linkLocalStart[]     = "fe80::";
 906     const char linkLocalMid[]       = "fe80:0000:0000:0000:0f00:0000:0000:0000";
 907     const char linkLocalEnd[]       = "febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 908
 909     const char siteLocalStart[]     = "fec0::";
 910     const char siteLocalMid[]       = "fec0:0000:0000:0000:0f00:0000:0000:0000";
 911     const char siteLocalEnd[]       = "feff:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 912
 913     const char globalStart[]   = "2000:0000:0000:0000:0000:0000:0000:0000";
 914     const char globalMid[]     = "2000:0000:0000:0f00:0000:0000:0000:0000";
 915     const char globalEnd[]     = "3fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 916
 917     // loopback
 918     CATransportFlags_t scopeLevel = CA_DEFAULT_FLAGS;
 919     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(linkLocalLoopBack, &scopeLevel));
 920     EXPECT_EQ(CA_SCOPE_LINK, scopeLevel);
 921     scopeLevel = CA_DEFAULT_FLAGS;
 922
 923     // linklocal
 924     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(linkLocalStart, &scopeLevel));
 925     EXPECT_EQ(CA_SCOPE_LINK, scopeLevel);
 926     scopeLevel = CA_DEFAULT_FLAGS;
 927
 928     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(linkLocalMid, &scopeLevel));
 929     EXPECT_EQ(CA_SCOPE_LINK, scopeLevel);
 930     scopeLevel = CA_DEFAULT_FLAGS;
 931
 932     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(linkLocalEnd, &scopeLevel));
 933     EXPECT_EQ(CA_SCOPE_LINK, scopeLevel);
 934     scopeLevel = CA_DEFAULT_FLAGS;
 935
 936     // sitelocal
 937     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(siteLocalStart, &scopeLevel));
 938     EXPECT_EQ(CA_SCOPE_SITE, scopeLevel);
 939     scopeLevel = CA_DEFAULT_FLAGS;
 940
 941     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(siteLocalMid, &scopeLevel));
 942     EXPECT_EQ(CA_SCOPE_SITE, scopeLevel);
 943     scopeLevel = CA_DEFAULT_FLAGS;
 944
 945     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(siteLocalEnd, &scopeLevel));
 946     EXPECT_EQ(CA_SCOPE_SITE, scopeLevel);
 947     scopeLevel = CA_DEFAULT_FLAGS;
 948
 949     // global
 950     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(globalStart, &scopeLevel));
 951     EXPECT_EQ(CA_SCOPE_GLOBAL, scopeLevel);
 952     scopeLevel = CA_DEFAULT_FLAGS;
 953
 954     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(globalMid, &scopeLevel));
 955     EXPECT_EQ(CA_SCOPE_GLOBAL, scopeLevel);
 956     scopeLevel = CA_DEFAULT_FLAGS;
 957
 958     EXPECT_EQ(CA_STATUS_OK, CAGetIpv6AddrScope(globalEnd, &scopeLevel));
 959     EXPECT_EQ(CA_SCOPE_GLOBAL, scopeLevel);
 960     scopeLevel = CA_DEFAULT_FLAGS;
 961 }
 962
 963 TEST(Ipv6ScopeLevel, invalidAddressTest)
 964 {
 965     const char invalidAddr1[]    = "qqqq";
 966     const char invalidAddr2[]    = "ffx7:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 967     const char invalidAddr3[]    = "ffx7::::::::::dsds";
 968     const char invalidAddr4[]    = "ffx7:ffff:ffff:ff@f:ffff:ffff:ffff:ffff";
 969
 970     CATransportFlags_t scopeLevel = CA_DEFAULT_FLAGS;
 971     EXPECT_EQ(CA_STATUS_FAILED, CAGetIpv6AddrScope(invalidAddr1, &scopeLevel));
 972     EXPECT_EQ(CA_STATUS_FAILED, CAGetIpv6AddrScope(invalidAddr2, &scopeLevel));
 973     EXPECT_EQ(CA_STATUS_FAILED, CAGetIpv6AddrScope(invalidAddr3, &scopeLevel));
 974     EXPECT_EQ(CA_STATUS_FAILED, CAGetIpv6AddrScope(invalidAddr4, &scopeLevel));
 975 }