1 /*
2  * Copyright (c) 2024 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 #include "water_version_manager.h"
16 
17 #include "accesstoken_kit.h"
18 #include "block_data.h"
19 #include "bootstrap.h"
20 #include "checker/checker_manager.h"
21 #include "device_manager_adapter.h"
22 #include "executor_pool.h"
23 #include "gtest/gtest.h"
24 #include "metadata/matrix_meta_data.h"
25 #include "metadata/meta_data_manager.h"
26 #include "mock/checker_mock.h"
27 #include "mock/db_store_mock.h"
28 #include "nativetoken_kit.h"
29 #include "serializable/serializable.h"
30 #include "token_setproc.h"
31 #include "utils/constant.h"
32 using namespace testing::ext;
33 using namespace OHOS::DistributedData;
34 using namespace DistributedDB;
35 using namespace OHOS::Security::AccessToken;
36 using WvManager = WaterVersionManager;
37 using DMAdapter = DeviceManagerAdapter;
38 using WaterVersionMetaData = WvManager::WaterVersionMetaData;
39 
40 namespace OHOS::Test {
41 namespace DistributedDataTest {
42 static std::vector<std::pair<std::string, std::string>> staticStores_ = { { "bundle0", "store0" },
43     { "bundle1", "store0" }, { "bundle2", "store0" } };
44 static std::vector<std::pair<std::string, std::string>> dynamicStores_ = { { "bundle0", "store1" },
45     { "bundle3", "store0" }, { "bundle4", "store0" } };
46 class WaterVersionManagerTest : public testing::Test {
47 public:
48     static void SetUpTestCase(void);
49     static void TearDownTestCase(void);
50     void SetUp();
51     void TearDown();
52 
53 protected:
54     static constexpr const char *TEST_DEVICE = "14a0a92a428005db27c40bad46bf145fede38ec37effe0347cd990fcb031f320";
55     static void GrantPermissionNative();
56     void InitMetaData();
57 
58     static std::shared_ptr<DBStoreMock> dbStoreMock_;
59     static WaterVersionMetaData dynamicMeta_;
60     static WaterVersionMetaData staticMeta_;
61     static CheckerMock instance_;
62 };
63 
GrantPermissionNative()64 void WaterVersionManagerTest::GrantPermissionNative()
65 {
66     const char **perms = new const char *[2];
67     perms[0] = "ohos.permission.DISTRIBUTED_DATASYNC";
68     perms[1] = "ohos.permission.ACCESS_SERVICE_DM";
69     TokenInfoParams infoInstance = {
70         .dcapsNum = 0,
71         .permsNum = 2,
72         .aclsNum = 0,
73         .dcaps = nullptr,
74         .perms = perms,
75         .acls = nullptr,
76         .processName = "WaterVersionManagerTest",
77         .aplStr = "system_basic",
78     };
79     uint64_t tokenId = GetAccessTokenId(&infoInstance);
80     SetSelfTokenID(tokenId);
81     AccessTokenKit::ReloadNativeTokenInfo();
82     delete[] perms;
83 }
84 CheckerMock WaterVersionManagerTest::instance_;
85 std::shared_ptr<DBStoreMock> WaterVersionManagerTest::dbStoreMock_ = std::make_shared<DBStoreMock>();
86 WaterVersionMetaData WaterVersionManagerTest::staticMeta_;
87 WaterVersionMetaData WaterVersionManagerTest::dynamicMeta_;
SetUpTestCase(void)88 void WaterVersionManagerTest::SetUpTestCase(void)
89 {
90     size_t max = 12;
91     size_t min = 5;
92     DeviceManagerAdapter::GetInstance().Init(std::make_shared<OHOS::ExecutorPool>(max, min));
93     GrantPermissionNative();
94     Bootstrap::GetInstance().LoadCheckers();
95     std::vector<CheckerManager::StoreInfo> dynamicStores;
96     for (auto &[bundle, store] : dynamicStores_) {
97         dynamicStores.push_back({ 0, 0, bundle, store });
98         instance_.SetDynamic(dynamicStores);
99     }
100     std::vector<CheckerManager::StoreInfo> staticStores;
101     for (auto &[bundle, store] : staticStores_) {
102         staticStores.push_back({ 0, 0, bundle, store });
103         instance_.SetStatic(staticStores);
104     }
105     WaterVersionManager::GetInstance().Init();
106     MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr);
107 
108     staticMeta_.deviceId = TEST_DEVICE;
109     staticMeta_.version = WvManager::WaterVersionMetaData::DEFAULT_VERSION;
110     staticMeta_.waterVersion = 0;
111     staticMeta_.type = WvManager::STATIC;
112     staticMeta_.keys.clear();
113     for (auto &it : staticStores_) {
114         staticMeta_.keys.push_back(Constant::Join(it.first, Constant::KEY_SEPARATOR, { it.second }));
115     }
116     staticMeta_.infos = { staticMeta_.keys.size(), std::vector<uint64_t>(staticMeta_.keys.size(), 0) };
117     dynamicMeta_ = staticMeta_;
118     dynamicMeta_.keys.clear();
119     for (auto &it : dynamicStores_) {
120         dynamicMeta_.keys.push_back(Constant::Join(it.first, Constant::KEY_SEPARATOR, { it.second }));
121     }
122     dynamicMeta_.infos = { dynamicMeta_.keys.size(), std::vector<uint64_t>(dynamicMeta_.keys.size(), 0) };
123     dynamicMeta_.type = WvManager::DYNAMIC;
124 }
125 
TearDownTestCase(void)126 void WaterVersionManagerTest::TearDownTestCase(void) {}
127 
SetUp()128 void WaterVersionManagerTest::SetUp()
129 {
130     InitMetaData();
131 }
132 
TearDown()133 void WaterVersionManagerTest::TearDown()
134 {
135     WvManager::GetInstance().DelWaterVersion(TEST_DEVICE);
136     WvManager::GetInstance().DelWaterVersion(DMAdapter::GetInstance().GetLocalDevice().uuid);
137     MetaDataManager::GetInstance().DelMeta(staticMeta_.GetKey(), true);
138     MetaDataManager::GetInstance().DelMeta(dynamicMeta_.GetKey(), true);
139     MatrixMetaData matrixMetaData;
140     matrixMetaData.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid;
141     MetaDataManager::GetInstance().DelMeta(matrixMetaData.GetKey(), true);
142 }
143 
InitMetaData()144 void WaterVersionManagerTest::InitMetaData()
145 {
146     MetaDataManager::GetInstance().SaveMeta(staticMeta_.GetKey(), staticMeta_, true);
147     MetaDataManager::GetInstance().SaveMeta(dynamicMeta_.GetKey(), dynamicMeta_, true);
148 }
149 
150 /**
151 * @tc.name: SetWaterVersionTest1
152 * @tc.desc: updating remote device water version once;
153 * @tc.type: FUNC
154 * @tc.require:
155 * @tc.author: ht
156 */
157 HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest1, TestSize.Level0)
158 {
159     std::string waterVersion = WvManager::GetInstance().GetWaterVersion(TEST_DEVICE, WvManager::STATIC);
160     ASSERT_EQ(waterVersion, Serializable::Marshall(staticMeta_)) << "meta: " << waterVersion;
161     WvManager::WaterVersionMetaData meta;
162     ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta));
163     meta.infos[0] = { 1, 0, 0 };
164     meta.waterVersion = 1;
165 
166     EXPECT_TRUE(WvManager::GetInstance().SetWaterVersion(staticStores_[0].first, staticStores_[0].second,
167         Serializable::Marshall(meta)))
168         << Serializable::Marshall(meta);
169 
170     waterVersion = WvManager::GetInstance().GetWaterVersion(TEST_DEVICE, WvManager::STATIC);
171     ASSERT_EQ(Serializable::Marshall(meta), waterVersion);
172     auto [success, version] = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::STATIC);
173     EXPECT_TRUE(success && version == 1)
174         << "success:" << success << " version:" << version << " meta: " << meta.ToAnonymousString();
175 
176     // update to matrixMeta
177     MatrixMetaData matrixMetaData;
178     matrixMetaData.deviceId = TEST_DEVICE;
179     EXPECT_TRUE(MetaDataManager::GetInstance().LoadMeta(matrixMetaData.GetConsistentKey(), matrixMetaData, true));
180     EXPECT_EQ(matrixMetaData.statics, version << 4);
181 }
182 
183 /**
184 * @tc.name: SetWaterVersionTest2
185 * @tc.desc: Continuously updating remote device water version more than once;
186 * @tc.type: FUNC
187 * @tc.require:
188 * @tc.author: ht
189 */
190 HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest2, TestSize.Level0)
191 {
192     std::string waterVersion = WvManager::GetInstance().GetWaterVersion(TEST_DEVICE, WvManager::STATIC);
193     ASSERT_EQ(waterVersion, Serializable::Marshall(staticMeta_)) << "meta: " << waterVersion;
194     WvManager::WaterVersionMetaData meta;
195     ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta));
196     // first store update
197     meta.infos[0] = { 1, 0, 0 };
198     meta.waterVersion = 1;
199     EXPECT_TRUE(WvManager::GetInstance().SetWaterVersion(staticStores_[0].first, staticStores_[0].second,
200         Serializable::Marshall(meta)));
201     auto [_, version] = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::STATIC);
202     EXPECT_EQ(version, 1);
203 
204     // second store update
205     meta.infos[1] = { 1, 2, 0 };
206     meta.waterVersion = 2;
207     EXPECT_TRUE(WvManager::GetInstance().SetWaterVersion(staticStores_[1].first, staticStores_[1].second,
208         Serializable::Marshall(meta)));
209     std::tie(_, version) = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::STATIC);
210     EXPECT_EQ(version, 2);
211 
212     // update to matrixMeta
213     MatrixMetaData matrixMetaData;
214     matrixMetaData.deviceId = TEST_DEVICE;
215     EXPECT_TRUE(MetaDataManager::GetInstance().LoadMeta(matrixMetaData.GetConsistentKey(), matrixMetaData, true));
216     EXPECT_EQ(matrixMetaData.statics, version << 4);
217 }
218 
219 /**
220 * @tc.name: SetWaterVersionTest3
221 * @tc.desc: A updates first, but B synchronizes first
222 * @tc.type: FUNC
223 * @tc.require:
224 * @tc.author: ht
225 */
226 HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest3, TestSize.Level0)
227 {
228     std::string waterVersion = WvManager::GetInstance().GetWaterVersion(TEST_DEVICE, WvManager::DYNAMIC);
229     ASSERT_EQ(waterVersion, Serializable::Marshall(dynamicMeta_)) << "meta: " << waterVersion;
230     WvManager::WaterVersionMetaData meta;
231     ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta));
232     EXPECT_EQ(meta.GetVersion(), 0) << "meta: " << Serializable::Marshall(meta);
233 
234     //bundle2 updated later, but sync first. Do not update waterVersion
235     meta.infos[1] = { 1, 2, 0 };
236     meta.waterVersion = 2;
237     EXPECT_TRUE(WvManager::GetInstance().SetWaterVersion(dynamicStores_[1].first, dynamicStores_[1].second,
238         Serializable::Marshall(meta)));
239     auto res = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::STATIC);
240     EXPECT_TRUE(res.first && res.second == 0)
241         << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString();
242 
243     //bundle1 updated earlier, but sync later. update waterVersion
244     meta.infos[0] = { 1, 0, 0 };
245     meta.waterVersion = 1;
246     EXPECT_TRUE(WvManager::GetInstance().SetWaterVersion(dynamicStores_[0].first, dynamicStores_[0].second,
247         Serializable::Marshall(meta)));
248     res = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::DYNAMIC);
249     EXPECT_TRUE(res.first && res.second == 2)
250         << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString();
251 
252     // update to matrixMeta
253     MatrixMetaData matrixMetaData;
254     matrixMetaData.deviceId = TEST_DEVICE;
255     EXPECT_TRUE(MetaDataManager::GetInstance().LoadMeta(matrixMetaData.GetConsistentKey(), matrixMetaData, true));
256     EXPECT_EQ(matrixMetaData.dynamic, res.second << 4);
257 }
258 
259 /**
260 * @tc.name: SetWaterVersionTest4
261 * @tc.desc: updates twice, but sync once
262 * @tc.type: FUNC
263 * @tc.require:
264 * @tc.author: ht
265 */
266 HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest4, TestSize.Level0)
267 {
268     std::string waterVersion = WvManager::GetInstance().GetWaterVersion(TEST_DEVICE, WvManager::STATIC);
269     ASSERT_EQ(waterVersion, Serializable::Marshall(staticMeta_)) << "meta: " << waterVersion;
270     WvManager::WaterVersionMetaData meta;
271     ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta));
272     EXPECT_EQ(meta.GetVersion(), 0) << "meta: " << Serializable::Marshall(meta);
273 
274     //bundle1 updated twice, but sync once. update waterVersion
275     meta.infos[0] = { 2, 0, 0 };
276     meta.waterVersion = 2;
277     EXPECT_TRUE(WvManager::GetInstance().SetWaterVersion(staticStores_[0].first, staticStores_[0].second,
278         Serializable::Marshall(meta)));
279 
280     auto res = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::STATIC);
281     EXPECT_TRUE(res.first && res.second == 2)
282         << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString();
283 }
284 
285 /**
286 * @tc.name: SetWaterVersionTest5
287 * @tc.desc: Update(upload) multiple times, sync(download) fewer times
288 * @tc.type: FUNC
289 * @tc.require:
290 * @tc.author: ht
291 */
292 HWTEST_F(WaterVersionManagerTest, SetWaterVersionTest5, TestSize.Level0)
293 {
294     auto type = WvManager::DYNAMIC;
295     std::string waterVersion = WvManager::GetInstance().GetWaterVersion(TEST_DEVICE, type);
296     ASSERT_EQ(waterVersion, Serializable::Marshall(dynamicMeta_)) << "meta: " << waterVersion;
297     WvManager::WaterVersionMetaData meta;
298     ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta));
299     EXPECT_EQ(meta.GetVersion(), 0) << "meta: " << Serializable::Marshall(meta);
300 
301     //order: 0(u)->1(u)->0(u)->2(u)->1(s)->2(s)->1(u)->1(u)->0(s)
302     //1 sync
303     meta.infos[0] = { 1, 0, 0 };
304     meta.infos[1] = { 1, 2, 0 };
305     meta.infos[2] = { 0, 0, 0 };
306     meta.waterVersion = 2;
307     EXPECT_TRUE(WvManager::GetInstance().SetWaterVersion(dynamicStores_[1].first, dynamicStores_[1].second,
308         Serializable::Marshall(meta)));
309 
310     auto res = WvManager::GetInstance().GetVersion(TEST_DEVICE, type);
311     EXPECT_TRUE(res.first && res.second == 0)
312         << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString();
313 
314     //2 sync
315     meta.infos[0] = { 3, 2, 0 };
316     meta.infos[1] = { 1, 2, 0 };
317     meta.infos[2] = { 3, 2, 4 };
318     meta.waterVersion = 4;
319     EXPECT_TRUE(WvManager::GetInstance().SetWaterVersion(dynamicStores_[2].first, dynamicStores_[2].second,
320         Serializable::Marshall(meta)));
321     res = WvManager::GetInstance().GetVersion(TEST_DEVICE, type);
322     EXPECT_TRUE(res.first && res.second == 0)
323         << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString();
324 
325     //0 sync
326     meta.infos[0] = { 3, 2, 0 };
327     meta.infos[1] = { 1, 2, 0 };
328     meta.infos[2] = { 0, 0, 0 };
329     meta.waterVersion = 3;
330     EXPECT_TRUE(WvManager::GetInstance().SetWaterVersion(dynamicStores_[0].first, dynamicStores_[0].second,
331         Serializable::Marshall(meta)));
332     res = WvManager::GetInstance().GetVersion(TEST_DEVICE, type);
333     EXPECT_TRUE(res.first && res.second == 4)
334         << "success:" << res.first << " version:" << res.second << " meta: " << meta.ToAnonymousString();
335 }
336 
337 /**
338 * @tc.name: GenerateWaterVersionTest1
339 * @tc.desc: GenerateWaterVersion once, add one to the waterVersion
340 * @tc.type: FUNC
341 * @tc.require:
342 * @tc.author: ht
343 */
344 HWTEST_F(WaterVersionManagerTest, GenerateWaterVersionTest1, TestSize.Level0)
345 {
346     std::string waterVersion =
347         WvManager::GetInstance().GenerateWaterVersion(staticStores_[0].first, staticStores_[0].second);
348     WvManager::WaterVersionMetaData meta;
349     ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)) << "waterVersion: " << waterVersion;
350     EXPECT_EQ(meta.waterVersion, 1) << "waterVersion: " << waterVersion;
351 
352     waterVersion = WvManager::GetInstance().GenerateWaterVersion(staticStores_[1].first, staticStores_[1].second);
353     ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)) << "waterVersion: " << waterVersion;
354     EXPECT_EQ(meta.waterVersion, 2) << "waterVersion: " << waterVersion;
355 
356     waterVersion = WvManager::GetInstance().GenerateWaterVersion(staticStores_[0].first, staticStores_[0].second);
357     ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)) << "waterVersion: " << waterVersion;
358     EXPECT_EQ(meta.waterVersion, 3) << "waterVersion: " << waterVersion;
359 
360     MatrixMetaData matrixMetaData;
361     matrixMetaData.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid;
362     auto key = matrixMetaData.GetKey();
363     ASSERT_TRUE(MetaDataManager::GetInstance().LoadMeta(key, matrixMetaData, true));
364     EXPECT_EQ(matrixMetaData.statics & 0xFFF0, 3 << 4);
365 }
366 
367 /**
368 * @tc.name: GenerateWaterVersionTest2
369 * @tc.desc: Multiple threads simultaneously GenerateWaterVersion
370 * @tc.type: FUNC
371 * @tc.require:
372 * @tc.author: ht
373 */
374 HWTEST_F(WaterVersionManagerTest, GenerateWaterVersionTest2, TestSize.Level0)
375 {
376     auto executorPool = std::make_shared<ExecutorPool>(5, 5);
377     auto len = dynamicStores_.size();
378     for (size_t i = 0; i < 10; ++i) {
__anon5220b2e90102null379         executorPool->Execute([index = i % len] {
380             WvManager::GetInstance().GenerateWaterVersion(dynamicStores_[index].first, dynamicStores_[index].second);
381         });
382     }
383     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
384 
385     auto [success, version] =
386         WvManager::GetInstance().GetVersion(DMAdapter::GetInstance().GetLocalDevice().uuid, WvManager::DYNAMIC);
387     EXPECT_EQ(version, 10);
388 
389     MatrixMetaData matrixMetaData;
390     matrixMetaData.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid;
391     auto key = matrixMetaData.GetKey();
392     ASSERT_TRUE(MetaDataManager::GetInstance().LoadMeta(key, matrixMetaData, true));
393     EXPECT_EQ(matrixMetaData.dynamic & 0xFFF0, version << 4);
394 }
395 
396 /**
397 * @tc.name: GetWaterVersionTest1
398 * @tc.desc: GetWaterVersion by different key
399 * @tc.type: FUNC
400 * @tc.require:
401 * @tc.author: ht
402 */
403 HWTEST_F(WaterVersionManagerTest, GetWaterVersionTest1, TestSize.Level0)
404 {
405     auto len = staticStores_.size();
406     for (size_t i = 0; i < 10; ++i) {
407         auto bundle = staticStores_[i % len].first;
408         auto store = staticStores_[i % len].second;
409         ASSERT_FALSE(WvManager::GetInstance().GenerateWaterVersion(bundle, store).empty());
410     }
411     for (size_t i = 0; i < len; i++) {
412         auto waterVersion = WvManager::GetInstance().GetWaterVersion(staticStores_[i].first, staticStores_[i].second);
413         WvManager::WaterVersionMetaData meta;
414         ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)) << "waterVersion: " << waterVersion;
415         EXPECT_EQ(meta.waterVersion, 10 / len * len + i + 1 - len * (10 % len <= i ? 1 : 0));
416     }
417 }
418 
419 /**
420 * @tc.name: MixCallTest1
421 * @tc.desc: use GenerateWaterVersion to SetWaterVersion
422 * @tc.type: FUNC
423 * @tc.require:
424 * @tc.author: ht
425 */
426 HWTEST_F(WaterVersionManagerTest, MixCallTest1, TestSize.Level0)
427 {
428     std::string waterVersion =
429         WvManager::GetInstance().GenerateWaterVersion(staticStores_[0].first, staticStores_[0].second);
430     WvManager::WaterVersionMetaData meta;
431     ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)) << "waterVersion: " << waterVersion;
432     EXPECT_EQ(meta.waterVersion, 1) << "waterVersion: " << waterVersion;
433 
434     meta.deviceId = TEST_DEVICE;
435     EXPECT_TRUE(WvManager::GetInstance().SetWaterVersion(staticStores_[0].first, staticStores_[0].second,
436         Serializable::Marshall(meta)));
437 
438     auto [_, version] = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::STATIC);
439     EXPECT_EQ(version, 1) << "version: " << version;
440 }
441 
442 /**
443 * @tc.name: MixCallTest2
444 * @tc.desc: use GenerateWaterVersion to SetWaterVersion and GenerateWaterVersion more than once
445 * @tc.type: FUNC
446 * @tc.require:
447 * @tc.author: ht
448 */
449 HWTEST_F(WaterVersionManagerTest, MixCallTest2, TestSize.Level0)
450 {
451     bool success = false;
452     uint64_t version = 0;
453     for (int i = 1; i < 11; ++i) {
454         int index = i % dynamicMeta_.keys.size();
455         std::string waterVersion =
456             WvManager::GetInstance().GenerateWaterVersion(dynamicStores_[index].first, dynamicStores_[index].second);
457         WvManager::WaterVersionMetaData meta;
458         ASSERT_TRUE(Serializable::Unmarshall(waterVersion, meta)) << "waterVersion: " << waterVersion;
459         EXPECT_EQ(meta.waterVersion, i) << "waterVersion: " << waterVersion;
460         meta.deviceId = TEST_DEVICE;
461         EXPECT_TRUE(WvManager::GetInstance().SetWaterVersion(dynamicStores_[index].first, dynamicStores_[index].second,
462             Serializable::Marshall(meta)));
463 
464         std::tie(success, version) = WvManager::GetInstance().GetVersion(TEST_DEVICE, WvManager::DYNAMIC);
465         EXPECT_TRUE(success && version == i)
466             << "i:" << i << " success:" << success << " version:" << version << " meta: " << meta.ToAnonymousString();
467     }
468 }
469 } // namespace DistributedDataTest
470 } // namespace OHOS::Test