webkitpy: Implement device type specific expected results (Part 2)
[WebKit-https.git] / Tools / Scripts / webkitpy / layout_tests / models / test_expectations_unittest.py
index 6fa9fba..2046446 100644 (file)
@@ -1,5 +1,5 @@
-#!/usr/bin/python
 # Copyright (C) 2010 Google Inc. All rights reserved.
+# Copyright (C) 2013 Apple Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
@@ -29,6 +29,8 @@
 
 import unittest
 
+from collections import OrderedDict
+
 from webkitpy.common.host_mock import MockHost
 from webkitpy.common.system.outputcapture import OutputCapture
 
@@ -36,12 +38,6 @@ from webkitpy.layout_tests.models.test_configuration import *
 from webkitpy.layout_tests.models.test_expectations import *
 from webkitpy.layout_tests.models.test_configuration import *
 
-try:
-    from collections import OrderedDict
-except ImportError:
-    # Needed for Python < 2.7
-    from webkitpy.thirdparty.ordered_dict import OrderedDict
-
 
 class Base(unittest.TestCase):
     # Note that all of these tests are written assuming the configuration
@@ -53,25 +49,29 @@ class Base(unittest.TestCase):
         self._exp = None
         unittest.TestCase.__init__(self, testFunc)
 
-    def get_test(self, test_name):
-        # FIXME: Remove this routine and just reference test names directly.
-        return test_name
-
     def get_basic_tests(self):
-        return [self.get_test('failures/expected/text.html'),
-                self.get_test('failures/expected/image_checksum.html'),
-                self.get_test('failures/expected/crash.html'),
-                self.get_test('failures/expected/missing_text.html'),
-                self.get_test('failures/expected/image.html'),
-                self.get_test('passes/text.html')]
+        return ['failures/expected/text.html',
+                'failures/expected/image_checksum.html',
+                'failures/expected/crash.html',
+                'failures/expected/leak.html',
+                'failures/expected/flaky-leak.html',
+                'failures/expected/missing_text.html',
+                'failures/expected/image.html',
+                'failures/expected/reftest.html',
+                'failures/expected/leaky-reftest.html',
+                'passes/text.html']
 
     def get_basic_expectations(self):
         return """
-BUG_TEST : failures/expected/text.html = FAIL
-BUG_TEST WONTFIX : failures/expected/crash.html = PASS
-BUG_TEST REBASELINE : failures/expected/missing_image.html = MISSING
-BUG_TEST WONTFIX : failures/expected/image_checksum.html = PASS
-BUG_TEST WONTFIX MAC : failures/expected/image.html = PASS
+Bug(test) failures/expected/text.html [ Failure ]
+Bug(test) failures/expected/crash.html [ WontFix ]
+Bug(test) failures/expected/leak.html [ Leak ]
+Bug(test) failures/expected/flaky-leak.html [ Failure Leak ]
+Bug(test) failures/expected/missing_image.html [ Rebaseline Missing ]
+Bug(test) failures/expected/image_checksum.html [ WontFix ]
+Bug(test) failures/expected/image.html [ WontFix Mac ]
+Bug(test) failures/expected/reftest.html [ ImageOnlyFailure ]
+Bug(test) failures/expected/leaky-reftest.html [ ImageOnlyFailure Leak ]
 """
 
     def parse_exp(self, expectations, overrides=None, is_lint_mode=False):
@@ -79,12 +79,16 @@ BUG_TEST WONTFIX MAC : failures/expected/image.html = PASS
         expectations_dict['expectations'] = expectations
         if overrides:
             expectations_dict['overrides'] = overrides
-        self._port.expectations_dict = lambda: expectations_dict
-        self._exp = TestExpectations(self._port, self.get_basic_tests(), is_lint_mode)
+        self._port.expectations_dict = lambda **kwargs: expectations_dict
+        expectations_to_lint = expectations_dict if is_lint_mode else None
+        self._exp = TestExpectations(self._port, self.get_basic_tests(), expectations_to_lint=expectations_to_lint)
+        self._exp.parse_all_expectations()
 
     def assert_exp(self, test, result):
-        self.assertEquals(self._exp.get_expectations(self.get_test(test)),
-                          set([result]))
+        self.assertEqual(self._exp.model().get_expectations(test), set([result]))
+
+    def assert_exp_set(self, test, result_set):
+        self.assertEqual(self._exp.model().get_expectations(test), result_set)
 
     def assert_bad_expectations(self, expectations, overrides=None):
         self.assertRaises(ParseError, self.parse_exp, expectations, is_lint_mode=True, overrides=overrides)
@@ -95,411 +99,376 @@ class BasicTests(Base):
         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('failures/expected/reftest.html', IMAGE)
+        self.assert_exp_set('failures/expected/leaky-reftest.html', set([IMAGE, LEAK]))
+        self.assert_exp('failures/expected/leak.html', LEAK)
+        self.assert_exp_set('failures/expected/flaky-leak.html', set([FAIL, LEAK]))
         self.assert_exp('passes/text.html', PASS)
+        # self.assert_exp_set('passes/flaky-leak.html', set([PASS, LEAK]))
         self.assert_exp('failures/expected/image.html', PASS)
 
 
 class MiscTests(Base):
     def test_multiple_results(self):
