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