Remove get_test function in test_expectations_unittest.py

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 33 matching lines @@
 class Base(unittest.TestCase):
     # Note that all of these tests are written assuming the configuration
     # being tested is Windows XP, Release build.
 
     def __init__(self, testFunc):
         host = MockHost()
         self._port = host.port_factory.get('test-win-xp', None)
         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/needsrebaseline.html'),
-                self.get_test('failures/expected/needsmanualrebaseline.html'),
-                self.get_test('failures/expected/missing_text.html'),
-                self.get_test('failures/expected/image.html'),
-                self.get_test('failures/expected/timeout.html'),
-                self.get_test('passes/text.html')]
+        return ['failures/expected/text.html',
+                'failures/expected/image_checksum.html',
+                'failures/expected/crash.html',
+                'failures/expected/needsrebaseline.html',
+                'failures/expected/needsmanualrebaseline.html',
+                'failures/expected/missing_text.html',
+                'failures/expected/image.html',
+                'failures/expected/timeout.html',
+                'passes/text.html']
 
 
     def get_basic_expectations(self):
         return """
 Bug(test) failures/expected/text.html [ Failure ]
 Bug(test) failures/expected/crash.html [ WontFix ]
 Bug(test) failures/expected/needsrebaseline.html [ NeedsRebaseline ]
 Bug(test) failures/expected/needsmanualrebaseline.html [ NeedsManualRebaseline ]
 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 ]
 """
 
     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))
+        self.assertEqual(self._exp.get_expectations(test), set(results))
 
     def assert_exp(self, test, 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_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]))
+        self.assertEqual(self._exp.get_expectations('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)
         self.assertEqual(TestExpectations.result_was_expected(SKIP, set([LEAK]), test_needs_rebaselining=False), True)
 
@@ skipping 24 matching lines @@
         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 = 'Bug(x) failures/expected [ WontFix ]'
         self.parse_exp(exp_str)
         test_name = 'failures/expected/unknown-test.html'
-        unknown_test = self.get_test(test_name)
+        unknown_test = test_name
         self.assertRaises(KeyError, self._exp.get_expectations,
                           unknown_test)
         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')
+        self.assertEqual(self._exp.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)
 
     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)
-        self.assertEqual(s,
-            set([self.get_test('failures/expected/crash.html'),
-                 self.get_test('failures/expected/image_checksum.html')]))
+        self.assertEqual(s, set(['failures/expected/crash.html', 'failures/expected/image_checksum.html']))
 
     def test_needs_rebaseline_reftest(self):
         try:
             filesystem = self._port.host.filesystem
             filesystem.write_text_file(filesystem.join(self._port.layout_tests_dir(), 'failures/expected/needsrebaseline.html'), 'content')
             filesystem.write_text_file(filesystem.join(self._port.layout_tests_dir(), 'failures/expected/needsrebaseline-expected.html'), 'content')
             filesystem.write_text_file(filesystem.join(self._port.layout_tests_dir(), 'failures/expected/needsmanualrebaseline.html'), 'content')
             filesystem.write_text_file(filesystem.join(self._port.layout_tests_dir(), 'failures/expected/needsmanualrebaseline-expected.html'), 'content')
             self.parse_exp("""Bug(user) failures/expected/needsrebaseline.html [ NeedsRebaseline ]
 Bug(user) failures/expected/needsmanualrebaseline.html [ NeedsManualRebaseline ]""", is_lint_mode=True)
             self.assertFalse(True, "ParseError wasn't raised")
         except ParseError, e:
             warnings = """expectations:1 A reftest cannot be marked as NeedsRebaseline/NeedsManualRebaseline failures/expected/needsrebaseline.html
 expectations:2 A reftest cannot be marked as NeedsRebaseline/NeedsManualRebaseline failures/expected/needsmanualrebaseline.html"""
             self.assertEqual(str(e), warnings)
 
     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'),
+            'disabled-test.html-disabled',
             self.parse_exp("Bug(user) [ FOO ] failures/expected/text.html [ Failure ]\n"
                 "Bug(user) non-existent-test.html [ Failure ]\n"
                 "Bug(user) disabled-test.html-disabled [ ImageOnlyFailure ]", is_lint_mode=True)
             self.assertFalse(True, "ParseError wasn't raised")
         except ParseError, e:
             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):
@@ skipping 29 matching lines @@
         self.assert_exp_list('failures/expected/image.html', [CRASH])
 
     def test_overrides__duplicate(self):
         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, sanitizer_is_enabled=False)
+                test, result, pixel_tests_enabled, sanitizer_is_enabled=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('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_sanitizer_flag(self):
         def match(test, result):
             return self._exp.matches_an_expected_result(
-                self.get_test(test), result, pixel_tests_are_enabled=False, sanitizer_is_enabled=True)
+                test, result, pixel_tests_are_enabled=False, sanitizer_is_enabled=True)
 
         self.parse_exp("""
 Bug(test) failures/expected/crash.html [ Crash ]
 Bug(test) failures/expected/image.html [ ImageOnlyFailure ]
 Bug(test) failures/expected/text.html [ Failure ]
 Bug(test) failures/expected/timeout.html [ Timeout ]
 """)
         self.assertTrue(match('failures/expected/crash.html', CRASH))
         self.assertTrue(match('failures/expected/image.html', PASS))
         self.assertTrue(match('failures/expected/text.html', PASS))
@@ skipping 10 matching lines @@
     def test_bot_test_expectations(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(expectations.get_expectations(self.get_test(test_name2)), set([SLOW]))
+        self.assertEqual(expectations.get_expectations(test_name1), set([IMAGE]))
+        self.assertEqual(expectations.get_expectations(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([CRASH, SLOW]))
+        self.assertEqual(expectations.get_expectations(test_name1), set([PASS, IMAGE, TIMEOUT]))
+        self.assertEqual(expectations.get_expectations(test_name2), set([CRASH, SLOW]))
 
 class SkippedTests(Base):
     def check(self, expectations, overrides, skips, lint=False, expected_results=[WONTFIX, SKIP, FAIL]):
         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
@@ skipping 583 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.')