// Copyright (c) 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <stddef.h>
#include <stdint.h>

#include <limits>
#include <sstream>
#include <unordered_map>
#include <utility>

#include "base/macros.h"
#include "services/device/hid/test_report_descriptors.h"
#include "services/device/public/cpp/hid/hid_report_descriptor.h"
#include "services/device/public/cpp/hid/hid_usage_and_page.h"
#include "services/device/public/mojom/hid.mojom.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace device {

namespace {
using HidReport = std::vector<std::unique_ptr<HidReportItem>>;
using HidReportMap = std::unordered_map<uint8_t, HidReport>;
using HidCollectionVector = std::vector<std::unique_ptr<HidCollection>>;

// HID unit values.
const uint32_t kUnitCandela = 0x010000e1;
const uint32_t kUnitDegrees = 0x14;
const uint32_t kUnitInch = 0x13;
const uint32_t kUnitNewton = 0xe111;
const uint32_t kUnitSecond = 0x1001;

// Report info bitfield values. The bits are:
//   bit 0: Data (0) | Constant (1)
//   bit 1: Array (0) | Variable (1)
//   bit 2: Absolute (0) | Relative (1)
//   bit 3: No Wrap (0) | Wrap (1)
//   bit 4: Linear (0) | Non-Linear (1)
//   bit 5: Preferred State (0) | No Preferred State (1)
//   bit 6: No Null Value (0) | Has Null Value (1)
//   bit 7: Non-Volatile (0) | Volatile (1)
//   bit 8: Bit Field (0) | Buffered Bytes (1)
const uint16_t kNonNullableArray = 0x0000;
const uint16_t kConstantArray = 0x0001;
const uint16_t kAbsoluteVariable = 0x0002;
const uint16_t kConstant = 0x0003;
const uint16_t kRelativeVariable = 0x0006;
const uint16_t kNonLinearVariable = 0x0012;
const uint16_t kNullableArray = 0x0040;
const uint16_t kNullableAbsoluteVariable = 0x0042;
const uint16_t kVolatileConstant = 0x0083;
const uint16_t kBufferedBytes = 0x0102;

// Vendor usage pages.
const uint16_t kPageVendor02 = mojom::kPageVendor + 0x02;
const uint16_t kPageVendor05 = mojom::kPageVendor + 0x05;
const uint16_t kPageVendor80 = mojom::kPageVendor + 0x80;

// Bit-width and mask for the usage ID field in a 32-bit usage value.
const size_t kUsageIdSizeBits = sizeof(uint16_t) * 8;
const uint32_t kUsageIdMask = std::numeric_limits<uint16_t>::max();

// Combined usage page and usage ID values. The usage page occupies the high 16
// bits, the usage ID occupies the low 16 bits.
const uint32_t kUsageButton = (mojom::kPageButton << kUsageIdSizeBits);
const uint32_t kUsageConsumer = (mojom::kPageConsumer << kUsageIdSizeBits);
const uint32_t kUsageConsumerACBack = kUsageConsumer | 0x0224;
const uint32_t kUsageConsumerACHome = kUsageConsumer | 0x0223;
const uint32_t kUsageConsumerControl = kUsageConsumer | 0x01;
const uint32_t kUsageConsumerModeStep = kUsageConsumer | 0x82;
const uint32_t kUsageDigitizer = (mojom::kPageDigitizer << kUsageIdSizeBits);
const uint32_t kUsageDigitizerDigitizer = kUsageDigitizer | 0x01;
const uint32_t kUsageDigitizerBarrelSwitch = kUsageDigitizer | 0x44;
const uint32_t kUsageDigitizerInRange = kUsageDigitizer | 0x32;
const uint32_t kUsageDigitizerPuck = kUsageDigitizer | 0x21;
const uint32_t kUsageDigitizerStylus = kUsageDigitizer | 0x20;
const uint32_t kUsageDigitizerTipPressure = kUsageDigitizer | 0x30;
const uint32_t kUsageDigitizerTipSwitch = kUsageDigitizer | 0x42;
const uint32_t kUsageGenericDesktop =
    (mojom::kPageGenericDesktop << kUsageIdSizeBits);
const uint32_t kUsageGenericDesktopDial =
    kUsageGenericDesktop | mojom::kGenericDesktopDial;
const uint32_t kUsageGenericDesktopGamePad =
    kUsageGenericDesktop | mojom::kGenericDesktopGamePad;
const uint32_t kUsageGenericDesktopHatSwitch =
    kUsageGenericDesktop | mojom::kGenericDesktopHatSwitch;
const uint32_t kUsageGenericDesktopJoystick =
    kUsageGenericDesktop | mojom::kGenericDesktopJoystick;
const uint32_t kUsageGenericDesktopKeyboard =
    kUsageGenericDesktop | mojom::kGenericDesktopKeyboard;
const uint32_t kUsageGenericDesktopMouse =
    kUsageGenericDesktop | mojom::kGenericDesktopMouse;
const uint32_t kUsageGenericDesktopPointer =
    kUsageGenericDesktop | mojom::kGenericDesktopPointer;
const uint32_t kUsageGenericDesktopRx =
    kUsageGenericDesktop | mojom::kGenericDesktopRx;
const uint32_t kUsageGenericDesktopRy =
    kUsageGenericDesktop | mojom::kGenericDesktopRy;
const uint32_t kUsageGenericDesktopRz =
    kUsageGenericDesktop | mojom::kGenericDesktopRz;
const uint32_t kUsageGenericDesktopSystemControl =
    kUsageGenericDesktop | mojom::kGenericDesktopSystemControl;
const uint32_t kUsageGenericDesktopSystemMainMenu =
    kUsageGenericDesktop | mojom::kGenericDesktopSystemMainMenu;
const uint32_t kUsageGenericDesktopVbrx =
    kUsageGenericDesktop | mojom::kGenericDesktopVbrx;
const uint32_t kUsageGenericDesktopVbry =
    kUsageGenericDesktop | mojom::kGenericDesktopVbry;
const uint32_t kUsageGenericDesktopVbrz =
    kUsageGenericDesktop | mojom::kGenericDesktopVbrz;
const uint32_t kUsageGenericDesktopVx =
    kUsageGenericDesktop | mojom::kGenericDesktopVx;
const uint32_t kUsageGenericDesktopVy =
    kUsageGenericDesktop | mojom::kGenericDesktopVy;
const uint32_t kUsageGenericDesktopVz =
    kUsageGenericDesktop | mojom::kGenericDesktopVz;
const uint32_t kUsageGenericDesktopWheel =
    kUsageGenericDesktop | mojom::kGenericDesktopWheel;
const uint32_t kUsageGenericDesktopX =
    kUsageGenericDesktop | mojom::kGenericDesktopX;
const uint32_t kUsageGenericDesktopY =
    kUsageGenericDesktop | mojom::kGenericDesktopY;
const uint32_t kUsageGenericDesktopZ =
    kUsageGenericDesktop | mojom::kGenericDesktopZ;
const uint32_t kUsageGenericDeviceBatteryStrength =
    (mojom::kPageGenericDevice << kUsageIdSizeBits) | 0x20;
const uint32_t kUsageKeyboard = (mojom::kPageKeyboard << kUsageIdSizeBits);
const uint32_t kUsageKeyboardApplication = kUsageKeyboard | 0x65;
const uint32_t kUsageKeyboardLeftControl = kUsageKeyboard | 0xe0;
const uint32_t kUsageKeyboardRightGui = kUsageKeyboard | 0xe7;
const uint32_t kUsageLedNumLock = (mojom::kPageLed << kUsageIdSizeBits) | 0x01;
const uint32_t kUsageLedCapsLock = (mojom::kPageLed << kUsageIdSizeBits) | 0x02;
const uint32_t kUsageLedScrollLock =
    (mojom::kPageLed << kUsageIdSizeBits) | 0x03;
const uint32_t kUsageLedCompose = (mojom::kPageLed << kUsageIdSizeBits) | 0x04;
const uint32_t kUsageLedKana = (mojom::kPageLed << kUsageIdSizeBits) | 0x05;
const uint32_t kUsageMonitorControl =
    (mojom::kPageMonitor0 << kUsageIdSizeBits) | 0x01;
const uint32_t kUsageMonitorEdidInfo =
    (mojom::kPageMonitor0 << kUsageIdSizeBits) | 0x02;
const uint32_t kUsageMonitorVdifInfo =
    (mojom::kPageMonitor0 << kUsageIdSizeBits) | 0x03;
const uint32_t kUsageMonitorBrightness =
    (mojom::kPageMonitor2 << kUsageIdSizeBits) | 0x10;
const uint32_t kUsageMonitorContrast =
    (mojom::kPageMonitor2 << kUsageIdSizeBits) | 0x12;
const uint32_t kUsageMonitorRedVideoGain =
    (mojom::kPageMonitor2 << kUsageIdSizeBits) | 0x16;
const uint32_t kUsageMonitorGreenVideoGain =
    (mojom::kPageMonitor2 << kUsageIdSizeBits) | 0x18;
const uint32_t kUsageMonitorBlueVideoGain =
    (mojom::kPageMonitor2 << kUsageIdSizeBits) | 0x1a;
const uint32_t kUsageMonitorHorizontalPosition =
    (mojom::kPageMonitor2 << kUsageIdSizeBits) | 0x20;
const uint32_t kUsageMonitorHorizontalSize =
    (mojom::kPageMonitor2 << kUsageIdSizeBits) | 0x22;
const uint32_t kUsageMonitorVerticalPosition =
    (mojom::kPageMonitor2 << kUsageIdSizeBits) | 0x30;
const uint32_t kUsageMonitorVerticalSize =
    (mojom::kPageMonitor2 << kUsageIdSizeBits) | 0x32;
const uint32_t kUsageMonitorTrapezoidalDistortion =
    (mojom::kPageMonitor2 << kUsageIdSizeBits) | 0x42;
const uint32_t kUsageMonitorTilt =
    (mojom::kPageMonitor2 << kUsageIdSizeBits) | 0x44;
const uint32_t kUsageMonitorRedVideoBlackLevel =
    (mojom::kPageMonitor2 << kUsageIdSizeBits) | 0x6c;
const uint32_t kUsageMonitorGreenVideoBlackLevel =
    (mojom::kPageMonitor2 << kUsageIdSizeBits) | 0x6e;
const uint32_t kUsageMonitorBlueVideoBlackLevel =
    (mojom::kPageMonitor2 << kUsageIdSizeBits) | 0x70;
const uint32_t kUsagePidSetEffectReport =
    (mojom::kPagePidPage << kUsageIdSizeBits) | 0x21;
const uint32_t kUsagePidDuration =
    (mojom::kPagePidPage << kUsageIdSizeBits) | 0x50;
const uint32_t kUsagePidMagnitude =
    (mojom::kPagePidPage << kUsageIdSizeBits) | 0x70;
const uint32_t kUsagePidLoopCount =
    (mojom::kPagePidPage << kUsageIdSizeBits) | 0x7c;
const uint32_t kUsagePidDCEnableActuators =
    (mojom::kPagePidPage << kUsageIdSizeBits) | 0x97;
const uint32_t kUsagePidStartDelay =
    (mojom::kPagePidPage << kUsageIdSizeBits) | 0xa7;
const uint32_t kUsageSimulationAccelerator =
    (mojom::kPageSimulation << kUsageIdSizeBits) | 0xc4;
const uint32_t kUsageSimulationBrake =
    (mojom::kPageSimulation << kUsageIdSizeBits) | 0xc5;
const uint32_t kUsageVendor = mojom::kPageVendor << kUsageIdSizeBits;
const uint32_t kUsageVendor02 = kPageVendor02 << kUsageIdSizeBits;
const uint32_t kUsageVendor05 = kPageVendor05 << kUsageIdSizeBits;
const uint32_t kUsageVendor80 = kPageVendor80 << kUsageIdSizeBits;

// Report item tags.
const HidReportDescriptorItem::Tag kInput = HidReportDescriptorItem::kTagInput;
const HidReportDescriptorItem::Tag kOutput =
    HidReportDescriptorItem::kTagOutput;
const HidReportDescriptorItem::Tag kFeature =
    HidReportDescriptorItem::kTagFeature;
const HidReportDescriptorItem::CollectionType kCollectionTypeApplication =
    HidReportDescriptorItem::kCollectionTypeApplication;
const HidReportDescriptorItem::CollectionType kCollectionTypeLogical =
    HidReportDescriptorItem::kCollectionTypeLogical;
const HidReportDescriptorItem::CollectionType kCollectionTypePhysical =
    kCollectionTypePhysical;

}  // namespace

