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         g_free(tlvs_buffer);
 139 }
 140
 141 TEST_F(ThreadNetworkTest, GetActiveDatasetTlvsInvalidParameter)
 142 {
 143         uint8_t *tlvs_buffer = NULL;
 144         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 145                 thread_network_get_active_dataset_tlvs(instance, &tlvs_buffer, &tlvsBufferLength));
 146         g_free(tlvs_buffer);
 147 }
 148
 149 TEST_F(ThreadNetworkTest, GetActiveDatasetTlvsErrorNone)
 150 {
 151         uint8_t *tlvs_buffer = NULL;
 152         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 153         EXPECT_EQ(THREAD_ERROR_NONE,
 154                 thread_network_get_active_dataset_tlvs(instance, &tlvs_buffer, &tlvsBufferLength));
 155         g_free(tlvs_buffer);
 156 }
 157
 158 TEST_F(ThreadNetworkTest, AttachNotInitialized)
 159 {
 160         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 161         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_network_attach(instance));
 162 }
 163
 164 TEST_F(ThreadNetworkTest, AttachInvalidParameter)
 165 {
 166         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_network_attach(instance));
 167 }
 168
 169 TEST_F(ThreadNetworkTest, AttachErrorNone)
 170 {
 171         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 172         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_attach(instance));
 173 }
 174
 175 TEST_F(ThreadNetworkTest, DetachNotInitialized)
 176 {
 177         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 178         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_network_detach(instance));
 179 }
 180
 181 TEST_F(ThreadNetworkTest, DetachInvalidParameter)
 182 {
 183         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_network_detach(instance));
 184 }
 185
 186 TEST_F(ThreadNetworkTest, DetachErrorNone)
 187 {
 188         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 189         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 190         EXPECT_EQ(THREAD_ERROR_NONE,
 191                 thread_set_operational_network(instance, network));
 192         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_detach(instance));
 193 }
 194
 195 TEST_F(ThreadNetworkTest, GetIpAddrNotInitialized)
 196 {
 197         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 198         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 199                 thread_get_ipaddr(instance, getIpAddrCallback,
 200                         THREAD_IPADDR_TYPE_ALL, nullptr));
 201 }
 202
 203 TEST_F(ThreadNetworkTest, GetIpAddrInvalidParameter)
 204 {
 205         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 206                 thread_get_ipaddr(instance, getIpAddrCallback,
 207                         THREAD_IPADDR_TYPE_ALL, nullptr));
 208 }
 209
 210 TEST_F(ThreadNetworkTest, GetIpAddrErrorNone)
 211 {
 212         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 213         EXPECT_EQ(THREAD_ERROR_NONE,
 214                 thread_get_ipaddr(instance, getIpAddrCallback,
 215                         THREAD_IPADDR_TYPE_ALL, nullptr));
 216         EXPECT_EQ(THREAD_ERROR_NONE,
 217                 thread_get_ipaddr(instance, getIpAddrCallback,
 218                         THREAD_IPADDR_TYPE_LINK_LOCAL, nullptr));
 219         EXPECT_EQ(THREAD_ERROR_NONE,
 220                 thread_get_ipaddr(instance, getIpAddrCallback,
 221                         THREAD_IPADDR_TYPE_RLOC, nullptr));
 222         EXPECT_EQ(THREAD_ERROR_NONE,
 223                 thread_get_ipaddr(instance, getIpAddrCallback,
 224                         THREAD_IPADDR_TYPE_MLEID, nullptr));
 225 }
 226
 227 TEST_F(ThreadNetworkTest, AddIpAddrNotInitialized)
 228 {
 229         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 230         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 231                 thread_add_ipaddr(instance, ipv6Address));
 232 }
 233
 234 TEST_F(ThreadNetworkTest, AddIpAddrInvalidParameter)
 235 {
 236         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 237                 thread_add_ipaddr(instance, ipv6Address));
 238 }
 239
 240 TEST_F(ThreadNetworkTest, AddIpAddrErrorNone)
 241 {
 242         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 243         EXPECT_EQ(THREAD_ERROR_NONE,
 244                 thread_add_ipaddr(instance, ipv6Address));
 245 }
 246
 247 TEST_F(ThreadNetworkTest, RemoveIpAddrNotInitialized)
 248 {
 249         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 250         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 251                 thread_remove_ipaddr(instance, ipv6Address));
 252 }
 253
 254 TEST_F(ThreadNetworkTest, RemoveIpAddrInvalidParameter)
 255 {
 256         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 257                 thread_remove_ipaddr(instance, ipv6Address));
 258 }
 259
 260 TEST_F(ThreadNetworkTest, RemoveIpAddrErrorNone)
 261 {
 262         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 263         EXPECT_EQ(THREAD_ERROR_NONE,
 264                 thread_remove_ipaddr(instance, ipv6Address));
 265 }
 266
 267 TEST_F(ThreadNetworkTest, GetPanIdNotInitialized)
 268 {
 269         uint16_t panid;
 270         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 271         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 272                 thread_network_get_panid(instance, &panid));
 273 }
 274
 275 TEST_F(ThreadNetworkTest, GetPanIdInvalidParameter)
 276 {
 277         uint16_t panid;
 278         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 279                 thread_network_get_panid(instance, &panid));
 280 }
 281
 282 TEST_F(ThreadNetworkTest, GetPanIdErrorNone)
 283 {
 284         uint16_t panid;
 285         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 286         EXPECT_EQ(THREAD_ERROR_NONE,
 287                 thread_network_set_active_dataset_tlvs(instance, tlvsBuffer, tlvsBufferLength));
 288         EXPECT_EQ(THREAD_ERROR_NONE,
 289                 thread_network_get_panid(instance, &panid));
 290 }
 291
 292 TEST_F(ThreadNetworkTest, CreateNotInitialized)
 293 {
 294         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 295         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_network_create(&network));
 296 }
 297
 298 TEST_F(ThreadNetworkTest, CreateInvalidParameter)
 299 {
 300         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_network_create(nullptr));
 301 }
 302
 303 TEST_F(ThreadNetworkTest, CreateErrorNone)
 304 {
 305         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 306 }
 307
 308 TEST_F(ThreadNetworkTest, DestroyNotInitialized)
 309 {
 310         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 311         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_network_destroy(network));
 312 }
 313
 314 TEST_F(ThreadNetworkTest, DestroyInvalidParameter)
 315 {
 316         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_network_destroy(nullptr));
 317 }
 318
 319 TEST_F(ThreadNetworkTest, DestroyErrorNone)
 320 {
 321         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 322         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_destroy(network));
 323 }
 324
 325 TEST_F(ThreadNetworkTest, SetNameNotInitialized)
 326 {
 327         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 328         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 329                 thread_network_set_name(network, NETWORK_DUMMY_NAME));
 330 }
 331
 332 TEST_F(ThreadNetworkTest, SetNameInvalidParameter)
 333 {
 334         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 335                 thread_network_set_name(nullptr, NETWORK_DUMMY_NAME));
 336 }
 337
 338 TEST_F(ThreadNetworkTest, SetNameErrorNone)
 339 {
 340         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 341         EXPECT_EQ(THREAD_ERROR_NONE,
 342                 thread_network_set_name(network, NETWORK_DUMMY_NAME));
 343 }
 344
 345 TEST_F(ThreadNetworkTest, SetKeyNotInitialized)
 346 {
 347         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 348         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 349                 thread_network_set_key(network, NETWORK_DUMMY_KEY));
 350 }
 351
 352 TEST_F(ThreadNetworkTest, SetKeyInvalidParameter)
 353 {
 354         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 355                 thread_network_set_key(nullptr, NETWORK_DUMMY_KEY));
 356 }
 357
 358 TEST_F(ThreadNetworkTest, SetKeyErrorNone)
 359 {
 360         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 361         EXPECT_EQ(THREAD_ERROR_NONE,
 362                 thread_network_set_key(network, NETWORK_DUMMY_KEY));
 363 }
 364
 365 TEST_F(ThreadNetworkTest, SetPskcNotInitialized)
 366 {
 367         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 368         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 369                 thread_network_set_pskc(network, NETWORK_DUMMY_PSKC));
 370 }
 371
 372 TEST_F(ThreadNetworkTest, SetPskcInvalidParameter)
 373 {
 374         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 375                 thread_network_set_pskc(nullptr, NETWORK_DUMMY_PSKC));
 376 }
 377
 378 TEST_F(ThreadNetworkTest, SetPskcErrorNone)
 379 {
 380         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 381         EXPECT_EQ(THREAD_ERROR_NONE,
 382                 thread_network_set_pskc(network, NETWORK_DUMMY_PSKC));
 383 }
 384
 385 TEST_F(ThreadNetworkTest, SetChannelNotInitialized)
 386 {
 387         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 388         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 389                 thread_network_set_channel(network, NETWORK_DUMMY_CHANNEL));
 390 }
 391
 392 TEST_F(ThreadNetworkTest, SetChannelInvalidParameter)
 393 {
 394         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 395                 thread_network_set_channel(nullptr, NETWORK_DUMMY_CHANNEL));
 396 }
 397
 398 TEST_F(ThreadNetworkTest, SetChannelErrorNone)
 399 {
 400         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 401         EXPECT_EQ(THREAD_ERROR_NONE,
 402                 thread_network_set_channel(network, NETWORK_DUMMY_CHANNEL));
 403 }
 404
 405 TEST_F(ThreadNetworkTest, SetExtendedPanidNotInitialized)
 406 {
 407         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 408         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 409                 thread_network_set_extended_panid(network, NETWORK_DUMMY_EXTENDED_PANID));
 410 }
 411
 412 TEST_F(ThreadNetworkTest, SetExtendedPanidInvalidParameter)
 413 {
 414         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 415                 thread_network_set_extended_panid(nullptr, NETWORK_DUMMY_EXTENDED_PANID));
 416 }
 417
 418 TEST_F(ThreadNetworkTest, SetExtendedPanidErrorNone)
 419 {
 420         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 421         EXPECT_EQ(THREAD_ERROR_NONE,
 422                 thread_network_set_extended_panid(network, NETWORK_DUMMY_EXTENDED_PANID));
 423 }
 424
 425 TEST_F(ThreadNetworkTest, SetPanidNotInitialized)
 426 {
 427         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 428         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 429                 thread_network_set_panid(network, NETWORK_DUMMY_PANID));
 430 }
 431
 432 TEST_F(ThreadNetworkTest, SetPanidInvalidParameter)
 433 {
 434         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 435                 thread_network_set_panid(nullptr, NETWORK_DUMMY_PANID));
 436 }
 437
 438 TEST_F(ThreadNetworkTest, SetPanidErrorNone)
 439 {
 440         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 441         EXPECT_EQ(THREAD_ERROR_NONE,
 442                 thread_network_set_panid(network, NETWORK_DUMMY_PANID));
 443 }
 444
 445 TEST_F(ThreadNetworkTest, SetOperationalNetworkNotInitialized)
 446 {
 447         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 448         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 449                 thread_set_operational_network(instance, network));
 450 }
 451
 452 TEST_F(ThreadNetworkTest, SetOperationalNetworkInvalidParameter)
 453 {
 454         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 455                 thread_set_operational_network(instance, network));
 456 }
 457
 458 TEST_F(ThreadNetworkTest, SetOperationalNetworkErrorNone)
 459 {
 460         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 461         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 462         EXPECT_EQ(THREAD_ERROR_NONE,
 463                 thread_set_operational_network(instance, network));
 464 }
 465
 466 TEST_F(ThreadNetworkTest, UnsetOperationalNetworkNotInitialized)
 467 {
 468         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 469         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 470                 thread_unset_operational_network(instance));
 471 }
 472
 473 TEST_F(ThreadNetworkTest, UnsetOperationalNetworkInvalidParameter)
 474 {
 475         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 476                 thread_unset_operational_network(instance));
 477 }
 478
 479 TEST_F(ThreadNetworkTest, UnsetOperationalNetworkErrorNone)
 480 {
 481         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 482         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 483         EXPECT_EQ(THREAD_ERROR_NONE,
 484                 thread_set_operational_network(instance, network));
 485         EXPECT_EQ(THREAD_ERROR_NONE,
 486                 thread_unset_operational_network(instance));
 487 }