⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 284775 in webkit


Ignore:
Timestamp:
Oct 25, 2021, 4:07:20 AM (5 years ago)
Author:
Sam Sneddon
Message:

[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:
Location:
trunk
Files:
25 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r284768 r284775  
     12021-10-25  Sam Sneddon  <gsnedders@apple.com>
     2
     3        [Python] rename assertEquals/assertNotEquals
     4        https://bugs.webkit.org/show_bug.cgi?id=232214
     5
     6        Reviewed by Alexey Proskuryakov.
     7
     8        This is assert(Not)?Equals -> assert(\1)Equal
     9
     10        Python 3.11 (currently CPython main branch) removes the deprecated
     11        aliases assertEquals/assertNotEquals. These have long been deprecated,
     12        and the modern names exist all the way back to Python 2.7, hence there's
     13        no reason not to switch.
     14
     15        * Scripts/webkit/messages_unittest.py:
     16        (GeneratedFileContentsTest.assertGeneratedFileContentsEqual):
     17        * Scripts/webkit/model_unittest.py:
     18        * Scripts/webkit/parser_unittest.py:
     19        (ParsingTest.check_message):
     20        (ParsingTest.test_receiver):
     21
    1222021-10-24  Wenson Hsieh  <wenson_hsieh@apple.com>
    223

  • trunk/Source/WebKit/Scripts/webkit/messages_unittest.py

    r284096 r284775  
    8585
    8686            for index, actual_line in enumerate(actual_line_list):
    87                 self.assertEquals(actual_line, expected_line_list[index])
     87                self.assertEqual(actual_line, expected_line_list[index])
    8888
    89             self.assertEquals(len(actual_line_list), len(expected_line_list))
     89            self.assertEqual(len(actual_line_list), len(expected_line_list))
    9090        except Exception:
    9191            sys.stderr.write('In expected file %s\n' % expected_file_name)

  • trunk/Source/WebKit/Scripts/webkit/model_unittest.py

    r284096 r284775  
    4747}"""
    4848        receiver = parser.parse(StringIO(contents))
    49         self.assertEquals(receiver.name, 'WebPage')
    50         self.assertEquals(receiver.messages[0].name, 'LoadURL')
     49        self.assertEqual(receiver.name, 'WebPage')
     50        self.assertEqual(receiver.messages[0].name, 'LoadURL')
    5151
    5252        other_contents = """
    … …  
    5757
    5858        other_receiver = parser.parse(StringIO(other_contents))
    59         self.assertEquals(other_receiver.name, 'WebPage')
    60         self.assertEquals(other_receiver.messages[0].name, 'LoadURL')
    61         self.assertEquals(other_receiver.messages[1].name, 'LoadURL2')
     59        self.assertEqual(other_receiver.name, 'WebPage')
     60        self.assertEqual(other_receiver.messages[0].name, 'LoadURL')
     61        self.assertEqual(other_receiver.messages[1].name, 'LoadURL2')
    6262        errors = model.check_global_model_inputs([receiver, other_receiver])
    63         self.assertEquals(len(errors), 1)
     63        self.assertEqual(len(errors), 1)
    6464        self.assertTrue("Duplicate" in errors[0])
    6565
    … …  
    7575}"""
    7676        receiver = parser.parse(StringIO(contents))
    77         self.assertEquals(receiver.name, 'WebPage')
    78         self.assertEquals(receiver.messages[0].name, 'LoadURL')
     77        self.assertEqual(receiver.name, 'WebPage')
     78        self.assertEqual(receiver.messages[0].name, 'LoadURL')
    7979        errors = model.check_global_model_inputs([receiver])
    80         self.assertEquals(len(errors), 1)
     80        self.assertEqual(len(errors), 1)
    8181        self.assertTrue("attribute mismatch" in errors[0])
    8282

  • trunk/Source/WebKit/Scripts/webkit/parser_unittest.py

    r284096 r284775  
    317317
    318318    def check_message(self, message, expected_message):
    319         self.assertEquals(message.name, expected_message['name'])
    320         self.assertEquals(len(message.parameters), len(expected_message['parameters']))
     319        self.assertEqual(message.name, expected_message['name'])
     320        self.assertEqual(len(message.parameters), len(expected_message['parameters']))
    321321        for index, parameter in enumerate(message.parameters):
    322322            expected_parameter = expected_message['parameters'][index]
    323             self.assertEquals(parameter.type, expected_parameter[0])
    324             self.assertEquals(parameter.name, expected_parameter[1])
     323            self.assertEqual(parameter.type, expected_parameter[0])
     324            self.assertEqual(parameter.name, expected_parameter[1])
    325325            if len(expected_parameter) > 2:
    326                 self.assertEquals(parameter.attributes, frozenset(expected_parameter[2]))
     326                self.assertEqual(parameter.attributes, frozenset(expected_parameter[2]))
    327327                for attribute in expected_parameter[2]:
    328328                    self.assertTrue(parameter.has_attribute(attribute))
    329329            else:
    330                 self.assertEquals(parameter.attributes, frozenset())
     330                self.assertEqual(parameter.attributes, frozenset())
    331331        if message.reply_parameters is not None:
    332332            for index, parameter in enumerate(message.reply_parameters):
    333                 self.assertEquals(parameter.type, expected_message['reply_parameters'][index][0])
    334                 self.assertEquals(parameter.name, expected_message['reply_parameters'][index][1])
     333                self.assertEqual(parameter.type, expected_message['reply_parameters'][index][0])
     334                self.assertEqual(parameter.name, expected_message['reply_parameters'][index][1])
    335335        else:
    336336            self.assertFalse('reply_parameters' in expected_message)
    337         self.assertEquals(message.condition, expected_message['conditions'])
     337        self.assertEqual(message.condition, expected_message['conditions'])
    338338
    339339    def test_receiver(self):
    340340        """Receiver should be parsed as expected"""
    341341        for receiver, expected_model in zip(self.receivers, _parsing_test_cases):
    342             self.assertEquals(receiver.name, expected_model['name'])
    343             self.assertEquals(receiver.condition, expected_model['conditions'])
    344             self.assertEquals(len(receiver.messages), len(expected_model['messages']))
     342            self.assertEqual(receiver.name, expected_model['name'])
     343            self.assertEqual(receiver.condition, expected_model['conditions'])
     344            self.assertEqual(len(receiver.messages), len(expected_model['messages']))
    345345            for index, message in enumerate(receiver.messages):
    346346                self.check_message(message, expected_model['messages'][index])

  • trunk/Tools/ChangeLog

    r284765 r284775  
     12021-10-25  Sam Sneddon  <gsnedders@apple.com>
     2
     3        [Python] rename assertEquals/assertNotEquals
     4        https://bugs.webkit.org/show_bug.cgi?id=232214
     5
     6        Reviewed by Alexey Proskuryakov.
     7
     8        This is assert(Not)?Equals -> assert(\1)Equal
     9
     10        Python 3.11 (currently CPython main branch) removes the deprecated
     11        aliases assertEquals/assertNotEquals. These have long been deprecated,
     12        and the modern names exist all the way back to Python 2.7, hence there's
     13        no reason not to switch.
     14
     15        * Scripts/libraries/webkitcorepy/webkitcorepy/tests/task_pool_unittest.py:
     16        (TaskPoolUnittest.test_multiple):
     17        * Scripts/webkitpy/common/attribute_saver_unittest.py:
     18        (AttributeSaverTest.test_class):
     19        (AttributeSaverTest.test_normal_default):
     20        (AttributeSaverTest.test_normal_value):
     21        (AttributeSaverTest.test_normal_value_on_exception):
     22        (AttributeSaverTest.test_normal_value_on_normal_exit):
     23        (AttributeSaverTest.test_normal_value_with_finally_on_exception):
     24        (AttributeSaverTest.test_normal_value_with_finally_on_normal_exit):
     25        (AttributeSaverTest.test_normal_value_with_else_on_exception):
     26        (AttributeSaverTest.test_normal_value_with_else_on_normal_exit):
     27        * Scripts/webkitpy/common/checkout/scm/stub_repository_unittest.py:
     28        (StubRepositoryTest.test_find_checkout_root):
     29        * Scripts/webkitpy/layout_tests/models/test_configuration_unittest.py:
     30        (TestConfigurationTest.test_eq):
     31        * Scripts/webkitpy/layout_tests/models/test_expectations_unittest.py:
     32        (MiscTests.test_parse_warnings_are_logged_if_not_in_lint_mode):
     33        * Scripts/webkitpy/layout_tests/models/test_run_results_unittest.py:
     34        (SummarizedResultsTest.test_svn_revision_exists):
     35        (SummarizedResultsTest.test_svn_revision):
     36        (SummarizedResultsTest.test_svn_revision_git):
     37        * Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py:
     38        (RunTest.test_tests_options):
     39        * Scripts/webkitpy/layout_tests/servers/http_server_unittest.py:
     40        (TestHttpServer.test_win32_start_and_stop):
     41        * Scripts/webkitpy/port/driver_unittest.py:
     42        * Scripts/webkitpy/port/gtk_unittest.py:
     43        (GtkPortTest.test_gtk4_expectations_binary_only):
     44        (GtkPortTest.test_gtk3_expectations_binary_only):
     45        (GtkPortTest.test_gtk_expectations_both_binaries):
     46        * Scripts/webkitpy/style/checkers/test_expectations_unittest.py:
     47        (TestExpectationsTestCase.assert_lines_lint):
     48        * Scripts/webkitpy/tool/steps/preparechangelog_unittest.py:
     49        * Scripts/webkitpy/w3c/test_converter_unittest.py:
     50        (verify_test_harness_paths):
     51        * Scripts/webkitpy/w3c/test_exporter_unittest.py:
     52        (TestExporterTest.test_export):
     53        (TestExporterTest.test_export_with_specific_branch):
     54        * Scripts/webkitpy/w3c/test_importer_unittest.py:
     55        * Scripts/webkitpy/w3c/test_parser_unittest.py:
     56        * Scripts/webkitpy/w3c/wpt_runner_unittest.py:
     57        (WPTRunnerTest.MockSpawnWPT.__call__):
     58        (WPTRunnerTest.test_prepare_wpt_checkout):
     59        (WPTRunnerTest.test_prepare_wpt_checkout_specified_path):
     60        * Scripts/webkitpy/xcode/device_type_unittest.py:
     61        (DeviceTypeTest.test_iphone_initialization):
     62        (DeviceTypeTest.test_ipad_initialization):
     63        (DeviceTypeTest.test_generic_ios_device):
     64        (DeviceTypeTest.test_watch_initialization):
     65        (DeviceTypeTest.test_tv_initialization):
     66        * Scripts/webkitpy/xcode/sdk_unittest.py:
     67        (SDKTest.test_iphoneos):
     68        (SDKTest.test_iphonesim):
     69        (SDKTest.test_macos):
     70        (SDKTest.test_appletvos):
     71        (SDKTest.test_appletvsim):
     72        (SDKTest.test_watchos):
     73        (SDKTest.test_watchsimulator):
     74        (SDKTest.test_prodos):
     75        * Scripts/webkitpy/xcode/simulated_device_unittest.py:
     76
    1772021-10-24  Arcady Goldmints-Orlov  <agoldmints@igalia.com>
    278

  • trunk/Tools/Scripts/libraries/webkitcorepy/webkitcorepy/tests/task_pool_unittest.py

    r281448 r284775  
    111111
    112112            lines = captured.stdout.getvalue().splitlines()
    113             self.assertEquals(sorted(lines), ['action({})'.format(character) for character in self.alphabet])
     113            self.assertEqual(sorted(lines), ['action({})'.format(character) for character in self.alphabet])
    114114            self.assertEqual(
    115115                sorted(captured.webkitcorepy.log.getvalue().splitlines()),

  • trunk/Tools/Scripts/webkitpy/common/attribute_saver_unittest.py

    r245364 r284775  
    3939    def test_class(self):
    4040        obj = self.SimpleTestClass()
    41         self.assertEquals(obj.value, 0)
     41        self.assertEqual(obj.value, 0)
    4242
    4343    def test_normal_default(self):
    4444        obj = self.SimpleTestClass()
    45         self.assertEquals(obj.value, 0)
     45        self.assertEqual(obj.value, 0)
    4646        with AttributeSaver(obj, "value"):
    47             self.assertEquals(obj.value, None)
    48         self.assertEquals(obj.value, 0)
     47            self.assertEqual(obj.value, None)
     48        self.assertEqual(obj.value, 0)
    4949
    5050    def test_normal_value(self):
    5151        obj = self.SimpleTestClass()
    52         self.assertEquals(obj.value, 0)
     52        self.assertEqual(obj.value, 0)
    5353        with AttributeSaver(obj, "value", 1):
    54             self.assertEquals(obj.value, 1)
    55         self.assertEquals(obj.value, 0)
     54            self.assertEqual(obj.value, 1)
     55        self.assertEqual(obj.value, 0)
    5656
    5757    def test_normal_value_on_exception(self):
    5858        with self.assertRaises(RuntimeError):
    5959            obj = self.SimpleTestClass()
    60             self.assertEquals(obj.value, 0)
     60            self.assertEqual(obj.value, 0)
    6161            try:
    6262                with AttributeSaver(obj, "value", 1):
    63                     self.assertEquals(obj.value, 1)
     63                    self.assertEqual(obj.value, 1)
    6464                    raise RuntimeError()
    6565            except:
    66                 self.assertEquals(obj.value, 0)
     66                self.assertEqual(obj.value, 0)
    6767                raise
    68             self.assertEquals(obj.value, 0)
     68            self.assertEqual(obj.value, 0)
    6969
    7070    def test_normal_value_on_normal_exit(self):
    7171        obj = self.SimpleTestClass()
    72         self.assertEquals(obj.value, 0)
     72        self.assertEqual(obj.value, 0)
    7373        try:
    7474            with AttributeSaver(obj, "value", 1):
    75                 self.assertEquals(obj.value, 1)
     75                self.assertEqual(obj.value, 1)
    7676        except:
    77             self.assertEquals(obj.value, 0)
     77            self.assertEqual(obj.value, 0)
    7878            raise
    79         self.assertEquals(obj.value, 0)
     79        self.assertEqual(obj.value, 0)
    8080
    8181    def test_normal_value_with_finally_on_exception(self):
    8282        with self.assertRaises(RuntimeError):
    8383            obj = self.SimpleTestClass()
    84             self.assertEquals(obj.value, 0)
     84            self.assertEqual(obj.value, 0)
    8585            try:
    8686                with AttributeSaver(obj, "value", 1):
    87                     self.assertEquals(obj.value, 1)
     87                    self.assertEqual(obj.value, 1)
    8888                    raise RuntimeError()
    8989            finally:
    90                 self.assertEquals(obj.value, 0)
    91             self.assertEquals(obj.value, 0)
     90                self.assertEqual(obj.value, 0)
     91            self.assertEqual(obj.value, 0)
    9292
    9393    def test_normal_value_with_finally_on_normal_exit(self):
    9494        obj = self.SimpleTestClass()
    95         self.assertEquals(obj.value, 0)
     95        self.assertEqual(obj.value, 0)
    9696        try:
    9797            with AttributeSaver(obj, "value", 1):
    98                 self.assertEquals(obj.value, 1)
     98                self.assertEqual(obj.value, 1)
    9999        finally:
    100             self.assertEquals(obj.value, 0)
    101         self.assertEquals(obj.value, 0)
     100            self.assertEqual(obj.value, 0)
     101        self.assertEqual(obj.value, 0)
    102102
    103103    def test_normal_value_with_else_on_exception(self):
    104104        with self.assertRaises(RuntimeError):
    105105            obj = self.SimpleTestClass()
    106             self.assertEquals(obj.value, 0)
     106            self.assertEqual(obj.value, 0)
    107107            try:
    108108                with AttributeSaver(obj, "value", 1):
    109                     self.assertEquals(obj.value, 1)
     109                    self.assertEqual(obj.value, 1)
    110110                    raise RuntimeError()
    111111            except IOError:
    112112                self.assertFalse(True)
    113113            else:
    114                 self.assertEquals(obj.value, 0)
    115             self.assertEquals(obj.value, 0)
     114                self.assertEqual(obj.value, 0)
     115            self.assertEqual(obj.value, 0)
    116116
    117117    def test_normal_value_with_else_on_normal_exit(self):
    118118        obj = self.SimpleTestClass()
    119         self.assertEquals(obj.value, 0)
     119        self.assertEqual(obj.value, 0)
    120120        try:
    121121            with AttributeSaver(obj, "value", 1):
    122                 self.assertEquals(obj.value, 1)
     122                self.assertEqual(obj.value, 1)
    123123        except IOError:
    124124            self.assertFalse(True)
    125125        else:
    126             self.assertEquals(obj.value, 0)
    127         self.assertEquals(obj.value, 0)
     126            self.assertEqual(obj.value, 0)
     127        self.assertEqual(obj.value, 0)

  • trunk/Tools/Scripts/webkitpy/common/checkout/scm/stub_repository_unittest.py

    r257796 r284775  
    6868        host = StubRepositoryTest.mock_host_for_stub_repository()
    6969        repository = StubRepository(cwd=host.filesystem.getcwd(), filesystem=host.filesystem, executive=host.executive)
    70         self.assertEquals(repository.find_checkout_root(path=host.filesystem.join('TestDirectory', 'TestDirectory2', 'TestDirectory3')), host.filesystem.join(host.filesystem.getcwd(), 'TestDirectory', 'TestDirectory2'))
     70        self.assertEqual(repository.find_checkout_root(path=host.filesystem.join('TestDirectory', 'TestDirectory2', 'TestDirectory3')), host.filesystem.join(host.filesystem.getcwd(), 'TestDirectory', 'TestDirectory2'))
    7171
    7272    def test_find_checkout_root_failure(self):

  • trunk/Tools/Scripts/webkitpy/layout_tests/models/test_configuration_unittest.py

    r174136 r284775  
    8787    def test_eq(self):
    8888        self.assertEqual(TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'release'))
    89         self.assertNotEquals(TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'debug'))
     89        self.assertNotEqual(TestConfiguration('xp', 'x86', 'release'), TestConfiguration('xp', 'x86', 'debug'))
    9090
    9191    def test_values(self):

  • trunk/Tools/Scripts/webkitpy/layout_tests/models/test_expectations_unittest.py

    r265883 r284775  
    200200        with OutputCapture() as captured:
    201201            self.parse_exp('-- this should be a syntax error', is_lint_mode=False)
    202         self.assertNotEquals(captured.root.log.getvalue(), '')
     202        self.assertNotEqual(captured.root.log.getvalue(), '')
    203203
    204204    def test_error_on_different_platform(self):

  • trunk/Tools/Scripts/webkitpy/layout_tests/models/test_run_results_unittest.py

    r279445 r284775  
    159159        self.port._options.builder_name = 'dummy builder'
    160160        summary = summarized_results(self.port, expected=False, passing=False, flaky=False)
    161         self.assertNotEquals(summary['revision'], '')
     161        self.assertNotEqual(summary['revision'], '')
    162162
    163163    def test_svn_revision(self):
    … …  
    165165            self.port._options.builder_name = 'dummy builder'
    166166            summary = summarized_results(self.port, expected=False, passing=False, flaky=False)
    167             self.assertEquals(summary['revision'], '6')
     167            self.assertEqual(summary['revision'], '6')
    168168
    169169    def test_svn_revision_git(self):
    … …  
    171171            self.port._options.builder_name = 'dummy builder'
    172172            summary = summarized_results(self.port, expected=False, passing=False, flaky=False)
    173             self.assertEquals(summary['revision'], '9')
     173            self.assertEqual(summary['revision'], '9')
    174174
    175175    def test_summarized_results_wontfix(self):

  • trunk/Tools/Scripts/webkitpy/layout_tests/run_webkit_tests_integrationtest.py

    r281340 r284775  
    823823                                     'failures/unexpected/timeout.html'],
    824824                                    host=host)
    825         self.assertEquals(details.initial_results.slow_tests,
     825        self.assertEqual(details.initial_results.slow_tests,
    826826                          {'failures/unexpected/timeout.html'})
    827         self.assertEquals(details.retry_results.slow_tests,
     827        self.assertEqual(details.retry_results.slow_tests,
    828828                          {'failures/unexpected/timeout.html'})
    829829

  • trunk/Tools/Scripts/webkitpy/layout_tests/servers/http_server_unittest.py

    r214558 r284775  
    8989
    9090        server.start()
    91         self.assertNotEquals(host.executive.calls, [])
     91        self.assertNotEqual(host.executive.calls, [])
    9292
    9393        def wait_for_action(action):

  • trunk/Tools/Scripts/webkitpy/port/driver_unittest.py

    r276559 r284775  
    299299        driver.start(True, [])
    300300        last_tmpdir = port._filesystem.last_tmpdir
    301         self.assertNotEquals(last_tmpdir, None)
     301        self.assertNotEqual(last_tmpdir, None)
    302302        driver.stop()
    303303        self.assertFalse(port._filesystem.isdir(last_tmpdir))
    … …  
    402402            driver.start(True, [])
    403403            environ_driver = driver._setup_environ_for_test()
    404             self.assertNotEquals(environ_driver['HOME'], environ_user['HOME'])
     404            self.assertNotEqual(environ_driver['HOME'], environ_user['HOME'])
    405405            self.assertIn(str(driver._driver_tempdir), environ_driver['HOME'])
    406406            self.assertNotIn(str(driver._driver_tempdir), environ_user['HOME'])

  • trunk/Tools/Scripts/webkitpy/port/gtk_unittest.py

    r275513 r284775  
    102102        })
    103103        with OutputCapture() as _:
    104             self.assertEquals(port.expectations_files(),
     104            self.assertEqual(port.expectations_files(),
    105105                              ['/mock-checkout/LayoutTests/TestExpectations',
    106106                               '/mock-checkout/LayoutTests/platform/wk2/TestExpectations',
    … …  
    116116
    117117        with OutputCapture() as _:
    118             self.assertEquals(port.expectations_files(),
     118            self.assertEqual(port.expectations_files(),
    119119                              ['/mock-checkout/LayoutTests/TestExpectations',
    120120                               '/mock-checkout/LayoutTests/platform/wk2/TestExpectations',
    … …  
    130130
    131131        with OutputCapture() as captured:
    132             self.assertEquals(port.expectations_files(),
     132            self.assertEqual(port.expectations_files(),
    133133                              ['/mock-checkout/LayoutTests/TestExpectations',
    134134                               '/mock-checkout/LayoutTests/platform/wk2/TestExpectations',
    135135                               '/mock-checkout/LayoutTests/platform/glib/TestExpectations',
    136136                               '/mock-checkout/LayoutTests/platform/gtk/TestExpectations'])
    137             self.assertEquals(captured.root.log.getvalue(), 'Multiple WebKit2GTK libraries found. Skipping GTK4 detection.\n')
     137            self.assertEqual(captured.root.log.getvalue(), 'Multiple WebKit2GTK libraries found. Skipping GTK4 detection.\n')

  • trunk/Tools/Scripts/webkitpy/style/checkers/test_expectations_unittest.py

    r277490 r284775  
    9696            self.assertEqual(expected_output, self._error_collector.get_errors())
    9797        else:
    98             self.assertNotEquals('', self._error_collector.get_errors())
     98            self.assertNotEqual('', self._error_collector.get_errors())
    9999
    100100        # Note that a patch might change a line that introduces errors elsewhere, but we

  • trunk/Tools/Scripts/webkitpy/tool/steps/preparechangelog_unittest.py

    r265883 r284775  
    116116            step._resolve_existing_entry(path)
    117117            actual_output = step._tool.filesystem.read_text_file(path)
    118             self.assertEquals(actual_output, end_file)
     118            self.assertEqual(actual_output, end_file)
    119119
    120120    def test_ensure_bug_url(self):

  • trunk/Tools/Scripts/webkitpy/w3c/test_converter_unittest.py

    r276128 r284775  
    369369        # Verify the original paths are gone, and the new paths are present.
    370370        orig_path_pattern = re.compile('\"/resources/testharness')
    371         self.assertEquals(len(converted.findAll(src=orig_path_pattern)), 0, 'testharness src path was not converted')
    372         self.assertEquals(len(converted.findAll(href=orig_path_pattern)), 0, 'testharness href path was not converted')
     371        self.assertEqual(len(converted.findAll(src=orig_path_pattern)), 0, 'testharness src path was not converted')
     372        self.assertEqual(len(converted.findAll(href=orig_path_pattern)), 0, 'testharness href path was not converted')
    373373
    374374        new_relpath = os.path.relpath(resources_dir, test_path).replace(os.sep, '/')
    375375        relpath_pattern = re.compile(new_relpath)
    376         self.assertEquals(len(converted.findAll(src=relpath_pattern)), num_src_paths, 'testharness src relative path not correct')
    377         self.assertEquals(len(converted.findAll(href=relpath_pattern)), num_href_paths, 'testharness href relative path not correct')
     376        self.assertEqual(len(converted.findAll(src=relpath_pattern)), num_src_paths, 'testharness src relative path not correct')
     377        self.assertEqual(len(converted.findAll(href=relpath_pattern)), num_href_paths, 'testharness href relative path not correct')
    378378
    379379    def verify_prefixed_properties(self, converted, test_properties):

  • trunk/Tools/Scripts/webkitpy/w3c/test_exporter_unittest.py

    r253587 r284775  
    131131        exporter = WebPlatformTestExporter(host, options, TestExporterTest.MockGit, TestExporterTest.MockBugzilla, MockWPTGitHub, TestExporterTest.MockWPTLinter)
    132132        exporter.do_export()
    133         self.assertEquals(exporter._github.calls, ['create_pr', 'add_label "webkit-export"'])
     133        self.assertEqual(exporter._github.calls, ['create_pr', 'add_label "webkit-export"'])
    134134        self.assertTrue('WebKit export' in exporter._github.pull_requests_created[0][1])
    135         self.assertEquals(exporter._git.calls, [
     135        self.assertEqual(exporter._git.calls, [
    136136            '/mock-checkout/WebKitBuild/w3c-tests/web-platform-tests',
    137137            'fetch',
    … …  
    149149            'checkout master',
    150150            'reset hard origin/master'])
    151         self.assertEquals(exporter._bugzilla.calls, [
     151        self.assertEqual(exporter._bugzilla.calls, [
    152152            'fetch bug 1234',
    153153            'Append https://github.com/web-platform-tests/wpt/pull/5678 to see also list',
    154154            'post comment to bug 1234 : Submitted web-platform-tests pull request: https://github.com/web-platform-tests/wpt/pull/5678'])
    155         self.assertEquals(mock_linter.calls, ['/mock-checkout/WebKitBuild/w3c-tests/web-platform-tests', 'lint'])
     155        self.assertEqual(mock_linter.calls, ['/mock-checkout/WebKitBuild/w3c-tests/web-platform-tests', 'lint'])
    156156
    157157    def test_export_with_specific_branch(self):
    … …  
    161161        exporter = WebPlatformTestExporter(host, options, TestExporterTest.MockGit, TestExporterTest.MockBugzilla, MockWPTGitHub, TestExporterTest.MockWPTLinter)
    162162        exporter.do_export()
    163         self.assertEquals(exporter._git.calls, [
     163        self.assertEqual(exporter._git.calls, [
    164164            '/mock-checkout/WebKitBuild/w3c-tests/web-platform-tests',
    165165            'fetch',

  • trunk/Tools/Scripts/webkitpy/w3c/test_importer_unittest.py

    r283230 r284775  
    346346        fs = self.import_downloaded_tests(['--no-fetch', '--import-all', '-d', 'w3c'], FAKE_FILES)
    347347        self.assertFalse(fs.exists('/mock-checkout/LayoutTests/w3c/web-platform-tests/t/new-manual.html'))
    348         self.assertEquals(tests_options, fs.read_text_file('/mock-checkout/LayoutTests/tests-options.json'))
     348        self.assertEqual(tests_options, fs.read_text_file('/mock-checkout/LayoutTests/tests-options.json'))
    349349
    350350    def test_webkit_test_runner_options(self):

  • trunk/Tools/Scripts/webkitpy/w3c/test_parser_unittest.py

    r276434 r284775  
    134134        self.assertTrue(test_info['reference'].startswith(test_path), 'reference path is not correct')
    135135        self.assertTrue('reference_support_info' in test_info.keys(), 'there should be reference_support_info for this test')
    136         self.assertEquals(len(test_info['reference_support_info']['files']), 4, 'there should be 4 support files in this reference')
     136        self.assertEqual(len(test_info['reference_support_info']['files']), 4, 'there should be 4 support files in this reference')
    137137        self.assertFalse('jstest' in test_info.keys(), 'test should not have been analyzed as a jstest')
    138138

  • trunk/Tools/Scripts/webkitpy/w3c/wpt_runner_unittest.py

    r250286 r284775  
    128128
    129129        def __call__(self, script_name, wpt_checkout, wpt_args):
    130             self._test_case.assertEquals(script_name, "wptrunner_unittest")
    131             self._test_case.assertEquals(wpt_checkout, self._expected_wpt_checkout)
    132             self._test_case.assertEquals(wpt_args, self._expected_wpt_args)
     130            self._test_case.assertEqual(script_name, "wptrunner_unittest")
     131            self._test_case.assertEqual(wpt_checkout, self._expected_wpt_checkout)
     132            self._test_case.assertEqual(wpt_args, self._expected_wpt_args)
    133133
    134134    class TestInstance(object):
    … …  
    155155
    156156        expected_wpt_checkout = "/mock-checkout/WebKitBuild/w3c-tests/web-platform-tests"
    157         self.assertEquals(instance.runner._options.wpt_checkout, expected_wpt_checkout)
     157        self.assertEqual(instance.runner._options.wpt_checkout, expected_wpt_checkout)
    158158        self.assertTrue(instance.host.filesystem.isdir(expected_wpt_checkout))
    159159
    … …  
    167167
    168168        self.assertTrue(instance.runner.prepare_wpt_checkout())
    169         self.assertEquals(instance.runner._options.wpt_checkout, specified_wpt_checkout)
     169        self.assertEqual(instance.runner._options.wpt_checkout, specified_wpt_checkout)
    170170
    171171    def test_run(self):

  • trunk/Tools/Scripts/webkitpy/xcode/device_type_unittest.py

    r279496 r284775  
    3232    def test_iphone_initialization(self):
    3333        type = DeviceType(hardware_family='iPhone')
    34         self.assertEquals('iPhone', type.hardware_family)
    35         self.assertEquals(None, type.hardware_type)
    36         self.assertEquals('iOS', type.software_variant)
    37         self.assertEquals(None, type.software_version)
     34        self.assertEqual('iPhone', type.hardware_family)
     35        self.assertEqual(None, type.hardware_type)
     36        self.assertEqual('iOS', type.software_variant)
     37        self.assertEqual(None, type.software_version)
    3838        self.assertEqual('iPhone running iOS', str(type))
    3939
    4040        type = DeviceType('iPhone', '6s', Version(11))
    41         self.assertEquals('iPhone', type.hardware_family)
    42         self.assertEquals('6s', type.hardware_type)
    43         self.assertEquals('iOS', type.software_variant)
    44         self.assertEquals(Version(11), type.software_version)
     41        self.assertEqual('iPhone', type.hardware_family)
     42        self.assertEqual('6s', type.hardware_type)
     43        self.assertEqual('iOS', type.software_variant)
     44        self.assertEqual(Version(11), type.software_version)
    4545        self.assertEqual('iPhone 6s running iOS 11', str(type))
    4646
    4747    def test_ipad_initialization(self):
    4848        type = DeviceType(hardware_family='iPad')
    49         self.assertEquals('iPad', type.hardware_family)
    50         self.assertEquals(None, type.hardware_type)
    51         self.assertEquals('iOS', type.software_variant)
    52         self.assertEquals(None, type.software_version)
     49        self.assertEqual('iPad', type.hardware_family)
     50        self.assertEqual(None, type.hardware_type)
     51        self.assertEqual('iOS', type.software_variant)
     52        self.assertEqual(None, type.software_version)
    5353        self.assertEqual('iPad running iOS', str(type))
    5454
    5555        type = DeviceType('iPad', 'Air 2', Version(11))
    56         self.assertEquals('iPad', type.hardware_family)
    57         self.assertEquals('Air 2', type.hardware_type)
    58         self.assertEquals('iOS', type.software_variant)
    59         self.assertEquals(Version(11), type.software_version)
     56        self.assertEqual('iPad', type.hardware_family)
     57        self.assertEqual('Air 2', type.hardware_type)
     58        self.assertEqual('iOS', type.software_variant)
     59        self.assertEqual(Version(11), type.software_version)
    6060        self.assertEqual('iPad Air 2 running iOS 11', str(type))
    6161
    6262    def test_generic_ios_device(self):
    6363        type = DeviceType(software_variant='iOS')
    64         self.assertEquals(None, type.hardware_family)
    65         self.assertEquals(None, type.hardware_type)
    66         self.assertEquals('iOS', type.software_variant)
    67         self.assertEquals(None, type.software_version)
     64        self.assertEqual(None, type.hardware_family)
     65        self.assertEqual(None, type.hardware_type)
     66        self.assertEqual('iOS', type.software_variant)
     67        self.assertEqual(None, type.software_version)
    6868        self.assertEqual('Device running iOS', str(type))
    6969
    7070    def test_watch_initialization(self):
    7171        type = DeviceType(hardware_family='Watch')
    72         self.assertEquals('Apple Watch', type.hardware_family)
    73         self.assertEquals(None, type.hardware_type)
    74         self.assertEquals('watchOS', type.software_variant)
    75         self.assertEquals(None, type.software_version)
     72        self.assertEqual('Apple Watch', type.hardware_family)
     73        self.assertEqual(None, type.hardware_type)
     74        self.assertEqual('watchOS', type.software_variant)
     75        self.assertEqual(None, type.software_version)
    7676        self.assertEqual('Apple Watch running watchOS', str(type))
    7777
    7878        type = DeviceType('Apple Watch', 'Series 2 - 42mm', Version(4))
    79         self.assertEquals('Apple Watch', type.hardware_family)
    80         self.assertEquals('Series 2 - 42mm', type.hardware_type)
    81         self.assertEquals('watchOS', type.software_variant)
    82         self.assertEquals(Version(4), type.software_version)
     79        self.assertEqual('Apple Watch', type.hardware_family)
     80        self.assertEqual('Series 2 - 42mm', type.hardware_type)
     81        self.assertEqual('watchOS', type.software_variant)
     82        self.assertEqual(Version(4), type.software_version)
    8383        self.assertEqual('Apple Watch Series 2 - 42mm running watchOS 4', str(type))
    8484
    8585    def test_tv_initialization(self):
    8686        type = DeviceType(hardware_family='TV')
    87         self.assertEquals('Apple TV', type.hardware_family)
    88         self.assertEquals(None, type.hardware_type)
    89         self.assertEquals('tvOS', type.software_variant)
    90         self.assertEquals(None, type.software_version)
     87        self.assertEqual('Apple TV', type.hardware_family)
     88        self.assertEqual(None, type.hardware_type)
     89        self.assertEqual('tvOS', type.software_variant)
     90        self.assertEqual(None, type.software_version)
    9191        self.assertEqual('Apple TV running tvOS', str(type))
    9292
    9393        type = DeviceType('Apple TV', '4K', Version(11))
    94         self.assertEquals('Apple TV', type.hardware_family)
    95         self.assertEquals('4K', type.hardware_type)
    96         self.assertEquals('tvOS', type.software_variant)
    97         self.assertEquals(Version(11), type.software_version)
     94        self.assertEqual('Apple TV', type.hardware_family)
     95        self.assertEqual('4K', type.hardware_type)
     96        self.assertEqual('tvOS', type.software_variant)
     97        self.assertEqual(Version(11), type.software_version)
    9898        self.assertEqual('Apple TV 4K running tvOS 11', str(type))
    9999

  • trunk/Tools/Scripts/webkitpy/xcode/sdk_unittest.py

    r245364 r284775  
    7373    def test_iphoneos(self):
    7474        preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("iphoneos", self.executive)
    75         self.assertEquals("iphoneos", preferred_sdk.platform)
    76         self.assertEquals("12.0", preferred_sdk.version)
     75        self.assertEqual("iphoneos", preferred_sdk.platform)
     76        self.assertEqual("12.0", preferred_sdk.version)
    7777        self.assertTrue(preferred_sdk.internal)
    7878
    7979    def test_iphonesim(self):
    8080        preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("iphonesimulator", self.executive)
    81         self.assertEquals("iphonesimulator", preferred_sdk.platform)
    82         self.assertEquals("12.0", preferred_sdk.version)
     81        self.assertEqual("iphonesimulator", preferred_sdk.platform)
     82        self.assertEqual("12.0", preferred_sdk.version)
    8383        self.assertFalse(preferred_sdk.internal)
    8484
    8585    def test_macos(self):
    8686        preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("macosx", self.executive)
    87         self.assertEquals("macosx", preferred_sdk.platform)
    88         self.assertEquals("10.14", preferred_sdk.version)
     87        self.assertEqual("macosx", preferred_sdk.platform)
     88        self.assertEqual("10.14", preferred_sdk.version)
    8989        self.assertTrue(preferred_sdk.internal)
    9090
    9191    def test_appletvos(self):
    9292        preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("appletvos", self.executive)
    93         self.assertEquals("appletvos", preferred_sdk.platform)
    94         self.assertEquals("12.0", preferred_sdk.version)
     93        self.assertEqual("appletvos", preferred_sdk.platform)
     94        self.assertEqual("12.0", preferred_sdk.version)
    9595        self.assertTrue(preferred_sdk.internal)
    9696
    9797    def test_appletvsim(self):
    9898        preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("appletvsimulator", self.executive)
    99         self.assertEquals("appletvsimulator", preferred_sdk.platform)
    100         self.assertEquals("12.0", preferred_sdk.version)
     99        self.assertEqual("appletvsimulator", preferred_sdk.platform)
     100        self.assertEqual("12.0", preferred_sdk.version)
    101101        self.assertFalse(preferred_sdk.internal)
    102102
    103103    def test_watchos(self):
    104104        preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("watchos", self.executive)
    105         self.assertEquals("watchos", preferred_sdk.platform)
    106         self.assertEquals("4.0", preferred_sdk.version)
     105        self.assertEqual("watchos", preferred_sdk.platform)
     106        self.assertEqual("4.0", preferred_sdk.version)
    107107        self.assertTrue(preferred_sdk.internal)
    108108
    109109    def test_watchsimulator(self):
    110110        preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("watchsimulator", self.executive)
    111         self.assertEquals("watchsimulator", preferred_sdk.platform)
    112         self.assertEquals("4.0", preferred_sdk.version)
     111        self.assertEqual("watchsimulator", preferred_sdk.platform)
     112        self.assertEqual("4.0", preferred_sdk.version)
    113113        self.assertFalse(preferred_sdk.internal)
    114114
    115115    def test_prodos(self):
    116116        preferred_sdk = sdk.SDK.get_preferred_sdk_for_platform("prodos", self.executive)
    117         self.assertEquals("prodos", preferred_sdk.platform)
    118         self.assertEquals(None, preferred_sdk.version)
    119         self.assertEquals(None, preferred_sdk.internal)
     117        self.assertEqual("prodos", preferred_sdk.platform)
     118        self.assertEqual(None, preferred_sdk.version)
     119        self.assertEqual(None, preferred_sdk.internal)

  • trunk/Tools/Scripts/webkitpy/xcode/simulated_device_unittest.py

    r280882 r284775  
    569569
    570570        # There should only be 1 iPhone X, iPhone 8 and iPhone SE
    571         self.assertEquals(1, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone X'), host)))
    572         self.assertEquals(1, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone 8'), host)))
     571        self.assertEqual(1, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone X'), host)))
     572        self.assertEqual(1, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone 8'), host)))
    573573
    574574        # There should be 2 5s and 6s
    575         self.assertEquals(2, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone 5s'), host)))
    576         self.assertEquals(2, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone 6s'), host)))
     575        self.assertEqual(2, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone 5s'), host)))
     576        self.assertEqual(2, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone 6s'), host)))
    577577
    578578        # 19 iPhones
    579         self.assertEquals(19, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone'), host)))
     579        self.assertEqual(19, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPhone'), host)))
    580580
    581581        # 11 iPads
    582         self.assertEquals(11, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPad'), host)))
     582        self.assertEqual(11, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('iPad'), host)))
    583583
    584584        # 18 Apple watches
    585         self.assertEquals(6, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('Apple Watch'), host)))
     585        self.assertEqual(6, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('Apple Watch'), host)))
    586586
    587587        # 3 Apple TVs
    588         self.assertEquals(3, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('Apple TV'), host)))
     588        self.assertEqual(3, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType.from_string('Apple TV'), host)))
    589589
    590590        # 18 devices running iOS 11.0
    591         self.assertEquals(18, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType(software_variant='iOS', software_version=Version(11, 0, 1)), host)))
     591        self.assertEqual(18, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType(software_variant='iOS', software_version=Version(11, 0, 1)), host)))
    592592
    593593        # 11 iPhones running iOS 11.0
    594         self.assertEquals(11, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType(hardware_family='iPhone', software_version=Version(11, 0, 1)), host)))
     594        self.assertEqual(11, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType(hardware_family='iPhone', software_version=Version(11, 0, 1)), host)))
    595595
    596596        # 1 device running iOS 12
    597         self.assertEquals(1, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType(software_variant='iOS', software_version=Version(12, 0, 0)), host)))
     597        self.assertEqual(1, len(SimulatedDeviceManager.device_by_filter(lambda device: device.device_type == DeviceType(software_variant='iOS', software_version=Version(12, 0, 0)), host)))
    598598
    599599    def test_existing_simulator(self):
    … …  
    604604        SimulatedDeviceManager.initialize_devices(DeviceRequest(DeviceType.from_string('iPhone', Version(11))), host=host)
    605605
    606         self.assertEquals(1, len(SimulatedDeviceManager.INITIALIZED_DEVICES))
    607         self.assertEquals('34FB476C-6FA0-43C8-8945-1BD7A4EBF0DE', SimulatedDeviceManager.INITIALIZED_DEVICES[0].udid)
    608         self.assertEquals('15A8401', SimulatedDeviceManager.INITIALIZED_DEVICES[0].build_version)
    609         self.assertEquals(SimulatedDevice.DeviceState.BOOTED, SimulatedDeviceManager.INITIALIZED_DEVICES[0].platform_device.state())
     606        self.assertEqual(1, len(SimulatedDeviceManager.INITIALIZED_DEVICES))
     607        self.assertEqual('34FB476C-6FA0-43C8-8945-1BD7A4EBF0DE', SimulatedDeviceManager.INITIALIZED_DEVICES[0].udid)
     608        self.assertEqual('15A8401', SimulatedDeviceManager.INITIALIZED_DEVICES[0].build_version)
     609        self.assertEqual(SimulatedDevice.DeviceState.BOOTED, SimulatedDeviceManager.INITIALIZED_DEVICES[0].platform_device.state())
    610610
    611611        SimulatedDeviceManager.tear_down(host)
    … …  
    619619        SimulatedDeviceManager.initialize_devices(DeviceRequest(DeviceType.from_string('iphone 5s', Version(11))), host=host)
    620620
    621         self.assertEquals(1, len(SimulatedDeviceManager.INITIALIZED_DEVICES))
    622         self.assertEquals('34FB476C-6FA0-43C8-8945-1BD7A4EBF0DE', SimulatedDeviceManager.INITIALIZED_DEVICES[0].udid)
    623         self.assertEquals(SimulatedDevice.DeviceState.BOOTED, SimulatedDeviceManager.INITIALIZED_DEVICES[0].platform_device.state())
     621        self.assertEqual(1, len(SimulatedDeviceManager.INITIALIZED_DEVICES))
     622        self.assertEqual('34FB476C-6FA0-43C8-8945-1BD7A4EBF0DE', SimulatedDeviceManager.INITIALIZED_DEVICES[0].udid)
     623        self.assertEqual(SimulatedDevice.DeviceState.BOOTED, SimulatedDeviceManager.INITIALIZED_DEVICES[0].platform_device.state())
    624624
    625625        SimulatedDeviceManager.tear_down(host)
    … …  
    632632
    633633        runtime = SimulatedDeviceManager.get_runtime_for_device_type(DeviceType.from_string('iphone 5s', Version(9, 2)))
    634         self.assertEquals(runtime.os_variant, 'iOS')
    635         self.assertEquals(runtime.version, Version(9, 3))
     634        self.assertEqual(runtime.os_variant, 'iOS')
     635        self.assertEqual(runtime.version, Version(9, 3))
    636636
    637637    def test_matching_up_failure(self):
    … …  
    641641
    642642        runtime = SimulatedDeviceManager.get_runtime_for_device_type(DeviceType.from_string('iphone 5s', Version(9, 4)))
    643         self.assertEquals(runtime, None)
     643        self.assertEqual(runtime, None)
    644644
    645645    def test_no_state_files(self):
    … …  
    650650
    651651        for device in devices:
    652             self.assertEquals(SimulatedDevice.DeviceState.SHUT_DOWN, device.state(force_update=True))
     652            self.assertEqual(SimulatedDevice.DeviceState.SHUT_DOWN, device.state(force_update=True))
Note: See TracChangeset for help on using the changeset viewer.