← Back to branch summary

~opencompute-developers/opencompute/checkbox

« back to all changes in this revision

Viewing changes to checkbox/parsers/tests/test_udevadm.py

Updated OCP Checkbox to the final release version of Checkbox which is now in Legacy mode.

Also fixed some unittest failures found during the update.

Incremented release version to match the last release version of Checkbox.

Show diffs side-by-side

added added

removed removed

Lines of Context:
checkbox/parsers/tests/test_udevadm.py
1
1
#
2
2
# This file is part of Checkbox.
3
3
#
4
 
# Copyright 2012 Canonical Ltd.
 
4
# Copyright 2012-2013 Canonical Ltd.
5
5
#
6
6
# Checkbox is free software: you can redistribute it and/or modify
7
 
# it under the terms of the GNU General Public License as published by
8
 
# the Free Software Foundation, either version 3 of the License, or
9
 
# (at your option) any later version.
 
7
# it under the terms of the GNU General Public License version 3,
 
8
# as published by the Free Software Foundation.
 
9
 
10
10
#
11
11
# Checkbox is distributed in the hope that it will be useful,
12
12
# but WITHOUT ANY WARRANTY; without even the implied warranty of
18
18
#
19
19
from io import StringIO
20
20
 
 
21
from pkg_resources import resource_filename
21
22
from unittest import TestCase
22
23
 
23
24
from checkbox.parsers.udevadm import UdevadmParser, decode_id
 
25
from checkbox.parsers.udevadm import parse_udevadm_output
24
26
 
25
27
 
26
28
class DeviceResult:
39
41
        return None
40
42
 
41
43
 
42
 
class TestUdevadmParser(TestCase):
 
44
class UdevadmDataMixIn:
 
45
    """
 
46
    Mix in with a helper method to load sample udevadm data
 
47
    """
 
48
 
 
49
    def get_text(self, name):
 
50
        resource = 'parsers/tests/udevadm_data/{}.txt'.format(name)
 
51
        filename = resource_filename('checkbox', resource)
 
52
        with open(filename, 'rt', encoding='UTF-8') as stream:
 
53
            return stream.read()
 
54
 
 
55
 
 
56
class TestUdevadmParser(TestCase, UdevadmDataMixIn):
43
57
 
44
58
    def getParser(self, string):
45
59
        stream = StringIO(string)
51
65
        parser.run(result)
52
66
        return result
53
67
 
 
68
    def parse(self, name):
 
69
        # Uncomment only for debugging purpose
 
70
        #attributes = ("path", "driver", "bus", "product_id", "vendor_id",
 
71
        #    "product", "vendor", "interface",)
 
72
        #
 
73
        #devices = parse_udevadm_output(self.get_text(name), 64)["device_list"]
 
74
        #for i,j in enumerate(devices):
 
75
            #print(i, j.category, [getattr(j, a) for a in attributes])
 
76
        return parse_udevadm_output(self.get_text(name), 64)["device_list"]
 
77
 
 
78
    def count(self, devices, category):
 
79
        return len([d for d in devices if d.category == category])
 
80
 
54
81
    def test_usb_capture(self):
