tests/unittest/thread-unittest-network.cpp

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <gtest/gtest.h>
  18 #include <arpa/inet.h>
  19
  20 #include "thread.h"
  21 #include "mocks/thread-mock-dummy.h"
  22
  23 #define NETWORK_DATA_SIZE 256
  24 #define NETWORK_TLVS_SIZE 1024
  25 #define DUMMY_TLVS_STR "0e080000000000010000000300001935060004001" \
  26         "fffe00208763d64768c8f3ecf0708fdd10ceaadb65a7b05105e1ec3e" \
  27         "16d3e0aee52fb7e618a759973030f4f70656e5468726561642d34633" \
  28         "33801024c3804103044b2dc6512dce13b11d3386eb2ce7e0c0402a0fff8"
  29 #define DUMMY_TLVS_SIZE ((int)(sizeof(DUMMY_TLVS_STR) / 2))
  30
  31 class ThreadNetworkTest : public ::testing::Test
  32 {
  33 public:
  34         const char *NETWORK_DUMMY_NAME = "TizenOpenThread";
  35         const char *NETWORK_DUMMY_KEY = "c03aa2d3c869847b0e7f2ca288efd251";
  36         const char *NETWORK_DUMMY_PSKC = "19d3bd4ee76baad7ff2da29c87c67452";
  37         const uint32_t NETWORK_DUMMY_CHANNEL = 15;
  38         const uint64_t NETWORK_DUMMY_EXTENDED_PANID = 0xeea0d4484e93db7a;
  39         const uint16_t NETWORK_DUMMY_PANID = 0x68a0;
  40
  41         thread_instance_h instance;
  42         thread_network_h network;
  43         thread_network_h operationalNetwork;
  44         char name[NETWORK_DATA_SIZE + 1];
  45         char key[NETWORK_DATA_SIZE + 1];
  46         char pskc[NETWORK_DATA_SIZE + 1];
  47         uint32_t channel;
  48         uint64_t extendedPanId;
  49         uint16_t panId;
  50         uint8_t tlvsBuffer[NETWORK_TLVS_SIZE];
  51         int tlvsBufferLength;
  52         uint8_t ipv6Address[THREAD_IPV6_ADDRESS_SIZE];
  53
  54 public:
  55         static void getIpAddrCallback(int index, char* ipaddr,
  56                 thread_ipaddr_type_e ipaddr_type, void *user_data) {};
  57
  58 protected:
  59         void SetUp() override
  60         {
  61                 thread_initialize();
  62                 instance = nullptr;
  63                 network = nullptr;
  64                 operationalNetwork = nullptr;
  65                 snprintf(name, NETWORK_DATA_SIZE + 1, "Thread-test");
  66                 snprintf(key, NETWORK_DATA_SIZE + 1, "f780b002ec7d904c9995daaa78a50083");
  67                 snprintf(pskc, NETWORK_DATA_SIZE + 1, "ba473fecdb235d30bd65233e6089ee50");
  68                 channel = 0x07fff800;
  69                 extendedPanId = strtoull("18446744073709551615LL", nullptr, 10);
  70                 panId = 65535;
  71                 makeTlvsBuffer();
  72                 tlvsBufferLength = DUMMY_TLVS_SIZE;
  73                 makeIpv6Address();
  74         }
  75
  76         void TearDown() override
  77         {
  78                 if (instance)
  79                 {
  80                         if (network)
  81                         {
  82                                 thread_unset_operational_network(instance);
  83                                 thread_network_destroy(network);
  84                         }
  85                         thread_disable(instance);
  86                 }
  87
  88                 thread_deinitialize();
  89         }
  90
  91 private:
  92         void makeTlvsBuffer()
  93         {
  94                 for (int i = 0; i < DUMMY_TLVS_SIZE; ++i)
  95                 {
  96                         char subBuffer[3];
  97                         memcpy(subBuffer, &DUMMY_TLVS_STR[2 * i], 2);
  98                         subBuffer[2] = '\0';
  99                         tlvsBuffer[i] = (uint8_t)strtol(subBuffer, NULL, 16);
 100                 }
 101         }
 102
 103         void makeIpv6Address()
 104         {
 105                 struct in6_addr result;
 106                 inet_pton(AF_INET6, DUMMY_IPV6_ADDRESS, &result);
 107                 memcpy(ipv6Address, result.s6_addr,
 108                         THREAD_IPV6_PREFIX_SIZE * sizeof(uint8_t));
 109         }
 110 };
 111
 112 TEST_F(ThreadNetworkTest, SetActiveDatasetTlvsNotInitialized)
 113 {
 114         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 115         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 116                 thread_network_set_active_dataset_tlvs(instance, tlvsBuffer, tlvsBufferLength));
 117 }
 118
 119 TEST_F(ThreadNetworkTest, SetActiveDatasetTlvsInvalidParameter)
 120 {
 121         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 122                 thread_network_set_active_dataset_tlvs(instance, tlvsBuffer, tlvsBufferLength));
 123 }
 124
 125 TEST_F(ThreadNetworkTest, SetActiveDatasetTlvsErrorNone)
 126 {
 127         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 128         EXPECT_EQ(THREAD_ERROR_NONE,
 129                 thread_network_set_active_dataset_tlvs(instance, tlvsBuffer, tlvsBufferLength));
 130 }
 131
 132 TEST_F(ThreadNetworkTest, GetActiveDatasetTlvsNotInitialized)
 133 {
 134         uint8_t *tlvs_buffer = NULL;
 135         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 136         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 137                 thread_network_get_active_dataset_tlvs(instance, &tlvs_buffer, &tlvsBufferLength));
 138 }
 139
 140 TEST_F(ThreadNetworkTest, GetActiveDatasetTlvsInvalidParameter)
 141 {
 142         uint8_t *tlvs_buffer = NULL;
 143         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 144                 thread_network_get_active_dataset_tlvs(instance, &tlvs_buffer, &tlvsBufferLength));
 145 }
 146
 147 TEST_F(ThreadNetworkTest, GetActiveDatasetTlvsErrorNone)
 148 {
 149         uint8_t *tlvs_buffer = NULL;
 150         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 151         EXPECT_EQ(THREAD_ERROR_NONE,
 152                 thread_network_get_active_dataset_tlvs(instance, &tlvs_buffer, &tlvsBufferLength));
 153         g_free(tlvs_buffer);
 154 }
 155
 156 TEST_F(ThreadNetworkTest, AttachNotInitialized)
 157 {
 158         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 159         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_network_attach(instance));
 160 }
 161
 162 TEST_F(ThreadNetworkTest, AttachInvalidParameter)
 163 {
 164         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_network_attach(instance));
 165 }
 166
 167 TEST_F(ThreadNetworkTest, AttachErrorNone)
 168 {
 169         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 170         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_attach(instance));
 171 }
 172
 173 TEST_F(ThreadNetworkTest, DetachNotInitialized)
 174 {
 175         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 176         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_network_detach(instance));
 177 }
 178
 179 TEST_F(ThreadNetworkTest, DetachInvalidParameter)
 180 {
 181         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_network_detach(instance));
 182 }
 183
 184 TEST_F(ThreadNetworkTest, DetachErrorNone)
 185 {
 186         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 187         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 188         EXPECT_EQ(THREAD_ERROR_NONE,
 189                 thread_set_operational_network(instance, network));
 190         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_detach(instance));
 191 }
 192
 193 TEST_F(ThreadNetworkTest, GetIpAddrNotInitialized)
 194 {
 195         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 196         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 197                 thread_get_ipaddr(instance, getIpAddrCallback,
 198                         THREAD_IPADDR_TYPE_ALL, nullptr));
 199 }
 200
 201 TEST_F(ThreadNetworkTest, GetIpAddrInvalidParameter)
 202 {
 203         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 204                 thread_get_ipaddr(instance, getIpAddrCallback,
 205                         THREAD_IPADDR_TYPE_ALL, nullptr));
 206 }
 207
 208 TEST_F(ThreadNetworkTest, GetIpAddrErrorNone)
 209 {
 210         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 211         EXPECT_EQ(THREAD_ERROR_NONE,
 212                 thread_get_ipaddr(instance, getIpAddrCallback,
 213                         THREAD_IPADDR_TYPE_ALL, nullptr));
 214         EXPECT_EQ(THREAD_ERROR_NONE,
 215                 thread_get_ipaddr(instance, getIpAddrCallback,
 216                         THREAD_IPADDR_TYPE_LINK_LOCAL, nullptr));
 217         EXPECT_EQ(THREAD_ERROR_NONE,
 218                 thread_get_ipaddr(instance, getIpAddrCallback,
 219                         THREAD_IPADDR_TYPE_RLOC, nullptr));
 220         EXPECT_EQ(THREAD_ERROR_NONE,
 221                 thread_get_ipaddr(instance, getIpAddrCallback,
 222                         THREAD_IPADDR_TYPE_MLEID, nullptr));
 223 }
 224
 225 TEST_F(ThreadNetworkTest, AddIpAddrNotInitialized)
 226 {
 227         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 228         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 229                 thread_add_ipaddr(instance, ipv6Address));
 230 }
 231
 232 TEST_F(ThreadNetworkTest, AddIpAddrInvalidParameter)
 233 {
 234         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 235                 thread_add_ipaddr(instance, ipv6Address));
 236 }
 237
 238 TEST_F(ThreadNetworkTest, AddIpAddrErrorNone)
 239 {
 240         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 241         EXPECT_EQ(THREAD_ERROR_NONE,
 242                 thread_add_ipaddr(instance, ipv6Address));
 243 }
 244
 245 TEST_F(ThreadNetworkTest, RemoveIpAddrNotInitialized)
 246 {
 247         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 248         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 249                 thread_remove_ipaddr(instance, ipv6Address));
 250 }
 251
 252 TEST_F(ThreadNetworkTest, RemoveIpAddrInvalidParameter)
 253 {
 254         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 255                 thread_remove_ipaddr(instance, ipv6Address));
 256 }
 257
 258 TEST_F(ThreadNetworkTest, RemoveIpAddrErrorNone)
 259 {
 260         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 261         EXPECT_EQ(THREAD_ERROR_NONE,
 262                 thread_remove_ipaddr(instance, ipv6Address));
 263 }
 264
 265 TEST_F(ThreadNetworkTest, GetPanIdNotInitialized)
 266 {
 267         uint16_t panid;
 268         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 269         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 270                 thread_network_get_panid(instance, &panid));
 271 }
 272
 273 TEST_F(ThreadNetworkTest, GetPanIdInvalidParameter)
 274 {
 275         uint16_t panid;
 276         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 277                 thread_network_get_panid(instance, &panid));
 278 }
 279
 280 TEST_F(ThreadNetworkTest, GetPanIdErrorNone)
 281 {
 282         uint16_t panid;
 283         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 284         EXPECT_EQ(THREAD_ERROR_NONE,
 285                 thread_network_set_active_dataset_tlvs(instance, tlvsBuffer, tlvsBufferLength));
 286         EXPECT_EQ(THREAD_ERROR_NONE,
 287                 thread_network_get_panid(instance, &panid));
 288 }
 289
 290 TEST_F(ThreadNetworkTest, CreateNotInitialized)
 291 {
 292         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 293         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_network_create(&network));
 294 }
 295
 296 TEST_F(ThreadNetworkTest, CreateInvalidParameter)
 297 {
 298         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_network_create(nullptr));
 299 }
 300
 301 TEST_F(ThreadNetworkTest, CreateErrorNone)
 302 {
 303         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 304 }
 305
 306 TEST_F(ThreadNetworkTest, DestroyNotInitialized)
 307 {
 308         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 309         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_network_destroy(network));
 310 }
 311
 312 TEST_F(ThreadNetworkTest, DestroyInvalidParameter)
 313 {
 314         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_network_destroy(nullptr));
 315 }
 316
 317 TEST_F(ThreadNetworkTest, DestroyErrorNone)
 318 {
 319         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 320         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_destroy(network));
 321 }
 322
 323 TEST_F(ThreadNetworkTest, SetNameNotInitialized)
 324 {
 325         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 326         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 327                 thread_network_set_name(network, NETWORK_DUMMY_NAME));
 328 }
 329
 330 TEST_F(ThreadNetworkTest, SetNameInvalidParameter)
 331 {
 332         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 333                 thread_network_set_name(nullptr, NETWORK_DUMMY_NAME));
 334 }
 335
 336 TEST_F(ThreadNetworkTest, SetNameErrorNone)
 337 {
 338         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 339         EXPECT_EQ(THREAD_ERROR_NONE,
 340                 thread_network_set_name(network, NETWORK_DUMMY_NAME));
 341 }
 342
 343 TEST_F(ThreadNetworkTest, SetKeyNotInitialized)
 344 {
 345         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 346         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 347                 thread_network_set_key(network, NETWORK_DUMMY_KEY));
 348 }
 349
 350 TEST_F(ThreadNetworkTest, SetKeyInvalidParameter)
 351 {
 352         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 353                 thread_network_set_key(nullptr, NETWORK_DUMMY_KEY));
 354 }
 355
 356 TEST_F(ThreadNetworkTest, SetKeyErrorNone)
 357 {
 358         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 359         EXPECT_EQ(THREAD_ERROR_NONE,
 360                 thread_network_set_key(network, NETWORK_DUMMY_KEY));
 361 }
 362
 363 TEST_F(ThreadNetworkTest, SetPskcNotInitialized)
 364 {
 365         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 366         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 367                 thread_network_set_pskc(network, NETWORK_DUMMY_PSKC));
 368 }
 369
 370 TEST_F(ThreadNetworkTest, SetPskcInvalidParameter)
 371 {
 372         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 373                 thread_network_set_pskc(nullptr, NETWORK_DUMMY_PSKC));
 374 }
 375
 376 TEST_F(ThreadNetworkTest, SetPskcErrorNone)
 377 {
 378         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 379         EXPECT_EQ(THREAD_ERROR_NONE,
 380                 thread_network_set_pskc(network, NETWORK_DUMMY_PSKC));
 381 }
 382
 383 TEST_F(ThreadNetworkTest, SetChannelNotInitialized)
 384 {
 385         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 386         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 387                 thread_network_set_channel(network, NETWORK_DUMMY_CHANNEL));
 388 }
 389
 390 TEST_F(ThreadNetworkTest, SetChannelInvalidParameter)
 391 {
 392         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 393                 thread_network_set_channel(nullptr, NETWORK_DUMMY_CHANNEL));
 394 }
 395
 396 TEST_F(ThreadNetworkTest, SetChannelErrorNone)
 397 {
 398         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 399         EXPECT_EQ(THREAD_ERROR_NONE,
 400                 thread_network_set_channel(network, NETWORK_DUMMY_CHANNEL));
 401 }
 402
 403 TEST_F(ThreadNetworkTest, SetExtendedPanidNotInitialized)
 404 {
 405         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 406         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 407                 thread_network_set_extended_panid(network, NETWORK_DUMMY_EXTENDED_PANID));
 408 }
 409
 410 TEST_F(ThreadNetworkTest, SetExtendedPanidInvalidParameter)
 411 {
 412         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 413                 thread_network_set_extended_panid(nullptr, NETWORK_DUMMY_EXTENDED_PANID));
 414 }
 415
 416 TEST_F(ThreadNetworkTest, SetExtendedPanidErrorNone)
 417 {
 418         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 419         EXPECT_EQ(THREAD_ERROR_NONE,
 420                 thread_network_set_extended_panid(network, NETWORK_DUMMY_EXTENDED_PANID));
 421 }
 422
 423 TEST_F(ThreadNetworkTest, SetPanidNotInitialized)
 424 {
 425         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 426         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 427                 thread_network_set_panid(network, NETWORK_DUMMY_PANID));
 428 }
 429
 430 TEST_F(ThreadNetworkTest, SetPanidInvalidParameter)
 431 {
 432         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 433                 thread_network_set_panid(nullptr, NETWORK_DUMMY_PANID));
 434 }
 435
 436 TEST_F(ThreadNetworkTest, SetPanidErrorNone)
 437 {
 438         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 439         EXPECT_EQ(THREAD_ERROR_NONE,
 440                 thread_network_set_panid(network, NETWORK_DUMMY_PANID));
 441 }
 442
 443 TEST_F(ThreadNetworkTest, SetOperationalNetworkNotInitialized)
 444 {
 445         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 446         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 447                 thread_set_operational_network(instance, network));
 448 }
 449
 450 TEST_F(ThreadNetworkTest, SetOperationalNetworkInvalidParameter)
 451 {
 452         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 453                 thread_set_operational_network(instance, network));
 454 }
 455
 456 TEST_F(ThreadNetworkTest, SetOperationalNetworkErrorNone)
 457 {
 458         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 459         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 460         EXPECT_EQ(THREAD_ERROR_NONE,
 461                 thread_set_operational_network(instance, network));
 462 }
 463
 464 TEST_F(ThreadNetworkTest, UnsetOperationalNetworkNotInitialized)
 465 {
 466         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 467         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 468                 thread_unset_operational_network(instance));
 469 }
 470
 471 TEST_F(ThreadNetworkTest, UnsetOperationalNetworkInvalidParameter)
 472 {
 473         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 474                 thread_unset_operational_network(instance));
 475 }
 476
 477 TEST_F(ThreadNetworkTest, UnsetOperationalNetworkErrorNone)
 478 {
 479         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 480         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 481         EXPECT_EQ(THREAD_ERROR_NONE,
 482                 thread_set_operational_network(instance, network));
 483         EXPECT_EQ(THREAD_ERROR_NONE,
 484                 thread_unset_operational_network(instance));
 485 }