class HidReportDescriptorTest : public testing::Test {
 protected:
  using HidUsageAndPage = mojom::HidUsageAndPage;
  using HidCollectionInfo = mojom::HidCollectionInfo;
  using HidCollectionInfoPtr = mojom::HidCollectionInfoPtr;

  void TearDown() override {
    descriptor_ = nullptr;
    expected_collection_infos_.clear();
    expected_collections_.clear();
    report_id_ = 0;
    globals_ = HidItemStateTable::HidGlobalItemState();
  }

 public:
  // Add a top-level collection to |expected_collection_infos_|.
  void AddTopCollectionInfo(HidCollectionInfoPtr collection_info) {
    expected_collection_infos_.push_back(std::move(collection_info));
  }

  // Create a new collection and append it to |expected_collections_|.
  HidCollection* AddTopCollection(
      uint32_t usage,
      HidReportDescriptorItem::CollectionType collection_type) {
    uint16_t usage_page = (usage >> kUsageIdSizeBits) & kUsageIdMask;
    usage = usage & kUsageIdMask;
    expected_collections_.push_back(std::make_unique<HidCollection>(
        nullptr, usage_page, usage, static_cast<uint32_t>(collection_type)));
    return expected_collections_.back().get();
  }

  // Create a new collection as a child of |parent|.
  HidCollection* AddChild(
      HidCollection* parent,
      uint32_t usage,
      HidReportDescriptorItem::CollectionType collection_type) {
    uint16_t usage_page = (usage >> kUsageIdSizeBits) & kUsageIdMask;
    usage = usage & kUsageIdMask;
    parent->AddChildForTesting(std::make_unique<HidCollection>(
        parent, usage_page, usage, static_cast<uint32_t>(collection_type)));
    return parent->GetChildren().back().get();
  }

  // Set the |report_id|. Subsequent report items will be appended to the report
  // with this ID.
  void SetReportId(uint8_t report_id) { report_id_ = report_id; }

  // Set the |unit| and |unit_exponent|. Subsequent report items will inherit
  // these values.
  void SetUnitAndUnitExponent(uint32_t unit, uint32_t unit_exponent) {
    globals_.unit = unit;
    globals_.unit_exponent = unit_exponent;
  }

  // Set the logical and physical minimums and maximums. Subsequent report items
  // will inherit these values.
  void SetLogicalAndPhysicalBounds(uint32_t logical_minimum,
                                   uint32_t logical_maximum,
                                   uint32_t physical_minimum,
                                   uint32_t physical_maximum) {
    globals_.logical_minimum = int32_t{logical_minimum};
    globals_.logical_maximum = int32_t{logical_maximum};
    globals_.physical_minimum = int32_t{physical_minimum};
    globals_.physical_maximum = int32_t{physical_maximum};
  }

  // Set the |report_size| in bits, and the |report_count|. Subsequent report
  // items will inherit these values.
  void SetReportSizeAndCount(uint32_t report_size, uint32_t report_count) {
    globals_.report_size = report_size;
    globals_.report_count = report_count;
  }

  // Add a report item with a size and count but no usage value.
  void AddReportConstant(HidCollection* collection,
                         HidReportDescriptorItem::Tag tag,
                         uint32_t report_info) {
    HidItemStateTable state;
    state.global_stack.push_back(globals_);
    state.report_id = report_id_;
    for (const HidCollection* c = collection; c; c = c->GetParent())
      const_cast<HidCollection*>(c)->AddReportItem(tag, report_info, state);
  }

  // Add a report item for one or more usages with the same size. The size of
  // |usage_ids| is not required to be the same as the report count.
  void AddReportItem(HidCollection* collection,
                     HidReportDescriptorItem::Tag tag,
                     uint32_t report_info,
                     const std::vector<uint32_t>& usage_ids) {
    HidItemStateTable state;
    state.global_stack.push_back(globals_);
    state.report_id = report_id_;
    state.local.usages = usage_ids;
    for (const HidCollection* c = collection; c; c = c->GetParent())
      const_cast<HidCollection*>(c)->AddReportItem(tag, report_info, state);
  }

  // Add a report item for a range of usages. The item may be a variable or an
  // array.
  void AddReportItemRange(HidCollection* collection,
                          HidReportDescriptorItem::Tag tag,
                          uint32_t report_info,
                          uint32_t usage_minimum,
                          uint32_t usage_maximum) {
    HidItemStateTable state;
    state.global_stack.push_back(globals_);
    state.report_id = report_id_;
    state.local.usage_minimum = usage_minimum;
    state.local.usage_maximum = usage_maximum;
    for (const HidCollection* c = collection; c; c = c->GetParent())
      const_cast<HidCollection*>(c)->AddReportItem(tag, report_info, state);
  }

  void ValidateDetails(
      const bool expected_has_report_id,
      const size_t expected_max_input_report_size,
      const size_t expected_max_output_report_size,
      const size_t expected_max_feature_report_size,
      const uint8_t* bytes,
      size_t size) {
    descriptor_ = std::make_unique<HidReportDescriptor>(
        std::vector<uint8_t>(bytes, bytes + size));
    std::vector<HidCollectionInfoPtr> actual_collection_infos;
    bool actual_has_report_id;
    size_t actual_max_input_report_size;
    size_t actual_max_output_report_size;
    size_t actual_max_feature_report_size;
    descriptor_->GetDetails(&actual_collection_infos, &actual_has_report_id,
                            &actual_max_input_report_size,
                            &actual_max_output_report_size,
                            &actual_max_feature_report_size);

    ASSERT_EQ(expected_collection_infos_.size(),
              actual_collection_infos.size());
    auto actual_info_iter = actual_collection_infos.begin();
    auto expected_info_iter = expected_collection_infos_.begin();
    while (expected_info_iter != expected_collection_infos_.end() &&
           actual_info_iter != actual_collection_infos.end()) {
      const HidCollectionInfoPtr& expected_info = *expected_info_iter;
      const HidCollectionInfoPtr& actual_info = *actual_info_iter;
      ASSERT_EQ(expected_info->usage->usage_page,
                actual_info->usage->usage_page);
      ASSERT_EQ(expected_info->usage->usage, actual_info->usage->usage);
      ASSERT_THAT(actual_info->report_ids,
                  testing::ContainerEq(expected_info->report_ids));
      ++expected_info_iter;
      ++actual_info_iter;
    }
    ASSERT_EQ(expected_has_report_id, actual_has_report_id);
    ASSERT_EQ(expected_max_input_report_size, actual_max_input_report_size);
    ASSERT_EQ(expected_max_output_report_size, actual_max_output_report_size);
    ASSERT_EQ(expected_max_feature_report_size, actual_max_feature_report_size);
  }

