| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright (c) 2014 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include <sstream> |
| 6 |
| 7 #include "device/hid/hid_report_descriptor.h" |
| 8 #include "testing/gmock/include/gmock/gmock.h" |
| 9 #include "testing/gtest/include/gtest/gtest.h" |
| 10 |
| 11 using namespace testing; |
| 12 |
| 13 namespace device { |
| 14 |
| 15 namespace { |
| 16 |
| 17 std::ostream& operator<<(std::ostream& os, |
| 18 const HidUsageAndPage::Page& usage_page) { |
| 19 switch (usage_page) { |
| 20 case HidUsageAndPage::kPageUndefined: |
| 21 os << "Undefined"; |
| 22 break; |
| 23 case HidUsageAndPage::kPageGenericDesktop: |
| 24 os << "Generic Desktop"; |
| 25 break; |
| 26 case HidUsageAndPage::kPageSimulation: |
| 27 os << "Simulation"; |
| 28 break; |
| 29 case HidUsageAndPage::kPageVirtualReality: |
| 30 os << "Virtual Reality"; |
| 31 break; |
| 32 case HidUsageAndPage::kPageSport: |
| 33 os << "Sport"; |
| 34 break; |
| 35 case HidUsageAndPage::kPageGame: |
| 36 os << "Game"; |
| 37 break; |
| 38 case HidUsageAndPage::kPageKeyboard: |
| 39 os << "Keyboard"; |
| 40 break; |
| 41 case HidUsageAndPage::kPageLed: |
| 42 os << "Led"; |
| 43 break; |
| 44 case HidUsageAndPage::kPageButton: |
| 45 os << "Button"; |
| 46 break; |
| 47 case HidUsageAndPage::kPageOrdinal: |
| 48 os << "Ordinal"; |
| 49 break; |
| 50 case HidUsageAndPage::kPageTelephony: |
| 51 os << "Telephony"; |
| 52 break; |
| 53 case HidUsageAndPage::kPageConsumer: |
| 54 os << "Consumer"; |
| 55 break; |
| 56 case HidUsageAndPage::kPageDigitizer: |
| 57 os << "Digitizer"; |
| 58 break; |
| 59 case HidUsageAndPage::kPagePidPage: |
| 60 os << "Pid Page"; |
| 61 break; |
| 62 case HidUsageAndPage::kPageUnicode: |
| 63 os << "Unicode"; |
| 64 break; |
| 65 case HidUsageAndPage::kPageAlphanumericDisplay: |
| 66 os << "Alphanumeric Display"; |
| 67 break; |
| 68 case HidUsageAndPage::kPageMedicalInstruments: |
| 69 os << "Medical Instruments"; |
| 70 break; |
| 71 case HidUsageAndPage::kPageMonitor0: |
| 72 os << "Monitor 0"; |
| 73 break; |
| 74 case HidUsageAndPage::kPageMonitor1: |
| 75 os << "Monitor 1"; |
| 76 break; |
| 77 case HidUsageAndPage::kPageMonitor2: |
| 78 os << "Monitor 2"; |
| 79 break; |
| 80 case HidUsageAndPage::kPageMonitor3: |
| 81 os << "Monitor 3"; |
| 82 break; |
| 83 case HidUsageAndPage::kPagePower0: |
| 84 os << "Power 0"; |
| 85 break; |
| 86 case HidUsageAndPage::kPagePower1: |
| 87 os << "Power 1"; |
| 88 break; |
| 89 case HidUsageAndPage::kPagePower2: |
| 90 os << "Power 2"; |
| 91 break; |
| 92 case HidUsageAndPage::kPagePower3: |
| 93 os << "Power 3"; |
| 94 break; |
| 95 case HidUsageAndPage::kPageBarCodeScanner: |
| 96 os << "Bar Code Scanner"; |
| 97 break; |
| 98 case HidUsageAndPage::kPageScale: |
| 99 os << "Scale"; |
| 100 break; |
| 101 case HidUsageAndPage::kPageMagneticStripeReader: |
| 102 os << "Magnetic Stripe Reader"; |
| 103 break; |
| 104 case HidUsageAndPage::kPageReservedPointOfSale: |
| 105 os << "Reserved Point Of Sale"; |
| 106 break; |
| 107 case HidUsageAndPage::kPageCameraControl: |
| 108 os << "Camera Control"; |
| 109 break; |
| 110 case HidUsageAndPage::kPageArcade: |
| 111 os << "Arcade"; |
| 112 break; |
| 113 case HidUsageAndPage::kPageVendor: |
| 114 os << "Vendor"; |
| 115 break; |
| 116 case HidUsageAndPage::kPageMediaCenter: |
| 117 os << "Media Center"; |
| 118 break; |
| 119 default: |
| 120 NOTREACHED(); |
| 121 break; |
| 122 } |
| 123 return os; |
| 124 } |
| 125 |
| 126 std::ostream& operator<<(std::ostream& os, |
| 127 const HidUsageAndPage& usage_and_page) { |
| 128 os << "Usage Page: " << usage_and_page.usage_page << ", Usage: " |
| 129 << "0x" << std::hex << std::uppercase << usage_and_page.usage; |
| 130 return os; |
| 131 } |
| 132 |
| 133 std::ostream& operator<<(std::ostream& os, |
| 134 const HidReportDescriptorItem::Tag& tag) { |
| 135 switch (tag) { |
| 136 case HidReportDescriptorItem::kTagDefault: |
| 137 os << "Default"; |
| 138 break; |
| 139 case HidReportDescriptorItem::kTagInput: |
| 140 os << "Input"; |
| 141 break; |
| 142 case HidReportDescriptorItem::kTagOutput: |
| 143 os << "Output"; |
| 144 break; |
| 145 case HidReportDescriptorItem::kTagFeature: |
| 146 os << "Feature"; |
| 147 break; |
| 148 case HidReportDescriptorItem::kTagCollection: |
| 149 os << "Collection"; |
| 150 break; |
| 151 case HidReportDescriptorItem::kTagEndCollection: |
| 152 os << "End Collection"; |
| 153 break; |
| 154 case HidReportDescriptorItem::kTagUsagePage: |
| 155 os << "Usage Page"; |
| 156 break; |
| 157 case HidReportDescriptorItem::kTagLogicalMinimum: |
| 158 os << "Logical Minimum"; |
| 159 break; |
| 160 case HidReportDescriptorItem::kTagLogicalMaximum: |
| 161 os << "Logical Maximum"; |
| 162 break; |
| 163 case HidReportDescriptorItem::kTagPhysicalMinimum: |
| 164 os << "Physical Minimum"; |
| 165 break; |
| 166 case HidReportDescriptorItem::kTagPhysicalMaximum: |
| 167 os << "Physical Maximum"; |
| 168 break; |
| 169 case HidReportDescriptorItem::kTagUnitExponent: |
| 170 os << "Unit Exponent"; |
| 171 break; |
| 172 case HidReportDescriptorItem::kTagUnit: |
| 173 os << "Unit"; |
| 174 break; |
| 175 case HidReportDescriptorItem::kTagReportSize: |
| 176 os << "Report Size"; |
| 177 break; |
| 178 case HidReportDescriptorItem::kTagReportId: |
| 179 os << "Report ID"; |
| 180 break; |
| 181 case HidReportDescriptorItem::kTagReportCount: |
| 182 os << "Report Count"; |
| 183 break; |
| 184 case HidReportDescriptorItem::kTagPush: |
| 185 os << "Push"; |
| 186 break; |
| 187 case HidReportDescriptorItem::kTagPop: |
| 188 os << "Pop"; |
| 189 break; |
| 190 case HidReportDescriptorItem::kTagUsage: |
| 191 os << "Usage"; |
| 192 break; |
| 193 case HidReportDescriptorItem::kTagUsageMinimum: |
| 194 os << "Usage Minimum"; |
| 195 break; |
| 196 case HidReportDescriptorItem::kTagUsageMaximum: |
| 197 os << "Usage Maximum"; |
| 198 break; |
| 199 case HidReportDescriptorItem::kTagDesignatorIndex: |
| 200 os << "Designator Index"; |
| 201 break; |
| 202 case HidReportDescriptorItem::kTagDesignatorMinimum: |
| 203 os << "Designator Minimum"; |
| 204 break; |
| 205 case HidReportDescriptorItem::kTagDesignatorMaximum: |
| 206 os << "Designator Maximum"; |
| 207 break; |
| 208 case HidReportDescriptorItem::kTagStringIndex: |
| 209 os << "String Index"; |
| 210 break; |
| 211 case HidReportDescriptorItem::kTagStringMinimum: |
| 212 os << "String Minimum"; |
| 213 break; |
| 214 case HidReportDescriptorItem::kTagStringMaximum: |
| 215 os << "String Maximum"; |
| 216 break; |
| 217 case HidReportDescriptorItem::kTagDelimiter: |
| 218 os << "Delimeter"; |
| 219 break; |
| 220 case HidReportDescriptorItem::kTagLong: |
| 221 os << "Long"; |
| 222 break; |
| 223 default: |
| 224 NOTREACHED(); |
| 225 break; |
| 226 } |
| 227 |
| 228 return os; |
| 229 } |
| 230 |
| 231 std::ostream& operator<<(std::ostream& os, |
| 232 const HidReportDescriptorItem::ReportInfo& data) { |
| 233 if (data.data_or_constant) |
| 234 os << "Con"; |
| 235 else |
| 236 os << "Dat"; |
| 237 if (data.array_or_variable) |
| 238 os << "|Arr"; |
| 239 else |
| 240 os << "|Var"; |
| 241 if (data.absolute_or_relative) |
| 242 os << "|Abs"; |
| 243 else |
| 244 os << "|Rel"; |
| 245 if (data.wrap) |
| 246 os << "|Wrp"; |
| 247 else |
| 248 os << "|NoWrp"; |
| 249 if (data.linear) |
| 250 os << "|NoLin"; |
| 251 else |
| 252 os << "|Lin"; |
| 253 if (data.preferred) |
| 254 os << "|NoPrf"; |
| 255 else |
| 256 os << "|Prf"; |
| 257 if (data.null) |
| 258 os << "|Null"; |
| 259 else |
| 260 os << "|NoNull"; |
| 261 if (data.bit_field_or_buffer) |
| 262 os << "|Buff"; |
| 263 else |
| 264 os << "|BitF"; |
| 265 return os; |
| 266 } |
| 267 |
| 268 std::ostream& operator<<(std::ostream& os, |
| 269 const HidReportDescriptorItem::CollectionType& type) { |
| 270 switch (type) { |
| 271 case HidReportDescriptorItem::kCollectionTypePhysical: |
| 272 os << "Physical"; |
| 273 break; |
| 274 case HidReportDescriptorItem::kCollectionTypeApplication: |
| 275 os << "Application"; |
| 276 break; |
| 277 case HidReportDescriptorItem::kCollectionTypeLogical: |
| 278 os << "Logical"; |
| 279 break; |
| 280 case HidReportDescriptorItem::kCollectionTypeReport: |
| 281 os << "Report"; |
| 282 break; |
| 283 case HidReportDescriptorItem::kCollectionTypeNamedArray: |
| 284 os << "Named Array"; |
| 285 break; |
| 286 case HidReportDescriptorItem::kCollectionTypeUsageSwitch: |
| 287 os << "Usage Switch"; |
| 288 break; |
| 289 case HidReportDescriptorItem::kCollectionTypeUsageModifier: |
| 290 os << "Usage Modifier"; |
| 291 break; |
| 292 case HidReportDescriptorItem::kCollectionTypeReserved: |
| 293 os << "Reserved"; |
| 294 break; |
| 295 case HidReportDescriptorItem::kCollectionTypeVendor: |
| 296 os << "Vendor"; |
| 297 break; |
| 298 default: |
| 299 NOTREACHED(); |
| 300 break; |
| 301 } |
| 302 return os; |
| 303 } |
| 304 |
| 305 std::ostream& operator<<(std::ostream& os, |
| 306 const HidReportDescriptorItem& item) { |
| 307 HidReportDescriptorItem::Tag item_tag = item.tag(); |
| 308 uint32_t data = item.GetShortData(); |
| 309 |
| 310 std::ostringstream sstr; |
| 311 sstr << item_tag; |
| 312 sstr << " ("; |
| 313 |
| 314 long pos = sstr.tellp(); |
| 315 switch (item_tag) { |
| 316 case HidReportDescriptorItem::kTagDefault: |
| 317 case HidReportDescriptorItem::kTagEndCollection: |
| 318 case HidReportDescriptorItem::kTagPush: |
| 319 case HidReportDescriptorItem::kTagPop: |
| 320 case HidReportDescriptorItem::kTagLong: |
| 321 break; |
| 322 |
| 323 case HidReportDescriptorItem::kTagCollection: |
| 324 sstr << HidReportDescriptorItem::GetCollectionTypeFromValue(data); |
| 325 break; |
| 326 |
| 327 case HidReportDescriptorItem::kTagInput: |
| 328 case HidReportDescriptorItem::kTagOutput: |
| 329 case HidReportDescriptorItem::kTagFeature: |
| 330 sstr << (HidReportDescriptorItem::ReportInfo&)data; |
| 331 break; |
| 332 |
| 333 case HidReportDescriptorItem::kTagUsagePage: |
| 334 sstr << (HidUsageAndPage::Page)data; |
| 335 break; |
| 336 |
| 337 case HidReportDescriptorItem::kTagUsage: |
| 338 case HidReportDescriptorItem::kTagReportId: |
| 339 sstr << "0x" << std::hex << std::uppercase << data; |
| 340 break; |
| 341 |
| 342 default: |
| 343 sstr << data; |
| 344 break; |
| 345 } |
| 346 if (pos == sstr.tellp()) { |
| 347 std::string str = sstr.str(); |
| 348 str.erase(str.end() - 2, str.end()); |
| 349 os << str; |
| 350 } else { |
| 351 os << sstr.str() << ")"; |
| 352 } |
| 353 |
| 354 return os; |
| 355 } |
| 356 |
| 357 const char kIndentStep[] = " "; |
| 358 |
| 359 std::ostream& operator<<(std::ostream& os, |
| 360 const HidReportDescriptor& descriptor) { |
| 361 for (std::vector<linked_ptr<HidReportDescriptorItem> >::const_iterator |
| 362 items_iter = descriptor.items().begin(); |
| 363 items_iter != descriptor.items().end(); |
| 364 ++items_iter) { |
| 365 linked_ptr<HidReportDescriptorItem> item = *items_iter; |
| 366 size_t indentLevel = item->GetDepth(); |
| 367 for (size_t i = 0; i < indentLevel; i++) |
| 368 os << kIndentStep; |
| 369 os << *item.get() << std::endl; |
| 370 } |
| 371 return os; |
| 372 } |
| 373 |
| 374 // See 'E.6 Report Descriptor (Keyboard)' |
| 375 // in HID specifications (v1.11) |
| 376 const uint8_t kKeyboard[] = { |
| 377 0x05, 0x01, 0x09, 0x06, 0xA1, 0x01, 0x05, 0x07, 0x19, 0xE0, 0x29, |
| 378 0xE7, 0x15, 0x00, 0x25, 0x01, 0x75, 0x01, 0x95, 0x08, 0x81, 0x02, |
| 379 0x95, 0x01, 0x75, 0x08, 0x81, 0x01, 0x95, 0x05, 0x75, 0x01, 0x05, |
| 380 0x08, 0x19, 0x01, 0x29, 0x05, 0x91, 0x02, 0x95, 0x01, 0x75, 0x03, |
| 381 0x91, 0x01, 0x95, 0x06, 0x75, 0x08, 0x15, 0x00, 0x25, 0x65, 0x05, |
| 382 0x07, 0x19, 0x00, 0x29, 0x65, 0x81, 0x00, 0xC0}; |
| 383 |
| 384 // See 'E.10 Report Descriptor (Mouse)' |
| 385 // in HID specifications (v1.11) |
| 386 const uint8_t kMouse[] = {0x05, 0x01, 0x09, 0x02, 0xA1, 0x01, 0x09, 0x01, 0xA1, |
| 387 0x00, 0x05, 0x09, 0x19, 0x01, 0x29, 0x03, 0x15, 0x00, |
| 388 0x25, 0x01, 0x95, 0x03, 0x75, 0x01, 0x81, 0x02, 0x95, |
| 389 0x01, 0x75, 0x05, 0x81, 0x01, 0x05, 0x01, 0x09, 0x30, |
| 390 0x09, 0x31, 0x15, 0x81, 0x25, 0x7F, 0x75, 0x08, 0x95, |
| 391 0x02, 0x81, 0x06, 0xC0, 0xC0}; |
| 392 |
| 393 const uint8_t kLogitechUnifyingReceiver[] = { |
| 394 0x06, 0x00, 0xFF, 0x09, 0x01, 0xA1, 0x01, 0x85, 0x10, 0x75, 0x08, |
| 395 0x95, 0x06, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x09, 0x01, 0x81, 0x00, |
| 396 0x09, 0x01, 0x91, 0x00, 0xC0, 0x06, 0x00, 0xFF, 0x09, 0x02, 0xA1, |
| 397 0x01, 0x85, 0x11, 0x75, 0x08, 0x95, 0x13, 0x15, 0x00, 0x26, 0xFF, |
| 398 0x00, 0x09, 0x02, 0x81, 0x00, 0x09, 0x02, 0x91, 0x00, 0xC0, 0x06, |
| 399 0x00, 0xFF, 0x09, 0x04, 0xA1, 0x01, 0x85, 0x20, 0x75, 0x08, 0x95, |
| 400 0x0E, 0x15, 0x00, 0x26, 0xFF, 0x00, 0x09, 0x41, 0x81, 0x00, 0x09, |
| 401 0x41, 0x91, 0x00, 0x85, 0x21, 0x95, 0x1F, 0x15, 0x00, 0x26, 0xFF, |
| 402 0x00, 0x09, 0x42, 0x81, 0x00, 0x09, 0x42, 0x91, 0x00, 0xC0}; |
| 403 |
| 404 } // namespace |
| 405 |
| 406 class HidReportDescriptorTest : public testing::Test { |
| 407 |
| 408 protected: |
| 409 virtual void SetUp() OVERRIDE { descriptor_ = NULL; } |
| 410 |
| 411 virtual void TearDown() OVERRIDE { |
| 412 if (descriptor_) { |
| 413 delete descriptor_; |
| 414 } |
| 415 } |
| 416 |
| 417 public: |
| 418 void ParseDescriptor(const std::string& expected, |
| 419 const uint8_t* bytes, |
| 420 size_t size) { |
| 421 descriptor_ = new HidReportDescriptor(bytes, size); |
| 422 |
| 423 std::stringstream actual; |
| 424 actual << *descriptor_; |
| 425 |
| 426 std::cout << "HID report descriptor:" << std::endl; |
| 427 std::cout << actual.str(); |
| 428 |
| 429 // TODO(jracle@logitech.com): refactor string comparison in favor of |
| 430 // testing individual fields. |
| 431 ASSERT_EQ(expected, actual.str()); |
| 432 } |
| 433 |
| 434 void GetTopLevelCollections(const std::vector<HidUsageAndPage>& expected, |
| 435 const uint8_t* bytes, |
| 436 size_t size) { |
| 437 descriptor_ = new HidReportDescriptor(bytes, size); |
| 438 |
| 439 std::vector<HidUsageAndPage> actual; |
| 440 descriptor_->GetTopLevelCollections(&actual); |
| 441 |
| 442 std::cout << "HID top-level collections:" << std::endl; |
| 443 for (std::vector<HidUsageAndPage>::const_iterator iter = actual.begin(); |
| 444 iter != actual.end(); |
| 445 ++iter) { |
| 446 std::cout << *iter << std::endl; |
| 447 } |
| 448 |
| 449 ASSERT_THAT(actual, ContainerEq(expected)); |
| 450 } |
| 451 |
| 452 private: |
| 453 HidReportDescriptor* descriptor_; |
| 454 }; |
| 455 |
| 456 TEST_F(HidReportDescriptorTest, ParseDescriptor_Keyboard) { |
| 457 const char expected[] = { |
| 458 "Usage Page (Generic Desktop)\n" |
| 459 "Usage (0x6)\n" |
| 460 "Collection (Physical)\n" |
| 461 " Usage Page (Keyboard)\n" |
| 462 " Usage Minimum (224)\n" |
| 463 " Usage Maximum (231)\n" |
| 464 " Logical Minimum (0)\n" |
| 465 " Logical Maximum (1)\n" |
| 466 " Report Size (1)\n" |
| 467 " Report Count (8)\n" |
| 468 " Input (Dat|Arr|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 469 " Report Count (1)\n" |
| 470 " Report Size (8)\n" |
| 471 " Input (Con|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 472 " Report Count (5)\n" |
| 473 " Report Size (1)\n" |
| 474 " Usage Page (Led)\n" |
| 475 " Usage Minimum (1)\n" |
| 476 " Usage Maximum (5)\n" |
| 477 " Output (Dat|Arr|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 478 " Report Count (1)\n" |
| 479 " Report Size (3)\n" |
| 480 " Output (Con|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 481 " Report Count (6)\n" |
| 482 " Report Size (8)\n" |
| 483 " Logical Minimum (0)\n" |
| 484 " Logical Maximum (101)\n" |
| 485 " Usage Page (Keyboard)\n" |
| 486 " Usage Minimum (0)\n" |
| 487 " Usage Maximum (101)\n" |
| 488 " Input (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 489 "End Collection\n"}; |
| 490 |
| 491 ParseDescriptor(std::string(expected), kKeyboard, sizeof(kKeyboard)); |
| 492 } |
| 493 |
| 494 TEST_F(HidReportDescriptorTest, TopLevelCollections_Keyboard) { |
| 495 HidUsageAndPage expected[] = { |
| 496 HidUsageAndPage(0x06, HidUsageAndPage::kPageGenericDesktop)}; |
| 497 |
| 498 GetTopLevelCollections(std::vector<HidUsageAndPage>( |
| 499 expected, expected + ARRAYSIZE_UNSAFE(expected)), |
| 500 kKeyboard, |
| 501 sizeof(kKeyboard)); |
| 502 } |
| 503 |
| 504 TEST_F(HidReportDescriptorTest, ParseDescriptor_Mouse) { |
| 505 const char expected[] = { |
| 506 "Usage Page (Generic Desktop)\n" |
| 507 "Usage (0x2)\n" |
| 508 "Collection (Physical)\n" |
| 509 " Usage (0x1)\n" |
| 510 " Collection (Physical)\n" |
| 511 " Usage Page (Button)\n" |
| 512 " Usage Minimum (1)\n" |
| 513 " Usage Maximum (3)\n" |
| 514 " Logical Minimum (0)\n" |
| 515 " Logical Maximum (1)\n" |
| 516 " Report Count (3)\n" |
| 517 " Report Size (1)\n" |
| 518 " Input (Dat|Arr|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 519 " Report Count (1)\n" |
| 520 " Report Size (5)\n" |
| 521 " Input (Con|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 522 " Usage Page (Generic Desktop)\n" |
| 523 " Usage (0x30)\n" |
| 524 " Usage (0x31)\n" |
| 525 " Logical Minimum (129)\n" |
| 526 " Logical Maximum (127)\n" |
| 527 " Report Size (8)\n" |
| 528 " Report Count (2)\n" |
| 529 " Input (Dat|Arr|Abs|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 530 " End Collection\n" |
| 531 "End Collection\n"}; |
| 532 |
| 533 ParseDescriptor(std::string(expected), kMouse, sizeof(kMouse)); |
| 534 } |
| 535 |
| 536 TEST_F(HidReportDescriptorTest, TopLevelCollections_Mouse) { |
| 537 HidUsageAndPage expected[] = { |
| 538 HidUsageAndPage(0x02, HidUsageAndPage::kPageGenericDesktop)}; |
| 539 |
| 540 GetTopLevelCollections(std::vector<HidUsageAndPage>( |
| 541 expected, expected + ARRAYSIZE_UNSAFE(expected)), |
| 542 kMouse, |
| 543 sizeof(kMouse)); |
| 544 } |
| 545 |
| 546 TEST_F(HidReportDescriptorTest, ParseDescriptor_LogitechUnifyingReceiver) { |
| 547 const char expected[] = { |
| 548 "Usage Page (Vendor)\n" |
| 549 "Usage (0x1)\n" |
| 550 "Collection (Physical)\n" |
| 551 " Report ID (0x10)\n" |
| 552 " Report Size (8)\n" |
| 553 " Report Count (6)\n" |
| 554 " Logical Minimum (0)\n" |
| 555 " Logical Maximum (255)\n" |
| 556 " Usage (0x1)\n" |
| 557 " Input (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 558 " Usage (0x1)\n" |
| 559 " Output (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 560 "End Collection\n" |
| 561 "Usage Page (Vendor)\n" |
| 562 "Usage (0x2)\n" |
| 563 "Collection (Physical)\n" |
| 564 " Report ID (0x11)\n" |
| 565 " Report Size (8)\n" |
| 566 " Report Count (19)\n" |
| 567 " Logical Minimum (0)\n" |
| 568 " Logical Maximum (255)\n" |
| 569 " Usage (0x2)\n" |
| 570 " Input (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 571 " Usage (0x2)\n" |
| 572 " Output (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 573 "End Collection\n" |
| 574 "Usage Page (Vendor)\n" |
| 575 "Usage (0x4)\n" |
| 576 "Collection (Physical)\n" |
| 577 " Report ID (0x20)\n" |
| 578 " Report Size (8)\n" |
| 579 " Report Count (14)\n" |
| 580 " Logical Minimum (0)\n" |
| 581 " Logical Maximum (255)\n" |
| 582 " Usage (0x41)\n" |
| 583 " Input (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 584 " Usage (0x41)\n" |
| 585 " Output (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 586 " Report ID (0x21)\n" |
| 587 " Report Count (31)\n" |
| 588 " Logical Minimum (0)\n" |
| 589 " Logical Maximum (255)\n" |
| 590 " Usage (0x42)\n" |
| 591 " Input (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 592 " Usage (0x42)\n" |
| 593 " Output (Dat|Var|Rel|NoWrp|Lin|Prf|NoNull|BitF)\n" |
| 594 "End Collection\n"}; |
| 595 |
| 596 ParseDescriptor(std::string(expected), |
| 597 kLogitechUnifyingReceiver, |
| 598 sizeof(kLogitechUnifyingReceiver)); |
| 599 } |
| 600 |
| 601 TEST_F(HidReportDescriptorTest, TopLevelCollections_LogitechUnifyingReceiver) { |
| 602 HidUsageAndPage expected[] = { |
| 603 HidUsageAndPage(0x01, HidUsageAndPage::kPageVendor), |
| 604 HidUsageAndPage(0x02, HidUsageAndPage::kPageVendor), |
| 605 HidUsageAndPage(0x04, HidUsageAndPage::kPageVendor), }; |
| 606 |
| 607 GetTopLevelCollections(std::vector<HidUsageAndPage>( |
| 608 expected, expected + ARRAYSIZE_UNSAFE(expected)), |
| 609 kLogitechUnifyingReceiver, |
| 610 sizeof(kLogitechUnifyingReceiver)); |
| 611 } |
| 612 |
| 613 } // namespace device |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 256673002:
HID: Support top-level collection usages in device info. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src