Run auto-formatter on files in webkitpy/layout_tests/.

third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/models/test_expectations.py

 # Copyright (C) 2010 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 43 matching lines @@
 CHROMIUM_BUG_PREFIX = 'crbug.com/'
 V8_BUG_PREFIX = 'code.google.com/p/v8/issues/detail?id='
 NAMED_BUG_PREFIX = 'Bug('
 
 MISSING_KEYWORD = 'Missing'
 NEEDS_REBASELINE_KEYWORD = 'NeedsRebaseline'
 NEEDS_MANUAL_REBASELINE_KEYWORD = 'NeedsManualRebaseline'
 
 
 class ParseError(Exception):
+
     def __init__(self, warnings):
         super(ParseError, self).__init__()
         self.warnings = warnings
 
     def __str__(self):
         return '\n'.join(map(str, self.warnings))
 
     def __repr__(self):
         return 'ParseError(warnings=%s)' % self.warnings
 
 
 class TestExpectationParser(object):
     """Provides parsing facilities for lines in the test_expectation.txt file."""
 
-    # FIXME: Rename these to *_KEYWORD as in MISSING_KEYWORD above, but make the case studdly-caps to match the actual file contents.
+    # FIXME: Rename these to *_KEYWORD as in MISSING_KEYWORD above, but make
+    # the case studdly-caps to match the actual file contents.
     REBASELINE_MODIFIER = 'rebaseline'
     NEEDS_REBASELINE_MODIFIER = 'needsrebaseline'
     NEEDS_MANUAL_REBASELINE_MODIFIER = 'needsmanualrebaseline'
     PASS_EXPECTATION = 'pass'
     SKIP_MODIFIER = 'skip'
     SLOW_MODIFIER = 'slow'
     WONTFIX_MODIFIER = 'wontfix'
 
     TIMEOUT_EXPECTATION = 'timeout'
 
     MISSING_BUG_WARNING = 'Test lacks BUG specifier.'
 
     def __init__(self, port, all_tests, is_lint_mode):
         self._port = port
-        self._test_configuration_converter = TestConfigurationConverter(set(port.all_test_configurations()), port.configuration_specifier_macros())
+        self._test_configuration_converter = TestConfigurationConverter(
+            set(port.all_test_configurations()), port.configuration_specifier_macros())
 
         if all_tests:
             self._all_tests = set(all_tests)
         else:
             self._all_tests = set()
 
         self._is_lint_mode = is_lint_mode
 
     def parse(self, filename, expectations_string):
         expectation_lines = []
@@ skipping 11 matching lines @@
         expectation_line.name = test_name
         expectation_line.filename = file_name
         expectation_line.expectations = expectations
         return expectation_line
 
     def expectation_line_for_test(self, test_name, expectations):
         expectation_line = self._create_expectation_line(test_name, expectations, '<Bot TestExpectations>')
         self._parse_line(expectation_line)
         return expectation_line
 
-
     def expectation_for_skipped_test(self, test_name):
         if not self._port.test_exists(test_name):
             _log.warning('The following test %s from the Skipped list doesn\'t exist' % test_name)
         expectation_line = self._create_expectation_line(test_name, [TestExpectationParser.PASS_EXPECTATION], '<Skipped file>')
         expectation_line.expectations = [TestExpectationParser.SKIP_MODIFIER, TestExpectationParser.WONTFIX_MODIFIER]
         expectation_line.is_skipped_outside_expectations_file = True
         self._parse_line(expectation_line)
         return expectation_line
 
     def _parse_line(self, expectation_line):
@@ skipping 15 matching lines @@
         self._parse_expectations(expectation_line)
 
     def _parse_specifier(self, specifier):
         return specifier.lower()
 
     def _parse_specifiers(self, expectation_line):
         if self._is_lint_mode:
             self._lint_line(expectation_line)
 
         parsed_specifiers = set([self._parse_specifier(specifier) for specifier in expectation_line.specifiers])
