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