Clean up style in layout_tests/models/test_expectations.py.

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 85 matching lines @@
         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 = []
         line_number = 0
-        for line in expectations_string.split("\n"):
+        for line in expectations_string.split('\n'):
             line_number += 1
             test_expectation = TestExpectationLine.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
@@ skipping 105 matching lines @@
             expectation_line.matching_tests.append(expectation_line.path)
 
 
 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_extra_skipped_test = False
 
     def __str__(self):
-        return "TestExpectationLine{name=%s, matching_configurations=%s, original_string=%s}" % (
+        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
@@ skipping 11 matching lines @@
 
     def is_flaky(self):
         return len(self.parsed_expectations) > 1
 
     def is_comment(self):
         return bool(re.match(r"^\s*#.*$", self.original_string))
 
     def is_whitespace(self):
         return not self.original_string.strip()
 
-
     # FIXME: Update the original specifiers and remove this once the old syntax is gone.
     _configuration_tokens_list = [
         'Mac', 'Mac10.9', 'Mac10.10', 'Mac10.11', 'Retina',
         'Win', 'Win7', 'Win10',
         'Linux', 'Precise', 'Trusty',
         'Android',
         'Release',
         'Debug',
     ]
 
@@ skipping 28 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 = []
@@ skipping 68 matching lines @@
             elif state not in ('name_found', 'done'):
                 warnings.append('Missing a "]"')
 
         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.')
+            warnings.append('SLOW tests should only 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.')
+                'WONTFIX tests should only 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.')
 
         if 'MISSING' in expectations:
             warnings.append(
                 '"Missing" expectations are not allowed; either download new baselines '
-                '(see https://goo.gl/SHVYrZ) or use "NeedsRebaseline" expecatations.')
+                '(see https://goo.gl/SHVYrZ) or use "NeedsRebaseline" expectations.')
 
         expectation_line.bugs = bugs
         expectation_line.specifiers = specifiers
         expectation_line.expectations = expectations
         expectation_line.name = name
         expectation_line.warnings = warnings
         return expectation_line
 
     @staticmethod
     def create_passing_expectation(test):
@@ skipping 14 matching lines @@
             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_extra_skipped_test = line1.is_extra_skipped_test or line2.is_extra_skipped_test
         return result
 
     def to_string(self, test_configuration_converter=None, 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()])
 
         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)
 
     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 = []
@@ skipping 34 matching lines @@
         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 = {}
@@ skipping 43 matching lines @@
             else:
                 merged_line = other_line
 
             self._test_to_expectation_line[test] = merged_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 = {}
-        for c in strings_to_constants.values():
-            d[c] = set()
-        return d
+        """Takes a dictionary of keys to values and returns a dict mapping each value to an empty set."""
+        result = {}
+        for value in strings_to_constants.values():
+            result[value] = set()
+        return result
 
     def get_test_set(self, expectation, include_skips=True):
         tests = self._expectation_to_tests[expectation]
         if not include_skips:
             tests = tests - self.get_test_set(SKIP)
         return tests
 
     def get_test_set_for_keyword(self, keyword):
         expectation_enum = TestExpectations.EXPECTATIONS.get(keyword.lower(), None)
         if expectation_enum is not None:
@@ skipping 30 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):
@@ skipping 163 matching lines @@
     WontFix: For tests that we never intend to pass on a given platform (treated like Skip).
 
     Notes:
       -A test cannot be both SLOW and TIMEOUT
       -A test can be included twice, but not via the same path.
       -If a test is included twice, then the more precise path wins.
       -CRASH tests cannot be WONTFIX
     """
 
     # FIXME: Update to new syntax once the old format is no longer supported.
-    EXPECTATIONS = {'pass': PASS,
-                    'audio': AUDIO,
-                    'fail': FAIL,
-                    'image': IMAGE,
-                    'image+text': IMAGE_PLUS_TEXT,
-                    'text': TEXT,
-                    '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 = {
+        'pass': PASS,
+        'audio': AUDIO,
+        'fail': FAIL,
+        'image': IMAGE,
+        'image+text': IMAGE_PLUS_TEXT,
+        'text': TEXT,
+        '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',
-                                AUDIO: 'audio failures',
-                                CRASH: 'crashes',
-                                LEAK: 'leaks',
-                                TIMEOUT: 'timeouts',
-                                MISSING: 'missing results'}
+    EXPECTATION_DESCRIPTIONS = {
+        SKIP: 'skipped',
+        PASS: 'passes',
+        FAIL: 'failures',
+        IMAGE: 'image-only failures',
+        TEXT: 'text-only failures',
+        IMAGE_PLUS_TEXT: 'image and text failures',
+        AUDIO: 'audio failures',
+        CRASH: 'crashes',
+        LEAK: 'leaks',
+        TIMEOUT: 'timeouts',
+        MISSING: 'missing results',
+    }
 
     NON_TEST_OUTCOME_EXPECTATIONS = (REBASELINE, SKIP, SLOW, WONTFIX)
 
     BUILD_TYPES = ('debug', 'release')
 
-    TIMELINES = {TestExpectationParser.WONTFIX_MODIFIER: WONTFIX,
-                 'now': NOW}
+    TIMELINES = {
+        TestExpectationParser.WONTFIX_MODIFIER: WONTFIX,
+        'now': NOW,
+    }
 
-    RESULT_TYPES = {'skip': SKIP,
-                    'pass': PASS,
-                    'fail': FAIL,
-                    'flaky': FLAKY}
+    RESULT_TYPES = {
+        'skip': SKIP,
+        'pass': PASS,
+        'fail': FAIL,
+        'flaky': FLAKY,
+    }
 
     @classmethod
     def expectation_from_string(cls, string):
         assert ' ' not in string  # This only handles one expectation at a time.
         return cls.EXPECTATIONS.get(string.lower())
 
     @staticmethod
     def result_was_expected(result, expected_results, test_needs_rebaselining):
         """Returns whether we got a result we were expecting.
         Args:
@@ skipping 277 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)))