1 /*
2 * Copyright (c) 2025 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 <cstdint>
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19
20 #include "datashare_helper_mock.h"
21 #include "datashare_result_set_mock.h"
22 #include "dfs_error.h"
23 #include "settings_data_manager.h"
24
25 namespace OHOS::FileManagement::CloudSync::Test {
26 using namespace testing;
27 using namespace testing::ext;
28 using namespace std;
29 using namespace OHOS::DataShare;
30
31 static const std::string SYNC_SWITCH_KEY = "photos_sync_options"; // "0", "1", "2"
32 static const std::string NETWORK_CONNECTION_KEY = "photo_network_connection_status"; // "on", "off"
33 static const std::string LOCAL_SPACE_FREE_KEY = "photos_local_space_free"; // "1", "0"
34 static const std::string LOCAL_SPACE_DAYS_KEY = "photos_local_space_free_day_count"; // "30"
35 static const std::string MOBILE_DATA_SYNC_KEY = "photos_mobile_data_sync"; // "1", "0"
36
37 class SettingsDataManagerTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 static inline shared_ptr<DataShareHelperMock> dataShareHelperMock_ = nullptr;
44 static inline shared_ptr<DataShareResultSetMock> resultSetMock_ = nullptr;
45 };
46
SetUpTestCase(void)47 void SettingsDataManagerTest::SetUpTestCase(void)
48 {
49 GTEST_LOG_(INFO) << "SetUpTestCase";
50 dataShareHelperMock_ = std::make_shared<DataShareHelperMock>();
51 resultSetMock_ = std::make_shared<DataShareResultSetMock>();
52 DataShareHelperMock::proxy_ = dataShareHelperMock_;
53 DataShareResultSetMock::proxy_ = resultSetMock_;
54 }
55
TearDownTestCase(void)56 void SettingsDataManagerTest::TearDownTestCase(void)
57 {
58 GTEST_LOG_(INFO) << "TearDownTestCase";
59 dataShareHelperMock_ = nullptr;
60 DataShareHelperMock::proxy_ = nullptr;
61 resultSetMock_ = nullptr;
62 DataShareResultSetMock::proxy_ = nullptr;
63 }
64
SetUp(void)65 void SettingsDataManagerTest::SetUp(void)
66 {
67 DataShareHelperMock::proxy_ = dataShareHelperMock_;
68 DataShareResultSetMock::proxy_ = resultSetMock_;
69 }
70
TearDown(void)71 void SettingsDataManagerTest::TearDown(void) {}
72
73 HWTEST_F(SettingsDataManagerTest, QueryParamInSettingsDataTest001, TestSize.Level1)
74 {
75 GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest001 Start";
76 DataShareResultSetMock::proxy_ = nullptr;
77 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr));
78 std::string key = "";
79 std::string value;
80 int32_t ret = SettingsDataManager::QueryParamInSettingsData(key, value);
81 EXPECT_EQ(ret, E_RDB);
82
83 GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest001 End";
84 }
85
86 HWTEST_F(SettingsDataManagerTest, QueryParamInSettingsDataTest002, TestSize.Level1)
87 {
88 GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest002 Start";
89 DataShareResultSetMock::proxy_ = nullptr;
90 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
91 std::shared_ptr<DataShareResultSet> resultSet = std::make_shared<DataShareResultSet>();
92 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
93 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet));
94 std::string key = "";
95 std::string value;
96 int32_t ret = SettingsDataManager::QueryParamInSettingsData(key, value);
97 EXPECT_EQ(ret, E_OK);
98
99 GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest002 End";
100 }
101
102 HWTEST_F(SettingsDataManagerTest, QueryParamInSettingsDataTest003, TestSize.Level1)
103 {
104 GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest003 Start";
105 DataShareResultSetMock::proxy_ = nullptr;
106 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
107 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
108 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(nullptr));
109 std::string key = "";
110 std::string value;
111 int32_t ret = SettingsDataManager::QueryParamInSettingsData(key, value);
112 EXPECT_EQ(ret, E_RDB);
113
114 GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest003 End";
115 }
116
117 HWTEST_F(SettingsDataManagerTest, QueryParamInSettingsDataTest004, TestSize.Level1)
118 {
119 GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest004 Start";
120 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
121 std::shared_ptr<DataShareResultSet> resultSet = std::make_shared<DataShareResultSet>();
122 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
123 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet));
124 EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(E_OK));
125 EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
126 EXPECT_CALL(*resultSetMock_, GetString(_, _)).WillOnce(Return(E_OK));
127 std::string key = "";
128 std::string value;
129 int32_t ret = SettingsDataManager::QueryParamInSettingsData(key, value);
130 EXPECT_EQ(ret, E_OK);
131
132 GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest004 End";
133 }
134
135 HWTEST_F(SettingsDataManagerTest, QueryParamInSettingsDataTest005, TestSize.Level1)
136 {
137 GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest005 Start";
138 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
139 std::shared_ptr<DataShareResultSet> resultSet = std::make_shared<DataShareResultSet>();
140 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
141 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet));
142 EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(-1));
143 EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).Times(0);
144 EXPECT_CALL(*resultSetMock_, GetString(_, _)).Times(0);
145 std::string key = "";
146 std::string value;
147 int32_t ret = SettingsDataManager::QueryParamInSettingsData(key, value);
148 EXPECT_EQ(ret, E_INNER_RDB);
149
150 GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest005 End";
151 }
152
153 HWTEST_F(SettingsDataManagerTest, QueryParamInSettingsDataTest006, TestSize.Level1)
154 {
155 GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest006 Start";
156 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
157 std::shared_ptr<DataShareResultSet> resultSet = std::make_shared<DataShareResultSet>();
158 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
159 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet));
160 EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(E_OK));
161 EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).WillOnce(Return(-1));
162 EXPECT_CALL(*resultSetMock_, GetString(_, _)).Times(0);
163 std::string key = "";
164 std::string value;
165 int32_t ret = SettingsDataManager::QueryParamInSettingsData(key, value);
166 EXPECT_EQ(ret, E_RDB);
167
168 GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest006 End";
169 }
170
171 HWTEST_F(SettingsDataManagerTest, QueryParamInSettingsDataTest007, TestSize.Level1)
172 {
173 GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest007 Start";
174 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
175 std::shared_ptr<DataShareResultSet> resultSet = std::make_shared<DataShareResultSet>();
176 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
177 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet));
178 EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(E_OK));
179 EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
180 EXPECT_CALL(*resultSetMock_, GetString(_, _)).WillOnce(Return(-1));
181 std::string key = "";
182 std::string value;
183 int32_t ret = SettingsDataManager::QueryParamInSettingsData(key, value);
184 EXPECT_EQ(ret, E_RDB);
185
186 GTEST_LOG_(INFO) << "QueryParamInSettingsDataTest007 End";
187 }
188
189 HWTEST_F(SettingsDataManagerTest, GetSwitchStatusByCacheTest001, TestSize.Level1)
190 {
191 GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest001 Start";
192 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr));
193 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
194 SwitchStatus status = SettingsDataManager::GetSwitchStatusByCache();
195 EXPECT_EQ(status, SwitchStatus::NONE);
196
197 GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest001 End";
198 }
199
200 HWTEST_F(SettingsDataManagerTest, GetSwitchStatusByCacheTest002, TestSize.Level1)
201 {
202 GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest002 Start";
203 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
204 std::shared_ptr<DataShareResultSet> resultSet = std::make_shared<DataShareResultSet>();
205 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
206 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet));
207 EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(-1));
208 EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).Times(0);
209 EXPECT_CALL(*resultSetMock_, GetString(_, _)).Times(0);
210 SwitchStatus status = SettingsDataManager::GetSwitchStatusByCache();
211 EXPECT_EQ(status, SwitchStatus::CLOUD_SPACE);
212
213 GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest002 End";
214 }
215
216 HWTEST_F(SettingsDataManagerTest, GetSwitchStatusByCacheTest003, TestSize.Level1)
217 {
218 GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest003 Start";
219 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0);
220 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
221 SettingsDataManager::settingsDataMap_.EnsureInsert(SYNC_SWITCH_KEY, "0");
222 SwitchStatus status = SettingsDataManager::GetSwitchStatusByCache();
223 EXPECT_EQ(status, SwitchStatus::NONE);
224
225 SettingsDataManager::settingsDataMap_.Clear();
226 GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest003 End";
227 }
228
229 HWTEST_F(SettingsDataManagerTest, GetSwitchStatusByCacheTest004, TestSize.Level1)
230 {
231 GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest004 Start";
232 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0);
233 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
234 SettingsDataManager::settingsDataMap_.EnsureInsert(SYNC_SWITCH_KEY, "1");
235 SwitchStatus status = SettingsDataManager::GetSwitchStatusByCache();
236 EXPECT_EQ(status, SwitchStatus::CLOUD_SPACE);
237
238 SettingsDataManager::settingsDataMap_.Clear();
239 GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest004 End";
240 }
241
242 HWTEST_F(SettingsDataManagerTest, GetSwitchStatusByCacheTest005, TestSize.Level1)
243 {
244 GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest005 Start";
245 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0);
246 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
247 SettingsDataManager::settingsDataMap_.EnsureInsert(SYNC_SWITCH_KEY, "2");
248 SwitchStatus status = SettingsDataManager::GetSwitchStatusByCache();
249 EXPECT_EQ(status, SwitchStatus::AI_FAMILY);
250
251 SettingsDataManager::settingsDataMap_.Clear();
252 GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest005 End";
253 }
254
255 HWTEST_F(SettingsDataManagerTest, GetSwitchStatusByCacheTest006, TestSize.Level1)
256 {
257 GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest006 Start";
258 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
259 std::shared_ptr<DataShareResultSet> resultSet = std::make_shared<DataShareResultSet>();
260 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
261 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet));
262 EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(E_OK));
263 EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).WillOnce(Return(-1));
264 EXPECT_CALL(*resultSetMock_, GetString(_, _)).Times(0);
265 SwitchStatus status = SettingsDataManager::GetSwitchStatusByCache();
266 EXPECT_EQ(status, SwitchStatus::NONE);
267
268 GTEST_LOG_(INFO) << "GetSwitchStatusByCacheTest006 End";
269 }
270
271 HWTEST_F(SettingsDataManagerTest, GetSwitchStatusTest001, TestSize.Level1)
272 {
273 GTEST_LOG_(INFO) << "GetSwitchStatusTest001 Start";
274 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr));
275 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
276 SwitchStatus status = SettingsDataManager::GetSwitchStatus();
277 EXPECT_EQ(status, SwitchStatus::NONE);
278
279 GTEST_LOG_(INFO) << "GetSwitchStatusTest001 End";
280 }
281
282 HWTEST_F(SettingsDataManagerTest, GetSwitchStatusTest002, TestSize.Level1)
283 {
284 GTEST_LOG_(INFO) << "GetSwitchStatusTest002 Start";
285 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
286 std::shared_ptr<DataShareResultSet> resultSet = std::make_shared<DataShareResultSet>();
287 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
288 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet));
289 EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(-1));
290 EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).Times(0);
291 EXPECT_CALL(*resultSetMock_, GetString(_, _)).Times(0);
292 SwitchStatus status = SettingsDataManager::GetSwitchStatus();
293 EXPECT_EQ(status, SwitchStatus::CLOUD_SPACE);
294
295 GTEST_LOG_(INFO) << "GetSwitchStatusTest002 End";
296 }
297
298 HWTEST_F(SettingsDataManagerTest, GetSwitchStatusTest003, TestSize.Level1)
299 {
300 GTEST_LOG_(INFO) << "GetSwitchStatusTest003 Start";
301 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
302 std::shared_ptr<DataShareResultSet> resultSet = std::make_shared<DataShareResultSet>();
303 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
304 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet));
305 EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(E_OK));
306 EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
307 EXPECT_CALL(*resultSetMock_, GetString(_, _)).WillOnce(Return(E_OK));
308 SettingsDataManager::settingsDataMap_.EnsureInsert(SYNC_SWITCH_KEY, "2");
309 SwitchStatus status = SettingsDataManager::GetSwitchStatus();
310 EXPECT_EQ(status, SwitchStatus::NONE);
311
312 SettingsDataManager::settingsDataMap_.Clear();
313 GTEST_LOG_(INFO) << "GetSwitchStatusTest003 End";
314 }
315
316 HWTEST_F(SettingsDataManagerTest, GetSwitchStatusTest004, TestSize.Level1)
317 {
318 GTEST_LOG_(INFO) << "GetSwitchStatusTest004 Start";
319 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
320 std::shared_ptr<DataShareResultSet> resultSet = std::make_shared<DataShareResultSet>();
321 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
322 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet));
323 EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(E_OK));
324 EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
325 EXPECT_CALL(*resultSetMock_, GetString(_, _)).WillOnce(Return(E_OK));
326 SettingsDataManager::settingsDataMap_.EnsureInsert(SYNC_SWITCH_KEY, "1");
327 SwitchStatus status = SettingsDataManager::GetSwitchStatus();
328 EXPECT_EQ(status, SwitchStatus::NONE);
329
330 SettingsDataManager::settingsDataMap_.Clear();
331 GTEST_LOG_(INFO) << "GetSwitchStatusTest004 End";
332 }
333
334 HWTEST_F(SettingsDataManagerTest, GetSwitchStatusTest005, TestSize.Level1)
335 {
336 GTEST_LOG_(INFO) << "GetSwitchStatusTest005 Start";
337 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
338 std::shared_ptr<DataShareResultSet> resultSet = std::make_shared<DataShareResultSet>();
339 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
340 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).WillOnce(Return(resultSet));
341 EXPECT_CALL(*resultSetMock_, GoToFirstRow()).WillOnce(Return(E_OK));
342 EXPECT_CALL(*resultSetMock_, GetColumnIndex(_, _)).WillOnce(Return(E_OK));
343 EXPECT_CALL(*resultSetMock_, GetString(_, _)).WillOnce(Return(E_OK));
344 SettingsDataManager::settingsDataMap_.EnsureInsert(SYNC_SWITCH_KEY, "0");
345 SwitchStatus status = SettingsDataManager::GetSwitchStatus();
346 EXPECT_EQ(status, SwitchStatus::NONE);
347
348 SettingsDataManager::settingsDataMap_.Clear();
349 GTEST_LOG_(INFO) << "GetSwitchStatusTest005 End";
350 }
351
352 HWTEST_F(SettingsDataManagerTest, GetNetworkConnectionStatusTest001, TestSize.Level1)
353 {
354 GTEST_LOG_(INFO) << "GetNetworkConnectionStatusTest001 Start";
355 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr));
356 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
357 bool status = SettingsDataManager::GetNetworkConnectionStatus();
358 EXPECT_EQ(status, true);
359
360 GTEST_LOG_(INFO) << "GetNetworkConnectionStatusTest001 End";
361 }
362
363 HWTEST_F(SettingsDataManagerTest, GetNetworkConnectionStatusTest002, TestSize.Level1)
364 {
365 GTEST_LOG_(INFO) << "GetNetworkConnectionStatusTest002 Start";
366 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0);
367 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
368 SettingsDataManager::settingsDataMap_.EnsureInsert(NETWORK_CONNECTION_KEY, "off");
369 bool status = SettingsDataManager::GetNetworkConnectionStatus();
370 EXPECT_EQ(status, false);
371
372 SettingsDataManager::settingsDataMap_.Clear();
373 GTEST_LOG_(INFO) << "GetNetworkConnectionStatusTest002 End";
374 }
375
376 HWTEST_F(SettingsDataManagerTest, GetNetworkConnectionStatusTest003, TestSize.Level1)
377 {
378 GTEST_LOG_(INFO) << "GetNetworkConnectionStatusTest003 Start";
379 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0);
380 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
381 SettingsDataManager::settingsDataMap_.EnsureInsert(NETWORK_CONNECTION_KEY, "on");
382 bool status = SettingsDataManager::GetNetworkConnectionStatus();
383 EXPECT_EQ(status, true);
384
385 SettingsDataManager::settingsDataMap_.Clear();
386 GTEST_LOG_(INFO) << "GetNetworkConnectionStatusTest003 End";
387 }
388
389 HWTEST_F(SettingsDataManagerTest, GetLocalSpaceFreeStatusTest001, TestSize.Level1)
390 {
391 GTEST_LOG_(INFO) << "GetLocalSpaceFreeStatusTest001 Start";
392 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr));
393 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
394 int32_t status = SettingsDataManager::GetLocalSpaceFreeStatus();
395 EXPECT_EQ(status, 1);
396 GTEST_LOG_(INFO) << "GetLocalSpaceFreeStatusTest001 End";
397 }
398
399 HWTEST_F(SettingsDataManagerTest, GetLocalSpaceFreeStatusTest002, TestSize.Level1)
400 {
401 GTEST_LOG_(INFO) << "GetLocalSpaceFreeStatusTest002 Start";
402 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0);
403 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
404 SettingsDataManager::settingsDataMap_.EnsureInsert(LOCAL_SPACE_FREE_KEY, "1");
405 int32_t status = SettingsDataManager::GetLocalSpaceFreeStatus();
406 EXPECT_EQ(status, 1);
407 SettingsDataManager::settingsDataMap_.Clear();
408 GTEST_LOG_(INFO) << "GetLocalSpaceFreeStatusTest002 End";
409 }
410
411 HWTEST_F(SettingsDataManagerTest, GetLocalSpaceFreeStatusTest003, TestSize.Level1)
412 {
413 GTEST_LOG_(INFO) << "GetLocalSpaceFreeStatusTest003 Start";
414 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0);
415 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
416 SettingsDataManager::settingsDataMap_.EnsureInsert(LOCAL_SPACE_FREE_KEY, "0");
417 int32_t status = SettingsDataManager::GetLocalSpaceFreeStatus();
418 EXPECT_EQ(status, 0);
419 SettingsDataManager::settingsDataMap_.Clear();
420 GTEST_LOG_(INFO) << "GetLocalSpaceFreeStatusTest003 End";
421 }
422
423 HWTEST_F(SettingsDataManagerTest, GetLocalSpaceFreeDaysTest001, TestSize.Level1)
424 {
425 GTEST_LOG_(INFO) << "GetLocalSpaceFreeDaysTest001 Start";
426 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr));
427 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
428 int32_t status = SettingsDataManager::GetLocalSpaceFreeDays();
429 EXPECT_EQ(status, 30);
430 GTEST_LOG_(INFO) << "GetLocalSpaceFreeDaysTest001 End";
431 }
432
433 HWTEST_F(SettingsDataManagerTest, GetLocalSpaceFreeDaysTest002, TestSize.Level1)
434 {
435 GTEST_LOG_(INFO) << "GetLocalSpaceFreeDaysTest002 Start";
436 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0);
437 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
438 SettingsDataManager::settingsDataMap_.EnsureInsert(LOCAL_SPACE_DAYS_KEY, "10");
439 int32_t status = SettingsDataManager::GetLocalSpaceFreeDays();
440 EXPECT_EQ(status, 10);
441 SettingsDataManager::settingsDataMap_.Clear();
442 GTEST_LOG_(INFO) << "GetLocalSpaceFreeDaysTest002 End";
443 }
444
445 HWTEST_F(SettingsDataManagerTest, GetLocalSpaceFreeDaysTest003, TestSize.Level1)
446 {
447 GTEST_LOG_(INFO) << "GetLocalSpaceFreeDaysTest003 Start";
448 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0);
449 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
450 SettingsDataManager::settingsDataMap_.EnsureInsert(LOCAL_SPACE_DAYS_KEY, "");
451 int32_t status = SettingsDataManager::GetLocalSpaceFreeDays();
452 EXPECT_EQ(status, 30);
453 SettingsDataManager::settingsDataMap_.Clear();
454 GTEST_LOG_(INFO) << "GetLocalSpaceFreeDaysTest003 End";
455 }
456
457 HWTEST_F(SettingsDataManagerTest, GetLocalSpaceFreeDaysTest004, TestSize.Level1)
458 {
459 GTEST_LOG_(INFO) << "GetLocalSpaceFreeDaysTest004 Start";
460 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0);
461 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
462 SettingsDataManager::settingsDataMap_.EnsureInsert(LOCAL_SPACE_DAYS_KEY, "xx");
463 int32_t status = SettingsDataManager::GetLocalSpaceFreeDays();
464 EXPECT_EQ(status, 30);
465 SettingsDataManager::settingsDataMap_.Clear();
466 GTEST_LOG_(INFO) << "GetLocalSpaceFreeDaysTest004 End";
467 }
468
469 HWTEST_F(SettingsDataManagerTest, GetMobileDataStatusTest001, TestSize.Level1)
470 {
471 GTEST_LOG_(INFO) << "GetMobileDataStatusTest001 Start";
472 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr));
473 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
474 bool status = SettingsDataManager::GetMobileDataStatus();
475 EXPECT_EQ(status, false);
476
477 GTEST_LOG_(INFO) << "GetMobileDataStatusTest001 End";
478 }
479
480 HWTEST_F(SettingsDataManagerTest, GetMobileDataStatusTest002, TestSize.Level1)
481 {
482 GTEST_LOG_(INFO) << "GetMobileDataStatusTest002 Start";
483 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0);
484 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
485 SettingsDataManager::settingsDataMap_.EnsureInsert(MOBILE_DATA_SYNC_KEY, "0");
486 bool status = SettingsDataManager::GetMobileDataStatus();
487 EXPECT_EQ(status, false);
488
489 SettingsDataManager::settingsDataMap_.Clear();
490 GTEST_LOG_(INFO) << "GetMobileDataStatusTest002 end";
491 }
492
493 HWTEST_F(SettingsDataManagerTest, GetMobileDataStatusTest003, TestSize.Level1)
494 {
495 GTEST_LOG_(INFO) << "GetMobileDataStatusTest003 Start";
496 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).Times(0);
497 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
498 SettingsDataManager::settingsDataMap_.EnsureInsert(MOBILE_DATA_SYNC_KEY, "1");
499 bool status = SettingsDataManager::GetMobileDataStatus();
500 EXPECT_EQ(status, true);
501
502 SettingsDataManager::settingsDataMap_.Clear();
503 GTEST_LOG_(INFO) << "GetMobileDataStatusTest003 end";
504 }
505
506 HWTEST_F(SettingsDataManagerTest, RegisterObserverTest001, TestSize.Level1)
507 {
508 GTEST_LOG_(INFO) << "RegisterObserverTest001 Start";
509 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr));
510 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
511 SettingsDataManager::RegisterObserver("");
512 EXPECT_TRUE(true);
513
514 GTEST_LOG_(INFO) << "RegisterObserverTest001 End";
515 }
516
517 HWTEST_F(SettingsDataManagerTest, RegisterObserverTest002, TestSize.Level1)
518 {
519 GTEST_LOG_(INFO) << "RegisterObserverTest002 Start";
520 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
521 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
522 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
523 SettingsDataManager::RegisterObserver("");
524 EXPECT_TRUE(true);
525
526 GTEST_LOG_(INFO) << "RegisterObserverTest002 End";
527 }
528
529 HWTEST_F(SettingsDataManagerTest, RegisterObserverTest003, TestSize.Level1)
530 {
531 GTEST_LOG_(INFO) << "RegisterObserverTest003 Start";
532 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr));
533 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
534 SettingsDataManager::RegisterObserver("", nullptr);
535 EXPECT_TRUE(true);
536
537 GTEST_LOG_(INFO) << "RegisterObserverTest003 End";
538 }
539
540 HWTEST_F(SettingsDataManagerTest, RegisterObserverTest004, TestSize.Level1)
541 {
542 GTEST_LOG_(INFO) << "RegisterObserverTest004 Start";
543 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
544 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
545 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
546 SettingsDataManager::RegisterObserver("", nullptr);
547 EXPECT_TRUE(true);
548
549 GTEST_LOG_(INFO) << "RegisterObserverTest004 End";
550 }
551
552 HWTEST_F(SettingsDataManagerTest, UnregisterObserverTest001, TestSize.Level1)
553 {
554 GTEST_LOG_(INFO) << "UnregisterObserverTest001 Start";
555 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(nullptr));
556 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
557 SettingsDataManager::UnregisterObserver("");
558 EXPECT_TRUE(true);
559
560 GTEST_LOG_(INFO) << "UnregisterObserverTest001 End";
561 }
562
563 HWTEST_F(SettingsDataManagerTest, UnregisterObserverTest002, TestSize.Level1)
564 {
565 GTEST_LOG_(INFO) << "UnregisterObserverTest002 Start";
566 std::shared_ptr<DataShareHelper> dataShareHelper = std::make_shared<DataShareHelper>();
567 EXPECT_CALL(*dataShareHelperMock_, Creator(_, _, _)).WillOnce(Return(dataShareHelper));
568 EXPECT_CALL(*dataShareHelperMock_, Query(_, _, _, _)).Times(0);
569 SettingsDataManager::UnregisterObserver("");
570 EXPECT_TRUE(true);
571
572 GTEST_LOG_(INFO) << "UnregisterObserverTest002 End";
573 }
574
575 HWTEST_F(SettingsDataManagerTest, QueryTest001, TestSize.Level1)
576 {
577 GTEST_LOG_(INFO) << "QueryTest001 Start";
578 DataShareHelperMock::proxy_ = nullptr;
579 DataShareResultSetMock::proxy_ = nullptr;
580 int32_t ret = -1;
581 int32_t size = -1;
582 ret = SettingsDataManager::QuerySwitchStatus();
583 EXPECT_EQ(ret, E_OK);
584 size = SettingsDataManager::settingsDataMap_.Size();
585 EXPECT_EQ(size, 1);
586
587 ret = SettingsDataManager::QueryNetworkConnectionStatus();
588 EXPECT_EQ(ret, E_OK);
589 size = SettingsDataManager::settingsDataMap_.Size();
590 EXPECT_EQ(size, 2);
591
592 ret = SettingsDataManager::QueryLocalSpaceFreeStatus();
593 EXPECT_EQ(ret, E_OK);
594 size = SettingsDataManager::settingsDataMap_.Size();
595 EXPECT_EQ(size, 3);
596
597 ret = SettingsDataManager::QueryLocalSpaceFreeDays();
598 EXPECT_EQ(ret, E_OK);
599 size = SettingsDataManager::settingsDataMap_.Size();
600 EXPECT_EQ(size, 4);
601
602 ret = SettingsDataManager::QueryMobileDataStatus();
603 EXPECT_EQ(ret, E_OK);
604 size = SettingsDataManager::settingsDataMap_.Size();
605 EXPECT_EQ(size, 5);
606
607 GTEST_LOG_(INFO) << "QueryTest001 End";
608 }
609
610 HWTEST_F(SettingsDataManagerTest, OnChangeTest001, TestSize.Level1)
611 {
612 GTEST_LOG_(INFO) << "OnChangeTest001 Start";
613 DataShareHelperMock::proxy_ = nullptr;
614 DataShareResultSetMock::proxy_ = nullptr;
615
616 SettingsDataObserver observer1(SYNC_SWITCH_KEY);
617 observer1.OnChange();
618
619 SettingsDataObserver observer2(NETWORK_CONNECTION_KEY);
620 observer2.OnChange();
621
622 SettingsDataObserver observer3(LOCAL_SPACE_FREE_KEY);
623 observer3.OnChange();
624
625 SettingsDataObserver observer4(LOCAL_SPACE_DAYS_KEY);
626 observer4.OnChange();
627
628 SettingsDataObserver observer5(MOBILE_DATA_SYNC_KEY);
629 observer5.OnChange();
630
631 GTEST_LOG_(INFO) << "OnChangeTest001 End";
632 }
633 }