<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[284775] trunk</title>
</head>
<body>

<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt;  }
#msg dl a { font-weight: bold}
#msg dl a:link    { color:#fc3; }
#msg dl a:active  { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff  {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/284775">284775</a></dd>
<dt>Author</dt> <dd>gsnedders@apple.com</dd>
<dt>Date</dt> <dd>2021-10-25 04:07:20 -0700 (Mon, 25 Oct 2021)</dd>
</dl>

<h3>Log Message</h3>
<pre>[Python] rename assertEquals/assertNotEquals
https://bugs.webkit.org/show_bug.cgi?id=232214

Reviewed by Alexey Proskuryakov.

This is assert(Not)?Equals -> assert(\1)Equal

Python 3.11 (currently CPython main branch) removes the deprecated
aliases assertEquals/assertNotEquals. These have long been deprecated,
and the modern names exist all the way back to Python 2.7, hence there's
no reason not to switch.

Source/WebKit:

* Scripts/webkit/messages_unittest.py:
(GeneratedFileContentsTest.assertGeneratedFileContentsEqual):
* Scripts/webkit/model_unittest.py:
* Scripts/webkit/parser_unittest.py:
(ParsingTest.check_message):
(ParsingTest.test_receiver):

Tools:

* Scripts/libraries/webkitcorepy/webkitcorepy/tests/task_pool_unittest.py:
(TaskPoolUnittest.test_multiple):
* Scripts/webkitpy/common/attribute_saver_unittest.py:
(AttributeSaverTest.test_class):
(AttributeSaverTest.test_normal_default):
(AttributeSaverTest.test_normal_value):
(AttributeSaverTest.test_normal_value_on_exception):
(AttributeSaverTest.test_normal_value_on_normal_exit):
(AttributeSaverTest.test_normal_value_with_finally_on_exception):
(AttributeSaverTest.test_normal_value_with_finally_on_normal_exit):
(AttributeSaverTest.test_normal_value_with_else_on_exception):
(AttributeSaverTest.test_normal_value_with_else_on_normal_exit):
* Scripts/webkitpy/common/checkout/scm/stub_repository_unittest.py:
(StubRepositoryTest.test_find_checkout_root):
* Scripts/webkitpy/layout_tests/models/test_configuration_unittest.py:
(TestConfigurationTest.test_eq):
* Scripts/webkitpy/layout_tests/models/test_expectations_unittest.py:
(MiscTests.test_parse_warnings_are_logged_if_not_in_lint_mode):
* Scripts/webkitpy/layout_tests/models/test_run_results_unittest.py:
(SummarizedResultsTest.test_svn_revision_exists):
(SummarizedResultsTest.test_svn_revision):
(SummarizedResultsTest.test_svn_revision_git):
* Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py:
(RunTest.test_tests_options):
* Scripts/webkitpy/layout_tests/servers/http_server_unittest.py:
(TestHttpServer.test_win32_start_and_stop):
* Scripts/webkitpy/port/driver_unittest.py:
* Scripts/webkitpy/port/gtk_unittest.py:
(GtkPortTest.test_gtk4_expectations_binary_only):
(GtkPortTest.test_gtk3_expectations_binary_only):
(GtkPortTest.test_gtk_expectations_both_binaries):
* Scripts/webkitpy/style/checkers/test_expectations_unittest.py:
(TestExpectationsTestCase.assert_lines_lint):
* Scripts/webkitpy/tool/steps/preparechangelog_unittest.py:
* Scripts/webkitpy/w3c/test_converter_unittest.py:
(verify_test_harness_paths):
* Scripts/webkitpy/w3c/test_exporter_unittest.py:
(TestExporterTest.test_export):
(TestExporterTest.test_export_with_specific_branch):
* Scripts/webkitpy/w3c/test_importer_unittest.py:
* Scripts/webkitpy/w3c/test_parser_unittest.py:
* Scripts/webkitpy/w3c/wpt_runner_unittest.py:
(WPTRunnerTest.MockSpawnWPT.__call__):
(WPTRunnerTest.test_prepare_wpt_checkout):
(WPTRunnerTest.test_prepare_wpt_checkout_specified_path):
* Scripts/webkitpy/xcode/device_type_unittest.py:
(DeviceTypeTest.test_iphone_initialization):
(DeviceTypeTest.test_ipad_initialization):
(DeviceTypeTest.test_generic_ios_device):
(DeviceTypeTest.test_watch_initialization):
(DeviceTypeTest.test_tv_initialization):
* Scripts/webkitpy/xcode/sdk_unittest.py:
(SDKTest.test_iphoneos):
(SDKTest.test_iphonesim):
(SDKTest.test_macos):
(SDKTest.test_appletvos):
(SDKTest.test_appletvsim):
(SDKTest.test_watchos):
(SDKTest.test_watchsimulator):
(SDKTest.test_prodos):
* Scripts/webkitpy/xcode/simulated_device_unittest.py:</pre>

<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebKitChangeLog">trunk/Source/WebKit/ChangeLog</a></li>
<li><a href="#trunkSourceWebKitScriptswebkitmessages_unittestpy">trunk/Source/WebKit/Scripts/webkit/messages_unittest.py</a></li>
<li><a href="#trunkSourceWebKitScriptswebkitmodel_unittestpy">trunk/Source/WebKit/Scripts/webkit/model_unittest.py</a></li>
<li><a href="#trunkSourceWebKitScriptswebkitparser_unittestpy">trunk/Source/WebKit/Scripts/webkit/parser_unittest.py</a></li>
<li><a href="#trunkToolsChangeLog">trunk/Tools/ChangeLog</a></li>
<li><a href="#trunkToolsScriptslibrarieswebkitcorepywebkitcorepyteststask_pool_unittestpy">trunk/Tools/Scripts/libraries/webkitcorepy/webkitcorepy/tests/task_pool_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpycommonattribute_saver_unittestpy">trunk/Tools/Scripts/webkitpy/common/attribute_saver_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpycommoncheckoutscmstub_repository_unittestpy">trunk/Tools/Scripts/webkitpy/common/checkout/scm/stub_repository_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testsmodelstest_configuration_unittestpy">trunk/Tools/Scripts/webkitpy/layout_tests/models/test_configuration_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testsmodelstest_expectations_unittestpy">trunk/Tools/Scripts/webkitpy/layout_tests/models/test_expectations_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testsmodelstest_run_results_unittestpy">trunk/Tools/Scripts/webkitpy/layout_tests/models/test_run_results_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testsrun_webkit_tests_integrationtestpy">trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpylayout_testsservershttp_server_unittestpy">trunk/Tools/Scripts/webkitpy/layout_tests/servers/http_server_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpyportdriver_unittestpy">trunk/Tools/Scripts/webkitpy/port/driver_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpyportgtk_unittestpy">trunk/Tools/Scripts/webkitpy/port/gtk_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpystylecheckerstest_expectations_unittestpy">trunk/Tools/Scripts/webkitpy/style/checkers/test_expectations_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpytoolstepspreparechangelog_unittestpy">trunk/Tools/Scripts/webkitpy/tool/steps/preparechangelog_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpyw3ctest_converter_unittestpy">trunk/Tools/Scripts/webkitpy/w3c/test_converter_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpyw3ctest_exporter_unittestpy">trunk/Tools/Scripts/webkitpy/w3c/test_exporter_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpyw3ctest_importer_unittestpy">trunk/Tools/Scripts/webkitpy/w3c/test_importer_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpyw3ctest_parser_unittestpy">trunk/Tools/Scripts/webkitpy/w3c/test_parser_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpyw3cwpt_runner_unittestpy">trunk/Tools/Scripts/webkitpy/w3c/wpt_runner_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpyxcodedevice_type_unittestpy">trunk/Tools/Scripts/webkitpy/xcode/device_type_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpyxcodesdk_unittestpy">trunk/Tools/Scripts/webkitpy/xcode/sdk_unittest.py</a></li>
<li><a href="#trunkToolsScriptswebkitpyxcodesimulated_device_unittestpy">trunk/Tools/Scripts/webkitpy/xcode/simulated_device_unittest.py</a></li>
</ul>

