Get rid of the distinction between modifiers and expectations.

Tools/Scripts/webkitpy/layout_tests/models/test_expectations_unittest.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 67 matching lines @@
 
     def parse_exp(self, expectations, overrides=None, is_lint_mode=False):
         expectations_dict = OrderedDict()
         expectations_dict['expectations'] = expectations
         if overrides:
             expectations_dict['overrides'] = overrides
         self._port.expectations_dict = lambda: expectations_dict
         expectations_to_lint = expectations_dict if is_lint_mode else None
         self._exp = TestExpectations(self._port, self.get_basic_tests(), expectations_dict=expectations_to_lint, is_lint_mode=is_lint_mode)
 
+    def assert_exp_list(self, test, results):
+        self.assertEqual(self._exp.get_expectations(self.get_test(test)), set(results))
+
     def assert_exp(self, test, result):
-        self.assertEqual(self._exp.get_expectations(self.get_test(test)),
-                          set([result]))
+        self.assert_exp_list(test, [result])
 
     def assert_bad_expectations(self, expectations, overrides=None):
         self.assertRaises(ParseError, self.parse_exp, expectations, is_lint_mode=True, overrides=overrides)
 
 
 class BasicTests(Base):
     def test_basic(self):
         self.parse_exp(self.get_basic_expectations())
         self.assert_exp('failures/expected/text.html', FAIL)
-        self.assert_exp('failures/expected/image_checksum.html', PASS)
+        self.assert_exp_list('failures/expected/image_checksum.html', [WONTFIX, SKIP])
         self.assert_exp('passes/text.html', PASS)
         self.assert_exp('failures/expected/image.html', PASS)
 
 
 class MiscTests(Base):
     def test_multiple_results(self):
         self.parse_exp('Bug(x) failures/expected/text.html [ Crash Failure ]')
         self.assertEqual(self._exp.get_expectations(
             self.get_test('failures/expected/text.html')),
             set([FAIL, CRASH]))
 
     def test_result_was_expected(self):
         # test basics
         self.assertEqual(TestExpectations.result_was_expected(PASS, set([PASS]), test_needs_rebaselining=False), True)
         self.assertEqual(TestExpectations.result_was_expected(FAIL, set([PASS]), test_needs_rebaselining=False), False)
 
         # test handling of SKIPped tests and results
         self.assertEqual(TestExpectations.result_was_expected(SKIP, set([CRASH]), test_needs_rebaselining=False), True)
 
-        # test handling of MISSING results and the REBASELINE modifier
+        # test handling of MISSING results and the REBASELINE specifier
         self.assertEqual(TestExpectations.result_was_expected(MISSING, set([PASS]), test_needs_rebaselining=True), True)
         self.assertEqual(TestExpectations.result_was_expected(MISSING, set([PASS]), test_needs_rebaselining=False), False)
 
         self.assertTrue(TestExpectations.result_was_expected(PASS, set([NEEDS_REBASELINE]), test_needs_rebaselining=False))
         self.assertTrue(TestExpectations.result_was_expected(MISSING, set([NEEDS_REBASELINE]), test_needs_rebaselining=False))
         self.assertTrue(TestExpectations.result_was_expected(TEXT, set([NEEDS_REBASELINE]), test_needs_rebaselining=False))
         self.assertTrue(TestExpectations.result_was_expected(IMAGE, set([NEEDS_REBASELINE]), test_needs_rebaselining=False))
         self.assertTrue(TestExpectations.result_was_expected(IMAGE_PLUS_TEXT, set([NEEDS_REBASELINE]), test_needs_rebaselining=False))
         self.assertTrue(TestExpectations.result_was_expected(AUDIO, set([NEEDS_REBASELINE]), test_needs_rebaselining=False))
         self.assertFalse(TestExpectations.result_was_expected(TIMEOUT, set([NEEDS_REBASELINE]), test_needs_rebaselining=False))
@@ skipping 15 matching lines @@
     def test_category_expectations(self):
         # This test checks unknown tests are not present in the
         # expectations and that known test part of a test category is
         # present in the expectations.
         exp_str = 'Bug(x) failures/expected [ WontFix ]'
         self.parse_exp(exp_str)
         test_name = 'failures/expected/unknown-test.html'
         unknown_test = self.get_test(test_name)
         self.assertRaises(KeyError, self._exp.get_expectations,
                           unknown_test)