  static void ValidateReportItem(const HidReportItem& expected,
                                 const HidReportItem& actual) {
    uint32_t expected_report_info =
        *reinterpret_cast<const uint32_t*>(&expected.GetReportInfo());
    uint32_t actual_report_info =
        *reinterpret_cast<const uint32_t*>(&actual.GetReportInfo());
    ASSERT_EQ(expected.GetTag(), actual.GetTag());
    ASSERT_EQ(expected_report_info, actual_report_info);
    ASSERT_EQ(expected.GetReportId(), actual.GetReportId());
    ASSERT_THAT(actual.GetUsages(), testing::ContainerEq(expected.GetUsages()));
    ASSERT_EQ(expected.GetUsageMinimum(), actual.GetUsageMinimum());
    ASSERT_EQ(expected.GetUsageMaximum(), actual.GetUsageMaximum());
    ASSERT_EQ(expected.GetDesignatorMinimum(), actual.GetDesignatorMinimum());
    ASSERT_EQ(expected.GetDesignatorMaximum(), actual.GetDesignatorMaximum());
    ASSERT_EQ(expected.GetStringMinimum(), actual.GetStringMinimum());
    ASSERT_EQ(expected.GetStringMaximum(), actual.GetStringMaximum());
    ASSERT_EQ(expected.GetLogicalMinimum(), actual.GetLogicalMinimum());
    ASSERT_EQ(expected.GetLogicalMaximum(), actual.GetLogicalMaximum());
    ASSERT_EQ(expected.GetPhysicalMinimum(), actual.GetPhysicalMinimum());
    ASSERT_EQ(expected.GetPhysicalMaximum(), actual.GetPhysicalMaximum());
    ASSERT_EQ(expected.GetUnitExponent(), actual.GetUnitExponent());
    ASSERT_EQ(expected.GetUnit(), actual.GetUnit());
    ASSERT_EQ(expected.GetReportSize(), actual.GetReportSize());
    ASSERT_EQ(expected.GetReportCount(), actual.GetReportCount());
  }

  static void ValidateReportMap(const HidReportMap& expected_reports,
                                const HidReportMap& actual_reports) {
    for (const auto& expected_entry : expected_reports) {
      auto find_it = actual_reports.find(expected_entry.first);
      ASSERT_NE(find_it, actual_reports.end());
      const auto& expected_report = expected_entry.second;
      const auto& actual_report = find_it->second;
      ASSERT_EQ(expected_report.size(), actual_report.size());
      auto expected_item_iter = expected_report.begin();
      auto actual_item_iter = actual_report.begin();
      while (expected_item_iter != expected_report.end() &&
             actual_item_iter != actual_report.end()) {
        ValidateReportItem(**expected_item_iter, **actual_item_iter);
        ++expected_item_iter;
        ++actual_item_iter;
      }
    }
    ASSERT_EQ(expected_reports.size(), actual_reports.size());
  }

  static void ValidateLinkCollection(const HidCollection* expected_collection,
                                     const HidCollection* actual_collection) {
    ASSERT_EQ(expected_collection->GetUsagePage(),
              actual_collection->GetUsagePage());
    ASSERT_EQ(expected_collection->GetUsage(), actual_collection->GetUsage());
    ASSERT_EQ(expected_collection->GetCollectionType(),
              actual_collection->GetCollectionType());
    ValidateReportMap(expected_collection->GetInputReports(),
                      actual_collection->GetInputReports());
    ValidateReportMap(expected_collection->GetOutputReports(),
                      actual_collection->GetOutputReports());
    ValidateReportMap(expected_collection->GetFeatureReports(),
                      actual_collection->GetFeatureReports());
    const auto& expected_children = expected_collection->GetChildren();
    const auto& actual_children = actual_collection->GetChildren();
    auto expected_child_iter = expected_children.begin();
    auto actual_child_iter = actual_children.begin();
    while (expected_child_iter != expected_children.end() &&
           actual_child_iter != actual_children.end()) {
      const HidCollection* expected_child = expected_child_iter->get();
      const HidCollection* actual_child = actual_child_iter->get();
      ASSERT_EQ(actual_child->GetParent(), actual_collection);
      ValidateLinkCollection(expected_child, actual_child);
      ++expected_child_iter;
      ++actual_child_iter;
    }
    ASSERT_EQ(expected_children.size(), actual_children.size());
  }

  void ValidateCollections(const uint8_t* bytes, size_t size) {
    descriptor_ = std::make_unique<HidReportDescriptor>(
        std::vector<uint8_t>(bytes, bytes + size));
    const auto& actual_collections = descriptor_->collections();
    auto actual_collection_iter = actual_collections.begin();
    auto expected_collection_iter = expected_collections_.begin();
    while (expected_collection_iter != expected_collections_.end() &&
           actual_collection_iter != actual_collections.end()) {
      ValidateLinkCollection(expected_collection_iter->get(),
                             actual_collection_iter->get());
      ++expected_collection_iter;
      ++actual_collection_iter;
    }
    ASSERT_EQ(expected_collections_.size(), actual_collections.size());
  }

 private:
  std::unique_ptr<HidReportDescriptor> descriptor_;
  std::vector<HidCollectionInfoPtr> expected_collection_infos_;
  HidCollectionVector expected_collections_;
  uint8_t report_id_ = 0;
  HidItemStateTable::HidGlobalItemState globals_;
};

