Rename test port baseline directories in unit tests.

third_party/WebKit/Tools/Scripts/webkitpy/tool/commands/rebaseline_unittest.py

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import optparse
 import unittest
 
 from webkitpy.common.net.buildbot import Build
 from webkitpy.common.net.layouttestresults import LayoutTestResults
 from webkitpy.common.system.executive_mock import MockExecutive, MockExecutive2
@@ skipping 105 matching lines @@
             'verbose': False,
         }
         options_dict.update(kwargs)
         return optparse.Values(options_dict)
 
     def test_copy_baseline_mac(self):
         port = self.tool.port_factory.get('test-mac-mac10.11')
         self._write(
             port.host.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-mac-mac10.11/failures/expected/image-expected.txt'),
+                'platform/mac-baselines/failures/expected/image-expected.txt'),
             'original mac10.11 result')
         self.assertFalse(self.tool.filesystem.exists(
             self.tool.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-mac-mac10.10/failures/expected/image-expected.txt')))
+                'platform/mac10.10-baselines/failures/expected/image-expected.txt')))
 
         self.command.execute(self.options(builder='MOCK Mac10.11', test='failures/expected/image.html'), [], self.tool)
 
         # The Mac 10.11 baseline is copied over to the Mac 10.10 directory,
         # because Mac10.10 is the "immediate predecessor" in the fallback tree.
         # That means that normally for Mac10.10 if there's no Mac10.10-specific
         # baseline, then we fall back to the Mac10.11 baseline.
         # The idea is, if in the next step we download new baselines for Mac10.11
         # but not Mac10.10, then mac10.10 will still have the correct baseline.
         self.assertEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-mac-mac10.11/failures/expected/image-expected.txt')),
+                'platform/mac-baselines/failures/expected/image-expected.txt')),
             'original mac10.11 result')
         self.assertEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-mac-mac10.10/failures/expected/image-expected.txt')),
+                'platform/mac10.10-baselines/failures/expected/image-expected.txt')),
             'original mac10.11 result')
 
     def test_copying_overwritten_baseline_to_multiple_locations(self):
         self.tool.executive = MockExecutive2()
 
-    def test_copy_baseline_win7_to_linux_trusty(self):
+    def test_copy_baseline_win_to_linux(self):
         port = self.tool.port_factory.get('test-win-win7')
         self._write(
             self.tool.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-win-win7/failures/expected/image-expected.txt'),
+                'platform/win7-baselines/failures/expected/image-expected.txt'),
             'original win7 result')
         self.assertFalse(self.tool.filesystem.exists(
             self.tool.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-linux-trusty/failures/expected/image-expected.txt')))
+                'platform/linux-baselines/failures/expected/image-expected.txt')))
 
         self.command.execute(self.options(builder='MOCK Win7', test='failures/expected/image.html'), [], self.tool)
 
         # The Mac Win7 baseline is copied over to the Linux Trusty directory,
         # because Linux Trusty is the baseline fallback "immediate predecessor" of Win7.
         self.assertEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-win-win7/failures/expected/image-expected.txt')),
+                'platform/win7-baselines/failures/expected/image-expected.txt')),
             'original win7 result')
         self.assertEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-linux-trusty/failures/expected/image-expected.txt')),
+                'platform/linux-baselines/failures/expected/image-expected.txt')),
             'original win7 result')
 
     def test_no_copy_existing_baseline(self):
         port = self.tool.port_factory.get('test-win-win7')
         self._write(
             self.tool.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-win-win7/failures/expected/image-expected.txt'),
+                'platform/win7-baselines/failures/expected/image-expected.txt'),
             'original win7 result')
         self._write(
             self.tool.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-linux-trusty/failures/expected/image-expected.txt'),
+                'platform/linux-baselines/failures/expected/image-expected.txt'),
             'original linux trusty result')
 
         self.command.execute(self.options(builder='MOCK Win7', test='failures/expected/image.html'), [], self.tool)
 
         # Since a baseline existed already for Linux Trusty, the Win7 baseline is not copied over.
         self.assertEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-win-win7/failures/expected/image-expected.txt')),
