1 /* 2 * Copyright (c) 2023-2024 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 "map" 18 #include "gmock/gmock.h" 19 #ifdef EXTDEVMGR_USB_PASS_THROUGH 20 #include "usb_host_impl_mock.h" 21 #else 22 #include "usb_impl_mock.h" 23 #endif // EXTDEVMGR_USB_PASS_THROUGH 24 #include "usb_ddk_service_mock.h" 25 #define private public 26 #include "ibus_extension.h" 27 #include "usb_bus_extension.h" 28 #undef private 29 namespace OHOS { 30 namespace ExternalDeviceManager { 31 using namespace std; 32 using namespace testing; 33 using namespace testing::ext; 34 using namespace ExternalDeviceManager; 35 using namespace OHOS::USB; 36 37 class UsbSubscriberTest : public testing::Test { 38 public: SetUp()39 void SetUp() override 40 { 41 cout << "UsbSubscriberTest SetUp" << endl; 42 busExt = make_shared<UsbBusExtension>(); 43 usbBusExt = static_cast<UsbBusExtension*>(busExt.get()); 44 #ifdef EXTDEVMGR_USB_PASS_THROUGH 45 mockUsb = sptr<UsbHostImplMock>(new UsbHostImplMock()); 46 #else 47 mockUsb = sptr<UsbImplMock>(new UsbImplMock()); 48 #endif // EXTDEVMGR_USB_PASS_THROUGH 49 mockUsbDdk = sptr<UsbDdkServiceMock>(new UsbDdkServiceMock()); 50 usbBusExt->SetUsbInferface(mockUsb); 51 usbBusExt->SetUsbDdk(mockUsbDdk); 52 } TearDown()53 void TearDown() override 54 { 55 cout << "UsbSubscriberTest TearDown" << endl; 56 mockUsb = nullptr; 57 mockUsbDdk = nullptr; 58 } 59 shared_ptr<IBusExtension> busExt; 60 #ifdef EXTDEVMGR_USB_PASS_THROUGH 61 sptr<UsbHostImplMock> mockUsb; 62 #else 63 sptr<UsbImplMock> mockUsb; 64 #endif // EXTDEVMGR_USB_PASS_THROUGH 65 sptr<UsbDdkServiceMock> mockUsbDdk; 66 UsbBusExtension *usbBusExt; 67 }; 68 69 class TestDevChangeCallback : public IDevChangeCallback { 70 public: 71 map<uint64_t, shared_ptr<DeviceInfo>> devInfoMap; TestDevChangeCallback()72 TestDevChangeCallback() { }; ~TestDevChangeCallback()73 ~TestDevChangeCallback() { }; 74 OnDeviceAdd(std::shared_ptr<DeviceInfo> device)75 int32_t OnDeviceAdd(std::shared_ptr<DeviceInfo> device) override 76 { 77 this->devInfoMap[device->devInfo_.deviceId] = device; 78 return 0; 79 }; OnDeviceRemove(std::shared_ptr<DeviceInfo> device)80 int32_t OnDeviceRemove(std::shared_ptr<DeviceInfo> device) override 81 { 82 this->devInfoMap.erase(device->devInfo_.deviceId); 83 return 1; 84 }; 85 }; 86 87 const uint32_t ACT_DEVUP = 0; 88 const uint32_t ACT_DEVDOWN = 1; 89 90 /** 91 * @tc.number: SUB_Driver_Ext_BusExtensionUSB_0800 92 * @tc.name: UsbDevCallbackTest 93 * @tc.desc: Pile driving test USB hot plug event 94 * @tc.size: MediumTest 95 * @tc.type: Function 96 */ 97 HWTEST_F(UsbSubscriberTest, SUB_Driver_Ext_BusExtensionUSB_0800, TestSize.Level1) 98 { 99 auto testCb = make_shared<TestDevChangeCallback>(); 100 usbBusExt->SetDevChangeCallback(testCb); 101 102 USBDeviceInfo info = {ACT_DEVUP, BUS_NUM_OK, DEV_ADDR_OK}; 103 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)0); 104 105 auto ret = mockUsb->SubscriberDeviceEvent(info); 106 EXPECT_EQ(ret, 0); 107 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)1); 108 109 // invalid devNum 110 info.busNum = BUS_NUM_OK; 111 info.devNum = 9999; 112 ret = mockUsb->SubscriberDeviceEvent(info); 113 EXPECT_NE(ret, 0); 114 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)1); 115 116 // valid param 117 info.busNum = BUS_NUM_OK; 118 info.devNum = DEV_ADDR_OK_2; 119 ret = mockUsb->SubscriberDeviceEvent(info); 120 EXPECT_EQ(ret, 0); 121 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)2); 122 123 info.busNum = BUS_NUM_OK_2; 124 info.devNum = DEV_ADDR_OK_2; 125 ret = mockUsb->SubscriberDeviceEvent(info); 126 EXPECT_EQ(ret, 0); 127 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)3); 128 129 info.status=ACT_DEVDOWN; 130 131 info.busNum = BUS_NUM_OK_2; 132 info.devNum = DEV_ADDR_OK_2; 133 ret = mockUsb->SubscriberDeviceEvent(info); 134 EXPECT_EQ(ret, 0); 135 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)2); 136 137 info.busNum = BUS_NUM_OK; 138 info.devNum = DEV_ADDR_OK_2; 139 ret = mockUsb->SubscriberDeviceEvent(info); 140 EXPECT_EQ(ret, 0); 141 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)1); 142 143 info.busNum = BUS_NUM_OK; 144 info.devNum = DEV_ADDR_OK; 145 ret = mockUsb->SubscriberDeviceEvent(info); 146 EXPECT_EQ(ret, 0); 147 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)0); 148 } 149 150 /** 151 * @tc.number: SUB_Driver_Ext_BusExtensionUSB_0900 152 * @tc.name: UsbDevCallbackErrorTest 153 * @tc.desc: Error data return for USB hot plug event during pile driving test 154 * @tc.size: MediumTest 155 * @tc.type: Function 156 */ 157 HWTEST_F(UsbSubscriberTest, SUB_Driver_Ext_BusExtensionUSB_0900, TestSize.Level1) 158 { 159 USBDeviceInfo info = {ACT_DEVUP, BUS_NUM_OK, DEV_ADDR_OK}; 160 int ret = 0; 161 usbBusExt->SetDevChangeCallback(nullptr); 162 // valid param, but error usb desc 163 info.busNum = BUS_NUM_OK; 164 info.devNum = DEV_ADDR_OK_ERR_DESC; 165 ret = mockUsb->SubscriberDeviceEvent(info); 166 EXPECT_NE(ret, 0); 167 // valid param, but null usb desc 168 info.busNum = BUS_NUM_OK; 169 info.devNum = DEV_ADDR_OK_NULL_DESC; 170 ret = mockUsb->SubscriberDeviceEvent(info); 171 EXPECT_NE(ret, 0); 172 173 // valid param, but null usb desc, action not support 174 info.busNum = BUS_NUM_OK; 175 info.devNum = DEV_ADDR_OK_NULL_DESC; 176 info.status = 99; 177 ret = mockUsb->SubscriberDeviceEvent(info); 178 EXPECT_EQ(ret, 0); 179 } 180 181 /** 182 * @tc.number: SUB_Driver_Ext_BusExtensionUSB_1000 183 * @tc.name: PortChangEeventTest 184 * @tc.desc: Unsupported PortEvent for USB hot plug events during pile driving testing 185 * @tc.size: MediumTest 186 * @tc.type: Function 187 */ 188 #ifndef EXTDEVMGR_USB_PASS_THROUGH 189 HWTEST_F(UsbSubscriberTest, SUB_Driver_Ext_BusExtensionUSB_1000, TestSize.Level1) 190 { 191 int ret = 0; 192 usbBusExt->SetDevChangeCallback(nullptr); 193 ret = mockUsb->SetPortRole(0, 0, 0); 194 ASSERT_EQ(ret, 0); 195 } 196 #endif // EXTDEVMGR_USB_PASS_THROUGH 197 } 198 }