TEST_F(HidReportDescriptorTest, ValidateDetails_Digitizer) {
  auto digitizer = HidCollectionInfo::New();
  digitizer->usage = HidUsageAndPage::New(0x01, mojom::kPageDigitizer);
  ASSERT_EQ(IsProtected(*digitizer->usage), false);
  digitizer->report_ids = {0x01, 0x02, 0x03};
  AddTopCollectionInfo(std::move(digitizer));
  ValidateDetails(true, 6, 0, 0, kDigitizer, kDigitizerSize);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_Digitizer) {
  auto* top =
      AddTopCollection(kUsageDigitizerDigitizer, kCollectionTypeApplication);
  auto* puck = AddChild(top, kUsageDigitizerPuck, kCollectionTypePhysical);
  SetReportId(0x01);
  SetLogicalAndPhysicalBounds(0, 12000, 0, 12);
  SetUnitAndUnitExponent(kUnitInch, 0);
  SetReportSizeAndCount(16, 2);
  AddReportItem(puck, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopX, kUsageGenericDesktopY});
  SetLogicalAndPhysicalBounds(0, 1, 0, 1);
  SetUnitAndUnitExponent(0, 0);
  SetReportSizeAndCount(1, 3);
  AddReportItem(puck, kInput, kAbsoluteVariable,
                {kUsageDigitizerInRange, kUsageDigitizerBarrelSwitch,
                 kUsageDigitizerTipSwitch});
  SetReportSizeAndCount(5, 1);
  AddReportConstant(puck, kInput, kConstant);
  SetReportId(0x02);
  auto* stylus_up =
      AddChild(top, kUsageDigitizerStylus, kCollectionTypePhysical);
  SetLogicalAndPhysicalBounds(0, 12000, 0, 12);
  SetUnitAndUnitExponent(kUnitInch, 0);
  SetReportSizeAndCount(16, 2);
  AddReportItem(stylus_up, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopX, kUsageGenericDesktopY});
  SetLogicalAndPhysicalBounds(0, 1, 0, 1);
  SetUnitAndUnitExponent(0, 0);
  SetReportSizeAndCount(1, 2);
  AddReportItem(stylus_up, kInput, kAbsoluteVariable, {kUsageDigitizerInRange});
  SetLogicalAndPhysicalBounds(0, 16, 0, 1);
  SetReportSizeAndCount(5, 2);
  AddReportItemRange(stylus_up, kInput, kNullableArray, kUsageButton,
                     kUsageButton + 16);
  SetReportSizeAndCount(2, 2);
  AddReportConstant(stylus_up, kInput, kConstantArray);
  SetReportId(0x03);
  auto* stylus_down =
      AddChild(top, kUsageDigitizerStylus, kCollectionTypePhysical);
  SetLogicalAndPhysicalBounds(0, 12000, 0, 12);
  SetUnitAndUnitExponent(kUnitInch, 0);
  SetReportSizeAndCount(16, 2);
  AddReportItem(stylus_down, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopX, kUsageGenericDesktopY});
  SetLogicalAndPhysicalBounds(0, 1, 0, 1);
  SetUnitAndUnitExponent(0, 0);
  SetReportSizeAndCount(1, 2);
  AddReportItem(stylus_down, kInput, kAbsoluteVariable,
                {kUsageDigitizerInRange, kUsageDigitizerBarrelSwitch});
  SetReportSizeAndCount(1, 6);
  AddReportConstant(stylus_down, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 127, 0, 45);
  SetUnitAndUnitExponent(kUnitNewton, 4);
  SetReportSizeAndCount(8, 1);
  AddReportItem(stylus_down, kInput, kNonLinearVariable,
                {kUsageDigitizerTipPressure});
  ValidateCollections(kDigitizer, kDigitizerSize);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_Keyboard) {
  auto keyboard = HidCollectionInfo::New();
  keyboard->usage = HidUsageAndPage::New(mojom::kGenericDesktopKeyboard,
                                         mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*keyboard->usage), true);
  AddTopCollectionInfo(std::move(keyboard));
  ValidateDetails(false, 8, 1, 0, kKeyboard, kKeyboardSize);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_Keyboard) {
  auto* top = AddTopCollection(kUsageGenericDesktopKeyboard,
                               kCollectionTypeApplication);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(1, 8);
  AddReportItemRange(top, kInput, kAbsoluteVariable, kUsageKeyboardLeftControl,
                     kUsageKeyboardRightGui);
  SetReportSizeAndCount(8, 1);
  AddReportConstant(top, kInput, kConstant);
  SetReportSizeAndCount(1, 5);
  AddReportItemRange(top, kOutput, kAbsoluteVariable, kUsageLedNumLock,
                     kUsageLedKana);
  SetReportSizeAndCount(3, 1);
  AddReportConstant(top, kOutput, kConstant);
  SetLogicalAndPhysicalBounds(0, 101, 0, 0);
  SetReportSizeAndCount(8, 6);
  AddReportItemRange(top, kInput, kNonNullableArray, kUsageKeyboard,
                     kUsageKeyboardApplication);
  ValidateCollections(kKeyboard, kKeyboardSize);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_Monitor) {
  auto monitor = HidCollectionInfo::New();
  monitor->usage = HidUsageAndPage::New(0x01, mojom::kPageMonitor0);
  ASSERT_EQ(IsProtected(*monitor->usage), false);
  monitor->report_ids = {0x01, 0x02, 0x03, 0x04, 0x05};
  AddTopCollectionInfo(std::move(monitor));
  ValidateDetails(true, 0, 0, 243, kMonitor, kMonitorSize);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_Monitor) {
  auto* top =
      AddTopCollection(kUsageMonitorControl, kCollectionTypeApplication);
  SetReportId(0x01);
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  SetReportSizeAndCount(8, 128);
  AddReportItem(top, kFeature, kBufferedBytes, {kUsageMonitorEdidInfo});
  SetReportId(0x02);
  SetReportSizeAndCount(8, 243);
  AddReportItem(top, kFeature, kBufferedBytes, {kUsageMonitorVdifInfo});
  SetReportId(0x03);
  SetUnitAndUnitExponent(kUnitCandela, 0x0e);
  SetReportSizeAndCount(16, 1);
  SetLogicalAndPhysicalBounds(0, 200, 0, 0);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageMonitorBrightness});
  SetReportId(0x04);
  SetLogicalAndPhysicalBounds(0, 100, 0, 0);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageMonitorContrast});
  SetReportSizeAndCount(16, 6);
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  AddReportItem(
      top, kFeature, kAbsoluteVariable,
      {kUsageMonitorRedVideoGain, kUsageMonitorGreenVideoGain,
       kUsageMonitorBlueVideoGain, kUsageMonitorRedVideoBlackLevel,
       kUsageMonitorGreenVideoBlackLevel, kUsageMonitorBlueVideoBlackLevel});
  SetReportId(0x05);
  SetLogicalAndPhysicalBounds(0, 127, 0, 0);
  AddReportItem(top, kFeature, kAbsoluteVariable,
                {kUsageMonitorHorizontalPosition, kUsageMonitorHorizontalSize,
                 kUsageMonitorVerticalPosition, kUsageMonitorVerticalSize,
                 kUsageMonitorTrapezoidalDistortion, kUsageMonitorTilt});
  ValidateCollections(kMonitor, kMonitorSize);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_Mouse) {
  auto mouse = HidCollectionInfo::New();
  mouse->usage = HidUsageAndPage::New(mojom::kGenericDesktopMouse,
                                      mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*mouse->usage), true);
  AddTopCollectionInfo(std::move(mouse));
  ValidateDetails(false, 3, 0, 0, kMouse, kMouseSize);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_Mouse) {
  auto* top =
      AddTopCollection(kUsageGenericDesktopMouse, kCollectionTypeApplication);
  auto* physical =
      AddChild(top, kUsageGenericDesktopPointer, kCollectionTypePhysical);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(1, 3);
  AddReportItemRange(physical, kInput, kAbsoluteVariable, kUsageButton + 1,
                     kUsageButton + 3);
  SetReportSizeAndCount(5, 1);
  AddReportConstant(physical, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0x81, 0x7f, 0, 0);
  SetReportSizeAndCount(8, 2);
  AddReportItem(physical, kInput, kRelativeVariable,
                {kUsageGenericDesktopX, kUsageGenericDesktopY});
  ValidateCollections(kMouse, kMouseSize);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_LogitechUnifyingReceiver) {
  auto hidpp_short = HidCollectionInfo::New();
  hidpp_short->usage = HidUsageAndPage::New(0x01, mojom::kPageVendor);
  ASSERT_EQ(IsProtected(*hidpp_short->usage), false);
  hidpp_short->report_ids = {0x10};
  auto hidpp_long = HidCollectionInfo::New();
  hidpp_long->usage = HidUsageAndPage::New(0x02, mojom::kPageVendor);
  ASSERT_EQ(IsProtected(*hidpp_long->usage), false);
  hidpp_long->report_ids = {0x11};
  auto hidpp_dj = HidCollectionInfo::New();
  hidpp_dj->usage = HidUsageAndPage::New(0x04, mojom::kPageVendor);
  ASSERT_EQ(IsProtected(*hidpp_dj->usage), false);
  hidpp_dj->report_ids = {0x20, 0x21};
  AddTopCollectionInfo(std::move(hidpp_short));
  AddTopCollectionInfo(std::move(hidpp_long));
  AddTopCollectionInfo(std::move(hidpp_dj));
  ValidateDetails(true, 31, 31, 0, kLogitechUnifyingReceiver,
                  kLogitechUnifyingReceiverSize);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_LogitechUnifyingReceiver) {
  auto* short_collection =
      AddTopCollection(kUsageVendor + 0x01, kCollectionTypeApplication);
  SetReportId(0x10);
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  SetReportSizeAndCount(8, 6);
  AddReportItem(short_collection, kInput, kNonNullableArray,
                {kUsageVendor + 0x01});
  AddReportItem(short_collection, kOutput, kNonNullableArray,
                {kUsageVendor + 0x01});
  auto* long_collection =
      AddTopCollection(kUsageVendor + 0x02, kCollectionTypeApplication);
  SetReportId(0x11);
  SetReportSizeAndCount(8, 19);
  AddReportItem(long_collection, kInput, kNonNullableArray,
                {kUsageVendor + 0x02});
  AddReportItem(long_collection, kOutput, kNonNullableArray,
                {kUsageVendor + 0x02});
  auto* dj_collection =
      AddTopCollection(kUsageVendor + 0x04, kCollectionTypeApplication);
  SetReportId(0x20);
  SetReportSizeAndCount(8, 14);
  AddReportItem(dj_collection, kInput, kNonNullableArray,
                {kUsageVendor + 0x41});
  AddReportItem(dj_collection, kOutput, kNonNullableArray,
                {kUsageVendor + 0x41});
  SetReportId(0x21);
  SetReportSizeAndCount(8, 31);
  AddReportItem(dj_collection, kInput, kNonNullableArray,
                {kUsageVendor + 0x42});
  AddReportItem(dj_collection, kOutput, kNonNullableArray,
                {kUsageVendor + 0x42});
  ValidateCollections(kLogitechUnifyingReceiver, kLogitechUnifyingReceiverSize);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_SonyDualshock3) {
  auto top_info = HidCollectionInfo::New();
  top_info->usage = HidUsageAndPage::New(mojom::kGenericDesktopJoystick,
                                         mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*top_info->usage), false);
  top_info->report_ids = {0x01, 0x02, 0xee, 0xef};
  AddTopCollectionInfo(std::move(top_info));
  ValidateDetails(true, 48, 48, 48, kSonyDualshock3, kSonyDualshock3Size);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_SonyDualshock3) {
  auto* top = AddTopCollection(kUsageGenericDesktopJoystick,
                               kCollectionTypeApplication);
  auto* joystick = AddChild(top, kUsageGenericDesktop, kCollectionTypeLogical);
  SetReportId(0x01);
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  SetReportSizeAndCount(8, 1);
  AddReportConstant(joystick, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 1, 0, 1);
  SetReportSizeAndCount(1, 19);
  AddReportItemRange(joystick, kInput, kAbsoluteVariable, kUsageButton + 1,
                     kUsageButton + 19);
  SetReportSizeAndCount(1, 13);
  AddReportConstant(joystick, kInput, kConstant);
  auto* stick_axes =
      AddChild(joystick, kUsageGenericDesktopPointer, kCollectionTypePhysical);
  SetLogicalAndPhysicalBounds(0, 255, 0, 255);
  SetReportSizeAndCount(8, 4);
  AddReportItem(stick_axes, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopX, kUsageGenericDesktopY,
                 kUsageGenericDesktopZ, kUsageGenericDesktopRz});
  SetReportSizeAndCount(8, 39);
  AddReportItem(joystick, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopPointer});
  SetReportSizeAndCount(8, 48);
  AddReportItem(joystick, kOutput, kAbsoluteVariable,
                {kUsageGenericDesktopPointer});
  AddReportItem(joystick, kFeature, kAbsoluteVariable,
                {kUsageGenericDesktopPointer});
  auto* report_02_collection =
      AddChild(top, kUsageGenericDesktop, kCollectionTypeLogical);
  SetReportId(0x02);
  AddReportItem(report_02_collection, kFeature, kAbsoluteVariable,
                {kUsageGenericDesktopPointer});
  auto* report_ee_collection =
      AddChild(top, kUsageGenericDesktop, kCollectionTypeLogical);
  SetReportId(0xee);
  AddReportItem(report_ee_collection, kFeature, kAbsoluteVariable,
                {kUsageGenericDesktopPointer});
  auto* report_ef_collection =
      AddChild(top, kUsageGenericDesktop, kCollectionTypeLogical);
  SetReportId(0xef);
  AddReportItem(report_ef_collection, kFeature, kAbsoluteVariable,
                {kUsageGenericDesktopPointer});
  ValidateCollections(kSonyDualshock3, kSonyDualshock3Size);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_SonyDualshock4) {
  auto top_info = HidCollectionInfo::New();
  top_info->usage = HidUsageAndPage::New(mojom::kGenericDesktopGamePad,
                                         mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*top_info->usage), false);
  top_info->report_ids = {0x01, 0x05, 0x04, 0x02, 0x08, 0x10, 0x11, 0x12, 0x13,
                          0x14, 0x15, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86,
                          0x87, 0x88, 0x89, 0x90, 0x91, 0x92, 0x93, 0xa0, 0xa1,
                          0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xf0, 0xf1, 0xf2, 0xa7,
                          0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0};
  AddTopCollectionInfo(std::move(top_info));
  ValidateDetails(true, 63, 31, 63, kSonyDualshock4, kSonyDualshock4Size);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_SonyDualshock4) {
  auto* top =
      AddTopCollection(kUsageGenericDesktopGamePad, kCollectionTypeApplication);
  SetReportId(0x01);
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  SetReportSizeAndCount(8, 4);
  AddReportItem(top, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopX, kUsageGenericDesktopY,
                 kUsageGenericDesktopZ, kUsageGenericDesktopRz});
  SetLogicalAndPhysicalBounds(0, 7, 0, 315);
  SetUnitAndUnitExponent(kUnitDegrees, 0);
  SetReportSizeAndCount(4, 1);
  AddReportItem(top, kInput, kNullableAbsoluteVariable,
                {kUsageGenericDesktopHatSwitch});
  SetLogicalAndPhysicalBounds(0, 1, 0, 315);
  SetUnitAndUnitExponent(0, 0);
  SetReportSizeAndCount(1, 14);
  AddReportItemRange(top, kInput, kAbsoluteVariable, kUsageButton + 1,
                     kUsageButton + 14);
  SetLogicalAndPhysicalBounds(0, 127, 0, 315);
  SetReportSizeAndCount(6, 1);
  AddReportItem(top, kInput, kAbsoluteVariable, {kUsageVendor + 0x20});
  SetLogicalAndPhysicalBounds(0, 255, 0, 315);
  SetReportSizeAndCount(8, 2);
  AddReportItem(top, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopRx, kUsageGenericDesktopRy});
  SetReportSizeAndCount(8, 54);
  AddReportItem(top, kInput, kAbsoluteVariable, {kUsageVendor + 0x21});
  SetReportId(0x05);
  SetReportSizeAndCount(8, 31);
  AddReportItem(top, kOutput, kAbsoluteVariable, {kUsageVendor + 0x22});
  SetReportId(0x04);
  SetReportSizeAndCount(8, 36);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor + 0x23});
  SetReportId(0x02);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor + 0x24});
  SetReportId(0x08);
  SetReportSizeAndCount(8, 3);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor + 0x25});
  SetReportId(0x10);
  SetReportSizeAndCount(8, 4);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor + 0x26});
  SetReportId(0x11);
  SetReportSizeAndCount(8, 2);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor + 0x27});
  SetReportId(0x12);
  SetReportSizeAndCount(8, 15);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor02 + 0x21});
  SetReportId(0x13);
  SetReportSizeAndCount(8, 22);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor02 + 0x22});
  SetReportId(0x14);
  SetReportSizeAndCount(8, 16);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor05 + 0x20});
  SetReportId(0x15);
  SetReportSizeAndCount(8, 44);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor05 + 0x21});
  SetReportId(0x80);
  SetReportSizeAndCount(8, 6);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x20});
  SetReportId(0x81);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x21});
  SetReportId(0x82);
  SetReportSizeAndCount(8, 5);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x22});
  SetReportId(0x83);
  SetReportSizeAndCount(8, 1);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x23});
  SetReportId(0x84);
  SetReportSizeAndCount(8, 4);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x24});
  SetReportId(0x85);
  SetReportSizeAndCount(8, 6);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x25});
  SetReportId(0x86);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x26});
  SetReportId(0x87);
  SetReportSizeAndCount(8, 35);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x27});
  SetReportId(0x88);
  SetReportSizeAndCount(8, 34);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x28});
  SetReportId(0x89);
  SetReportSizeAndCount(8, 2);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x29});
  SetReportId(0x90);
  SetReportSizeAndCount(8, 5);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x30});
  SetReportId(0x91);
  SetReportSizeAndCount(8, 3);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x31});
  SetReportId(0x92);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x32});
  SetReportId(0x93);
  SetReportSizeAndCount(8, 12);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x33});
  SetReportId(0xa0);
  SetReportSizeAndCount(8, 6);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x40});
  SetReportId(0xa1);
  SetReportSizeAndCount(8, 1);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x41});
  SetReportId(0xa2);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x42});
  SetReportId(0xa3);
  SetReportSizeAndCount(8, 48);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x43});
  SetReportId(0xa4);
  SetReportSizeAndCount(8, 13);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x44});
  SetReportId(0xa5);
  SetReportSizeAndCount(8, 21);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x45});
  SetReportId(0xa6);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x46});
  SetReportId(0xf0);
  SetReportSizeAndCount(8, 63);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x47});
  SetReportId(0xf1);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x48});
  SetReportId(0xf2);
  SetReportSizeAndCount(8, 15);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x49});
  SetReportId(0xa7);
  SetReportSizeAndCount(8, 1);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x4a});
  SetReportId(0xa8);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x4b});
  SetReportId(0xa9);
  SetReportSizeAndCount(8, 8);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x4c});
  SetReportId(0xaa);
  SetReportSizeAndCount(8, 1);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x4e});
  SetReportId(0xab);
  SetReportSizeAndCount(8, 57);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x4f});
  SetReportId(0xac);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x50});
  SetReportId(0xad);
  SetReportSizeAndCount(8, 11);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x51});
  SetReportId(0xae);
  SetReportSizeAndCount(8, 1);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x52});
  SetReportId(0xaf);
  SetReportSizeAndCount(8, 2);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x53});
  SetReportId(0xb0);
  SetReportSizeAndCount(8, 63);
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor80 + 0x54});
  ValidateCollections(kSonyDualshock4, kSonyDualshock4Size);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_XboxWirelessController) {
  auto top_info = HidCollectionInfo::New();
  top_info->usage = HidUsageAndPage::New(mojom::kGenericDesktopGamePad,
                                         mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*top_info->usage), false);
  top_info->report_ids = {0x01, 0x02, 0x03, 0x04};
  AddTopCollectionInfo(std::move(top_info));
  ValidateDetails(true, 15, 8, 0, kMicrosoftXboxWirelessController,
                  kMicrosoftXboxWirelessControllerSize);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_XboxWirelessController) {
  auto* top =
      AddTopCollection(kUsageGenericDesktopGamePad, kCollectionTypeApplication);
  SetReportId(0x01);
  auto* left_stick =
      AddChild(top, kUsageGenericDesktopPointer, kCollectionTypePhysical);
  SetLogicalAndPhysicalBounds(0, 0xffff, 0, 0);
  SetReportSizeAndCount(16, 2);
  AddReportItem(left_stick, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopX, kUsageGenericDesktopY});
  auto* right_stick =
      AddChild(top, kUsageGenericDesktopPointer, kCollectionTypePhysical);
  SetLogicalAndPhysicalBounds(0, 0xffff, 0, 0);
  AddReportItem(right_stick, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopRx, kUsageGenericDesktopRy});
  SetLogicalAndPhysicalBounds(0, 1023, 0, 0);
  SetReportSizeAndCount(10, 1);
  AddReportItem(top, kInput, kAbsoluteVariable, {kUsageGenericDesktopZ});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetReportSizeAndCount(6, 1);
  AddReportConstant(top, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 1023, 0, 0);
  SetReportSizeAndCount(10, 1);
  AddReportItem(top, kInput, kAbsoluteVariable, {kUsageGenericDesktopRz});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetReportSizeAndCount(6, 1);
  AddReportConstant(top, kInput, kConstant);
  SetLogicalAndPhysicalBounds(1, 8, 0, 315);
  SetUnitAndUnitExponent(kUnitDegrees, 0);
  SetReportSizeAndCount(4, 1);
  AddReportItem(top, kInput, kNullableAbsoluteVariable,
                {kUsageGenericDesktopHatSwitch});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetUnitAndUnitExponent(0, 0);
  AddReportConstant(top, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(1, 10);
  AddReportItemRange(top, kInput, kAbsoluteVariable, kUsageButton + 1,
                     kUsageButton + 10);
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetReportSizeAndCount(6, 1);
  AddReportConstant(top, kInput, kConstant);
  SetReportId(0x02);
  auto* mode_collection =
      AddChild(top, kUsageGenericDesktopSystemControl, kCollectionTypePhysical);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(1, 1);
  AddReportItem(mode_collection, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopSystemMainMenu});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetReportSizeAndCount(7, 1);
  AddReportConstant(mode_collection, kInput, kConstant);
  SetReportId(0x03);
  auto* pid_collection =
      AddChild(top, kUsagePidSetEffectReport, kCollectionTypeLogical);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(4, 1);
  AddReportItem(pid_collection, kOutput, kAbsoluteVariable,
                {kUsagePidDCEnableActuators});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  AddReportConstant(pid_collection, kOutput, kConstant);
  SetLogicalAndPhysicalBounds(0, 100, 0, 0);
  SetReportSizeAndCount(8, 4);
  AddReportItem(pid_collection, kOutput, kAbsoluteVariable,
                {kUsagePidMagnitude});
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  SetUnitAndUnitExponent(kUnitSecond, 0x0e);
  SetReportSizeAndCount(8, 1);
  AddReportItem(pid_collection, kOutput, kAbsoluteVariable,
                {kUsagePidDuration});
  AddReportItem(pid_collection, kOutput, kAbsoluteVariable,
                {kUsagePidStartDelay});
  SetUnitAndUnitExponent(0, 0);
  AddReportItem(pid_collection, kOutput, kAbsoluteVariable,
                {kUsagePidLoopCount});
  SetReportId(0x04);
  AddReportItem(top, kInput, kAbsoluteVariable,
                {kUsageGenericDeviceBatteryStrength});
  ValidateCollections(kMicrosoftXboxWirelessController,
                      kMicrosoftXboxWirelessControllerSize);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_NintendoSwitchProController) {
  auto top_info = HidCollectionInfo::New();
  top_info->usage = HidUsageAndPage::New(mojom::kGenericDesktopJoystick,
                                         mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*top_info->usage), false);
  top_info->report_ids = {0x30, 0x21, 0x81, 0x01, 0x10, 0x80, 0x82};
  AddTopCollectionInfo(std::move(top_info));
  ValidateDetails(true, 63, 63, 0, kNintendoSwitchProController,
                  kNintendoSwitchProControllerSize);
}