+                'platform/win7-baselines/failures/expected/image-expected.txt')),
             'original win7 result')
         self.assertEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-linux-trusty/failures/expected/image-expected.txt')),
+                'platform/linux-baselines/failures/expected/image-expected.txt')),
             'original linux trusty result')
 
     def test_no_copy_skipped_test(self):
         port = self.tool.port_factory.get('test-win-win7')
         self._write(
             self.tool.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-win-win7/failures/expected/image-expected.txt'),
+                'platform/win7-baselines/failures/expected/image-expected.txt'),
             'original win7 result')
         self._write(
             port.path_to_generic_test_expectations_file(),
             ("[ Win ] failures/expected/image.html [ Failure ]\n"
              "[ Linux ] failures/expected/image.html [ Skip ]\n"))
 
         self.command.execute(self.options(builder='MOCK Win7', test='failures/expected/image.html'), [], self.tool)
 
         # The Win7 baseline is not copied over to the Linux Trusty directory
         # because the test is skipped on linux.
         self.assertFalse(
             self.tool.filesystem.exists(self.tool.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-linux-trusty/failures/expected/image-expected.txt')))
+                'platform/linux-baselines/failures/expected/image-expected.txt')))
 
 
 class TestRebaselineTest(BaseTestCase):
     command_constructor = RebaselineTest  # AKA webkit-patch rebaseline-test-internal
 
     def setUp(self):
         super(TestRebaselineTest, self).setUp()
 
     @staticmethod
     def options(**kwargs):
         return optparse.Values(dict({
             'builder': "MOCK Mac10.11",
             'test': "userscripts/another-test.html",
             'suffixes': "txt",
             'results_directory': None,
             'build_number': None
         }, **kwargs))
 
     def test_baseline_directory(self):
         command = self.command
         self.assertMultiLineEqual(command._baseline_directory("MOCK Mac10.11"),
-                                  "/test.checkout/LayoutTests/platform/test-mac-mac10.11")
+                                  "/test.checkout/LayoutTests/platform/mac-baselines")
         self.assertMultiLineEqual(command._baseline_directory("MOCK Mac10.10"),
-                                  "/test.checkout/LayoutTests/platform/test-mac-mac10.10")
+                                  "/test.checkout/LayoutTests/platform/mac10.10-baselines")
         self.assertMultiLineEqual(command._baseline_directory("MOCK Trusty"),
-                                  "/test.checkout/LayoutTests/platform/test-linux-trusty")
+                                  "/test.checkout/LayoutTests/platform/linux-baselines")
         self.assertMultiLineEqual(command._baseline_directory("MOCK Precise"),
-                                  "/test.checkout/LayoutTests/platform/test-linux-precise")
+                                  "/test.checkout/LayoutTests/platform/linux-precise-baselines")
 
     def test_rebaseline_updates_expectations_file_noop(self):
         self._zero_out_test_expectations()
         self._write(
             self.mac_expectations_path,
             ("Bug(B) [ Mac Linux Win7 Debug ] fast/dom/Window/window-postmessage-clone-really-deep-array.html [ Pass ]\n"
              "Bug(A) [ Debug ] : fast/css/large-list-of-rules-crash.html [ Failure ]\n"))
         self._write("fast/dom/Window/window-postmessage-clone-really-deep-array.html", "Dummy test contents")
         self._write("fast/css/large-list-of-rules-crash.html", "Dummy test contents")
         self._write("userscripts/another-test.html", "Dummy test contents")
