Reformat webkitpy.layout_tests w/ format-webkitpy.

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 39 matching lines @@
 
 WEBKIT_BUG_PREFIX = 'webkit.org/b/'
 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, full_test_list, 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())
         self._full_test_list = full_test_list
         self._is_lint_mode = is_lint_mode
 
     def parse(self, filename, expectations_string):
         expectation_lines = []
         line_number = 0
-        for line in expectations_string.split("\n"):
+        for line in expectations_string.split('\n'):
             line_number += 1
             test_expectation = self._tokenize_line(filename, line, line_number)
             self._parse_line(test_expectation)
             expectation_lines.append(test_expectation)
         return expectation_lines
 
     def _create_expectation_line(self, test_name, expectations, file_name):
         expectation_line = TestExpectationLine()
         expectation_line.original_string = test_name
         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 12 matching lines @@
         self._collect_matching_tests(expectation_line)
 
         self._parse_specifiers(expectation_line)
         self._parse_expectations(expectation_line)
 
     def _parse_specifiers(self, expectation_line):
         if self._is_lint_mode:
             self._lint_line(expectation_line)
 
         parsed_specifiers = set([specifier.lower() 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 88 matching lines @@
         [[bugs] [ "[" <configuration specifiers> "]" <name> [ "[" <expectations> "]" ["#" <comment>]
 
         Any errant whitespace is not preserved.
 
         """
         expectation_line = TestExpectationLine()
         expectation_line.original_string = expectation_string
         expectation_line.filename = filename
         expectation_line.line_numbers = str(line_number)
 
-        comment_index = expectation_string.find("#")
+        comment_index = expectation_string.find('#')
         if comment_index == -1:
             comment_index = len(expectation_string)
         else:
             expectation_line.comment = expectation_string[comment_index + 1:]
 
-        remaining_string = re.sub(r"\s+", " ", expectation_string[:comment_index].strip())
+        remaining_string = re.sub(r"\s+", ' ', expectation_string[:comment_index].strip())
         if len(remaining_string) == 0:
             return expectation_line
 
         # special-case parsing this so that we fail immediately instead of treating this as a test name
         if remaining_string.startswith('//'):
             expectation_line.warnings = ['use "#" instead of "//" for comments']
             return expectation_line
 
         bugs = []
         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 59 matching lines @@
         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.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 __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]))
+        return bool(re.match('^\s*$', self.original_string.split('#')[0]))
 
     @staticmethod
     def create_passing_expectation(test):
         expectation_line = TestExpectationLine()
         expectation_line.name = test
         expectation_line.path = test
         expectation_line.parsed_expectations = set([PASS])
         expectation_line.expectations = set(['PASS'])
         expectation_line.matching_tests = [test]
         return expectation_line
 
     @staticmethod
     def merge_expectation_lines(line1, line2, model_all_expectations):
         """Merges the expectations of line2 into line1 and returns a fresh object."""
         if line1 is None:
             return line2
         if line2 is None:
             return line1
         if model_all_expectations and line1.filename != line2.filename:
             return line2
 
         # Don't merge original_string or comment.
         result = TestExpectationLine()
         # We only care about filenames when we're linting, in which case the filenames are the same.
         # Not clear that there's anything better to do when not linting and the filenames are different.
         if model_all_expectations:
             result.filename = line2.filename
-        result.line_numbers = line1.line_numbers + "," + line2.line_numbers
+        result.line_numbers = line1.line_numbers + ',' + line2.line_numbers
         result.name = line1.name
         result.path = line1.path
         result.parsed_expectations = set(line1.parsed_expectations) | set(line2.parsed_expectations)
         result.expectations = list(set(line1.expectations) | set(line2.expectations))
         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
+            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 '\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])
         return ' '.join(result)
 
     def _serialize_parsed_specifiers(self, test_configuration_converter, specifiers):
         result = []
         result.extend(sorted(self.parsed_specifiers))
         result.extend(test_configuration_converter.specifier_sorter().sort_specifiers(specifiers))
         return ' '.join(result)
 
     @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
+            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 14 matching lines @@
 
     def _merge_dict_of_sets(self, self_dict, other_dict):
         for key in other_dict:
             self_dict[key] |= other_dict[key]
 
     def merge_model(self, other):
         self._merge_test_map(self._test_to_expectations, other._test_to_expectations)
 
         for test, line in other._test_to_expectation_line.items():
             if test in self._test_to_expectation_line:
-                line = TestExpectationLine.merge_expectation_lines(self._test_to_expectation_line[test], line, model_all_expectations=False)
+                line = TestExpectationLine.merge_expectation_lines(
+                    self._test_to_expectation_line[test],
+                    line,
+                    model_all_expectations=False)
             self._test_to_expectation_line[test] = line
 
         self._merge_dict_of_sets(self._expectation_to_tests, other._expectation_to_tests)
         self._merge_dict_of_sets(self._timeline_to_tests, other._timeline_to_tests)
         self._merge_dict_of_sets(self._result_type_to_tests, other._result_type_to_tests)
 
     def _dict_of_sets(self, strings_to_constants):
         """Takes a dict of strings->constants and returns a dict mapping
         each constant to an empty set."""
         d = {}
@@ skipping 42 matching lines @@
         expectations = self.get_expectations(test)
         retval = []
 
         # FIXME: WontFix should cause the test to get skipped without artificially adding SKIP to the expectations list.
         if WONTFIX in expectations and SKIP in expectations:
             expectations.remove(SKIP)
 
         for expectation in expectations:
             retval.append(self.expectation_to_string(expectation))
 
-        return " ".join(retval)
+        return ' '.join(retval)
 
     def expectation_to_string(self, expectation):
         """Return the uppercased string equivalent of a given expectation."""
         for item in TestExpectations.EXPECTATIONS.items():
             if item[1] == expectation:
                 return item[0].upper()
         raise ValueError(expectation)
 
     def remove_expectation_line(self, test):
         if not self.has_test(test):
             return
         self._clear_expectations_for_test(test)
         del self._test_to_expectation_line[test]
 
     def add_expectation_line(self, expectation_line,
                              model_all_expectations=False):
         """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
     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 25 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 25 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_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 71 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 83 matching lines @@
         def serialize(expectation_line):
             # 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)))
+        return '\n'.join(filter(nones_out, map(serialize, expectation_lines)))