-        self.parse_exp('BUGX : failures/expected/text.html = FAIL CRASH')
-        self.assertEqual(self._exp.get_expectations(
-            self.get_test('failures/expected/text.html')),
+        self.parse_exp('Bug(x) failures/expected/text.html [ Crash Failure ]')
+        self.assertEqual(self._exp.model().get_expectations(
+            'failures/expected/text.html'),
             set([FAIL, CRASH]))
 
     def test_result_was_expected(self):
         # test basics
-        self.assertEquals(TestExpectations.result_was_expected(PASS, set([PASS]), test_needs_rebaselining=False, test_is_skipped=False), True)
-        self.assertEquals(TestExpectations.result_was_expected(FAIL, set([PASS]), test_needs_rebaselining=False, test_is_skipped=False), False)
+        self.assertEqual(TestExpectations.result_was_expected(PASS, set([PASS]), test_needs_rebaselining=False, test_is_skipped=False), True)
+        self.assertEqual(TestExpectations.result_was_expected(FAIL, set([PASS]), test_needs_rebaselining=False, test_is_skipped=False), False)
 
         # test handling of SKIPped tests and results
-        self.assertEquals(TestExpectations.result_was_expected(SKIP, set([CRASH]), test_needs_rebaselining=False, test_is_skipped=True), True)
-        self.assertEquals(TestExpectations.result_was_expected(SKIP, set([CRASH]), test_needs_rebaselining=False, test_is_skipped=False), False)
+        self.assertEqual(TestExpectations.result_was_expected(SKIP, set([CRASH]), test_needs_rebaselining=False, test_is_skipped=True), True)
+        self.assertEqual(TestExpectations.result_was_expected(SKIP, set([CRASH]), test_needs_rebaselining=False, test_is_skipped=False), False)
 
         # test handling of MISSING results and the REBASELINE modifier
-        self.assertEquals(TestExpectations.result_was_expected(MISSING, set([PASS]), test_needs_rebaselining=True, test_is_skipped=False), True)
-        self.assertEquals(TestExpectations.result_was_expected(MISSING, set([PASS]), test_needs_rebaselining=False, test_is_skipped=False), False)
+        self.assertEqual(TestExpectations.result_was_expected(MISSING, set([PASS]), test_needs_rebaselining=True, test_is_skipped=False), True)
+        self.assertEqual(TestExpectations.result_was_expected(MISSING, set([PASS]), test_needs_rebaselining=False, test_is_skipped=False), False)
 
     def test_remove_pixel_failures(self):
-        self.assertEquals(TestExpectations.remove_pixel_failures(set([FAIL])), set([FAIL]))
-        self.assertEquals(TestExpectations.remove_pixel_failures(set([PASS])), set([PASS]))
-        self.assertEquals(TestExpectations.remove_pixel_failures(set([IMAGE])), set([PASS]))
-        self.assertEquals(TestExpectations.remove_pixel_failures(set([FAIL])), set([FAIL]))
-        self.assertEquals(TestExpectations.remove_pixel_failures(set([PASS, IMAGE, CRASH])), set([PASS, CRASH]))
+        self.assertEqual(TestExpectations.remove_pixel_failures(set([FAIL])), set([FAIL]))
+        self.assertEqual(TestExpectations.remove_pixel_failures(set([PASS])), set([PASS]))
+        self.assertEqual(TestExpectations.remove_pixel_failures(set([IMAGE])), set([PASS]))
+        self.assertEqual(TestExpectations.remove_pixel_failures(set([FAIL])), set([FAIL]))
+        self.assertEqual(TestExpectations.remove_pixel_failures(set([PASS, IMAGE, CRASH])), set([PASS, CRASH]))
+
+    def test_remove_leak_failures(self):
+        self.assertEqual(TestExpectations.remove_leak_failures(set([FAIL])), set([FAIL]))
+        self.assertEqual(TestExpectations.remove_leak_failures(set([PASS])), set([PASS]))
+        self.assertEqual(TestExpectations.remove_leak_failures(set([LEAK])), set([PASS]))
+        self.assertEqual(TestExpectations.remove_leak_failures(set([PASS, LEAK])), set([PASS]))
+        self.assertEqual(TestExpectations.remove_leak_failures(set([FAIL, LEAK])), set([FAIL]))
+        self.assertEqual(TestExpectations.remove_leak_failures(set([PASS, IMAGE, LEAK, CRASH])), set([PASS, IMAGE, CRASH]))
 
     def test_suffixes_for_expectations(self):
-        self.assertEquals(TestExpectations.suffixes_for_expectations(set([FAIL])), set(['txt', 'png', 'wav']))
-        self.assertEquals(TestExpectations.suffixes_for_expectations(set([IMAGE])), set(['png']))
-        self.assertEquals(TestExpectations.suffixes_for_expectations(set([FAIL, IMAGE, CRASH])), set(['txt', 'png', 'wav']))
-        self.assertEquals(TestExpectations.suffixes_for_expectations(set()), set())
+        self.assertEqual(TestExpectations.suffixes_for_expectations(set([FAIL])), set(['txt', 'png', 'wav']))
+        self.assertEqual(TestExpectations.suffixes_for_expectations(set([IMAGE])), set(['png']))
+        self.assertEqual(TestExpectations.suffixes_for_expectations(set([FAIL, IMAGE, CRASH])), set(['txt', 'png', 'wav']))
+        self.assertEqual(TestExpectations.suffixes_for_expectations(set()), set())
 
     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 = """
-BUGX WONTFIX : failures/expected = PASS
-"""
+        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 = test_name
+        self.assertRaises(KeyError, self._exp.model().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.assertEqual(self._exp.model().get_modifiers('passes/text.html'), [])
 
     def test_get_expectations_string(self):
         self.parse_exp(self.get_basic_expectations())
-        self.assertEquals(self._exp.get_expectations_string(
-                          self.get_test('failures/expected/text.html')),
-                          'FAIL')
+        self.assertEqual(self._exp.model().get_expectations_string('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())
-        self.assertRaises(ValueError, self._exp.expectation_to_string,
-                          -1)
+        self.assertRaises(ValueError, self._exp.model().expectation_to_string, -1)
 
     def test_get_test_set(self):
         # Handle some corner cases for this routine not covered by other tests.
         self.parse_exp(self.get_basic_expectations())
-        s = self._exp.get_test_set(WONTFIX)
+        s = self._exp.model().get_test_set(WONTFIX)
         self.assertEqual(s,
-            set([self.get_test('failures/expected/crash.html'),
-                 self.get_test('failures/expected/image_checksum.html')]))
+            set(['failures/expected/crash.html',
+                 'failures/expected/image_checksum.html']))
 
     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 Test lacks BUG modifier. failures/expected/text.html\n"
-                        "expectations:1 Unrecognized modifier 'foo' failures/expected/text.html\n"
+        except ParseError as e:
+            warnings = ("expectations:1 Unrecognized modifier '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()
+            self.assertNotEquals(logs, '')
+
     def test_error_on_different_platform(self):
         # parse_exp uses a Windows port. Assert errors on Mac show up in lint mode.
         self.assertRaises(ParseError, self.parse_exp,
-            'BUG_TEST MAC : failures/expected/text.html = FAIL\nBUG_TEST MAC : failures/expected/text.html = FAIL',
+            'Bug(test) [ Mac ] failures/expected/text.html [ Failure ]\nBug(test) [ Mac ] failures/expected/text.html [ Failure ]',
             is_lint_mode=True)
 
     def test_error_on_different_build_type(self):
         # parse_exp uses a Release port. Assert errors on DEBUG show up in lint mode.
         self.assertRaises(ParseError, self.parse_exp,
-            'BUG_TEST DEBUG : failures/expected/text.html = FAIL\nBUG_TEST DEBUG : failures/expected/text.html = FAIL',
+            'Bug(test) [ Debug ] failures/expected/text.html [ Failure ]\nBug(test) [ Debug ] failures/expected/text.html [ Failure ]',
             is_lint_mode=True)
 
     def test_overrides(self):
-        self.parse_exp("BUG_EXP: failures/expected/text.html = FAIL",
-                       "BUG_OVERRIDE : failures/expected/text.html = IMAGE")
+        self.parse_exp("Bug(exp) failures/expected/text.html [ Failure ]",
+                       "Bug(override) failures/expected/text.html [ ImageOnlyFailure ]")
         self.assert_exp('failures/expected/text.html', IMAGE)
 
     def test_overrides__directory(self):
-        self.parse_exp("BUG_EXP: failures/expected/text.html = FAIL",
-                       "BUG_OVERRIDE: failures/expected = CRASH")
+        self.parse_exp("Bug(exp) failures/expected/text.html [ Failure ]",
+                       "Bug(override) failures/expected [ Crash ]")
         self.assert_exp('failures/expected/text.html', CRASH)
         self.assert_exp('failures/expected/image.html', CRASH)
 
     def test_overrides__duplicate(self):
-        self.assert_bad_expectations("BUG_EXP: failures/expected/text.html = FAIL",
-                                     "BUG_OVERRIDE : failures/expected/text.html = IMAGE\n"
-                                     "BUG_OVERRIDE : failures/expected/text.html = CRASH\n")
+        self.assert_bad_expectations("Bug(exp) failures/expected/text.html [ Failure ]",
+                                     "Bug(override) failures/expected/text.html [ ImageOnlyFailure ]\n"
+                                     "Bug(override) failures/expected/text.html [ Crash ]\n")
 
     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)
+            expectations = self._exp.filtered_expectations_for_test(test, pixel_tests_enabled, False)
+            return self._exp.matches_an_expected_result(test, result, expectations)
+
+        self.parse_exp(self.get_basic_expectations())
+        pixel_tests_enabled = True
+        pixel_tests_disabled = False
+        self.assertTrue(match('failures/expected/text.html', FAIL, pixel_tests_enabled))
+        self.assertTrue(match('failures/expected/text.html', FAIL, pixel_tests_disabled))
+        self.assertFalse(match('failures/expected/text.html', CRASH, pixel_tests_enabled))
+        self.assertFalse(match('failures/expected/text.html', CRASH, pixel_tests_disabled))
+        self.assertTrue(match('failures/expected/image_checksum.html', PASS, pixel_tests_enabled))
+        self.assertTrue(match('failures/expected/image_checksum.html', PASS, pixel_tests_disabled))
+        self.assertTrue(match('failures/expected/crash.html', PASS, pixel_tests_disabled))
+        self.assertTrue(match('passes/text.html', PASS, pixel_tests_disabled))
+
+    def test_world_leaks_flag(self):
+        def match(test, result, pixel_tests_enabled, world_leaks_enabled):
+            expectations = self._exp.filtered_expectations_for_test(test, pixel_tests_enabled, world_leaks_enabled)
+            return self._exp.matches_an_expected_result(test, result, expectations)
+
+        pixel_tests_enabled = True
+        pixel_tests_disabled = False
+        world_leaks_enabled = True
+        world_leaks_disabled = False
 
         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/crash.html', PASS, False))
-        self.assertTrue(match('passes/text.html', PASS, False))
+        self.assertTrue(match('failures/expected/leak.html', LEAK, pixel_tests_enabled, world_leaks_enabled))
+        self.assertTrue(match('failures/expected/leak.html', PASS, pixel_tests_enabled, world_leaks_disabled))
+        self.assertTrue(match('failures/expected/flaky-leak.html', FAIL, pixel_tests_enabled, world_leaks_disabled))
+
+        self.assertTrue(match('failures/expected/leaky-reftest.html', LEAK, pixel_tests_disabled, world_leaks_enabled))
+        self.assertTrue(match('failures/expected/leaky-reftest.html', PASS, pixel_tests_disabled, world_leaks_disabled))
+
+        self.assertTrue(match('failures/expected/leaky-reftest.html', IMAGE, pixel_tests_enabled, world_leaks_enabled))
+        self.assertTrue(match('failures/expected/leaky-reftest.html', LEAK, pixel_tests_enabled, world_leaks_enabled))
+        self.assertTrue(match('failures/expected/leaky-reftest.html', IMAGE, pixel_tests_enabled, world_leaks_disabled))
+
+        self.assertFalse(match('failures/expected/text.html', PASS, pixel_tests_enabled, world_leaks_enabled))
+        self.assertFalse(match('failures/expected/text.html', CRASH, pixel_tests_enabled, world_leaks_disabled))
+        self.assertTrue(match('passes/text.html', PASS, pixel_tests_enabled, world_leaks_disabled))
 
     def test_more_specific_override_resets_skip(self):
-        self.parse_exp("BUGX SKIP : failures/expected = FAIL\n"
-                       "BUGX : failures/expected/text.html = IMAGE\n")
+        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))
+                         self._exp.model().get_tests_with_result_type(SKIP))
 
 
 class SkippedTests(Base):
     def check(self, expectations, overrides, skips, lint=False):