-        expectation_line.matching_configurations = self._test_configuration_converter.to_config_set(parsed_specifiers, expectation_line.warnings)
+        expectation_line.matching_configurations = self._test_configuration_converter.to_config_set(
+            parsed_specifiers, expectation_line.warnings)
 
     def _lint_line(self, expectation_line):
         expectations = [expectation.lower() for expectation in expectation_line.expectations]
         if not expectation_line.bugs and self.WONTFIX_MODIFIER not in expectations:
             expectation_line.warnings.append(self.MISSING_BUG_WARNING)
         if self.REBASELINE_MODIFIER in expectations:
             expectation_line.warnings.append('REBASELINE should only be used for running rebaseline.py. Cannot be checked in.')
 
         if self.NEEDS_REBASELINE_MODIFIER in expectations or self.NEEDS_MANUAL_REBASELINE_MODIFIER in expectations:
             for test in expectation_line.matching_tests:
@@ skipping 230 matching lines @@
         self.comment = None
         self.matching_tests = []
         self.warnings = []
         self.is_skipped_outside_expectations_file = False
 
     def __str__(self):
         return "TestExpectationLine{name=%s, matching_configurations=%s, original_string=%s}" % (self.name, self.matching_configurations, self.original_string)
 
     def __eq__(self, other):
         return (self.original_string == other.original_string
-            and self.filename == other.filename
-            and self.line_numbers == other.line_numbers
-            and self.name == other.name
-            and self.path == other.path
-            and self.bugs == other.bugs
-            and self.specifiers == other.specifiers
-            and self.parsed_specifiers == other.parsed_specifiers
-            and self.matching_configurations == other.matching_configurations
-            and self.expectations == other.expectations
-            and self.parsed_expectations == other.parsed_expectations
-            and self.comment == other.comment
-            and self.matching_tests == other.matching_tests
-            and self.warnings == other.warnings
-            and self.is_skipped_outside_expectations_file == other.is_skipped_outside_expectations_file)
+                and self.filename == other.filename
+                and self.line_numbers == other.line_numbers
+                and self.name == other.name
+                and self.path == other.path
+                and self.bugs == other.bugs
+                and self.specifiers == other.specifiers
+                and self.parsed_specifiers == other.parsed_specifiers
+                and self.matching_configurations == other.matching_configurations
+                and self.expectations == other.expectations
+                and self.parsed_expectations == other.parsed_expectations
+                and self.comment == other.comment
+                and self.matching_tests == other.matching_tests
+                and self.warnings == other.warnings
+                and self.is_skipped_outside_expectations_file == other.is_skipped_outside_expectations_file)
 
     def is_invalid(self):
         return bool(self.warnings and self.warnings != [TestExpectationParser.MISSING_BUG_WARNING])
 
     def is_flaky(self):
         return len(self.parsed_expectations) > 1
 
     def is_whitespace_or_comment(self):
         return bool(re.match("^\s*$", self.original_string.split('#')[0]))
 
@@ skipping 31 matching lines @@
         result.bugs = list(set(line1.bugs) | set(line2.bugs))
         result.specifiers = list(set(line1.specifiers) | set(line2.specifiers))
         result.parsed_specifiers = list(set(line1.parsed_specifiers) | set(line2.parsed_specifiers))
         result.matching_configurations = set(line1.matching_configurations) | set(line2.matching_configurations)
         result.matching_tests = list(list(set(line1.matching_tests) | set(line2.matching_tests)))
         result.warnings = list(set(line1.warnings) | set(line2.warnings))
         result.is_skipped_outside_expectations_file = line1.is_skipped_outside_expectations_file or line2.is_skipped_outside_expectations_file
         return result
 
     def to_string(self, test_configuration_converter, include_specifiers=True, include_expectations=True, include_comment=True):