55
82
        result = self.getResult("""
56
83
P: /devices/pci0000:00/0000:00:1a.7/usb1/1-6/1-6:1.0
67
94
        device = result.getDevice("CAPTURE")
68
95
        self.assertTrue(device)
69
96
 
 
97
    def test_openfirmware_network(self):
 
98
        result = self.getResult("""
 
99
P: /devices/soc.0/ffe64000.ethernet
 
100
E: DEVPATH=/devices/soc.0/ffe64000.ethernet
 
101
E: DRIVER=XXXXX
 
102
E: MODALIAS=of:NethernetTXXXXXCXXXXX,XXXXX
 
103
E: OF_COMPATIBLE_0=XXXXX,XXXXX
 
104
E: OF_COMPATIBLE_N=1
 
105
E: OF_NAME=ethernet
 
106
E: OF_TYPE=XXXXX
 
107
E: SUBSYSTEM=platform
 
108
E: UDEV_LOG=3
 
109
 
 
110
P: /devices/soc.0/ffe64000.ethernet/net/eth1
 
111
E: DEVPATH=/devices/soc.0/ffe64000.ethernet/net/eth1
 
112
E: IFINDEX=3
 
113
E: INTERFACE=eth1
 
114
E: SUBSYSTEM=net
 
115
E: UDEV_LOG=3
 
116
""")
 
117
        device = result.getDevice("NETWORK")
 
118
        self.assertTrue(device)
 
119
 
 
120
    def _test_DELL_INSPIRON3521_TOUCHSCREEN(self):
 
121
        """
 
122
        Check devices category having the ID_INPUT_TOUCHSCREEN property
 
123
        """
 
124
        devices = self.parse("DELL_INSPIRON3521_TOUCHSCREEN")
 
125
        self.assertEqual(len(devices), 59)
 
126
        # Check the Accelerometer device category/product
 
127
        self.assertEqual(devices[36].category, "TOUCHSCREEN")
 
128
        self.assertEqual(devices[36].product, "ELAN Touchscreen")
 
129
        self.assertEqual(self.count(devices, "VIDEO"), 1)
 
130
        self.assertEqual(self.count(devices, "AUDIO"), 1)
 
131
        self.assertEqual(self.count(devices, "KEYBOARD"), 1)
 
132
        self.assertEqual(self.count(devices, "TOUCHPAD"), 1)
 
133
        self.assertEqual(self.count(devices, "CARDREADER"), 1)
 
134
        self.assertEqual(self.count(devices, "CDROM"), 1)
 
135
        self.assertEqual(self.count(devices, "FIREWIRE"), 0)
 
136
        self.assertEqual(self.count(devices, "MOUSE"), 0)
 
137
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
138
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 1)
 
139
        self.assertEqual(self.count(devices, "RAID"), 0)
 
140
        self.assertEqual(self.count(devices, "DISK"), 2)
 
141
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
142
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
143
        self.assertEqual(self.count(devices, "CAPTURE"), 1)
 
144
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
145
 
 
146
    def test_DELL_LATITUDEE4310(self):
 
147
        devices = self.parse("DELL_LATITUDEE4310")
 
148
        self.assertEqual(len(devices), 75)
 
149
        self.assertEqual(self.count(devices, "VIDEO"), 1)
 
150
        self.assertEqual(self.count(devices, "AUDIO"), 2)
 
151
        self.assertEqual(self.count(devices, "KEYBOARD"), 1)
 
152
        self.assertEqual(self.count(devices, "TOUCHPAD"), 1)
 
153
        self.assertEqual(self.count(devices, "CARDREADER"), 1)
 
154
        self.assertEqual(self.count(devices, "CDROM"), 1)
 
155
        self.assertEqual(self.count(devices, "FIREWIRE"), 0)
 
156
        self.assertEqual(self.count(devices, "MOUSE"), 1)
 
157
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
158
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
159
        self.assertEqual(self.count(devices, "CAPTURE"), 0)
 
160
        self.assertEqual(self.count(devices, "RAID"), 1)
 
161
        self.assertEqual(self.count(devices, "BLUETOOTH"), 0)
 
162
        self.assertEqual(self.count(devices, "DISK"), 3)
 
163
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
164
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
165
 
 
166
    def test_DELL_LATITUDEE6430(self):
 
167
        devices = self.parse("DELL_LATITUDEE6430")
 
168
        self.assertEqual(len(devices), 78)
 
169
        self.assertEqual(self.count(devices, "VIDEO"), 1)
 
170
        self.assertEqual(self.count(devices, "AUDIO"), 2)
 
171
        self.assertEqual(self.count(devices, "KEYBOARD"), 1)
 
172
        self.assertEqual(self.count(devices, "TOUCHPAD"), 0)
 
173
        self.assertEqual(self.count(devices, "CARDREADER"), 1)
 
174
        self.assertEqual(self.count(devices, "CDROM"), 1)
 
175
        self.assertEqual(self.count(devices, "FIREWIRE"), 0)
 
176
        self.assertEqual(self.count(devices, "MOUSE"), 2)
 
177
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
178
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
179
        self.assertEqual(self.count(devices, "RAID"), 1)
 
180
        self.assertEqual(self.count(devices, "DISK"), 3)
 
181
        # Check that a Bluetooth device is properly detected
 
182
        # See https://bugs.launchpad.net/checkbox/+bug/1075052
 
183
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
184
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
185
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
186
        self.assertEqual(self.count(devices, "CAPTURE"), 1)
 
187
 
 
188
    def test_DELL_OPTIPLEX9020AIO(self):
 
189
        devices = self.parse("DELL_OPTIPLEX9020AIO")
 
190
        self.assertEqual(len(devices), 62)
 
191
        self.assertEqual(self.count(devices, "VIDEO"), 1)
 
192
        self.assertEqual(self.count(devices, "AUDIO"), 4)
 
193
        self.assertEqual(self.count(devices, "KEYBOARD"), 1)
 
194
        self.assertEqual(self.count(devices, "TOUCHPAD"), 0)
 
195
        self.assertEqual(self.count(devices, "CARDREADER"), 3)
 
196
        self.assertEqual(self.count(devices, "CDROM"), 1)
 
197
        self.assertEqual(self.count(devices, "FIREWIRE"), 0)
 
198
        self.assertEqual(self.count(devices, "MOUSE"), 1)
 
199
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
200
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
201
        self.assertEqual(self.count(devices, "CAPTURE"), 0)
 
202
        self.assertEqual(self.count(devices, "BLUETOOTH"), 0)
 
203
        self.assertEqual(self.count(devices, "RAID"), 1)
 
204
        # At least one network device must be detected to solve
 
205
        # https://bugs.launchpad.net/checkbox/+bug/1167733
 
206
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
207
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
208
        self.assertEqual(self.count(devices, "DISK"), 3)
 
209
 
 
210
    def test_DELL_VOSTRO3460_FINGERPRINT(self):
 
211
        """
 
212
        This system has a fingerprint reader
 
213
 
 
214
        usb.ids:
 
215
        138a  Validity Sensors, Inc.
 
216
                0011  VFS5011 Fingerprint Reader
 
217
        """
 
218
        devices = self.parse("DELL_VOSTRO3460_FINGERPRINT")
 
219
        self.assertEqual(len(devices), 76)
 
220
        self.assertEqual(devices[35].category, "OTHER")
 
221
        self.assertEqual(devices[35].vendor_id, 0x0138a)
 
222
        self.assertEqual(devices[35].product_id, 0x0011)
 
223
        self.assertEqual(self.count(devices, "VIDEO"), 1)
 
224
        self.assertEqual(self.count(devices, "AUDIO"), 2)
 
225
        self.assertEqual(self.count(devices, "KEYBOARD"), 1)
 
226
        self.assertEqual(self.count(devices, "TOUCHPAD"), 0)
 
227
        self.assertEqual(self.count(devices, "CARDREADER"), 1)
 
228
        self.assertEqual(self.count(devices, "CDROM"), 1)
 
229
        self.assertEqual(self.count(devices, "FIREWIRE"), 0)
 
230
        self.assertEqual(self.count(devices, "MOUSE"), 1)
 
231
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
232
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
233
        self.assertEqual(self.count(devices, "DISK"), 1)
 
234
        self.assertEqual(self.count(devices, "RAID"), 0)
 
235
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
236
        self.assertEqual(self.count(devices, "NETWORK"), 2)
 
237
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
238
        self.assertEqual(self.count(devices, "CAPTURE"), 1)
 
239
 
 
240
    def test_DELL_VOSTROV131(self):
 
241
        devices = self.parse("DELL_VOSTROV131")
 
242
        expected_devices = [("RTL8111/8168 PCI Express Gigabit "
 
243
                            "Ethernet controller",
 
244
                            "NETWORK", "pci", 0x10EC, 0x8168),
 
245
                            ("AR9285 Wireless Network Adapter (PCI-Express)",
 
246
                            "WIRELESS", "pci", 0x168C, 0x002B)
 
247
                            ]
 
248
        self.assertEqual(len(devices), 63)
 
249
        self.assertEqual(self.count(devices, "VIDEO"), 1)
 
250
        self.assertEqual(self.count(devices, "AUDIO"), 2)
 
251
        self.assertEqual(self.count(devices, "KEYBOARD"), 1)
 
252
        self.assertEqual(self.count(devices, "TOUCHPAD"), 1)
 
253
        self.assertEqual(self.count(devices, "CARDREADER"), 0)
 
254
        self.assertEqual(self.count(devices, "CDROM"), 0)
 
255
        self.assertEqual(self.count(devices, "FIREWIRE"), 0)
 
256
        self.assertEqual(self.count(devices, "MOUSE"), 0)
 
257
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
258
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
259
        self.assertEqual(self.count(devices, "RAID"), 0)
 
260
        self.assertEqual(self.count(devices, "DISK"), 3)
 
261
        self.assertEqual(self.count(devices, "CAPTURE"), 1)
 
262
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
263
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
264
        self.assertEqual(self.count(devices, "WIRELESS"), 2)
 
265
        self.verify_devices(devices, expected_devices)
 
266
 
 
267
    def test_DELL_XPS1340(self):
 
268
        devices = self.parse("DELL_XPS1340")
 
269
        self.assertEqual(len(devices), 76)
 
270
        self.assertEqual(self.count(devices, "VIDEO"), 2)
 
271
        self.assertEqual(self.count(devices, "AUDIO"), 2)
 
272
        self.assertEqual(self.count(devices, "KEYBOARD"), 3)
 
273
        self.assertEqual(self.count(devices, "TOUCHPAD"), 1)
 
274
        self.assertEqual(self.count(devices, "CARDREADER"), 1)
 
275
        self.assertEqual(self.count(devices, "CDROM"), 1)
 
276
        self.assertEqual(self.count(devices, "FIREWIRE"), 1)
 
277
        self.assertEqual(self.count(devices, "MOUSE"), 0)
 
278
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
279
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
280
        self.assertEqual(self.count(devices, "DISK"), 1)
 
281
        self.assertEqual(self.count(devices, "CAPTURE"), 0)
 
282
        self.assertEqual(self.count(devices, "RAID"), 0)
 
283
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
284
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
285
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
286
 
 
287
    def test_DELL_INSPIRON_7737_NVIDIA(self):
 
288
        devices = self.parse("DELL_INSPIRON_7737_NVIDIA")
 
289
        expected_devices = [(None,
 
290
                             "WIRELESS", "pci", 0x8086, 0x08b1),
 
291
                            (None,
 
292
                             "VIDEO", "pci", 0x10de, 0x0fe4),
 
293
                            (None,
 
294
                             "VIDEO", "pci", 0x8086, 0x0a16)
 
295
                            ]
 
296
        # The first video device is an NVIDIA GPU, which is too new
 
297
        # to have a  device name. The second one is the built-in Haswell
 
298
        # GPU.
 
299
        self.assertEqual(len(devices), 59)
 
300
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
301
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
302
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
303
        self.assertEqual(self.count(devices, "VIDEO"), 2)
 
304
        self.assertEqual(self.count(devices, "AUDIO"), 4)
 
305
        self.assertEqual(self.count(devices, "DISK"), 1)
 
306
        self.verify_devices(devices, expected_devices)
 
307
 
 
308
    def test_DELL_INSPIRON_3048_AMD(self):
 
309
        devices = self.parse("DELL_INSPIRON_3048")
 
310
        expected_devices = [(None,
 
311
                             "WIRELESS", "pci", 0x168c, 0x0036),
 
312
                            (None,
 
313
                             "VIDEO", "pci", 0x1002, 0x6664),
 
314
                            (None,
 
315
                             "VIDEO", "pci", 0x8086, 0x0402)
 
316
                            ]
 
317
        # The first video device is an AMD GPU, which is too new
 
318
        # to have a  device name. The second one is the built-in Haswell
 
319
        # GPU.
 
320
        self.assertEqual(len(devices), 63)
 
321
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
322
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
323
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
324
        self.assertEqual(self.count(devices, "AUDIO"), 4)
 
325
        self.assertEqual(self.count(devices, "DISK"), 1)
 
326
        self.assertEqual(self.count(devices, "VIDEO"), 2)
 
327
        self.verify_devices(devices, expected_devices)
 
328
 
 
329
    def test_HOME_MADE(self):
 
330
        devices = self.parse("HOME_MADE")
 
331
        self.assertEqual(len(devices), 72)
 
332
        self.assertEqual(self.count(devices, "VIDEO"), 1)
 
333
        self.assertEqual(self.count(devices, "AUDIO"), 4)
 
334
        self.assertEqual(self.count(devices, "KEYBOARD"), 2)
 
335
        self.assertEqual(self.count(devices, "TOUCHPAD"), 0)
 
336
        self.assertEqual(self.count(devices, "CARDREADER"), 1)
 
337
        self.assertEqual(self.count(devices, "CDROM"), 2)
 
338
        self.assertEqual(self.count(devices, "FLOPPY"), 2)
 
339
        self.assertEqual(self.count(devices, "FIREWIRE"), 1)
 
340
        self.assertEqual(self.count(devices, "MOUSE"), 1)
 
341
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
342
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
343
        self.assertEqual(self.count(devices, "CAPTURE"), 0)
 
344
        self.assertEqual(self.count(devices, "RAID"), 0)
 
345
        self.assertEqual(self.count(devices, "BLUETOOTH"), 0)
 
346
        self.assertEqual(self.count(devices, "WIRELESS"), 0)
 
347
        self.assertEqual(self.count(devices, "DISK"), 2)
 
348
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
349
 
 
350
    def test_HP_PAVILIONSLEEKBOOK14_ACCELEROMETER(self):
 
351
        devices = self.parse("HP_PAVILIONSLEEKBOOK14_ACCELEROMETER")
 
352
        self.assertEqual(len(devices), 58)
 
353
        self.assertEqual(devices[56].product, "ST LIS3LV02DL Accelerometer")
 
354
        self.assertEqual(devices[56].category, "ACCELEROMETER")
 
355
        self.assertEqual(self.count(devices, "VIDEO"), 1)
 
356
        self.assertEqual(self.count(devices, "AUDIO"), 2)
 
357
        self.assertEqual(self.count(devices, "KEYBOARD"), 1)
 
358
        self.assertEqual(self.count(devices, "TOUCHPAD"), 1)
 
359
        self.assertEqual(self.count(devices, "CARDREADER"), 1)
 
360
        self.assertEqual(self.count(devices, "CDROM"), 0)
 
361
        self.assertEqual(self.count(devices, "FIREWIRE"), 0)
 
362
        self.assertEqual(self.count(devices, "MOUSE"), 0)
 
363
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 1)
 
364
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
365
        self.assertEqual(self.count(devices, "CAPTURE"), 0)
 
366
        # Check that a Bluetooth device is properly detected on PCI bus
 
367
        # See https://bugs.launchpad.net/checkbox/+bug/1036124
 
368
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
369
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
370
        self.assertEqual(self.count(devices, "RAID"), 0)
 
371
        self.assertEqual(self.count(devices, "DISK"), 1)
 
372
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
373
 
 
374
    def test_HP_PRO2110(self):
 
375
        devices = self.parse("HP_PRO2110")
 
376
        self.assertEqual(len(devices), 60)
 
377
        # Check that the Avocent IBM 73P5832 is not a CAPTURE device
 
378
        # See https://bugs.launchpad.net/checkbox/+bug/1065064
 
379
        self.assertEqual(devices[33].product, "Avocent IBM 73P5832")
 
380
        self.assertNotEqual(devices[33].category, "CAPTURE")
 
381
        self.assertEqual(self.count(devices, "VIDEO"), 1)
 
382
        self.assertEqual(self.count(devices, "AUDIO"), 2)
 
383
        self.assertEqual(self.count(devices, "KEYBOARD"), 1)
 
384
        self.assertEqual(self.count(devices, "TOUCHPAD"), 0)
 
385
        self.assertEqual(self.count(devices, "CARDREADER"), 4)
 
386
        self.assertEqual(self.count(devices, "CDROM"), 1)
 
387
        self.assertEqual(self.count(devices, "FIREWIRE"), 0)
 
388
        self.assertEqual(self.count(devices, "MOUSE"), 1)
 
389
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
390
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
391
        self.assertEqual(self.count(devices, "CAPTURE"), 0)
 
392
        self.assertEqual(self.count(devices, "BLUETOOTH"), 0)
 
393
        self.assertEqual(self.count(devices, "WIRELESS"), 0)
 
394
        self.assertEqual(self.count(devices, "RAID"), 0)
 
395
        self.assertEqual(self.count(devices, "DISK"), 3)
 
396
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
397
        expected_devices = [(None, "VIDEO", "pci", 0x8086, 0x2E32)]
 
398
        self.verify_devices(devices, expected_devices)
 
399
 
 
400
    def test_HP_PROBOOK6550B_ACCELEROMETER(self):
 
401
        devices = self.parse("HP_PROBOOK6550B_ACCELEROMETER")
 
402
        expected_devices = [("Centrino Advanced-N 6200",
 
403
                             "WIRELESS", "pci", 0x8086, 0x4239),
 
404
                            ("82577LC Gigabit Network Connection",
 
405
                             "NETWORK", "pci", 0x8086, 0x10EB)
 
406
                            ]
 
407
        self.assertEqual(len(devices), 80)
 
408
        # Check the accelerometer device category/product
 
409
        self.assertEqual(devices[78].product, "ST LIS3LV02DL Accelerometer")
 
410
        self.assertEqual(devices[78].category, "ACCELEROMETER")
 
411
        self.assertEqual(self.count(devices, "VIDEO"), 1)
 
412
        self.assertEqual(self.count(devices, "AUDIO"), 2)
 
413
        self.assertEqual(self.count(devices, "KEYBOARD"), 1)
 
414
        self.assertEqual(self.count(devices, "TOUCHPAD"), 1)
 
415
        self.assertEqual(self.count(devices, "CARDREADER"), 1)
 
416
        self.assertEqual(self.count(devices, "CDROM"), 1)
 
417
        self.assertEqual(self.count(devices, "FIREWIRE"), 1)
 
418
        self.assertEqual(self.count(devices, "MOUSE"), 1)
 
419
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 1)
 
420
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
421
        self.assertEqual(self.count(devices, "RAID"), 0)
 
422
        self.assertEqual(self.count(devices, "DISK"), 3)
 
423
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
424
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
425
        self.assertEqual(self.count(devices, "CAPTURE"), 1)
 
426
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
427
        self.verify_devices(devices, expected_devices)
 
428
 
 
429
    def test_LENOVO_E431(self):
 
430
        devices = self.parse("LENOVO_E431")
 
431
        self.assertEqual(len(devices), 65)
 
432
        self.assertEqual(self.count(devices, "VIDEO"), 1)
 
433
        self.assertEqual(self.count(devices, "AUDIO"), 2)
 
434
        self.assertEqual(self.count(devices, "KEYBOARD"), 1)
 
435
        self.assertEqual(self.count(devices, "TOUCHPAD"), 1)
 
436
        self.assertEqual(self.count(devices, "CARDREADER"), 1)
 
437
        self.assertEqual(self.count(devices, "CDROM"), 1)
 
438
        self.assertEqual(self.count(devices, "FIREWIRE"), 0)
 
439
        self.assertEqual(self.count(devices, "MOUSE"), 1)
 
440
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
441
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
442
        self.assertEqual(self.count(devices, "DISK"), 1)
 
443
        self.assertEqual(self.count(devices, "RAID"), 0)
 
444
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
445
        self.assertEqual(self.count(devices, "CAPTURE"), 1)
 
446
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
447
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
448
 
 
449
    def test_LENOVO_E445(self):
 
450
        devices = self.parse("LENOVO_E445")
 
451
        self.assertEqual(len(devices), 78)
 
452
        self.assertEqual(self.count(devices, "VIDEO"), 2)
 
453
        self.assertEqual(self.count(devices, "AUDIO"), 4)
 
454
        self.assertEqual(self.count(devices, "KEYBOARD"), 1)
 
455
        self.assertEqual(self.count(devices, "TOUCHPAD"), 1)
 
456
        self.assertEqual(self.count(devices, "CARDREADER"), 1)
 
457
        self.assertEqual(self.count(devices, "CDROM"), 1)
 
458
        self.assertEqual(self.count(devices, "FIREWIRE"), 0)
 
459
        self.assertEqual(self.count(devices, "MOUSE"), 1)
 
460
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
461
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
462
        self.assertEqual(self.count(devices, "DISK"), 1)
 
463
        self.assertEqual(self.count(devices, "RAID"), 0)
 
464
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
465
        self.assertEqual(self.count(devices, "CAPTURE"), 1)
 
466
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
467
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
468
        # System has two CPUs, AMD Richland [Radeon HD 8650G] and
 
469
        # Sun PRO [Radeon HD 8570A/8570M]
 
470
        expected_devices = [(None, "VIDEO", "pci", 0x1002, 0x990b),
 
471
                            (None, "VIDEO", "pci", 0x1002, 0x6663)]
 
472
        self.verify_devices(devices, expected_devices)
 
473
 
 
474
    def test_LENOVO_T430S(self):
 
475
        devices = self.parse("LENOVO_T430S")
 
476
        expected_devices = [("Centrino Ultimate-N 6300",
 
477
                             "WIRELESS", "pci", 0x8086, 0x4238),
 
478
                            ("82579LM Gigabit Network Connection",
 
479
                             "NETWORK", "pci", 0x8086, 0x1502),
 
480
                            ("H5321 gw",
 
481
                             "NETWORK", "usb", 0x0bdb, 0x1926)
 
482
                            ]
 
483
        self.assertEqual(len(devices), 103)
 
484
        # Check that the Thinkpad hotkeys are not a CAPTURE device
 
485
        self.assertEqual(devices[102].product, "ThinkPad Extra Buttons")
 
486
        self.assertEqual(devices[102].category, "OTHER")
 
487
        # Check that the Ericsson MBM module is set as a NETWORK device with
 
488
        # proper vendor/product names
 
489
        self.assertEqual(devices[54].product, "H5321 gw")
 
490
        self.assertEqual(
 
491
            devices[54].vendor,
 
492
            "Ericsson Business Mobile Networks BV")
 
493
        self.assertEqual(devices[54].category, "NETWORK")
 
494
        self.assertEqual(self.count(devices, "VIDEO"), 1)
 
495
        self.assertEqual(self.count(devices, "AUDIO"), 9)
 
496
        # Logitech Illuminated keyboard + T430S keyboard + KVM
 
497
        self.assertEqual(self.count(devices, "KEYBOARD"), 3)
 
498
        self.assertEqual(self.count(devices, "TOUCHPAD"), 1)
 
499
        self.assertEqual(self.count(devices, "CARDREADER"), 1)
 
500
        self.assertEqual(self.count(devices, "CDROM"), 1)
 
501
        self.assertEqual(self.count(devices, "FIREWIRE"), 0)
 
502
        self.assertEqual(self.count(devices, "MOUSE"), 1)
 
503
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
504
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
505
        self.assertEqual(self.count(devices, "DISK"), 1)
 
506
        self.assertEqual(self.count(devices, "RAID"), 0)
 
507
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
508
        self.assertEqual(self.count(devices, "NETWORK"), 2)
 
509
        self.assertEqual(self.count(devices, "CAPTURE"), 2)
 
510
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
511
        self.verify_devices(devices, expected_devices)
 
512
 
 
513
    def test_PANDABOARD(self):
 
514
        devices = self.parse("PANDABOARD")
 
515
        self.assertEqual(len(devices), 14)
 
516
        # Check that the wireless product name is extracted from the platform
 
517
        # modalias
 
518
        self.assertEqual(devices[2].product, "wl12xx")
 
519
        self.assertEqual(self.count(devices, "VIDEO"), 0)
 
520
        self.assertEqual(self.count(devices, "AUDIO"), 0)
 
521
        self.assertEqual(self.count(devices, "KEYBOARD"), 1)
 
522
        self.assertEqual(self.count(devices, "TOUCHPAD"), 0)
 
523
        self.assertEqual(self.count(devices, "CARDREADER"), 0)
 
524
        self.assertEqual(self.count(devices, "CDROM"), 0)
 
525
        self.assertEqual(self.count(devices, "FIREWIRE"), 0)
 
526
        self.assertEqual(self.count(devices, "MOUSE"), 0)
 
527
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
528
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
529
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
530
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
531
        self.assertEqual(self.count(devices, "BLUETOOTH"), 0)
 
532
        self.assertEqual(self.count(devices, "CAPTURE"), 0)
 
533
        self.assertEqual(self.count(devices, "RAID"), 0)
 
534
        self.assertEqual(self.count(devices, "DISK"), 2)
 
535
 
 
536
    def test_SAMSUNG_N310(self):
 
537
        devices = self.parse("SAMSUNG_N310")
 
538
        self.assertEqual(len(devices), 57)
 
539
        self.assertEqual(self.count(devices, "VIDEO"), 1)
 
540
        self.assertEqual(self.count(devices, "AUDIO"), 2)
 
541
        self.assertEqual(self.count(devices, "KEYBOARD"), 1)
 
542
        self.assertEqual(self.count(devices, "TOUCHPAD"), 1)
 
543
        self.assertEqual(self.count(devices, "CARDREADER"), 0)
 
544
        self.assertEqual(self.count(devices, "CDROM"), 0)
 
545
        self.assertEqual(self.count(devices, "FIREWIRE"), 0)
 
546
        self.assertEqual(self.count(devices, "MOUSE"), 0)
 
547
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
548
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
549
        # Check that wireless device are properly detected even if the usb
 
550
        # modalias is wrong.
 
551
        # The PCI_CLASS is 20000 for the Atheros cards in this Samsung netbook
 
552
        # but 28000 anywhere else.
 
553
        # See https://bugs.launchpad.net/checkbox/+bug/855382
 
554
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
555
        self.assertEqual(self.count(devices, "DISK"), 1)
 
556
        self.assertEqual(self.count(devices, "RAID"), 0)
 
557
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
558
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
559
        self.assertEqual(self.count(devices, "CAPTURE"), 1)
 
560
 
 
561
    def test_LENOVO_T420(self):
 
562
        devices = self.parse("LENOVO_T420")
 
563
        expected_devices = [("Centrino Advanced-N 6205 [Taylor Peak]",
 
564
                             "WIRELESS", "pci", 0x8086, 0x85),
 
565
                            ("82579LM Gigabit Network Connection",
 
566
                             "NETWORK", "pci", 0x8086, 0x1502)
 
567
                            ]
 
568
        self.assertEqual(len(devices), 65)
 
569
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
570
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
571
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
572
        self.verify_devices(devices, expected_devices)
 
573
 
 
574
    def test_HP_ENVY_15_MEDIATEK_BT(self):
 
575
        devices = self.parse("HP_ENVY_15_MEDIATEK_BT")
 
576
        expected_devices = [
 
577
            (None, "WIRELESS", "pci", 0x14C3, 0x7630),
 
578
            ("RTL8111/8168B PCI Express Gigabit "
 
579
             "Ethernet controller", "NETWORK", "pci",
 
580
             0x10EC, 0x8168),
 
581
            (None, "BLUETOOTH", "usb", 0x0e8d, 0x763f)]
 
582
        self.assertEqual(len(devices), 63)
 
583
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
584
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
585
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
586
        self.verify_devices(devices, expected_devices)
 
587
 
 
588
    def test_HP_PAVILION14_NOTEBOOK_MEDIATEK_BT(self):
 
589
        devices = self.parse("HP_PAVILION14_NOTEBOOK_MEDIATEK_BT")
 
590
        expected_devices = [
 
591
            (None, "WIRELESS", "pci", 0x14C3, 0x7630),
 
592
            ("RTL8101E/RTL8102E PCI Express Fast "
 
593
             "Ethernet controller", "NETWORK", "pci",
 
594
             0x10EC, 0x8136),
 
595
            (None, "BLUETOOTH", "usb", 0x0e8d, 0x763f)]
 
596
        self.assertEqual(len(devices), 67)
 
597
        self.verify_devices(devices, expected_devices)
 
598
        self.assertEqual(self.count(devices, "WIRELESS"), 1)
 
599
        self.assertEqual(self.count(devices, "BLUETOOTH"), 1)
 
600
        self.assertEqual(self.count(devices, "NETWORK"), 1)
 
601
 
 
602
    def test_CALXEDA_HIGHBANK(self):
 
603
        #This is a very bare-bones SoC meant for server use
 
604
        devices = self.parse("CALXEDA_HIGHBANK")
 
605
        self.assertEqual(len(devices), 3)
 
606
        self.assertEqual(self.count(devices, "VIDEO"), 0)
 
607
        self.assertEqual(self.count(devices, "AUDIO"), 0)
 
608
        self.assertEqual(self.count(devices, "KEYBOARD"), 0)
 
609
        self.assertEqual(self.count(devices, "TOUCHPAD"), 0)
 
610
        self.assertEqual(self.count(devices, "CARDREADER"), 0)
 
611
        self.assertEqual(self.count(devices, "CDROM"), 0)
 
612
        self.assertEqual(self.count(devices, "FIREWIRE"), 0)
 
613
        self.assertEqual(self.count(devices, "MOUSE"), 0)
 
614
        self.assertEqual(self.count(devices, "ACCELEROMETER"), 0)
 
615
        self.assertEqual(self.count(devices, "TOUCHSCREEN"), 0)
 
616
        self.assertEqual(self.count(devices, "WIRELESS"), 0)
 
617
        self.assertEqual(self.count(devices, "NETWORK"), 2)
 
618
        self.assertEqual(self.count(devices, "BLUETOOTH"), 0)
 
619
        self.assertEqual(self.count(devices, "CAPTURE"), 0)
 
620
        self.assertEqual(self.count(devices, "RAID"), 0)
 
621
        self.assertEqual(self.count(devices, "DISK"), 1)
 
622
 
 
623
    def verify_devices(self, devices, expected_device_list):
 
624
        """
 
625
        Verify we have exactly one of each device given in the list,
 
626
        and that product name, category, bus, vendor_id and
 
627
        product_id match.
 
628
        The list contains a tuple with product name, category, bus,
 
629
        vendor and product.
 
630
        They look like:
 
631
        [(name, category, bus, vendor_id, product_id)]
 
632
        Note that name can be None, in which case we don't need the
 
633
        name to match. All other attributes must have a value and match.
 
634
        """
 
635
        # See this bug, that prompted for closer inspection of
 
636
        # devices and IDs:
 
637
        # https://bugs.launchpad.net/checkbox/+bug/1211521
 
638
        for device in expected_device_list:
 
639
            # Match by product and vendor ID
 
640
            indices = [idx for idx, elem in enumerate(devices)
 
641
                       if elem.product_id == device[4] and
 
642
                       elem.vendor_id == device[3]]
 
643
            # If we have a name to match, eliminate everyhing without
 
644
            # that name (as they are bogus, uninteresting devices)
 
645
            if device[0] is not None:
 
646
                indices = [idx for idx in indices
 
647
                           if devices[idx].product == device[0]]
 
648
            # Now do my validation checks
 
649
            self.assertEqual(len(indices), 1,
 
650
                             "{} items of {} (id {}:{}) found".format(
 
651
                                 len(indices),
 
652
                                 device[0],
 
653
                                 device[3],
 
654
                                 device[4]))
 
655
            if device[0] is not None:
 
656
                self.assertEqual(devices[indices[0]].product, device[0],
 
657
                                 "Bad product name for {}".format(device[0]))
 
658
            self.assertEqual(devices[indices[0]].category, device[1],
 
659
                             "Bad category for {}".format(device[0]))
 
660
            self.assertEqual(devices[indices[0]].bus, device[2],
 
661
                             "Bad bus for {}".format(device[0]))
 
662
            self.assertEqual(devices[indices[0]].vendor_id, device[3],
 
663
                             "Bad vendor_id for {}".format(device[0]))
 
664
            self.assertEqual(devices[indices[0]].product_id, device[4],
 
665
                             "Bad product_id for {}".format(device[0]))
 
666
 
70
667
 
71
668
class TestDecodeId(TestCase):
72
669