-        self.assert_exp('failures/expected/crash.html', PASS)
-
-    def test_get_modifiers(self):
-        self.parse_exp(self.get_basic_expectations())
-        self.assertEqual(self._exp.get_modifiers(
-                         self.get_test('passes/text.html')), [])
+        self.assert_exp_list('failures/expected/crash.html', [WONTFIX, SKIP])
 
     def test_get_expectations_string(self):
         self.parse_exp(self.get_basic_expectations())
         self.assertEqual(self._exp.get_expectations_string(
                           self.get_test('failures/expected/text.html')),
                           'FAIL')
 
     def test_expectation_to_string(self):
         # Normal cases are handled by other tests.
         self.parse_exp(self.get_basic_expectations())
@@ skipping 11 matching lines @@
     def test_parse_warning(self):
         try:
             filesystem = self._port.host.filesystem
             filesystem.write_text_file(filesystem.join(self._port.layout_tests_dir(), 'disabled-test.html-disabled'), 'content')
             self.get_test('disabled-test.html-disabled'),
             self.parse_exp("[ FOO ] failures/expected/text.html [ Failure ]\n"
                 "Bug(rniwa) non-existent-test.html [ Failure ]\n"
                 "Bug(rniwa) disabled-test.html-disabled [ ImageOnlyFailure ]", is_lint_mode=True)
             self.assertFalse(True, "ParseError wasn't raised")
         except ParseError, e:
-            warnings = ("expectations:1 Unrecognized modifier 'foo' failures/expected/text.html\n"
+            warnings = ("expectations:1 Unrecognized specifier 'foo' failures/expected/text.html\n"
                         "expectations:2 Path does not exist. non-existent-test.html")
             self.assertEqual(str(e), warnings)
 
     def test_parse_warnings_are_logged_if_not_in_lint_mode(self):
         oc = OutputCapture()
         try:
             oc.capture_output()
             self.parse_exp('-- this should be a syntax error', is_lint_mode=False)
         finally:
             _, _, logs = oc.restore_output()
@@ skipping 30 matching lines @@
     def test_pixel_tests_flag(self):
         def match(test, result, pixel_tests_enabled):
             return self._exp.matches_an_expected_result(
                 self.get_test(test), result, pixel_tests_enabled)
 
         self.parse_exp(self.get_basic_expectations())
         self.assertTrue(match('failures/expected/text.html', FAIL, True))
         self.assertTrue(match('failures/expected/text.html', FAIL, False))
         self.assertFalse(match('failures/expected/text.html', CRASH, True))
         self.assertFalse(match('failures/expected/text.html', CRASH, False))
-        self.assertTrue(match('failures/expected/image_checksum.html', PASS,
-                              True))
-        self.assertTrue(match('failures/expected/image_checksum.html', PASS,
-                              False))
+        self.assertTrue(match('failures/expected/image_checksum.html', PASS, True))
+        self.assertTrue(match('failures/expected/image_checksum.html', PASS, False))
         self.assertTrue(match('failures/expected/crash.html', PASS, False))
         self.assertTrue(match('failures/expected/needsrebaseline.html', TEXT, True))
         self.assertFalse(match('failures/expected/needsrebaseline.html', CRASH, True))
         self.assertTrue(match('failures/expected/needsmanualrebaseline.html', TEXT, True))
         self.assertFalse(match('failures/expected/needsmanualrebaseline.html', CRASH, True))
         self.assertTrue(match('passes/text.html', PASS, False))
 
     def test_more_specific_override_resets_skip(self):
         self.parse_exp("Bug(x) failures/expected [ Skip ]\n"
                        "Bug(x) failures/expected/text.html [ ImageOnlyFailure ]\n")
         self.assert_exp('failures/expected/text.html', IMAGE)
         self.assertFalse(self._port._filesystem.join(self._port.layout_tests_dir(),
                                                      'failures/expected/text.html') in
                          self._exp.get_tests_with_result_type(SKIP))
 
     def test_bot_test_expectations(self):
         test_name = 'failures/expected/text.html'
 
         expectations_dict = OrderedDict()
         expectations_dict['expectations'] = "Bug(x) %s [ ImageOnlyFailure ]\n" % test_name
         self._port.expectations_dict = lambda: expectations_dict
 
         expectations = TestExpectations(self._port, self.get_basic_tests())
         self.assertEqual(expectations.get_expectations(self.get_test(test_name)), set([IMAGE]))
-        self.assertEqual(expectations.get_modifiers(self.get_test(test_name)), [])
 
         def bot_expectations():
             return {test_name: ['PASS', 'IMAGE']}
         self._port.bot_expectations = bot_expectations
         self._port._options.ignore_flaky_tests = 'very-flaky'
 
         expectations = TestExpectations(self._port, self.get_basic_tests())
         self.assertEqual(expectations.get_expectations(self.get_test(test_name)), set([PASS, IMAGE]))
 
-        # The following line tests the actual behavior, which is not necessarily a usefull behavior.
-        # Existing modifiers from a test expectation file are overridden by the bot expectations.
-        self.assertEqual(expectations.get_modifiers(self.get_test(test_name)), [])
-
     def test_bot_test_expectations_merge(self):
         """Test that expectations are merged rather than overridden when using flaky option 'unexpected'."""
         test_name1 = 'failures/expected/text.html'
         test_name2 = 'passes/text.html'
 
         expectations_dict = OrderedDict()
         expectations_dict['expectations'] = "Bug(x) %s [ ImageOnlyFailure ]\nBug(x) %s [ Slow ]\n" % (test_name1, test_name2)
         self._port.expectations_dict = lambda: expectations_dict
 
         expectations = TestExpectations(self._port, self.get_basic_tests())
         self.assertEqual(expectations.get_expectations(self.get_test(test_name1)), set([IMAGE]))
-        self.assertEqual(set(expectations.get_modifiers(self.get_test(test_name2))), set(['SLOW']))
+        self.assertEqual(expectations.get_expectations(self.get_test(test_name2)), set([SLOW]))
 
         def bot_expectations():
             return {test_name1: ['PASS', 'TIMEOUT'], test_name2: ['CRASH']}
         self._port.bot_expectations = bot_expectations
         self._port._options.ignore_flaky_tests = 'unexpected'
 
         expectations = TestExpectations(self._port, self.get_basic_tests())
         self.assertEqual(expectations.get_expectations(self.get_test(test_name1)), set([PASS, IMAGE, TIMEOUT]))
-        self.assertEqual(expectations.get_expectations(self.get_test(test_name2)), set([PASS, CRASH]))
-        self.assertEqual(set(expectations.get_modifiers(self.get_test(test_name2))), set(['SLOW']))
+        self.assertEqual(expectations.get_expectations(self.get_test(test_name2)), set([CRASH, SLOW]))
 
 class SkippedTests(Base):
     def check(self, expectations, overrides, skips, lint=False):
         port = MockHost().port_factory.get('test-win-xp')
         port._filesystem.write_text_file(port._filesystem.join(port.layout_tests_dir(), 'failures/expected/text.html'), 'foo')
         expectations_dict = OrderedDict()
         expectations_dict['expectations'] = expectations
         if overrides:
             expectations_dict['overrides'] = overrides
         port.expectations_dict = lambda: expectations_dict
         port.skipped_layout_tests = lambda tests: set(skips)
         expectations_to_lint = expectations_dict if lint else None
         exp = TestExpectations(port, ['failures/expected/text.html'], expectations_dict=expectations_to_lint, is_lint_mode=lint)
-
-        # Check that the expectation is for SKIP : ... [ Pass ]
-        self.assertEqual(exp.get_modifiers('failures/expected/text.html'),
-                          [TestExpectationParser.SKIP_MODIFIER, TestExpectationParser.WONTFIX_MODIFIER])
-        self.assertEqual(exp.get_expectations('failures/expected/text.html'), set([PASS]))
+        self.assertEqual(exp.get_expectations('failures/expected/text.html'), set([WONTFIX, SKIP]))
 
     def test_skipped_tests_work(self):
         self.check(expectations='', overrides=None, skips=['failures/expected/text.html'])
 
     def test_duplicate_skipped_test_fails_lint(self):
         self.assertRaises(ParseError, self.check, expectations='Bug(x) failures/expected/text.html [ Failure ]\n', overrides=None, skips=['failures/expected/text.html'], lint=True)
 
     def test_skipped_file_overrides_expectations(self):
         self.check(expectations='Bug(x) failures/expected/text.html [ Failure ]\n', overrides=None,
                    skips=['failures/expected/text.html'])
@@ skipping 31 matching lines @@
 
 class ExpectationSyntaxTests(Base):
     def test_unrecognized_expectation(self):
         self.assert_bad_expectations('Bug(test) failures/expected/text.html [ Unknown ]')
 
     def test_macro(self):
         exp_str = 'Bug(test) [ Win ] failures/expected/text.html [ Failure ]'
         self.parse_exp(exp_str)
         self.assert_exp('failures/expected/text.html', FAIL)
 
-    def assert_tokenize_exp(self, line, bugs=None, modifiers=None, expectations=None, warnings=None, comment=None, name='foo.html'):
+    def assert_tokenize_exp(self, line, bugs=None, specifiers=None, expectations=None, warnings=None, comment=None, name='foo.html'):
         bugs = bugs or []
-        modifiers = modifiers or []
+        specifiers = specifiers or []
         expectations = expectations or []
         warnings = warnings or []
         filename = 'TestExpectations'
         line_number = '1'
         expectation_line = TestExpectationParser._tokenize_line(filename, line, line_number)
         self.assertEqual(expectation_line.warnings, warnings)
         self.assertEqual(expectation_line.name, name)
         self.assertEqual(expectation_line.filename, filename)
         self.assertEqual(expectation_line.line_numbers, line_number)
         if not warnings:
-            self.assertEqual(expectation_line.modifiers, modifiers)
+            self.assertEqual(expectation_line.specifiers, specifiers)
             self.assertEqual(expectation_line.expectations, expectations)
 
     def test_comments(self):
         self.assert_tokenize_exp("# comment", name=None, comment="# comment")
-        self.assert_tokenize_exp("foo.html [ Pass ] # comment", comment="# comment", expectations=['PASS'], modifiers=[])
+        self.assert_tokenize_exp("foo.html [ Pass ] # comment", comment="# comment", expectations=['PASS'], specifiers=[])
 
-    def test_config_modifiers(self):
-        self.assert_tokenize_exp('[ Mac ] foo.html [ Failure ] ', modifiers=['MAC'], expectations=['FAIL'])
+    def test_config_specifiers(self):
+        self.assert_tokenize_exp('[ Mac ] foo.html [ Failure ] ', specifiers=['MAC'], expectations=['FAIL'])
 
     def test_unknown_config(self):
-        self.assert_tokenize_exp('[ Foo ] foo.html [ Pass ]', modifiers=['Foo'], expectations=['PASS'])
+        self.assert_tokenize_exp('[ Foo ] foo.html [ Pass ]', specifiers=['Foo'], expectations=['PASS'])
 
     def test_unknown_expectation(self):
         self.assert_tokenize_exp('foo.html [ Audio ]', warnings=['Unrecognized expectation "Audio"'])
 
     def test_skip(self):
-        self.assert_tokenize_exp('foo.html [ Skip ]', modifiers=['SKIP'], expectations=['PASS'])
+        self.assert_tokenize_exp('foo.html [ Skip ]', specifiers=[], expectations=['SKIP'])
 
     def test_slow(self):
-        self.assert_tokenize_exp('foo.html [ Slow ]', modifiers=['SLOW'], expectations=['PASS'])
+        self.assert_tokenize_exp('foo.html [ Slow ]', specifiers=[], expectations=['SLOW'])
 
     def test_wontfix(self):
-        self.assert_tokenize_exp('foo.html [ WontFix ]', modifiers=['WONTFIX', 'SKIP'], expectations=['PASS'])
-        self.assert_tokenize_exp('foo.html [ WontFix ImageOnlyFailure ]', modifiers=['WONTFIX'], expectations=['IMAGE'])
-        self.assert_tokenize_exp('foo.html [ WontFix Pass Failure ]', modifiers=['WONTFIX'], expectations=['PASS', 'FAIL'])
+        self.assert_tokenize_exp('foo.html [ WontFix ]', specifiers=[], expectations=['WONTFIX', 'SKIP'])
+        self.assert_tokenize_exp('foo.html [ WontFix ImageOnlyFailure ]', specifiers=[], expectations=['WONTFIX', 'SKIP'],
+            warnings=['A test marked Skip or WontFix must not have other expectations.'])
 
     def test_blank_line(self):
         self.assert_tokenize_exp('', name=None)
 
     def test_warnings(self):
         self.assert_tokenize_exp('[ Mac ]', warnings=['Did not find a test name.', 'Missing expectations.'], name=None)
         self.assert_tokenize_exp('[ [', warnings=['unexpected "["', 'Missing expectations.'], name=None)
         self.assert_tokenize_exp('crbug.com/12345 ]', warnings=['unexpected "]"', 'Missing expectations.'], name=None)
 
         self.assert_tokenize_exp('foo.html crbug.com/12345 ]', warnings=['"crbug.com/12345" is not at the start of the line.', 'Missing expectations.'])
@@ skipping 13 matching lines @@
 
     def test_missing_bugid(self):
         self.parse_exp('failures/expected/text.html [ Failure ]')
         self.assertFalse(self._exp.has_warnings())
 
         self._port.warn_if_bug_missing_in_test_expectations = lambda: True
 
         self.parse_exp('failures/expected/text.html [ Failure ]')
         line = self._exp._model.get_expectation_line('failures/expected/text.html')
         self.assertFalse(line.is_invalid())
-        self.assertEqual(line.warnings, ['Test lacks BUG modifier.'])
+        self.assertEqual(line.warnings, ['Test lacks BUG specifier.'])
 
     def test_skip_and_wontfix(self):
         # Skip is not allowed to have other expectations as well, because those
         # expectations won't be exercised and may become stale .
         self.parse_exp('failures/expected/text.html [ Failure Skip ]')
         self.assertTrue(self._exp.has_warnings())
 
         self.parse_exp('failures/expected/text.html [ Crash WontFix ]')
-        self.assertFalse(self._exp.has_warnings())
+        self.assertTrue(self._exp.has_warnings())
 
         self.parse_exp('failures/expected/text.html [ Pass WontFix ]')
-        self.assertFalse(self._exp.has_warnings())
+        self.assertTrue(self._exp.has_warnings())
 
     def test_slow_and_timeout(self):
         # A test cannot be SLOW and expected to TIMEOUT.
         self.assertRaises(ParseError, self.parse_exp,
             'Bug(test) failures/expected/timeout.html [ Slow Timeout ]', is_lint_mode=True)
 
     def test_rebaseline(self):
         # Can't lint a file w/ 'REBASELINE' in it.
         self.assertRaises(ParseError, self.parse_exp,
             'Bug(test) failures/expected/text.html [ Failure Rebaseline ]',
@@ skipping 23 matching lines @@
 class PrecedenceTests(Base):
     def test_file_over_directory(self):
         # This tests handling precedence of specific lines over directories
         # and tests expectations covering entire directories.
         exp_str = """
 Bug(x) failures/expected/text.html [ Failure ]
 Bug(y) failures/expected [ WontFix ]
 """
         self.parse_exp(exp_str)
         self.assert_exp('failures/expected/text.html', FAIL)
-        self.assert_exp('failures/expected/crash.html', PASS)
+        self.assert_exp_list('failures/expected/crash.html', [WONTFIX, SKIP])
 
         exp_str = """
 Bug(x) failures/expected [ WontFix ]
 Bug(y) failures/expected/text.html [ Failure ]
 """
         self.parse_exp(exp_str)
         self.assert_exp('failures/expected/text.html', FAIL)
-        self.assert_exp('failures/expected/crash.html', PASS)
+        self.assert_exp_list('failures/expected/crash.html', [WONTFIX, SKIP])
 
     def test_ambiguous(self):
         self.assert_bad_expectations("Bug(test) [ Release ] passes/text.html [ Pass ]\n"
                                      "Bug(test) [ Win ] passes/text.html [ Failure ]\n")
 
-    def test_more_modifiers(self):
+    def test_more_specifiers(self):
         self.assert_bad_expectations("Bug(test) [ Release ] passes/text.html [ Pass ]\n"
                                      "Bug(test) [ Win Release ] passes/text.html [ Failure ]\n")
 
     def test_order_in_file(self):
         self.assert_bad_expectations("Bug(test) [ Win Release ] : passes/text.html [ Failure ]\n"
                                      "Bug(test) [ Release ] : passes/text.html [ Pass ]\n")
 
     def test_macro_overrides(self):
         self.assert_bad_expectations("Bug(test) [ Win ] passes/text.html [ Pass ]\n"
                                      "Bug(test) [ XP ] passes/text.html [ Failure ]\n")
@@ skipping 156 matching lines @@
 
         actual_expectations = expectations.remove_configuration_from_test('failures/expected/foo.html', test_config)
         actual_expectations = expectations.remove_configuration_from_test('failures/expected/foo.html', host.port_factory.get('test-win-win7', None).test_configuration())
 
         self.assertEqual("""Bug(x) [ Win Debug ] failures/expected/foo.html [ Failure Timeout ]
 Bug(y) [ Mac ] failures/expected/foo.html [ Crash ]
 """, actual_expectations)
 
 
 class RebaseliningTest(Base):
-    """Test rebaselining-specific functionality."""
-    def assertRemove(self, input_expectations, input_overrides, tests, expected_expectations, expected_overrides):
-        self.parse_exp(input_expectations, is_lint_mode=False, overrides=input_overrides)
-        actual_expectations = self._exp.remove_rebaselined_tests(tests, 'expectations')
-        self.assertEqual(expected_expectations, actual_expectations)
-        actual_overrides = self._exp.remove_rebaselined_tests(tests, 'overrides')
-        self.assertEqual(expected_overrides, actual_overrides)
-
-    def test_remove(self):
-        self.assertRemove('Bug(x) failures/expected/text.html [ Failure Rebaseline ]\n'
-                          'Bug(y) failures/expected/image.html [ ImageOnlyFailure Rebaseline ]\n'
-                          'Bug(z) failures/expected/crash.html [ Crash ]\n',
-                          'Bug(x0) failures/expected/image.html [ Crash ]\n',
-                          ['failures/expected/text.html'],
-                          'Bug(y) failures/expected/image.html [ ImageOnlyFailure Rebaseline ]\n'
-                          'Bug(z) failures/expected/crash.html [ Crash ]\n',
-                          'Bug(x0) failures/expected/image.html [ Crash ]\n')
-
-        # Ensure that we don't modify unrelated lines, even if we could rewrite them.
-        # i.e., the second line doesn't get rewritten to "Bug(y) failures/expected/skip.html"
-        self.assertRemove('Bug(x) failures/expected/text.html [ Failure Rebaseline ]\n'
-                          'Bug(Y) failures/expected/image.html [ Skip   ]\n'
-                          'Bug(z) failures/expected/crash.html\n',
-                          '',
-                          ['failures/expected/text.html'],
-                          'Bug(Y) failures/expected/image.html [ Skip   ]\n'
-                          'Bug(z) failures/expected/crash.html\n',
-                          '')
-
     def test_get_rebaselining_failures(self):
         # Make sure we find a test as needing a rebaseline even if it is not marked as a failure.
         self.parse_exp('Bug(x) failures/expected/text.html [ Rebaseline ]\n')
         self.assertEqual(len(self._exp.get_rebaselining_failures()), 1)
 
         self.parse_exp(self.get_basic_expectations())
         self.assertEqual(len(self._exp.get_rebaselining_failures()), 0)
 
 
 class TestExpectationsParserTests(unittest.TestCase):
     def __init__(self, testFunc):
         host = MockHost()
         test_port = host.port_factory.get('test-win-xp', None)
         self._converter = TestConfigurationConverter(test_port.all_test_configurations(), test_port.configuration_specifier_macros())
         unittest.TestCase.__init__(self, testFunc)
-        self._parser = TestExpectationParser(host.port_factory.get('test-win-xp', None), [], allow_rebaseline_modifier=False)
+        self._parser = TestExpectationParser(host.port_factory.get('test-win-xp', None), [], allow_rebaseline=False)
 
     def test_expectation_line_for_test(self):
         # This is kind of a silly test, but it at least ensures that we don't throw an error.
         test_name = 'foo/test.html'
         expectations = set(["PASS", "IMAGE"])
 
         expectation_line = TestExpectationLine()
         expectation_line.original_string = test_name
         expectation_line.name = test_name
         expectation_line.filename = '<Bot TestExpectations>'
@@ skipping 15 matching lines @@
         return TestExpectationParser._tokenize_line('path', line, 0)
 
     def assert_round_trip(self, in_string, expected_string=None):
         expectation = self._tokenize(in_string)
         if expected_string is None:
             expected_string = in_string
         self.assertEqual(expected_string, expectation.to_string(self._converter))
 
     def assert_list_round_trip(self, in_string, expected_string=None):
         host = MockHost()
-        parser = TestExpectationParser(host.port_factory.get('test-win-xp', None), [], allow_rebaseline_modifier=False)
+        parser = TestExpectationParser(host.port_factory.get('test-win-xp', None), [], allow_rebaseline=False)
         expectations = parser.parse('path', in_string)
         if expected_string is None:
             expected_string = in_string
         self.assertEqual(expected_string, TestExpectations.list_to_string(expectations, self._converter))
 
     def test_unparsed_to_string(self):
         expectation = TestExpectationLine()
 
         self.assertEqual(expectation.to_string(self._converter), '')
         expectation.comment = ' Qux.'
         self.assertEqual(expectation.to_string(self._converter), '# Qux.')
         expectation.name = 'bar'
         self.assertEqual(expectation.to_string(self._converter), 'bar # Qux.')
-        expectation.modifiers = ['foo']
+        expectation.specifiers = ['foo']
         # FIXME: case should be preserved here but we can't until we drop the old syntax.
         self.assertEqual(expectation.to_string(self._converter), '[ FOO ] bar # Qux.')
         expectation.expectations = ['bAz']
         self.assertEqual(expectation.to_string(self._converter), '[ FOO ] bar [ BAZ ] # Qux.')
         expectation.expectations = ['bAz1', 'baZ2']
         self.assertEqual(expectation.to_string(self._converter), '[ FOO ] bar [ BAZ1 BAZ2 ] # Qux.')
-        expectation.modifiers = ['foo1', 'foO2']
+        expectation.specifiers = ['foo1', 'foO2']
         self.assertEqual(expectation.to_string(self._converter), '[ FOO1 FOO2 ] bar [ BAZ1 BAZ2 ] # Qux.')
         expectation.warnings.append('Oh the horror.')
         self.assertEqual(expectation.to_string(self._converter), '')
         expectation.original_string = 'Yes it is!'
         self.assertEqual(expectation.to_string(self._converter), 'Yes it is!')
 
     def test_unparsed_list_to_string(self):
         expectation = TestExpectationLine()
         expectation.comment = 'Qux.'
         expectation.name = 'bar'
-        expectation.modifiers = ['foo']
+        expectation.specifiers = ['foo']
         expectation.expectations = ['bAz1', 'baZ2']
         # FIXME: case should be preserved here but we can't until we drop the old syntax.
         self.assertEqual(TestExpectations.list_to_string([expectation]), '[ FOO ] bar [ BAZ1 BAZ2 ] #Qux.')
 
     def test_parsed_to_string(self):
         expectation_line = TestExpectationLine()
         expectation_line.bugs = ['Bug(x)']
         expectation_line.name = 'test/name/for/realz.html'
         expectation_line.parsed_expectations = set([IMAGE])
         self.assertEqual(expectation_line.to_string(self._converter), None)
         expectation_line.matching_configurations = set([TestConfiguration('xp', 'x86', 'release')])
         self.assertEqual(expectation_line.to_string(self._converter), 'Bug(x) [ XP Release ] test/name/for/realz.html [ ImageOnlyFailure ]')
         expectation_line.matching_configurations = set([TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'debug')])
         self.assertEqual(expectation_line.to_string(self._converter), 'Bug(x) [ XP ] test/name/for/realz.html [ ImageOnlyFailure ]')
 
     def test_serialize_parsed_expectations(self):
         expectation_line = TestExpectationLine()
         expectation_line.parsed_expectations = set([])
         parsed_expectation_to_string = dict([[parsed_expectation, expectation_string] for expectation_string, parsed_expectation in TestExpectations.EXPECTATIONS.items()])
         self.assertEqual(expectation_line._serialize_parsed_expectations(parsed_expectation_to_string), '')
         expectation_line.parsed_expectations = set([FAIL])
         self.assertEqual(expectation_line._serialize_parsed_expectations(parsed_expectation_to_string), 'fail')
         expectation_line.parsed_expectations = set([PASS, IMAGE])
         self.assertEqual(expectation_line._serialize_parsed_expectations(parsed_expectation_to_string), 'pass image')
         expectation_line.parsed_expectations = set([FAIL, PASS])
         self.assertEqual(expectation_line._serialize_parsed_expectations(parsed_expectation_to_string), 'pass fail')
 
-    def test_serialize_parsed_modifier_string(self):
+    def test_serialize_parsed_specifier_string(self):
         expectation_line = TestExpectationLine()
         expectation_line.bugs = ['garden-o-matic']
-        expectation_line.parsed_modifiers = ['the', 'for']
-        self.assertEqual(expectation_line._serialize_parsed_modifiers(self._converter, []), 'for the')
-        self.assertEqual(expectation_line._serialize_parsed_modifiers(self._converter, ['win']), 'for the win')
+        expectation_line.parsed_specifiers = ['the', 'for']
+        self.assertEqual(expectation_line._serialize_parsed_specifiers(self._converter, []), 'for the')
+        self.assertEqual(expectation_line._serialize_parsed_specifiers(self._converter, ['win']), 'for the win')
         expectation_line.bugs = []
-        expectation_line.parsed_modifiers = []
-        self.assertEqual(expectation_line._serialize_parsed_modifiers(self._converter, []), '')
-        self.assertEqual(expectation_line._serialize_parsed_modifiers(self._converter, ['win']), 'win')
+        expectation_line.parsed_specifiers = []
+        self.assertEqual(expectation_line._serialize_parsed_specifiers(self._converter, []), '')
+        self.assertEqual(expectation_line._serialize_parsed_specifiers(self._converter, ['win']), 'win')
 
     def test_format_line(self):
         self.assertEqual(TestExpectationLine._format_line([], ['MODIFIERS'], 'name', ['EXPECTATIONS'], 'comment'), '[ MODIFIERS ] name [ EXPECTATIONS ] #comment')
         self.assertEqual(TestExpectationLine._format_line([], ['MODIFIERS'], 'name', ['EXPECTATIONS'], None), '[ MODIFIERS ] name [ EXPECTATIONS ]')
 
     def test_string_roundtrip(self):
         self.assert_round_trip('')
         self.assert_round_trip('[')
         self.assert_round_trip('FOO [')
         self.assert_round_trip('FOO ] bar')
@@ skipping 47 matching lines @@
 
     def disabled_test_string_whitespace_stripping(self):
         # FIXME: Re-enable this test once we rework the code to no longer support the old syntax.
         self.assert_round_trip('\n', '')
         self.assert_round_trip('  [ FOO ] bar [ BAZ ]', '[ FOO ] bar [ BAZ ]')
         self.assert_round_trip('[ FOO ]    bar [ BAZ ]', '[ FOO ] bar [ BAZ ]')
         self.assert_round_trip('[ FOO ] bar [ BAZ ]       # Qux.', '[ FOO ] bar [ BAZ ] # Qux.')
         self.assert_round_trip('[ FOO ] bar [        BAZ ]  # Qux.', '[ FOO ] bar [ BAZ ] # Qux.')
         self.assert_round_trip('[ FOO ]       bar [    BAZ ]  # Qux.', '[ FOO ] bar [ BAZ ] # Qux.')
         self.assert_round_trip('[ FOO ]       bar     [    BAZ ]  # Qux.', '[ FOO ] bar [ BAZ ] # Qux.')