-        parsed_expectation_to_string = dict([[parsed_expectation, expectation_string] for expectation_string, parsed_expectation in TestExpectations.EXPECTATIONS.items()])
+        parsed_expectation_to_string = dict([[parsed_expectation, expectation_string]
+                                             for expectation_string, parsed_expectation in TestExpectations.EXPECTATIONS.items()])
 
         if self.is_invalid():
             return self.original_string or ''
 
         if self.name is None:
             return '' if self.comment is None else "#%s" % self.comment
 
         if test_configuration_converter and self.bugs:
             specifiers_list = test_configuration_converter.to_specifiers_list(self.matching_configurations)
             result = []
             for specifiers in specifiers_list:
                 # FIXME: this is silly that we join the specifiers and then immediately split them.
                 specifiers = self._serialize_parsed_specifiers(test_configuration_converter, specifiers).split()
                 expectations = self._serialize_parsed_expectations(parsed_expectation_to_string).split()
                 result.append(self._format_line(self.bugs, specifiers, self.name, expectations, self.comment))
             return "\n".join(result) if result else None
 
         return self._format_line(self.bugs, self.specifiers, self.name, self.expectations, self.comment,
-            include_specifiers, include_expectations, include_comment)
+                                 include_specifiers, include_expectations, include_comment)
 
     def to_csv(self):
         # Note that this doesn't include the comments.
         return '%s,%s,%s,%s' % (self.name, ' '.join(self.bugs), ' '.join(self.specifiers), ' '.join(self.expectations))
 
     def _serialize_parsed_expectations(self, parsed_expectation_to_string):
         result = []
         for index in TestExpectations.EXPECTATIONS.values():
             if index in self.parsed_expectations:
                 result.append(parsed_expectation_to_string[index])
@@ skipping 176 matching lines @@
         """Returns a list of warnings encountered while matching specifiers."""
 
         if expectation_line.is_invalid():
             return
 
         for test in expectation_line.matching_tests:
             if self._already_seen_better_match(test, expectation_line):
                 continue
 
             if model_all_expectations:
-                expectation_line = TestExpectationLine.merge_expectation_lines(self.get_expectation_line(test), expectation_line, model_all_expectations)
+                expectation_line = TestExpectationLine.merge_expectation_lines(
+                    self.get_expectation_line(test), expectation_line, model_all_expectations)
 
             self._clear_expectations_for_test(test)
             self._test_to_expectation_line[test] = expectation_line
             self._add_test(test, expectation_line)
 
     def _add_test(self, test, expectation_line):
         """Sets the expected state for a given test.
 
         This routine assumes the test has not been added before. If it has,
         use _clear_expectations_for_test() to reset the state prior to
@@ skipping 76 matching lines @@
         # to be warnings and return False".
 
         if prev_expectation_line.matching_configurations == expectation_line.matching_configurations:
             expectation_line.warnings.append('Duplicate or ambiguous entry lines %s:%s and %s:%s.' % (
                 self._shorten_filename(prev_expectation_line.filename), prev_expectation_line.line_numbers,
                 self._shorten_filename(expectation_line.filename), expectation_line.line_numbers))
             return True
 
         if prev_expectation_line.matching_configurations >= expectation_line.matching_configurations:
             expectation_line.warnings.append('More specific entry for %s on line %s:%s overrides line %s:%s.' % (expectation_line.name,
-                self._shorten_filename(prev_expectation_line.filename), prev_expectation_line.line_numbers,
-                self._shorten_filename(expectation_line.filename), expectation_line.line_numbers))
+                                                                                                                 self._shorten_filename(
+                                                                                                                     prev_expectation_line.filename), prev_expectation_line.line_numbers,
+                                                                                                                 self._shorten_filename(expectation_line.filename), expectation_line.line_numbers))
             # FIXME: return False if we want more specific to win.
             return True
 
         if prev_expectation_line.matching_configurations <= expectation_line.matching_configurations:
             expectation_line.warnings.append('More specific entry for %s on line %s:%s overrides line %s:%s.' % (expectation_line.name,
-                self._shorten_filename(expectation_line.filename), expectation_line.line_numbers,
-                self._shorten_filename(prev_expectation_line.filename), prev_expectation_line.line_numbers))
+                                                                                                                 self._shorten_filename(
+                                                                                                                     expectation_line.filename), expectation_line.line_numbers,
+                                                                                                                 self._shorten_filename(prev_expectation_line.filename), prev_expectation_line.line_numbers))
             return True
 
         if prev_expectation_line.matching_configurations & expectation_line.matching_configurations:
             expectation_line.warnings.append('Entries for %s on lines %s:%s and %s:%s match overlapping sets of configurations.' % (expectation_line.name,
-                self._shorten_filename(prev_expectation_line.filename), prev_expectation_line.line_numbers,
-                self._shorten_filename(expectation_line.filename), expectation_line.line_numbers))
+                                                                                                                                    self._shorten_filename(
+                                                                                                                                        prev_expectation_line.filename), prev_expectation_line.line_numbers,
+                                                                                                                                    self._shorten_filename(expectation_line.filename), expectation_line.line_numbers))
             return True
 
         # Configuration sets are disjoint, then.
         return False
 
 
 class TestExpectations(object):
     """Test expectations consist of lines with specifications of what
     to expect from layout test cases. The test cases can be directories
     in which case the expectations apply to all test cases in that
