1 /*
2 * Copyright (c) 2023 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 "usb_event_mock_test.h"
16
17 #include <gtest/gtest.h>
18 #include <iostream>
19 #include "cJSON.h"
20 #include <semaphore.h>
21
22 #include "common_event_manager.h"
23 #include "common_event_support.h"
24 #include "usb_common_test.h"
25 #include "usb_device.h"
26 #include "usb_device_pipe.h"
27 #include "usb_srv_client.h"
28 #include "usb_srv_support.h"
29
30 using namespace OHOS;
31 using namespace OHOS::HDI::Usb::V1_0;
32 using namespace OHOS::USB;
33 using namespace OHOS::EventFwk;
34 using namespace OHOS::USB::Common;
35 using namespace std;
36 using namespace testing::ext;
37
38 using ::testing::Eq;
39 using ::testing::Exactly;
40 using ::testing::Ge;
41 using ::testing::Le;
42 using ::testing::Ne;
43 using ::testing::Return;
44
45 namespace OHOS {
46 namespace USB {
47 sem_t UsbEventMockTest::testSem_ {};
48 sptr<MockUsbImpl> UsbEventMockTest::mockUsbImpl_ = nullptr;
49 sptr<UsbService> UsbEventMockTest::usbSrv_ = nullptr;
50
51 class UsbSubscriberMockTest : public CommonEventSubscriber {
52 public:
UsbSubscriberMockTest(const CommonEventSubscribeInfo & sp)53 explicit UsbSubscriberMockTest(const CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp) {}
54
OnReceiveEvent(const CommonEventData & data)55 void OnReceiveEvent(const CommonEventData &data) override
56 {
57 USB_HILOGI(MODULE_USB_SERVICE, "recv event ok");
58 eventData_ = data;
59 sem_post(&UsbEventMockTest::testSem_);
60 }
61
62 static CommonEventData eventData_;
63 };
64
65 CommonEventData UsbSubscriberMockTest::eventData_ {};
66
SetUpTestCase(void)67 void UsbEventMockTest::SetUpTestCase(void)
68 {
69 USB_HILOGI(MODULE_USB_SERVICE, "UsbEventMockTest SetUpTestCase Start");
70 UsbCommonTest::SetTestCaseHapApply();
71
72 usbSrv_ = DelayedSpSingleton<UsbService>::GetInstance();
73 EXPECT_NE(usbSrv_, nullptr);
74 mockUsbImpl_ = DelayedSpSingleton<MockUsbImpl>::GetInstance();
75 EXPECT_NE(mockUsbImpl_, nullptr);
76
77 usbSrv_->SetUsbd(mockUsbImpl_);
78
79 sptr<UsbServiceSubscriber> iSubscriber = new UsbServiceSubscriber();
80 EXPECT_NE(iSubscriber, nullptr);
81 mockUsbImpl_->BindUsbdSubscriber(iSubscriber);
82 }
83
TearDownTestCase(void)84 void UsbEventMockTest::TearDownTestCase(void)
85 {
86 USB_HILOGI(MODULE_USB_SERVICE, "UsbEventMockTest TearDownTestCase enter");
87 sptr<IUsbInterface> usbd = IUsbInterface::Get();
88 mockUsbImpl_->UnbindUsbdSubscriber(nullptr);
89 usbSrv_->SetUsbd(usbd);
90
91 mockUsbImpl_ = nullptr;
92 usbSrv_ = nullptr;
93 DelayedSpSingleton<UsbService>::DestroyInstance();
94 DelayedSpSingleton<MockUsbImpl>::DestroyInstance();
95 }
96
SetUp()97 void UsbEventMockTest::SetUp()
98 {
99 sem_init(&UsbEventMockTest::testSem_, 1, 0);
100 }
101
TearDown()102 void UsbEventMockTest::TearDown()
103 {
104 sem_destroy(&UsbEventMockTest::testSem_);
105 }
106
107 /**
108 * @tc.name: SUB_USB_Broadcast_0100
109 * @tc.desc: usb gadget connected event
110 * @tc.desc: Positive test: parameters correctly
111 * @tc.type: FUNC
112 */
113 HWTEST_F(UsbEventMockTest, SUB_USB_Broadcast_0100, TestSize.Level1)
114 {
115 MatchingSkills matchingSkills;
116 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USB_STATE);
117 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
118 std::shared_ptr<UsbSubscriberMockTest> subscriber = std::make_shared<UsbSubscriberMockTest>(subscriberInfo);
119 CommonEventManager::SubscribeCommonEvent(subscriber);
120
121 USBDeviceInfo info;
122 info.status = ACT_UPDEVICE;
123 EXPECT_CALL(*mockUsbImpl_, GetCurrentFunctions(testing::_)).WillRepeatedly(Return(0));
124 auto ret = mockUsbImpl_->SubscriberDeviceEvent(info);
125 EXPECT_EQ(0, ret);
126
127 sem_wait(&UsbEventMockTest::testSem_);
128 CommonEventManager::UnSubscribeCommonEvent(subscriber);
129 auto &want = UsbSubscriberMockTest::eventData_.GetWant();
130 EXPECT_EQ(want.GetAction(), CommonEventSupport::COMMON_EVENT_USB_STATE);
131 EXPECT_TRUE(want.GetBoolParam(std::string {UsbSrvSupport::CONNECTED}, false));
132 EXPECT_TRUE(want.GetBoolParam(std::string {UsbSrvSupport::FUNCTION_NAME_HDC}, false));
133 }
134
135 /**
136 * @tc.name: SUB_USB_Broadcast_0200
137 * @tc.desc: usb gadget disconnected event
138 * @tc.desc: Positive test: parameters correctly
139 * @tc.type: FUNC
140 */
141 HWTEST_F(UsbEventMockTest, SUB_USB_Broadcast_0200, TestSize.Level1)
142 {
143 MatchingSkills matchingSkills;
144 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USB_STATE);
145 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
146 std::shared_ptr<UsbSubscriberMockTest> subscriber = std::make_shared<UsbSubscriberMockTest>(subscriberInfo);
147 CommonEventManager::SubscribeCommonEvent(subscriber);
148
149 USBDeviceInfo info;
150 info.status = ACT_DOWNDEVICE;
151 EXPECT_CALL(*mockUsbImpl_, GetCurrentFunctions(testing::_)).WillRepeatedly(Return(0));
152 auto ret = mockUsbImpl_->SubscriberDeviceEvent(info);
153 EXPECT_EQ(0, ret);
154
155 sem_wait(&UsbEventMockTest::testSem_);
156 CommonEventManager::UnSubscribeCommonEvent(subscriber);
157 auto &want = UsbSubscriberMockTest::eventData_.GetWant();
158 EXPECT_EQ(want.GetAction(), CommonEventSupport::COMMON_EVENT_USB_STATE);
159 EXPECT_FALSE(want.GetBoolParam(std::string {UsbSrvSupport::CONNECTED}, true));
160 EXPECT_TRUE(want.GetBoolParam(std::string {UsbSrvSupport::FUNCTION_NAME_HDC}, false));
161 }
162
163 /**
164 * @tc.name: SUB_USB_Broadcast_0300
165 * @tc.desc: usb device attached event
166 * @tc.desc: Positive test: parameters correctly
167 * @tc.type: FUNC
168 */
169 HWTEST_F(UsbEventMockTest, SUB_USB_Broadcast_0300, TestSize.Level1)
170 {
171 MatchingSkills matchingSkills;
172 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USB_DEVICE_ATTACHED);
173 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
174 std::shared_ptr<UsbSubscriberMockTest> subscriber = std::make_shared<UsbSubscriberMockTest>(subscriberInfo);
175 CommonEventManager::SubscribeCommonEvent(subscriber);
176
177 USBDeviceInfo info = {ACT_DEVUP, BUS_NUM_OK, DEV_ADDR_OK};
178 EXPECT_CALL(*mockUsbImpl_, OpenDevice(testing::_)).WillRepeatedly(Return(0));
179 EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(0));
180 auto ret = mockUsbImpl_->SubscriberDeviceEvent(info);
181 EXPECT_EQ(0, ret);
182
183 sem_wait(&UsbEventMockTest::testSem_);
184 CommonEventManager::UnSubscribeCommonEvent(subscriber);
185 auto &want = UsbSubscriberMockTest::eventData_.GetWant();
186 EXPECT_EQ(want.GetAction(), CommonEventSupport::COMMON_EVENT_USB_DEVICE_ATTACHED);
187 std::string deviceStr = UsbSubscriberMockTest::eventData_.GetData();
188 cJSON* deviceJson = cJSON_Parse(deviceStr.c_str());
189 if (!deviceJson) {
190 USB_HILOGI(MODULE_USB_SERVICE, "SUB_USB_Broadcast_0300 error, parse json string error");
191 }
192 EXPECT_TRUE(deviceJson);
193 UsbDevice device(deviceJson);
194 EXPECT_NE(device.GetiProduct(), 0);
195 EXPECT_NE(device.GetiManufacturer(), 0);
196 EXPECT_GT(device.GetConfigCount(), 0);
197 USBConfig config;
198 device.GetConfig(0, config);
199 EXPECT_NE(config.GetAttributes(), 0);
200 EXPECT_GT(config.GetInterfaceCount(), 0);
201 UsbInterface interface;
202 config.GetInterface(0, interface);
203 EXPECT_NE(interface.GetClass(), 0);
204 EXPECT_NE(interface.GetEndpointCount(), 0);
205 auto endpoint = interface.GetEndpoint(0);
206 EXPECT_NE(endpoint.value().GetAttributes(), 0);
207
208 info.status = ACT_DOWNDEVICE;
209 EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(0));
210 ret = mockUsbImpl_->SubscriberDeviceEvent(info);
211 EXPECT_EQ(0, ret);
212 }
213
214 /**
215 * @tc.name: SUB_USB_Broadcast_0400
216 * @tc.desc: usb device detached event
217 * @tc.desc: Positive test: parameters correctly
218 * @tc.type: FUNC
219 */
220 HWTEST_F(UsbEventMockTest, SUB_USB_Broadcast_0400, TestSize.Level1)
221 {
222 USBDeviceInfo info = {ACT_DEVUP, BUS_NUM_OK, DEV_ADDR_OK};
223 EXPECT_CALL(*mockUsbImpl_, OpenDevice(testing::_)).WillRepeatedly(Return(0));
224 EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(0));
225 auto ret = mockUsbImpl_->SubscriberDeviceEvent(info);
226 EXPECT_EQ(0, ret);
227
228 MatchingSkills matchingSkills;
229 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USB_DEVICE_DETACHED);
230 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
231 std::shared_ptr<UsbSubscriberMockTest> subscriber = std::make_shared<UsbSubscriberMockTest>(subscriberInfo);
232 CommonEventManager::SubscribeCommonEvent(subscriber);
233
234 info.status = ACT_DEVDOWN;
235 EXPECT_CALL(*mockUsbImpl_, CloseDevice(testing::_)).WillRepeatedly(Return(0));
236 ret = mockUsbImpl_->SubscriberDeviceEvent(info);
237 EXPECT_EQ(0, ret);
238
239 sem_wait(&UsbEventMockTest::testSem_);
240 CommonEventManager::UnSubscribeCommonEvent(subscriber);
241 auto &want = UsbSubscriberMockTest::eventData_.GetWant();
242 EXPECT_EQ(want.GetAction(), CommonEventSupport::COMMON_EVENT_USB_DEVICE_DETACHED);
243 std::string deviceStr = UsbSubscriberMockTest::eventData_.GetData();
244 cJSON* deviceJson = cJSON_Parse(deviceStr.c_str());
245 if (!deviceJson) {
246 USB_HILOGI(MODULE_USB_SERVICE, "SUB_USB_Broadcast_0400 error, parse json string error");
247 }
248 EXPECT_TRUE(deviceJson);
249 UsbDevice device(deviceJson);
250 EXPECT_NE(device.GetiProduct(), 0);
251 EXPECT_NE(device.GetiManufacturer(), 0);
252 }
253
254 /**
255 * @tc.name: SUB_USB_Broadcast_0500
256 * @tc.desc: usb port change to host event
257 * @tc.desc: Positive test: parameters correctly
258 * @tc.type: FUNC
259 */
260 HWTEST_F(UsbEventMockTest, SUB_USB_Broadcast_0500, TestSize.Level1)
261 {
262 MatchingSkills matchingSkills;
263 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USB_PORT_CHANGED);
264 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
265 std::shared_ptr<UsbSubscriberMockTest> subscriber = std::make_shared<UsbSubscriberMockTest>(subscriberInfo);
266 CommonEventManager::SubscribeCommonEvent(subscriber);
267
268 int32_t portId = DEFAULT_PORT_ID;
269 int32_t powerRole = UsbSrvSupport::POWER_ROLE_SOURCE;
270 int32_t dataRole = UsbSrvSupport::DATA_ROLE_HOST;
271 auto ret = mockUsbImpl_->SetPortRole(portId, powerRole, dataRole);
272 EXPECT_EQ(0, ret);
273
274 sem_wait(&UsbEventMockTest::testSem_);
275 CommonEventManager::UnSubscribeCommonEvent(subscriber);
276 auto &want = UsbSubscriberMockTest::eventData_.GetWant();
277 EXPECT_EQ(want.GetAction(), CommonEventSupport::COMMON_EVENT_USB_PORT_CHANGED);
278 std::string portStr = UsbSubscriberMockTest::eventData_.GetData();
279 cJSON* portJson = cJSON_Parse(portStr.c_str());
280 if (!portJson) {
281 USB_HILOGI(MODULE_USB_SERVICE, "SUB_USB_Broadcast_0500 error, parse json string error");
282 }
283 EXPECT_TRUE(portJson);
284 cJSON* jsonMode = cJSON_GetObjectItem(portJson, "mode");
285 EXPECT_EQ(jsonMode->valueint, UsbSrvSupport::PORT_MODE_HOST);
286 }
287
288 /**
289 * @tc.name: SUB_USB_Broadcast_0600
290 * @tc.desc: usb port change to device event
291 * @tc.desc: Positive test: parameters correctly
292 * @tc.type: FUNC
293 */
294 HWTEST_F(UsbEventMockTest, SUB_USB_Broadcast_0600, TestSize.Level1)
295 {
296 MatchingSkills matchingSkills;
297 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USB_PORT_CHANGED);
298 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
299 std::shared_ptr<UsbSubscriberMockTest> subscriber = std::make_shared<UsbSubscriberMockTest>(subscriberInfo);
300 CommonEventManager::SubscribeCommonEvent(subscriber);
301
302 int32_t portId = DEFAULT_PORT_ID;
303 int32_t powerRole = UsbSrvSupport::POWER_ROLE_SINK;
304 int32_t dataRole = UsbSrvSupport::DATA_ROLE_DEVICE;
305 auto ret = mockUsbImpl_->SetPortRole(portId, powerRole, dataRole);
306 EXPECT_EQ(0, ret);
307
308 sem_wait(&UsbEventMockTest::testSem_);
309 CommonEventManager::UnSubscribeCommonEvent(subscriber);
310 auto &want = UsbSubscriberMockTest::eventData_.GetWant();
311 EXPECT_EQ(want.GetAction(), CommonEventSupport::COMMON_EVENT_USB_PORT_CHANGED);
312 std::string portStr = UsbSubscriberMockTest::eventData_.GetData();
313 cJSON* portJson = cJSON_Parse(portStr.c_str());
314 if (!portJson) {
315 USB_HILOGI(MODULE_USB_SERVICE, "SUB_USB_Broadcast_0600 error, parse json string error");
316 }
317 EXPECT_TRUE(portJson);
318 cJSON* jsonMode = cJSON_GetObjectItem(portJson, "mode");
319 EXPECT_EQ(jsonMode->valueint, UsbSrvSupport::PORT_MODE_DEVICE);
320 }
321 } // namespace USB
322 } // namespace OHOS
323