1 /* 2 * Copyright (c) 2023-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 #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 60 shared_ptr<IBusExtension> busExt; 61 #ifdef EXTDEVMGR_USB_PASS_THROUGH 62 sptr<UsbHostImplMock> mockUsb; 63 #else 64 sptr<UsbImplMock> mockUsb; 65 #endif // EXTDEVMGR_USB_PASS_THROUGH 66 sptr<UsbDdkServiceMock> mockUsbDdk; 67 UsbBusExtension *usbBusExt; 68 }; 69 70 class TestDevChangeCallback : public IDevChangeCallback { 71 public: 72 map<uint64_t, shared_ptr<DeviceInfo>> devInfoMap; TestDevChangeCallback()73 TestDevChangeCallback() { }; ~TestDevChangeCallback()74 ~TestDevChangeCallback() { }; 75 OnDeviceAdd(std::shared_ptr<DeviceInfo> device)76 int32_t OnDeviceAdd(std::shared_ptr<DeviceInfo> device) override 77 { 78 this->devInfoMap[device->devInfo_.deviceId] = device; 79 return 0; 80 }; OnDeviceRemove(std::shared_ptr<DeviceInfo> device)81 int32_t OnDeviceRemove(std::shared_ptr<DeviceInfo> device) override 82 { 83 this->devInfoMap.erase(device->devInfo_.deviceId); 84 return 1; 85 }; 86 }; 87 88 const uint32_t ACT_DEVUP = 0; 89 const uint32_t ACT_DEVDOWN = 1; 90 91 HWTEST_F(UsbSubscriberTest, UsbDevCallbackTest, TestSize.Level1) 92 { 93 auto testCb = make_shared<TestDevChangeCallback>(); 94 usbBusExt->SetDevChangeCallback(testCb); 95 96 USBDeviceInfo info = {ACT_DEVUP, BUS_NUM_OK, DEV_ADDR_OK}; 97 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)0); 98 99 auto ret = mockUsb->SubscriberDeviceEvent(info); 100 EXPECT_EQ(ret, 0); 101 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)1); 102 103 // invalid devNum 104 info.busNum = BUS_NUM_OK; 105 info.devNum = 9999; 106 ret = mockUsb->SubscriberDeviceEvent(info); 107 EXPECT_NE(ret, 0); 108 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)1); 109 110 // valid param 111 info.busNum = BUS_NUM_OK; 112 info.devNum = DEV_ADDR_OK_2; 113 ret = mockUsb->SubscriberDeviceEvent(info); 114 EXPECT_EQ(ret, 0); 115 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)2); 116 117 info.busNum = BUS_NUM_OK_2; 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)3); 122 123 info.status=ACT_DEVDOWN; 124 125 info.busNum = BUS_NUM_OK_2; 126 info.devNum = DEV_ADDR_OK_2; 127 ret = mockUsb->SubscriberDeviceEvent(info); 128 EXPECT_EQ(ret, 0); 129 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)2); 130 131 info.busNum = BUS_NUM_OK; 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)1); 136 137 info.busNum = BUS_NUM_OK; 138 info.devNum = DEV_ADDR_OK; 139 ret = mockUsb->SubscriberDeviceEvent(info); 140 EXPECT_EQ(ret, 0); 141 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)0); 142 } 143 HWTEST_F(UsbSubscriberTest, UsbDevCallbackErrorTest, TestSize.Level1) 144 { 145 USBDeviceInfo info = {ACT_DEVUP, BUS_NUM_OK, DEV_ADDR_OK}; 146 int ret = 0; 147 usbBusExt->SetDevChangeCallback(nullptr); 148 // valid param, but error usb desc 149 info.busNum = BUS_NUM_OK; 150 info.devNum = DEV_ADDR_OK_ERR_DESC; 151 ret = mockUsb->SubscriberDeviceEvent(info); 152 EXPECT_NE(ret, 0); 153 // valid param, but null usb desc 154 info.busNum = BUS_NUM_OK; 155 info.devNum = DEV_ADDR_OK_NULL_DESC; 156 ret = mockUsb->SubscriberDeviceEvent(info); 157 EXPECT_NE(ret, 0); 158 159 // valid param, but null usb desc, action not support 160 info.busNum = BUS_NUM_OK; 161 info.devNum = DEV_ADDR_OK_NULL_DESC; 162 info.status = 99; 163 ret = mockUsb->SubscriberDeviceEvent(info); 164 EXPECT_EQ(ret, 0); 165 } 166 167 HWTEST_F(UsbSubscriberTest, UsbDevCallbackErrorTest1, TestSize.Level1) 168 { 169 USBDeviceInfo info = {ACT_DEVUP, BUS_NUM_OK, DEV_ADDR_OK}; 170 int ret = 0; 171 usbBusExt->SetDevChangeCallback(nullptr); 172 173 info.busNum = BUS_NUM_ERR; 174 info.devNum = DEV_ADDR_ERR; 175 ret = mockUsb->SubscriberDeviceEvent(info); 176 EXPECT_NE(ret, 0); 177 info.busNum = BUS_NUM_OK; 178 info.devNum = DEV_ADDR_INVALID; 179 ret = mockUsb->SubscriberDeviceEvent(info); 180 EXPECT_NE(ret, 0); 181 info.busNum = BUS_NUM_OK; 182 info.devNum = DEV_ADDR_OK_ERR_DESC; 183 ret = mockUsb->SubscriberDeviceEvent(info); 184 EXPECT_NE(ret, 0); 185 186 info.busNum = BUS_NUM_OK; 187 info.devNum = DEV_ADDR_INTERFACE_ERR; 188 ret = mockUsb->SubscriberDeviceEvent(info); 189 EXPECT_EQ(ret, 0); 190 } 191 192 #ifndef EXTDEVMGR_USB_PASS_THROUGH 193 HWTEST_F(UsbSubscriberTest, PortChangEeventTest, TestSize.Level1) 194 { 195 int ret = 0; 196 usbBusExt->SetDevChangeCallback(nullptr); 197 ret = mockUsb->SetPortRole(0, 0, 0); 198 ASSERT_EQ(ret, 0); 199 } 200 #endif // EXTDEVMGR_USB_PASS_THROUGH 201 } 202 }