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 "enable_task_test.h"
17
18 #include "ffrt.h"
19
20 #include "dh_utils_tool.h"
21 #include "distributed_hardware_errno.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace DistributedHardware {
28 namespace {
29
30 const std::string DEV_ID_1 = "bb536a637105409e904d4da83790a4a8";
31 const std::string DEV_NETWORK_ID_1 = "nt36a637105409e904d4da83790a4a8";
32 const std::string DEV_DID_1 = "2144a637105409e904d4da83790a4a8";
33
34 const TaskParam TASK_PARAM_1 = {
35 .networkId = DEV_NETWORK_ID_1,
36 .uuid = DEV_ID_1,
37 .udid = DEV_DID_1,
38 .dhId = "",
39 .dhType = DHType::UNKNOWN
40 };
41
42 }
43
SetUpTestCase()44 void EnableTaskTest::SetUpTestCase()
45 {}
46
TearDownTestCase()47 void EnableTaskTest::TearDownTestCase()
48 {}
49
SetUp()50 void EnableTaskTest::SetUp()
51 {
52 auto componentManager = IComponentManager::GetOrCreateInstance();
53 componentManager_ = std::static_pointer_cast<MockComponentManager>(componentManager);
54 auto utilTool = IDhUtilTool::GetOrCreateInstance();
55 utilTool_ = std::static_pointer_cast<MockDhUtilTool>(utilTool);
56 }
57
TearDown()58 void EnableTaskTest::TearDown()
59 {
60 IComponentManager::ReleaseInstance();
61 componentManager_ = nullptr;
62 IDhUtilTool::ReleaseInstance();
63 utilTool_ = nullptr;
64 }
65
66 HWTEST_F(EnableTaskTest, RegisterHardware_001, TestSize.Level0)
67 {
68 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
69 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
70 enableTask->SetCallingUid(1);
71 auto ret = enableTask->RegisterHardware();
72 EXPECT_EQ(DH_FWK_SUCCESS, ret);
73 }
74
75 HWTEST_F(EnableTaskTest, RegisterHardware_002, TestSize.Level0)
76 {
77 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
78 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
79 enableTask->SetCallingPid(1);
80 auto ret = enableTask->RegisterHardware();
81 EXPECT_EQ(DH_FWK_SUCCESS, ret);
82 }
83
84 HWTEST_F(EnableTaskTest, RegisterHardware_003, TestSize.Level0)
85 {
86 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
87 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
88 enableTask->SetCallingUid(1);
89 enableTask->SetCallingPid(1);
90 auto ret = enableTask->RegisterHardware();
91 EXPECT_EQ(DH_FWK_SUCCESS, ret);
92 }
93
94 HWTEST_F(EnableTaskTest, RegisterHardware_004, TestSize.Level0)
95 {
96 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
97 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
98 EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return("udid_test"));
99 EXPECT_CALL(*componentManager_, CheckDemandStart(_, _, _)).Times(1).WillRepeatedly(Return(-1));
100 auto ret = enableTask->RegisterHardware();
101 EXPECT_EQ(-1, ret);
102 }
103
104 HWTEST_F(EnableTaskTest, DoAutoEnable_001, TestSize.Level0)
105 {
106 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
107 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
108 EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return("udid_test"));
109 EXPECT_CALL(*componentManager_, CheckDemandStart(_, _, _)).Times(1).WillRepeatedly(
110 DoAll(SetArgReferee<2>(false), Return(0)));
111 auto ret = enableTask->DoAutoEnable();
112 EXPECT_EQ(ERR_DH_FWK_COMPONENT_NO_NEED_ENABLE, ret);
113 }
114
115 HWTEST_F(EnableTaskTest, DoAutoEnable_002, TestSize.Level0)
116 {
117 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
118 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
119 EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return("udid_test"));
120 EXPECT_CALL(*componentManager_, CheckDemandStart(_, _, _)).Times(1).WillRepeatedly(
121 DoAll(SetArgReferee<2>(true), Return(0)));
122 EXPECT_CALL(*componentManager_, EnableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(-1));
123 auto ret = enableTask->DoAutoEnable();
124 EXPECT_EQ(-1, ret);
125 }
126
127 HWTEST_F(EnableTaskTest, DoAutoEnable_003, TestSize.Level0)
128 {
129 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
130 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
131 EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return("udid_test"));
132 EXPECT_CALL(*componentManager_, CheckDemandStart(_, _, _)).Times(1).WillRepeatedly(
133 DoAll(SetArgReferee<2>(true), Return(0)));
134 EXPECT_CALL(*componentManager_, EnableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(0));
135 auto ret = enableTask->DoAutoEnable();
136 EXPECT_EQ(DH_FWK_SUCCESS, ret);
137 }
138
139 HWTEST_F(EnableTaskTest, DoAutoEnable_005, TestSize.Level0)
140 {
141 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
142 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
143 EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return(DEV_DID_1));
144 EXPECT_CALL(*componentManager_, CheckSinkConfigStart(_, _)).Times(1).WillRepeatedly(Return(-1));
145 auto ret = enableTask->DoAutoEnable();
146 EXPECT_EQ(-1, ret);
147 }
148
149 HWTEST_F(EnableTaskTest, DoAutoEnable_006, TestSize.Level0)
150 {
151 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
152 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
153 EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return(DEV_DID_1));
154 EXPECT_CALL(*componentManager_, CheckSinkConfigStart(_, _)).Times(1).WillRepeatedly(
155 DoAll(SetArgReferee<1>(false), Return(0)));
156 auto ret = enableTask->DoAutoEnable();
157 EXPECT_EQ(ERR_DH_FWK_COMPONENT_NO_NEED_ENABLE, ret);
158 }
159
160 HWTEST_F(EnableTaskTest, DoAutoEnable_007, TestSize.Level0)
161 {
162 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
163 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
164 EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return(DEV_DID_1));
165 EXPECT_CALL(*componentManager_, CheckSinkConfigStart(_, _)).Times(1).WillRepeatedly(
166 DoAll(SetArgReferee<1>(true), Return(0)));
167 EXPECT_CALL(*componentManager_, EnableSink(_, _, _)).Times(1).WillRepeatedly(Return(-1));
168 auto ret = enableTask->DoAutoEnable();
169 EXPECT_EQ(-1, ret);
170 }
171
172 HWTEST_F(EnableTaskTest, DoAutoEnable_008, TestSize.Level0)
173 {
174 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
175 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
176 EXPECT_CALL(*utilTool_, GetLocalUdid()).WillRepeatedly(Return(DEV_DID_1));
177 EXPECT_CALL(*componentManager_, CheckSinkConfigStart(_, _)).Times(1).WillRepeatedly(
178 DoAll(SetArgReferee<1>(true), Return(0)));
179 EXPECT_CALL(*componentManager_, EnableSink(_, _, _)).Times(1).WillRepeatedly(Return(0));
180 auto ret = enableTask->DoAutoEnable();
181 EXPECT_EQ(DH_FWK_SUCCESS, ret);
182 }
183
184 HWTEST_F(EnableTaskTest, DoActiveEnable_001, TestSize.Level0)
185 {
186 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
187 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
188 enableTask->SetEffectSink(true);
189 EXPECT_CALL(*componentManager_, EnableSink(_, _, _)).Times(1).WillRepeatedly(Return(0));
190 auto ret = enableTask->DoActiveEnable();
191 EXPECT_EQ(DH_FWK_SUCCESS, ret);
192 }
193
194 HWTEST_F(EnableTaskTest, DoActiveEnable_002, TestSize.Level0)
195 {
196 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
197 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
198 enableTask->SetEffectSink(true);
199 EXPECT_CALL(*componentManager_, EnableSink(_, _, _)).Times(1).WillRepeatedly(Return(-1));
200 auto ret = enableTask->DoActiveEnable();
201 EXPECT_EQ(-1, ret);
202 }
203
204 HWTEST_F(EnableTaskTest, DoActiveEnable_003, TestSize.Level0)
205 {
206 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
207 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
208 enableTask->SetEffectSource(true);
209 EXPECT_CALL(*componentManager_, EnableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(0));
210 auto ret = enableTask->DoActiveEnable();
211 EXPECT_EQ(DH_FWK_SUCCESS, ret);
212 }
213
214 HWTEST_F(EnableTaskTest, DoActiveEnable_004, TestSize.Level0)
215 {
216 auto enableTask = std::make_shared<EnableTask>(TASK_PARAM_1.networkId, TASK_PARAM_1.uuid, TASK_PARAM_1.udid,
217 TASK_PARAM_1.dhId, TASK_PARAM_1.dhType);
218 enableTask->SetEffectSource(true);
219 EXPECT_CALL(*componentManager_, EnableSource(_, _, _, _)).Times(1).WillRepeatedly(Return(-1));
220 auto ret = enableTask->DoActiveEnable();
221 EXPECT_EQ(-1, ret);
222 }
223 } // namespace DistributedHardware
224 } // namespace OHOS