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