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 #include "device_matrix.h"
16
17 #include "block_data.h"
18 #include "bootstrap.h"
19 #include "checker/checker_manager.h"
20 #include "device_manager_adapter.h"
21 #include "eventcenter/event_center.h"
22 #include "feature/feature_system.h"
23 #include "ipc_skeleton.h"
24 #include "matrix_event.h"
25 #include "metadata/meta_data_manager.h"
26 #include "metadata/store_meta_data_local.h"
27 #include "mock/checker_mock.h"
28 #include "mock/db_store_mock.h"
29 #include "types.h"
30 #include "gtest/gtest.h"
31 using namespace testing::ext;
32 using namespace OHOS::DistributedData;
33 using namespace OHOS::DistributedKv;
34 using namespace OHOS;
35 using DMAdapter = DeviceManagerAdapter;
36 using namespace DistributedDB;
37 class DeviceMatrixTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43
44 protected:
45 struct Result {
46 uint16_t mask_ = DeviceMatrix::INVALID_LEVEL;
47 std::string deviceId_;
ResultDeviceMatrixTest::Result48 Result() {};
49 };
50 static constexpr const char *TEST_DEVICE = "14a0a92a428005db27c40bad46bf145fede38ec37effe0347cd990fcb031f320";
51 static constexpr const char *TEST_BUNDLE = "matrix_test";
52 static constexpr const char *TEST_STORE = "matrix_store";
53 static constexpr const char *TEST_USER = "0";
54 void InitRemoteMatrixMeta();
55 void InitMetaData();
56
57 static inline std::vector<std::pair<std::string, std::string>> staticStores_ = {
58 { "bundle0", "store0" },
59 { "bundle1", "store0" }
60 };
61 static inline std::vector<std::pair<std::string, std::string>> dynamicStores_ = {
62 { "bundle0", "store1" },
63 { "bundle3", "store0" }
64 };
65 static BlockData<Result> isFinished_;
66 static std::shared_ptr<DBStoreMock> dbStoreMock_;
67 static uint32_t selfToken_;
68 StoreMetaData metaData_;
69 StoreMetaDataLocal localMeta_;
70 static CheckerMock instance_;
71 static constexpr uint32_t CURRENT_VERSION = 3;
72 };
73 BlockData<DeviceMatrixTest::Result> DeviceMatrixTest::isFinished_(1, Result());
74 std::shared_ptr<DBStoreMock> DeviceMatrixTest::dbStoreMock_ = std::make_shared<DBStoreMock>();
75 uint32_t DeviceMatrixTest::selfToken_ = 0;
76 CheckerMock DeviceMatrixTest::instance_;
SetUpTestCase(void)77 void DeviceMatrixTest::SetUpTestCase(void)
78 {
79 MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr, "");
80 MetaDataManager::GetInstance().SetCloudSyncer([]() {
81 DeviceMatrix::GetInstance().OnChanged(DeviceMatrix::META_STORE_MASK);
82 });
83 selfToken_ = IPCSkeleton::GetCallingTokenID();
84 FeatureSystem::GetInstance().GetCreator("kv_store")();
85 std::vector<CheckerManager::StoreInfo> dynamicStores;
86 for (auto &[bundle, store] : dynamicStores_) {
87 dynamicStores.push_back({ 0, 0, bundle, store });
88 instance_.SetDynamic(dynamicStores);
89 }
90 std::vector<CheckerManager::StoreInfo> staticStores;
91 for (auto &[bundle, store] : staticStores_) {
92 staticStores.push_back({ 0, 0, bundle, store });
93 instance_.SetStatic(staticStores);
94 }
95 Bootstrap::GetInstance().LoadCheckers();
96 DeviceMatrix::GetInstance().Initialize(selfToken_, "service_meta");
97 mkdir("/data/service/el1/public/database/matrix_test", (S_IRWXU | S_IRWXG | S_IRWXO));
98 mkdir("/data/service/el1/public/database/matrix_test/kvdb", (S_IRWXU | S_IRWXG | S_IRWXO));
99 }
100
TearDownTestCase(void)101 void DeviceMatrixTest::TearDownTestCase(void)
102 {
103 EventCenter::GetInstance().Unsubscribe(DeviceMatrix::MATRIX_BROADCAST);
104 }
105
SetUp()106 void DeviceMatrixTest::SetUp()
107 {
108 isFinished_.Clear(Result());
109 DeviceMatrix::GetInstance().Clear();
110 InitMetaData();
111 InitRemoteMatrixMeta();
112 }
113
TearDown()114 void DeviceMatrixTest::TearDown()
115 {
116 (void)remove("/data/service/el1/public/database/matrix_test/kvdb");
117 (void)remove("/data/service/el1/public/database/matrix_test");
118 }
119
InitRemoteMatrixMeta()120 void DeviceMatrixTest::InitRemoteMatrixMeta()
121 {
122 MatrixMetaData metaData;
123 metaData.version = CURRENT_VERSION;
124 metaData.dynamic = 0x7;
125 metaData.deviceId = TEST_DEVICE;
126 metaData.origin = MatrixMetaData::Origin::REMOTE_RECEIVED;
127 metaData.dynamicInfo.clear();
128 for (auto &[bundleName, _] : dynamicStores_) {
129 metaData.dynamicInfo.push_back(bundleName);
130 }
131 MetaDataManager::GetInstance().DelMeta(metaData.GetKey());
132 MetaDataManager::GetInstance().SaveMeta(metaData.GetKey(), metaData);
133 }
134
InitMetaData()135 void DeviceMatrixTest::InitMetaData()
136 {
137 metaData_.deviceId = DMAdapter::GetInstance().GetLocalDevice().uuid;
138 metaData_.appId = TEST_BUNDLE;
139 metaData_.bundleName = TEST_BUNDLE;
140 metaData_.user = TEST_USER;
141 metaData_.area = EL1;
142 metaData_.tokenId = IPCSkeleton::GetCallingTokenID();
143 metaData_.instanceId = 0;
144 metaData_.isAutoSync = true;
145 metaData_.storeType = true;
146 metaData_.storeId = TEST_STORE;
147 metaData_.dataType = 1;
148 PolicyValue value;
149 value.type = PolicyType::IMMEDIATE_SYNC_ON_ONLINE;
150 localMeta_.policies = { std::move(value) };
151 }
152
153 /**
154 * @tc.name: GetMetaStoreCode
155 * @tc.desc: get the meta data store mask code;
156 * @tc.type: FUNC
157 * @tc.require:
158 * @tc.author: blue sky
159 */
160 HWTEST_F(DeviceMatrixTest, GetMetaStoreCode, TestSize.Level0)
161 {
162 StoreMetaData meta;
163 meta.bundleName = "distributeddata";
164 meta.tokenId = selfToken_;
165 meta.storeId = "service_meta";
166 meta.dataType = 1;
167 auto code = DeviceMatrix::GetInstance().GetCode(meta);
168 ASSERT_EQ(code, DeviceMatrix::META_STORE_MASK);
169 }
170
171 /**
172 * @tc.name: GetAllCode
173 * @tc.desc: get all dynamic store mask code;
174 * @tc.type: FUNC
175 * @tc.require:
176 * @tc.author: blue sky
177 */
178 HWTEST_F(DeviceMatrixTest, GetAllCode, TestSize.Level0)
179 {
180 StoreMetaData meta = metaData_;
181
182 for (size_t i = 0; i < dynamicStores_.size(); ++i) {
183 meta.appId = dynamicStores_[i].first;
184 meta.bundleName = dynamicStores_[i].first;
185 ASSERT_EQ(DeviceMatrix::GetInstance().GetCode(meta), 0x1 << (i + 1));
186 }
187 }
188
189 /**
190 * @tc.name: GetOtherStoreCode
191 * @tc.desc: get the other store mask code;
192 * @tc.type: FUNC
193 * @tc.require:
194 * @tc.author: blue sky
195 */
196 HWTEST_F(DeviceMatrixTest, GetOtherStoreCode, TestSize.Level0)
197 {
198 StoreMetaData meta = metaData_;
199 auto code = DeviceMatrix::GetInstance().GetCode(meta);
200 ASSERT_EQ(code, 0);
201 }
202
203 /**
204 * @tc.name: BroadcastMeta
205 * @tc.desc: broadcast the meta store change;
206 * @tc.type: FUNC
207 * @tc.require:
208 * @tc.author: blue sky
209 */
210 HWTEST_F(DeviceMatrixTest, BroadcastMeta, TestSize.Level0)
211 {
212 DeviceMatrix::DataLevel level = {
213 .dynamic = DeviceMatrix::META_STORE_MASK,
214 };
215 auto mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, level);
216 ASSERT_EQ(mask.first, DeviceMatrix::META_STORE_MASK);
217 }
218
219 /**
220 * @tc.name: BroadcastFirst
221 * @tc.desc: broadcast all stores change;
222 * @tc.type: FUNC
223 * @tc.require:
224 * @tc.author: blue sky
225 */
226 HWTEST_F(DeviceMatrixTest, BroadcastFirst, TestSize.Level0)
227 {
228 StoreMetaData meta = metaData_;
229 meta.appId = dynamicStores_[0].first;
230 meta.bundleName = dynamicStores_[0].first;
231 auto code = DeviceMatrix::GetInstance().GetCode(meta);
232 ASSERT_EQ(code, 0x2);
233 DeviceMatrix::DataLevel level = {
234 .dynamic = code,
235 };
236 auto mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, level);
237 ASSERT_EQ(mask.first, code);
238 }
239
240 /**
241 * @tc.name: BroadcastOthers
242 * @tc.desc: broadcast the device profile store change;
243 * @tc.type: FUNC
244 * @tc.require:
245 * @tc.author: blue sky
246 */
247 HWTEST_F(DeviceMatrixTest, BroadcastOthers, TestSize.Level0)
248 {
249 StoreMetaData meta = metaData_;
250 auto code = DeviceMatrix::GetInstance().GetCode(meta);
251 DeviceMatrix::DataLevel level = {
252 .dynamic = code,
253 };
254 auto mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, level);
255 ASSERT_EQ(mask.first, 0);
256 }
257
258 /**
259 * @tc.name: BroadcastAll
260 * @tc.desc: broadcast the all store change;
261 * @tc.type: FUNC
262 * @tc.require:
263 * @tc.author: blue sky
264 */
265 HWTEST_F(DeviceMatrixTest, BroadcastAll, TestSize.Level0)
266 {
267 DeviceMatrix::DataLevel level = {
268 .dynamic = DeviceMatrix::META_STORE_MASK,
269 };
270 auto mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, level);
271 ASSERT_EQ(mask.first, DeviceMatrix::META_STORE_MASK);
272 StoreMetaData meta = metaData_;
273 for (size_t i = 0; i < dynamicStores_.size(); ++i) {
274 meta.appId = dynamicStores_[i].first;
275 meta.bundleName = dynamicStores_[i].first;
276 auto code = DeviceMatrix::GetInstance().GetCode(meta);
277 level.dynamic = code;
278 mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, level);
279 ASSERT_EQ(mask.first, (0x1 << (i + 1)) + 1);
280 DeviceMatrix::GetInstance().OnExchanged(TEST_DEVICE, code);
281 }
282 DeviceMatrix::GetInstance().OnExchanged(TEST_DEVICE, DeviceMatrix::META_STORE_MASK);
283 level.dynamic = DeviceMatrix::GetInstance().GetCode(metaData_);
284 mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, level);
285 ASSERT_EQ(mask.first, 0);
286
287 level.dynamic = 0xFFFF;
288 level.statics = 0x000D;
289 mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, level);
290 ASSERT_EQ(mask.first, 0x0);
291 }
292
293 /**
294 * @tc.name: UpdateMatrixMeta
295 * @tc.desc: update the remote matrix meta the all store change;
296 * @tc.type: FUNC
297 * @tc.require:
298 * @tc.author: blue sky
299 */
300 HWTEST_F(DeviceMatrixTest, UpdateMatrixMeta, TestSize.Level0)
301 {
302 MatrixMetaData metaData;
303 metaData.version = 4;
304 metaData.dynamic = 0x1F;
305 metaData.deviceId = TEST_DEVICE;
306 metaData.origin = MatrixMetaData::Origin::REMOTE_RECEIVED;
307 metaData.dynamicInfo = { TEST_BUNDLE, dynamicStores_[0].first };
308 MetaDataManager::GetInstance().Subscribe(
__anon1781cbf30202(const std::string &, const std::string &value, int32_t flag) 309 MatrixMetaData::GetPrefix({ TEST_DEVICE }), [](const std::string &, const std::string &value, int32_t flag) {
310 if (flag != MetaDataManager::INSERT && flag != MetaDataManager::UPDATE) {
311 return true;
312 }
313 MatrixMetaData meta;
314 MatrixMetaData::Unmarshall(value, meta);
315 Result result;
316 result.deviceId_ = meta.deviceId;
317 isFinished_.SetValue(result);
318 return true;
319 });
320 MetaDataManager::GetInstance().DelMeta(metaData.GetKey());
321 MetaDataManager::GetInstance().SaveMeta(metaData.GetKey(), metaData);
322
323 auto result = isFinished_.GetValue();
324 ASSERT_EQ(result.deviceId_, std::string(TEST_DEVICE));
325
326 DeviceMatrix::DataLevel level = {
327 .dynamic = 0x2,
328 };
329 auto mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, level);
330 ASSERT_EQ(mask.first, 0);
331 level.dynamic = DeviceMatrix::META_STORE_MASK;
332 mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, level);
333 ASSERT_EQ(mask.first, DeviceMatrix::META_STORE_MASK);
334 level.dynamic = 0x4;
335 mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, level);
336 ASSERT_EQ(mask.first, 0x3);
337 DeviceMatrix::GetInstance().OnExchanged(TEST_DEVICE, DeviceMatrix::META_STORE_MASK);
338 DeviceMatrix::GetInstance().OnExchanged(TEST_DEVICE, 0x2);
339 level.dynamic = 0xFFFF;
340 level.statics = 0x000D;
341 mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, level);
342 ASSERT_EQ(mask.first, 0x0);
343 MetaDataManager::GetInstance().Unsubscribe(MatrixMetaData::GetPrefix({ TEST_DEVICE }));
344 }
345
346 /**
347 * @tc.name: Online
348 * @tc.desc: The test equipment is operated both online and offline.
349 * @tc.type: FUNC
350 * @tc.require:
351 * @tc.author: suoqilong
352 */
353 HWTEST_F(DeviceMatrixTest, Online, TestSize.Level0)
354 {
355 RefCount refCount;
356 std::string device = "Online";
357 DeviceMatrix::GetInstance().Online(device, refCount);
358
359 DeviceMatrix::GetInstance().Offline(device);
360 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().Online(device, refCount));
361 }
362
363 /**
364 * @tc.name: Offline
365 * @tc.desc: Switch between offline and online status of test equipment.
366 * @tc.type: FUNC
367 * @tc.require:
368 * @tc.author: suoqilong
369 */
370 HWTEST_F(DeviceMatrixTest, Offline, TestSize.Level0)
371 {
372 RefCount refCount;
373 std::string device = "Offline";
374 DeviceMatrix::GetInstance().Offline(device);
375
376 DeviceMatrix::GetInstance().Online(device, refCount);
377 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().Offline(device));
378 }
379
380 /**
381 * @tc.name: OnChanged001
382 * @tc.desc: Test the DeviceMatrix::OnChanged method exception scenario.
383 * @tc.type: FUNC
384 * @tc.require:
385 * @tc.author: suoqilong
386 */
387 HWTEST_F(DeviceMatrixTest, OnChanged001, TestSize.Level0)
388 {
389 StoreMetaData metaData;
390 metaData.dataType = static_cast<DeviceMatrix::LevelType>(DeviceMatrix::LevelType::STATICS - 1);
391 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().OnChanged(metaData));
392
393 metaData.dataType = DeviceMatrix::LevelType::BUTT;
394 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().OnChanged(metaData));
395 }
396
397 /**
398 * @tc.name: OnChanged002
399 * @tc.desc: Test the DeviceMatrix::OnChanged method exception scenario.
400 * @tc.type: FUNC
401 * @tc.require:
402 * @tc.author: suoqilong
403 */
404 HWTEST_F(DeviceMatrixTest, OnChanged002, TestSize.Level0)
405 {
406 StoreMetaData metaData;
407 metaData.bundleName = "distributeddata";
408 metaData.tokenId = selfToken_;
409 metaData.storeId = "service_meta";
410 metaData.dataType = 1;
411 auto code = DeviceMatrix::GetInstance().GetCode(metaData);
412 DeviceMatrix::LevelType type = static_cast<DeviceMatrix::LevelType>(DeviceMatrix::LevelType::STATICS - 1);
413 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().OnChanged(code, type));
414
415 type = DeviceMatrix::LevelType::BUTT;
416 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().OnChanged(code, type));
417 }
418
419 /**
420 * @tc.name: OnExchanged001
421 * @tc.desc: Test the DeviceMatrix::OnExchanged method exception scenario.
422 * @tc.type: FUNC
423 * @tc.require:
424 * @tc.author: suoqilong
425 */
426 HWTEST_F(DeviceMatrixTest, OnExchanged001, TestSize.Level0)
427 {
428 StoreMetaData metaData;
429 metaData.dataType = static_cast<DeviceMatrix::LevelType>(DeviceMatrix::LevelType::STATICS - 1);
430 std::string device = "OnExchanged";
431 EXPECT_NO_FATAL_FAILURE(
432 DeviceMatrix::GetInstance().OnExchanged(device, metaData, DeviceMatrix::ChangeType::CHANGE_REMOTE));
433
434 metaData.dataType = DeviceMatrix::LevelType::BUTT;
435 EXPECT_NO_FATAL_FAILURE(
436 DeviceMatrix::GetInstance().OnExchanged(device, metaData, DeviceMatrix::ChangeType::CHANGE_REMOTE));
437 }
438
439 /**
440 * @tc.name: OnExchanged002
441 * @tc.desc: Test the DeviceMatrix::OnExchanged method exception scenario.
442 * @tc.type: FUNC
443 * @tc.require:
444 * @tc.author: suoqilong
445 */
446 HWTEST_F(DeviceMatrixTest, OnExchanged002, TestSize.Level0)
447 {
448 StoreMetaData metaData;
449 metaData.bundleName = "distributeddata";
450 metaData.tokenId = selfToken_;
451 metaData.storeId = "service_meta";
452 metaData.dataType = 1;
453 auto code = DeviceMatrix::GetInstance().GetCode(metaData);
454 DeviceMatrix::LevelType type = static_cast<DeviceMatrix::LevelType>(DeviceMatrix::LevelType::STATICS - 1);
455 std::string device;
456 EXPECT_NO_FATAL_FAILURE(
457 DeviceMatrix::GetInstance().OnExchanged(device, code, type, DeviceMatrix::ChangeType::CHANGE_REMOTE));
458
459 device = "OnExchanged";
460 EXPECT_NO_FATAL_FAILURE(
461 DeviceMatrix::GetInstance().OnExchanged(device, code, type, DeviceMatrix::ChangeType::CHANGE_REMOTE));
462
463 type = DeviceMatrix::LevelType::BUTT;
464 EXPECT_NO_FATAL_FAILURE(
465 DeviceMatrix::GetInstance().OnExchanged(device, code, type, DeviceMatrix::ChangeType::CHANGE_REMOTE));
466 }
467
468 /**
469 * @tc.name: OnExchangedd003
470 * @tc.desc: Test the DeviceMatrix::OnExchanged method.
471 * @tc.type: FUNC
472 * @tc.require:
473 * @tc.author: suoqilong
474 */
475 HWTEST_F(DeviceMatrixTest, OnExchangedd003, TestSize.Level0)
476 {
477 StoreMetaData metaData;
478 metaData.dataType = DeviceMatrix::LevelType::STATICS;
479 std::string device = "OnExchanged";
480 EXPECT_NO_FATAL_FAILURE(
481 DeviceMatrix::GetInstance().OnExchanged(device, metaData, DeviceMatrix::ChangeType::CHANGE_REMOTE));
482 }
483
484 /**
485 * @tc.name: GetCode
486 * @tc.desc: Test the DeviceMatrix::GetCode method.
487 * @tc.type: FUNC
488 * @tc.require:
489 * @tc.author: suoqilong
490 */
491 HWTEST_F(DeviceMatrixTest, GetCode, TestSize.Level0)
492 {
493 StoreMetaData metaData;
494 metaData.bundleName = "distributeddata";
495 metaData.tokenId = selfToken_;
496 metaData.storeId = "storeId";
497 metaData.dataType = DeviceMatrix::LevelType::BUTT;
498 auto code = DeviceMatrix::GetInstance().GetCode(metaData);
499 EXPECT_EQ(code, 0);
500 }
501
502 /**
503 * @tc.name: GetMask001
504 * @tc.desc: Test the DeviceMatrix::GetMask method.
505 * @tc.type: FUNC
506 * @tc.require:
507 * @tc.author: suoqilong
508 */
509 HWTEST_F(DeviceMatrixTest, GetMask001, TestSize.Level0)
510 {
511 std::string device = "GetMask";
512 DeviceMatrix::LevelType type = DeviceMatrix::LevelType::STATICS;
513 std::pair<bool, uint16_t> mask = DeviceMatrix::GetInstance().GetMask(device, type);
514 EXPECT_EQ(mask.first, false);
515 }
516
517 /**
518 * @tc.name: GetMask002
519 * @tc.desc: Test the DeviceMatrix::GetMask method.
520 * @tc.type: FUNC
521 * @tc.require:
522 * @tc.author: suoqilong
523 */
524 HWTEST_F(DeviceMatrixTest, GetMask002, TestSize.Level0)
525 {
526 std::string device = "GetMask";
527 DeviceMatrix::LevelType type = DeviceMatrix::LevelType::STATICS;
528 RefCount refCount;
529 DeviceMatrix::GetInstance().Online(device, refCount);
530 std::pair<bool, uint16_t> mask = DeviceMatrix::GetInstance().GetMask(device, type);
531 EXPECT_EQ(mask.first, true);
532
533 type = DeviceMatrix::LevelType::DYNAMIC;
534 mask = DeviceMatrix::GetInstance().GetMask(device, type);
535 EXPECT_EQ(mask.first, true);
536
537 type = DeviceMatrix::LevelType::BUTT;
538 mask = DeviceMatrix::GetInstance().GetMask(device, type);
539 EXPECT_EQ(mask.first, false);
540 }
541
542 /**
543 * @tc.name: GetRemoteMask001
544 * @tc.desc: Test the DeviceMatrix::GetRemoteMask method.
545 * @tc.type: FUNC
546 * @tc.require:
547 * @tc.author: suoqilong
548 */
549 HWTEST_F(DeviceMatrixTest, GetRemoteMask001, TestSize.Level0)
550 {
551 std::string device = "GetRemoteMask";
552 DeviceMatrix::LevelType type = DeviceMatrix::LevelType::STATICS;
553 std::pair<bool, uint16_t> mask = DeviceMatrix::GetInstance().GetRemoteMask(device, type);
554 EXPECT_EQ(mask.first, false);
555 }
556
557 /**
558 * @tc.name: GetRemoteMask002
559 * @tc.desc: Test the DeviceMatrix::GetRemoteMask method.
560 * @tc.type: FUNC
561 * @tc.require:
562 * @tc.author: suoqilong
563 */
564 HWTEST_F(DeviceMatrixTest, GetRemoteMask002, TestSize.Level0)
565 {
566 std::string device = "GetRemoteMask";
567 StoreMetaData meta = metaData_;
568 auto code = DeviceMatrix::GetInstance().GetCode(meta);
569 DeviceMatrix::DataLevel level = {
570 .dynamic = code,
571 };
572 DeviceMatrix::GetInstance().OnBroadcast(device, level);
573
574 DeviceMatrix::LevelType type = DeviceMatrix::LevelType::STATICS;
575 std::pair<bool, uint16_t> mask = DeviceMatrix::GetInstance().GetRemoteMask(device, type);
576 EXPECT_EQ(mask.first, true);
577
578 type = DeviceMatrix::LevelType::DYNAMIC;
579 mask = DeviceMatrix::GetInstance().GetRemoteMask(device, type);
580 EXPECT_EQ(mask.first, true);
581
582 type = DeviceMatrix::LevelType::BUTT;
583 mask = DeviceMatrix::GetInstance().GetRemoteMask(device, type);
584 EXPECT_EQ(mask.first, false);
585 }
586
587 /**
588 * @tc.name: GetRecvLevel
589 * @tc.desc: Test the DeviceMatrix::GetRecvLevel method.
590 * @tc.type: FUNC
591 * @tc.require:
592 * @tc.author: suoqilong
593 */
594 HWTEST_F(DeviceMatrixTest, GetRecvLevel, TestSize.Level0)
595 {
596 std::string device = "GetRemoteMask";
597 DeviceMatrix::LevelType type = DeviceMatrix::LevelType::STATICS;
598 std::pair<bool, uint16_t> mask = DeviceMatrix::GetInstance().GetRecvLevel(device, type);
599 EXPECT_EQ(mask.first, true);
600
601 device = TEST_DEVICE;
602 mask = DeviceMatrix::GetInstance().GetRecvLevel(device, type);
603 EXPECT_EQ(mask.first, true);
604
605 type = DeviceMatrix::LevelType::DYNAMIC;
606 mask = DeviceMatrix::GetInstance().GetRecvLevel(device, type);
607 EXPECT_EQ(mask.first, true);
608
609 type = DeviceMatrix::LevelType::BUTT;
610 mask = DeviceMatrix::GetInstance().GetRecvLevel(device, type);
611 EXPECT_EQ(mask.first, false);
612 }
613
614 /**
615 * @tc.name: GetConsLevel
616 * @tc.desc: Test the DeviceMatrix::GetConsLevel method.
617 * @tc.type: FUNC
618 * @tc.require:
619 * @tc.author: suoqilong
620 */
621 HWTEST_F(DeviceMatrixTest, GetConsLevel, TestSize.Level0)
622 {
623 std::string device = "GetRemoteMask";
624 DeviceMatrix::LevelType type = DeviceMatrix::LevelType::STATICS;
625 std::pair<bool, uint16_t> mask = DeviceMatrix::GetInstance().GetConsLevel(device, type);
626 EXPECT_EQ(mask.first, false);
627
628 device = TEST_DEVICE;
629 mask = DeviceMatrix::GetInstance().GetConsLevel(device, type);
630 EXPECT_EQ(mask.first, true);
631
632 type = DeviceMatrix::LevelType::DYNAMIC;
633 mask = DeviceMatrix::GetInstance().GetConsLevel(device, type);
634 EXPECT_EQ(mask.first, true);
635
636 type = DeviceMatrix::LevelType::BUTT;
637 mask = DeviceMatrix::GetInstance().GetConsLevel(device, type);
638 EXPECT_EQ(mask.first, false);
639 }
640
641 /**
642 * @tc.name: UpdateLevel
643 * @tc.desc: Test the DeviceMatrix::UpdateLevel method exception scenario.
644 * @tc.type: FUNC
645 * @tc.require:
646 * @tc.author: suoqilong
647 */
648 HWTEST_F(DeviceMatrixTest, UpdateLevel, TestSize.Level0)
649 {
650 uint16_t level = 0;
651 DeviceMatrix::LevelType type = static_cast<DeviceMatrix::LevelType>(DeviceMatrix::LevelType::STATICS - 1);
652 std::string device;
653 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().UpdateLevel(device, level, type));
654
655 device = "OnExchanged";
656 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().UpdateLevel(device, level, type));
657
658 type = DeviceMatrix::LevelType::BUTT;
659 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().UpdateLevel(device, level, type));
660
661 type = DeviceMatrix::LevelType::STATICS;
662 device = TEST_DEVICE;
663 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().UpdateLevel(device, level, type));
664 }
665
666 /**
667 * @tc.name: IsDynamic
668 * @tc.desc: Test the DeviceMatrix::IsDynamic method exception scenario.
669 * @tc.type: FUNC
670 * @tc.require:
671 * @tc.author: suoqilong
672 */
673 HWTEST_F(DeviceMatrixTest, IsDynamic, TestSize.Level0)
674 {
675 StoreMetaData meta;
676 meta.bundleName = "distributeddata";
677 meta.tokenId = selfToken_;
678 meta.storeId = "service_meta";
679 meta.dataType = DeviceMatrix::LevelType::STATICS;
680 bool isDynamic = DeviceMatrix::GetInstance().IsDynamic(meta);
681 EXPECT_EQ(isDynamic, false);
682
683 meta.dataType = DeviceMatrix::LevelType::DYNAMIC;
684 isDynamic = DeviceMatrix::GetInstance().IsDynamic(meta);
685 EXPECT_EQ(isDynamic, true);
686 }
687
688 /**
689 * @tc.name: IsValid
690 * @tc.desc: Test the DeviceMatrix::IsValid method exception scenario.
691 * @tc.type: FUNC
692 * @tc.require:
693 * @tc.author: suoqilong
694 */
695 HWTEST_F(DeviceMatrixTest, IsValid, TestSize.Level0)
696 {
697 DistributedData::DeviceMatrix::DataLevel dataLevel;
698 EXPECT_EQ(dataLevel.IsValid(), false);
699
700 dataLevel.dynamic = 0;
701 dataLevel.statics = 0;
702 dataLevel.switches = 0;
703 dataLevel.switchesLen = 0;
704 EXPECT_EQ(dataLevel.IsValid(), true);
705 }
706
707 class MatrixEventTest : public testing::Test {
708 public:
SetUpTestCase(void)709 static void SetUpTestCase(void){};
TearDownTestCase(void)710 static void TearDownTestCase(void){};
SetUp()711 void SetUp(){};
TearDown()712 void TearDown(){};
713 };
714
715 /**
716 * @tc.name: IsValid
717 * @tc.desc: Test the MatrixEvent::IsValid method exception scenario.
718 * @tc.type: FUNC
719 * @tc.require:
720 * @tc.author: suoqilong
721 */
722 HWTEST_F(MatrixEventTest, IsValid, TestSize.Level0)
723 {
724 DistributedData::MatrixEvent::MatrixData matrixData;
725 EXPECT_EQ(matrixData.IsValid(), false);
726
727 matrixData.dynamic = 0;
728 matrixData.statics = 0;
729 matrixData.switches = 0;
730 matrixData.switchesLen = 0;
731 EXPECT_EQ(matrixData.IsValid(), true);
732 }