1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "gtest/gtest.h"
17
18 #define private public
19 #include "ans_inner_errors.h"
20 #include "distributed_data_define.h"
21 #include "distributed_extension_service.h"
22 #include "distributed_device_manager.h"
23 #include "mock_device_manager_impl.h"
24
25 namespace OHOS {
26 namespace Notification {
27
28 using namespace testing::ext;
29 using namespace DistributedHardware;
30
31 class DistributedExtensionServiceTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
SetUp()35 void SetUp() {};
TearDown()36 void TearDown() {};
37 };
38
SetUpTestCase()39 void DistributedExtensionServiceTest::SetUpTestCase()
40 {
41 GTEST_LOG_(INFO) << "SetUp Case start";
42 GTEST_LOG_(INFO) << "SetUp end";
43 }
44
TearDownTestCase()45 void DistributedExtensionServiceTest::TearDownTestCase()
46 {
47 GTEST_LOG_(INFO) << "TearDown case";
48 }
49
50 /**
51 * @tc.name: Distributed extension service config check
52 * @tc.desc: Test device data service
53 * @tc.type: FUNC
54 * @tc.require: issue
55 */
56 HWTEST_F(DistributedExtensionServiceTest, extension_00001, Function | SmallTest | Level1)
57 {
58 // init extension conifg.
59 bool result = DistributedExtensionService::GetInstance().initConfig();
60 ASSERT_EQ(result, true);
61 DistributedDeviceConfig config = DistributedExtensionService::GetInstance().deviceConfig_;
62 if (config.localType == "Phone") {
63 ASSERT_EQ(config.supportPeerDevice.count("Watch"), 1);
64 }
65 }
66
67 /**
68 * @tc.name: Distributed extension service
69 * @tc.desc: Check device Type Convert
70 * @tc.type: FUNC
71 * @tc.require: issue
72 */
73 HWTEST_F(DistributedExtensionServiceTest, extension_00002, Function | SmallTest | Level1)
74 {
75 std::string deviceType;
76 deviceType = DistributedExtensionService::TransDeviceTypeToName(DmDeviceType::DEVICE_TYPE_WATCH);
77 ASSERT_EQ(deviceType, "Watch");
78 deviceType = DistributedExtensionService::TransDeviceTypeToName(DmDeviceType::DEVICE_TYPE_PAD);
79 ASSERT_EQ(deviceType, "Tablet");
80 deviceType = DistributedExtensionService::TransDeviceTypeToName(DmDeviceType::DEVICE_TYPE_PHONE);
81 ASSERT_EQ(deviceType, "Phone");
82 deviceType = DistributedExtensionService::TransDeviceTypeToName(DmDeviceType::DEVICE_TYPE_2IN1);
83 ASSERT_EQ(deviceType, "Pc");
84 deviceType = DistributedExtensionService::TransDeviceTypeToName(DmDeviceType::DEVICE_TYPE_PC);
85 ASSERT_EQ(deviceType, "Pc");
86 deviceType = DistributedExtensionService::TransDeviceTypeToName(DmDeviceType::DEVICE_TYPE_WIFI_CAMERA);
87 ASSERT_EQ(deviceType, "");
88 deviceType = DistributedExtensionService::DeviceTypeToTypeString(DmDeviceType::DEVICE_TYPE_PAD);
89 ASSERT_EQ(deviceType, "tablet");
90 deviceType = DistributedExtensionService::DeviceTypeToTypeString(DmDeviceType::DEVICE_TYPE_PC);
91 ASSERT_EQ(deviceType, "2in1");
92 deviceType = DistributedExtensionService::DeviceTypeToTypeString(DmDeviceType::DEVICE_TYPE_2IN1);
93 ASSERT_EQ(deviceType, "2in1");
94 deviceType = DistributedExtensionService::DeviceTypeToTypeString(DmDeviceType::DEVICE_TYPE_WATCH);
95 ASSERT_EQ(deviceType, "");
96 }
97
98 /**
99 * @tc.name: Distributed extension service
100 * @tc.desc: Check device Type Convert
101 * @tc.type: FUNC
102 * @tc.require: issue
103 */
104 HWTEST_F(DistributedExtensionServiceTest, extension_00003, Function | SmallTest | Level1)
105 {
106 nlohmann::json operationJson;
107 operationJson["operationReplyTimeout"] = 10;
108 DistributedExtensionService::GetInstance().SetOperationReplyTimeout(operationJson);
109 int32_t data = DistributedExtensionService::GetInstance().deviceConfig_.operationReplyTimeout;
110 ASSERT_EQ(data, 10);
111 nlohmann::json emptyTimeJson;
112 DistributedExtensionService::GetInstance().SetOperationReplyTimeout(emptyTimeJson);
113 data = DistributedExtensionService::GetInstance().deviceConfig_.operationReplyTimeout;
114 ASSERT_EQ(data, 3);
115 emptyTimeJson["operationReplyTimeout"] = "10";
116 DistributedExtensionService::GetInstance().SetOperationReplyTimeout(emptyTimeJson);
117 data = DistributedExtensionService::GetInstance().deviceConfig_.operationReplyTimeout;
118 ASSERT_EQ(data, 3);
119
120
121 nlohmann::json contentJson;
122 contentJson["maxContentLength"] = 20;
123 DistributedExtensionService::GetInstance().SetMaxContentLength(contentJson);
124 data = DistributedExtensionService::GetInstance().deviceConfig_.maxContentLength;
125 ASSERT_EQ(data, 20);
126 nlohmann::json emptyJson;
127 DistributedExtensionService::GetInstance().SetMaxContentLength(emptyJson);
128 data = DistributedExtensionService::GetInstance().deviceConfig_.maxContentLength;
129 ASSERT_EQ(data, 400);
130 emptyJson["maxContentLength"] = "20";
131 DistributedExtensionService::GetInstance().SetMaxContentLength(emptyJson);
132 data = DistributedExtensionService::GetInstance().deviceConfig_.maxContentLength;
133 ASSERT_EQ(data, 400);
134 }
135
136 /**
137 * @tc.name: Distributed extension service
138 * @tc.desc: Check the device status change
139 * @tc.type: FUNC
140 * @tc.require: issue
141 */
142 HWTEST_F(DistributedExtensionServiceTest, extension_00004, Function | SmallTest | Level1)
143 {
144 // register device manager.
145 bool result = DistributedDeviceManager::GetInstance().RegisterDms(true);
146 ASSERT_EQ(result, true);
147 // register device manager.
148 DeviceTrigger::TriggerOnRemoteDied();
149 DistributedExtensionService::GetInstance().HADotCallback(0, 0, 0, "{\"deviceType\":\"pc\"}");
150 DistributedExtensionService::GetInstance().HADotCallback(0, 0, 0, "{\"result\":\"ok\"}");
151 DistributedDeviceManager::GetInstance().InitTrustList();
152 // trigger device online
153 DeviceTrigger::MockTransDeviceIdToUdid(true);
154 DeviceTrigger::TriggerDeviceOnline();
155 DeviceTrigger::MockTransDeviceIdToUdid(false);
156 bool isEmpty = DistributedExtensionService::GetInstance().deviceMap_.empty();
157 ASSERT_EQ(isEmpty, true);
158
159 DeviceTrigger::TriggerDeviceOnline();
160 DistributedExtensionService::GetInstance().OnAllConnectOnline();
161 sleep(1);
162 // check online device
163 DistributedExtensionService::GetInstance().HADotCallback(7, 0, BRANCH_3, "{\"result\":\"ok\"}");
164 isEmpty = DistributedExtensionService::GetInstance().deviceMap_.empty();
165 ASSERT_EQ(isEmpty, false);
166 // trigger device ready
167 DistributedExtensionService::GetInstance().HADotCallback(7, 0, BRANCH_4, "{\"result\":\"ok\"}");
168 DeviceTrigger::TriggerDeviceReady();
169 // trigger device change
170 DistributedExtensionService::GetInstance().HADotCallback(7, 5, BRANCH_5, "{\"result\":\"ok\"}");
171 DeviceTrigger::TriggerDeviceChanged();
172 // trigger device offline
173 DistributedExtensionService::GetInstance().HADotCallback(5, 0, BRANCH_5, "{\"result\":\"ok\"}");
174 DeviceTrigger::TriggerDeviceOffline();
175 sleep(1);
176 DistributedExtensionService::GetInstance().HADotCallback(6, 0, 0, "{\"result\":\"ok\"}");
177 DistributedExtensionService::GetInstance().SendReportCallback(7, 0, "ok");
178 // check online device
179 isEmpty = DistributedExtensionService::GetInstance().deviceMap_.empty();
180 ASSERT_EQ(isEmpty, true);
181 }
182
183 /**
184 * @tc.name: Distributed extension service
185 * @tc.desc: Check branch when ffrt is null
186 * @tc.type: FUNC
187 * @tc.require: issue
188 */
189 HWTEST_F(DistributedExtensionServiceTest, extension_00005, Function | SmallTest | Level1)
190 {
191 // register device manager.
192 DeviceTrigger::MockInitDeviceManager(true);
193 bool result = DistributedDeviceManager::GetInstance().RegisterDms(true);
194 ASSERT_EQ(result, false);
195 DeviceTrigger::MockInitDeviceManager(false);
196
197 DeviceTrigger::MockRegisterDevStateCallback(true);
198 DistributedDeviceManager::GetInstance().hasInit.store(false);
199 DistributedDeviceManager::GetInstance().InitTrustList();
200 result = DistributedDeviceManager::GetInstance().RegisterDms(true);
201 ASSERT_EQ(result, false);
202 DistributedDeviceManager::GetInstance().hasInit.store(true);
203 DeviceTrigger::MockGetTrustedDeviceList(true);
204 DistributedDeviceManager::GetInstance().InitTrustList();
205 DeviceTrigger::MockGetTrustedDeviceList(false);
206 DeviceTrigger::MockRegisterDevStateCallback(false);
207 result = DistributedDeviceManager::GetInstance().RegisterDms(true);
208 ASSERT_EQ(result, true);
209 }
210
211 /**
212 * @tc.name: Distributed extension service
213 * @tc.desc: Check ccm config
214 * @tc.type: FUNC
215 * @tc.require: issue
216 */
217 HWTEST_F(DistributedExtensionServiceTest, extension_00006, Function | SmallTest | Level1)
218 {
219 DistributedDeviceConfig config;
220 DistributedExtensionService::GetInstance().deviceConfig_ = config;
221 // register device manager.
222 DeviceTrigger::MockConfigScene(0);
223 bool result = DistributedExtensionService::GetInstance().initConfig();
224 ASSERT_EQ(result, false);
225
226 DeviceTrigger::MockConfigScene(1);
227 result = DistributedExtensionService::GetInstance().initConfig();
228 ASSERT_EQ(result, false);
229
230 DeviceTrigger::MockConfigScene(2);
231 result = DistributedExtensionService::GetInstance().initConfig();
232 ASSERT_EQ(result, false);
233
234 DeviceTrigger::MockConfigScene(3);
235 result = DistributedExtensionService::GetInstance().initConfig();
236 ASSERT_EQ(result, false);
237
238 DeviceTrigger::MockConfigScene(4);
239 result = DistributedExtensionService::GetInstance().initConfig();
240 ASSERT_EQ(result, true);
241 std::string localType = DistributedExtensionService::GetInstance().deviceConfig_.localType;
242 ASSERT_EQ(localType.empty(), true);
243 auto peers = DistributedExtensionService::GetInstance().deviceConfig_.supportPeerDevice;
244 ASSERT_EQ(peers.empty(), false);
245 int len = DistributedExtensionService::GetInstance().deviceConfig_.maxTitleLength;
246 ASSERT_EQ(len, 200);
247 DeviceTrigger::MockConfigScene(-1);
248 result = DistributedExtensionService::GetInstance().initConfig();
249 ASSERT_EQ(result, true);
250 }
251 }
252 }
253