TEST_F(HidReportDescriptorTest,
       ValidateCollections_NintendoSwitchProController) {
  auto* top = AddTopCollection(kUsageGenericDesktopJoystick,
                               kCollectionTypeApplication);
  SetReportId(0x30);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetUnitAndUnitExponent(0, 0);
  SetReportSizeAndCount(1, 10);
  AddReportItemRange(top, kInput, kAbsoluteVariable, kUsageButton + 1,
                     kUsageButton + 10);
  SetReportSizeAndCount(1, 4);
  AddReportItemRange(top, kInput, kAbsoluteVariable, kUsageButton + 11,
                     kUsageButton + 14);
  SetReportSizeAndCount(1, 2);
  AddReportConstant(top, kInput, kConstant);
  auto* stick_axes =
      AddChild(top, kUsageGenericDesktopPointer, kCollectionTypePhysical);
  SetLogicalAndPhysicalBounds(0, 0xffff, 0, 0);
  SetReportSizeAndCount(16, 4);
  AddReportItem(stick_axes, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopX, kUsageGenericDesktopY,
                 kUsageGenericDesktopZ, kUsageGenericDesktopRz});
  SetLogicalAndPhysicalBounds(0, 7, 0, 315);
  SetUnitAndUnitExponent(kUnitDegrees, 0);
  SetReportSizeAndCount(4, 1);
  AddReportItem(top, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopHatSwitch});
  SetLogicalAndPhysicalBounds(0, 1, 0, 315);
  SetReportSizeAndCount(1, 4);
  AddReportItemRange(top, kInput, kAbsoluteVariable, kUsageButton + 15,
                     kUsageButton + 18);
  SetReportSizeAndCount(8, 52);
  AddReportConstant(top, kInput, kConstant);
  SetReportId(0x21);
  SetReportSizeAndCount(8, 63);
  AddReportItem(top, kInput, kConstant, {kUsageVendor + 0x01});
  SetReportId(0x81);
  AddReportItem(top, kInput, kConstant, {kUsageVendor + 0x02});
  SetReportId(0x01);
  AddReportItem(top, kOutput, kVolatileConstant, {kUsageVendor + 0x03});
  SetReportId(0x10);
  AddReportItem(top, kOutput, kVolatileConstant, {kUsageVendor + 0x04});
  SetReportId(0x80);
  AddReportItem(top, kOutput, kVolatileConstant, {kUsageVendor + 0x05});
  SetReportId(0x82);
  AddReportItem(top, kOutput, kVolatileConstant, {kUsageVendor + 0x06});
  ValidateCollections(kNintendoSwitchProController,
                      kNintendoSwitchProControllerSize);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_XboxAdaptiveController) {
  auto gamepad_info = HidCollectionInfo::New();
  gamepad_info->usage = HidUsageAndPage::New(mojom::kGenericDesktopGamePad,
                                             mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*gamepad_info->usage), false);
  gamepad_info->report_ids = {0x01, 0x02, 0x03, 0x04, 0x06,
                              0x07, 0x08, 0x09, 0x0a, 0x0b};
  auto keyboard_info = HidCollectionInfo::New();
  keyboard_info->usage = HidUsageAndPage::New(mojom::kGenericDesktopKeyboard,
                                              mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*keyboard_info->usage), true);
  keyboard_info->report_ids = {0x05};
  AddTopCollectionInfo(std::move(gamepad_info));
  AddTopCollectionInfo(std::move(keyboard_info));
  ValidateDetails(true, 54, 8, 64, kMicrosoftXboxAdaptiveController,
                  kMicrosoftXboxAdaptiveControllerSize);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_XboxAdaptiveController) {
  auto* gamepad =
      AddTopCollection(kUsageGenericDesktopGamePad, kCollectionTypeApplication);
  SetReportId(0x01);
  auto* left_stick =
      AddChild(gamepad, kUsageGenericDesktopPointer, kCollectionTypePhysical);
  SetLogicalAndPhysicalBounds(0, 0xffff, 0, 0);
  SetReportSizeAndCount(16, 2);
  AddReportItem(left_stick, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopX, kUsageGenericDesktopY});
  auto* right_stick =
      AddChild(gamepad, kUsageGenericDesktopPointer, kCollectionTypePhysical);
  AddReportItem(right_stick, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopZ, kUsageGenericDesktopRz});
  SetLogicalAndPhysicalBounds(0, 1023, 0, 0);
  SetReportSizeAndCount(10, 1);
  AddReportItem(gamepad, kInput, kAbsoluteVariable, {kUsageSimulationBrake});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetReportSizeAndCount(6, 1);
  AddReportConstant(gamepad, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 1023, 0, 0);
  SetReportSizeAndCount(10, 1);
  AddReportItem(gamepad, kInput, kAbsoluteVariable,
                {kUsageSimulationAccelerator});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetReportSizeAndCount(6, 1);
  AddReportConstant(gamepad, kInput, kConstant);
  SetLogicalAndPhysicalBounds(1, 8, 0, 315);
  SetUnitAndUnitExponent(kUnitDegrees, 0);
  SetReportSizeAndCount(4, 1);
  AddReportItem(gamepad, kInput, kNullableAbsoluteVariable,
                {kUsageGenericDesktopHatSwitch});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetUnitAndUnitExponent(0, 0);
  AddReportConstant(gamepad, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(1, 15);
  AddReportItemRange(gamepad, kInput, kAbsoluteVariable, kUsageButton + 1,
                     kUsageButton + 15);
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetReportSizeAndCount(1, 1);
  AddReportConstant(gamepad, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  AddReportItem(gamepad, kInput, kAbsoluteVariable, {kUsageConsumerACBack});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetReportSizeAndCount(7, 1);
  AddReportConstant(gamepad, kInput, kConstant);
  auto* left_stick2 =
      AddChild(gamepad, kUsageGenericDesktopPointer, kCollectionTypePhysical);
  SetLogicalAndPhysicalBounds(0, 0xffff, 0, 0);
  SetReportSizeAndCount(16, 2);
  AddReportItem(left_stick2, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopVx, kUsageGenericDesktopVy});
  auto* right_stick2 =
      AddChild(gamepad, kUsageGenericDesktopPointer, kCollectionTypePhysical);
  SetLogicalAndPhysicalBounds(0, 0xffff, 0, 0);
  AddReportItem(right_stick2, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopVbrx, kUsageGenericDesktopVbry});
  SetLogicalAndPhysicalBounds(0, 1023, 0, 0);
  SetReportSizeAndCount(10, 1);
  AddReportItem(gamepad, kInput, kAbsoluteVariable, {kUsageGenericDesktopVz});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetReportSizeAndCount(6, 1);
  AddReportConstant(gamepad, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 1023, 0, 0);
  SetReportSizeAndCount(10, 1);
  AddReportItem(gamepad, kInput, kAbsoluteVariable, {kUsageGenericDesktopVbrz});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetReportSizeAndCount(6, 1);
  AddReportConstant(gamepad, kInput, kConstant);
  SetLogicalAndPhysicalBounds(1, 8, 0, 315);
  SetUnitAndUnitExponent(kUnitDegrees, 0);
  SetReportSizeAndCount(4, 1);
  AddReportItem(gamepad, kInput, kNullableAbsoluteVariable,
                {kUsageGenericDesktopDial});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetUnitAndUnitExponent(0, 0);
  AddReportConstant(gamepad, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(1, 15);
  AddReportItemRange(gamepad, kInput, kAbsoluteVariable, kUsageButton + 16,
                     kUsageButton + 30);
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetReportSizeAndCount(1, 1);
  AddReportConstant(gamepad, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  AddReportItem(gamepad, kInput, kAbsoluteVariable, {kUsageConsumerModeStep});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetReportSizeAndCount(7, 1);
  AddReportConstant(gamepad, kInput, kConstant);
  auto* consumer_collection =
      AddChild(gamepad, kUsageConsumerControl, kCollectionTypeApplication);
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  SetReportSizeAndCount(4, 1);
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0x81});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  AddReportConstant(consumer_collection, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0x84});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  AddReportConstant(consumer_collection, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  SetReportSizeAndCount(8, 1);
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0x85});
  SetReportSizeAndCount(4, 1);
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0x99});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  AddReportConstant(consumer_collection, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  SetReportSizeAndCount(8, 1);
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0x9e});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xa1});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xa2});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xa3});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xa4});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xb9});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xba});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xbb});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xbe});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xc0});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xc1});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xc2});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xc3});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xc4});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xc5});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xc6});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xc7});
  AddReportItem(consumer_collection, kInput, kAbsoluteVariable,
                {kUsageConsumer + 0xc8});
  SetReportId(0x02);
  auto* mode_collection =
      AddChild(gamepad, kUsageConsumerControl, kCollectionTypeApplication);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(1, 1);
  AddReportItem(mode_collection, kInput, kAbsoluteVariable,
                {kUsageConsumerACHome});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  SetReportSizeAndCount(7, 1);
  AddReportConstant(mode_collection, kInput, kConstant);
  SetReportId(0x03);
  auto* pid_collection =
      AddChild(gamepad, kUsagePidSetEffectReport, kCollectionTypeLogical);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(4, 1);
  AddReportItem(pid_collection, kOutput, kAbsoluteVariable,
                {kUsagePidDCEnableActuators});
  SetLogicalAndPhysicalBounds(0, 0, 0, 0);
  AddReportConstant(pid_collection, kOutput, kConstant);
  SetLogicalAndPhysicalBounds(0, 100, 0, 0);
  SetReportSizeAndCount(8, 4);
  AddReportItem(pid_collection, kOutput, kAbsoluteVariable,
                {kUsagePidMagnitude});
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  SetUnitAndUnitExponent(kUnitSecond, 0x0e);
  SetReportSizeAndCount(8, 1);
  AddReportItem(pid_collection, kOutput, kAbsoluteVariable,
                {kUsagePidDuration});
  AddReportItem(pid_collection, kOutput, kAbsoluteVariable,
                {kUsagePidStartDelay});
  SetUnitAndUnitExponent(0, 0);
  AddReportItem(pid_collection, kOutput, kAbsoluteVariable,
                {kUsagePidLoopCount});
  SetReportId(0x04);
  AddReportItem(gamepad, kInput, kAbsoluteVariable,
                {kUsageGenericDeviceBatteryStrength});
  SetReportId(0x06);
  auto* report_06_collection =
      AddChild(gamepad, kUsageVendor + 0x01, kCollectionTypeLogical);
  SetLogicalAndPhysicalBounds(0, 100, 0, 0);
  AddReportItem(report_06_collection, kFeature, kAbsoluteVariable,
                {kUsageVendor + 0x01});
  AddReportItem(report_06_collection, kFeature, kAbsoluteVariable,
                {kUsageVendor + 0x02});
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  AddReportItem(report_06_collection, kFeature, kAbsoluteVariable,
                {kUsageVendor + 0x03});
  SetReportSizeAndCount(8, 60);
  AddReportItem(report_06_collection, kFeature, kBufferedBytes,
                {kUsageVendor + 0x04});
  SetReportId(0x07);
  auto* report_07_collection =
      AddChild(gamepad, kUsageVendor + 0x02, kCollectionTypeLogical);
  SetLogicalAndPhysicalBounds(0, 100, 0, 0);
  SetReportSizeAndCount(8, 1);
  AddReportItem(report_07_collection, kFeature, kAbsoluteVariable,
                {kUsageVendor + 0x05});
  AddReportItem(report_07_collection, kFeature, kAbsoluteVariable,
                {kUsageVendor + 0x06});
  AddReportItem(report_07_collection, kFeature, kAbsoluteVariable,
                {kUsageVendor + 0x07});
  SetReportId(0x08);
  auto* report_08_collection =
      AddChild(gamepad, kUsageVendor + 0x03, kCollectionTypeLogical);
  AddReportItem(report_08_collection, kFeature, kAbsoluteVariable,
                {kUsageVendor + 0x08});
  AddReportItem(report_08_collection, kFeature, kAbsoluteVariable,
                {kUsageVendor + 0x09});
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  AddReportItem(report_08_collection, kFeature, kAbsoluteVariable,
                {kUsageVendor + 0x0a});
  SetReportId(0x09);
  auto* report_09_collection =
      AddChild(gamepad, kUsageVendor + 0x04, kCollectionTypeApplication);
  SetLogicalAndPhysicalBounds(0, 100, 0, 0);
  AddReportItem(report_09_collection, kFeature, kAbsoluteVariable,
                {kUsageVendor + 0x0b});
  AddReportItem(report_09_collection, kFeature, kAbsoluteVariable,
                {kUsageVendor + 0x0c});
  AddReportItem(report_09_collection, kFeature, kAbsoluteVariable,
                {kUsageVendor + 0x0d});
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  AddReportItem(report_09_collection, kFeature, kAbsoluteVariable,
                {kUsageVendor + 0x0e});
  SetReportSizeAndCount(8, 60);
  AddReportItem(report_09_collection, kFeature, kBufferedBytes,
                {kUsageVendor + 0x0f});
  SetReportId(0x0a);
  auto* report_0a_collection =
      AddChild(gamepad, kUsageVendor + 0x05, kCollectionTypeApplication);
  SetLogicalAndPhysicalBounds(0, 0x7fffffff, 0, 0);
  SetReportSizeAndCount(32, 1);
  AddReportItem(report_0a_collection, kInput, kAbsoluteVariable,
                {kUsageVendor + 0x10});
  AddReportItem(report_0a_collection, kInput, kAbsoluteVariable,
                {kUsageVendor + 0x11});
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  SetReportSizeAndCount(8, 2);
  AddReportItem(report_0a_collection, kInput, kAbsoluteVariable,
                {kUsageVendor + 0x12});
  SetReportSizeAndCount(8, 1);
  AddReportItem(report_0a_collection, kInput, kAbsoluteVariable,
                {kUsageVendor + 0x13});
  SetReportId(0x0b);
  auto* report_0b_collection =
      AddChild(gamepad, kUsageVendor + 0x06, kCollectionTypeLogical);
  SetLogicalAndPhysicalBounds(0, 100, 0, 0);

  AddReportItem(report_0b_collection, kFeature, kAbsoluteVariable,
                {kUsageVendor + 0x14});
  SetReportId(0x05);
  auto* keyboard = AddTopCollection(kUsageGenericDesktopKeyboard,
                                    kCollectionTypeApplication);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(1, 8);
  AddReportItemRange(keyboard, kInput, kAbsoluteVariable,
                     kUsageKeyboardLeftControl, kUsageKeyboardRightGui);
  SetReportSizeAndCount(8, 1);
  AddReportConstant(keyboard, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 101, 0, 0);
  SetReportSizeAndCount(8, 6);
  AddReportItemRange(keyboard, kInput, kNonNullableArray, kUsageKeyboard,
                     kUsageKeyboardApplication);
  ValidateCollections(kMicrosoftXboxAdaptiveController,
                      kMicrosoftXboxAdaptiveControllerSize);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_NexusPlayerController) {
  auto gamepad_info = HidCollectionInfo::New();
  gamepad_info->usage = HidUsageAndPage::New(mojom::kGenericDesktopGamePad,
                                             mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*gamepad_info->usage), false);
  gamepad_info->report_ids = {0x01, 0x02};
  auto status_info = HidCollectionInfo::New();
  status_info->usage = HidUsageAndPage::New(mojom::kGenericDesktopGamePad,
                                            mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*status_info->usage), false);
  status_info->report_ids = {0x03};
  AddTopCollectionInfo(std::move(gamepad_info));
  AddTopCollectionInfo(std::move(status_info));
  ValidateDetails(true, 8, 1, 0, kNexusPlayerController,
                  kNexusPlayerControllerSize);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_NexusPlayerController) {
  auto* gamepad =
      AddTopCollection(kUsageGenericDesktopGamePad, kCollectionTypeApplication);
  SetReportId(0x01);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(1, 11);
  AddReportItem(
      gamepad, kInput, kAbsoluteVariable,
      {kUsageButton + 1, kUsageButton + 2, kUsageButton + 4, kUsageButton + 5,
       kUsageButton + 7, kUsageButton + 8, kUsageButton + 14, kUsageButton + 15,
       kUsageButton + 13, kUsageConsumerACBack, kUsageConsumerACHome});
  SetReportSizeAndCount(1, 1);
  AddReportConstant(gamepad, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 7, 0, 315);
  SetUnitAndUnitExponent(kUnitDegrees, 0);
  SetReportSizeAndCount(4, 1);
  AddReportItem(gamepad, kInput, kNullableAbsoluteVariable,
                {kUsageGenericDesktopHatSwitch});
  SetUnitAndUnitExponent(0, 0);
  auto* axes_collection =
      AddChild(gamepad, kUsageGenericDesktop, kCollectionTypePhysical);
  SetLogicalAndPhysicalBounds(0, 255, 0, 255);
  SetReportSizeAndCount(8, 6);
  AddReportItem(axes_collection, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopX, kUsageGenericDesktopY,
                 kUsageGenericDesktopZ, kUsageGenericDesktopRz,
                 kUsageSimulationBrake, kUsageSimulationAccelerator});
  SetReportId(0x02);
  SetLogicalAndPhysicalBounds(0, 1, 0, 255);
  SetReportSizeAndCount(1, 4);
  AddReportItem(gamepad, kOutput, kAbsoluteVariable,
                {kUsageLedNumLock, kUsageLedCapsLock, kUsageLedScrollLock,
                 kUsageLedCompose});
  SetReportSizeAndCount(4, 1);
  AddReportConstant(gamepad, kOutput, kConstant);
  SetReportId(0x03);
  auto* status =
      AddTopCollection(kUsageGenericDesktopGamePad, kCollectionTypeApplication);
  SetLogicalAndPhysicalBounds(0, 255, 0, 255);
  SetReportSizeAndCount(8, 1);
  AddReportItem(status, kInput, kAbsoluteVariable,
                {kUsageGenericDeviceBatteryStrength});
  SetReportSizeAndCount(8, 6);
  AddReportItem(status, kInput, kAbsoluteVariable, {0xffbcbdad});
  ValidateCollections(kNexusPlayerController, kNexusPlayerControllerSize);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_SteamControllerKeyboard) {
  auto info = HidCollectionInfo::New();
  info->usage = HidUsageAndPage::New(mojom::kGenericDesktopKeyboard,
                                     mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*info->usage), true);
  AddTopCollectionInfo(std::move(info));
  ValidateDetails(false, 8, 1, 0, kSteamControllerKeyboard,
                  kSteamControllerKeyboardSize);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_SteamControllerKeyboard) {
  auto* top = AddTopCollection(kUsageGenericDesktopKeyboard,
                               kCollectionTypeApplication);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(1, 8);
  AddReportItemRange(top, kInput, kAbsoluteVariable, kUsageKeyboardLeftControl,
                     kUsageKeyboardRightGui);
  SetReportSizeAndCount(8, 1);
  AddReportConstant(top, kInput, kConstantArray);
  SetReportSizeAndCount(1, 5);
  AddReportItemRange(top, kOutput, kAbsoluteVariable, kUsageLedNumLock,
                     kUsageLedKana);
  SetReportSizeAndCount(3, 1);
  AddReportConstant(top, kOutput, kConstantArray);
  SetReportSizeAndCount(8, 6);
  SetLogicalAndPhysicalBounds(0, 101, 0, 0);
  AddReportItemRange(top, kInput, kNonNullableArray, kUsageKeyboard,
                     kUsageKeyboardApplication);
  ValidateCollections(kSteamControllerKeyboard, kSteamControllerKeyboardSize);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_SteamControllerMouse) {
  auto info = HidCollectionInfo::New();
  info->usage = HidUsageAndPage::New(mojom::kGenericDesktopMouse,
                                     mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*info->usage), true);
  AddTopCollectionInfo(std::move(info));
  ValidateDetails(false, 4, 0, 0, kSteamControllerMouse,
                  kSteamControllerMouseSize);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_SteamControllerMouse) {
  auto* top =
      AddTopCollection(kUsageGenericDesktopMouse, kCollectionTypeApplication);
  auto* pointer =
      AddChild(top, kUsageGenericDesktopPointer, kCollectionTypePhysical);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(1, 5);
  AddReportItemRange(pointer, kInput, kAbsoluteVariable, kUsageButton + 1,
                     kUsageButton + 5);
  SetReportSizeAndCount(3, 1);
  AddReportConstant(pointer, kInput, kConstantArray);
  SetLogicalAndPhysicalBounds(0x81, 0x7f, 0, 0);
  SetReportSizeAndCount(8, 3);
  AddReportItem(pointer, kInput, kRelativeVariable,
                {kUsageGenericDesktopX, kUsageGenericDesktopY,
                 kUsageGenericDesktopWheel});
  ValidateCollections(kSteamControllerMouse, kSteamControllerMouseSize);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_SteamControllerVendor) {
  auto info = HidCollectionInfo::New();
  info->usage = HidUsageAndPage::New(0x01, mojom::kPageVendor);
  ASSERT_EQ(IsProtected(*info->usage), false);
  AddTopCollectionInfo(std::move(info));
  ValidateDetails(false, 64, 64, 64, kSteamControllerVendor,
                  kSteamControllerVendorSize);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_SteamControllerVendor) {
  auto* top = AddTopCollection(kUsageVendor + 0x01, kCollectionTypeApplication);
  SetLogicalAndPhysicalBounds(0, 255, 0, 0);
  SetReportSizeAndCount(8, 64);
  AddReportItem(top, kInput, kAbsoluteVariable, {kUsageVendor + 0x01});
  AddReportItem(top, kOutput, kAbsoluteVariable, {kUsageVendor + 0x01});
  AddReportItem(top, kFeature, kAbsoluteVariable, {kUsageVendor + 0x01});
  ValidateCollections(kSteamControllerVendor, kSteamControllerVendorSize);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_XSkillsUsbAdapter) {
  auto info = HidCollectionInfo::New();
  info->usage = HidUsageAndPage::New(mojom::kGenericDesktopJoystick,
                                     mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*info->usage), false);
  AddTopCollectionInfo(std::move(info));
  ValidateDetails(false, 7, 4, 0, kXSkillsUsbAdapter, kXSkillsUsbAdapterSize);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_XSkillsUsbAdapter) {
  auto* top = AddTopCollection(kUsageGenericDesktopJoystick,
                               kCollectionTypeApplication);
  SetLogicalAndPhysicalBounds(0, 1, 0, 1);
  SetReportSizeAndCount(1, 12);
  AddReportItemRange(top, kInput, kAbsoluteVariable, kUsageButton + 1,
                     kUsageButton + 12);
  SetReportSizeAndCount(1, 4);
  AddReportConstant(top, kInput, kConstant);
  SetLogicalAndPhysicalBounds(0, 255, 0, 255);
  SetReportSizeAndCount(8, 4);
  AddReportItem(top, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopX, kUsageGenericDesktopY,
                 kUsageGenericDesktopRz, kUsageGenericDesktopZ});
  SetLogicalAndPhysicalBounds(0, 15, 0, 15);
  SetReportSizeAndCount(4, 2);
  AddReportItem(top, kInput, kAbsoluteVariable,
                {kUsageGenericDesktopRx, kUsageGenericDesktopRy});
  SetReportSizeAndCount(8, 4);
  AddReportItemRange(top, kOutput, kAbsoluteVariable, kUsageVendor + 0x01,
                     kUsageVendor + 0x04);
  ValidateCollections(kXSkillsUsbAdapter, kXSkillsUsbAdapterSize);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_BelkinNostromoKeyboard) {
  auto info = HidCollectionInfo::New();
  info->usage = HidUsageAndPage::New(mojom::kGenericDesktopKeyboard,
                                     mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*info->usage), true);
  AddTopCollectionInfo(std::move(info));
  ValidateDetails(false, 8, 0, 0, kBelkinNostromoKeyboard,
                  kBelkinNostromoKeyboardSize);
}

