Rename any builder with prefix 'WebKit Linux' to 'WebKit Linux Precise'

third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/update_test_expectations_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.
 
 from collections import OrderedDict
 
 from webkitpy.common.host_mock import MockHost
 from webkitpy.common.system.filesystem_mock import MockFileSystem
 from webkitpy.common.system.logtesting import LoggingTestCase
 from webkitpy.layout_tests.builder_list import BuilderList
@@ skipping 17 matching lines @@
 
 
 class FakeBotTestExpectationsFactory(object):
 
     def __init__(self):
         """The distinct results seen in at least one run of the test.
         E.g. if the bot results for mytest.html are:
             PASS PASS FAIL PASS TIMEOUT
         then _all_results_by_builder would be:
             {
-                'WebKit Linux' : {
+                'WebKit Linux Precise' : {

[Dirk Pranke, 2016/09/16 22:39:57]

Ideally we'd change these test cases to refer to a totally fake builder, so that
we didn't have to change the tests when we change real revisions.

[jeffcarp, 2016/09/21 19:21:50]

That sounds good but sounds like it should be in a separate CL. Should I revert
this file or leave it as-is so it matches the new WebKit Precise bots?

                     'mytest.html': ['FAIL', 'PASS', 'TIMEOUT']
                 }
             }
         """
         self._all_results_by_builder = {}
 
     def expectations_for_builder(self, builder):
         if builder not in self._all_results_by_builder:
             return None
 
