tools/usb_gadget/usb_descriptors_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 hid_constants
   9 import usb_descriptors
  10
  11
  12 class DescriptorWithField(usb_descriptors.Descriptor):
  13   pass
  14
  15 DescriptorWithField.AddField('bField', 'B')
  16
  17
  18 class DescriptorWithDefault(usb_descriptors.Descriptor):
  19   pass
  20
  21 DescriptorWithDefault.AddField('bDefault', 'B', default=42)
  22
  23
  24 class DescriptorWithFixed(usb_descriptors.Descriptor):
  25   pass
  26
  27 DescriptorWithFixed.AddFixedField('bFixed', 'B', 42)
  28
  29
  30 class DescriptorWithComputed(usb_descriptors.Descriptor):
  31
  32   @property
  33   def foo(self):
  34     return 42
  35
  36 DescriptorWithComputed.AddComputedField('bComputed', 'B', 'foo')
  37
  38
  39 class DescriptorWithDescriptors(usb_descriptors.DescriptorContainer):
  40   pass
  41
  42 DescriptorWithDescriptors.AddField('bType', 'B')
  43
  44
  45 class DescriptorTest(unittest.TestCase):
  46
  47   def test_default(self):
  48     obj = DescriptorWithDefault()
  49     self.assertEquals(obj.bDefault, 42)
  50
  51   def test_change_default(self):
  52     obj = DescriptorWithDefault()
  53     obj.bDefault = 1
  54     self.assertEquals(obj.bDefault, 1)
  55
  56   def test_override_default(self):
  57     obj = DescriptorWithDefault(bDefault=56)
  58     self.assertEquals(obj.bDefault, 56)
  59
  60   def test_fixed(self):
  61     obj = DescriptorWithFixed()
  62     self.assertEquals(obj.bFixed, 42)
  63
  64   def test_set_fixed(self):
  65     with self.assertRaises(RuntimeError):
  66       DescriptorWithFixed(bFixed=1)
  67
  68   def test_modify_fixed(self):
  69     obj = DescriptorWithFixed()
  70     with self.assertRaises(RuntimeError):
  71       obj.bFixed = 1
  72
  73   def test_computed(self):
  74     obj = DescriptorWithComputed()
  75     self.assertEquals(obj.bComputed, 42)
  76
  77   def test_set_computed(self):
  78     with self.assertRaises(RuntimeError):
  79       DescriptorWithComputed(bComputed=1)
  80
  81   def test_modify_computed(self):
  82     obj = DescriptorWithComputed()
  83     with self.assertRaises(RuntimeError):
  84       obj.bComputed = 1
  85
  86   def test_unexpected(self):
  87     with self.assertRaisesRegexp(TypeError, 'Unexpected'):
  88       DescriptorWithField(bUnexpected=1)
  89
  90   def test_missing(self):
  91     with self.assertRaisesRegexp(TypeError, 'Missing'):
  92       DescriptorWithField()
  93
  94   def test_size(self):
  95     obj = DescriptorWithField(bField=42)
  96     self.assertEquals(obj.struct_size, 1)
  97     self.assertEquals(obj.total_size, 1)
  98
  99   def test_encode(self):
 100     obj = DescriptorWithField(bField=0xff)
 101     self.assertEquals(obj.Encode(), '\xff')
 102
 103   def test_string(self):
 104     obj = DescriptorWithField(bField=42)
 105     string = str(obj)
 106     self.assertIn('bField', string)
 107     self.assertIn('42', string)
 108
 109   def test_container(self):
 110     parent = DescriptorWithDescriptors(bType=0)
 111     child1 = DescriptorWithField(bField=1)
 112     parent.Add(child1)
 113     child2 = DescriptorWithField(bField=2)
 114     parent.Add(child2)
 115     self.assertEquals(parent.total_size, 3)
 116     self.assertEquals(parent.Encode(), '\x00\x01\x02')
 117     string = str(parent)
 118     self.assertIn('bType', string)
 119     self.assertIn('bField', string)
 120
 121
 122 class TestUsbDescriptors(unittest.TestCase):
 123
 124   def test_device_descriptor(self):
 125     device_desc = usb_descriptors.DeviceDescriptor(
 126         idVendor=0xDEAD,
 127         idProduct=0xBEEF,
 128         bcdDevice=0x0100,
 129         bNumConfigurations=1)
 130     self.assertEquals(
 131         device_desc.Encode(),
 132         '\x12\x01\x00\x02\x00\x00\x00\x40\xAD\xDE\xEF\xBE\x00\x01\x00\x00\x00'
 133         '\x01')
 134
 135   def test_unique_interfaces(self):
 136     interface_desc1 = usb_descriptors.InterfaceDescriptor(bInterfaceNumber=1)
 137     interface_desc2 = usb_descriptors.InterfaceDescriptor(bInterfaceNumber=1,
 138                                                           bAlternateSetting=1)
 139     interface_desc3 = usb_descriptors.InterfaceDescriptor(bInterfaceNumber=1)
 140
 141     configuration_desc = usb_descriptors.ConfigurationDescriptor(
 142         bmAttributes=0xC0,
 143         MaxPower=100)
 144     configuration_desc.AddInterface(interface_desc1)
 145     configuration_desc.AddInterface(interface_desc2)
 146     with self.assertRaisesRegexp(RuntimeError, r'Interface 1 \(alternate 0\)'):
 147       configuration_desc.AddInterface(interface_desc3)
 148
 149   def test_unique_endpoints(self):
 150     endpoint_desc1 = usb_descriptors.EndpointDescriptor(
 151         bEndpointAddress=0x01,
 152         bmAttributes=0x02,
 153         wMaxPacketSize=64,
 154         bInterval=1)
 155     endpoint_desc2 = usb_descriptors.EndpointDescriptor(
 156         bEndpointAddress=0x81,
 157         bmAttributes=0x02,
 158         wMaxPacketSize=64,
 159         bInterval=1)
 160     endpoint_desc3 = usb_descriptors.EndpointDescriptor(
 161         bEndpointAddress=0x01,
 162         bmAttributes=0x01,
 163         wMaxPacketSize=32,
 164         bInterval=10)
 165
 166     interface_desc = usb_descriptors.InterfaceDescriptor(bInterfaceNumber=1)
 167     interface_desc.AddEndpoint(endpoint_desc1)
 168     interface_desc.AddEndpoint(endpoint_desc2)
 169     with self.assertRaisesRegexp(RuntimeError, 'Endpoint 0x01 already defined'):
 170       interface_desc.AddEndpoint(endpoint_desc3)
 171
 172   def test_configuration_descriptor(self):
 173     endpoint_desc = usb_descriptors.EndpointDescriptor(
 174         bEndpointAddress=0x01,
 175         bmAttributes=0x02,
 176         wMaxPacketSize=64,
 177         bInterval=1)
 178     encoded_endpoint = '\x07\x05\x01\x02\x40\x00\x01'
 179     self.assertEquals(endpoint_desc.Encode(), encoded_endpoint)
 180
 181     interface_desc = usb_descriptors.InterfaceDescriptor(bInterfaceNumber=1)
 182     interface_desc.AddEndpoint(endpoint_desc)
 183     self.assertEquals([endpoint_desc], interface_desc.GetEndpoints())
 184     encoded_interface = ('\x09\x04\x01\x00\x01\xFF\xFF\xFF\x00' +
 185                          encoded_endpoint)
 186     self.assertEquals(interface_desc.Encode(), encoded_interface)
 187
 188     configuration_desc = usb_descriptors.ConfigurationDescriptor(
 189         bmAttributes=0xC0,
 190         MaxPower=100)
 191     configuration_desc.AddInterface(interface_desc)
 192     self.assertEquals([interface_desc], configuration_desc.GetInterfaces())
 193     encoded_configuration = ('\x09\x02\x19\x00\x01\x01\x00\xC0\x64' +
 194                              encoded_interface)
 195     self.assertEquals(configuration_desc.Encode(), encoded_configuration)
 196
 197   def test_encode_hid_descriptor(self):
 198     hid_desc = usb_descriptors.HidDescriptor()
 199     hid_desc.AddDescriptor(hid_constants.DescriptorType.REPORT, 0x80)
 200     hid_desc.AddDescriptor(hid_constants.DescriptorType.PHYSICAL, 0x60)
 201     encoded_desc = '\x0C\x21\x11\x01\x00\x02\x22\x80\x00\x23\x60\x00'
 202     self.assertEquals(hid_desc.Encode(), encoded_desc)
 203
 204   def test_print_hid_descriptor(self):
 205     hid_desc = usb_descriptors.HidDescriptor()
 206     hid_desc.AddDescriptor(hid_constants.DescriptorType.REPORT, 0x80)
 207     hid_desc.AddDescriptor(hid_constants.DescriptorType.PHYSICAL, 0x60)
 208     string = str(hid_desc)
 209     self.assertIn('0x22', string)
 210     self.assertIn('0x23', string)
 211
 212
 213 if __name__ == '__main__':
 214   unittest.main()