Move tokenize_line method from TestExpectationParser to TestExpectationLine.

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 87 matching lines @@
         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"):
             line_number += 1
-            test_expectation = self._tokenize_line(filename, line, line_number)
+            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
         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
+        expectation_line.is_extra_skipped_test = True
         self._parse_line(expectation_line)
         return expectation_line
 
     def _parse_line(self, expectation_line):
         if not expectation_line.name:
             return
 
         if not self._check_test_exists(expectation_line):
             return
 
@@ skipping 72 matching lines @@
         if not expectation_line.is_file:
             # this is a test category, return all the tests of the category.
             expectation_line.matching_tests = [test for test in self._all_tests if test.startswith(expectation_line.path)]
             return
 
         # this is a test file, do a quick check if it's in the
         # full test suite.
         if expectation_line.path in self._all_tests:
             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.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}" % (
+            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_extra_skipped_test == other.is_extra_skipped_test)
+
+    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_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',
     ]
 
     _configuration_tokens = dict((token, token.upper()) for token in _configuration_tokens_list)
     _inverted_configuration_tokens = dict((value, name) for name, value in _configuration_tokens.iteritems())
 
     # FIXME: Update the original specifiers list and remove this once the old syntax is gone.
     _expectation_tokens = {
         'Crash': 'CRASH',
         'Leak': 'LEAK',
         'Failure': 'FAIL',
         MISSING_KEYWORD: 'MISSING',
         'Pass': 'PASS',
         'Rebaseline': 'REBASELINE',
         NEEDS_REBASELINE_KEYWORD: 'NEEDSREBASELINE',
         NEEDS_MANUAL_REBASELINE_KEYWORD: 'NEEDSMANUALREBASELINE',
         'Skip': 'SKIP',
         'Slow': 'SLOW',
         'Timeout': 'TIMEOUT',
         'WontFix': 'WONTFIX',
     }
 
-    _inverted_expectation_tokens = dict(
+    inverted_expectation_tokens = dict(
         [(value, name) for name, value in _expectation_tokens.iteritems()] +
         [('TEXT', 'Failure'), ('IMAGE', 'Failure'), ('IMAGE+TEXT', 'Failure'), ('AUDIO', 'Failure')])
 
-    # FIXME: Seems like these should be classmethods on TestExpectationLine instead of TestExpectationParser.
     @classmethod
-    def _tokenize_line(cls, filename, expectation_string, line_number):
+    def tokenize_line(cls, filename, expectation_string, line_number):
         """Tokenizes a line from TestExpectations and returns an unparsed TestExpectationLine instance using the old format.
 
         The new format for a test expectation line is:
 
         [[bugs] [ "[" <configuration specifiers> "]" <name> [ "[" <expectations> "]" ["#" <comment>]
 
         Any errant whitespace is not preserved.
         """
         expectation_line = TestExpectationLine()
         expectation_line.original_string = expectation_string
@@ skipping 110 matching lines @@
         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(' ')]

[qyearsley, 2016/09/15 21:02:31]

Note: This CL removes this method which appears unused.

-
-
-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

[qyearsley, 2016/09/15 21:02:31]

Note: This CL renames this variable to is_extra_skipped_test to make it shorter.
That's not really a super clear name, but the original name isn't super clear
either.

-
-    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)
-
-    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_comment(self):
-        return bool(re.match(r"^\s*#.*$", self.original_string))
-
-    def is_whitespace(self):
-        return not self.original_string.strip()
-
     @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
 
@@ skipping 17 matching lines @@
         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)
+        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 ''
@@ skipping 32 matching lines @@
         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,
+    @classmethod
+    def _format_line(cls, 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))
+            new_specifiers.append(cls._inverted_configuration_tokens.get(specifier, specifier))

[qyearsley, 2016/09/15 21:02:31]

Note: This CL changes this to a classmethod to indicate that it accesses the
protected class attribute _inverted_configuration_tokens.

 
         for expectation in expectations:
             expectation = expectation.upper()
-            new_expectations.append(TestExpectationParser._inverted_expectation_tokens.get(expectation, expectation))
+            new_expectations.append(cls.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)
@@ skipping 100 matching lines @@
     def get_expectation_line(self, test):
         return self._test_to_expectation_line.get(test)
 
     def get_expectations(self, test):
         return self._test_to_expectations[test]
 
     def get_expectations_string(self, test):
         """Returns the expectations for the given test as an uppercase string.
         If there are no expectations for the test, then "PASS" is returned.
         """
-        if self.get_expectation_line(test).is_skipped_outside_expectations_file:
+        if self.get_expectation_line(test).is_extra_skipped_test:
             return 'NOTRUN'
 
         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:
@@ skipping 518 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)))