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 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 HWTEST_F(UsbSubscriberTest, UsbDevCallbackTest, TestSize.Level1) 80 { 81 auto testCb = make_shared<TestDevChangeCallback>(); 82 usbBusExt->SetDevChangeCallback(testCb); 83 84 USBDeviceInfo info = {ACT_DEVUP, BUS_NUM_OK, DEV_ADDR_OK}; 85 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)0); 86 87 auto ret = mockUsb->SubscriberDeviceEvent(info); 88 EXPECT_EQ(ret, 0); 89 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)1); 90 91 // invalid devNum 92 info.busNum = BUS_NUM_OK; 93 info.devNum = 9999; 94 ret = mockUsb->SubscriberDeviceEvent(info); 95 EXPECT_NE(ret, 0); 96 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)1); 97 98 // valid param 99 info.busNum = BUS_NUM_OK; 100 info.devNum = DEV_ADDR_OK_2; 101 ret = mockUsb->SubscriberDeviceEvent(info); 102 EXPECT_EQ(ret, 0); 103 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)2); 104 105 info.busNum = BUS_NUM_OK_2; 106 info.devNum = DEV_ADDR_OK_2; 107 ret = mockUsb->SubscriberDeviceEvent(info); 108 EXPECT_EQ(ret, 0); 109 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)3); 110 111 info.status=ACT_DEVDOWN; 112 113 info.busNum = BUS_NUM_OK_2; 114 info.devNum = DEV_ADDR_OK_2; 115 ret = mockUsb->SubscriberDeviceEvent(info); 116 EXPECT_EQ(ret, 0); 117 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)2); 118 119 info.busNum = BUS_NUM_OK; 120 info.devNum = DEV_ADDR_OK_2; 121 ret = mockUsb->SubscriberDeviceEvent(info); 122 EXPECT_EQ(ret, 0); 123 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)1); 124 125 info.busNum = BUS_NUM_OK; 126 info.devNum = DEV_ADDR_OK; 127 ret = mockUsb->SubscriberDeviceEvent(info); 128 EXPECT_EQ(ret, 0); 129 EXPECT_EQ(testCb->devInfoMap.size(), (size_t)0); 130 } 131 HWTEST_F(UsbSubscriberTest, UsbDevCallbackErrorTest, TestSize.Level1) 132 { 133 USBDeviceInfo info = {ACT_DEVUP, BUS_NUM_OK, DEV_ADDR_OK}; 134 int ret = 0; 135 usbBusExt->SetDevChangeCallback(nullptr); 136 // valid param, but error usb desc 137 info.busNum = BUS_NUM_OK; 138 info.devNum = DEV_ADDR_OK_ERR_DESC; 139 ret = mockUsb->SubscriberDeviceEvent(info); 140 EXPECT_NE(ret, 0); 141 // valid param, but null usb desc 142 info.busNum = BUS_NUM_OK; 143 info.devNum = DEV_ADDR_OK_NULL_DESC; 144 ret = mockUsb->SubscriberDeviceEvent(info); 145 EXPECT_NE(ret, 0); 146 147 // valid param, but null usb desc, action not support 148 info.busNum = BUS_NUM_OK; 149 info.devNum = DEV_ADDR_OK_NULL_DESC; 150 info.status = 99; 151 ret = mockUsb->SubscriberDeviceEvent(info); 152 EXPECT_EQ(ret, 0); 153 } 154 155 HWTEST_F(UsbSubscriberTest, PortChangEeventTest, TestSize.Level1) 156 { 157 int ret = 0; 158 usbBusExt->SetDevChangeCallback(nullptr); 159 ret = mockUsb->SetPortRole(0, 0, 0); 160 ASSERT_EQ(ret, 0); 161 } 162 } 163 }