TEST_F(HidReportDescriptorTest, ValidateCollections_BelkinNostromoKeyboard) {
  auto* top = AddTopCollection(kUsageGenericDesktopKeyboard,
                               kCollectionTypeApplication);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(1, 8);
  AddReportItemRange(top, kInput, kAbsoluteVariable, kUsageKeyboardLeftControl,
                     kUsageKeyboardRightGui);
  SetReportSizeAndCount(8, 1);
  AddReportConstant(top, kInput, kConstantArray);
  SetLogicalAndPhysicalBounds(0, 101, 0, 0);
  SetReportSizeAndCount(8, 6);
  AddReportItemRange(top, kInput, kNonNullableArray, kUsageKeyboard,
                     kUsageKeyboardApplication);
  ValidateCollections(kBelkinNostromoKeyboard, kBelkinNostromoKeyboardSize);
}

TEST_F(HidReportDescriptorTest, ValidateDetails_BelkinNostromoMouseAndExtra) {
  auto info = HidCollectionInfo::New();
  info->usage = HidUsageAndPage::New(mojom::kGenericDesktopMouse,
                                     mojom::kPageGenericDesktop);
  ASSERT_EQ(IsProtected(*info->usage), true);
  AddTopCollectionInfo(std::move(info));
  ValidateDetails(false, 4, 1, 0, kBelkinNostromoMouseAndExtra,
                  kBelkinNostromoMouseAndExtraSize);
}

