Merge lp:~adeuring/launchpad/hwdb-build-udev-device-list-2 into lp:launchpad
- hwdb-build-udev-device-list-2
- Merge into devel
Proposed by
Abel Deuring
| Status: | Merged |
|---|---|
| Approved by: | Jeroen T. Vermeulen |
| Approved revision: | no longer in the source branch. |
| Merged at revision: | not available |
| Proposed branch: | lp:~adeuring/launchpad/hwdb-build-udev-device-list-2 |
| Merge into: | lp:launchpad |
| Diff against target: |
1064 lines 2 files modified
lib/canonical/launchpad/scripts/hwdbsubmissions.py (+69/-8) lib/canonical/launchpad/scripts/tests/test_hwdb_submission_processing.py (+208/-159) |
| To merge this branch: | bzr merge lp:~adeuring/launchpad/hwdb-build-udev-device-list-2 |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Jeroen T. Vermeulen (community) | Approve | ||
|
Review via email:
|
|||
Commit message
Description of the change
To post a comment you must log in.
Revision history for this message
| Abel Deuring (adeuring) wrote : | # |
Revision history for this message
| Abel Deuring (adeuring) wrote : | # |
test: ./bin/test --test=
= Launchpad lint =
Checking for conflicts. and issues in doctests and templates.
Running jslint, xmllint, pyflakes, and pylint.
Using normal rules.
Linting changed files:
lib/canonical
lib/canonical
== Pyflakes notices ==
lib/canonical/
22: redefinition of unused 'etree' from line 20
== Pylint notices ==
lib/canonical/
20: [F0401] Unable to import 'xml.etree.
Revision history for this message
| Jeroen T. Vermeulen (jtv) wrote : | # |
Looks fine. I appreciate the courage it takes to defy review limits for the cleanup.
We discussed a few superficialities on IRC. I'll trust your judgment on which tests should test the hal devices and which should test all devices. Beyond that, it looks solid to me.
review:
Approve
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
| 1 | === modified file 'lib/canonical/launchpad/icing/style-3-0.css' | |||
| 2 | === modified file 'lib/canonical/launchpad/scripts/hwdbsubmissions.py' | |||
| 3 | --- lib/canonical/launchpad/scripts/hwdbsubmissions.py 2009-10-20 13:33:14 +0000 | |||
| 4 | +++ lib/canonical/launchpad/scripts/hwdbsubmissions.py 2009-10-21 10:10:35 +0000 | |||
| 5 | @@ -1397,15 +1397,75 @@ | |||
| 6 | 1397 | 1397 | ||
| 7 | 1398 | def buildDeviceList(self, parsed_data): | 1398 | def buildDeviceList(self, parsed_data): |
| 8 | 1399 | """Create a list of devices from a submission.""" | 1399 | """Create a list of devices from a submission.""" |
| 10 | 1400 | self.hal_devices = hal_devices = {} | 1400 | if 'hal' in parsed_data['hardware']: |
| 11 | 1401 | return self.buildHalDeviceList(parsed_data) | ||
| 12 | 1402 | else: | ||
| 13 | 1403 | return self.buildUdevDeviceList(parsed_data) | ||
| 14 | 1404 | |||
| 15 | 1405 | def buildHalDeviceList(self, parsed_data): | ||
| 16 | 1406 | """Create a list of devices from the HAL data of a submission.""" | ||
| 17 | 1407 | self.devices = {} | ||
| 18 | 1401 | for hal_data in parsed_data['hardware']['hal']['devices']: | 1408 | for hal_data in parsed_data['hardware']['hal']['devices']: |
| 19 | 1402 | udi = hal_data['udi'] | 1409 | udi = hal_data['udi'] |
| 23 | 1403 | hal_devices[udi] = HALDevice(hal_data['id'], udi, | 1410 | self.devices[udi] = HALDevice(hal_data['id'], udi, |
| 24 | 1404 | hal_data['properties'], self) | 1411 | hal_data['properties'], self) |
| 25 | 1405 | for device in hal_devices.values(): | 1412 | for device in self.devices.values(): |
| 26 | 1406 | parent_udi = device.parent_udi | 1413 | parent_udi = device.parent_udi |
| 27 | 1407 | if parent_udi is not None: | 1414 | if parent_udi is not None: |
| 29 | 1408 | hal_devices[parent_udi].addChild(device) | 1415 | self.devices[parent_udi].addChild(device) |
| 30 | 1416 | return True | ||
| 31 | 1417 | |||
| 32 | 1418 | def buildUdevDeviceList(self, parsed_data): | ||
| 33 | 1419 | """Create a list of devices from the udev data of a submission.""" | ||
| 34 | 1420 | self.devices = {} | ||
| 35 | 1421 | sysfs_data = parsed_data['hardware']['sysfs-attributes'] | ||
| 36 | 1422 | dmi_data = parsed_data['hardware']['dmi'] | ||
| 37 | 1423 | for udev_data in parsed_data['hardware']['udev']: | ||
| 38 | 1424 | device_path = udev_data['P'] | ||
| 39 | 1425 | if device_path == UDEV_ROOT_PATH: | ||
| 40 | 1426 | device = UdevDevice( | ||
| 41 | 1427 | self, udev_data, sysfs_data=sysfs_data.get(device_path), | ||
| 42 | 1428 | dmi_data=dmi_data) | ||
| 43 | 1429 | else: | ||
| 44 | 1430 | device = UdevDevice( | ||
| 45 | 1431 | self, udev_data, sysfs_data=sysfs_data.get(device_path)) | ||
| 46 | 1432 | self.devices[device_path] = device | ||
| 47 | 1433 | |||
| 48 | 1434 | # The parent-child relations are derived from the path names of | ||
| 49 | 1435 | # the devices. If A and B are the path names of two devices, | ||
| 50 | 1436 | # the device with path name A is an ancestor of the device with | ||
| 51 | 1437 | # path name B, iff B.startswith(A). If C is the set of the path | ||
| 52 | 1438 | # names of all ancestors of A, the element with the longest path | ||
| 53 | 1439 | # name belongs to the parent of A. | ||
| 54 | 1440 | # | ||
| 55 | 1441 | # There is one exception to this rule: The root node has the | ||
| 56 | 1442 | # the path name '/devices/LNXSYSTM:00', while the path names | ||
| 57 | 1443 | # of PCI devices start with '/devices/pci'. We'll temporarily | ||
| 58 | 1444 | # change the path name of the root device so that the rule | ||
| 59 | 1445 | # holds for all devices. | ||
| 60 | 1446 | if UDEV_ROOT_PATH not in self.devices: | ||
| 61 | 1447 | self._logError('No udev root device defined', self.submission_key) | ||
| 62 | 1448 | return False | ||
| 63 | 1449 | self.devices['/devices'] = self.devices[UDEV_ROOT_PATH] | ||
| 64 | 1450 | del self.devices[UDEV_ROOT_PATH] | ||
| 65 | 1451 | |||
| 66 | 1452 | path_names = sorted(self.devices, key=len, reverse=True) | ||
| 67 | 1453 | for path_index, path_name in enumerate(path_names[:-1]): | ||
| 68 | 1454 | # Ensure that the last ancestor of each device is our | ||
| 69 | 1455 | # root node. | ||
| 70 | 1456 | if not path_name.startswith('/devices'): | ||
| 71 | 1457 | self._logError( | ||
| 72 | 1458 | 'Invalid device path name: %r' % path_name, | ||
| 73 | 1459 | self.submission_key) | ||
| 74 | 1460 | return False | ||
| 75 | 1461 | for parent_path in path_names[path_index+1:]: | ||
| 76 | 1462 | if path_name.startswith(parent_path): | ||
| 77 | 1463 | self.devices[parent_path].addChild( | ||
| 78 | 1464 | self.devices[path_name]) | ||
| 79 | 1465 | break | ||
| 80 | 1466 | self.devices[UDEV_ROOT_PATH] = self.devices['/devices'] | ||
| 81 | 1467 | del self.devices['/devices'] | ||
| 82 | 1468 | return True | ||
| 83 | 1409 | 1469 | ||
| 84 | 1410 | def buildUdevDeviceList(self, parsed_data): | 1470 | def buildUdevDeviceList(self, parsed_data): |
| 85 | 1411 | """Create a list of devices from the udev data of a submission.""" | 1471 | """Create a list of devices from the udev data of a submission.""" |
| 86 | @@ -1460,7 +1520,7 @@ | |||
| 87 | 1460 | 1520 | ||
| 88 | 1461 | def getKernelPackageName(self): | 1521 | def getKernelPackageName(self): |
| 89 | 1462 | """Return the kernel package name of the submission,""" | 1522 | """Return the kernel package name of the submission,""" |
| 91 | 1463 | root_hal_device = self.hal_devices[ROOT_UDI] | 1523 | root_hal_device = self.devices[ROOT_UDI] |
| 92 | 1464 | kernel_version = root_hal_device.getProperty('system.kernel.version') | 1524 | kernel_version = root_hal_device.getProperty('system.kernel.version') |
| 93 | 1465 | if kernel_version is None: | 1525 | if kernel_version is None: |
| 94 | 1466 | self._logWarning( | 1526 | self._logWarning( |
| 95 | @@ -1521,8 +1581,9 @@ | |||
| 96 | 1521 | self.parsed_data = parsed_data | 1581 | self.parsed_data = parsed_data |
| 97 | 1522 | if not self.checkConsistency(parsed_data): | 1582 | if not self.checkConsistency(parsed_data): |
| 98 | 1523 | return False | 1583 | return False |
| 101 | 1524 | self.buildDeviceList(parsed_data) | 1584 | if not self.buildDeviceList(parsed_data): |
| 102 | 1525 | root_device = self.hal_devices[ROOT_UDI] | 1585 | return False |
| 103 | 1586 | root_device = self.devices[ROOT_UDI] | ||
| 104 | 1526 | root_device.createDBData(submission, None) | 1587 | root_device.createDBData(submission, None) |
| 105 | 1527 | return True | 1588 | return True |
| 106 | 1528 | 1589 | ||
| 107 | 1529 | 1590 | ||
| 108 | === modified file 'lib/canonical/launchpad/scripts/tests/test_hwdb_submission_processing.py' | |||
| 109 | --- lib/canonical/launchpad/scripts/tests/test_hwdb_submission_processing.py 2009-10-20 14:03:44 +0000 | |||
| 110 | +++ lib/canonical/launchpad/scripts/tests/test_hwdb_submission_processing.py 2009-10-21 10:10:35 +0000 | |||
| 111 | @@ -136,7 +136,44 @@ | |||
| 112 | 136 | class TestHWDBSubmissionProcessing(TestCaseHWDB): | 136 | class TestHWDBSubmissionProcessing(TestCaseHWDB): |
| 113 | 137 | """Tests for processing of HWDB submissions.""" | 137 | """Tests for processing of HWDB submissions.""" |
| 114 | 138 | 138 | ||
| 116 | 139 | def testBuildDeviceList(self): | 139 | def test_buildDeviceList(self): |
| 117 | 140 | """Test of SubmissionParser.buildDeviceList().""" | ||
| 118 | 141 | class MockSubmissionParser(SubmissionParser): | ||
| 119 | 142 | """A SubmissionParser variant for testing.""" | ||
| 120 | 143 | |||
| 121 | 144 | def __init__(self, hal_result, udev_result): | ||
| 122 | 145 | super(MockSubmissionParser, self).__init__() | ||
| 123 | 146 | self.hal_result = hal_result | ||
| 124 | 147 | self.udev_result = udev_result | ||
| 125 | 148 | |||
| 126 | 149 | def buildHalDeviceList(self, parsed_data): | ||
| 127 | 150 | """See `SubmissionParser`.""" | ||
| 128 | 151 | return self.hal_result | ||
| 129 | 152 | |||
| 130 | 153 | def buildUdevDeviceList(self, parsed_data): | ||
| 131 | 154 | """See `SubmissionParser`.""" | ||
| 132 | 155 | return self.udev_result | ||
| 133 | 156 | |||
| 134 | 157 | parsed_data_hal = { | ||
| 135 | 158 | 'hardware': {'hal': None} | ||
| 136 | 159 | } | ||
| 137 | 160 | |||
| 138 | 161 | parser = MockSubmissionParser(True, True) | ||
| 139 | 162 | self.assertTrue(parser.buildDeviceList(parsed_data_hal)) | ||
| 140 | 163 | |||
| 141 | 164 | parser = MockSubmissionParser(False, True) | ||
| 142 | 165 | self.assertFalse(parser.buildDeviceList(parsed_data_hal)) | ||
| 143 | 166 | |||
| 144 | 167 | parsed_data_udev = { | ||
| 145 | 168 | 'hardware': {'udev': None} | ||
| 146 | 169 | } | ||
| 147 | 170 | parser = MockSubmissionParser(True, True) | ||
| 148 | 171 | self.assertTrue(parser.buildDeviceList(parsed_data_udev)) | ||
| 149 | 172 | |||
| 150 | 173 | parser = MockSubmissionParser(True, False) | ||
| 151 | 174 | self.assertFalse(parser.buildDeviceList(parsed_data_udev)) | ||
| 152 | 175 | |||
| 153 | 176 | def test_buildHalDeviceList(self): | ||
| 154 | 140 | """Test the creation of list HALDevice instances for a submission.""" | 177 | """Test the creation of list HALDevice instances for a submission.""" |
| 155 | 141 | devices = [ | 178 | devices = [ |
| 156 | 142 | { | 179 | { |
| 157 | @@ -160,11 +197,11 @@ | |||
| 158 | 160 | }, | 197 | }, |
| 159 | 161 | } | 198 | } |
| 160 | 162 | parser = SubmissionParser(self.log) | 199 | parser = SubmissionParser(self.log) |
| 164 | 163 | parser.buildDeviceList(parsed_data) | 200 | parser.buildHalDeviceList(parsed_data) |
| 165 | 164 | self.assertEqual(len(parser.hal_devices), len(devices), | 201 | self.assertEqual(len(parser.devices), len(devices), |
| 166 | 165 | 'Numbers of devices in parser.hal_devices and in ' | 202 | 'Numbers of devices in parser.devices and in ' |
| 167 | 166 | 'sample data are different') | 203 | 'sample data are different') |
| 169 | 167 | root_device = parser.hal_devices[self.UDI_COMPUTER] | 204 | root_device = parser.devices[self.UDI_COMPUTER] |
| 170 | 168 | self.assertEqual(root_device.id, 1, | 205 | self.assertEqual(root_device.id, 1, |
| 171 | 169 | 'Unexpected value of root device ID.') | 206 | 'Unexpected value of root device ID.') |
| 172 | 170 | self.assertEqual(root_device.udi, self.UDI_COMPUTER, | 207 | self.assertEqual(root_device.udi, self.UDI_COMPUTER, |
| 173 | @@ -172,7 +209,7 @@ | |||
| 174 | 172 | self.assertEqual(root_device.properties, | 209 | self.assertEqual(root_device.properties, |
| 175 | 173 | devices[0]['properties'], | 210 | devices[0]['properties'], |
| 176 | 174 | 'Unexpected properties of root device.') | 211 | 'Unexpected properties of root device.') |
| 178 | 175 | child_device = parser.hal_devices[self.UDI_SATA_CONTROLLER] | 212 | child_device = parser.devices[self.UDI_SATA_CONTROLLER] |
| 179 | 176 | self.assertEqual(child_device.id, 2, | 213 | self.assertEqual(child_device.id, 2, |
| 180 | 177 | 'Unexpected value of child device ID.') | 214 | 'Unexpected value of child device ID.') |
| 181 | 178 | self.assertEqual(child_device.udi, self.UDI_SATA_CONTROLLER, | 215 | self.assertEqual(child_device.udi, self.UDI_SATA_CONTROLLER, |
| 182 | @@ -181,8 +218,8 @@ | |||
| 183 | 181 | devices[1]['properties'], | 218 | devices[1]['properties'], |
| 184 | 182 | 'Unexpected properties of child device.') | 219 | 'Unexpected properties of child device.') |
| 185 | 183 | 220 | ||
| 188 | 184 | parent = parser.hal_devices[self.UDI_COMPUTER] | 221 | parent = parser.devices[self.UDI_COMPUTER] |
| 189 | 185 | child = parser.hal_devices[self.UDI_SATA_CONTROLLER] | 222 | child = parser.devices[self.UDI_SATA_CONTROLLER] |
| 190 | 186 | self.assertEqual(parent.children, [child], | 223 | self.assertEqual(parent.children, [child], |
| 191 | 187 | 'Child missing in parent.children.') | 224 | 'Child missing in parent.children.') |
| 192 | 188 | self.assertEqual(child.parent, parent, | 225 | self.assertEqual(child.parent, parent, |
| 193 | @@ -744,11 +781,10 @@ | |||
| 194 | 744 | } | 781 | } |
| 195 | 745 | 782 | ||
| 196 | 746 | parser = SubmissionParser() | 783 | parser = SubmissionParser() |
| 198 | 747 | parser.buildDeviceList(parsed_data) | 784 | parser.buildHalDeviceList(parsed_data) |
| 199 | 748 | 785 | ||
| 203 | 749 | usb_fake_scsi_disk = parser.hal_devices[ | 786 | usb_fake_scsi_disk = parser.devices[self.UDI_USB_STORAGE_SCSI_DEVICE] |
| 204 | 750 | self.UDI_USB_STORAGE_SCSI_DEVICE] | 787 | usb_main_device = parser.devices[self.UDI_USB_STORAGE_IF0] |
| 202 | 751 | usb_main_device = parser.hal_devices[self.UDI_USB_STORAGE_IF0] | ||
| 205 | 752 | self.assertEqual(usb_main_device, usb_fake_scsi_disk.scsi_controller) | 788 | self.assertEqual(usb_main_device, usb_fake_scsi_disk.scsi_controller) |
| 206 | 753 | 789 | ||
| 207 | 754 | def test_HALDevice_scsi_controller_pci_controller(self): | 790 | def test_HALDevice_scsi_controller_pci_controller(self): |
| 208 | @@ -795,10 +831,10 @@ | |||
| 209 | 795 | } | 831 | } |
| 210 | 796 | 832 | ||
| 211 | 797 | parser = SubmissionParser() | 833 | parser = SubmissionParser() |
| 213 | 798 | parser.buildDeviceList(parsed_data) | 834 | parser.buildHalDeviceList(parsed_data) |
| 214 | 799 | 835 | ||
| 217 | 800 | scsi_device = parser.hal_devices[self.UDI_SATA_DISK] | 836 | scsi_device = parser.devices[self.UDI_SATA_DISK] |
| 218 | 801 | controller = parser.hal_devices[self.UDI_SATA_CONTROLLER] | 837 | controller = parser.devices[self.UDI_SATA_CONTROLLER] |
| 219 | 802 | self.assertEqual(controller, scsi_device.scsi_controller) | 838 | self.assertEqual(controller, scsi_device.scsi_controller) |
| 220 | 803 | 839 | ||
| 221 | 804 | def test_HALDevice_scsi_controller_non_scsi_device(self): | 840 | def test_HALDevice_scsi_controller_non_scsi_device(self): |
| 222 | @@ -822,9 +858,9 @@ | |||
| 223 | 822 | } | 858 | } |
| 224 | 823 | 859 | ||
| 225 | 824 | parser = SubmissionParser() | 860 | parser = SubmissionParser() |
| 227 | 825 | parser.buildDeviceList(parsed_data) | 861 | parser.buildHalDeviceList(parsed_data) |
| 228 | 826 | 862 | ||
| 230 | 827 | device = parser.hal_devices[self.UDI_COMPUTER] | 863 | device = parser.devices[self.UDI_COMPUTER] |
| 231 | 828 | self.assertEqual(None, device.scsi_controller) | 864 | self.assertEqual(None, device.scsi_controller) |
| 232 | 829 | 865 | ||
| 233 | 830 | def test_HALDevice_scsi_controller_no_grandparent(self): | 866 | def test_HALDevice_scsi_controller_no_grandparent(self): |
| 234 | @@ -859,9 +895,9 @@ | |||
| 235 | 859 | 895 | ||
| 236 | 860 | parser = SubmissionParser(self.log) | 896 | parser = SubmissionParser(self.log) |
| 237 | 861 | parser.submission_key = 'SCSI device without grandparent device' | 897 | parser.submission_key = 'SCSI device without grandparent device' |
| 239 | 862 | parser.buildDeviceList(parsed_data) | 898 | parser.buildHalDeviceList(parsed_data) |
| 240 | 863 | 899 | ||
| 242 | 864 | scsi_device = parser.hal_devices[self.UDI_SATA_DISK] | 900 | scsi_device = parser.devices[self.UDI_SATA_DISK] |
| 243 | 865 | self.assertEqual(None, scsi_device.scsi_controller) | 901 | self.assertEqual(None, scsi_device.scsi_controller) |
| 244 | 866 | self.assertWarningMessage( | 902 | self.assertWarningMessage( |
| 245 | 867 | parser.submission_key, | 903 | parser.submission_key, |
| 246 | @@ -893,9 +929,9 @@ | |||
| 247 | 893 | 929 | ||
| 248 | 894 | parser = SubmissionParser(self.log) | 930 | parser = SubmissionParser(self.log) |
| 249 | 895 | parser.submission_key = 'SCSI device without parent device' | 931 | parser.submission_key = 'SCSI device without parent device' |
| 251 | 896 | parser.buildDeviceList(parsed_data) | 932 | parser.buildHalDeviceList(parsed_data) |
| 252 | 897 | 933 | ||
| 254 | 898 | scsi_device = parser.hal_devices[self.UDI_SATA_DISK] | 934 | scsi_device = parser.devices[self.UDI_SATA_DISK] |
| 255 | 899 | self.assertEqual(None, scsi_device.scsi_controller) | 935 | self.assertEqual(None, scsi_device.scsi_controller) |
| 256 | 900 | self.assertWarningMessage( | 936 | self.assertWarningMessage( |
| 257 | 901 | parser.submission_key, | 937 | parser.submission_key, |
| 258 | @@ -930,8 +966,8 @@ | |||
| 259 | 930 | }, | 966 | }, |
| 260 | 931 | } | 967 | } |
| 261 | 932 | parser = SubmissionParser(self.log) | 968 | parser = SubmissionParser(self.log) |
| 264 | 933 | parser.buildDeviceList(parsed_data) | 969 | parser.buildHalDeviceList(parsed_data) |
| 265 | 934 | test_device = parser.hal_devices[UDI_TEST_DEVICE] | 970 | test_device = parser.devices[UDI_TEST_DEVICE] |
| 266 | 935 | test_bus = test_device.real_bus | 971 | test_bus = test_device.real_bus |
| 267 | 936 | self.assertEqual(test_bus, real_bus, | 972 | self.assertEqual(test_bus, real_bus, |
| 268 | 937 | 'Unexpected result of HALDevice.real_bus for ' | 973 | 'Unexpected result of HALDevice.real_bus for ' |
| 269 | @@ -957,8 +993,8 @@ | |||
| 270 | 957 | }, | 993 | }, |
| 271 | 958 | } | 994 | } |
| 272 | 959 | parser = SubmissionParser(self.log) | 995 | parser = SubmissionParser(self.log) |
| 275 | 960 | parser.buildDeviceList(parsed_data) | 996 | parser.buildHalDeviceList(parsed_data) |
| 276 | 961 | test_device = parser.hal_devices[self.UDI_COMPUTER] | 997 | test_device = parser.devices[self.UDI_COMPUTER] |
| 277 | 962 | test_bus = test_device.real_bus | 998 | test_bus = test_device.real_bus |
| 278 | 963 | self.assertEqual(test_bus, HWBus.SYSTEM, | 999 | self.assertEqual(test_bus, HWBus.SYSTEM, |
| 279 | 964 | 'Unexpected result of HALDevice.real_bus for ' | 1000 | 'Unexpected result of HALDevice.real_bus for ' |
| 280 | @@ -1017,10 +1053,9 @@ | |||
| 281 | 1017 | } | 1053 | } |
| 282 | 1018 | 1054 | ||
| 283 | 1019 | parser = SubmissionParser(self.log) | 1055 | parser = SubmissionParser(self.log) |
| 285 | 1020 | parser.buildDeviceList(parsed_data) | 1056 | parser.buildHalDeviceList(parsed_data) |
| 286 | 1021 | 1057 | ||
| 289 | 1022 | usb_fake_scsi_disk = parser.hal_devices[ | 1058 | usb_fake_scsi_disk = parser.devices[self.UDI_USB_STORAGE_SCSI_DEVICE] |
| 288 | 1023 | self.UDI_USB_STORAGE_SCSI_DEVICE] | ||
| 290 | 1024 | self.assertEqual(usb_fake_scsi_disk.real_bus, None, | 1059 | self.assertEqual(usb_fake_scsi_disk.real_bus, None, |
| 291 | 1025 | 'Unexpected result of HALDevice.real_bus for the fake SCSI ' | 1060 | 'Unexpected result of HALDevice.real_bus for the fake SCSI ' |
| 292 | 1026 | 'disk HAL node of a USB storage device bus.') | 1061 | 'disk HAL node of a USB storage device bus.') |
| 293 | @@ -1085,12 +1120,12 @@ | |||
| 294 | 1085 | ) | 1120 | ) |
| 295 | 1086 | 1121 | ||
| 296 | 1087 | parser = SubmissionParser(self.log) | 1122 | parser = SubmissionParser(self.log) |
| 298 | 1088 | parser.buildDeviceList(parsed_data) | 1123 | parser.buildHalDeviceList(parsed_data) |
| 299 | 1089 | 1124 | ||
| 300 | 1090 | for device_subclass, expected_bus in pci_subclass_bus: | 1125 | for device_subclass, expected_bus in pci_subclass_bus: |
| 301 | 1091 | devices[0]['properties']['pci.device_subclass'] = ( | 1126 | devices[0]['properties']['pci.device_subclass'] = ( |
| 302 | 1092 | device_subclass, 'int') | 1127 | device_subclass, 'int') |
| 304 | 1093 | fake_scsi_disk = parser.hal_devices[self.UDI_SATA_DISK] | 1128 | fake_scsi_disk = parser.devices[self.UDI_SATA_DISK] |
| 305 | 1094 | found_bus = fake_scsi_disk.real_bus | 1129 | found_bus = fake_scsi_disk.real_bus |
| 306 | 1095 | self.assertEqual(found_bus, expected_bus, | 1130 | self.assertEqual(found_bus, expected_bus, |
| 307 | 1096 | 'Unexpected result of HWDevice.real_bus for PCI storage ' | 1131 | 'Unexpected result of HWDevice.real_bus for PCI storage ' |
| 308 | @@ -1125,8 +1160,8 @@ | |||
| 309 | 1125 | } | 1160 | } |
| 310 | 1126 | parser = SubmissionParser(self.log) | 1161 | parser = SubmissionParser(self.log) |
| 311 | 1127 | parser.submission_key = 'Test SCSI disk without a grandparent' | 1162 | parser.submission_key = 'Test SCSI disk without a grandparent' |
| 314 | 1128 | parser.buildDeviceList(parsed_data) | 1163 | parser.buildHalDeviceList(parsed_data) |
| 315 | 1129 | scsi_disk = parser.hal_devices[self.UDI_SCSI_DISK] | 1164 | scsi_disk = parser.devices[self.UDI_SCSI_DISK] |
| 316 | 1130 | bus = scsi_disk.real_bus | 1165 | bus = scsi_disk.real_bus |
| 317 | 1131 | self.assertEqual(bus, None, | 1166 | self.assertEqual(bus, None, |
| 318 | 1132 | 'Unexpected result of HALDevice.real_bus for a SCSI device ' | 1167 | 'Unexpected result of HALDevice.real_bus for a SCSI device ' |
| 319 | @@ -1155,8 +1190,8 @@ | |||
| 320 | 1155 | } | 1190 | } |
| 321 | 1156 | parser = SubmissionParser(self.log) | 1191 | parser = SubmissionParser(self.log) |
| 322 | 1157 | parser.submission_key = 'Test SCSI disk without a parent' | 1192 | parser.submission_key = 'Test SCSI disk without a parent' |
| 325 | 1158 | parser.buildDeviceList(parsed_data) | 1193 | parser.buildHalDeviceList(parsed_data) |
| 326 | 1159 | scsi_disk = parser.hal_devices[self.UDI_SCSI_DISK] | 1194 | scsi_disk = parser.devices[self.UDI_SCSI_DISK] |
| 327 | 1160 | bus = scsi_disk.real_bus | 1195 | bus = scsi_disk.real_bus |
| 328 | 1161 | self.assertEqual(bus, None, | 1196 | self.assertEqual(bus, None, |
| 329 | 1162 | 'Unexpected result of HALDevice.real_bus for a SCSI device ' | 1197 | 'Unexpected result of HALDevice.real_bus for a SCSI device ' |
| 330 | @@ -1210,8 +1245,8 @@ | |||
| 331 | 1210 | parser = SubmissionParser(self.log) | 1245 | parser = SubmissionParser(self.log) |
| 332 | 1211 | parser.submission_key = ( | 1246 | parser.submission_key = ( |
| 333 | 1212 | 'Test SCSI disk with invalid controller device class') | 1247 | 'Test SCSI disk with invalid controller device class') |
| 336 | 1213 | parser.buildDeviceList(parsed_data) | 1248 | parser.buildHalDeviceList(parsed_data) |
| 337 | 1214 | scsi_disk = parser.hal_devices[self.UDI_SATA_DISK] | 1249 | scsi_disk = parser.devices[self.UDI_SATA_DISK] |
| 338 | 1215 | bus = scsi_disk.real_bus | 1250 | bus = scsi_disk.real_bus |
| 339 | 1216 | self.assertEqual(bus, None, | 1251 | self.assertEqual(bus, None, |
| 340 | 1217 | 'Unexpected result of HALDevice.real_bus for a SCSI device ' | 1252 | 'Unexpected result of HALDevice.real_bus for a SCSI device ' |
| 341 | @@ -1286,8 +1321,8 @@ | |||
| 342 | 1286 | parent_device['udi'], 'str') | 1321 | parent_device['udi'], 'str') |
| 343 | 1287 | devices.append(tested_device) | 1322 | devices.append(tested_device) |
| 344 | 1288 | parsed_data['hardware']['hal']['devices'] = devices | 1323 | parsed_data['hardware']['hal']['devices'] = devices |
| 347 | 1289 | parser.buildDeviceList(parsed_data) | 1324 | parser.buildHalDeviceList(parsed_data) |
| 348 | 1290 | tested_hal_device = parser.hal_devices[self.UDI_PCCARD_DEVICE] | 1325 | tested_hal_device = parser.devices[self.UDI_PCCARD_DEVICE] |
| 349 | 1291 | found_bus = tested_hal_device.real_bus | 1326 | found_bus = tested_hal_device.real_bus |
| 350 | 1292 | expected_bus = expected_result_for_parent_device[ | 1327 | expected_bus = expected_result_for_parent_device[ |
| 351 | 1293 | parent_device['udi']] | 1328 | parent_device['udi']] |
| 352 | @@ -1317,8 +1352,8 @@ | |||
| 353 | 1317 | 1352 | ||
| 354 | 1318 | parser = SubmissionParser(self.log) | 1353 | parser = SubmissionParser(self.log) |
| 355 | 1319 | parser.submission_key = 'Test of unknown bus name' | 1354 | parser.submission_key = 'Test of unknown bus name' |
| 358 | 1320 | parser.buildDeviceList(parsed_data) | 1355 | parser.buildHalDeviceList(parsed_data) |
| 359 | 1321 | found_bus = parser.hal_devices[self.UDI_PCCARD_DEVICE].real_bus | 1356 | found_bus = parser.devices[self.UDI_PCCARD_DEVICE].real_bus |
| 360 | 1322 | self.assertEqual(found_bus, None, | 1357 | self.assertEqual(found_bus, None, |
| 361 | 1323 | 'Unexpected result of HWDevice.real_bus for an ' | 1358 | 'Unexpected result of HWDevice.real_bus for an ' |
| 362 | 1324 | 'unknown bus name: Expected None, got %r.' | 1359 | 'unknown bus name: Expected None, got %r.' |
| 363 | @@ -1346,8 +1381,8 @@ | |||
| 364 | 1346 | 1381 | ||
| 365 | 1347 | parser = SubmissionParser() | 1382 | parser = SubmissionParser() |
| 366 | 1348 | parser.submission_key = 'Test of HALDevice.is_root_device' | 1383 | parser.submission_key = 'Test of HALDevice.is_root_device' |
| 369 | 1349 | parser.buildDeviceList(parsed_data) | 1384 | parser.buildHalDeviceList(parsed_data) |
| 370 | 1350 | self.assertTrue(parser.hal_devices[self.UDI_COMPUTER].is_root_device) | 1385 | self.assertTrue(parser.devices[self.UDI_COMPUTER].is_root_device) |
| 371 | 1351 | 1386 | ||
| 372 | 1352 | def test_HALDevice_is_root_device_for_non_root_device(self): | 1387 | def test_HALDevice_is_root_device_for_non_root_device(self): |
| 373 | 1353 | """Test of HALDevice.is_root_device for a non-root device.""" | 1388 | """Test of HALDevice.is_root_device for a non-root device.""" |
| 374 | @@ -1368,9 +1403,9 @@ | |||
| 375 | 1368 | 1403 | ||
| 376 | 1369 | parser = SubmissionParser() | 1404 | parser = SubmissionParser() |
| 377 | 1370 | parser.submission_key = 'Test of HALDevice.is_root_device' | 1405 | parser.submission_key = 'Test of HALDevice.is_root_device' |
| 379 | 1371 | parser.buildDeviceList(parsed_data) | 1406 | parser.buildHalDeviceList(parsed_data) |
| 380 | 1372 | self.assertFalse( | 1407 | self.assertFalse( |
| 382 | 1373 | parser.hal_devices[self.UDI_PCCARD_DEVICE].is_root_device) | 1408 | parser.devices[self.UDI_PCCARD_DEVICE].is_root_device) |
| 383 | 1374 | 1409 | ||
| 384 | 1375 | def renameInfoBusToInfoSubsystem(self, devices): | 1410 | def renameInfoBusToInfoSubsystem(self, devices): |
| 385 | 1376 | """Rename the property info.bus in a device list to info.subsystem. | 1411 | """Rename the property info.bus in a device list to info.subsystem. |
| 386 | @@ -1418,14 +1453,14 @@ | |||
| 387 | 1418 | }, | 1453 | }, |
| 388 | 1419 | } | 1454 | } |
| 389 | 1420 | parser = SubmissionParser(self.log) | 1455 | parser = SubmissionParser(self.log) |
| 392 | 1421 | parser.buildDeviceList(parsed_data) | 1456 | parser.buildHalDeviceList(parsed_data) |
| 393 | 1422 | device = parser.hal_devices[self.UDI_USB_CONTROLLER_PCI_SIDE] | 1457 | device = parser.devices[self.UDI_USB_CONTROLLER_PCI_SIDE] |
| 394 | 1423 | self.failUnless(device.is_real_device, | 1458 | self.failUnless(device.is_real_device, |
| 395 | 1424 | 'Device with info.bus property not treated as a ' | 1459 | 'Device with info.bus property not treated as a ' |
| 396 | 1425 | 'real device.') | 1460 | 'real device.') |
| 397 | 1426 | self.renameInfoBusToInfoSubsystem(devices) | 1461 | self.renameInfoBusToInfoSubsystem(devices) |
| 400 | 1427 | parser.buildDeviceList(parsed_data) | 1462 | parser.buildHalDeviceList(parsed_data) |
| 401 | 1428 | device = parser.hal_devices[self.UDI_USB_CONTROLLER_PCI_SIDE] | 1463 | device = parser.devices[self.UDI_USB_CONTROLLER_PCI_SIDE] |
| 402 | 1429 | self.failUnless(device.is_real_device, | 1464 | self.failUnless(device.is_real_device, |
| 403 | 1430 | 'Device with info.subsystem property not treated as ' | 1465 | 'Device with info.subsystem property not treated as ' |
| 404 | 1431 | 'a real device.') | 1466 | 'a real device.') |
| 405 | @@ -1449,8 +1484,8 @@ | |||
| 406 | 1449 | } | 1484 | } |
| 407 | 1450 | 1485 | ||
| 408 | 1451 | parser = SubmissionParser(self.log) | 1486 | parser = SubmissionParser(self.log) |
| 411 | 1452 | parser.buildDeviceList(parsed_data) | 1487 | parser.buildHalDeviceList(parsed_data) |
| 412 | 1453 | device = parser.hal_devices[UDI_HAL_STORAGE_DEVICE] | 1488 | device = parser.devices[UDI_HAL_STORAGE_DEVICE] |
| 413 | 1454 | self.failIf(device.is_real_device, | 1489 | self.failIf(device.is_real_device, |
| 414 | 1455 | 'Device without info.bus property treated as a ' | 1490 | 'Device without info.bus property treated as a ' |
| 415 | 1456 | 'real device') | 1491 | 'real device') |
| 416 | @@ -1489,8 +1524,8 @@ | |||
| 417 | 1489 | 'sound', 'ssb', 'tty', 'usb', 'video4linux', ) | 1524 | 'sound', 'ssb', 'tty', 'usb', 'video4linux', ) |
| 418 | 1490 | for tested_bus in ignored_buses: | 1525 | for tested_bus in ignored_buses: |
| 419 | 1491 | properties['info.bus'] = (tested_bus, 'str') | 1526 | properties['info.bus'] = (tested_bus, 'str') |
| 422 | 1492 | parser.buildDeviceList(parsed_data) | 1527 | parser.buildHalDeviceList(parsed_data) |
| 423 | 1493 | device = parser.hal_devices[self.UDI_USB_HUB_IF0] | 1528 | device = parser.devices[self.UDI_USB_HUB_IF0] |
| 424 | 1494 | self.failIf( | 1529 | self.failIf( |
| 425 | 1495 | device.is_real_device, | 1530 | device.is_real_device, |
| 426 | 1496 | 'Device with info.bus=%s treated as a real device' | 1531 | 'Device with info.bus=%s treated as a real device' |
| 427 | @@ -1499,8 +1534,8 @@ | |||
| 428 | 1499 | del properties['info.bus'] | 1534 | del properties['info.bus'] |
| 429 | 1500 | for tested_bus in ignored_buses: | 1535 | for tested_bus in ignored_buses: |
| 430 | 1501 | properties['info.subsystem'] = (tested_bus, 'str') | 1536 | properties['info.subsystem'] = (tested_bus, 'str') |
| 433 | 1502 | parser.buildDeviceList(parsed_data) | 1537 | parser.buildHalDeviceList(parsed_data) |
| 434 | 1503 | device = parser.hal_devices[self.UDI_USB_HUB_IF0] | 1538 | device = parser.devices[self.UDI_USB_HUB_IF0] |
| 435 | 1504 | self.failIf( | 1539 | self.failIf( |
| 436 | 1505 | device.is_real_device, | 1540 | device.is_real_device, |
| 437 | 1506 | 'Device with info.subsystem=%s treated as a real device' | 1541 | 'Device with info.subsystem=%s treated as a real device' |
| 438 | @@ -1532,12 +1567,12 @@ | |||
| 439 | 1532 | ) | 1567 | ) |
| 440 | 1533 | 1568 | ||
| 441 | 1534 | parser = SubmissionParser(self.log) | 1569 | parser = SubmissionParser(self.log) |
| 443 | 1535 | parser.buildDeviceList(parsed_data) | 1570 | parser.buildHalDeviceList(parsed_data) |
| 444 | 1536 | 1571 | ||
| 445 | 1537 | for device_subclass, expected_is_real in pci_subclass_bus: | 1572 | for device_subclass, expected_is_real in pci_subclass_bus: |
| 446 | 1538 | devices[0]['properties']['pci.device_subclass'] = ( | 1573 | devices[0]['properties']['pci.device_subclass'] = ( |
| 447 | 1539 | device_subclass, 'int') | 1574 | device_subclass, 'int') |
| 449 | 1540 | scsi_device = parser.hal_devices[self.UDI_SATA_DISK] | 1575 | scsi_device = parser.devices[self.UDI_SATA_DISK] |
| 450 | 1541 | found_is_real = scsi_device.is_real_device | 1576 | found_is_real = scsi_device.is_real_device |
| 451 | 1542 | self.assertEqual(found_is_real, expected_is_real, | 1577 | self.assertEqual(found_is_real, expected_is_real, |
| 452 | 1543 | 'Unexpected result of HWDevice.is_real_device for a HAL SCSI ' | 1578 | 'Unexpected result of HWDevice.is_real_device for a HAL SCSI ' |
| 453 | @@ -1641,15 +1676,15 @@ | |||
| 454 | 1641 | } | 1676 | } |
| 455 | 1642 | 1677 | ||
| 456 | 1643 | parser = SubmissionParser(self.log) | 1678 | parser = SubmissionParser(self.log) |
| 458 | 1644 | parser.buildDeviceList(parsed_data) | 1679 | parser.buildHalDeviceList(parsed_data) |
| 459 | 1645 | 1680 | ||
| 461 | 1646 | scsi_device = parser.hal_devices[self.UDI_USB_STORAGE_SCSI_DEVICE] | 1681 | scsi_device = parser.devices[self.UDI_USB_STORAGE_SCSI_DEVICE] |
| 462 | 1647 | self.failIf(scsi_device.is_real_device, | 1682 | self.failIf(scsi_device.is_real_device, |
| 463 | 1648 | 'Unexpected result of HWDevice.is_real_device for a HAL SCSI ' | 1683 | 'Unexpected result of HWDevice.is_real_device for a HAL SCSI ' |
| 464 | 1649 | 'device as a subdevice of a USB storage device.') | 1684 | 'device as a subdevice of a USB storage device.') |
| 465 | 1650 | 1685 | ||
| 466 | 1651 | self.renameInfoBusToInfoSubsystem(devices) | 1686 | self.renameInfoBusToInfoSubsystem(devices) |
| 468 | 1652 | scsi_device = parser.hal_devices[self.UDI_USB_STORAGE_SCSI_DEVICE] | 1687 | scsi_device = parser.devices[self.UDI_USB_STORAGE_SCSI_DEVICE] |
| 469 | 1653 | self.failIf(scsi_device.is_real_device, | 1688 | self.failIf(scsi_device.is_real_device, |
| 470 | 1654 | 'Unexpected result of HWDevice.is_real_device for a HAL SCSI ' | 1689 | 'Unexpected result of HWDevice.is_real_device for a HAL SCSI ' |
| 471 | 1655 | 'device as a subdevice of a USB storage device.') | 1690 | 'device as a subdevice of a USB storage device.') |
| 472 | @@ -1672,8 +1707,8 @@ | |||
| 473 | 1672 | } | 1707 | } |
| 474 | 1673 | 1708 | ||
| 475 | 1674 | parser = SubmissionParser(self.log) | 1709 | parser = SubmissionParser(self.log) |
| 478 | 1675 | parser.buildDeviceList(parsed_data) | 1710 | parser.buildHalDeviceList(parsed_data) |
| 479 | 1676 | device = parser.hal_devices[self.UDI_COMPUTER] | 1711 | device = parser.devices[self.UDI_COMPUTER] |
| 480 | 1677 | self.failUnless(device.is_real_device, | 1712 | self.failUnless(device.is_real_device, |
| 481 | 1678 | 'Root device not treated as a real device') | 1713 | 'Root device not treated as a real device') |
| 482 | 1679 | 1714 | ||
| 483 | @@ -1745,11 +1780,11 @@ | |||
| 484 | 1745 | } | 1780 | } |
| 485 | 1746 | 1781 | ||
| 486 | 1747 | parser = SubmissionParser(self.log) | 1782 | parser = SubmissionParser(self.log) |
| 488 | 1748 | parser.buildDeviceList(parsed_data) | 1783 | parser.buildHalDeviceList(parsed_data) |
| 489 | 1749 | 1784 | ||
| 490 | 1750 | # The PCI-USB bridge is a child of the system. | 1785 | # The PCI-USB bridge is a child of the system. |
| 493 | 1751 | root_device = parser.hal_devices[self.UDI_COMPUTER] | 1786 | root_device = parser.devices[self.UDI_COMPUTER] |
| 494 | 1752 | pci_usb_bridge = parser.hal_devices[self.UDI_USB_CONTROLLER_PCI_SIDE] | 1787 | pci_usb_bridge = parser.devices[self.UDI_USB_CONTROLLER_PCI_SIDE] |
| 495 | 1753 | self.assertEqual(root_device.getRealChildren(), [pci_usb_bridge], | 1788 | self.assertEqual(root_device.getRealChildren(), [pci_usb_bridge], |
| 496 | 1754 | 'Unexpected list of real children of the root ' | 1789 | 'Unexpected list of real children of the root ' |
| 497 | 1755 | 'device') | 1790 | 'device') |
| 498 | @@ -1759,7 +1794,7 @@ | |||
| 499 | 1759 | # but the node for the USB device is considered to be a child | 1794 | # but the node for the USB device is considered to be a child |
| 500 | 1760 | # of the bridge. | 1795 | # of the bridge. |
| 501 | 1761 | 1796 | ||
| 503 | 1762 | usb_device = parser.hal_devices[self.UDI_USB_HUB] | 1797 | usb_device = parser.devices[self.UDI_USB_HUB] |
| 504 | 1763 | self.assertEqual(pci_usb_bridge.getRealChildren(), [usb_device], | 1798 | self.assertEqual(pci_usb_bridge.getRealChildren(), [usb_device], |
| 505 | 1764 | 'Unexpected list of real children of the PCI-> ' | 1799 | 'Unexpected list of real children of the PCI-> ' |
| 506 | 1765 | 'USB bridge') | 1800 | 'USB bridge') |
| 507 | @@ -1793,8 +1828,8 @@ | |||
| 508 | 1793 | }, | 1828 | }, |
| 509 | 1794 | } | 1829 | } |
| 510 | 1795 | parser = SubmissionParser(self.log) | 1830 | parser = SubmissionParser(self.log) |
| 513 | 1796 | parser.buildDeviceList(parsed_data) | 1831 | parser.buildHalDeviceList(parsed_data) |
| 514 | 1797 | device = parser.hal_devices[self.UDI_SATA_CONTROLLER] | 1832 | device = parser.devices[self.UDI_SATA_CONTROLLER] |
| 515 | 1798 | self.failUnless( | 1833 | self.failUnless( |
| 516 | 1799 | device.has_reliable_data, | 1834 | device.has_reliable_data, |
| 517 | 1800 | 'Regular device treated as not having reliable data.') | 1835 | 'Regular device treated as not having reliable data.') |
| 518 | @@ -1821,8 +1856,8 @@ | |||
| 519 | 1821 | 'mmc', 'mmc_host', 'pcmcia', 'platform', 'pnp', | 1856 | 'mmc', 'mmc_host', 'pcmcia', 'platform', 'pnp', |
| 520 | 1822 | 'power_supply', 'unknown'): | 1857 | 'power_supply', 'unknown'): |
| 521 | 1823 | properties['info.bus'] = (bus, 'str') | 1858 | properties['info.bus'] = (bus, 'str') |
| 524 | 1824 | parser.buildDeviceList(parsed_data) | 1859 | parser.buildHalDeviceList(parsed_data) |
| 525 | 1825 | device = parser.hal_devices[self.UDI_SATA_CONTROLLER] | 1860 | device = parser.devices[self.UDI_SATA_CONTROLLER] |
| 526 | 1826 | self.failIf(device.has_reliable_data, | 1861 | self.failIf(device.has_reliable_data, |
| 527 | 1827 | 'Device with bus=%s treated as having reliable data.' % bus) | 1862 | 'Device with bus=%s treated as having reliable data.' % bus) |
| 528 | 1828 | 1863 | ||
| 529 | @@ -1853,8 +1888,8 @@ | |||
| 530 | 1853 | } | 1888 | } |
| 531 | 1854 | parser = SubmissionParser(self.log) | 1889 | parser = SubmissionParser(self.log) |
| 532 | 1855 | properties = devices[0]['properties'] | 1890 | properties = devices[0]['properties'] |
| 535 | 1856 | parser.buildDeviceList(parsed_data) | 1891 | parser.buildHalDeviceList(parsed_data) |
| 536 | 1857 | device = parser.hal_devices[self.UDI_COMPUTER] | 1892 | device = parser.devices[self.UDI_COMPUTER] |
| 537 | 1858 | self.failUnless(device.has_reliable_data, | 1893 | self.failUnless(device.has_reliable_data, |
| 538 | 1859 | 'Root device not treated as having reliable data.') | 1894 | 'Root device not treated as having reliable data.') |
| 539 | 1860 | 1895 | ||
| 540 | @@ -1921,8 +1956,8 @@ | |||
| 541 | 1921 | parser = SubmissionParser(self.log) | 1956 | parser = SubmissionParser(self.log) |
| 542 | 1922 | submission_key = 'test_missing_%s' % missing_data | 1957 | submission_key = 'test_missing_%s' % missing_data |
| 543 | 1923 | parser.submission_key = submission_key | 1958 | parser.submission_key = submission_key |
| 546 | 1924 | parser.buildDeviceList(test_parsed_data) | 1959 | parser.buildHalDeviceList(test_parsed_data) |
| 547 | 1925 | device = parser.hal_devices[self.UDI_SATA_CONTROLLER] | 1960 | device = parser.devices[self.UDI_SATA_CONTROLLER] |
| 548 | 1926 | self.failIf( | 1961 | self.failIf( |
| 549 | 1927 | device.has_reliable_data, | 1962 | device.has_reliable_data, |
| 550 | 1928 | 'Device with missing property %s treated as having reliable' | 1963 | 'Device with missing property %s treated as having reliable' |
| 551 | @@ -1971,8 +2006,8 @@ | |||
| 552 | 1971 | } | 2006 | } |
| 553 | 1972 | 2007 | ||
| 554 | 1973 | parser = SubmissionParser(self.log) | 2008 | parser = SubmissionParser(self.log) |
| 557 | 1974 | parser.buildDeviceList(parsed_data) | 2009 | parser.buildHalDeviceList(parsed_data) |
| 558 | 1975 | device = parser.hal_devices[self.UDI_SATA_DISK] | 2010 | device = parser.devices[self.UDI_SATA_DISK] |
| 559 | 1976 | self.failIf( | 2011 | self.failIf( |
| 560 | 1977 | device.has_reliable_data, | 2012 | device.has_reliable_data, |
| 561 | 1978 | 'IDE Device with missing properties vendor ID, product ID, ' | 2013 | 'IDE Device with missing properties vendor ID, product ID, ' |
| 562 | @@ -2003,8 +2038,8 @@ | |||
| 563 | 2003 | }, | 2038 | }, |
| 564 | 2004 | } | 2039 | } |
| 565 | 2005 | parser = SubmissionParser(self.log) | 2040 | parser = SubmissionParser(self.log) |
| 568 | 2006 | parser.buildDeviceList(parsed_data) | 2041 | parser.buildHalDeviceList(parsed_data) |
| 569 | 2007 | device = parser.hal_devices[self.UDI_SCSI_DISK] | 2042 | device = parser.devices[self.UDI_SCSI_DISK] |
| 570 | 2008 | vendor_model = device.getScsiVendorAndModelName() | 2043 | vendor_model = device.getScsiVendorAndModelName() |
| 571 | 2009 | self.assertEqual( | 2044 | self.assertEqual( |
| 572 | 2010 | { | 2045 | { |
| 573 | @@ -2042,8 +2077,8 @@ | |||
| 574 | 2042 | }, | 2077 | }, |
| 575 | 2043 | } | 2078 | } |
| 576 | 2044 | parser = SubmissionParser(self.log) | 2079 | parser = SubmissionParser(self.log) |
| 579 | 2045 | parser.buildDeviceList(parsed_data) | 2080 | parser.buildHalDeviceList(parsed_data) |
| 580 | 2046 | device = parser.hal_devices[self.UDI_SCSI_DISK] | 2081 | device = parser.devices[self.UDI_SCSI_DISK] |
| 581 | 2047 | vendor_model = device.getScsiVendorAndModelName() | 2082 | vendor_model = device.getScsiVendorAndModelName() |
| 582 | 2048 | self.assertEqual( | 2083 | self.assertEqual( |
| 583 | 2049 | { | 2084 | { |
| 584 | @@ -2080,8 +2115,8 @@ | |||
| 585 | 2080 | }, | 2115 | }, |
| 586 | 2081 | } | 2116 | } |
| 587 | 2082 | parser = SubmissionParser(self.log) | 2117 | parser = SubmissionParser(self.log) |
| 590 | 2083 | parser.buildDeviceList(parsed_data) | 2118 | parser.buildHalDeviceList(parsed_data) |
| 591 | 2084 | device = parser.hal_devices[self.UDI_SCSI_DISK] | 2119 | device = parser.devices[self.UDI_SCSI_DISK] |
| 592 | 2085 | vendor_product = device.getScsiVendorAndModelName() | 2120 | vendor_product = device.getScsiVendorAndModelName() |
| 593 | 2086 | self.assertEqual( | 2121 | self.assertEqual( |
| 594 | 2087 | { | 2122 | { |
| 595 | @@ -2116,8 +2151,8 @@ | |||
| 596 | 2116 | }, | 2151 | }, |
| 597 | 2117 | } | 2152 | } |
| 598 | 2118 | parser = SubmissionParser(self.log) | 2153 | parser = SubmissionParser(self.log) |
| 601 | 2119 | parser.buildDeviceList(parsed_data) | 2154 | parser.buildHalDeviceList(parsed_data) |
| 602 | 2120 | found_vendor = parser.hal_devices[self.UDI_SATA_CONTROLLER].vendor | 2155 | found_vendor = parser.devices[self.UDI_SATA_CONTROLLER].vendor |
| 603 | 2121 | self.assertEqual(found_vendor, 'Intel Corporation', | 2156 | self.assertEqual(found_vendor, 'Intel Corporation', |
| 604 | 2122 | 'Unexpected result of HWDevice.vendor. ' | 2157 | 'Unexpected result of HWDevice.vendor. ' |
| 605 | 2123 | 'Expected Intel Corporation, got %r.' | 2158 | 'Expected Intel Corporation, got %r.' |
| 606 | @@ -2147,8 +2182,8 @@ | |||
| 607 | 2147 | }, | 2182 | }, |
| 608 | 2148 | } | 2183 | } |
| 609 | 2149 | parser = SubmissionParser(self.log) | 2184 | parser = SubmissionParser(self.log) |
| 612 | 2150 | parser.buildDeviceList(parsed_data) | 2185 | parser.buildHalDeviceList(parsed_data) |
| 613 | 2151 | found_vendor = parser.hal_devices[self.UDI_SATA_CONTROLLER].vendor | 2186 | found_vendor = parser.devices[self.UDI_SATA_CONTROLLER].vendor |
| 614 | 2152 | self.assertEqual(found_vendor, 'Intel Corporation', | 2187 | self.assertEqual(found_vendor, 'Intel Corporation', |
| 615 | 2153 | 'Unexpected result of HWDevice.vendor, ' | 2188 | 'Unexpected result of HWDevice.vendor, ' |
| 616 | 2154 | 'if info.vendor does not exist. ' | 2189 | 'if info.vendor does not exist. ' |
| 617 | @@ -2175,8 +2210,8 @@ | |||
| 618 | 2175 | }, | 2210 | }, |
| 619 | 2176 | } | 2211 | } |
| 620 | 2177 | parser = SubmissionParser(self.log) | 2212 | parser = SubmissionParser(self.log) |
| 623 | 2178 | parser.buildDeviceList(parsed_data) | 2213 | parser.buildHalDeviceList(parsed_data) |
| 624 | 2179 | found_vendor = parser.hal_devices[self.UDI_SCSI_DISK].vendor | 2214 | found_vendor = parser.devices[self.UDI_SCSI_DISK].vendor |
| 625 | 2180 | self.assertEqual(found_vendor, 'SEAGATE', | 2215 | self.assertEqual(found_vendor, 'SEAGATE', |
| 626 | 2181 | 'Unexpected result of HWDevice.vendor ' | 2216 | 'Unexpected result of HWDevice.vendor ' |
| 627 | 2182 | 'for SCSI device. Expected SEAGATE, got %r.' | 2217 | 'for SCSI device. Expected SEAGATE, got %r.' |
| 628 | @@ -2203,8 +2238,8 @@ | |||
| 629 | 2203 | }, | 2238 | }, |
| 630 | 2204 | } | 2239 | } |
| 631 | 2205 | parser = SubmissionParser(self.log) | 2240 | parser = SubmissionParser(self.log) |
| 634 | 2206 | parser.buildDeviceList(parsed_data) | 2241 | parser.buildHalDeviceList(parsed_data) |
| 635 | 2207 | found_vendor = parser.hal_devices[self.UDI_SCSI_DISK].vendor | 2242 | found_vendor = parser.devices[self.UDI_SCSI_DISK].vendor |
| 636 | 2208 | self.assertEqual(found_vendor, 'Hitachi', | 2243 | self.assertEqual(found_vendor, 'Hitachi', |
| 637 | 2209 | 'Unexpected result of HWDevice.vendor, for fake ' | 2244 | 'Unexpected result of HWDevice.vendor, for fake ' |
| 638 | 2210 | 'SCSI device. Expected Hitachi, got %r.' | 2245 | 'SCSI device. Expected Hitachi, got %r.' |
| 639 | @@ -2233,8 +2268,8 @@ | |||
| 640 | 2233 | }, | 2268 | }, |
| 641 | 2234 | } | 2269 | } |
| 642 | 2235 | parser = SubmissionParser(self.log) | 2270 | parser = SubmissionParser(self.log) |
| 645 | 2236 | parser.buildDeviceList(parsed_data) | 2271 | parser.buildHalDeviceList(parsed_data) |
| 646 | 2237 | found_vendor = parser.hal_devices[self.UDI_COMPUTER].vendor | 2272 | found_vendor = parser.devices[self.UDI_COMPUTER].vendor |
| 647 | 2238 | self.assertEqual(found_vendor, 'FUJITSU SIEMENS', | 2273 | self.assertEqual(found_vendor, 'FUJITSU SIEMENS', |
| 648 | 2239 | 'Unexpected result of HWDevice.vendor for a ' | 2274 | 'Unexpected result of HWDevice.vendor for a ' |
| 649 | 2240 | 'system. Expected FUJITSU SIEMENS, got %r.' | 2275 | 'system. Expected FUJITSU SIEMENS, got %r.' |
| 650 | @@ -2266,8 +2301,8 @@ | |||
| 651 | 2266 | }, | 2301 | }, |
| 652 | 2267 | } | 2302 | } |
| 653 | 2268 | parser = SubmissionParser(self.log) | 2303 | parser = SubmissionParser(self.log) |
| 656 | 2269 | parser.buildDeviceList(parsed_data) | 2304 | parser.buildHalDeviceList(parsed_data) |
| 657 | 2270 | found_product = parser.hal_devices[self.UDI_SATA_CONTROLLER].product | 2305 | found_product = parser.devices[self.UDI_SATA_CONTROLLER].product |
| 658 | 2271 | self.assertEqual(found_product, '82801GBM/GHM SATA AHCI Controller', | 2306 | self.assertEqual(found_product, '82801GBM/GHM SATA AHCI Controller', |
| 659 | 2272 | 'Unexpected result of HWDevice.product. ' | 2307 | 'Unexpected result of HWDevice.product. ' |
| 660 | 2273 | 'Expected 82801GBM/GHM SATA AHCI Controller, got %r.' | 2308 | 'Expected 82801GBM/GHM SATA AHCI Controller, got %r.' |
| 661 | @@ -2297,8 +2332,8 @@ | |||
| 662 | 2297 | }, | 2332 | }, |
| 663 | 2298 | } | 2333 | } |
| 664 | 2299 | parser = SubmissionParser(self.log) | 2334 | parser = SubmissionParser(self.log) |
| 667 | 2300 | parser.buildDeviceList(parsed_data) | 2335 | parser.buildHalDeviceList(parsed_data) |
| 668 | 2301 | found_product = parser.hal_devices[self.UDI_SATA_CONTROLLER].product | 2336 | found_product = parser.devices[self.UDI_SATA_CONTROLLER].product |
| 669 | 2302 | self.assertEqual(found_product, '82801GBM/GHM SATA AHCI Controller', | 2337 | self.assertEqual(found_product, '82801GBM/GHM SATA AHCI Controller', |
| 670 | 2303 | 'Unexpected result of HWDevice.product, ' | 2338 | 'Unexpected result of HWDevice.product, ' |
| 671 | 2304 | 'if info.product does not exist. ' | 2339 | 'if info.product does not exist. ' |
| 672 | @@ -2327,8 +2362,8 @@ | |||
| 673 | 2327 | }, | 2362 | }, |
| 674 | 2328 | } | 2363 | } |
| 675 | 2329 | parser = SubmissionParser(self.log) | 2364 | parser = SubmissionParser(self.log) |
| 678 | 2330 | parser.buildDeviceList(parsed_data) | 2365 | parser.buildHalDeviceList(parsed_data) |
| 679 | 2331 | found_product = parser.hal_devices[self.UDI_SCSI_DISK].product | 2366 | found_product = parser.devices[self.UDI_SCSI_DISK].product |
| 680 | 2332 | self.assertEqual(found_product, 'ST36530N', | 2367 | self.assertEqual(found_product, 'ST36530N', |
| 681 | 2333 | 'Unexpected result of HWDevice.product ' | 2368 | 'Unexpected result of HWDevice.product ' |
| 682 | 2334 | 'for SCSI device. Expected ST36530N, got %r.' | 2369 | 'for SCSI device. Expected ST36530N, got %r.' |
| 683 | @@ -2355,8 +2390,8 @@ | |||
| 684 | 2355 | }, | 2390 | }, |
| 685 | 2356 | } | 2391 | } |
| 686 | 2357 | parser = SubmissionParser(self.log) | 2392 | parser = SubmissionParser(self.log) |
| 689 | 2358 | parser.buildDeviceList(parsed_data) | 2393 | parser.buildHalDeviceList(parsed_data) |
| 690 | 2359 | found_product = parser.hal_devices[self.UDI_SCSI_DISK].product | 2394 | found_product = parser.devices[self.UDI_SCSI_DISK].product |
| 691 | 2360 | self.assertEqual(found_product, 'HTS54161', | 2395 | self.assertEqual(found_product, 'HTS54161', |
| 692 | 2361 | 'Unexpected result of HWDevice.product, for fake ' | 2396 | 'Unexpected result of HWDevice.product, for fake ' |
| 693 | 2362 | 'SCSI device. Expected HTS54161, got %r.' | 2397 | 'SCSI device. Expected HTS54161, got %r.' |
| 694 | @@ -2385,8 +2420,8 @@ | |||
| 695 | 2385 | }, | 2420 | }, |
| 696 | 2386 | } | 2421 | } |
| 697 | 2387 | parser = SubmissionParser(self.log) | 2422 | parser = SubmissionParser(self.log) |
| 700 | 2388 | parser.buildDeviceList(parsed_data) | 2423 | parser.buildHalDeviceList(parsed_data) |
| 701 | 2389 | found_product = parser.hal_devices[self.UDI_COMPUTER].product | 2424 | found_product = parser.devices[self.UDI_COMPUTER].product |
| 702 | 2390 | self.assertEqual(found_product, 'LIFEBOOK E8210', | 2425 | self.assertEqual(found_product, 'LIFEBOOK E8210', |
| 703 | 2391 | 'Unexpected result of HWDevice.product, ' | 2426 | 'Unexpected result of HWDevice.product, ' |
| 704 | 2392 | 'if info.product does not exist. ' | 2427 | 'if info.product does not exist. ' |
| 705 | @@ -2418,8 +2453,8 @@ | |||
| 706 | 2418 | }, | 2453 | }, |
| 707 | 2419 | } | 2454 | } |
| 708 | 2420 | parser = SubmissionParser(self.log) | 2455 | parser = SubmissionParser(self.log) |
| 711 | 2421 | parser.buildDeviceList(parsed_data) | 2456 | parser.buildHalDeviceList(parsed_data) |
| 712 | 2422 | found_vendor_id = parser.hal_devices[ | 2457 | found_vendor_id = parser.devices[ |
| 713 | 2423 | self.UDI_SATA_CONTROLLER].vendor_id | 2458 | self.UDI_SATA_CONTROLLER].vendor_id |
| 714 | 2424 | self.assertEqual(found_vendor_id, self.PCI_VENDOR_ID_INTEL, | 2459 | self.assertEqual(found_vendor_id, self.PCI_VENDOR_ID_INTEL, |
| 715 | 2425 | 'Unexpected result of HWDevice.vendor_id. ' | 2460 | 'Unexpected result of HWDevice.vendor_id. ' |
| 716 | @@ -2451,8 +2486,8 @@ | |||
| 717 | 2451 | }, | 2486 | }, |
| 718 | 2452 | } | 2487 | } |
| 719 | 2453 | parser = SubmissionParser(self.log) | 2488 | parser = SubmissionParser(self.log) |
| 722 | 2454 | parser.buildDeviceList(parsed_data) | 2489 | parser.buildHalDeviceList(parsed_data) |
| 723 | 2455 | found_vendor_id = parser.hal_devices[self.UDI_SCSI_DISK].vendor_id | 2490 | found_vendor_id = parser.devices[self.UDI_SCSI_DISK].vendor_id |
| 724 | 2456 | self.assertEqual(found_vendor_id, 'SEAGATE', | 2491 | self.assertEqual(found_vendor_id, 'SEAGATE', |
| 725 | 2457 | 'Unexpected result of HWDevice.vendor_id for a. ' | 2492 | 'Unexpected result of HWDevice.vendor_id for a. ' |
| 726 | 2458 | 'SCSI device. Expected SEAGATE, got %r.' | 2493 | 'SCSI device. Expected SEAGATE, got %r.' |
| 727 | @@ -2480,8 +2515,8 @@ | |||
| 728 | 2480 | }, | 2515 | }, |
| 729 | 2481 | } | 2516 | } |
| 730 | 2482 | parser = SubmissionParser(self.log) | 2517 | parser = SubmissionParser(self.log) |
| 733 | 2483 | parser.buildDeviceList(parsed_data) | 2518 | parser.buildHalDeviceList(parsed_data) |
| 734 | 2484 | found_vendor_id = parser.hal_devices[self.UDI_SCSI_DISK].vendor_id | 2519 | found_vendor_id = parser.devices[self.UDI_SCSI_DISK].vendor_id |
| 735 | 2485 | self.assertEqual(found_vendor_id, 'Hitachi', | 2520 | self.assertEqual(found_vendor_id, 'Hitachi', |
| 736 | 2486 | 'Unexpected result of HWDevice.vendor_id for a. ' | 2521 | 'Unexpected result of HWDevice.vendor_id for a. ' |
| 737 | 2487 | 'fake SCSI device. Expected Hitachi, got %r.' | 2522 | 'fake SCSI device. Expected Hitachi, got %r.' |
| 738 | @@ -2510,8 +2545,8 @@ | |||
| 739 | 2510 | }, | 2545 | }, |
| 740 | 2511 | } | 2546 | } |
| 741 | 2512 | parser = SubmissionParser(self.log) | 2547 | parser = SubmissionParser(self.log) |
| 744 | 2513 | parser.buildDeviceList(parsed_data) | 2548 | parser.buildHalDeviceList(parsed_data) |
| 745 | 2514 | found_vendor_id = parser.hal_devices[self.UDI_COMPUTER].vendor_id | 2549 | found_vendor_id = parser.devices[self.UDI_COMPUTER].vendor_id |
| 746 | 2515 | self.assertEqual(found_vendor_id, 'FUJITSU SIEMENS', | 2550 | self.assertEqual(found_vendor_id, 'FUJITSU SIEMENS', |
| 747 | 2516 | 'Unexpected result of HWDevice.vendor_id for a ' | 2551 | 'Unexpected result of HWDevice.vendor_id for a ' |
| 748 | 2517 | 'system. Expected FUJITSU SIEMENS, got %r.' | 2552 | 'system. Expected FUJITSU SIEMENS, got %r.' |
| 749 | @@ -2542,9 +2577,8 @@ | |||
| 750 | 2542 | }, | 2577 | }, |
| 751 | 2543 | } | 2578 | } |
| 752 | 2544 | parser = SubmissionParser(self.log) | 2579 | parser = SubmissionParser(self.log) |
| 756 | 2545 | parser.buildDeviceList(parsed_data) | 2580 | parser.buildHalDeviceList(parsed_data) |
| 757 | 2546 | found_product_id = parser.hal_devices[ | 2581 | found_product_id = parser.devices[self.UDI_SATA_CONTROLLER].product_id |
| 755 | 2547 | self.UDI_SATA_CONTROLLER].product_id | ||
| 758 | 2548 | self.assertEqual(found_product_id, 0x27c5, | 2582 | self.assertEqual(found_product_id, 0x27c5, |
| 759 | 2549 | 'Unexpected result of HWDevice.product_id. ' | 2583 | 'Unexpected result of HWDevice.product_id. ' |
| 760 | 2550 | 'Expected 0x27c5, got 0x%x.' | 2584 | 'Expected 0x27c5, got 0x%x.' |
| 761 | @@ -2576,8 +2610,8 @@ | |||
| 762 | 2576 | }, | 2610 | }, |
| 763 | 2577 | } | 2611 | } |
| 764 | 2578 | parser = SubmissionParser(self.log) | 2612 | parser = SubmissionParser(self.log) |
| 767 | 2579 | parser.buildDeviceList(parsed_data) | 2613 | parser.buildHalDeviceList(parsed_data) |
| 768 | 2580 | found_product_id = parser.hal_devices[self.UDI_SCSI_DISK].product_id | 2614 | found_product_id = parser.devices[self.UDI_SCSI_DISK].product_id |
| 769 | 2581 | self.assertEqual(found_product_id, 'ST36530N', | 2615 | self.assertEqual(found_product_id, 'ST36530N', |
| 770 | 2582 | 'Unexpected result of HWDevice.product_id for a. ' | 2616 | 'Unexpected result of HWDevice.product_id for a. ' |
| 771 | 2583 | 'SCSI device. Expected ST35630N, got %r.' | 2617 | 'SCSI device. Expected ST35630N, got %r.' |
| 772 | @@ -2605,8 +2639,8 @@ | |||
| 773 | 2605 | }, | 2639 | }, |
| 774 | 2606 | } | 2640 | } |
| 775 | 2607 | parser = SubmissionParser(self.log) | 2641 | parser = SubmissionParser(self.log) |
| 778 | 2608 | parser.buildDeviceList(parsed_data) | 2642 | parser.buildHalDeviceList(parsed_data) |
| 779 | 2609 | found_product_id = parser.hal_devices[self.UDI_SCSI_DISK].product_id | 2643 | found_product_id = parser.devices[self.UDI_SCSI_DISK].product_id |
| 780 | 2610 | self.assertEqual(found_product_id, 'HTS54161', | 2644 | self.assertEqual(found_product_id, 'HTS54161', |
| 781 | 2611 | 'Unexpected result of HWDevice.product_id for a. ' | 2645 | 'Unexpected result of HWDevice.product_id for a. ' |
| 782 | 2612 | 'fake SCSI device. Expected HTS54161, got %r.' | 2646 | 'fake SCSI device. Expected HTS54161, got %r.' |
| 783 | @@ -2635,8 +2669,8 @@ | |||
| 784 | 2635 | }, | 2669 | }, |
| 785 | 2636 | } | 2670 | } |
| 786 | 2637 | parser = SubmissionParser(self.log) | 2671 | parser = SubmissionParser(self.log) |
| 789 | 2638 | parser.buildDeviceList(parsed_data) | 2672 | parser.buildHalDeviceList(parsed_data) |
| 790 | 2639 | found_product_id = parser.hal_devices[self.UDI_COMPUTER].product_id | 2673 | found_product_id = parser.devices[self.UDI_COMPUTER].product_id |
| 791 | 2640 | self.assertEqual(found_product_id, 'LIFEBOOK E8210', | 2674 | self.assertEqual(found_product_id, 'LIFEBOOK E8210', |
| 792 | 2641 | 'Unexpected result of HWDevice.product_id for a ' | 2675 | 'Unexpected result of HWDevice.product_id for a ' |
| 793 | 2642 | 'system. Expected LIFEBOOK E8210, got %r.' | 2676 | 'system. Expected LIFEBOOK E8210, got %r.' |
| 794 | @@ -2672,8 +2706,8 @@ | |||
| 795 | 2672 | properties['%s.vendor' % bus] = vendor_id | 2706 | properties['%s.vendor' % bus] = vendor_id |
| 796 | 2673 | else: | 2707 | else: |
| 797 | 2674 | properties['%s.vendor_id' % bus] = vendor_id | 2708 | properties['%s.vendor_id' % bus] = vendor_id |
| 800 | 2675 | parser.buildDeviceList(parsed_data) | 2709 | parser.buildHalDeviceList(parsed_data) |
| 801 | 2676 | found_vendor_id = parser.hal_devices[ | 2710 | found_vendor_id = parser.devices[ |
| 802 | 2677 | self.UDI_SATA_DISK].vendor_id_for_db | 2711 | self.UDI_SATA_DISK].vendor_id_for_db |
| 803 | 2678 | self.assertEqual(found_vendor_id, expected_vendor_id, | 2712 | self.assertEqual(found_vendor_id, expected_vendor_id, |
| 804 | 2679 | 'Unexpected result of HWDevice.vendor_id_for_db for bus ' | 2713 | 'Unexpected result of HWDevice.vendor_id_for_db for bus ' |
| 805 | @@ -2699,9 +2733,8 @@ | |||
| 806 | 2699 | }, | 2733 | }, |
| 807 | 2700 | } | 2734 | } |
| 808 | 2701 | parser = SubmissionParser(self.log) | 2735 | parser = SubmissionParser(self.log) |
| 812 | 2702 | parser.buildDeviceList(parsed_data) | 2736 | parser.buildHalDeviceList(parsed_data) |
| 813 | 2703 | found_vendor_id = parser.hal_devices[ | 2737 | found_vendor_id = parser.devices[self.UDI_COMPUTER].vendor_id_for_db |
| 811 | 2704 | self.UDI_COMPUTER].vendor_id_for_db | ||
| 814 | 2705 | self.assertEqual(found_vendor_id, 'FUJITSU SIEMENS', | 2738 | self.assertEqual(found_vendor_id, 'FUJITSU SIEMENS', |
| 815 | 2706 | 'Unexpected result of HWDevice.vendor_id_for_db for system. ' | 2739 | 'Unexpected result of HWDevice.vendor_id_for_db for system. ' |
| 816 | 2707 | 'Expected FUJITSU SIEMENS, got %r.' % found_vendor_id) | 2740 | 'Expected FUJITSU SIEMENS, got %r.' % found_vendor_id) |
| 817 | @@ -2737,8 +2770,8 @@ | |||
| 818 | 2737 | properties['%s.model' % bus] = product_id | 2770 | properties['%s.model' % bus] = product_id |
| 819 | 2738 | else: | 2771 | else: |
| 820 | 2739 | properties['%s.product_id' % bus] = product_id | 2772 | properties['%s.product_id' % bus] = product_id |
| 823 | 2740 | parser.buildDeviceList(parsed_data) | 2773 | parser.buildHalDeviceList(parsed_data) |
| 824 | 2741 | found_product_id = parser.hal_devices[ | 2774 | found_product_id = parser.devices[ |
| 825 | 2742 | self.UDI_SATA_DISK].product_id_for_db | 2775 | self.UDI_SATA_DISK].product_id_for_db |
| 826 | 2743 | self.assertEqual(found_product_id, expected_product_id, | 2776 | self.assertEqual(found_product_id, expected_product_id, |
| 827 | 2744 | 'Unexpected result of HWDevice.product_id_for_db for bus ' | 2777 | 'Unexpected result of HWDevice.product_id_for_db for bus ' |
| 828 | @@ -2764,9 +2797,8 @@ | |||
| 829 | 2764 | }, | 2797 | }, |
| 830 | 2765 | } | 2798 | } |
| 831 | 2766 | parser = SubmissionParser(self.log) | 2799 | parser = SubmissionParser(self.log) |
| 835 | 2767 | parser.buildDeviceList(parsed_data) | 2800 | parser.buildHalDeviceList(parsed_data) |
| 836 | 2768 | found_product_id = parser.hal_devices[ | 2801 | found_product_id = parser.devices[self.UDI_COMPUTER].product_id_for_db |
| 834 | 2769 | self.UDI_COMPUTER].product_id_for_db | ||
| 837 | 2770 | self.assertEqual(found_product_id, 'E8210', | 2802 | self.assertEqual(found_product_id, 'E8210', |
| 838 | 2771 | 'Unexpected result of HWDevice.product_id_for_db for system. ' | 2803 | 'Unexpected result of HWDevice.product_id_for_db for system. ' |
| 839 | 2772 | 'Expected FUJITSU SIEMENS, got %r.' % found_product_id) | 2804 | 'Expected FUJITSU SIEMENS, got %r.' % found_product_id) |
| 840 | @@ -2829,16 +2861,16 @@ | |||
| 841 | 2829 | def testUSBDeviceRegularCase(self): | 2861 | def testUSBDeviceRegularCase(self): |
| 842 | 2830 | """Test of HALDevice.is_real_device: info.bus == 'usb_device'.""" | 2862 | """Test of HALDevice.is_real_device: info.bus == 'usb_device'.""" |
| 843 | 2831 | parser = SubmissionParser(self.log) | 2863 | parser = SubmissionParser(self.log) |
| 846 | 2832 | parser.buildDeviceList(self.parsed_data) | 2864 | parser.buildHalDeviceList(self.parsed_data) |
| 847 | 2833 | device = parser.hal_devices[self.UDI_USB_STORAGE] | 2865 | device = parser.devices[self.UDI_USB_STORAGE] |
| 848 | 2834 | self.failUnless( | 2866 | self.failUnless( |
| 849 | 2835 | device.is_real_device, | 2867 | device.is_real_device, |
| 850 | 2836 | 'Testing info.bus property: Regular USB Device not treated ' | 2868 | 'Testing info.bus property: Regular USB Device not treated ' |
| 851 | 2837 | 'as a real device.') | 2869 | 'as a real device.') |
| 852 | 2838 | 2870 | ||
| 853 | 2839 | self.renameInfoBusToInfoSubsystem() | 2871 | self.renameInfoBusToInfoSubsystem() |
| 856 | 2840 | parser.buildDeviceList(self.parsed_data) | 2872 | parser.buildHalDeviceList(self.parsed_data) |
| 857 | 2841 | device = parser.hal_devices[self.UDI_USB_STORAGE] | 2873 | device = parser.devices[self.UDI_USB_STORAGE] |
| 858 | 2842 | self.failUnless( | 2874 | self.failUnless( |
| 859 | 2843 | device.is_real_device, | 2875 | device.is_real_device, |
| 860 | 2844 | 'Testing info.subsystem property: Regular USB Device not treated ' | 2876 | 'Testing info.subsystem property: Regular USB Device not treated ' |
| 861 | @@ -2852,17 +2884,16 @@ | |||
| 862 | 2852 | """ | 2884 | """ |
| 863 | 2853 | 2885 | ||
| 864 | 2854 | parser = SubmissionParser(self.log) | 2886 | parser = SubmissionParser(self.log) |
| 867 | 2855 | parser.buildDeviceList(self.parsed_data) | 2887 | parser.buildHalDeviceList(self.parsed_data) |
| 868 | 2856 | device = parser.hal_devices[self.UDI_USB_CONTROLLER_USB_SIDE] | 2888 | device = parser.devices[self.UDI_USB_CONTROLLER_USB_SIDE] |
| 869 | 2857 | self.failIf( | 2889 | self.failIf( |
| 870 | 2858 | device.is_real_device, | 2890 | device.is_real_device, |
| 871 | 2859 | 'Testing info.bus property: USB Device with vendor/product ' | 2891 | 'Testing info.bus property: USB Device with vendor/product ' |
| 872 | 2860 | 'ID 0:0 property treated as a real device.') | 2892 | 'ID 0:0 property treated as a real device.') |
| 873 | 2861 | 2893 | ||
| 874 | 2862 | self.renameInfoBusToInfoSubsystem() | 2894 | self.renameInfoBusToInfoSubsystem() |
| 878 | 2863 | parser.buildDeviceList(self.parsed_data) | 2895 | parser.buildHalDeviceList(self.parsed_data) |
| 879 | 2864 | parser.buildDeviceList(self.parsed_data) | 2896 | device = parser.devices[self.UDI_USB_CONTROLLER_USB_SIDE] |
| 877 | 2865 | device = parser.hal_devices[self.UDI_USB_CONTROLLER_USB_SIDE] | ||
| 880 | 2866 | self.failIf( | 2897 | self.failIf( |
| 881 | 2867 | device.is_real_device, | 2898 | device.is_real_device, |
| 882 | 2868 | 'Testing info.subsystem property: USB Device with vendor/product ' | 2899 | 'Testing info.subsystem property: USB Device with vendor/product ' |
| 883 | @@ -2879,8 +2910,8 @@ | |||
| 884 | 2879 | parent_properties['pci.device_class'] = (PCI_CLASS_STORAGE, 'int') | 2910 | parent_properties['pci.device_class'] = (PCI_CLASS_STORAGE, 'int') |
| 885 | 2880 | parser = SubmissionParser(self.log) | 2911 | parser = SubmissionParser(self.log) |
| 886 | 2881 | parser.submission_key = 'USB device test 1' | 2912 | parser.submission_key = 'USB device test 1' |
| 889 | 2882 | parser.buildDeviceList(self.parsed_data) | 2913 | parser.buildHalDeviceList(self.parsed_data) |
| 890 | 2883 | device = parser.hal_devices[self.UDI_USB_CONTROLLER_USB_SIDE] | 2914 | device = parser.devices[self.UDI_USB_CONTROLLER_USB_SIDE] |
| 891 | 2884 | self.failIf( | 2915 | self.failIf( |
| 892 | 2885 | device.is_real_device, | 2916 | device.is_real_device, |
| 893 | 2886 | 'Testing info.bus property: USB Device with vendor/product ' | 2917 | 'Testing info.bus property: USB Device with vendor/product ' |
| 894 | @@ -2892,8 +2923,8 @@ | |||
| 895 | 2892 | + self.UDI_USB_CONTROLLER_USB_SIDE) | 2923 | + self.UDI_USB_CONTROLLER_USB_SIDE) |
| 896 | 2893 | 2924 | ||
| 897 | 2894 | self.renameInfoBusToInfoSubsystem() | 2925 | self.renameInfoBusToInfoSubsystem() |
| 900 | 2895 | parser.buildDeviceList(self.parsed_data) | 2926 | parser.buildHalDeviceList(self.parsed_data) |
| 901 | 2896 | device = parser.hal_devices[self.UDI_USB_CONTROLLER_USB_SIDE] | 2927 | device = parser.devices[self.UDI_USB_CONTROLLER_USB_SIDE] |
| 902 | 2897 | self.failIf( | 2928 | self.failIf( |
| 903 | 2898 | device.is_real_device, | 2929 | device.is_real_device, |
| 904 | 2899 | 'Testing info.subsystem property: USB Device with vendor/product ' | 2930 | 'Testing info.subsystem property: USB Device with vendor/product ' |
| 905 | @@ -2915,8 +2946,8 @@ | |||
| 906 | 2915 | parent_properties['pci.device_subclass'] = (1, 'int') | 2946 | parent_properties['pci.device_subclass'] = (1, 'int') |
| 907 | 2916 | parser = SubmissionParser(self.log) | 2947 | parser = SubmissionParser(self.log) |
| 908 | 2917 | parser.submission_key = 'USB device test 2' | 2948 | parser.submission_key = 'USB device test 2' |
| 911 | 2918 | parser.buildDeviceList(self.parsed_data) | 2949 | parser.buildHalDeviceList(self.parsed_data) |
| 912 | 2919 | device = parser.hal_devices[self.UDI_USB_CONTROLLER_USB_SIDE] | 2950 | device = parser.devices[self.UDI_USB_CONTROLLER_USB_SIDE] |
| 913 | 2920 | self.failIf( | 2951 | self.failIf( |
| 914 | 2921 | device.is_real_device, | 2952 | device.is_real_device, |
| 915 | 2922 | 'Testing info.bus property: USB Device with vendor/product ' | 2953 | 'Testing info.bus property: USB Device with vendor/product ' |
| 916 | @@ -2928,8 +2959,8 @@ | |||
| 917 | 2928 | + self.UDI_USB_CONTROLLER_USB_SIDE) | 2959 | + self.UDI_USB_CONTROLLER_USB_SIDE) |
| 918 | 2929 | 2960 | ||
| 919 | 2930 | self.renameInfoBusToInfoSubsystem() | 2961 | self.renameInfoBusToInfoSubsystem() |
| 922 | 2931 | parser.buildDeviceList(self.parsed_data) | 2962 | parser.buildHalDeviceList(self.parsed_data) |
| 923 | 2932 | device = parser.hal_devices[self.UDI_USB_CONTROLLER_USB_SIDE] | 2963 | device = parser.devices[self.UDI_USB_CONTROLLER_USB_SIDE] |
| 924 | 2933 | self.failIf( | 2964 | self.failIf( |
| 925 | 2934 | device.is_real_device, | 2965 | device.is_real_device, |
| 926 | 2935 | 'Testing info.subsystem property: USB Device with vendor/product ' | 2966 | 'Testing info.subsystem property: USB Device with vendor/product ' |
| 927 | @@ -2951,8 +2982,8 @@ | |||
| 928 | 2951 | parent_properties['info.bus'] = ('not pci', 'str') | 2982 | parent_properties['info.bus'] = ('not pci', 'str') |
| 929 | 2952 | parser = SubmissionParser(self.log) | 2983 | parser = SubmissionParser(self.log) |
| 930 | 2953 | parser.submission_key = 'USB device test 3' | 2984 | parser.submission_key = 'USB device test 3' |
| 933 | 2954 | parser.buildDeviceList(self.parsed_data) | 2985 | parser.buildHalDeviceList(self.parsed_data) |
| 934 | 2955 | device = parser.hal_devices[self.UDI_USB_CONTROLLER_USB_SIDE] | 2986 | device = parser.devices[self.UDI_USB_CONTROLLER_USB_SIDE] |
| 935 | 2956 | self.failIf( | 2987 | self.failIf( |
| 936 | 2957 | device.is_real_device, | 2988 | device.is_real_device, |
| 937 | 2958 | 'Testing info.bus property: USB Device with vendor/product ' | 2989 | 'Testing info.bus property: USB Device with vendor/product ' |
| 938 | @@ -2966,15 +2997,15 @@ | |||
| 939 | 2966 | # All other devices which have an info.bus property return True | 2997 | # All other devices which have an info.bus property return True |
| 940 | 2967 | # for HALDevice.is_real_device. The USB host controller in the | 2998 | # for HALDevice.is_real_device. The USB host controller in the |
| 941 | 2968 | # test data is an example. | 2999 | # test data is an example. |
| 943 | 2969 | device = parser.hal_devices[self.UDI_USB_CONTROLLER_PCI_SIDE] | 3000 | device = parser.devices[self.UDI_USB_CONTROLLER_PCI_SIDE] |
| 944 | 2970 | self.failUnless( | 3001 | self.failUnless( |
| 945 | 2971 | device.is_real_device, | 3002 | device.is_real_device, |
| 946 | 2972 | 'Testing info.bus property: Device with existing info.bus ' | 3003 | 'Testing info.bus property: Device with existing info.bus ' |
| 947 | 2973 | 'property not treated as a real device.') | 3004 | 'property not treated as a real device.') |
| 948 | 2974 | 3005 | ||
| 949 | 2975 | self.renameInfoBusToInfoSubsystem() | 3006 | self.renameInfoBusToInfoSubsystem() |
| 952 | 2976 | parser.buildDeviceList(self.parsed_data) | 3007 | parser.buildHalDeviceList(self.parsed_data) |
| 953 | 2977 | device = parser.hal_devices[self.UDI_USB_CONTROLLER_USB_SIDE] | 3008 | device = parser.devices[self.UDI_USB_CONTROLLER_USB_SIDE] |
| 954 | 2978 | self.failIf( | 3009 | self.failIf( |
| 955 | 2979 | device.is_real_device, | 3010 | device.is_real_device, |
| 956 | 2980 | 'Testing info.subsystem property: USB Device with vendor/product ' | 3011 | 'Testing info.subsystem property: USB Device with vendor/product ' |
| 957 | @@ -2985,7 +3016,7 @@ | |||
| 958 | 2985 | 'parent device does not look like a USB host controller: ' | 3016 | 'parent device does not look like a USB host controller: ' |
| 959 | 2986 | + self.UDI_USB_CONTROLLER_USB_SIDE) | 3017 | + self.UDI_USB_CONTROLLER_USB_SIDE) |
| 960 | 2987 | 3018 | ||
| 962 | 2988 | device = parser.hal_devices[self.UDI_USB_CONTROLLER_PCI_SIDE] | 3019 | device = parser.devices[self.UDI_USB_CONTROLLER_PCI_SIDE] |
| 963 | 2989 | self.failUnless( | 3020 | self.failUnless( |
| 964 | 2990 | device.is_real_device, | 3021 | device.is_real_device, |
| 965 | 2991 | 'Testing info.subsystem property: Device with existing info.bus ' | 3022 | 'Testing info.subsystem property: Device with existing info.bus ' |
| 966 | @@ -4318,7 +4349,7 @@ | |||
| 967 | 4318 | self.setHALDevices(devices) | 4349 | self.setHALDevices(devices) |
| 968 | 4319 | parser = SubmissionParser(self.log) | 4350 | parser = SubmissionParser(self.log) |
| 969 | 4320 | parser.buildDeviceList(self.parsed_data) | 4351 | parser.buildDeviceList(self.parsed_data) |
| 971 | 4321 | device = parser.hal_devices[self.UDI_COMPUTER] | 4352 | device = parser.devices[self.UDI_COMPUTER] |
| 972 | 4322 | self.assertEqual(device.getDriver(), None, | 4353 | self.assertEqual(device.getDriver(), None, |
| 973 | 4323 | 'HALDevice.getDriver found a driver where none is expected.') | 4354 | 'HALDevice.getDriver found a driver where none is expected.') |
| 974 | 4324 | 4355 | ||
| 975 | @@ -4332,7 +4363,7 @@ | |||
| 976 | 4332 | parser = SubmissionParser(self.log) | 4363 | parser = SubmissionParser(self.log) |
| 977 | 4333 | parser.parsed_data = self.parsed_data | 4364 | parser.parsed_data = self.parsed_data |
| 978 | 4334 | parser.buildDeviceList(self.parsed_data) | 4365 | parser.buildDeviceList(self.parsed_data) |
| 980 | 4335 | device = parser.hal_devices[self.UDI_PCI_PCCARD_BRIDGE] | 4366 | device = parser.devices[self.UDI_PCI_PCCARD_BRIDGE] |
| 981 | 4336 | driver = device.getDriver() | 4367 | driver = device.getDriver() |
| 982 | 4337 | self.assertNotEqual(driver, None, | 4368 | self.assertNotEqual(driver, None, |
| 983 | 4338 | 'HALDevice.getDriver did not find a driver where one ' | 4369 | 'HALDevice.getDriver did not find a driver where one ' |
| 984 | @@ -4372,7 +4403,7 @@ | |||
| 985 | 4372 | 4403 | ||
| 986 | 4373 | # HALDevice.ensureVendorIDVendorNameExists() creates these | 4404 | # HALDevice.ensureVendorIDVendorNameExists() creates these |
| 987 | 4374 | # records. | 4405 | # records. |
| 989 | 4375 | hal_system = parser.hal_devices[self.UDI_COMPUTER] | 4406 | hal_system = parser.devices[self.UDI_COMPUTER] |
| 990 | 4376 | hal_system.ensureVendorIDVendorNameExists() | 4407 | hal_system.ensureVendorIDVendorNameExists() |
| 991 | 4377 | 4408 | ||
| 992 | 4378 | vendor_name = vendor_name_set.getByName('Lenovo') | 4409 | vendor_name = vendor_name_set.getByName('Lenovo') |
| 993 | @@ -4400,7 +4431,7 @@ | |||
| 994 | 4400 | parser.parsed_data = self.parsed_data | 4431 | parser.parsed_data = self.parsed_data |
| 995 | 4401 | parser.buildDeviceList(self.parsed_data) | 4432 | parser.buildDeviceList(self.parsed_data) |
| 996 | 4402 | 4433 | ||
| 998 | 4403 | hal_device = parser.hal_devices[test_udi] | 4434 | hal_device = parser.devices[test_udi] |
| 999 | 4404 | hal_device.ensureVendorIDVendorNameExists() | 4435 | hal_device.ensureVendorIDVendorNameExists() |
| 1000 | 4405 | 4436 | ||
| 1001 | 4406 | vendor_id_set = getUtility(IHWVendorIDSet) | 4437 | vendor_id_set = getUtility(IHWVendorIDSet) |
| 1002 | @@ -4474,7 +4505,7 @@ | |||
| 1003 | 4474 | 4505 | ||
| 1004 | 4475 | # HALDevice.ensureVendorIDVendorNameExists() creates these | 4506 | # HALDevice.ensureVendorIDVendorNameExists() creates these |
| 1005 | 4476 | # records. | 4507 | # records. |
| 1007 | 4477 | scsi_disk = parser.hal_devices[self.UDI_SCSI_DISK] | 4508 | scsi_disk = parser.devices[self.UDI_SCSI_DISK] |
| 1008 | 4478 | scsi_disk.ensureVendorIDVendorNameExists() | 4509 | scsi_disk.ensureVendorIDVendorNameExists() |
| 1009 | 4479 | 4510 | ||
| 1010 | 4480 | vendor_name = vendor_name_set.getByName('WDC') | 4511 | vendor_name = vendor_name_set.getByName('WDC') |
| 1011 | @@ -4506,7 +4537,7 @@ | |||
| 1012 | 4506 | submission_set = getUtility(IHWSubmissionSet) | 4537 | submission_set = getUtility(IHWSubmissionSet) |
| 1013 | 4507 | submission = submission_set.getBySubmissionKey('test_submission_id_1') | 4538 | submission = submission_set.getBySubmissionKey('test_submission_id_1') |
| 1014 | 4508 | 4539 | ||
| 1016 | 4509 | hal_device = parser.hal_devices[self.UDI_COMPUTER] | 4540 | hal_device = parser.devices[self.UDI_COMPUTER] |
| 1017 | 4510 | hal_device.createDBData(submission, None) | 4541 | hal_device.createDBData(submission, None) |
| 1018 | 4511 | 4542 | ||
| 1019 | 4512 | # HALDevice.createDBData created a HWDevice record. | 4543 | # HALDevice.createDBData created a HWDevice record. |
| 1020 | @@ -4573,7 +4604,7 @@ | |||
| 1021 | 4573 | submission_set = getUtility(IHWSubmissionSet) | 4604 | submission_set = getUtility(IHWSubmissionSet) |
| 1022 | 4574 | submission = submission_set.getBySubmissionKey('test_submission_id_1') | 4605 | submission = submission_set.getBySubmissionKey('test_submission_id_1') |
| 1023 | 4575 | 4606 | ||
| 1025 | 4576 | hal_root_device = parser.hal_devices[self.UDI_COMPUTER] | 4607 | hal_root_device = parser.devices[self.UDI_COMPUTER] |
| 1026 | 4577 | hal_root_device.createDBData(submission, None) | 4608 | hal_root_device.createDBData(submission, None) |
| 1027 | 4578 | 4609 | ||
| 1028 | 4579 | # We now have a HWDevice record for the PCCard bridge... | 4610 | # We now have a HWDevice record for the PCCard bridge... |
| 1029 | @@ -4680,7 +4711,7 @@ | |||
| 1030 | 4680 | submission_set = getUtility(IHWSubmissionSet) | 4711 | submission_set = getUtility(IHWSubmissionSet) |
| 1031 | 4681 | submission = submission_set.getBySubmissionKey('test_submission_id_1') | 4712 | submission = submission_set.getBySubmissionKey('test_submission_id_1') |
| 1032 | 4682 | 4713 | ||
| 1034 | 4683 | hal_root_device = parser.hal_devices[self.UDI_COMPUTER] | 4714 | hal_root_device = parser.devices[self.UDI_COMPUTER] |
| 1035 | 4684 | hal_root_device.createDBData(submission, None) | 4715 | hal_root_device.createDBData(submission, None) |
| 1036 | 4685 | 4716 | ||
| 1037 | 4686 | # The USB controller has a HWDevice record. | 4717 | # The USB controller has a HWDevice record. |
| 1038 | @@ -4934,6 +4965,24 @@ | |||
| 1039 | 4934 | self.failIf( | 4965 | self.failIf( |
| 1040 | 4935 | result, 'Submission with inconsistent data treated as valid.') | 4966 | result, 'Submission with inconsistent data treated as valid.') |
| 1041 | 4936 | 4967 | ||
| 1042 | 4968 | def test_processSubmission_buildDeviceList_failing(self): | ||
| 1043 | 4969 | """Test of SubmissionParser.processSubmission(). | ||
| 1044 | 4970 | |||
| 1045 | 4971 | If the method buildDeviceList() fails for a submission, it is | ||
| 1046 | 4972 | rejected. | ||
| 1047 | 4973 | """ | ||
| 1048 | 4974 | def no(*args, **kw): | ||
| 1049 | 4975 | return False | ||
| 1050 | 4976 | |||
| 1051 | 4977 | submission_key = 'builddevicelist-fails' | ||
| 1052 | 4978 | submission_data = self.getSampleData( | ||
| 1053 | 4979 | 'simple_valid_hwdb_submission.xml') | ||
| 1054 | 4980 | submission = self.createSubmissionData( | ||
| 1055 | 4981 | submission_data, False, submission_key) | ||
| 1056 | 4982 | parser = SubmissionParser() | ||
| 1057 | 4983 | parser.buildDeviceList = no | ||
| 1058 | 4984 | self.assertFalse(parser.processSubmission(submission)) | ||
| 1059 | 4985 | |||
| 1060 | 4937 | def testProcessSubmissionRealData(self): | 4986 | def testProcessSubmissionRealData(self): |
| 1061 | 4938 | """Test of SubmissionParser.processSubmission(). | 4987 | """Test of SubmissionParser.processSubmission(). |
| 1062 | 4939 | 4988 | ||
| 1063 | 4940 | 4989 | ||
| 1064 | === modified file 'lib/lp/registry/browser/product.py' | |||
This branch renames the method SubmissionParse
HWDB Submissions coming from the clinet in Karmic do no longer contain data gathered by HAL; instead, the contain udev data.
The udev data looks quite different and is thus processed differently. Single devices found in submissions with HAL data are represented by instances of class HalDevice, while devices from submissions with udev data are represented by instances of class UdevDevice.
One step in the proeccsing of a HWDB submission is the creation of instances of HalDevice/
Depending on the type of the submission, the "right" method from these two should be called, which is done in buildDeviceList().
SuubmissionPars
A second change is mostly mechanical, but causes half of all diff lines: I renames the property SubmissisonPars
The interesting part of the diff are the first 100 line and the last 20 lines; the remaining part of the diff just reflects the name change SubmissisonPars