1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "dns_config_client.h"
19 #include "dns_param_cache.h"
20 #include "netnative_log_wrapper.h"
21
22 namespace OHOS {
23 namespace NetsysNative {
24 using namespace testing::ext;
25 using namespace OHOS::nmd;
26 class DNSParamCacheTest : public testing::Test {
27 public:
28 static void SetUpTestCase();
29 static void TearDownTestCase();
30 void SetUp();
31 void TearDown();
32 };
33
SetUpTestCase()34 void DNSParamCacheTest::SetUpTestCase() {}
35
TearDownTestCase()36 void DNSParamCacheTest::TearDownTestCase() {}
37
SetUp()38 void DNSParamCacheTest::SetUp() {}
39
TearDown()40 void DNSParamCacheTest::TearDown() {}
41
42 HWTEST_F(DNSParamCacheTest, SetResolverConfigTest001, TestSize.Level1)
43 {
44 NETNATIVE_LOGI("SetResolverConfigTest001 enter");
45 DnsParamCache dnsParCache;
46 std::vector<std::string> servers;
47 std::vector<std::string> domains;
48 servers.resize(MAX_SERVER_NUM + 1);
49 uint16_t netId = 1;
50 uint16_t baseTimeoutMsec = 0;
51 uint8_t retryCount = 0;
52 int32_t ret = dnsParCache.SetResolverConfig(netId, baseTimeoutMsec, retryCount, servers, domains);
53 EXPECT_EQ(ret, -ENOENT);
54 }
55
56 HWTEST_F(DNSParamCacheTest, SetResolverConfigTest002, TestSize.Level1)
57 {
58 NETNATIVE_LOGI("SetResolverConfigTest002 enter");
59 DnsParamCache dnsParCache;
60 std::vector<std::string> servers;
61 std::vector<std::string> domains;
62 servers.resize(MAX_SERVER_NUM + 1);
63 std::string hostName = "hoseName";
64 AddrInfo addrInfo;
65 for (size_t i = 0; i < MAX_SERVER_NUM; i++) {
66 dnsParCache.CreateCacheForNet(i + 1);
67 dnsParCache.SetDnsCache(i, hostName.append(std::to_string(i)), addrInfo);
68 servers.emplace_back(hostName);
69 }
70 uint16_t netId = 1;
71 uint16_t baseTimeoutMsec = 0;
72 uint8_t retryCount = 0;
73 int32_t ret = dnsParCache.SetResolverConfig(netId, baseTimeoutMsec, retryCount, servers, domains);
74 EXPECT_EQ(ret, 0);
75 }
76
77 HWTEST_F(DNSParamCacheTest, SetResolverConfigTest003, TestSize.Level1)
78 {
79 NETNATIVE_LOGI("SetResolverConfigTest003 enter");
80 DnsParamCache dnsParCache;
81 std::vector<std::string> servers;
82 std::vector<std::string> domains;
83 servers.resize(MAX_SERVER_NUM + 1);
84 uint16_t netId = 1;
85 std::string hostName = "hoseName";
86 dnsParCache.GetDnsCache(netId, hostName);
87 AddrInfo addrInfo;
88 addrInfo.aiFlags = 100;
89 for (size_t i = 0; i < MAX_SERVER_NUM; i++) {
90 dnsParCache.CreateCacheForNet(i);
91 dnsParCache.SetDnsCache(i, hostName.append(std::to_string(i)), addrInfo);
92 servers.emplace_back(hostName.append(std::to_string(i)));
93 }
94
95 uint16_t baseTimeoutMsec = 100;
96 uint8_t retryCount = 2;
97 int32_t ret = dnsParCache.SetResolverConfig(netId, baseTimeoutMsec, retryCount, servers, domains);
98 EXPECT_EQ(ret, 0);
99 netId = 100;
100 ret = dnsParCache.GetResolverConfig(netId, servers, domains, baseTimeoutMsec, retryCount);
101 EXPECT_EQ(ret, -ENOENT);
102 netId = 1;
103 ret = dnsParCache.GetResolverConfig(netId, servers, domains, baseTimeoutMsec, retryCount);
104 EXPECT_EQ(ret, 0);
105 std::string info;
106 dnsParCache.GetDumpInfo(info);
107 }
108
109 HWTEST_F(DNSParamCacheTest, CreateCacheForNetTest, TestSize.Level1)
110 {
111 NETNATIVE_LOGI("CreateCacheForNetTest enter");
112 DnsParamCache dnsParCache;
113 uint16_t netId = 1;
114 dnsParCache.SetDefaultNetwork(netId);
115 int32_t ret = dnsParCache.CreateCacheForNet(netId);
116 EXPECT_EQ(ret, 0);
117 ret = dnsParCache.CreateCacheForNet(netId);
118 EXPECT_EQ(ret, -EEXIST);
119 netId = 0;
120 std::string hostName = "hostName";
121 dnsParCache.SetCacheDelayed(netId, hostName);
122 netId = 2;
123 dnsParCache.SetCacheDelayed(netId, hostName);
124 }
125
126 HWTEST_F(DNSParamCacheTest, DestroyNetworkCacheTest, TestSize.Level1)
127 {
128 NETNATIVE_LOGI("DestroyNetworkCacheTest enter");
129 DnsParamCache dnsParCache;
130 uint16_t netId = 1;
131 int32_t ret = dnsParCache.DestroyNetworkCache(netId);
132 EXPECT_EQ(ret, -EEXIST);
133 dnsParCache.SetDefaultNetwork(netId);
134 dnsParCache.CreateCacheForNet(netId);
135 ret = dnsParCache.DestroyNetworkCache(netId);
136 EXPECT_EQ(ret, 0);
137 }
138 } // namespace NetsysNative
139 } // namespace OHOS
140