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(
__anonb2c6e5150202(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.Level1)
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.Level1)
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: OnBroadcast
382 * @tc.desc: OnBroadcast testing exceptions.
383 * @tc.type: FUNC
384 * @tc.require:
385 * @tc.author: suoqilong
386 */
387 HWTEST_F(DeviceMatrixTest, OnBroadcast, TestSize.Level1)
388 {
389 std::string device;
390 DeviceMatrix::DataLevel dataLevel;
391 EXPECT_TRUE(!dataLevel.IsValid());
392 auto mask = DeviceMatrix::GetInstance().OnBroadcast(device, dataLevel);
393 EXPECT_EQ(mask.first, DeviceMatrix::INVALID_LEVEL); // true true
394
395 dataLevel = {
396 .dynamic = DeviceMatrix::META_STORE_MASK,
397 };
398 EXPECT_FALSE(!dataLevel.IsValid());
399 mask = DeviceMatrix::GetInstance().OnBroadcast(device, dataLevel);
400 EXPECT_EQ(mask.first, DeviceMatrix::INVALID_LEVEL); // true false
401
402 EXPECT_FALSE(!dataLevel.IsValid());
403 mask = DeviceMatrix::GetInstance().OnBroadcast(TEST_DEVICE, dataLevel);
404 EXPECT_EQ(mask.first, DeviceMatrix::META_STORE_MASK); // false false
405
406 DeviceMatrix::DataLevel dataLevels;
407 EXPECT_TRUE(!dataLevels.IsValid());
408 mask = DeviceMatrix::GetInstance().OnBroadcast(device, dataLevels);
409 EXPECT_EQ(mask.first, DeviceMatrix::INVALID_LEVEL); // false true
410 }
411
412 /**
413 * @tc.name: ConvertStatics
414 * @tc.desc: ConvertStatics testing exceptions.
415 * @tc.type: FUNC
416 * @tc.require:
417 * @tc.author: suoqilong
418 */
419 HWTEST_F(DeviceMatrixTest, ConvertStatics, TestSize.Level1)
420 {
421 DeviceMatrix deviceMatrix;
422 DistributedData::MatrixMetaData meta;
423 uint16_t mask = 0;
424 uint16_t result = deviceMatrix.ConvertStatics(meta, mask);
425 EXPECT_EQ(result, 0);
426
427 mask = 0xFFFF;
428 result = deviceMatrix.ConvertStatics(meta, mask);
429 EXPECT_EQ(result, 0);
430
431 meta.version = 4;
432 meta.dynamic = 0x1F;
433 meta.deviceId = TEST_DEVICE;
434 meta.origin = MatrixMetaData::Origin::REMOTE_RECEIVED;
435 meta.dynamicInfo = { TEST_BUNDLE, dynamicStores_[0].first };
436 result = deviceMatrix.ConvertStatics(meta, DeviceMatrix::INVALID_LEVEL);
437 EXPECT_EQ(result, 0);
438 }
439
440 /**
441 * @tc.name: SaveSwitches
442 * @tc.desc: SaveSwitches testing exceptions.
443 * @tc.type: FUNC
444 * @tc.require:
445 * @tc.author: suoqilong
446 */
447 HWTEST_F(DeviceMatrixTest, SaveSwitches, TestSize.Level1)
448 {
449 DeviceMatrix deviceMatrix;
450 std::string device;
451 DeviceMatrix::DataLevel dataLevel;
452 dataLevel.switches = DeviceMatrix::INVALID_VALUE;
453 dataLevel.switchesLen = DeviceMatrix::INVALID_LENGTH;
454 EXPECT_NO_FATAL_FAILURE(deviceMatrix.SaveSwitches(device, dataLevel));
455
456 device = "SaveSwitches";
457 EXPECT_NO_FATAL_FAILURE(deviceMatrix.SaveSwitches(device, dataLevel));
458
459 dataLevel.switches = 0;
460 EXPECT_NO_FATAL_FAILURE(deviceMatrix.SaveSwitches(device, dataLevel));
461
462 dataLevel.switchesLen = 0;
463 EXPECT_NO_FATAL_FAILURE(deviceMatrix.SaveSwitches(device, dataLevel));
464 }
465
466 /**
467 * @tc.name: Broadcast
468 * @tc.desc: Broadcast testing exceptions.
469 * @tc.type: FUNC
470 * @tc.require:
471 * @tc.author: suoqilong
472 */
473 HWTEST_F(DeviceMatrixTest, Broadcast, TestSize.Level1)
474 {
475 DeviceMatrix deviceMatrix;
476 DeviceMatrix::DataLevel dataLevel;
477 EXPECT_FALSE(deviceMatrix.lasts_.IsValid());
478 EXPECT_NO_FATAL_FAILURE(deviceMatrix.Broadcast(dataLevel));
479
480 dataLevel.statics = 0;
481 dataLevel.dynamic = 0;
482 EXPECT_NO_FATAL_FAILURE(deviceMatrix.Broadcast(dataLevel));
483
484 deviceMatrix.lasts_.statics = 0;
485 deviceMatrix.lasts_.dynamic = 0;
486 EXPECT_TRUE(deviceMatrix.lasts_.IsValid());
487 EXPECT_NO_FATAL_FAILURE(deviceMatrix.Broadcast(dataLevel));
488
489 DeviceMatrix::DataLevel dataLevels;
490 dataLevel = dataLevels;
491 EXPECT_NO_FATAL_FAILURE(deviceMatrix.Broadcast(dataLevel));
492 }
493
494 /**
495 * @tc.name: UpdateConsistentMeta
496 * @tc.desc: UpdateConsistentMeta testing exceptions.
497 * @tc.type: FUNC
498 * @tc.require:
499 * @tc.author: suoqilong
500 */
501 HWTEST_F(DeviceMatrixTest, UpdateConsistentMeta, TestSize.Level1)
502 {
503 DeviceMatrix deviceMatrix;
504 std::string device = "device";
505 DeviceMatrix::Mask remote;
506 remote.statics = 0;
507 remote.dynamic = 0;
508 EXPECT_NO_FATAL_FAILURE(deviceMatrix.UpdateConsistentMeta(device, remote));
509
510 remote.statics = 0x1;
511 EXPECT_NO_FATAL_FAILURE(deviceMatrix.UpdateConsistentMeta(device, remote));
512
513 remote.dynamic = 0x1;
514 EXPECT_NO_FATAL_FAILURE(deviceMatrix.UpdateConsistentMeta(device, remote));
515
516 remote.statics = 0;
517 EXPECT_NO_FATAL_FAILURE(deviceMatrix.UpdateConsistentMeta(device, remote));
518 }
519
520 /**
521 * @tc.name: OnChanged001
522 * @tc.desc: Test the DeviceMatrix::OnChanged method exception scenario.
523 * @tc.type: FUNC
524 * @tc.require:
525 * @tc.author: suoqilong
526 */
527 HWTEST_F(DeviceMatrixTest, OnChanged001, TestSize.Level1)
528 {
529 StoreMetaData metaData;
530 metaData.dataType = static_cast<DeviceMatrix::LevelType>(DeviceMatrix::LevelType::STATICS - 1);
531 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().OnChanged(metaData));
532
533 metaData.dataType = DeviceMatrix::LevelType::BUTT;
534 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().OnChanged(metaData));
535
536 metaData.bundleName = "distributeddata";
537 metaData.tokenId = selfToken_;
538 metaData.storeId = "service_meta";
539 metaData.dataType = 1;
540 metaData.dataType = DeviceMatrix::LevelType::STATICS;
541 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().OnChanged(metaData));
542
543 StoreMetaData meta = metaData_;
544 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().OnChanged(meta));
545 }
546
547 /**
548 * @tc.name: OnChanged002
549 * @tc.desc: Test the DeviceMatrix::OnChanged method exception scenario.
550 * @tc.type: FUNC
551 * @tc.require:
552 * @tc.author: suoqilong
553 */
554 HWTEST_F(DeviceMatrixTest, OnChanged002, TestSize.Level1)
555 {
556 StoreMetaData metaData;
557 metaData.bundleName = "distributeddata";
558 metaData.tokenId = selfToken_;
559 metaData.storeId = "service_meta";
560 metaData.dataType = 1;
561 auto code = DeviceMatrix::GetInstance().GetCode(metaData);
562 DeviceMatrix::LevelType type = static_cast<DeviceMatrix::LevelType>(DeviceMatrix::LevelType::STATICS - 1);
563 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().OnChanged(code, type));
564
565 type = DeviceMatrix::LevelType::BUTT;
566 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().OnChanged(code, type));
567
568 StoreMetaData meta = metaData_;
569 code = DeviceMatrix::GetInstance().GetCode(meta);
570 EXPECT_EQ(code, 0);
571 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().OnChanged(code, type));
572 }
573
574 /**
575 * @tc.name: OnExchanged001
576 * @tc.desc: Test the DeviceMatrix::OnExchanged method exception scenario.
577 * @tc.type: FUNC
578 * @tc.require:
579 * @tc.author: suoqilong
580 */
581 HWTEST_F(DeviceMatrixTest, OnExchanged001, TestSize.Level1)
582 {
583 StoreMetaData metaData;
584 metaData.bundleName = "distributeddata";
585 metaData.tokenId = selfToken_;
586 metaData.storeId = "service_meta";
587 metaData.dataType = 1;
588 auto code = DeviceMatrix::GetInstance().GetCode(metaData);
589 DeviceMatrix::LevelType type = static_cast<DeviceMatrix::LevelType>(DeviceMatrix::LevelType::STATICS - 1);
590 std::string device;
591 EXPECT_NO_FATAL_FAILURE(
592 DeviceMatrix::GetInstance().OnExchanged(device, code, type, DeviceMatrix::ChangeType::CHANGE_REMOTE));
593
594 device = "OnExchanged";
595 EXPECT_NO_FATAL_FAILURE(
596 DeviceMatrix::GetInstance().OnExchanged(device, code, type, DeviceMatrix::ChangeType::CHANGE_REMOTE));
597
598 type = DeviceMatrix::LevelType::BUTT;
599 EXPECT_NO_FATAL_FAILURE(
600 DeviceMatrix::GetInstance().OnExchanged(device, code, type, DeviceMatrix::ChangeType::CHANGE_REMOTE));
601 }
602
603 /**
604 * @tc.name: OnExchanged002
605 * @tc.desc: Test the DeviceMatrix::OnExchanged method exception scenario.
606 * @tc.type: FUNC
607 * @tc.require:
608 * @tc.author: suoqilong
609 */
610 HWTEST_F(DeviceMatrixTest, OnExchanged002, TestSize.Level1)
611 {
612 StoreMetaData metaData;
613 metaData.dataType = static_cast<DeviceMatrix::LevelType>(DeviceMatrix::LevelType::STATICS - 1);
614 std::string device = "OnExchanged";
615 EXPECT_NO_FATAL_FAILURE(
616 DeviceMatrix::GetInstance().OnExchanged(device, metaData, DeviceMatrix::ChangeType::CHANGE_REMOTE));
617
618 metaData.dataType = DeviceMatrix::LevelType::BUTT;
619 EXPECT_NO_FATAL_FAILURE(
620 DeviceMatrix::GetInstance().OnExchanged(device, metaData, DeviceMatrix::ChangeType::CHANGE_REMOTE));
621 }
622
623 /**
624 * @tc.name: OnExchanged003
625 * @tc.desc: Test the DeviceMatrix::OnExchanged method.
626 * @tc.type: FUNC
627 * @tc.require:
628 * @tc.author: suoqilong
629 */
630 HWTEST_F(DeviceMatrixTest, OnExchanged003, TestSize.Level1)
631 {
632 StoreMetaData metaData;
633 metaData.bundleName = "distributeddata";
634 metaData.tokenId = selfToken_;
635 metaData.storeId = "service_meta";
636 metaData.dataType = 1;
637 std::string device = "OnExchanged";
638 EXPECT_NO_FATAL_FAILURE(
639 DeviceMatrix::GetInstance().OnExchanged(device, metaData, DeviceMatrix::ChangeType::CHANGE_REMOTE));
640
641 StoreMetaData meta = metaData_;
642 EXPECT_NO_FATAL_FAILURE(
643 DeviceMatrix::GetInstance().OnExchanged(device, meta, DeviceMatrix::ChangeType::CHANGE_REMOTE));
644 }
645
646 /**
647 * @tc.name: GetCode
648 * @tc.desc: Test the DeviceMatrix::GetCode method.
649 * @tc.type: FUNC
650 * @tc.require:
651 * @tc.author: suoqilong
652 */
653 HWTEST_F(DeviceMatrixTest, GetCode, TestSize.Level1)
654 {
655 StoreMetaData metaData;
656 metaData.bundleName = "distributeddata";
657 metaData.tokenId = selfToken_;
658 metaData.storeId = "storeId";
659 metaData.dataType = DeviceMatrix::LevelType::BUTT;
660 auto code = DeviceMatrix::GetInstance().GetCode(metaData);
661 EXPECT_EQ(code, 0);
662 }
663
664 /**
665 * @tc.name: GetMask001
666 * @tc.desc: Test the DeviceMatrix::GetMask method.
667 * @tc.type: FUNC
668 * @tc.require:
669 * @tc.author: suoqilong
670 */
671 HWTEST_F(DeviceMatrixTest, GetMask001, TestSize.Level1)
672 {
673 std::string device = "GetMask";
674 DeviceMatrix::LevelType type = DeviceMatrix::LevelType::STATICS;
675 std::pair<bool, uint16_t> mask = DeviceMatrix::GetInstance().GetMask(device, type);
676 EXPECT_EQ(mask.first, false);
677 }
678
679 /**
680 * @tc.name: GetMask002
681 * @tc.desc: Test the DeviceMatrix::GetMask method.
682 * @tc.type: FUNC
683 * @tc.require:
684 * @tc.author: suoqilong
685 */
686 HWTEST_F(DeviceMatrixTest, GetMask002, TestSize.Level1)
687 {
688 std::string device = "GetMask";
689 DeviceMatrix::LevelType type = DeviceMatrix::LevelType::STATICS;
690 RefCount refCount;
691 DeviceMatrix::GetInstance().Online(device, refCount);
692 std::pair<bool, uint16_t> mask = DeviceMatrix::GetInstance().GetMask(device, type);
693 EXPECT_EQ(mask.first, true);
694
695 type = DeviceMatrix::LevelType::DYNAMIC;
696 mask = DeviceMatrix::GetInstance().GetMask(device, type);
697 EXPECT_EQ(mask.first, true);
698
699 type = DeviceMatrix::LevelType::BUTT;
700 mask = DeviceMatrix::GetInstance().GetMask(device, type);
701 EXPECT_EQ(mask.first, false);
702 }
703
704 /**
705 * @tc.name: GetRemoteMask001
706 * @tc.desc: Test the DeviceMatrix::GetRemoteMask method.
707 * @tc.type: FUNC
708 * @tc.require:
709 * @tc.author: suoqilong
710 */
711 HWTEST_F(DeviceMatrixTest, GetRemoteMask001, TestSize.Level1)
712 {
713 std::string device = "GetRemoteMask";
714 DeviceMatrix::LevelType type = DeviceMatrix::LevelType::STATICS;
715 std::pair<bool, uint16_t> mask = DeviceMatrix::GetInstance().GetRemoteMask(device, type);
716 EXPECT_EQ(mask.first, false);
717 }
718
719 /**
720 * @tc.name: GetRemoteMask002
721 * @tc.desc: Test the DeviceMatrix::GetRemoteMask method.
722 * @tc.type: FUNC
723 * @tc.require:
724 * @tc.author: suoqilong
725 */
726 HWTEST_F(DeviceMatrixTest, GetRemoteMask002, TestSize.Level1)
727 {
728 std::string device = "GetRemoteMask";
729 StoreMetaData meta = metaData_;
730 auto code = DeviceMatrix::GetInstance().GetCode(meta);
731 DeviceMatrix::DataLevel level = {
732 .dynamic = code,
733 };
734 DeviceMatrix::GetInstance().OnBroadcast(device, level);
735
736 DeviceMatrix::LevelType type = DeviceMatrix::LevelType::STATICS;
737 std::pair<bool, uint16_t> mask = DeviceMatrix::GetInstance().GetRemoteMask(device, type);
738 EXPECT_EQ(mask.first, true);
739
740 type = DeviceMatrix::LevelType::DYNAMIC;
741 mask = DeviceMatrix::GetInstance().GetRemoteMask(device, type);
742 EXPECT_EQ(mask.first, true);
743
744 type = DeviceMatrix::LevelType::BUTT;
745 mask = DeviceMatrix::GetInstance().GetRemoteMask(device, type);
746 EXPECT_EQ(mask.first, false);
747 }
748
749 /**
750 * @tc.name: GetRecvLevel
751 * @tc.desc: Test the DeviceMatrix::GetRecvLevel method.
752 * @tc.type: FUNC
753 * @tc.require:
754 * @tc.author: suoqilong
755 */
756 HWTEST_F(DeviceMatrixTest, GetRecvLevel, TestSize.Level1)
757 {
758 std::string device = "GetRemoteMask";
759 DeviceMatrix::LevelType type = DeviceMatrix::LevelType::STATICS;
760 std::pair<bool, uint16_t> mask = DeviceMatrix::GetInstance().GetRecvLevel(device, type);
761 EXPECT_EQ(mask.first, true);
762
763 device = TEST_DEVICE;
764 mask = DeviceMatrix::GetInstance().GetRecvLevel(device, type);
765 EXPECT_EQ(mask.first, true);
766
767 type = DeviceMatrix::LevelType::DYNAMIC;
768 mask = DeviceMatrix::GetInstance().GetRecvLevel(device, type);
769 EXPECT_EQ(mask.first, true);
770
771 type = DeviceMatrix::LevelType::BUTT;
772 mask = DeviceMatrix::GetInstance().GetRecvLevel(device, type);
773 EXPECT_EQ(mask.first, false);
774 }
775
776 /**
777 * @tc.name: GetConsLevel
778 * @tc.desc: Test the DeviceMatrix::GetConsLevel method.
779 * @tc.type: FUNC
780 * @tc.require:
781 * @tc.author: suoqilong
782 */
783 HWTEST_F(DeviceMatrixTest, GetConsLevel, TestSize.Level1)
784 {
785 std::string device = "GetRemoteMask";
786 DeviceMatrix::LevelType type = DeviceMatrix::LevelType::STATICS;
787 std::pair<bool, uint16_t> mask = DeviceMatrix::GetInstance().GetConsLevel(device, type);
788 EXPECT_EQ(mask.first, false);
789
790 device = TEST_DEVICE;
791 mask = DeviceMatrix::GetInstance().GetConsLevel(device, type);
792 EXPECT_EQ(mask.first, true);
793
794 type = DeviceMatrix::LevelType::DYNAMIC;
795 mask = DeviceMatrix::GetInstance().GetConsLevel(device, type);
796 EXPECT_EQ(mask.first, true);
797
798 type = DeviceMatrix::LevelType::BUTT;
799 mask = DeviceMatrix::GetInstance().GetConsLevel(device, type);
800 EXPECT_EQ(mask.first, false);
801 }
802
803 /**
804 * @tc.name: UpdateLevel
805 * @tc.desc: Test the DeviceMatrix::UpdateLevel method exception scenario.
806 * @tc.type: FUNC
807 * @tc.require:
808 * @tc.author: suoqilong
809 */
810 HWTEST_F(DeviceMatrixTest, UpdateLevel, TestSize.Level1)
811 {
812 uint16_t level = 0;
813 DeviceMatrix::LevelType type = static_cast<DeviceMatrix::LevelType>(DeviceMatrix::LevelType::STATICS - 1);
814 std::string device;
815 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().UpdateLevel(device, level, type));
816
817 device = "OnExchanged";
818 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().UpdateLevel(device, level, type));
819
820 type = DeviceMatrix::LevelType::BUTT;
821 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().UpdateLevel(device, level, type));
822
823 type = DeviceMatrix::LevelType::STATICS;
824 device = TEST_DEVICE;
825 EXPECT_NO_FATAL_FAILURE(DeviceMatrix::GetInstance().UpdateLevel(device, level, type));
826 }
827
828 /**
829 * @tc.name: IsDynamic
830 * @tc.desc: Test the DeviceMatrix::IsDynamic method exception scenario.
831 * @tc.type: FUNC
832 * @tc.require:
833 * @tc.author: suoqilong
834 */
835 HWTEST_F(DeviceMatrixTest, IsDynamic, TestSize.Level1)
836 {
837 StoreMetaData meta;
838 meta.bundleName = "distributeddata";
839 meta.tokenId = selfToken_;
840 meta.storeId = "";
841 meta.dataType = DeviceMatrix::LevelType::STATICS;
842 bool isDynamic = DeviceMatrix::GetInstance().IsDynamic(meta);
843 EXPECT_EQ(isDynamic, false);
844
845 meta.dataType = DeviceMatrix::LevelType::DYNAMIC;
846 isDynamic = DeviceMatrix::GetInstance().IsDynamic(meta);
847 EXPECT_EQ(isDynamic, false);
848
849 meta.storeId = "service_meta";
850 isDynamic = DeviceMatrix::GetInstance().IsDynamic(meta);
851 EXPECT_EQ(isDynamic, true);
852
853 meta.tokenId = 1;
854 isDynamic = DeviceMatrix::GetInstance().IsDynamic(meta);
855 EXPECT_EQ(isDynamic, false);
856
857 meta.storeId = "";
858 isDynamic = DeviceMatrix::GetInstance().IsDynamic(meta);
859 EXPECT_EQ(isDynamic, false);
860 }
861
862 /**
863 * @tc.name: IsValid
864 * @tc.desc: Test the DeviceMatrix::IsValid method exception scenario.
865 * @tc.type: FUNC
866 * @tc.require:
867 * @tc.author: suoqilong
868 */
869 HWTEST_F(DeviceMatrixTest, IsValid, TestSize.Level1)
870 {
871 DistributedData::DeviceMatrix::DataLevel dataLevel;
872 EXPECT_EQ(dataLevel.IsValid(), false);
873
874 dataLevel.dynamic = 0;
875 dataLevel.statics = 0;
876 dataLevel.switches = 0;
877 dataLevel.switchesLen = 0;
878 EXPECT_EQ(dataLevel.IsValid(), true);
879 }
880
881 class MatrixEventTest : public testing::Test {
882 public:
SetUpTestCase(void)883 static void SetUpTestCase(void){};
TearDownTestCase(void)884 static void TearDownTestCase(void){};
SetUp()885 void SetUp(){};
TearDown()886 void TearDown(){};
887 };
888
889 /**
890 * @tc.name: IsValid
891 * @tc.desc: Test the MatrixEvent::IsValid method exception scenario.
892 * @tc.type: FUNC
893 * @tc.require:
894 * @tc.author: suoqilong
895 */
896 HWTEST_F(MatrixEventTest, IsValid, TestSize.Level1)
897 {
898 DistributedData::MatrixEvent::MatrixData matrixData;
899 EXPECT_EQ(matrixData.IsValid(), false);
900
901 matrixData.dynamic = 0;
902 matrixData.statics = 0;
903 matrixData.switches = 0;
904 matrixData.switchesLen = 0;
905 EXPECT_EQ(matrixData.IsValid(), true);
906 }