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