Reformat webkitpy.layout_tests w/ format-webkitpy.

Tools/Scripts/webkitpy/layout_tests/models/test_configuration_unittest.py

 # Copyright (C) 2011 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 28 matching lines @@
     return all_test_configurations
 
 MOCK_MACROS = {
     'mac': ['snowleopard'],
     'win': ['xp', 'vista', 'win7'],
     'linux': ['lucid'],
 }
 
 
 class TestConfigurationTest(unittest.TestCase):
+
     def test_items(self):
         config = TestConfiguration('xp', 'x86', 'release')
         result_config_dict = {}
         for category, specifier in config.items():
             result_config_dict[category] = specifier
         self.assertEqual({'version': 'xp', 'architecture': 'x86', 'build_type': 'release'}, result_config_dict)
 
     def test_keys(self):
         config = TestConfiguration('xp', 'x86', 'release')
         result_config_keys = []
@@ skipping 14 matching lines @@
         config_dict[TestConfiguration('xp', 'x86', 'release')] = True
         self.assertIn(TestConfiguration('xp', 'x86', 'release'), config_dict)
         self.assertTrue(config_dict[TestConfiguration('xp', 'x86', 'release')])
 
         def query_unknown_key():
             return config_dict[TestConfiguration('xp', 'x86', 'debug')]
 
         self.assertRaises(KeyError, query_unknown_key)
         self.assertIn(TestConfiguration('xp', 'x86', 'release'), config_dict)
         self.assertNotIn(TestConfiguration('xp', 'x86', 'debug'), config_dict)
-        configs_list = [TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'debug'), TestConfiguration('xp', 'x86', 'debug')]
+        configs_list = [
+            TestConfiguration(
+                'xp', 'x86', 'release'), TestConfiguration(
+                'xp', 'x86', 'debug'), TestConfiguration(
+                'xp', 'x86', 'debug')]
         self.assertEqual(len(configs_list), 3)
         self.assertEqual(len(set(configs_list)), 2)
 
     def test_eq(self):
         self.assertEqual(TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'release'))
         self.assertNotEquals(TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'debug'))
 
     def test_values(self):
         config = TestConfiguration('xp', 'x86', 'release')
         result_config_values = []
         for value in config.values():
             result_config_values.append(value)
         self.assertEqual(set(['xp', 'x86', 'release']), set(result_config_values))
 
 
 class SpecifierSorterTest(unittest.TestCase):
+
     def __init__(self, testFunc):
         self._all_test_configurations = make_mock_all_test_configurations_set()
         unittest.TestCase.__init__(self, testFunc)
 
     def test_init(self):
         sorter = SpecifierSorter()
         self.assertIsNone(sorter.category_for_specifier('control'))
         sorter = SpecifierSorter(self._all_test_configurations)
         self.assertEqual(sorter.category_for_specifier('xp'), 'version')
         sorter = SpecifierSorter(self._all_test_configurations, MOCK_MACROS)
@@ skipping 26 matching lines @@
         sorter = SpecifierSorter(self._all_test_configurations)
         self.assertEqual(sorter.specifier_priority('x86'), 1)
         self.assertEqual(sorter.specifier_priority('snowleopard'), 0)
 
     def test_sort_specifiers(self):
         sorter = SpecifierSorter(self._all_test_configurations, MOCK_MACROS)
         self.assertEqual(sorter.sort_specifiers(set()), [])
         self.assertEqual(sorter.sort_specifiers(set(['x86'])), ['x86'])
         self.assertEqual(sorter.sort_specifiers(set(['x86', 'win7'])), ['win7', 'x86'])
         self.assertEqual(sorter.sort_specifiers(set(['x86', 'debug', 'win7'])), ['win7', 'x86', 'debug'])
-        self.assertEqual(sorter.sort_specifiers(set(['snowleopard', 'x86', 'debug', 'win7'])), ['snowleopard', 'win7', 'x86', 'debug'])
+        self.assertEqual(sorter.sort_specifiers(set(['snowleopard', 'x86', 'debug', 'win7'])), [
+                         'snowleopard', 'win7', 'x86', 'debug'])
         self.assertEqual(sorter.sort_specifiers(set(['x86', 'mac', 'debug', 'win7'])), ['mac', 'win7', 'x86', 'debug'])
 
 
 class TestConfigurationConverterTest(unittest.TestCase):
+
     def __init__(self, testFunc):
         self._all_test_configurations = make_mock_all_test_configurations_set()
         unittest.TestCase.__init__(self, testFunc)
 
     def test_symmetric_difference(self):
         self.assertEqual(TestConfigurationConverter.symmetric_difference([set(['a', 'b']), set(['b', 'c'])]), set(['a', 'c']))
