Run format-webkit on webkitpy code (without string conversion).

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 56 matching lines @@
         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.
     REBASELINE_MODIFIER = 'rebaseline'
     NEEDS_REBASELINE_MODIFIER = 'needsrebaseline'
     NEEDS_MANUAL_REBASELINE_MODIFIER = 'needsmanualrebaseline'
     PASS_EXPECTATION = 'pass'
     SKIP_MODIFIER = 'skip'
     SLOW_MODIFIER = 'slow'
@@ skipping 81 matching lines @@
         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:
                 if self._port.reference_files(test):
                     text_expected_filename = self._port.expected_filename(test, '.txt')
                     if not self._port.host.filesystem.exists(text_expected_filename):
-                        expectation_line.warnings.append('A reftest without text expectation cannot be marked as NeedsRebaseline/NeedsManualRebaseline')
+                        expectation_line.warnings.append(
+                            'A reftest without text expectation cannot be marked as NeedsRebaseline/NeedsManualRebaseline')
 
         specifiers = [specifier.lower() for specifier in expectation_line.specifiers]
-        if (self.REBASELINE_MODIFIER in expectations or self.NEEDS_REBASELINE_MODIFIER in expectations) and ('debug' in specifiers or 'release' in specifiers):
+        if (self.REBASELINE_MODIFIER in expectations or self.NEEDS_REBASELINE_MODIFIER in expectations) and (
+                'debug' in specifiers or 'release' in specifiers):
             expectation_line.warnings.append('A test cannot be rebaselined for Debug/Release.')
 
     def _parse_expectations(self, expectation_line):
         result = set()
         for part in expectation_line.expectations:
             expectation = TestExpectations.expectation_from_string(part)
             if expectation is None:  # Careful, PASS is currently 0.
                 expectation_line.warnings.append('Unsupported expectation: %s' % part)
                 continue
             result.add(expectation)
@@ skipping 96 matching lines @@
         specifiers = []
         name = None
         expectations = []
         warnings = []
         has_unrecognized_expectation = False
 
         tokens = remaining_string.split()
         state = 'start'
         for token in tokens:
             if (token.startswith(WEBKIT_BUG_PREFIX) or
-                token.startswith(CHROMIUM_BUG_PREFIX) or
-                token.startswith(V8_BUG_PREFIX) or
-                token.startswith(NAMED_BUG_PREFIX)):
+                    token.startswith(CHROMIUM_BUG_PREFIX) or
+                    token.startswith(V8_BUG_PREFIX) or
+                    token.startswith(NAMED_BUG_PREFIX)):
                 if state != 'start':
                     warnings.append('"%s" is not at the start of the line.' % token)
                     break
                 if token.startswith(WEBKIT_BUG_PREFIX):
                     bugs.append(token)
                 elif token.startswith(CHROMIUM_BUG_PREFIX):
                     bugs.append(token)
                 elif token.startswith(V8_BUG_PREFIX):
                     bugs.append(token)
                 else:
@@ skipping 46 matching lines @@
         if 'WONTFIX' in expectations and 'SKIP' not in expectations:
             expectations.append('SKIP')
 
         if ('SKIP' in expectations or 'WONTFIX' in expectations) and len(set(expectations) - set(['SKIP', 'WONTFIX'])):
             warnings.append('A test marked Skip or WontFix must not have other expectations.')
 
         if 'SLOW' in expectations and 'SlowTests' not in filename:
             warnings.append('SLOW tests should ony be added to SlowTests and not to TestExpectations.')
 
         if 'WONTFIX' in expectations and ('NeverFixTests' not in filename and 'StaleTestExpectations' not in filename):
-            warnings.append('WONTFIX tests should ony be added to NeverFixTests or StaleTestExpectations and not to TestExpectations.')
+            warnings.append(
+                'WONTFIX tests should ony be added to NeverFixTests or StaleTestExpectations and not to TestExpectations.')
 
         if 'NeverFixTests' in filename and expectations != ['WONTFIX', 'SKIP']:
             warnings.append('Only WONTFIX expectations are allowed in NeverFixTests')
 
         if 'SlowTests' in filename and expectations != ['SLOW']:
             warnings.append('Only SLOW expectations are allowed in SlowTests')
 
         if not expectations and not has_unrecognized_expectation:
             warnings.append('Missing expectations.')
 
         expectation_line.bugs = bugs
         expectation_line.specifiers = specifiers
         expectation_line.expectations = expectations
         expectation_line.name = name
         expectation_line.warnings = warnings
         return expectation_line
 
     @classmethod
     def _split_space_separated(cls, space_separated_string):
         """Splits a space-separated string into an array."""
         return [part.strip() for part in space_separated_string.strip().split(' ')]
 
 
 class TestExpectationLine(object):
+
     """Represents a line in test expectations file."""
 
     def __init__(self):
         """Initializes a blank-line equivalent of an expectation."""
         self.original_string = None
         self.filename = None  # this is the path to the expectations file for this line
         self.line_numbers = "0"
         self.name = None  # this is the path in the line itself
         self.path = None  # this is the normpath of self.name
         self.bugs = []
         self.specifiers = []
         self.parsed_specifiers = []
         self.matching_configurations = set()
         self.expectations = []
         self.parsed_expectations = set()
         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)
