1 /*
2 * Copyright (c) 2022 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 <thread>
18
19 #include "accesstoken_kit.h"
20 #include "distributed_object.h"
21 #include "distributed_object_impl.h"
22 #include "distributed_objectstore.h"
23 #include "distributed_objectstore_impl.h"
24 #include "flat_object_storage_engine.h"
25 #include "flat_object_store.h"
26 #include "mock_flat_object_watcher.h"
27 #include "mock_object_watcher.h"
28 #include "nativetoken_kit.h"
29 #include "object_storage_engine.h"
30 #include "objectstore_errors.h"
31 #include "store_errno.h"
32 #include "token_setproc.h"
33
34 using namespace testing::ext;
35 using namespace OHOS::ObjectStore;
36 using namespace OHOS::Security::AccessToken;
37 namespace {
38 // object service error code
39 enum Status : int32_t {
40 OBJECT_SUCCESS,
41 OBJECT_DBSTATUS_ERROR,
42 OBJECT_INNER_ERROR,
43 OBJECT_PERMISSION_DENIED,
44 OBJECT_STORE_NOT_FOUND
45 };
46 constexpr static double SALARY = 100.5;
47 class TableWatcherImpl : public TableWatcher {
48 public:
TableWatcherImpl(const std::string & sessionId)49 explicit TableWatcherImpl(const std::string &sessionId) : TableWatcher(sessionId) {}
50 void OnChanged(
51 const std::string &sessionid, const std::vector<std::string> &changedData, bool enableTransfer) override;
52 virtual ~TableWatcherImpl();
53 };
54
~TableWatcherImpl()55 TableWatcherImpl::~TableWatcherImpl() {}
OnChanged(const std::string & sessionid,const std::vector<std::string> & changedData,bool enableTransfer)56 void TableWatcherImpl::OnChanged(
57 const std::string &sessionid, const std::vector<std::string> &changedData, bool enableTransfer) {}
58
59 class StatusNotifierImpl : public StatusWatcher {
60 public:
61 void OnChanged(
62 const std::string &sessionId, const std::string &networkId, const std::string &onlineStatus) override;
63 virtual ~StatusNotifierImpl();
64 };
~StatusNotifierImpl()65 StatusNotifierImpl::~StatusNotifierImpl() {}
66
OnChanged(const std::string & sessionId,const std::string & networkId,const std::string & onlineStatus)67 void StatusNotifierImpl::OnChanged(const std::string &sessionId,
68 const std::string &networkId,
69 const std::string &onlineStatus)
70 {
71 }
72
73 class ProgressNotifierImpl : public ProgressWatcher {
74 public:
75 void OnChanged(const std::string &sessionId, int32_t progress) override;
76 virtual ~ProgressNotifierImpl();
77 };
~ProgressNotifierImpl()78 ProgressNotifierImpl::~ProgressNotifierImpl()
79 {
80 }
81
OnChanged(const std::string & sessionId,int32_t progress)82 void ProgressNotifierImpl::OnChanged(const std::string &sessionId, int32_t progress)
83 {
84 }
GrantPermissionNative()85 void GrantPermissionNative()
86 {
87 const char **perms = new const char *[3];
88 perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
89 perms[1] = "ohos.permission.DISTRIBUTED_SOFTBUS_CENTER";
90 perms[2] = "ohos.permission.MONITOR_DEVICE_NETWORK_STATE"; // perms[2] is a permission parameter
91 TokenInfoParams infoInstance = {
92 .dcapsNum = 0,
93 .permsNum = 3,
94 .aclsNum = 0,
95 .dcaps = nullptr,
96 .perms = perms,
97 .acls = nullptr,
98 .processName = "distributed_object",
99 .aplStr = "system_basic",
100 };
101 uint64_t tokenId = GetAccessTokenId(&infoInstance);
102 SetSelfTokenID(tokenId);
103 AccessTokenKit::ReloadNativeTokenInfo();
104 }
105
106 class NativeObjectStoreTest : public testing::Test {
107 public:
108 static void SetUpTestCase(void);
109 static void TearDownTestCase(void);
110 void SetUp();
111 void TearDown();
112 };
113
SetUpTestCase(void)114 void NativeObjectStoreTest::SetUpTestCase(void)
115 {
116 // input testsuit setup step，setup invoked before all testcases
117 }
118
TearDownTestCase(void)119 void NativeObjectStoreTest::TearDownTestCase(void)
120 {
121 // input testsuit teardown step，teardown invoked after all testcases
122 }
123
SetUp(void)124 void NativeObjectStoreTest::SetUp(void)
125 {
126 // input testcase setup step，setup invoked before each testcases
127 GrantPermissionNative();
128 }
129
TearDown(void)130 void NativeObjectStoreTest::TearDown(void)
131 {
132 // input testcase teardown step，teardown invoked after each testcases
133 }
134
135 /**
136 * @tc.name: DistributedObjectStore_Create_Destroy_001
137 * @tc.desc: test Create DistributedObject and Destroy DistrbutedObject
138 * @tc.type: FUNC
139 */
140 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Create_Destroy_001, TestSize.Level1)
141 {
142 std::string bundleName = "default";
143 std::string sessionId = "123456";
144 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
145 ASSERT_NE(nullptr, objectStore);
146
147 DistributedObject *object = objectStore->CreateObject(sessionId);
148 ASSERT_NE(nullptr, object);
149
150 uint32_t ret = objectStore->DeleteObject(sessionId);
151 EXPECT_EQ(SUCCESS, ret);
152 }
153
154 /**
155 * @tc.name: DistributedObjectStore_Create_Destroy_002
156 * @tc.desc: test Create DistributedObject and Destroy DistrbutedObject
157 * @tc.type: FUNC
158 */
159 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Create_Destroy_002, TestSize.Level1)
160 {
161 std::string sessionId = "123456";
162
163 auto objectStore = new DistributedObjectStoreImpl(nullptr);
164 DistributedObject *object = objectStore->CreateObject(sessionId);
165 EXPECT_EQ(nullptr, object);
166 delete objectStore;
167 }
168
169 /**
170 * @tc.name: DistributedObjectStore_Create_Destroy_003
171 * @tc.desc: test Create DistributedObject and Destroy DistrbutedObject
172 * @tc.type: FUNC
173 */
174 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Create_Destroy_003, TestSize.Level1)
175 {
176 std::string bundleName = "default";
177 std::string sessionId = "123456";
178 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
179 ASSERT_NE(nullptr, objectStore);
180
181 DistributedObject *object = objectStore->CreateObject(sessionId);
182 ASSERT_NE(nullptr, object);
183
184 DistributedObject *object2 = objectStore->CreateObject(sessionId);
185 EXPECT_EQ(nullptr, object2);
186
187 uint32_t ret = objectStore->DeleteObject(sessionId);
188 EXPECT_EQ(SUCCESS, ret);
189 }
190
191 /**
192 * @tc.name: DistributedObjectStore_Create_Destroy_004
193 * @tc.desc: test Create DistributedObject and Destroy DistrbutedObject
194 * @tc.type: FUNC
195 */
196 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Create_Destroy_004, TestSize.Level1)
197 {
198 std::string bundleName = "default";
199 std::string sessionId = "123456";
200 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
201 ASSERT_NE(nullptr, objectStore);
202
203 uint32_t status = -1;
204 DistributedObject *object = objectStore->CreateObject(sessionId, status);
205 ASSERT_NE(nullptr, object);
206 EXPECT_EQ(SUCCESS, status);
207
208 uint32_t ret = objectStore->DeleteObject(sessionId);
209 EXPECT_EQ(SUCCESS, ret);
210 }
211
212 /**
213 * @tc.name: DistributedObjectStoreImpl_CreateObject_001
214 * @tc.desc: test Create DistributedObjectStoreImpl
215 * @tc.type: FUNC
216 */
217 HWTEST_F(NativeObjectStoreTest, DistributedObjectStoreImpl_CreateObject_001, TestSize.Level1)
218 {
219 std::string bundleName = "default";
220 std::string sessionId = "123456";
221 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
222 ASSERT_NE(nullptr, objectStore);
223
224 DistributedObject *object = objectStore->CreateObject("");
225 EXPECT_EQ(nullptr, object);
226 }
227
228 /**
229 * @tc.name: DistributedObjectStoreImpl_CreateObject_002
230 * @tc.desc: test Create DistributedObjectStoreImpl
231 * @tc.type: FUNC
232 */
233 HWTEST_F(NativeObjectStoreTest, DistributedObjectStoreImpl_CreateObject_002, TestSize.Level1)
234 {
235 std::string sessionId = "123456";
236 auto objectStore = DistributedObjectStoreImpl(nullptr);
237 uint32_t status = -1;
238 DistributedObject *object = objectStore.CreateObject(sessionId, status);
239 EXPECT_EQ(nullptr, object);
240 EXPECT_EQ(ERR_NULL_OBJECTSTORE, status);
241
242 status = objectStore.DeleteObject(sessionId);
243 EXPECT_EQ(ERR_NULL_OBJECTSTORE, status);
244 }
245
246 /**
247 * @tc.name: DistributedObjectStoreImpl_CreateObject_003
248 * @tc.desc: test Create DistributedObjectStoreImpl
249 * @tc.type: FUNC
250 */
251 HWTEST_F(NativeObjectStoreTest, DistributedObjectStoreImpl_CreateObject_003, TestSize.Level1)
252 {
253 std::string bundleName = "default";
254 std::string sessionId = "";
255 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
256 ASSERT_NE(nullptr, objectStore);
257
258 uint32_t status = -1;
259 DistributedObject *object = objectStore->CreateObject(sessionId, status);
260 EXPECT_EQ(nullptr, object);
261 EXPECT_EQ(ERR_INVALID_ARGS, status);
262
263 status = objectStore->DeleteObject(sessionId);
264 EXPECT_EQ(ERR_DB_NOT_EXIST, status);
265 }
266
267 /**
268 * @tc.name: DistributedObjectStoreImpl_Get_001
269 * @tc.desc: test DistributedObjectStoreImpl Get
270 * @tc.type: FUNC
271 */
272 HWTEST_F(NativeObjectStoreTest, DistributedObjectStoreImpl_Get_001, TestSize.Level1)
273 {
274 std::string bundleName = "default";
275 std::string sessionId = "sessionId";
276 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
277 ASSERT_NE(nullptr, objectStore);
278
279 DistributedObject *object = objectStore->CreateObject(sessionId);
280 ASSERT_NE(nullptr, object);
281
282 DistributedObject *Object1 = nullptr;
283 uint32_t status = objectStore->Get("", &Object1);
284 EXPECT_EQ(ERR_GET_OBJECT, status);
285
286 status = objectStore->DeleteObject(sessionId);
287 EXPECT_EQ(SUCCESS, status);
288 }
289
290 /**
291 * @tc.name: DistributedObjectStoreImpl_Watch_001
292 * @tc.desc: test DistributedObjectStoreImpl Watch
293 * @tc.type: FUNC
294 */
295 HWTEST_F(NativeObjectStoreTest, DistributedObjectStoreImpl_Watch_001, TestSize.Level1)
296 {
297 std::string bundleName = "default";
298 std::string sessionId = "sessionId";
299 auto objectStore = new DistributedObjectStoreImpl(nullptr);
300
301 std::shared_ptr<MockObjectWatcher> watcher = std::make_shared<MockObjectWatcher>();
302 uint32_t status = objectStore->Watch(nullptr, watcher);
303 EXPECT_EQ(ERR_NULL_OBJECT, status);
304
305 auto flatObjectStore = new FlatObjectStore(bundleName);
306 auto object = new DistributedObjectImpl(sessionId, flatObjectStore);
307
308 status = objectStore->Watch(object, watcher);
309 EXPECT_EQ(ERR_NULL_OBJECTSTORE, status);
310
311 status = objectStore->UnWatch(object);
312 EXPECT_EQ(ERR_NULL_OBJECTSTORE, status);
313 delete objectStore;
314 delete flatObjectStore;
315 delete object;
316 }
317
318 /**
319 * @tc.name: DistributedObjectStoreImpl_Watch_002
320 * @tc.desc: test DistributedObjectStoreImpl Watch
321 * @tc.type: FUNC
322 */
323 HWTEST_F(NativeObjectStoreTest, DistributedObjectStoreImpl_Watch_002, TestSize.Level1)
324 {
325 std::string bundleName = "default";
326 std::string sessionId = "sessionId";
327 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
328 ASSERT_NE(nullptr, objectStore);
329
330 DistributedObject *object = objectStore->CreateObject(sessionId);
331 ASSERT_NE(nullptr, object);
332
333 std::shared_ptr<MockObjectWatcher> watcher = std::make_shared<MockObjectWatcher>();
334 uint32_t status = objectStore->Watch(object, watcher);
335 EXPECT_EQ(SUCCESS, status);
336
337 status = objectStore->Watch(object, watcher);
338 EXPECT_EQ(ERR_EXIST, status);
339
340 std::string bundleName1 = "default1";
341 std::string sessionId1 = "sessionId1";
342 auto flatObjectStore = new FlatObjectStore(bundleName1);
343 auto object1 = new DistributedObjectImpl(sessionId1, flatObjectStore);
344 status = objectStore->Watch(object1, watcher);
345 EXPECT_EQ(ERR_DB_NOT_EXIST, status);
346
347 status = objectStore->UnWatch(object1);
348 EXPECT_EQ(ERR_DB_NOT_EXIST, status);
349
350 status = objectStore->UnWatch(object);
351 EXPECT_EQ(SUCCESS, status);
352
353 status = objectStore->DeleteObject(sessionId);
354 EXPECT_EQ(SUCCESS, status);
355 delete flatObjectStore;
356 delete object1;
357 }
358
359 /**
360 * @tc.name: DistributedObjectStore_Get_001
361 * @tc.desc: test DistributedObjectStore Get.
362 * @tc.type: FUNC
363 */
364 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Get_001, TestSize.Level1)
365 {
366 std::string bundleName = "default";
367 std::string sessionId = "123456";
368 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
369 ASSERT_NE(nullptr, objectStore);
370
371 DistributedObject *object = objectStore->CreateObject(sessionId);
372 ASSERT_NE(nullptr, object);
373
374 DistributedObject *object2 = nullptr;
375 uint32_t ret = objectStore->Get(sessionId, &object2);
376 EXPECT_EQ(SUCCESS, ret);
377 EXPECT_EQ(object, object2);
378
379 ret = objectStore->DeleteObject(sessionId);
380 EXPECT_EQ(SUCCESS, ret);
381 }
382
383 /**
384 * @tc.name: DistributedObjectStore_Watch_UnWatch_001
385 * @tc.desc: test DistributedObjectStore Watch and UnWatch.
386 * @tc.type: FUNC
387 */
388 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Watch_UnWatch_001, TestSize.Level1)
389 {
390 std::string bundleName = "default";
391 std::string sessionId = "123456";
392 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
393 ASSERT_NE(nullptr, objectStore);
394
395 DistributedObject *object = objectStore->CreateObject(sessionId);
396 ASSERT_NE(nullptr, object);
397
398 auto watcherPtr = std::shared_ptr<ObjectWatcher>();
399 uint32_t ret = objectStore->Watch(object, watcherPtr);
400 EXPECT_EQ(SUCCESS, ret);
401
402 ret = objectStore->UnWatch(object);
403 EXPECT_EQ(SUCCESS, ret);
404
405 ret = objectStore->DeleteObject(sessionId);
406 EXPECT_EQ(SUCCESS, ret);
407 }
408
409 /**
410 * @tc.name: DistributedObjectStore_SetStatusNotifier_001
411 * @tc.desc: test DistributedObjectStore SetStatusNotifier.
412 * @tc.type: FUNC
413 */
414 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_SetStatusNotifier_001, TestSize.Level1)
415 {
416 std::string bundleName = "default";
417 std::string sessionId = "123456";
418 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
419 ASSERT_NE(nullptr, objectStore);
420 DistributedObject *object = objectStore->CreateObject(sessionId);
421 ASSERT_NE(nullptr, object);
422
423 auto notifierPtr = std::shared_ptr<StatusNotifier>();
424 uint32_t ret = objectStore->SetStatusNotifier(notifierPtr);
425 EXPECT_EQ(ret, 0);
426
427 objectStore->NotifyCachedStatus(sessionId);
428 ret = objectStore->DeleteObject(sessionId);
429 EXPECT_EQ(ret, 0);
430 }
431
432 /**
433 * @tc.name: DistributedObject_Double_001
434 * @tc.desc: test DistributedObjectStore PutDouble.
435 * @tc.type: FUNC
436 */
437 HWTEST_F(NativeObjectStoreTest, DistributedObject_Double_001, TestSize.Level1)
438 {
439 std::string bundleName = "default";
440 std::string sessionId = "123456";
441 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
442 ASSERT_NE(nullptr, objectStore);
443 DistributedObject *object = objectStore->CreateObject(sessionId);
444 ASSERT_NE(nullptr, object);
445
446 uint32_t ret = object->PutDouble("salary", SALARY);
447 EXPECT_EQ(ret, 0);
448
449 double value = 0.0;
450 object->GetDouble("salary", value);
451 EXPECT_EQ(ret, 0);
452 EXPECT_EQ(value, SALARY);
453
454 ret = objectStore->DeleteObject(sessionId);
455 EXPECT_EQ(ret, 0);
456 }
457
458 /**
459 * @tc.name: DistributedObject_GetDouble_001
460 * @tc.desc: test DistributedObjectStore GetDouble.
461 * @tc.type: FUNC
462 */
463 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetDouble_001, TestSize.Level1)
464 {
465 std::string bundleName = "default";
466 std::string sessionId = "123456";
467 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
468 ASSERT_NE(nullptr, objectStore);
469 DistributedObject *object = objectStore->CreateObject(sessionId);
470 ASSERT_NE(nullptr, object);
471
472 double value = 0.0;
473 uint32_t ret = object->GetDouble("salary", value);
474 EXPECT_EQ(ret, DistributedDB::DBStatus::NOT_FOUND);
475 EXPECT_EQ(value, 0.0);
476
477 ret = objectStore->DeleteObject(sessionId);
478 EXPECT_EQ(ret, 0);
479 }
480
481 /**
482 * @tc.name: DistributedObject_Boolean_001
483 * @tc.desc: test DistributedObjectStore PutBoolean.
484 * @tc.type: FUNC
485 */
486 HWTEST_F(NativeObjectStoreTest, DistributedObject_Boolean_001, TestSize.Level1)
487 {
488 std::string bundleName = "default";
489 std::string sessionId = "123456";
490 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
491 ASSERT_NE(nullptr, objectStore);
492 DistributedObject *object = objectStore->CreateObject(sessionId);
493 ASSERT_NE(nullptr, object);
494
495 uint32_t ret = object->PutBoolean("isTrue", true);
496 EXPECT_EQ(SUCCESS, ret);
497
498 bool value = false;
499 ret = object->GetBoolean("isTrue", value);
500 EXPECT_EQ(SUCCESS, ret);
501 EXPECT_EQ(true, value);
502
503 ret = objectStore->DeleteObject(sessionId);
504 EXPECT_EQ(SUCCESS, ret);
505 }
506
507 /**
508 * @tc.name: DistributedObject_GetBoolean_001
509 * @tc.desc: test DistributedObjectStore GetBoolean.
510 * @tc.type: FUNC
511 */
512 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetBoolean_001, TestSize.Level1)
513 {
514 std::string bundleName = "default";
515 std::string sessionId = "123456";
516 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
517 ASSERT_NE(nullptr, objectStore);
518 DistributedObject *object = objectStore->CreateObject(sessionId);
519 ASSERT_NE(nullptr, object);
520
521 bool value = false;
522 uint32_t ret = object->GetBoolean("isTrue", value);
523 EXPECT_EQ(DistributedDB::DBStatus::NOT_FOUND, ret);
524 EXPECT_EQ(false, value);
525
526 ret = objectStore->DeleteObject(sessionId);
527 EXPECT_EQ(SUCCESS, ret);
528 }
529
530 /**
531 * @tc.name: DistributedObject_String_001
532 * @tc.desc: test DistributedObjectStore String.
533 * @tc.type: FUNC
534 */
535 HWTEST_F(NativeObjectStoreTest, DistributedObject_String_001, TestSize.Level1)
536 {
537 std::string bundleName = "default";
538 std::string sessionId = "123456";
539 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
540 ASSERT_NE(nullptr, objectStore);
541 DistributedObject *object = objectStore->CreateObject(sessionId);
542 ASSERT_NE(nullptr, object);
543
544 uint32_t ret = object->PutString("name", "zhangsan");
545 EXPECT_EQ(SUCCESS, ret);
546
547 std::string value = "";
548 ret = object->GetString("name", value);
549 EXPECT_EQ(SUCCESS, ret);
550 EXPECT_EQ(value, "zhangsan");
551
552 ret = objectStore->DeleteObject(sessionId);
553 EXPECT_EQ(SUCCESS, ret);
554 }
555
556 /**
557 * @tc.name: DistributedObject_GetString_001
558 * @tc.desc: test DistributedObjectStore GetString.
559 * @tc.type: FUNC
560 */
561 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetString_001, TestSize.Level1)
562 {
563 std::string bundleName = "default";
564 std::string sessionId = "123456";
565 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
566 ASSERT_NE(nullptr, objectStore);
567 DistributedObject *object = objectStore->CreateObject(sessionId);
568 ASSERT_NE(nullptr, object);
569
570 std::string value = "";
571 uint32_t ret = object->GetString("name", value);
572 EXPECT_EQ(DistributedDB::DBStatus::NOT_FOUND, ret);
573 EXPECT_EQ(value, "");
574
575 ret = objectStore->DeleteObject(sessionId);
576 EXPECT_EQ(SUCCESS, ret);
577 }
578
579 /**
580 * @tc.name: DistributedObject_GetSessionId_001
581 * @tc.desc: test DistributedObjectStore GetSessionId.
582 * @tc.type: FUNC
583 */
584 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetSessionId_001, TestSize.Level1)
585 {
586 std::string bundleName = "default";
587 std::string sessionId = "123456";
588 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
589 ASSERT_NE(nullptr, objectStore);
590 DistributedObject *object = objectStore->CreateObject(sessionId);
591 ASSERT_NE(nullptr, object);
592 std::string getSessionId = object->GetSessionId();
593 EXPECT_EQ(sessionId, getSessionId);
594 uint32_t ret = objectStore->DeleteObject(sessionId);
595 EXPECT_EQ(SUCCESS, ret);
596 }
597
598 /**
599 * @tc.name: DistributedObject_PutComplex_001
600 * @tc.desc: test DistributedObjectStore PutComplex.
601 * @tc.type: FUNC
602 */
603 HWTEST_F(NativeObjectStoreTest, DistributedObject_PutComplex_001, TestSize.Level1)
604 {
605 std::string bundleName = "default";
606 std::string sessionId = "123456";
607 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
608 ASSERT_NE(nullptr, objectStore);
609 DistributedObject *object = objectStore->CreateObject(sessionId);
610 ASSERT_NE(nullptr, object);
611
612 std::vector<uint8_t> value = {'z', 'h'};
613 uint32_t ret = object->PutComplex("name", value);
614 EXPECT_EQ(SUCCESS, ret);
615 ret = objectStore->DeleteObject(sessionId);
616 EXPECT_EQ(SUCCESS, ret);
617 }
618
619 /**
620 * @tc.name: DistributedObject_GetComplex_001
621 * @tc.desc: test DistributedObjectStore GetComplex.
622 * @tc.type: FUNC
623 */
624 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetComplex_001, TestSize.Level1)
625 {
626 std::string bundleName = "default";
627 std::string sessionId = "123456";
628 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
629 ASSERT_NE(nullptr, objectStore);
630 DistributedObject *object = objectStore->CreateObject(sessionId);
631 ASSERT_NE(nullptr, object);
632
633 std::vector<uint8_t> value = {'z', 'h'};
634 uint32_t ret = object->PutComplex("name", value);
635 EXPECT_EQ(SUCCESS, ret);
636 ret = object->GetComplex("name", value);
637 EXPECT_EQ(SUCCESS, ret);
638 ret = objectStore->DeleteObject(sessionId);
639 EXPECT_EQ(SUCCESS, ret);
640 }
641
642 /**
643 * @tc.name: DistributedObject_GetComplex_002
644 * @tc.desc: test DistributedObjectStore GetComplex.
645 * @tc.type: FUNC
646 */
647 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetComplex_002, TestSize.Level1)
648 {
649 std::string bundleName = "default";
650 std::string sessionId = "123456";
651 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
652 ASSERT_NE(nullptr, objectStore);
653 DistributedObject *object = objectStore->CreateObject(sessionId);
654 ASSERT_NE(nullptr, object);
655
656 std::vector<uint8_t> value = {'z', 'h'};
657 uint32_t ret = object->GetComplex("name", value);
658 EXPECT_EQ(DistributedDB::DBStatus::NOT_FOUND, ret);
659 ret = objectStore->DeleteObject(sessionId);
660 EXPECT_EQ(SUCCESS, ret);
661 }
662
663 /**
664 * @tc.name: DistributedObject_SetAsset_001
665 * @tc.desc: test DistributedObjectStore SetAsset.
666 * @tc.type: FUNC
667 */
668 HWTEST_F(NativeObjectStoreTest, DistributedObject_SetAsset_001, TestSize.Level1)
669 {
670 std::string bundleName = "default";
671 std::string sessionId = "123456";
672 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
673 ASSERT_NE(nullptr, objectStore);
674 DistributedObject *object = objectStore->CreateObject(sessionId);
675 ASSERT_NE(nullptr, object);
676
677 uint32_t ret = object->PutString("attachment.name", "1.txt");
678 EXPECT_EQ(SUCCESS, ret);
679
680 std::string value;
681 ret = object->GetString("attachment.name", value);
682 EXPECT_EQ(SUCCESS, ret);
683 EXPECT_EQ(value, "1.txt");
684
685 std::string deviceId;
686 ret = object->GetString("__deviceId", deviceId);
687 EXPECT_EQ(SUCCESS, ret);
688 EXPECT_FALSE(deviceId.empty());
689
690 ret = objectStore->DeleteObject(sessionId);
691 EXPECT_EQ(SUCCESS, ret);
692 }
693
694 /**
695 * @tc.name: DistributedObject_TestSetSessionId_001
696 * @tc.desc: test DistributedObjectStore TestSetSessionId.
697 * @tc.type: FUNC
698 */
699 HWTEST_F(NativeObjectStoreTest, DistributedObject_TestSetSessionId_001, TestSize.Level1)
700 {
__anonba25df920202(std::string bundleName, std::string sessionId) 701 auto testSetSessionId = [] (std::string bundleName, std::string sessionId) {
702 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
703 ASSERT_NE(nullptr, objectStore);
704 DistributedObject *object = objectStore->CreateObject(sessionId);
705 ASSERT_NE(nullptr, object);
706
707 uint32_t ret = objectStore->DeleteObject(sessionId);
708 EXPECT_EQ(SUCCESS, ret);
709 };
710 std::thread t1(testSetSessionId, "default1", "session1");
711 std::thread t2(testSetSessionId, "default2", "session2");
712 std::thread t3(testSetSessionId, "default3", "session3");
713 t1.join();
714 t2.join();
715 t3.join();
716 }
717
718 /**
719 * @tc.name: DistributedObject_GetType_001
720 * @tc.desc: test DistributedObject GetType.
721 * @tc.type: FUNC
722 */
723 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetType_001, TestSize.Level1)
724 {
725 std::string bundleName = "default";
726 std::string sessionId = "123456";
727 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
728 ASSERT_NE(nullptr, objectStore);
729 DistributedObject *object = objectStore->CreateObject(sessionId);
730 ASSERT_NE(nullptr, object);
731
732 uint32_t ret = object->PutString("name", "zhangsan");
733 EXPECT_EQ(SUCCESS, ret);
734 Type type;
735 ret = object->GetType("name", type);
736 EXPECT_EQ(SUCCESS, ret);
737 EXPECT_EQ(TYPE_STRING, type);
738
739 ret = object->PutDouble("salary", SALARY);
740 EXPECT_EQ(SUCCESS, ret);
741 ret = object->GetType("salary", type);
742 EXPECT_EQ(SUCCESS, ret);
743 EXPECT_EQ(TYPE_DOUBLE, type);
744
745 ret = object->PutBoolean("isTrue", true);
746 EXPECT_EQ(SUCCESS, ret);
747 ret = object->GetType("isTrue", type);
748 EXPECT_EQ(SUCCESS, ret);
749 EXPECT_EQ(TYPE_BOOLEAN, type);
750
751 ret = objectStore->DeleteObject(sessionId);
752 EXPECT_EQ(SUCCESS, ret);
753 }
754
755 /**
756 * @tc.name: DistributedObject_GetType_002
757 * @tc.desc: test DistributedObject GetType.
758 * @tc.type: FUNC
759 */
760 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetType_002, TestSize.Level1)
761 {
762 std::string bundleName = "default";
763 std::string sessionId = "123456";
764 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
765 ASSERT_NE(nullptr, objectStore);
766 DistributedObject *object = objectStore->CreateObject(sessionId);
767 ASSERT_NE(nullptr, object);
768
769 Type type;
770 uint32_t ret = object->GetType("name", type);
771 EXPECT_EQ(DistributedDB::DBStatus::NOT_FOUND, ret);
772 EXPECT_EQ(TYPE_STRING, type);
773
774 ret = objectStore->DeleteObject(sessionId);
775 EXPECT_EQ(SUCCESS, ret);
776 }
777
778 /**
779 * @tc.name: DistributedObject_Save_RevokeSave_001
780 * @tc.desc: test DistributedObjectStore Save.
781 * @tc.type: FUNC
782 */
783 HWTEST_F(NativeObjectStoreTest, DistributedObject_Save_RevokeSave_001, TestSize.Level1)
784 {
785 std::string bundleName = "default";
786 std::string sessionId = "123456";
787 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
788 ASSERT_NE(nullptr, objectStore);
789 DistributedObject *object = objectStore->CreateObject(sessionId);
790 ASSERT_NE(nullptr, object);
791
792
793 uint32_t ret = object->PutString("name", "zhangsan");
794 EXPECT_EQ(SUCCESS, ret);
795 ret = object->PutDouble("salary", SALARY);
796 EXPECT_EQ(SUCCESS, ret);
797 ret = object->PutBoolean("isTrue", true);
798 EXPECT_EQ(SUCCESS, ret);
799
800 ret = object->Save("local");
801 EXPECT_EQ(SUCCESS, ret);
802 ret = object->RevokeSave();
803 EXPECT_EQ(SUCCESS, ret);
804
805 ret = objectStore->DeleteObject(sessionId);
806 EXPECT_EQ(SUCCESS, ret);
807 }
808
809 /**
810 * @tc.name: DistributedObject_Save_RevokeSave_002
811 * @tc.desc: test DistributedObjectStore Save.
812 * @tc.type: FUNC
813 */
814 HWTEST_F(NativeObjectStoreTest, DistributedObject_Save_RevokeSave_002, TestSize.Level1)
815 {
__anonba25df920302(std::string bundleName, std::string sessionId) 816 auto testSaveAndRevokeSave = [](std::string bundleName, std::string sessionId) {
817 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
818 ASSERT_NE(nullptr, objectStore);
819 DistributedObject *object = objectStore->CreateObject(sessionId);
820 ASSERT_NE(nullptr, object);
821
822 uint32_t ret = object->PutString("name", "zhangsan");
823 EXPECT_EQ(SUCCESS, ret);
824 ret = object->PutDouble("salary", SALARY);
825 EXPECT_EQ(SUCCESS, ret);
826 ret = object->PutBoolean("isTrue", true);
827 EXPECT_EQ(SUCCESS, ret);
828
829 ret = object->Save("local");
830 EXPECT_EQ(SUCCESS, ret);
831 ret = object->RevokeSave();
832 EXPECT_EQ(SUCCESS, ret);
833
834 ret = objectStore->DeleteObject(sessionId);
835 EXPECT_EQ(SUCCESS, ret);
836 };
837 std::thread t1(testSaveAndRevokeSave, "default1", "session1");
838 std::thread t2(testSaveAndRevokeSave, "default2", "session2");
839 std::thread t3(testSaveAndRevokeSave, "default3", "session3");
840 t1.join();
841 t2.join();
842 t3.join();
843 }
844
845 /**
846 * @tc.name: DistributedObject_Save_RevokeSave_003
847 * @tc.desc: test DistributedObjectStore Save.
848 * @tc.type: FUNC
849 */
850 HWTEST_F(NativeObjectStoreTest, DistributedObject_Save_RevokeSave_003, TestSize.Level1)
851 {
852 std::string bundleName = "default";
853 std::string sessionId = "123456";
854 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
855 ASSERT_NE(nullptr, objectStore);
856 DistributedObject *object = objectStore->CreateObject(sessionId);
857 ASSERT_NE(nullptr, object);
858
859 uint32_t ret = object->RevokeSave();
860 EXPECT_EQ(SUCCESS, ret);
861
862 ret = objectStore->DeleteObject(sessionId);
863 EXPECT_EQ(SUCCESS, ret);
864 }
865
866 /**
867 * @tc.name: DistributedObject_Open_001
868 * @tc.desc: test ObjectStorageEngine Open, calling Open repeatedly.
869 * @tc.type: FUNC
870 */
871 HWTEST_F(NativeObjectStoreTest, DistributedObject_Open_001, TestSize.Level1)
872 {
873 std::string bundleName = "default";
874 std::string sessionId = "123456";
875 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
876 uint32_t ret = objectStorageEngine->Open(bundleName);
877 EXPECT_EQ(SUCCESS, ret);
878 ret = objectStorageEngine->Open(bundleName);
879 EXPECT_EQ(SUCCESS, ret);
880 ret = objectStorageEngine->CreateTable(sessionId);
881 EXPECT_EQ(SUCCESS, ret);
882 ret = objectStorageEngine->DeleteTable(sessionId);
883 EXPECT_EQ(SUCCESS, ret);
884 delete objectStorageEngine;
885 }
886
887 /**
888 * @tc.name: DistributedObject_CreateTable_001
889 * @tc.desc: test ObjectStorageEngine CreateTable.
890 * @tc.type: FUNC
891 */
892 HWTEST_F(NativeObjectStoreTest, DistributedObject_CreateTable_001, TestSize.Level1)
893 {
894 std::string bundleName = "default";
895 std::string sessionId = "123456";
896 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
897 uint32_t ret = objectStorageEngine->Open(bundleName);
898 EXPECT_EQ(SUCCESS, ret);
899 ret = objectStorageEngine->CreateTable(sessionId);
900 EXPECT_EQ(SUCCESS, ret);
901 ret = objectStorageEngine->DeleteTable(sessionId);
902 EXPECT_EQ(SUCCESS, ret);
903 delete objectStorageEngine;
904 }
905
906 /**
907 * @tc.name: DistributedObject_CreateTable_002
908 * @tc.desc: test ObjectStorageEngine CreateTable, calling CreateTable() repeatedly.
909 * @tc.type: FUNC
910 */
911 HWTEST_F(NativeObjectStoreTest, DistributedObject_CreateTable_002, TestSize.Level1)
912 {
913 std::string bundleName = "default";
914 std::string sessionId = "123456";
915 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
916 uint32_t ret = objectStorageEngine->Open(bundleName);
917 EXPECT_EQ(SUCCESS, ret);
918 ret = objectStorageEngine->CreateTable(sessionId);
919 EXPECT_EQ(SUCCESS, ret);
920 ret = objectStorageEngine->CreateTable(sessionId);
921 EXPECT_NE(SUCCESS, ret);
922 ret = objectStorageEngine->DeleteTable(sessionId);
923 EXPECT_EQ(SUCCESS, ret);
924 delete objectStorageEngine;
925 }
926
927 /**
928 * @tc.name: DistributedObject_CreateTable_003
929 * @tc.desc: test ObjectStorageEngine CreateTable, calling CreateTable after calling Close().
930 * @tc.type: FUNC
931 */
932 HWTEST_F(NativeObjectStoreTest, DistributedObject_CreateTable_003, TestSize.Level1)
933 {
934 std::string bundleName = "default";
935 std::string sessionId = "123456";
936 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
937 uint32_t ret = objectStorageEngine->Open(bundleName);
938 EXPECT_EQ(SUCCESS, ret);
939 ret = objectStorageEngine->Close();
940 EXPECT_EQ(SUCCESS, ret);
941 ret = objectStorageEngine->CreateTable(sessionId);
942 EXPECT_NE(SUCCESS, ret);
943 delete objectStorageEngine;
944 }
945
946 /**
947 * @tc.name: DistributedObject_GetTable_001
948 * @tc.desc: test ObjectStorageEngine GetTable, not calling Open().
949 * @tc.type: FUNC
950 */
951 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_001, TestSize.Level1)
952 {
953 std::string sessionId = "session01";
954 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
955 std::map<std::string, Value> result = {};
956 uint32_t ret = objectStorageEngine->GetTable(sessionId, result);
957 EXPECT_NE(SUCCESS, ret);
958 delete objectStorageEngine;
959 }
960
961 /**
962 * @tc.name: DistributedObject_GetTable_002
963 * @tc.desc: test ObjectStorageEngine GetTable, calling Open(),but not calling CreateTable().
964 * @tc.type: FUNC
965 */
966 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_002, TestSize.Level1)
967 {
968 std::string bundleName = "default02";
969 std::string sessionId = "session02";
970 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
971 uint32_t ret = objectStorageEngine->Open(bundleName);
972 EXPECT_EQ(SUCCESS, ret);
973 std::map<std::string, Value> result = {};
974 ret = objectStorageEngine->GetTable(sessionId, result);
975 EXPECT_NE(SUCCESS, ret);
976 delete objectStorageEngine;
977 }
978
979 /**
980 * @tc.name: DistributedObject_GetTable_003
981 * @tc.desc: test ObjectStorageEngine GetTable, calling Open() and CreateTable(), but not calling UpdateItem().
982 * @tc.type: FUNC
983 */
984 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_003, TestSize.Level1)
985 {
986 std::string bundleName = "default03";
987 std::string sessionId = "session03";
988 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
989 uint32_t ret = objectStorageEngine->Open(bundleName);
990 EXPECT_EQ(SUCCESS, ret);
991 ret = objectStorageEngine->CreateTable(sessionId);
992 EXPECT_EQ(SUCCESS, ret);
993 std::map<std::string, Value> result = {};
994 ret = objectStorageEngine->GetTable(sessionId, result);
995 EXPECT_NE(SUCCESS, ret);
996 ret = objectStorageEngine->DeleteTable(sessionId);
997 EXPECT_EQ(SUCCESS, ret);
998 delete objectStorageEngine;
999 }
1000
1001 /**
1002 * @tc.name: DistributedObject_GetTable_004
1003 * @tc.desc: test ObjectStorageEngine GetTable.
1004 * @tc.type: FUNC
1005 */
1006 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_004, TestSize.Level1)
1007 {
1008 std::string bundleName = "default04";
1009 std::string sessionId = "session04";
1010 std::vector<uint8_t> value = { 1, 8 };
1011 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
1012 uint32_t ret = objectStorageEngine->Open(bundleName);
1013 EXPECT_EQ(SUCCESS, ret);
1014 ret = objectStorageEngine->CreateTable(sessionId);
1015 EXPECT_EQ(SUCCESS, ret);
1016 ret = objectStorageEngine->UpdateItem(sessionId, "age", value);
1017 EXPECT_EQ(SUCCESS, ret);
1018 std::map<std::string, Value> result = {};
1019 ret = objectStorageEngine->GetTable(sessionId, result);
1020 EXPECT_EQ(SUCCESS, ret);
1021 ret = objectStorageEngine->DeleteTable(sessionId);
1022 EXPECT_EQ(SUCCESS, ret);
1023 delete objectStorageEngine;
1024 }
1025
1026 /**
1027 * @tc.name: FlatObjectStore_UpdateItems_001
1028 * @tc.desc: test ObjectStorageEngine UpdateItems. input data is empty.
1029 * @tc.type: FUNC
1030 */
1031 HWTEST_F(NativeObjectStoreTest, DistributedObject_UpdateItems_001, TestSize.Level1)
1032 {
1033 std::string bundleName = "default06";
1034 std::string sessionId = "session06";
1035 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
1036 uint32_t ret = objectStorageEngine->Open(bundleName);
1037 EXPECT_EQ(SUCCESS, ret);
1038 ret = objectStorageEngine->CreateTable(sessionId);
1039 EXPECT_EQ(SUCCESS, ret);
1040 std::map<std::string, std::vector<uint8_t>> data = {};
1041 ret = objectStorageEngine->UpdateItems(sessionId, data);
1042 EXPECT_NE(SUCCESS, ret);
1043 delete objectStorageEngine;
1044 }
1045
1046 /**
1047 * @tc.name: FlatObjectStore_UpdateItems_002
1048 * @tc.desc: test FlatObjectStore UpdateItems.
1049 * @tc.type: FUNC
1050 */
1051 HWTEST_F(NativeObjectStoreTest, FlatObjectStore_UpdateItems_002, TestSize.Level1)
1052 {
1053 std::string bundleName = "default07";
1054 std::string sessionId = "session07";
1055 std::vector<uint8_t> value = { 1, 8 };
1056 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
1057 uint32_t ret = objectStorageEngine->Open(bundleName);
1058 EXPECT_EQ(SUCCESS, ret);
1059 ret = objectStorageEngine->CreateTable(sessionId);
1060 EXPECT_EQ(SUCCESS, ret);
1061 std::map<std::string, std::vector<uint8_t>> data = { { "age", value } };
1062 ret = objectStorageEngine->UpdateItems(sessionId, data);
1063 EXPECT_EQ(SUCCESS, ret);
1064 delete objectStorageEngine;
1065 }
1066
1067 /**
1068 * @tc.name: DistributedObject_OpenAndClose_001
1069 * @tc.desc: test FlatObjectStorageEngine OpenAndClose and Close when FlatObjectStorageEngine is not open.
1070 * @tc.type: FUNC
1071 */
1072 HWTEST_F(NativeObjectStoreTest, DistributedObject_OpenAndClose_001, TestSize.Level1)
1073 {
1074 std::string bundleName = "default07";
1075 FlatObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
1076 uint32_t ret = objectStorageEngine->Open(bundleName);
1077 EXPECT_EQ(SUCCESS, ret);
1078 ret = objectStorageEngine->Close();
1079 EXPECT_EQ(SUCCESS, ret);
1080 objectStorageEngine->isOpened_ = false;
1081 ret = objectStorageEngine->Close();
1082 EXPECT_EQ(SUCCESS, ret);
1083 delete objectStorageEngine;
1084 }
1085
1086 /**
1087 * @tc.name: DistributedObject_NotifyChange_001
1088 * @tc.desc: test FlatObjectStorageEngine NotifyChange.
1089 * @tc.type: FUNC
1090 */
1091 HWTEST_F(NativeObjectStoreTest, DistributedObject_NotifyChange_001, TestSize.Level1)
1092 {
1093 std::string bundleName = "default07";
1094 std::string sessionId = "session07";
1095 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1096 uint32_t ret = storageEngine->Open(bundleName);
1097 ret = storageEngine->CreateTable(sessionId);
1098 EXPECT_EQ(SUCCESS, ret);
1099 std::map<std::string, std::vector<uint8_t>> filteredData;
1100 storageEngine->NotifyChange(sessionId, filteredData);
1101 ret = storageEngine->Close();
1102 EXPECT_EQ(SUCCESS, ret);
1103 }
1104
1105 /**
1106 * @tc.name: FlatObjectStore_CheckRetrieveCache_001
1107 * @tc.desc: test FlatObjectStore CheckRetrieveCache.
1108 * @tc.type: FUNC
1109 */
1110 HWTEST_F(NativeObjectStoreTest, FlatObjectStore_CheckRetrieveCache_001, TestSize.Level1)
1111 {
1112 std::string sessionId = "session05";
1113 std::string bundleName = "default07";
1114 std::shared_ptr<FlatObjectStore> flatObjectStore = std::make_shared<FlatObjectStore>(bundleName);
1115 uint32_t ret = flatObjectStore->CreateObject(sessionId);
1116 EXPECT_EQ(SUCCESS, ret);
1117 flatObjectStore->CheckRetrieveCache(sessionId);
1118 ret = flatObjectStore->Delete(sessionId);
1119 EXPECT_EQ(SUCCESS, ret);
1120 }
1121
1122 /**
1123 * @tc.name: FlatObjectStore_Delete_001
1124 * @tc.desc: test FlatObjectStore Delete. wrong sessionId
1125 * @tc.type: FUNC
1126 */
1127 HWTEST_F(NativeObjectStoreTest, FlatObjectStore_Delete_001, TestSize.Level1)
1128 {
1129 std::string sessionId = "session001";
1130 std::string bundleName = "default001";
1131 std::shared_ptr<FlatObjectStore> flatObjectStore = std::make_shared<FlatObjectStore>(bundleName);
1132 uint32_t ret = flatObjectStore->CreateObject(sessionId);
1133 EXPECT_EQ(SUCCESS, ret);
1134 sessionId = "session002";
1135 ret = flatObjectStore->Delete(sessionId);
1136 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1137 }
1138
1139 /**
1140 * @tc.name: FlatObjectStore_Delete_002
1141 * @tc.desc: test FlatObjectStore Delete. wrong sessionId
1142 * @tc.type: FUNC
1143 */
1144 HWTEST_F(NativeObjectStoreTest, FlatObjectStore_Delete_002, TestSize.Level1)
1145 {
1146 std::string sessionId = "session001";
1147 std::string bundleName = "";
1148 std::shared_ptr<FlatObjectStore> flatObjectStore = std::make_shared<FlatObjectStore>(bundleName);
1149 uint32_t ret = flatObjectStore->CreateObject(sessionId);
1150 EXPECT_EQ(ERR_DB_GETKV_FAIL, ret);
1151 }
1152
1153 /**
1154 * @tc.name: FlatObjectStore_Watch_001
1155 * @tc.desc: test FlatObjectStore Watch. wrong sessionId
1156 * @tc.type: FUNC
1157 */
1158 HWTEST_F(NativeObjectStoreTest, FlatObjectStore_Watch_001, TestSize.Level1)
1159 {
1160 std::string sessionId = "session002";
1161 std::string bundleName = "default002";
1162 std::shared_ptr<FlatObjectStore> flatObjectStore = std::make_shared<FlatObjectStore>(bundleName);
1163 uint32_t ret = flatObjectStore->CreateObject(sessionId);
1164 EXPECT_EQ(SUCCESS, ret);
1165 sessionId = "session003";
1166 std::shared_ptr<MockFlatObjectWatcher> watcher = std::make_shared<MockFlatObjectWatcher>(sessionId);
1167 ret = flatObjectStore->Watch(sessionId, watcher);
1168 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1169 }
1170
1171 /**
1172 * @tc.name: FlatObjectStore_UnWatch_001
1173 * @tc.desc: test FlatObjectStore UnWatch. wrong sessionId
1174 * @tc.type: FUNC
1175 */
1176 HWTEST_F(NativeObjectStoreTest, FlatObjectStore_UnWatch_001, TestSize.Level1)
1177 {
1178 std::string sessionId = "session003";
1179 std::string bundleName = "default003";
1180 std::shared_ptr<FlatObjectStore> flatObjectStore = std::make_shared<FlatObjectStore>(bundleName);
1181 uint32_t ret = flatObjectStore->CreateObject(sessionId);
1182 EXPECT_EQ(SUCCESS, ret);
1183 sessionId = "session004";
1184 std::shared_ptr<MockFlatObjectWatcher> watcher = std::make_shared<MockFlatObjectWatcher>(sessionId);
1185 ret = flatObjectStore->UnWatch(sessionId);
1186 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1187 }
1188
1189 /**
1190 * @tc.name: FlatObjectStore_Save_001
1191 * @tc.desc: test FlatObjectStore Save. wrong sessionId
1192 * @tc.type: FUNC
1193 */
1194 HWTEST_F(NativeObjectStoreTest, FlatObjectStore_Save_001, TestSize.Level1)
1195 {
1196 std::string sessionId = "session004";
1197 std::string bundleName = "default004";
1198 std::string deviceId = "deviceId004";
1199 std::shared_ptr<FlatObjectStore> flatObjectStore = std::make_shared<FlatObjectStore>(bundleName);
1200 uint32_t ret = flatObjectStore->CreateObject(sessionId);
1201 EXPECT_EQ(SUCCESS, ret);
1202 sessionId = "session005";
1203 std::shared_ptr<MockFlatObjectWatcher> watcher = std::make_shared<MockFlatObjectWatcher>(sessionId);
1204 ret = flatObjectStore->Save(sessionId, deviceId);
1205 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1206 }
1207
1208 /**
1209 * @tc.name: FlatObjectStore_OnComplete_001
1210 * @tc.desc: test FlatObjectStore OnComplete.
1211 * @tc.type: FUNC
1212 */
1213 HWTEST_F(NativeObjectStoreTest, FlatObjectStore_OnComplete_001, TestSize.Level1)
1214 {
1215 std::string bundleName = "default005";
1216 std::string sessionId = "session005";
1217 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1218 uint32_t ret = storageEngine->Open(bundleName);
1219 EXPECT_EQ(SUCCESS, ret);
1220 ret = storageEngine->CreateTable(sessionId);
1221 std::shared_ptr<StatusNotifierImpl> statusWatcher = std::make_shared<StatusNotifierImpl>();
1222 DistributedDB::DBStatus status = DistributedDB::DBStatus::OK;
1223 std::map<std::string, DistributedDB::DBStatus> devices = { { sessionId, status } };
1224 storageEngine->OnComplete(sessionId, devices, statusWatcher);
1225 ret = storageEngine->DeleteTable(sessionId);
1226 EXPECT_EQ(SUCCESS, ret);
1227 }
1228
1229 /**
1230 * @tc.name: CacheManager_Save_001
1231 * @tc.desc: test CacheManager Save.
1232 * @tc.type: FUNC
1233 */
1234 HWTEST_F(NativeObjectStoreTest, CacheManager_Save_001, TestSize.Level1)
1235 {
1236 std::string bundleName = "";
1237 std::string sessionId = "";
1238 std::string deviceId = "";
1239 std::map<std::string, std::vector<uint8_t>> objectData;
1240 CacheManager cacheManager;
1241 auto ret = cacheManager.Save(bundleName, sessionId, deviceId, objectData);
1242 EXPECT_EQ(OHOS::DistributedKv::Status::INVALID_ARGUMENT, ret);
1243 }
1244
1245 /**
1246 * @tc.name: CacheManager_RevokeSave_001
1247 * @tc.desc: test CacheManager RevokeSave.
1248 * @tc.type: FUNC
1249 */
1250 HWTEST_F(NativeObjectStoreTest, CacheManager_RevokeSave_001, TestSize.Level1)
1251 {
1252 std::string bundleName = "";
1253 std::string sessionId = "";
1254 CacheManager cacheManager;
1255 auto ret = cacheManager.RevokeSave(bundleName, sessionId);
1256 EXPECT_EQ(SUCCESS, ret);
1257 }
1258
1259 /**
1260 * @tc.name: CacheManager_ResumeObject_001
1261 * @tc.desc: test CacheManager ResumeObject.
1262 * @tc.type: FUNC
1263 */
1264 HWTEST_F(NativeObjectStoreTest, CacheManager_ResumeObject_001, TestSize.Level1)
1265 {
1266 std::string bundleName = "";
1267 std::string sessionId = "";
1268 CacheManager cacheManager;
1269 std::function<void(const std::map<std::string, std::vector<uint8_t>> &data, bool allReady)> callback =
__anonba25df920402(const std::map<std::string, std::vector<uint8_t>> &data, bool allReady) 1270 [](const std::map<std::string, std::vector<uint8_t>> &data, bool allReady) {};
1271 auto ret = cacheManager.ResumeObject(bundleName, sessionId, callback);
1272 EXPECT_EQ(OHOS::DistributedKv::Status::KEY_NOT_FOUND, ret);
1273 }
1274
1275 /**
1276 * @tc.name: CacheManager_SubscribeDataChange_001
1277 * @tc.desc: test CacheManager SubscribeDataChange.
1278 * @tc.type: FUNC
1279 */
1280 HWTEST_F(NativeObjectStoreTest, CacheManager_SubscribeDataChange_001, TestSize.Level1)
1281 {
1282 std::string bundleName = "";
1283 std::string sessionId = "";
1284 CacheManager cacheManager;
1285 std::function<void(const std::map<std::string, std::vector<uint8_t>> &data, bool allReady)> callback =
__anonba25df920502(const std::map<std::string, std::vector<uint8_t>> &data, bool allReady) 1286 [](const std::map<std::string, std::vector<uint8_t>> &data, bool allReady) {};
1287 auto ret = cacheManager.SubscribeDataChange(bundleName, sessionId, callback);
1288 EXPECT_EQ(SUCCESS, ret);
1289 }
1290
1291 /**
1292 * @tc.name: CacheManager_UnregisterDataChange_001
1293 * @tc.desc: test CacheManager UnregisterDataChange.
1294 * @tc.type: FUNC
1295 */
1296 HWTEST_F(NativeObjectStoreTest, CacheManager_UnregisterDataChange_001, TestSize.Level1)
1297 {
1298 std::string bundleName = "";
1299 std::string sessionId = "";
1300 CacheManager cacheManager;
1301 auto ret = cacheManager.UnregisterDataChange(bundleName, sessionId);
1302 EXPECT_EQ(SUCCESS, ret);
1303 }
1304
1305 /**
1306 * @tc.name: CacheManager_IsContinue_001
1307 * @tc.desc: test CacheManager IsContinue.
1308 * @tc.type: FUNC
1309 */
1310 HWTEST_F(NativeObjectStoreTest, CacheManager_IsContinue_001, TestSize.Level1)
1311 {
1312 auto cacheManager = std::make_shared<CacheManager>();
1313 auto result = cacheManager->IsContinue();
1314 EXPECT_FALSE(result);
1315 }
1316
1317 /**
1318 * @tc.name: DistributedObject_NotifyCachedStatus_001
1319 * @tc.desc: test DistributedObjectStore NotifyCachedStatus.
1320 * @tc.type: FUNC
1321 */
1322 HWTEST_F(NativeObjectStoreTest, DistributedObject_NotifyCachedStatus_001, TestSize.Level1)
1323 {
1324 std::string bundleName = "default";
1325 std::string sessionId = "123456";
1326 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
1327 ASSERT_NE(nullptr, objectStore);
1328 uint32_t status = 0;
1329 DistributedObject *object = objectStore->CreateObject(sessionId, status);
1330 ASSERT_NE(nullptr, object);
1331 EXPECT_EQ(SUCCESS, status);
1332 objectStore->NotifyCachedStatus(sessionId);
1333 uint32_t ret = objectStore->DeleteObject(sessionId);
1334 EXPECT_EQ(SUCCESS, ret);
1335 }
1336
1337 /**
1338 * @tc.name: DistributedObject_UnWatch_001
1339 * @tc.desc: test DistributedObjectStore UnWatch, DistributedObject is nullptr.
1340 * @tc.type: FUNC
1341 */
1342 HWTEST_F(NativeObjectStoreTest, DistributedObject_UnWatch_001, TestSize.Level1)
1343 {
1344 std::string bundleName = "default";
1345 std::string sessionId = "123456";
1346 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
1347 ASSERT_NE(nullptr, objectStore);
1348 DistributedObject *object = objectStore->CreateObject(sessionId);
1349 ASSERT_NE(nullptr, object);
1350 uint32_t ret = objectStore->UnWatch(nullptr);
1351 EXPECT_EQ(ERR_NULL_OBJECT, ret);
1352 ret = objectStore->DeleteObject(sessionId);
1353 EXPECT_EQ(SUCCESS, ret);
1354 }
1355
1356 /**
1357 * @tc.name: DistributedObject_CreateTable_004
1358 * @tc.desc: test FlatObjectStorageEngine CreateTable, sessionId is empty.
1359 * @tc.type: FUNC
1360 */
1361 HWTEST_F(NativeObjectStoreTest, DistributedObject_CreateTable_004, TestSize.Level1)
1362 {
1363 std::string bundleName = "default";
1364 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1365 storageEngine->Open(bundleName);
1366 uint32_t ret = storageEngine->CreateTable("");
1367 EXPECT_EQ(ERR_DB_GETKV_FAIL, ret);
1368 }
1369
1370 /**
1371 * @tc.name: DistributedObject_GetTable_005
1372 * @tc.desc: test FlatObjectStorageEngine GetTable, storageEngine is not open or sessionId is empty.
1373 * @tc.type: FUNC
1374 */
1375 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_005, TestSize.Level1)
1376 {
1377 std::string bundleName = "default";
1378 std::string sessionId = "123456";
1379 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1380 storageEngine->Open(bundleName);
1381 storageEngine->CreateTable(sessionId);
1382 std::map<std::string, Value> tableResult;
1383 storageEngine->isOpened_ = false;
1384 uint32_t ret = storageEngine->GetTable(sessionId, tableResult);
1385 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
1386 storageEngine->isOpened_ = true;
1387 ret = storageEngine->GetTable("", tableResult);
1388 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1389 storageEngine->DeleteTable(sessionId);
1390 }
1391
1392 /**
1393 * @tc.name: DistributedObject_UpdateItem_003
1394 * @tc.desc: test FlatObjectStorageEngine UpdateItem, storageEngine is not open or error sessionid.
1395 * @tc.type: FUNC
1396 */
1397 HWTEST_F(NativeObjectStoreTest, DistributedObject_UpdateItem_001, TestSize.Level1)
1398 {
1399 std::string bundleName = "default";
1400 std::string sessionId = "123456";
1401 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1402 storageEngine->Open(bundleName);
1403 storageEngine->CreateTable(sessionId);
1404 storageEngine->isOpened_ = false;
1405 std::vector<uint8_t> value = { 1, 8 };
1406 uint32_t ret = storageEngine->UpdateItem(sessionId, "age", value);
1407 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
1408 storageEngine->isOpened_ = true;
1409 ret = storageEngine->UpdateItem("123", "age", value);
1410 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1411 storageEngine->DeleteTable(sessionId);
1412 }
1413
1414 /**
1415 * @tc.name: DistributedObject_UpdateItems_004
1416 * @tc.desc: test FlatObjectStorageEngine UpdateItems, storageEngine is not open or error sessionid.
1417 * @tc.type: FUNC
1418 */
1419 HWTEST_F(NativeObjectStoreTest, DistributedObject_UpdateItems_003, TestSize.Level1)
1420 {
1421 std::string bundleName = "default";
1422 std::string sessionId = "123456";
1423 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1424 storageEngine->Open(bundleName);
1425 storageEngine->CreateTable(sessionId);
1426 storageEngine->isOpened_ = false;
1427 std::vector<uint8_t> value = { 1, 8 };
1428 std::map<std::string, std::vector<uint8_t>> data = { { "age", value } };
1429 uint32_t ret = storageEngine->UpdateItems(sessionId, data);
1430 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
1431
1432 storageEngine->isOpened_ = true;
1433 ret = storageEngine->UpdateItems("123", data);
1434 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1435 storageEngine->DeleteTable(sessionId);
1436 }
1437
1438 /**
1439 * @tc.name: DistributedObject_DeleteTable_001
1440 * @tc.desc: test FlatObjectStorageEngine DeleteTable, storageEngine is not open or error sessionid.
1441 * @tc.type: FUNC
1442 */
1443 HWTEST_F(NativeObjectStoreTest, DistributedObject_DeleteTable_001, TestSize.Level1)
1444 {
1445 std::string bundleName = "default";
1446 std::string sessionId = "123456";
1447 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1448 storageEngine->Open(bundleName);
1449 storageEngine->CreateTable(sessionId);
1450 storageEngine->isOpened_ = false;
1451 uint32_t ret = storageEngine->DeleteTable(sessionId);
1452 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
1453 storageEngine->isOpened_ = true;
1454 ret = storageEngine->DeleteTable("123");
1455 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1456 storageEngine->DeleteTable(sessionId);
1457 }
1458
1459 /**
1460 * @tc.name: DistributedObject_GetItem_002
1461 * @tc.desc: test FlatObjectStorageEngine GetItem, storageEngine is not open or error key.
1462 * @tc.type: FUNC
1463 */
1464 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetItem_002, TestSize.Level1)
1465 {
1466 std::string bundleName = "default";
1467 std::string sessionId = "123456";
1468 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1469 storageEngine->Open(bundleName);
1470 storageEngine->CreateTable(sessionId);
1471 storageEngine->isOpened_ = false;
1472 std::vector<uint8_t> value = { 1, 8 };
1473 uint32_t ret = storageEngine->GetItem(sessionId, "", value);
1474 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
1475 storageEngine->Open(bundleName);
1476 ret = storageEngine->DeleteTable(sessionId);
1477 EXPECT_EQ(SUCCESS, ret);
1478 }
1479
1480 /**
1481 * @tc.name: DistributedObject_GetItem_003
1482 * @tc.desc: test FlatObjectStorageEngine GetItem, error key.
1483 * @tc.type: FUNC
1484 */
1485 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetItem_003, TestSize.Level1)
1486 {
1487 std::string sessionId = "123456";
1488 std::string bundleName = "default";
1489 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1490 std::vector<uint8_t> value = { 1, 8 };
1491 storageEngine->Open(bundleName);
1492 uint32_t ret = storageEngine->GetItem(sessionId, "123", value);
1493 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1494 }
1495
1496 /**
1497 * @tc.name: DistributedObject_RegisterObserver_001
1498 * @tc.desc: test FlatObjectStorageEngine RegisterObserver, storageEngine is not open.
1499 * @tc.type: FUNC
1500 */
1501 HWTEST_F(NativeObjectStoreTest, DistributedObject_RegisterObserver_001, TestSize.Level1)
1502 {
1503 std::string sessionId = "123456";
1504 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1505 storageEngine->isOpened_ = false;
1506 auto tableWatcherPtr = std::make_shared<TableWatcherImpl>(sessionId);
1507 uint32_t ret = storageEngine->RegisterObserver(sessionId, tableWatcherPtr);
1508 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
1509 }
1510
1511 /**
1512 * @tc.name: DistributedObject_RegisterObserver_002
1513 * @tc.desc: test FlatObjectStorageEngine RegisterObserver, empty sessionId.
1514 * @tc.type: FUNC
1515 */
1516 HWTEST_F(NativeObjectStoreTest, DistributedObject_RegisterObserver_002, TestSize.Level1)
1517 {
1518 std::string bundleName = "default";
1519 std::string sessionId = "123456";
1520 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1521 storageEngine->Open(bundleName);
1522 storageEngine->CreateTable(sessionId);
1523 auto tableWatcherPtr = std::make_shared<TableWatcherImpl>(sessionId);
1524 uint32_t ret = storageEngine->RegisterObserver("", tableWatcherPtr);
1525 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1526 ret = storageEngine->DeleteTable(sessionId);
1527 EXPECT_EQ(SUCCESS, ret);
1528 }
1529
1530 /**
1531 * @tc.name: DistributedObject_RegisterObserver_003
1532 * @tc.desc: test FlatObjectStorageEngine RegisterObserver, repeat RegisterObserver.
1533 * @tc.type: FUNC
1534 */
1535 HWTEST_F(NativeObjectStoreTest, DistributedObject_RegisterObserver_003, TestSize.Level1)
1536 {
1537 std::string bundleName = "default";
1538 std::string sessionId = "123456";
1539 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1540 storageEngine->Open(bundleName);
1541 storageEngine->CreateTable(sessionId);
1542 auto tableWatcherPtr = std::make_shared<TableWatcherImpl>(sessionId);
1543 // RegisterObserver observer already exist
1544 uint32_t ret = storageEngine->RegisterObserver(sessionId, tableWatcherPtr);
1545 EXPECT_EQ(SUCCESS, ret);
1546 storageEngine->RegisterObserver(sessionId, tableWatcherPtr);
1547 EXPECT_EQ(SUCCESS, ret);
1548 ret = storageEngine->DeleteTable(sessionId);
1549 EXPECT_EQ(SUCCESS, ret);
1550 }
1551
1552 /**
1553 * @tc.name: DistributedObject_UnRegisterObserver_001
1554 * @tc.desc: test FlatObjectStorageEngine UnRegisterObserver, storageEngine is not open.
1555 * @tc.type: FUNC
1556 */
1557 HWTEST_F(NativeObjectStoreTest, DistributedObject_UnRegisterObserver_001, TestSize.Level1)
1558 {
1559 std::string sessionId = "123456";
1560 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1561 storageEngine->isOpened_ = false;
1562 uint32_t ret = storageEngine->UnRegisterObserver(sessionId);
1563 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
1564 }
1565
1566 /**
1567 * @tc.name: DistributedObject_UnRegisterObserver_001
1568 * @tc.desc: test FlatObjectStorageEngine UnRegisterObserver, empty sessionId.
1569 * @tc.type: FUNC
1570 */
1571 HWTEST_F(NativeObjectStoreTest, DistributedObject_UnRegisterObserver_002, TestSize.Level1)
1572 {
1573 std::string bundleName = "default";
1574 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1575 storageEngine->Open(bundleName);
1576 uint32_t ret = storageEngine->UnRegisterObserver("");
1577 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1578 }
1579
1580 /**
1581 * @tc.name: DistributedObject_SetStatusNotifier_002
1582 * @tc.desc: test FlatObjectStorageEngine SetStatusNotifier.
1583 * @tc.type: FUNC
1584 */
1585 HWTEST_F(NativeObjectStoreTest, DistributedObject_SetStatusNotifier_002, TestSize.Level1)
1586 {
1587 std::string bundleName = "default";
1588 std::string sessionId = "123456";
1589 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1590 storageEngine->Open(bundleName);
1591 storageEngine->CreateTable(sessionId);
1592 auto statusNotifier = std::make_shared<StatusNotifierImpl>();
1593 uint32_t ret = storageEngine->SetStatusNotifier(statusNotifier);
1594 EXPECT_EQ(SUCCESS, ret);
1595 ret = storageEngine->DeleteTable(sessionId);
1596 EXPECT_EQ(SUCCESS, ret);
1597 }
1598
1599 /**
1600 * @tc.name: DistributedObject_SetStatusNotifier_003
1601 * @tc.desc: test FlatObjectStorageEngine SetStatusNotifier, storageEngine is not open.
1602 * @tc.type: FUNC
1603 */
1604 HWTEST_F(NativeObjectStoreTest, DistributedObject_SetStatusNotifier_003, TestSize.Level1)
1605 {
1606 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1607 auto statusNotifier = std::make_shared<StatusNotifierImpl>();
1608 storageEngine->isOpened_ = false;
1609 uint32_t ret = storageEngine->SetStatusNotifier(statusNotifier);
1610 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
1611 }
1612
1613 /**
1614 * @tc.name: DistributedObject_GetItems_001
1615 * @tc.desc: test FlatObjectStorageEngine GetItems, storageEngine is not open or error key.
1616 * @tc.type: FUNC
1617 */
1618 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetItems_001, TestSize.Level1)
1619 {
1620 std::string bundleName = "default";
1621 std::string sessionId = "123456";
1622 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1623 storageEngine->Open(bundleName);
1624 storageEngine->CreateTable(sessionId);
1625 storageEngine->isOpened_ = false;
1626 std::vector<uint8_t> value = { 1, 8 };
1627 std::map<std::string, std::vector<uint8_t>> data = { { "age", value } };
1628 uint32_t ret = storageEngine->GetItems(sessionId, data);
1629 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
1630 storageEngine->Open(bundleName);
1631 ret = storageEngine->GetItems("", data);
1632 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1633 ret = storageEngine->DeleteTable(sessionId);
1634 EXPECT_EQ(SUCCESS, ret);
1635 }
1636
1637 /**
1638 * @tc.name: DistributedObject_NotifyStatus_001
1639 * @tc.desc: test FlatObjectStorageEngine NotifyStatus.
1640 * @tc.type: FUNC
1641 */
1642 HWTEST_F(NativeObjectStoreTest, DistributedObject_NotifyStatus_001, TestSize.Level1)
1643 {
1644 std::string bundleName = "default07";
1645 std::string sessionId = "123456";
1646 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1647 uint32_t ret = storageEngine->Open(bundleName);
1648 storageEngine->NotifyStatus(sessionId, "local", "restored");
1649 ret = storageEngine->Close();
1650 EXPECT_EQ(SUCCESS, ret);
1651 }
1652
1653 /**
1654 * @tc.name: DistributedObject_SyncAllData_002
1655 * @tc.desc: test FlatObjectStorageEngine SyncAllData.
1656 * @tc.type: FUNC
1657 */
1658 HWTEST_F(NativeObjectStoreTest, DistributedObject_SyncAllData_002, TestSize.Level1)
1659 {
1660 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
__anonba25df920602(const std::map<std::string, DistributedDB::DBStatus> &) 1661 auto onComplete = [](const std::map<std::string, DistributedDB::DBStatus> &) {};
1662 std::vector<std::string> deviceIds = { "deviceIds" };
1663 uint32_t ret = storageEngine->SyncAllData("", deviceIds, onComplete);
1664 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1665 }
1666
1667 /**
1668 * @tc.name: DistributedObject_UpdateItem_002
1669 * @tc.desc: test FlatObjectStorageEngine UpdateItem, error status.
1670 * @tc.type: FUNC
1671 */
1672 HWTEST_F(NativeObjectStoreTest, DistributedObject_UpdateItem_002, TestSize.Level1)
1673 {
1674 std::string bundleName = "default";
1675 std::string sessionId = "123456";
1676 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1677 storageEngine->Open(bundleName);
1678 storageEngine->CreateTable(sessionId);
1679 std::vector<uint8_t> value = { 1, 2 };
1680 uint32_t ret = storageEngine->UpdateItem(sessionId, std::string(1025, 't'), value);
1681 EXPECT_EQ(ERR_CLOSE_STORAGE, ret);
1682 ret = storageEngine->DeleteTable(sessionId);
1683 EXPECT_EQ(SUCCESS, ret);
1684 }
1685
1686 /**
1687 * @tc.name: DistributedObjectStore_SetProgressNotifier_001
1688 * @tc.desc: test DistributedObjectStore SetProgressNotifier.
1689 * @tc.type: FUNC
1690 */
1691 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_SetProgressNotifier_001, TestSize.Level1)
1692 {
1693 std::string bundleName = "default";
1694 std::string sessionId = "123456";
1695 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
1696 ASSERT_NE(nullptr, objectStore);
1697 DistributedObject *object = objectStore->CreateObject(sessionId);
1698 ASSERT_NE(nullptr, object);
1699 objectStore->NotifyProgressStatus(sessionId);
1700 auto progressNotifierPtr = std::shared_ptr<ProgressNotifier>();
1701 auto ret = objectStore->SetProgressNotifier(progressNotifierPtr);
1702 EXPECT_EQ(ret, 0);
1703 }
1704
1705 /**
1706 * @tc.name: DistributedObject_SetProgressNotifier_002
1707 * @tc.desc: test FlatObjectStorageEngine SetProgressNotifier.
1708 * @tc.type: FUNC
1709 */
1710 HWTEST_F(NativeObjectStoreTest, DistributedObject_SetProgressNotifier_002, TestSize.Level1)
1711 {
1712 std::string bundleName = "default";
1713 std::string sessionId = "123456";
1714 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1715 storageEngine->isOpened_ = true;
1716 auto progressNotifier = std::make_shared<ProgressNotifierImpl>();
1717 uint32_t ret = storageEngine->SetProgressNotifier(progressNotifier);
1718 EXPECT_EQ(SUCCESS, ret);
1719 }
1720
1721 /**
1722 * @tc.name: DistributedObject_SetProgressNotifier_003
1723 * @tc.desc: test FlatObjectStorageEngine SetProgressNotifier, storageEngine is not open.
1724 * @tc.type: FUNC
1725 */
1726 HWTEST_F(NativeObjectStoreTest, DistributedObject_SetProgressNotifier_003, TestSize.Level1)
1727 {
1728 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1729 auto progressNotifier = std::make_shared<ProgressNotifierImpl>();
1730 storageEngine->isOpened_ = false;
1731 uint32_t ret = storageEngine->SetProgressNotifier(progressNotifier);
1732 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
1733 }
1734
1735 /**
1736 * @tc.name: DistributedObject_NotifyProgress_001
1737 * @tc.desc: test FlatObjectStorageEngine NotifyProgress.
1738 * @tc.type: FUNC
1739 */
1740 HWTEST_F(NativeObjectStoreTest, DistributedObject_NotifyProgress_001, TestSize.Level1)
1741 {
1742 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1743 std::string sessionId = "123456";
1744 int32_t progress = 100;
1745 auto ret = storageEngine->NotifyProgress(sessionId, progress);
1746 EXPECT_EQ(ret, false);
1747 auto progressNotifier = std::make_shared<ProgressNotifierImpl>();
1748 storageEngine->isOpened_ = true;
1749 ret = storageEngine->SetProgressNotifier(progressNotifier);
1750 ret = storageEngine->NotifyProgress(sessionId, progress);
1751 EXPECT_EQ(ret, true);
1752 }
1753
1754 /**
1755 * @tc.name: CacheManager_SubscribeProgressChange_001
1756 * @tc.desc: test CacheManager SubscribeProgressChange.
1757 * @tc.type: FUNC
1758 */
1759 HWTEST_F(NativeObjectStoreTest, CacheManager_SubscribeProgressChange_001, TestSize.Level1)
1760 {
1761 std::string bundleName = "";
1762 std::string sessionId = "";
1763 CacheManager cacheManager;
__anonba25df920702(int32_t progress) 1764 std::function<void(int32_t progress)> callback = [sessionId, this](int32_t progress) {};
1765 auto ret = cacheManager.SubscribeProgressChange(bundleName, sessionId, callback);
1766 EXPECT_EQ(SUCCESS, ret);
1767 }
1768
1769 /**
1770 * @tc.name: CacheManager_UnregisterProgressChange_001
1771 * @tc.desc: test CacheManager UnregisterProgressChange.
1772 * @tc.type: FUNC
1773 */
1774 HWTEST_F(NativeObjectStoreTest, CacheManager_UnregisterProgressChange_001, TestSize.Level1)
1775 {
1776 std::string bundleName = "";
1777 std::string sessionId = "";
1778 CacheManager cacheManager;
1779 auto ret = cacheManager.UnregisterProgressChange(bundleName, sessionId);
1780 EXPECT_EQ(SUCCESS, ret);
1781 }
1782
1783 /**
1784 * @tc.name: FlatObjectStore_CheckProgressCache_001
1785 * @tc.desc: test FlatObjectStore CheckProgressCache.
1786 * @tc.type: FUNC
1787 */
1788 HWTEST_F(NativeObjectStoreTest, FlatObjectStore_CheckProgressCache_001, TestSize.Level1)
1789 {
1790 std::string sessionId = "session001";
1791 std::string bundleName = "default001";
1792 std::shared_ptr<FlatObjectStore> flatObjectStore = std::make_shared<FlatObjectStore>(bundleName);
1793 uint32_t ret = flatObjectStore->CreateObject(sessionId);
1794 EXPECT_EQ(SUCCESS, ret);
1795 flatObjectStore->CheckProgressCache(sessionId);
1796 flatObjectStore->SubscribeProgressChange(sessionId);
1797 flatObjectStore->CheckProgressCache(sessionId);
1798 int32_t progress = 100;
1799 flatObjectStore->progressInfoCache_[sessionId] = progress;
1800 flatObjectStore->CheckProgressCache(sessionId);
1801 auto progressNotifier = std::make_shared<ProgressNotifierImpl>();
1802 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1803 storageEngine->isOpened_ = true;
1804 ret = storageEngine->SetProgressNotifier(progressNotifier);
1805 ret = storageEngine->NotifyProgress(sessionId, progress);
1806 EXPECT_EQ(ret, true);
1807 flatObjectStore->CheckProgressCache(sessionId);
1808 ret = flatObjectStore->Delete(sessionId);
1809 EXPECT_EQ(SUCCESS, ret);
1810 }
1811
1812 /**
1813 * @tc.name: FlatObjectStore_SubscribeProgressChange_001
1814 * @tc.desc: test FlatObjectStore SubscribeProgressChange.
1815 * @tc.type: FUNC
1816 */
1817 HWTEST_F(NativeObjectStoreTest, FlatObjectStore_SubscribeProgressChange_001, TestSize.Level1)
1818 {
1819 std::string sessionId = "session001";
1820 std::string bundleName = "default001";
1821 std::shared_ptr<FlatObjectStore> flatObjectStore = std::make_shared<FlatObjectStore>(bundleName);
1822 uint32_t ret = flatObjectStore->CreateObject(sessionId);
1823 EXPECT_EQ(SUCCESS, ret);
1824 flatObjectStore->SubscribeProgressChange(sessionId);
1825 ret = flatObjectStore->Delete(sessionId);
1826 EXPECT_EQ(SUCCESS, ret);
1827 }
1828
1829 /**
1830 * @tc.name: FlatObjectStore_SetProgressNotifier_001
1831 * @tc.desc: test FlatObjectStore SetProgressNotifier.
1832 * @tc.type: FUNC
1833 */
1834 HWTEST_F(NativeObjectStoreTest, FlatObjectStore_SetProgressNotifier_001, TestSize.Level1)
1835 {
1836 std::string sessionId = "session001";
1837 std::string bundleName = "default001";
1838 std::shared_ptr<FlatObjectStore> flatObjectStore = std::make_shared<FlatObjectStore>(bundleName);
1839 uint32_t ret = flatObjectStore->CreateObject(sessionId);
1840 EXPECT_EQ(SUCCESS, ret);
1841 auto progressNotifier = std::make_shared<ProgressNotifierImpl>();
1842 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1843 flatObjectStore->storageEngine_->isOpened_ = true;
1844 flatObjectStore->SetProgressNotifier(progressNotifier);
1845 flatObjectStore->storageEngine_->isOpened_ = false;
1846 flatObjectStore->SetProgressNotifier(progressNotifier);
1847 ret = flatObjectStore->Delete(sessionId);
1848 EXPECT_EQ(SUCCESS, ret);
1849 }
1850
1851 /**
1852 * @tc.name: FlatObjectStore_SetProgressNotifier_002
1853 * @tc.desc: test FlatObjectStore SetProgressNotifier，storageEngine is not open.
1854 * @tc.type: FUNC
1855 */
1856 HWTEST_F(NativeObjectStoreTest, FlatObjectStore_SetProgressNotifier_002, TestSize.Level1)
1857 {
1858 std::string sessionId = "session001";
1859 std::string bundleName = "default001";
1860 std::shared_ptr<FlatObjectStore> flatObjectStore = std::make_shared<FlatObjectStore>(bundleName);
1861 uint32_t ret = flatObjectStore->CreateObject(sessionId);
1862 EXPECT_EQ(SUCCESS, ret);
1863 auto progressNotifier = std::make_shared<ProgressNotifierImpl>();
1864 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1865 auto notifier = std::shared_ptr<ProgressNotifier>();
1866 std::shared_ptr<ProgressNotifierProxy> progressNotifierProxy = std::make_shared<ProgressNotifierProxy>(notifier);
1867 int32_t progress = 100;
1868 progressNotifierProxy->OnChanged(sessionId, progress);
1869 progressNotifierProxy->notifier = notifier;
1870 progressNotifierProxy->OnChanged(sessionId, progress);
1871 storageEngine->isOpened_ = false;
1872 flatObjectStore->SetProgressNotifier(progressNotifier);
1873 EXPECT_EQ(SUCCESS, ret);
1874 ret = flatObjectStore->Delete(sessionId);
1875 EXPECT_EQ(SUCCESS, ret);
1876 }
1877 } // namespace
1878