-        port = MockHost().port_factory.get('qt')
+        port = MockHost().port_factory.get('mac')
         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)
-        exp = TestExpectations(port, ['failures/expected/text.html'], lint)
-
-        # Check that the expectation is for BUG_DUMMY SKIP : ... = PASS
-        self.assertEquals(exp.get_modifiers('failures/expected/text.html'),
+        port.expectations_dict = lambda **kwargs: expectations_dict
+        port.skipped_layout_tests = lambda tests, **kwargs: set(skips)
+        expectations_to_lint = expectations_dict if lint else None
+        exp = TestExpectations(port, ['failures/expected/text.html'], expectations_to_lint=expectations_to_lint)
+        exp.parse_all_expectations()
+
+        # Check that the expectation is for BUG_DUMMY SKIP : ... [ Pass ]
+        self.assertEqual(exp.model().get_modifiers('failures/expected/text.html'),
                           [TestExpectationParser.DUMMY_BUG_MODIFIER, TestExpectationParser.SKIP_MODIFIER, TestExpectationParser.WONTFIX_MODIFIER])
-        self.assertEquals(exp.get_expectations('failures/expected/text.html'), set([PASS]))
+        self.assertEqual(exp.model().get_expectations('failures/expected/text.html'), set([PASS]))
 
     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='BUGX : failures/expected/text.html = text\n', overrides=None, skips=['failures/expected/text.html'], lint=True)
