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