1 /*
2 * Copyright (c) 2022-2023 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 <memory>
17 #include <random>
18
19 #include <gtest/gtest.h>
20
21 #ifdef GTEST_API_
22 #define private public
23 #endif
24 #include "net_mgr_log_wrapper.h"
25 #include "net_stats_constants.h"
26 #include "net_stats_data_handler.h"
27 #include "net_stats_database_defines.h"
28 #include "net_stats_database_helper.h"
29
30 namespace OHOS {
31 namespace NetManagerStandard {
32 using namespace NetStatsDatabaseDefines;
33
34 using namespace testing::ext;
35 namespace {
36 constexpr uint32_t UID_MAX_TEST = 200;
37 constexpr uint32_t MAX_TEST_DATA = 100;
38 constexpr uint32_t UID = 2000222;
39 const std::vector<std::string> MOCK_IFACE = {"wlan0", "eth0", "eth1", "usb0", "wlan1", "usb1"};
40 std::random_device g_rd;
41 std::mt19937 g_regn(g_rd());
GetUint32()42 uint32_t GetUint32()
43 {
44 return static_cast<uint32_t>(g_regn()) % UID_MAX_TEST;
45 }
46
GetUint64()47 uint64_t GetUint64()
48 {
49 return static_cast<uint64_t>(g_regn());
50 }
51
GetMockIface()52 std::string GetMockIface()
53 {
54 return MOCK_IFACE.at(g_regn() % MOCK_IFACE.size());
55 }
56 std::vector<NetStatsInfo> g_statsData;
57
CreateMockStatsInfo()58 NetStatsInfo CreateMockStatsInfo()
59 {
60 NetStatsInfo info;
61 info.uid_ = GetUint32();
62 info.ident_ = std::to_string(GetUint32());
63 info.date_ = GetUint64();
64 info.iface_ = GetMockIface();
65 info.rxBytes_ = GetUint64();
66 info.rxPackets_ = GetUint64();
67 info.txBytes_ = GetUint64();
68 info.txPackets_ = GetUint64();
69 return info;
70 }
71
CreateMockStatsData()72 void CreateMockStatsData()
73 {
74 g_statsData.clear();
75 for (uint32_t i = 0; i < MAX_TEST_DATA; i++) {
76 NetStatsInfo info;
77 info.uid_ = GetUint32();
78 info.ident_ = std::to_string(GetUint32());
79 info.date_ = GetUint64();
80 info.iface_ = GetMockIface();
81 info.rxBytes_ = GetUint64();
82 info.rxPackets_ = GetUint64();
83 info.txBytes_ = GetUint64();
84 info.txPackets_ = GetUint64();
85 g_statsData.push_back(info);
86 }
87 }
88
ClearMockStatsData()89 void ClearMockStatsData()
90 {
91 g_statsData.clear();
92 }
93 } // namespace
94
95 class NetStatsDataHandlerTest : public testing::Test {
96 public:
97 static void SetUpTestCase();
98 static void TearDownTestCase();
99 void SetUp();
100 void TearDown();
101 };
102
SetUpTestCase()103 void NetStatsDataHandlerTest::SetUpTestCase()
104 {
105 CreateMockStatsData();
106 }
107
TearDownTestCase()108 void NetStatsDataHandlerTest::TearDownTestCase()
109 {
110 ClearMockStatsData();
111 }
112
SetUp()113 void NetStatsDataHandlerTest::SetUp() {}
114
TearDown()115 void NetStatsDataHandlerTest::TearDown() {}
116
117 HWTEST_F(NetStatsDataHandlerTest, WriteStatsDataTest001, TestSize.Level1)
118 {
119 NetStatsDataHandler handler;
120 CreateMockStatsData();
121 int32_t ret = handler.WriteStatsData(g_statsData, UID_TABLE);
122 ClearMockStatsData();
123 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
124 }
125
126 HWTEST_F(NetStatsDataHandlerTest, WriteStatsDataTest002, TestSize.Level1)
127 {
128 NetStatsDataHandler handler;
129 std::vector<NetStatsInfo> mockEmptyStatsData;
130 int32_t ret = handler.WriteStatsData(mockEmptyStatsData, UID_TABLE);
131 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
132 }
133
134 HWTEST_F(NetStatsDataHandlerTest, WriteStatsDataTest003, TestSize.Level1)
135 {
136 NetStatsDataHandler handler;
137 std::vector<NetStatsInfo> mockStatsData;
138 mockStatsData.push_back(CreateMockStatsInfo());
139 std::string mockEmptyIfaceName;
140 int32_t ret = handler.WriteStatsData(mockStatsData, mockEmptyIfaceName);
141 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
142 }
143
144 HWTEST_F(NetStatsDataHandlerTest, WriteStatsDataTest004, TestSize.Level1)
145 {
146 NetStatsDataHandler handler;
147 CreateMockStatsData();
148 int32_t ret = handler.WriteStatsData(g_statsData, IFACE_TABLE);
149 ClearMockStatsData();
150 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
151 }
152
153 HWTEST_F(NetStatsDataHandlerTest, WriteStatsDataTest005, TestSize.Level1)
154 {
155 NetStatsDataHandler handler;
156 CreateMockStatsData();
157 int32_t ret = handler.WriteStatsData(g_statsData, UID_SIM_TABLE);
158 ClearMockStatsData();
159 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
160 }
161
162 HWTEST_F(NetStatsDataHandlerTest, ReadStatsDataTest001, TestSize.Level1)
163 {
164 NETMGR_LOG_E("NetStatsDataHandlerTest ReadStatsDataTest001 enter");
165 NetStatsDataHandler handler;
166 std::vector<NetStatsInfo> infos;
167 int32_t ret = handler.ReadStatsData(infos, 0, LONG_MAX);
168 std::cout << "Data size: " << infos.size() << std::endl;
__anone7abb94d0202(const auto &info) 169 std::for_each(infos.begin(), infos.end(), [](const auto &info) { std::cout << info.UidData() << std::endl; });
170 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
171 }
172
173 HWTEST_F(NetStatsDataHandlerTest, ReadStatsDataTest002, TestSize.Level1)
174 {
175 NetStatsDataHandler handler;
176 std::vector<NetStatsInfo> infos;
177 std::string iface;
178 int32_t ret = handler.ReadStatsData(infos, iface, 0, LONG_MAX);
179 std::cout << "Data size: " << infos.size() << std::endl;
__anone7abb94d0302(const auto &info) 180 std::for_each(infos.begin(), infos.end(), [](const auto &info) { std::cout << info.UidData() << std::endl; });
181 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
182 }
183
184 HWTEST_F(NetStatsDataHandlerTest, ReadStatsDataTest003, TestSize.Level1)
185 {
186 NetStatsDataHandler handler;
187 std::vector<NetStatsInfo> infos;
188 std::string iface = "testIface";
189 int32_t ret = handler.ReadStatsData(infos, iface, 0, LONG_MAX);
190 std::cout << "Data size: " << infos.size() << std::endl;
__anone7abb94d0402(const auto &info) 191 std::for_each(infos.begin(), infos.end(), [](const auto &info) { std::cout << info.UidData() << std::endl; });
192 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
193 }
194
195 HWTEST_F(NetStatsDataHandlerTest, ReadStatsDataTest004, TestSize.Level1)
196 {
197 NetStatsDataHandler handler;
198 std::vector<NetStatsInfo> infos;
199 uint32_t testUid = 122;
200 std::string emptyIface = "";
201 int32_t ret = handler.ReadStatsData(infos, emptyIface, testUid, 0, LONG_MAX);
202 std::cout << "Data size: " << infos.size() << std::endl;
__anone7abb94d0502(const auto &info) 203 std::for_each(infos.begin(), infos.end(), [](const auto &info) { std::cout << info.UidData() << std::endl; });
204 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
205 }
206
207 HWTEST_F(NetStatsDataHandlerTest, ReadStatsDataTest005, TestSize.Level1)
208 {
209 NetStatsDataHandler handler;
210 std::vector<NetStatsInfo> infos;
211 uint32_t testUid = 122;
212 std::string iface = "testIface";
213 int32_t ret = handler.ReadStatsData(infos, iface, 0, testUid, LONG_MAX);
214 std::cout << "Data size: " << infos.size() << std::endl;
__anone7abb94d0602(const auto &info) 215 std::for_each(infos.begin(), infos.end(), [](const auto &info) { std::cout << info.UidData() << std::endl; });
216 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
217 }
218
219 HWTEST_F(NetStatsDataHandlerTest, ReadStatsDataTest006, TestSize.Level1)
220 {
221 NetStatsDataHandler handler;
222 std::vector<NetStatsInfo> infos;
223 std::string ident = "2";
224 int32_t ret = handler.ReadStatsDataByIdent(infos, ident, 0, LONG_MAX);
225 std::cout << "Data size: " << infos.size() << std::endl;
__anone7abb94d0702(const auto &info) 226 std::for_each(infos.begin(), infos.end(), [](const auto &info) { std::cout << info.UidData() << std::endl; });
227 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
228 }
229
230 HWTEST_F(NetStatsDataHandlerTest, ReadStatsDataTest007, TestSize.Level1)
231 {
232 NetStatsDataHandler handler;
233 std::vector<NetStatsInfo> infos;
234 uint32_t uid = UID;
235 std::string ident = "2";
236 int32_t ret = handler.ReadStatsData(infos, uid, ident, 0, LONG_MAX);
237 std::cout << "Data size: " << infos.size() << std::endl;
__anone7abb94d0802(const auto &info) 238 std::for_each(infos.begin(), infos.end(), [](const auto &info) { std::cout << info.UidData() << std::endl; });
239 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
240 }
241
242 HWTEST_F(NetStatsDataHandlerTest, NetStatsDataHandlerBranchTest001, TestSize.Level1)
243 {
244 NetStatsDataHandler handler;
245 uint64_t uid = 100;
246 int32_t ret = handler.DeleteByUid(uid);
247 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
248
249 std::string tableName = "";
250 ret = handler.DeleteByDate(tableName, 0, 0);
251 EXPECT_NE(ret, NETMANAGER_SUCCESS);
252
253 ret = handler.ClearData();
254 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
255 }
256 } // namespace NetManagerStandard
257 } // namespace OHOS
258