@@ skipping 32 matching lines @@
                     'timeout': TIMEOUT,
                     'crash': CRASH,
                     'leak': LEAK,
                     'missing': MISSING,
                     TestExpectationParser.SKIP_MODIFIER: SKIP,
                     TestExpectationParser.NEEDS_REBASELINE_MODIFIER: NEEDS_REBASELINE,
                     TestExpectationParser.NEEDS_MANUAL_REBASELINE_MODIFIER: NEEDS_MANUAL_REBASELINE,
                     TestExpectationParser.WONTFIX_MODIFIER: WONTFIX,
                     TestExpectationParser.SLOW_MODIFIER: SLOW,
                     TestExpectationParser.REBASELINE_MODIFIER: REBASELINE,
-    }
+                    }
 
     EXPECTATIONS_TO_STRING = dict((k, v) for (v, k) in EXPECTATIONS.iteritems())
 
     # (aggregated by category, pass/fail/skip, type)
     EXPECTATION_DESCRIPTIONS = {SKIP: 'skipped',
                                 PASS: 'passes',
                                 FAIL: 'failures',
                                 IMAGE: 'image-only failures',
                                 TEXT: 'text-only failures',
                                 IMAGE_PLUS_TEXT: 'image and text failures',
@@ skipping 183 matching lines @@
     def _shorten_filename(self, filename):
         if filename.startswith(self._port.path_from_webkit_base()):
             return self._port.host.filesystem.relpath(filename, self._port.path_from_webkit_base())
         return filename
 
     def _report_warnings(self):
         warnings = []
         for expectation in self._expectations:
             for warning in expectation.warnings:
                 warnings.append('%s:%s %s %s' % (self._shorten_filename(expectation.filename), expectation.line_numbers,
-                                warning, expectation.name if expectation.expectations else expectation.original_string))
+                                                 warning, expectation.name if expectation.expectations else expectation.original_string))
 
         if warnings:
             self._has_warnings = True
             if self._is_lint_mode:
                 raise ParseError(warnings)
             _log.warning('--lint-test-files warnings:')
             for warning in warnings:
                 _log.warning(warning)
             _log.warning('')
 
@@ skipping 84 matching lines @@
             # If reconstitute_only_these is an empty list, we want to return original_string.
             # So we need to compare reconstitute_only_these to None, not just check if it's falsey.
             if reconstitute_only_these is None or expectation_line in reconstitute_only_these:
                 return expectation_line.to_string(test_configuration_converter)
             return expectation_line.original_string
 
         def nones_out(expectation_line):
             return expectation_line is not None
 
         return "\n".join(filter(nones_out, map(serialize, expectation_lines)))