tests/unittest/thread-unittest-srp.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
  19 #include "thread.h"
  20 #include "mocks/thread-mock-dummy.h"
  21
  22 class ThreadSrpTest : public ::testing::Test
  23 {
  24 public:
  25         const char *hostName = "host_name";
  26
  27         const char *serviceName;
  28         const char *address;
  29         uint64_t port;
  30         bool isDeleted;
  31
  32         thread_instance_h instance;
  33
  34 protected:
  35         void SetUp() override
  36         {
  37                 thread_initialize();
  38                 instance = nullptr;
  39                 serviceName = nullptr;
  40                 address = nullptr;
  41                 port = 25540;
  42                 isDeleted = false;
  43         }
  44
  45         void TearDown() override
  46         {
  47                 if (instance)
  48                         thread_disable(instance);
  49                 thread_deinitialize();
  50         }
  51 };
  52
  53 TEST_F(ThreadSrpTest, ClientStartNotInitialized)
  54 {
  55         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
  56         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_srp_client_start(instance));
  57 }
  58
  59 TEST_F(ThreadSrpTest, ClientStartInvalidParameter)
  60 {
  61         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_srp_client_start(instance));
  62 }
  63
  64 TEST_F(ThreadSrpTest, ClientStartErrorNone)
  65 {
  66         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
  67         EXPECT_EQ(THREAD_ERROR_NONE, thread_srp_client_start(instance));
  68 }
  69
  70 TEST_F(ThreadSrpTest, ClientStopNotInitialized)
  71 {
  72         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
  73         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_srp_client_stop(instance));
  74 }
  75
  76 TEST_F(ThreadSrpTest, ClientStopInvalidParameter)
  77 {
  78         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_srp_client_stop(instance));
  79 }
  80
  81 TEST_F(ThreadSrpTest, ClientStopErrorNone)
  82 {
  83         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
  84         EXPECT_EQ(THREAD_ERROR_NONE, thread_srp_client_stop(instance));
  85 }
  86
  87 TEST_F(ThreadSrpTest, ClientRemoveHostNotInitialized)
  88 {
  89         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
  90         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_srp_client_remove_host(instance));
  91 }
  92
  93 TEST_F(ThreadSrpTest, ClientRemoveHostInvalidParameter)
  94 {
  95         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_srp_client_remove_host(instance));
  96 }
  97
  98 TEST_F(ThreadSrpTest, ClientRemoveHostErrorNone)
  99 {
 100         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 101         EXPECT_EQ(THREAD_ERROR_NONE, thread_srp_client_remove_host(instance));
 102 }
 103
 104 TEST_F(ThreadSrpTest, ClientSetHostNameNotInitialized)
 105 {
 106         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 107         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 108                 thread_srp_client_set_host_name(instance, hostName));
 109 }
 110
 111 TEST_F(ThreadSrpTest, ClientSetHostNameInvalidParameter)
 112 {
 113         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 114                 thread_srp_client_set_host_name(instance, hostName));
 115 }
 116
 117 TEST_F(ThreadSrpTest, ClientSetHostNameErrorNone)
 118 {
 119         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 120         EXPECT_EQ(THREAD_ERROR_NONE,
 121                 thread_srp_client_set_host_name(instance, hostName));
 122 }
 123
 124 TEST_F(ThreadSrpTest, ClientSetHostAddressNotInitialized)
 125 {
 126         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 127         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 128                 thread_srp_client_set_host_address(instance, DUMMY_IPV6_ADDRESS));
 129 }
 130
 131 TEST_F(ThreadSrpTest, ClientSetHostAddressInvalidParameter)
 132 {
 133         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 134                 thread_srp_client_set_host_address(instance, DUMMY_IPV6_ADDRESS));
 135 }
 136
 137 TEST_F(ThreadSrpTest, ClientSetHostAddressErrorNone)
 138 {
 139         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 140         EXPECT_EQ(THREAD_ERROR_NONE,
 141                 thread_srp_client_set_host_address(instance, DUMMY_IPV6_ADDRESS));
 142 }
 143
 144 TEST_F(ThreadSrpTest, ServerStartNotInitialized)
 145 {
 146         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 147         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_srp_server_start(instance));
 148 }
 149
 150 TEST_F(ThreadSrpTest, ServerStartInvalidParameter)
 151 {
 152         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_srp_server_start(instance));
 153 }
 154
 155 TEST_F(ThreadSrpTest, ServerStartErrorNone)
 156 {
 157         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 158         EXPECT_EQ(THREAD_ERROR_NONE, thread_srp_server_start(instance));
 159 }
 160
 161 TEST_F(ThreadSrpTest, ServerStopNotInitialized)
 162 {
 163         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 164         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED, thread_srp_server_stop(instance));
 165 }
 166
 167 TEST_F(ThreadSrpTest, ServerStopInvalidParameter)
 168 {
 169         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER, thread_srp_server_stop(instance));
 170 }
 171
 172 TEST_F(ThreadSrpTest, ServerStopErrorNone)
 173 {
 174         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 175         EXPECT_EQ(THREAD_ERROR_NONE, thread_srp_server_stop(instance));
 176 }
 177
 178 TEST_F(ThreadSrpTest, ServerGetRegisteredServiceNotInitialized)
 179 {
 180         EXPECT_EQ(THREAD_ERROR_NONE, thread_deinitialize());
 181         EXPECT_EQ(THREAD_ERROR_NOT_INITIALIZED,
 182                 thread_srp_server_get_registered_service(instance,
 183                 &serviceName, &address, &port, &isDeleted));
 184 }
 185
 186 TEST_F(ThreadSrpTest, ServerGetRegisteredServiceInvalidParameter)
 187 {
 188         EXPECT_EQ(THREAD_ERROR_INVALID_PARAMETER,
 189                 thread_srp_server_get_registered_service(instance,
 190                 &serviceName, &address, &port, &isDeleted));
 191 }
 192
 193 TEST_F(ThreadSrpTest, ServerGetRegisteredServiceErrorNone)
 194 {
 195         EXPECT_EQ(THREAD_ERROR_NONE, thread_enable(&instance));
 196         EXPECT_EQ(THREAD_ERROR_NONE,
 197                 thread_srp_server_get_registered_service(instance,
 198                 &serviceName, &address, &port, &isDeleted));
 199 }