services/device/public/cpp/hid/hid_report_descriptor_unittest.cc - chromium/src - Git at Google

 // 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 <sstream>

 #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/mojom/hid.mojom.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace device {

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

   void SetUp() override { descriptor_ = nullptr; }

   void TearDown() override {
     if (descriptor_) {
       delete descriptor_;
     }
   }

  public:
   void ValidateDetails(
       const std::vector<HidCollectionInfoPtr>& expected_collection_infos,
       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_ =
         new 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);
   }

  private:
   HidReportDescriptor* descriptor_;
 };

 TEST_F(HidReportDescriptorTest, ValidateDetails_Digitizer) {
   const uint16_t usage_page = mojom::kPageDigitizer;
   const uint16_t usage = 0x01;  // Digitizer

   auto digitizer = HidCollectionInfo::New();
   digitizer->usage = HidUsageAndPage::New(usage, usage_page);
   digitizer->report_ids = {0x01, 0x02, 0x03};

   std::vector<HidCollectionInfoPtr> expected_infos;
   expected_infos.push_back(std::move(digitizer));
   ValidateDetails(expected_infos, true, 6, 0, 0, kDigitizer, kDigitizerSize);
 }

 TEST_F(HidReportDescriptorTest, ValidateDetails_Keyboard) {
   const uint16_t usage_page = mojom::kPageGenericDesktop;
   const uint16_t usage = mojom::kGenericDesktopKeyboard;

   auto keyboard = HidCollectionInfo::New();
   keyboard->usage = HidUsageAndPage::New(usage, usage_page);

   std::vector<HidCollectionInfoPtr> expected_infos;
   expected_infos.push_back(std::move(keyboard));
   ValidateDetails(expected_infos, false, 8, 1, 0, kKeyboard, kKeyboardSize);
 }

 TEST_F(HidReportDescriptorTest, ValidateDetails_Monitor) {
   const uint16_t usage_page = mojom::kPageMonitor0;  // USB monitor
   const uint16_t usage = 0x01;                       // Monitor control

   auto monitor = HidCollectionInfo::New();
   monitor->usage = HidUsageAndPage::New(usage, usage_page);
   monitor->report_ids = {1, 2, 3, 4, 5};

   std::vector<HidCollectionInfoPtr> expected_infos;
   expected_infos.push_back(std::move(monitor));
   ValidateDetails(expected_infos, true, 0, 0, 243, kMonitor, kMonitorSize);
 }

 TEST_F(HidReportDescriptorTest, ValidateDetails_Mouse) {
   const uint16_t usage_page = mojom::kPageGenericDesktop;
   const uint16_t usage = mojom::kGenericDesktopMouse;

   auto mouse = HidCollectionInfo::New();
   mouse->usage = HidUsageAndPage::New(usage, usage_page);

   std::vector<HidCollectionInfoPtr> expected_infos;
   expected_infos.push_back(std::move(mouse));
   ValidateDetails(expected_infos, false, 3, 0, 0, kMouse, kMouseSize);
 }

 TEST_F(HidReportDescriptorTest, ValidateDetails_LogitechUnifyingReceiver) {
   const uint16_t usage_page = mojom::kPageVendor;
   const uint16_t usage_hidpp_short = 0x01;  // Vendor-defined
   const uint16_t usage_hidpp_long = 0x02;   // Vendor-defined
   const uint16_t usage_hidpp_dj = 0x04;     // Vendor-defined

   auto hidpp_short = HidCollectionInfo::New();
   hidpp_short->usage = HidUsageAndPage::New(usage_hidpp_short, usage_page);
   hidpp_short->report_ids = {0x10};
   auto hidpp_long = HidCollectionInfo::New();
   hidpp_long->usage = HidUsageAndPage::New(usage_hidpp_long, usage_page);
   hidpp_long->report_ids = {0x11};
   auto hidpp_dj = HidCollectionInfo::New();
   hidpp_dj->usage = HidUsageAndPage::New(usage_hidpp_dj, usage_page);
   hidpp_dj->report_ids = {0x20, 0x21};

   std::vector<HidCollectionInfoPtr> expected_infos;
   expected_infos.push_back(std::move(hidpp_short));
   expected_infos.push_back(std::move(hidpp_long));
   expected_infos.push_back(std::move(hidpp_dj));
   ValidateDetails(expected_infos, true, 31, 31, 0, kLogitechUnifyingReceiver,
                   kLogitechUnifyingReceiverSize);
 }

 TEST_F(HidReportDescriptorTest, ValidateDetails_SonyDualshock3) {
   const uint16_t usage_page = mojom::kPageGenericDesktop;
   const uint16_t usage = mojom::kGenericDesktopJoystick;

   auto top_info = HidCollectionInfo::New();
   top_info->usage = HidUsageAndPage::New(usage, usage_page);
   top_info->report_ids = {0x01, 0x02, 0xee, 0xef};

   std::vector<HidCollectionInfoPtr> expected_infos;
   expected_infos.push_back(std::move(top_info));
   ValidateDetails(expected_infos, true, 48, 48, 48, kSonyDualshock3,
                   kSonyDualshock3Size);
 }

 TEST_F(HidReportDescriptorTest, ValidateDetails_SonyDualshock4) {
   const uint16_t usage_page = mojom::kPageGenericDesktop;
   const uint16_t usage = mojom::kGenericDesktopGamePad;

   auto top_info = HidCollectionInfo::New();
   top_info->usage = HidUsageAndPage::New(usage, usage_page);
   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};

   std::vector<HidCollectionInfoPtr> expected_infos;
   expected_infos.push_back(std::move(top_info));
   ValidateDetails(expected_infos, true, 63, 31, 63, kSonyDualshock4,
                   kSonyDualshock4Size);
 }

 TEST_F(HidReportDescriptorTest, ValidateDetails_XboxWirelessController) {
   const uint16_t usage_page = mojom::kPageGenericDesktop;
   const uint16_t usage = mojom::kGenericDesktopGamePad;

   auto top_info = HidCollectionInfo::New();
   top_info->usage = HidUsageAndPage::New(usage, usage_page);
   top_info->report_ids = {0x01, 0x02, 0x03, 0x04};

   std::vector<HidCollectionInfoPtr> expected_info;
   expected_info.push_back(std::move(top_info));
   ValidateDetails(expected_info, true, 15, 8, 0,
                   kMicrosoftXboxWirelessController,
                   kMicrosoftXboxWirelessControllerSize);
 }

 TEST_F(HidReportDescriptorTest, ValidateDetails_NintendoSwitchProController) {
   const uint16_t usage_page = mojom::kPageGenericDesktop;
   const uint16_t usage = mojom::kGenericDesktopJoystick;

   auto top_info = HidCollectionInfo::New();
   top_info->usage = HidUsageAndPage::New(usage, usage_page);
   top_info->report_ids = {0x30, 0x21, 0x81, 0x01, 0x10, 0x80, 0x82};

   std::vector<HidCollectionInfoPtr> expected_info;
   expected_info.push_back(std::move(top_info));
   ValidateDetails(expected_info, true, 63, 63, 0, kNintendoSwitchProController,
                   kNintendoSwitchProControllerSize);
 }

 TEST_F(HidReportDescriptorTest, ValidateDetails_XboxAdaptiveController) {
   const uint16_t usage_page = mojom::kPageGenericDesktop;
   const uint16_t usage_gamepad = mojom::kGenericDesktopGamePad;
   const uint16_t usage_keyboard = mojom::kGenericDesktopKeyboard;
   const uint8_t report_ids_gamepad[] = {0x01, 0x02, 0x03, 0x04, 0x06,
                                         0x07, 0x08, 0x09, 0x0a, 0x0b};
   const size_t report_ids_gamepad_size = base::size(report_ids_gamepad);
   const uint8_t report_ids_keyboard[] = {0x05};
   const size_t report_ids_keyboard_size = base::size(report_ids_keyboard);

   auto gamepad_info = HidCollectionInfo::New();
   gamepad_info->usage = HidUsageAndPage::New(usage_gamepad, usage_page);
   gamepad_info->report_ids.insert(gamepad_info->report_ids.begin(),
                                   report_ids_gamepad,
                                   report_ids_gamepad + report_ids_gamepad_size);

   auto keyboard_info = HidCollectionInfo::New();
   keyboard_info->usage = HidUsageAndPage::New(usage_keyboard, usage_page);
   keyboard_info->report_ids.insert(
       keyboard_info->report_ids.begin(), report_ids_keyboard,
       report_ids_keyboard + report_ids_keyboard_size);

   std::vector<HidCollectionInfoPtr> expected_info;
   expected_info.push_back(std::move(gamepad_info));
   expected_info.push_back(std::move(keyboard_info));
   ValidateDetails(expected_info, true, 54, 8, 64,
                   kMicrosoftXboxAdaptiveController,
                   kMicrosoftXboxAdaptiveControllerSize);
 }

 }  // namespace device
	// 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 <sstream>

	#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/mojom/hid.mojom.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace device {

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

	void SetUp() override { descriptor_ = nullptr; }

	void TearDown() override {
	if (descriptor_) {
	delete descriptor_;
	}
	}

	public:
	void ValidateDetails(
	const std::vector<HidCollectionInfoPtr>& expected_collection_infos,
	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_ =
	new 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);
	}

	private:
	HidReportDescriptor* descriptor_;
	};

	TEST_F(HidReportDescriptorTest, ValidateDetails_Digitizer) {
	const uint16_t usage_page = mojom::kPageDigitizer;
	const uint16_t usage = 0x01; // Digitizer

	auto digitizer = HidCollectionInfo::New();
	digitizer->usage = HidUsageAndPage::New(usage, usage_page);
	digitizer->report_ids = {0x01, 0x02, 0x03};

	std::vector<HidCollectionInfoPtr> expected_infos;
	expected_infos.push_back(std::move(digitizer));
	ValidateDetails(expected_infos, true, 6, 0, 0, kDigitizer, kDigitizerSize);
	}

	TEST_F(HidReportDescriptorTest, ValidateDetails_Keyboard) {
	const uint16_t usage_page = mojom::kPageGenericDesktop;
	const uint16_t usage = mojom::kGenericDesktopKeyboard;

	auto keyboard = HidCollectionInfo::New();
	keyboard->usage = HidUsageAndPage::New(usage, usage_page);

	std::vector<HidCollectionInfoPtr> expected_infos;
	expected_infos.push_back(std::move(keyboard));
	ValidateDetails(expected_infos, false, 8, 1, 0, kKeyboard, kKeyboardSize);
	}

	TEST_F(HidReportDescriptorTest, ValidateDetails_Monitor) {
	const uint16_t usage_page = mojom::kPageMonitor0; // USB monitor
	const uint16_t usage = 0x01; // Monitor control

	auto monitor = HidCollectionInfo::New();
	monitor->usage = HidUsageAndPage::New(usage, usage_page);
	monitor->report_ids = {1, 2, 3, 4, 5};

	std::vector<HidCollectionInfoPtr> expected_infos;
	expected_infos.push_back(std::move(monitor));
	ValidateDetails(expected_infos, true, 0, 0, 243, kMonitor, kMonitorSize);
	}

	TEST_F(HidReportDescriptorTest, ValidateDetails_Mouse) {
	const uint16_t usage_page = mojom::kPageGenericDesktop;
	const uint16_t usage = mojom::kGenericDesktopMouse;

	auto mouse = HidCollectionInfo::New();
	mouse->usage = HidUsageAndPage::New(usage, usage_page);

	std::vector<HidCollectionInfoPtr> expected_infos;
	expected_infos.push_back(std::move(mouse));
	ValidateDetails(expected_infos, false, 3, 0, 0, kMouse, kMouseSize);
	}

	TEST_F(HidReportDescriptorTest, ValidateDetails_LogitechUnifyingReceiver) {
	const uint16_t usage_page = mojom::kPageVendor;
	const uint16_t usage_hidpp_short = 0x01; // Vendor-defined
	const uint16_t usage_hidpp_long = 0x02; // Vendor-defined
	const uint16_t usage_hidpp_dj = 0x04; // Vendor-defined

	auto hidpp_short = HidCollectionInfo::New();
	hidpp_short->usage = HidUsageAndPage::New(usage_hidpp_short, usage_page);
	hidpp_short->report_ids = {0x10};
	auto hidpp_long = HidCollectionInfo::New();
	hidpp_long->usage = HidUsageAndPage::New(usage_hidpp_long, usage_page);
	hidpp_long->report_ids = {0x11};
	auto hidpp_dj = HidCollectionInfo::New();
	hidpp_dj->usage = HidUsageAndPage::New(usage_hidpp_dj, usage_page);
	hidpp_dj->report_ids = {0x20, 0x21};

	std::vector<HidCollectionInfoPtr> expected_infos;
	expected_infos.push_back(std::move(hidpp_short));
	expected_infos.push_back(std::move(hidpp_long));
	expected_infos.push_back(std::move(hidpp_dj));
	ValidateDetails(expected_infos, true, 31, 31, 0, kLogitechUnifyingReceiver,
	kLogitechUnifyingReceiverSize);
	}

	TEST_F(HidReportDescriptorTest, ValidateDetails_SonyDualshock3) {
	const uint16_t usage_page = mojom::kPageGenericDesktop;
	const uint16_t usage = mojom::kGenericDesktopJoystick;

	auto top_info = HidCollectionInfo::New();
	top_info->usage = HidUsageAndPage::New(usage, usage_page);
	top_info->report_ids = {0x01, 0x02, 0xee, 0xef};

	std::vector<HidCollectionInfoPtr> expected_infos;
	expected_infos.push_back(std::move(top_info));
	ValidateDetails(expected_infos, true, 48, 48, 48, kSonyDualshock3,
	kSonyDualshock3Size);
	}

	TEST_F(HidReportDescriptorTest, ValidateDetails_SonyDualshock4) {
	const uint16_t usage_page = mojom::kPageGenericDesktop;
	const uint16_t usage = mojom::kGenericDesktopGamePad;

	auto top_info = HidCollectionInfo::New();
	top_info->usage = HidUsageAndPage::New(usage, usage_page);
	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};

	std::vector<HidCollectionInfoPtr> expected_infos;
	expected_infos.push_back(std::move(top_info));
	ValidateDetails(expected_infos, true, 63, 31, 63, kSonyDualshock4,
	kSonyDualshock4Size);
	}

	TEST_F(HidReportDescriptorTest, ValidateDetails_XboxWirelessController) {
	const uint16_t usage_page = mojom::kPageGenericDesktop;
	const uint16_t usage = mojom::kGenericDesktopGamePad;

	auto top_info = HidCollectionInfo::New();
	top_info->usage = HidUsageAndPage::New(usage, usage_page);
	top_info->report_ids = {0x01, 0x02, 0x03, 0x04};

	std::vector<HidCollectionInfoPtr> expected_info;
	expected_info.push_back(std::move(top_info));
	ValidateDetails(expected_info, true, 15, 8, 0,
	kMicrosoftXboxWirelessController,
	kMicrosoftXboxWirelessControllerSize);
	}

	TEST_F(HidReportDescriptorTest, ValidateDetails_NintendoSwitchProController) {
	const uint16_t usage_page = mojom::kPageGenericDesktop;
	const uint16_t usage = mojom::kGenericDesktopJoystick;

	auto top_info = HidCollectionInfo::New();
	top_info->usage = HidUsageAndPage::New(usage, usage_page);
	top_info->report_ids = {0x30, 0x21, 0x81, 0x01, 0x10, 0x80, 0x82};

	std::vector<HidCollectionInfoPtr> expected_info;
	expected_info.push_back(std::move(top_info));
	ValidateDetails(expected_info, true, 63, 63, 0, kNintendoSwitchProController,
	kNintendoSwitchProControllerSize);
	}

	TEST_F(HidReportDescriptorTest, ValidateDetails_XboxAdaptiveController) {
	const uint16_t usage_page = mojom::kPageGenericDesktop;
	const uint16_t usage_gamepad = mojom::kGenericDesktopGamePad;
	const uint16_t usage_keyboard = mojom::kGenericDesktopKeyboard;
	const uint8_t report_ids_gamepad[] = {0x01, 0x02, 0x03, 0x04, 0x06,
	0x07, 0x08, 0x09, 0x0a, 0x0b};
	const size_t report_ids_gamepad_size = base::size(report_ids_gamepad);
	const uint8_t report_ids_keyboard[] = {0x05};
	const size_t report_ids_keyboard_size = base::size(report_ids_keyboard);

	auto gamepad_info = HidCollectionInfo::New();
	gamepad_info->usage = HidUsageAndPage::New(usage_gamepad, usage_page);
	gamepad_info->report_ids.insert(gamepad_info->report_ids.begin(),
	report_ids_gamepad,
	report_ids_gamepad + report_ids_gamepad_size);

	auto keyboard_info = HidCollectionInfo::New();
	keyboard_info->usage = HidUsageAndPage::New(usage_keyboard, usage_page);
	keyboard_info->report_ids.insert(
	keyboard_info->report_ids.begin(), report_ids_keyboard,
	report_ids_keyboard + report_ids_keyboard_size);

	std::vector<HidCollectionInfoPtr> expected_info;
	expected_info.push_back(std::move(gamepad_info));
	expected_info.push_back(std::move(keyboard_info));
	ValidateDetails(expected_info, true, 54, 8, 64,
	kMicrosoftXboxAdaptiveController,
	kMicrosoftXboxAdaptiveControllerSize);
	}

	} // namespace device