@@ skipping 98 matching lines @@
             # Even though the results show all passing, none of the
             # expectations are flaky so we shouldn't remove any.
             Bug(test) test/a.html [ Pass ]
             Bug(test) test/b.html [ Timeout ]
             Bug(test) test/c.html [ Failure Timeout ]
             Bug(test) test/d.html [ Rebaseline ]
             Bug(test) test/e.html [ NeedsManualRebaseline ]
             Bug(test) test/f.html [ NeedsRebaseline ]"""
 
         self._define_builders({
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
         })
         self._port.all_build_types = ('release',)
         self._port.all_systems = (('precise', 'x86_64'),)
 
         self._parse_expectations(test_expectations_before)
         self._expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["PASS", "PASS"],
                 "test/b.html": ["PASS", "PASS"],
                 "test/c.html": ["PASS", "PASS"],
                 "test/d.html": ["PASS", "PASS"],
                 "test/e.html": ["PASS", "PASS"],
                 "test/f.html": ["PASS", "PASS"],
             }
         }
         updated_expectations = (
             self._flake_remover.get_updated_test_expectations())
         self._assert_expectations_match(
             updated_expectations, test_expectations_before)
 
     def test_dont_remove_skip(self):
         """Tests that lines with Skip are untouched.
 
         If a line is marked as Skip, it will eventually contain no results,
         which is indistinguishable from "All Passing" so don't remove since we
         don't know what the results actually are.
         """
         test_expectations_before = """
             # Skip expectations should never be removed.
             Bug(test) test/a.html [ Skip ]
             Bug(test) test/b.html [ Skip ]
             Bug(test) test/c.html [ Skip ]"""
 
         self._define_builders({
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
         })
         self._port.all_build_types = ('release',)
         self._port.all_systems = (('precise', 'x86_64'),)
 
         self._parse_expectations(test_expectations_before)
         self._expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["PASS", "PASS"],
                 "test/b.html": ["PASS", "IMAGE"],
             }
         }
         updated_expectations = (
             self._flake_remover.get_updated_test_expectations())
         self._assert_expectations_match(
             updated_expectations, test_expectations_before)
 
     def test_dont_remove_rebaselines(self):
         """Tests that lines with rebaseline expectations are untouched."""
         test_expectations_before = """
             # Even though the results show all passing, none of the
             # expectations are flaky so we shouldn't remove any.
             Bug(test) test/a.html [ Failure NeedsRebaseline Pass ]
             Bug(test) test/b.html [ Failure Pass Rebaseline ]
             Bug(test) test/c.html [ Failure NeedsManualRebaseline Pass ]"""
 
         self._define_builders({
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
         })
         self._port.all_build_types = ('release',)
         self._port.all_systems = (('precise', 'x86_64'),)
 
         self._parse_expectations(test_expectations_before)
         self._expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["PASS", "PASS"],
                 "test/b.html": ["PASS", "PASS"],
                 "test/c.html": ["PASS", "PASS"]
             }
         }
         updated_expectations = (
             self._flake_remover.get_updated_test_expectations())
         self._assert_expectations_match(
             updated_expectations, test_expectations_before)
 
     def test_all_failure_types(self):
         """Tests that all failure types are treated as failure."""
         test_expectations_before = (
             """Bug(test) test/a.html [ Failure Pass ]
             Bug(test) test/b.html [ Failure Pass ]
             Bug(test) test/c.html [ Failure Pass ]
             Bug(test) test/d.html [ Failure Pass ]
             # Remove these two since CRASH and TIMEOUT aren't considered
             # Failure.
             Bug(test) test/e.html [ Failure Pass ]
             Bug(test) test/f.html [ Failure Pass ]""")
 
         self._define_builders({
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
         })
         self._port.all_build_types = ('release',)
         self._port.all_systems = (('precise', 'x86_64'),)
 
         self._parse_expectations(test_expectations_before)
         self._expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["PASS", "IMAGE"],
                 "test/b.html": ["PASS", "TEXT"],
                 "test/c.html": ["PASS", "IMAGE+TEXT"],
                 "test/d.html": ["PASS", "AUDIO"],
                 "test/e.html": ["PASS", "CRASH"],
                 "test/f.html": ["PASS", "TIMEOUT"],
             }
         }
         updated_expectations = (
             self._flake_remover.get_updated_test_expectations())
@@ skipping 13 matching lines @@
         """
         test_expectations_before = (
             """# Remove this since it's passing all runs.
             Bug(test) test/a.html [ Failure Pass ]
             # Remove this since, although there's a failure, it's not a timeout.
             Bug(test) test/b.html [ Pass Timeout ]
             # Keep since we have both crashes and passes.
             Bug(test) test/c.html [ Crash Pass ]""")
 
         self._define_builders({
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
         })
         self._port.all_build_types = ('release',)
         self._port.all_systems = (('precise', 'x86_64'),)
 
         self._parse_expectations(test_expectations_before)
         self._expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
                 "test/b.html": ["PASS", "IMAGE", "PASS"],
                 "test/c.html": ["PASS", "CRASH", "PASS"],
             }
         }
         updated_expectations = (
             self._flake_remover.get_updated_test_expectations())
         self._assert_expectations_match(updated_expectations, (
             """# Keep since we have both crashes and passes.
             Bug(test) test/c.html [ Crash Pass ]"""))
 
     def test_all_failure_case(self):
         """Tests that results with all failures are not treated as non-flaky."""
         test_expectations_before = (
             """# Keep since it's all failures.
             Bug(test) test/a.html [ Failure Pass ]""")
 
         self._define_builders({
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
         })
         self._port.all_build_types = ('release',)
         self._port.all_systems = (('precise', 'x86_64'),)
 
         self._parse_expectations(test_expectations_before)
         self._expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["IMAGE", "IMAGE", "IMAGE"],
             }
         }
         updated_expectations = (
             self._flake_remover.get_updated_test_expectations())
         self._assert_expectations_match(updated_expectations, (
             """# Keep since it's all failures.
             Bug(test) test/a.html [ Failure Pass ]"""))
 
     def test_empty_test_expectations(self):
         """Running on an empty TestExpectations file outputs an empty file."""
         test_expectations_before = ""
 
         self._define_builders({
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
         })
         self._port.all_build_types = ('release',)
         self._port.all_systems = (('precise', 'x86_64'),)
 
         self._parse_expectations(test_expectations_before)
         self._expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
             }
         }
         updated_expectations = (
             self._flake_remover.get_updated_test_expectations())
         self._assert_expectations_match(updated_expectations, "")
 
     def test_basic_multiple_builders(self):
         """Tests basic functionality with multiple builders."""
         test_expectations_before = (
             """# Remove since it's passing on both builders.
             Bug(test) test/a.html [ Failure Pass ]
             # Keep since it's failing on the Mac builder.
             Bug(test) test/b.html [ Failure Pass ]
             # Keep since it's failing on the Linux builder.
             Bug(test) test/c.html [ Failure Pass ]""")
 
         self._define_builders({
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
             "WebKit Mac10.10": {
                 "port_name": "mac-mac10.10",
                 "specifiers": ['Mac10.10', 'Release']
             },
         })
 
         self._port.all_build_types = ('release',)
         self._port.all_systems = (('mac10.10', 'x86'),
                                   ('precise', 'x86_64'))
 
         self._parse_expectations(test_expectations_before)
         self._expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
                 "test/b.html": ["PASS", "PASS", "PASS"],
                 "test/c.html": ["AUDIO", "AUDIO", "AUDIO"],
             },
             'WebKit Mac10.10': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
                 "test/b.html": ["PASS", "PASS", "IMAGE"],
                 "test/c.html": ["PASS", "PASS", "PASS"],
             },
         }