+        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='BUGX : failures/expected/text.html = FAIL\n', overrides=None,
+        self.check(expectations='Bug(x) failures/expected/text.html [ Failure ]\n', overrides=None,
                    skips=['failures/expected/text.html'])
 
     def test_skipped_dir_overrides_expectations(self):
-        self.check(expectations='BUGX : failures/expected/text.html = FAIL\n', overrides=None,
+        self.check(expectations='Bug(x) failures/expected/text.html [ Failure ]\n', overrides=None,
                    skips=['failures/expected'])
 
     def test_skipped_file_overrides_overrides(self):
-        self.check(expectations='', overrides='BUGX : failures/expected/text.html = FAIL\n',
+        self.check(expectations='', overrides='Bug(x) failures/expected/text.html [ Failure ]\n',
                    skips=['failures/expected/text.html'])
 
     def test_skipped_dir_overrides_overrides(self):
-        self.check(expectations='', overrides='BUGX : failures/expected/text.html = FAIL\n',
+        self.check(expectations='', overrides='Bug(x) failures/expected/text.html [ Failure ]\n',
                    skips=['failures/expected'])
 
     def test_skipped_entry_dont_exist(self):
-        port = MockHost().port_factory.get('qt')
+        port = MockHost().port_factory.get('mac')
         expectations_dict = OrderedDict()
         expectations_dict['expectations'] = ''
-        port.expectations_dict = lambda: expectations_dict
-        port.skipped_layout_tests = lambda tests: set(['foo/bar/baz.html'])
+        port.expectations_dict = lambda **kwargs: expectations_dict
+        port.skipped_layout_tests = lambda tests, **kwargs: set(['foo/bar/baz.html'])
         capture = OutputCapture()
         capture.capture_output()
         exp = TestExpectations(port)
+        exp.parse_all_expectations()
         _, _, logs = capture.restore_output()
         self.assertEqual('The following test foo/bar/baz.html from the Skipped list doesn\'t exist\n', logs)
 
 
-# FIXME: remove these tests when we stop supporting the old syntax.
-
 class ExpectationSyntaxTests(Base):
-    def test_missing_expectation(self):
-        # This is missing the expectation.
-        self.assert_bad_expectations('BUG_TEST: failures/expected/text.html')
-
-    def test_missing_colon(self):
-        # This is missing the modifiers and the ':'
-        self.assert_bad_expectations('failures/expected/text.html = FAIL')
-
-    def test_too_many_colons(self):
-        self.assert_bad_expectations('BUG_TEST: failures/expected/text.html = PASS :')
-
-    def test_too_many_equals_signs(self):
-        self.assert_bad_expectations('BUG_TEST: failures/expected/text.html = FAIL = IMAGE')
-
     def test_unrecognized_expectation(self):
-        self.assert_bad_expectations('BUG_TEST: failures/expected/text.html = UNKNOWN')
+        self.assert_bad_expectations('Bug(test) failures/expected/text.html [ Unknown ]')
 
     def test_macro(self):
-        exp_str = """
-BUG_TEST WIN : failures/expected/text.html = FAIL
-"""
+        exp_str = 'Bug(test) [ Win ] failures/expected/text.html [ Failure ]'
         self.parse_exp(exp_str)
         self.assert_exp('failures/expected/text.html', FAIL)
 
-
-class NewExpectationSyntaxTests(unittest.TestCase):
-    def assert_exp(self, line, bugs=None, modifiers=None, expectations=None, warnings=None, comment=None, name='foo.html'):
+    def assert_tokenize_exp(self, line, bugs=None, modifiers=None, expectations=None, warnings=None, comment=None, name='foo.html'):
         bugs = bugs or []
         modifiers = modifiers or []
         expectations = expectations or []
         warnings = warnings or []
         filename = 'TestExpectations'
         line_number = 1
-        expectation_line = TestExpectationParser._tokenize_line_using_new_format(filename, line, line_number)
-        self.assertEquals(expectation_line.warnings, warnings)
-        self.assertEquals(expectation_line.name, name)
-        self.assertEquals(expectation_line.filename, filename)
-        self.assertEquals(expectation_line.line_number, line_number)
+        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_number, line_number)
         if not warnings:
-            self.assertEquals(expectation_line.modifiers, modifiers)
-            self.assertEquals(expectation_line.expectations, expectations)
+            self.assertEqual(expectation_line.modifiers, modifiers)
+            self.assertEqual(expectation_line.expectations, expectations)
 
     def test_bare_name(self):
-        self.assert_exp('foo.html', modifiers=['SKIP'], expectations=['PASS'])
+        self.assert_tokenize_exp('foo.html', modifiers=['SKIP'], expectations=['PASS'])
 
     def test_bare_name_and_bugs(self):
-        self.assert_exp('webkit.org/b/12345 foo.html', modifiers=['BUGWK12345', 'SKIP'], expectations=['PASS'])
-        self.assert_exp('crbug.com/12345 foo.html', modifiers=['BUGCR12345', 'SKIP'], expectations=['PASS'])
-        self.assert_exp('Bug(dpranke) foo.html', modifiers=['BUGDPRANKE', 'SKIP'], expectations=['PASS'])
-        self.assert_exp('crbug.com/12345 crbug.com/34567 foo.html', modifiers=['BUGCR12345', 'BUGCR34567', 'SKIP'], expectations=['PASS'])
+        self.assert_tokenize_exp('webkit.org/b/12345 foo.html', modifiers=['BUGWK12345', 'SKIP'], expectations=['PASS'])
+        self.assert_tokenize_exp('Bug(dpranke) foo.html', modifiers=['BUGDPRANKE', 'SKIP'], expectations=['PASS'])
+        self.assert_tokenize_exp('webkit.org/b/12345 webkit.org/b/34567 foo.html', modifiers=['BUGWK12345', 'BUGWK34567', 'SKIP'], expectations=['PASS'])
 
     def test_comments(self):
-        self.assert_exp("# comment", name=None, comment="# comment")
-        self.assert_exp("foo.html # comment", comment="# comment", expectations=['PASS'], modifiers=['SKIP'])
+        self.assert_tokenize_exp("# comment", name=None, comment="# comment")
+        self.assert_tokenize_exp("foo.html # comment", comment="# comment", expectations=['PASS'], modifiers=['SKIP'])
 
     def test_config_modifiers(self):
-        self.assert_exp('[ Mac ] foo.html', modifiers=['MAC', 'SKIP'], expectations=['PASS'])
-        self.assert_exp('[ Mac Vista ] foo.html', modifiers=['MAC', 'VISTA', 'SKIP'], expectations=['PASS'])
-        self.assert_exp('[ Mac ] foo.html [ Failure ] ', modifiers=['MAC'], expectations=['FAIL'])
+        self.assert_tokenize_exp('[ Mac ] foo.html', modifiers=['MAC', 'SKIP'], expectations=['PASS'])
+        self.assert_tokenize_exp('[ Mac Vista ] foo.html', modifiers=['MAC', 'VISTA', 'SKIP'], expectations=['PASS'])
+        self.assert_tokenize_exp('[ Mac ] foo.html [ Failure ] ', modifiers=['MAC'], expectations=['FAIL'])
 
     def test_unknown_config(self):
-        self.assert_exp('[ Foo ] foo.html ', modifiers=['Foo', 'SKIP'], expectations=['PASS'])
+        self.assert_tokenize_exp('[ Foo ] foo.html ', modifiers=['Foo', 'SKIP'], expectations=['PASS'])
 
     def test_unknown_expectation(self):
-        self.assert_exp('foo.html [ Audio ]', expectations=['Audio'])
+        self.assert_tokenize_exp('foo.html [ Audio ]', warnings=['Unrecognized expectation "Audio"'])
 
     def test_skip(self):
-        self.assert_exp('foo.html [ Skip ]', modifiers=['SKIP'], expectations=['PASS'])
+        self.assert_tokenize_exp('foo.html [ Skip ]', modifiers=['SKIP'], expectations=['PASS'])
 
     def test_slow(self):
-        self.assert_exp('foo.html [ Slow ]', modifiers=['SLOW'], expectations=['PASS'])
-
-    def test_wontfix(self):
-        self.assert_exp('foo.html [ WontFix ]', modifiers=['WONTFIX', 'SKIP'], expectations=['PASS'])
-
-    def test_blank_line(self):
-        self.assert_exp('', name=None)
-
-    def test_warnings(self):
-        self.assert_exp('[ Mac ]', warnings=['Did not find a test name.'], name=None)
-
-        self.assert_exp('[ [', warnings=['unexpected "["'], name=None)
-        self.assert_exp('crbug.com/12345 ]', warnings=['unexpected "]"'], name=None)
-
-        self.assert_exp('foo.html crbug.com/12345 ]', warnings=['"crbug.com/12345" is not at the start of the line.'])
-
-
-class NewExpectationSyntaxTests(unittest.TestCase):
-    def assert_exp(self, line, bugs=None, modifiers=None, expectations=None, warnings=None, comment=None, name='foo.html'):
-        bugs = bugs or []
-        modifiers = modifiers or []
-        expectations = expectations or []
-        warnings = warnings or []
-        filename = 'TestExpectations'
-        line_number = 1
-        expectation_line = TestExpectationParser._tokenize_line_using_new_format(filename, line, line_number)
-        self.assertEquals(expectation_line.warnings, warnings)
-        self.assertEquals(expectation_line.name, name)
-        self.assertEquals(expectation_line.filename, filename)
-        self.assertEquals(expectation_line.line_number, line_number)
-        if not warnings:
-            self.assertEquals(expectation_line.modifiers, modifiers)
-            self.assertEquals(expectation_line.expectations, expectations)
-
-    def test_bare_name(self):
-        self.assert_exp('foo.html', modifiers=['SKIP'], expectations=['PASS'])
-
-    def test_bare_name_and_bugs(self):
-        self.assert_exp('webkit.org/b/12345 foo.html', modifiers=['BUGWK12345', 'SKIP'], expectations=['PASS'])
-        self.assert_exp('crbug.com/12345 foo.html', modifiers=['BUGCR12345', 'SKIP'], expectations=['PASS'])
-        self.assert_exp('Bug(dpranke) foo.html', modifiers=['BUGDPRANKE', 'SKIP'], expectations=['PASS'])
-        self.assert_exp('crbug.com/12345 crbug.com/34567 foo.html', modifiers=['BUGCR12345', 'BUGCR34567', 'SKIP'], expectations=['PASS'])
+        self.assert_tokenize_exp('foo.html [ Slow ]', modifiers=['SLOW'], expectations=['PASS'])
 
-    def test_comments(self):
-        self.assert_exp("# comment", name=None, comment="# comment")
-        self.assert_exp("foo.html # comment", comment="# comment", expectations=['PASS'], modifiers=['SKIP'])
-
-    def test_config_modifiers(self):
-        self.assert_exp('[ Mac ] foo.html', modifiers=['MAC', 'SKIP'], expectations=['PASS'])
-        self.assert_exp('[ Mac Vista ] foo.html', modifiers=['MAC', 'VISTA', 'SKIP'], expectations=['PASS'])
-        self.assert_exp('[ Mac ] foo.html [ Failure ] ', modifiers=['MAC'], expectations=['FAIL'])
-
-    def test_unknown_config(self):
-        self.assert_exp('[ Foo ] foo.html ', modifiers=['Foo', 'SKIP'], expectations=['PASS'])
-
-    def test_unknown_expectation(self):
-        self.assert_exp('foo.html [ Audio ]', expectations=['Audio'])
-
-    def test_skip(self):
-        self.assert_exp('foo.html [ Skip ]', modifiers=['SKIP'], expectations=['PASS'])
-
-    def test_slow(self):
-        self.assert_exp('foo.html [ Slow ]', modifiers=['SLOW'], expectations=['PASS'])
+    def test_leak(self):
+        self.assert_tokenize_exp('foo.html [ Leak ]', modifiers=[], expectations=['LEAK'])
 
     def test_wontfix(self):
-        self.assert_exp('foo.html [ WontFix ]', modifiers=['WONTFIX', 'SKIP'], expectations=['PASS'])
+        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'])
 
     def test_blank_line(self):
-        self.assert_exp('', name=None)
+        self.assert_tokenize_exp('', name=None)
 
     def test_warnings(self):
-        self.assert_exp('[ Mac ]', warnings=['Did not find a test name.'], name=None)
-        self.assert_exp('[ [', warnings=['unexpected "["'], name=None)
-        self.assert_exp('crbug.com/12345 ]', warnings=['unexpected "]"'], name=None)
+        self.assert_tokenize_exp('[ Mac ]', warnings=['Did not find a test name.'], name=None)
+        self.assert_tokenize_exp('[ [', warnings=['unexpected "["'], name=None)
+        self.assert_tokenize_exp('webkit.org/b/12345 ]', warnings=['unexpected "]"'], name=None)
 
-        self.assert_exp('foo.html crbug.com/12345 ]', warnings=['"crbug.com/12345" is not at the start of the line.'])
+        self.assert_tokenize_exp('foo.html webkit.org/b/12345 ]', warnings=['"webkit.org/b/12345" is not at the start of the line.'])
 
 
 class SemanticTests(Base):
     def test_bug_format(self):
-        self.assertRaises(ParseError, self.parse_exp, 'BUG1234 : failures/expected/text.html = FAIL', is_lint_mode=True)
+        self.assertRaises(ParseError, self.parse_exp, 'BUG1234 failures/expected/text.html [ Failure ]', is_lint_mode=True)
 
     def test_bad_bugid(self):
         try:
-            self.parse_exp('BUG1234 SLOW : failures/expected/text.html = FAIL', is_lint_mode=True)
+            self.parse_exp('BUG1234 failures/expected/text.html [ Failure ]', is_lint_mode=True)
             self.fail('should have raised an error about a bad bug identifier')
-        except ParseError, exp:
-            self.assertEquals(len(exp.warnings), 1)
+        except ParseError as exp:
+            self.assertEqual(len(exp.warnings), 1)
 
     def test_missing_bugid(self):
-        self.parse_exp('SLOW : failures/expected/text.html = FAIL')
-        self.assertTrue(self._exp.has_warnings())
+        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.assertEquals(line.warnings, ['Test lacks BUG modifier.'])
+        self.assertEqual(line.warnings, ['Test lacks BUG modifier.'])
 
     def test_skip_and_wontfix(self):
-        # Skip and WontFix are not allowed to have other expectations as well, because those
+        # 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.assertTrue(self._exp.has_warnings())
+        self.assertFalse(self._exp.has_warnings())
 
-        # We can't warn against [ Pass WontFix ] until we get rid of the old syntax.
         self.parse_exp('failures/expected/text.html [ Pass WontFix ]')
         self.assertFalse(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 SLOW : failures/expected/timeout.html = TIMEOUT', is_lint_mode=True)
+            '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 REBASELINE : failures/expected/text.html = FAIL',
+            'Bug(test) failures/expected/text.html [ Failure Rebaseline ]',
             is_lint_mode=True)
 
     def test_duplicates(self):
         self.assertRaises(ParseError, self.parse_exp, """
-BUG_EXP : failures/expected/text.html = FAIL
-BUG_EXP : failures/expected/text.html = IMAGE""", is_lint_mode=True)
+Bug(exp) failures/expected/text.html [ Failure ]
+Bug(exp) failures/expected/text.html [ ImageOnlyFailure ]""", is_lint_mode=True)
 
         self.assertRaises(ParseError, self.parse_exp,
             self.get_basic_expectations(), overrides="""
-BUG_OVERRIDE : failures/expected/text.html = FAIL
-BUG_OVERRIDE : failures/expected/text.html = IMAGE""", is_lint_mode=True)
+Bug(override) failures/expected/text.html [ Failure ]
+Bug(override) failures/expected/text.html [ ImageOnlyFailure ]""", is_lint_mode=True)
 
     def test_missing_file(self):
-        # This should log a non-fatal error.
-        self.parse_exp('BUG_TEST : missing_file.html = FAIL')
+        self.parse_exp('Bug(test) missing_file.html [ Failure ]')
         self.assertTrue(self._exp.has_warnings(), 1)
 
 
@@ -508,36 +477,36 @@ class PrecedenceTests(Base):
         # This tests handling precedence of specific lines over directories
         # and tests expectations covering entire directories.
         exp_str = """
-BUGX : failures/expected/text.html = FAIL
-BUGX WONTFIX : failures/expected = PASS
+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)
 
         exp_str = """
-BUGX WONTFIX : failures/expected = PASS
-BUGX : failures/expected/text.html = FAIL
+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)
 
     def test_ambiguous(self):
