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 "edm_errors.h"
18 #include "hilog_wrapper.h"
19 #define private public
20 #include "dev_change_callback.h"
21 #include "etx_device_mgr.h"
22 #include "ibus_extension.h"
23 #include "usb_bus_extension.h"
24 #include "bus_extension_core.h"
25 #include "driver_pkg_manager.h"
26 #undef private
27 
28 namespace OHOS {
29 namespace ExternalDeviceManager {
30 using namespace std;
31 using namespace testing::ext;
32 
33 class DeviceManagerTest : public testing::Test {
34 public:
SetUp()35     void SetUp() override
36     {
37         EDM_LOGD(MODULE_DEV_MGR, "DeviceManagerTest SetUp");
38     }
TearDown()39     void TearDown() override
40     {
41         EDM_LOGD(MODULE_DEV_MGR, "DeviceManagerTest TearDown");
42     }
43 };
44 
clearDeviceMap(ExtDeviceManager & instance)45 static void clearDeviceMap(ExtDeviceManager &instance)
46 {
47     unordered_map<BusType, unordered_map<uint64_t, shared_ptr<Device>>> map;
48     instance.deviceMap_ = map;
49 }
50 
getDeviceNum(unordered_map<uint64_t,shared_ptr<Device>> map)51 static size_t getDeviceNum(unordered_map<uint64_t, shared_ptr<Device>> map)
52 {
53     size_t num = 0;
54     for (auto &[_, device] : map) {
55         if (!device->IsUnRegisted()) {
56             num++;
57         }
58     }
59     return num;
60 }
61 
62 HWTEST_F(DeviceManagerTest, BusExtensionRegisterTest, TestSize.Level1)
63 {
64     BusExtensionCore &core = BusExtensionCore::GetInstance();
65     int32_t ret = core.Register(BusType::BUS_TYPE_USB, std::make_shared<UsbBusExtension>());
66     ASSERT_EQ(ret, EDM_OK);
67     ASSERT_NE(core.busExtensions_[BusType::BUS_TYPE_USB], nullptr);
68 }
69 
70 HWTEST_F(DeviceManagerTest, InitTest, TestSize.Level1)
71 {
72     DriverPkgManager::GetInstance().Init();
73     int32_t ret = ExtDeviceManager::GetInstance().Init();
74     ASSERT_EQ(ret, EDM_OK);
75 }
76 
77 // test OnDeviceAdd and OnDeviceRemove
78 HWTEST_F(DeviceManagerTest, OnDeviceAddRemoveTest001, TestSize.Level1)
79 {
80     ExtDeviceManager &extMgr = ExtDeviceManager::GetInstance();
81     clearDeviceMap(extMgr);
82     std::shared_ptr<DevChangeCallback> callback = std::make_shared<DevChangeCallback>();
83     std::shared_ptr<DeviceInfo> device = std::make_shared<DeviceInfo>(0);
84     device->devInfo_.devBusInfo.busType = BusType::BUS_TYPE_TEST;
85     device->devInfo_.devBusInfo.busDeviceId = 1;
86     int32_t ret = callback->OnDeviceAdd(device);
87     ASSERT_EQ(ret, EDM_OK);
88     ASSERT_EQ(getDeviceNum(extMgr.deviceMap_[BusType::BUS_TYPE_TEST]), 1);
89     ret = callback->OnDeviceRemove(device);
90     ASSERT_EQ(ret, EDM_OK);
91     ASSERT_EQ(getDeviceNum(extMgr.deviceMap_[BusType::BUS_TYPE_TEST]), 0);
92 }
93 
94 // test adding device repeatedly
95 HWTEST_F(DeviceManagerTest, OnDeviceAddRemoveTest002, TestSize.Level1)
96 {
97     ExtDeviceManager &extMgr = ExtDeviceManager::GetInstance();
98     clearDeviceMap(extMgr);
99     std::shared_ptr<DevChangeCallback> callback = std::make_shared<DevChangeCallback>();
100     std::shared_ptr<DeviceInfo> device = std::make_shared<DeviceInfo>(0);
101     device->devInfo_.devBusInfo.busType = BusType::BUS_TYPE_TEST;
102     device->devInfo_.devBusInfo.busDeviceId = 1;
103     int32_t ret = callback->OnDeviceAdd(device);
104     ASSERT_EQ(ret, EDM_OK);
105     ret = callback->OnDeviceAdd(device);
106     ASSERT_EQ(ret, EDM_OK);
107     ASSERT_EQ(getDeviceNum(extMgr.deviceMap_[BusType::BUS_TYPE_TEST]), 1);
108     ret = callback->OnDeviceRemove(device);
109     ASSERT_EQ(ret, EDM_OK);
110     ASSERT_EQ(getDeviceNum(extMgr.deviceMap_[BusType::BUS_TYPE_TEST]), 0);
111     ret = callback->OnDeviceRemove(device);
112     ASSERT_EQ(ret, EDM_OK);
113 }
114 
115 HWTEST_F(DeviceManagerTest, OnDeviceAddRemoveTest003, TestSize.Level1)
116 {
117     ExtDeviceManager &extMgr = ExtDeviceManager::GetInstance();
118     clearDeviceMap(extMgr);
119     std::shared_ptr<DevChangeCallback> callback = std::make_shared<DevChangeCallback>();
120     std::shared_ptr<DeviceInfo> device0 = std::make_shared<DeviceInfo>(0);
121     device0->devInfo_.devBusInfo.busType = BusType::BUS_TYPE_TEST;
122     device0->devInfo_.devBusInfo.busDeviceId = 1;
123     int32_t ret = callback->OnDeviceAdd(device0);
124     ASSERT_EQ(ret, EDM_OK);
125     std::shared_ptr<DeviceInfo> device1 = std::make_shared<DeviceInfo>(0);
126     device1->devInfo_.devBusInfo.busType = BusType::BUS_TYPE_TEST;
127     device1->devInfo_.devBusInfo.busDeviceId = 2;
128     ret = callback->OnDeviceAdd(device1);
129     ASSERT_EQ(ret, EDM_OK);
130     ASSERT_EQ(getDeviceNum(extMgr.deviceMap_[BusType::BUS_TYPE_TEST]), 2);
131     ret = callback->OnDeviceRemove(device1);
132     ASSERT_EQ(ret, EDM_OK);
133     ASSERT_EQ(getDeviceNum(extMgr.deviceMap_[BusType::BUS_TYPE_TEST]), 1);
134     ret = callback->OnDeviceRemove(device0);
135     ASSERT_EQ(ret, EDM_OK);
136     ASSERT_EQ(getDeviceNum(extMgr.deviceMap_[BusType::BUS_TYPE_TEST]), 0);
137 }
138 
139 HWTEST_F(DeviceManagerTest, QueryDeviceTest, TestSize.Level1)
140 {
141     ExtDeviceManager &extMgr = ExtDeviceManager::GetInstance();
142     clearDeviceMap(extMgr);
143     std::vector<std::shared_ptr<DeviceInfo>> devVec = extMgr.QueryDevice(BUS_TYPE_TEST);
144     ASSERT_EQ(devVec.size(), 0);
145     std::shared_ptr<DevChangeCallback> callback = std::make_shared<DevChangeCallback>();
146     std::shared_ptr<DeviceInfo> device0 = std::make_shared<DeviceInfo>(0);
147     device0->devInfo_.devBusInfo.busType = BusType::BUS_TYPE_TEST;
148     device0->devInfo_.devBusInfo.busDeviceId = 1;
149     int32_t ret = callback->OnDeviceAdd(device0);
150     ASSERT_EQ(ret, EDM_OK);
151     std::shared_ptr<DeviceInfo> device1 = std::make_shared<DeviceInfo>(0);
152     device1->devInfo_.devBusInfo.busType = BusType::BUS_TYPE_TEST;
153     device1->devInfo_.devBusInfo.busDeviceId = 2;
154     ret = callback->OnDeviceAdd(device1);
155     ASSERT_EQ(ret, EDM_OK);
156     devVec = extMgr.QueryDevice(BUS_TYPE_TEST);
157     ASSERT_EQ(devVec.size(), 2);
158     ret = callback->OnDeviceRemove(device0);
159     ret = callback->OnDeviceRemove(device1);
160     ASSERT_EQ(getDeviceNum(extMgr.deviceMap_[BusType::BUS_TYPE_TEST]), 0);
161 }
162 
163 HWTEST_F(DeviceManagerTest, GetBusExtensionByNameTest, TestSize.Level1)
164 {
165     BusExtensionCore &core = BusExtensionCore::GetInstance();
166     ASSERT_NE(core.busExtensions_[BusType::BUS_TYPE_USB], nullptr);
167     std::shared_ptr<IBusExtension> extension = core.GetBusExtensionByName("HDMI");
168     ASSERT_EQ(extension, nullptr);
169     extension = core.GetBusExtensionByName("USB");
170     ASSERT_NE(extension, nullptr);
171     core.busExtensions_.erase(BusType::BUS_TYPE_USB);
172     extension = core.GetBusExtensionByName("USB");
173     ASSERT_EQ(extension, nullptr);
174 }
175 } // namespace ExternalDeviceManager
176 } // namespace OHOS
177