1 /*
2 * Copyright (c) 2024 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 <gtest/gtest.h>
17 #include <gmock/gmock.h>
18
19 // mock
20 #include "data_ability_observer_stub.h"
21 #include "datashare_helper.h"
22 #include "ipc_skeleton.h"
23 #include "iremote_object.h"
24 #include "if_system_ability_manager.h"
25 #include "iservice_registry.h"
26 #include "system_ability_definition.h"
27
28 #define private public
29 #include "setting_data_manager.h"
30 #undef private
31
32 using namespace testing;
33 using namespace testing::ext;
34
35 namespace OHOS::ArkUi::UiAppearance {
36 namespace {
37 constexpr const char* TEST_KEY1 = "testKey1";
38 constexpr const char* TEST_KEY2 = "testKey2";
39 constexpr const char* TEST_KEY3 = "testKey3";
40 constexpr const char* TEST_VAL1 = "testVal1";
41 constexpr const char* TEST_VAL2 = "testVal2";
42 constexpr const char* TEST_VAL3 = "testVal3";
43 constexpr int32_t TEST_USER100 = 100;
44 constexpr int32_t TEST_USER1 = 1;
45 constexpr const char* SETTING_DATA_URI =
46 "datashare:///com.ohos.settingsdata/entry/settingsdata/SETTINGSDATA?Proxy=true";
47 constexpr const char* SETTING_DATA_USER_URI_PREFIX =
48 "datashare:///com.ohos.settingsdata/entry/settingsdata/USER_SETTINGSDATA_";
49 constexpr const char* SETTING_DATA_USER_URI_SUFFIX = "?Proxy=true";
50 constexpr const char* SETTING_DATA_EXT_URI = "datashare:///com.ohos.settingsdata.DataAbility";
51 constexpr const char* SETTING_DATA_KEY_URI = "&key=";
52 constexpr const char* SETTING_DATA_COLUMN_KEYWORD = "KEYWORD";
53 constexpr const char* SETTING_DATA_COLUMN_VALUE = "VALUE";
54
GetUserUri(const int32_t userId)55 std::string GetUserUri(const int32_t userId)
56 {
57 if (userId == INVALID_USER_ID) {
58 return SETTING_DATA_URI;
59 }
60 return SETTING_DATA_USER_URI_PREFIX + std::to_string(userId) + SETTING_DATA_USER_URI_SUFFIX;
61 }
62
GetUserUriWithKey(const int32_t userId,const std::string & key)63 std::string GetUserUriWithKey(const int32_t userId, const std::string& key)
64 {
65 if (userId == INVALID_USER_ID) {
66 std::string uriString = SETTING_DATA_URI;
67 uriString.append(SETTING_DATA_KEY_URI + key);
68 return uriString;
69 }
70 std::string uriString = SETTING_DATA_USER_URI_PREFIX;
71 uriString.append(std::to_string(userId) + SETTING_DATA_USER_URI_SUFFIX);
72 uriString.append(SETTING_DATA_KEY_URI + key);
73 return uriString;
74 }
75
GenerateObserverName(const int32_t userId,const std::string & key)76 std::string GenerateObserverName(const int32_t userId, const std::string& key)
77 {
78 return key + "::" + std::to_string(userId);
79 }
80 }
81
82 class SettingDataManagerInitializeTest : public Test {
83 protected:
TearDown()84 void TearDown() override
85 {
86 SettingDataManager& manager = SettingDataManager::GetInstance();
87 manager.isInitialized_ = false;
88 manager.remoteObject_ = nullptr;
89 manager.observers_.clear();
90 }
91 };
92
93 class SettingDataManagerTest : public Test {
94 protected:
95 sptr<IRemoteObject> object_ = sptr<IRemoteObject>::MakeSptr();
96 sptr<ISystemAbilityManager> saMgr_ = sptr<ISystemAbilityManager>::MakeSptr();
97
SetUp()98 void SetUp() override
99 {
100 SettingDataManager& manager = SettingDataManager::GetInstance();
101 SystemAbilityManagerClient& client = SystemAbilityManagerClient::GetInstance();
102 EXPECT_CALL(client, GetSystemAbilityManager()).Times(1).WillOnce(Return(saMgr_));
103 EXPECT_CALL(*saMgr_, GetSystemAbility(ARKUI_UI_APPEARANCE_SERVICE_ID)).Times(1).WillOnce(Return(object_));
104 EXPECT_EQ(manager.Initialize(), ERR_OK);
105 EXPECT_EQ(manager.IsInitialized(), true);
106 EXPECT_EQ(manager.remoteObject_, object_);
107 }
108
TearDown()109 void TearDown() override
110 {
111 SettingDataManager& manager = SettingDataManager::GetInstance();
112 manager.isInitialized_ = false;
113 manager.remoteObject_ = nullptr;
114 manager.observers_.clear();
115 }
116
RegisterObserverCreateFailTest(const int32_t userId,const std::string & key) const117 void RegisterObserverCreateFailTest(const int32_t userId, const std::string& key) const
118 {
119 GTEST_LOG_(INFO) << "RegisterObserverCreateFailTest userId: " << userId << ", key: " << key;
120 HelperCreateFailTest(userId);
121 SettingDataManager& manager = SettingDataManager::GetInstance();
122 size_t observerSize = manager.observers_.size();
123 EXPECT_EQ(manager.observers_.size(), observerSize);
124 EXPECT_EQ(manager.RegisterObserver(key, nullptr, userId), ERR_NO_INIT);
125 EXPECT_EQ(manager.observers_.size(), observerSize);
126 }
127
RegisterObserverTest(const int32_t userId,const std::string & key) const128 void RegisterObserverTest(const int32_t userId, const std::string& key) const
129 {
130 GTEST_LOG_(INFO) << "RegisterObserverTest userId: " << userId << ", key: " << key;
131 ExpectationSet expectationSet;
132 HelperCreateTest(userId, expectationSet);
133
134 auto checkRegisterObserver = [userId, key](const Uri& uri, const sptr<AAFwk::IDataAbilityObserver>& obs) {
135 EXPECT_EQ(uri.ToString(), GetUserUriWithKey(userId, key));
136 auto* settingDataObserver = static_cast<SettingDataObserver *>(obs.GetRefPtr());
137 EXPECT_EQ(settingDataObserver->GetKey(), key);
138 EXPECT_EQ(settingDataObserver->GetUserId(), userId);
139 };
140 expectationSet += EXPECT_CALL(*myHelper_, RegisterObserver(_, _))
141 .Times(1).After(expectationSet).WillOnce(Invoke(checkRegisterObserver));
142
143 HelperNotifyChangeTest(expectationSet, key, userId);
144 HelperReleaseTest(expectationSet);
145 SettingDataManager& manager = SettingDataManager::GetInstance();
146 size_t observerSize = manager.observers_.size();
147 EXPECT_EQ(manager.RegisterObserver(key, nullptr, userId), ERR_OK);
148 EXPECT_EQ(manager.observers_.size(), observerSize + 1);
149 EXPECT_EQ(manager.RegisterObserver(key, nullptr, userId), ERR_OK);
150 EXPECT_EQ(manager.observers_.size(), observerSize + 1);
151 }
152
UnregisterObserverCreateFailTest(const int32_t userId,const std::string & key) const153 void UnregisterObserverCreateFailTest(const int32_t userId, const std::string& key) const
154 {
155 GTEST_LOG_(INFO) << "UnregisterObserverCreateFailTest userId: " << userId << ", key: " << key;
156 HelperCreateFailTest(userId);
157 SettingDataManager& manager = SettingDataManager::GetInstance();
158 size_t observerSize = manager.observers_.size();
159 EXPECT_EQ(manager.observers_.size(), observerSize);
160 EXPECT_EQ(manager.UnregisterObserver(key, userId), ERR_NO_INIT);
161 EXPECT_EQ(manager.observers_.size(), observerSize - 1);
162 }
163
UnregisterObserverTest(const int32_t userId,const std::string & key) const164 void UnregisterObserverTest(const int32_t userId, const std::string& key) const
165 {
166 GTEST_LOG_(INFO) << "UnregisterObserverTest userId: " << userId << ", key: " << key;
167 ExpectationSet expectationSet;
168 HelperCreateTest(userId, expectationSet);
169
170 auto checkUnregisterObserver = [userId, key](const Uri& uri, const sptr<AAFwk::IDataAbilityObserver>& obs) {
171 EXPECT_EQ(uri.ToString(), GetUserUriWithKey(userId, key));
172 auto* settingDataObserver = static_cast<SettingDataObserver *>(obs.GetRefPtr());
173 EXPECT_EQ(settingDataObserver->GetKey(), key);
174 EXPECT_EQ(settingDataObserver->GetUserId(), userId);
175 };
176 expectationSet += EXPECT_CALL(*myHelper_, UnregisterObserver(_, _))
177 .Times(1).After(expectationSet).WillOnce(Invoke(checkUnregisterObserver));
178
179 HelperReleaseTest(expectationSet);
180 SettingDataManager& manager = SettingDataManager::GetInstance();
181 size_t observerSize = manager.observers_.size();
182 EXPECT_EQ(manager.UnregisterObserver(key, userId), ERR_OK);
183 EXPECT_EQ(manager.observers_.size(), observerSize - 1);
184 EXPECT_EQ(manager.UnregisterObserver(key, userId), ERR_INVALID_VALUE);
185 EXPECT_EQ(manager.observers_.size(), observerSize - 1);
186 }
187
SetStringValueCreateFailTest(const std::string & key,const std::string & value,const int32_t userId,const bool needNotify) const188 void SetStringValueCreateFailTest(const std::string& key,
189 const std::string& value, const int32_t userId, const bool needNotify) const
190 {
191 GTEST_LOG_(INFO) << "SetStringValueCreateFailTest userId: " << userId << ", key: " << key;
192 HelperCreateFailTest(userId);
193 SettingDataManager& manager = SettingDataManager::GetInstance();
194 EXPECT_EQ(manager.SetStringValue(key, value, userId, needNotify), ERR_NO_INIT);
195 }
196
SetStringValueInsertAndUpdateFailTest(const std::string & key,const std::string & value,const int32_t userId,const bool needNotify) const197 void SetStringValueInsertAndUpdateFailTest(const std::string& key,
198 const std::string& value, const int32_t userId, const bool needNotify) const
199 {
200 GTEST_LOG_(INFO) << "SetStringValueInsertAndUpdateFailTest userId: " << userId << ", key: " << key;
201 SetStringValueInsertAndUpdateFailInnerTest(key, value, userId, needNotify);
202 SettingDataManager& manager = SettingDataManager::GetInstance();
203 EXPECT_EQ(manager.SetStringValue(key, value, userId, needNotify), ERR_INVALID_OPERATION);
204 }
205
SetStringValueUpdateTest(const std::string & key,const std::string & value,const int32_t userId,const bool needNotify) const206 void SetStringValueUpdateTest(const std::string& key,
207 const std::string& value, const int32_t userId, const bool needNotify) const
208 {
209 GTEST_LOG_(INFO) << "SetStringValueUpdateTest userId: " << userId << ", key: " << key;
210 SetStringValueUpdateInnerTest(key, value, userId, needNotify);
211 SettingDataManager& manager = SettingDataManager::GetInstance();
212 EXPECT_EQ(manager.SetStringValue(key, value, userId, needNotify), ERR_OK);
213 }
214
SetStringValueInsertTest(const std::string & key,const std::string & value,const int32_t userId,const bool needNotify) const215 void SetStringValueInsertTest(const std::string& key,
216 const std::string& value, const int32_t userId, const bool needNotify) const
217 {
218 GTEST_LOG_(INFO) << "SetStringValueInsertTest userId: " << userId << ", key: " << key;
219 SetStringValueInsertInnerTest(key, value, userId, needNotify);
220 SettingDataManager& manager = SettingDataManager::GetInstance();
221 EXPECT_EQ(manager.SetStringValue(key, value, userId, needNotify), ERR_OK);
222 }
223
SetInt32ValueCreateFailTest(const std::string & key,const int32_t value,const int32_t userId,const bool needNotify) const224 void SetInt32ValueCreateFailTest(const std::string& key,
225 const int32_t value, const int32_t userId, const bool needNotify) const
226 {
227 GTEST_LOG_(INFO) << "SetInt32ValueCreateFailTest userId: " << userId << ", key: " << key;
228 HelperCreateFailTest(userId);
229 SettingDataManager& manager = SettingDataManager::GetInstance();
230 EXPECT_EQ(manager.SetInt32Value(key, value, userId, needNotify), ERR_NO_INIT);
231 }
232
SetInt32ValueInsertAndUpdateFailTest(const std::string & key,const int32_t value,const int32_t userId,const bool needNotify) const233 void SetInt32ValueInsertAndUpdateFailTest(const std::string& key,
234 const int32_t value, const int32_t userId, const bool needNotify) const
235 {
236 GTEST_LOG_(INFO) << "SetInt32ValueInsertAndUpdateFailTest userId: " << userId << ", key: " << key;
237 SetStringValueInsertAndUpdateFailInnerTest(key, std::to_string(value), userId, needNotify);
238 SettingDataManager& manager = SettingDataManager::GetInstance();
239 EXPECT_EQ(manager.SetInt32Value(key, value, userId, needNotify), ERR_INVALID_OPERATION);
240 }
241
SetInt32ValueUpdateTest(const std::string & key,const int32_t value,const int32_t userId,const bool needNotify) const242 void SetInt32ValueUpdateTest(const std::string& key,
243 const int32_t value, const int32_t userId, const bool needNotify) const
244 {
245 GTEST_LOG_(INFO) << "SetInt32ValueUpdateTest userId: " << userId << ", key: " << key;
246 SetStringValueUpdateInnerTest(key, std::to_string(value), userId, needNotify);
247 SettingDataManager& manager = SettingDataManager::GetInstance();
248 EXPECT_EQ(manager.SetInt32Value(key, value, userId, needNotify), ERR_OK);
249 }
250
SetInt32ValueInsertTest(const std::string & key,const int32_t value,const int32_t userId,const bool needNotify) const251 void SetInt32ValueInsertTest(const std::string& key,
252 const int32_t value, const int32_t userId, const bool needNotify) const
253 {
254 GTEST_LOG_(INFO) << "SetInt32ValueInsertTest userId: " << userId << ", key: " << key;
255 SetStringValueInsertInnerTest(key, std::to_string(value), userId, needNotify);
256 SettingDataManager& manager = SettingDataManager::GetInstance();
257 EXPECT_EQ(manager.SetInt32Value(key, value, userId, needNotify), ERR_OK);
258 }
259
SetBoolValueCreateFailTest(const std::string & key,const bool value,const int32_t userId,const bool needNotify) const260 void SetBoolValueCreateFailTest(const std::string& key,
261 const bool value, const int32_t userId, const bool needNotify) const
262 {
263 GTEST_LOG_(INFO) << "SetBoolValueCreateFailTest userId: " << userId << ", key: " << key;
264 HelperCreateFailTest(userId);
265 SettingDataManager& manager = SettingDataManager::GetInstance();
266 EXPECT_EQ(manager.SetBoolValue(key, value, userId, needNotify), ERR_NO_INIT);
267 }
268
SetBoolValueInsertAndUpdateFailTest(const std::string & key,const bool value,const int32_t userId,const bool needNotify) const269 void SetBoolValueInsertAndUpdateFailTest(const std::string& key,
270 const bool value, const int32_t userId, const bool needNotify) const
271 {
272 GTEST_LOG_(INFO) << "SetBoolValueInsertAndUpdateFailTest userId: " << userId << ", key: " << key;
273 SetStringValueInsertAndUpdateFailInnerTest(key, value ? "true" : "false", userId, needNotify);
274 SettingDataManager& manager = SettingDataManager::GetInstance();
275 EXPECT_EQ(manager.SetBoolValue(key, value, userId, needNotify), ERR_INVALID_OPERATION);
276 }
277
SetBoolValueUpdateTest(const std::string & key,const bool value,const int32_t userId,const bool needNotify) const278 void SetBoolValueUpdateTest(const std::string& key,
279 const bool value, const int32_t userId, const bool needNotify) const
280 {
281 GTEST_LOG_(INFO) << "SetBoolValueUpdateTest userId: " << userId << ", key: " << key;
282 SetStringValueUpdateInnerTest(key, value ? "true" : "false", userId, needNotify);
283 SettingDataManager& manager = SettingDataManager::GetInstance();
284 EXPECT_EQ(manager.SetBoolValue(key, value, userId, needNotify), ERR_OK);
285 }
286
SetBoolValueInsertTest(const std::string & key,const bool value,const int32_t userId,const bool needNotify) const287 void SetBoolValueInsertTest(const std::string& key,
288 const bool value, const int32_t userId, const bool needNotify) const
289 {
290 GTEST_LOG_(INFO) << "SetBoolValueInsertTest userId: " << userId << ", key: " << key;
291 SetStringValueInsertInnerTest(key, value ? "true" : "false", userId, needNotify);
292 SettingDataManager& manager = SettingDataManager::GetInstance();
293 EXPECT_EQ(manager.SetBoolValue(key, value, userId, needNotify), ERR_OK);
294 }
295
GetStringValueCreateFailTest(const std::string & key,const int32_t userId) const296 void GetStringValueCreateFailTest(const std::string& key, const int32_t userId) const
297 {
298 GTEST_LOG_(INFO) << "GetStringValueCreateFailTest userId: " << userId << ", key: " << key;
299 HelperCreateFailTest(userId);
300 SettingDataManager& manager = SettingDataManager::GetInstance();
301 std::string value;
302 EXPECT_EQ(manager.GetStringValue(key, value, userId), ERR_NO_INIT);
303 }
304
GetStringValueQueryNullTest(const std::string & key,const int32_t userId) const305 void GetStringValueQueryNullTest(const std::string& key, const int32_t userId) const
306 {
307 GTEST_LOG_(INFO) << "GetStringValueQueryNullTest userId: " << userId << ", key: " << key;
308 GetStringValueQueryNullInnerTest(key, userId);
309 SettingDataManager& manager = SettingDataManager::GetInstance();
310 std::string value;
311 EXPECT_EQ(manager.GetStringValue(key, value, userId), ERR_INVALID_OPERATION);
312 }
313
GetStringValueResultNotFoundTest(const std::string & key,const int32_t userId) const314 void GetStringValueResultNotFoundTest(const std::string& key, const int32_t userId) const
315 {
316 GTEST_LOG_(INFO) << "GetStringValueResultNotFoundTest userId: " << userId << ", key: " << key;
317 GetStringValueResultNotFoundInnerTest(key, userId);
318 SettingDataManager& manager = SettingDataManager::GetInstance();
319 std::string value;
320 EXPECT_EQ(manager.GetStringValue(key, value, userId), ERR_NAME_NOT_FOUND);
321 }
322
GetStringValueResultGetStringFailTest(const std::string & key,const int32_t userId) const323 void GetStringValueResultGetStringFailTest(const std::string& key, const int32_t userId) const
324 {
325 GTEST_LOG_(INFO) << "GetStringValueResultGetStringFailTest userId: " << userId << ", key: " << key;
326 GetStringValueResultGetStringFailInnerTest(key, userId);
327 SettingDataManager& manager = SettingDataManager::GetInstance();
328 std::string value;
329 EXPECT_EQ(manager.GetStringValue(key, value, userId), ERR_INVALID_VALUE);
330 }
331
GetStringValueResultTest(const std::string & key,const std::string & valueExpect,const int32_t userId) const332 void GetStringValueResultTest(const std::string& key, const std::string& valueExpect, const int32_t userId) const
333 {
334 GTEST_LOG_(INFO) << "GetStringValueResultTest userId: " << userId << ", key: " << key << ", value: " <<
335 valueExpect;
336 GetStringValueResultInnerTest(key, userId, valueExpect);
337 SettingDataManager& manager = SettingDataManager::GetInstance();
338 std::string value;
339 EXPECT_EQ(manager.GetStringValue(key, value, userId), ERR_OK);
340 EXPECT_EQ(value, valueExpect);
341 }
342
GetInt32ValueCreateFailTest(const std::string & key,const int32_t userId) const343 void GetInt32ValueCreateFailTest(const std::string& key, const int32_t userId) const
344 {
345 GTEST_LOG_(INFO) << "GetInt32ValueCreateFailTest userId: " << userId << ", key: " << key;
346 HelperCreateFailTest(userId);
347 SettingDataManager& manager = SettingDataManager::GetInstance();
348 int32_t value;
349 EXPECT_EQ(manager.GetInt32Value(key, value, userId), ERR_NO_INIT);
350 }
351
GetInt32ValueQueryNullTest(const std::string & key,const int32_t userId) const352 void GetInt32ValueQueryNullTest(const std::string& key, const int32_t userId) const
353 {
354 GTEST_LOG_(INFO) << "GetInt32ValueQueryNullTest userId: " << userId << ", key: " << key;
355 GetStringValueQueryNullInnerTest(key, userId);
356 SettingDataManager& manager = SettingDataManager::GetInstance();
357 int32_t value;
358 EXPECT_EQ(manager.GetInt32Value(key, value, userId), ERR_INVALID_OPERATION);
359 }
360
GetInt32ValueResultNotFoundTest(const std::string & key,const int32_t userId) const361 void GetInt32ValueResultNotFoundTest(const std::string& key, const int32_t userId) const
362 {
363 GTEST_LOG_(INFO) << "GetInt32ValueResultNotFoundTest userId: " << userId << ", key: " << key;
364 GetStringValueResultNotFoundInnerTest(key, userId);
365 SettingDataManager& manager = SettingDataManager::GetInstance();
366 int32_t value;
367 EXPECT_EQ(manager.GetInt32Value(key, value, userId), ERR_NAME_NOT_FOUND);
368 }
369
GetInt32ValueResultGetStringFailTest(const std::string & key,const int32_t userId) const370 void GetInt32ValueResultGetStringFailTest(const std::string& key, const int32_t userId) const
371 {
372 GTEST_LOG_(INFO) << "GetInt32ValueResultGetStringFailTest userId: " << userId << ", key: " << key;
373 GetStringValueResultGetStringFailInnerTest(key, userId);
374 SettingDataManager& manager = SettingDataManager::GetInstance();
375 int32_t value;
376 EXPECT_EQ(manager.GetInt32Value(key, value, userId), ERR_INVALID_VALUE);
377 }
378
GetInt32ValueResultTest(const std::string & key,const int32_t userId,const int32_t valueExpect,const std::string & savedVal,const int32_t code) const379 void GetInt32ValueResultTest(const std::string& key, const int32_t userId,
380 const int32_t valueExpect, const std::string& savedVal, const int32_t code) const
381 {
382 GTEST_LOG_(INFO) << "GetInt32ValueResultTest userId: " << userId << ", key: " << key << ", value: " <<
383 savedVal;
384 GetStringValueResultInnerTest(key, userId, savedVal);
385 SettingDataManager& manager = SettingDataManager::GetInstance();
386 int32_t value;
387 EXPECT_EQ(manager.GetInt32Value(key, value, userId), code);
388 if (code == ERR_OK) {
389 EXPECT_EQ(value, valueExpect);
390 }
391 }
392
GetInt32ValueStrictlyResultTest(const std::string & key,const int32_t userId,const int32_t valueExpect,const std::string & savedVal,const int32_t code) const393 void GetInt32ValueStrictlyResultTest(const std::string& key, const int32_t userId,
394 const int32_t valueExpect, const std::string& savedVal, const int32_t code) const
395 {
396 GTEST_LOG_(INFO) << "GetInt32ValueStrictlyResultTest userId: " << userId << ", key: " << key;
397 GetStringValueResultInnerTest(key, userId, savedVal);
398 SettingDataManager& manager = SettingDataManager::GetInstance();
399 int32_t value;
400 EXPECT_EQ(manager.GetInt32ValueStrictly(key, value, userId), code);
401 if (code == ERR_OK) {
402 EXPECT_EQ(value, valueExpect);
403 }
404 }
405
GetBoolValueCreateFailTest(const std::string & key,const int32_t userId) const406 void GetBoolValueCreateFailTest(const std::string& key, const int32_t userId) const
407 {
408 GTEST_LOG_(INFO) << "GetBoolValueCreateFailTest userId: " << userId << ", key: " << key;
409 HelperCreateFailTest(userId);
410 SettingDataManager& manager = SettingDataManager::GetInstance();
411 bool value;
412 EXPECT_EQ(manager.GetBoolValue(key, value, userId), ERR_NO_INIT);
413 }
414
GetBoolValueQueryNullTest(const std::string & key,const int32_t userId) const415 void GetBoolValueQueryNullTest(const std::string& key, const int32_t userId) const
416 {
417 GTEST_LOG_(INFO) << "GetBoolValueQueryNullTest userId: " << userId << ", key: " << key;
418 GetStringValueQueryNullInnerTest(key, userId);
419 SettingDataManager& manager = SettingDataManager::GetInstance();
420 bool value;
421 EXPECT_EQ(manager.GetBoolValue(key, value, userId), ERR_INVALID_OPERATION);
422 }
423
GetBoolValueResultNotFoundTest(const std::string & key,const int32_t userId) const424 void GetBoolValueResultNotFoundTest(const std::string& key, const int32_t userId) const
425 {
426 GTEST_LOG_(INFO) << "GetBoolValueResultNotFoundTest userId: " << userId << ", key: " << key;
427 GetStringValueResultNotFoundInnerTest(key, userId);
428 SettingDataManager& manager = SettingDataManager::GetInstance();
429 bool value;
430 EXPECT_EQ(manager.GetBoolValue(key, value, userId), ERR_NAME_NOT_FOUND);
431 }
432
GetBoolValueResultGetStringFailTest(const std::string & key,const int32_t userId) const433 void GetBoolValueResultGetStringFailTest(const std::string& key, const int32_t userId) const
434 {
435 GTEST_LOG_(INFO) << "GetBoolValueResultGetStringFailTest userId: " << userId << ", key: " << key;
436 GetStringValueResultGetStringFailInnerTest(key, userId);
437 SettingDataManager& manager = SettingDataManager::GetInstance();
438 bool value;
439 EXPECT_EQ(manager.GetBoolValue(key, value, userId), ERR_INVALID_VALUE);
440 }
441
GetBoolValueResultTest(const std::string & key,const int32_t userId,const bool valueExpect,const std::string & savedVal,const int32_t code) const442 void GetBoolValueResultTest(const std::string& key, const int32_t userId,
443 const bool valueExpect, const std::string& savedVal, const int32_t code) const
444 {
445 GTEST_LOG_(INFO) << "GetBoolValueResultTest userId: " << userId << ", key: " << key << ", value: " <<
446 savedVal;
447 GetStringValueResultInnerTest(key, userId, savedVal);
448 SettingDataManager& manager = SettingDataManager::GetInstance();
449 bool value;
450 EXPECT_EQ(manager.GetBoolValue(key, value, userId), code);
451 if (code == ERR_OK) {
452 EXPECT_EQ(value, valueExpect);
453 }
454 }
455
IsValidKeyCreateFailTest(const std::string & key,const int32_t userId) const456 void IsValidKeyCreateFailTest(const std::string& key, const int32_t userId) const
457 {
458 GTEST_LOG_(INFO) << "IsValidKeyCreateFailTest userId: " << userId << ", key: " << key;
459 HelperCreateFailTest(userId);
460 SettingDataManager& manager = SettingDataManager::GetInstance();
461 EXPECT_EQ(manager.IsValidKey(key, userId), false);
462 }
463
IsValidKeyQueryNullTest(const std::string & key,const int32_t userId) const464 void IsValidKeyQueryNullTest(const std::string& key, const int32_t userId) const
465 {
466 GTEST_LOG_(INFO) << "IsValidKeyQueryNullTest userId: " << userId << ", key: " << key;
467 GetStringValueQueryNullInnerTest(key, userId);
468 SettingDataManager& manager = SettingDataManager::GetInstance();
469 EXPECT_EQ(manager.IsValidKey(key, userId), false);
470 }
471
IsValidKeyResultNotFoundTest(const std::string & key,const int32_t userId) const472 void IsValidKeyResultNotFoundTest(const std::string& key, const int32_t userId) const
473 {
474 GTEST_LOG_(INFO) << "IsValidKeyResultNotFoundTest userId: " << userId << ", key: " << key;
475 GetStringValueResultNotFoundInnerTest(key, userId);
476 SettingDataManager& manager = SettingDataManager::GetInstance();
477 EXPECT_EQ(manager.IsValidKey(key, userId), false);
478 }
479
IsValidKeyResultGetStringFailTest(const std::string & key,const int32_t userId) const480 void IsValidKeyResultGetStringFailTest(const std::string& key, const int32_t userId) const
481 {
482 GTEST_LOG_(INFO) << "IsValidKeyResultGetStringFailTest userId: " << userId << ", key: " << key;
483 GetStringValueResultGetStringFailInnerTest(key, userId);
484 SettingDataManager& manager = SettingDataManager::GetInstance();
485 EXPECT_EQ(manager.IsValidKey(key, userId), false);
486 }
487
IsValidKeyResultTest(const std::string & key,const int32_t userId,const bool valueExpect,const std::string & savedVal) const488 void IsValidKeyResultTest(const std::string& key, const int32_t userId,
489 const bool valueExpect, const std::string& savedVal) const
490 {
491 GTEST_LOG_(INFO) << "IsValidKeyResultTest userId: " << userId << ", key: " << key << ", value: " <<
492 savedVal;
493 GetStringValueResultInnerTest(key, userId, savedVal);
494 SettingDataManager& manager = SettingDataManager::GetInstance();
495 EXPECT_EQ(manager.IsValidKey(key, userId), valueExpect);
496 }
497
498 private:
499 std::shared_ptr<DataShare::DataShareHelper> myHelper_ = std::make_shared<DataShare::DataShareHelper>();
500 std::shared_ptr<DataShare::DataShareResultSet> myResult_ = std::make_shared<DataShare::DataShareResultSet>();
501
HelperCreateFailTest(const int32_t userId) const502 void HelperCreateFailTest(const int32_t userId) const
503 {
504 auto* testInfo = UnitTest::GetInstance()->current_test_info();
505 IPCSkeleton& instance = IPCSkeleton::GetInstance();
506 ExpectationSet expectationSet = EXPECT_CALL(instance, MockResetCallingIdentity())
507 .Times(1).WillOnce(Return(testInfo->name()));
508 DataShare::DataShareHelper& helper = DataShare::DataShareHelper::GetInstance();
509 auto checkMockCreate = [this, userId](
510 const sptr<IRemoteObject>& token, const std::string& uri, const std::string& extUri, Unused) {
511 EXPECT_EQ(token, object_);
512 EXPECT_EQ(uri, GetUserUri(userId));
513 EXPECT_EQ(extUri, SETTING_DATA_EXT_URI);
514 return std::make_pair(DataShare::E_BASE, nullptr);
515 };
516 expectationSet += EXPECT_CALL(helper, MockCreate(_, _, _, _))
517 .Times(1).After(expectationSet).WillOnce(checkMockCreate);
518 EXPECT_CALL(instance, MockSetCallingIdentity(testInfo->name())).Times(1).After(expectationSet);
519 }
520
HelperCreateTest(const int32_t userId,ExpectationSet & expectationSet) const521 void HelperCreateTest(const int32_t userId, ExpectationSet& expectationSet) const
522 {
523 auto* testInfo = UnitTest::GetInstance()->current_test_info();
524 IPCSkeleton& instance = IPCSkeleton::GetInstance();
525 expectationSet += EXPECT_CALL(instance, MockResetCallingIdentity())
526 .Times(1).WillOnce(Return(testInfo->name()));
527
528 DataShare::DataShareHelper& helper = DataShare::DataShareHelper::GetInstance();
529 auto checkMockCreate = [this, userId, weak = myHelper_->weak_from_this()](
530 const sptr<IRemoteObject>& token, const std::string& uri, const std::string& extUri, Unused) {
531 auto myHelper = weak.lock();
532 EXPECT_EQ(token, object_);
533 EXPECT_EQ(uri, GetUserUri(userId));
534 EXPECT_EQ(extUri, SETTING_DATA_EXT_URI);
535 return std::make_pair(DataShare::E_OK, myHelper);
536 };
537 expectationSet += EXPECT_CALL(helper, MockCreate(_, _, _, _))
538 .Times(1).After(expectationSet).WillOnce(checkMockCreate);
539 }
540
HelperReleaseTest(ExpectationSet & expectationSet) const541 void HelperReleaseTest(ExpectationSet& expectationSet) const
542 {
543 expectationSet += EXPECT_CALL(*myHelper_, Release())
544 .Times(1).After(expectationSet).WillOnce(Return(true));
545
546 auto* testInfo = UnitTest::GetInstance()->current_test_info();
547 IPCSkeleton& instance = IPCSkeleton::GetInstance();
548 EXPECT_CALL(instance, MockSetCallingIdentity(testInfo->name())).Times(1).After(expectationSet);
549 }
550
HelperInsertTest(ExpectationSet & expectationSet,const std::string & key,const std::string & value,const int32_t userId,int32_t returnVal) const551 void HelperInsertTest(ExpectationSet& expectationSet, const std::string& key, const std::string& value,
552 const int32_t userId, int32_t returnVal) const
553 {
554 auto checkInsert = [userId, key, value, returnVal](Uri& uri, const DataShare::DataShareValuesBucket& bucket) {
555 EXPECT_EQ(uri.ToString(), GetUserUriWithKey(userId, key));
556 bool isValid = false;
557 auto obj = bucket.Get(SETTING_DATA_COLUMN_KEYWORD, isValid);
558 EXPECT_TRUE(isValid);
559 std::string keyObj = obj;
560 EXPECT_EQ(keyObj, key);
561 isValid = false;
562 obj = bucket.Get(SETTING_DATA_COLUMN_VALUE, isValid);
563 EXPECT_TRUE(isValid);
564 std::string valObj = obj;
565 EXPECT_EQ(valObj, value);
566 return returnVal;
567 };
568 expectationSet += EXPECT_CALL(*myHelper_, Insert(_, _))
569 .Times(1).After(expectationSet).WillOnce(Invoke(checkInsert));
570 }
571
HelperUpdateTest(ExpectationSet & expectationSet,const std::string & key,const std::string & value,const int32_t userId,int32_t returnVal) const572 void HelperUpdateTest(ExpectationSet& expectationSet, const std::string& key, const std::string& value,
573 const int32_t userId, int32_t returnVal) const
574 {
575 auto checkUpdate = [userId, key, value, returnVal](Uri& uri,
576 const DataShare::DataSharePredicates& predicates, const DataShare::DataShareValuesBucket& bucket) {
577 EXPECT_EQ(uri.ToString(), GetUserUriWithKey(userId, key));
578
579 auto& operationList = predicates.GetOperationList();
580 EXPECT_EQ(operationList.size(), 1);
581 EXPECT_EQ(operationList[0].operation, DataShare::EQUAL_TO);
582 std::string predKey0 = operationList[0].GetSingle(0);
583 std::string predKey1 = operationList[0].GetSingle(1);
584 EXPECT_EQ(predKey0, SETTING_DATA_COLUMN_KEYWORD);
585 EXPECT_EQ(predKey1, key);
586
587 bool isValid = false;
588 auto obj = bucket.Get(SETTING_DATA_COLUMN_KEYWORD, isValid);
589 EXPECT_TRUE(isValid);
590 std::string keyObj = obj;
591 EXPECT_EQ(keyObj, key);
592 isValid = false;
593 obj = bucket.Get(SETTING_DATA_COLUMN_VALUE, isValid);
594 EXPECT_TRUE(isValid);
595 std::string valObj = obj;
596 EXPECT_EQ(valObj, value);
597 return returnVal;
598 };
599 expectationSet += EXPECT_CALL(*myHelper_, Update(_, _, _))
600 .Times(1).After(expectationSet).WillOnce(Invoke(checkUpdate));
601 }
602
HelperQueryNullTest(ExpectationSet & expectationSet,const std::string & key,const int32_t userId) const603 void HelperQueryNullTest(ExpectationSet& expectationSet, const std::string& key, const int32_t userId) const
604 {
605 auto checkQuery = [key, userId](Uri& uri, const DataShare::DataSharePredicates& predicates,
606 std::vector<std::string>& columns) {
607 EXPECT_EQ(uri.ToString(), GetUserUriWithKey(userId, key));
608
609 auto& operationList = predicates.GetOperationList();
610 EXPECT_EQ(operationList.size(), 1);
611 EXPECT_EQ(operationList[0].operation, DataShare::EQUAL_TO);
612 std::string predKey0 = operationList[0].GetSingle(0);
613 std::string predKey1 = operationList[0].GetSingle(1);
614 EXPECT_EQ(predKey0, SETTING_DATA_COLUMN_KEYWORD);
615 EXPECT_EQ(predKey1, key);
616
617 EXPECT_EQ(columns.size(), 1);
618 EXPECT_EQ(columns[0], SETTING_DATA_COLUMN_VALUE);
619 return nullptr;
620 };
621 expectationSet += EXPECT_CALL(*myHelper_, Query(_, _, _))
622 .Times(1).After(expectationSet).WillOnce(Invoke(checkQuery));
623 }
624
HelperQueryTest(ExpectationSet & expectationSet,const std::string & key,const int32_t userId) const625 void HelperQueryTest(ExpectationSet& expectationSet, const std::string& key, const int32_t userId) const
626 {
627 auto checkQuery = [this, key, userId](Uri& uri, const DataShare::DataSharePredicates& predicates,
628 std::vector<std::string>& columns) {
629 EXPECT_EQ(uri.ToString(), GetUserUriWithKey(userId, key));
630
631 auto& operationList = predicates.GetOperationList();
632 EXPECT_EQ(operationList.size(), 1);
633 EXPECT_EQ(operationList[0].operation, DataShare::EQUAL_TO);
634 std::string predKey0 = operationList[0].GetSingle(0);
635 std::string predKey1 = operationList[0].GetSingle(1);
636 EXPECT_EQ(predKey0, SETTING_DATA_COLUMN_KEYWORD);
637 EXPECT_EQ(predKey1, key);
638
639 EXPECT_EQ(columns.size(), 1);
640 EXPECT_EQ(columns[0], SETTING_DATA_COLUMN_VALUE);
641 return myResult_;
642 };
643 expectationSet += EXPECT_CALL(*myHelper_, Query(_, _, _))
644 .Times(1).After(expectationSet).WillOnce(Invoke(checkQuery));
645 }
646
ResultNotFoundTest(ExpectationSet & expectationSet,const std::string & key,const int32_t userId) const647 void ResultNotFoundTest(ExpectationSet& expectationSet, const std::string& key, const int32_t userId) const
648 {
649 auto checkGetRowCount = [](int32_t& count) {
650 count = 0;
651 return 0;
652 };
653 expectationSet += EXPECT_CALL(*myResult_, GetRowCount(_))
654 .Times(1).After(expectationSet).WillOnce(Invoke(checkGetRowCount));
655 }
656
ResultGetStringFailTest(ExpectationSet & expectationSet,const std::string & key,const int32_t userId) const657 void ResultGetStringFailTest(ExpectationSet& expectationSet, const std::string& key, const int32_t userId) const
658 {
659 auto checkGetRowCount = [](int32_t& count) {
660 count = 1;
661 return 0;
662 };
663 expectationSet += EXPECT_CALL(*myResult_, GetRowCount(_))
664 .Times(1).After(expectationSet).WillOnce(Invoke(checkGetRowCount));
665
666 expectationSet += EXPECT_CALL(*myResult_, GoToRow(0))
667 .Times(1).After(expectationSet).WillOnce(Return(0));
668
669 expectationSet += EXPECT_CALL(*myResult_, GetString(0, _))
670 .Times(1).After(expectationSet).WillOnce(Return(1));
671 }
672
ResultTest(ExpectationSet & expectationSet,const std::string & key,const int32_t userId,const std::string & valueExpect) const673 void ResultTest(ExpectationSet& expectationSet, const std::string& key, const int32_t userId,
674 const std::string& valueExpect) const
675 {
676 auto checkGetRowCount = [](int32_t& count) {
677 count = 1;
678 return 0;
679 };
680 expectationSet += EXPECT_CALL(*myResult_, GetRowCount(_))
681 .Times(1).After(expectationSet).WillOnce(Invoke(checkGetRowCount));
682
683 expectationSet += EXPECT_CALL(*myResult_, GoToRow(0))
684 .Times(1).After(expectationSet).WillOnce(Return(0));
685
686 auto checkGetString = [valueExpect](Unused, std::string& value) {
687 value = valueExpect;
688 return 0;
689 };
690 expectationSet += EXPECT_CALL(*myResult_, GetString(0, _))
691 .Times(1).After(expectationSet).WillOnce(Invoke(checkGetString));
692 }
693
ResultCloseTest(ExpectationSet & expectationSet) const694 void ResultCloseTest(ExpectationSet& expectationSet) const
695 {
696 expectationSet += EXPECT_CALL(*myResult_, Close()).Times(1).After(expectationSet);
697 }
698
HelperNotifyChangeTest(ExpectationSet & expectationSet,const std::string & key,const int32_t userId) const699 void HelperNotifyChangeTest(ExpectationSet& expectationSet, const std::string& key, const int32_t userId) const
700 {
701 auto checkNotifyChange = [userId, key](const Uri& uri) {
702 EXPECT_EQ(uri.ToString(), GetUserUriWithKey(userId, key));
703 };
704 expectationSet += EXPECT_CALL(*myHelper_, NotifyChange(_))
705 .Times(1).After(expectationSet).WillOnce(Invoke(checkNotifyChange));
706 }
707
SetStringValueInsertAndUpdateFailInnerTest(const std::string & key,const std::string & value,const int32_t userId,const bool needNotify) const708 void SetStringValueInsertAndUpdateFailInnerTest(const std::string& key,
709 const std::string& value, const int32_t userId, const bool needNotify) const
710 {
711 ExpectationSet expectationSet;
712 HelperCreateTest(userId, expectationSet);
713 HelperUpdateTest(expectationSet, key, value, userId, 0);
714 HelperInsertTest(expectationSet, key, value, userId, 0);
715 HelperReleaseTest(expectationSet);
716 }
717
SetStringValueUpdateInnerTest(const std::string & key,const std::string & value,const int32_t userId,const bool needNotify) const718 void SetStringValueUpdateInnerTest(const std::string& key,
719 const std::string& value, const int32_t userId, const bool needNotify) const
720 {
721 ExpectationSet expectationSet;
722 HelperCreateTest(userId, expectationSet);
723 HelperUpdateTest(expectationSet, key, value, userId, 1);
724 EXPECT_CALL(*myHelper_, Insert(_, _)).Times(0);
725 if (needNotify) {
726 HelperNotifyChangeTest(expectationSet, key, userId);
727 }
728 HelperReleaseTest(expectationSet);
729 }
730
SetStringValueInsertInnerTest(const std::string & key,const std::string & value,const int32_t userId,const bool needNotify) const731 void SetStringValueInsertInnerTest(const std::string& key,
732 const std::string& value, const int32_t userId, const bool needNotify) const
733 {
734 ExpectationSet expectationSet;
735 HelperCreateTest(userId, expectationSet);
736 HelperUpdateTest(expectationSet, key, value, userId, 0);
737 HelperInsertTest(expectationSet, key, value, userId, 1);
738 if (needNotify) {
739 HelperNotifyChangeTest(expectationSet, key, userId);
740 }
741 HelperReleaseTest(expectationSet);
742 }
743
GetStringValueQueryNullInnerTest(const std::string & key,const int32_t userId) const744 void GetStringValueQueryNullInnerTest(const std::string& key, const int32_t userId) const
745 {
746 ExpectationSet expectationSet;
747 HelperCreateTest(userId, expectationSet);
748 HelperQueryNullTest(expectationSet, key, userId);
749 HelperReleaseTest(expectationSet);
750 }
751
GetStringValueResultNotFoundInnerTest(const std::string & key,const int32_t userId) const752 void GetStringValueResultNotFoundInnerTest(const std::string& key, const int32_t userId) const
753 {
754 ExpectationSet expectationSet;
755 HelperCreateTest(userId, expectationSet);
756 HelperQueryTest(expectationSet, key, userId);
757 HelperReleaseTest(expectationSet);
758 ResultNotFoundTest(expectationSet, key, userId);
759 ResultCloseTest(expectationSet);
760 }
761
GetStringValueResultGetStringFailInnerTest(const std::string & key,const int32_t userId) const762 void GetStringValueResultGetStringFailInnerTest(const std::string& key, const int32_t userId) const
763 {
764 ExpectationSet expectationSet;
765 HelperCreateTest(userId, expectationSet);
766 HelperQueryTest(expectationSet, key, userId);
767 HelperReleaseTest(expectationSet);
768 ResultGetStringFailTest(expectationSet, key, userId);
769 ResultCloseTest(expectationSet);
770 }
771
GetStringValueResultInnerTest(const std::string & key,const int32_t userId,const std::string & valueExpect) const772 void GetStringValueResultInnerTest(const std::string& key, const int32_t userId,
773 const std::string& valueExpect) const
774 {
775 ExpectationSet expectationSet;
776 HelperCreateTest(userId, expectationSet);
777 HelperQueryTest(expectationSet, key, userId);
778 HelperReleaseTest(expectationSet);
779 ResultTest(expectationSet, key, userId, valueExpect);
780 ResultCloseTest(expectationSet);
781 }
782 };
783
784 HWTEST_F(SettingDataManagerInitializeTest, InitializeTest_0100, TestSize.Level1)
785 {
786 SettingDataManager& manager = SettingDataManager::GetInstance();
787 EXPECT_EQ(manager.IsInitialized(), false);
788
789 SystemAbilityManagerClient& client = SystemAbilityManagerClient::GetInstance();
790 EXPECT_CALL(client, GetSystemAbilityManager()).Times(1).WillOnce(Return(nullptr));
791 EXPECT_EQ(manager.Initialize(), ERR_NO_INIT);
792 EXPECT_EQ(manager.IsInitialized(), false);
793 }
794
795 HWTEST_F(SettingDataManagerInitializeTest, InitializeTest_0200, TestSize.Level1)
796 {
797 SettingDataManager& manager = SettingDataManager::GetInstance();
798 EXPECT_EQ(manager.IsInitialized(), false);
799
800 SystemAbilityManagerClient& client = SystemAbilityManagerClient::GetInstance();
801 auto saMgr = sptr<ISystemAbilityManager>::MakeSptr();
802 EXPECT_CALL(client, GetSystemAbilityManager()).Times(1).WillOnce(Return(saMgr));
803 EXPECT_CALL(*saMgr, GetSystemAbility(ARKUI_UI_APPEARANCE_SERVICE_ID)).Times(1).WillOnce(Return(nullptr));
804 EXPECT_EQ(manager.Initialize(), ERR_NO_INIT);
805 EXPECT_EQ(manager.IsInitialized(), false);
806 }
807
808 HWTEST_F(SettingDataManagerInitializeTest, InitializeTest_0300, TestSize.Level1)
809 {
810 SettingDataManager& manager = SettingDataManager::GetInstance();
811 EXPECT_EQ(manager.IsInitialized(), false);
812
813 SystemAbilityManagerClient& client = SystemAbilityManagerClient::GetInstance();
814 auto saMgr = sptr<ISystemAbilityManager>::MakeSptr();
815 EXPECT_CALL(client, GetSystemAbilityManager()).Times(1).WillOnce(Return(saMgr));
816 auto obj = sptr<IRemoteObject>::MakeSptr();
817 EXPECT_CALL(*saMgr, GetSystemAbility(ARKUI_UI_APPEARANCE_SERVICE_ID)).Times(1).WillOnce(Return(obj));
818 EXPECT_EQ(manager.Initialize(), ERR_OK);
819 EXPECT_EQ(manager.IsInitialized(), true);
820 EXPECT_EQ(manager.remoteObject_, obj);
821
822 EXPECT_EQ(manager.Initialize(), ERR_OK);
823 EXPECT_EQ(manager.IsInitialized(), true);
824 EXPECT_EQ(manager.remoteObject_, obj);
825 }
826
827 HWTEST_F(SettingDataManagerInitializeTest, RegisterObserver_0100, TestSize.Level1)
828 {
829 SettingDataManager& manager = SettingDataManager::GetInstance();
830 EXPECT_EQ(manager.IsInitialized(), false);
831 EXPECT_EQ(manager.RegisterObserver(TEST_KEY1, nullptr, TEST_USER100), ERR_NO_INIT);
832 }
833
834 HWTEST_F(SettingDataManagerTest, RegisterObserver_0200, TestSize.Level1)
835 {
836 RegisterObserverCreateFailTest(INVALID_USER_ID, TEST_KEY1);
837 RegisterObserverCreateFailTest(INVALID_USER_ID, TEST_KEY2);
838 RegisterObserverCreateFailTest(INVALID_USER_ID, TEST_KEY3);
839 }
840
841 HWTEST_F(SettingDataManagerTest, RegisterObserver_0300, TestSize.Level1)
842 {
843 RegisterObserverCreateFailTest(INVALID_USER_ID, TEST_KEY1);
844 RegisterObserverCreateFailTest(TEST_USER100, TEST_KEY1);
845 RegisterObserverCreateFailTest(TEST_USER1, TEST_KEY1);
846 }
847
848 HWTEST_F(SettingDataManagerTest, RegisterObserver_0400, TestSize.Level1)
849 {
850 RegisterObserverCreateFailTest(INVALID_USER_ID, TEST_KEY1);
851 RegisterObserverCreateFailTest(TEST_USER100, TEST_KEY2);
852 RegisterObserverCreateFailTest(TEST_USER1, TEST_KEY3);
853 }
854
855 HWTEST_F(SettingDataManagerTest, RegisterObserver_0500, TestSize.Level1)
856 {
857 RegisterObserverTest(INVALID_USER_ID, TEST_KEY1);
858 RegisterObserverTest(INVALID_USER_ID, TEST_KEY2);
859 RegisterObserverTest(INVALID_USER_ID, TEST_KEY3);
860 }
861
862 HWTEST_F(SettingDataManagerTest, RegisterObserver_0600, TestSize.Level1)
863 {
864 RegisterObserverTest(INVALID_USER_ID, TEST_KEY1);
865 RegisterObserverTest(TEST_USER100, TEST_KEY1);
866 RegisterObserverTest(TEST_USER1, TEST_KEY1);
867 }
868
869 HWTEST_F(SettingDataManagerTest, RegisterObserver_0700, TestSize.Level1)
870 {
871 RegisterObserverTest(INVALID_USER_ID, TEST_KEY1);
872 RegisterObserverTest(TEST_USER100, TEST_KEY2);
873 RegisterObserverTest(TEST_USER1, TEST_KEY3);
874 }
875
876 HWTEST_F(SettingDataManagerTest, UnregisterObserver_0100, TestSize.Level1)
877 {
878 RegisterObserverTest(INVALID_USER_ID, TEST_KEY1);
879 RegisterObserverTest(INVALID_USER_ID, TEST_KEY2);
880 RegisterObserverTest(INVALID_USER_ID, TEST_KEY3);
881 UnregisterObserverCreateFailTest(INVALID_USER_ID, TEST_KEY1);
882 UnregisterObserverCreateFailTest(INVALID_USER_ID, TEST_KEY2);
883 UnregisterObserverCreateFailTest(INVALID_USER_ID, TEST_KEY3);
884 }
885
886 HWTEST_F(SettingDataManagerTest, UnregisterObserver_0200, TestSize.Level1)
887 {
888 RegisterObserverTest(INVALID_USER_ID, TEST_KEY1);
889 RegisterObserverTest(TEST_USER100, TEST_KEY1);
890 RegisterObserverTest(TEST_USER1, TEST_KEY1);
891 UnregisterObserverCreateFailTest(INVALID_USER_ID, TEST_KEY1);
892 UnregisterObserverCreateFailTest(TEST_USER100, TEST_KEY1);
893 UnregisterObserverCreateFailTest(TEST_USER1, TEST_KEY1);
894 }
895
896 HWTEST_F(SettingDataManagerTest, UnregisterObserver_0300, TestSize.Level1)
897 {
898 RegisterObserverTest(INVALID_USER_ID, TEST_KEY1);
899 RegisterObserverTest(TEST_USER100, TEST_KEY2);
900 RegisterObserverTest(TEST_USER1, TEST_KEY3);
901 UnregisterObserverCreateFailTest(INVALID_USER_ID, TEST_KEY1);
902 UnregisterObserverCreateFailTest(TEST_USER100, TEST_KEY2);
903 UnregisterObserverCreateFailTest(TEST_USER1, TEST_KEY3);
904 }
905
906 HWTEST_F(SettingDataManagerTest, UnregisterObserver_0400, TestSize.Level1)
907 {
908 RegisterObserverTest(INVALID_USER_ID, TEST_KEY1);
909 RegisterObserverTest(INVALID_USER_ID, TEST_KEY2);
910 RegisterObserverTest(INVALID_USER_ID, TEST_KEY3);
911 UnregisterObserverTest(INVALID_USER_ID, TEST_KEY1);
912 UnregisterObserverTest(INVALID_USER_ID, TEST_KEY2);
913 UnregisterObserverTest(INVALID_USER_ID, TEST_KEY3);
914 }
915
916 HWTEST_F(SettingDataManagerTest, UnregisterObserver_0500, TestSize.Level1)
917 {
918 RegisterObserverTest(INVALID_USER_ID, TEST_KEY1);
919 RegisterObserverTest(TEST_USER100, TEST_KEY1);
920 RegisterObserverTest(TEST_USER1, TEST_KEY1);
921 UnregisterObserverTest(INVALID_USER_ID, TEST_KEY1);
922 UnregisterObserverTest(TEST_USER100, TEST_KEY1);
923 UnregisterObserverTest(TEST_USER1, TEST_KEY1);
924 }
925
926 HWTEST_F(SettingDataManagerTest, UnregisterObserver_0600, TestSize.Level1)
927 {
928 RegisterObserverTest(INVALID_USER_ID, TEST_KEY1);
929 RegisterObserverTest(TEST_USER100, TEST_KEY2);
930 RegisterObserverTest(TEST_USER1, TEST_KEY3);
931 UnregisterObserverTest(INVALID_USER_ID, TEST_KEY1);
932 UnregisterObserverTest(TEST_USER100, TEST_KEY2);
933 UnregisterObserverTest(TEST_USER1, TEST_KEY3);
934 }
935
936 HWTEST_F(SettingDataManagerTest, UnregisterObserver_0700, TestSize.Level1)
937 {
938 SettingDataManager& manager = SettingDataManager::GetInstance();
939 size_t observerSize = manager.observers_.size();
940 EXPECT_EQ(manager.observers_.size(), observerSize);
941 EXPECT_EQ(manager.UnregisterObserver(TEST_KEY1, INVALID_USER_ID), ERR_INVALID_VALUE);
942 EXPECT_EQ(manager.observers_.size(), observerSize);
943 manager.observers_.emplace(GenerateObserverName(INVALID_USER_ID, TEST_KEY1), nullptr);
944 EXPECT_EQ(manager.observers_.size(), observerSize + 1);
945 EXPECT_EQ(manager.UnregisterObserver(TEST_KEY1, INVALID_USER_ID), ERR_INVALID_OPERATION);
946 EXPECT_EQ(manager.observers_.size(), observerSize);
947
948 observerSize = manager.observers_.size();
949 EXPECT_EQ(manager.observers_.size(), observerSize);
950 EXPECT_EQ(manager.UnregisterObserver(TEST_KEY2, TEST_USER100), ERR_INVALID_VALUE);
951 EXPECT_EQ(manager.observers_.size(), observerSize);
952 manager.observers_.emplace(GenerateObserverName(TEST_USER100, TEST_KEY2), nullptr);
953 EXPECT_EQ(manager.observers_.size(), observerSize + 1);
954 EXPECT_EQ(manager.UnregisterObserver(TEST_KEY2, TEST_USER100), ERR_INVALID_OPERATION);
955 EXPECT_EQ(manager.observers_.size(), observerSize);
956 }
957
958 HWTEST_F(SettingDataManagerTest, SetStringValue_0100, TestSize.Level1)
959 {
960 SetStringValueCreateFailTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, true);
961 SetStringValueCreateFailTest(TEST_KEY2, TEST_VAL2, INVALID_USER_ID, true);
962 SetStringValueCreateFailTest(TEST_KEY3, TEST_VAL3, INVALID_USER_ID, true);
963 SetStringValueCreateFailTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, false);
964 SetStringValueCreateFailTest(TEST_KEY2, TEST_VAL2, INVALID_USER_ID, false);
965 SetStringValueCreateFailTest(TEST_KEY3, TEST_VAL3, INVALID_USER_ID, false);
966
967 SetStringValueCreateFailTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, true);
968 SetStringValueCreateFailTest(TEST_KEY1, TEST_VAL1, TEST_USER100, true);
969 SetStringValueCreateFailTest(TEST_KEY1, TEST_VAL1, TEST_USER1, true);
970 SetStringValueCreateFailTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, false);
971 SetStringValueCreateFailTest(TEST_KEY1, TEST_VAL1, TEST_USER100, false);
972 SetStringValueCreateFailTest(TEST_KEY1, TEST_VAL1, TEST_USER1, false);
973 }
974
975 HWTEST_F(SettingDataManagerTest, SetStringValue_0200, TestSize.Level1)
976 {
977 SetStringValueInsertAndUpdateFailTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, true);
978 SetStringValueInsertAndUpdateFailTest(TEST_KEY2, TEST_VAL2, INVALID_USER_ID, true);
979 SetStringValueInsertAndUpdateFailTest(TEST_KEY3, TEST_VAL3, INVALID_USER_ID, true);
980 SetStringValueInsertAndUpdateFailTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, false);
981 SetStringValueInsertAndUpdateFailTest(TEST_KEY2, TEST_VAL2, INVALID_USER_ID, false);
982 SetStringValueInsertAndUpdateFailTest(TEST_KEY3, TEST_VAL3, INVALID_USER_ID, false);
983
984 SetStringValueInsertAndUpdateFailTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, true);
985 SetStringValueInsertAndUpdateFailTest(TEST_KEY1, TEST_VAL1, TEST_USER100, true);
986 SetStringValueInsertAndUpdateFailTest(TEST_KEY1, TEST_VAL1, TEST_USER1, true);
987 SetStringValueInsertAndUpdateFailTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, false);
988 SetStringValueInsertAndUpdateFailTest(TEST_KEY1, TEST_VAL1, TEST_USER100, false);
989 SetStringValueInsertAndUpdateFailTest(TEST_KEY1, TEST_VAL1, TEST_USER1, false);
990 }
991
992 HWTEST_F(SettingDataManagerTest, SetStringValue_0300, TestSize.Level1)
993 {
994 SetStringValueInsertTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, true);
995 SetStringValueInsertTest(TEST_KEY2, TEST_VAL2, INVALID_USER_ID, true);
996 SetStringValueInsertTest(TEST_KEY3, TEST_VAL3, INVALID_USER_ID, true);
997 SetStringValueInsertTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, false);
998 SetStringValueInsertTest(TEST_KEY2, TEST_VAL2, INVALID_USER_ID, false);
999 SetStringValueInsertTest(TEST_KEY3, TEST_VAL3, INVALID_USER_ID, false);
1000
1001 SetStringValueInsertTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, true);
1002 SetStringValueInsertTest(TEST_KEY1, TEST_VAL1, TEST_USER100, true);
1003 SetStringValueInsertTest(TEST_KEY1, TEST_VAL1, TEST_USER1, true);
1004 SetStringValueInsertTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, false);
1005 SetStringValueInsertTest(TEST_KEY1, TEST_VAL1, TEST_USER100, false);
1006 SetStringValueInsertTest(TEST_KEY1, TEST_VAL1, TEST_USER1, false);
1007 }
1008
1009 HWTEST_F(SettingDataManagerTest, SetStringValue_0400, TestSize.Level1)
1010 {
1011 SetStringValueUpdateTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, true);
1012 SetStringValueUpdateTest(TEST_KEY2, TEST_VAL2, INVALID_USER_ID, true);
1013 SetStringValueUpdateTest(TEST_KEY3, TEST_VAL3, INVALID_USER_ID, true);
1014 SetStringValueUpdateTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, false);
1015 SetStringValueUpdateTest(TEST_KEY2, TEST_VAL2, INVALID_USER_ID, false);
1016 SetStringValueUpdateTest(TEST_KEY3, TEST_VAL3, INVALID_USER_ID, false);
1017
1018 SetStringValueUpdateTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, true);
1019 SetStringValueUpdateTest(TEST_KEY1, TEST_VAL1, TEST_USER100, true);
1020 SetStringValueUpdateTest(TEST_KEY1, TEST_VAL1, TEST_USER1, true);
1021 SetStringValueUpdateTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID, false);
1022 SetStringValueUpdateTest(TEST_KEY1, TEST_VAL1, TEST_USER100, false);
1023 SetStringValueUpdateTest(TEST_KEY1, TEST_VAL1, TEST_USER1, false);
1024 }
1025
1026 HWTEST_F(SettingDataManagerTest, SetInt32Value_0100, TestSize.Level1)
1027 {
1028 SetInt32ValueCreateFailTest(TEST_KEY1, 0, INVALID_USER_ID, true);
1029 SetInt32ValueCreateFailTest(TEST_KEY2, 1, INVALID_USER_ID, true);
1030 SetInt32ValueCreateFailTest(TEST_KEY3, -1, INVALID_USER_ID, true);
1031 SetInt32ValueCreateFailTest(TEST_KEY1, 0, INVALID_USER_ID, false);
1032 SetInt32ValueCreateFailTest(TEST_KEY2, 1, INVALID_USER_ID, false);
1033 SetInt32ValueCreateFailTest(TEST_KEY3, -1, INVALID_USER_ID, false);
1034
1035 SetInt32ValueCreateFailTest(TEST_KEY1, 0, INVALID_USER_ID, true);
1036 SetInt32ValueCreateFailTest(TEST_KEY1, 0, TEST_USER100, true);
1037 SetInt32ValueCreateFailTest(TEST_KEY1, 0, TEST_USER1, true);
1038 SetInt32ValueCreateFailTest(TEST_KEY1, 0, INVALID_USER_ID, false);
1039 SetInt32ValueCreateFailTest(TEST_KEY1, 0, TEST_USER100, false);
1040 SetInt32ValueCreateFailTest(TEST_KEY1, 0, TEST_USER1, false);
1041 }
1042
1043 HWTEST_F(SettingDataManagerTest, SetInt32Value_0200, TestSize.Level1)
1044 {
1045 SetInt32ValueInsertAndUpdateFailTest(TEST_KEY1, 0, INVALID_USER_ID, true);
1046 SetInt32ValueInsertAndUpdateFailTest(TEST_KEY2, 1, INVALID_USER_ID, true);
1047 SetInt32ValueInsertAndUpdateFailTest(TEST_KEY3, -1, INVALID_USER_ID, true);
1048 SetInt32ValueInsertAndUpdateFailTest(TEST_KEY1, 0, INVALID_USER_ID, false);
1049 SetInt32ValueInsertAndUpdateFailTest(TEST_KEY2, 1, INVALID_USER_ID, false);
1050 SetInt32ValueInsertAndUpdateFailTest(TEST_KEY3, -1, INVALID_USER_ID, false);
1051
1052 SetInt32ValueInsertAndUpdateFailTest(TEST_KEY1, 0, INVALID_USER_ID, true);
1053 SetInt32ValueInsertAndUpdateFailTest(TEST_KEY1, 0, TEST_USER100, true);
1054 SetInt32ValueInsertAndUpdateFailTest(TEST_KEY1, 0, TEST_USER1, true);
1055 SetInt32ValueInsertAndUpdateFailTest(TEST_KEY1, 0, INVALID_USER_ID, false);
1056 SetInt32ValueInsertAndUpdateFailTest(TEST_KEY1, 0, TEST_USER100, false);
1057 SetInt32ValueInsertAndUpdateFailTest(TEST_KEY1, 0, TEST_USER1, false);
1058 }
1059
1060 HWTEST_F(SettingDataManagerTest, SetInt32Value_0300, TestSize.Level1)
1061 {
1062 SetInt32ValueInsertTest(TEST_KEY1, 0, INVALID_USER_ID, true);
1063 SetInt32ValueInsertTest(TEST_KEY2, 1, INVALID_USER_ID, true);
1064 SetInt32ValueInsertTest(TEST_KEY3, -1, INVALID_USER_ID, true);
1065 SetInt32ValueInsertTest(TEST_KEY1, 0, INVALID_USER_ID, false);
1066 SetInt32ValueInsertTest(TEST_KEY2, 1, INVALID_USER_ID, false);
1067 SetInt32ValueInsertTest(TEST_KEY3, -1, INVALID_USER_ID, false);
1068
1069 SetInt32ValueInsertTest(TEST_KEY1, 0, INVALID_USER_ID, true);
1070 SetInt32ValueInsertTest(TEST_KEY1, 0, TEST_USER100, true);
1071 SetInt32ValueInsertTest(TEST_KEY1, 0, TEST_USER1, true);
1072 SetInt32ValueInsertTest(TEST_KEY1, 0, INVALID_USER_ID, false);
1073 SetInt32ValueInsertTest(TEST_KEY1, 0, TEST_USER100, false);
1074 SetInt32ValueInsertTest(TEST_KEY1, 0, TEST_USER1, false);
1075 }
1076
1077 HWTEST_F(SettingDataManagerTest, SetInt32Value_0400, TestSize.Level1)
1078 {
1079 SetInt32ValueUpdateTest(TEST_KEY1, 0, INVALID_USER_ID, true);
1080 SetInt32ValueUpdateTest(TEST_KEY2, 1, INVALID_USER_ID, true);
1081 SetInt32ValueUpdateTest(TEST_KEY3, -1, INVALID_USER_ID, true);
1082 SetInt32ValueUpdateTest(TEST_KEY1, 0, INVALID_USER_ID, false);
1083 SetInt32ValueUpdateTest(TEST_KEY2, 1, INVALID_USER_ID, false);
1084 SetInt32ValueUpdateTest(TEST_KEY3, -1, INVALID_USER_ID, false);
1085
1086 SetInt32ValueUpdateTest(TEST_KEY1, 0, INVALID_USER_ID, true);
1087 SetInt32ValueUpdateTest(TEST_KEY1, 0, TEST_USER100, true);
1088 SetInt32ValueUpdateTest(TEST_KEY1, 0, TEST_USER1, true);
1089 SetInt32ValueUpdateTest(TEST_KEY1, 0, INVALID_USER_ID, false);
1090 SetInt32ValueUpdateTest(TEST_KEY1, 0, TEST_USER100, false);
1091 SetInt32ValueUpdateTest(TEST_KEY1, 0, TEST_USER1, false);
1092 }
1093
1094 HWTEST_F(SettingDataManagerTest, SetBoolValue_0100, TestSize.Level1)
1095 {
1096 SetBoolValueCreateFailTest(TEST_KEY1, false, INVALID_USER_ID, true);
1097 SetBoolValueCreateFailTest(TEST_KEY2, true, INVALID_USER_ID, true);
1098 SetBoolValueCreateFailTest(TEST_KEY1, false, INVALID_USER_ID, false);
1099 SetBoolValueCreateFailTest(TEST_KEY2, true, INVALID_USER_ID, false);
1100
1101 SetBoolValueCreateFailTest(TEST_KEY1, true, INVALID_USER_ID, true);
1102 SetBoolValueCreateFailTest(TEST_KEY1, true, TEST_USER100, true);
1103 SetBoolValueCreateFailTest(TEST_KEY1, true, TEST_USER1, true);
1104 SetBoolValueCreateFailTest(TEST_KEY1, true, INVALID_USER_ID, false);
1105 SetBoolValueCreateFailTest(TEST_KEY1, true, TEST_USER100, false);
1106 SetBoolValueCreateFailTest(TEST_KEY1, true, TEST_USER1, false);
1107 }
1108
1109 HWTEST_F(SettingDataManagerTest, SetBoolValue_0200, TestSize.Level1)
1110 {
1111 SetBoolValueInsertAndUpdateFailTest(TEST_KEY1, false, INVALID_USER_ID, true);
1112 SetBoolValueInsertAndUpdateFailTest(TEST_KEY2, true, INVALID_USER_ID, true);
1113 SetBoolValueInsertAndUpdateFailTest(TEST_KEY1, false, INVALID_USER_ID, false);
1114 SetBoolValueInsertAndUpdateFailTest(TEST_KEY2, true, INVALID_USER_ID, false);
1115
1116 SetBoolValueInsertAndUpdateFailTest(TEST_KEY1, true, INVALID_USER_ID, true);
1117 SetBoolValueInsertAndUpdateFailTest(TEST_KEY1, true, TEST_USER100, true);
1118 SetBoolValueInsertAndUpdateFailTest(TEST_KEY1, true, TEST_USER1, true);
1119 SetBoolValueInsertAndUpdateFailTest(TEST_KEY1, true, INVALID_USER_ID, false);
1120 SetBoolValueInsertAndUpdateFailTest(TEST_KEY1, true, TEST_USER100, false);
1121 SetBoolValueInsertAndUpdateFailTest(TEST_KEY1, true, TEST_USER1, false);
1122 }
1123
1124 HWTEST_F(SettingDataManagerTest, SetBoolValue_0300, TestSize.Level1)
1125 {
1126 SetBoolValueInsertTest(TEST_KEY1, false, INVALID_USER_ID, true);
1127 SetBoolValueInsertTest(TEST_KEY2, true, INVALID_USER_ID, true);
1128 SetBoolValueInsertTest(TEST_KEY1, false, INVALID_USER_ID, false);
1129 SetBoolValueInsertTest(TEST_KEY2, true, INVALID_USER_ID, false);
1130
1131 SetBoolValueInsertTest(TEST_KEY1, true, INVALID_USER_ID, true);
1132 SetBoolValueInsertTest(TEST_KEY1, true, TEST_USER100, true);
1133 SetBoolValueInsertTest(TEST_KEY1, true, TEST_USER1, true);
1134 SetBoolValueInsertTest(TEST_KEY1, true, INVALID_USER_ID, false);
1135 SetBoolValueInsertTest(TEST_KEY1, true, TEST_USER100, false);
1136 SetBoolValueInsertTest(TEST_KEY1, true, TEST_USER1, false);
1137 }
1138
1139 HWTEST_F(SettingDataManagerTest, SetBoolValue_0400, TestSize.Level1)
1140 {
1141 SetBoolValueUpdateTest(TEST_KEY1, false, INVALID_USER_ID, true);
1142 SetBoolValueUpdateTest(TEST_KEY2, true, INVALID_USER_ID, true);
1143 SetBoolValueUpdateTest(TEST_KEY1, false, INVALID_USER_ID, false);
1144 SetBoolValueUpdateTest(TEST_KEY2, true, INVALID_USER_ID, false);
1145
1146 SetBoolValueUpdateTest(TEST_KEY1, true, INVALID_USER_ID, true);
1147 SetBoolValueUpdateTest(TEST_KEY1, true, TEST_USER100, true);
1148 SetBoolValueUpdateTest(TEST_KEY1, true, TEST_USER1, true);
1149 SetBoolValueUpdateTest(TEST_KEY1, true, INVALID_USER_ID, false);
1150 SetBoolValueUpdateTest(TEST_KEY1, true, TEST_USER100, false);
1151 SetBoolValueUpdateTest(TEST_KEY1, true, TEST_USER1, false);
1152 }
1153
1154 HWTEST_F(SettingDataManagerTest, GetStringValue_0100, TestSize.Level1)
1155 {
1156 GetStringValueCreateFailTest(TEST_KEY1, INVALID_USER_ID);
1157 GetStringValueCreateFailTest(TEST_KEY2, INVALID_USER_ID);
1158 GetStringValueCreateFailTest(TEST_KEY3, INVALID_USER_ID);
1159 GetStringValueCreateFailTest(TEST_KEY1, INVALID_USER_ID);
1160 GetStringValueCreateFailTest(TEST_KEY1, TEST_USER100);
1161 GetStringValueCreateFailTest(TEST_KEY1, TEST_USER1);
1162 }
1163
1164 HWTEST_F(SettingDataManagerTest, GetStringValue_0200, TestSize.Level1)
1165 {
1166 GetStringValueQueryNullTest(TEST_KEY1, INVALID_USER_ID);
1167 GetStringValueQueryNullTest(TEST_KEY2, INVALID_USER_ID);
1168 GetStringValueQueryNullTest(TEST_KEY3, INVALID_USER_ID);
1169 GetStringValueQueryNullTest(TEST_KEY1, INVALID_USER_ID);
1170 GetStringValueQueryNullTest(TEST_KEY1, TEST_USER100);
1171 GetStringValueQueryNullTest(TEST_KEY1, TEST_USER1);
1172 }
1173
1174 HWTEST_F(SettingDataManagerTest, GetStringValue_0300, TestSize.Level1)
1175 {
1176 GetStringValueResultNotFoundTest(TEST_KEY1, INVALID_USER_ID);
1177 GetStringValueResultNotFoundTest(TEST_KEY2, INVALID_USER_ID);
1178 GetStringValueResultNotFoundTest(TEST_KEY3, INVALID_USER_ID);
1179 GetStringValueResultNotFoundTest(TEST_KEY1, INVALID_USER_ID);
1180 GetStringValueResultNotFoundTest(TEST_KEY1, TEST_USER100);
1181 GetStringValueResultNotFoundTest(TEST_KEY1, TEST_USER1);
1182 }
1183
1184 HWTEST_F(SettingDataManagerTest, GetStringValue_0400, TestSize.Level1)
1185 {
1186 GetStringValueResultGetStringFailTest(TEST_KEY1, INVALID_USER_ID);
1187 GetStringValueResultGetStringFailTest(TEST_KEY2, INVALID_USER_ID);
1188 GetStringValueResultGetStringFailTest(TEST_KEY3, INVALID_USER_ID);
1189 GetStringValueResultGetStringFailTest(TEST_KEY1, INVALID_USER_ID);
1190 GetStringValueResultGetStringFailTest(TEST_KEY1, TEST_USER100);
1191 GetStringValueResultGetStringFailTest(TEST_KEY1, TEST_USER1);
1192 }
1193
1194 HWTEST_F(SettingDataManagerTest, GetStringValue_0500, TestSize.Level1)
1195 {
1196 GetStringValueResultTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID);
1197 GetStringValueResultTest(TEST_KEY2, TEST_VAL2, INVALID_USER_ID);
1198 GetStringValueResultTest(TEST_KEY3, TEST_VAL3, INVALID_USER_ID);
1199 GetStringValueResultTest(TEST_KEY1, TEST_VAL1, INVALID_USER_ID);
1200 GetStringValueResultTest(TEST_KEY1, TEST_VAL1, TEST_USER100);
1201 GetStringValueResultTest(TEST_KEY1, TEST_VAL1, TEST_USER1);
1202
1203 GetStringValueResultTest(TEST_KEY1, "", INVALID_USER_ID);
1204 }
1205
1206 HWTEST_F(SettingDataManagerTest, GetInt32Value_0100, TestSize.Level1)
1207 {
1208 GetInt32ValueCreateFailTest(TEST_KEY1, INVALID_USER_ID);
1209 GetInt32ValueCreateFailTest(TEST_KEY2, INVALID_USER_ID);
1210 GetInt32ValueCreateFailTest(TEST_KEY3, INVALID_USER_ID);
1211 GetInt32ValueCreateFailTest(TEST_KEY1, INVALID_USER_ID);
1212 GetInt32ValueCreateFailTest(TEST_KEY1, TEST_USER100);
1213 GetInt32ValueCreateFailTest(TEST_KEY1, TEST_USER1);
1214 }
1215
1216 HWTEST_F(SettingDataManagerTest, GetInt32Value_0200, TestSize.Level1)
1217 {
1218 GetInt32ValueQueryNullTest(TEST_KEY1, INVALID_USER_ID);
1219 GetInt32ValueQueryNullTest(TEST_KEY2, INVALID_USER_ID);
1220 GetInt32ValueQueryNullTest(TEST_KEY3, INVALID_USER_ID);
1221 GetInt32ValueQueryNullTest(TEST_KEY1, INVALID_USER_ID);
1222 GetInt32ValueQueryNullTest(TEST_KEY1, TEST_USER100);
1223 GetInt32ValueQueryNullTest(TEST_KEY1, TEST_USER1);
1224 }
1225
1226 HWTEST_F(SettingDataManagerTest, GetInt32Value_0300, TestSize.Level1)
1227 {
1228 GetInt32ValueResultNotFoundTest(TEST_KEY1, INVALID_USER_ID);
1229 GetInt32ValueResultNotFoundTest(TEST_KEY2, INVALID_USER_ID);
1230 GetInt32ValueResultNotFoundTest(TEST_KEY3, INVALID_USER_ID);
1231 GetInt32ValueResultNotFoundTest(TEST_KEY1, INVALID_USER_ID);
1232 GetInt32ValueResultNotFoundTest(TEST_KEY1, TEST_USER100);
1233 GetInt32ValueResultNotFoundTest(TEST_KEY1, TEST_USER1);
1234 }
1235
1236 HWTEST_F(SettingDataManagerTest, GetInt32Value_0400, TestSize.Level1)
1237 {
1238 GetInt32ValueResultGetStringFailTest(TEST_KEY1, INVALID_USER_ID);
1239 GetInt32ValueResultGetStringFailTest(TEST_KEY2, INVALID_USER_ID);
1240 GetInt32ValueResultGetStringFailTest(TEST_KEY3, INVALID_USER_ID);
1241 GetInt32ValueResultGetStringFailTest(TEST_KEY1, INVALID_USER_ID);
1242 GetInt32ValueResultGetStringFailTest(TEST_KEY1, TEST_USER100);
1243 GetInt32ValueResultGetStringFailTest(TEST_KEY1, TEST_USER1);
1244 }
1245
1246 HWTEST_F(SettingDataManagerTest, GetInt32Value_0500, TestSize.Level1)
1247 {
1248 GetInt32ValueResultTest(TEST_KEY1, INVALID_USER_ID, 0, "0", ERR_OK);
1249 GetInt32ValueResultTest(TEST_KEY2, INVALID_USER_ID, 1, "1", ERR_OK);
1250 GetInt32ValueResultTest(TEST_KEY3, INVALID_USER_ID, -1, "-1", ERR_OK);
1251 GetInt32ValueResultTest(TEST_KEY1, INVALID_USER_ID, 0, "0", ERR_OK);
1252 GetInt32ValueResultTest(TEST_KEY1, TEST_USER100, 0, "0", ERR_OK);
1253 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 0, "0", ERR_OK);
1254
1255 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 0, "abcdefghijklmnopqrstuvwxyz", ERR_INVALID_VALUE);
1256 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 0, "!@#$%^&*()_+-={}[]<,>.?/:;", ERR_INVALID_VALUE);
1257 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 0, "-9999999999999999999999999", ERR_INVALID_VALUE);
1258 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 0, "99999999999999999999999999", ERR_INVALID_VALUE);
1259 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 0, "abcdefghijkl99999999999999", ERR_INVALID_VALUE);
1260 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 0, "abc999", ERR_INVALID_VALUE);
1261 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 0, "", ERR_INVALID_VALUE);
1262
1263 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 999, "999abc", ERR_OK);
1264 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 1, "1e10", ERR_OK);
1265 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 1, "1e-10", ERR_OK);
1266 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, -1, "-1e10", ERR_OK);
1267 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, -1, "-1e-10", ERR_OK);
1268 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 0, "0.000000", ERR_OK);
1269 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 0, "0.000001", ERR_OK);
1270 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 0, "0.5", ERR_OK);
1271 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 0, "0.999999", ERR_OK);
1272 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 1, "1.000001", ERR_OK);
1273 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 1, "1.5", ERR_OK);
1274 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 1, "1.999999", ERR_OK);
1275 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 2, "2.000000", ERR_OK);
1276 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 2, "2.000001", ERR_OK);
1277 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 2, "2.5", ERR_OK);
1278 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 2, "2.999999", ERR_OK);
1279 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 3, "3.000000", ERR_OK);
1280 GetInt32ValueResultTest(TEST_KEY1, TEST_USER1, 3, "3.000001", ERR_OK);
1281 }
1282
1283 HWTEST_F(SettingDataManagerTest, GetInt32Value_0600, TestSize.Level1)
1284 {
1285 GetInt32ValueStrictlyResultTest(TEST_KEY1, INVALID_USER_ID, 0, "0", ERR_OK);
1286 GetInt32ValueStrictlyResultTest(TEST_KEY2, INVALID_USER_ID, 1, "1", ERR_OK);
1287 GetInt32ValueStrictlyResultTest(TEST_KEY3, INVALID_USER_ID, -1, "-1", ERR_OK);
1288 GetInt32ValueStrictlyResultTest(TEST_KEY1, INVALID_USER_ID, 0, "0", ERR_OK);
1289 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER100, 0, "0", ERR_OK);
1290 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "0", ERR_OK);
1291
1292 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "abcdefghijklmnopqrstuvwxyz", ERR_INVALID_VALUE);
1293 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "!@#$%^&*()_+-={}[]<,>.?/:;", ERR_INVALID_VALUE);
1294 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "-9999999999999999999999999", ERR_INVALID_VALUE);
1295 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "99999999999999999999999999", ERR_INVALID_VALUE);
1296 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "abcdefghijkl99999999999999", ERR_INVALID_VALUE);
1297 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "abc999", ERR_INVALID_VALUE);
1298 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "", ERR_INVALID_VALUE);
1299
1300 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "999abc", ERR_INVALID_VALUE);
1301 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "1e10", ERR_INVALID_VALUE);
1302 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "1e-10", ERR_INVALID_VALUE);
1303 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "-1e10", ERR_INVALID_VALUE);
1304 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "-1e-10", ERR_INVALID_VALUE);
1305 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "0.000000", ERR_INVALID_VALUE);
1306 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "0.000001", ERR_INVALID_VALUE);
1307 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "0.5", ERR_INVALID_VALUE);
1308 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "0.999999", ERR_INVALID_VALUE);
1309 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "1.000001", ERR_INVALID_VALUE);
1310 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "1.5", ERR_INVALID_VALUE);
1311 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "1.999999", ERR_INVALID_VALUE);
1312 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "2.000000", ERR_INVALID_VALUE);
1313 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "2.000001", ERR_INVALID_VALUE);
1314 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "2.5", ERR_INVALID_VALUE);
1315 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "2.999999", ERR_INVALID_VALUE);
1316 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "3.000000", ERR_INVALID_VALUE);
1317 GetInt32ValueStrictlyResultTest(TEST_KEY1, TEST_USER1, 0, "3.000001", ERR_INVALID_VALUE);
1318 }
1319
1320 HWTEST_F(SettingDataManagerTest, GetBoolValue_0100, TestSize.Level1)
1321 {
1322 GetBoolValueCreateFailTest(TEST_KEY1, INVALID_USER_ID);
1323 GetBoolValueCreateFailTest(TEST_KEY2, INVALID_USER_ID);
1324 GetBoolValueCreateFailTest(TEST_KEY3, INVALID_USER_ID);
1325 GetBoolValueCreateFailTest(TEST_KEY1, INVALID_USER_ID);
1326 GetBoolValueCreateFailTest(TEST_KEY1, TEST_USER100);
1327 GetBoolValueCreateFailTest(TEST_KEY1, TEST_USER1);
1328 }
1329
1330 HWTEST_F(SettingDataManagerTest, GetBoolValue_0200, TestSize.Level1)
1331 {
1332 GetBoolValueQueryNullTest(TEST_KEY1, INVALID_USER_ID);
1333 GetBoolValueQueryNullTest(TEST_KEY2, INVALID_USER_ID);
1334 GetBoolValueQueryNullTest(TEST_KEY3, INVALID_USER_ID);
1335 GetBoolValueQueryNullTest(TEST_KEY1, INVALID_USER_ID);
1336 GetBoolValueQueryNullTest(TEST_KEY1, TEST_USER100);
1337 GetBoolValueQueryNullTest(TEST_KEY1, TEST_USER1);
1338 }
1339
1340 HWTEST_F(SettingDataManagerTest, GetBoolValue_0300, TestSize.Level1)
1341 {
1342 GetBoolValueResultNotFoundTest(TEST_KEY1, INVALID_USER_ID);
1343 GetBoolValueResultNotFoundTest(TEST_KEY2, INVALID_USER_ID);
1344 GetBoolValueResultNotFoundTest(TEST_KEY3, INVALID_USER_ID);
1345 GetBoolValueResultNotFoundTest(TEST_KEY1, INVALID_USER_ID);
1346 GetBoolValueResultNotFoundTest(TEST_KEY1, TEST_USER100);
1347 GetBoolValueResultNotFoundTest(TEST_KEY1, TEST_USER1);
1348 }
1349
1350 HWTEST_F(SettingDataManagerTest, GetBoolValue_0400, TestSize.Level1)
1351 {
1352 GetBoolValueResultGetStringFailTest(TEST_KEY1, INVALID_USER_ID);
1353 GetBoolValueResultGetStringFailTest(TEST_KEY2, INVALID_USER_ID);
1354 GetBoolValueResultGetStringFailTest(TEST_KEY3, INVALID_USER_ID);
1355 GetBoolValueResultGetStringFailTest(TEST_KEY1, INVALID_USER_ID);
1356 GetBoolValueResultGetStringFailTest(TEST_KEY1, TEST_USER100);
1357 GetBoolValueResultGetStringFailTest(TEST_KEY1, TEST_USER1);
1358 }
1359
1360 HWTEST_F(SettingDataManagerTest, GetBoolValue_0500, TestSize.Level1)
1361 {
1362 GetBoolValueResultTest(TEST_KEY1, INVALID_USER_ID, true, "true", ERR_OK);
1363 GetBoolValueResultTest(TEST_KEY2, INVALID_USER_ID, false, "false", ERR_OK);
1364 GetBoolValueResultTest(TEST_KEY3, INVALID_USER_ID, true, "true", ERR_OK);
1365 GetBoolValueResultTest(TEST_KEY1, INVALID_USER_ID, false, "false", ERR_OK);
1366 GetBoolValueResultTest(TEST_KEY1, TEST_USER100, true, "true", ERR_OK);
1367 GetBoolValueResultTest(TEST_KEY1, TEST_USER1, false, "false", ERR_OK);
1368
1369 GetBoolValueResultTest(TEST_KEY1, TEST_USER1, false, "false1", ERR_INVALID_VALUE);
1370 GetBoolValueResultTest(TEST_KEY1, TEST_USER1, false, "fals", ERR_INVALID_VALUE);
1371 GetBoolValueResultTest(TEST_KEY1, TEST_USER1, false, "1false", ERR_INVALID_VALUE);
1372 GetBoolValueResultTest(TEST_KEY1, TEST_USER1, false, "true1", ERR_INVALID_VALUE);
1373 GetBoolValueResultTest(TEST_KEY1, TEST_USER1, false, "tru", ERR_INVALID_VALUE);
1374 GetBoolValueResultTest(TEST_KEY1, TEST_USER1, false, "1true", ERR_INVALID_VALUE);
1375 GetBoolValueResultTest(TEST_KEY1, TEST_USER1, false, "", ERR_INVALID_VALUE);
1376 }
1377
1378 HWTEST_F(SettingDataManagerTest, IsValidKey_0100, TestSize.Level1)
1379 {
1380 IsValidKeyCreateFailTest(TEST_KEY1, INVALID_USER_ID);
1381 IsValidKeyCreateFailTest(TEST_KEY2, INVALID_USER_ID);
1382 IsValidKeyCreateFailTest(TEST_KEY3, INVALID_USER_ID);
1383 IsValidKeyCreateFailTest(TEST_KEY1, INVALID_USER_ID);
1384 IsValidKeyCreateFailTest(TEST_KEY1, TEST_USER100);
1385 IsValidKeyCreateFailTest(TEST_KEY1, TEST_USER1);
1386 }
1387
1388 HWTEST_F(SettingDataManagerTest, IsValidKey_0200, TestSize.Level1)
1389 {
1390 IsValidKeyQueryNullTest(TEST_KEY1, INVALID_USER_ID);
1391 IsValidKeyQueryNullTest(TEST_KEY2, INVALID_USER_ID);
1392 IsValidKeyQueryNullTest(TEST_KEY3, INVALID_USER_ID);
1393 IsValidKeyQueryNullTest(TEST_KEY1, INVALID_USER_ID);
1394 IsValidKeyQueryNullTest(TEST_KEY1, TEST_USER100);
1395 IsValidKeyQueryNullTest(TEST_KEY1, TEST_USER1);
1396 }
1397
1398 HWTEST_F(SettingDataManagerTest, IsValidKey_0300, TestSize.Level1)
1399 {
1400 IsValidKeyResultNotFoundTest(TEST_KEY1, INVALID_USER_ID);
1401 IsValidKeyResultNotFoundTest(TEST_KEY2, INVALID_USER_ID);
1402 IsValidKeyResultNotFoundTest(TEST_KEY3, INVALID_USER_ID);
1403 IsValidKeyResultNotFoundTest(TEST_KEY1, INVALID_USER_ID);
1404 IsValidKeyResultNotFoundTest(TEST_KEY1, TEST_USER100);
1405 IsValidKeyResultNotFoundTest(TEST_KEY1, TEST_USER1);
1406 }
1407
1408 HWTEST_F(SettingDataManagerTest, IsValidKey_0400, TestSize.Level1)
1409 {
1410 IsValidKeyResultGetStringFailTest(TEST_KEY1, INVALID_USER_ID);
1411 IsValidKeyResultGetStringFailTest(TEST_KEY2, INVALID_USER_ID);
1412 IsValidKeyResultGetStringFailTest(TEST_KEY3, INVALID_USER_ID);
1413 IsValidKeyResultGetStringFailTest(TEST_KEY1, INVALID_USER_ID);
1414 IsValidKeyResultGetStringFailTest(TEST_KEY1, TEST_USER100);
1415 IsValidKeyResultGetStringFailTest(TEST_KEY1, TEST_USER1);
1416 }
1417
1418 HWTEST_F(SettingDataManagerTest, IsValidKey_0500, TestSize.Level1)
1419 {
1420 IsValidKeyResultTest(TEST_KEY1, INVALID_USER_ID, true, TEST_VAL1);
1421 IsValidKeyResultTest(TEST_KEY2, INVALID_USER_ID, true, TEST_VAL2);
1422 IsValidKeyResultTest(TEST_KEY3, INVALID_USER_ID, true, TEST_VAL3);
1423 IsValidKeyResultTest(TEST_KEY1, INVALID_USER_ID, true, TEST_VAL1);
1424 IsValidKeyResultTest(TEST_KEY1, TEST_USER100, true, TEST_VAL1);
1425 IsValidKeyResultTest(TEST_KEY1, TEST_USER1, true, TEST_VAL1);
1426 IsValidKeyResultTest(TEST_KEY1, TEST_USER1, false, "");
1427 }
1428 } // namespace OHOS::ArkUi::UiAppearance
1429