@@ skipping 15 matching lines @@
             # Remove since it's passing on both Linux and Windows builders.
             Bug(test) [ Linux Win ] test/c.html [ Failure Pass ]
             # Remove since it's passing on Mac results
             Bug(test) [ Mac ] test/d.html [ Failure Pass ]""")
 
         self._define_builders({
             "WebKit Win7": {
                 "port_name": "win-win7",
                 "specifiers": ['Win7', 'Release']
             },
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
             "WebKit Mac10.10": {
                 "port_name": "mac-mac10.10",
                 "specifiers": ['Mac10.10', 'Release']
             },
         })
         self._port.all_build_types = ('release',)
         self._port.all_systems = (('mac10.10', 'x86'),
                                   ('win7', 'x86'),
                                   ('precise', 'x86_64'))
 
         self._parse_expectations(test_expectations_before)
         self._expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
                 "test/b.html": ["PASS", "PASS", "PASS"],
                 "test/c.html": ["PASS", "PASS", "PASS"],
                 "test/d.html": ["IMAGE", "PASS", "PASS"],
             },
             'WebKit Mac10.10': {
                 "test/a.html": ["PASS", "PASS", "IMAGE"],
                 "test/b.html": ["PASS", "IMAGE", "PASS"],
                 "test/c.html": ["PASS", "IMAGE", "PASS"],
                 "test/d.html": ["PASS", "PASS", "PASS"],
@@ skipping 29 matching lines @@
 
         self._define_builders({
             "WebKit Win7": {
                 "port_name": "win-win7",
                 "specifiers": ['Win7', 'Release']
             },
             "WebKit Win7 (dbg)": {
                 "port_name": "win-win7",
                 "specifiers": ['Win7', 'Debug']
             },
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
-            "WebKit Linux (dbg)": {
+            "WebKit Linux Precise (dbg)": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Debug']
             },
         })
         self._port.all_build_types = ('release', 'debug')
         self._port.all_systems = (('win7', 'x86'),
                                   ('precise', 'x86_64'))
 
         self._parse_expectations(test_expectations_before)
         self._expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
                 "test/b.html": ["PASS", "IMAGE", "PASS"],
                 "test/c.html": ["PASS", "IMAGE", "PASS"],
                 "test/d.html": ["PASS", "PASS", "PASS"],
                 "test/e.html": ["PASS", "PASS", "PASS"],
             },
-            'WebKit Linux (dbg)': {
+            'WebKit Linux Precise (dbg)': {
                 "test/a.html": ["PASS", "IMAGE", "PASS"],
                 "test/b.html": ["PASS", "PASS", "PASS"],
                 "test/c.html": ["PASS", "PASS", "PASS"],
                 "test/d.html": ["IMAGE", "PASS", "PASS"],
                 "test/e.html": ["PASS", "PASS", "PASS"],
             },
             'WebKit Win7 (dbg)': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
                 "test/b.html": ["PASS", "PASS", "PASS"],
                 "test/c.html": ["PASS", "PASS", "PASS"],
@@ skipping 51 matching lines @@
 
             # Comment F - Keep since only b is removed
             Bug(test) test/b.html [ Failure Pass ]
             Bug(test) test/c.html [ Failure Pass ]
 
             # Comment G - Should be removed since both d and e will be removed.
             Bug(test) test/d.html [ Failure Pass ]
             Bug(test) test/e.html [ Failure Pass ]"""
 
         self._define_builders({
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
         })
         self._port.all_build_types = ('release',)
         self._port.all_systems = (('precise', 'x86_64'),)
 
         self._parse_expectations(test_expectations_before)
         self._expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
                 "test/b.html": ["PASS", "PASS", "PASS"],
                 "test/c.html": ["PASS", "IMAGE", "PASS"],
                 "test/d.html": ["PASS", "PASS", "PASS"],
                 "test/e.html": ["PASS", "PASS", "PASS"],
             }
         }
         updated_expectations = (
             self._flake_remover.get_updated_test_expectations())
         self._assert_expectations_match(updated_expectations, (
@@ skipping 19 matching lines @@
             Bug(test) test/a.html [ Skip ]
             # This line shouldn't be removed either since it's not flaky.
             Bug(test) test/b.html [ Failure Timeout ]
             # The lines below should be removed since they're flaky but all runs
             # are passing.
             Bug(test) test/c.html [ Failure Pass ]
             Bug(test) test/d.html [ Pass Timeout ]
             Bug(test) test/e.html [ Crash Pass ]"""
 
         self._define_builders({
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
         })
         self._port.all_build_types = ('release',)
         self._port.all_systems = (('precise', 'x86_64'),)
 
         self._parse_expectations(test_expectations_before)
         self._expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
             }
         }
         updated_expectations = (
             self._flake_remover.get_updated_test_expectations())
         self._assert_expectations_match(updated_expectations, """
             # A Skip expectation probably won't have any results but we
             # shouldn't consider those passing so this line should remain.
             Bug(test) test/a.html [ Skip ]
             # This line shouldn't be removed either since it's not flaky.
             Bug(test) test/b.html [ Failure Timeout ]""")
@@ skipping 10 matching lines @@
             Bug(test) [ Linux ] test/b.html [ Failure Pass ]
             # This one shouldn't emit an error since it's not flaky, we don't
             # have to check the builder results.
             Bug(test) test/c.html [ Failure ]
             Bug(test) test/d.html [ Failure Pass ]
             # This one shouldn't emit an error since it will only match the
             # existing Linux Release configuration
             Bug(test) [ Linux Release ] test/e.html [ Failure Pass ]"""
 
         self._define_builders({
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
         })
 
         # Three errors should be emitted:
         # (1) There's no Windows builders so a.html will emit an error on the
         #     first missing one.
         # (2) There's no Linux debug builder so b.html will emit an error.
         # (3) c.html is missing will match both the Windows and Linux dbg
         # builders which are missing so it'll emit an error on the first one.
         self._port.all_build_types = ('release', 'debug')
         self._port.all_systems = (('win7', 'x86'),
                                   ('precise', 'x86_64'))
 
         self._parse_expectations(test_expectations_before)
         self._expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
                 "test/b.html": ["PASS", "PASS", "PASS"],
                 "test/c.html": ["PASS", "IMAGE", "PASS"],
                 "test/d.html": ["PASS", "PASS", "PASS"],
                 "test/e.html": ["PASS", "IMAGE", "PASS"],
             }
         }
 
         updated_expectations = (
             self._flake_remover.get_updated_test_expectations())
