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