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 const std::vector<std::string> MOCK_IFACE = {"wlan0", "eth0", "eth1", "usb0", "wlan1", "usb1"};
39 std::random_device g_rd;
40 std::mt19937 g_regn(g_rd());
GetUint32()41 uint32_t GetUint32()
42 {
43 return static_cast<uint32_t>(g_regn()) % UID_MAX_TEST;
44 }
45
GetUint64()46 uint64_t GetUint64()
47 {
48 return static_cast<uint64_t>(g_regn());
49 }
50
GetMockIface()51 std::string GetMockIface()
52 {
53 return MOCK_IFACE.at(g_regn() % MOCK_IFACE.size());
54 }
55 std::vector<NetStatsInfo> g_statsData;
56
CreateMockStatsInfo()57 NetStatsInfo CreateMockStatsInfo()
58 {
59 NetStatsInfo info;
60 info.uid_ = GetUint32();
61 info.date_ = GetUint64();
62 info.iface_ = GetMockIface();
63 info.rxBytes_ = GetUint64();
64 info.rxPackets_ = GetUint64();
65 info.txBytes_ = GetUint64();
66 info.txPackets_ = GetUint64();
67 return info;
68 }
69
CreateMockStatsData()70 void CreateMockStatsData()
71 {
72 g_statsData.clear();
73 for (uint32_t i = 0; i < MAX_TEST_DATA; i++) {
74 NetStatsInfo info;
75 info.uid_ = GetUint32();
76 info.date_ = GetUint64();
77 info.iface_ = GetMockIface();
78 info.rxBytes_ = GetUint64();
79 info.rxPackets_ = GetUint64();
80 info.txBytes_ = GetUint64();
81 info.txPackets_ = GetUint64();
82 g_statsData.push_back(info);
83 }
84 }
85
ClearMockStatsData()86 void ClearMockStatsData()
87 {
88 g_statsData.clear();
89 }
90 } // namespace
91
92 class NetStatsDataHandlerTest : public testing::Test {
93 public:
94 static void SetUpTestCase();
95 static void TearDownTestCase();
96 void SetUp();
97 void TearDown();
98 };
99
SetUpTestCase()100 void NetStatsDataHandlerTest::SetUpTestCase()
101 {
102 CreateMockStatsData();
103 }
104
TearDownTestCase()105 void NetStatsDataHandlerTest::TearDownTestCase()
106 {
107 ClearMockStatsData();
108 }
109
SetUp()110 void NetStatsDataHandlerTest::SetUp() {}
111
TearDown()112 void NetStatsDataHandlerTest::TearDown() {}
113
114 HWTEST_F(NetStatsDataHandlerTest, WriteStatsDataTest001, TestSize.Level1)
115 {
116 NetStatsDataHandler handler;
117 CreateMockStatsData();
118 int32_t ret = handler.WriteStatsData(g_statsData, UID_TABLE);
119 ClearMockStatsData();
120 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
121 }
122
123 HWTEST_F(NetStatsDataHandlerTest, WriteStatsDataTest002, TestSize.Level1)
124 {
125 NetStatsDataHandler handler;
126 std::vector<NetStatsInfo> mockEmptyStatsData;
127 int32_t ret = handler.WriteStatsData(mockEmptyStatsData, UID_TABLE);
128 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
129 }
130
131 HWTEST_F(NetStatsDataHandlerTest, WriteStatsDataTest003, TestSize.Level1)
132 {
133 NetStatsDataHandler handler;
134 std::vector<NetStatsInfo> mockStatsData;
135 mockStatsData.push_back(CreateMockStatsInfo());
136 std::string mockEmptyIfaceName;
137 int32_t ret = handler.WriteStatsData(mockStatsData, mockEmptyIfaceName);
138 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
139 }
140
141 HWTEST_F(NetStatsDataHandlerTest, WriteStatsDataTest004, TestSize.Level1)
142 {
143 NetStatsDataHandler handler;
144 CreateMockStatsData();
145 int32_t ret = handler.WriteStatsData(g_statsData, IFACE_TABLE);
146 ClearMockStatsData();
147 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
148 }
149
150 HWTEST_F(NetStatsDataHandlerTest, ReadStatsDataTest001, TestSize.Level1)
151 {
152 NETMGR_LOG_E("NetStatsDataHandlerTest ReadStatsDataTest001 enter");
153 NetStatsDataHandler handler;
154 std::vector<NetStatsInfo> infos;
155 int32_t ret = handler.ReadStatsData(infos, 0, LONG_MAX);
156 std::cout << "Data size: " << infos.size() << std::endl;
__anon4707e9360202(const auto &info) 157 std::for_each(infos.begin(), infos.end(), [](const auto &info) { std::cout << info.UidData() << std::endl; });
158 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
159 }
160
161 HWTEST_F(NetStatsDataHandlerTest, ReadStatsDataTest002, TestSize.Level1)
162 {
163 NetStatsDataHandler handler;
164 std::vector<NetStatsInfo> infos;
165 std::string iface;
166 int32_t ret = handler.ReadStatsData(infos, iface, 0, LONG_MAX);
167 std::cout << "Data size: " << infos.size() << std::endl;
__anon4707e9360302(const auto &info) 168 std::for_each(infos.begin(), infos.end(), [](const auto &info) { std::cout << info.UidData() << std::endl; });
169 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
170 }
171
172 HWTEST_F(NetStatsDataHandlerTest, ReadStatsDataTest003, TestSize.Level1)
173 {
174 NetStatsDataHandler handler;
175 std::vector<NetStatsInfo> infos;
176 std::string iface = "testIface";
177 int32_t ret = handler.ReadStatsData(infos, iface, 0, LONG_MAX);
178 std::cout << "Data size: " << infos.size() << std::endl;
__anon4707e9360402(const auto &info) 179 std::for_each(infos.begin(), infos.end(), [](const auto &info) { std::cout << info.UidData() << std::endl; });
180 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
181 }
182
183 HWTEST_F(NetStatsDataHandlerTest, ReadStatsDataTest004, TestSize.Level1)
184 {
185 NetStatsDataHandler handler;
186 std::vector<NetStatsInfo> infos;
187 uint32_t testUid = 122;
188 int32_t ret = handler.ReadStatsData(infos, {}, 0, testUid, LONG_MAX);
189 std::cout << "Data size: " << infos.size() << std::endl;
__anon4707e9360502(const auto &info) 190 std::for_each(infos.begin(), infos.end(), [](const auto &info) { std::cout << info.UidData() << std::endl; });
191 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
192 }
193
194 HWTEST_F(NetStatsDataHandlerTest, ReadStatsDataTest005, TestSize.Level1)
195 {
196 NetStatsDataHandler handler;
197 std::vector<NetStatsInfo> infos;
198 uint32_t testUid = 122;
199 std::string iface = "testIface";
200 int32_t ret = handler.ReadStatsData(infos, iface, 0, testUid, LONG_MAX);
201 std::cout << "Data size: " << infos.size() << std::endl;
__anon4707e9360602(const auto &info) 202 std::for_each(infos.begin(), infos.end(), [](const auto &info) { std::cout << info.UidData() << std::endl; });
203 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
204 }
205
206 HWTEST_F(NetStatsDataHandlerTest, NetStatsDataHandlerBranchTest001, TestSize.Level1)
207 {
208 NetStatsDataHandler handler;
209 uint64_t uid = 100;
210 int32_t ret = handler.DeleteByUid(uid);
211 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
212
213 std::string tableName = "";
214 ret = handler.DeleteByDate(tableName, 0, 0);
215 EXPECT_NE(ret, NETMANAGER_SUCCESS);
216
217 ret = handler.ClearData();
218 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
219 }
220 } // namespace NetManagerStandard
221 } // namespace OHOS
222