@@ skipping 18 matching lines @@
         test_expectations_before = """
             Bug(test) [ Linux ] test/a.html [ Failure Pass ]
             # This line won't emit an error since the Linux Release results
             # exist.
             Bug(test) [ Linux Release ] test/b.html [ Failure Pass ]
             Bug(test) [ Release ] test/c.html [ Failure Pass ]
             # This line is not flaky so we shouldn't even check the results.
             Bug(test) [ Linux ] test/d.html [ Failure ]"""
 
         self._define_builders({
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
-            "WebKit Linux (dbg)": {
+            "WebKit Linux Precise (dbg)": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Debug']
             },
             "WebKit Win7": {
                 "port_name": "win-win7",
                 "specifiers": ['Win7', 'Release']
             },
             "WebKit Win7 (dbg)": {
                 "port_name": "win-win7",
                 "specifiers": ['Win7', 'Debug']
             },
         })
 
         # Two warnings and two errors should be emitted:
         # (1) A warning since the results don't contain anything for the Linux
         #     (dbg) builder
         # (2) A warning since the results don't contain anything for the Win
         #     release builder
         # (3) The first line needs and is missing results for Linux (dbg).
         # (4) The third line needs and is missing results for Win Release.
         self._port.all_build_types = ('release', 'debug')
         self._port.all_systems = (('win7', 'x86'),
                                   ('precise', 'x86_64'))
 
         self._parse_expectations(test_expectations_before)
         self._expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
                 "test/b.html": ["PASS", "IMAGE", "PASS"],
                 "test/c.html": ["PASS", "PASS", "PASS"],
                 "test/d.html": ["PASS", "PASS", "PASS"],
             },
             'WebKit Win7 (dbg)': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
                 "test/b.html": ["PASS", "PASS", "PASS"],
                 "test/c.html": ["PASS", "PASS", "PASS"],
                 "test/d.html": ["PASS", "PASS", "PASS"],
             },
         }
 
         updated_expectations = (
             self._flake_remover.get_updated_test_expectations())
         self.assertLog([
-            'WARNING: Downloaded results are missing results for builder "WebKit Linux (dbg)"\n',
+            'WARNING: Downloaded results are missing results for builder "WebKit Linux Precise (dbg)"\n',
             'WARNING: Downloaded results are missing results for builder "WebKit Win7"\n',
-            'ERROR: Failed to find results for builder "WebKit Linux (dbg)"\n',
+            'ERROR: Failed to find results for builder "WebKit Linux Precise (dbg)"\n',
             'ERROR: Failed to find results for builder "WebKit Win7"\n',
         ])
 
         # Also make sure we didn't remove any lines if some builders were
         # missing.
         self._assert_expectations_match(
             updated_expectations, test_expectations_before)
 
     def test_harness_updates_file(self):
         """Tests that the call harness updates the TestExpectations file."""
 
         self._define_builders({
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
-            "WebKit Linux (dbg)": {
+            "WebKit Linux Precise (dbg)": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Debug']
             },
         })
 
         # Setup the mock host and port.
         host = MockHost()
         host.port_factory = FakePortFactory(host)
         host.port_factory._all_build_types = ('release', 'debug')
         host.port_factory._all_systems = (('precise', 'x86_64'),)
