hid_preparsed_data_unittest.cc 42 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980
  1. // Copyright 2020 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "services/device/hid/hid_service_win.h"
  5. #include <vector>
  6. #include "services/device/public/mojom/hid.mojom.h"
  7. #include "testing/gmock/include/gmock/gmock.h"
  8. #include "testing/gtest/include/gtest/gtest.h"
  9. namespace device {
  10. namespace {
  11. using ::testing::ElementsAre;
  12. using ::testing::NiceMock;
  13. using ::testing::Return;
  14. using ::testing::ReturnRef;
  15. using ReportItem = HidServiceWin::PreparsedData::ReportItem;
  16. // Report IDs.
  17. constexpr uint8_t kNoReportId = 0x00;
  18. constexpr uint8_t kReportId01 = 0x01;
  19. constexpr uint8_t kReportId02 = 0x02;
  20. // HID usage page constants.
  21. constexpr uint16_t kPageButton = mojom::kPageButton;
  22. constexpr uint16_t kPageGenericDesktop = mojom::kPageGenericDesktop;
  23. // HID usage constants.
  24. constexpr uint16_t kUsageMouse = mojom::kGenericDesktopMouse;
  25. constexpr uint16_t kUsageX = mojom::kGenericDesktopX;
  26. constexpr uint16_t kUsageY = mojom::kGenericDesktopY;
  27. constexpr uint16_t kUsage00 = 0x00;
  28. constexpr uint16_t kUsage01 = 0x01;
  29. constexpr uint16_t kUsage02 = 0x02;
  30. constexpr uint16_t kUsage03 = 0x03;
  31. constexpr uint16_t kUsage04 = 0x04;
  32. constexpr uint16_t kUsage05 = 0x05;
  33. constexpr uint16_t kUsage06 = 0x06;
  34. constexpr uint16_t kUsage07 = 0x07;
  35. constexpr uint16_t kUsage08 = 0x08;
  36. constexpr uint16_t kUsageFF = 0xff;
  37. // Data, Array, Abs, No Wrap, Linear, Preferred State, No Null Position.
  38. constexpr uint16_t kBitFieldArray = 0x0000;
  39. // Data, Var, Abs, No Wrap, Linear, Preferred State, No Null Position.
  40. constexpr uint16_t kBitFieldVariable = 0x0002;
  41. class MockPreparsedData : public NiceMock<HidServiceWin::PreparsedData> {
  42. public:
  43. MockPreparsedData() {
  44. ON_CALL(*this, GetReportItems)
  45. .WillByDefault(Return(std::vector<ReportItem>()));
  46. }
  47. ~MockPreparsedData() override = default;
  48. MOCK_CONST_METHOD0(GetCaps, const HIDP_CAPS&());
  49. MOCK_CONST_METHOD1(GetReportItems, std::vector<ReportItem>(HIDP_REPORT_TYPE));
  50. };
  51. ReportItem SimpleButtonItem(uint16_t usage_page,
  52. uint16_t usage,
  53. uint8_t report_id,
  54. size_t bit_index) {
  55. return {report_id,
  56. kBitFieldVariable,
  57. /*report_size=*/1,
  58. /*report_count=*/1,
  59. usage_page,
  60. /*usage_min=*/usage,
  61. /*usage_max=*/usage,
  62. /*designator_minimum=*/0,
  63. /*designator_maximum=*/0,
  64. /*string_minimum=*/0,
  65. /*string_maximum=*/0,
  66. /*logical_minimum=*/0,
  67. /*logical_maximum=*/1,
  68. /*physical_minimum=*/0,
  69. /*physical_maximum=*/0,
  70. /*unit=*/0,
  71. /*unit_exponent=*/0,
  72. bit_index};
  73. }
  74. ReportItem RangeButtonItem(uint16_t usage_page,
  75. uint16_t usage_min,
  76. uint16_t usage_max,
  77. uint8_t report_id,
  78. size_t bit_index) {
  79. uint16_t report_count = usage_max - usage_min + 1;
  80. return {report_id,
  81. kBitFieldVariable,
  82. /*report_size=*/1,
  83. report_count,
  84. usage_page,
  85. usage_min,
  86. usage_max,
  87. /*designator_minimum=*/0,
  88. /*designator_maximum=*/0,
  89. /*string_minimum=*/0,
  90. /*string_maximum=*/0,
  91. /*logical_minimum=*/0,
  92. /*logical_maximum=*/1,
  93. /*physical_minimum=*/0,
  94. /*physical_maximum=*/0,
  95. /*unit=*/0,
  96. /*unit_exponent=*/0,
  97. bit_index};
  98. }
  99. ReportItem ArrayItem(uint16_t usage_page,
  100. uint16_t usage_min,
  101. uint16_t usage_max,
  102. uint8_t report_id,
  103. uint16_t report_count,
  104. size_t bit_index) {
  105. return {report_id,
  106. kBitFieldArray,
  107. /*report_size=*/8,
  108. report_count,
  109. usage_page,
  110. usage_min,
  111. usage_max,
  112. /*designator_minimum=*/0,
  113. /*designator_maximum=*/0,
  114. /*string_minimum=*/0,
  115. /*string_maximum=*/0,
  116. /*logical_minimum=*/usage_min,
  117. /*logical_maximum=*/usage_max,
  118. /*physical_minimum=*/0,
  119. /*physical_maximum=*/0,
  120. /*unit=*/0,
  121. /*unit_exponent=*/0,
  122. bit_index};
  123. }
  124. ReportItem SimpleValueItem(uint16_t usage_page,
  125. uint16_t usage,
  126. uint8_t report_id,
  127. size_t bit_index) {
  128. return {report_id,
  129. kBitFieldVariable,
  130. /*report_size=*/8,
  131. /*report_count=*/1,
  132. usage_page,
  133. /*usage_min=*/usage,
  134. /*usage_max=*/usage,
  135. /*designator_minimum=*/0,
  136. /*designator_maximum=*/0,
  137. /*string_minimum=*/0,
  138. /*string_maximum=*/0,
  139. /*logical_minimum=*/0x00,
  140. /*logical_maximum=*/0xff,
  141. /*physical_minimum=*/0,
  142. /*physical_maximum=*/0,
  143. /*unit=*/0,
  144. /*unit_exponent=*/0,
  145. bit_index};
  146. }
  147. ReportItem RangeValueItem(uint16_t usage_page,
  148. uint16_t usage_min,
  149. uint16_t usage_max,
  150. uint16_t report_count,
  151. uint8_t report_id,
  152. size_t bit_index) {
  153. return {report_id,
  154. kBitFieldVariable,
  155. /*report_size=*/8,
  156. report_count,
  157. usage_page,
  158. usage_min,
  159. usage_max,
  160. /*designator_minimum=*/0,
  161. /*designator_maximum=*/0,
  162. /*string_minimum=*/0,
  163. /*string_maximum=*/0,
  164. /*logical_minimum=*/0x00,
  165. /*logical_maximum=*/0xff,
  166. /*physical_minimum=*/0,
  167. /*physical_maximum=*/0,
  168. /*unit=*/0,
  169. /*unit_exponent=*/0,
  170. bit_index};
  171. }
  172. } // namespace
  173. TEST(HidPreparsedDataTest, NoReportItems) {
  174. HIDP_CAPS capabilities = {0};
  175. capabilities.UsagePage = kPageGenericDesktop;
  176. capabilities.Usage = kUsageMouse;
  177. MockPreparsedData preparsed_data;
  178. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  179. const auto collection = preparsed_data.CreateHidCollectionInfo();
  180. ASSERT_TRUE(collection->usage);
  181. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  182. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  183. EXPECT_TRUE(collection->report_ids.empty());
  184. EXPECT_TRUE(collection->input_reports.empty());
  185. EXPECT_TRUE(collection->output_reports.empty());
  186. EXPECT_TRUE(collection->feature_reports.empty());
  187. EXPECT_TRUE(collection->children.empty());
  188. }
  189. TEST(HidPreparsedDataTest, OneButtonItemWithNoReportId) {
  190. HIDP_CAPS capabilities = {0};
  191. capabilities.UsagePage = kPageGenericDesktop;
  192. capabilities.Usage = kUsageMouse;
  193. capabilities.InputReportByteLength = 2;
  194. capabilities.NumberInputButtonCaps = 1;
  195. std::vector<ReportItem> input_items = {
  196. SimpleButtonItem(kPageButton, kUsage01, kNoReportId, /*bit_index=*/0)};
  197. MockPreparsedData preparsed_data;
  198. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  199. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  200. .WillOnce(Return(input_items));
  201. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  202. .WillOnce(Return(std::vector<ReportItem>()));
  203. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  204. .WillOnce(Return(std::vector<ReportItem>()));
  205. const auto collection = preparsed_data.CreateHidCollectionInfo();
  206. ASSERT_TRUE(collection->usage);
  207. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  208. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  209. EXPECT_TRUE(collection->report_ids.empty());
  210. ASSERT_EQ(collection->input_reports.size(), 1U);
  211. const auto& report = collection->input_reports[0];
  212. EXPECT_EQ(report->report_id, kNoReportId);
  213. ASSERT_EQ(report->items.size(), 2U);
  214. EXPECT_FALSE(report->items[0]->is_range);
  215. EXPECT_FALSE(report->items[0]->is_constant);
  216. EXPECT_TRUE(report->items[0]->is_variable);
  217. ASSERT_EQ(report->items[0]->usages.size(), 1U);
  218. EXPECT_EQ(report->items[0]->usages[0]->usage_page, kPageButton);
  219. EXPECT_EQ(report->items[0]->usages[0]->usage, kUsage01);
  220. EXPECT_EQ(report->items[0]->report_size, 1U);
  221. EXPECT_EQ(report->items[0]->report_count, 1U);
  222. EXPECT_TRUE(report->items[1]->is_constant);
  223. EXPECT_EQ(report->items[1]->report_size, 7U);
  224. EXPECT_EQ(report->items[1]->report_count, 1U);
  225. EXPECT_TRUE(collection->output_reports.empty());
  226. EXPECT_TRUE(collection->feature_reports.empty());
  227. EXPECT_TRUE(collection->children.empty());
  228. }
  229. TEST(HidPreparsedDataTest, OneButtonItemWithReportId) {
  230. HIDP_CAPS capabilities = {0};
  231. capabilities.UsagePage = kPageGenericDesktop;
  232. capabilities.Usage = kUsageMouse;
  233. capabilities.InputReportByteLength = 2;
  234. capabilities.NumberInputButtonCaps = 1;
  235. std::vector<ReportItem> input_items = {
  236. SimpleButtonItem(kPageButton, kUsage01, kReportId01, /*bit_index=*/0)};
  237. MockPreparsedData preparsed_data;
  238. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  239. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  240. .WillOnce(Return(input_items));
  241. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  242. .WillOnce(Return(std::vector<ReportItem>()));
  243. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  244. .WillOnce(Return(std::vector<ReportItem>()));
  245. const auto collection = preparsed_data.CreateHidCollectionInfo();
  246. ASSERT_TRUE(collection->usage);
  247. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  248. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  249. EXPECT_THAT(collection->report_ids, ElementsAre(kReportId01));
  250. ASSERT_EQ(collection->input_reports.size(), 1U);
  251. const auto& report = collection->input_reports[0];
  252. EXPECT_EQ(report->report_id, kReportId01);
  253. ASSERT_EQ(report->items.size(), 2U);
  254. EXPECT_FALSE(report->items[0]->is_range);
  255. EXPECT_FALSE(report->items[0]->is_constant);
  256. EXPECT_TRUE(report->items[0]->is_variable);
  257. ASSERT_EQ(report->items[0]->usages.size(), 1U);
  258. EXPECT_EQ(report->items[0]->usages[0]->usage_page, kPageButton);
  259. EXPECT_EQ(report->items[0]->usages[0]->usage, kUsage01);
  260. EXPECT_EQ(report->items[0]->report_size, 1U);
  261. EXPECT_EQ(report->items[0]->report_count, 1U);
  262. EXPECT_TRUE(report->items[1]->is_constant);
  263. EXPECT_EQ(report->items[1]->report_size, 7U);
  264. EXPECT_EQ(report->items[1]->report_count, 1U);
  265. EXPECT_TRUE(collection->output_reports.empty());
  266. EXPECT_TRUE(collection->feature_reports.empty());
  267. EXPECT_TRUE(collection->children.empty());
  268. }
  269. TEST(HidPreparsedDataTest, ButtonItemWithUsageRange) {
  270. HIDP_CAPS capabilities = {0};
  271. capabilities.UsagePage = kPageGenericDesktop;
  272. capabilities.Usage = kUsageMouse;
  273. capabilities.InputReportByteLength = 2;
  274. capabilities.NumberInputValueCaps = 1;
  275. std::vector<ReportItem> input_items = {RangeButtonItem(
  276. kPageButton, kUsage01, kUsage08, kReportId01, /*bit_index=*/0)};
  277. MockPreparsedData preparsed_data;
  278. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  279. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  280. .WillOnce(Return(input_items));
  281. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  282. .WillOnce(Return(std::vector<ReportItem>()));
  283. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  284. .WillOnce(Return(std::vector<ReportItem>()));
  285. const auto collection = preparsed_data.CreateHidCollectionInfo();
  286. ASSERT_TRUE(collection->usage);
  287. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  288. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  289. EXPECT_THAT(collection->report_ids, ElementsAre(kReportId01));
  290. ASSERT_EQ(collection->input_reports.size(), 1U);
  291. const auto& report = collection->input_reports[0];
  292. EXPECT_EQ(report->report_id, kReportId01);
  293. ASSERT_EQ(report->items.size(), 1U);
  294. EXPECT_TRUE(report->items[0]->is_range);
  295. EXPECT_FALSE(report->items[0]->is_constant);
  296. EXPECT_TRUE(report->items[0]->is_variable);
  297. EXPECT_EQ(report->items[0]->usage_minimum->usage_page, kPageButton);
  298. EXPECT_EQ(report->items[0]->usage_minimum->usage, kUsage01);
  299. EXPECT_EQ(report->items[0]->usage_maximum->usage_page, kPageButton);
  300. EXPECT_EQ(report->items[0]->usage_maximum->usage, kUsage08);
  301. EXPECT_EQ(report->items[0]->report_size, 1U);
  302. EXPECT_EQ(report->items[0]->report_count, 8U);
  303. EXPECT_TRUE(collection->output_reports.empty());
  304. EXPECT_TRUE(collection->feature_reports.empty());
  305. EXPECT_TRUE(collection->children.empty());
  306. }
  307. TEST(HidPreparsedDataTest, ArrayItemWithReportCount1) {
  308. HIDP_CAPS capabilities = {0};
  309. capabilities.UsagePage = kPageGenericDesktop;
  310. capabilities.Usage = kUsageMouse;
  311. capabilities.InputReportByteLength = 2;
  312. capabilities.NumberInputValueCaps = 1;
  313. std::vector<ReportItem> input_items = {
  314. ArrayItem(kPageButton, kUsage00, kUsageFF, kReportId01,
  315. /*report_count=*/1, /*bit_index=*/0)};
  316. MockPreparsedData preparsed_data;
  317. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  318. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  319. .WillOnce(Return(input_items));
  320. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  321. .WillOnce(Return(std::vector<ReportItem>()));
  322. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  323. .WillOnce(Return(std::vector<ReportItem>()));
  324. const auto collection = preparsed_data.CreateHidCollectionInfo();
  325. ASSERT_TRUE(collection->usage);
  326. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  327. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  328. EXPECT_THAT(collection->report_ids, ElementsAre(kReportId01));
  329. ASSERT_EQ(collection->input_reports.size(), 1U);
  330. const auto& report = collection->input_reports[0];
  331. EXPECT_EQ(report->report_id, kReportId01);
  332. ASSERT_EQ(report->items.size(), 1U);
  333. EXPECT_TRUE(report->items[0]->is_range);
  334. EXPECT_FALSE(report->items[0]->is_constant);
  335. EXPECT_FALSE(report->items[0]->is_variable);
  336. EXPECT_EQ(report->items[0]->usage_minimum->usage_page, kPageButton);
  337. EXPECT_EQ(report->items[0]->usage_minimum->usage, kUsage00);
  338. EXPECT_EQ(report->items[0]->usage_maximum->usage_page, kPageButton);
  339. EXPECT_EQ(report->items[0]->usage_maximum->usage, kUsageFF);
  340. EXPECT_EQ(report->items[0]->report_size, 8U);
  341. EXPECT_EQ(report->items[0]->report_count, 1U);
  342. EXPECT_TRUE(collection->output_reports.empty());
  343. EXPECT_TRUE(collection->feature_reports.empty());
  344. EXPECT_TRUE(collection->children.empty());
  345. }
  346. TEST(HidPreparsedDataTest, ArrayItemWithReportCount2) {
  347. HIDP_CAPS capabilities = {0};
  348. capabilities.UsagePage = kPageGenericDesktop;
  349. capabilities.Usage = kUsageMouse;
  350. capabilities.InputReportByteLength = 3;
  351. capabilities.NumberInputValueCaps = 1;
  352. std::vector<ReportItem> input_items = {
  353. ArrayItem(kPageButton, kUsage00, kUsageFF, kReportId01,
  354. /*report_count=*/2, /*bit_index=*/0)};
  355. MockPreparsedData preparsed_data;
  356. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  357. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  358. .WillOnce(Return(input_items));
  359. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  360. .WillOnce(Return(std::vector<ReportItem>()));
  361. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  362. .WillOnce(Return(std::vector<ReportItem>()));
  363. const auto collection = preparsed_data.CreateHidCollectionInfo();
  364. ASSERT_TRUE(collection->usage);
  365. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  366. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  367. EXPECT_THAT(collection->report_ids, ElementsAre(kReportId01));
  368. ASSERT_EQ(collection->input_reports.size(), 1U);
  369. const auto& report = collection->input_reports[0];
  370. EXPECT_EQ(report->report_id, kReportId01);
  371. ASSERT_EQ(report->items.size(), 1U);
  372. EXPECT_TRUE(report->items[0]->is_range);
  373. EXPECT_FALSE(report->items[0]->is_constant);
  374. EXPECT_FALSE(report->items[0]->is_variable);
  375. EXPECT_EQ(report->items[0]->usage_minimum->usage_page, kPageButton);
  376. EXPECT_EQ(report->items[0]->usage_minimum->usage, kUsage00);
  377. EXPECT_EQ(report->items[0]->usage_maximum->usage_page, kPageButton);
  378. EXPECT_EQ(report->items[0]->usage_maximum->usage, kUsageFF);
  379. EXPECT_EQ(report->items[0]->report_size, 8U);
  380. EXPECT_EQ(report->items[0]->report_count, 2U);
  381. EXPECT_TRUE(collection->output_reports.empty());
  382. EXPECT_TRUE(collection->feature_reports.empty());
  383. EXPECT_TRUE(collection->children.empty());
  384. }
  385. TEST(HidPreparsedDataTest, ArrayItemWithNoValidUsages) {
  386. HIDP_CAPS capabilities = {0};
  387. capabilities.UsagePage = kPageGenericDesktop;
  388. capabilities.Usage = kUsageMouse;
  389. capabilities.InputReportByteLength = 2;
  390. capabilities.NumberInputValueCaps = 1;
  391. std::vector<ReportItem> input_items = {
  392. ArrayItem(kPageButton, kUsage00, kUsage00, kReportId01,
  393. /*report_count=*/1, /*bit_index=*/0)};
  394. MockPreparsedData preparsed_data;
  395. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  396. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  397. .WillOnce(Return(input_items));
  398. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  399. .WillOnce(Return(std::vector<ReportItem>()));
  400. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  401. .WillOnce(Return(std::vector<ReportItem>()));
  402. const auto collection = preparsed_data.CreateHidCollectionInfo();
  403. ASSERT_TRUE(collection->usage);
  404. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  405. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  406. EXPECT_THAT(collection->report_ids, ElementsAre(kReportId01));
  407. EXPECT_EQ(collection->input_reports.size(), 1U);
  408. const auto& report = collection->input_reports[0];
  409. EXPECT_EQ(report->report_id, kReportId01);
  410. ASSERT_EQ(report->items.size(), 1U);
  411. EXPECT_FALSE(report->items[0]->is_range);
  412. EXPECT_FALSE(report->items[0]->is_constant);
  413. EXPECT_FALSE(report->items[0]->is_variable);
  414. ASSERT_EQ(report->items[0]->usages.size(), 1U);
  415. EXPECT_EQ(report->items[0]->usages[0]->usage_page, kPageButton);
  416. EXPECT_EQ(report->items[0]->usages[0]->usage, kUsage00);
  417. EXPECT_EQ(report->items[0]->report_size, 8U);
  418. EXPECT_EQ(report->items[0]->report_count, 1U);
  419. EXPECT_TRUE(collection->output_reports.empty());
  420. EXPECT_TRUE(collection->feature_reports.empty());
  421. EXPECT_TRUE(collection->children.empty());
  422. }
  423. TEST(HidPreparsedDataTest, ValueItemWithNoReportId) {
  424. HIDP_CAPS capabilities = {0};
  425. capabilities.UsagePage = kPageGenericDesktop;
  426. capabilities.Usage = kUsageMouse;
  427. capabilities.InputReportByteLength = 2;
  428. capabilities.NumberInputValueCaps = 1;
  429. std::vector<ReportItem> input_items = {SimpleValueItem(
  430. kPageGenericDesktop, kUsageX, kNoReportId, /*bit_index=*/0)};
  431. MockPreparsedData preparsed_data;
  432. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  433. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  434. .WillOnce(Return(input_items));
  435. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  436. .WillOnce(Return(std::vector<ReportItem>()));
  437. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  438. .WillOnce(Return(std::vector<ReportItem>()));
  439. const auto collection = preparsed_data.CreateHidCollectionInfo();
  440. ASSERT_TRUE(collection->usage);
  441. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  442. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  443. EXPECT_TRUE(collection->report_ids.empty());
  444. ASSERT_EQ(collection->input_reports.size(), 1U);
  445. const auto& report = collection->input_reports[0];
  446. EXPECT_EQ(report->report_id, kNoReportId);
  447. ASSERT_EQ(report->items.size(), 1U);
  448. EXPECT_FALSE(report->items[0]->is_range);
  449. EXPECT_FALSE(report->items[0]->is_constant);
  450. EXPECT_TRUE(report->items[0]->is_variable);
  451. ASSERT_EQ(report->items[0]->usages.size(), 1U);
  452. EXPECT_EQ(report->items[0]->usages[0]->usage_page, kPageGenericDesktop);
  453. EXPECT_EQ(report->items[0]->usages[0]->usage, kUsageX);
  454. EXPECT_EQ(report->items[0]->report_size, 8U);
  455. EXPECT_EQ(report->items[0]->report_count, 1U);
  456. EXPECT_TRUE(collection->output_reports.empty());
  457. EXPECT_TRUE(collection->feature_reports.empty());
  458. EXPECT_TRUE(collection->children.empty());
  459. }
  460. TEST(HidPreparsedDataTest, ValueItemWithReportId) {
  461. HIDP_CAPS capabilities = {0};
  462. capabilities.UsagePage = kPageGenericDesktop;
  463. capabilities.Usage = kUsageMouse;
  464. capabilities.InputReportByteLength = 2;
  465. capabilities.NumberInputValueCaps = 1;
  466. std::vector<ReportItem> input_items = {SimpleValueItem(
  467. kPageGenericDesktop, kUsageX, kReportId01, /*bit_index=*/0)};
  468. MockPreparsedData preparsed_data;
  469. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  470. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  471. .WillOnce(Return(input_items));
  472. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  473. .WillOnce(Return(std::vector<ReportItem>()));
  474. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  475. .WillOnce(Return(std::vector<ReportItem>()));
  476. const auto collection = preparsed_data.CreateHidCollectionInfo();
  477. ASSERT_TRUE(collection->usage);
  478. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  479. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  480. EXPECT_THAT(collection->report_ids, ElementsAre(kReportId01));
  481. ASSERT_EQ(collection->input_reports.size(), 1U);
  482. const auto& report = collection->input_reports[0];
  483. EXPECT_EQ(report->report_id, kReportId01);
  484. ASSERT_EQ(report->items.size(), 1U);
  485. EXPECT_FALSE(report->items[0]->is_range);
  486. EXPECT_FALSE(report->items[0]->is_constant);
  487. EXPECT_TRUE(report->items[0]->is_variable);
  488. ASSERT_EQ(report->items[0]->usages.size(), 1U);
  489. EXPECT_EQ(report->items[0]->usages[0]->usage_page, kPageGenericDesktop);
  490. EXPECT_EQ(report->items[0]->usages[0]->usage, kUsageX);
  491. EXPECT_EQ(report->items[0]->report_size, 8U);
  492. EXPECT_EQ(report->items[0]->report_count, 1U);
  493. EXPECT_TRUE(collection->output_reports.empty());
  494. EXPECT_TRUE(collection->feature_reports.empty());
  495. EXPECT_TRUE(collection->children.empty());
  496. }
  497. TEST(HidPreparsedDataTest, TwoValueItemsWithMatchingReportIds) {
  498. HIDP_CAPS capabilities = {0};
  499. capabilities.UsagePage = kPageGenericDesktop;
  500. capabilities.Usage = kUsageMouse;
  501. capabilities.InputReportByteLength = 3;
  502. capabilities.NumberInputValueCaps = 2;
  503. std::vector<ReportItem> input_items = {
  504. SimpleValueItem(kPageGenericDesktop, kUsageX, kReportId01,
  505. /*bit_index=*/0),
  506. SimpleValueItem(kPageGenericDesktop, kUsageY, kReportId01,
  507. /*bit_index=*/8),
  508. };
  509. MockPreparsedData preparsed_data;
  510. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  511. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  512. .WillOnce(Return(input_items));
  513. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  514. .WillOnce(Return(std::vector<ReportItem>()));
  515. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  516. .WillOnce(Return(std::vector<ReportItem>()));
  517. const auto collection = preparsed_data.CreateHidCollectionInfo();
  518. ASSERT_TRUE(collection->usage);
  519. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  520. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  521. EXPECT_THAT(collection->report_ids, ElementsAre(kReportId01));
  522. ASSERT_EQ(collection->input_reports.size(), 1U);
  523. const auto& report = collection->input_reports[0];
  524. EXPECT_EQ(report->report_id, kReportId01);
  525. ASSERT_EQ(report->items.size(), 2U);
  526. EXPECT_FALSE(report->items[0]->is_range);
  527. EXPECT_FALSE(report->items[0]->is_constant);
  528. EXPECT_TRUE(report->items[0]->is_variable);
  529. ASSERT_EQ(report->items[0]->usages.size(), 1U);
  530. EXPECT_EQ(report->items[0]->usages[0]->usage_page, kPageGenericDesktop);
  531. EXPECT_EQ(report->items[0]->usages[0]->usage, kUsageX);
  532. EXPECT_EQ(report->items[0]->report_size, 8U);
  533. EXPECT_EQ(report->items[0]->report_count, 1U);
  534. EXPECT_FALSE(report->items[1]->is_range);
  535. EXPECT_FALSE(report->items[1]->is_constant);
  536. EXPECT_TRUE(report->items[1]->is_variable);
  537. ASSERT_EQ(report->items[1]->usages.size(), 1U);
  538. EXPECT_EQ(report->items[1]->usages[0]->usage_page, kPageGenericDesktop);
  539. EXPECT_EQ(report->items[1]->usages[0]->usage, kUsageY);
  540. EXPECT_EQ(report->items[1]->report_size, 8U);
  541. EXPECT_EQ(report->items[1]->report_count, 1U);
  542. EXPECT_TRUE(collection->output_reports.empty());
  543. EXPECT_TRUE(collection->feature_reports.empty());
  544. EXPECT_TRUE(collection->children.empty());
  545. }
  546. TEST(HidPreparsedDataTest, TwoValueItemsWithDifferentReportIds) {
  547. HIDP_CAPS capabilities = {0};
  548. capabilities.UsagePage = kPageGenericDesktop;
  549. capabilities.Usage = kUsageMouse;
  550. capabilities.InputReportByteLength = 2;
  551. capabilities.NumberInputValueCaps = 2;
  552. std::vector<ReportItem> input_items = {
  553. SimpleValueItem(kPageGenericDesktop, kUsageX, kReportId01,
  554. /*bit_index=*/0),
  555. SimpleValueItem(kPageGenericDesktop, kUsageY, kReportId02,
  556. /*bit_index=*/0),
  557. };
  558. MockPreparsedData preparsed_data;
  559. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  560. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  561. .WillOnce(Return(input_items));
  562. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  563. .WillOnce(Return(std::vector<ReportItem>()));
  564. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  565. .WillOnce(Return(std::vector<ReportItem>()));
  566. const auto collection = preparsed_data.CreateHidCollectionInfo();
  567. ASSERT_TRUE(collection->usage);
  568. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  569. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  570. EXPECT_THAT(collection->report_ids, ElementsAre(kReportId01, kReportId02));
  571. ASSERT_EQ(collection->input_reports.size(), 2U);
  572. const auto& report01 = collection->input_reports[0];
  573. EXPECT_EQ(report01->report_id, kReportId01);
  574. ASSERT_EQ(report01->items.size(), 1U);
  575. EXPECT_FALSE(report01->items[0]->is_range);
  576. EXPECT_FALSE(report01->items[0]->is_constant);
  577. EXPECT_TRUE(report01->items[0]->is_variable);
  578. ASSERT_EQ(report01->items[0]->usages.size(), 1U);
  579. EXPECT_EQ(report01->items[0]->usages[0]->usage_page, kPageGenericDesktop);
  580. EXPECT_EQ(report01->items[0]->usages[0]->usage, kUsageX);
  581. EXPECT_EQ(report01->items[0]->report_size, 8U);
  582. EXPECT_EQ(report01->items[0]->report_count, 1U);
  583. const auto& report02 = collection->input_reports[1];
  584. EXPECT_EQ(report02->report_id, kReportId02);
  585. ASSERT_EQ(report02->items.size(), 1U);
  586. EXPECT_FALSE(report02->items[0]->is_range);
  587. EXPECT_FALSE(report02->items[0]->is_constant);
  588. EXPECT_TRUE(report02->items[0]->is_variable);
  589. ASSERT_EQ(report02->items[0]->usages.size(), 1U);
  590. EXPECT_EQ(report02->items[0]->usages[0]->usage_page, kPageGenericDesktop);
  591. EXPECT_EQ(report02->items[0]->usages[0]->usage, kUsageY);
  592. EXPECT_EQ(report02->items[0]->report_size, 8U);
  593. EXPECT_EQ(report02->items[0]->report_count, 1U);
  594. EXPECT_TRUE(collection->output_reports.empty());
  595. EXPECT_TRUE(collection->feature_reports.empty());
  596. EXPECT_TRUE(collection->children.empty());
  597. }
  598. TEST(HidPreparsedDataTest, TwoValueItemsWithDifferentReportTypes) {
  599. HIDP_CAPS capabilities = {0};
  600. capabilities.UsagePage = kPageGenericDesktop;
  601. capabilities.Usage = kUsageMouse;
  602. capabilities.InputReportByteLength = 2;
  603. capabilities.OutputReportByteLength = 2;
  604. capabilities.NumberInputValueCaps = 1;
  605. capabilities.NumberOutputValueCaps = 1;
  606. std::vector<ReportItem> input_items = {SimpleValueItem(
  607. kPageGenericDesktop, kUsageX, kReportId01, /*bit_index=*/0)};
  608. std::vector<ReportItem> output_items = {SimpleValueItem(
  609. kPageGenericDesktop, kUsageY, kReportId01, /*bit_index=*/0)};
  610. MockPreparsedData preparsed_data;
  611. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  612. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  613. .WillOnce(Return(input_items));
  614. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  615. .WillOnce(Return(output_items));
  616. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  617. .WillOnce(Return(std::vector<ReportItem>()));
  618. const auto collection = preparsed_data.CreateHidCollectionInfo();
  619. ASSERT_TRUE(collection->usage);
  620. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  621. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  622. EXPECT_THAT(collection->report_ids, ElementsAre(kReportId01));
  623. ASSERT_EQ(collection->input_reports.size(), 1U);
  624. const auto& in_report = collection->input_reports[0];
  625. EXPECT_EQ(in_report->report_id, kReportId01);
  626. ASSERT_EQ(in_report->items.size(), 1U);
  627. EXPECT_FALSE(in_report->items[0]->is_range);
  628. EXPECT_FALSE(in_report->items[0]->is_constant);
  629. EXPECT_TRUE(in_report->items[0]->is_variable);
  630. ASSERT_EQ(in_report->items[0]->usages.size(), 1U);
  631. EXPECT_EQ(in_report->items[0]->usages[0]->usage_page, kPageGenericDesktop);
  632. EXPECT_EQ(in_report->items[0]->usages[0]->usage, kUsageX);
  633. EXPECT_EQ(in_report->items[0]->report_size, 8U);
  634. EXPECT_EQ(in_report->items[0]->report_count, 1U);
  635. ASSERT_EQ(collection->output_reports.size(), 1U);
  636. const auto& out_report = collection->output_reports[0];
  637. EXPECT_EQ(out_report->report_id, kReportId01);
  638. ASSERT_EQ(out_report->items.size(), 1U);
  639. EXPECT_FALSE(out_report->items[0]->is_range);
  640. EXPECT_FALSE(out_report->items[0]->is_constant);
  641. EXPECT_TRUE(out_report->items[0]->is_variable);
  642. ASSERT_EQ(out_report->items[0]->usages.size(), 1U);
  643. EXPECT_EQ(out_report->items[0]->usages[0]->usage_page, kPageGenericDesktop);
  644. EXPECT_EQ(out_report->items[0]->usages[0]->usage, kUsageY);
  645. EXPECT_EQ(out_report->items[0]->report_size, 8U);
  646. EXPECT_EQ(out_report->items[0]->report_count, 1U);
  647. EXPECT_TRUE(collection->feature_reports.empty());
  648. EXPECT_TRUE(collection->children.empty());
  649. }
  650. TEST(HidPreparsedDataTest, ValueItemWithUsageRange) {
  651. HIDP_CAPS capabilities = {0};
  652. capabilities.UsagePage = kPageGenericDesktop;
  653. capabilities.Usage = kUsageMouse;
  654. capabilities.InputReportByteLength = 3;
  655. capabilities.NumberInputValueCaps = 1;
  656. std::vector<ReportItem> input_items = {
  657. RangeValueItem(kPageGenericDesktop, kUsageX, kUsageY, /*report_count=*/2,
  658. kReportId01, /*bit_index=*/0)};
  659. MockPreparsedData preparsed_data;
  660. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  661. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  662. .WillOnce(Return(input_items));
  663. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  664. .WillOnce(Return(std::vector<ReportItem>()));
  665. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  666. .WillOnce(Return(std::vector<ReportItem>()));
  667. const auto collection = preparsed_data.CreateHidCollectionInfo();
  668. ASSERT_TRUE(collection->usage);
  669. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  670. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  671. EXPECT_THAT(collection->report_ids, ElementsAre(kReportId01));
  672. ASSERT_EQ(collection->input_reports.size(), 1U);
  673. const auto& report = collection->input_reports[0];
  674. EXPECT_EQ(report->report_id, kReportId01);
  675. ASSERT_EQ(report->items.size(), 1U);
  676. EXPECT_TRUE(report->items[0]->is_range);
  677. EXPECT_FALSE(report->items[0]->is_constant);
  678. EXPECT_TRUE(report->items[0]->is_variable);
  679. EXPECT_EQ(report->items[0]->usage_minimum->usage_page, kPageGenericDesktop);
  680. EXPECT_EQ(report->items[0]->usage_minimum->usage, kUsageX);
  681. EXPECT_EQ(report->items[0]->usage_maximum->usage_page, kPageGenericDesktop);
  682. EXPECT_EQ(report->items[0]->usage_maximum->usage, kUsageY);
  683. EXPECT_EQ(report->items[0]->report_size, 8U);
  684. EXPECT_EQ(report->items[0]->report_count, 2U);
  685. EXPECT_TRUE(collection->output_reports.empty());
  686. EXPECT_TRUE(collection->feature_reports.empty());
  687. EXPECT_TRUE(collection->children.empty());
  688. }
  689. TEST(HidPreparsedDataTest, ValueItemWithUsageRangeAndRepeatedUsageValue) {
  690. HIDP_CAPS capabilities = {0};
  691. capabilities.UsagePage = kPageGenericDesktop;
  692. capabilities.Usage = kUsageMouse;
  693. capabilities.InputReportByteLength = 3;
  694. capabilities.NumberInputValueCaps = 1;
  695. std::vector<ReportItem> input_items = {
  696. RangeValueItem(kPageGenericDesktop, kUsageX, kUsageX, /*report_count=*/2,
  697. kReportId01, /*bit_index=*/0)};
  698. MockPreparsedData preparsed_data;
  699. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  700. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  701. .WillOnce(Return(input_items));
  702. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  703. .WillOnce(Return(std::vector<ReportItem>()));
  704. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  705. .WillOnce(Return(std::vector<ReportItem>()));
  706. const auto collection = preparsed_data.CreateHidCollectionInfo();
  707. ASSERT_TRUE(collection->usage);
  708. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  709. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  710. EXPECT_THAT(collection->report_ids, ElementsAre(kReportId01));
  711. ASSERT_EQ(collection->input_reports.size(), 1U);
  712. const auto& report = collection->input_reports[0];
  713. EXPECT_EQ(report->report_id, kReportId01);
  714. ASSERT_EQ(report->items.size(), 1U);
  715. EXPECT_FALSE(report->items[0]->is_range);
  716. EXPECT_FALSE(report->items[0]->is_constant);
  717. EXPECT_TRUE(report->items[0]->is_variable);
  718. ASSERT_EQ(report->items[0]->usages.size(), 1U);
  719. EXPECT_EQ(report->items[0]->usages[0]->usage_page, kPageGenericDesktop);
  720. EXPECT_EQ(report->items[0]->usages[0]->usage, kUsageX);
  721. EXPECT_EQ(report->items[0]->report_size, 8U);
  722. EXPECT_EQ(report->items[0]->report_count, 2U);
  723. EXPECT_TRUE(collection->output_reports.empty());
  724. EXPECT_TRUE(collection->feature_reports.empty());
  725. EXPECT_TRUE(collection->children.empty());
  726. }
  727. TEST(HidPreparsedDataTest, ButtonAndValueItemsInSameReport) {
  728. HIDP_CAPS capabilities = {0};
  729. capabilities.UsagePage = kPageGenericDesktop;
  730. capabilities.Usage = kUsageMouse;
  731. capabilities.InputReportByteLength = 3;
  732. capabilities.NumberInputButtonCaps = 1;
  733. capabilities.NumberInputValueCaps = 1;
  734. std::vector<ReportItem> input_items = {
  735. RangeButtonItem(kPageButton, kUsage01, kUsage08, kReportId01,
  736. /*bit_index=*/0),
  737. SimpleValueItem(kPageGenericDesktop, kUsageX, kReportId01,
  738. /*bit_index=*/8),
  739. };
  740. MockPreparsedData preparsed_data;
  741. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  742. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  743. .WillOnce(Return(input_items));
  744. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  745. .WillOnce(Return(std::vector<ReportItem>()));
  746. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  747. .WillOnce(Return(std::vector<ReportItem>()));
  748. const auto collection = preparsed_data.CreateHidCollectionInfo();
  749. ASSERT_TRUE(collection->usage);
  750. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  751. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  752. EXPECT_THAT(collection->report_ids, ElementsAre(kReportId01));
  753. ASSERT_EQ(collection->input_reports.size(), 1U);
  754. const auto& report = collection->input_reports[0];
  755. EXPECT_EQ(report->report_id, kReportId01);
  756. ASSERT_EQ(report->items.size(), 2U);
  757. EXPECT_TRUE(report->items[0]->is_range);
  758. EXPECT_FALSE(report->items[0]->is_constant);
  759. EXPECT_TRUE(report->items[0]->is_variable);
  760. EXPECT_EQ(report->items[0]->usage_minimum->usage_page, kPageButton);
  761. EXPECT_EQ(report->items[0]->usage_minimum->usage, kUsage01);
  762. EXPECT_EQ(report->items[0]->usage_maximum->usage_page, kPageButton);
  763. EXPECT_EQ(report->items[0]->usage_maximum->usage, kUsage08);
  764. EXPECT_EQ(report->items[0]->report_size, 1U);
  765. EXPECT_EQ(report->items[0]->report_count, 8U);
  766. EXPECT_FALSE(report->items[1]->is_range);
  767. EXPECT_FALSE(report->items[1]->is_constant);
  768. EXPECT_TRUE(report->items[1]->is_variable);
  769. ASSERT_EQ(report->items[1]->usages.size(), 1U);
  770. EXPECT_EQ(report->items[1]->usages[0]->usage_page, kPageGenericDesktop);
  771. EXPECT_EQ(report->items[1]->usages[0]->usage, kUsageX);
  772. EXPECT_EQ(report->items[1]->report_size, 8U);
  773. EXPECT_EQ(report->items[1]->report_count, 1U);
  774. EXPECT_TRUE(collection->output_reports.empty());
  775. EXPECT_TRUE(collection->feature_reports.empty());
  776. EXPECT_TRUE(collection->children.empty());
  777. }
  778. TEST(HidPreparsedDataTest, ButtonAndValueItemsInSameReportWithGap) {
  779. HIDP_CAPS capabilities = {0};
  780. capabilities.UsagePage = kPageGenericDesktop;
  781. capabilities.Usage = kUsageMouse;
  782. capabilities.InputReportByteLength = 3;
  783. capabilities.NumberInputButtonCaps = 1;
  784. capabilities.NumberInputValueCaps = 1;
  785. std::vector<ReportItem> input_items = {
  786. SimpleButtonItem(kPageButton, kUsage01, kReportId01, /*bit_index=*/0),
  787. SimpleValueItem(kPageGenericDesktop, kUsageX, kReportId01,
  788. /*bit_index=*/8),
  789. };
  790. MockPreparsedData preparsed_data;
  791. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  792. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  793. .WillOnce(Return(input_items));
  794. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  795. .WillOnce(Return(std::vector<ReportItem>()));
  796. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  797. .WillOnce(Return(std::vector<ReportItem>()));
  798. const auto collection = preparsed_data.CreateHidCollectionInfo();
  799. ASSERT_TRUE(collection->usage);
  800. EXPECT_EQ(collection->usage->usage_page, kPageGenericDesktop);
  801. EXPECT_EQ(collection->usage->usage, kUsageMouse);
  802. EXPECT_THAT(collection->report_ids, ElementsAre(kReportId01));
  803. ASSERT_EQ(collection->input_reports.size(), 1U);
  804. const auto& report = collection->input_reports[0];
  805. EXPECT_EQ(report->report_id, kReportId01);
  806. ASSERT_EQ(report->items.size(), 3U);
  807. EXPECT_FALSE(report->items[0]->is_range);
  808. EXPECT_FALSE(report->items[0]->is_constant);
  809. EXPECT_TRUE(report->items[0]->is_variable);
  810. ASSERT_EQ(report->items[0]->usages.size(), 1U);
  811. EXPECT_EQ(report->items[0]->usages[0]->usage_page, kPageButton);
  812. EXPECT_EQ(report->items[0]->usages[0]->usage, kUsage01);
  813. EXPECT_EQ(report->items[0]->report_size, 1U);
  814. EXPECT_EQ(report->items[0]->report_count, 1U);
  815. EXPECT_TRUE(report->items[1]->is_constant);
  816. EXPECT_EQ(report->items[1]->report_size, 7U);
  817. EXPECT_EQ(report->items[1]->report_count, 1U);
  818. EXPECT_FALSE(report->items[2]->is_range);
  819. EXPECT_FALSE(report->items[2]->is_constant);
  820. EXPECT_TRUE(report->items[2]->is_variable);
  821. ASSERT_EQ(report->items[2]->usages.size(), 1U);
  822. EXPECT_EQ(report->items[2]->usages[0]->usage_page, kPageGenericDesktop);
  823. EXPECT_EQ(report->items[2]->usages[0]->usage, kUsageX);
  824. EXPECT_EQ(report->items[2]->report_size, 8U);
  825. EXPECT_EQ(report->items[2]->report_count, 1U);
  826. EXPECT_TRUE(collection->output_reports.empty());
  827. EXPECT_TRUE(collection->feature_reports.empty());
  828. EXPECT_TRUE(collection->children.empty());
  829. }
  830. TEST(HidPreparsedDataTest, ButtonAndValueItemsInWrongOrderAndOffByteAlignment) {
  831. HIDP_CAPS capabilities = {0};
  832. capabilities.UsagePage = kPageGenericDesktop;
  833. capabilities.Usage = kUsageMouse;
  834. capabilities.InputReportByteLength = 3;
  835. capabilities.NumberInputButtonCaps = 1;
  836. capabilities.NumberInputValueCaps = 1;
  837. std::vector<ReportItem> input_items = {
  838. SimpleButtonItem(kPageButton, kUsage01, kReportId01, /*bit_index=*/15),
  839. SimpleButtonItem(kPageButton, kUsage02, kReportId01, /*bit_index=*/14),
  840. SimpleButtonItem(kPageButton, kUsage03, kReportId01, /*bit_index=*/13),
  841. SimpleButtonItem(kPageButton, kUsage04, kReportId01, /*bit_index=*/12),
  842. SimpleButtonItem(kPageButton, kUsage05, kReportId01, /*bit_index=*/3),
  843. SimpleButtonItem(kPageButton, kUsage06, kReportId01, /*bit_index=*/2),
  844. SimpleButtonItem(kPageButton, kUsage07, kReportId01, /*bit_index=*/1),
  845. SimpleButtonItem(kPageButton, kUsage08, kReportId01, /*bit_index=*/0),
  846. SimpleValueItem(kPageGenericDesktop, kUsageX, kReportId01,
  847. /*bit_index=*/4),
  848. };
  849. MockPreparsedData preparsed_data;
  850. ON_CALL(preparsed_data, GetCaps).WillByDefault(ReturnRef(capabilities));
  851. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Input))
  852. .WillOnce(Return(input_items));
  853. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Output))
  854. .WillOnce(Return(std::vector<ReportItem>()));
  855. EXPECT_CALL(preparsed_data, GetReportItems(HidP_Feature))
  856. .WillOnce(Return(std::vector<ReportItem>()));
  857. const auto collection = preparsed_data.CreateHidCollectionInfo();
  858. ASSERT_EQ(collection->input_reports.size(), 1U);
  859. const auto& report = collection->input_reports[0];
  860. EXPECT_EQ(report->report_id, kReportId01);
  861. ASSERT_EQ(report->items.size(), 9U);
  862. ASSERT_EQ(report->items[0]->usages.size(), 1U);
  863. EXPECT_EQ(report->items[0]->usages[0]->usage_page, kPageButton);
  864. EXPECT_EQ(report->items[0]->usages[0]->usage, kUsage08);
  865. EXPECT_EQ(report->items[0]->report_size, 1U);
  866. EXPECT_EQ(report->items[0]->report_count, 1U);
  867. ASSERT_EQ(report->items[1]->usages.size(), 1U);
  868. EXPECT_EQ(report->items[1]->usages[0]->usage_page, kPageButton);
  869. EXPECT_EQ(report->items[1]->usages[0]->usage, kUsage07);
  870. EXPECT_EQ(report->items[1]->report_size, 1U);
  871. EXPECT_EQ(report->items[1]->report_count, 1U);
  872. ASSERT_EQ(report->items[2]->usages.size(), 1U);
  873. EXPECT_EQ(report->items[2]->usages[0]->usage_page, kPageButton);
  874. EXPECT_EQ(report->items[2]->usages[0]->usage, kUsage06);
  875. EXPECT_EQ(report->items[2]->report_size, 1U);
  876. EXPECT_EQ(report->items[2]->report_count, 1U);
  877. ASSERT_EQ(report->items[3]->usages.size(), 1U);
  878. EXPECT_EQ(report->items[3]->usages[0]->usage_page, kPageButton);
  879. EXPECT_EQ(report->items[3]->usages[0]->usage, kUsage05);
  880. EXPECT_EQ(report->items[3]->report_size, 1U);
  881. EXPECT_EQ(report->items[3]->report_count, 1U);
  882. ASSERT_EQ(report->items[4]->usages.size(), 1U);
  883. EXPECT_EQ(report->items[4]->usages[0]->usage_page, kPageGenericDesktop);
  884. EXPECT_EQ(report->items[4]->usages[0]->usage, kUsageX);
  885. EXPECT_EQ(report->items[4]->report_size, 8U);
  886. EXPECT_EQ(report->items[4]->report_count, 1U);
  887. ASSERT_EQ(report->items[5]->usages.size(), 1U);
  888. EXPECT_EQ(report->items[5]->usages[0]->usage_page, kPageButton);
  889. EXPECT_EQ(report->items[5]->usages[0]->usage, kUsage04);
  890. EXPECT_EQ(report->items[5]->report_size, 1U);
  891. EXPECT_EQ(report->items[5]->report_count, 1U);
  892. ASSERT_EQ(report->items[6]->usages.size(), 1U);
  893. EXPECT_EQ(report->items[6]->usages[0]->usage_page, kPageButton);
  894. EXPECT_EQ(report->items[6]->usages[0]->usage, kUsage03);
  895. EXPECT_EQ(report->items[6]->report_size, 1U);
  896. EXPECT_EQ(report->items[6]->report_count, 1U);
  897. ASSERT_EQ(report->items[7]->usages.size(), 1U);
  898. EXPECT_EQ(report->items[7]->usages[0]->usage_page, kPageButton);
  899. EXPECT_EQ(report->items[7]->usages[0]->usage, kUsage02);
  900. EXPECT_EQ(report->items[7]->report_size, 1U);
  901. EXPECT_EQ(report->items[7]->report_count, 1U);
  902. ASSERT_EQ(report->items[8]->usages.size(), 1U);
  903. EXPECT_EQ(report->items[8]->usages[0]->usage_page, kPageButton);
  904. EXPECT_EQ(report->items[8]->usages[0]->usage, kUsage01);
  905. EXPECT_EQ(report->items[8]->report_size, 1U);
  906. EXPECT_EQ(report->items[8]->report_count, 1U);
  907. }
  908. } // namespace device