-        self.assertEqual(TestConfigurationConverter.symmetric_difference([set(['a', 'b']), set(['b', 'c']), set(['b', 'd'])]), set(['a', 'c', 'd']))
+        self.assertEqual(TestConfigurationConverter.symmetric_difference(
+            [set(['a', 'b']), set(['b', 'c']), set(['b', 'd'])]), set(['a', 'c', 'd']))
 
     def test_to_config_set(self):
         converter = TestConfigurationConverter(self._all_test_configurations)
 
         self.assertEqual(converter.to_config_set(set()), self._all_test_configurations)
 
         self.assertEqual(converter.to_config_set(set(['foo'])), set())
 
         self.assertEqual(converter.to_config_set(set(['xp', 'foo'])), set())
 
         errors = []
         self.assertEqual(converter.to_config_set(set(['xp', 'foo']), errors), set())
         self.assertEqual(errors, ["Unrecognized specifier 'foo'"])
 
         self.assertEqual(converter.to_config_set(set(['xp', 'x86_64'])), set())
 
         configs_to_match = set([
             TestConfiguration('xp', 'x86', 'release'),
         ])
         self.assertEqual(converter.to_config_set(set(['xp', 'release'])), configs_to_match)
 
         configs_to_match = set([
             TestConfiguration('snowleopard', 'x86', 'release'),
             TestConfiguration('vista', 'x86', 'release'),
             TestConfiguration('win7', 'x86', 'release'),
             TestConfiguration('xp', 'x86', 'release'),
             TestConfiguration('lucid', 'x86', 'release'),
             TestConfiguration('lucid', 'x86_64', 'release'),
-       ])
+        ])
         self.assertEqual(converter.to_config_set(set(['release'])), configs_to_match)
 
         configs_to_match = set([
-             TestConfiguration('lucid', 'x86_64', 'release'),
-             TestConfiguration('lucid', 'x86_64', 'debug'),
+            TestConfiguration('lucid', 'x86_64', 'release'),
+            TestConfiguration('lucid', 'x86_64', 'debug'),
         ])
         self.assertEqual(converter.to_config_set(set(['x86_64'])), configs_to_match)
 
         configs_to_match = set([
             TestConfiguration('lucid', 'x86_64', 'release'),
             TestConfiguration('lucid', 'x86_64', 'debug'),
             TestConfiguration('lucid', 'x86', 'release'),
             TestConfiguration('lucid', 'x86', 'debug'),
             TestConfiguration('snowleopard', 'x86', 'release'),
             TestConfiguration('snowleopard', 'x86', 'debug'),
@@ skipping 56 matching lines @@
         configs_to_match = set([
             TestConfiguration('xp', 'x86', 'release'),
             TestConfiguration('xp', 'x86', 'debug'),
         ])
         self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['xp'])])
 
         configs_to_match = set([
             TestConfiguration('lucid', 'x86_64', 'debug'),
             TestConfiguration('xp', 'x86', 'release'),
         ])
-        self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['release', 'xp']), set(['debug', 'x86_64', 'linux'])])
+        self.assertEqual(converter.to_specifiers_list(
+            configs_to_match), [set(['release', 'xp']), set(['debug', 'x86_64', 'linux'])])
 
         configs_to_match = set([
             TestConfiguration('xp', 'x86', 'release'),
             TestConfiguration('xp', 'x86', 'release'),
             TestConfiguration('lucid', 'x86_64', 'debug'),
             TestConfiguration('lucid', 'x86', 'debug'),
             TestConfiguration('lucid', 'x86_64', 'debug'),
             TestConfiguration('lucid', 'x86', 'debug'),
         ])
         self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['release', 'xp']), set(['debug', 'linux'])])
@@ skipping 14 matching lines @@
         ])
         self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['xp', 'mac', 'release'])])
 
         configs_to_match = set([
             TestConfiguration('xp', 'x86', 'release'),
             TestConfiguration('snowleopard', 'x86', 'release'),
             TestConfiguration('win7', 'x86', 'release'),
             TestConfiguration('win7', 'x86', 'debug'),
             TestConfiguration('lucid', 'x86', 'release'),
         ])
-        self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['win7']), set(['release', 'linux', 'x86']), set(['release', 'xp', 'mac'])])
+        self.assertEqual(converter.to_specifiers_list(configs_to_match), [
+                         set(['win7']), set(['release', 'linux', 'x86']), set(['release', 'xp', 'mac'])])
 
     def test_macro_collapsing(self):
         macros = {'foo': ['bar', 'baz'], 'people': ['bob', 'alice', 'john']}
 
         specifiers_list = [set(['john', 'godzilla', 'bob', 'alice'])]
         TestConfigurationConverter.collapse_macros(macros, specifiers_list)
         self.assertEqual(specifiers_list, [set(['people', 'godzilla'])])
 
         specifiers_list = [set(['john', 'godzilla', 'alice'])]
         TestConfigurationConverter.collapse_macros(macros, specifiers_list)
@@ skipping 46 matching lines @@
             TestConfiguration('xp', 'x86', 'release'),
             TestConfiguration('vista', 'x86', 'release'),
             TestConfiguration('win7', 'x86', 'release'),
         ])
         self.assertEqual(converter.to_specifiers_list(configs_to_match), [set(['win', 'release'])])
 
     def test_specifier_converter_access(self):
         specifier_sorter = TestConfigurationConverter(self._all_test_configurations, MOCK_MACROS).specifier_sorter()
         self.assertEqual(specifier_sorter.category_for_specifier('snowleopard'), 'version')
         self.assertEqual(specifier_sorter.category_for_specifier('mac'), 'version')