@@ skipping 31 matching lines @@
             expected_logs="Cannot rebaseline image result for reftest: userscripts/another-test.html\n")
         self.assertDictEqual(self.command.expectation_line_changes.to_dict(), {'remove-lines': []})
 
     def test_rebaseline_test_internal_with_port_that_lacks_buildbot(self):
         self.tool.executive = MockExecutive2()
 
         port = self.tool.port_factory.get('test-win-win7')
         self._write(
             port.host.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-win-win10/failures/expected/image-expected.txt'),
+                'platform/win-baselines/failures/expected/image-expected.txt'),
             'original win10 result')
 
         oc = OutputCapture()
         try:
             options = optparse.Values({
                 'optimize': True,
                 'builder': "MOCK Win10",
                 'suffixes': "txt",
                 'verbose': True,
                 'test': "failures/expected/image.html",
                 'results_directory': None,
                 'build_number': None
             })
             oc.capture_output()
             self.command.execute(options, [], self.tool)
         finally:
             out, _, _ = oc.restore_output()
 
         self.assertMultiLineEqual(
             self._read(self.tool.filesystem.join(
                 port.layout_tests_dir(),
-                'platform/test-win-win10/failures/expected/image-expected.txt')),
+                'platform/win-baselines/failures/expected/image-expected.txt')),
             'MOCK Web result, convert 404 to None=True')
         self.assertFalse(self.tool.filesystem.exists(self.tool.filesystem.join(
-            port.layout_tests_dir(), 'platform/test-win-win7/failures/expected/image-expected.txt')))
+            port.layout_tests_dir(), 'platform/win7-baselines/failures/expected/image-expected.txt')))
         self.assertMultiLineEqual(
             out, '{"remove-lines": [{"test": "failures/expected/image.html", "builder": "MOCK Win10"}]}\n')
 
 
 class TestAbstractParallelRebaselineCommand(BaseTestCase):
     command_constructor = AbstractParallelRebaselineCommand
 
     def test_builders_to_fetch_from(self):
         builders_to_fetch = self.command._builders_to_fetch_from(
             ["MOCK Win10", "MOCK Win7 (dbg)(1)", "MOCK Win7 (dbg)(2)", "MOCK Win7"])
         self.assertEqual(builders_to_fetch, ["MOCK Win7", "MOCK Win10"])
 
     def test_all_baseline_paths(self):
         test_prefix_list = {
             'passes/text.html': {
                 Build('MOCK Win7'): ('txt', 'png'),
                 Build('MOCK Win10'): ('txt',),
             }
         }
         # pylint: disable=protected-access
         baseline_paths = self.command._all_baseline_paths(test_prefix_list)
         self.assertEqual(baseline_paths, [
             '/test.checkout/LayoutTests/passes/text-expected.png',
             '/test.checkout/LayoutTests/passes/text-expected.txt',
-            '/test.checkout/LayoutTests/platform/test-win-win10/passes/text-expected.txt',
-            '/test.checkout/LayoutTests/platform/test-win-win7/passes/text-expected.png',
-            '/test.checkout/LayoutTests/platform/test-win-win7/passes/text-expected.txt',
+            '/test.checkout/LayoutTests/platform/win-baselines/passes/text-expected.txt',
+            '/test.checkout/LayoutTests/platform/win7-baselines/passes/text-expected.png',
+            '/test.checkout/LayoutTests/platform/win7-baselines/passes/text-expected.txt',
         ])
 
     def test_remove_all_pass_testharness_baselines(self):
         self.tool.filesystem.write_text_file(
             '/test.checkout/LayoutTests/passes/text-expected.txt',
             ('This is a testharness.js-based test.\n'
              'PASS: foo\n'
              'Harness: the test ran to completion.\n'))
         test_prefix_list = {
             'passes/text.html': {
@@ skipping 556 matching lines @@
         for cmd_line, cwd in commands:
             out = self.run_command(cmd_line, cwd=cwd)
             if 'rebaseline-test-internal' in cmd_line:
                 out = '{"remove-lines": [{"test": "%s", "builder": "%s"}]}\n' % (cmd_line[8], cmd_line[6])
             command_outputs.append([0, out, ''])
 
         new_calls = self.calls[num_previous_calls:]
         self.calls = self.calls[:num_previous_calls]
         self.calls.append(new_calls)
         return command_outputs