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
16 #include <gtest/gtest.h>
17 #include "cJSON.h"
18 #include <semaphore.h>
19 #include <thread>
20 #include <chrono>
21 #include <iostream>
22
23 #include "common_event_manager.h"
24 #include "common_event_support.h"
25 #include "usb_srv_client.h"
26 #include "usb_srv_support.h"
27
28 using namespace OHOS::EventFwk;
29 using namespace testing::ext;
30 using namespace OHOS::USB;
31
32 namespace OHOS {
33 namespace USB {
34 class UsbEventTest : public testing::Test {
35 public:
36 void SetUp() override;
37 void TearDown() override;
38
39 static sem_t testSem_;
40 };
41
42 sem_t UsbEventTest::testSem_ {};
43
44 class UsbSubscriberTest : public CommonEventSubscriber {
45 public:
UsbSubscriberTest(const CommonEventSubscribeInfo & sp)46 explicit UsbSubscriberTest(const CommonEventSubscribeInfo &sp) : CommonEventSubscriber(sp) {}
47
OnReceiveEvent(const CommonEventData & data)48 void OnReceiveEvent(const CommonEventData &data) override
49 {
50 USB_HILOGI(MODULE_USB_SERVICE, "recv event ok");
51 eventData_ = data;
52 sem_post(&UsbEventTest::testSem_);
53 }
54
55 static CommonEventData eventData_;
56 };
57
58 CommonEventData UsbSubscriberTest::eventData_ {};
59
SetUp()60 void UsbEventTest::SetUp()
61 {
62 sem_init(&UsbEventTest::testSem_, 1, 0);
63 }
64
TearDown()65 void UsbEventTest::TearDown()
66 {
67 sem_destroy(&UsbEventTest::testSem_);
68 }
69
70 /**
71 * @tc.name: SUB_USB_Broadcast_0100
72 * @tc.desc: usb gadget connected event
73 * @tc.type: FUNC
74 */
75 HWTEST_F(UsbEventTest, SUB_USB_Broadcast_0100, TestSize.Level1)
76 {
77 // subscribe usb common event
78 MatchingSkills matchingSkills;
79 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USB_STATE);
80 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
81 std::shared_ptr<UsbSubscriberTest> subscriber = std::make_shared<UsbSubscriberTest>(subscriberInfo);
82 CommonEventManager::SubscribeCommonEvent(subscriber);
83
84 std::cout << "please connect the gadget to some host" << std::endl;
85
86 // block until UsbSubscriberTest post
87 sem_wait(&UsbEventTest::testSem_);
88 CommonEventManager::UnSubscribeCommonEvent(subscriber);
89
90 auto &want = UsbSubscriberTest::eventData_.GetWant();
91 EXPECT_EQ(want.GetAction(), CommonEventSupport::COMMON_EVENT_USB_STATE);
92 EXPECT_TRUE(want.GetBoolParam(std::string {UsbSrvSupport::CONNECTED}, false));
93 EXPECT_TRUE(want.GetBoolParam(std::string {UsbSrvSupport::FUNCTION_NAME_HDC}, false));
94 }
95
96 /**
97 * @tc.name: SUB_USB_Broadcast_0200
98 * @tc.desc: usb gadget disconnected event
99 * @tc.type: FUNC
100 */
101 HWTEST_F(UsbEventTest, SUB_USB_Broadcast_0200, TestSize.Level1)
102 {
103 MatchingSkills matchingSkills;
104 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USB_STATE);
105 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
106 std::shared_ptr<UsbSubscriberTest> subscriber = std::make_shared<UsbSubscriberTest>(subscriberInfo);
107 CommonEventManager::SubscribeCommonEvent(subscriber);
108
109 std::cout << "please disconnect the gadget" << std::endl;
110
111 // block until UsbSubscriberTest post
112 sem_wait(&UsbEventTest::testSem_);
113 std::this_thread::sleep_for(std::chrono::seconds(5));
114 CommonEventManager::UnSubscribeCommonEvent(subscriber);
115
116 auto &want = UsbSubscriberTest::eventData_.GetWant();
117 EXPECT_EQ(want.GetAction(), CommonEventSupport::COMMON_EVENT_USB_STATE);
118 EXPECT_FALSE(want.GetBoolParam(std::string {UsbSrvSupport::CONNECTED}, true));
119 EXPECT_TRUE(want.GetBoolParam(std::string {UsbSrvSupport::FUNCTION_NAME_HDC}, false));
120 }
121
122 /**
123 * @tc.name: SUB_USB_Broadcast_0300
124 * @tc.desc: usb device attached event
125 * @tc.type: FUNC
126 */
127 HWTEST_F(UsbEventTest, SUB_USB_Broadcast_0300, TestSize.Level1)
128 {
129 MatchingSkills matchingSkills;
130 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USB_DEVICE_ATTACHED);
131 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
132 std::shared_ptr<UsbSubscriberTest> subscriber = std::make_shared<UsbSubscriberTest>(subscriberInfo);
133 CommonEventManager::SubscribeCommonEvent(subscriber);
134
135 std::cout << "please connect a device to the host" << std::endl;
136
137 // block until UsbSubscriberTest post
138 sem_wait(&UsbEventTest::testSem_);
139 CommonEventManager::UnSubscribeCommonEvent(subscriber);
140
141 auto &want = UsbSubscriberTest::eventData_.GetWant();
142 EXPECT_EQ(want.GetAction(), CommonEventSupport::COMMON_EVENT_USB_DEVICE_ATTACHED);
143
144 // parse string to Json::Value
145 std::string deviceStr = UsbSubscriberTest::eventData_.GetData();
146 std::cout << deviceStr << std::endl;
147 cJSON* deviceJson = cJSON_Parse(deviceStr.c_str());
148 if (!deviceJson) {
149 USB_HILOGI(MODULE_USB_SERVICE, "SUB_USB_Broadcast_0300 error, parse json string error");
150 }
151 EXPECT_TRUE(deviceJson);
152
153 // valid device
154 UsbDevice device(deviceJson);
155 EXPECT_NE(device.GetiProduct(), 0);
156 EXPECT_NE(device.GetiManufacturer(), 0);
157 EXPECT_GT(device.GetConfigCount(), 0);
158
159 // valid config
160 USBConfig config;
161 device.GetConfig(0, config);
162 EXPECT_NE(config.GetAttributes(), 0);
163 EXPECT_GT(config.GetInterfaceCount(), 0);
164
165 // valid interface
166 UsbInterface interface;
167 config.GetInterface(0, interface);
168 EXPECT_NE(interface.GetClass(), 0);
169 EXPECT_NE(interface.GetEndpointCount(), 0);
170
171 // valid endpoint
172 auto endpoint = interface.GetEndpoint(0);
173 EXPECT_NE(endpoint.value().GetAttributes(), 0);
174 }
175
176 /**
177 * @tc.name: SUB_USB_Broadcast_0400
178 * @tc.desc: usb device detached event
179 * @tc.type: FUNC
180 */
181 HWTEST_F(UsbEventTest, SUB_USB_Broadcast_0400, TestSize.Level1)
182 {
183 MatchingSkills matchingSkills;
184 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USB_DEVICE_DETACHED);
185 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
186 std::shared_ptr<UsbSubscriberTest> subscriber = std::make_shared<UsbSubscriberTest>(subscriberInfo);
187 CommonEventManager::SubscribeCommonEvent(subscriber);
188
189 std::cout << "please disconnect the device to the host" << std::endl;
190
191 // block until UsbSubscriberTest post
192 sem_wait(&UsbEventTest::testSem_);
193 CommonEventManager::UnSubscribeCommonEvent(subscriber);
194
195 auto &want = UsbSubscriberTest::eventData_.GetWant();
196 EXPECT_EQ(want.GetAction(), CommonEventSupport::COMMON_EVENT_USB_DEVICE_DETACHED);
197
198 std::string deviceStr = UsbSubscriberTest::eventData_.GetData();
199 std::cout << deviceStr << std::endl;
200 cJSON* deviceJson = cJSON_Parse(deviceStr.c_str());
201 if (!deviceJson) {
202 USB_HILOGI(MODULE_USB_SERVICE, "SUB_USB_Broadcast_0400 error, parse json string error");
203 }
204 EXPECT_TRUE(deviceJson);
205
206 // valid device
207 UsbDevice device(deviceJson);
208 EXPECT_NE(device.GetiProduct(), 0);
209 EXPECT_NE(device.GetiManufacturer(), 0);
210 }
211 #ifdef SUPPORT_PORT_CHNAGE_TEST
212 /**
213 * @tc.name: SUB_USB_Broadcast_0500
214 * @tc.desc: usb port change to host event
215 * @tc.type: FUNC
216 */
217 HWTEST_F(UsbEventTest, SUB_USB_Broadcast_0500, TestSize.Level1)
218 {
219 MatchingSkills matchingSkills;
220 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USB_PORT_CHANGED);
221 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
222 std::shared_ptr<UsbSubscriberTest> subscriber = std::make_shared<UsbSubscriberTest>(subscriberInfo);
223 CommonEventManager::SubscribeCommonEvent(subscriber);
224 std::cout << "please switch port to host" << std::endl;
225
226 // block until UsbSubscriberTest post
227 sem_wait(&UsbEventTest::testSem_);
228 CommonEventManager::UnSubscribeCommonEvent(subscriber);
229
230 auto &want = UsbSubscriberTest::eventData_.GetWant();
231 EXPECT_EQ(want.GetAction(), CommonEventSupport::COMMON_EVENT_USB_PORT_CHANGED);
232
233 std::string portStr = UsbSubscriberTest::eventData_.GetData();
234 std::cout << portStr << std::endl;
235 cJSON* portJson = cJSON_Parse(portStr.c_str());
236 if (!portJson) {
237 USB_HILOGI(MODULE_USB_SERVICE, "SUB_USB_Broadcast_0500 error, parse json string error");
238 }
239 EXPECT_TRUE(portJson);
240
241 // valid event
242 cJSON* jsonMode = cJSON_GetObjectItem(portJson, "mode");
243 EXPECT_EQ(jsonMode->valueint, UsbSrvSupport::PORT_MODE_HOST);
244 }
245
246 /**
247 * @tc.name: SUB_USB_Broadcast_0600
248 * @tc.desc: usb port change to device event
249 * @tc.type: FUNC
250 */
251 HWTEST_F(UsbEventTest, SUB_USB_Broadcast_0600, TestSize.Level1)
252 {
253 MatchingSkills matchingSkills;
254 matchingSkills.AddEvent(CommonEventSupport::COMMON_EVENT_USB_PORT_CHANGED);
255 CommonEventSubscribeInfo subscriberInfo(matchingSkills);
256 std::shared_ptr<UsbSubscriberTest> subscriber = std::make_shared<UsbSubscriberTest>(subscriberInfo);
257 CommonEventManager::SubscribeCommonEvent(subscriber);
258 std::cout << "please switch port to device" << std::endl;
259
260 // block until UsbSubscriberTest post
261 sem_wait(&UsbEventTest::testSem_);
262 CommonEventManager::UnSubscribeCommonEvent(subscriber);
263
264 auto &want = UsbSubscriberTest::eventData_.GetWant();
265 EXPECT_EQ(want.GetAction(), CommonEventSupport::COMMON_EVENT_USB_PORT_CHANGED);
266
267 std::string portStr = UsbSubscriberTest::eventData_.GetData();
268 std::cout << portStr << std::endl;
269 cJSON* portJson = cJSON_Parse(portStr.c_str());
270 if (!portJson) {
271 USB_HILOGI(MODULE_USB_SERVICE, "SUB_USB_Broadcast_0600 error, parse json string error");
272 }
273 EXPECT_TRUE(portJson);
274
275 // valid event
276 cJSON* jsonMode = cJSON_GetObjectItem(portJson, "mode");
277 EXPECT_EQ(jsonMode->valueint, UsbSrvSupport::PORT_MODE_DEVICE);
278 }
279 #endif //SUPPORT_PORT_CHNAGE_TEST
280 } // namespace USB
281 } // namespace OHOS
282