@@ skipping 12 matching lines @@
             Bug(test) [ Linux ] test/d.html [ Failure ]"""
         files = {
             test_expectation_path: test_expectations
         }
         host.filesystem = MockFileSystem(files)
         self._write_tests_into_filesystem(host.filesystem)
 
         # Write out the fake builder bot results.
         expectation_factory = FakeBotTestExpectationsFactory()
         expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
                 "test/b.html": ["PASS", "IMAGE", "PASS"],
                 "test/c.html": ["PASS", "PASS", "PASS"],
                 "test/d.html": ["PASS", "PASS", "PASS"],
             },
-            'WebKit Linux (dbg)': {
+            'WebKit Linux Precise (dbg)': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
                 "test/b.html": ["PASS", "PASS", "PASS"],
                 "test/c.html": ["PASS", "PASS", "PASS"],
                 "test/d.html": ["IMAGE", "PASS", "PASS"],
             },
         }
 
         main(host, expectation_factory, [])
 
         self.assertEqual(host.filesystem.files[test_expectation_path], (
@@ skipping 34 matching lines @@
         ])
         self.assertFalse(host.filesystem.isfile(test_expectation_path))
 
     def test_harness_remove_all(self):
         """Tests that removing all expectations doesn't delete the file.
 
         Make sure we're prepared for the day when we exterminated flakes.
         """
 
         self._define_builders({
-            "WebKit Linux": {
+            "WebKit Linux Precise": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Release']
             },
-            "WebKit Linux (dbg)": {
+            "WebKit Linux Precise (dbg)": {
                 "port_name": "linux-precise",
                 "specifiers": ['Precise', 'Debug']
             },
         })
 
         # Setup the mock host and port.
         host = MockHost()
         host.port_factory = FakePortFactory(host)
         host.port_factory._all_build_types = ('release', 'debug')
         host.port_factory._all_systems = (('precise', 'x86_64'),)
 
         # Write out a fake TestExpectations file.
         test_expectation_path = (
             host.port_factory.get().path_to_generic_test_expectations_file())
         test_expectations = """
             # Remove since passing on both bots.
             Bug(test) [ Linux ] test/a.html [ Failure Pass ]"""
 
         files = {
             test_expectation_path: test_expectations
         }
         host.filesystem = MockFileSystem(files)
         self._write_tests_into_filesystem(host.filesystem)
 
         # Write out the fake builder bot results.
         expectation_factory = FakeBotTestExpectationsFactory()
         expectation_factory._all_results_by_builder = {
-            'WebKit Linux': {
+            'WebKit Linux Precise': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
             },
-            'WebKit Linux (dbg)': {
+            'WebKit Linux Precise (dbg)': {
                 "test/a.html": ["PASS", "PASS", "PASS"],
             },
         }
 
         main(host, expectation_factory, [])
 
         self.assertTrue(host.filesystem.isfile(test_expectation_path))
         self.assertEqual(host.filesystem.files[test_expectation_path], '')