TEST_F(HidReportDescriptorTest,
       ValidateCollections_BelkinNostromoMouseAndExtra) {
  auto* top =
      AddTopCollection(kUsageGenericDesktopMouse, kCollectionTypeApplication);
  auto* pointer =
      AddChild(top, kUsageGenericDesktopPointer, kCollectionTypePhysical);
  SetLogicalAndPhysicalBounds(0, 1, 0, 0);
  SetReportSizeAndCount(1, 3);
  AddReportItemRange(pointer, kInput, kAbsoluteVariable, kUsageButton + 1,
                     kUsageButton + 3);
  SetReportSizeAndCount(5, 1);
  AddReportConstant(pointer, kInput, kConstantArray);
  SetLogicalAndPhysicalBounds(0x81, 0x7f, 0, 0);
  SetReportSizeAndCount(8, 3);
  AddReportItem(pointer, kInput, kRelativeVariable,
                {kUsageGenericDesktopX, kUsageGenericDesktopY,
                 kUsageGenericDesktopWheel});
  SetLogicalAndPhysicalBounds(0, 1, 0, 1);
  SetReportSizeAndCount(1, 3);
  AddReportItemRange(pointer, kOutput, kAbsoluteVariable, kUsageLedNumLock,
                     kUsageLedScrollLock);
  SetReportSizeAndCount(5, 1);
  AddReportConstant(pointer, kOutput, kConstantArray);
  ValidateCollections(kBelkinNostromoMouseAndExtra,
                      kBelkinNostromoMouseAndExtraSize);
}

}  // namespace device