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
18 #include <string>
19 #include <thread>
20
21 #include "auto_launch_export.h"
22 #include "flat_object_store.h"
23 #include "flat_object_storage_engine.h"
24 #include "distributed_object.h"
25 #include "distributed_objectstore.h"
26 #include "distributed_objectstore_impl.h"
27 #include "hilog/log.h"
28 #include "kv_store_delegate_manager.h"
29 #include "object_storage_engine.h"
30 #include "objectstore_errors.h"
31 #include "store_observer.h"
32 #include "ipc_skeleton.h"
33 #include "accesstoken_kit.h"
34 #include "nativetoken_kit.h"
35 #include "token_setproc.h"
36
37 using namespace testing::ext;
38 using namespace OHOS::ObjectStore;
39 using namespace OHOS::Security::AccessToken;
40 using namespace OHOS::HiviewDFX;
41 namespace {
42 constexpr static double SALARY = 100.5;
43 constexpr HiLogLabel LABEL = { LOG_CORE, 0, "DistributedTest" };
44 class TableWatcherImpl : public TableWatcher {
45 public:
TableWatcherImpl(const std::string & sessionId)46 explicit TableWatcherImpl(const std::string &sessionId) : TableWatcher(sessionId) {}
47 void OnChanged(const std::string &sessionid, const std::vector<std::string> &changedData) override;
48 virtual ~TableWatcherImpl();
49 };
50
~TableWatcherImpl()51 TableWatcherImpl::~TableWatcherImpl() {}
OnChanged(const std::string & sessionid,const std::vector<std::string> & changedData)52 void TableWatcherImpl::OnChanged(const std::string &sessionid, const std::vector<std::string> &changedData) {}
53
54 class StatusNotifierImpl : public StatusWatcher {
55 public:
56 void OnChanged(
57 const std::string &sessionId, const std::string &networkId, const std::string &onlineStatus) override;
58 virtual ~StatusNotifierImpl();
59 };
~StatusNotifierImpl()60 StatusNotifierImpl::~StatusNotifierImpl() {}
61
OnChanged(const std::string & sessionId,const std::string & networkId,const std::string & onlineStatus)62 void StatusNotifierImpl::OnChanged(const std::string &sessionId,
63 const std::string &networkId,
64 const std::string &onlineStatus)
65 {
66 }
TestSetSessionId(std::string bundleName,std::string sessionId)67 static void TestSetSessionId(std::string bundleName, std::string sessionId)
68 {
69 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
70 EXPECT_NE(nullptr, objectStore);
71 DistributedObject *object = objectStore->CreateObject(sessionId);
72 EXPECT_NE(nullptr, object);
73
74 uint32_t ret = objectStore->DeleteObject(sessionId);
75 EXPECT_EQ(SUCCESS, ret);
76 }
77
TestSaveAndRevokeSave(std::string bundleName,std::string sessionId)78 static void TestSaveAndRevokeSave(std::string bundleName, std::string sessionId)
79 {
80 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
81 EXPECT_NE(nullptr, objectStore);
82 DistributedObject *object = objectStore->CreateObject(sessionId);
83 EXPECT_NE(nullptr, object);
84
85 uint32_t ret = object->PutString("name", "zhangsan");
86 EXPECT_EQ(SUCCESS, ret);
87 ret = object->PutDouble("salary", SALARY);
88 EXPECT_EQ(SUCCESS, ret);
89 ret = object->PutBoolean("isTrue", true);
90 EXPECT_EQ(SUCCESS, ret);
91
92 ret = object->Save("local");
93 EXPECT_EQ(SUCCESS, ret);
94 ret = object->RevokeSave();
95 EXPECT_EQ(SUCCESS, ret);
96
97 ret = objectStore->DeleteObject(sessionId);
98 EXPECT_EQ(SUCCESS, ret);
99 }
100
GrantPermissionNative()101 void GrantPermissionNative()
102 {
103 const char **perms = new const char *[2];
104 perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
105 perms[1] = "ohos.permission.DISTRIBUTED_SOFTBUS_CENTER";
106 TokenInfoParams infoInstance = {
107 .dcapsNum = 0,
108 .permsNum = 2,
109 .aclsNum = 0,
110 .dcaps = nullptr,
111 .perms = perms,
112 .acls = nullptr,
113 .processName = "distributed_object",
114 .aplStr = "system_basic",
115 };
116 uint64_t tokenId = GetAccessTokenId(&infoInstance);
117 SetSelfTokenID(tokenId);
118 AccessTokenKit::ReloadNativeTokenInfo();
119 }
120
121 class NativeObjectStoreTest : public testing::Test {
122 public:
123 static void SetUpTestCase(void);
124 static void TearDownTestCase(void);
125 void SetUp();
126 void TearDown();
127 };
128
SetUpTestCase(void)129 void NativeObjectStoreTest::SetUpTestCase(void)
130 {
131 // input testsuit setup step，setup invoked before all testcases
132 }
133
TearDownTestCase(void)134 void NativeObjectStoreTest::TearDownTestCase(void)
135 {
136 // input testsuit teardown step，teardown invoked after all testcases
137 }
138
SetUp(void)139 void NativeObjectStoreTest::SetUp(void)
140 {
141 // input testcase setup step，setup invoked before each testcases
142 GrantPermissionNative();
143 }
144
TearDown(void)145 void NativeObjectStoreTest::TearDown(void)
146 {
147 // input testcase teardown step，teardown invoked after each testcases
148 }
149
150 /**
151 * @tc.name: DistributedObjectStore_Create_Destroy_001
152 * @tc.desc: test Create DistributedObject and Destroy DistrbutedObject
153 * @tc.type: FUNC
154 */
155 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Create_Destroy_001, TestSize.Level1)
156 {
157 std::string bundleName = "default";
158 std::string sessionId = "123456";
159 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
160 EXPECT_NE(nullptr, objectStore);
161
162 DistributedObject *object = objectStore->CreateObject(sessionId);
163 EXPECT_NE(nullptr, object);
164
165 uint32_t ret = objectStore->DeleteObject(sessionId);
166 EXPECT_EQ(SUCCESS, ret);
167 }
168
169 /**
170 * @tc.name: DistributedObjectStore_Create_Destroy_002
171 * @tc.desc: test Create DistributedObject and Destroy DistrbutedObject
172 * @tc.type: FUNC
173 */
174 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Create_Destroy_002, TestSize.Level1)
175 {
176 std::string sessionId = "123456";
177
178 auto objectStore = new DistributedObjectStoreImpl(nullptr);
179 DistributedObject *object = objectStore->CreateObject(sessionId);
180 EXPECT_EQ(nullptr, object);
181 delete objectStore;
182 }
183
184 /**
185 * @tc.name: DistributedObjectStore_Create_Destroy_003
186 * @tc.desc: test Create DistributedObject and Destroy DistrbutedObject
187 * @tc.type: FUNC
188 */
189 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Create_Destroy_003, TestSize.Level1)
190 {
191 std::string bundleName = "default";
192 std::string sessionId = "123456";
193 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
194 EXPECT_NE(nullptr, objectStore);
195
196 DistributedObject *object = objectStore->CreateObject(sessionId);
197 EXPECT_NE(nullptr, object);
198
199 DistributedObject *object2 = objectStore->CreateObject(sessionId);
200 EXPECT_EQ(nullptr, object2);
201
202 uint32_t ret = objectStore->DeleteObject(sessionId);
203 EXPECT_EQ(SUCCESS, ret);
204 }
205
206 /**
207 * @tc.name: DistributedObjectStore_Create_Destroy_004
208 * @tc.desc: test Create DistributedObject and Destroy DistrbutedObject
209 * @tc.type: FUNC
210 */
211 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Create_Destroy_004, TestSize.Level1)
212 {
213 std::string bundleName = "default";
214 std::string sessionId = "123456";
215 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
216 EXPECT_NE(nullptr, objectStore);
217
218 uint32_t status = -1;
219 DistributedObject *object = objectStore->CreateObject(sessionId, status);
220 EXPECT_NE(nullptr, object);
221 EXPECT_EQ(SUCCESS, status);
222
223 uint32_t ret = objectStore->DeleteObject(sessionId);
224 EXPECT_EQ(SUCCESS, ret);
225 }
226
227 /**
228 * @tc.name: DistributedObjectStore_Get_001
229 * @tc.desc: test DistributedObjectStore Get.
230 * @tc.type: FUNC
231 */
232 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Get_001, TestSize.Level1)
233 {
234 std::string bundleName = "default";
235 std::string sessionId = "123456";
236 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
237 EXPECT_NE(nullptr, objectStore);
238
239 DistributedObject *object = objectStore->CreateObject(sessionId);
240 EXPECT_NE(nullptr, object);
241
242 DistributedObject *object2 = nullptr;
243 uint32_t ret = objectStore->Get(sessionId, &object2);
244 EXPECT_EQ(SUCCESS, ret);
245 EXPECT_EQ(object, object2);
246
247 ret = objectStore->DeleteObject(sessionId);
248 EXPECT_EQ(SUCCESS, ret);
249 }
250
251 /**
252 * @tc.name: DistributedObjectStore_Watch_UnWatch_001
253 * @tc.desc: test DistributedObjectStore Watch and UnWatch.
254 * @tc.type: FUNC
255 */
256 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_Watch_UnWatch_001, TestSize.Level1)
257 {
258 std::string bundleName = "default";
259 std::string sessionId = "123456";
260 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
261 EXPECT_NE(nullptr, objectStore);
262
263 DistributedObject *object = objectStore->CreateObject(sessionId);
264 EXPECT_NE(nullptr, object);
265
266 auto watcherPtr = std::shared_ptr<ObjectWatcher>();
267 uint32_t ret = objectStore->Watch(object, watcherPtr);
268 EXPECT_EQ(SUCCESS, ret);
269
270 ret = objectStore->UnWatch(object);
271 EXPECT_EQ(SUCCESS, ret);
272
273 ret = objectStore->DeleteObject(sessionId);
274 EXPECT_EQ(SUCCESS, ret);
275 }
276
277 /**
278 * @tc.name: DistributedObjectStore_SetStatusNotifier_001
279 * @tc.desc: test DistributedObjectStore SetStatusNotifier.
280 * @tc.type: FUNC
281 */
282 HWTEST_F(NativeObjectStoreTest, DistributedObjectStore_SetStatusNotifier_001, TestSize.Level1)
283 {
284 std::string bundleName = "default";
285 std::string sessionId = "123456";
286 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
287 EXPECT_NE(nullptr, objectStore);
288 DistributedObject *object = objectStore->CreateObject(sessionId);
289 EXPECT_NE(nullptr, object);
290
291 auto notifierPtr = std::shared_ptr<StatusNotifier>();
292 uint32_t ret = objectStore->SetStatusNotifier(notifierPtr);
293 EXPECT_EQ(ret, 0);
294
295 ret = objectStore->DeleteObject(sessionId);
296 EXPECT_EQ(ret, 0);
297 }
298
299 /**
300 * @tc.name: DistributedObject_Double_001
301 * @tc.desc: test DistributedObjectStore PutDouble.
302 * @tc.type: FUNC
303 */
304 HWTEST_F(NativeObjectStoreTest, DistributedObject_Double_001, TestSize.Level1)
305 {
306 std::string bundleName = "default";
307 std::string sessionId = "123456";
308 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
309 EXPECT_NE(nullptr, objectStore);
310 DistributedObject *object = objectStore->CreateObject(sessionId);
311 EXPECT_NE(nullptr, object);
312
313 uint32_t ret = object->PutDouble("salary", SALARY);
314 EXPECT_EQ(ret, 0);
315
316 double value = 0.0;
317 object->GetDouble("salary", value);
318 EXPECT_EQ(ret, 0);
319 EXPECT_EQ(value, SALARY);
320
321 ret = objectStore->DeleteObject(sessionId);
322 EXPECT_EQ(ret, 0);
323 }
324
325 /**
326 * @tc.name: DistributedObject_Boolean_001
327 * @tc.desc: test DistributedObjectStore PutBoolean.
328 * @tc.type: FUNC
329 */
330 HWTEST_F(NativeObjectStoreTest, DistributedObject_Boolean_001, TestSize.Level1)
331 {
332 std::string bundleName = "default";
333 std::string sessionId = "123456";
334 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
335 EXPECT_NE(nullptr, objectStore);
336 DistributedObject *object = objectStore->CreateObject(sessionId);
337 EXPECT_NE(nullptr, object);
338
339 uint32_t ret = object->PutBoolean("isTrue", true);
340 EXPECT_EQ(SUCCESS, ret);
341
342 bool value = false;
343 ret = object->GetBoolean("isTrue", value);
344 EXPECT_EQ(SUCCESS, ret);
345 EXPECT_EQ(true, value);
346
347 ret = objectStore->DeleteObject(sessionId);
348 EXPECT_EQ(SUCCESS, ret);
349 }
350
351 /**
352 * @tc.name: DistributedObject_String_001
353 * @tc.desc: test DistributedObjectStore String.
354 * @tc.type: FUNC
355 */
356 HWTEST_F(NativeObjectStoreTest, DistributedObject_String_001, TestSize.Level1)
357 {
358 std::string bundleName = "default";
359 std::string sessionId = "123456";
360 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
361 EXPECT_NE(nullptr, objectStore);
362 DistributedObject *object = objectStore->CreateObject(sessionId);
363 EXPECT_NE(nullptr, object);
364
365 uint32_t ret = object->PutString("name", "zhangsan");
366 EXPECT_EQ(SUCCESS, ret);
367
368 std::string value = "";
369 ret = object->GetString("name", value);
370 EXPECT_EQ(SUCCESS, ret);
371 EXPECT_EQ(value, "zhangsan");
372
373 ret = objectStore->DeleteObject(sessionId);
374 EXPECT_EQ(SUCCESS, ret);
375 }
376
377 /**
378 * @tc.name: DistributedObject_GetSessionId_001
379 * @tc.desc: test DistributedObjectStore GetSessionId.
380 * @tc.type: FUNC
381 */
382 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetSessionId_001, TestSize.Level1)
383 {
384 std::string bundleName = "default";
385 std::string sessionId = "123456";
386 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
387 EXPECT_NE(nullptr, objectStore);
388 DistributedObject *object = objectStore->CreateObject(sessionId);
389 EXPECT_NE(nullptr, object);
390 std::string getSessionId = object->GetSessionId();
391 EXPECT_EQ(sessionId, getSessionId);
392 uint32_t ret = objectStore->DeleteObject(sessionId);
393 EXPECT_EQ(SUCCESS, ret);
394 }
395
396 /**
397 * @tc.name: DistributedObject_TestSetSessionId_001
398 * @tc.desc: test DistributedObjectStore TestSetSessionId.
399 * @tc.type: FUNC
400 */
401 HWTEST_F(NativeObjectStoreTest, DistributedObject_TestSetSessionId_001, TestSize.Level1)
402 {
403 std::thread t1(TestSetSessionId, "default1", "session1");
404 std::thread t2(TestSetSessionId, "default2", "session2");
405 std::thread t3(TestSetSessionId, "default3", "session3");
406 t1.join();
407 t2.join();
408 t3.join();
409 }
410
411 /**
412 * @tc.name: DistributedObject_GetType_001
413 * @tc.desc: test DistributedObject GetType.
414 * @tc.type: FUNC
415 */
416 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetType_001, TestSize.Level1)
417 {
418 std::string bundleName = "default";
419 std::string sessionId = "123456";
420 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
421 EXPECT_NE(nullptr, objectStore);
422 DistributedObject *object = objectStore->CreateObject(sessionId);
423 EXPECT_NE(nullptr, object);
424
425 uint32_t ret = object->PutString("name", "zhangsan");
426 EXPECT_EQ(SUCCESS, ret);
427 Type type;
428 ret = object->GetType("name", type);
429 EXPECT_EQ(SUCCESS, ret);
430 EXPECT_EQ(TYPE_STRING, type);
431
432 ret = object->PutDouble("salary", SALARY);
433 EXPECT_EQ(SUCCESS, ret);
434 ret = object->GetType("salary", type);
435 EXPECT_EQ(SUCCESS, ret);
436 EXPECT_EQ(TYPE_DOUBLE, type);
437
438 ret = object->PutBoolean("isTrue", true);
439 EXPECT_EQ(SUCCESS, ret);
440 ret = object->GetType("isTrue", type);
441 EXPECT_EQ(SUCCESS, ret);
442 EXPECT_EQ(TYPE_BOOLEAN, type);
443
444 ret = objectStore->DeleteObject(sessionId);
445 EXPECT_EQ(SUCCESS, ret);
446 }
447
448 /**
449 * @tc.name: DistributedObject_Save_RevokeSave_001
450 * @tc.desc: test DistributedObjectStore Save.
451 * @tc.type: FUNC
452 */
453 HWTEST_F(NativeObjectStoreTest, DistributedObject_Save_RevokeSave_001, TestSize.Level1)
454 {
455 std::string bundleName = "default";
456 std::string sessionId = "123456";
457 TestSaveAndRevokeSave(bundleName, sessionId);
458 }
459
460 /**
461 * @tc.name: DistributedObject_Save_RevokeSave_002
462 * @tc.desc: test DistributedObjectStore Save.
463 * @tc.type: FUNC
464 */
465 HWTEST_F(NativeObjectStoreTest, DistributedObject_Save_RevokeSave_002, TestSize.Level1)
466 {
467 std::thread t1(TestSaveAndRevokeSave, "default1", "session1");
468 std::thread t2(TestSaveAndRevokeSave, "default2", "session2");
469 std::thread t3(TestSaveAndRevokeSave, "default3", "session3");
470 t1.join();
471 t2.join();
472 t3.join();
473 }
474
475 /**
476 * @tc.name: DistributedObject_Open_001
477 * @tc.desc: test ObjectStorageEngine Open, calling Open repeatedly.
478 * @tc.type: FUNC
479 */
480 HWTEST_F(NativeObjectStoreTest, DistributedObject_Open_001, TestSize.Level1)
481 {
482 std::string bundleName = "default";
483 std::string sessionId = "123456";
484 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
485 uint32_t ret = objectStorageEngine->Open(bundleName);
486 EXPECT_EQ(SUCCESS, ret);
487 ret = objectStorageEngine->Open(bundleName);
488 EXPECT_EQ(SUCCESS, ret);
489 ret = objectStorageEngine->CreateTable(sessionId);
490 EXPECT_EQ(SUCCESS, ret);
491 ret = objectStorageEngine->DeleteTable(sessionId);
492 EXPECT_EQ(SUCCESS, ret);
493 delete objectStorageEngine;
494 }
495
496 /**
497 * @tc.name: DistributedObject_CreateTable_001
498 * @tc.desc: test ObjectStorageEngine CreateTable.
499 * @tc.type: FUNC
500 */
501 HWTEST_F(NativeObjectStoreTest, DistributedObject_CreateTable_001, TestSize.Level1)
502 {
503 std::string bundleName = "default";
504 std::string sessionId = "123456";
505 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
506 uint32_t ret = objectStorageEngine->Open(bundleName);
507 EXPECT_EQ(SUCCESS, ret);
508 ret = objectStorageEngine->CreateTable(sessionId);
509 EXPECT_EQ(SUCCESS, ret);
510 ret = objectStorageEngine->DeleteTable(sessionId);
511 EXPECT_EQ(SUCCESS, ret);
512 delete objectStorageEngine;
513 }
514
515 /**
516 * @tc.name: DistributedObject_CreateTable_002
517 * @tc.desc: test ObjectStorageEngine CreateTable, calling CreateTable() repeatedly.
518 * @tc.type: FUNC
519 */
520 HWTEST_F(NativeObjectStoreTest, DistributedObject_CreateTable_002, TestSize.Level1)
521 {
522 std::string bundleName = "default";
523 std::string sessionId = "123456";
524 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
525 uint32_t ret = objectStorageEngine->Open(bundleName);
526 EXPECT_EQ(SUCCESS, ret);
527 ret = objectStorageEngine->CreateTable(sessionId);
528 EXPECT_EQ(SUCCESS, ret);
529 ret = objectStorageEngine->CreateTable(sessionId);
530 EXPECT_NE(SUCCESS, ret);
531 ret = objectStorageEngine->DeleteTable(sessionId);
532 EXPECT_EQ(SUCCESS, ret);
533 delete objectStorageEngine;
534 }
535
536 /**
537 * @tc.name: DistributedObject_CreateTable_003
538 * @tc.desc: test ObjectStorageEngine CreateTable, calling CreateTable after calling Close().
539 * @tc.type: FUNC
540 */
541 HWTEST_F(NativeObjectStoreTest, DistributedObject_CreateTable_003, TestSize.Level1)
542 {
543 std::string bundleName = "default";
544 std::string sessionId = "123456";
545 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
546 uint32_t ret = objectStorageEngine->Open(bundleName);
547 EXPECT_EQ(SUCCESS, ret);
548 ret = objectStorageEngine->Close();
549 EXPECT_EQ(SUCCESS, ret);
550 ret = objectStorageEngine->CreateTable(sessionId);
551 EXPECT_NE(SUCCESS, ret);
552 delete objectStorageEngine;
553 }
554
555 /**
556 * @tc.name: DistributedObject_GetTable_001
557 * @tc.desc: test ObjectStorageEngine GetTable, not calling Open().
558 * @tc.type: FUNC
559 */
560 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_001, TestSize.Level1)
561 {
562 std::string sessionId = "session01";
563 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
564 std::map<std::string, Value> result = {};
565 uint32_t ret = objectStorageEngine->GetTable(sessionId, result);
566 EXPECT_NE(SUCCESS, ret);
567 delete objectStorageEngine;
568 }
569
570 /**
571 * @tc.name: DistributedObject_GetTable_002
572 * @tc.desc: test ObjectStorageEngine GetTable, calling Open(),but not calling CreateTable().
573 * @tc.type: FUNC
574 */
575 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_002, TestSize.Level1)
576 {
577 std::string bundleName = "default02";
578 std::string sessionId = "session02";
579 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
580 uint32_t ret = objectStorageEngine->Open(bundleName);
581 EXPECT_EQ(SUCCESS, ret);
582 std::map<std::string, Value> result = {};
583 ret = objectStorageEngine->GetTable(sessionId, result);
584 EXPECT_NE(SUCCESS, ret);
585 delete objectStorageEngine;
586 }
587
588 /**
589 * @tc.name: DistributedObject_GetTable_003
590 * @tc.desc: test ObjectStorageEngine GetTable, calling Open() and CreateTable(), but not calling UpdateItem().
591 * @tc.type: FUNC
592 */
593 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_003, TestSize.Level1)
594 {
595 std::string bundleName = "default03";
596 std::string sessionId = "session03";
597 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
598 uint32_t ret = objectStorageEngine->Open(bundleName);
599 EXPECT_EQ(SUCCESS, ret);
600 ret = objectStorageEngine->CreateTable(sessionId);
601 EXPECT_EQ(SUCCESS, ret);
602 std::map<std::string, Value> result = {};
603 ret = objectStorageEngine->GetTable(sessionId, result);
604 EXPECT_NE(SUCCESS, ret);
605 ret = objectStorageEngine->DeleteTable(sessionId);
606 EXPECT_EQ(SUCCESS, ret);
607 delete objectStorageEngine;
608 }
609
610 /**
611 * @tc.name: DistributedObject_GetTable_004
612 * @tc.desc: test ObjectStorageEngine GetTable.
613 * @tc.type: FUNC
614 */
615 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_004, TestSize.Level1)
616 {
617 std::string bundleName = "default04";
618 std::string sessionId = "session04";
619 std::vector<uint8_t> value = { 1, 8 };
620 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
621 uint32_t ret = objectStorageEngine->Open(bundleName);
622 EXPECT_EQ(SUCCESS, ret);
623 ret = objectStorageEngine->CreateTable(sessionId);
624 EXPECT_EQ(SUCCESS, ret);
625 ret = objectStorageEngine->UpdateItem(sessionId, "age", value);
626 EXPECT_EQ(SUCCESS, ret);
627 std::map<std::string, Value> result = {};
628 ret = objectStorageEngine->GetTable(sessionId, result);
629 EXPECT_EQ(SUCCESS, ret);
630 ret = objectStorageEngine->DeleteTable(sessionId);
631 EXPECT_EQ(SUCCESS, ret);
632 delete objectStorageEngine;
633 }
634
635 /**
636 * @tc.name: FlatObjectStore_FilterData_001
637 * @tc.desc: test FlatObjectStore FilterData.
638 * @tc.type: FUNC
639 */
640 HWTEST_F(NativeObjectStoreTest, DistributedObject_FilterData_001, TestSize.Level1)
641 {
642 std::string bundleName = "default05";
643 std::string sessionId = "session05";
644 std::vector<uint8_t> value = { 1, 8 };
645 FlatObjectStore *flatObjectStore = new FlatObjectStore(bundleName);
646 uint32_t ret = flatObjectStore->CreateObject(sessionId);
647 EXPECT_EQ(SUCCESS, ret);
648 ret = flatObjectStore->Put(sessionId, "phone", value);
649 EXPECT_EQ(SUCCESS, ret);
650 ret = flatObjectStore->Put(sessionId, "age", value);
651 EXPECT_EQ(SUCCESS, ret);
652 std::map<std::string, std::vector<uint8_t>> data = { { "age", value }, { "age", value } };
653 auto dataSize = data.size();
654 flatObjectStore->FilterData(sessionId, data);
655 EXPECT_GT(dataSize, data.size());
656 ret = flatObjectStore->Delete(sessionId);
657 EXPECT_EQ(SUCCESS, ret);
658 delete flatObjectStore;
659 }
660
661 /**
662 * @tc.name: FlatObjectStore_UpdateItems_001
663 * @tc.desc: test ObjectStorageEngine UpdateItems. input data is empty.
664 * @tc.type: FUNC
665 */
666 HWTEST_F(NativeObjectStoreTest, DistributedObject_UpdateItems_001, TestSize.Level1)
667 {
668 std::string bundleName = "default06";
669 std::string sessionId = "session06";
670 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
671 uint32_t ret = objectStorageEngine->Open(bundleName);
672 EXPECT_EQ(SUCCESS, ret);
673 ret = objectStorageEngine->CreateTable(sessionId);
674 EXPECT_EQ(SUCCESS, ret);
675 std::map<std::string, std::vector<uint8_t>> data = {};
676 ret = objectStorageEngine->UpdateItems(sessionId, data);
677 EXPECT_NE(SUCCESS, ret);
678 delete objectStorageEngine;
679 }
680
681 /**
682 * @tc.name: FlatObjectStore_UpdateItems_002
683 * @tc.desc: test FlatObjectStore FilterData.
684 * @tc.type: FUNC
685 */
686 HWTEST_F(NativeObjectStoreTest, DistributedObject_UpdateItems_002, TestSize.Level1)
687 {
688 std::string bundleName = "default07";
689 std::string sessionId = "session07";
690 std::vector<uint8_t> value = { 1, 8 };
691 ObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
692 uint32_t ret = objectStorageEngine->Open(bundleName);
693 EXPECT_EQ(SUCCESS, ret);
694 ret = objectStorageEngine->CreateTable(sessionId);
695 EXPECT_EQ(SUCCESS, ret);
696 std::map<std::string, std::vector<uint8_t>> data = { { "age", value } };
697 ret = objectStorageEngine->UpdateItems(sessionId, data);
698 EXPECT_EQ(SUCCESS, ret);
699 delete objectStorageEngine;
700 }
701
702 /**
703 * @tc.name: DistributedObject_OpenAndClose_001
704 * @tc.desc: test FlatObjectStorageEngine OpenAndClose and Close when FlatObjectStorageEngine is not open.
705 * @tc.type: FUNC
706 */
707 HWTEST_F(NativeObjectStoreTest, DistributedObject_OpenAndClose_001, TestSize.Level1)
708 {
709 std::string bundleName = "default07";
710 FlatObjectStorageEngine *objectStorageEngine = new FlatObjectStorageEngine();
711 uint32_t ret = objectStorageEngine->Open(bundleName);
712 EXPECT_EQ(SUCCESS, ret);
713 ret = objectStorageEngine->Close();
714 EXPECT_EQ(SUCCESS, ret);
715 objectStorageEngine->isOpened_ = false;
716 ret = objectStorageEngine->Close();
717 EXPECT_EQ(SUCCESS, ret);
718 delete objectStorageEngine;
719 }
720
721 /**
722 * @tc.name: DistributedObject_NotifyChange_001
723 * @tc.desc: test FlatObjectStorageEngine NotifyChange.
724 * @tc.type: FUNC
725 */
726 HWTEST_F(NativeObjectStoreTest, DistributedObject_NotifyChange_001, TestSize.Level1)
727 {
728 std::string bundleName = "default07";
729 std::string sessionId = "session07";
730 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
731 uint32_t ret = storageEngine->Open(bundleName);
732 ret = storageEngine->CreateTable(sessionId);
733 EXPECT_EQ(SUCCESS, ret);
734 std::map<std::string, std::vector<uint8_t>> filteredData;
735 storageEngine->NotifyChange(sessionId, filteredData);
736 ret = storageEngine->Close();
737 EXPECT_EQ(SUCCESS, ret);
738 }
739
740 /**
741 * @tc.name: DistributedObject_CheckRetrieveCache_001
742 * @tc.desc: test FlatObjectStore CheckRetrieveCache.
743 * @tc.type: FUNC
744 */
745 HWTEST_F(NativeObjectStoreTest, DistributedObject_CheckRetrieveCache_001, TestSize.Level1)
746 {
747 std::string sessionId = "session05";
748 std::string bundleName = "default07";
749 std::shared_ptr<FlatObjectStore> flatObjectStore = std::make_shared<FlatObjectStore>(bundleName);
750 uint32_t ret = flatObjectStore->CreateObject(sessionId);
751 EXPECT_EQ(SUCCESS, ret);
752 flatObjectStore->CheckRetrieveCache(sessionId);
753 ret = flatObjectStore->Delete(sessionId);
754 EXPECT_EQ(SUCCESS, ret);
755 }
756
757 /**
758 * @tc.name: DistributedObject_SyncAllData_001
759 * @tc.desc: test FlatObjectStore SyncAllData.
760 * @tc.type: FUNC
761 */
762 HWTEST_F(NativeObjectStoreTest, DistributedObject_SyncAllData_001, TestSize.Level1)
763 {
764 std::string sessionId = "session258";
765 std::string bundleName = "default07";
766 std::shared_ptr<FlatObjectStore> flatObjectStore = std::make_shared<FlatObjectStore>(bundleName);
767 uint32_t ret = flatObjectStore->CreateObject(sessionId);
768 EXPECT_EQ(SUCCESS, ret);
__anon2dca90710202(const std::map<std::string, DistributedDB::DBStatus> &devices) 769 auto onComplete = [sessionId](const std::map<std::string, DistributedDB::DBStatus> &devices) {
770 for (auto item : devices) {
771 HiLog::Info(LABEL, "%{public}s pull data result %{public}d in device %{public}s", sessionId.c_str(),
772 item.second, (item.first).c_str());
773 }
774 };
775 ret = flatObjectStore->SyncAllData(sessionId, onComplete);
776 EXPECT_EQ(ERR_SINGLE_DEVICE, ret);
777 ret = flatObjectStore->SyncAllData("", onComplete);
778 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
779 ret = flatObjectStore->Delete(sessionId);
780 EXPECT_EQ(SUCCESS, ret);
781 }
782
783 /**
784 * @tc.name: DistributedObject_NotifyCachedStatus_001
785 * @tc.desc: test DistributedObjectStore NotifyCachedStatus.
786 * @tc.type: FUNC
787 */
788 HWTEST_F(NativeObjectStoreTest, DistributedObject_NotifyCachedStatus_001, TestSize.Level1)
789 {
790 std::string bundleName = "default";
791 std::string sessionId = "123456";
792 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
793 EXPECT_NE(nullptr, objectStore);
794 uint32_t status = 0;
795 DistributedObject *object = objectStore->CreateObject(sessionId, status);
796 EXPECT_NE(nullptr, object);
797 EXPECT_EQ(SUCCESS, status);
798 objectStore->NotifyCachedStatus(sessionId);
799 uint32_t ret = objectStore->DeleteObject(sessionId);
800 EXPECT_EQ(SUCCESS, ret);
801 }
802
803 /**
804 * @tc.name: DistributedObject_UnWatch_001
805 * @tc.desc: test DistributedObjectStore UnWatch, DistributedObject is nullptr.
806 * @tc.type: FUNC
807 */
808 HWTEST_F(NativeObjectStoreTest, DistributedObject_UnWatch_001, TestSize.Level1)
809 {
810 std::string bundleName = "default";
811 std::string sessionId = "123456";
812 DistributedObjectStore *objectStore = DistributedObjectStore::GetInstance(bundleName);
813 EXPECT_NE(nullptr, objectStore);
814 DistributedObject *object = objectStore->CreateObject(sessionId);
815 EXPECT_NE(nullptr, object);
816 uint32_t ret = objectStore->UnWatch(nullptr);
817 EXPECT_EQ(ERR_NULL_OBJECT, ret);
818 ret = objectStore->DeleteObject(sessionId);
819 EXPECT_EQ(SUCCESS, ret);
820 }
821
822 /**
823 * @tc.name: DistributedObject_OnComplete_001
824 * @tc.desc: test FlatObjectStore OnComplete.
825 * @tc.type: FUNC
826 */
827 HWTEST_F(NativeObjectStoreTest, DistributedObject_OnComplete_001, TestSize.Level1)
828 {
829 std::string bundleName = "default";
830 std::string sessionId = "123456";
831 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
832 uint32_t ret = storageEngine->Open(bundleName);
833 EXPECT_EQ(SUCCESS, ret);
834 ret = storageEngine->CreateTable(sessionId);
835 std::shared_ptr<StatusNotifierImpl> statusWatcher = std::make_shared<StatusNotifierImpl>();
836 DistributedDB::DBStatus status = DistributedDB::DBStatus::OK;
837 std::map<std::string, DistributedDB::DBStatus> devices = { { sessionId, status } };
838 storageEngine->OnComplete(sessionId, devices, statusWatcher);
839 ret = storageEngine->DeleteTable(sessionId);
840 EXPECT_EQ(SUCCESS, ret);
841 }
842
843 /**
844 * @tc.name: DistributedObject_CreateTable_004
845 * @tc.desc: test FlatObjectStorageEngine CreateTable, sessionId is empty.
846 * @tc.type: FUNC
847 */
848 HWTEST_F(NativeObjectStoreTest, DistributedObject_CreateTable_004, TestSize.Level1)
849 {
850 std::string bundleName = "default";
851 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
852 storageEngine->Open(bundleName);
853 uint32_t ret = storageEngine->CreateTable("");
854 EXPECT_EQ(ERR_DB_GETKV_FAIL, ret);
855 }
856
857 /**
858 * @tc.name: DistributedObject_GetTable_005
859 * @tc.desc: test FlatObjectStorageEngine GetTable, storageEngine is not open or sessionId is empty.
860 * @tc.type: FUNC
861 */
862 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetTable_005, TestSize.Level1)
863 {
864 std::string bundleName = "default";
865 std::string sessionId = "123456";
866 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
867 storageEngine->Open(bundleName);
868 storageEngine->CreateTable(sessionId);
869 std::map<std::string, Value> tableResult;
870 storageEngine->isOpened_ = false;
871 uint32_t ret = storageEngine->GetTable(sessionId, tableResult);
872 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
873 storageEngine->isOpened_ = true;
874 ret = storageEngine->GetTable("", tableResult);
875 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
876 storageEngine->DeleteTable(sessionId);
877 }
878
879 /**
880 * @tc.name: DistributedObject_UpdateItem_003
881 * @tc.desc: test FlatObjectStorageEngine UpdateItem, storageEngine is not open or error sessionid.
882 * @tc.type: FUNC
883 */
884 HWTEST_F(NativeObjectStoreTest, DistributedObject_UpdateItem_001, TestSize.Level1)
885 {
886 std::string bundleName = "default";
887 std::string sessionId = "123456";
888 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
889 storageEngine->Open(bundleName);
890 storageEngine->CreateTable(sessionId);
891 storageEngine->isOpened_ = false;
892 std::vector<uint8_t> value = { 1, 8 };
893 uint32_t ret = storageEngine->UpdateItem(sessionId, "age", value);
894 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
895 storageEngine->isOpened_ = true;
896 ret = storageEngine->UpdateItem("123", "age", value);
897 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
898 storageEngine->DeleteTable(sessionId);
899 }
900
901 /**
902 * @tc.name: DistributedObject_UpdateItems_004
903 * @tc.desc: test FlatObjectStorageEngine UpdateItems, storageEngine is not open or error sessionid.
904 * @tc.type: FUNC
905 */
906 HWTEST_F(NativeObjectStoreTest, DistributedObject_UpdateItems_003, TestSize.Level1)
907 {
908 std::string bundleName = "default";
909 std::string sessionId = "123456";
910 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
911 storageEngine->Open(bundleName);
912 storageEngine->CreateTable(sessionId);
913 storageEngine->isOpened_ = false;
914 std::vector<uint8_t> value = { 1, 8 };
915 std::map<std::string, std::vector<uint8_t>> data = { { "age", value } };
916 uint32_t ret = storageEngine->UpdateItems(sessionId, data);
917 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
918
919 storageEngine->isOpened_ = true;
920 ret = storageEngine->UpdateItems("123", data);
921 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
922 storageEngine->DeleteTable(sessionId);
923 }
924
925 /**
926 * @tc.name: DistributedObject_DeleteTable_001
927 * @tc.desc: test FlatObjectStorageEngine DeleteTable, storageEngine is not open or error sessionid.
928 * @tc.type: FUNC
929 */
930 HWTEST_F(NativeObjectStoreTest, DistributedObject_DeleteTable_001, TestSize.Level1)
931 {
932 std::string bundleName = "default";
933 std::string sessionId = "123456";
934 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
935 storageEngine->Open(bundleName);
936 storageEngine->CreateTable(sessionId);
937 storageEngine->isOpened_ = false;
938 uint32_t ret = storageEngine->DeleteTable(sessionId);
939 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
940 storageEngine->isOpened_ = true;
941 ret = storageEngine->DeleteTable("123");
942 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
943 storageEngine->DeleteTable(sessionId);
944 }
945
946 /**
947 * @tc.name: DistributedObject_GetItem_002
948 * @tc.desc: test FlatObjectStorageEngine GetItem, storageEngine is not open or error key.
949 * @tc.type: FUNC
950 */
951 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetItem_002, TestSize.Level1)
952 {
953 std::string bundleName = "default";
954 std::string sessionId = "123456";
955 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
956 storageEngine->Open(bundleName);
957 storageEngine->CreateTable(sessionId);
958 storageEngine->isOpened_ = false;
959 std::vector<uint8_t> value = { 1, 8 };
960 uint32_t ret = storageEngine->GetItem(sessionId, "", value);
961 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
962 storageEngine->Open(bundleName);
963 ret = storageEngine->DeleteTable(sessionId);
964 EXPECT_EQ(SUCCESS, ret);
965 }
966
967 /**
968 * @tc.name: DistributedObject_GetItem_003
969 * @tc.desc: test FlatObjectStorageEngine GetItem, error key.
970 * @tc.type: FUNC
971 */
972 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetItem_003, TestSize.Level1)
973 {
974 std::string sessionId = "123456";
975 std::string bundleName = "default";
976 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
977 std::vector<uint8_t> value = { 1, 8 };
978 storageEngine->Open(bundleName);
979 uint32_t ret = storageEngine->GetItem(sessionId, "123", value);
980 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
981 }
982
983 /**
984 * @tc.name: DistributedObject_RegisterObserver_001
985 * @tc.desc: test FlatObjectStorageEngine RegisterObserver, storageEngine is not open.
986 * @tc.type: FUNC
987 */
988 HWTEST_F(NativeObjectStoreTest, DistributedObject_RegisterObserver_001, TestSize.Level1)
989 {
990 std::string sessionId = "123456";
991 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
992 storageEngine->isOpened_ = false;
993 auto tableWatcherPtr = std::make_shared<TableWatcherImpl>(sessionId);
994 uint32_t ret = storageEngine->RegisterObserver(sessionId, tableWatcherPtr);
995 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
996 }
997
998 /**
999 * @tc.name: DistributedObject_RegisterObserver_002
1000 * @tc.desc: test FlatObjectStorageEngine RegisterObserver, empty sessionId.
1001 * @tc.type: FUNC
1002 */
1003 HWTEST_F(NativeObjectStoreTest, DistributedObject_RegisterObserver_002, TestSize.Level1)
1004 {
1005 std::string bundleName = "default";
1006 std::string sessionId = "123456";
1007 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1008 storageEngine->Open(bundleName);
1009 storageEngine->CreateTable(sessionId);
1010 auto tableWatcherPtr = std::make_shared<TableWatcherImpl>(sessionId);
1011 uint32_t ret = storageEngine->RegisterObserver("", tableWatcherPtr);
1012 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1013 ret = storageEngine->DeleteTable(sessionId);
1014 EXPECT_EQ(SUCCESS, ret);
1015 }
1016
1017 /**
1018 * @tc.name: DistributedObject_RegisterObserver_003
1019 * @tc.desc: test FlatObjectStorageEngine RegisterObserver, repeat RegisterObserver.
1020 * @tc.type: FUNC
1021 */
1022 HWTEST_F(NativeObjectStoreTest, DistributedObject_RegisterObserver_003, TestSize.Level1)
1023 {
1024 std::string bundleName = "default";
1025 std::string sessionId = "123456";
1026 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1027 storageEngine->Open(bundleName);
1028 storageEngine->CreateTable(sessionId);
1029 auto tableWatcherPtr = std::make_shared<TableWatcherImpl>(sessionId);
1030 // RegisterObserver observer already exist
1031 uint32_t ret = storageEngine->RegisterObserver(sessionId, tableWatcherPtr);
1032 EXPECT_EQ(SUCCESS, ret);
1033 storageEngine->RegisterObserver(sessionId, tableWatcherPtr);
1034 EXPECT_EQ(SUCCESS, ret);
1035 ret = storageEngine->DeleteTable(sessionId);
1036 EXPECT_EQ(SUCCESS, ret);
1037 }
1038
1039 /**
1040 * @tc.name: DistributedObject_UnRegisterObserver_001
1041 * @tc.desc: test FlatObjectStorageEngine UnRegisterObserver, storageEngine is not open.
1042 * @tc.type: FUNC
1043 */
1044 HWTEST_F(NativeObjectStoreTest, DistributedObject_UnRegisterObserver_001, TestSize.Level1)
1045 {
1046 std::string sessionId = "123456";
1047 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1048 storageEngine->isOpened_ = false;
1049 uint32_t ret = storageEngine->UnRegisterObserver(sessionId);
1050 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
1051 }
1052
1053 /**
1054 * @tc.name: DistributedObject_UnRegisterObserver_001
1055 * @tc.desc: test FlatObjectStorageEngine UnRegisterObserver, empty sessionId.
1056 * @tc.type: FUNC
1057 */
1058 HWTEST_F(NativeObjectStoreTest, DistributedObject_UnRegisterObserver_002, TestSize.Level1)
1059 {
1060 std::string bundleName = "default";
1061 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1062 storageEngine->Open(bundleName);
1063 uint32_t ret = storageEngine->UnRegisterObserver("");
1064 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1065 }
1066
1067 /**
1068 * @tc.name: DistributedObject_SetStatusNotifier_002
1069 * @tc.desc: test FlatObjectStorageEngine SetStatusNotifier.
1070 * @tc.type: FUNC
1071 */
1072 HWTEST_F(NativeObjectStoreTest, DistributedObject_SetStatusNotifier_002, TestSize.Level1)
1073 {
1074 std::string bundleName = "default";
1075 std::string sessionId = "123456";
1076 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1077 storageEngine->Open(bundleName);
1078 storageEngine->CreateTable(sessionId);
1079 auto statusNotifier = std::make_shared<StatusNotifierImpl>();
1080 uint32_t ret = storageEngine->SetStatusNotifier(statusNotifier);
1081 EXPECT_EQ(SUCCESS, ret);
1082 ret = storageEngine->DeleteTable(sessionId);
1083 EXPECT_EQ(SUCCESS, ret);
1084 }
1085
1086 /**
1087 * @tc.name: DistributedObject_SetStatusNotifier_003
1088 * @tc.desc: test FlatObjectStorageEngine SetStatusNotifier, storageEngine is not open.
1089 * @tc.type: FUNC
1090 */
1091 HWTEST_F(NativeObjectStoreTest, DistributedObject_SetStatusNotifier_003, TestSize.Level1)
1092 {
1093 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1094 auto statusNotifier = std::make_shared<StatusNotifierImpl>();
1095 storageEngine->isOpened_ = false;
1096 uint32_t ret = storageEngine->SetStatusNotifier(statusNotifier);
1097 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
1098 }
1099
1100 /**
1101 * @tc.name: DistributedObject_GetItems_001
1102 * @tc.desc: test FlatObjectStorageEngine GetItems, storageEngine is not open or error key.
1103 * @tc.type: FUNC
1104 */
1105 HWTEST_F(NativeObjectStoreTest, DistributedObject_GetItems_001, TestSize.Level1)
1106 {
1107 std::string bundleName = "default";
1108 std::string sessionId = "123456";
1109 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1110 storageEngine->Open(bundleName);
1111 storageEngine->CreateTable(sessionId);
1112 storageEngine->isOpened_ = false;
1113 std::vector<uint8_t> value = { 1, 8 };
1114 std::map<std::string, std::vector<uint8_t>> data = { { "age", value } };
1115 uint32_t ret = storageEngine->GetItems(sessionId, data);
1116 EXPECT_EQ(ERR_DB_NOT_INIT, ret);
1117 storageEngine->Open(bundleName);
1118 ret = storageEngine->GetItems("", data);
1119 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1120 ret = storageEngine->DeleteTable(sessionId);
1121 EXPECT_EQ(SUCCESS, ret);
1122 }
1123
1124 /**
1125 * @tc.name: DistributedObject_NotifyStatus_001
1126 * @tc.desc: test FlatObjectStorageEngine NotifyStatus.
1127 * @tc.type: FUNC
1128 */
1129 HWTEST_F(NativeObjectStoreTest, DistributedObject_NotifyStatus_001, TestSize.Level1)
1130 {
1131 std::string bundleName = "default07";
1132 std::string sessionId = "123456";
1133 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1134 uint32_t ret = storageEngine->Open(bundleName);
1135 storageEngine->NotifyStatus(sessionId, "local", "restored");
1136 ret = storageEngine->Close();
1137 EXPECT_EQ(SUCCESS, ret);
1138 }
1139
1140 /**
1141 * @tc.name: DistributedObject_SyncAllData_002
1142 * @tc.desc: test FlatObjectStorageEngine SyncAllData.
1143 * @tc.type: FUNC
1144 */
1145 HWTEST_F(NativeObjectStoreTest, DistributedObject_SyncAllData_002, TestSize.Level1)
1146 {
1147 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
__anon2dca90710302(const std::map<std::string, DistributedDB::DBStatus> &) 1148 auto onComplete = [](const std::map<std::string, DistributedDB::DBStatus> &) {};
1149 std::vector<std::string> deviceIds = { "deviceIds" };
1150 uint32_t ret = storageEngine->SyncAllData("", deviceIds, onComplete);
1151 EXPECT_EQ(ERR_DB_NOT_EXIST, ret);
1152 }
1153
1154 /**
1155 * @tc.name: DistributedObject_UpdateItem_002
1156 * @tc.desc: test FlatObjectStorageEngine UpdateItem, error status.
1157 * @tc.type: FUNC
1158 */
1159 HWTEST_F(NativeObjectStoreTest, DistributedObject_UpdateItem_002, TestSize.Level1)
1160 {
1161 std::string bundleName = "default";
1162 std::string sessionId = "123456";
1163 std::shared_ptr<FlatObjectStorageEngine> storageEngine = std::make_shared<FlatObjectStorageEngine>();
1164 storageEngine->Open(bundleName);
1165 storageEngine->CreateTable(sessionId);
1166 std::vector<uint8_t> value = { 1, 2 };
1167 uint32_t ret = storageEngine->UpdateItem(sessionId, std::string(1025, 't'), value);
1168 EXPECT_EQ(ERR_CLOSE_STORAGE, ret);
1169 ret = storageEngine->DeleteTable(sessionId);
1170 EXPECT_EQ(SUCCESS, ret);
1171 }
1172 } // namespace
1173