+        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
@@ skipping 96 matching lines @@
 
     @staticmethod
     def _filter_redundant_expectations(expectations):
         if set(expectations) == set(['Pass', 'Skip']):
             return ['Skip']
         if set(expectations) == set(['Pass', 'Slow']):
             return ['Slow']
         return expectations
 
     @staticmethod
-    def _format_line(bugs, specifiers, name, expectations, comment, include_specifiers=True, include_expectations=True, include_comment=True):
+    def _format_line(bugs, specifiers, name, expectations, comment, include_specifiers=True,
+                     include_expectations=True, include_comment=True):
         new_specifiers = []
         new_expectations = []
         for specifier in specifiers:
             # FIXME: Make this all work with the mixed-cased specifiers (e.g. WontFix, Slow, etc).
             specifier = specifier.upper()
             new_specifiers.append(TestExpectationParser._inverted_configuration_tokens.get(specifier, specifier))
 
         for expectation in expectations:
             expectation = expectation.upper()
             new_expectations.append(TestExpectationParser._inverted_expectation_tokens.get(expectation, expectation))
 
         result = ''
         if include_specifiers and (bugs or new_specifiers):
             if bugs:
                 result += ' '.join(bugs) + ' '
             if new_specifiers:
                 result += '[ %s ] ' % ' '.join(new_specifiers)
         result += name
         if include_expectations and new_expectations:
             new_expectations = TestExpectationLine._filter_redundant_expectations(new_expectations)
             result += ' [ %s ]' % ' '.join(sorted(set(new_expectations)))
         if include_comment and comment is not None:
             result += " #%s" % comment
         return result
 
 
 # FIXME: Refactor API to be a proper CRUD.
 class TestExpectationsModel(object):
+
     """Represents relational store of all expectations and provides CRUD semantics to manage it."""
 
     def __init__(self, shorten_filename=None):
         # Maps a test to its list of expectations.
         self._test_to_expectations = {}
 
         # Maps a test to list of its specifiers (string values)
         self._test_to_specifiers = {}
 
         # Maps a test to a TestExpectationLine instance.
@@ skipping 243 matching lines @@
                                                                                                                                     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
     directory and any subdirectory. The format is along the lines of:
 
       LayoutTests/fast/js/fixme.js [ Failure ]
       LayoutTests/fast/js/flaky.js [ Failure Pass ]
       LayoutTests/fast/js/crash.js [ Crash Failure Pass Timeout ]
       ...
 
@@ skipping 71 matching lines @@
         """Returns whether we got a result we were expecting.
         Args:
             result: actual result of a test execution
             expected_results: set of results listed in test_expectations
             test_needs_rebaselining: whether test was marked as REBASELINE"""
         if not (set(expected_results) - (set(TestExpectations.NON_TEST_OUTCOME_EXPECTATIONS))):
             expected_results = set([PASS])
 
         if result in expected_results:
             return True
-        if result in (PASS, TEXT, IMAGE, IMAGE_PLUS_TEXT, AUDIO, MISSING) and (NEEDS_REBASELINE in expected_results or NEEDS_MANUAL_REBASELINE in expected_results):
+        if result in (PASS, TEXT, IMAGE, IMAGE_PLUS_TEXT, AUDIO, MISSING) and (
+                NEEDS_REBASELINE in expected_results or NEEDS_MANUAL_REBASELINE in expected_results):
             return True
         if result in (TEXT, IMAGE, IMAGE_PLUS_TEXT, AUDIO) and (FAIL in expected_results):
             return True
         if result == MISSING and test_needs_rebaselining:
             return True
         if result == SKIP:
             return True
         return False
 
     @staticmethod
@@ skipping 45 matching lines @@
             suffixes.add('wav')
         if 'MISSING' in expectations:
             suffixes.add('txt')
             suffixes.add('png')
             suffixes.add('wav')
         return suffixes
 
     # FIXME: This constructor does too much work. We should move the actual parsing of
     # the expectations into separate routines so that linting and handling overrides
     # can be controlled separately, and the constructor can be more of a no-op.
-    def __init__(self, port, tests=None, include_overrides=True, expectations_dict=None, model_all_expectations=False, is_lint_mode=False):
+    def __init__(self, port, tests=None, include_overrides=True, expectations_dict=None,
+                 model_all_expectations=False, is_lint_mode=False):
         self._full_test_list = tests
         self._test_config = port.test_configuration()
         self._is_lint_mode = is_lint_mode
         self._model_all_expectations = self._is_lint_mode or model_all_expectations
         self._model = TestExpectationsModel(self._shorten_filename)
         self._parser = TestExpectationParser(port, tests, self._is_lint_mode)
         self._port = port
         self._skipped_tests_warnings = []
         self._expectations = []
 
@@ skipping 176 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)))