1/* 2* Copyright (c) 2023 Huawei Device Co., Ltd. 3* Licensed under the Apache License, Version 2.0 (the "License"); 4* you may not use this file except in compliance with the License. 5* You may obtain a copy of the License at 6* 7* http://www.apache.org/licenses/LICENSE-2.0 8* 9* Unless required by applicable law or agreed to in writing, software 10* distributed under the License is distributed on an "AS IS" BASIS, 11* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12* See the License for the specific language governing permissions and 13* limitations under the License. 14*/ 15import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium'; 16import data_preferences from '@ohos.data.preferences'; 17import featureAbility from '@ohos.ability.featureAbility'; 18 19const NAME = 'test_preferences_store'; 20const KEY_TEST_INT_ELEMENT = 'key_test_int'; 21const KEY_TEST_LONG_ELEMENT = 'key_test_long'; 22const KEY_TEST_FLOAT_ELEMENT = 'key_test_float'; 23const KEY_TEST_BOOLEAN_ELEMENT = 'key_test_boolean'; 24const KEY_TEST_STRING_ELEMENT = 'key_test_string'; 25const KEY_TEST_NUMBER_ARRAY_ELEMENT = 'key_test_number_array'; 26const KEY_TEST_STRING_ARRAY_ELEMENT = 'key_test_string_array'; 27const KEY_TEST_BOOL_ARRAY_ELEMENT = 'key_test_bool_array'; 28let mPreferences; 29let context; 30 31export default function PreferencesSyncTest() { 32 describe('PreferencesSyncTest', function () { 33 beforeAll(async function () { 34 console.info('beforeAll'); 35 context = featureAbility.getContext(); 36 mPreferences = await data_preferences.getPreferences(context, NAME); 37 }) 38 39 afterAll(async function () { 40 console.info('afterAll'); 41 await data_preferences.deletePreferences(context, NAME); 42 }) 43 44 /** 45 * @tc.number SUB_DDM_Preferences_PutSync_0100 46 * @tc.name putSync StringArray interface test 47 * @tc.desc putSync StringArray interface test 48 */ 49 it('SUB_DDM_Preferences_PutSync_0100', 0, function (done) { 50 mPreferences.clearSync(); 51 const stringArr = ['1', '2', '3']; 52 mPreferences.putSync(KEY_TEST_STRING_ARRAY_ELEMENT, stringArr); 53 let rc = mPreferences.getSync(KEY_TEST_STRING_ARRAY_ELEMENT, []); 54 for (let i = 0; i < stringArr.length; i++) { 55 console.info('ttt stringArr = ' + stringArr[i] + ' rc = ' + rc[i]); 56 expect(stringArr[i]).assertEqual(rc[i]); 57 } 58 done(); 59 }); 60 61 /** 62 * @tc.number SUB_DDM_Preferences_PutSync_0200 63 * @tc.name putSync numberArr interface test 64 * @tc.desc putSync numberArr interface test 65 */ 66 it('SUB_DDM_Preferences_PutSync_0200', 0, async function (done) { 67 mPreferences.clearSync(); 68 const numberArr = [1, 2, 3]; 69 mPreferences.putSync(KEY_TEST_NUMBER_ARRAY_ELEMENT, numberArr); 70 let rc = mPreferences.getSync(KEY_TEST_NUMBER_ARRAY_ELEMENT, []); 71 for (let i = 0; i < numberArr.length; i++) { 72 console.info('ttt stringArr = ' + numberArr[i] + ' rc = ' + rc[i]); 73 expect(numberArr[i]).assertEqual(rc[i]); 74 } 75 done(); 76 }); 77 78 /** 79 * @tc.number SUB_DDM_Preferences_PutSync_0300 80 * @tc.name putSync boolArr interface test 81 * @tc.desc putSync boolArr interface test 82 */ 83 it('SUB_DDM_Preferences_PutSync_0300', 0, async function (done) { 84 mPreferences.clearSync(); 85 const boolArr = [true, true, false]; 86 mPreferences.putSync(KEY_TEST_BOOL_ARRAY_ELEMENT, boolArr); 87 let rc = mPreferences.getSync(KEY_TEST_BOOL_ARRAY_ELEMENT, [false, true]); 88 for (let i = 0; i < boolArr.length; i++) { 89 console.info('ttt stringArr = ' + boolArr[i] + ' rc = ' + rc[i]); 90 expect(boolArr[i]).assertEqual(rc[i]); 91 } 92 done(); 93 }); 94 95 /** 96 * @tc.number SUB_DDM_Preferences_GetAllSync_0100 97 * @tc.name getAllSync interface test 98 * @tc.desc getAllSync interface test 99 */ 100 it('SUB_DDM_Preferences_GetAllSync_0100', 0, async function (done) { 101 mPreferences.clearSync(); 102 const doubleArr = [11, 22, 33]; 103 const stringArr = ['11', '22', '33']; 104 const boolArr = [true, false, false, true]; 105 mPreferences.putSync(KEY_TEST_STRING_ARRAY_ELEMENT, stringArr); 106 mPreferences.putSync(KEY_TEST_BOOL_ARRAY_ELEMENT, boolArr); 107 mPreferences.putSync(KEY_TEST_NUMBER_ARRAY_ELEMENT, doubleArr); 108 mPreferences.putSync(KEY_TEST_BOOLEAN_ELEMENT, false); 109 mPreferences.putSync(KEY_TEST_STRING_ELEMENT, "123"); 110 mPreferences.putSync(KEY_TEST_FLOAT_ELEMENT, 123.1); 111 await mPreferences.flush(); 112 let obj = mPreferences.getAllSync(); 113 expect(false).assertEqual(obj.key_test_boolean); 114 expect("123").assertEqual(obj.key_test_string); 115 expect(123.1).assertEqual(obj.key_test_float); 116 let sArr = obj.key_test_string_array; 117 for (let i = 0; i < sArr.length; i++) { 118 expect(sArr[i]).assertEqual(stringArr[i]); 119 } 120 let bArr = obj.key_test_bool_array; 121 for (let i = 0; i < bArr.length; i++) { 122 expect(bArr[i]).assertEqual(boolArr[i]); 123 } 124 let nArr = obj.key_test_number_array; 125 for (let i = 0; i < nArr.length; i++) { 126 expect(nArr[i]).assertEqual(doubleArr[i]); 127 } 128 done(); 129 }) 130 131 /** 132 * @tc.number SUB_DDM_Preferences_ClearSync_0100 133 * @tc.name clearSync interface test 134 * @tc.desc clearSync interface test 135 */ 136 it('SUB_DDM_Preferences_ClearSync_0100', 0, async function (done) { 137 mPreferences.clearSync(); 138 mPreferences.putSync(KEY_TEST_STRING_ELEMENT, "test"); 139 await mPreferences.flush(); 140 mPreferences.clearSync(); 141 let per = mPreferences.getSync(KEY_TEST_STRING_ELEMENT, "defaultvalue"); 142 expect("defaultvalue").assertEqual(per); 143 done(); 144 }) 145 146 /** 147 * @tc.number SUB_DDM_Preferences_HasSync_0100 148 * @tc.name hasSync interface test 149 * @tc.desc hasSync interface test 150 */ 151 it('SUB_DDM_Preferences_HasSync_0100', 0, async function (done) { 152 mPreferences.clearSync(); 153 mPreferences.putSync(KEY_TEST_STRING_ELEMENT, "test"); 154 const ret = mPreferences.hasSync(KEY_TEST_STRING_ELEMENT); 155 expect(true).assertEqual(ret); 156 done(); 157 }) 158 159 /** 160 * @tc.number SUB_DDM_Preferences_HasSync_0200 161 * @tc.name hasSync interface test 162 * @tc.desc hasSync interface test 163 */ 164 it('SUB_DDM_Preferences_HasSync_0200', 0, async function (done) { 165 mPreferences.clearSync(); 166 mPreferences.putSync(KEY_TEST_INT_ELEMENT, 1); 167 const ret = mPreferences.hasSync(KEY_TEST_INT_ELEMENT); 168 expect(true).assertEqual(ret); 169 done(); 170 }) 171 172 /** 173 * @tc.number SUB_DDM_Preferences_HasSync_0300 174 * @tc.name hasSync interface test 175 * @tc.desc hasSync interface test 176 */ 177 it('SUB_DDM_Preferences_HasSync_0300', 0, async function (done) { 178 mPreferences.clearSync(); 179 mPreferences.putSync(KEY_TEST_FLOAT_ELEMENT, 2.0); 180 const ret = mPreferences.hasSync(KEY_TEST_FLOAT_ELEMENT); 181 expect(true).assertEqual(ret); 182 done(); 183 }) 184 185 /** 186 * @tc.number SUB_DDM_Preferences_HasSync_0400 187 * @tc.name hasSync interface test 188 * @tc.desc hasSync interface test 189 */ 190 it('SUB_DDM_Preferences_HasSync_0400', 0, async function (done) { 191 mPreferences.clearSync(); 192 mPreferences.putSync(KEY_TEST_BOOLEAN_ELEMENT, false); 193 const ret = mPreferences.hasSync(KEY_TEST_BOOLEAN_ELEMENT); 194 expect(true).assertEqual(ret); 195 done(); 196 }) 197 198 /** 199 * @tc.number SUB_DDM_Preferences_HasSync_0500 200 * @tc.name hasSync interface test 201 * @tc.desc hasSync interface test 202 */ 203 it('SUB_DDM_Preferences_HasSync_0500', 0, async function (done) { 204 mPreferences.clearSync(); 205 mPreferences.putSync(KEY_TEST_LONG_ELEMENT, 0); 206 const ret = mPreferences.hasSync(KEY_TEST_LONG_ELEMENT); 207 expect(true).assertEqual(ret); 208 done(); 209 }) 210 211 /** 212 * @tc.number SUB_DDM_Preferences_HasSync_0600 213 * @tc.name hasSync interface test 214 * @tc.desc hasSync interface test 215 */ 216 it('SUB_DDM_Preferences_HasSync_0600', 0, async function (done) { 217 mPreferences.clearSync(); 218 const ret = mPreferences.hasSync(KEY_TEST_LONG_ELEMENT); 219 console.info('ret = ' + ret); 220 expect(ret === false).assertTrue(); 221 done(); 222 }) 223 224 /** 225 * @tc.number SUB_DDM_Preferences_GetSync_0100 226 * @tc.name getSync interface test 227 * @tc.desc getSync interface test 228 */ 229 it('SUB_DDM_Preferences_GetSync_0100', 0, async function (done) { 230 mPreferences.clearSync(); 231 const ret = mPreferences.getSync(KEY_TEST_STRING_ELEMENT, "defaultValue"); 232 expect('defaultValue').assertEqual(ret); 233 done(); 234 }) 235 236 /** 237 * @tc.number SUB_DDM_Preferences_GetSync_0200 238 * @tc.name getSync interface test 239 * @tc.desc getSync interface test 240 */ 241 it('SUB_DDM_Preferences_GetSync_0200', 0, async function (done) { 242 mPreferences.clearSync(); 243 mPreferences.putSync(KEY_TEST_FLOAT_ELEMENT, 3.0); 244 const ret = mPreferences.getSync(KEY_TEST_FLOAT_ELEMENT, 0.0); 245 expect(3.0).assertEqual(ret); 246 done(); 247 }) 248 249 /** 250 * @tc.number SUB_DDM_Preferences_GetSync_0300 251 * @tc.name getSync interface test 252 * @tc.desc getSync interface test 253 */ 254 it('SUB_DDM_Preferences_GetSync_0300', 0, async function (done) { 255 mPreferences.clearSync(); 256 mPreferences.putSync(KEY_TEST_INT_ELEMENT, 3); 257 const ret = mPreferences.getSync(KEY_TEST_INT_ELEMENT, 0.0); 258 expect(3).assertEqual(ret); 259 done(); 260 }) 261 262 /** 263 * @tc.number SUB_DDM_Preferences_GetSync_0400 264 * @tc.name getSync interface test 265 * @tc.desc getSync interface test 266 */ 267 it('SUB_DDM_Preferences_GetSync_0400', 0, async function (done) { 268 mPreferences.clearSync(); 269 mPreferences.putSync(KEY_TEST_LONG_ELEMENT, 3); 270 const ret = mPreferences.getSync(KEY_TEST_LONG_ELEMENT, 0); 271 expect(3).assertEqual(ret); 272 done(); 273 }) 274 275 /** 276 * @tc.number SUB_DDM_Preferences_GetSync_0500 277 * @tc.name getSync interface test 278 * @tc.desc getSync interface test 279 */ 280 it('SUB_DDM_Preferences_GetSync_0500', 0, async function (done) { 281 mPreferences.clearSync(); 282 mPreferences.putSync(KEY_TEST_STRING_ELEMENT, "test"); 283 await mPreferences.flush(); 284 const ret = mPreferences.getSync(KEY_TEST_STRING_ELEMENT, "defaultvalue"); 285 expect('test').assertEqual(ret); 286 done(); 287 }) 288 289 /** 290 * @tc.number SUB_DDM_Preferences_PutSync_0400 291 * @tc.name putSync interface test 292 * @tc.desc putSync interface test 293 */ 294 it('SUB_DDM_Preferences_PutSync_0400', 0, async function (done) { 295 mPreferences.clearSync(); 296 mPreferences.putSync(KEY_TEST_BOOLEAN_ELEMENT, true); 297 let per = mPreferences.getSync(KEY_TEST_BOOLEAN_ELEMENT, false); 298 expect(true).assertEqual(per); 299 await mPreferences.flush(); 300 let per2 = mPreferences.getSync(KEY_TEST_BOOLEAN_ELEMENT, false); 301 expect(true).assertEqual(per2); 302 done(); 303 }) 304 305 /** 306 * @tc.number SUB_DDM_Preferences_PutSync_0500 307 * @tc.name putSync interface test 308 * @tc.desc putSync interface test 309 */ 310 it('SUB_DDM_Preferences_PutSync_0500', 0, async function (done) { 311 mPreferences.clearSync(); 312 mPreferences.putSync(KEY_TEST_FLOAT_ELEMENT, 4.0); 313 let per = mPreferences.getSync(KEY_TEST_FLOAT_ELEMENT, 0.0); 314 expect(4.0).assertEqual(per); 315 await mPreferences.flush(); 316 let per2 = mPreferences.getSync(KEY_TEST_FLOAT_ELEMENT, 0.0); 317 expect(4.0).assertEqual(per2); 318 done(); 319 }) 320 321 /** 322 * @tc.number SUB_DDM_Preferences_PutSync_0600 323 * @tc.name putSync interface test 324 * @tc.desc putSync interface test 325 */ 326 it('SUB_DDM_Preferences_PutSync_0600', 0, async function (done) { 327 mPreferences.clearSync(); 328 mPreferences.putSync(KEY_TEST_INT_ELEMENT, 4); 329 let per = mPreferences.getSync(KEY_TEST_INT_ELEMENT, 0); 330 expect(4).assertEqual(per); 331 await mPreferences.flush(); 332 let per2 = mPreferences.getSync(KEY_TEST_INT_ELEMENT, 0); 333 expect(4).assertEqual(per2); 334 done(); 335 }) 336 337 /** 338 * @tc.number SUB_DDM_Preferences_PutSync_0700 339 * @tc.name putSync interface test 340 * @tc.desc putSync interface test 341 */ 342 it('SUB_DDM_Preferences_PutSync_0700', 0, async function (done) { 343 mPreferences.clearSync(); 344 mPreferences.putSync(KEY_TEST_LONG_ELEMENT, 4); 345 let per = mPreferences.getSync(KEY_TEST_LONG_ELEMENT, 0); 346 expect(4).assertEqual(per); 347 await mPreferences.flush(); 348 let per2 = mPreferences.getSync(KEY_TEST_LONG_ELEMENT, 0); 349 expect(4).assertEqual(per2); 350 done(); 351 }) 352 353 /** 354 * @tc.number SUB_DDM_Preferences_PutSync_0800 355 * @tc.name putSync interface test 356 * @tc.desc putSync interface test 357 */ 358 it('SUB_DDM_Preferences_PutSync_0800', 0, async function (done) { 359 mPreferences.clearSync(); 360 mPreferences.putSync(KEY_TEST_STRING_ELEMENT, ''); 361 let per = mPreferences.getSync(KEY_TEST_STRING_ELEMENT, "defaultvalue"); 362 expect('').assertEqual(per); 363 await mPreferences.flush(); 364 let per2 = mPreferences.getSync(KEY_TEST_STRING_ELEMENT, "defaultvalue"); 365 expect('').assertEqual(per2); 366 done(); 367 }) 368 369 /** 370 * @tc.number SUB_DDM_Preferences_deleteSync_0100 371 * @tc.name deleteSync interface test 372 * @tc.desc deleteSync interface test 373 */ 374 it('SUB_DDM_Preferences_deleteSync_0100', 0, async function (done) { 375 mPreferences.putSync(KEY_TEST_STRING_ELEMENT, "abc"); 376 expect("abc").assertEqual(mPreferences.getSync(KEY_TEST_STRING_ELEMENT, "default")); 377 mPreferences.deleteSync(KEY_TEST_STRING_ELEMENT); 378 expect("default").assertEqual(mPreferences.getSync(KEY_TEST_STRING_ELEMENT, "default")); 379 done(); 380 }) 381 382 /** 383 * @tc.number SUB_DDM_Preferences_removePreferencesFromCacheSync_0100 384 * @tc.name removePreferencesFromCacheSync interface test 385 * @tc.desc removePreferencesFromCacheSync interface test 386 */ 387 it('SUB_DDM_Preferences_removePreferencesFromCacheSync_0100', 0, async function (done) { 388 console.log("SUB_DDM_Preferences_removePreferencesFromCacheSync_0100 begin."); 389 mPreferences = await data_preferences.getPreferences(context, NAME); 390 await mPreferences.clearSync(); 391 await mPreferences.putSync(KEY_TEST_STRING_ELEMENT, 'test') 392 await mPreferences.getSync(KEY_TEST_STRING_ELEMENT, "defaultvalue") 393 mPreferences.flush(async function (err, val) { 394 if (err) { 395 console.log("flush err."); 396 expect().assertFail(); 397 } 398 console.log("flush done."); 399 await data_preferences.removePreferencesFromCacheSync(context, NAME); 400 let value = mPreferences.getSync(KEY_TEST_STRING_ELEMENT, "defaultvalue") 401 console.log("SUB_DDM_Preferences_removePreferencesFromCacheSync_0100 end." + value); 402 expect('test').assertEqual(value); 403 done(); 404 console.log("SUB_DDM_Preferences_removePreferencesFromCacheSync_0100 end."); 405 }); 406 }) 407 }) 408}