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 #include "net_conn_client_mock.h"
28 #include "net_handle.h"
29 #include "settings_data_manager.h"
30 #include "network_set_manager.h"
31
32 namespace OHOS::FileManagement::CloudSync::Test {
33 using namespace testing;
34 using namespace testing::ext;
35 using namespace std;
36 using namespace CloudFile;
37
38 class NetworkStatusTest : public testing::Test {
39 public:
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44 static inline shared_ptr<NetConnClientMock> dfsNetConnClient_ = nullptr;
45 };
SetUpTestCase(void)46 void NetworkStatusTest::SetUpTestCase(void)
47 {
48 dfsNetConnClient_ = make_shared<NetConnClientMock>();
49 NetConnClientMock::dfsNetConnClient = dfsNetConnClient_;
50 GTEST_LOG_(INFO) << "SetUpTestCase";
51 }
52
TearDownTestCase(void)53 void NetworkStatusTest::TearDownTestCase(void)
54 {
55 NetConnClientMock::dfsNetConnClient = nullptr;
56 dfsNetConnClient_ = nullptr;
57 GTEST_LOG_(INFO) << "TearDownTestCase";
58 }
59
SetUp(void)60 void NetworkStatusTest::SetUp(void)
61 {
62 GTEST_LOG_(INFO) << "SetUp";
63 }
64
TearDown(void)65 void NetworkStatusTest::TearDown(void)
66 {
67 GTEST_LOG_(INFO) << "TearDown";
68 }
69
70 /**
71 * @tc.name: RegisterNetConnCallbackTest
72 * @tc.desc: Verify the RegisterNetConnCallback function
73 * @tc.type: FUNC
74 * @tc.require: I6JPKG
75 */
76 HWTEST_F(NetworkStatusTest, RegisterNetConnCallbackTest001, TestSize.Level1)
77 {
78 GTEST_LOG_(INFO) << "RegisterNetConnCallbackTest Start";
79 try {
80 auto dataSyncManager = std::make_shared<DataSyncManager>();
81 int32_t ret = NetworkStatus::RegisterNetConnCallback(dataSyncManager);
82 EXPECT_EQ(ret, E_GET_NETWORK_MANAGER_FAILED);
83 } catch (...) {
84 EXPECT_TRUE(false);
85 GTEST_LOG_(INFO) << " RegisterNetConnCallbackTest FAILED";
86 }
87 GTEST_LOG_(INFO) << "RegisterNetConnCallbackTest End";
88 }
89
90 /**
91 * @tc.name: GetDefaultNetTest001
92 * @tc.desc: Verify the GetDefaultNet function
93 * @tc.type: FUNC
94 * @tc.require: I6JPKG
95 */
96 HWTEST_F(NetworkStatusTest, GetDefaultNetTest001, TestSize.Level1)
97 {
98 GTEST_LOG_(INFO) << "GetDefaultNetTest001 Start";
99 EXPECT_CALL(*dfsNetConnClient_, GetDefaultNet(_)).WillOnce(Return(E_GET_NETWORK_MANAGER_FAILED));
100 NetworkStatus netStatus;
101 int32_t ret = netStatus.GetDefaultNet();
102 EXPECT_EQ(ret, E_GET_NETWORK_MANAGER_FAILED);
103 GTEST_LOG_(INFO) << "GetDefaultNetTest001 End";
104 }
105
106 /**
107 * @tc.name: GetDefaultNetTest002
108 * @tc.desc: Verify the GetDefaultNet function
109 * @tc.type: FUNC
110 * @tc.require: I6JPKG
111 */
112 HWTEST_F(NetworkStatusTest, GetDefaultNetTest002, TestSize.Level1)
113 {
114 GTEST_LOG_(INFO) << "GetDefaultNetTest002 Start";
115 EXPECT_CALL(*dfsNetConnClient_, GetDefaultNet(_)).WillOnce(Return(NetManagerStandard::NETMANAGER_SUCCESS));
116 NetworkStatus netStatus;
117 int32_t ret = netStatus.GetDefaultNet();
118 EXPECT_EQ(ret, E_OK);
119 GTEST_LOG_(INFO) << "GetDefaultNetTest002 End";
120 }
121
122 /**
123 * @tc.name: SetNetConnStatusTest001
124 * @tc.desc: Verify the SetNetConnStatus function
125 * @tc.type: FUNC
126 * @tc.require: I6JPKG
127 */
128 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest001, TestSize.Level1)
129 {
130 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 Start";
131 try {
132 NetManagerStandard::NetAllCapabilities netAllCap;
133 NetworkStatus::SetNetConnStatus(netAllCap);
134 EXPECT_TRUE(true);
135 } catch (...) {
136 EXPECT_TRUE(false);
137 GTEST_LOG_(INFO) << " SetNetConnStatusTest001 FAILED";
138 }
139 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 End";
140 }
141
142 /**
143 * @tc.name: SetNetConnStatusTest002
144 * @tc.desc: Verify the SetNetConnStatus function
145 * @tc.type: FUNC
146 * @tc.require: I6JPKG
147 */
148 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest002, TestSize.Level1)
149 {
150 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 Start";
151 try {
152 NetManagerStandard::NetAllCapabilities netAllCap;
153 netAllCap.netCaps_.insert(NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET);
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: SetNetConnStatusTest003
165 * @tc.desc: Verify the SetNetConnStatus function
166 * @tc.type: FUNC
167 * @tc.require: I6JPKG
168 */
169 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest003, 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_ETHERNET);
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: SetNetConnStatusTest004
187 * @tc.desc: Verify the SetNetConnStatus function
188 * @tc.type: FUNC
189 * @tc.require: I6JPKG
190 */
191 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest004, 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_WIFI);
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: SetNetConnStatusTest005
209 * @tc.desc: Verify the SetNetConnStatus function
210 * @tc.type: FUNC
211 * @tc.require: I6JPKG
212 */
213 HWTEST_F(NetworkStatusTest, SetNetConnStatusTest005, TestSize.Level1)
214 {
215 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 Start";
216 try {
217 NetManagerStandard::NetAllCapabilities netAllCap;
218 netAllCap.netCaps_.insert(NetManagerStandard::NetCap::NET_CAPABILITY_INTERNET);
219 netAllCap.bearerTypes_.insert(NetManagerStandard::BEARER_CELLULAR);
220 NetworkStatus::SetNetConnStatus(netAllCap);
221 EXPECT_TRUE(true);
222 } catch (...) {
223 EXPECT_TRUE(false);
224 GTEST_LOG_(INFO) << " SetNetConnStatusTest001 FAILED";
225 }
226 GTEST_LOG_(INFO) << "SetNetConnStatusTest001 End";
227 }
228
229 /**
230 * @tc.name: GetAndRegisterNetworkTest
231 * @tc.desc: Verify the GetAndRegisterNetwork function
232 * @tc.type: FUNC
233 * @tc.require: I6JPKG
234 */
235 HWTEST_F(NetworkStatusTest, GetAndRegisterNetworkTest, TestSize.Level1)
236 {
237 GTEST_LOG_(INFO) << "GetAndRegisterNetworkTest Start";
238 try {
239 EXPECT_CALL(*dfsNetConnClient_, GetDefaultNet(_)).WillOnce(Return(E_OK));
240 auto dataSyncManager = std::make_shared<DataSyncManager>();
241 int32_t ret = NetworkStatus::GetAndRegisterNetwork(dataSyncManager);
242 EXPECT_EQ(ret, E_GET_NETWORK_MANAGER_FAILED);
243 } catch (...) {
244 EXPECT_TRUE(false);
245 GTEST_LOG_(INFO) << " GetAndRegisterNetworkTest FAILED";
246 }
247 GTEST_LOG_(INFO) << "GetAndRegisterNetworkTest End";
248 }
249
250 /**
251 * @tc.name: InitNetworkTest
252 * @tc.desc: Verify the InitNetwork function
253 * @tc.type: FUNC
254 * @tc.require: I6JPKG
255 */
256 HWTEST_F(NetworkStatusTest, InitNetworkTest, TestSize.Level1)
257 {
258 GTEST_LOG_(INFO) << "InitNetworkTest Start";
259 try {
260 EXPECT_CALL(*dfsNetConnClient_, GetDefaultNet(_)).WillOnce(Return(E_OK)).WillRepeatedly(Return(E_OK));
261 auto dataSyncManager = std::make_shared<DataSyncManager>();
262 NetworkStatus::InitNetwork(dataSyncManager);
263 EXPECT_TRUE(true);
264 } catch (...) {
265 EXPECT_TRUE(false);
266 GTEST_LOG_(INFO) << " InitNetworkTest FAILED";
267 }
268 GTEST_LOG_(INFO) << "InitNetworkTest End";
269 }
270
271 /**
272 * @tc.name: CheckMobileNetworkTest001
273 * @tc.desc: Verify the CheckMobileNetwork function
274 * @tc.type: FUNC
275 * @tc.require: I6JPKG
276 */
277 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest001, TestSize.Level1)
278 {
279 GTEST_LOG_(INFO) << "CheckMobileNetworkTest Start";
280 try {
281 NetworkStatus networkStatus;
282 string bundleName = "";
283 int32_t userId = 100;
284 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
285 EXPECT_EQ(ret, true);
286 } catch (...) {
287 EXPECT_TRUE(false);
288 GTEST_LOG_(INFO) << "CheckMobileNetworkTest FAILED";
289 }
290 GTEST_LOG_(INFO) << "CheckMobileNetworkTest End";
291 }
292
293 /**
294 * @tc.name: CheckMobileNetworkTest002
295 * @tc.desc: Verify the CheckMobileNetwork function
296 * @tc.type: FUNC
297 * @tc.require: I6JPKG
298 */
299 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest002, TestSize.Level1)
300 {
301 GTEST_LOG_(INFO) << "CheckMobileNetworkTest Start";
302 try {
303 NetworkStatus networkStatus;
304 string bundleName = "com.ohos.photos";
305 int32_t userId = 1;
306 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
307 EXPECT_EQ(ret, false);
308 } catch (...) {
309 EXPECT_TRUE(false);
310 GTEST_LOG_(INFO) << "CheckMobileNetworkTest FAILED";
311 }
312 GTEST_LOG_(INFO) << "CheckMobileNetworkTest End";
313 }
314
315 /**
316 * @tc.name: CheckMobileNetworkTest003
317 * @tc.desc: Verify the CheckMobileNetwork function
318 * @tc.type: FUNC
319 * @tc.require: I6JPKG
320 */
321 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest003, TestSize.Level1)
322 {
323 GTEST_LOG_(INFO) << "CheckMobileNetworkTest Start";
324 try {
325 NetworkStatus networkStatus;
326 string bundleName = "com.ohos.photos";
327 int32_t userId = 100;
328 networkStatus.SetNetConnStatus(NetworkStatus::WIFI_CONNECT);
329 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
330 EXPECT_EQ(ret, true);
331 } catch (...) {
332 EXPECT_TRUE(false);
333 GTEST_LOG_(INFO) << "CheckMobileNetworkTest FAILED";
334 }
335 GTEST_LOG_(INFO) << "CheckMobileNetworkTest End";
336 }
337
338 /**
339 * @tc.name: CheckMobileNetworkTest004
340 * @tc.desc: Verify the CheckMobileNetwork function
341 * @tc.type: FUNC
342 * @tc.require: I6JPKG
343 */
344 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest004, TestSize.Level1)
345 {
346 GTEST_LOG_(INFO) << "CheckMobileNetworkTest Start";
347 try {
348 NetworkStatus networkStatus;
349 string bundleName = "com.ohos.photos";
350 int32_t userId = 100;
351 networkStatus.SetNetConnStatus(NetworkStatus::NO_NETWORK);
352 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
353 EXPECT_EQ(ret, false);
354 } catch (...) {
355 EXPECT_TRUE(false);
356 GTEST_LOG_(INFO) << "CheckMobileNetworkTest FAILED";
357 }
358 GTEST_LOG_(INFO) << "CheckMobileNetworkTest End";
359 }
360
361 /**
362 * @tc.name: CheckMobileNetworkTest005
363 * @tc.desc: Verify the CheckMobileNetwork function
364 * @tc.type: FUNC
365 * @tc.require: I6JPKG
366 */
367 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest005, TestSize.Level1)
368 {
369 GTEST_LOG_(INFO) << "CheckMobileNetworkTest005 Start";
370 try {
371 NetworkStatus networkStatus;
372 string bundleName = "com.ohos.ailife";
373 int32_t userId = 100;
374 SettingsDataManager::settingsDataMap_.EnsureInsert("photos_mobile_data_sync", "1");
375 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
376 EXPECT_EQ(ret, true);
377 } catch (...) {
378 EXPECT_TRUE(false);
379 GTEST_LOG_(INFO) << "CheckMobileNetworkTest005 FAILED";
380 }
381 GTEST_LOG_(INFO) << "CheckMobileNetworkTest005 End";
382 }
383
384 /**
385 * @tc.name: CheckMobileNetworkTest006
386 * @tc.desc: Verify the CheckMobileNetwork function
387 * @tc.type: FUNC
388 * @tc.require: I6JPKG
389 */
390 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest006, TestSize.Level1)
391 {
392 GTEST_LOG_(INFO) << "CheckMobileNetworkTest006 Start";
393 try {
394 NetworkStatus networkStatus;
395 string bundleName = "com.ohos.photos";
396 int32_t userId = 100;
397 std::string key = std::to_string(userId) + "/" + bundleName;
398 NetworkSetManager::cellularNetMap_.EnsureInsert(key, true);
399 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
400 EXPECT_EQ(ret, true);
401 } catch (...) {
402 EXPECT_TRUE(false);
403 GTEST_LOG_(INFO) << "CheckMobileNetworkTest006 FAILED";
404 }
405 GTEST_LOG_(INFO) << "CheckMobileNetworkTest006 End";
406 }
407
408 /**
409 * @tc.name: CheckMobileNetworkTest007
410 * @tc.desc: Verify the CheckMobileNetwork function
411 * @tc.type: FUNC
412 * @tc.require: I6JPKG
413 */
414 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest007, TestSize.Level1)
415 {
416 GTEST_LOG_(INFO) << "CheckMobileNetworkTest007 Start";
417 try {
418 NetworkStatus networkStatus;
419 string bundleName = "com.ohos.photos";
420 int32_t userId = 100;
421 std::string key = std::to_string(userId) + "/" + bundleName;
422 networkStatus.SetNetConnStatus(NetworkStatus::WIFI_CONNECT);
423 NetworkSetManager::cellularNetMap_.EnsureInsert(key, false);
424 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
425 EXPECT_EQ(ret, true);
426 } catch (...) {
427 EXPECT_TRUE(false);
428 GTEST_LOG_(INFO) << "CheckMobileNetworkTest007 FAILED";
429 }
430 GTEST_LOG_(INFO) << "CheckMobileNetworkTest007 End";
431 }
432
433 /**
434 * @tc.name: CheckMobileNetworkTest008
435 * @tc.desc: Verify the CheckMobileNetwork function
436 * @tc.type: FUNC
437 * @tc.require: I6JPKG
438 */
439 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest008, TestSize.Level1)
440 {
441 GTEST_LOG_(INFO) << "CheckMobileNetworkTest008 Start";
442 try {
443 NetworkStatus networkStatus;
444 string bundleName = "com.ohos.photos";
445 int32_t userId = 100;
446 std::string key = std::to_string(userId) + "/" + bundleName;
447 networkStatus.SetNetConnStatus(NetworkStatus::NO_NETWORK);
448 NetworkSetManager::cellularNetMap_.EnsureInsert(key, false);
449 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
450 EXPECT_EQ(ret, false);
451 } catch (...) {
452 EXPECT_TRUE(false);
453 GTEST_LOG_(INFO) << "CheckMobileNetworkTest008 FAILED";
454 }
455 GTEST_LOG_(INFO) << "CheckMobileNetworkTest008 End";
456 }
457
458 /**
459 * @tc.name: CheckMobileNetworkTest009
460 * @tc.desc: Verify the CheckMobileNetwork function
461 * @tc.type: FUNC
462 * @tc.require: I6JPKG
463 */
464 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest009, TestSize.Level1)
465 {
466 GTEST_LOG_(INFO) << "CheckMobileNetworkTest009 Start";
467 try {
468 NetworkStatus networkStatus;
469 string bundleName = "xxxxxxxxx";
470 int32_t userId = 100;
471 std::string key = std::to_string(userId) + "/" + bundleName;
472 networkStatus.SetNetConnStatus(NetworkStatus::NO_NETWORK);
473 NetworkSetManager::cellularNetMap_.EnsureInsert(key, false);
474 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
475 EXPECT_EQ(ret, true);
476 } catch (...) {
477 EXPECT_TRUE(false);
478 GTEST_LOG_(INFO) << "CheckMobileNetworkTest009 FAILED";
479 }
480 GTEST_LOG_(INFO) << "CheckMobileNetworkTest009 End";
481 }
482
483 /**
484 * @tc.name: CheckMobileNetworkTest010
485 * @tc.desc: Verify the CheckMobileNetwork function
486 * @tc.type: FUNC
487 * @tc.require: ICQFDC
488 */
489 HWTEST_F(NetworkStatusTest, CheckMobileNetworkTest010, TestSize.Level1)
490 {
491 GTEST_LOG_(INFO) << "CheckMobileNetworkTest010 Start";
492 try {
493 NetworkStatus networkStatus;
494 string bundleName = "com.ohos.ailife";
495 int32_t userId = 100;
496 SettingsDataManager::settingsDataMap_.EnsureInsert("photos_mobile_data_sync", "0");
497 bool ret = networkStatus.CheckMobileNetwork(bundleName, userId);
498 EXPECT_EQ(ret, false);
499 } catch (...) {
500 EXPECT_TRUE(false);
501 GTEST_LOG_(INFO) << "CheckMobileNetworkTest005 FAILED";
502 }
503 GTEST_LOG_(INFO) << "CheckMobileNetworkTest005 End";
504 }
505
506 /**
507 * @tc.name: CheckNetworkTest001
508 * @tc.desc: Verify the CheckNetwork function
509 * @tc.type: FUNC
510 * @tc.require: ICQFDC
511 */
512 HWTEST_F(NetworkStatusTest, CheckNetworkTest001, TestSize.Level1)
513 {
514 GTEST_LOG_(INFO) << "CheckNetworkTest Start";
515 try {
516 NetworkStatus networkStatus;
517 string bundleName = "";
518 int32_t userId = 100;
519 bool ret = networkStatus.CheckNetwork(bundleName, userId);
520 EXPECT_EQ(ret, true);
521 } catch (...) {
522 EXPECT_TRUE(false);
523 GTEST_LOG_(INFO) << "CheckNetworkTest FAILED";
524 }
525 GTEST_LOG_(INFO) << "CheckNetworkTest End";
526 }
527
528 /**
529 * @tc.name: CheckNetworkTest002
530 * @tc.desc: Verify the CheckNetwork function
531 * @tc.type: FUNC
532 * @tc.require: ICQFDC
533 */
534 HWTEST_F(NetworkStatusTest, CheckNetworkTest002, TestSize.Level1)
535 {
536 GTEST_LOG_(INFO) << "CheckNetworkTest Start";
537 try {
538 NetworkStatus networkStatus;
539 string bundleName = "com.ohos.photos";
540 int32_t userId = 1;
541 SettingsDataManager::settingsDataMap_.EnsureInsert("photo_network_connection_status", "off");
542 bool ret = networkStatus.CheckNetwork(bundleName, userId);
543 EXPECT_EQ(ret, false);
544 } catch (...) {
545 EXPECT_TRUE(false);
546 GTEST_LOG_(INFO) << "CheckNetworkTest FAILED";
547 }
548 GTEST_LOG_(INFO) << "CheckNetworkTest End";
549 }
550
551 /**
552 * @tc.name: CheckNetworkTest003
553 * @tc.desc: Verify the CheckNetwork function
554 * @tc.type: FUNC
555 * @tc.require: ICQFDC
556 */
557 HWTEST_F(NetworkStatusTest, CheckNetworkTest003, TestSize.Level1)
558 {
559 GTEST_LOG_(INFO) << "CheckNetworkTest Start";
560 try {
561 NetworkStatus networkStatus;
562 string bundleName = "com.ohos.photos";
563 int32_t userId = 100;
564 SettingsDataManager::settingsDataMap_.EnsureInsert("photo_network_connection_status", "on");
565 bool ret = networkStatus.CheckNetwork(bundleName, userId);
566 EXPECT_EQ(ret, true);
567 } catch (...) {
568 EXPECT_TRUE(false);
569 GTEST_LOG_(INFO) << "CheckNetworkTest FAILED";
570 }
571 GTEST_LOG_(INFO) << "CheckNetworkTest End";
572 }
573
574 /**
575 * @tc.name: CheckNetworkTest004
576 * @tc.desc: Verify the CheckNetwork function
577 * @tc.type: FUNC
578 * @tc.require: ICQFDC
579 */
580 HWTEST_F(NetworkStatusTest, CheckNetworkTest004, TestSize.Level1)
581 {
582 GTEST_LOG_(INFO) << "CheckNetworkTest004 Start";
583 try {
584 NetworkStatus networkStatus;
585 string bundleName = "com.ohos.ailife";
586 int32_t userId = 100;
587 SettingsDataManager::settingsDataMap_.EnsureInsert("photo_network_connection_status", "on");
588 bool ret = networkStatus.CheckNetwork(bundleName, userId);
589 EXPECT_EQ(ret, true);
590 } catch (...) {
591 EXPECT_TRUE(false);
592 GTEST_LOG_(INFO) << "CheckNetworkTest004 FAILED";
593 }
594 GTEST_LOG_(INFO) << "CheckNetworkTest004 End";
595 }
596
597 /**
598 * @tc.name: CheckNetworkTest005
599 * @tc.desc: Verify the CheckNetwork function
600 * @tc.type: FUNC
601 * @tc.require: ICQFDC
602 */
603 HWTEST_F(NetworkStatusTest, CheckNetworkTest005, TestSize.Level1)
604 {
605 GTEST_LOG_(INFO) << "CheckNetworkTest005 Start";
606 try {
607 NetworkStatus networkStatus;
608 string bundleName = "com.ohos.ailife";
609 int32_t userId = 100;
610 SettingsDataManager::settingsDataMap_.EnsureInsert("photo_network_connection_status", "false");
611 bool ret = networkStatus.CheckNetwork(bundleName, userId);
612 EXPECT_EQ(ret, false);
613 } catch (...) {
614 EXPECT_TRUE(false);
615 GTEST_LOG_(INFO) << "CheckNetworkTest005 FAILED";
616 }
617 GTEST_LOG_(INFO) << "CheckNetworkTest005 End";
618 }
619
620 /**
621 * @tc.name: OnNetworkAvailTest001
622 * @tc.desc: Verify the OnNetworkAvail function
623 * @tc.type: FUNC
624 * @tc.require: I6JPKG
625 */
626 HWTEST_F(NetworkStatusTest, OnNetworkAvailTest001, TestSize.Level1)
627 {
628 GTEST_LOG_(INFO) << "OnNetworkAvailTest Start";
629 try {
630 NetworkStatus networkStatus;
631 networkStatus.SetNetConnStatus(NetworkStatus::WIFI_CONNECT);
632 } catch (...) {
633 EXPECT_TRUE(false);
634 GTEST_LOG_(INFO) << "OnNetworkAvailTest FAILED";
635 }
636 GTEST_LOG_(INFO) << "OnNetworkAvailTest End";
637 }
638
639 /**
640 * @tc.name: CheckWifiOrEthernetTest001
641 * @tc.desc: Verify the CheckNetwork function
642 * @tc.type: FUNC
643 * @tc.require: I6JPKG
644 */
645 HWTEST_F(NetworkStatusTest, CheckWifiOrEthernetTest001, TestSize.Level1)
646 {
647 GTEST_LOG_(INFO) << "CheckWifiOrEthernetTest Start";
648 try {
649 NetworkStatus networkStatus;
650 networkStatus.SetNetConnStatus(NetworkStatus::WIFI_CONNECT);
651 bool ret = networkStatus.CheckWifiOrEthernet();
652 EXPECT_EQ(ret, true);
653 } catch (...) {
654 EXPECT_TRUE(false);
655 GTEST_LOG_(INFO) << "CheckWifiOrEthernetTest FAILED";
656 }
657 GTEST_LOG_(INFO) << "CheckWifiOrEthernetTest End";
658 }
659
660 /**
661 * @tc.name: CheckWifiOrEthernetTest002
662 * @tc.desc: Verify the CheckNetwork function
663 * @tc.type: FUNC
664 * @tc.require: I6JPKG
665 */
666 HWTEST_F(NetworkStatusTest, CheckWifiOrEthernetTest002, TestSize.Level1)
667 {
668 GTEST_LOG_(INFO) << "CheckWifiOrEthernetTest Start";
669 try {
670 NetworkStatus networkStatus;
671 networkStatus.SetNetConnStatus(NetworkStatus::ETHERNET_CONNECT);
672 bool ret = networkStatus.CheckWifiOrEthernet();
673 EXPECT_EQ(ret, true);
674 } catch (...) {
675 EXPECT_TRUE(false);
676 GTEST_LOG_(INFO) << "CheckWifiOrEthernetTest FAILED";
677 }
678 GTEST_LOG_(INFO) << "CheckWifiOrEthernetTest End";
679 }
680 } // namespace OHOS::FileManagement::CloudSync::Test