tools/usb_gadget/gadget_test.py

   1 #!/usr/bin/python
   2 # Copyright 2014 The Chromium Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 import unittest
   7
   8 import mock
   9
  10 import gadget
  11 import usb_constants
  12 import usb_descriptors
  13
  14
  15 device_desc = usb_descriptors.DeviceDescriptor(
  16     idVendor=0x18D1,   # Google Inc.
  17     idProduct=0xFF00,
  18     bcdUSB=0x0200,
  19     iManufacturer=1,
  20     iProduct=2,
  21     iSerialNumber=3,
  22     bNumConfigurations=1,
  23     bcdDevice=0x0100)
  24
  25 fs_config_desc = usb_descriptors.ConfigurationDescriptor(
  26     bmAttributes=0xC0,
  27     MaxPower=50)
  28
  29 fs_interface_desc = usb_descriptors.InterfaceDescriptor(
  30     bInterfaceNumber=0
  31 )
  32 fs_config_desc.AddInterface(fs_interface_desc)
  33
  34 fs_bulk_in_endpoint_desc = usb_descriptors.EndpointDescriptor(
  35     bEndpointAddress=0x01,
  36     bmAttributes=usb_constants.TransferType.BULK,
  37     wMaxPacketSize=64,
  38     bInterval=0
  39 )
  40 fs_interface_desc.AddEndpoint(fs_bulk_in_endpoint_desc)
  41
  42 fs_bulk_out_endpoint_desc = usb_descriptors.EndpointDescriptor(
  43     bEndpointAddress=0x81,
  44     bmAttributes=usb_constants.TransferType.BULK,
  45     wMaxPacketSize=64,
  46     bInterval=0
  47 )
  48 fs_interface_desc.AddEndpoint(fs_bulk_out_endpoint_desc)
  49
  50 fs_alt_interface_desc = usb_descriptors.InterfaceDescriptor(
  51     bInterfaceNumber=0,
  52     bAlternateSetting=1
  53 )
  54 fs_config_desc.AddInterface(fs_alt_interface_desc)
  55
  56 fs_interrupt_in_endpoint_desc = usb_descriptors.EndpointDescriptor(
  57     bEndpointAddress=0x01,
  58     bmAttributes=usb_constants.TransferType.INTERRUPT,
  59     wMaxPacketSize=64,
  60     bInterval=1
  61 )
  62 fs_alt_interface_desc.AddEndpoint(fs_interrupt_in_endpoint_desc)
  63
  64 fs_interrupt_out_endpoint_desc = usb_descriptors.EndpointDescriptor(
  65     bEndpointAddress=0x81,
  66     bmAttributes=usb_constants.TransferType.INTERRUPT,
  67     wMaxPacketSize=64,
  68     bInterval=1
  69 )
  70 fs_alt_interface_desc.AddEndpoint(fs_interrupt_out_endpoint_desc)
  71
  72 hs_config_desc = usb_descriptors.ConfigurationDescriptor(
  73     bmAttributes=0xC0,
  74     MaxPower=50)
  75
  76 hs_interface_desc = usb_descriptors.InterfaceDescriptor(
  77     bInterfaceNumber=0
  78 )
  79 hs_config_desc.AddInterface(hs_interface_desc)
  80
  81 hs_bulk_in_endpoint_desc = usb_descriptors.EndpointDescriptor(
  82     bEndpointAddress=0x01,
  83     bmAttributes=usb_constants.TransferType.BULK,
  84     wMaxPacketSize=512,
  85     bInterval=0
  86 )
  87 hs_interface_desc.AddEndpoint(hs_bulk_in_endpoint_desc)
  88
  89 hs_bulk_out_endpoint_desc = usb_descriptors.EndpointDescriptor(
  90     bEndpointAddress=0x81,
  91     bmAttributes=usb_constants.TransferType.BULK,
  92     wMaxPacketSize=512,
  93     bInterval=0
  94 )
  95 hs_interface_desc.AddEndpoint(hs_bulk_out_endpoint_desc)
  96
  97 hs_alt_interface_desc = usb_descriptors.InterfaceDescriptor(
  98     bInterfaceNumber=0,
  99     bAlternateSetting=1
 100 )
 101 hs_config_desc.AddInterface(hs_alt_interface_desc)
 102
 103 hs_interrupt_in_endpoint_desc = usb_descriptors.EndpointDescriptor(
 104     bEndpointAddress=0x01,
 105     bmAttributes=usb_constants.TransferType.INTERRUPT,
 106     wMaxPacketSize=256,
 107     bInterval=1
 108 )
 109 hs_alt_interface_desc.AddEndpoint(hs_interrupt_in_endpoint_desc)
 110
 111 hs_interrupt_out_endpoint_desc = usb_descriptors.EndpointDescriptor(
 112     bEndpointAddress=0x81,
 113     bmAttributes=usb_constants.TransferType.INTERRUPT,
 114     wMaxPacketSize=256,
 115     bInterval=1
 116 )
 117 hs_alt_interface_desc.AddEndpoint(hs_interrupt_out_endpoint_desc)
 118
 119
 120 class GadgetTest(unittest.TestCase):
 121
 122   def test_get_descriptors(self):
 123     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 124     self.assertEquals(g.GetDeviceDescriptor(), device_desc)
 125     self.assertEquals(g.GetFullSpeedConfigurationDescriptor(), fs_config_desc)
 126     self.assertEquals(g.GetHighSpeedConfigurationDescriptor(), hs_config_desc)
 127     with self.assertRaisesRegexp(RuntimeError, 'not connected'):
 128       g.GetConfigurationDescriptor()
 129
 130   def test_connect_full_speed(self):
 131     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 132     g.Connected(mock.Mock(), usb_constants.Speed.FULL)
 133     self.assertTrue(g.IsConnected())
 134     self.assertEquals(g.GetSpeed(), usb_constants.Speed.FULL)
 135     self.assertEquals(g.GetConfigurationDescriptor(), fs_config_desc)
 136     g.Disconnected()
 137     self.assertFalse(g.IsConnected())
 138
 139   def test_connect_high_speed(self):
 140     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 141     g.Connected(mock.Mock(), usb_constants.Speed.HIGH)
 142     self.assertTrue(g.IsConnected())
 143     self.assertEquals(g.GetSpeed(), usb_constants.Speed.HIGH)
 144     self.assertEquals(g.GetConfigurationDescriptor(), hs_config_desc)
 145     g.Disconnected()
 146     self.assertFalse(g.IsConnected())
 147
 148   def test_string_index_out_of_range(self):
 149     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 150     with self.assertRaisesRegexp(ValueError, 'index out of range'):
 151       g.AddStringDescriptor(0, 'Hello world!')
 152
 153   def test_language_id_out_of_range(self):
 154     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 155     with self.assertRaisesRegexp(ValueError, 'language code out of range'):
 156       g.AddStringDescriptor(1, 'Hello world!', lang=-1)
 157
 158   def test_get_languages(self):
 159     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 160     g.AddStringDescriptor(1, 'Hello world!')
 161     desc = g.ControlRead(0x80, 6, 0x0300, 0, 255)
 162     self.assertEquals(desc, '\x04\x03\x09\x04')
 163
 164   def test_get_string_descriptor(self):
 165     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 166     g.AddStringDescriptor(1, 'Hello world!')
 167     desc = g.ControlRead(0x80, 6, 0x0301, 0x0409, 255)
 168     self.assertEquals(desc, '\x1A\x03H\0e\0l\0l\0o\0 \0w\0o\0r\0l\0d\0!\0')
 169
 170   def test_get_missing_string_descriptor(self):
 171     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 172     g.AddStringDescriptor(1, 'Hello world!')
 173     desc = g.ControlRead(0x80, 6, 0x0302, 0x0409, 255)
 174     self.assertEquals(desc, None)
 175
 176   def test_get_missing_string_language(self):
 177     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 178     g.AddStringDescriptor(1, 'Hello world!')
 179     desc = g.ControlRead(0x80, 6, 0x0301, 0x040C, 255)
 180     self.assertEquals(desc, None)
 181
 182   def test_class_and_vendor_transfers(self):
 183     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 184     self.assertIsNone(g.ControlRead(0xA0, 0, 0, 0, 0))
 185     self.assertIsNone(g.ControlRead(0xC0, 0, 0, 0, 0))
 186     self.assertIsNone(g.ControlWrite(0x20, 0, 0, 0, ''))
 187     self.assertIsNone(g.ControlWrite(0x40, 0, 0, 0, ''))
 188
 189   def test_set_configuration(self):
 190     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 191     chip = mock.Mock()
 192     g.Connected(chip, usb_constants.Speed.HIGH)
 193     g.ControlWrite(0, 9, 1, 0, 0)
 194     chip.StartEndpoint.assert_has_calls([
 195         mock.call(hs_bulk_in_endpoint_desc),
 196         mock.call(hs_bulk_out_endpoint_desc)
 197     ])
 198
 199   def test_set_configuration_zero(self):
 200     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 201     chip = mock.Mock()
 202     g.Connected(chip, usb_constants.Speed.HIGH)
 203     g.ControlWrite(0, 9, 1, 0, 0)
 204     chip.StartEndpoint.reset_mock()
 205     g.ControlWrite(0, 9, 0, 0, 0)
 206     chip.StopEndpoint.assert_has_calls([
 207         mock.call(0x01),
 208         mock.call(0x81)
 209     ])
 210
 211   def test_set_bad_configuration(self):
 212     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 213     g.Connected(mock.Mock(), usb_constants.Speed.HIGH)
 214     self.assertIsNone(g.ControlWrite(0, 9, 2, 0, 0))
 215
 216   def test_set_interface(self):
 217     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 218     chip = mock.Mock()
 219     g.Connected(chip, usb_constants.Speed.HIGH)
 220     self.assertTrue(g.ControlWrite(0, 9, 1, 0, 0))
 221     chip.reset_mock()
 222     self.assertTrue(g.ControlWrite(1, 11, 1, 0, 0))
 223     chip.StopEndpoint.assert_has_calls([
 224         mock.call(0x01),
 225         mock.call(0x81)
 226     ])
 227     chip.StartEndpoint.assert_has_calls([
 228         mock.call(hs_interrupt_in_endpoint_desc),
 229         mock.call(hs_interrupt_out_endpoint_desc)
 230     ])
 231     chip.reset_mock()
 232     self.assertTrue(g.ControlWrite(1, 11, 0, 0, 0))
 233     chip.StopEndpoint.assert_has_calls([
 234         mock.call(0x01),
 235         mock.call(0x81)
 236     ])
 237     chip.StartEndpoint.assert_has_calls([
 238         mock.call(hs_bulk_in_endpoint_desc),
 239         mock.call(hs_bulk_out_endpoint_desc)
 240     ])
 241
 242   def test_set_bad_interface(self):
 243     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 244     g.Connected(mock.Mock(), usb_constants.Speed.HIGH)
 245     self.assertTrue(g.ControlWrite(0, 9, 1, 0, 0))
 246     self.assertIsNone(g.ControlWrite(1, 11, 0, 1, 0))
 247
 248   def test_send_packet(self):
 249     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 250     chip = mock.Mock()
 251     g.Connected(chip, usb_constants.Speed.HIGH)
 252     g.SendPacket(0x81, 'Hello world!')
 253     chip.SendPacket.assert_called_once_with(0x81, 'Hello world!')
 254
 255   def test_send_packet_disconnected(self):
 256     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 257     with self.assertRaisesRegexp(RuntimeError, 'not connected'):
 258       g.SendPacket(0x81, 'Hello world!')
 259     g.Connected(mock.Mock(), usb_constants.Speed.HIGH)
 260     g.SendPacket(0x81, 'Hello world!')
 261     g.Disconnected()
 262     with self.assertRaisesRegexp(RuntimeError, 'not connected'):
 263       g.SendPacket(0x81, 'Hello world!')
 264
 265   def test_send_invalid_endpoint(self):
 266     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 267     chip = mock.Mock()
 268     g.Connected(chip, usb_constants.Speed.HIGH)
 269     with self.assertRaisesRegexp(ValueError, 'non-input endpoint'):
 270       g.SendPacket(0x01, 'Hello world!')
 271
 272   def test_receive_packet(self):
 273     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 274     self.assertIsNone(g.ReceivePacket(0x01, 'Hello world!'))
 275
 276   def test_halt_endpoint(self):
 277     g = gadget.Gadget(device_desc, fs_config_desc, hs_config_desc)
 278     chip = mock.Mock()
 279     g.Connected(chip, usb_constants.Speed.HIGH)
 280     g.HaltEndpoint(0x01)
 281     chip.HaltEndpoint.assert_called_once_with(0x01)
 282
 283
 284 if __name__ == '__main__':
 285   unittest.main()