tests/unittest/thread-unittest-br.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 class ThreadBRTest : public ::testing::Test
  24 {
  25 public:
  26         enum class RouteInfo {
  27                 kIpv6Prefix,
  28                 kRloc16,
  29                 kPreference,
  30                 kStable,
  31                 kDeviceNexthop,
  32         };
  33
  34         uint8_t ipv6Prefix[THREAD_IPV6_PREFIX_SIZE];
  35         uint8_t ipv6PrefixLen;
  36         uint16_t rloc16;
  37         uint8_t preference;
  38         bool isStable;
  39         bool isDeviceNextHop;
  40
  41         uint8_t onmeshIpv6Prefix[THREAD_IPV6_PREFIX_SIZE];
  42         uint8_t onmeshIpv6PrefixLen;
  43         bool preferred;
  44         bool slaac;
  45         bool dhcp;
  46         bool configure;
  47         bool defaultRoute;
  48         bool onMesh;
  49         bool stable;
  50         bool ndDns;
  51         bool dp;
  52
  53         thread_instance_h instance;
  54         thread_route_info_h routeInfo;
  55         thread_onmesh_prefix_info_h onmeshPrefix;
  56
  57 public:
  58         static bool GetOnmeshPrefixesCallback(int total,
  59                 thread_onmesh_prefix_info_h onmesh_prefix_info, void *user_data)
  60         {
  61                 return true;
  62         };
  63
  64         static bool GetExternalRoutesCallback(int total,
  65                 thread_route_info_h route_info, void *user_data)
  66         {
  67                 RouteInfo routeInfo = static_cast<RouteInfo>(GPOINTER_TO_UINT(user_data));
  68
  69                 switch (routeInfo) {
  70                 case RouteInfo::kIpv6Prefix:
  71                         {
  72                                 uint8_t ipv6Prefix[THREAD_IPV6_ADDRESS_SIZE];
  73                                 uint8_t ipv6PrefixLen;
  74                                 EXPECT_EQ(THREAD_ERROR_NONE, thread_br_get_ipv6_prefix(route_info, ipv6Prefix, &ipv6PrefixLen));
  75                         }
  76                         break;
  77                 case RouteInfo::kRloc16:
  78                         {
  79                                 uint16_t rloc16;
  80                                 EXPECT_EQ(THREAD_ERROR_NONE, thread_br_get_rloc16(route_info, &rloc16));
  81                         }
  82                         break;
  83                 case RouteInfo::kPreference:
  84                         {
  85                                 int8_t preference;
  86                                 EXPECT_EQ(THREAD_ERROR_NONE, thread_br_get_preference(route_info, &preference));
  87                         }
  88                         break;
  89                 case RouteInfo::kStable:
  90                         {
  91                                 bool isStable;
  92                                 EXPECT_EQ(THREAD_ERROR_NONE, thread_br_check_stable(route_info, &isStable));
  93                         }
  94                         break;
  95                 case RouteInfo::kDeviceNexthop:
  96                         {
  97                                 bool isDeviceNexthop;
  98                                 EXPECT_EQ(THREAD_ERROR_NONE, thread_br_check_device_nexthop(route_info, &isDeviceNexthop));
  99                         }
 100                         break;
 101                 default:
 102                         break;
 103                 }
 104
 105                 return true;
 106         };
 107
 108 protected:
 109         void SetUp() override
 110         {
 111                 thread_initialize();
 112                 instance = nullptr;
 113                 makeIpv6Prefix();
 114                 ipv6PrefixLen = THREAD_IPV6_PREFIX_SIZE;
 115                 rloc16 = 0xb801;
 116                 preference = 0;
 117                 isStable = TRUE;
 118                 isDeviceNextHop = TRUE;
 119                 makeOnmeshIpv6Prefix();
 120                 onmeshIpv6PrefixLen = THREAD_IPV6_PREFIX_SIZE;
 121                 preferred = true;
 122                 slaac = true;
 123                 dhcp = true;
 124                 configure = true;
 125                 defaultRoute = true;
 126                 onMesh = true;
 127                 stable = true;
 128         }
 129
 130         void TearDown() override
 131         {
 132                 if (instance)
 133                 {
 134                         if (onmeshPrefix)
 135                                 thread_onmesh_prefix_destroy(instance, onmeshPrefix);
 136                         thread_br_disable(instance);
 137                         thread_disable(instance);
 138                 }
 139                 thread_deinitialize();
 140         }
 141
 142 private:
 143         void makeIpv6Prefix()
 144         {
 145                 struct in6_addr result;
 146                 inet_pton(AF_INET6, DUMMY_IPV6_ADDRESS, &result);
 147                 memcpy(ipv6Prefix, result.s6_addr,
 148                         THREAD_IPV6_PREFIX_SIZE * sizeof(uint8_t));
 149         }
 150
 151         void makeOnmeshIpv6Prefix()
 152         {
 153                 struct in6_addr result;
 154                 inet_pton(AF_INET6, DUMMY_IPV6_ADDRESS, &result);
 155                 memcpy(ipv6Prefix, result.s6_addr,
 156                         THREAD_IPV6_PREFIX_SIZE * sizeof(uint8_t));
 157         }
 158 };
 159
 160 TEST_F(ThreadBRTest, BREnableNotInitialized)
 161 {
 162         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 163         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_br_enable(instance));
 164 }
 165
 166 TEST_F(ThreadBRTest, BREnableInvalidParameter)
 167 {
 168         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_br_enable(instance));
 169 }
 170
 171 TEST_F(ThreadBRTest, BREnableErrorNone)
 172 {
 173         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 174         EXPECT_EQ(THREAD_ERROR_NONE, thread_br_enable(instance));
 175 }
 176
 177 TEST_F(ThreadBRTest, BRDisableNotInitialized)
 178 {
 179         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 180         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_br_disable(instance));
 181 }
 182
 183 TEST_F(ThreadBRTest, BRDisableInvalidParameter)
 184 {
 185         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_br_disable(instance));
 186 }
 187
 188 TEST_F(ThreadBRTest, BRDisableErrorNone)
 189 {
 190         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 191         EXPECT_EQ(THREAD_ERROR_NONE, thread_br_enable(instance));
 192         EXPECT_EQ(THREAD_ERROR_NONE, thread_br_disable(instance));
 193 }
 194
 195 TEST_F(ThreadBRTest, BRGetExternalRoutesNotInitialized)
 196 {
 197         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 198         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 199                 thread_br_get_external_routes(instance, GetExternalRoutesCallback, nullptr));
 200 }
 201
 202 TEST_F(ThreadBRTest, BRGetExternalRoutesInvalidParameter)
 203 {
 204         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 205                 thread_br_get_external_routes(instance, GetExternalRoutesCallback, nullptr));
 206 }
 207
 208 TEST_F(ThreadBRTest, BRGetExternalRoutesNotEnabled)
 209 {
 210         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 211         EXPECT_EQ(THREAD_ERROR_NOT_ENABLED,
 212                 thread_br_get_external_routes(instance, GetExternalRoutesCallback, nullptr));
 213 }
 214
 215 TEST_F(ThreadBRTest, BRGetExternalRoutesErrorNone)
 216 {
 217         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 218         EXPECT_EQ(THREAD_ERROR_NONE, thread_br_enable(instance));
 219         EXPECT_EQ(THREAD_ERROR_NONE,
 220                 thread_br_get_external_routes(instance, GetExternalRoutesCallback, nullptr));
 221 }
 222
 223 TEST_F(ThreadBRTest, BRGetIpv6PrefixErrorNone)
 224 {
 225         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 226         EXPECT_EQ(THREAD_ERROR_NONE, thread_br_enable(instance));
 227         EXPECT_EQ(THREAD_ERROR_NONE,
 228                 thread_br_get_external_routes(instance, GetExternalRoutesCallback,
 229                 GUINT_TO_POINTER(static_cast<guint>(RouteInfo::kIpv6Prefix))));
 230 }
 231
 232 TEST_F(ThreadBRTest, BRGetRloc16ErrorNone)
 233 {
 234         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 235         EXPECT_EQ(THREAD_ERROR_NONE, thread_br_enable(instance));
 236         EXPECT_EQ(THREAD_ERROR_NONE,
 237                 thread_br_get_external_routes(instance, GetExternalRoutesCallback,
 238                 GUINT_TO_POINTER(static_cast<guint>(RouteInfo::kRloc16))));
 239 }
 240
 241 TEST_F(ThreadBRTest, BRGetPreferenceErrorNone)
 242 {
 243         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 244         EXPECT_EQ(THREAD_ERROR_NONE, thread_br_enable(instance));
 245         EXPECT_EQ(THREAD_ERROR_NONE,
 246                 thread_br_get_external_routes(instance, GetExternalRoutesCallback,
 247                 GUINT_TO_POINTER(static_cast<guint>(RouteInfo::kPreference))));
 248 }
 249
 250 TEST_F(ThreadBRTest, BRCheckStableErrorNone)
 251 {
 252         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 253         EXPECT_EQ(THREAD_ERROR_NONE, thread_br_enable(instance));
 254         EXPECT_EQ(THREAD_ERROR_NONE,
 255                 thread_br_get_external_routes(instance, GetExternalRoutesCallback,
 256                 GUINT_TO_POINTER(static_cast<guint>(RouteInfo::kStable))));
 257 }
 258
 259 TEST_F(ThreadBRTest, BRCheckDeviceNexthopErrorNone)
 260 {
 261         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 262         EXPECT_EQ(THREAD_ERROR_NONE, thread_br_enable(instance));
 263         EXPECT_EQ(THREAD_ERROR_NONE,
 264                 thread_br_get_external_routes(instance, GetExternalRoutesCallback,
 265                 GUINT_TO_POINTER(static_cast<guint>(RouteInfo::kDeviceNexthop))));
 266 }
 267
 268 TEST_F(ThreadBRTest, BRAddExternalRouteNotInitialized)
 269 {
 270         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 271         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 272                 thread_br_add_external_route(instance, ipv6Prefix, ipv6PrefixLen,
 273                 rloc16, preference, isStable, isDeviceNextHop, &routeInfo));
 274 }
 275
 276 TEST_F(ThreadBRTest, BRAddExternalRouteInvalidParameter)
 277 {
 278         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 279                 thread_br_add_external_route(instance, ipv6Prefix, ipv6PrefixLen,
 280                 rloc16, preference, isStable, isDeviceNextHop, &routeInfo));
 281 }
 282
 283 TEST_F(ThreadBRTest, BRAddExternalRouteNotEnabled)
 284 {
 285         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 286         EXPECT_EQ(THREAD_ERROR_NOT_ENABLED,
 287                 thread_br_add_external_route(instance, ipv6Prefix, ipv6PrefixLen,
 288                 rloc16, preference, isStable, isDeviceNextHop, &routeInfo));
 289 }
 290
 291 TEST_F(ThreadBRTest, BRAddExternalRouteErrorNone)
 292 {
 293         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 294         EXPECT_EQ(THREAD_ERROR_NONE, thread_br_enable(instance));
 295         EXPECT_EQ(THREAD_ERROR_NONE,
 296                 thread_br_add_external_route(instance, ipv6Prefix, ipv6PrefixLen,
 297                 rloc16, preference, isStable, isDeviceNextHop, &routeInfo));
 298 }
 299
 300 TEST_F(ThreadBRTest, BRRemoveExternalRouteNotInitialized)
 301 {
 302         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 303         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 304                 thread_br_remove_external_route(instance, routeInfo));
 305 }
 306
 307 TEST_F(ThreadBRTest, BRRemoveExternalRouteInvalidParameter)
 308 {
 309         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 310                 thread_br_remove_external_route(instance, routeInfo));
 311 }
 312
 313 TEST_F(ThreadBRTest, BRRemoveExternalRouteNotEnabled)
 314 {
 315         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 316         EXPECT_EQ(THREAD_ERROR_NOT_ENABLED,
 317                 thread_br_remove_external_route(instance, routeInfo));
 318 }
 319
 320 TEST_F(ThreadBRTest, BRRemoveExternalRouteErrorNone)
 321 {
 322         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 323         EXPECT_EQ(THREAD_ERROR_NONE, thread_br_enable(instance));
 324         EXPECT_EQ(THREAD_ERROR_NONE,
 325                 thread_br_add_external_route(instance, ipv6Prefix, ipv6PrefixLen,
 326                 rloc16, preference, isStable, isDeviceNextHop, &routeInfo));
 327         EXPECT_EQ(THREAD_ERROR_NONE,
 328                 thread_br_remove_external_route(instance, routeInfo));
 329 }
 330
 331 TEST_F(ThreadBRTest, BRCreateOnmeshPrefixErrorNone)
 332 {
 333         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 334         EXPECT_EQ(THREAD_ERROR_NONE,
 335                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 336 }
 337
 338 TEST_F(ThreadBRTest, BRDestroyOnmeshPrefixErrorNone)
 339 {
 340         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 341         EXPECT_EQ(THREAD_ERROR_NONE,
 342                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 343         EXPECT_EQ(THREAD_ERROR_NONE,
 344                 thread_onmesh_prefix_destroy(instance, onmeshPrefix));
 345 }
 346
 347 TEST_F(ThreadBRTest, BRSetOnmeshIpv6PrefixErrorNone)
 348 {
 349         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 350         EXPECT_EQ(THREAD_ERROR_NONE,
 351                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 352         EXPECT_EQ(THREAD_ERROR_NONE,
 353                 thread_onmesh_prefix_set_ipv6_prefix(onmeshPrefix,
 354                         onmeshIpv6Prefix, onmeshIpv6PrefixLen));
 355 }
 356
 357 TEST_F(ThreadBRTest, BRGetOnmeshIpv6PrefixErrorNone)
 358 {
 359         uint8_t *ipv6Prefix = NULL;
 360         uint8_t ipv6PrefixLen;
 361
 362         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 363         EXPECT_EQ(THREAD_ERROR_NONE,
 364                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 365         EXPECT_EQ(THREAD_ERROR_NONE,
 366                 thread_onmesh_prefix_set_ipv6_prefix(onmeshPrefix,
 367                         onmeshIpv6Prefix, onmeshIpv6PrefixLen));
 368         EXPECT_EQ(THREAD_ERROR_NONE,
 369                 thread_onmesh_prefix_get_ipv6_prefix(onmeshPrefix,
 370                         &ipv6Prefix, &ipv6PrefixLen));
 371         g_free(ipv6Prefix);
 372 }
 373
 374 TEST_F(ThreadBRTest, BRSetOnmeshPreferenceErrorNone)
 375 {
 376         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 377         EXPECT_EQ(THREAD_ERROR_NONE,
 378                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 379         EXPECT_EQ(THREAD_ERROR_NONE,
 380                 thread_onmesh_prefix_set_preference(onmeshPrefix, preference));
 381 }
 382
 383 TEST_F(ThreadBRTest, BRGetOnmeshPreferenceErrorNone)
 384 {
 385         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 386         EXPECT_EQ(THREAD_ERROR_NONE,
 387                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 388         EXPECT_EQ(THREAD_ERROR_NONE,
 389                 thread_onmesh_prefix_set_preference(onmeshPrefix, preference));
 390         EXPECT_EQ(THREAD_ERROR_NONE,
 391                 thread_onmesh_prefix_get_preference(onmeshPrefix, &preference));
 392 }
 393
 394 TEST_F(ThreadBRTest, BRSetOnmeshRlocErrorNone)
 395 {
 396         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 397         EXPECT_EQ(THREAD_ERROR_NONE,
 398                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 399         EXPECT_EQ(THREAD_ERROR_NONE,
 400                 thread_onmesh_prefix_set_rloc(onmeshPrefix, rloc16));
 401 }
 402
 403 TEST_F(ThreadBRTest, BRGetOnmeshRlocErrorNone)
 404 {
 405         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 406         EXPECT_EQ(THREAD_ERROR_NONE,
 407                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 408         EXPECT_EQ(THREAD_ERROR_NONE,
 409                 thread_onmesh_prefix_set_rloc(onmeshPrefix, rloc16));
 410         EXPECT_EQ(THREAD_ERROR_NONE,
 411                 thread_onmesh_prefix_get_rloc(onmeshPrefix, &rloc16));
 412 }
 413
 414 TEST_F(ThreadBRTest, BRSetOnmeshPreferredErrorNone)
 415 {
 416         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 417         EXPECT_EQ(THREAD_ERROR_NONE,
 418                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 419         EXPECT_EQ(THREAD_ERROR_NONE,
 420                 thread_onmesh_prefix_set_preferred(onmeshPrefix, preferred));
 421 }
 422
 423 TEST_F(ThreadBRTest, BRGetOnmeshPreferredErrorNone)
 424 {
 425         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 426         EXPECT_EQ(THREAD_ERROR_NONE,
 427                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 428         EXPECT_EQ(THREAD_ERROR_NONE,
 429                 thread_onmesh_prefix_set_preferred(onmeshPrefix, preferred));
 430         EXPECT_EQ(THREAD_ERROR_NONE,
 431                 thread_onmesh_prefix_get_preferred(onmeshPrefix, &preferred));
 432 }
 433
 434 TEST_F(ThreadBRTest, BRSetOnmeshSlaacErrorNone)
 435 {
 436         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 437         EXPECT_EQ(THREAD_ERROR_NONE,
 438                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 439         EXPECT_EQ(THREAD_ERROR_NONE,
 440                 thread_onmesh_prefix_set_slaac(onmeshPrefix, slaac));
 441 }
 442
 443 TEST_F(ThreadBRTest, BRGetOnmeshSlaacErrorNone)
 444 {
 445         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 446         EXPECT_EQ(THREAD_ERROR_NONE,
 447                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 448         EXPECT_EQ(THREAD_ERROR_NONE,
 449                 thread_onmesh_prefix_set_slaac(onmeshPrefix, slaac));
 450         EXPECT_EQ(THREAD_ERROR_NONE,
 451                 thread_onmesh_prefix_get_slaac(onmeshPrefix, &slaac));
 452 }
 453
 454 TEST_F(ThreadBRTest, BRSetOnmeshDhcpErrorNone)
 455 {
 456         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 457         EXPECT_EQ(THREAD_ERROR_NONE,
 458                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 459         EXPECT_EQ(THREAD_ERROR_NONE,
 460                 thread_onmesh_prefix_set_dhcp(onmeshPrefix, dhcp));
 461 }
 462
 463 TEST_F(ThreadBRTest, BRGetOnmeshDhcpErrorNone)
 464 {
 465         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 466         EXPECT_EQ(THREAD_ERROR_NONE,
 467                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 468         EXPECT_EQ(THREAD_ERROR_NONE,
 469                 thread_onmesh_prefix_set_dhcp(onmeshPrefix, dhcp));
 470         EXPECT_EQ(THREAD_ERROR_NONE,
 471                 thread_onmesh_prefix_get_dhcp(onmeshPrefix, &dhcp));
 472 }
 473
 474 TEST_F(ThreadBRTest, BRSetOnmeshConfigureErrorNone)
 475 {
 476         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 477         EXPECT_EQ(THREAD_ERROR_NONE,
 478                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 479         EXPECT_EQ(THREAD_ERROR_NONE,
 480                 thread_onmesh_prefix_set_configure(onmeshPrefix, configure));
 481 }
 482
 483 TEST_F(ThreadBRTest, BRGetOnmeshConfigureErrorNone)
 484 {
 485         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 486         EXPECT_EQ(THREAD_ERROR_NONE,
 487                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 488         EXPECT_EQ(THREAD_ERROR_NONE,
 489                 thread_onmesh_prefix_set_configure(onmeshPrefix, configure));
 490         EXPECT_EQ(THREAD_ERROR_NONE,
 491                 thread_onmesh_prefix_get_configure(onmeshPrefix, &configure));
 492 }
 493
 494 TEST_F(ThreadBRTest, BRSetOnmeshDefaultRouteErrorNone)
 495 {
 496         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 497         EXPECT_EQ(THREAD_ERROR_NONE,
 498                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 499         EXPECT_EQ(THREAD_ERROR_NONE,
 500                 thread_onmesh_prefix_set_default_route(onmeshPrefix, defaultRoute));
 501 }
 502
 503 TEST_F(ThreadBRTest, BRGetOnmeshDefaultRouteErrorNone)
 504 {
 505         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 506         EXPECT_EQ(THREAD_ERROR_NONE,
 507                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 508         EXPECT_EQ(THREAD_ERROR_NONE,
 509                 thread_onmesh_prefix_set_default_route(onmeshPrefix, defaultRoute));
 510         EXPECT_EQ(THREAD_ERROR_NONE,
 511                 thread_onmesh_prefix_get_default_route(onmeshPrefix, &defaultRoute));
 512 }
 513
 514 TEST_F(ThreadBRTest, BRSetOnmeshOnMeshErrorNone)
 515 {
 516         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 517         EXPECT_EQ(THREAD_ERROR_NONE,
 518                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 519         EXPECT_EQ(THREAD_ERROR_NONE,
 520                 thread_onmesh_prefix_set_on_mesh(onmeshPrefix, onMesh));
 521 }
 522
 523 TEST_F(ThreadBRTest, BRGetOnmeshOnMeshErrorNone)
 524 {
 525         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 526         EXPECT_EQ(THREAD_ERROR_NONE,
 527                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 528         EXPECT_EQ(THREAD_ERROR_NONE,
 529                 thread_onmesh_prefix_set_on_mesh(onmeshPrefix, onMesh));
 530         EXPECT_EQ(THREAD_ERROR_NONE,
 531                 thread_onmesh_prefix_get_on_mesh(onmeshPrefix, &onMesh));
 532 }
 533
 534 TEST_F(ThreadBRTest, BRSetOnmeshStableErrorNone)
 535 {
 536         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 537         EXPECT_EQ(THREAD_ERROR_NONE,
 538                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 539         EXPECT_EQ(THREAD_ERROR_NONE,
 540                 thread_onmesh_prefix_set_stable(onmeshPrefix, stable));
 541 }
 542
 543 TEST_F(ThreadBRTest, BRGetOnmeshStableErrorNone)
 544 {
 545         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 546         EXPECT_EQ(THREAD_ERROR_NONE,
 547                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 548         EXPECT_EQ(THREAD_ERROR_NONE,
 549                 thread_onmesh_prefix_set_stable(onmeshPrefix, stable));
 550         EXPECT_EQ(THREAD_ERROR_NONE,
 551                 thread_onmesh_prefix_get_stable(onmeshPrefix, &stable));
 552 }
 553
 554 TEST_F(ThreadBRTest, BRSetOnmeshNdDnsErrorNone)
 555 {
 556         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 557         EXPECT_EQ(THREAD_ERROR_NONE,
 558                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 559         EXPECT_EQ(THREAD_ERROR_NONE,
 560                 thread_onmesh_prefix_set_nd_dns(onmeshPrefix, ndDns));
 561 }
 562
 563 TEST_F(ThreadBRTest, BRGetOnmeshNdDnsErrorNone)
 564 {
 565         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 566         EXPECT_EQ(THREAD_ERROR_NONE,
 567                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 568         EXPECT_EQ(THREAD_ERROR_NONE,
 569                 thread_onmesh_prefix_set_nd_dns(onmeshPrefix, ndDns));
 570         EXPECT_EQ(THREAD_ERROR_NONE,
 571                 thread_onmesh_prefix_get_nd_dns(onmeshPrefix, &ndDns));
 572 }
 573
 574 TEST_F(ThreadBRTest, BRSetOnmeshDpErrorNone)
 575 {
 576         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 577         EXPECT_EQ(THREAD_ERROR_NONE,
 578                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 579         EXPECT_EQ(THREAD_ERROR_NONE,
 580                 thread_onmesh_prefix_set_dp(onmeshPrefix, dp));
 581 }
 582
 583 TEST_F(ThreadBRTest, BRGetOnmeshDpErrorNone)
 584 {
 585         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 586         EXPECT_EQ(THREAD_ERROR_NONE,
 587                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 588         EXPECT_EQ(THREAD_ERROR_NONE,
 589                 thread_onmesh_prefix_set_dp(onmeshPrefix, dp));
 590         EXPECT_EQ(THREAD_ERROR_NONE,
 591                 thread_onmesh_prefix_get_dp(onmeshPrefix, &dp));
 592 }
 593
 594 TEST_F(ThreadBRTest, BRAddOnmeshPrefixNotInitialized)
 595 {
 596         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 597         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 598                 thread_br_add_onmesh_prefix(instance, onmeshPrefix));
 599 }
 600
 601 TEST_F(ThreadBRTest, BRAddOnmeshPrefixInvalidParameter)
 602 {
 603         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 604                 thread_br_add_onmesh_prefix(instance, onmeshPrefix));
 605 }
 606
 607 TEST_F(ThreadBRTest, BRAddOnmeshPrefixNotEnabled)
 608 {
 609         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 610         EXPECT_EQ(THREAD_ERROR_NOT_ENABLED,
 611                 thread_br_add_onmesh_prefix(instance, onmeshPrefix));
 612 }
 613
 614 TEST_F(ThreadBRTest, BRAddOnmeshPrefixErrorNone)
 615 {
 616         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 617         EXPECT_EQ(THREAD_ERROR_NONE, thread_br_enable(instance));
 618         EXPECT_EQ(THREAD_ERROR_NONE,
 619                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 620         EXPECT_EQ(THREAD_ERROR_NONE,
 621                 thread_br_add_onmesh_prefix(instance, onmeshPrefix));
 622 }
 623
 624 TEST_F(ThreadBRTest, BRGetOnmeshPrefixesNotInitialized)
 625 {
 626         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 627         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 628                 thread_br_get_onmesh_prefixes(instance,
 629                         GetOnmeshPrefixesCallback, nullptr));
 630 }
 631
 632 TEST_F(ThreadBRTest, BRGetOnmeshPrefixesInvalidParameter)
 633 {
 634         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 635                 thread_br_get_onmesh_prefixes(instance,
 636                         GetOnmeshPrefixesCallback, nullptr));
 637 }
 638
 639 TEST_F(ThreadBRTest, BRGetOnmeshPrefixesNotEnabled)
 640 {
 641         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 642         EXPECT_EQ(THREAD_ERROR_NOT_ENABLED,
 643                 thread_br_get_onmesh_prefixes(instance,
 644                         GetOnmeshPrefixesCallback, nullptr));
 645 }
 646
 647 TEST_F(ThreadBRTest, BRGetOnmeshPrefixesErrorNone)
 648 {
 649         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 650         EXPECT_EQ(THREAD_ERROR_NONE, thread_br_enable(instance));
 651         EXPECT_EQ(THREAD_ERROR_NONE,
 652                 thread_br_get_onmesh_prefixes(instance,
 653                         GetOnmeshPrefixesCallback, nullptr));
 654 }
 655
 656 TEST_F(ThreadBRTest, BRRemoveOnmeshPrefixNotInitialized)
 657 {
 658         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 659         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 660                 thread_br_remove_onmesh_prefix(instance, onmeshPrefix));
 661 }
 662
 663 TEST_F(ThreadBRTest, BRRemoveOnmeshPrefixInvalidParameter)
 664 {
 665         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 666                 thread_br_remove_onmesh_prefix(instance, onmeshPrefix));
 667 }
 668
 669 TEST_F(ThreadBRTest, BRRemoveOnmeshPrefixNotEnabled)
 670 {
 671         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 672         EXPECT_EQ(THREAD_ERROR_NOT_ENABLED,
 673                 thread_br_remove_onmesh_prefix(instance, onmeshPrefix));
 674 }
 675
 676 TEST_F(ThreadBRTest, BRRemoveOnmeshPrefixErrorNone)
 677 {
 678         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 679         EXPECT_EQ(THREAD_ERROR_NONE, thread_br_enable(instance));
 680         EXPECT_EQ(THREAD_ERROR_NONE,
 681                 thread_onmesh_prefix_create(instance, &onmeshPrefix));
 682         EXPECT_EQ(THREAD_ERROR_NONE,
 683                 thread_br_add_onmesh_prefix(instance, onmeshPrefix));
 684         EXPECT_EQ(THREAD_ERROR_NONE,
 685                 thread_br_remove_onmesh_prefix(instance, onmeshPrefix));
 686 }