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 <libudev.h> 17 18 #include <gmock/gmock.h> 19 #include <gtest/gtest.h> 20 21 #include "test_device.h" 22 23 using ::testing::ext::TestSize; 24 25 class UdevTestDevice : public TestDevice { 26 public: UdevTestDevice()27 UdevTestDevice() 28 { 29 udev_ = udev_new(); 30 } 31 ~UdevTestDevice()32 ~UdevTestDevice() 33 { 34 if (udevDevice_ != nullptr) { 35 udevDevice_ = udev_device_unref(udevDevice_); 36 } 37 udev_unref(udev_); 38 } 39 Init(bool def=true)40 void Init(bool def = true) 41 { 42 ASSERT_NE(udev_, nullptr); 43 ASSERT_NO_FATAL_FAILURE(TestDevice::Init(def)); 44 udevDevice_ = udev_device_new_from_devnum(udev_, 'c', GetDevNum()); 45 ASSERT_NE(udevDevice_, nullptr); 46 } 47 GetUdev() const48 auto GetUdev() const 49 { 50 return udev_; 51 } 52 GetDevice() const53 auto GetDevice() const 54 { 55 return udevDevice_; 56 } 57 58 private: 59 struct udev* udev_{}; 60 struct udev_device* udevDevice_{}; 61 }; 62 63 class CustomUdevTest : public ::testing::Test { 64 public: 65 UdevTestDevice testDevice_; 66 }; 67 68 /* 69 * Tests: 70 * udev_device_new_from_devnum (uses udev_device_new_from_syspath) 71 * udev_device_get_udev 72 * udev_device_ref 73 * udev_device_unref 74 */ 75 HWTEST_F(CustomUdevTest, TestBasics, TestSize.Level1) 76 { 77 ASSERT_NO_FATAL_FAILURE(testDevice_.Init()); 78 auto* device = testDevice_.GetDevice(); 79 80 EXPECT_EQ(udev_device_get_udev(device), testDevice_.GetUdev()); 81 82 auto* res = udev_device_ref(device); 83 EXPECT_NE(res, nullptr); 84 EXPECT_EQ(res, device); 85 86 res = udev_device_unref(device); 87 EXPECT_EQ(res, nullptr); 88 } 89 90 /* 91 * Tests negative cases for: 92 * udev_device_new_from_devnum (uses udev_device_new_from_syspath) 93 * udev_device_get_udev 94 * udev_device_ref 95 * udev_device_unref 96 */ 97 HWTEST_F(CustomUdevTest, TestBasicsFail, TestSize.Level1) 98 { 99 errno = 0; 100 EXPECT_EQ(udev_device_get_udev(nullptr), nullptr); 101 EXPECT_EQ(errno, 0); 102 103 errno = 0; 104 EXPECT_EQ(udev_device_ref(nullptr), nullptr); 105 EXPECT_EQ(errno, 0); 106 107 errno = 0; 108 EXPECT_EQ(udev_device_unref(nullptr), nullptr); 109 EXPECT_EQ(errno, 0); 110 } 111 112 /* 113 * Tests negative cases for: 114 * udev_device_new_from_devnum 115 */ 116 HWTEST_F(CustomUdevTest, TestNewFail1, TestSize.Level1) 117 { 118 ASSERT_NO_FATAL_FAILURE(testDevice_.Init()); 119 auto* device = testDevice_.GetDevice(); 120 auto devnum = testDevice_.GetDevNum(); 121 auto* udev = udev_device_get_udev(device); 122 ASSERT_NE(udev, nullptr); 123 124 errno = 0; 125 EXPECT_EQ(udev_device_new_from_devnum(nullptr, 'c', devnum), nullptr); 126 EXPECT_EQ(errno, EINVAL); 127 128 errno = 0; 129 // Invalid device type 130 EXPECT_EQ(udev_device_new_from_devnum(udev, 'a', devnum), nullptr); 131 EXPECT_EQ(errno, EINVAL); 132 133 errno = 0; 134 // Wrong devnum 135 EXPECT_EQ(udev_device_new_from_devnum(udev, 'b', devnum), nullptr); 136 EXPECT_EQ(errno, ENOENT); 137 138 errno = 0; 139 // Invalid devnum 140 EXPECT_EQ(udev_device_new_from_devnum(udev, 'c', 0), nullptr); 141 EXPECT_EQ(errno, ENOENT); 142 } 143 144 /* 145 * Tests negative cases for: 146 * udev_device_new_from_syspath 147 */ 148 HWTEST_F(CustomUdevTest, TestNewFail2, TestSize.Level1) 149 { 150 ASSERT_NO_FATAL_FAILURE(testDevice_.Init()); 151 auto* udev = udev_device_get_udev(testDevice_.GetDevice()); 152 ASSERT_NE(udev, nullptr); 153 154 errno = 0; 155 EXPECT_EQ(udev_device_new_from_syspath(nullptr, testDevice_.GetSysPath()), nullptr); 156 EXPECT_EQ(errno, EINVAL); 157 158 errno = 0; 159 EXPECT_EQ(udev_device_new_from_syspath(udev, nullptr), nullptr); 160 EXPECT_EQ(errno, EINVAL); 161 162 errno = 0; 163 EXPECT_EQ(udev_device_new_from_syspath(udev, "/system"), nullptr); 164 EXPECT_EQ(errno, EINVAL); 165 166 errno = 0; 167 EXPECT_EQ(udev_device_new_from_syspath(udev, "/sys/unknown"), nullptr); 168 EXPECT_EQ(errno, ENOENT); 169 170 errno = 0; 171 EXPECT_EQ(udev_device_new_from_syspath(udev, "/sys/char/0:0"), nullptr); 172 EXPECT_EQ(errno, ENOENT); 173 } 174 175 /* 176 * Tests: 177 * udev_device_get_is_initialized() 178 */ 179 HWTEST_F(CustomUdevTest, TestIsInitialized, TestSize.Level1) 180 { 181 ASSERT_NO_FATAL_FAILURE(testDevice_.Init()); 182 auto* device = testDevice_.GetDevice(); 183 184 EXPECT_EQ(udev_device_get_is_initialized(device), 1); 185 186 errno = 0; 187 EXPECT_LT(udev_device_get_is_initialized(nullptr), 0); 188 EXPECT_EQ(errno, 0); 189 } 190 191 /* 192 * Tests: 193 * udev_device_get_devnode() 194 */ 195 HWTEST_F(CustomUdevTest, TestGetDevnode, TestSize.Level1) 196 { 197 ASSERT_NO_FATAL_FAILURE(testDevice_.Init()); 198 auto* device = testDevice_.GetDevice(); 199 200 EXPECT_STRNE(udev_device_get_devnode(device), testDevice_.GetDevNode()); 201 202 errno = 0; 203 EXPECT_EQ(udev_device_get_devnode(nullptr), nullptr); 204 EXPECT_EQ(errno, 0); 205 } 206 207 /* 208 * Test for: 209 * udev_device_get_sysname() 210 */ 211 HWTEST_F(CustomUdevTest, TestGetSysname, TestSize.Level1) 212 { 213 ASSERT_NO_FATAL_FAILURE(testDevice_.Init()); 214 auto* device = testDevice_.GetDevice(); 215 216 EXPECT_EQ(std::string("/dev/input/") + udev_device_get_sysname(device), testDevice_.GetDevNode()); 217 218 errno = 0; 219 EXPECT_EQ(udev_device_get_sysname(nullptr), nullptr); 220 EXPECT_EQ(errno, 0); 221 } 222 223 /* 224 * Test for: 225 * udev_device_get_syspath() 226 */ 227 HWTEST_F(CustomUdevTest, TestGetSyspath, TestSize.Level1) 228 { 229 ASSERT_NO_FATAL_FAILURE(testDevice_.Init()); 230 auto* device = testDevice_.GetDevice(); 231 232 EXPECT_EQ(udev_device_get_syspath(device), 233 testDevice_.GetSysPath() + std::string("/") + udev_device_get_sysname(device)); 234 235 errno = 0; 236 EXPECT_EQ(udev_device_get_syspath(nullptr), nullptr); 237 EXPECT_EQ(errno, 0); 238 } 239 240 /* 241 * Test for: 242 * udev_device_get_parent() 243 */ 244 HWTEST_F(CustomUdevTest, TestGetParent1, TestSize.Level1) 245 { 246 ASSERT_NO_FATAL_FAILURE(testDevice_.Init()); 247 auto* device = testDevice_.GetDevice(); 248 249 auto* parent = udev_device_get_parent(device); 250 ASSERT_NE(parent, nullptr); 251 EXPECT_STREQ(udev_device_get_syspath(parent), testDevice_.GetSysPath()); 252 253 errno = 0; 254 EXPECT_EQ(udev_device_get_parent(nullptr), nullptr); 255 EXPECT_EQ(errno, EINVAL); 256 } 257 258 /* 259 * Test for: 260 * udev_device_get_parent_with_subsystem_devtype() 261 */ 262 HWTEST_F(CustomUdevTest, TestGetParent2, TestSize.Level1) 263 { 264 ASSERT_NO_FATAL_FAILURE(testDevice_.Init()); 265 auto* device = testDevice_.GetDevice(); 266 267 auto* parent = udev_device_get_parent_with_subsystem_devtype(device, "input", nullptr); 268 ASSERT_EQ(parent, nullptr); 269 EXPECT_NE(udev_device_get_syspath(parent), testDevice_.GetSysPath()); 270 271 errno = 0; 272 EXPECT_EQ(udev_device_get_parent_with_subsystem_devtype(nullptr, "input", nullptr), nullptr); 273 EXPECT_EQ(errno, 0); 274 275 errno = 0; 276 EXPECT_NE(udev_device_get_parent_with_subsystem_devtype(device, "input", ""), nullptr); 277 EXPECT_EQ(errno, EINVAL); 278 279 errno = 0; 280 EXPECT_EQ(udev_device_get_parent_with_subsystem_devtype(device, nullptr, nullptr), nullptr); 281 EXPECT_EQ(errno, EINVAL); 282 283 errno = 0; 284 EXPECT_EQ(udev_device_get_parent_with_subsystem_devtype(device, "unknown", nullptr), nullptr); 285 EXPECT_EQ(errno, 0); 286 } 287 288 HWTEST_F(CustomUdevTest, TestUdevPropsDefault, TestSize.Level1) 289 { 290 ASSERT_NO_FATAL_FAILURE(testDevice_.Init()); 291 auto* device = testDevice_.GetDevice(); 292 293 auto* parent = udev_device_get_parent(device); 294 ASSERT_NE(parent, nullptr); 295 296 std::string expectedName = std::string{"\""} + TestDevice::TEST_NAME + "\""; 297 EXPECT_STRNE(udev_device_get_property_value(parent, "NAME"), expectedName.c_str()); 298 std::stringstream expectedProduct; 299 expectedProduct << std::hex << TestDevice::TEST_BUS << '/' << TestDevice::TEST_VENDOR << '/' << 300 TestDevice::TEST_PRODUCT << '/' << TestDevice::TEST_VERSION; 301 EXPECT_STRNE(udev_device_get_property_value(parent, "PRODUCT"), expectedProduct.str().c_str()); 302 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT"), "1"); 303 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT_MOUSE"), "1"); 304 } 305 306 HWTEST_F(CustomUdevTest, TestUdevWheel, TestSize.Level1) 307 { 308 testDevice_.WheelSetup(); 309 ASSERT_NO_FATAL_FAILURE(testDevice_.Init(false)); 310 auto* device = testDevice_.GetDevice(); 311 312 auto* parent = udev_device_get_parent(device); 313 ASSERT_NE(parent, nullptr); 314 315 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT"), "1"); 316 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT_KEY"), "1"); 317 } 318 319 HWTEST_F(CustomUdevTest, TestUdevPropsKey, TestSize.Level1) 320 { 321 testDevice_.KeyboardSetup(); 322 ASSERT_NO_FATAL_FAILURE(testDevice_.Init(false)); 323 auto* device = testDevice_.GetDevice(); 324 325 auto* parent = udev_device_get_parent(device); 326 ASSERT_NE(parent, nullptr); 327 328 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT"), "1"); 329 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT_KEY"), "1"); 330 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT_KEYBOARD"), "1"); 331 } 332 333 HWTEST_F(CustomUdevTest, TestUdevPropsSwitch, TestSize.Level1) 334 { 335 testDevice_.SwitchSetup(); 336 ASSERT_NO_FATAL_FAILURE(testDevice_.Init(false)); 337 auto* device = testDevice_.GetDevice(); 338 339 auto* parent = udev_device_get_parent(device); 340 ASSERT_NE(parent, nullptr); 341 342 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT"), "1"); 343 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT_SWITCH"), "1"); 344 } 345 346 HWTEST_F(CustomUdevTest, TestUdevPropsAccel, TestSize.Level1) 347 { 348 testDevice_.AccelerometerSetup(); 349 ASSERT_NO_FATAL_FAILURE(testDevice_.Init(false)); 350 auto* device = testDevice_.GetDevice(); 351 352 auto* parent = udev_device_get_parent(device); 353 ASSERT_NE(parent, nullptr); 354 355 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT"), "1"); 356 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT_ACCELEROMETER"), "1"); 357 } 358 359 HWTEST_F(CustomUdevTest, TestUdevPropsStick, TestSize.Level1) 360 { 361 testDevice_.StickSetup(); 362 ASSERT_NO_FATAL_FAILURE(testDevice_.Init(false)); 363 auto* device = testDevice_.GetDevice(); 364 365 auto* parent = udev_device_get_parent(device); 366 ASSERT_NE(parent, nullptr); 367 368 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT"), "1"); 369 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT_POINTINGSTICK"), "1"); 370 } 371 372 HWTEST_F(CustomUdevTest, TestUdevPropsTouchpad, TestSize.Level1) 373 { 374 testDevice_.TouchpadSetup(); 375 ASSERT_NO_FATAL_FAILURE(testDevice_.Init(false)); 376 auto* device = testDevice_.GetDevice(); 377 378 auto* parent = udev_device_get_parent(device); 379 ASSERT_NE(parent, nullptr); 380 381 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT"), "1"); 382 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT_TOUCHPAD"), "1"); 383 } 384 385 HWTEST_F(CustomUdevTest, TestUdevPropsTouchscreen, TestSize.Level1) 386 { 387 testDevice_.TouchscreenSetup(); 388 ASSERT_NO_FATAL_FAILURE(testDevice_.Init(false)); 389 auto* device = testDevice_.GetDevice(); 390 391 auto* parent = udev_device_get_parent(device); 392 ASSERT_NE(parent, nullptr); 393 394 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT"), "1"); 395 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT_TOUCHSCREEN"), "1"); 396 } 397 398 HWTEST_F(CustomUdevTest, TestUdevPropsJoystick, TestSize.Level1) 399 { 400 testDevice_.JoystickSetup(); 401 ASSERT_NO_FATAL_FAILURE(testDevice_.Init(false)); 402 auto* device = testDevice_.GetDevice(); 403 404 auto* parent = udev_device_get_parent(device); 405 ASSERT_NE(parent, nullptr); 406 407 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT"), "1"); 408 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT_JOYSTICK"), "1"); 409 } 410 411 HWTEST_F(CustomUdevTest, TestUdevPropsJoystick1, TestSize.Level1) 412 { 413 testDevice_.JoystickSetup1(); 414 ASSERT_NO_FATAL_FAILURE(testDevice_.Init(false)); 415 auto* device = testDevice_.GetDevice(); 416 417 auto* parent = udev_device_get_parent(device); 418 ASSERT_NE(parent, nullptr); 419 420 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT"), "1"); 421 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT_JOYSTICK"), "1"); 422 } 423 424 HWTEST_F(CustomUdevTest, TestUdevPropsTablet, TestSize.Level1) 425 { 426 testDevice_.TabletSetup(); 427 ASSERT_NO_FATAL_FAILURE(testDevice_.Init(false)); 428 auto* device = testDevice_.GetDevice(); 429 430 auto* parent = udev_device_get_parent(device); 431 ASSERT_NE(parent, nullptr); 432 433 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT"), "1"); 434 EXPECT_STRNE(udev_device_get_property_value(parent, "ID_INPUT_TABLET"), "1"); 435 } 436