-        self.assert_bad_expectations("BUG_TEST RELEASE : passes/text.html = PASS\n"
-                                     "BUG_TEST WIN : passes/text.html = FAIL\n")
+        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):
-        self.assert_bad_expectations("BUG_TEST RELEASE : passes/text.html = PASS\n"
-                                     "BUG_TEST WIN RELEASE : passes/text.html = FAIL\n")
+        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 = FAIL\n"
-                                     "BUG_TEST RELEASE : passes/text.html = PASS\n")
+        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 = FAIL\n")
+        self.assert_bad_expectations("Bug(test) [ Win ] passes/text.html [ Pass ]\n"
+                                     "Bug(test) [ XP ] passes/text.html [ Failure ]\n")
 
 
 class RemoveConfigurationsTest(Base):
@@ -548,14 +517,15 @@ class RemoveConfigurationsTest(Base):
         test_port.test_isfile = lambda test: True
 
         test_config = test_port.test_configuration()
-        test_port.expectations_dict = lambda: {"expectations": """Bug(x) [ Linux Win Release ] failures/expected/foo.html [ Failure ]
+        test_port.expectations_dict = lambda **kwargs: {"expectations": """Bug(x) [ Linux Win Release ] failures/expected/foo.html [ Failure ]
 Bug(y) [ Win Mac Debug ] failures/expected/foo.html [ Crash ]
 """}
         expectations = TestExpectations(test_port, self.get_basic_tests())
+        expectations.parse_all_expectations()
 
         actual_expectations = expectations.remove_configuration_from_test('failures/expected/foo.html', test_config)
 
-        self.assertEqual("""Bug(x) [ Linux Vista Win7 Release ] failures/expected/foo.html [ Failure ]
+        self.assertEqual("""Bug(x) [ 7SP0 Linux Vista Release ] failures/expected/foo.html [ Failure ]
 Bug(y) [ Win Mac Debug ] failures/expected/foo.html [ Crash ]
 """, actual_expectations)
 
@@ -566,14 +536,15 @@ Bug(y) [ Win Mac Debug ] failures/expected/foo.html [ Crash ]
         test_port.test_isfile = lambda test: True
 
         test_config = test_port.test_configuration()
-        test_port.expectations_dict = lambda: {'expectations': """Bug(x) [ Win Release ] failures/expected/foo.html [ Failure ]
+        test_port.expectations_dict = lambda **kwargs: {'expectations': """Bug(x) [ Win Release ] failures/expected/foo.html [ Failure ]
 Bug(y) [ Win Debug ] failures/expected/foo.html [ Crash ]
 """}
         expectations = TestExpectations(test_port)
+        expectations.parse_all_expectations()
 
         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-vista', None).test_configuration())
-        actual_expectations = expectations.remove_configuration_from_test('failures/expected/foo.html', host.port_factory.get('test-win-win7', None).test_configuration())
+        actual_expectations = expectations.remove_configuration_from_test('failures/expected/foo.html', host.port_factory.get('test-win-7sp0', None).test_configuration())
 
         self.assertEqual("""Bug(y) [ Win Debug ] failures/expected/foo.html [ Crash ]
 """, actual_expectations)
@@ -598,75 +569,26 @@ class RebaseliningTest(Base):
                           '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)
 
-    def test_no_get_rebaselining_failures(self):
         self.parse_exp(self.get_basic_expectations())
         self.assertEqual(len(self._exp.get_rebaselining_failures()), 0)
 
 
-# FIXME: remove most of these tests when we no longer support the old syntax.
-
-class TestExpectationParserTests(unittest.TestCase):
-    def _tokenize(self, line):
-        return TestExpectationParser._tokenize_line('path', line, 0)
-
-    def test_tokenize_blank(self):
-        expectation = self._tokenize('')
-        self.assertEqual(expectation.comment, None)
-        self.assertEqual(len(expectation.warnings), 0)
-
-    def test_tokenize_extra_colon(self):
-        expectation = self._tokenize('FOO : : bar')
-        self.assertEqual(expectation.warnings, ['":" is not legal in the new TestExpectations syntax.'])
-
-    def test_tokenize_empty_comment(self):
-        expectation = self._tokenize('//')
-        self.assertEqual(expectation.comment, '')
-        self.assertEqual(len(expectation.warnings), 0)
-
-    def test_tokenize_comment(self):
-        expectation = self._tokenize('//Qux.')
-        self.assertEqual(expectation.comment, 'Qux.')
-        self.assertEqual(len(expectation.warnings), 0)
-
-    def test_tokenize_missing_equal(self):
-        expectation = self._tokenize('FOO : bar')
-        self.assertEqual(expectation.warnings, ['":" is not legal in the new TestExpectations syntax.'])
-
-    def test_tokenize_extra_equal(self):
-        expectation = self._tokenize('FOO : bar = BAZ = Qux.')
-        self.assertEqual(expectation.warnings, ['":" is not legal in the new TestExpectations syntax.'])
-
-    def test_tokenize_valid(self):
-        expectation = self._tokenize('FOO : bar = BAZ')
-        self.assertEqual(expectation.comment, None)
-        self.assertEqual(len(expectation.warnings), 0)
-
-    def test_tokenize_valid_with_comment(self):
-        expectation = self._tokenize('FOO : bar = BAZ //Qux.')
-        self.assertEqual(expectation.comment, 'Qux.')
-        self.assertEqual(str(expectation.modifiers), "['FOO']")
-        self.assertEqual(str(expectation.expectations), "['BAZ']")
-        self.assertEqual(len(expectation.warnings), 0)
-
-    def test_tokenize_valid_with_multiple_modifiers(self):
-        expectation = self._tokenize('FOO1 FOO2 : bar = BAZ //Qux.')
-        self.assertEqual(expectation.comment, 'Qux.')
-        self.assertEqual(str(expectation.modifiers), "['FOO1', 'FOO2']")
-        self.assertEqual(str(expectation.expectations), "['BAZ']")
-        self.assertEqual(len(expectation.warnings), 0)
-
-    def test_parse_empty_string(self):
-        host = MockHost()
-        test_port = host.port_factory.get('test-win-xp', None)
-        test_port.test_exists = lambda test: True
-        full_test_list = []
-        expectation_line = self._tokenize('')
-        parser = TestExpectationParser(test_port, full_test_list, allow_rebaseline_modifier=False)
-        parser._parse_line(expectation_line)
-        self.assertFalse(expectation_line.is_invalid())
-
-
 class TestExpectationSerializationTests(unittest.TestCase):
     def __init__(self, testFunc):
         host = MockHost()
@@ -815,11 +737,12 @@ class TestExpectationSerializationTests(unittest.TestCase):
         add_line(set([TestConfiguration('xp', 'x86', 'release')]), True)
         add_line(set([TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'debug')]), False)
         serialized = TestExpectations.list_to_string(lines, self._converter)
-        self.assertEquals(serialized, "Bug(x) [ XP Release ] Yay [ ImageOnlyFailure ]\nBug(x) [ XP ] Yay [ ImageOnlyFailure ]")
+        self.assertEqual(serialized, "Bug(x) [ XP Release ] Yay [ ImageOnlyFailure ]\nBug(x) [ XP ] Yay [ ImageOnlyFailure ]")
         serialized = TestExpectations.list_to_string(lines, self._converter, reconstitute_only_these=reconstitute_only_these)
-        self.assertEquals(serialized, "Bug(x) [ XP Release ] Yay [ ImageOnlyFailure ]\nNay")
+        self.assertEqual(serialized, "Bug(x) [ XP Release ] Yay [ ImageOnlyFailure ]\nNay")
 
-    def test_string_whitespace_stripping(self):
+    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 ]')
@@ -827,7 +750,3 @@ class TestExpectationSerializationTests(unittest.TestCase):
         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.')
-
-
-if __name__ == '__main__':
-    unittest.main()