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         const char *globalIpaddr;
  54
  55 public:
  56         static void getIpAddrCallback(int index, char* ipaddr,
  57                 thread_ipaddr_type_e ipaddr_type, void *user_data) {};
  58
  59 protected:
  60         void SetUp() override
  61         {
  62                 thread_initialize();
  63                 instance = nullptr;
  64                 network = nullptr;
  65                 operationalNetwork = nullptr;
  66                 snprintf(name, NETWORK_DATA_SIZE + 1, "Thread-test");
  67                 snprintf(key, NETWORK_DATA_SIZE + 1, "f780b002ec7d904c9995daaa78a50083");
  68                 snprintf(pskc, NETWORK_DATA_SIZE + 1, "ba473fecdb235d30bd65233e6089ee50");
  69                 channel = 0x07fff800;
  70                 extendedPanId = strtoull("18446744073709551615LL", nullptr, 10);
  71                 panId = 65535;
  72                 makeTlvsBuffer();
  73                 tlvsBufferLength = DUMMY_TLVS_SIZE;
  74                 makeIpv6Address();
  75         }
  76
  77         void TearDown() override
  78         {
  79                 if (instance)
  80                 {
  81                         if (network)
  82                         {
  83                                 thread_unset_operational_network(instance);
  84                                 thread_network_destroy(network);
  85                         }
  86                         thread_disable(instance);
  87                 }
  88
  89                 thread_deinitialize();
  90         }
  91
  92 private:
  93         void makeTlvsBuffer()
  94         {
  95                 for (int i = 0; i < DUMMY_TLVS_SIZE; ++i)
  96                 {
  97                         char subBuffer[3];
  98                         memcpy(subBuffer, &DUMMY_TLVS_STR[2 * i], 2);
  99                         subBuffer[2] = '\0';
 100                         tlvsBuffer[i] = (uint8_t)strtol(subBuffer, NULL, 16);
 101                 }
 102         }
 103
 104         void makeIpv6Address()
 105         {
 106                 struct in6_addr result;
 107                 inet_pton(AF_INET6, DUMMY_IPV6_ADDRESS, &result);
 108                 memcpy(ipv6Address, result.s6_addr,
 109                         THREAD_IPV6_PREFIX_SIZE * sizeof(uint8_t));
 110         }
 111 };
 112
 113 TEST_F(ThreadNetworkTest, SetActiveDatasetTlvsNotInitialized)
 114 {
 115         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 116         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 117                 thread_network_set_active_dataset_tlvs(instance, tlvsBuffer, tlvsBufferLength));
 118 }
 119
 120 TEST_F(ThreadNetworkTest, SetActiveDatasetTlvsInvalidParameter)
 121 {
 122         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 123                 thread_network_set_active_dataset_tlvs(instance, tlvsBuffer, tlvsBufferLength));
 124 }
 125
 126 TEST_F(ThreadNetworkTest, SetActiveDatasetTlvsErrorNone)
 127 {
 128         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 129         EXPECT_EQ(THREAD_ERROR_NONE,
 130                 thread_network_set_active_dataset_tlvs(instance, tlvsBuffer, tlvsBufferLength));
 131 }
 132
 133 TEST_F(ThreadNetworkTest, GetActiveDatasetTlvsNotInitialized)
 134 {
 135         uint8_t *tlvs_buffer = NULL;
 136         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 137         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 138                 thread_network_get_active_dataset_tlvs(instance, &tlvs_buffer, &tlvsBufferLength));
 139         g_free(tlvs_buffer);
 140 }
 141
 142 TEST_F(ThreadNetworkTest, GetActiveDatasetTlvsInvalidParameter)
 143 {
 144         uint8_t *tlvs_buffer = NULL;
 145         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 146                 thread_network_get_active_dataset_tlvs(instance, &tlvs_buffer, &tlvsBufferLength));
 147         g_free(tlvs_buffer);
 148 }
 149
 150 TEST_F(ThreadNetworkTest, GetActiveDatasetTlvsErrorNone)
 151 {
 152         uint8_t *tlvs_buffer = NULL;
 153         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 154         EXPECT_EQ(THREAD_ERROR_NONE,
 155                 thread_network_get_active_dataset_tlvs(instance, &tlvs_buffer, &tlvsBufferLength));
 156         g_free(tlvs_buffer);
 157 }
 158
 159 TEST_F(ThreadNetworkTest, AttachNotInitialized)
 160 {
 161         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 162         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_network_attach(instance));
 163 }
 164
 165 TEST_F(ThreadNetworkTest, AttachInvalidParameter)
 166 {
 167         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_network_attach(instance));
 168 }
 169
 170 TEST_F(ThreadNetworkTest, AttachErrorNone)
 171 {
 172         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 173         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_attach(instance));
 174 }
 175
 176 TEST_F(ThreadNetworkTest, DetachNotInitialized)
 177 {
 178         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 179         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_network_detach(instance));
 180 }
 181
 182 TEST_F(ThreadNetworkTest, DetachInvalidParameter)
 183 {
 184         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_network_detach(instance));
 185 }
 186
 187 TEST_F(ThreadNetworkTest, DetachErrorNone)
 188 {
 189         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 190         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 191         EXPECT_EQ(THREAD_ERROR_NONE,
 192                 thread_set_operational_network(instance, network));
 193         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_detach(instance));
 194 }
 195
 196 TEST_F(ThreadNetworkTest, GetIpAddrNotInitialized)
 197 {
 198         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 199         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 200                 thread_get_ipaddr(instance, getIpAddrCallback,
 201                         THREAD_IPADDR_TYPE_ALL, nullptr));
 202 }
 203
 204 TEST_F(ThreadNetworkTest, GetIpAddrInvalidParameter)
 205 {
 206         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 207                 thread_get_ipaddr(instance, getIpAddrCallback,
 208                         THREAD_IPADDR_TYPE_ALL, nullptr));
 209 }
 210
 211 TEST_F(ThreadNetworkTest, GetIpAddrErrorNone)
 212 {
 213         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 214         EXPECT_EQ(THREAD_ERROR_NONE,
 215                 thread_get_ipaddr(instance, getIpAddrCallback,
 216                         THREAD_IPADDR_TYPE_ALL, nullptr));
 217         EXPECT_EQ(THREAD_ERROR_NONE,
 218                 thread_get_ipaddr(instance, getIpAddrCallback,
 219                         THREAD_IPADDR_TYPE_LINK_LOCAL, nullptr));
 220         EXPECT_EQ(THREAD_ERROR_NONE,
 221                 thread_get_ipaddr(instance, getIpAddrCallback,
 222                         THREAD_IPADDR_TYPE_RLOC, nullptr));
 223         EXPECT_EQ(THREAD_ERROR_NONE,
 224                 thread_get_ipaddr(instance, getIpAddrCallback,
 225                         THREAD_IPADDR_TYPE_MLEID, nullptr));
 226 }
 227
 228 TEST_F(ThreadNetworkTest, AddIpAddrNotInitialized)
 229 {
 230         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 231         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 232                 thread_add_ipaddr(instance, ipv6Address));
 233 }
 234
 235 TEST_F(ThreadNetworkTest, AddIpAddrInvalidParameter)
 236 {
 237         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 238                 thread_add_ipaddr(instance, ipv6Address));
 239 }
 240
 241 TEST_F(ThreadNetworkTest, AddIpAddrErrorNone)
 242 {
 243         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 244         EXPECT_EQ(THREAD_ERROR_NONE,
 245                 thread_add_ipaddr(instance, ipv6Address));
 246 }
 247
 248 TEST_F(ThreadNetworkTest, RemoveIpAddrNotInitialized)
 249 {
 250         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 251         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 252                 thread_remove_ipaddr(instance, ipv6Address));
 253 }
 254
 255 TEST_F(ThreadNetworkTest, RemoveIpAddrInvalidParameter)
 256 {
 257         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 258                 thread_remove_ipaddr(instance, ipv6Address));
 259 }
 260
 261 TEST_F(ThreadNetworkTest, RemoveIpAddrErrorNone)
 262 {
 263         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 264         EXPECT_EQ(THREAD_ERROR_NONE,
 265                 thread_remove_ipaddr(instance, ipv6Address));
 266 }
 267
 268 TEST_F(ThreadNetworkTest, GetGlobalIpAddrNotInitialized)
 269 {
 270         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 271         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 272                 thread_get_global_ipaddr(instance, &globalIpaddr));
 273 }
 274
 275 TEST_F(ThreadNetworkTest, GetGlobalIpAddrInvalidParameter)
 276 {
 277         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 278                 thread_get_global_ipaddr(instance, nullptr));
 279 }
 280
 281 TEST_F(ThreadNetworkTest, GetGlobalIpAddrErrorNone)
 282 {
 283         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 284         EXPECT_EQ(THREAD_ERROR_NONE,
 285                 thread_get_global_ipaddr(instance, &globalIpaddr));
 286         g_free((char *)globalIpaddr);
 287 }
 288
 289 TEST_F(ThreadNetworkTest, GetPanIdNotInitialized)
 290 {
 291         uint16_t panid;
 292         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 293         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 294                 thread_network_get_panid(instance, &panid));
 295 }
 296
 297 TEST_F(ThreadNetworkTest, GetPanIdInvalidParameter)
 298 {
 299         uint16_t panid;
 300         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 301                 thread_network_get_panid(instance, &panid));
 302 }
 303
 304 TEST_F(ThreadNetworkTest, GetPanIdErrorNone)
 305 {
 306         uint16_t panid;
 307         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 308         EXPECT_EQ(THREAD_ERROR_NONE,
 309                 thread_network_set_active_dataset_tlvs(instance, tlvsBuffer, tlvsBufferLength));
 310         EXPECT_EQ(THREAD_ERROR_NONE,
 311                 thread_network_get_panid(instance, &panid));
 312 }
 313
 314 TEST_F(ThreadNetworkTest, CreateNotInitialized)
 315 {
 316         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 317         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_network_create(&network));
 318 }
 319
 320 TEST_F(ThreadNetworkTest, CreateInvalidParameter)
 321 {
 322         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_network_create(nullptr));
 323 }
 324
 325 TEST_F(ThreadNetworkTest, CreateErrorNone)
 326 {
 327         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 328 }
 329
 330 TEST_F(ThreadNetworkTest, DestroyNotInitialized)
 331 {
 332         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 333         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_network_destroy(network));
 334 }
 335
 336 TEST_F(ThreadNetworkTest, DestroyInvalidParameter)
 337 {
 338         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_network_destroy(nullptr));
 339 }
 340
 341 TEST_F(ThreadNetworkTest, DestroyErrorNone)
 342 {
 343         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 344         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_destroy(network));
 345 }
 346
 347 TEST_F(ThreadNetworkTest, SetNameNotInitialized)
 348 {
 349         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 350         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 351                 thread_network_set_name(network, NETWORK_DUMMY_NAME));
 352 }
 353
 354 TEST_F(ThreadNetworkTest, SetNameInvalidParameter)
 355 {
 356         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 357                 thread_network_set_name(nullptr, NETWORK_DUMMY_NAME));
 358 }
 359
 360 TEST_F(ThreadNetworkTest, SetNameErrorNone)
 361 {
 362         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 363         EXPECT_EQ(THREAD_ERROR_NONE,
 364                 thread_network_set_name(network, NETWORK_DUMMY_NAME));
 365 }
 366
 367 TEST_F(ThreadNetworkTest, SetKeyNotInitialized)
 368 {
 369         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 370         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 371                 thread_network_set_key(network, NETWORK_DUMMY_KEY));
 372 }
 373
 374 TEST_F(ThreadNetworkTest, SetKeyInvalidParameter)
 375 {
 376         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 377                 thread_network_set_key(nullptr, NETWORK_DUMMY_KEY));
 378 }
 379
 380 TEST_F(ThreadNetworkTest, SetKeyErrorNone)
 381 {
 382         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 383         EXPECT_EQ(THREAD_ERROR_NONE,
 384                 thread_network_set_key(network, NETWORK_DUMMY_KEY));
 385 }
 386
 387 TEST_F(ThreadNetworkTest, SetPskcNotInitialized)
 388 {
 389         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 390         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 391                 thread_network_set_pskc(network, NETWORK_DUMMY_PSKC));
 392 }
 393
 394 TEST_F(ThreadNetworkTest, SetPskcInvalidParameter)
 395 {
 396         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 397                 thread_network_set_pskc(nullptr, NETWORK_DUMMY_PSKC));
 398 }
 399
 400 TEST_F(ThreadNetworkTest, SetPskcErrorNone)
 401 {
 402         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 403         EXPECT_EQ(THREAD_ERROR_NONE,
 404                 thread_network_set_pskc(network, NETWORK_DUMMY_PSKC));
 405 }
 406
 407 TEST_F(ThreadNetworkTest, SetChannelNotInitialized)
 408 {
 409         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 410         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 411                 thread_network_set_channel(network, NETWORK_DUMMY_CHANNEL));
 412 }
 413
 414 TEST_F(ThreadNetworkTest, SetChannelInvalidParameter)
 415 {
 416         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 417                 thread_network_set_channel(nullptr, NETWORK_DUMMY_CHANNEL));
 418 }
 419
 420 TEST_F(ThreadNetworkTest, SetChannelErrorNone)
 421 {
 422         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 423         EXPECT_EQ(THREAD_ERROR_NONE,
 424                 thread_network_set_channel(network, NETWORK_DUMMY_CHANNEL));
 425 }
 426
 427 TEST_F(ThreadNetworkTest, SetExtendedPanidNotInitialized)
 428 {
 429         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 430         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 431                 thread_network_set_extended_panid(network, NETWORK_DUMMY_EXTENDED_PANID));
 432 }
 433
 434 TEST_F(ThreadNetworkTest, SetExtendedPanidInvalidParameter)
 435 {
 436         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 437                 thread_network_set_extended_panid(nullptr, NETWORK_DUMMY_EXTENDED_PANID));
 438 }
 439
 440 TEST_F(ThreadNetworkTest, SetExtendedPanidErrorNone)
 441 {
 442         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 443         EXPECT_EQ(THREAD_ERROR_NONE,
 444                 thread_network_set_extended_panid(network, NETWORK_DUMMY_EXTENDED_PANID));
 445 }
 446
 447 TEST_F(ThreadNetworkTest, SetPanidNotInitialized)
 448 {
 449         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 450         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 451                 thread_network_set_panid(network, NETWORK_DUMMY_PANID));
 452 }
 453
 454 TEST_F(ThreadNetworkTest, SetPanidInvalidParameter)
 455 {
 456         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 457                 thread_network_set_panid(nullptr, NETWORK_DUMMY_PANID));
 458 }
 459
 460 TEST_F(ThreadNetworkTest, SetPanidErrorNone)
 461 {
 462         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 463         EXPECT_EQ(THREAD_ERROR_NONE,
 464                 thread_network_set_panid(network, NETWORK_DUMMY_PANID));
 465 }
 466
 467 TEST_F(ThreadNetworkTest, SetOperationalNetworkNotInitialized)
 468 {
 469         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 470         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 471                 thread_set_operational_network(instance, network));
 472 }
 473
 474 TEST_F(ThreadNetworkTest, SetOperationalNetworkInvalidParameter)
 475 {
 476         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 477                 thread_set_operational_network(instance, network));
 478 }
 479
 480 TEST_F(ThreadNetworkTest, SetOperationalNetworkErrorNone)
 481 {
 482         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 483         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 484         EXPECT_EQ(THREAD_ERROR_NONE,
 485                 thread_set_operational_network(instance, network));
 486 }
 487
 488 TEST_F(ThreadNetworkTest, UnsetOperationalNetworkNotInitialized)
 489 {
 490         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 491         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 492                 thread_unset_operational_network(instance));
 493 }
 494
 495 TEST_F(ThreadNetworkTest, UnsetOperationalNetworkInvalidParameter)
 496 {
 497         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 498                 thread_unset_operational_network(instance));
 499 }
 500
 501 TEST_F(ThreadNetworkTest, UnsetOperationalNetworkErrorNone)
 502 {
 503         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 504         EXPECT_EQ(THREAD_ERROR_NONE, thread_network_create(&network));
 505         EXPECT_EQ(THREAD_ERROR_NONE,
 506                 thread_set_operational_network(instance, network));
 507         EXPECT_EQ(THREAD_ERROR_NONE,
 508                 thread_unset_operational_network(instance));
 509 }