usb_descriptors_unittest.cc 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465
  1. // Copyright 2015 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/usb/usb_descriptors.h"
  5. #include <stdint.h>
  6. #include <algorithm>
  7. #include <memory>
  8. #include <string>
  9. #include <utility>
  10. #include "base/bind.h"
  11. #include "base/strings/utf_string_conversions.h"
  12. #include "services/device/usb/mock_usb_device_handle.h"
  13. #include "testing/gtest/include/gtest/gtest.h"
  14. using testing::_;
  15. namespace device {
  16. using mojom::UsbControlTransferRecipient;
  17. using mojom::UsbControlTransferType;
  18. using mojom::UsbSynchronizationType;
  19. using mojom::UsbTransferDirection;
  20. using mojom::UsbTransferStatus;
  21. using mojom::UsbTransferType;
  22. using mojom::UsbUsageType;
  23. namespace {
  24. ACTION_P2(InvokeCallback, data, length) {
  25. size_t transferred_length = std::min(length, arg6->size());
  26. memcpy(arg6->front(), data, transferred_length);
  27. std::move(arg8).Run(UsbTransferStatus::COMPLETED, arg6, transferred_length);
  28. }
  29. void ExpectStringDescriptors(
  30. std::unique_ptr<std::map<uint8_t, std::u16string>> string_map) {
  31. EXPECT_EQ(3u, string_map->size());
  32. EXPECT_EQ(u"String 1", (*string_map)[1]);
  33. EXPECT_EQ(u"String 2", (*string_map)[2]);
  34. EXPECT_EQ(u"String 3", (*string_map)[3]);
  35. }
  36. // clang-format off
  37. const uint8_t kDeviceDescriptor[] = {0x12, 0x01, 0x10, 0x03, 0xFF, 0xFF,
  38. 0xFF, 0x09, 0x34, 0x12, 0x78, 0x56,
  39. 0x00, 0x01, 0x01, 0x02, 0x03, 0x02};
  40. const uint8_t kConfig1Descriptor[] = {
  41. // Config 1
  42. 0x09, 0x02, 0x38, 0x00, 0x02, 0x01, 0x01, 0x01, 0x10,
  43. // Interface Association (0 + 1)
  44. 0x08, 0x0B, 0x00, 0x02, 0xFF, 0xFF, 0xFF, 0x00,
  45. // Interface 0
  46. 0x09, 0x04, 0x00, 0x00, 0x03, 0x12, 0x34, 0x56, 0x02,
  47. // Endpoint 1 IN
  48. 0x07, 0x05, 0x81, 0x02, 0x00, 0x02, 0x00,
  49. // Endpoint 2 IN
  50. 0x07, 0x05, 0x82, 0x03, 0x00, 0x02, 0x04,
  51. // Endpoint 3 OUT
  52. 0x07, 0x05, 0x03, 0x13, 0x00, 0x02, 0x04,
  53. // Interface 1
  54. 0x09, 0x04, 0x01, 0x00, 0x00, 0x78, 0x9A, 0xAB, 0x03,
  55. };
  56. const uint8_t kConfig2Descriptor[] = {
  57. // Config 2
  58. 0x09, 0x02, 0x29, 0x00, 0x01, 0x02, 0x04, 0x03, 0x20,
  59. // Interface 0 (alternate 0)
  60. 0x09, 0x04, 0x00, 0x00, 0x00, 0xCD, 0xEF, 0x01, 0x04,
  61. // Interface 0 (alternate 1)
  62. 0x09, 0x04, 0x00, 0x01, 0x02, 0xCD, 0xEF, 0x01, 0x05,
  63. // Endpoint 1 IN
  64. 0x07, 0x05, 0x81, 0x01, 0x00, 0x04, 0x08,
  65. // Endpoint 2 OUT
  66. 0x07, 0x05, 0x02, 0x11, 0x00, 0x04, 0x08,
  67. };
  68. // clang-format on
  69. void ExpectConfig1Info(const mojom::UsbConfigurationInfo& config) {
  70. // Config 1
  71. EXPECT_EQ(1, config.configuration_value);
  72. EXPECT_FALSE(config.self_powered);
  73. EXPECT_FALSE(config.remote_wakeup);
  74. EXPECT_EQ(16, config.maximum_power);
  75. ASSERT_EQ(2u, config.interfaces.size());
  76. EXPECT_EQ(8u, config.extra_data.size());
  77. // Interface 0
  78. EXPECT_EQ(0, config.interfaces[0]->interface_number);
  79. EXPECT_EQ(0, config.interfaces[0]->first_interface);
  80. const auto& alternate = config.interfaces[0]->alternates[0];
  81. EXPECT_EQ(0, alternate->alternate_setting);
  82. EXPECT_EQ(0x12, alternate->class_code);
  83. EXPECT_EQ(0x34, alternate->subclass_code);
  84. EXPECT_EQ(0x56, alternate->protocol_code);
  85. ASSERT_EQ(3u, alternate->endpoints.size());
  86. EXPECT_EQ(0u, alternate->extra_data.size());
  87. // Endpoint 1 IN
  88. EXPECT_EQ(0x01, alternate->endpoints[0]->endpoint_number);
  89. EXPECT_EQ(UsbTransferDirection::INBOUND, alternate->endpoints[0]->direction);
  90. EXPECT_EQ(512u, alternate->endpoints[0]->packet_size);
  91. EXPECT_EQ(UsbSynchronizationType::NONE,
  92. alternate->endpoints[0]->synchronization_type);
  93. EXPECT_EQ(UsbTransferType::BULK, alternate->endpoints[0]->type);
  94. EXPECT_EQ(UsbUsageType::RESERVED, alternate->endpoints[0]->usage_type);
  95. EXPECT_EQ(0, alternate->endpoints[0]->polling_interval);
  96. EXPECT_EQ(0u, alternate->endpoints[0]->extra_data.size());
  97. // Endpoint 2 IN
  98. EXPECT_EQ(0x02, alternate->endpoints[1]->endpoint_number);
  99. EXPECT_EQ(UsbTransferDirection::INBOUND, alternate->endpoints[1]->direction);
  100. EXPECT_EQ(512u, alternate->endpoints[1]->packet_size);
  101. EXPECT_EQ(UsbSynchronizationType::NONE,
  102. alternate->endpoints[1]->synchronization_type);
  103. EXPECT_EQ(UsbTransferType::INTERRUPT, alternate->endpoints[1]->type);
  104. EXPECT_EQ(UsbUsageType::PERIODIC, alternate->endpoints[1]->usage_type);
  105. EXPECT_EQ(4, alternate->endpoints[1]->polling_interval);
  106. EXPECT_EQ(0u, alternate->endpoints[1]->extra_data.size());
  107. // Endpoint 3 OUT
  108. EXPECT_EQ(0x03, alternate->endpoints[2]->endpoint_number);
  109. EXPECT_EQ(UsbTransferDirection::OUTBOUND, alternate->endpoints[2]->direction);
  110. EXPECT_EQ(512u,
  111. config.interfaces[0]->alternates[0]->endpoints[2]->packet_size);
  112. EXPECT_EQ(UsbSynchronizationType::NONE,
  113. alternate->endpoints[2]->synchronization_type);
  114. EXPECT_EQ(UsbTransferType::INTERRUPT, alternate->endpoints[2]->type);
  115. EXPECT_EQ(UsbUsageType::NOTIFICATION, alternate->endpoints[2]->usage_type);
  116. EXPECT_EQ(4, alternate->endpoints[2]->polling_interval);
  117. EXPECT_EQ(0u, alternate->endpoints[2]->extra_data.size());
  118. // Interface 1
  119. EXPECT_EQ(1, config.interfaces[1]->interface_number);
  120. EXPECT_EQ(0, config.interfaces[1]->first_interface);
  121. EXPECT_EQ(0, config.interfaces[1]->alternates[0]->alternate_setting);
  122. EXPECT_EQ(0x78, config.interfaces[1]->alternates[0]->class_code);
  123. EXPECT_EQ(0x9A, config.interfaces[1]->alternates[0]->subclass_code);
  124. EXPECT_EQ(0xAB, config.interfaces[1]->alternates[0]->protocol_code);
  125. ASSERT_EQ(0u, config.interfaces[1]->alternates[0]->endpoints.size());
  126. EXPECT_EQ(0u, config.interfaces[1]->alternates[0]->extra_data.size());
  127. }
  128. void ExpectConfig2Info(const mojom::UsbConfigurationInfo& config) {
  129. // Config 2
  130. EXPECT_EQ(2, config.configuration_value);
  131. EXPECT_TRUE(config.self_powered);
  132. EXPECT_FALSE(config.remote_wakeup);
  133. EXPECT_EQ(32, config.maximum_power);
  134. ASSERT_EQ(1u, config.interfaces.size());
  135. ASSERT_EQ(2u, config.interfaces[0]->alternates.size());
  136. EXPECT_EQ(0u, config.extra_data.size());
  137. // Interface 0
  138. EXPECT_EQ(0, config.interfaces[0]->interface_number);
  139. EXPECT_EQ(0, config.interfaces[0]->alternates[0]->alternate_setting);
  140. EXPECT_EQ(0xCD, config.interfaces[0]->alternates[0]->class_code);
  141. EXPECT_EQ(0xEF, config.interfaces[0]->alternates[0]->subclass_code);
  142. EXPECT_EQ(0x01, config.interfaces[0]->alternates[0]->protocol_code);
  143. ASSERT_EQ(0u, config.interfaces[0]->alternates[0]->endpoints.size());
  144. EXPECT_EQ(0u, config.interfaces[0]->alternates[0]->extra_data.size());
  145. EXPECT_EQ(0, config.interfaces[0]->first_interface);
  146. // Interface 0 (alternate 1)
  147. const auto& alternate = config.interfaces[0]->alternates[1];
  148. EXPECT_EQ(1, alternate->alternate_setting);
  149. EXPECT_EQ(0xCD, alternate->class_code);
  150. EXPECT_EQ(0xEF, alternate->subclass_code);
  151. EXPECT_EQ(0x01, alternate->protocol_code);
  152. ASSERT_EQ(2u, alternate->endpoints.size());
  153. EXPECT_EQ(0u, alternate->extra_data.size());
  154. // Endpoint 1 IN
  155. EXPECT_EQ(0x01, alternate->endpoints[0]->endpoint_number);
  156. EXPECT_EQ(UsbTransferDirection::INBOUND, alternate->endpoints[0]->direction);
  157. EXPECT_EQ(1024u, alternate->endpoints[0]->packet_size);
  158. EXPECT_EQ(UsbSynchronizationType::NONE,
  159. alternate->endpoints[0]->synchronization_type);
  160. EXPECT_EQ(UsbTransferType::ISOCHRONOUS, alternate->endpoints[0]->type);
  161. EXPECT_EQ(UsbUsageType::DATA, alternate->endpoints[0]->usage_type);
  162. EXPECT_EQ(8, alternate->endpoints[0]->polling_interval);
  163. EXPECT_EQ(0u, alternate->endpoints[0]->extra_data.size());
  164. // Endpoint 2 OUT
  165. EXPECT_EQ(0x02, alternate->endpoints[1]->endpoint_number);
  166. EXPECT_EQ(UsbTransferDirection::OUTBOUND, alternate->endpoints[1]->direction);
  167. EXPECT_EQ(1024u, alternate->endpoints[1]->packet_size);
  168. EXPECT_EQ(UsbSynchronizationType::NONE,
  169. alternate->endpoints[1]->synchronization_type);
  170. EXPECT_EQ(UsbTransferType::ISOCHRONOUS, alternate->endpoints[1]->type);
  171. EXPECT_EQ(UsbUsageType::FEEDBACK, alternate->endpoints[1]->usage_type);
  172. EXPECT_EQ(8, alternate->endpoints[1]->polling_interval);
  173. EXPECT_EQ(0u, alternate->endpoints[1]->extra_data.size());
  174. }
  175. void ExpectDeviceDescriptor(const UsbDeviceDescriptor& descriptor) {
  176. // Device
  177. EXPECT_EQ(0x03, descriptor.device_info->usb_version_major);
  178. EXPECT_EQ(0x01, descriptor.device_info->usb_version_minor);
  179. EXPECT_EQ(0x00, descriptor.device_info->usb_version_subminor);
  180. EXPECT_EQ(0xFF, descriptor.device_info->class_code);
  181. EXPECT_EQ(0xFF, descriptor.device_info->subclass_code);
  182. EXPECT_EQ(0xFF, descriptor.device_info->protocol_code);
  183. EXPECT_EQ(0x1234, descriptor.device_info->vendor_id);
  184. EXPECT_EQ(0x5678, descriptor.device_info->product_id);
  185. EXPECT_EQ(0x01, descriptor.device_info->device_version_major);
  186. EXPECT_EQ(0x00, descriptor.device_info->device_version_minor);
  187. EXPECT_EQ(0x00, descriptor.device_info->device_version_subminor);
  188. ASSERT_EQ(2u, descriptor.device_info->configurations.size());
  189. ExpectConfig1Info(*descriptor.device_info->configurations[0]);
  190. ExpectConfig2Info(*descriptor.device_info->configurations[1]);
  191. }
  192. void OnReadDescriptors(std::unique_ptr<UsbDeviceDescriptor> descriptor) {
  193. ASSERT_TRUE(descriptor);
  194. ExpectDeviceDescriptor(*descriptor);
  195. }
  196. class UsbDescriptorsTest : public ::testing::Test {};
  197. TEST_F(UsbDescriptorsTest, ParseDescriptor) {
  198. std::vector<uint8_t> buffer;
  199. buffer.insert(buffer.end(), kDeviceDescriptor,
  200. kDeviceDescriptor + sizeof(kDeviceDescriptor));
  201. buffer.insert(buffer.end(), kConfig1Descriptor,
  202. kConfig1Descriptor + sizeof(kConfig1Descriptor));
  203. buffer.insert(buffer.end(), kConfig2Descriptor,
  204. kConfig2Descriptor + sizeof(kConfig2Descriptor));
  205. UsbDeviceDescriptor descriptor;
  206. ASSERT_TRUE(descriptor.Parse(buffer));
  207. ExpectDeviceDescriptor(descriptor);
  208. }
  209. TEST_F(UsbDescriptorsTest, ReadDescriptors) {
  210. scoped_refptr<MockUsbDeviceHandle> device_handle(
  211. new MockUsbDeviceHandle(nullptr));
  212. EXPECT_CALL(*device_handle,
  213. ControlTransferInternal(UsbTransferDirection::INBOUND,
  214. UsbControlTransferType::STANDARD,
  215. UsbControlTransferRecipient::DEVICE, 0x06,
  216. 0x0100, 0x0000, _, _, _))
  217. .WillOnce(InvokeCallback(kDeviceDescriptor, sizeof(kDeviceDescriptor)));
  218. EXPECT_CALL(*device_handle,
  219. ControlTransferInternal(UsbTransferDirection::INBOUND,
  220. UsbControlTransferType::STANDARD,
  221. UsbControlTransferRecipient::DEVICE, 0x06,
  222. 0x0200, 0x0000, _, _, _))
  223. .Times(2)
  224. .WillRepeatedly(
  225. InvokeCallback(kConfig1Descriptor, sizeof(kConfig1Descriptor)));
  226. EXPECT_CALL(*device_handle,
  227. ControlTransferInternal(UsbTransferDirection::INBOUND,
  228. UsbControlTransferType::STANDARD,
  229. UsbControlTransferRecipient::DEVICE, 0x06,
  230. 0x0201, 0x0000, _, _, _))
  231. .Times(2)
  232. .WillRepeatedly(
  233. InvokeCallback(kConfig2Descriptor, sizeof(kConfig2Descriptor)));
  234. ReadUsbDescriptors(device_handle, base::BindOnce(&OnReadDescriptors));
  235. }
  236. TEST_F(UsbDescriptorsTest, NoInterfaceAssociations) {
  237. mojom::UsbConfigurationInfoPtr config =
  238. BuildUsbConfigurationInfoPtr(1, false, false, 0);
  239. config->interfaces.push_back(BuildUsbInterfaceInfoPtr(0, 0, 255, 255, 255));
  240. config->interfaces.push_back(BuildUsbInterfaceInfoPtr(0, 1, 255, 255, 255));
  241. config->interfaces.push_back(BuildUsbInterfaceInfoPtr(1, 0, 255, 255, 255));
  242. AssignFirstInterfaceNumbers(config.get());
  243. EXPECT_EQ(0, config->interfaces[0]->first_interface);
  244. EXPECT_EQ(0, config->interfaces[1]->first_interface);
  245. EXPECT_EQ(1, config->interfaces[2]->first_interface);
  246. }
  247. TEST_F(UsbDescriptorsTest, InterfaceAssociations) {
  248. // Links interfaces 0 and 1 into a single function.
  249. static const uint8_t kIAD1[] = {0x08, 0x0b, 0x00, 0x02,
  250. 0xff, 0xff, 0xff, 0x00};
  251. // Only references a single interface, 2.
  252. static const uint8_t kIAD2[] = {0x08, 0x0b, 0x02, 0x01,
  253. 0xff, 0xff, 0xff, 0x00};
  254. // Malformed. References interface 3 but bInterfaceCount is 0.
  255. static const uint8_t kIAD3[] = {0x08, 0x0b, 0x03, 0x00,
  256. 0xff, 0xff, 0xff, 0x00};
  257. // Links interfaces 4 and 5 into a single function.
  258. static const uint8_t kIAD4[] = {0x08, 0x0b, 0x04, 0x02,
  259. 0xff, 0xff, 0xff, 0x00};
  260. mojom::UsbConfigurationInfoPtr config =
  261. BuildUsbConfigurationInfoPtr(1, false, false, 0);
  262. config->extra_data.assign(kIAD1, kIAD1 + sizeof(kIAD1));
  263. config->extra_data.insert(config->extra_data.end(), kIAD2,
  264. kIAD2 + sizeof(kIAD2));
  265. config->interfaces.push_back(BuildUsbInterfaceInfoPtr(0, 0, 255, 255, 255));
  266. config->interfaces.push_back(BuildUsbInterfaceInfoPtr(1, 0, 255, 255, 255));
  267. mojom::UsbInterfaceInfoPtr iface1a =
  268. BuildUsbInterfaceInfoPtr(1, 1, 255, 255, 255);
  269. iface1a->alternates[0]->extra_data.assign(kIAD3, kIAD3 + sizeof(kIAD3));
  270. config->interfaces.push_back(std::move(iface1a));
  271. config->interfaces.push_back(BuildUsbInterfaceInfoPtr(2, 0, 255, 255, 255));
  272. config->interfaces.push_back(BuildUsbInterfaceInfoPtr(3, 0, 255, 255, 255));
  273. mojom::UsbInterfaceInfoPtr iface4 =
  274. BuildUsbInterfaceInfoPtr(4, 0, 255, 255, 255);
  275. iface4->alternates[0]->extra_data.assign(kIAD4, kIAD4 + sizeof(kIAD4));
  276. config->interfaces.push_back(std::move(iface4));
  277. config->interfaces.push_back(BuildUsbInterfaceInfoPtr(5, 0, 255, 255, 255));
  278. AssignFirstInterfaceNumbers(config.get());
  279. // Interfaces 0 and 1 (plus 1's alternate) are a single function.
  280. EXPECT_EQ(0, config->interfaces[0]->interface_number);
  281. EXPECT_EQ(0, config->interfaces[0]->first_interface);
  282. EXPECT_EQ(1, config->interfaces[1]->interface_number);
  283. EXPECT_EQ(0, config->interfaces[1]->first_interface);
  284. EXPECT_EQ(1, config->interfaces[2]->interface_number);
  285. EXPECT_EQ(0, config->interfaces[2]->first_interface);
  286. // Interfaces 2 and 3 are their own functions.
  287. EXPECT_EQ(2, config->interfaces[3]->interface_number);
  288. EXPECT_EQ(2, config->interfaces[3]->first_interface);
  289. EXPECT_EQ(3, config->interfaces[4]->interface_number);
  290. EXPECT_EQ(3, config->interfaces[4]->first_interface);
  291. // Interfaces 4 and 5 are a single function.
  292. EXPECT_EQ(4, config->interfaces[5]->interface_number);
  293. EXPECT_EQ(4, config->interfaces[5]->first_interface);
  294. EXPECT_EQ(5, config->interfaces[6]->interface_number);
  295. EXPECT_EQ(4, config->interfaces[6]->first_interface);
  296. }
  297. TEST_F(UsbDescriptorsTest, CorruptInterfaceAssociations) {
  298. {
  299. // Descriptor is too short.
  300. static const uint8_t kIAD[] = {0x01};
  301. mojom::UsbConfigurationInfoPtr config =
  302. BuildUsbConfigurationInfoPtr(1, false, false, 0);
  303. config->extra_data.assign(kIAD, kIAD + sizeof(kIAD));
  304. AssignFirstInterfaceNumbers(config.get());
  305. }
  306. {
  307. // Descriptor is too long.
  308. static const uint8_t kIAD[] = {0x09, 0x0b, 0x00, 0x00,
  309. 0x00, 0x00, 0x00, 0x00};
  310. mojom::UsbConfigurationInfoPtr config =
  311. BuildUsbConfigurationInfoPtr(1, false, false, 0);
  312. config->extra_data.assign(kIAD, kIAD + sizeof(kIAD));
  313. AssignFirstInterfaceNumbers(config.get());
  314. }
  315. {
  316. // References an undefined interface.
  317. static const uint8_t kIAD[] = {0x08, 0x0b, 0x07, 0x00,
  318. 0xff, 0xff, 0xff, 0x00};
  319. mojom::UsbConfigurationInfoPtr config =
  320. BuildUsbConfigurationInfoPtr(1, false, false, 0);
  321. config->interfaces.push_back(BuildUsbInterfaceInfoPtr(0, 0, 255, 255, 255));
  322. config->extra_data.assign(kIAD, kIAD + sizeof(kIAD));
  323. AssignFirstInterfaceNumbers(config.get());
  324. EXPECT_EQ(0, config->interfaces[0]->interface_number);
  325. EXPECT_EQ(0, config->interfaces[0]->first_interface);
  326. }
  327. }
  328. TEST_F(UsbDescriptorsTest, StringDescriptor) {
  329. static const uint8_t kBuffer[] = {0x1a, 0x03, 'H', 0, 'e', 0, 'l', 0, 'l', 0,
  330. 'o', 0, ' ', 0, 'w', 0, 'o', 0, 'r', 0,
  331. 'l', 0, 'd', 0, '!', 0};
  332. std::u16string string;
  333. ASSERT_TRUE(ParseUsbStringDescriptor(
  334. std::vector<uint8_t>(kBuffer, kBuffer + sizeof(kBuffer)), &string));
  335. EXPECT_EQ(u"Hello world!", string);
  336. }
  337. TEST_F(UsbDescriptorsTest, ShortStringDescriptorHeader) {
  338. // The buffer is just too darn short.
  339. static const uint8_t kBuffer[] = {0x01};
  340. std::u16string string;
  341. ASSERT_FALSE(ParseUsbStringDescriptor(
  342. std::vector<uint8_t>(kBuffer, kBuffer + sizeof(kBuffer)), &string));
  343. }
  344. TEST_F(UsbDescriptorsTest, ShortStringDescriptor) {
  345. // The buffer is just too darn short.
  346. static const uint8_t kBuffer[] = {0x01, 0x03};
  347. std::u16string string;
  348. ASSERT_FALSE(ParseUsbStringDescriptor(
  349. std::vector<uint8_t>(kBuffer, kBuffer + sizeof(kBuffer)), &string));
  350. }
  351. TEST_F(UsbDescriptorsTest, OddLengthStringDescriptor) {
  352. // There's an extra byte at the end of the string.
  353. static const uint8_t kBuffer[] = {0x0d, 0x03, 'H', 0, 'e', 0, 'l',
  354. 0, 'l', 0, 'o', 0, '!'};
  355. std::u16string string;
  356. ASSERT_TRUE(ParseUsbStringDescriptor(
  357. std::vector<uint8_t>(kBuffer, kBuffer + sizeof(kBuffer)), &string));
  358. EXPECT_EQ(u"Hello", string);
  359. }
  360. TEST_F(UsbDescriptorsTest, EmptyStringDescriptor) {
  361. // The string is empty.
  362. static const uint8_t kBuffer[] = {0x02, 0x03};
  363. std::u16string string;
  364. ASSERT_TRUE(ParseUsbStringDescriptor(
  365. std::vector<uint8_t>(kBuffer, kBuffer + sizeof(kBuffer)), &string));
  366. EXPECT_EQ(std::u16string(), string);
  367. }
  368. TEST_F(UsbDescriptorsTest, OneByteStringDescriptor) {
  369. // The string is only one byte.
  370. static const uint8_t kBuffer[] = {0x03, 0x03, '?'};
  371. std::u16string string;
  372. ASSERT_TRUE(ParseUsbStringDescriptor(
  373. std::vector<uint8_t>(kBuffer, kBuffer + sizeof(kBuffer)), &string));
  374. EXPECT_EQ(std::u16string(), string);
  375. }
  376. TEST_F(UsbDescriptorsTest, ReadStringDescriptors) {
  377. std::unique_ptr<std::map<uint8_t, std::u16string>> string_map(
  378. new std::map<uint8_t, std::u16string>());
  379. (*string_map)[1] = std::u16string();
  380. (*string_map)[2] = std::u16string();
  381. (*string_map)[3] = std::u16string();
  382. scoped_refptr<MockUsbDeviceHandle> device_handle(
  383. new MockUsbDeviceHandle(nullptr));
  384. static const uint8_t kStringDescriptor0[] = {0x04, 0x03, 0x21, 0x43};
  385. EXPECT_CALL(*device_handle,
  386. ControlTransferInternal(UsbTransferDirection::INBOUND,
  387. UsbControlTransferType::STANDARD,
  388. UsbControlTransferRecipient::DEVICE, 0x06,
  389. 0x0300, 0x0000, _, _, _))
  390. .WillOnce(InvokeCallback(kStringDescriptor0, sizeof(kStringDescriptor0)));
  391. static const uint8_t kStringDescriptor1[] = {0x12, 0x03, 'S', 0, 't', 0,
  392. 'r', 0, 'i', 0, 'n', 0,
  393. 'g', 0, ' ', 0, '1', 0};
  394. EXPECT_CALL(*device_handle,
  395. ControlTransferInternal(UsbTransferDirection::INBOUND,
  396. UsbControlTransferType::STANDARD,
  397. UsbControlTransferRecipient::DEVICE, 0x06,
  398. 0x0301, 0x4321, _, _, _))
  399. .WillOnce(InvokeCallback(kStringDescriptor1, sizeof(kStringDescriptor1)));
  400. static const uint8_t kStringDescriptor2[] = {0x12, 0x03, 'S', 0, 't', 0,
  401. 'r', 0, 'i', 0, 'n', 0,
  402. 'g', 0, ' ', 0, '2', 0};
  403. EXPECT_CALL(*device_handle,
  404. ControlTransferInternal(UsbTransferDirection::INBOUND,
  405. UsbControlTransferType::STANDARD,
  406. UsbControlTransferRecipient::DEVICE, 0x06,
  407. 0x0302, 0x4321, _, _, _))
  408. .WillOnce(InvokeCallback(kStringDescriptor2, sizeof(kStringDescriptor2)));
  409. static const uint8_t kStringDescriptor3[] = {0x12, 0x03, 'S', 0, 't', 0,
  410. 'r', 0, 'i', 0, 'n', 0,
  411. 'g', 0, ' ', 0, '3', 0};
  412. EXPECT_CALL(*device_handle,
  413. ControlTransferInternal(UsbTransferDirection::INBOUND,
  414. UsbControlTransferType::STANDARD,
  415. UsbControlTransferRecipient::DEVICE, 0x06,
  416. 0x0303, 0x4321, _, _, _))
  417. .WillOnce(InvokeCallback(kStringDescriptor3, sizeof(kStringDescriptor3)));
  418. ReadUsbStringDescriptors(device_handle, std::move(string_map),
  419. base::BindOnce(&ExpectStringDescriptors));
  420. }
  421. } // namespace
  422. } // namespace device