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