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 #define LOG_TAG "disDataTest"
16
17 #include <cstdint>
18 #include <cstring>
19 #include <gtest/gtest.h>
20 #include <iostream>
21 #include <iterator>
22 #include <sstream> // 使用stringstream
23 #include <string.h>
24 #include <string>
25 #include <unistd.h>
26 #include <vector>
27
28 #include "distributed_kv_data_manager.h"
29 #include "log_print.h"
30 #include "shm_utils.h"
31 #include "types.h"
32
33 typedef enum {
34 CTRL_CODE_SOFTBUS_TYPE = 1000,
35 CTRL_CODE_SOFTBUS_OPEN_SESSION,
36 CTRL_CODE_DATAMGR_TYPE = 2000,
37 CTRL_CODE_DATAMGR_GET_DATA,
38 CTRL_CODE_DATAMGR_GET_DATA_REPLY,
39 CTRL_CODE_DATAMGR_CREATE_KV,
40 CTRL_CODE_DATAMGR_DELETE_KV,
41 CTRL_CODE_DATAMGR_PUT_DATA,
42 CTRL_CODE_DATAMGR_DELETE_DATA,
43 CTRL_CODE_DM_TYPE = 3000,
44 CTRL_CODE_FILEMGR_TYPE = 4000,
45 CTRL_CODE_DP_TYPE = 5000,
46 CTRL_CODE_SEC_TYPE = 6000,
47 CTRL_CODE_MEDIA_TYPE = 7000,
48 CTRL_CODE_RESULT_TYPE = 9999,
49 } CtrlCodeType;
50
51 #define MAX_DATA_LENGTH 1024
52
53 using namespace testing::ext;
54 using namespace OHOS::DistributedKv;
55 namespace {
56 const int USLEEP_TIME = 2000000;
57 }
58
59 class DeathRecipient : public KvStoreDeathRecipient {
60 public:
DeathRecipient()61 DeathRecipient() {}
~DeathRecipient()62 virtual ~DeathRecipient() {}
OnRemoteDied()63 virtual void OnRemoteDied() override
64 {
65 std::cout << "server is dead" << std::endl;
66 }
67 };
68
69 class DistributedKvDataManagerTest : public testing::Test {
70 public:
71 static void SetUpTestCase(void);
72 static void TearDownTestCase(void);
73 void SetUp();
74 void TearDown();
75
76 static const uint32_t CHECK_WAITING_TIME = 50000; // 50ms
77 static void RemoveAllStore(DistributedKvDataManager manager);
78
79 DistributedKvDataManagerTest();
80 };
81
82 class DisKvTest {
83 public:
84 static DistributedKvDataManager manager;
85 static std::shared_ptr<SingleKvStore> KvStorePtr; // declare kvstore instance.
86 static Status statusGetKvStore;
87 static Status statusCloseKvStore;
88 static Status statusDeleteKvStore;
89 static Options create;
90 static UserId userId;
91 static AppId appId;
92 static StoreId storeIdTest;
93 };
94
95 DistributedKvDataManager DisKvTest::manager;
96 std::shared_ptr<SingleKvStore> DisKvTest::KvStorePtr = nullptr; // declare kvstore instance.
97 Status DisKvTest::statusGetKvStore = Status::ERROR;
98 Status DisKvTest::statusCloseKvStore = Status::ERROR;
99 Status DisKvTest::statusDeleteKvStore = Status::ERROR;
100 UserId DisKvTest::userId;
101 AppId DisKvTest::appId;
102 StoreId DisKvTest::storeIdTest;
103
SetUpTestCase(void)104 void DistributedKvDataManagerTest::SetUpTestCase(void)
105 {
106 //连接共享内存
107 createShm(SHM_SEND_KEY);
108 }
109
TearDownTestCase(void)110 void DistributedKvDataManagerTest::TearDownTestCase(void)
111 {
112 //解关联共享内存
113 disconnectShm();
114 }
115
SetUp(void)116 void DistributedKvDataManagerTest::SetUp(void)
117 {
118 DisKvTest::userId.userId = "account0";
119 DisKvTest::appId.appId = "com.ohos.kvdatamanager3.test";
120 DisKvTest::storeIdTest.storeId = "test3";
121
122 Options options { .createIfMissing = true,
123 .encrypt = false, // .persistant = true,
124 .autoSync = false,
125 .backup = false,
126 .kvStoreType = KvStoreType::SINGLE_VERSION };
127
128 // 1.本地删除数据库
129 RemoveAllStore(DisKvTest::manager);
130
131 // 2.远端删除数据库
132 char* str1 = (char*)malloc(MAX_DATA_LENGTH);
133 memset_s(str1, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
134 strcpy_s(str1, strlen("") + 1, "");
135 writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_KV, str1);
136
137 char code[10] = { "9999" };
138 memset_s(str1, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
139 memset_s(code, 10, 0, 10);
140 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str1)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str1));
141 memset_s(str1, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
142 waitDataWithCode(code, str1);
143
144 free(str1);
145
146 // 1.本地创建数据库
147 auto deathRecipient = std::make_shared<DeathRecipient>();
148 DisKvTest::manager.RegisterKvStoreServiceDeathRecipient(deathRecipient);
149
150 DisKvTest::statusGetKvStore = DisKvTest::manager.GetSingleKvStore(
151 options, { DisKvTest::appId }, { DisKvTest::storeIdTest }, DisKvTest::KvStorePtr);
152
153 // 2. 远端创建数据库
154 str1 = (char*)malloc(MAX_DATA_LENGTH);
155 memset_s(str1, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
156 strcpy_s(str1, strlen("") + 1, "");
157 writeCodeDataToShm(CTRL_CODE_DATAMGR_CREATE_KV, str1);
158
159 memset_s(str1, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
160 memset_s(code, 10, 0, 10);
161 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str1)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str1));
162 waitDataWithCode(code, str1);
163 free(str1);
164 }
165
TearDown(void)166 void DistributedKvDataManagerTest::TearDown(void)
167 {
168 // //1.本地删除数据库
169 // RemoveAllStore(DisKvTest::manager);
170
171 // //2.远端删除数据库
172 // char* str1 =(char *)malloc(MAX_DATA_LENGTH);
173 // memset_s(str1,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
174 // strcpy_s(str1,"");
175 // writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_KV, str1);
176
177 // char code[10]={"9999"};
178 // memset_s(str1,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
179 // strcpy_s(code, Int2String(CTRL_CODE_RESULT_TYPE,str1));
180 // memset_s(str1,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
181 // waitDataWithCode(code, str1);
182
183 // free(str1);
184 }
185
RemoveAllStore(DistributedKvDataManager manager)186 void DistributedKvDataManagerTest::RemoveAllStore(DistributedKvDataManager manager)
187 {
188 DisKvTest::statusCloseKvStore = DisKvTest::manager.CloseAllKvStore(DisKvTest::appId);
189 DisKvTest::statusDeleteKvStore = DisKvTest::manager.DeleteAllKvStore(DisKvTest::appId);
190 }
191
DistributedKvDataManagerTest(void)192 DistributedKvDataManagerTest::DistributedKvDataManagerTest(void) {}
193
194 class KvStoreSyncCallbackTestImpl : public KvStoreSyncCallback {
195 public:
196 void SyncCompleted(const std::map<std::string, Status>& results);
197 };
198
SyncCompleted(const std::map<std::string,Status> & results)199 void KvStoreSyncCallbackTestImpl::SyncCompleted(const std::map<std::string, Status>& results)
200 {
201 // std::cout<<"KvStoreSyncCallbackTestImpl timestamp:"<< getCurrentLocalTimeStamp() << std::endl;
202 std::cout << "KvStoreSyncCallbackTestImpl timestamp:" << std::endl;
203 for (const auto& result : results) {
204 std::cout << result.first << " " << static_cast<int>(result.second) << std::endl;
205 }
206 }
207
208 /**
209 * @tc.number: DistribitedKvDataManager_Sync_Push_0100
210 * @tc.name: DistribitedKvDataManagerTest sync push
211 * @tc.desc: sync push, put int data
212 * @tc.type: FUNC
213 */
214 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Push_0100, TestSize.Level1 | Function | MediumTest)
215 {
216 ZLOGI("DistribitedKvDataManager_Sync_Push_0100 begin.");
217 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
218 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
219
220 //本地数据库添加数据 100
221 std::string stringKey = "math_score_int";
222 Key keyInt = stringKey;
223 // int nint = 100;
224 Value valueInt = Value(TransferTypeToByteArray<int>(100));
225 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
226 EXPECT_EQ(Status::SUCCESS, status);
227
228 //同步数据到远端
229 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
230 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
231 EXPECT_EQ(status, Status::SUCCESS);
232
233 std::vector<std::string> deviceList;
234 for (const auto& device : remoteDevice) {
235 std::cout << "start sync" << device.deviceId << std::endl;
236 deviceList.push_back(device.deviceId);
237 }
238
239 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
240 ASSERT_EQ(status, Status::SUCCESS);
241
242 char strKV[MAX_DATA_LENGTH] = { "math" };
243 memset_s(strKV, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
244 strcpy_s(strKV, strlen("math_score_int:100") + 1, "math_score_int:100");
245 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); // 2001:math_score_int:10
246 char str[MAX_DATA_LENGTH] = { 0 };
247 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
248 char code[10] = { 0 };
249 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
250
251 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
252 waitDataWithCode(code, str);
253 std::cout << "int 100 get result=" << str << std::endl;
254
255 //检查远端是否返回成功
256 int ret = strcmp(str, "0");
257 // ret = 0;
258 EXPECT_EQ(ret, 0);
259 }
260
261 /**
262 * @tc.number: DistribitedKvDataManager_Sync_Push_0200
263 * @tc.name: DistribitedKvDataManagerTest sync push
264 * @tc.desc: sync push, put float data
265 * @tc.type: FUNC
266 */
267 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Push_0200, TestSize.Level1)
268 {
269 ZLOGI("DistribitedKvDataManager_Sync_Push_0200 begin.");
270 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
271 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
272
273 //////////////////////////////////////////////////////////////////////////////////////////////
274 //本地数据库添加数据 3.14f
275 std::string stringKey = "math_score_float";
276 Key keyInt = stringKey;
277 // float nfloat = 3.14f;
278 Value valueInt = Value(TransferTypeToByteArray<float>(3.14f));
279 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
280 EXPECT_EQ(Status::SUCCESS, status);
281
282 //同步数据到远端
283 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
284 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
285 EXPECT_EQ(status, Status::SUCCESS);
286
287 std::vector<std::string> deviceList;
288 for (const auto& device : remoteDevice) {
289 std::cout << "start sync" << device.deviceId << std::endl;
290 deviceList.push_back(device.deviceId);
291 }
292
293 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
294 ASSERT_EQ(status, Status::SUCCESS);
295
296 char strKV[MAX_DATA_LENGTH] = { "math" };
297 memset_s(strKV, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
298 strcpy_s(strKV, strlen("math_score_float:3.14") + 1, "math_score_float:3.14");
299
300 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); // 2001:math_score_int:10
301 char str[MAX_DATA_LENGTH] = { 0 };
302 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
303 char code[10] = { 0 };
304 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
305
306 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
307 waitDataWithCode(code, str);
308 std::cout << " float 3.14f get result=" << str << std::endl;
309
310 //检查远端是否返回成功
311
312 int ret = strcmp(str, "0");
313 EXPECT_EQ(ret, 0);
314 }
315
316 /**
317 * @tc.number: DistribitedKvDataManager_Sync_Push_0300
318 * @tc.name: DistribitedKvDataManagerTest sync push
319 * @tc.desc: sync push, put double data
320 * @tc.type: FUNC
321 */
322 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Push_0300, TestSize.Level1)
323 {
324 ZLOGI("DistribitedKvDataManager_Sync_Push_0300 begin.");
325 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
326 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
327
328 //////////////////////////////////////////////////////////////////////////////////////////////
329 //本地数据库添加数据 28.288f
330 std::string stringKey = "math_score_double";
331 Key keyInt = stringKey;
332 // double nfloat = 28.288f;
333 Value valueInt = Value(TransferTypeToByteArray<double>(28.288f));
334 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
335 EXPECT_EQ(Status::SUCCESS, status);
336
337 //同步数据到远端
338 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
339 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
340 EXPECT_EQ(status, Status::SUCCESS);
341
342 std::vector<std::string> deviceList;
343 for (const auto& device : remoteDevice) {
344 std::cout << "start sync" << device.deviceId << std::endl;
345 deviceList.push_back(device.deviceId);
346 }
347
348 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
349 ASSERT_EQ(status, Status::SUCCESS);
350
351 char strKV[MAX_DATA_LENGTH] = { "math" };
352 memset_s(strKV, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
353 strcpy_s(strKV, strlen("math_score_double:28.288") + 1, "math_score_double:28.288");
354
355 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); // 2001:math_score_int:10
356 char str[MAX_DATA_LENGTH] = { 0 };
357 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
358 char code[10] = { 0 };
359 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
360
361 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
362 waitDataWithCode(code, str);
363 std::cout << "<double>(28.288f) get result=" << str << std::endl;
364
365 //检查远端是否返回成功
366 int ret = strcmp(str, "0");
367 EXPECT_EQ(ret, 0);
368 }
369
370 /**
371 * @tc.number: DistribitedKvDataManager_Sync_Push_0400
372 * @tc.name: DistribitedKvDataManagerTest sync push
373 * @tc.desc: sync push, put int64_t data
374 * @tc.type: FUNC
375 */
376 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Push_0400, TestSize.Level1)
377 {
378 ZLOGI("DistribitedKvDataManager_Sync_Push_0400 begin.");
379 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
380 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
381
382 //本地数据库添加数据 12345678
383 Key keyInt = "math_score_int64_t";
384 Value valueInt = Value(TransferTypeToByteArray<int64_t>(12345678));
385 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
386 EXPECT_EQ(Status::SUCCESS, status);
387
388 //同步数据到远端
389 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
390 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
391 EXPECT_EQ(status, Status::SUCCESS);
392
393 std::vector<std::string> deviceList;
394 for (const auto& device : remoteDevice) {
395 std::cout << "start sync" << device.deviceId << std::endl;
396 deviceList.push_back(device.deviceId);
397 }
398
399 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
400 ASSERT_EQ(status, Status::SUCCESS);
401
402 //数据发送到远端并等待返回结果
403 char strKV[MAX_DATA_LENGTH] = { "math" };
404 memset_s(strKV, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
405 strcpy_s(strKV, strlen("math_score_int64_t:12345678") + 1, "math_score_int64_t:12345678");
406
407 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); // 2001:math_score_int:10
408 char str[MAX_DATA_LENGTH] = { 0 };
409 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
410 char code[10] = { 0 };
411 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
412
413 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
414 waitDataWithCode(code, str);
415 std::cout << " <int64_t>(12345678) get result=" << str << std::endl;
416
417 //检查远端是否返回成功
418 int ret = strcmp(str, "0");
419 EXPECT_EQ(ret, 0);
420 }
421
422 /**
423 * @tc.number: DistribitedKvDataManager_Sync_Push_0500
424 * @tc.name: DistribitedKvDataManagerTest sync push
425 * @tc.desc: sync push, put size_t data
426 * @tc.type: FUNC
427 */
428 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Push_0500, TestSize.Level1)
429 {
430 ZLOGI("DistribitedKvDataManager_Sync_Push_0500 begin.");
431 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
432 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
433
434 //本地数据库添加数据 28
435 Key keyInt = "math_score_size_t";
436 Value valueInt = Value(TransferTypeToByteArray<size_t>(28));
437 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
438 EXPECT_EQ(Status::SUCCESS, status);
439
440 //同步数据到远端
441 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
442 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
443 EXPECT_EQ(status, Status::SUCCESS);
444
445 std::vector<std::string> deviceList;
446 for (const auto& device : remoteDevice) {
447 std::cout << "start sync" << device.deviceId << std::endl;
448 deviceList.push_back(device.deviceId);
449 }
450
451 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
452 ASSERT_EQ(status, Status::SUCCESS);
453
454 //数据发送到远端并等待返回结果
455 char strKV[MAX_DATA_LENGTH] = { "math" };
456 memset_s(strKV, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
457 strcpy_s(strKV, strlen("math_score_size_t:28") + 1, "math_score_size_t:28");
458
459 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV); // 2001:math_score_int:10
460 char str[MAX_DATA_LENGTH] = { 0 };
461 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
462 char code[10] = { 0 };
463 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
464
465 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
466 waitDataWithCode(code, str);
467 std::cout << " <size_t>(28) get result=" << str << std::endl;
468
469 //检查远端是否返回成功
470 int ret = strcmp(str, "0");
471 EXPECT_EQ(ret, 0);
472 }
473
474 /**
475 * @tc.number: DistribitedKvDataManager_Sync_Push_0600
476 * @tc.name: DistribitedKvDataManagerTest sync push
477 * @tc.desc: sync push, put string data
478 * @tc.type: FUNC
479 */
480 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Push_0600, TestSize.Level1)
481 {
482 ZLOGI("DistribitedKvDataManager_Sync_Push_0600 begin.");
483 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
484 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
485
486 //本地数据库添加数据string
487 Key keyInt = "math_score_string";
488 Value valueInt = Value("{\"class\":20, \"age\":18, \"gradle\":\"good\"}");
489 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
490 EXPECT_EQ(Status::SUCCESS, status);
491
492 //同步数据到远端
493 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
494 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
495 EXPECT_EQ(status, Status::SUCCESS);
496
497 std::vector<std::string> deviceList;
498 for (const auto& device : remoteDevice) {
499 std::cout << "start sync" << device.deviceId << std::endl;
500 deviceList.push_back(device.deviceId);
501 }
502
503 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
504 ASSERT_EQ(status, Status::SUCCESS);
505
506 //数据发送到远端并等待返回结果
507 char str[MAX_DATA_LENGTH] = { "math_score_string:{\"class\":20, \"age\":18, \"gradle\":\"good\"}" };
508 // strcpy_s(str, strlen("math_score_int:d")+1, "math_score_int:d");
509
510 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, str); // 2001:math_score_int:10
511 // char str[MAX_DATA_LENGTH] = {0};
512 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
513 char code[10] = { 0 };
514 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
515
516 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
517 waitDataWithCode(code, str);
518 std::cout << "string get result=" << str << std::endl;
519
520 //检查远端是否返回成功
521 int ret = strcmp(str, "0");
522 EXPECT_EQ(ret, 0);
523 }
524
525 /**
526 * @tc.number: DistribitedKvDataManager_Sync_Push_0700
527 * @tc.name: DistribitedKvDataManagerTest sync push
528 * @tc.desc: sync push, put vector<uint8_t> data
529 * @tc.type: FUNC
530 */
531 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Push_0700, TestSize.Level1)
532 {
533 ZLOGI("DistribitedKvDataManager_Sync_Push_0700 begin.");
534 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
535 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
536
537 // 1.///////////////////////////////////////////////////////////////////////////////////////////////////////
538 //本地数据库添加数据 vector<int>
539 std::string stringKey = "math_score_vector";
540 Key keyInt = stringKey;
541 std::vector<uint8_t> vect = { 0, 1, 2, 3, 4, 5, 6, 7 };
542 Value valueInt = Value(vect);
543 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
544 EXPECT_EQ(Status::SUCCESS, status);
545
546 //同步数据到远端
547 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
548 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
549 EXPECT_EQ(status, Status::SUCCESS);
550
551 std::vector<std::string> deviceList;
552 for (const auto& device : remoteDevice) {
553 std::cout << "start sync" << device.deviceId << std::endl;
554 deviceList.push_back(device.deviceId);
555 }
556
557 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
558 ASSERT_EQ(status, Status::SUCCESS);
559
560 usleep(USLEEP_TIME);
561
562 //数据发送到远端并等待返回结果
563 // std::vector<uint8_t> vect = {0,1,2,3,4,5,6,0};
564 std::string strvc;
565 strvc.assign(vect.begin(), vect.end());
566
567 char strKV[MAX_DATA_LENGTH] = { "math_score_int" };
568 strcpy_s(strKV, strlen(stringKey.c_str()) + 1, stringKey.c_str());
569 strcat_s(strKV, MAX_DATA_LENGTH, ":");
570 strcat_s(strKV, MAX_DATA_LENGTH, strvc.c_str());
571
572 std::cout << "strvc = " << strvc << std::endl;
573 std::cout << "strvc.c_str() = " << strvc.c_str() << std::endl;
574 std::cout << "strKV = " << strKV << std::endl;
575
576 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);
577 char str[MAX_DATA_LENGTH] = { 0 };
578 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
579 char code[10] = { "9999" };
580 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
581
582 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
583 waitDataWithCode(code, str);
584 std::cout << "vector<int> get result=" << str << std::endl;
585
586 //检查远端是否返回成功
587 int ret = strcmp(str, "0");
588 EXPECT_EQ(ret, 0);
589 }
590
591 /**
592 * @tc.number: DistribitedKvDataManager_Sync_Pull_0100
593 * @tc.name: remote put data, local sync pull
594 * @tc.desc: sync pull, put int data
595 * @tc.type: FUNC
596 */
597 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0100, TestSize.Level1)
598 {
599 ZLOGI("DistribitedKvDataManager_Sync_Pull_0100 begin.");
600 // 1.本端创建KV
601 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
602 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
603
604 // 2.创建远端KV
605 // 3. 本地数据库添加数据 100
606 Key keyInt = "math_score_int";
607 Value valueInt = Value(TransferTypeToByteArray<int>(100));
608 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
609 EXPECT_EQ(Status::SUCCESS, status);
610
611 // 4. sync push 同步数据到远端
612 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
613 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
614 EXPECT_EQ(status, Status::SUCCESS);
615
616 std::vector<std::string> deviceList;
617 for (const auto& device : remoteDevice) {
618 std::cout << "start sync" << device.deviceId << std::endl;
619 deviceList.push_back(device.deviceId);
620 }
621 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
622 ASSERT_EQ(status, Status::SUCCESS);
623
624 // 5.远端修改数据200
625 // char strPut[MAX_DATA_LENGTH] = {"math_score_int:200"};
626 char strKV[MAX_DATA_LENGTH] = { "math" };
627 memset_s(strKV, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
628 strcpy_s(strKV, strlen("math_score_int:200") + 1, "math_score_int:200");
629 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
630
631 char str[MAX_DATA_LENGTH] = { 0 };
632 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
633 char code[10] = { 0 };
634 memset_s(code, 10, 0, 10);
635 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
636
637 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
638 waitDataWithCode(code, str);
639 std::cout << " put-200 get result=" << str << std::endl;
640
641 //检查远端是否返回成功
642 int ret = strcmp(str, "0");
643 EXPECT_EQ(ret, 0);
644
645 // 6.本地pull远端数据
646 // std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
647 remoteDevice.clear();
648 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
649 EXPECT_EQ(status, Status::SUCCESS);
650
651 // std::vector<std::string> deviceList;
652 deviceList.clear();
653 for (const auto& device : remoteDevice) {
654 std::cout << "start sync" << device.deviceId << std::endl;
655 deviceList.push_back(device.deviceId);
656 }
657 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PULL); // PUSH_PULL
658 EXPECT_EQ(status, Status::SUCCESS);
659
660 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
661 status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
662 EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
663 if (status == Status::SUCCESS) {
664 std::cout << "LOGdisDataTest--SUCCESS: register sync callback" << std::endl;
665 } else {
666 std::cout << "LOGdisDataTest--FAIL: register sync callback" << static_cast<int>(status) << std::endl;
667 }
668
669 // 7.本地get数据 与200比较
670 usleep(USLEEP_TIME);
671
672 Value valueRetInt;
673 status = DisKvTest::KvStorePtr->Get("math_score_int", valueRetInt);
674 EXPECT_EQ(status, Status::SUCCESS);
675 int aaa = TransferByteArrayToType<int>(valueRetInt.Data());
676 EXPECT_EQ(aaa, 200);
677
678 // 8.数据发送到远端并等待返回结果
679 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);
680
681 // char str[MAX_DATA_LENGTH] = {0};
682 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
683 memset_s(code, 10, 0, 10);
684 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
685
686 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
687 waitDataWithCode(code, str);
688 std::cout << " get-200 get result=" << str << std::endl;
689
690 //检查远端是否返回成功
691 ret = strcmp(str, "0");
692 EXPECT_EQ(ret, 0);
693
694 //解注册回调
695 status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
696 EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
697 }
698
699 /**
700 * @tc.number: DistribitedKvDataManager_Sync_Pull_0200
701 * @tc.name: remote put data, local sync pull
702 * @tc.desc: sync pull, put float data
703 * @tc.type: FUNC
704 */
705 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0200, TestSize.Level1)
706 {
707 ZLOGI("DistribitedKvDataManager_Sync_Pull_0200 begin.");
708 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
709 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
710
711 // 2.创建远端Lv
712 // 3. 本地数据库添加数据 100
713 std::string stringKey = "math_score_float";
714 Key keyInt = stringKey;
715 // float nfloat = 3.14f;
716 Value valueInt = Value(TransferTypeToByteArray<float>(3.14f));
717
718 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
719 EXPECT_EQ(Status::SUCCESS, status);
720
721 // 4. sync push 同步数据到远端
722 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
723 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
724 EXPECT_EQ(status, Status::SUCCESS);
725
726 std::vector<std::string> deviceList;
727 for (const auto& device : remoteDevice) {
728 std::cout << "start sync" << device.deviceId << std::endl;
729 deviceList.push_back(device.deviceId);
730 }
731 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
732 ASSERT_EQ(status, Status::SUCCESS);
733
734 // 5.远端修改数据200
735
736 char strKV[MAX_DATA_LENGTH] = { "math" };
737 memset_s(strKV, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
738 strcpy_s(strKV, strlen("math_score_float:9.99") + 1, "math_score_float:9.99");
739
740 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
741
742 char str[MAX_DATA_LENGTH] = { 0 };
743 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
744 char code[10] = { 0 };
745 memset_s(code, 10, 0, 10);
746 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
747
748 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
749 waitDataWithCode(code, str);
750 std::cout << "put-9.99 get result=" << str << std::endl;
751
752 //检查远端是否返回成功
753 int ret = strcmp(str, "0");
754 EXPECT_EQ(ret, 0);
755
756 // 6.本地pull远端数据
757 // std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
758 remoteDevice.clear();
759 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
760 EXPECT_EQ(status, Status::SUCCESS);
761
762 // std::vector<std::string> deviceList;
763 deviceList.clear();
764 for (const auto& device : remoteDevice) {
765 std::cout << "start sync" << device.deviceId << std::endl;
766 deviceList.push_back(device.deviceId);
767 }
768 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PULL);
769 EXPECT_EQ(status, Status::SUCCESS);
770
771 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
772 status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
773 EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
774 if (status == Status::SUCCESS) {
775 std::cout << "LOGdisDataTest--SUCCESS: register sync callback" << std::endl;
776 } else {
777 std::cout << "LOGdisDataTest--FAIL: register sync callback" << static_cast<int>(status) << std::endl;
778 }
779
780 // 7.本地get数据 与200比较
781 usleep(USLEEP_TIME);
782
783 Value valueRetInt;
784 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
785 EXPECT_EQ(status, Status::SUCCESS);
786 float aaa = TransferByteArrayToType<float>(valueRetInt.Data());
787 float delta = aaa - 9.99f;
788 EXPECT_LE(std::abs(delta), 0.00001);
789
790 // 8.数据发送到远端并等待返回结果
791 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);
792
793 // char str[MAX_DATA_LENGTH] = {0};
794 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
795 memset_s(code, 10, 0, 10);
796 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
797
798 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
799 waitDataWithCode(code, str);
800 std::cout << "get-9.99 get result=" << str << std::endl;
801
802 //检查远端是否返回成功
803 ret = strcmp(str, "0");
804 EXPECT_EQ(ret, 0);
805
806 //解注册回调
807 status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
808 EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
809 }
810
811 /**
812 * @tc.number: DistribitedKvDataManager_Sync_Pull_0300
813 * @tc.name: remote put data, local sync pull
814 * @tc.desc: sync pull, put double data
815 * @tc.type: FUNC
816 */
817 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0300, TestSize.Level1)
818 {
819 ZLOGI("DistribitedKvDataManager_Sync_Pull_0300 begin.");
820 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
821 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
822
823 // 2.创建远端Lv
824 // 3. 本地数据库添加数据28.288f
825 std::string stringKey = "math_score_double";
826 Key keyInt = stringKey;
827 // double nfloat = 28.288;
828 Value valueInt = Value(TransferTypeToByteArray<double>(28.288));
829
830 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
831 EXPECT_EQ(Status::SUCCESS, status);
832
833 // 4. sync push 同步数据到远端
834 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
835 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
836 EXPECT_EQ(status, Status::SUCCESS);
837
838 std::vector<std::string> deviceList;
839 for (const auto& device : remoteDevice) {
840 std::cout << "start sync" << device.deviceId << std::endl;
841 deviceList.push_back(device.deviceId);
842 }
843 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
844 ASSERT_EQ(status, Status::SUCCESS);
845
846 // 5.远端修改数据
847
848 char strKV[MAX_DATA_LENGTH] = { "math_score_double:999.999" };
849 // memset_s(strKV,MAX_DATA_LENGTH,0,MAX_DATA_LENGTH);
850 // strcpy_s(strKV, strlen("math_score_double:999.999")+1, "math_score_double:999.999");
851
852 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
853 char str[MAX_DATA_LENGTH] = { 0 };
854 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
855 char code[10] = { "9999" };
856 memset_s(code, 10, 0, 10);
857 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
858
859 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
860 waitDataWithCode(code, str);
861 std::cout << "put double get result=" << str << std::endl;
862
863 //检查远端是否返回成功
864 int ret = strcmp(str, "0");
865 EXPECT_EQ(ret, 0);
866
867 // 6.本地pull远端数据
868 // std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
869 remoteDevice.clear();
870 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
871 EXPECT_EQ(status, Status::SUCCESS);
872
873 // std::vector<std::string> deviceList;
874 deviceList.clear();
875 for (const auto& device : remoteDevice) {
876 std::cout << "start sync" << device.deviceId << std::endl;
877 deviceList.push_back(device.deviceId);
878 }
879 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PULL);
880 EXPECT_EQ(status, Status::SUCCESS);
881
882 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
883 status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
884 EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
885 if (status == Status::SUCCESS) {
886 std::cout << "LOGdisDataTest--SUCCESS: register sync callback" << std::endl;
887 } else {
888 std::cout << "LOGdisDataTest--FAIL: register sync callback" << static_cast<int>(status) << std::endl;
889 }
890
891 // 7.本地get数据 与200比较
892 usleep(USLEEP_TIME);
893
894 Value valueRetInt;
895 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
896 EXPECT_EQ(status, Status::SUCCESS);
897 double aaa = TransferByteArrayToType<double>(valueRetInt.Data());
898 double delta = aaa - 999.999;
899 std::cout << "aaa = " << aaa << std::endl;
900 std::cout << "delta = " << delta << std::endl;
901 EXPECT_LE(std::abs(delta), 0.00001);
902
903 // 8.数据发送到远端并等待返回结果
904 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);
905
906 // char str[MAX_DATA_LENGTH] = {0};
907 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
908 // char code[10]={"9999"};
909 memset_s(code, 10, 0, 10);
910 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
911
912 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
913 waitDataWithCode(code, str);
914 std::cout << "put double get result=" << str << std::endl;
915
916 //检查远端是否返回成功
917 ret = strcmp(str, "0");
918 EXPECT_EQ(ret, 0);
919
920 //解注册回调
921 status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
922 EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
923 }
924
925 /**
926 * @tc.number: DistribitedKvDataManager_Sync_Pull_0400
927 * @tc.name: remote put data, local sync pull
928 * @tc.desc: sync pull, put int64_t data
929 * @tc.type: FUNC
930 */
931 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0400, TestSize.Level1)
932 {
933 ZLOGI("DistribitedKvDataManager_Sync_Pull_0400 begin.");
934 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
935 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
936
937 // 2.创建远端Lv
938 // 3. 本地数据库添加数据 100
939 Key keyInt = "math_score_int64_t";
940 Value valueInt = Value(TransferTypeToByteArray<int64_t>(12345678));
941 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
942 EXPECT_EQ(Status::SUCCESS, status);
943
944 // 4. sync push 同步数据到远端
945 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
946 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
947 EXPECT_EQ(status, Status::SUCCESS);
948
949 std::vector<std::string> deviceList;
950 for (const auto& device : remoteDevice) {
951 std::cout << "start sync" << device.deviceId << std::endl;
952 deviceList.push_back(device.deviceId);
953 }
954 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
955 ASSERT_EQ(status, Status::SUCCESS);
956
957 // 5.远端修改数据200
958 // char strPut[MAX_DATA_LENGTH] = {"math_score_int:99889988"};
959 char strKV[MAX_DATA_LENGTH] = { "math" };
960 memset_s(strKV, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
961 strcpy_s(strKV, strlen("math_score_int64_t:99889988") + 1, "math_score_int64_t:99889988");
962
963 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
964 char str[MAX_DATA_LENGTH] = { 0 };
965 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
966 char code[10] = { 0 };
967 memset_s(code, 10, 0, 10);
968 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
969
970 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
971 waitDataWithCode(code, str);
972 std::cout << "put-200 get result=" << str << std::endl;
973
974 //检查远端是否返回成功
975 int ret = strcmp(str, "0");
976 EXPECT_EQ(ret, 0);
977
978 // 6.本地pull远端数据
979 // std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
980 remoteDevice.clear();
981 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
982 EXPECT_EQ(status, Status::SUCCESS);
983
984 // std::vector<std::string> deviceList;
985 deviceList.clear();
986 for (const auto& device : remoteDevice) {
987 std::cout << "start sync" << device.deviceId << std::endl;
988 deviceList.push_back(device.deviceId);
989 }
990 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PULL);
991 EXPECT_EQ(status, Status::SUCCESS);
992 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
993 status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
994 EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
995 if (status == Status::SUCCESS) {
996 std::cout << "LOGdisDataTest--SUCCESS: register sync callback" << std::endl;
997 } else {
998 std::cout << "LOGdisDataTest--FAIL: register sync callback" << static_cast<int>(status) << std::endl;
999 }
1000
1001 // 7.本地get数据 与200比较
1002 usleep(USLEEP_TIME);
1003
1004 Value valueRetInt;
1005 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
1006 EXPECT_EQ(status, Status::SUCCESS);
1007 int64_t aaa = TransferByteArrayToType<int64_t>(valueRetInt.Data());
1008 EXPECT_EQ(aaa, 99889988u);
1009
1010 // 8.数据发送到远端并等待返回结果
1011 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);
1012
1013 // char str[MAX_DATA_LENGTH] = {0};
1014 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1015 memset_s(code, 10, 0, 10);
1016 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1017
1018 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1019 waitDataWithCode(code, str);
1020 std::cout << "put int64_t get result=" << str << std::endl;
1021
1022 //检查远端是否返回成功
1023 ret = strcmp(str, "0");
1024 EXPECT_EQ(ret, 0);
1025
1026 //解注册回调
1027 status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
1028 EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
1029 }
1030
1031 /**
1032 * @tc.number: DistribitedKvDataManager_Sync_Pull_0500
1033 * @tc.name: remote put data, local sync pull
1034 * @tc.desc: sync pull, put size_t data
1035 * @tc.type: FUNC
1036 */
1037 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0500, TestSize.Level1)
1038 {
1039 ZLOGI("DistribitedKvDataManager_Sync_Pull_0100 begin.");
1040 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
1041 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
1042
1043 // 2.创建远端Lv
1044 // 3. 本地数据库添加数据 100
1045 Key keyInt = "math_score_size_t";
1046 Value valueInt = Value(TransferTypeToByteArray<size_t>(28));
1047 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
1048 EXPECT_EQ(Status::SUCCESS, status);
1049
1050 // 4. sync push 同步数据到远端
1051 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1052 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1053 EXPECT_EQ(status, Status::SUCCESS);
1054
1055 std::vector<std::string> deviceList;
1056 for (const auto& device : remoteDevice) {
1057 std::cout << "start sync" << device.deviceId << std::endl;
1058 deviceList.push_back(device.deviceId);
1059 }
1060 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
1061 ASSERT_EQ(status, Status::SUCCESS);
1062
1063 // 5.远端修改数据200
1064 // char strPut[MAX_DATA_LENGTH] = {"math_score_int:88"};
1065 char strKV[MAX_DATA_LENGTH] = { "math" };
1066 memset_s(strKV, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1067 strcpy_s(strKV, strlen("math_score_size_t:88") + 1, "math_score_size_t:88");
1068
1069 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
1070 char str[MAX_DATA_LENGTH] = { 0 };
1071 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1072 char code[10] = { 0 };
1073 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1074
1075 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1076 waitDataWithCode(code, str);
1077 std::cout << "size_t get result=" << str << std::endl;
1078 //检查远端是否返回成功
1079 int ret = strcmp(str, "0");
1080 EXPECT_EQ(ret, 0);
1081
1082 // 6.本地pull远端数据
1083 // std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1084 remoteDevice.clear();
1085 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1086 EXPECT_EQ(status, Status::SUCCESS);
1087
1088 // std::vector<std::string> deviceList;
1089 deviceList.clear();
1090 for (const auto& device : remoteDevice) {
1091 std::cout << "start sync" << device.deviceId << std::endl;
1092 deviceList.push_back(device.deviceId);
1093 }
1094 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PULL);
1095 EXPECT_EQ(status, Status::SUCCESS);
1096 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
1097 status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
1098 EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
1099 if (status == Status::SUCCESS) {
1100 std::cout << "LOGdisDataTest--SUCCESS: register sync callback" << std::endl;
1101 } else {
1102 std::cout << "LOGdisDataTest--FAIL: register sync callback" << static_cast<int>(status) << std::endl;
1103 }
1104
1105 // 7.本地get数据 与200比较
1106 usleep(USLEEP_TIME);
1107
1108 Value valueRetInt;
1109 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
1110 EXPECT_EQ(status, Status::SUCCESS);
1111 size_t aaa = TransferByteArrayToType<size_t>(valueRetInt.Data());
1112 EXPECT_EQ(aaa, 88u);
1113
1114 // 8.数据发送到远端并等待返回结果
1115 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);
1116
1117 // char str[MAX_DATA_LENGTH] = {0};
1118 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1119 memset_s(code, 10, 0, 10);
1120 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1121
1122 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1123 waitDataWithCode(code, str);
1124 std::cout << "get size_t result=" << str << std::endl;
1125
1126 //检查远端是否返回成功
1127 ret = strcmp(str, "0");
1128 EXPECT_EQ(ret, 0);
1129
1130 //解注册回调
1131 status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
1132 EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
1133 }
1134
1135 /**
1136 * @tc.number: DistribitedKvDataManager_Sync_Pull_0600
1137 * @tc.name: remote put data, local sync pull
1138 * @tc.desc: sync pull, put string data
1139 * @tc.type: FUNC
1140 */
1141 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0600, TestSize.Level1)
1142 {
1143 ZLOGI("DistribitedKvDataManager_Sync_Pull_0600 begin.");
1144 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
1145 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
1146
1147 // 2.创建远端Lv
1148 // 3. 本地数据库添加数据 100
1149 Key keyInt = "math_score_string";
1150 Value valueInt = Value("{\"class\":20, \"age\":18, \"gradle\":\"good\"}");
1151 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
1152 EXPECT_EQ(Status::SUCCESS, status);
1153
1154 // 4. sync push 同步数据到远端
1155 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1156 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1157 EXPECT_EQ(status, Status::SUCCESS);
1158
1159 std::vector<std::string> deviceList;
1160 for (const auto& device : remoteDevice) {
1161 std::cout << "start sync" << device.deviceId << std::endl;
1162 deviceList.push_back(device.deviceId);
1163 }
1164 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
1165 ASSERT_EQ(status, Status::SUCCESS);
1166
1167 // 5.远端修改数据200
1168 char strPut[MAX_DATA_LENGTH] = { "math_score_string:{\"class\":88, \"age\":99, \"gradle\":\"QQWWQQ\"}" };
1169 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strPut);
1170 char str[MAX_DATA_LENGTH] = { 0 };
1171 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1172 char code[10] = { 0 };
1173 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1174
1175 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1176 waitDataWithCode(code, str);
1177 std::cout << "put string result=" << str << std::endl;
1178
1179 //检查远端是否返回成功
1180 int ret = strcmp(str, "0");
1181 EXPECT_EQ(ret, 0);
1182
1183 // 6.本地pull远端数据
1184 // std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1185 remoteDevice.clear();
1186 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1187 EXPECT_EQ(status, Status::SUCCESS);
1188
1189 // std::vector<std::string> deviceList;
1190 deviceList.clear();
1191 for (const auto& device : remoteDevice) {
1192 std::cout << "start sync" << device.deviceId << std::endl;
1193 deviceList.push_back(device.deviceId);
1194 }
1195 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PULL);
1196 EXPECT_EQ(status, Status::SUCCESS);
1197 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
1198 status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
1199 EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
1200 if (status == Status::SUCCESS) {
1201 std::cout << "LOGdisDataTest--SUCCESS: register sync callback" << std::endl;
1202 } else {
1203 std::cout << "LOGdisDataTest--FAIL: register sync callback" << static_cast<int>(status) << std::endl;
1204 }
1205
1206 // 7.本地get数据 与200比较
1207 usleep(USLEEP_TIME);
1208
1209 Value valueRetInt;
1210 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
1211 EXPECT_EQ(status, Status::SUCCESS);
1212 std::string aaa = valueRetInt.ToString();
1213 std::string sstring = "{\"class\":88, \"age\":99, \"gradle\":\"QQWWQQ\"}";
1214 EXPECT_EQ(aaa, sstring);
1215
1216 // 8.数据发送到远端并等待返回结果
1217 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strPut);
1218
1219 // char str[MAX_DATA_LENGTH] = {0};
1220 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1221 // char code[10]={0};
1222 memset_s(code, 10, 0, 10);
1223 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1224
1225 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1226 waitDataWithCode(code, str);
1227 std::cout << "get string result=" << str << std::endl;
1228
1229 //检查远端是否返回成功
1230 ret = strcmp(str, "0");
1231 EXPECT_EQ(ret, 0);
1232
1233 //解注册回调
1234 status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
1235 EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
1236 }
1237
1238 /**
1239 * @tc.number: DistribitedKvDataManager_Sync_Pull_0700
1240 * @tc.name: remote put data, local sync pull
1241 * @tc.desc: sync pull, put vector<uint8_t> data
1242 * @tc.type: FUNC
1243 */
1244 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_Pull_0700, TestSize.Level1)
1245 {
1246 ZLOGI("DistribitedKvDataManager_Sync_Pull_0700 begin.");
1247 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
1248 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
1249
1250 // 2.创建远端Lv
1251 // 3.本地数据库添加数据 vector<int>
1252 std::string stringKey = "math_score_vector";
1253 Key keyInt = stringKey;
1254 std::vector<uint8_t> vect = { 0, 1, 2, 3, 4, 5, 6, 7 };
1255 Value valueInt = Value(vect);
1256 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
1257 EXPECT_EQ(Status::SUCCESS, status);
1258
1259 // 4. sync push 同步数据到远端
1260 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1261 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1262 EXPECT_EQ(status, Status::SUCCESS);
1263
1264 std::vector<std::string> deviceList;
1265 for (const auto& device : remoteDevice) {
1266 std::cout << "start sync" << device.deviceId << std::endl;
1267 deviceList.push_back(device.deviceId);
1268 }
1269 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
1270 ASSERT_EQ(status, Status::SUCCESS);
1271
1272 // 5.远端修改数据200
1273
1274 std::vector<uint8_t> vect2 = { 9, 9, 8, 8, 7, 7, 6, 6 };
1275 std::string strvc;
1276 strvc.assign(vect2.begin(), vect2.end());
1277
1278 char strKV[MAX_DATA_LENGTH] = { "math_score_int" };
1279 strcpy_s(strKV, strlen(stringKey.c_str()) + 1, stringKey.c_str());
1280 strcat_s(strKV, MAX_DATA_LENGTH, ":");
1281 strcat_s(strKV, MAX_DATA_LENGTH, strvc.c_str());
1282
1283 std::cout << "strvc = " << strvc << std::endl;
1284 std::cout << "strvc.c_str() = " << strvc.c_str() << std::endl;
1285 std::cout << "strKV = " << strKV << std::endl;
1286
1287 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
1288 char str[MAX_DATA_LENGTH] = { 0 };
1289 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1290 char code[10] = { "9999" };
1291 memset_s(code, 10, 0, 10);
1292 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1293
1294 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1295 waitDataWithCode(code, str);
1296 std::cout << "yput-vector<uint8_t> get result=" << str << std::endl;
1297
1298 //检查远端是否返回成功
1299 int ret = strcmp(str, "0");
1300 EXPECT_EQ(ret, 0);
1301
1302 // 6.本地pull远端数据
1303 // std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1304 remoteDevice.clear();
1305 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1306 EXPECT_EQ(status, Status::SUCCESS);
1307
1308 // std::vector<std::string> deviceList;
1309 deviceList.clear();
1310 for (const auto& device : remoteDevice) {
1311 std::cout << "start sync" << device.deviceId << std::endl;
1312 deviceList.push_back(device.deviceId);
1313 }
1314 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PULL);
1315 EXPECT_EQ(status, Status::SUCCESS);
1316 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
1317 status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
1318 EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
1319 if (status == Status::SUCCESS) {
1320 std::cout << "LOGdisDataTest--SUCCESS: register sync callback" << std::endl;
1321 } else {
1322 std::cout << "LOGdisDataTest--FAIL: register sync callback" << static_cast<int>(status) << std::endl;
1323 }
1324
1325 // 7.本地get数据 与200比较
1326 usleep(USLEEP_TIME);
1327
1328 Value valueRetInt;
1329 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
1330 EXPECT_EQ(status, Status::SUCCESS);
1331 std::string strValueRet = valueRetInt.ToString();
1332 EXPECT_EQ(strvc, strValueRet.c_str());
1333
1334 // 8.数据发送到远端并等待返回结果
1335 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);
1336
1337 // char str[MAX_DATA_LENGTH] = {0};
1338 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1339 memset_s(code, 10, 0, 10);
1340 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1341
1342 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1343 waitDataWithCode(code, str);
1344 std::cout << "put vector<uint8_t> get result=" << str << std::endl;
1345
1346 //检查远端是否返回成功
1347 ret = strcmp(str, "0");
1348 EXPECT_EQ(ret, 0);
1349
1350 //解注册回调
1351 status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
1352 EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
1353 }
1354
1355 /**
1356 * @tc.number: DistribitedKvDataManager_Sync_PUSH_PULL_0100
1357 * @tc.name: remote delete data, local sync push_pull
1358 * @tc.desc: sync push_pull ,delete int data
1359 * @tc.type: FUNC
1360 */
1361 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_PUSH_PULL_0100, TestSize.Level1)
1362 {
1363 ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0100 begin.");
1364 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
1365 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
1366
1367 // 2.创建远端Lv
1368 // 3. 本地数据库添加数据 100
1369 Key keyInt = "math_score_int";
1370 Value valueInt = Value(TransferTypeToByteArray<int>(100));
1371 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
1372 EXPECT_EQ(Status::SUCCESS, status);
1373
1374 // 4. sync push 同步数据到远端
1375 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1376 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1377 EXPECT_EQ(status, Status::SUCCESS);
1378
1379 std::vector<std::string> deviceList;
1380 for (const auto& device : remoteDevice) {
1381 std::cout << "start sync" << device.deviceId << std::endl;
1382 deviceList.push_back(device.deviceId);
1383 }
1384 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
1385 ASSERT_EQ(status, Status::SUCCESS);
1386
1387 // 5.远端delete 数据
1388 char strKV[MAX_DATA_LENGTH] = { "math_score_int:100" };
1389 writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
1390
1391 char str[MAX_DATA_LENGTH] = { 0 };
1392 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1393 char code[10] = { 0 };
1394 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1395 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1396 waitDataWithCode(code, str);
1397 std::cout << " delete int result=" << str << std::endl;
1398
1399 int ret = strcmp(str, "0");
1400 EXPECT_EQ(ret, 0);
1401
1402 // 6.本地push_pull远端数据
1403 // std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1404 remoteDevice.clear();
1405 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1406 EXPECT_EQ(status, Status::SUCCESS);
1407
1408 // std::vector<std::string> deviceList;
1409 deviceList.clear();
1410 for (const auto& device : remoteDevice) {
1411 std::cout << "start sync" << device.deviceId << std::endl;
1412 deviceList.push_back(device.deviceId);
1413 }
1414 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
1415 EXPECT_EQ(status, Status::SUCCESS);
1416 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
1417 status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
1418 EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
1419 if (status == Status::SUCCESS) {
1420 std::cout << "LOGdisDataTest--SUCCESS: register sync callback" << std::endl;
1421 } else {
1422 std::cout << "LOGdisDataTest--FAIL: register sync callback" << static_cast<int>(status) << std::endl;
1423 }
1424
1425 // 7.本地get数据失败
1426 usleep(USLEEP_TIME);
1427
1428 Value valueRetInt;
1429 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
1430 EXPECT_EQ(status, Status::KEY_NOT_FOUND);
1431
1432 // 8.远端get数据失败
1433 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);
1434
1435 // char str[MAX_DATA_LENGTH] = {0};
1436 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1437 memset_s(code, 10, 0, 10);
1438 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1439 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1440 waitDataWithCode(code, str);
1441 std::cout << " get int result=" << str << std::endl;
1442
1443 //检查远端是否返回成功
1444 ret = strcmp(str, "1");
1445 EXPECT_EQ(ret, 0);
1446
1447 //解注册回调
1448 status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
1449 EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
1450 }
1451
1452 /**
1453 * @tc.number: DistribitedKvDataManager_Sync_PUSH_PULL_0200
1454 * @tc.name: remote delete data, local sync push_pull
1455 * @tc.desc: sync push_pull ,delete float data
1456 * @tc.type: FUNC
1457 */
1458 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_PUSH_PULL_0200, TestSize.Level1)
1459 {
1460 ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0200 begin.");
1461
1462 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
1463 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
1464
1465 // 2.创建远端Lv
1466 // 3. 本地数据库添加数据 100
1467 Key keyInt = "math_score_int";
1468 Value valueInt = Value(TransferTypeToByteArray<float>(3.14f));
1469 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
1470 EXPECT_EQ(Status::SUCCESS, status);
1471
1472 // 4. sync push 同步数据到远端
1473 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1474 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1475 EXPECT_EQ(status, Status::SUCCESS);
1476
1477 std::vector<std::string> deviceList;
1478 for (const auto& device : remoteDevice) {
1479 std::cout << "start sync" << device.deviceId << std::endl;
1480 deviceList.push_back(device.deviceId);
1481 }
1482 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
1483 ASSERT_EQ(status, Status::SUCCESS);
1484
1485 // 5.远端delete 数据
1486 char strKV[MAX_DATA_LENGTH] = { "math_score_int:100" };
1487 writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
1488
1489 char str[MAX_DATA_LENGTH] = { 0 };
1490 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1491 char code[10] = { 0 };
1492 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1493 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1494 waitDataWithCode(code, str);
1495 std::cout << " delete float get result=" << str << std::endl;
1496
1497 int ret = strcmp(str, "0");
1498 EXPECT_EQ(ret, 0);
1499
1500 // 6.本地push_pull远端数据
1501 // std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1502 remoteDevice.clear();
1503 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1504 EXPECT_EQ(status, Status::SUCCESS);
1505 // std::vector<std::string> deviceList;
1506 deviceList.clear();
1507 for (const auto& device : remoteDevice) {
1508 std::cout << "start sync" << device.deviceId << std::endl;
1509 deviceList.push_back(device.deviceId);
1510 }
1511 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
1512 EXPECT_EQ(status, Status::SUCCESS);
1513 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
1514 status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
1515 EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
1516 if (status == Status::SUCCESS) {
1517 std::cout << "LOGdisDataTest--SUCCESS: register sync callback" << std::endl;
1518 } else {
1519 std::cout << "LOGdisDataTest--FAIL: register sync callback" << static_cast<int>(status) << std::endl;
1520 }
1521
1522 // 7.本地get数据失败
1523 usleep(USLEEP_TIME);
1524
1525 Value valueRetInt;
1526 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
1527 EXPECT_EQ(status, Status::KEY_NOT_FOUND);
1528
1529 // 8.远端get数据失败
1530 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);
1531
1532 // char str[MAX_DATA_LENGTH] = {0};
1533 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1534 memset_s(code, 10, 0, 10);
1535 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1536 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1537 waitDataWithCode(code, str);
1538 std::cout << " get result=" << str << std::endl;
1539
1540 //检查远端是否返回成功
1541 ret = strcmp(str, "1");
1542 EXPECT_EQ(ret, 0);
1543
1544 //解注册回调
1545 status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
1546 EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
1547 }
1548
1549 /**
1550 * @tc.number: DistribitedKvDataManager_Sync_PUSH_PULL_0300
1551 * @tc.name: remote delete data, local sync push_pull
1552 * @tc.desc: sync push_pull ,delete double data
1553 * @tc.type: FUNC
1554 */
1555 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_PUSH_PULL_0300, TestSize.Level1)
1556 {
1557 ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0300 begin.");
1558
1559 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
1560 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
1561
1562 // 2.创建远端Lv
1563 // 3. 本地数据库添加数据 100
1564 Key keyInt = "math_score_int";
1565 Value valueInt = Value(TransferTypeToByteArray<double>(28.288f));
1566 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
1567 EXPECT_EQ(Status::SUCCESS, status);
1568
1569 // 4. sync push 同步数据到远端
1570 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1571 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1572 EXPECT_EQ(status, Status::SUCCESS);
1573
1574 std::vector<std::string> deviceList;
1575 for (const auto& device : remoteDevice) {
1576 std::cout << "start sync" << device.deviceId << std::endl;
1577 deviceList.push_back(device.deviceId);
1578 }
1579 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
1580 ASSERT_EQ(status, Status::SUCCESS);
1581
1582 // 5.远端delete 数据
1583 char strKV[MAX_DATA_LENGTH] = { "math_score_int:100" };
1584 writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
1585 char str[MAX_DATA_LENGTH] = { 0 };
1586 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1587 char code[10] = { 0 };
1588 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1589 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1590 waitDataWithCode(code, str);
1591 std::cout << "delete double result=" << str << std::endl;
1592
1593 int ret = strcmp(str, "0");
1594 EXPECT_EQ(ret, 0);
1595
1596 // 6.本地push_pull远端数据
1597 // std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1598 remoteDevice.clear();
1599 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1600 EXPECT_EQ(status, Status::SUCCESS);
1601
1602 // std::vector<std::string> deviceList;
1603 deviceList.clear();
1604 for (const auto& device : remoteDevice) {
1605 std::cout << "start sync" << device.deviceId << std::endl;
1606 deviceList.push_back(device.deviceId);
1607 }
1608
1609 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
1610 EXPECT_EQ(status, Status::SUCCESS);
1611 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
1612 status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
1613 EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
1614 if (status == Status::SUCCESS) {
1615 std::cout << "LOGdisDataTest--SUCCESS: register sync callback" << std::endl;
1616 } else {
1617 std::cout << "LOGdisDataTest--FAIL: register sync callback" << static_cast<int>(status) << std::endl;
1618 }
1619
1620 // 7.本地get数据失败
1621 usleep(USLEEP_TIME);
1622
1623 Value valueRetInt;
1624 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
1625 EXPECT_EQ(status, Status::KEY_NOT_FOUND);
1626
1627 // 8.远端get数据失败
1628 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);
1629
1630 // char str[MAX_DATA_LENGTH] = {0};
1631 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1632 memset_s(code, 10, 0, 10);
1633 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1634 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1635 waitDataWithCode(code, str);
1636 std::cout << "get result=" << str << std::endl;
1637
1638 //检查远端是否返回成功
1639 ret = strcmp(str, "1");
1640 EXPECT_EQ(ret, 0);
1641
1642 //解注册回调
1643 status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
1644 EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
1645 }
1646
1647 /**
1648 * @tc.number: DistribitedKvDataManager_Sync_PUSH_PULL_0400
1649 * @tc.name: remote delete data, local sync push_pull
1650 * @tc.desc: sync push_pull ,delete int64_t data
1651 * @tc.type: FUNC
1652 */
1653 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_PUSH_PULL_0400, TestSize.Level1)
1654 {
1655 ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0400 begin.");
1656
1657 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
1658 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
1659
1660 // 2.创建远端Lv
1661 // 3. 本地数据库添加数据 100
1662 Key keyInt = "math_score_int";
1663 Value valueInt = Value(TransferTypeToByteArray<int64_t>(12345678));
1664 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
1665 EXPECT_EQ(Status::SUCCESS, status);
1666
1667 // 4. sync push 同步数据到远端
1668 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1669 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1670 EXPECT_EQ(status, Status::SUCCESS);
1671
1672 std::vector<std::string> deviceList;
1673 for (const auto& device : remoteDevice) {
1674 std::cout << "start sync" << device.deviceId << std::endl;
1675 deviceList.push_back(device.deviceId);
1676 }
1677 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
1678 ASSERT_EQ(status, Status::SUCCESS);
1679
1680 // 5.远端delete 数据
1681 char strKV[MAX_DATA_LENGTH] = { "math_score_int:100" };
1682 writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
1683 char str[MAX_DATA_LENGTH] = { 0 };
1684 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1685 char code[10] = { 0 };
1686 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1687 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1688 waitDataWithCode(code, str);
1689 std::cout << " delete int64_t result=" << str << std::endl;
1690
1691 int ret = strcmp(str, "0");
1692 EXPECT_EQ(ret, 0);
1693
1694 // 6.本地push_pull远端数据
1695 // std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1696 remoteDevice.clear();
1697 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1698 EXPECT_EQ(status, Status::SUCCESS);
1699
1700 // std::vector<std::string> deviceList;
1701 deviceList.clear();
1702 for (const auto& device : remoteDevice) {
1703 std::cout << "start sync" << device.deviceId << std::endl;
1704 deviceList.push_back(device.deviceId);
1705 }
1706 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
1707 EXPECT_EQ(status, Status::SUCCESS);
1708 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
1709 status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
1710 EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
1711 if (status == Status::SUCCESS) {
1712 std::cout << "LOGdisDataTest--SUCCESS: register sync callback" << std::endl;
1713 } else {
1714 std::cout << "LOGdisDataTest--FAIL: register sync callback" << static_cast<int>(status) << std::endl;
1715 }
1716
1717 // 7.本地get数据失败
1718 usleep(USLEEP_TIME);
1719
1720 Value valueRetInt;
1721 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
1722 EXPECT_EQ(status, Status::KEY_NOT_FOUND);
1723
1724 // 8.远端get数据失败
1725 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);
1726
1727 // char str[MAX_DATA_LENGTH] = {0};
1728 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1729 memset_s(code, 10, 0, 10);
1730 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1731 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1732 waitDataWithCode(code, str);
1733 std::cout << "get result=" << str << std::endl;
1734
1735 //检查远端是否返回成功
1736 ret = strcmp(str, "1");
1737 EXPECT_EQ(ret, 0);
1738
1739 //解注册回调
1740 status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
1741 EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
1742 }
1743
1744 /**
1745 * @tc.number: DistribitedKvDataManager_Sync_PUSH_PULL_0500
1746 * @tc.name: remote delete data, local sync push_pull
1747 * @tc.desc: sync push_pull ,delete size_t data
1748 * @tc.type: FUNC
1749 */
1750 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_PUSH_PULL_0500, TestSize.Level1)
1751 {
1752 ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0500 begin.");
1753
1754 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
1755 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
1756
1757 // 2.创建远端Lv
1758 // 3. 本地数据库添加数据 100
1759 Key keyInt = "math_score_int";
1760 Value valueInt = Value(TransferTypeToByteArray<size_t>(28));
1761 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
1762 EXPECT_EQ(Status::SUCCESS, status);
1763
1764 // 4. sync push 同步数据到远端
1765 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1766 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1767 EXPECT_EQ(status, Status::SUCCESS);
1768
1769 std::vector<std::string> deviceList;
1770 for (const auto& device : remoteDevice) {
1771 std::cout << "start sync" << device.deviceId << std::endl;
1772 deviceList.push_back(device.deviceId);
1773 }
1774 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
1775 ASSERT_EQ(status, Status::SUCCESS);
1776
1777 // 5.远端delete 数据
1778 char strKV[MAX_DATA_LENGTH] = { "math_score_int:100" };
1779 writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
1780
1781 char str[MAX_DATA_LENGTH] = { 0 };
1782 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1783 char code[10] = { 0 };
1784 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1785 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1786 waitDataWithCode(code, str);
1787 std::cout << " delete size_t result=" << str << std::endl;
1788
1789 int ret = strcmp(str, "0");
1790 EXPECT_EQ(ret, 0);
1791
1792 // 6.本地push_pull远端数据
1793 // std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1794 remoteDevice.clear();
1795 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1796 EXPECT_EQ(status, Status::SUCCESS);
1797
1798 // std::vector<std::string> deviceList;
1799 deviceList.clear();
1800 for (const auto& device : remoteDevice) {
1801 std::cout << "start sync" << device.deviceId << std::endl;
1802 deviceList.push_back(device.deviceId);
1803 }
1804 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
1805 EXPECT_EQ(status, Status::SUCCESS);
1806 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
1807 status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
1808 EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
1809 if (status == Status::SUCCESS) {
1810 std::cout << "LOGdisDataTest--SUCCESS: register sync callback" << std::endl;
1811 } else {
1812 std::cout << "LOGdisDataTest--FAIL: register sync callback" << static_cast<int>(status) << std::endl;
1813 }
1814
1815 // 7.本地get数据失败
1816 usleep(USLEEP_TIME);
1817
1818 Value valueRetInt;
1819 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
1820 EXPECT_EQ(status, Status::KEY_NOT_FOUND);
1821
1822 // 8.远端get数据失败
1823 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);
1824 // char str[MAX_DATA_LENGTH] = {0};
1825 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1826 memset_s(code, 10, 0, 10);
1827 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1828 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1829 waitDataWithCode(code, str);
1830 std::cout << " get result=" << str << std::endl;
1831
1832 //检查远端是否返回成功
1833 ret = strcmp(str, "1");
1834 EXPECT_EQ(ret, 0);
1835
1836 //解注册回调
1837 status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
1838 EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
1839 }
1840
1841 /**
1842 * @tc.number: DistribitedKvDataManager_Sync_PUSH_PULL_0600
1843 * @tc.name: remote delete data, local sync push_pull
1844 * @tc.desc: sync push_pull ,delete string data
1845 * @tc.type: FUNC
1846 */
1847 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_PUSH_PULL_0600, TestSize.Level1)
1848 {
1849 ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0600 begin.");
1850
1851 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
1852 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
1853
1854 // 2.创建远端Lv
1855 // 3. 本地数据库添加数据 100
1856 Key keyInt = "math_score_int";
1857 Value valueInt = Value("{\"class\":20, \"age\":18, \"gradle\":\"good\"}");
1858 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
1859 EXPECT_EQ(Status::SUCCESS, status);
1860
1861 // 4. sync push 同步数据到远端
1862 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1863 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1864 EXPECT_EQ(status, Status::SUCCESS);
1865
1866 std::vector<std::string> deviceList;
1867 for (const auto& device : remoteDevice) {
1868 std::cout << "start sync" << device.deviceId << std::endl;
1869 deviceList.push_back(device.deviceId);
1870 }
1871 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
1872 ASSERT_EQ(status, Status::SUCCESS);
1873
1874 // 5.远端delete 数据
1875 char strKV[MAX_DATA_LENGTH] = { "math_score_int:100" };
1876 writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
1877
1878 char str[MAX_DATA_LENGTH] = { 0 };
1879 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1880 char code[10] = { 0 };
1881 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1882 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1883 waitDataWithCode(code, str);
1884 std::cout << "delete string result=" << str << std::endl;
1885
1886 int ret = strcmp(str, "0");
1887 EXPECT_EQ(ret, 0);
1888
1889 // 6.本地push_pull远端数据
1890 // std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1891 remoteDevice.clear();
1892 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1893 EXPECT_EQ(status, Status::SUCCESS);
1894
1895 // std::vector<std::string> deviceList;
1896 deviceList.clear();
1897 for (const auto& device : remoteDevice) {
1898 std::cout << "start sync" << device.deviceId << std::endl;
1899 deviceList.push_back(device.deviceId);
1900 }
1901 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
1902 EXPECT_EQ(status, Status::SUCCESS);
1903 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
1904 status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
1905 EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
1906 if (status == Status::SUCCESS) {
1907 std::cout << "LOGdisDataTest--SUCCESS: register sync callback" << std::endl;
1908 } else {
1909 std::cout << "LOGdisDataTest--FAIL: register sync callback" << static_cast<int>(status) << std::endl;
1910 }
1911
1912 // 7.本地get数据失败
1913 usleep(USLEEP_TIME);
1914
1915 Value valueRetInt;
1916 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
1917 EXPECT_EQ(status, Status::KEY_NOT_FOUND);
1918
1919 // 8.远端get数据失败
1920 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);
1921
1922 // char str[MAX_DATA_LENGTH] = {0};
1923 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1924 memset_s(code, 10, 0, 10);
1925 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1926 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1927 waitDataWithCode(code, str);
1928 std::cout << " get result=" << str << std::endl;
1929
1930 //检查远端是否返回成功
1931 ret = strcmp(str, "1");
1932 EXPECT_EQ(ret, 0);
1933
1934 //解注册回调
1935 status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
1936 EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
1937 }
1938
1939 /**
1940 * @tc.number: DistribitedKvDataManager_Sync_PUSH_PULL_0700
1941 * @tc.name: remote delete data, local sync push_pull
1942 * @tc.desc: sync push_pull ,delete vector<uint8_t> data
1943 * @tc.type: FUNC
1944 */
1945 HWTEST_F(DistributedKvDataManagerTest, DistribitedKvDataManager_Sync_PUSH_PULL_0700, TestSize.Level1)
1946 {
1947 ZLOGI("DistribitedKvDataManager_Sync_PUSH_PULL_0700 begin.");
1948 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
1949 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
1950 // 2.创建远端Lv
1951 // 3. 本地数据库添加数据 100
1952 Key keyInt = "math_score_int";
1953 std::vector<uint8_t> vect = { 0, 1, 2, 3, 4, 5, 6, 7 };
1954 Value valueInt = Value(vect);
1955 Status status = DisKvTest::KvStorePtr->Put(keyInt, valueInt);
1956 EXPECT_EQ(Status::SUCCESS, status);
1957
1958 // 4. sync push 同步数据到远端
1959 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1960 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1961 EXPECT_EQ(status, Status::SUCCESS);
1962
1963 std::vector<std::string> deviceList;
1964 for (const auto& device : remoteDevice) {
1965 std::cout << "start sync" << device.deviceId << std::endl;
1966 deviceList.push_back(device.deviceId);
1967 }
1968 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH);
1969 ASSERT_EQ(status, Status::SUCCESS);
1970
1971 // 5.远端delete 数据
1972 char strKV[MAX_DATA_LENGTH] = { "math_score_int:100" };
1973 writeCodeDataToShm(CTRL_CODE_DATAMGR_DELETE_DATA, strKV);
1974
1975 char str[MAX_DATA_LENGTH] = { 0 };
1976 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1977 char code[10] = { "9999" };
1978 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
1979 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
1980 waitDataWithCode(code, str);
1981 std::cout << " delete vector result=" << str << std::endl;
1982
1983 int ret = strcmp(str, "0");
1984 EXPECT_EQ(ret, 0);
1985
1986 // 6.本地push_pull远端数据
1987 // std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
1988 remoteDevice.clear();
1989 status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
1990 EXPECT_EQ(status, Status::SUCCESS);
1991
1992 // std::vector<std::string> deviceList;
1993 deviceList.clear();
1994 for (const auto& device : remoteDevice) {
1995 std::cout << "start sync" << device.deviceId << std::endl;
1996 deviceList.push_back(device.deviceId);
1997 }
1998 status = DisKvTest::KvStorePtr->Sync(deviceList, SyncMode::PUSH_PULL);
1999 EXPECT_EQ(status, Status::SUCCESS);
2000 auto syncCallback = std::make_shared<KvStoreSyncCallbackTestImpl>();
2001 status = DisKvTest::KvStorePtr->RegisterSyncCallback(syncCallback);
2002 EXPECT_EQ(status, Status::SUCCESS) << "register sync callback failed.";
2003 if (status == Status::SUCCESS) {
2004 std::cout << "LOGdisDataTest--SUCCESS: register sync callback" << std::endl;
2005 } else {
2006 std::cout << "LOGdisDataTest--FAIL: register sync callback" << static_cast<int>(status) << std::endl;
2007 }
2008
2009 // 7.本地get数据失败
2010 usleep(USLEEP_TIME);
2011
2012 Value valueRetInt;
2013 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2014 EXPECT_EQ(status, Status::KEY_NOT_FOUND);
2015
2016 // 8.远端get数据失败
2017 writeCodeDataToShm(CTRL_CODE_DATAMGR_GET_DATA, strKV);
2018
2019 // char str[MAX_DATA_LENGTH] = {0};
2020 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2021 memset_s(code, 10, 0, 10);
2022 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2023 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2024 waitDataWithCode(code, str);
2025 std::cout << " get result=" << str << std::endl;
2026
2027 //检查远端是否返回成功
2028 ret = strcmp(str, "1");
2029 EXPECT_EQ(ret, 0);
2030
2031 //解注册回调
2032 status = DisKvTest::KvStorePtr->UnRegisterSyncCallback();
2033 EXPECT_EQ(status, Status::SUCCESS) << "un register sync callback failed.";
2034 }
2035
2036 /**
2037 * @tc.number: SubscribeWithQuery_0100
2038 * @tc.name: SubscribeWithQuery
2039 * @tc.desc: SubscribeWithQuery, int data
2040 * @tc.type: FUNC
2041 */
2042 HWTEST_F(DistributedKvDataManagerTest, SubscribeWithQuery_0100, TestSize.Level1)
2043 {
2044 ZLOGI("SubscribeWithQuery_0100 begin.");
2045 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
2046 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
2047 // 1.本端创建Lv
2048 // 2.远端创建kv
2049
2050 // 3. 远端put int
2051 // char strPut[MAX_DATA_LENGTH] = {"math_score_int:200"};
2052 char strKV[MAX_DATA_LENGTH] = { "math_score_int" };
2053 memset_s(strKV, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2054 strcpy_s(strKV, strlen("math_score_int:200") + 1, "math_score_int:200");
2055 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
2056
2057 char str[MAX_DATA_LENGTH] = { 0 };
2058 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2059 char code[10] = { "9999" };
2060 memset_s(code, 10, 0, 10);
2061 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2062 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2063 waitDataWithCode(code, str);
2064 std::cout << "yput-200 get result=" << str << std::endl;
2065 //检查远端是否返回成功
2066 int ret = strcmp(str, "0");
2067 EXPECT_EQ(ret, 0);
2068
2069 // 4. 本段sync远端数据 SubscribeWithQuery
2070 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
2071 remoteDevice.clear();
2072 Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
2073 EXPECT_EQ(status, Status::SUCCESS);
2074
2075 std::vector<std::string> deviceList;
2076 deviceList.clear();
2077 for (const auto& device : remoteDevice) {
2078 std::cout << "start sync deviceId = " << device.deviceId << std::endl;
2079 deviceList.push_back(device.deviceId);
2080 }
2081
2082 DataQuery dataQuery;
2083 dataQuery.KeyPrefix("math");
2084 auto syncStatus = DisKvTest::KvStorePtr->SubscribeWithQuery(deviceList, dataQuery);
2085 EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SubscribeWithQuery";
2086
2087 // 5.本地get数据与200比较
2088 usleep(USLEEP_TIME);
2089
2090 Value valueRetInt;
2091 Key keyInt = "math_score_int";
2092 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2093 EXPECT_EQ(status, Status::SUCCESS);
2094 int aaa = TransferByteArrayToType<int>(valueRetInt.Data());
2095 std::cout << "LOGdisDataTest--本地get数据与200比较: aaa = " << aaa << std::endl;
2096 EXPECT_EQ(aaa, 200);
2097
2098 //////取消订阅
2099 auto unSubscribeStatus = DisKvTest::KvStorePtr->UnsubscribeWithQuery(deviceList, dataQuery);
2100 EXPECT_EQ(unSubscribeStatus, Status::SUCCESS) << "LOGdisDataTest--ERR:SubscribeWithQuery";
2101 }
2102
2103 /**
2104 * @tc.number: SubscribeWithQuery_0200
2105 * @tc.name: SubscribeWithQuery
2106 * @tc.desc: SubscribeWithQuery, float data
2107 * @tc.type: FUNC
2108 */
2109 HWTEST_F(DistributedKvDataManagerTest, SubscribeWithQuery_0200, TestSize.Level1)
2110 {
2111 ZLOGI("SubscribeWithQuery_0200 begin.");
2112 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
2113 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
2114 // 1.本端创建Lv
2115 // 2.远端创建kv
2116
2117 // 3. 远端put int
2118 char strKV[MAX_DATA_LENGTH] = { "math_score_float:9.99" };
2119 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
2120
2121 char str[MAX_DATA_LENGTH] = { 0 };
2122 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2123 char code[10] = { "9999" };
2124 memset_s(code, 10, 0, 10);
2125 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2126 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2127 waitDataWithCode(code, str);
2128 std::cout << "yput-200 get result=" << str << std::endl;
2129 //检查远端是否返回成功
2130 int ret = strcmp(str, "0");
2131 EXPECT_EQ(ret, 0);
2132
2133 // 4. 本段sync远端数据 SubscribeWithQuery
2134 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
2135 remoteDevice.clear();
2136 Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
2137 EXPECT_EQ(status, Status::SUCCESS);
2138
2139 std::vector<std::string> deviceList;
2140 deviceList.clear();
2141 for (const auto& device : remoteDevice) {
2142 std::cout << "start sync deviceId = " << device.deviceId << std::endl;
2143 deviceList.push_back(device.deviceId);
2144 }
2145
2146 DataQuery dataQuery;
2147 dataQuery.KeyPrefix("math");
2148 auto syncStatus = DisKvTest::KvStorePtr->SubscribeWithQuery(deviceList, dataQuery);
2149 EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SubscribeWithQuery";
2150
2151 // 5.本地get数据与200比较
2152 usleep(USLEEP_TIME);
2153
2154 Value valueRetInt;
2155 std::string stringKey = "math_score_float";
2156 Key keyInt = stringKey;
2157 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2158 EXPECT_EQ(status, Status::SUCCESS) << "LOGdisDataTest--ERR:Get(keyInt, valueRetInt)";
2159 float aaa = TransferByteArrayToType<float>(valueRetInt.Data());
2160 float delta = aaa - 9.99f;
2161 EXPECT_LE(std::abs(delta), 0.00001);
2162
2163 //////取消订阅
2164 auto unSubscribeStatus = DisKvTest::KvStorePtr->UnsubscribeWithQuery(deviceList, dataQuery);
2165 EXPECT_EQ(unSubscribeStatus, Status::SUCCESS) << "LOGdisDataTest--ERR:SubscribeWithQuery";
2166 }
2167
2168 /**
2169 * @tc.number: SubscribeWithQuery_0300
2170 * @tc.name: SubscribeWithQuery
2171 * @tc.desc: SubscribeWithQuery, double data
2172 * @tc.type: FUNC
2173 */
2174 HWTEST_F(DistributedKvDataManagerTest, SubscribeWithQuery_0300, TestSize.Level1)
2175 {
2176 ZLOGI("SubscribeWithQuery_0300 begin.");
2177 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
2178 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
2179 // 1.本端创建Lv
2180 // 2.远端创建kv
2181
2182 // 3. 远端put int
2183 char strKV[MAX_DATA_LENGTH] = { "math_score_double:999.999" };
2184 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
2185
2186 char str[MAX_DATA_LENGTH] = { 0 };
2187 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2188 char code[10] = { "9999" };
2189 memset_s(code, 10, 0, 10);
2190 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2191 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2192 waitDataWithCode(code, str);
2193 std::cout << "yput-200 get result=" << str << std::endl;
2194 //检查远端是否返回成功
2195 int ret = strcmp(str, "0");
2196 EXPECT_EQ(ret, 0);
2197
2198 // 4. 本段sync远端数据 SubscribeWithQuery
2199 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
2200 remoteDevice.clear();
2201 Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
2202 EXPECT_EQ(status, Status::SUCCESS);
2203
2204 std::vector<std::string> deviceList;
2205 deviceList.clear();
2206 for (const auto& device : remoteDevice) {
2207 std::cout << "start sync deviceId = " << device.deviceId << std::endl;
2208 deviceList.push_back(device.deviceId);
2209 }
2210
2211 DataQuery dataQuery;
2212 dataQuery.KeyPrefix("math");
2213 auto syncStatus = DisKvTest::KvStorePtr->SubscribeWithQuery(deviceList, dataQuery);
2214 EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SubscribeWithQuery";
2215
2216 // 5.本地get数据与200比较
2217 usleep(USLEEP_TIME);
2218
2219 Value valueRetInt;
2220 std::string stringKey = "math_score_double";
2221 Key keyInt = stringKey;
2222 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2223 EXPECT_EQ(status, Status::SUCCESS);
2224 double aaa = TransferByteArrayToType<double>(valueRetInt.Data());
2225 double delta = aaa - 999.999;
2226 std::cout << "aaa = " << aaa << std::endl;
2227 std::cout << "delta = " << delta << std::endl;
2228 EXPECT_LE(std::abs(delta), 0.00001);
2229
2230 //////取消订阅
2231 auto unSubscribeStatus = DisKvTest::KvStorePtr->UnsubscribeWithQuery(deviceList, dataQuery);
2232 EXPECT_EQ(unSubscribeStatus, Status::SUCCESS) << "LOGdisDataTest--ERR:SubscribeWithQuery";
2233 }
2234
2235 /**
2236 * @tc.number: SubscribeWithQuery_0400
2237 * @tc.name: SubscribeWithQuery
2238 * @tc.desc: SubscribeWithQuery, int64_t data
2239 * @tc.type: FUNC
2240 */
2241 HWTEST_F(DistributedKvDataManagerTest, SubscribeWithQuery_0400, TestSize.Level1)
2242 {
2243 ZLOGI("SubscribeWithQuery_0400 begin.");
2244 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
2245 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
2246 // 1.本端创建Lv
2247 // 2.远端创建kv
2248
2249 // 3. 远端put int
2250 char strKV[MAX_DATA_LENGTH] = { "math_score_int64_t:99889988" };
2251 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
2252
2253 char str[MAX_DATA_LENGTH] = { 0 };
2254 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2255 char code[10] = { "9999" };
2256 memset_s(code, 10, 0, 10);
2257 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2258 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2259 waitDataWithCode(code, str);
2260 std::cout << "yput-200 get result=" << str << std::endl;
2261 //检查远端是否返回成功
2262 int ret = strcmp(str, "0");
2263 EXPECT_EQ(ret, 0);
2264
2265 // 4. 本段sync远端数据 SubscribeWithQuery
2266 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
2267 remoteDevice.clear();
2268 Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
2269 EXPECT_EQ(status, Status::SUCCESS);
2270
2271 std::vector<std::string> deviceList;
2272 deviceList.clear();
2273 for (const auto& device : remoteDevice) {
2274 std::cout << "start sync deviceId = " << device.deviceId << std::endl;
2275 deviceList.push_back(device.deviceId);
2276 }
2277
2278 DataQuery dataQuery;
2279 dataQuery.KeyPrefix("math");
2280 auto syncStatus = DisKvTest::KvStorePtr->SubscribeWithQuery(deviceList, dataQuery);
2281 EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SubscribeWithQuery";
2282
2283 // 5.本地get数据与200比较
2284 usleep(USLEEP_TIME);
2285
2286 Key keyInt = "math_score_int64_t";
2287 Value valueRetInt;
2288 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2289 EXPECT_EQ(status, Status::SUCCESS);
2290 int64_t aaa = TransferByteArrayToType<int64_t>(valueRetInt.Data());
2291 EXPECT_EQ(aaa, 99889988u);
2292
2293 //////取消订阅
2294 auto unSubscribeStatus = DisKvTest::KvStorePtr->UnsubscribeWithQuery(deviceList, dataQuery);
2295 EXPECT_EQ(unSubscribeStatus, Status::SUCCESS) << "LOGdisDataTest--ERR:SubscribeWithQuery";
2296 }
2297
2298 /**
2299 * @tc.number: SubscribeWithQuery_0500
2300 * @tc.name: SubscribeWithQuery
2301 * @tc.desc: SubscribeWithQuery, size_t data
2302 * @tc.type: FUNC
2303 */
2304 HWTEST_F(DistributedKvDataManagerTest, SubscribeWithQuery_0500, TestSize.Level1)
2305 {
2306 ZLOGI("SubscribeWithQuery_0500 begin.");
2307 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
2308 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
2309 // 1.本端创建Lv
2310 // 2.远端创建kv
2311
2312 // 3. 远端put int
2313 char strKV[MAX_DATA_LENGTH] = { "math_score_size_t:88" };
2314 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
2315
2316 char str[MAX_DATA_LENGTH] = { 0 };
2317 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2318 char code[10] = { "9999" };
2319 memset_s(code, 10, 0, 10);
2320 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2321 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2322 waitDataWithCode(code, str);
2323 std::cout << "yput-200 get result=" << str << std::endl;
2324 //检查远端是否返回成功
2325 int ret = strcmp(str, "0");
2326 EXPECT_EQ(ret, 0);
2327
2328 // 4. 本段sync远端数据 SubscribeWithQuery
2329 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
2330 remoteDevice.clear();
2331 Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
2332 EXPECT_EQ(status, Status::SUCCESS);
2333
2334 std::vector<std::string> deviceList;
2335 deviceList.clear();
2336 for (const auto& device : remoteDevice) {
2337 std::cout << "start sync deviceId = " << device.deviceId << std::endl;
2338 deviceList.push_back(device.deviceId);
2339 }
2340
2341 DataQuery dataQuery;
2342 dataQuery.KeyPrefix("math");
2343 auto syncStatus = DisKvTest::KvStorePtr->SubscribeWithQuery(deviceList, dataQuery);
2344 EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SubscribeWithQuery";
2345
2346 // 5.本地get数据与200比较
2347 usleep(USLEEP_TIME);
2348
2349 Key keyInt = "math_score_size_t";
2350 Value valueRetInt;
2351 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2352 EXPECT_EQ(status, Status::SUCCESS);
2353 size_t aaa = TransferByteArrayToType<size_t>(valueRetInt.Data());
2354 EXPECT_EQ(aaa, 88u);
2355
2356 //////取消订阅
2357 auto unSubscribeStatus = DisKvTest::KvStorePtr->UnsubscribeWithQuery(deviceList, dataQuery);
2358 EXPECT_EQ(unSubscribeStatus, Status::SUCCESS) << "LOGdisDataTest--ERR:SubscribeWithQuery";
2359 }
2360
2361 /**
2362 * @tc.number: SubscribeWithQuery_0600
2363 * @tc.name: SubscribeWithQuery
2364 * @tc.desc: SubscribeWithQuery, string data
2365 * @tc.type: FUNC
2366 */
2367 HWTEST_F(DistributedKvDataManagerTest, SubscribeWithQuery_0600, TestSize.Level1)
2368 {
2369 ZLOGI("SubscribeWithQuery_0600 begin.");
2370 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
2371 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
2372 // 1.本端创建Lv
2373 // 2.远端创建kv
2374
2375 // 3. 远端put int
2376 char strKV[MAX_DATA_LENGTH] = { "math_score_string:{\"class\":88, \"age\":99, \"gradle\":\"QQWWQQ\"}" };
2377 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
2378
2379 char str[MAX_DATA_LENGTH] = { 0 };
2380 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2381 char code[10] = { "9999" };
2382 memset_s(code, 10, 0, 10);
2383 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2384 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2385 waitDataWithCode(code, str);
2386 std::cout << "yput-200 get result=" << str << std::endl;
2387 //检查远端是否返回成功
2388 int ret = strcmp(str, "0");
2389 EXPECT_EQ(ret, 0);
2390
2391 // 4. 本段sync远端数据 SubscribeWithQuery
2392 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
2393 remoteDevice.clear();
2394 Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
2395 EXPECT_EQ(status, Status::SUCCESS);
2396
2397 std::vector<std::string> deviceList;
2398 deviceList.clear();
2399 for (const auto& device : remoteDevice) {
2400 std::cout << "start sync deviceId = " << device.deviceId << std::endl;
2401 deviceList.push_back(device.deviceId);
2402 }
2403
2404 DataQuery dataQuery;
2405 dataQuery.KeyPrefix("math");
2406 auto syncStatus = DisKvTest::KvStorePtr->SubscribeWithQuery(deviceList, dataQuery);
2407 EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SubscribeWithQuery";
2408
2409 // 5.本地get数据与200比较
2410 usleep(USLEEP_TIME);
2411
2412 Key keyInt = "math_score_string";
2413 Value valueRetInt;
2414 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2415 EXPECT_EQ(status, Status::SUCCESS);
2416 std::string aaa = valueRetInt.ToString();
2417 std::string sstring = "{\"class\":88, \"age\":99, \"gradle\":\"QQWWQQ\"}";
2418 EXPECT_EQ(aaa, sstring);
2419
2420 //////取消订阅
2421 auto unSubscribeStatus = DisKvTest::KvStorePtr->UnsubscribeWithQuery(deviceList, dataQuery);
2422 EXPECT_EQ(unSubscribeStatus, Status::SUCCESS) << "LOGdisDataTest--ERR:SubscribeWithQuery";
2423 }
2424
2425 /**
2426 * @tc.number: SubscribeWithQuery_0700
2427 * @tc.name: SubscribeWithQuery
2428 * @tc.desc: SubscribeWithQuery, vector<uint8_t> data
2429 * @tc.type: FUNC
2430 */
2431 HWTEST_F(DistributedKvDataManagerTest, SubscribeWithQuery_0700, TestSize.Level1)
2432 {
2433 ZLOGI("SubscribeWithQuery_0700 begin.");
2434 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
2435 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
2436 // 1.本端创建Lv
2437 // 2.远端创建kv
2438
2439 // 3. 远端put int
2440
2441 std::string stringKey = "math_score_vector";
2442 Key keyInt = stringKey;
2443
2444 std::vector<uint8_t> vect2 = { 9, 9, 8, 8, 7, 7, 6, 6 };
2445 std::string strvc;
2446 strvc.assign(vect2.begin(), vect2.end());
2447
2448 char strKV[MAX_DATA_LENGTH] = { "math_score_int" };
2449 strcpy_s(strKV, strlen(stringKey.c_str()) + 1, stringKey.c_str());
2450 strcat_s(strKV, MAX_DATA_LENGTH, ":");
2451 strcat_s(strKV, MAX_DATA_LENGTH, strvc.c_str());
2452
2453 std::cout << "strvc = " << strvc << std::endl;
2454 std::cout << "strvc.c_str() = " << strvc.c_str() << std::endl;
2455 std::cout << "strKV = " << strKV << std::endl;
2456
2457 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
2458
2459 char str[MAX_DATA_LENGTH] = { 0 };
2460 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2461 char code[10] = { "9999" };
2462 memset_s(code, 10, 0, 10);
2463 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2464 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2465 waitDataWithCode(code, str);
2466 std::cout << "yput-vector<uint8_t> get result=" << str << std::endl;
2467 //检查远端是否返回成功
2468 int ret = strcmp(str, "0");
2469 EXPECT_EQ(ret, 0);
2470
2471 // 4. 本段sync远端数据 SubscribeWithQuery
2472 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
2473 remoteDevice.clear();
2474 Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
2475 EXPECT_EQ(status, Status::SUCCESS);
2476
2477 std::vector<std::string> deviceList;
2478 deviceList.clear();
2479 for (const auto& device : remoteDevice) {
2480 std::cout << "start sync deviceId = " << device.deviceId << std::endl;
2481 deviceList.push_back(device.deviceId);
2482 }
2483
2484 DataQuery dataQuery;
2485 dataQuery.KeyPrefix("math");
2486 auto syncStatus = DisKvTest::KvStorePtr->SubscribeWithQuery(deviceList, dataQuery);
2487 EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SubscribeWithQuery";
2488
2489 // 5.本地get数据与200比较
2490 usleep(USLEEP_TIME);
2491
2492 Value valueRetInt;
2493 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2494 EXPECT_EQ(status, Status::SUCCESS);
2495 std::string strValueRet = valueRetInt.ToString();
2496 EXPECT_EQ(strvc, strValueRet.c_str());
2497
2498 //////取消订阅
2499 auto unSubscribeStatus = DisKvTest::KvStorePtr->UnsubscribeWithQuery(deviceList, dataQuery);
2500 EXPECT_EQ(unSubscribeStatus, Status::SUCCESS) << "LOGdisDataTest--ERR:SubscribeWithQuery";
2501 }
2502
2503 /**
2504 * @tc.number: SyncWithCondition_0100
2505 * @tc.name: SyncWithCondition
2506 * @tc.desc: SyncWithCondition, int data
2507 * @tc.type: FUNC
2508 */
2509 HWTEST_F(DistributedKvDataManagerTest, SyncWithCondition_0100, TestSize.Level1)
2510 {
2511 ZLOGI("SyncWithCondition_0100 begin.");
2512 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
2513 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
2514 // 1.本端创建Lv
2515 // 2.远端创建kv
2516
2517 // 3. 远端put int
2518 // char strPut[MAX_DATA_LENGTH] = {"math_score_int:200"};
2519 char strKV[MAX_DATA_LENGTH] = { "math_score_int" };
2520 memset_s(strKV, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2521 strcpy_s(strKV, strlen("math_score_int:200") + 1, "math_score_int:200");
2522 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
2523
2524 char str[MAX_DATA_LENGTH] = { 0 };
2525 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2526 char code[10] = { "9999" };
2527 memset_s(code, 10, 0, 10);
2528 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2529 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2530 waitDataWithCode(code, str);
2531 std::cout << "yput-200 get result=" << str << std::endl;
2532 //检查远端是否返回成功
2533 int ret = strcmp(str, "0");
2534 EXPECT_EQ(ret, 0);
2535
2536 // 4. 本段sync远端数据 SyncWithCondition
2537 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
2538 remoteDevice.clear();
2539 Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
2540 EXPECT_EQ(status, Status::SUCCESS);
2541
2542 std::vector<std::string> deviceList;
2543 deviceList.clear();
2544 for (const auto& device : remoteDevice) {
2545 std::cout << "start sync deviceId = " << device.deviceId << std::endl;
2546 deviceList.push_back(device.deviceId);
2547 }
2548
2549 DataQuery dataQuery;
2550 dataQuery.KeyPrefix("math");
2551 auto syncStatus = DisKvTest::KvStorePtr->SyncWithCondition(deviceList, SyncMode::PULL, dataQuery);
2552 EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SyncWithCondition";
2553
2554 // 5.本地get数据与200比较
2555 usleep(USLEEP_TIME);
2556
2557 Value valueRetInt;
2558 Key keyInt = "math_score_int";
2559 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2560 EXPECT_EQ(status, Status::SUCCESS);
2561 int aaa = TransferByteArrayToType<int>(valueRetInt.Data());
2562 std::cout << "LOGdisDataTest--本地get数据与200比较: aaa = " << aaa << std::endl;
2563 EXPECT_EQ(aaa, 200);
2564 }
2565
2566 /**
2567 * @tc.number: SyncWithCondition_0200
2568 * @tc.name: SyncWithCondition
2569 * @tc.desc: SyncWithCondition, float data
2570 * @tc.type: FUNC
2571 */
2572 HWTEST_F(DistributedKvDataManagerTest, SyncWithCondition_0200, TestSize.Level1)
2573 {
2574 ZLOGI("SyncWithCondition_0200 begin.");
2575 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
2576 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
2577 // 1.本端创建Lv
2578 // 2.远端创建kv
2579
2580 // 3. 远端put int
2581 char strKV[MAX_DATA_LENGTH] = { "math_score_float:9.99" };
2582 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
2583
2584 char str[MAX_DATA_LENGTH] = { 0 };
2585 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2586 char code[10] = { "9999" };
2587 memset_s(code, 10, 0, 10);
2588 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2589 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2590 waitDataWithCode(code, str);
2591 std::cout << "yput-200 get result=" << str << std::endl;
2592 //检查远端是否返回成功
2593 int ret = strcmp(str, "0");
2594 EXPECT_EQ(ret, 0);
2595
2596 // 4. 本段sync远端数据 SyncWithCondition
2597 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
2598 remoteDevice.clear();
2599 Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
2600 EXPECT_EQ(status, Status::SUCCESS);
2601
2602 std::vector<std::string> deviceList;
2603 deviceList.clear();
2604 for (const auto& device : remoteDevice) {
2605 std::cout << "start sync deviceId = " << device.deviceId << std::endl;
2606 deviceList.push_back(device.deviceId);
2607 }
2608
2609 DataQuery dataQuery;
2610 dataQuery.KeyPrefix("math");
2611 auto syncStatus = DisKvTest::KvStorePtr->SyncWithCondition(deviceList, SyncMode::PULL, dataQuery);
2612 EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SyncWithCondition";
2613
2614 // 5.本地get数据与200比较
2615 usleep(USLEEP_TIME);
2616
2617 Value valueRetInt;
2618 std::string stringKey = "math_score_float";
2619 Key keyInt = stringKey;
2620 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2621 EXPECT_EQ(status, Status::SUCCESS) << "LOGdisDataTest--ERR:Get(keyInt, valueRetInt)";
2622 float aaa = TransferByteArrayToType<float>(valueRetInt.Data());
2623 float delta = aaa - 9.99f;
2624 EXPECT_LE(std::abs(delta), 0.00001);
2625 }
2626
2627 /**
2628 * @tc.number: SyncWithCondition_0300
2629 * @tc.name: SyncWithCondition
2630 * @tc.desc: SyncWithCondition, double data
2631 * @tc.type: FUNC
2632 */
2633 HWTEST_F(DistributedKvDataManagerTest, SyncWithCondition_0300, TestSize.Level1)
2634 {
2635 ZLOGI("SyncWithCondition_0300 begin.");
2636 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
2637 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
2638 // 1.本端创建Lv
2639 // 2.远端创建kv
2640
2641 // 3. 远端put int
2642 char strKV[MAX_DATA_LENGTH] = { "math_score_double:999.999" };
2643 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
2644
2645 char str[MAX_DATA_LENGTH] = { 0 };
2646 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2647 char code[10] = { "9999" };
2648 memset_s(code, 10, 0, 10);
2649 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2650 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2651 waitDataWithCode(code, str);
2652 std::cout << "yput-200 get result=" << str << std::endl;
2653 //检查远端是否返回成功
2654 int ret = strcmp(str, "0");
2655 EXPECT_EQ(ret, 0);
2656
2657 // 4. 本段sync远端数据 SyncWithCondition
2658 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
2659 remoteDevice.clear();
2660 Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
2661 EXPECT_EQ(status, Status::SUCCESS);
2662
2663 std::vector<std::string> deviceList;
2664 deviceList.clear();
2665 for (const auto& device : remoteDevice) {
2666 std::cout << "start sync deviceId = " << device.deviceId << std::endl;
2667 deviceList.push_back(device.deviceId);
2668 }
2669
2670 DataQuery dataQuery;
2671 dataQuery.KeyPrefix("math");
2672 auto syncStatus = DisKvTest::KvStorePtr->SyncWithCondition(deviceList, SyncMode::PULL, dataQuery);
2673 EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SyncWithCondition";
2674
2675 // 5.本地get数据与200比较
2676 usleep(USLEEP_TIME);
2677
2678 Value valueRetInt;
2679 std::string stringKey = "math_score_double";
2680 Key keyInt = stringKey;
2681 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2682 EXPECT_EQ(status, Status::SUCCESS);
2683 double aaa = TransferByteArrayToType<double>(valueRetInt.Data());
2684 double delta = aaa - 999.999;
2685 std::cout << "aaa = " << aaa << std::endl;
2686 std::cout << "delta = " << delta << std::endl;
2687 EXPECT_LE(std::abs(delta), 0.00001);
2688 }
2689
2690 /**
2691 * @tc.number: SyncWithCondition_0400
2692 * @tc.name: SyncWithCondition
2693 * @tc.desc: SyncWithCondition, int64_t data
2694 * @tc.type: FUNC
2695 */
2696 HWTEST_F(DistributedKvDataManagerTest, SyncWithCondition_0400, TestSize.Level1)
2697 {
2698 ZLOGI("SyncWithCondition_0400 begin.");
2699 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
2700 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
2701 // 1.本端创建Lv
2702 // 2.远端创建kv
2703
2704 // 3. 远端put int
2705 char strKV[MAX_DATA_LENGTH] = { "math_score_int64_t:99889988" };
2706 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
2707
2708 char str[MAX_DATA_LENGTH] = { 0 };
2709 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2710 char code[10] = { "9999" };
2711 memset_s(code, 10, 0, 10);
2712 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2713 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2714 waitDataWithCode(code, str);
2715 std::cout << "yput-200 get result=" << str << std::endl;
2716 //检查远端是否返回成功
2717 int ret = strcmp(str, "0");
2718 EXPECT_EQ(ret, 0);
2719
2720 // 4. 本段sync远端数据 SyncWithCondition
2721 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
2722 remoteDevice.clear();
2723 Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
2724 EXPECT_EQ(status, Status::SUCCESS);
2725
2726 std::vector<std::string> deviceList;
2727 deviceList.clear();
2728 for (const auto& device : remoteDevice) {
2729 std::cout << "start sync deviceId = " << device.deviceId << std::endl;
2730 deviceList.push_back(device.deviceId);
2731 }
2732
2733 DataQuery dataQuery;
2734 dataQuery.KeyPrefix("math");
2735 auto syncStatus = DisKvTest::KvStorePtr->SyncWithCondition(deviceList, SyncMode::PULL, dataQuery);
2736 EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SyncWithCondition";
2737
2738 // 5.本地get数据与200比较
2739 usleep(USLEEP_TIME);
2740
2741 Key keyInt = "math_score_int64_t";
2742 Value valueRetInt;
2743 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2744 EXPECT_EQ(status, Status::SUCCESS);
2745 int64_t aaa = TransferByteArrayToType<int64_t>(valueRetInt.Data());
2746 EXPECT_EQ(aaa, 99889988u);
2747 }
2748
2749 /**
2750 * @tc.number: SyncWithCondition_0500
2751 * @tc.name: SyncWithCondition
2752 * @tc.desc: SyncWithCondition, size_t data
2753 * @tc.type: FUNC
2754 */
2755 HWTEST_F(DistributedKvDataManagerTest, SyncWithCondition_0500, TestSize.Level1)
2756 {
2757 ZLOGI("SyncWithCondition_0500 begin.");
2758 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
2759 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
2760 // 1.本端创建Lv
2761 // 2.远端创建kv
2762
2763 // 3. 远端put int
2764 char strKV[MAX_DATA_LENGTH] = { "math_score_size_t:88" };
2765 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
2766
2767 char str[MAX_DATA_LENGTH] = { 0 };
2768 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2769 char code[10] = { "9999" };
2770 memset_s(code, 10, 0, 10);
2771 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2772 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2773 waitDataWithCode(code, str);
2774 std::cout << "yput-200 get result=" << str << std::endl;
2775 //检查远端是否返回成功
2776 int ret = strcmp(str, "0");
2777 EXPECT_EQ(ret, 0);
2778
2779 // 4. 本段sync远端数据 SyncWithCondition
2780 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
2781 remoteDevice.clear();
2782 Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
2783 EXPECT_EQ(status, Status::SUCCESS);
2784
2785 std::vector<std::string> deviceList;
2786 deviceList.clear();
2787 for (const auto& device : remoteDevice) {
2788 std::cout << "start sync deviceId = " << device.deviceId << std::endl;
2789 deviceList.push_back(device.deviceId);
2790 }
2791
2792 DataQuery dataQuery;
2793 dataQuery.KeyPrefix("math");
2794 auto syncStatus = DisKvTest::KvStorePtr->SyncWithCondition(deviceList, SyncMode::PULL, dataQuery);
2795 EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SyncWithCondition";
2796
2797 // 5.本地get数据与200比较
2798 usleep(USLEEP_TIME);
2799
2800 Key keyInt = "math_score_size_t";
2801 Value valueRetInt;
2802 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2803 EXPECT_EQ(status, Status::SUCCESS);
2804 size_t aaa = TransferByteArrayToType<size_t>(valueRetInt.Data());
2805 EXPECT_EQ(aaa, 88u);
2806 }
2807
2808 /**
2809 * @tc.number: SyncWithCondition_0600
2810 * @tc.name: SyncWithCondition
2811 * @tc.desc: SyncWithCondition, string data
2812 * @tc.type: FUNC
2813 */
2814 HWTEST_F(DistributedKvDataManagerTest, SyncWithCondition_0600, TestSize.Level1)
2815 {
2816 ZLOGI("SyncWithCondition_0600 begin.");
2817 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
2818 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
2819 // 1.本端创建Lv
2820 // 2.远端创建kv
2821
2822 // 3. 远端put int
2823 char strKV[MAX_DATA_LENGTH] = { "math_score_string:{\"class\":88, \"age\":99, \"gradle\":\"QQWWQQ\"}" };
2824 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
2825
2826 char str[MAX_DATA_LENGTH] = { 0 };
2827 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2828 char code[10] = { "9999" };
2829 memset_s(code, 10, 0, 10);
2830 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2831 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2832 waitDataWithCode(code, str);
2833 std::cout << "yput-200 get result=" << str << std::endl;
2834 //检查远端是否返回成功
2835 int ret = strcmp(str, "0");
2836 EXPECT_EQ(ret, 0);
2837
2838 // 4. 本段sync远端数据 SyncWithCondition
2839 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
2840 remoteDevice.clear();
2841 Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
2842 EXPECT_EQ(status, Status::SUCCESS);
2843
2844 std::vector<std::string> deviceList;
2845 deviceList.clear();
2846 for (const auto& device : remoteDevice) {
2847 std::cout << "start sync deviceId = " << device.deviceId << std::endl;
2848 deviceList.push_back(device.deviceId);
2849 }
2850
2851 DataQuery dataQuery;
2852 dataQuery.KeyPrefix("math");
2853 auto syncStatus = DisKvTest::KvStorePtr->SyncWithCondition(deviceList, SyncMode::PULL, dataQuery);
2854 EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SyncWithCondition";
2855
2856 // 5.本地get数据与200比较
2857 usleep(USLEEP_TIME);
2858
2859 Key keyInt = "math_score_string";
2860 Value valueRetInt;
2861 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2862 EXPECT_EQ(status, Status::SUCCESS);
2863 std::string aaa = valueRetInt.ToString();
2864 std::string sstring = "{\"class\":88, \"age\":99, \"gradle\":\"QQWWQQ\"}";
2865 EXPECT_EQ(aaa, sstring);
2866 }
2867
2868 /**
2869 * @tc.number: SyncWithCondition_0700
2870 * @tc.name: SyncWithCondition
2871 * @tc.desc: SyncWithCondition, vector<uint8_t> data
2872 * @tc.type: FUNC
2873 */
2874 HWTEST_F(DistributedKvDataManagerTest, SyncWithCondition_0700, TestSize.Level1)
2875 {
2876 ZLOGI("SyncWithCondition_0700 begin.");
2877 EXPECT_EQ(Status::SUCCESS, DisKvTest::statusGetKvStore) << "statusGetKvStore return wrong status";
2878 EXPECT_NE(nullptr, DisKvTest::KvStorePtr) << "KvStorePtr is nullptr";
2879 // 1.本端创建Lv
2880 // 2.远端创建kv
2881
2882 // 3. 远端put int
2883 std::string stringKey = "math_score_vector";
2884 Key keyInt = stringKey;
2885
2886 std::vector<uint8_t> vect2 = { 9, 9, 8, 8, 7, 7, 6, 6 };
2887 std::string strvc;
2888 strvc.assign(vect2.begin(), vect2.end());
2889
2890 char strKV[MAX_DATA_LENGTH] = { "math_score_int" };
2891 strcpy_s(strKV, strlen(stringKey.c_str()) + 1, stringKey.c_str());
2892 strcat_s(strKV, MAX_DATA_LENGTH, ":");
2893 strcat_s(strKV, MAX_DATA_LENGTH, strvc.c_str());
2894
2895 std::cout << "strvc = " << strvc << std::endl;
2896 std::cout << "strvc.c_str() = " << strvc.c_str() << std::endl;
2897 std::cout << "strKV = " << strKV << std::endl;
2898
2899 writeCodeDataToShm(CTRL_CODE_DATAMGR_PUT_DATA, strKV);
2900
2901 char str[MAX_DATA_LENGTH] = { 0 };
2902 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2903 char code[10] = { "9999" };
2904 memset_s(code, 10, 0, 10);
2905 strcpy_s(code, strlen(Int2String(CTRL_CODE_RESULT_TYPE, str)) + 1, Int2String(CTRL_CODE_RESULT_TYPE, str)); // 9999
2906 memset_s(str, MAX_DATA_LENGTH, 0, MAX_DATA_LENGTH);
2907 waitDataWithCode(code, str);
2908 std::cout << "yput-200 get result=" << str << std::endl;
2909 //检查远端是否返回成功
2910 int ret = strcmp(str, "0");
2911 EXPECT_EQ(ret, 0);
2912
2913 // 4. 本段sync远端数据 SyncWithCondition
2914 std::vector<OHOS::DistributedKv::DeviceInfo> remoteDevice;
2915 remoteDevice.clear();
2916 Status status = DisKvTest::manager.GetDeviceList(remoteDevice, DeviceFilterStrategy::NO_FILTER);
2917 EXPECT_EQ(status, Status::SUCCESS);
2918
2919 std::vector<std::string> deviceList;
2920 deviceList.clear();
2921 for (const auto& device : remoteDevice) {
2922 std::cout << "start sync deviceId = " << device.deviceId << std::endl;
2923 deviceList.push_back(device.deviceId);
2924 }
2925
2926 DataQuery dataQuery;
2927 dataQuery.KeyPrefix("math");
2928 auto syncStatus = DisKvTest::KvStorePtr->SyncWithCondition(deviceList, SyncMode::PULL, dataQuery);
2929 EXPECT_EQ(syncStatus, Status::SUCCESS) << "LOGdisDataTest--SUCCESS:SyncWithCondition";
2930
2931 // 5.本地get数据与200比较
2932 usleep(USLEEP_TIME);
2933
2934 Value valueRetInt;
2935 status = DisKvTest::KvStorePtr->Get(keyInt, valueRetInt);
2936 EXPECT_EQ(status, Status::SUCCESS);
2937 std::string strValueRet = valueRetInt.ToString();
2938 EXPECT_EQ(strvc, strValueRet.c_str());
2939 }
2940