</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebKitChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit/ChangeLog (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit/ChangeLog    2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Source/WebKit/ChangeLog       2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -1,3 +1,24 @@
</span><ins>+2021-10-25  Sam Sneddon  <gsnedders@apple.com>
+
+        [Python] rename assertEquals/assertNotEquals
+        https://bugs.webkit.org/show_bug.cgi?id=232214
+
+        Reviewed by Alexey Proskuryakov.
+
+        This is assert(Not)?Equals -> assert(\1)Equal
+
+        Python 3.11 (currently CPython main branch) removes the deprecated
+        aliases assertEquals/assertNotEquals. These have long been deprecated,
+        and the modern names exist all the way back to Python 2.7, hence there's
+        no reason not to switch.
+
+        * Scripts/webkit/messages_unittest.py:
+        (GeneratedFileContentsTest.assertGeneratedFileContentsEqual):
+        * Scripts/webkit/model_unittest.py:
+        * Scripts/webkit/parser_unittest.py:
+        (ParsingTest.check_message):
+        (ParsingTest.test_receiver):
+
</ins><span class="cx"> 2021-10-24  Wenson Hsieh  <wenson_hsieh@apple.com>
</span><span class="cx"> 
</span><span class="cx">         RemoteRenderingBackend should not send IPC in the middle of destruction
</span></span></pre></div>
<a id="trunkSourceWebKitScriptswebkitmessages_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit/Scripts/webkit/messages_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit/Scripts/webkit/messages_unittest.py  2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Source/WebKit/Scripts/webkit/messages_unittest.py     2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -84,9 +84,9 @@
</span><span class="cx">             expected_line_list = expected_file_contents.splitlines(False)
</span><span class="cx"> 
</span><span class="cx">             for index, actual_line in enumerate(actual_line_list):
</span><del>-                self.assertEquals(actual_line, expected_line_list[index])
</del><ins>+                self.assertEqual(actual_line, expected_line_list[index])
</ins><span class="cx"> 
</span><del>-            self.assertEquals(len(actual_line_list), len(expected_line_list))
</del><ins>+            self.assertEqual(len(actual_line_list), len(expected_line_list))
</ins><span class="cx">         except Exception:
</span><span class="cx">             sys.stderr.write('In expected file %s\n' % expected_file_name)
</span><span class="cx">             raise
</span></span></pre></div>
<a id="trunkSourceWebKitScriptswebkitmodel_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit/Scripts/webkit/model_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit/Scripts/webkit/model_unittest.py     2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Source/WebKit/Scripts/webkit/model_unittest.py        2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -46,8 +46,8 @@
</span><span class="cx">     LoadURL(String url)
</span><span class="cx"> }"""
</span><span class="cx">         receiver = parser.parse(StringIO(contents))
</span><del>-        self.assertEquals(receiver.name, 'WebPage')
-        self.assertEquals(receiver.messages[0].name, 'LoadURL')
</del><ins>+        self.assertEqual(receiver.name, 'WebPage')
+        self.assertEqual(receiver.messages[0].name, 'LoadURL')
</ins><span class="cx"> 
</span><span class="cx">         other_contents = """
</span><span class="cx">     messages -> WebPage {
</span><span class="lines">@@ -56,11 +56,11 @@
</span><span class="cx">     }"""
</span><span class="cx"> 
</span><span class="cx">         other_receiver = parser.parse(StringIO(other_contents))
</span><del>-        self.assertEquals(other_receiver.name, 'WebPage')
-        self.assertEquals(other_receiver.messages[0].name, 'LoadURL')
-        self.assertEquals(other_receiver.messages[1].name, 'LoadURL2')
</del><ins>+        self.assertEqual(other_receiver.name, 'WebPage')
+        self.assertEqual(other_receiver.messages[0].name, 'LoadURL')
+        self.assertEqual(other_receiver.messages[1].name, 'LoadURL2')
</ins><span class="cx">         errors = model.check_global_model_inputs([receiver, other_receiver])
</span><del>-        self.assertEquals(len(errors), 1)
</del><ins>+        self.assertEqual(len(errors), 1)
</ins><span class="cx">         self.assertTrue("Duplicate" in errors[0])
</span><span class="cx"> 
</span><span class="cx">     def test_mismatch_message_attribute_sync(self):
</span><span class="lines">@@ -74,10 +74,10 @@
</span><span class="cx"> #endif
</span><span class="cx"> }"""
</span><span class="cx">         receiver = parser.parse(StringIO(contents))
</span><del>-        self.assertEquals(receiver.name, 'WebPage')
-        self.assertEquals(receiver.messages[0].name, 'LoadURL')
</del><ins>+        self.assertEqual(receiver.name, 'WebPage')
+        self.assertEqual(receiver.messages[0].name, 'LoadURL')
</ins><span class="cx">         errors = model.check_global_model_inputs([receiver])
</span><del>-        self.assertEquals(len(errors), 1)
</del><ins>+        self.assertEqual(len(errors), 1)
</ins><span class="cx">         self.assertTrue("attribute mismatch" in errors[0])
</span><span class="cx"> 
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkSourceWebKitScriptswebkitparser_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebKit/Scripts/webkit/parser_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebKit/Scripts/webkit/parser_unittest.py    2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Source/WebKit/Scripts/webkit/parser_unittest.py       2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -316,32 +316,32 @@
</span><span class="cx">         self.receivers = [parse_receiver(expected_model['name']) for expected_model in _parsing_test_cases]
</span><span class="cx"> 
</span><span class="cx">     def check_message(self, message, expected_message):
</span><del>-        self.assertEquals(message.name, expected_message['name'])
-        self.assertEquals(len(message.parameters), len(expected_message['parameters']))
</del><ins>+        self.assertEqual(message.name, expected_message['name'])
+        self.assertEqual(len(message.parameters), len(expected_message['parameters']))
</ins><span class="cx">         for index, parameter in enumerate(message.parameters):
</span><span class="cx">             expected_parameter = expected_message['parameters'][index]
</span><del>-            self.assertEquals(parameter.type, expected_parameter[0])
-            self.assertEquals(parameter.name, expected_parameter[1])
</del><ins>+            self.assertEqual(parameter.type, expected_parameter[0])
+            self.assertEqual(parameter.name, expected_parameter[1])
</ins><span class="cx">             if len(expected_parameter) > 2:
</span><del>-                self.assertEquals(parameter.attributes, frozenset(expected_parameter[2]))
</del><ins>+                self.assertEqual(parameter.attributes, frozenset(expected_parameter[2]))
</ins><span class="cx">                 for attribute in expected_parameter[2]:
</span><span class="cx">                     self.assertTrue(parameter.has_attribute(attribute))
</span><span class="cx">             else:
</span><del>-                self.assertEquals(parameter.attributes, frozenset())
</del><ins>+                self.assertEqual(parameter.attributes, frozenset())
</ins><span class="cx">         if message.reply_parameters is not None:
</span><span class="cx">             for index, parameter in enumerate(message.reply_parameters):
</span><del>-                self.assertEquals(parameter.type, expected_message['reply_parameters'][index][0])
-                self.assertEquals(parameter.name, expected_message['reply_parameters'][index][1])
</del><ins>+                self.assertEqual(parameter.type, expected_message['reply_parameters'][index][0])
+                self.assertEqual(parameter.name, expected_message['reply_parameters'][index][1])
</ins><span class="cx">         else:
</span><span class="cx">             self.assertFalse('reply_parameters' in expected_message)
</span><del>-        self.assertEquals(message.condition, expected_message['conditions'])
</del><ins>+        self.assertEqual(message.condition, expected_message['conditions'])
</ins><span class="cx"> 
</span><span class="cx">     def test_receiver(self):
</span><span class="cx">         """Receiver should be parsed as expected"""
</span><span class="cx">         for receiver, expected_model in zip(self.receivers, _parsing_test_cases):
</span><del>-            self.assertEquals(receiver.name, expected_model['name'])
-            self.assertEquals(receiver.condition, expected_model['conditions'])
-            self.assertEquals(len(receiver.messages), len(expected_model['messages']))
</del><ins>+            self.assertEqual(receiver.name, expected_model['name'])
+            self.assertEqual(receiver.condition, expected_model['conditions'])
+            self.assertEqual(len(receiver.messages), len(expected_model['messages']))
</ins><span class="cx">             for index, message in enumerate(receiver.messages):
</span><span class="cx">                 self.check_message(message, expected_model['messages'][index])
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkToolsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Tools/ChangeLog (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/ChangeLog    2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/ChangeLog       2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -1,3 +1,79 @@
</span><ins>+2021-10-25  Sam Sneddon  <gsnedders@apple.com>
+
+        [Python] rename assertEquals/assertNotEquals
+        https://bugs.webkit.org/show_bug.cgi?id=232214
+
+        Reviewed by Alexey Proskuryakov.
+
+        This is assert(Not)?Equals -> assert(\1)Equal
+
+        Python 3.11 (currently CPython main branch) removes the deprecated
+        aliases assertEquals/assertNotEquals. These have long been deprecated,
+        and the modern names exist all the way back to Python 2.7, hence there's
+        no reason not to switch.
+
+        * Scripts/libraries/webkitcorepy/webkitcorepy/tests/task_pool_unittest.py:
+        (TaskPoolUnittest.test_multiple):
+        * Scripts/webkitpy/common/attribute_saver_unittest.py:
+        (AttributeSaverTest.test_class):
+        (AttributeSaverTest.test_normal_default):
+        (AttributeSaverTest.test_normal_value):
+        (AttributeSaverTest.test_normal_value_on_exception):
+        (AttributeSaverTest.test_normal_value_on_normal_exit):
+        (AttributeSaverTest.test_normal_value_with_finally_on_exception):
+        (AttributeSaverTest.test_normal_value_with_finally_on_normal_exit):
+        (AttributeSaverTest.test_normal_value_with_else_on_exception):
+        (AttributeSaverTest.test_normal_value_with_else_on_normal_exit):
+        * Scripts/webkitpy/common/checkout/scm/stub_repository_unittest.py:
+        (StubRepositoryTest.test_find_checkout_root):
+        * Scripts/webkitpy/layout_tests/models/test_configuration_unittest.py:
+        (TestConfigurationTest.test_eq):
+        * Scripts/webkitpy/layout_tests/models/test_expectations_unittest.py:
+        (MiscTests.test_parse_warnings_are_logged_if_not_in_lint_mode):
+        * Scripts/webkitpy/layout_tests/models/test_run_results_unittest.py:
+        (SummarizedResultsTest.test_svn_revision_exists):
+        (SummarizedResultsTest.test_svn_revision):
+        (SummarizedResultsTest.test_svn_revision_git):
+        * Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py:
+        (RunTest.test_tests_options):
+        * Scripts/webkitpy/layout_tests/servers/http_server_unittest.py:
+        (TestHttpServer.test_win32_start_and_stop):
+        * Scripts/webkitpy/port/driver_unittest.py:
+        * Scripts/webkitpy/port/gtk_unittest.py:
+        (GtkPortTest.test_gtk4_expectations_binary_only):
+        (GtkPortTest.test_gtk3_expectations_binary_only):
+        (GtkPortTest.test_gtk_expectations_both_binaries):
+        * Scripts/webkitpy/style/checkers/test_expectations_unittest.py:
+        (TestExpectationsTestCase.assert_lines_lint):
+        * Scripts/webkitpy/tool/steps/preparechangelog_unittest.py:
+        * Scripts/webkitpy/w3c/test_converter_unittest.py:
+        (verify_test_harness_paths):
+        * Scripts/webkitpy/w3c/test_exporter_unittest.py:
+        (TestExporterTest.test_export):
+        (TestExporterTest.test_export_with_specific_branch):
+        * Scripts/webkitpy/w3c/test_importer_unittest.py:
+        * Scripts/webkitpy/w3c/test_parser_unittest.py:
+        * Scripts/webkitpy/w3c/wpt_runner_unittest.py:
+        (WPTRunnerTest.MockSpawnWPT.__call__):
+        (WPTRunnerTest.test_prepare_wpt_checkout):
+        (WPTRunnerTest.test_prepare_wpt_checkout_specified_path):
+        * Scripts/webkitpy/xcode/device_type_unittest.py:
+        (DeviceTypeTest.test_iphone_initialization):
+        (DeviceTypeTest.test_ipad_initialization):
+        (DeviceTypeTest.test_generic_ios_device):
+        (DeviceTypeTest.test_watch_initialization):
+        (DeviceTypeTest.test_tv_initialization):
+        * Scripts/webkitpy/xcode/sdk_unittest.py:
+        (SDKTest.test_iphoneos):
+        (SDKTest.test_iphonesim):
+        (SDKTest.test_macos):
+        (SDKTest.test_appletvos):
+        (SDKTest.test_appletvsim):
+        (SDKTest.test_watchos):
+        (SDKTest.test_watchsimulator):
+        (SDKTest.test_prodos):
+        * Scripts/webkitpy/xcode/simulated_device_unittest.py:
+
</ins><span class="cx"> 2021-10-24  Arcady Goldmints-Orlov  <agoldmints@igalia.com>
</span><span class="cx"> 
</span><span class="cx">         REGRESSION(r282686) [GTK] Tests are flaky due to spurious "MainFrameView: mouseEnteredContentArea" messages in the log
</span></span></pre></div>
<a id="trunkToolsScriptslibrarieswebkitcorepywebkitcorepyteststask_pool_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/libraries/webkitcorepy/webkitcorepy/tests/task_pool_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/libraries/webkitcorepy/webkitcorepy/tests/task_pool_unittest.py      2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/libraries/webkitcorepy/webkitcorepy/tests/task_pool_unittest.py 2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -110,7 +110,7 @@
</span><span class="cx">                     pool.wait()
</span><span class="cx"> 
</span><span class="cx">             lines = captured.stdout.getvalue().splitlines()
</span><del>-            self.assertEquals(sorted(lines), ['action({})'.format(character) for character in self.alphabet])
</del><ins>+            self.assertEqual(sorted(lines), ['action({})'.format(character) for character in self.alphabet])
</ins><span class="cx">             self.assertEqual(
</span><span class="cx">                 sorted(captured.webkitcorepy.log.getvalue().splitlines()),
</span><span class="cx">                 sorted(['worker/{} starting'.format(number) for number in range(4)] + ['worker/{} stopping'.format(number) for number in range(4)]),
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpycommonattribute_saver_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/common/attribute_saver_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/common/attribute_saver_unittest.py  2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/common/attribute_saver_unittest.py     2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -38,90 +38,90 @@
</span><span class="cx"> 
</span><span class="cx">     def test_class(self):
</span><span class="cx">         obj = self.SimpleTestClass()
</span><del>-        self.assertEquals(obj.value, 0)
</del><ins>+        self.assertEqual(obj.value, 0)
</ins><span class="cx"> 
</span><span class="cx">     def test_normal_default(self):
</span><span class="cx">         obj = self.SimpleTestClass()
</span><del>-        self.assertEquals(obj.value, 0)
</del><ins>+        self.assertEqual(obj.value, 0)
</ins><span class="cx">         with AttributeSaver(obj, "value"):
</span><del>-            self.assertEquals(obj.value, None)
-        self.assertEquals(obj.value, 0)
</del><ins>+            self.assertEqual(obj.value, None)
+        self.assertEqual(obj.value, 0)
</ins><span class="cx"> 
</span><span class="cx">     def test_normal_value(self):
</span><span class="cx">         obj = self.SimpleTestClass()
</span><del>-        self.assertEquals(obj.value, 0)
</del><ins>+        self.assertEqual(obj.value, 0)
</ins><span class="cx">         with AttributeSaver(obj, "value", 1):
</span><del>-            self.assertEquals(obj.value, 1)
-        self.assertEquals(obj.value, 0)
</del><ins>+            self.assertEqual(obj.value, 1)
+        self.assertEqual(obj.value, 0)
</ins><span class="cx"> 
</span><span class="cx">     def test_normal_value_on_exception(self):
</span><span class="cx">         with self.assertRaises(RuntimeError):
</span><span class="cx">             obj = self.SimpleTestClass()
</span><del>-            self.assertEquals(obj.value, 0)
</del><ins>+            self.assertEqual(obj.value, 0)
</ins><span class="cx">             try:
</span><span class="cx">                 with AttributeSaver(obj, "value", 1):
</span><del>-                    self.assertEquals(obj.value, 1)
</del><ins>+                    self.assertEqual(obj.value, 1)
</ins><span class="cx">                     raise RuntimeError()
</span><span class="cx">             except:
</span><del>-                self.assertEquals(obj.value, 0)
</del><ins>+                self.assertEqual(obj.value, 0)
</ins><span class="cx">                 raise
</span><del>-            self.assertEquals(obj.value, 0)
</del><ins>+            self.assertEqual(obj.value, 0)
</ins><span class="cx"> 
</span><span class="cx">     def test_normal_value_on_normal_exit(self):
</span><span class="cx">         obj = self.SimpleTestClass()
</span><del>-        self.assertEquals(obj.value, 0)
</del><ins>+        self.assertEqual(obj.value, 0)
</ins><span class="cx">         try:
</span><span class="cx">             with AttributeSaver(obj, "value", 1):
</span><del>-                self.assertEquals(obj.value, 1)
</del><ins>+                self.assertEqual(obj.value, 1)
</ins><span class="cx">         except:
</span><del>-            self.assertEquals(obj.value, 0)
</del><ins>+            self.assertEqual(obj.value, 0)
</ins><span class="cx">             raise
</span><del>-        self.assertEquals(obj.value, 0)
</del><ins>+        self.assertEqual(obj.value, 0)
</ins><span class="cx"> 
</span><span class="cx">     def test_normal_value_with_finally_on_exception(self):
</span><span class="cx">         with self.assertRaises(RuntimeError):
</span><span class="cx">             obj = self.SimpleTestClass()
</span><del>-            self.assertEquals(obj.value, 0)
</del><ins>+            self.assertEqual(obj.value, 0)
</ins><span class="cx">             try:
</span><span class="cx">                 with AttributeSaver(obj, "value", 1):
</span><del>-                    self.assertEquals(obj.value, 1)
</del><ins>+                    self.assertEqual(obj.value, 1)
</ins><span class="cx">                     raise RuntimeError()
</span><span class="cx">             finally:
</span><del>-                self.assertEquals(obj.value, 0)
-            self.assertEquals(obj.value, 0)
</del><ins>+                self.assertEqual(obj.value, 0)
+            self.assertEqual(obj.value, 0)
</ins><span class="cx"> 
</span><span class="cx">     def test_normal_value_with_finally_on_normal_exit(self):
</span><span class="cx">         obj = self.SimpleTestClass()
</span><del>-        self.assertEquals(obj.value, 0)
</del><ins>+        self.assertEqual(obj.value, 0)
</ins><span class="cx">         try:
</span><span class="cx">             with AttributeSaver(obj, "value", 1):
</span><del>-                self.assertEquals(obj.value, 1)
</del><ins>+                self.assertEqual(obj.value, 1)
</ins><span class="cx">         finally:
</span><del>-            self.assertEquals(obj.value, 0)
-        self.assertEquals(obj.value, 0)
</del><ins>+            self.assertEqual(obj.value, 0)
+        self.assertEqual(obj.value, 0)
</ins><span class="cx"> 
</span><span class="cx">     def test_normal_value_with_else_on_exception(self):
</span><span class="cx">         with self.assertRaises(RuntimeError):
</span><span class="cx">             obj = self.SimpleTestClass()
</span><del>-            self.assertEquals(obj.value, 0)
</del><ins>+            self.assertEqual(obj.value, 0)
</ins><span class="cx">             try:
</span><span class="cx">                 with AttributeSaver(obj, "value", 1):
</span><del>-                    self.assertEquals(obj.value, 1)
</del><ins>+                    self.assertEqual(obj.value, 1)
</ins><span class="cx">                     raise RuntimeError()
</span><span class="cx">             except IOError:
</span><span class="cx">                 self.assertFalse(True)
</span><span class="cx">             else:
</span><del>-                self.assertEquals(obj.value, 0)
-            self.assertEquals(obj.value, 0)
</del><ins>+                self.assertEqual(obj.value, 0)
+            self.assertEqual(obj.value, 0)
</ins><span class="cx"> 
</span><span class="cx">     def test_normal_value_with_else_on_normal_exit(self):
</span><span class="cx">         obj = self.SimpleTestClass()
</span><del>-        self.assertEquals(obj.value, 0)
</del><ins>+        self.assertEqual(obj.value, 0)
</ins><span class="cx">         try:
</span><span class="cx">             with AttributeSaver(obj, "value", 1):
</span><del>-                self.assertEquals(obj.value, 1)
</del><ins>+                self.assertEqual(obj.value, 1)
</ins><span class="cx">         except IOError:
</span><span class="cx">             self.assertFalse(True)
</span><span class="cx">         else:
</span><del>-            self.assertEquals(obj.value, 0)
-        self.assertEquals(obj.value, 0)
</del><ins>+            self.assertEqual(obj.value, 0)
+        self.assertEqual(obj.value, 0)
</ins></span></pre></div>
<a id="trunkToolsScriptswebkitpycommoncheckoutscmstub_repository_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/common/checkout/scm/stub_repository_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/common/checkout/scm/stub_repository_unittest.py     2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/common/checkout/scm/stub_repository_unittest.py        2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -67,7 +67,7 @@
</span><span class="cx">     def test_find_checkout_root(self):
</span><span class="cx">         host = StubRepositoryTest.mock_host_for_stub_repository()
</span><span class="cx">         repository = StubRepository(cwd=host.filesystem.getcwd(), filesystem=host.filesystem, executive=host.executive)
</span><del>-        self.assertEquals(repository.find_checkout_root(path=host.filesystem.join('TestDirectory', 'TestDirectory2', 'TestDirectory3')), host.filesystem.join(host.filesystem.getcwd(), 'TestDirectory', 'TestDirectory2'))
</del><ins>+        self.assertEqual(repository.find_checkout_root(path=host.filesystem.join('TestDirectory', 'TestDirectory2', 'TestDirectory3')), host.filesystem.join(host.filesystem.getcwd(), 'TestDirectory', 'TestDirectory2'))
</ins><span class="cx"> 
</span><span class="cx">     def test_find_checkout_root_failure(self):
</span><span class="cx">         host = StubRepositoryTest.mock_host_for_stub_repository()
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testsmodelstest_configuration_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/models/test_configuration_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/models/test_configuration_unittest.py  2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/models/test_configuration_unittest.py     2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -86,7 +86,7 @@
</span><span class="cx"> 
</span><span class="cx">     def test_eq(self):
</span><span class="cx">         self.assertEqual(TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'release'))
</span><del>-        self.assertNotEquals(TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'debug'))
</del><ins>+        self.assertNotEqual(TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'debug'))
</ins><span class="cx"> 
</span><span class="cx">     def test_values(self):
</span><span class="cx">         config = TestConfiguration('xp', 'x86', 'release')
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testsmodelstest_expectations_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/models/test_expectations_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/models/test_expectations_unittest.py   2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/models/test_expectations_unittest.py      2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -199,7 +199,7 @@
</span><span class="cx">     def test_parse_warnings_are_logged_if_not_in_lint_mode(self):
</span><span class="cx">         with OutputCapture() as captured:
</span><span class="cx">             self.parse_exp('-- this should be a syntax error', is_lint_mode=False)
</span><del>-        self.assertNotEquals(captured.root.log.getvalue(), '')
</del><ins>+        self.assertNotEqual(captured.root.log.getvalue(), '')
</ins><span class="cx"> 
</span><span class="cx">     def test_error_on_different_platform(self):
</span><span class="cx">         # parse_exp uses a Windows port. Assert errors on Mac show up in lint mode.
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testsmodelstest_run_results_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/models/test_run_results_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/models/test_run_results_unittest.py    2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/models/test_run_results_unittest.py       2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -158,19 +158,19 @@
</span><span class="cx">     def test_svn_revision_exists(self):
</span><span class="cx">         self.port._options.builder_name = 'dummy builder'
</span><span class="cx">         summary = summarized_results(self.port, expected=False, passing=False, flaky=False)
</span><del>-        self.assertNotEquals(summary['revision'], '')
</del><ins>+        self.assertNotEqual(summary['revision'], '')
</ins><span class="cx"> 
</span><span class="cx">     def test_svn_revision(self):
</span><span class="cx">         with mocks.local.Svn(path='/'), mocks.local.Git():
</span><span class="cx">             self.port._options.builder_name = 'dummy builder'
</span><span class="cx">             summary = summarized_results(self.port, expected=False, passing=False, flaky=False)
</span><del>-            self.assertEquals(summary['revision'], '6')
</del><ins>+            self.assertEqual(summary['revision'], '6')
</ins><span class="cx"> 
</span><span class="cx">     def test_svn_revision_git(self):
</span><span class="cx">         with mocks.local.Svn(), mocks.local.Git(path='/', git_svn=True), OutputCapture():
</span><span class="cx">             self.port._options.builder_name = 'dummy builder'
</span><span class="cx">             summary = summarized_results(self.port, expected=False, passing=False, flaky=False)
</span><del>-            self.assertEquals(summary['revision'], '9')
</del><ins>+            self.assertEqual(summary['revision'], '9')
</ins><span class="cx"> 
</span><span class="cx">     def test_summarized_results_wontfix(self):
</span><span class="cx">         self.port._options.builder_name = 'dummy builder'
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testsrun_webkit_tests_integrationtestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py    2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py       2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -822,9 +822,9 @@
</span><span class="cx">         details, _, _ = logging_run(['failures/expected/timeout.html',
</span><span class="cx">                                      'failures/unexpected/timeout.html'],
</span><span class="cx">                                     host=host)
</span><del>-        self.assertEquals(details.initial_results.slow_tests,
</del><ins>+        self.assertEqual(details.initial_results.slow_tests,
</ins><span class="cx">                           {'failures/unexpected/timeout.html'})
</span><del>-        self.assertEquals(details.retry_results.slow_tests,
</del><ins>+        self.assertEqual(details.retry_results.slow_tests,
</ins><span class="cx">                           {'failures/unexpected/timeout.html'})
</span><span class="cx"> 
</span><span class="cx">     def serial_test_no_http_and_force(self):
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpylayout_testsservershttp_server_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/layout_tests/servers/http_server_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/layout_tests/servers/http_server_unittest.py        2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/layout_tests/servers/http_server_unittest.py   2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -88,7 +88,7 @@
</span><span class="cx">         server._is_server_running_on_all_ports = lambda: True
</span><span class="cx"> 
</span><span class="cx">         server.start()
</span><del>-        self.assertNotEquals(host.executive.calls, [])
</del><ins>+        self.assertNotEqual(host.executive.calls, [])
</ins><span class="cx"> 
</span><span class="cx">         def wait_for_action(action):
</span><span class="cx">             if action():
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpyportdriver_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/port/driver_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/port/driver_unittest.py     2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/port/driver_unittest.py        2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -298,7 +298,7 @@
</span><span class="cx">         driver = Driver(port, 0, pixel_tests=True)
</span><span class="cx">         driver.start(True, [])
</span><span class="cx">         last_tmpdir = port._filesystem.last_tmpdir
</span><del>-        self.assertNotEquals(last_tmpdir, None)
</del><ins>+        self.assertNotEqual(last_tmpdir, None)
</ins><span class="cx">         driver.stop()
</span><span class="cx">         self.assertFalse(port._filesystem.isdir(last_tmpdir))
</span><span class="cx"> 
</span><span class="lines">@@ -401,7 +401,7 @@
</span><span class="cx">             driver = Driver(port, None, pixel_tests=False)
</span><span class="cx">             driver.start(True, [])
</span><span class="cx">             environ_driver = driver._setup_environ_for_test()
</span><del>-            self.assertNotEquals(environ_driver['HOME'], environ_user['HOME'])
</del><ins>+            self.assertNotEqual(environ_driver['HOME'], environ_user['HOME'])
</ins><span class="cx">             self.assertIn(str(driver._driver_tempdir), environ_driver['HOME'])
</span><span class="cx">             self.assertNotIn(str(driver._driver_tempdir), environ_user['HOME'])
</span><span class="cx">             self.assertTrue(port._filesystem.isdir(environ_driver['HOME']))
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpyportgtk_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/port/gtk_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/port/gtk_unittest.py        2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/port/gtk_unittest.py   2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -101,7 +101,7 @@
</span><span class="cx">             "/mock-build/lib/libwebkit2gtk-5.0.so": ""
</span><span class="cx">         })
</span><span class="cx">         with OutputCapture() as _:
</span><del>-            self.assertEquals(port.expectations_files(),
</del><ins>+            self.assertEqual(port.expectations_files(),
</ins><span class="cx">                               ['/mock-checkout/LayoutTests/TestExpectations',
</span><span class="cx">                                '/mock-checkout/LayoutTests/platform/wk2/TestExpectations',
</span><span class="cx">                                '/mock-checkout/LayoutTests/platform/glib/TestExpectations',
</span><span class="lines">@@ -115,7 +115,7 @@
</span><span class="cx">         })
</span><span class="cx"> 
</span><span class="cx">         with OutputCapture() as _:
</span><del>-            self.assertEquals(port.expectations_files(),
</del><ins>+            self.assertEqual(port.expectations_files(),
</ins><span class="cx">                               ['/mock-checkout/LayoutTests/TestExpectations',
</span><span class="cx">                                '/mock-checkout/LayoutTests/platform/wk2/TestExpectations',
</span><span class="cx">                                '/mock-checkout/LayoutTests/platform/glib/TestExpectations',
</span><span class="lines">@@ -129,9 +129,9 @@
</span><span class="cx">         })
</span><span class="cx"> 
</span><span class="cx">         with OutputCapture() as captured:
</span><del>-            self.assertEquals(port.expectations_files(),
</del><ins>+            self.assertEqual(port.expectations_files(),
</ins><span class="cx">                               ['/mock-checkout/LayoutTests/TestExpectations',
</span><span class="cx">                                '/mock-checkout/LayoutTests/platform/wk2/TestExpectations',
</span><span class="cx">                                '/mock-checkout/LayoutTests/platform/glib/TestExpectations',
</span><span class="cx">                                '/mock-checkout/LayoutTests/platform/gtk/TestExpectations'])
</span><del>-            self.assertEquals(captured.root.log.getvalue(), 'Multiple WebKit2GTK libraries found. Skipping GTK4 detection.\n')
</del><ins>+            self.assertEqual(captured.root.log.getvalue(), 'Multiple WebKit2GTK libraries found. Skipping GTK4 detection.\n')
</ins></span></pre></div>
<a id="trunkToolsScriptswebkitpystylecheckerstest_expectations_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/style/checkers/test_expectations_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/style/checkers/test_expectations_unittest.py        2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/style/checkers/test_expectations_unittest.py   2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -95,7 +95,7 @@
</span><span class="cx">         elif expected_output:
</span><span class="cx">             self.assertEqual(expected_output, self._error_collector.get_errors())
</span><span class="cx">         else:
</span><del>-            self.assertNotEquals('', self._error_collector.get_errors())
</del><ins>+            self.assertNotEqual('', self._error_collector.get_errors())
</ins><span class="cx"> 
</span><span class="cx">         # Note that a patch might change a line that introduces errors elsewhere, but we
</span><span class="cx">         # don't want to lint the whole file (it can unfairly punish patches for pre-existing errors).
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpytoolstepspreparechangelog_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/tool/steps/preparechangelog_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/tool/steps/preparechangelog_unittest.py     2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/tool/steps/preparechangelog_unittest.py        2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -115,7 +115,7 @@
</span><span class="cx">             step._tool.filesystem.write_text_file(path, start_file)
</span><span class="cx">             step._resolve_existing_entry(path)
</span><span class="cx">             actual_output = step._tool.filesystem.read_text_file(path)
</span><del>-            self.assertEquals(actual_output, end_file)
</del><ins>+            self.assertEqual(actual_output, end_file)
</ins><span class="cx"> 
</span><span class="cx">     def test_ensure_bug_url(self):
</span><span class="cx">         step = PrepareChangeLog(MockTool(), MockOptions())
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpyw3ctest_converter_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/w3c/test_converter_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/w3c/test_converter_unittest.py      2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/w3c/test_converter_unittest.py 2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -368,13 +368,13 @@
</span><span class="cx"> 
</span><span class="cx">         # Verify the original paths are gone, and the new paths are present.
</span><span class="cx">         orig_path_pattern = re.compile('\"/resources/testharness')
</span><del>-        self.assertEquals(len(converted.findAll(src=orig_path_pattern)), 0, 'testharness src path was not converted')
-        self.assertEquals(len(converted.findAll(href=orig_path_pattern)), 0, 'testharness href path was not converted')
</del><ins>+        self.assertEqual(len(converted.findAll(src=orig_path_pattern)), 0, 'testharness src path was not converted')
+        self.assertEqual(len(converted.findAll(href=orig_path_pattern)), 0, 'testharness href path was not converted')
</ins><span class="cx"> 
</span><span class="cx">         new_relpath = os.path.relpath(resources_dir, test_path).replace(os.sep, '/')
</span><span class="cx">         relpath_pattern = re.compile(new_relpath)
</span><del>-        self.assertEquals(len(converted.findAll(src=relpath_pattern)), num_src_paths, 'testharness src relative path not correct')
-        self.assertEquals(len(converted.findAll(href=relpath_pattern)), num_href_paths, 'testharness href relative path not correct')
</del><ins>+        self.assertEqual(len(converted.findAll(src=relpath_pattern)), num_src_paths, 'testharness src relative path not correct')
+        self.assertEqual(len(converted.findAll(href=relpath_pattern)), num_href_paths, 'testharness href relative path not correct')
</ins><span class="cx"> 
</span><span class="cx">     def verify_prefixed_properties(self, converted, test_properties):
</span><span class="cx">         self.assertEqual(len(set(converted[0])), len(set(test_properties)), 'Incorrect number of properties converted')
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpyw3ctest_exporter_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/w3c/test_exporter_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/w3c/test_exporter_unittest.py       2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/w3c/test_exporter_unittest.py  2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -130,9 +130,9 @@
</span><span class="cx">         options = parse_args(['test_exporter.py', '-g', 'HEAD', '-b', '1234', '-c', '-n', 'USER', '-t', 'TOKEN'])
</span><span class="cx">         exporter = WebPlatformTestExporter(host, options, TestExporterTest.MockGit, TestExporterTest.MockBugzilla, MockWPTGitHub, TestExporterTest.MockWPTLinter)
</span><span class="cx">         exporter.do_export()
</span><del>-        self.assertEquals(exporter._github.calls, ['create_pr', 'add_label "webkit-export"'])
</del><ins>+        self.assertEqual(exporter._github.calls, ['create_pr', 'add_label "webkit-export"'])
</ins><span class="cx">         self.assertTrue('WebKit export' in exporter._github.pull_requests_created[0][1])
</span><del>-        self.assertEquals(exporter._git.calls, [
</del><ins>+        self.assertEqual(exporter._git.calls, [
</ins><span class="cx">             '/mock-checkout/WebKitBuild/w3c-tests/web-platform-tests',
</span><span class="cx">             'fetch',
</span><span class="cx">             'checkout master',
</span><span class="lines">@@ -148,11 +148,11 @@
</span><span class="cx">             'delete branch wpt-export-for-webkit-1234',
</span><span class="cx">             'checkout master',
</span><span class="cx">             'reset hard origin/master'])
</span><del>-        self.assertEquals(exporter._bugzilla.calls, [
</del><ins>+        self.assertEqual(exporter._bugzilla.calls, [
</ins><span class="cx">             'fetch bug 1234',
</span><span class="cx">             'Append https://github.com/web-platform-tests/wpt/pull/5678 to see also list',
</span><span class="cx">             'post comment to bug 1234 : Submitted web-platform-tests pull request: https://github.com/web-platform-tests/wpt/pull/5678'])
</span><del>-        self.assertEquals(mock_linter.calls, ['/mock-checkout/WebKitBuild/w3c-tests/web-platform-tests', 'lint'])
</del><ins>+        self.assertEqual(mock_linter.calls, ['/mock-checkout/WebKitBuild/w3c-tests/web-platform-tests', 'lint'])
</ins><span class="cx"> 
</span><span class="cx">     def test_export_with_specific_branch(self):
</span><span class="cx">         host = TestExporterTest.MyMockHost()
</span><span class="lines">@@ -160,7 +160,7 @@
</span><span class="cx">         options = parse_args(['test_exporter.py', '-g', 'HEAD', '-b', '1234', '-c', '-n', 'USER', '-t', 'TOKEN', '-bn', 'wpt-export-branch'])
</span><span class="cx">         exporter = WebPlatformTestExporter(host, options, TestExporterTest.MockGit, TestExporterTest.MockBugzilla, MockWPTGitHub, TestExporterTest.MockWPTLinter)
</span><span class="cx">         exporter.do_export()
</span><del>-        self.assertEquals(exporter._git.calls, [
</del><ins>+        self.assertEqual(exporter._git.calls, [
</ins><span class="cx">             '/mock-checkout/WebKitBuild/w3c-tests/web-platform-tests',
</span><span class="cx">             'fetch',
</span><span class="cx">             'checkout master',
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpyw3ctest_importer_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/w3c/test_importer_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/w3c/test_importer_unittest.py       2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/w3c/test_importer_unittest.py  2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -345,7 +345,7 @@
</span><span class="cx"> 
</span><span class="cx">         fs = self.import_downloaded_tests(['--no-fetch', '--import-all', '-d', 'w3c'], FAKE_FILES)
</span><span class="cx">         self.assertFalse(fs.exists('/mock-checkout/LayoutTests/w3c/web-platform-tests/t/new-manual.html'))
</span><del>-        self.assertEquals(tests_options, fs.read_text_file('/mock-checkout/LayoutTests/tests-options.json'))
</del><ins>+        self.assertEqual(tests_options, fs.read_text_file('/mock-checkout/LayoutTests/tests-options.json'))
</ins><span class="cx"> 
</span><span class="cx">     def test_webkit_test_runner_options(self):
</span><span class="cx">         FAKE_FILES = {
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpyw3ctest_parser_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/w3c/test_parser_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/w3c/test_parser_unittest.py 2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/w3c/test_parser_unittest.py    2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -133,7 +133,7 @@
</span><span class="cx">         self.assertTrue('reference' in test_info.keys(), 'did not find a reference file')
</span><span class="cx">         self.assertTrue(test_info['reference'].startswith(test_path), 'reference path is not correct')
</span><span class="cx">         self.assertTrue('reference_support_info' in test_info.keys(), 'there should be reference_support_info for this test')
</span><del>-        self.assertEquals(len(test_info['reference_support_info']['files']), 4, 'there should be 4 support files in this reference')
</del><ins>+        self.assertEqual(len(test_info['reference_support_info']['files']), 4, 'there should be 4 support files in this reference')
</ins><span class="cx">         self.assertFalse('jstest' in test_info.keys(), 'test should not have been analyzed as a jstest')
</span><span class="cx"> 
</span><span class="cx">     def test_analyze_jstest(self):
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpyw3cwpt_runner_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/w3c/wpt_runner_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/w3c/wpt_runner_unittest.py  2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/w3c/wpt_runner_unittest.py     2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -127,9 +127,9 @@
</span><span class="cx">             self._expected_wpt_args = expected_wpt_args
</span><span class="cx"> 
</span><span class="cx">         def __call__(self, script_name, wpt_checkout, wpt_args):
</span><del>-            self._test_case.assertEquals(script_name, "wptrunner_unittest")
-            self._test_case.assertEquals(wpt_checkout, self._expected_wpt_checkout)
-            self._test_case.assertEquals(wpt_args, self._expected_wpt_args)
</del><ins>+            self._test_case.assertEqual(script_name, "wptrunner_unittest")
+            self._test_case.assertEqual(wpt_checkout, self._expected_wpt_checkout)
+            self._test_case.assertEqual(wpt_args, self._expected_wpt_args)
</ins><span class="cx"> 
</span><span class="cx">     class TestInstance(object):
</span><span class="cx">         def __init__(self, options, spawn_wpt_func=None):
</span><span class="lines">@@ -154,7 +154,7 @@
</span><span class="cx">         self.assertTrue(instance.runner.prepare_wpt_checkout())
</span><span class="cx"> 
</span><span class="cx">         expected_wpt_checkout = "/mock-checkout/WebKitBuild/w3c-tests/web-platform-tests"
</span><del>-        self.assertEquals(instance.runner._options.wpt_checkout, expected_wpt_checkout)
</del><ins>+        self.assertEqual(instance.runner._options.wpt_checkout, expected_wpt_checkout)
</ins><span class="cx">         self.assertTrue(instance.host.filesystem.isdir(expected_wpt_checkout))
</span><span class="cx"> 
</span><span class="cx">     def test_prepare_wpt_checkout_specified_path(self):
</span><span class="lines">@@ -166,7 +166,7 @@
</span><span class="cx">         instance.host.filesystem.maybe_make_directory(specified_wpt_checkout)
</span><span class="cx"> 
</span><span class="cx">         self.assertTrue(instance.runner.prepare_wpt_checkout())
</span><del>-        self.assertEquals(instance.runner._options.wpt_checkout, specified_wpt_checkout)
</del><ins>+        self.assertEqual(instance.runner._options.wpt_checkout, specified_wpt_checkout)
</ins><span class="cx"> 
</span><span class="cx">     def test_run(self):
</span><span class="cx">         # Tests the run() method. Files are mocked to the point that helper methods don't fail.
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpyxcodedevice_type_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/xcode/device_type_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/xcode/device_type_unittest.py       2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/xcode/device_type_unittest.py  2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -31,70 +31,70 @@
</span><span class="cx"> 
</span><span class="cx">     def test_iphone_initialization(self):
</span><span class="cx">         type = DeviceType(hardware_family='iPhone')
</span><del>-        self.assertEquals('iPhone', type.hardware_family)
-        self.assertEquals(None, type.hardware_type)
-        self.assertEquals('iOS', type.software_variant)
-        self.assertEquals(None, type.software_version)
</del><ins>+        self.assertEqual('iPhone', type.hardware_family)
+        self.assertEqual(None, type.hardware_type)
+        self.assertEqual('iOS', type.software_variant)
+        self.assertEqual(None, type.software_version)
</ins><span class="cx">         self.assertEqual('iPhone running iOS', str(type))
</span><span class="cx"> 
</span><span class="cx">         type = DeviceType('iPhone', '6s', Version(11))
</span><del>-        self.assertEquals('iPhone', type.hardware_family)
-        self.assertEquals('6s', type.hardware_type)
-        self.assertEquals('iOS', type.software_variant)
-        self.assertEquals(Version(11), type.software_version)
</del><ins>+        self.assertEqual('iPhone', type.hardware_family)
+        self.assertEqual('6s', type.hardware_type)
+        self.assertEqual('iOS', type.software_variant)
+        self.assertEqual(Version(11), type.software_version)
</ins><span class="cx">         self.assertEqual('iPhone 6s running iOS 11', str(type))
</span><span class="cx"> 
</span><span class="cx">     def test_ipad_initialization(self):
</span><span class="cx">         type = DeviceType(hardware_family='iPad')
</span><del>-        self.assertEquals('iPad', type.hardware_family)
-        self.assertEquals(None, type.hardware_type)
-        self.assertEquals('iOS', type.software_variant)
-        self.assertEquals(None, type.software_version)
</del><ins>+        self.assertEqual('iPad', type.hardware_family)
+        self.assertEqual(None, type.hardware_type)
+        self.assertEqual('iOS', type.software_variant)
+        self.assertEqual(None, type.software_version)
</ins><span class="cx">         self.assertEqual('iPad running iOS', str(type))
</span><span class="cx"> 
</span><span class="cx">         type = DeviceType('iPad', 'Air 2', Version(11))
</span><del>-        self.assertEquals('iPad', type.hardware_family)
-        self.assertEquals('Air 2', type.hardware_type)
-        self.assertEquals('iOS', type.software_variant)
-        self.assertEquals(Version(11), type.software_version)
</del><ins>+        self.assertEqual('iPad', type.hardware_family)
+        self.assertEqual('Air 2', type.hardware_type)
+        self.assertEqual('iOS', type.software_variant)
+        self.assertEqual(Version(11), type.software_version)
</ins><span class="cx">         self.assertEqual('iPad Air 2 running iOS 11', str(type))
</span><span class="cx"> 
</span><span class="cx">     def test_generic_ios_device(self):
</span><span class="cx">         type = DeviceType(software_variant='iOS')
</span><del>-        self.assertEquals(None, type.hardware_family)
-        self.assertEquals(None, type.hardware_type)
-        self.assertEquals('iOS', type.software_variant)
-        self.assertEquals(None, type.software_version)
</del><ins>+        self.assertEqual(None, type.hardware_family)
+        self.assertEqual(None, type.hardware_type)
+        self.assertEqual('iOS', type.software_variant)
+        self.assertEqual(None, type.software_version)
</ins><span class="cx">         self.assertEqual('Device running iOS', str(type))
</span><span class="cx"> 
</span><span class="cx">     def test_watch_initialization(self):
</span><span class="cx">         type = DeviceType(hardware_family='Watch')
</span><del>-        self.assertEquals('Apple Watch', type.hardware_family)
-        self.assertEquals(None, type.hardware_type)
-        self.assertEquals('watchOS', type.software_variant)
-        self.assertEquals(None, type.software_version)
</del><ins>+        self.assertEqual('Apple Watch', type.hardware_family)
+        self.assertEqual(None, type.hardware_type)
+        self.assertEqual('watchOS', type.software_variant)
+        self.assertEqual(None, type.software_version)
</ins><span class="cx">         self.assertEqual('Apple Watch running watchOS', str(type))
</span><span class="cx"> 
</span><span class="cx">         type = DeviceType('Apple Watch', 'Series 2 - 42mm', Version(4))
</span><del>-        self.assertEquals('Apple Watch', type.hardware_family)
-        self.assertEquals('Series 2 - 42mm', type.hardware_type)
-        self.assertEquals('watchOS', type.software_variant)
-        self.assertEquals(Version(4), type.software_version)
</del><ins>+        self.assertEqual('Apple Watch', type.hardware_family)
+        self.assertEqual('Series 2 - 42mm', type.hardware_type)
+        self.assertEqual('watchOS', type.software_variant)
+        self.assertEqual(Version(4), type.software_version)
</ins><span class="cx">         self.assertEqual('Apple Watch Series 2 - 42mm running watchOS 4', str(type))
</span><span class="cx"> 
</span><span class="cx">     def test_tv_initialization(self):
</span><span class="cx">         type = DeviceType(hardware_family='TV')
</span><del>-        self.assertEquals('Apple TV', type.hardware_family)
-        self.assertEquals(None, type.hardware_type)
-        self.assertEquals('tvOS', type.software_variant)
-        self.assertEquals(None, type.software_version)
</del><ins>+        self.assertEqual('Apple TV', type.hardware_family)
+        self.assertEqual(None, type.hardware_type)
+        self.assertEqual('tvOS', type.software_variant)
+        self.assertEqual(None, type.software_version)
</ins><span class="cx">         self.assertEqual('Apple TV running tvOS', str(type))
</span><span class="cx"> 
</span><span class="cx">         type = DeviceType('Apple TV', '4K', Version(11))
</span><del>-        self.assertEquals('Apple TV', type.hardware_family)
-        self.assertEquals('4K', type.hardware_type)
-        self.assertEquals('tvOS', type.software_variant)
-        self.assertEquals(Version(11), type.software_version)
</del><ins>+        self.assertEqual('Apple TV', type.hardware_family)
+        self.assertEqual('4K', type.hardware_type)
+        self.assertEqual('tvOS', type.software_variant)
+        self.assertEqual(Version(11), type.software_version)
</ins><span class="cx">         self.assertEqual('Apple TV 4K running tvOS 11', str(type))
</span><span class="cx"> 
</span><span class="cx">     def test_from_string(self):
</span></span></pre></div>
<a id="trunkToolsScriptswebkitpyxcodesdk_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/xcode/sdk_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/xcode/sdk_unittest.py       2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/xcode/sdk_unittest.py  2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -72,48 +72,48 @@
</span><span class="cx"> 
</span><span class="cx">     def test_iphoneos(self):
</span><span class="cx">         preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("iphoneos", self.executive)
</span><del>-        self.assertEquals("iphoneos", preferred_sdk.platform)
-        self.assertEquals("12.0", preferred_sdk.version)
</del><ins>+        self.assertEqual("iphoneos", preferred_sdk.platform)
+        self.assertEqual("12.0", preferred_sdk.version)
</ins><span class="cx">         self.assertTrue(preferred_sdk.internal)
</span><span class="cx"> 
</span><span class="cx">     def test_iphonesim(self):
</span><span class="cx">         preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("iphonesimulator", self.executive)
</span><del>-        self.assertEquals("iphonesimulator", preferred_sdk.platform)
-        self.assertEquals("12.0", preferred_sdk.version)
</del><ins>+        self.assertEqual("iphonesimulator", preferred_sdk.platform)
+        self.assertEqual("12.0", preferred_sdk.version)
</ins><span class="cx">         self.assertFalse(preferred_sdk.internal)
</span><span class="cx"> 
</span><span class="cx">     def test_macos(self):
</span><span class="cx">         preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("macosx", self.executive)
</span><del>-        self.assertEquals("macosx", preferred_sdk.platform)
-        self.assertEquals("10.14", preferred_sdk.version)
</del><ins>+        self.assertEqual("macosx", preferred_sdk.platform)
+        self.assertEqual("10.14", preferred_sdk.version)
</ins><span class="cx">         self.assertTrue(preferred_sdk.internal)
</span><span class="cx"> 
</span><span class="cx">     def test_appletvos(self):
</span><span class="cx">         preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("appletvos", self.executive)
</span><del>-        self.assertEquals("appletvos", preferred_sdk.platform)
-        self.assertEquals("12.0", preferred_sdk.version)
</del><ins>+        self.assertEqual("appletvos", preferred_sdk.platform)
+        self.assertEqual("12.0", preferred_sdk.version)
</ins><span class="cx">         self.assertTrue(preferred_sdk.internal)
</span><span class="cx"> 
</span><span class="cx">     def test_appletvsim(self):
</span><span class="cx">         preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("appletvsimulator", self.executive)
</span><del>-        self.assertEquals("appletvsimulator", preferred_sdk.platform)
-        self.assertEquals("12.0", preferred_sdk.version)
</del><ins>+        self.assertEqual("appletvsimulator", preferred_sdk.platform)
+        self.assertEqual("12.0", preferred_sdk.version)
</ins><span class="cx">         self.assertFalse(preferred_sdk.internal)
</span><span class="cx"> 
</span><span class="cx">     def test_watchos(self):
</span><span class="cx">         preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("watchos", self.executive)
</span><del>-        self.assertEquals("watchos", preferred_sdk.platform)
-        self.assertEquals("4.0", preferred_sdk.version)
</del><ins>+        self.assertEqual("watchos", preferred_sdk.platform)
+        self.assertEqual("4.0", preferred_sdk.version)
</ins><span class="cx">         self.assertTrue(preferred_sdk.internal)
</span><span class="cx"> 
</span><span class="cx">     def test_watchsimulator(self):
</span><span class="cx">         preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("watchsimulator", self.executive)
</span><del>-        self.assertEquals("watchsimulator", preferred_sdk.platform)
-        self.assertEquals("4.0", preferred_sdk.version)
</del><ins>+        self.assertEqual("watchsimulator", preferred_sdk.platform)
+        self.assertEqual("4.0", preferred_sdk.version)
</ins><span class="cx">         self.assertFalse(preferred_sdk.internal)
</span><span class="cx"> 
</span><span class="cx">     def test_prodos(self):
</span><span class="cx">         preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("prodos", self.executive)
</span><del>-        self.assertEquals("prodos", preferred_sdk.platform)
-        self.assertEquals(None, preferred_sdk.version)
-        self.assertEquals(None, preferred_sdk.internal)
</del><ins>+        self.assertEqual("prodos", preferred_sdk.platform)
+        self.assertEqual(None, preferred_sdk.version)
+        self.assertEqual(None, preferred_sdk.internal)
</ins></span></pre></div>
<a id="trunkToolsScriptswebkitpyxcodesimulated_device_unittestpy"></a>
<div class="modfile"><h4>Modified: trunk/Tools/Scripts/webkitpy/xcode/simulated_device_unittest.py (284774 => 284775)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Tools/Scripts/webkitpy/xcode/simulated_device_unittest.py  2021-10-25 08:58:38 UTC (rev 284774)
+++ trunk/Tools/Scripts/webkitpy/xcode/simulated_device_unittest.py     2021-10-25 11:07:20 UTC (rev 284775)
</span><span class="lines">@@ -568,33 +568,33 @@
</span><span class="cx">         SimulatedDeviceManager.available_devices(host)
</span><span class="cx"> 
</span><span class="cx">         # There should only be 1 iPhone X, iPhone 8 and iPhone SE
</span><del>-        self.assertEquals(1, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone X'), host)))
-        self.assertEquals(1, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone 8'), host)))
</del><ins>+        self.assertEqual(1, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone X'), host)))
+        self.assertEqual(1, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone 8'), host)))
</ins><span class="cx"> 
</span><span class="cx">         # There should be 2 5s and 6s
</span><del>-        self.assertEquals(2, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone 5s'), host)))
-        self.assertEquals(2, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone 6s'), host)))
</del><ins>+        self.assertEqual(2, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone 5s'), host)))
+        self.assertEqual(2, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone 6s'), host)))
</ins><span class="cx"> 
</span><span class="cx">         # 19 iPhones
</span><del>-        self.assertEquals(19, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone'), host)))
</del><ins>+        self.assertEqual(19, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone'), host)))
</ins><span class="cx"> 
</span><span class="cx">         # 11 iPads
</span><del>-        self.assertEquals(11, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPad'), host)))
</del><ins>+        self.assertEqual(11, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPad'), host)))
</ins><span class="cx"> 
</span><span class="cx">         # 18 Apple watches
</span><del>-        self.assertEquals(6, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('Apple Watch'), host)))
</del><ins>+        self.assertEqual(6, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('Apple Watch'), host)))
</ins><span class="cx"> 
</span><span class="cx">         # 3 Apple TVs
</span><del>-        self.assertEquals(3, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('Apple TV'), host)))
</del><ins>+        self.assertEqual(3, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('Apple TV'), host)))
</ins><span class="cx"> 
</span><span class="cx">         # 18 devices running iOS 11.0
</span><del>-        self.assertEquals(18, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType(software_variant='iOS', software_version=Version(11, 0, 1)), host)))
</del><ins>+        self.assertEqual(18, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType(software_variant='iOS', software_version=Version(11, 0, 1)), host)))
</ins><span class="cx"> 
</span><span class="cx">         # 11 iPhones running iOS 11.0
</span><del>-        self.assertEquals(11, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType(hardware_family='iPhone', software_version=Version(11, 0, 1)), host)))
</del><ins>+        self.assertEqual(11, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType(hardware_family='iPhone', software_version=Version(11, 0, 1)), host)))
</ins><span class="cx"> 
</span><span class="cx">         # 1 device running iOS 12
</span><del>-        self.assertEquals(1, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType(software_variant='iOS', software_version=Version(12, 0, 0)), host)))
</del><ins>+        self.assertEqual(1, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType(software_variant='iOS', software_version=Version(12, 0, 0)), host)))
</ins><span class="cx"> 
</span><span class="cx">     def test_existing_simulator(self):
</span><span class="cx">         SimulatedDeviceTest.reset_simulated_device_manager()
</span><span class="lines">@@ -603,10 +603,10 @@
</span><span class="cx"> 
</span><span class="cx">         SimulatedDeviceManager.initialize_devices(DeviceRequest(DeviceType.from_string('iPhone', Version(11))), host=host)
</span><span class="cx"> 
</span><del>-        self.assertEquals(1, len(SimulatedDeviceManager.INITIALIZED_DEVICES))
-        self.assertEquals('34FB476C-6FA0-43C8-8945-1BD7A4EBF0DE', SimulatedDeviceManager.INITIALIZED_DEVICES[0].udid)
-        self.assertEquals('15A8401', SimulatedDeviceManager.INITIALIZED_DEVICES[0].build_version)
-        self.assertEquals(SimulatedDevice.DeviceState.BOOTED, SimulatedDeviceManager.INITIALIZED_DEVICES[0].platform_device.state())
</del><ins>+        self.assertEqual(1, len(SimulatedDeviceManager.INITIALIZED_DEVICES))
+        self.assertEqual('34FB476C-6FA0-43C8-8945-1BD7A4EBF0DE', SimulatedDeviceManager.INITIALIZED_DEVICES[0].udid)
+        self.assertEqual('15A8401', SimulatedDeviceManager.INITIALIZED_DEVICES[0].build_version)
+        self.assertEqual(SimulatedDevice.DeviceState.BOOTED, SimulatedDeviceManager.INITIALIZED_DEVICES[0].platform_device.state())
</ins><span class="cx"> 
</span><span class="cx">         SimulatedDeviceManager.tear_down(host)
</span><span class="cx">         self.assertIsNone(SimulatedDeviceManager.INITIALIZED_DEVICES)
</span><span class="lines">@@ -618,9 +618,9 @@
</span><span class="cx"> 
</span><span class="cx">         SimulatedDeviceManager.initialize_devices(DeviceRequest(DeviceType.from_string('iphone 5s', Version(11))), host=host)
</span><span class="cx"> 
</span><del>-        self.assertEquals(1, len(SimulatedDeviceManager.INITIALIZED_DEVICES))
-        self.assertEquals('34FB476C-6FA0-43C8-8945-1BD7A4EBF0DE', SimulatedDeviceManager.INITIALIZED_DEVICES[0].udid)
-        self.assertEquals(SimulatedDevice.DeviceState.BOOTED, SimulatedDeviceManager.INITIALIZED_DEVICES[0].platform_device.state())
</del><ins>+        self.assertEqual(1, len(SimulatedDeviceManager.INITIALIZED_DEVICES))
+        self.assertEqual('34FB476C-6FA0-43C8-8945-1BD7A4EBF0DE', SimulatedDeviceManager.INITIALIZED_DEVICES[0].udid)
+        self.assertEqual(SimulatedDevice.DeviceState.BOOTED, SimulatedDeviceManager.INITIALIZED_DEVICES[0].platform_device.state())
</ins><span class="cx"> 
</span><span class="cx">         SimulatedDeviceManager.tear_down(host)
</span><span class="cx">         self.assertIsNone(SimulatedDeviceManager.INITIALIZED_DEVICES)
</span><span class="lines">@@ -631,8 +631,8 @@
</span><span class="cx">         SimulatedDeviceManager.available_devices(host)
</span><span class="cx"> 
</span><span class="cx">         runtime = SimulatedDeviceManager.get_runtime_for_device_type(DeviceType.from_string('iphone 5s', Version(9, 2)))
</span><del>-        self.assertEquals(runtime.os_variant, 'iOS')
-        self.assertEquals(runtime.version, Version(9, 3))
</del><ins>+        self.assertEqual(runtime.os_variant, 'iOS')
+        self.assertEqual(runtime.version, Version(9, 3))
</ins><span class="cx"> 
</span><span class="cx">     def test_matching_up_failure(self):
</span><span class="cx">         SimulatedDeviceTest.reset_simulated_device_manager()
</span><span class="lines">@@ -640,7 +640,7 @@
</span><span class="cx">         SimulatedDeviceManager.available_devices(host)
</span><span class="cx"> 
</span><span class="cx">         runtime = SimulatedDeviceManager.get_runtime_for_device_type(DeviceType.from_string('iphone 5s', Version(9, 4)))
</span><del>-        self.assertEquals(runtime, None)
</del><ins>+        self.assertEqual(runtime, None)
</ins><span class="cx"> 
</span><span class="cx">     def test_no_state_files(self):
</span><span class="cx">         SimulatedDeviceTest.reset_simulated_device_manager()
</span><span class="lines">@@ -649,4 +649,4 @@
</span><span class="cx">         devices = SimulatedDeviceManager.available_devices(host)
</span><span class="cx"> 
</span><span class="cx">         for device in devices:
</span><del>-            self.assertEquals(SimulatedDevice.DeviceState.SHUT_DOWN, device.state(force_update=True))
</del><ins>+            self.assertEqual(SimulatedDevice.DeviceState.SHUT_DOWN, device.state(force_update=True))
</ins></span></pre>
</div>
</div>

</body>
</html>