1 /*
2 * Copyright (c) 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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include <cstdint>
19 #include <unistd.h>
20
21 #include "dfs_error.h"
22 #include "net_conn_client.h"
23 #include "parameter.h"
24 #include "net_conn_callback_observer.h"
25 #include "network_status.h"
26 #include "utils_log.h"
27
28 namespace OHOS::FileManagement::CloudSync::Test {
29 using namespace testing;
30 using namespace testing::ext;
31 using namespace std;
32 using namespace CloudFile;
33
34 class NetworkStatusTest : public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40 };
SetUpTestCase(void)41 void NetworkStatusTest::SetUpTestCase(void)
42 {
43 GTEST_LOG_(INFO) << "SetUpTestCase";
44 }
45
TearDownTestCase(void)46 void NetworkStatusTest::TearDownTestCase(void)
47 {
48 GTEST_LOG_(INFO) << "TearDownTestCase";
49 }
50
SetUp(void)51 void NetworkStatusTest::SetUp(void)
52 {
53 GTEST_LOG_(INFO) << "SetUp";
54 }
55
TearDown(void)56 void NetworkStatusTest::TearDown(void)
57 {
58 GTEST_LOG_(INFO) << "TearDown";
59 }
60
61 /**
62 * @tc.name: RegisterNetConnCallbackTest
63 * @tc.desc: Verify the RegisterNetConnCallback function
64 * @tc.type: FUNC
65 * @tc.require: I6JPKG
66 */
67 HWTEST_F(NetworkStatusTest, RegisterNetConnCallbackTest001, TestSize.Level1)
68 {
69 GTEST_LOG_(INFO) << "RegisterNetConnCallbackTest Start";
70 try {
71 auto dataSyncManager = std::make_shared<DataSyncManager>();
72 int32_t ret = NetworkStatus::RegisterNetConnCallback(dataSyncManager);
73 EXPECT_EQ(ret, E_GET_NETWORK_MANAGER_FAILED);
74 } catch (...) {
75 EXPECT_TRUE(false);
76 GTEST_LOG_(INFO) << " RegisterNetConnCallbackTest FAILED";
77 }
78 GTEST_LOG_(INFO) << "RegisterNetConnCallbackTest End";
79 }
80
81 /**
82 * @tc.name: GetDefaultNetTest
83 * @tc.desc: Verify the GetDefaultNet function
84 * @tc.type: FUNC
85 * @tc.require: I6JPKG
86 */
87 HWTEST_F(NetworkStatusTest, GetDefaultNetTest, TestSize.Level1)
88 {
89 GTEST_LOG_(INFO) << "GetDefaultNetTest Start";
90 try {
91 int32_t ret = NetworkStatus::GetDefaultNet();
92 EXPECT_EQ(ret, E_GET_NETWORK_MANAGER_FAILED);
93 } catch (...) {
94 EXPECT_TRUE(false);
95 GTEST_LOG_(INFO) << " GetDefaultNetTest FAILED";
96 }
97 GTEST_LOG_(INFO) << "GetDefaultNetTest End";
98 }
99
100 /**
101 * @tc.name: SetNetConnStatusTest001
102 * @tc.desc: Verify the SetNetConnStatus function
103 * @tc.type: FUNC
104 * @tc.require: I6JPKG
105 */
106 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest001, TestSize.Level1)
107 {
108 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 Start";
109 try {
110 NetManagerStandard::NetAllCapabilities netAllCap;
111 NetworkStatus::SetNetConnStatus(netAllCap);
112 EXPECT_TRUE(true);
113 } catch (...) {
114 EXPECT_TRUE(false);
115 GTEST_LOG_(INFO) << " SetNetConnStatusTest001 FAILED";
116 }
117 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 End";
118 }
119
120 /**
121 * @tc.name: SetNetConnStatusTest002
122 * @tc.desc: Verify the SetNetConnStatus function
123 * @tc.type: FUNC
124 * @tc.require: I6JPKG
125 */
126 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest002, TestSize.Level1)
127 {
128 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 Start";
129 try {
130 NetManagerStandard::NetAllCapabilities netAllCap;
131 netAllCap.netCaps_.insert(NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET);
132 NetworkStatus::SetNetConnStatus(netAllCap);
133 EXPECT_TRUE(true);
134 } catch (...) {
135 EXPECT_TRUE(false);
136 GTEST_LOG_(INFO) << " SetNetConnStatusTest001 FAILED";
137 }
138 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 End";
139 }
140
141 /**
142 * @tc.name: SetNetConnStatusTest003
143 * @tc.desc: Verify the SetNetConnStatus function
144 * @tc.type: FUNC
145 * @tc.require: I6JPKG
146 */
147 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest003, TestSize.Level1)
148 {
149 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 Start";
150 try {
151 NetManagerStandard::NetAllCapabilities netAllCap;
152 netAllCap.netCaps_.insert(NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET);
153 netAllCap.bearerTypes_.insert(NetManagerStandard::BEARER_ETHERNET);
154 NetworkStatus::SetNetConnStatus(netAllCap);
155 EXPECT_TRUE(true);
156 } catch (...) {
157 EXPECT_TRUE(false);
158 GTEST_LOG_(INFO) << " SetNetConnStatusTest001 FAILED";
159 }
160 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 End";
161 }
162
163 /**
164 * @tc.name: SetNetConnStatusTest004
165 * @tc.desc: Verify the SetNetConnStatus function
166 * @tc.type: FUNC
167 * @tc.require: I6JPKG
168 */
169 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest004, TestSize.Level1)
170 {
171 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 Start";
172 try {
173 NetManagerStandard::NetAllCapabilities netAllCap;
174 netAllCap.netCaps_.insert(NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET);
175 netAllCap.bearerTypes_.insert(NetManagerStandard::BEARER_WIFI);
176 NetworkStatus::SetNetConnStatus(netAllCap);
177 EXPECT_TRUE(true);
178 } catch (...) {
179 EXPECT_TRUE(false);
180 GTEST_LOG_(INFO) << " SetNetConnStatusTest001 FAILED";
181 }
182 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 End";
183 }
184
185 /**
186 * @tc.name: SetNetConnStatusTest005
187 * @tc.desc: Verify the SetNetConnStatus function
188 * @tc.type: FUNC
189 * @tc.require: I6JPKG
190 */
191 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest005, TestSize.Level1)
192 {
193 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 Start";
194 try {
195 NetManagerStandard::NetAllCapabilities netAllCap;
196 netAllCap.netCaps_.insert(NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET);
197 netAllCap.bearerTypes_.insert(NetManagerStandard::BEARER_CELLULAR);
198 NetworkStatus::SetNetConnStatus(netAllCap);
199 EXPECT_TRUE(true);
200 } catch (...) {
201 EXPECT_TRUE(false);
202 GTEST_LOG_(INFO) << " SetNetConnStatusTest001 FAILED";
203 }
204 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 End";
205 }
206
207 /**
208 * @tc.name: GetAndRegisterNetworkTest
209 * @tc.desc: Verify the GetAndRegisterNetwork function
210 * @tc.type: FUNC
211 * @tc.require: I6JPKG
212 */
213 HWTEST_F(NetworkStatusTest, GetAndRegisterNetworkTest, TestSize.Level1)
214 {
215 GTEST_LOG_(INFO) << "GetAndRegisterNetworkTest Start";
216 try {
217 auto dataSyncManager = std::make_shared<DataSyncManager>();
218 int32_t ret = NetworkStatus::GetAndRegisterNetwork(dataSyncManager);
219 EXPECT_EQ(ret, E_GET_NETWORK_MANAGER_FAILED);
220 } catch (...) {
221 EXPECT_TRUE(false);
222 GTEST_LOG_(INFO) << " GetAndRegisterNetworkTest FAILED";
223 }
224 GTEST_LOG_(INFO) << "GetAndRegisterNetworkTest End";
225 }
226
227 /**
228 * @tc.name: InitNetworkTest
229 * @tc.desc: Verify the InitNetwork function
230 * @tc.type: FUNC
231 * @tc.require: I6JPKG
232 */
233 HWTEST_F(NetworkStatusTest, InitNetworkTest, TestSize.Level1)
234 {
235 GTEST_LOG_(INFO) << "InitNetworkTest Start";
236 try {
237 auto dataSyncManager = std::make_shared<DataSyncManager>();
238 NetworkStatus::InitNetwork(dataSyncManager);
239 EXPECT_TRUE(true);
240 } catch (...) {
241 EXPECT_TRUE(false);
242 GTEST_LOG_(INFO) << " InitNetworkTest FAILED";
243 }
244 GTEST_LOG_(INFO) << "InitNetworkTest End";
245 }
246
247 /**
248 * @tc.name: CheckMobileNetworkTest001
249 * @tc.desc: Verify the CheckMobileNetwork function
250 * @tc.type: FUNC
251 * @tc.require: I6JPKG
252 */
253 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest001, TestSize.Level1)
254 {
255 GTEST_LOG_(INFO) << "CheckMobileNetworkTest Start";
256 try {
257 NetworkStatus networkStatus;
258 string bundleName = "";
259 int32_t userId = 100;
260 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
261 EXPECT_EQ(ret, true);
262 } catch (...) {
263 EXPECT_TRUE(false);
264 GTEST_LOG_(INFO) << "CheckMobileNetworkTest FAILED";
265 }
266 GTEST_LOG_(INFO) << "CheckMobileNetworkTest End";
267 }
268
269 /**
270 * @tc.name: CheckMobileNetworkTest002
271 * @tc.desc: Verify the CheckMobileNetwork function
272 * @tc.type: FUNC
273 * @tc.require: I6JPKG
274 */
275 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest002, TestSize.Level1)
276 {
277 GTEST_LOG_(INFO) << "CheckMobileNetworkTest Start";
278 try {
279 NetworkStatus networkStatus;
280 string bundleName = "com.ohos.photos";
281 int32_t userId = 1;
282 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
283 EXPECT_EQ(ret, true);
284 } catch (...) {
285 EXPECT_TRUE(false);
286 GTEST_LOG_(INFO) << "CheckMobileNetworkTest FAILED";
287 }
288 GTEST_LOG_(INFO) << "CheckMobileNetworkTest End";
289 }
290
291 /**
292 * @tc.name: CheckMobileNetworkTest003
293 * @tc.desc: Verify the CheckMobileNetwork function
294 * @tc.type: FUNC
295 * @tc.require: I6JPKG
296 */
297 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest003, TestSize.Level1)
298 {
299 GTEST_LOG_(INFO) << "CheckMobileNetworkTest Start";
300 try {
301 NetworkStatus networkStatus;
302 string bundleName = "com.ohos.photos";
303 int32_t userId = 100;
304 networkStatus.SetNetConnStatus(NetworkStatus::WIFI_CONNECT);
305 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
306 EXPECT_EQ(ret, true);
307 } catch (...) {
308 EXPECT_TRUE(false);
309 GTEST_LOG_(INFO) << "CheckMobileNetworkTest FAILED";
310 }
311 GTEST_LOG_(INFO) << "CheckMobileNetworkTest End";
312 }
313
314 /**
315 * @tc.name: CheckMobileNetworkTest004
316 * @tc.desc: Verify the CheckMobileNetwork function
317 * @tc.type: FUNC
318 * @tc.require: I6JPKG
319 */
320 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest004, TestSize.Level1)
321 {
322 GTEST_LOG_(INFO) << "CheckMobileNetworkTest Start";
323 try {
324 NetworkStatus networkStatus;
325 string bundleName = "com.ohos.photos";
326 int32_t userId = 100;
327 networkStatus.SetNetConnStatus(NetworkStatus::NO_NETWORK);
328 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
329 EXPECT_EQ(ret, false);
330 } catch (...) {
331 EXPECT_TRUE(false);
332 GTEST_LOG_(INFO) << "CheckMobileNetworkTest FAILED";
333 }
334 GTEST_LOG_(INFO) << "CheckMobileNetworkTest End";
335 }
336
337 /**
338 * @tc.name: CheckNetworkTest001
339 * @tc.desc: Verify the CheckNetwork function
340 * @tc.type: FUNC
341 * @tc.require: I6JPKG
342 */
343 HWTEST_F(NetworkStatusTest, CheckNetworkTest001, TestSize.Level1)
344 {
345 GTEST_LOG_(INFO) << "CheckNetworkTest Start";
346 try {
347 NetworkStatus networkStatus;
348 string bundleName = "";
349 int32_t userId = 100;
350 bool ret = networkStatus.CheckNetwork(bundleName, userId);
351 EXPECT_EQ(ret, true);
352 } catch (...) {
353 EXPECT_TRUE(false);
354 GTEST_LOG_(INFO) << "CheckNetworkTest FAILED";
355 }
356 GTEST_LOG_(INFO) << "CheckNetworkTest End";
357 }
358
359 /**
360 * @tc.name: CheckNetworkTest002
361 * @tc.desc: Verify the CheckNetwork function
362 * @tc.type: FUNC
363 * @tc.require: I6JPKG
364 */
365 HWTEST_F(NetworkStatusTest, CheckNetworkTest002, TestSize.Level1)
366 {
367 GTEST_LOG_(INFO) << "CheckNetworkTest Start";
368 try {
369 NetworkStatus networkStatus;
370 string bundleName = "com.ohos.photos";
371 int32_t userId = 1;
372 bool ret = networkStatus.CheckNetwork(bundleName, userId);
373 EXPECT_EQ(ret, true);
374 } catch (...) {
375 EXPECT_TRUE(false);
376 GTEST_LOG_(INFO) << "CheckNetworkTest FAILED";
377 }
378 GTEST_LOG_(INFO) << "CheckNetworkTest End";
379 }
380
381 /**
382 * @tc.name: CheckNetworkTest003
383 * @tc.desc: Verify the CheckNetwork function
384 * @tc.type: FUNC
385 * @tc.require: I6JPKG
386 */
387 HWTEST_F(NetworkStatusTest, CheckNetworkTest003, TestSize.Level1)
388 {
389 GTEST_LOG_(INFO) << "CheckNetworkTest Start";
390 try {
391 NetworkStatus networkStatus;
392 string bundleName = "com.ohos.photos";
393 int32_t userId = 100;
394 bool ret = networkStatus.CheckNetwork(bundleName, userId);
395 EXPECT_EQ(ret, false);
396 } catch (...) {
397 EXPECT_TRUE(false);
398 GTEST_LOG_(INFO) << "CheckNetworkTest FAILED";
399 }
400 GTEST_LOG_(INFO) << "CheckNetworkTest End";
401 }
402
403 /**
404 * @tc.name: OnNetworkAvailTest001
405 * @tc.desc: Verify the OnNetworkAvail function
406 * @tc.type: FUNC
407 * @tc.require: I6JPKG
408 */
409 HWTEST_F(NetworkStatusTest, OnNetworkAvailTest001, TestSize.Level1)
410 {
411 GTEST_LOG_(INFO) << "OnNetworkAvailTest Start";
412 try {
413 NetworkStatus networkStatus;
414 networkStatus.SetNetConnStatus(NetworkStatus::WIFI_CONNECT);
415 } catch (...) {
416 EXPECT_TRUE(false);
417 GTEST_LOG_(INFO) << "OnNetworkAvailTest FAILED";
418 }
419 GTEST_LOG_(INFO) << "OnNetworkAvailTest End";
420 }
421 } // namespace OHOS::FileManagement::CloudSync::Test