diff --git a/lldb/packages/Python/lldbsuite/test/lldbutil.py b/lldb/packages/Python/lldbsuite/test/lldbutil.py index 506c213639e09..58eb37fd742d7 100644 --- a/lldb/packages/Python/lldbsuite/test/lldbutil.py +++ b/lldb/packages/Python/lldbsuite/test/lldbutil.py @@ -696,24 +696,24 @@ def check_breakpoint( test.assertTrue(bkpt.IsValid(), "Breakpoint is not valid.") if expected_locations is not None: - test.assertEquals(expected_locations, bkpt.GetNumLocations()) + test.assertEqual(expected_locations, bkpt.GetNumLocations()) if expected_resolved_count is not None: - test.assertEquals(expected_resolved_count, bkpt.GetNumResolvedLocations()) + test.assertEqual(expected_resolved_count, bkpt.GetNumResolvedLocations()) else: expected_resolved_count = bkpt.GetNumLocations() if location_id is None: - test.assertEquals(expected_resolved_count, bkpt.GetNumResolvedLocations()) + test.assertEqual(expected_resolved_count, bkpt.GetNumResolvedLocations()) if expected_hit_count is not None: - test.assertEquals(expected_hit_count, bkpt.GetHitCount()) + test.assertEqual(expected_hit_count, bkpt.GetHitCount()) if location_id is not None: loc_bkpt = bkpt.FindLocationByID(location_id) test.assertTrue(loc_bkpt.IsValid(), "Breakpoint location is not valid.") - test.assertEquals(loc_bkpt.IsResolved(), expected_location_resolved) + test.assertEqual(loc_bkpt.IsResolved(), expected_location_resolved) if expected_location_hit_count is not None: - test.assertEquals(expected_location_hit_count, loc_bkpt.GetHitCount()) + test.assertEqual(expected_location_hit_count, loc_bkpt.GetHitCount()) # ================================================== diff --git a/lldb/test/API/commands/disassemble/basic/TestFrameDisassemble.py b/lldb/test/API/commands/disassemble/basic/TestFrameDisassemble.py index 0fd56a069d894..0d324918d0658 100644 --- a/lldb/test/API/commands/disassemble/basic/TestFrameDisassemble.py +++ b/lldb/test/API/commands/disassemble/basic/TestFrameDisassemble.py @@ -48,7 +48,7 @@ def frame_disassemble_test(self): ) # The hit count for the breakpoint should be 1. - self.assertEquals(breakpoint.GetHitCount(), 1) + self.assertEqual(breakpoint.GetHitCount(), 1) frame = threads[0].GetFrameAtIndex(0) disassembly = frame.Disassemble() diff --git a/lldb/test/API/commands/expression/call-restarts/TestCallThatRestarts.py b/lldb/test/API/commands/expression/call-restarts/TestCallThatRestarts.py index 220cd88bf194e..214d890db3fe3 100644 --- a/lldb/test/API/commands/expression/call-restarts/TestCallThatRestarts.py +++ b/lldb/test/API/commands/expression/call-restarts/TestCallThatRestarts.py @@ -75,7 +75,7 @@ def call_function(self): value = frame.EvaluateExpression("call_me (%d)" % (num_sigchld), options) self.assertTrue(value.IsValid()) self.assertSuccess(value.GetError()) - self.assertEquals(value.GetValueAsSigned(-1), num_sigchld) + self.assertEqual(value.GetValueAsSigned(-1), num_sigchld) self.check_after_call(num_sigchld) @@ -92,7 +92,7 @@ def call_function(self): self.assertTrue(value.IsValid()) self.assertSuccess(value.GetError()) - self.assertEquals(value.GetValueAsSigned(-1), num_sigchld) + self.assertEqual(value.GetValueAsSigned(-1), num_sigchld) self.check_after_call(num_sigchld) # Now set the signal to print but not stop and make sure that calling @@ -103,7 +103,7 @@ def call_function(self): self.assertTrue(value.IsValid()) self.assertSuccess(value.GetError()) - self.assertEquals(value.GetValueAsSigned(-1), num_sigchld) + self.assertEqual(value.GetValueAsSigned(-1), num_sigchld) self.check_after_call(num_sigchld) # Now set this unwind on error to false, and make sure that we still @@ -113,7 +113,7 @@ def call_function(self): self.assertTrue(value.IsValid()) self.assertSuccess(value.GetError()) - self.assertEquals(value.GetValueAsSigned(-1), num_sigchld) + self.assertEqual(value.GetValueAsSigned(-1), num_sigchld) self.check_after_call(num_sigchld) # Okay, now set UnwindOnError to true, and then make the signal behavior to stop diff --git a/lldb/test/API/commands/expression/call-throws/TestCallThatThrows.py b/lldb/test/API/commands/expression/call-throws/TestCallThatThrows.py index 9dce2529def01..8d524ad9e9b6f 100644 --- a/lldb/test/API/commands/expression/call-throws/TestCallThatThrows.py +++ b/lldb/test/API/commands/expression/call-throws/TestCallThatThrows.py @@ -46,7 +46,7 @@ def call_function(self): value = frame.EvaluateExpression("[my_class callMeIThrow]", options) self.assertTrue(value.IsValid()) - self.assertEquals(value.GetError().Success(), False) + self.assertEqual(value.GetError().Success(), False) self.check_after_call() @@ -86,7 +86,7 @@ def call_function(self): value = frame.EvaluateExpression("[my_class iCatchMyself]", options) self.assertTrue(value.IsValid()) self.assertSuccess(value.GetError()) - self.assertEquals(value.GetValueAsUnsigned(), 57) + self.assertEqual(value.GetValueAsUnsigned(), 57) self.check_after_call() options.SetTrapExceptions(True) diff --git a/lldb/test/API/commands/expression/completion/TestExprCompletion.py b/lldb/test/API/commands/expression/completion/TestExprCompletion.py index ada818989c789..c6a1e3c0f4227 100644 --- a/lldb/test/API/commands/expression/completion/TestExprCompletion.py +++ b/lldb/test/API/commands/expression/completion/TestExprCompletion.py @@ -305,7 +305,7 @@ def assume_no_completions(self, str_input, cursor_pos=None): for m in match_strings: available_completions.append(m) - self.assertEquals( + self.assertEqual( num_matches, 0, "Got matches, but didn't expect any: " + str(available_completions), diff --git a/lldb/test/API/commands/expression/fixits/TestFixIts.py b/lldb/test/API/commands/expression/fixits/TestFixIts.py index 38b242838c828..3289bc0c5c7e0 100644 --- a/lldb/test/API/commands/expression/fixits/TestFixIts.py +++ b/lldb/test/API/commands/expression/fixits/TestFixIts.py @@ -46,7 +46,7 @@ def test_with_target(self): value = frame.EvaluateExpression("my_pointer.first", options) self.assertTrue(value.IsValid()) self.assertSuccess(value.GetError()) - self.assertEquals(value.GetValueAsUnsigned(), 10) + self.assertEqual(value.GetValueAsUnsigned(), 10) # Try with one error in a top-level expression. # The Fix-It changes "ptr.m" to "ptr->m". @@ -56,14 +56,14 @@ def test_with_target(self): # unknown error . If a parsing error would have happened we # would get a different error kind, so let's check the error # kind here. - self.assertEquals(value.GetError().GetCString(), "unknown error") + self.assertEqual(value.GetError().GetCString(), "unknown error") # Try with two errors: two_error_expression = "my_pointer.second->a" value = frame.EvaluateExpression(two_error_expression, options) self.assertTrue(value.IsValid()) self.assertSuccess(value.GetError()) - self.assertEquals(value.GetValueAsUnsigned(), 20) + self.assertEqual(value.GetValueAsUnsigned(), 20) # Try a Fix-It that is stored in the 'note:' diagnostic of an error. # The Fix-It here is adding parantheses around the ToStr parameters. @@ -71,7 +71,7 @@ def test_with_target(self): value = frame.EvaluateExpression(fixit_in_note_expr, options) self.assertTrue(value.IsValid()) self.assertSuccess(value.GetError()) - self.assertEquals(value.GetSummary(), '"(0 {, })"') + self.assertEqual(value.GetSummary(), '"(0 {, })"') # Now turn off the fixits, and the expression should fail: options.SetAutoApplyFixIts(False) @@ -178,7 +178,7 @@ def test_with_multiple_retries(self): multiple_runs_options.SetRetriesWithFixIts(2) value = frame.EvaluateExpression(two_runs_expr, multiple_runs_options) # This error signals success for top level expressions. - self.assertEquals(value.GetError().GetCString(), "unknown error") + self.assertEqual(value.GetError().GetCString(), "unknown error") # Test that the code above compiles to the right thing. self.expect_expr("test_X(1)", result_type="int", result_value="123") diff --git a/lldb/test/API/commands/expression/save_jit_objects/TestSaveJITObjects.py b/lldb/test/API/commands/expression/save_jit_objects/TestSaveJITObjects.py index 438b92cdc4846..aa125253763fd 100644 --- a/lldb/test/API/commands/expression/save_jit_objects/TestSaveJITObjects.py +++ b/lldb/test/API/commands/expression/save_jit_objects/TestSaveJITObjects.py @@ -37,7 +37,7 @@ def test_save_jit_objects(self): self.cleanJITFiles() frame.EvaluateExpression("(void*)malloc(0x1)") - self.assertEquals( + self.assertEqual( self.countJITFiles(), 0, "No files emitted with save-jit-objects-dir empty" ) diff --git a/lldb/test/API/commands/expression/test/TestExprs.py b/lldb/test/API/commands/expression/test/TestExprs.py index 0e3d2e6cf41ff..0e3215522ea6e 100644 --- a/lldb/test/API/commands/expression/test/TestExprs.py +++ b/lldb/test/API/commands/expression/test/TestExprs.py @@ -124,7 +124,7 @@ def test_evaluate_expression_python(self): ) # We should be stopped on the breakpoint with a hit count of 1. - self.assertEquals(breakpoint.GetHitCount(), 1, BREAKPOINT_HIT_ONCE) + self.assertEqual(breakpoint.GetHitCount(), 1, BREAKPOINT_HIT_ONCE) # # Use Python API to evaluate expressions while stopped in a stack frame. @@ -169,15 +169,15 @@ def test_evaluate_expression_python(self): self.expect( "expression -i true -- a_function_to_call()", substrs=["(int) $", " 1"] ) - self.assertEquals(callee_break.GetHitCount(), 1) + self.assertEqual(callee_break.GetHitCount(), 1) # Now try ignoring breakpoints using the SB API's: options = lldb.SBExpressionOptions() options.SetIgnoreBreakpoints(True) value = frame.EvaluateExpression("a_function_to_call()", options) self.assertTrue(value.IsValid()) - self.assertEquals(value.GetValueAsSigned(0), 2) - self.assertEquals(callee_break.GetHitCount(), 2) + self.assertEqual(value.GetValueAsSigned(0), 2) + self.assertEqual(callee_break.GetHitCount(), 2) # rdar://problem/8686536 # CommandInterpreter::HandleCommand is stripping \'s from input for diff --git a/lldb/test/API/commands/expression/timeout/TestCallWithTimeout.py b/lldb/test/API/commands/expression/timeout/TestCallWithTimeout.py index dc3d175b695b6..2c48024c69833 100644 --- a/lldb/test/API/commands/expression/timeout/TestCallWithTimeout.py +++ b/lldb/test/API/commands/expression/timeout/TestCallWithTimeout.py @@ -46,7 +46,7 @@ def test(self): return_value = interp.HandleCommand( "expr -t 100 -u true -- wait_a_while(1000000)", result ) - self.assertEquals(return_value, lldb.eReturnStatusFailed) + self.assertEqual(return_value, lldb.eReturnStatusFailed) # Okay, now do it again with long enough time outs: @@ -63,7 +63,7 @@ def test(self): return_value = interp.HandleCommand( "expr -t 1000000 -u true -- wait_a_while(1000)", result ) - self.assertEquals(return_value, lldb.eReturnStatusSuccessFinishResult) + self.assertEqual(return_value, lldb.eReturnStatusSuccessFinishResult) # Finally set the one thread timeout and make sure that doesn't change # things much: diff --git a/lldb/test/API/commands/expression/unwind_expression/TestUnwindExpression.py b/lldb/test/API/commands/expression/unwind_expression/TestUnwindExpression.py index ca2ba37f88387..bb173c0584a46 100644 --- a/lldb/test/API/commands/expression/unwind_expression/TestUnwindExpression.py +++ b/lldb/test/API/commands/expression/unwind_expression/TestUnwindExpression.py @@ -42,7 +42,7 @@ def test_conditional_bktp(self): main_frame = self.thread.GetFrameAtIndex(0) val = main_frame.EvaluateExpression("second_function(47)", options) self.assertSuccess(val.GetError(), "We did complete the execution.") - self.assertEquals(47, val.GetValueAsSigned()) + self.assertEqual(47, val.GetValueAsSigned()) @add_test_categories(["pyapi"]) @expectedFlakeyNetBSD diff --git a/lldb/test/API/commands/frame/language/TestGuessLanguage.py b/lldb/test/API/commands/frame/language/TestGuessLanguage.py index e2912d3bf1731..dbf581ed7a12d 100644 --- a/lldb/test/API/commands/frame/language/TestGuessLanguage.py +++ b/lldb/test/API/commands/frame/language/TestGuessLanguage.py @@ -59,7 +59,7 @@ def do_test(self): ) # The hit count for the breakpoint should be 1. - self.assertEquals(breakpoint.GetHitCount(), 1) + self.assertEqual(breakpoint.GetHitCount(), 1) thread = threads[0] diff --git a/lldb/test/API/commands/frame/var/TestFrameVar.py b/lldb/test/API/commands/frame/var/TestFrameVar.py index c43121abfe432..92e47eb45f5ca 100644 --- a/lldb/test/API/commands/frame/var/TestFrameVar.py +++ b/lldb/test/API/commands/frame/var/TestFrameVar.py @@ -52,7 +52,7 @@ def do_test(self): ) # The hit count for the breakpoint should be 1. - self.assertEquals(breakpoint.GetHitCount(), 1) + self.assertEqual(breakpoint.GetHitCount(), 1) frame = threads[0].GetFrameAtIndex(0) command_result = lldb.SBCommandReturnObject() diff --git a/lldb/test/API/commands/log/basic/TestLogging.py b/lldb/test/API/commands/log/basic/TestLogging.py index 52d86a1f81aec..daa32dc85753d 100644 --- a/lldb/test/API/commands/log/basic/TestLogging.py +++ b/lldb/test/API/commands/log/basic/TestLogging.py @@ -62,7 +62,7 @@ def test_log_truncate(self): contents = f.read() # check that it got removed - self.assertEquals(contents.find("bacon"), -1) + self.assertEqual(contents.find("bacon"), -1) # Check that lldb can append to a log file def test_log_append(self): @@ -79,7 +79,7 @@ def test_log_append(self): contents = f.read() # check that it is still there - self.assertEquals(contents.find("bacon"), 0) + self.assertEqual(contents.find("bacon"), 0) # Enable all log options and check that nothing crashes. @skipIfWindows diff --git a/lldb/test/API/commands/memory/read/TestMemoryRead.py b/lldb/test/API/commands/memory/read/TestMemoryRead.py index cd7ad1bedc706..67b28ee79067b 100644 --- a/lldb/test/API/commands/memory/read/TestMemoryRead.py +++ b/lldb/test/API/commands/memory/read/TestMemoryRead.py @@ -57,7 +57,7 @@ def test_memory_read(self): address = int(items[0], 0) argc = int(items[1], 0) self.assertGreater(address, 0) - self.assertEquals(argc, 1) + self.assertEqual(argc, 1) # (lldb) memory read --format uint32_t[] --size 4 --count 4 `&argc` # 0x7fff5fbff9a0: {0x00000001} @@ -130,7 +130,7 @@ def test_memory_read(self): # Check that we got back 4 0x0000 etc bytes for o in objects_read: self.assertEqual(len(o), expected_object_length) - self.assertEquals(len(objects_read), 4) + self.assertEqual(len(objects_read), 4) def test_memory_read_file(self): self.build_run_stop() diff --git a/lldb/test/API/commands/watchpoints/step_over_watchpoint/TestStepOverWatchpoint.py b/lldb/test/API/commands/watchpoints/step_over_watchpoint/TestStepOverWatchpoint.py index 02f0592f40de6..cde218c783f12 100644 --- a/lldb/test/API/commands/watchpoints/step_over_watchpoint/TestStepOverWatchpoint.py +++ b/lldb/test/API/commands/watchpoints/step_over_watchpoint/TestStepOverWatchpoint.py @@ -53,11 +53,11 @@ def test_step_over_read_watchpoint(self): lldb.eStopReasonWatchpoint, STOPPED_DUE_TO_WATCHPOINT, ) - self.assertEquals(thread.GetStopDescription(20), "watchpoint 1") + self.assertEqual(thread.GetStopDescription(20), "watchpoint 1") process.Continue() self.assertState(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED) - self.assertEquals(thread.GetStopDescription(20), "step over") + self.assertEqual(thread.GetStopDescription(20), "step over") self.step_inst_for_watchpoint(1) @@ -95,11 +95,11 @@ def test_step_over_write_watchpoint(self): lldb.eStopReasonWatchpoint, STOPPED_DUE_TO_WATCHPOINT, ) - self.assertEquals(thread.GetStopDescription(20), "watchpoint 1") + self.assertEqual(thread.GetStopDescription(20), "watchpoint 1") process.Continue() self.assertState(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED) - self.assertEquals(thread.GetStopDescription(20), "step over") + self.assertEqual(thread.GetStopDescription(20), "step over") self.step_inst_for_watchpoint(1) @@ -113,7 +113,7 @@ def step_inst_for_watchpoint(self, wp_id): self.assertFalse(watchpoint_hit, "Watchpoint already hit.") expected_stop_desc = "watchpoint %d" % wp_id actual_stop_desc = self.thread().GetStopDescription(20) - self.assertEquals( + self.assertEqual( actual_stop_desc, expected_stop_desc, "Watchpoint ID didn't match." ) watchpoint_hit = True diff --git a/lldb/test/API/driver/job_control/TestJobControl.py b/lldb/test/API/driver/job_control/TestJobControl.py index 632f5ef2b8654..1a1739f4cb391 100644 --- a/lldb/test/API/driver/job_control/TestJobControl.py +++ b/lldb/test/API/driver/job_control/TestJobControl.py @@ -22,7 +22,7 @@ def post_spawn(): status = int(self.child.match[1]) self.assertTrue(os.WIFSTOPPED(status)) - self.assertEquals(os.WSTOPSIG(status), signal.SIGTSTP) + self.assertEqual(os.WSTOPSIG(status), signal.SIGTSTP) os.kill(self.lldb_pid, signal.SIGCONT) diff --git a/lldb/test/API/functionalities/breakpoint/address_breakpoints/TestAddressBreakpoints.py b/lldb/test/API/functionalities/breakpoint/address_breakpoints/TestAddressBreakpoints.py index 04272ad56e478..3ceccc6e6d641 100644 --- a/lldb/test/API/functionalities/breakpoint/address_breakpoints/TestAddressBreakpoints.py +++ b/lldb/test/API/functionalities/breakpoint/address_breakpoints/TestAddressBreakpoints.py @@ -64,7 +64,7 @@ def address_breakpoints(self): ) # The hit count for the breakpoint should be 1. - self.assertEquals(breakpoint.GetHitCount(), 1) + self.assertEqual(breakpoint.GetHitCount(), 1) process.Kill() @@ -82,4 +82,4 @@ def address_breakpoints(self): # The hit count for the breakpoint should be 1, since we reset counts # for each run. - self.assertEquals(breakpoint.GetHitCount(), 1) + self.assertEqual(breakpoint.GetHitCount(), 1) diff --git a/lldb/test/API/functionalities/breakpoint/address_breakpoints/TestBadAddressBreakpoints.py b/lldb/test/API/functionalities/breakpoint/address_breakpoints/TestBadAddressBreakpoints.py index 1b44a6183c982..0ab11a427c100 100644 --- a/lldb/test/API/functionalities/breakpoint/address_breakpoints/TestBadAddressBreakpoints.py +++ b/lldb/test/API/functionalities/breakpoint/address_breakpoints/TestBadAddressBreakpoints.py @@ -40,7 +40,7 @@ def address_breakpoints(self): bkpt = target.BreakpointCreateByAddress(illegal_address) # Verify that breakpoint is not resolved. for bp_loc in bkpt: - self.assertEquals(bp_loc.IsResolved(), False) + self.assertEqual(bp_loc.IsResolved(), False) else: self.fail( "Could not find an illegal address at which to set a bad breakpoint." diff --git a/lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py b/lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py index da7557cc33c41..923d8f8dc9ae5 100644 --- a/lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py +++ b/lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py @@ -361,8 +361,8 @@ def breakpoint_command_sequence(self): self.runCmd("run", RUN_SUCCEEDED) # Check the value of canary variables. - self.assertEquals("one liner was here", side_effect.one_liner) - self.assertEquals("function was here", side_effect.bktptcmd) + self.assertEqual("one liner was here", side_effect.one_liner) + self.assertEqual("function was here", side_effect.bktptcmd) # Finish the program. self.runCmd("process continue") @@ -558,10 +558,10 @@ def get_source_map_json(self): return json.loads(stream.GetData()) def verify_source_map_entry_pair(self, entry, original, replacement): - self.assertEquals( + self.assertEqual( entry[0], original, "source map entry 'original' does not match" ) - self.assertEquals( + self.assertEqual( entry[1], replacement, "source map entry 'replacement' does not match" ) @@ -604,7 +604,7 @@ def test_breakpoints_auto_source_map_relative(self): # "./a/b/c/main.cpp". source_map_json = self.get_source_map_json() - self.assertEquals( + self.assertEqual( len(source_map_json), 0, "source map should be empty initially" ) self.verify_source_map_deduce_statistics(target, 0) @@ -621,7 +621,7 @@ def test_breakpoints_auto_source_map_relative(self): ) source_map_json = self.get_source_map_json() - self.assertEquals(len(source_map_json), 1, "source map should not be empty") + self.assertEqual(len(source_map_json), 1, "source map should not be empty") self.verify_source_map_entry_pair(source_map_json[0], ".", "/x/y") self.verify_source_map_deduce_statistics(target, 1) @@ -640,7 +640,7 @@ def test_breakpoints_auto_source_map_relative(self): ) source_map_json = self.get_source_map_json() - self.assertEquals(len(source_map_json), 0, "source map should not be deduced") + self.assertEqual(len(source_map_json), 0, "source map should not be deduced") def test_breakpoint_statistics_hitcount(self): """Test breakpoints statistics have hitCount field.""" diff --git a/lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py b/lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py index 6bda9b5f5c79b..36f37870629be 100644 --- a/lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py +++ b/lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py @@ -163,7 +163,7 @@ def do_set_python_command_from_python(self): # Now finish, and make sure the return value is correct. threads = lldbutil.get_threads_stopped_at_breakpoint(self.process, body_bkpt) - self.assertEquals(len(threads), 1, "Stopped at inner breakpoint.") + self.assertEqual(len(threads), 1, "Stopped at inner breakpoint.") self.thread = threads[0] print( @@ -171,12 +171,12 @@ def do_set_python_command_from_python(self): list_bkpt.GetNumLocations(), list_bkpt.GetHitCount() ) ) - self.assertEquals("callback was here", side_effect.callback) - self.assertEquals("function was here", side_effect.bktptcmd) - self.assertEquals("I am fancy", side_effect.fancy) - self.assertEquals("I am fancier", side_effect.fancier) - self.assertEquals("Not so fancy", side_effect.not_so_fancy) - self.assertEquals("I come from list input", side_effect.from_list) + self.assertEqual("callback was here", side_effect.callback) + self.assertEqual("function was here", side_effect.bktptcmd) + self.assertEqual("I am fancy", side_effect.fancy) + self.assertEqual("I am fancier", side_effect.fancier) + self.assertEqual("Not so fancy", side_effect.not_so_fancy) + self.assertEqual("I come from list input", side_effect.from_list) def do_bad_args_to_python_command(self): error = lldb.SBError() diff --git a/lldb/test/API/functionalities/breakpoint/breakpoint_ids/TestBreakpointIDs.py b/lldb/test/API/functionalities/breakpoint/breakpoint_ids/TestBreakpointIDs.py index ca87a78a0c810..929ddf18ad030 100644 --- a/lldb/test/API/functionalities/breakpoint/breakpoint_ids/TestBreakpointIDs.py +++ b/lldb/test/API/functionalities/breakpoint/breakpoint_ids/TestBreakpointIDs.py @@ -18,17 +18,17 @@ def test(self): bpno = lldbutil.run_break_set_by_symbol( self, "product", num_expected_locations=-1, sym_exact=False ) - self.assertEquals(bpno, 1, "First breakpoint number is 1.") + self.assertEqual(bpno, 1, "First breakpoint number is 1.") bpno = lldbutil.run_break_set_by_symbol( self, "sum", num_expected_locations=-1, sym_exact=False ) - self.assertEquals(bpno, 2, "Second breakpoint number is 2.") + self.assertEqual(bpno, 2, "Second breakpoint number is 2.") bpno = lldbutil.run_break_set_by_symbol( self, "junk", num_expected_locations=0, sym_exact=False ) - self.assertEquals(bpno, 3, "Third breakpoint number is 3.") + self.assertEqual(bpno, 3, "Third breakpoint number is 3.") self.expect( "breakpoint disable 1.1 - 2.2 ", diff --git a/lldb/test/API/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py b/lldb/test/API/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py index b6c8fc4327739..8930bea619bb6 100644 --- a/lldb/test/API/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py +++ b/lldb/test/API/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py @@ -70,7 +70,7 @@ def shadowed_bkpt_cond_test(self): bkpt_cond = "1 == 0" bkpt.SetCondition(bkpt_cond) self.assertEqual(bkpt.GetCondition(), bkpt_cond, "Successfully set condition") - self.assertEquals( + self.assertEqual( bkpt.location[0].GetCondition(), bkpt.GetCondition(), "Conditions are the same", diff --git a/lldb/test/API/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py b/lldb/test/API/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py index ff34ec82a945e..330f916a907e6 100644 --- a/lldb/test/API/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py +++ b/lldb/test/API/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py @@ -130,12 +130,12 @@ def do_check_names(self): name_list = lldb.SBStringList() bkpt.GetNames(name_list) num_names = name_list.GetSize() - self.assertEquals( + self.assertEqual( num_names, 1, "Name list has %d items, expected 1." % (num_names) ) name = name_list.GetStringAtIndex(0) - self.assertEquals( + self.assertEqual( name, other_bkpt_name, "Remaining name was: %s expected %s." % (name, other_bkpt_name), @@ -190,10 +190,10 @@ def do_check_using_names(self): bkpts = lldb.SBBreakpointList(self.target) self.target.FindBreakpointsByName(bkpt_name, bkpts) - self.assertEquals(bkpts.GetSize(), 1, "One breakpoint matched.") + self.assertEqual(bkpts.GetSize(), 1, "One breakpoint matched.") found_bkpt = bkpts.GetBreakpointAtIndex(0) - self.assertEquals(bkpt.GetID(), found_bkpt.GetID(), "The right breakpoint.") - self.assertEquals(bkpt.GetID(), bkpt_id, "With the same ID as before.") + self.assertEqual(bkpt.GetID(), found_bkpt.GetID(), "The right breakpoint.") + self.assertEqual(bkpt.GetID(), bkpt_id, "With the same ID as before.") retval = lldb.SBCommandReturnObject() self.dbg.GetCommandInterpreter().HandleCommand( diff --git a/lldb/test/API/functionalities/breakpoint/consecutive_breakpoints/TestConsecutiveBreakpoints.py b/lldb/test/API/functionalities/breakpoint/consecutive_breakpoints/TestConsecutiveBreakpoints.py index b7d258d988583..73de4a294388b 100644 --- a/lldb/test/API/functionalities/breakpoint/consecutive_breakpoints/TestConsecutiveBreakpoints.py +++ b/lldb/test/API/functionalities/breakpoint/consecutive_breakpoints/TestConsecutiveBreakpoints.py @@ -27,7 +27,7 @@ def prepare_test(self): address = frame.GetPCAddress() instructions = self.target.ReadInstructions(address, 2) - self.assertEquals(len(instructions), 2) + self.assertEqual(len(instructions), 2) self.bkpt_address = instructions[1].GetAddress() self.breakpoint2 = self.target.BreakpointCreateByAddress( self.bkpt_address.GetLoadAddress(self.target) @@ -68,7 +68,7 @@ def test_single_step(self): self.thread.StepInstruction(step_over) self.assertState(self.process.GetState(), lldb.eStateStopped) - self.assertEquals( + self.assertEqual( self.thread.GetFrameAtIndex(0).GetPCAddress().GetLoadAddress(self.target), self.bkpt_address.GetLoadAddress(self.target), ) @@ -96,11 +96,11 @@ def test_single_step_thread_specific(self): self.thread.StepInstruction(step_over) self.assertState(self.process.GetState(), lldb.eStateStopped) - self.assertEquals( + self.assertEqual( self.thread.GetFrameAtIndex(0).GetPCAddress().GetLoadAddress(self.target), self.bkpt_address.GetLoadAddress(self.target), ) - self.assertEquals( + self.assertEqual( self.thread.GetStopReason(), lldb.eStopReasonPlanComplete, "Stop reason should be 'plan complete'", diff --git a/lldb/test/API/functionalities/breakpoint/cpp/TestCPPBreakpointLocations.py b/lldb/test/API/functionalities/breakpoint/cpp/TestCPPBreakpointLocations.py index 417fe7086063b..84bd170e26613 100644 --- a/lldb/test/API/functionalities/breakpoint/cpp/TestCPPBreakpointLocations.py +++ b/lldb/test/API/functionalities/breakpoint/cpp/TestCPPBreakpointLocations.py @@ -27,7 +27,7 @@ def verify_breakpoint_locations(self, target, bp_dict): name = bp_dict["name"] names = bp_dict["loc_names"] bp = target.BreakpointCreateByName(name) - self.assertEquals( + self.assertEqual( bp.GetNumLocations(), len(names), "Make sure we find the right number of breakpoint locations for {}".format( @@ -157,7 +157,7 @@ def test_destructors(self): bp_loc_names = { bp_loc.GetAddress().GetFunction().GetName() for bp_loc in bp } - self.assertEquals( + self.assertEqual( bp_loc_names, loc_names, "Breakpoint set on the correct symbol" ) @@ -165,13 +165,13 @@ def test_destructors(self): symbol_addresses = set() for symbol in symbols: sc_list = target.FindSymbols(symbol, lldb.eSymbolTypeCode) - self.assertEquals(sc_list.GetSize(), 1, "Found symbol " + symbol) + self.assertEqual(sc_list.GetSize(), 1, "Found symbol " + symbol) symbol = sc_list.GetContextAtIndex(0).GetSymbol() symbol_addresses.add( symbol.GetStartAddress().GetLoadAddress(target) ) - self.assertEquals( + self.assertEqual( symbol_addresses, bp_addresses, "Breakpoint set on correct address" ) finally: diff --git a/lldb/test/API/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py b/lldb/test/API/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py index e6e35ded20f4e..eef2ee3bd8aa4 100644 --- a/lldb/test/API/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py +++ b/lldb/test/API/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py @@ -51,7 +51,7 @@ def do_cpp_exception_bkpt(self): thread_list = lldbutil.get_threads_stopped_at_breakpoint( process, exception_bkpt ) - self.assertEquals( + self.assertEqual( len(thread_list), 1, "One thread stopped at the exception breakpoint." ) @@ -84,6 +84,6 @@ def do_dummy_target_cpp_exception_bkpt(self): thread_list = lldbutil.get_threads_stopped_at_breakpoint( process, exception_bkpt ) - self.assertEquals( + self.assertEqual( len(thread_list), 1, "One thread stopped at the exception breakpoint." ) diff --git a/lldb/test/API/functionalities/breakpoint/source_regexp/TestSourceRegexBreakpoints.py b/lldb/test/API/functionalities/breakpoint/source_regexp/TestSourceRegexBreakpoints.py index 19df46fa817f9..00bcde39bdfe1 100644 --- a/lldb/test/API/functionalities/breakpoint/source_regexp/TestSourceRegexBreakpoints.py +++ b/lldb/test/API/functionalities/breakpoint/source_regexp/TestSourceRegexBreakpoints.py @@ -52,7 +52,7 @@ def source_regex_locations(self): a_func_line = line_number("a.c", "Set A breakpoint here") line_entry = address.GetLineEntry() self.assertTrue(line_entry.IsValid(), "Got a valid line entry.") - self.assertEquals( + self.assertEqual( line_entry.line, a_func_line, "Our line number matches the one lldbtest found.", diff --git a/lldb/test/API/functionalities/breakpoint/step_over_breakpoint/TestStepOverBreakpoint.py b/lldb/test/API/functionalities/breakpoint/step_over_breakpoint/TestStepOverBreakpoint.py index 2daeb194ac917..15539b022bc85 100644 --- a/lldb/test/API/functionalities/breakpoint/step_over_breakpoint/TestStepOverBreakpoint.py +++ b/lldb/test/API/functionalities/breakpoint/step_over_breakpoint/TestStepOverBreakpoint.py @@ -59,7 +59,7 @@ def setUp(self): def test_step_instruction(self): # Count instructions between breakpoint_1 and breakpoint_4 contextList = self.target.FindFunctions("main", lldb.eFunctionNameTypeAuto) - self.assertEquals(contextList.GetSize(), 1) + self.assertEqual(contextList.GetSize(), 1) symbolContext = contextList.GetContextAtIndex(0) function = symbolContext.GetFunction() self.assertTrue(function) @@ -83,7 +83,7 @@ def test_step_instruction(self): ) if self.thread.GetStopReason() == lldb.eStopReasonBreakpoint: # we should not stop on breakpoint_2 and _3 because they have false condition - self.assertEquals( + self.assertEqual( self.thread.GetFrameAtIndex(0).GetLineEntry().GetLine(), self.line4 ) # breakpoint_2 and _3 should not affect step count @@ -113,13 +113,13 @@ def test_step_over(self): thread1 = lldbutil.get_one_thread_stopped_at_breakpoint( self.process, self.breakpoint4 ) - self.assertEquals(self.thread, thread1, "Didn't stop at breakpoint 4.") + self.assertEqual(self.thread, thread1, "Didn't stop at breakpoint 4.") # Check that stepping does not affect breakpoint's hit count - self.assertEquals(self.breakpoint1.GetHitCount(), 1) - self.assertEquals(self.breakpoint2.GetHitCount(), 0) - self.assertEquals(self.breakpoint3.GetHitCount(), 0) - self.assertEquals(self.breakpoint4.GetHitCount(), 1) + self.assertEqual(self.breakpoint1.GetHitCount(), 1) + self.assertEqual(self.breakpoint2.GetHitCount(), 0) + self.assertEqual(self.breakpoint3.GetHitCount(), 0) + self.assertEqual(self.breakpoint4.GetHitCount(), 1) # Run the process until termination self.process.Continue() diff --git a/lldb/test/API/functionalities/breakpoint/thread_plan_user_breakpoint/TestThreadPlanUserBreakpoint.py b/lldb/test/API/functionalities/breakpoint/thread_plan_user_breakpoint/TestThreadPlanUserBreakpoint.py index ee597ad2b148c..3f367f6e183f9 100644 --- a/lldb/test/API/functionalities/breakpoint/thread_plan_user_breakpoint/TestThreadPlanUserBreakpoint.py +++ b/lldb/test/API/functionalities/breakpoint/thread_plan_user_breakpoint/TestThreadPlanUserBreakpoint.py @@ -43,12 +43,12 @@ def check_correct_stop_reason(self, breakpoint_idx, condition): thread1 = lldbutil.get_one_thread_stopped_at_breakpoint( self.process, self.breakpoints[breakpoint_idx] ) - self.assertEquals( + self.assertEqual( self.thread, thread1, "Didn't stop at breakpoint %i." % breakpoint_idx ) else: # Breakpoints are inactive, stop reason is plan complete - self.assertEquals( + self.assertEqual( self.thread.GetStopReason(), lldb.eStopReasonPlanComplete, "Expected stop reason to be step into/over/out for inactive breakpoint %i line." diff --git a/lldb/test/API/functionalities/data-formatter/format-propagation/TestFormatPropagation.py b/lldb/test/API/functionalities/data-formatter/format-propagation/TestFormatPropagation.py index 5c6ba29eeab91..a13ca0eae8315 100644 --- a/lldb/test/API/functionalities/data-formatter/format-propagation/TestFormatPropagation.py +++ b/lldb/test/API/functionalities/data-formatter/format-propagation/TestFormatPropagation.py @@ -51,23 +51,23 @@ def cleanup(): Y = parent.GetChildMemberWithName("Y") self.assertTrue(Y is not None and Y.IsValid(), "could not find Y") # check their values now - self.assertEquals(X.GetValue(), "1", "X has an invalid value") - self.assertEquals(Y.GetValue(), "2", "Y has an invalid value") + self.assertEqual(X.GetValue(), "1", "X has an invalid value") + self.assertEqual(Y.GetValue(), "2", "Y has an invalid value") # set the format on the parent parent.SetFormat(lldb.eFormatHex) self.assertEqual(X.GetValue(), "0x00000001", "X has not changed format") self.assertEqual(Y.GetValue(), "0x00000002", "Y has not changed format") # Step and check if the values make sense still self.runCmd("next") - self.assertEquals(X.GetValue(), "0x00000004", "X has not become 4") - self.assertEquals(Y.GetValue(), "0x00000002", "Y has not stuck as hex") + self.assertEqual(X.GetValue(), "0x00000004", "X has not become 4") + self.assertEqual(Y.GetValue(), "0x00000002", "Y has not stuck as hex") # Check that children can still make their own choices Y.SetFormat(lldb.eFormatDecimal) - self.assertEquals(X.GetValue(), "0x00000004", "X is still hex") - self.assertEquals(Y.GetValue(), "2", "Y has not been reset") + self.assertEqual(X.GetValue(), "0x00000004", "X is still hex") + self.assertEqual(Y.GetValue(), "2", "Y has not been reset") # Make a few more changes parent.SetFormat(lldb.eFormatDefault) X.SetFormat(lldb.eFormatHex) Y.SetFormat(lldb.eFormatDefault) self.assertEqual(X.GetValue(), "0x00000004", "X is not hex as it asked") - self.assertEquals(Y.GetValue(), "2", "Y is not defaulted") + self.assertEqual(Y.GetValue(), "2", "Y is not defaulted") diff --git a/lldb/test/API/functionalities/diagnostic_reporting/TestDiagnosticReporting.py b/lldb/test/API/functionalities/diagnostic_reporting/TestDiagnosticReporting.py index c24cf46c6e663..36a3be695628f 100644 --- a/lldb/test/API/functionalities/diagnostic_reporting/TestDiagnosticReporting.py +++ b/lldb/test/API/functionalities/diagnostic_reporting/TestDiagnosticReporting.py @@ -29,10 +29,10 @@ def test_dwarf_symbol_loading_diagnostic_report(self): event = lldbutil.fetch_next_event(self, self.listener, self.broadcaster) diagnostic_data = lldb.SBDebugger.GetDiagnosticFromEvent(event) - self.assertEquals( + self.assertEqual( diagnostic_data.GetValueForKey("type").GetStringValue(100), "warning" ) - self.assertEquals( + self.assertEqual( diagnostic_data.GetValueForKey("message").GetStringValue(100), "unable to retrieve process ID from minidump file, setting process ID to 1", ) diff --git a/lldb/test/API/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py b/lldb/test/API/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py index 6e19006f00448..bbe9ba209ad2b 100644 --- a/lldb/test/API/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py +++ b/lldb/test/API/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py @@ -67,9 +67,9 @@ def test_get_dynamic_vals(self): self.assertState(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED) b = self.frame().FindVariable("b").GetDynamicValue(lldb.eDynamicCanRunTarget) - self.assertEquals(b.GetNumChildren(), 0, "b has 0 children") + self.assertEqual(b.GetNumChildren(), 0, "b has 0 children") self.runCmd("continue") - self.assertEquals(b.GetNumChildren(), 0, "b still has 0 children") + self.assertEqual(b.GetNumChildren(), 0, "b still has 0 children") self.runCmd("continue") self.assertNotEqual(b.GetNumChildren(), 0, "b now has 1 child") self.runCmd("continue") diff --git a/lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteClient.py b/lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteClient.py index 2f4c8d799a6f0..5eb3fc3cada92 100644 --- a/lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteClient.py +++ b/lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteClient.py @@ -63,7 +63,7 @@ def vAttach(self, pid): error = lldb.SBError() target.AttachToProcessWithID(lldb.SBListener(), 47, error) - self.assertEquals(error_msg, error.GetCString()) + self.assertEqual(error_msg, error.GetCString()) def test_launch_fail(self): class MyResponder(MockGDBServerResponder): @@ -132,11 +132,11 @@ def test_read_registers_using_g_packets(self): target = self.createTarget("a.yaml") process = self.connect(target) - self.assertEquals(1, self.server.responder.packetLog.count("g")) + self.assertEqual(1, self.server.responder.packetLog.count("g")) self.server.responder.packetLog = [] self.read_registers(process) # Reading registers should not cause any 'p' packets to be exchanged. - self.assertEquals( + self.assertEqual( 0, len([p for p in self.server.responder.packetLog if p.startswith("p")]) ) @@ -162,7 +162,7 @@ def test_write_registers_using_P_packets(self): process = self.connect(target) self.write_registers(process) - self.assertEquals( + self.assertEqual( 0, len([p for p in self.server.responder.packetLog if p.startswith("G")]) ) self.assertGreater( @@ -182,7 +182,7 @@ def readRegister(self, register): process = self.connect(target) self.write_registers(process) - self.assertEquals( + self.assertEqual( 0, len([p for p in self.server.responder.packetLog if p.startswith("P")]) ) self.assertGreater( @@ -191,7 +191,7 @@ def readRegister(self, register): def read_registers(self, process): self.for_each_gpr( - process, lambda r: self.assertEquals("0x0000000000000000", r.GetValue()) + process, lambda r: self.assertEqual("0x0000000000000000", r.GetValue()) ) def write_registers(self, process): diff --git a/lldb/test/API/functionalities/gdb_remote_client/TestGdbClientModuleLoad.py b/lldb/test/API/functionalities/gdb_remote_client/TestGdbClientModuleLoad.py index 345d7844c2803..2286c384d2320 100644 --- a/lldb/test/API/functionalities/gdb_remote_client/TestGdbClientModuleLoad.py +++ b/lldb/test/API/functionalities/gdb_remote_client/TestGdbClientModuleLoad.py @@ -150,4 +150,4 @@ def test_vdso(self): self.filecheck("image list", __file__, "-check-prefix=VDSO") # VDSO: [ 0] {{.*}} 0x0000000000ee0000 {{.*}}module_load # VDSO: [ 1] {{.*}} 0x0000000000ef0000 {{.*}}[vdso] - self.assertEquals(self.target().GetNumModules(), 2) + self.assertEqual(self.target().GetNumModules(), 2) diff --git a/lldb/test/API/functionalities/gdb_remote_client/TestWasm.py b/lldb/test/API/functionalities/gdb_remote_client/TestWasm.py index 61f315bb65ca5..733f40b5e1429 100644 --- a/lldb/test/API/functionalities/gdb_remote_client/TestWasm.py +++ b/lldb/test/API/functionalities/gdb_remote_client/TestWasm.py @@ -110,43 +110,43 @@ def test_load_module_with_embedded_symbols_from_remote(self): ) num_modules = target.GetNumModules() - self.assertEquals(1, num_modules) + self.assertEqual(1, num_modules) module = target.GetModuleAtIndex(0) num_sections = module.GetNumSections() - self.assertEquals(5, num_sections) + self.assertEqual(5, num_sections) code_section = module.GetSectionAtIndex(0) - self.assertEquals("code", code_section.GetName()) - self.assertEquals( + self.assertEqual("code", code_section.GetName()) + self.assertEqual( load_address | code_section.GetFileOffset(), code_section.GetLoadAddress(target), ) debug_info_section = module.GetSectionAtIndex(1) - self.assertEquals(".debug_info", debug_info_section.GetName()) - self.assertEquals( + self.assertEqual(".debug_info", debug_info_section.GetName()) + self.assertEqual( load_address | debug_info_section.GetFileOffset(), debug_info_section.GetLoadAddress(target), ) debug_abbrev_section = module.GetSectionAtIndex(2) - self.assertEquals(".debug_abbrev", debug_abbrev_section.GetName()) - self.assertEquals( + self.assertEqual(".debug_abbrev", debug_abbrev_section.GetName()) + self.assertEqual( load_address | debug_abbrev_section.GetFileOffset(), debug_abbrev_section.GetLoadAddress(target), ) debug_line_section = module.GetSectionAtIndex(3) - self.assertEquals(".debug_line", debug_line_section.GetName()) - self.assertEquals( + self.assertEqual(".debug_line", debug_line_section.GetName()) + self.assertEqual( load_address | debug_line_section.GetFileOffset(), debug_line_section.GetLoadAddress(target), ) debug_str_section = module.GetSectionAtIndex(4) - self.assertEquals(".debug_str", debug_str_section.GetName()) - self.assertEquals( + self.assertEqual(".debug_str", debug_str_section.GetName()) + self.assertEqual( load_address | debug_line_section.GetFileOffset(), debug_line_section.GetLoadAddress(target), ) @@ -180,40 +180,40 @@ def test_load_module_with_stripped_symbols_from_remote(self): ) num_modules = target.GetNumModules() - self.assertEquals(1, num_modules) + self.assertEqual(1, num_modules) module = target.GetModuleAtIndex(0) num_sections = module.GetNumSections() - self.assertEquals(5, num_sections) + self.assertEqual(5, num_sections) code_section = module.GetSectionAtIndex(0) - self.assertEquals("code", code_section.GetName()) - self.assertEquals( + self.assertEqual("code", code_section.GetName()) + self.assertEqual( load_address | code_section.GetFileOffset(), code_section.GetLoadAddress(target), ) debug_info_section = module.GetSectionAtIndex(1) - self.assertEquals(".debug_info", debug_info_section.GetName()) - self.assertEquals( + self.assertEqual(".debug_info", debug_info_section.GetName()) + self.assertEqual( LLDB_INVALID_ADDRESS, debug_info_section.GetLoadAddress(target) ) debug_abbrev_section = module.GetSectionAtIndex(2) - self.assertEquals(".debug_abbrev", debug_abbrev_section.GetName()) - self.assertEquals( + self.assertEqual(".debug_abbrev", debug_abbrev_section.GetName()) + self.assertEqual( LLDB_INVALID_ADDRESS, debug_abbrev_section.GetLoadAddress(target) ) debug_line_section = module.GetSectionAtIndex(3) - self.assertEquals(".debug_line", debug_line_section.GetName()) - self.assertEquals( + self.assertEqual(".debug_line", debug_line_section.GetName()) + self.assertEqual( LLDB_INVALID_ADDRESS, debug_line_section.GetLoadAddress(target) ) debug_str_section = module.GetSectionAtIndex(4) - self.assertEquals(".debug_str", debug_str_section.GetName()) - self.assertEquals( + self.assertEqual(".debug_str", debug_str_section.GetName()) + self.assertEqual( LLDB_INVALID_ADDRESS, debug_line_section.GetLoadAddress(target) ) @@ -236,39 +236,39 @@ def test_load_module_from_file(self): ) num_modules = target.GetNumModules() - self.assertEquals(1, num_modules) + self.assertEqual(1, num_modules) module = target.GetModuleAtIndex(0) num_sections = module.GetNumSections() - self.assertEquals(5, num_sections) + self.assertEqual(5, num_sections) code_section = module.GetSectionAtIndex(0) - self.assertEquals("code", code_section.GetName()) - self.assertEquals( + self.assertEqual("code", code_section.GetName()) + self.assertEqual( load_address | code_section.GetFileOffset(), code_section.GetLoadAddress(target), ) debug_info_section = module.GetSectionAtIndex(1) - self.assertEquals(".debug_info", debug_info_section.GetName()) - self.assertEquals( + self.assertEqual(".debug_info", debug_info_section.GetName()) + self.assertEqual( LLDB_INVALID_ADDRESS, debug_info_section.GetLoadAddress(target) ) debug_abbrev_section = module.GetSectionAtIndex(2) - self.assertEquals(".debug_abbrev", debug_abbrev_section.GetName()) - self.assertEquals( + self.assertEqual(".debug_abbrev", debug_abbrev_section.GetName()) + self.assertEqual( LLDB_INVALID_ADDRESS, debug_abbrev_section.GetLoadAddress(target) ) debug_line_section = module.GetSectionAtIndex(3) - self.assertEquals(".debug_line", debug_line_section.GetName()) - self.assertEquals( + self.assertEqual(".debug_line", debug_line_section.GetName()) + self.assertEqual( LLDB_INVALID_ADDRESS, debug_line_section.GetLoadAddress(target) ) debug_str_section = module.GetSectionAtIndex(4) - self.assertEquals(".debug_str", debug_str_section.GetName()) - self.assertEquals( + self.assertEqual(".debug_str", debug_str_section.GetName()) + self.assertEqual( LLDB_INVALID_ADDRESS, debug_line_section.GetLoadAddress(target) ) diff --git a/lldb/test/API/functionalities/gdb_remote_client/TestqOffsets.py b/lldb/test/API/functionalities/gdb_remote_client/TestqOffsets.py index 5697bfd8c35bc..a1adc20e864ba 100644 --- a/lldb/test/API/functionalities/gdb_remote_client/TestqOffsets.py +++ b/lldb/test/API/functionalities/gdb_remote_client/TestqOffsets.py @@ -14,7 +14,7 @@ def test(self): self.server.responder = TestqOffsets.Responder() target = self.createTarget("qOffsets.yaml") text = target.modules[0].FindSection(".text") - self.assertEquals(text.GetLoadAddress(target), lldb.LLDB_INVALID_ADDRESS) + self.assertEqual(text.GetLoadAddress(target), lldb.LLDB_INVALID_ADDRESS) process = self.connect(target) - self.assertEquals(text.GetLoadAddress(target), 0x471000) + self.assertEqual(text.GetLoadAddress(target), 0x471000) diff --git a/lldb/test/API/functionalities/limit-debug-info/TestLimitDebugInfo.py b/lldb/test/API/functionalities/limit-debug-info/TestLimitDebugInfo.py index bf45202ac316e..18371669462e2 100644 --- a/lldb/test/API/functionalities/limit-debug-info/TestLimitDebugInfo.py +++ b/lldb/test/API/functionalities/limit-debug-info/TestLimitDebugInfo.py @@ -19,7 +19,7 @@ def _check_type(self, target, name): base = type_.GetDirectBaseClassAtIndex(0).GetType() self.trace("base:%s" % base) self.assertTrue(base) - self.assertEquals(base.GetNumberOfFields(), 0) + self.assertEqual(base.GetNumberOfFields(), 0) self.assertFalse(base.IsTypeComplete()) def _check_debug_info_is_limited(self, target): diff --git a/lldb/test/API/functionalities/load_lazy/TestLoadUsingLazyBind.py b/lldb/test/API/functionalities/load_lazy/TestLoadUsingLazyBind.py index ed12b288c06e1..2783aaff1a0ed 100644 --- a/lldb/test/API/functionalities/load_lazy/TestLoadUsingLazyBind.py +++ b/lldb/test/API/functionalities/load_lazy/TestLoadUsingLazyBind.py @@ -62,4 +62,4 @@ def make_lib_path(name): frame = thread.GetFrameAtIndex(0) val = frame.EvaluateExpression("f1()") self.assertTrue(val.IsValid()) - self.assertEquals(val.GetValueAsSigned(-1), 5) + self.assertEqual(val.GetValueAsSigned(-1), 5) diff --git a/lldb/test/API/functionalities/memory/cache/TestMemoryCache.py b/lldb/test/API/functionalities/memory/cache/TestMemoryCache.py index 2c8a5a6d0237a..718215ba1d230 100644 --- a/lldb/test/API/functionalities/memory/cache/TestMemoryCache.py +++ b/lldb/test/API/functionalities/memory/cache/TestMemoryCache.py @@ -47,7 +47,7 @@ def test_memory_cache(self): # Check the value of my_ints[0] is the same as set in main.cpp. line = self.res.GetOutput().splitlines()[100] - self.assertEquals(0x00000042, int(line.split(":")[1], 0)) + self.assertEqual(0x00000042, int(line.split(":")[1], 0)) # Change the value of my_ints[0] in memory. self.runCmd("memory write -s 4 `&my_ints` AA") @@ -58,4 +58,4 @@ def test_memory_cache(self): # Check the value of my_ints[0] have been updated correctly. line = self.res.GetOutput().splitlines()[100] - self.assertEquals(0x000000AA, int(line.split(":")[1], 0)) + self.assertEqual(0x000000AA, int(line.split(":")[1], 0)) diff --git a/lldb/test/API/functionalities/plugins/python_os_plugin/TestPythonOSPlugin.py b/lldb/test/API/functionalities/plugins/python_os_plugin/TestPythonOSPlugin.py index 9ec49d0069a6b..859e87cf75a59 100644 --- a/lldb/test/API/functionalities/plugins/python_os_plugin/TestPythonOSPlugin.py +++ b/lldb/test/API/functionalities/plugins/python_os_plugin/TestPythonOSPlugin.py @@ -212,7 +212,7 @@ def run_python_os_step(self): "main.c", "Make sure we stepped from line 5 to line 6 in main.c", ) - self.assertEquals( + self.assertEqual( line_entry.GetLine(), 6, "Make sure we stepped from line 5 to line 6 in main.c", diff --git a/lldb/test/API/functionalities/process_group/TestChangeProcessGroup.py b/lldb/test/API/functionalities/process_group/TestChangeProcessGroup.py index 9cca83202e1c1..00459cd6008a5 100644 --- a/lldb/test/API/functionalities/process_group/TestChangeProcessGroup.py +++ b/lldb/test/API/functionalities/process_group/TestChangeProcessGroup.py @@ -68,7 +68,7 @@ def cleanupChild(): # release the child from its loop value = thread.GetSelectedFrame().EvaluateExpression("release_child_flag = 1") self.assertTrue(value.IsValid()) - self.assertEquals(value.GetValueAsUnsigned(0), 1) + self.assertEqual(value.GetValueAsUnsigned(0), 1) process.Continue() # make sure the child's process group id is different from its pid diff --git a/lldb/test/API/functionalities/return-value/TestReturnValue.py b/lldb/test/API/functionalities/return-value/TestReturnValue.py index 1e94a02a67f58..3c212a3be660b 100644 --- a/lldb/test/API/functionalities/return-value/TestReturnValue.py +++ b/lldb/test/API/functionalities/return-value/TestReturnValue.py @@ -79,20 +79,20 @@ def test_with_python(self): frame = thread.GetFrameAtIndex(0) fun_name = frame.GetFunctionName() - self.assertEquals(fun_name, "outer_sint(int)") + self.assertEqual(fun_name, "outer_sint(int)") return_value = thread.GetStopReturnValue() self.assertTrue(return_value.IsValid()) ret_int = return_value.GetValueAsSigned(error) self.assertSuccess(error) - self.assertEquals(in_int, ret_int) + self.assertEqual(in_int, ret_int) # Run again and we will stop in inner_sint the second time outer_sint is called. # Then test stepping out two frames at once: thread_list = lldbutil.continue_to_breakpoint(self.process, inner_sint_bkpt) - self.assertEquals(len(thread_list), 1) + self.assertEqual(len(thread_list), 1) thread = thread_list[0] # We are done with the inner_sint breakpoint: @@ -100,7 +100,7 @@ def test_with_python(self): frame = thread.GetFrameAtIndex(1) fun_name = frame.GetFunctionName() - self.assertEquals(fun_name, "outer_sint(int)") + self.assertEqual(fun_name, "outer_sint(int)") in_int = frame.FindVariable("value").GetValueAsSigned(error) self.assertSuccess(error) @@ -110,13 +110,13 @@ def test_with_python(self): self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonPlanComplete) frame = thread.GetFrameAtIndex(0) fun_name = frame.GetFunctionName() - self.assertEquals(fun_name, "main") + self.assertEqual(fun_name, "main") ret_value = thread.GetStopReturnValue() self.assertTrue(return_value.IsValid()) ret_int = ret_value.GetValueAsSigned(error) self.assertSuccess(error) - self.assertEquals(2 * in_int, ret_int) + self.assertEqual(2 * in_int, ret_int) # Now try some simple returns that have different types: inner_float_bkpt = self.target.BreakpointCreateByName("inner_float(float)", exe) @@ -125,7 +125,7 @@ def test_with_python(self): thread_list = lldbutil.get_threads_stopped_at_breakpoint( self.process, inner_float_bkpt ) - self.assertEquals(len(thread_list), 1) + self.assertEqual(len(thread_list), 1) thread = thread_list[0] self.target.BreakpointDelete(inner_float_bkpt.GetID()) @@ -140,7 +140,7 @@ def test_with_python(self): frame = thread.GetFrameAtIndex(0) fun_name = frame.GetFunctionName() - self.assertEquals(fun_name, "outer_float(float)") + self.assertEqual(fun_name, "outer_float(float)") # return_value = thread.GetStopReturnValue() # self.assertTrue(return_value.IsValid()) @@ -270,7 +270,7 @@ def return_and_test_struct_value(self, func_name): thread_list = lldbutil.get_threads_stopped_at_breakpoint(self.process, bkpt) - self.assertEquals(len(thread_list), 1) + self.assertEqual(len(thread_list), 1) thread = thread_list[0] self.target.BreakpointDelete(bkpt.GetID()) @@ -296,7 +296,7 @@ def return_and_test_struct_value(self, func_name): # if that would add something to the test. frame = thread.GetFrameAtIndex(0) fun_name = frame.GetFunctionName() - self.assertEquals(fun_name, "main") + self.assertEqual(fun_name, "main") frame = thread.GetFrameAtIndex(0) ret_value = thread.GetStopReturnValue() @@ -307,7 +307,7 @@ def return_and_test_struct_value(self, func_name): self.assertTrue(ret_value.IsValid()) num_ret_children = ret_value.GetNumChildren() - self.assertEquals(num_in_children, num_ret_children) + self.assertEqual(num_in_children, num_ret_children) for idx in range(0, num_ret_children): in_child = in_value.GetChildAtIndex(idx) ret_child = ret_value.GetChildAtIndex(idx) diff --git a/lldb/test/API/functionalities/signal/TestSendSignal.py b/lldb/test/API/functionalities/signal/TestSendSignal.py index c020be2a3e725..94d435a5fb17f 100644 --- a/lldb/test/API/functionalities/signal/TestSendSignal.py +++ b/lldb/test/API/functionalities/signal/TestSendSignal.py @@ -72,7 +72,7 @@ def test_with_run_command(self): # Now make sure the thread was stopped with a SIGUSR1: threads = lldbutil.get_stopped_threads(process, lldb.eStopReasonSignal) - self.assertEquals(len(threads), 1, "One thread stopped for a signal.") + self.assertEqual(len(threads), 1, "One thread stopped for a signal.") thread = threads[0] self.assertTrue( @@ -96,7 +96,7 @@ def match_state(self, process_listener, expected_state): ) self.assertTrue(got_event, "Got an event") state = lldb.SBProcess.GetStateFromEvent(event) - self.assertEquals( + self.assertEqual( state, expected_state, "It was the %s state." % lldb.SBDebugger.StateAsCString(expected_state), diff --git a/lldb/test/API/functionalities/source-map/TestTargetSourceMap.py b/lldb/test/API/functionalities/source-map/TestTargetSourceMap.py index 2114d71c2d506..609b0e69a2a21 100644 --- a/lldb/test/API/functionalities/source-map/TestTargetSourceMap.py +++ b/lldb/test/API/functionalities/source-map/TestTargetSourceMap.py @@ -17,7 +17,7 @@ def test_source_map_via_setting_api(self): source_map_setting_path = "target.source-map" initial_source_map = self.dbg.GetSetting(source_map_setting_path) - self.assertEquals( + self.assertEqual( initial_source_map.GetSize(), 0, "Initial source map should be empty" ) @@ -25,7 +25,7 @@ def test_source_map_via_setting_api(self): self.runCmd('settings set %s . "%s"' % (source_map_setting_path, src_dir)) source_map = self.dbg.GetSetting(source_map_setting_path) - self.assertEquals( + self.assertEqual( source_map.GetSize(), 1, "source map should be have one appended entry" ) @@ -33,15 +33,15 @@ def test_source_map_via_setting_api(self): source_map.GetAsJSON(stream) serialized_source_map = json.loads(stream.GetData()) - self.assertEquals( + self.assertEqual( len(serialized_source_map[0]), 2, "source map entry should have two parts" ) - self.assertEquals( + self.assertEqual( serialized_source_map[0][0], ".", "source map entry's first part does not match", ) - self.assertEquals( + self.assertEqual( serialized_source_map[0][1], src_dir, "source map entry's second part does not match", @@ -54,7 +54,7 @@ def test_source_map(self): def assertBreakpointWithSourceMap(src_path): # Set a breakpoint after we remap source and verify that it succeeds bp = target.BreakpointCreateByLocation(src_path, 2) - self.assertEquals( + self.assertEqual( bp.GetNumLocations(), 1, "make sure breakpoint was resolved with map" ) @@ -85,7 +85,7 @@ def assertBreakpointWithSourceMap(src_path): # Set a breakpoint before we remap source and verify that it fails bp = target.BreakpointCreateByLocation(src_path, 2) - self.assertEquals( + self.assertEqual( bp.GetNumLocations(), 0, "make sure no breakpoints were resolved without map", diff --git a/lldb/test/API/functionalities/step-avoids-no-debug/TestStepNoDebug.py b/lldb/test/API/functionalities/step-avoids-no-debug/TestStepNoDebug.py index ad59c5ccb1a4f..984a9c1b51c57 100644 --- a/lldb/test/API/functionalities/step-avoids-no-debug/TestStepNoDebug.py +++ b/lldb/test/API/functionalities/step-avoids-no-debug/TestStepNoDebug.py @@ -109,7 +109,7 @@ def get_to_starting_point(self): # Now finish, and make sure the return value is correct. threads = lldbutil.get_threads_stopped_at_breakpoint(self.process, inner_bkpt) - self.assertEquals(len(threads), 1, "Stopped at inner breakpoint.") + self.assertEqual(len(threads), 1, "Stopped at inner breakpoint.") self.thread = threads[0] def do_step_out_past_nodebug(self): diff --git a/lldb/test/API/functionalities/tail_call_frames/unambiguous_sequence/main.cpp b/lldb/test/API/functionalities/tail_call_frames/unambiguous_sequence/main.cpp index 2d6241a3fe3be..32a7eb40ad692 100644 --- a/lldb/test/API/functionalities/tail_call_frames/unambiguous_sequence/main.cpp +++ b/lldb/test/API/functionalities/tail_call_frames/unambiguous_sequence/main.cpp @@ -18,7 +18,7 @@ void __attribute__((noinline)) sink() { //% last_insn = func3_insns.GetInstructionAtIndex(func3_insns.GetSize()-1) //% addr = last_insn.GetAddress() //% if "GNU" in self.name: addr.OffsetAddress(last_insn.GetByteSize()) - //% self.assertEquals(frame1.GetPCAddress(), addr) + //% self.assertEqual(frame1.GetPCAddress(), addr) } void __attribute__((noinline)) func3() { diff --git a/lldb/test/API/functionalities/thread/main_thread_exit/TestMainThreadExit.py b/lldb/test/API/functionalities/thread/main_thread_exit/TestMainThreadExit.py index 442ae48952b90..c3c534368dd4a 100644 --- a/lldb/test/API/functionalities/thread/main_thread_exit/TestMainThreadExit.py +++ b/lldb/test/API/functionalities/thread/main_thread_exit/TestMainThreadExit.py @@ -21,7 +21,7 @@ def test(self): ) # There should be one (non-main) thread left - self.assertEquals(self.process().GetNumThreads(), 1) + self.assertEqual(self.process().GetNumThreads(), 1) # Ensure we can evaluate_expressions in this state self.expect_expr("call_me()", result_value="12345") diff --git a/lldb/test/API/functionalities/ubsan/basic/TestUbsanBasic.py b/lldb/test/API/functionalities/ubsan/basic/TestUbsanBasic.py index e123a1d4a41b2..868a2864d2b5e 100644 --- a/lldb/test/API/functionalities/ubsan/basic/TestUbsanBasic.py +++ b/lldb/test/API/functionalities/ubsan/basic/TestUbsanBasic.py @@ -67,7 +67,7 @@ def ubsan_tests(self): backtraces = thread.GetStopReasonExtendedBacktraces( lldb.eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer ) - self.assertEquals(backtraces.GetSize(), 1) + self.assertEqual(backtraces.GetSize(), 1) self.expect( "thread info -s", diff --git a/lldb/test/API/functionalities/unwind/noreturn/module-end/TestNoReturnModuleEnd.py b/lldb/test/API/functionalities/unwind/noreturn/module-end/TestNoReturnModuleEnd.py index 54a847aa19010..12410d53ef92e 100644 --- a/lldb/test/API/functionalities/unwind/noreturn/module-end/TestNoReturnModuleEnd.py +++ b/lldb/test/API/functionalities/unwind/noreturn/module-end/TestNoReturnModuleEnd.py @@ -36,6 +36,6 @@ def test(self): self.assertTrue(symbol.IsValid()) self.assertEqual(symbol.GetName(), backtrace[i][0]) function_start = symbol.GetStartAddress().GetLoadAddress(target) - self.assertEquals(function_start + backtrace[i][1], frame.GetPC()) + self.assertEqual(function_start + backtrace[i][1], frame.GetPC()) self.dbg.DeleteTarget(target) diff --git a/lldb/test/API/functionalities/value_md5_crash/TestValueMD5Crash.py b/lldb/test/API/functionalities/value_md5_crash/TestValueMD5Crash.py index 62e0614a756b1..24749b6e2fc75 100644 --- a/lldb/test/API/functionalities/value_md5_crash/TestValueMD5Crash.py +++ b/lldb/test/API/functionalities/value_md5_crash/TestValueMD5Crash.py @@ -40,7 +40,7 @@ def test_with_run_command(self): v = value.GetValue() type_name = value.GetTypeName() - self.assertEquals(type_name, "B *", "a is a B*") + self.assertEqual(type_name, "B *", "a is a B*") self.runCmd("next") self.runCmd("process kill") diff --git a/lldb/test/API/functionalities/var_path/TestVarPath.py b/lldb/test/API/functionalities/var_path/TestVarPath.py index 73c4f65f8e2e9..53c45f57f517d 100644 --- a/lldb/test/API/functionalities/var_path/TestVarPath.py +++ b/lldb/test/API/functionalities/var_path/TestVarPath.py @@ -22,7 +22,7 @@ def test_frame_var(self): def verify_point(self, frame, var_name, var_typename, x_value, y_value): v = frame.GetValueForVariablePath(var_name) self.assertSuccess(v.GetError(), "Make sure we find '%s'" % (var_name)) - self.assertEquals( + self.assertEqual( v.GetType().GetName(), var_typename, "Make sure '%s' has type '%s'" % (var_name, var_typename), @@ -43,12 +43,12 @@ def verify_point(self, frame, var_name, var_typename, x_value, y_value): v = frame.GetValueForVariablePath(valid_x_path) self.assertSuccess(v.GetError(), "Make sure we find '%s'" % (valid_x_path)) - self.assertEquals( + self.assertEqual( v.GetValue(), str(x_value), "Make sure '%s' has a value of %i" % (valid_x_path, x_value), ) - self.assertEquals( + self.assertEqual( v.GetType().GetName(), "int", "Make sure '%s' has type 'int'" % (valid_x_path), @@ -60,12 +60,12 @@ def verify_point(self, frame, var_name, var_typename, x_value, y_value): v = frame.GetValueForVariablePath(valid_y_path) self.assertSuccess(v.GetError(), "Make sure we find '%s'" % (valid_y_path)) - self.assertEquals( + self.assertEqual( v.GetValue(), str(y_value), "Make sure '%s' has a value of %i" % (valid_y_path, y_value), ) - self.assertEquals( + self.assertEqual( v.GetType().GetName(), "int", "Make sure '%s' has type 'int'" % (valid_y_path), diff --git a/lldb/test/API/functionalities/vtable/TestVTableValue.py b/lldb/test/API/functionalities/vtable/TestVTableValue.py index 3ee571207e7f9..bfc910614afa9 100644 --- a/lldb/test/API/functionalities/vtable/TestVTableValue.py +++ b/lldb/test/API/functionalities/vtable/TestVTableValue.py @@ -26,16 +26,16 @@ def test_vtable(self): # Test a shape instance to make sure we get the vtable correctly. shape = self.frame().FindVariable("shape") vtable = shape.GetVTable() - self.assertEquals(vtable.GetName(), "vtable for Shape") - self.assertEquals(vtable.GetTypeName(), "vtable for Shape") + self.assertEqual(vtable.GetName(), "vtable for Shape") + self.assertEqual(vtable.GetTypeName(), "vtable for Shape") # Make sure we have the right number of virtual functions in our vtable # for the shape class. - self.assertEquals(vtable.GetNumChildren(), 4) + self.assertEqual(vtable.GetNumChildren(), 4) # Verify vtable address vtable_addr = vtable.GetValueAsUnsigned(0) expected_addr = self.expected_vtable_addr(shape) - self.assertEquals(vtable_addr, expected_addr) + self.assertEqual(vtable_addr, expected_addr) for idx, vtable_entry in enumerate(vtable.children): self.verify_vtable_entry(vtable_entry, vtable_addr, idx) @@ -43,16 +43,16 @@ def test_vtable(self): # Test a shape reference to make sure we get the vtable correctly. shape = self.frame().FindVariable("shape_ref") vtable = shape.GetVTable() - self.assertEquals(vtable.GetName(), "vtable for Shape") - self.assertEquals(vtable.GetTypeName(), "vtable for Shape") + self.assertEqual(vtable.GetName(), "vtable for Shape") + self.assertEqual(vtable.GetTypeName(), "vtable for Shape") # Make sure we have the right number of virtual functions in our vtable # for the shape class. - self.assertEquals(vtable.GetNumChildren(), 4) + self.assertEqual(vtable.GetNumChildren(), 4) # Verify vtable address vtable_addr = vtable.GetValueAsUnsigned(0) expected_addr = self.expected_vtable_addr(shape) - self.assertEquals(vtable_addr, expected_addr) + self.assertEqual(vtable_addr, expected_addr) for idx, vtable_entry in enumerate(vtable.children): self.verify_vtable_entry(vtable_entry, vtable_addr, idx) @@ -60,17 +60,17 @@ def test_vtable(self): # Test we get the right vtable for the Rectangle instance. rect = self.frame().FindVariable("rect") vtable = rect.GetVTable() - self.assertEquals(vtable.GetName(), "vtable for Rectangle") - self.assertEquals(vtable.GetTypeName(), "vtable for Rectangle") + self.assertEqual(vtable.GetName(), "vtable for Rectangle") + self.assertEqual(vtable.GetTypeName(), "vtable for Rectangle") # Make sure we have the right number of virtual functions in our vtable # with the extra virtual function added by the Rectangle class - self.assertEquals(vtable.GetNumChildren(), 5) + self.assertEqual(vtable.GetNumChildren(), 5) # Verify vtable address vtable_addr = vtable.GetValueAsUnsigned() expected_addr = self.expected_vtable_addr(rect) - self.assertEquals(vtable_addr, expected_addr) + self.assertEqual(vtable_addr, expected_addr) for idx, vtable_entry in enumerate(vtable.children): self.verify_vtable_entry(vtable_entry, vtable_addr, idx) @@ -88,15 +88,15 @@ def test_base_class_ptr(self): shape_ptr = self.frame().FindVariable("shape_ptr") shape_ptr_vtable = shape_ptr.GetVTable() - self.assertEquals(shape_ptr_vtable.GetName(), "vtable for Rectangle") - self.assertEquals(shape_ptr_vtable.GetNumChildren(), 5) - self.assertEquals(shape_ptr.GetValueAsUnsigned(0), rect.GetLoadAddress()) + self.assertEqual(shape_ptr_vtable.GetName(), "vtable for Rectangle") + self.assertEqual(shape_ptr_vtable.GetNumChildren(), 5) + self.assertEqual(shape_ptr.GetValueAsUnsigned(0), rect.GetLoadAddress()) lldbutil.continue_to_source_breakpoint( self, process, "Shape is Shape", lldb.SBFileSpec("main.cpp") ) - self.assertEquals(shape_ptr.GetValueAsUnsigned(0), shape.GetLoadAddress()) - self.assertEquals(shape_ptr_vtable.GetNumChildren(), 4) - self.assertEquals(shape_ptr_vtable.GetName(), "vtable for Shape") + self.assertEqual(shape_ptr.GetValueAsUnsigned(0), shape.GetLoadAddress()) + self.assertEqual(shape_ptr_vtable.GetNumChildren(), 4) + self.assertEqual(shape_ptr_vtable.GetName(), "vtable for Shape") @skipUnlessPlatform(["linux", "macosx"]) def test_no_vtable(self): @@ -127,11 +127,11 @@ def test_overwrite_vtable(self): # Test a shape instance to make sure we get the vtable correctly. shape = self.frame().FindVariable("shape") vtable = shape.GetVTable() - self.assertEquals(vtable.GetName(), "vtable for Shape") - self.assertEquals(vtable.GetTypeName(), "vtable for Shape") + self.assertEqual(vtable.GetName(), "vtable for Shape") + self.assertEqual(vtable.GetTypeName(), "vtable for Shape") # Make sure we have the right number of virtual functions in our vtable # for the shape class. - self.assertEquals(vtable.GetNumChildren(), 4) + self.assertEqual(vtable.GetNumChildren(), 4) # Overwrite the first entry in the vtable and make sure we can still # see the bogus value which should have no summary @@ -145,11 +145,11 @@ def test_overwrite_vtable(self): process.WriteMemory(vtable_addr, data, error) scribbled_child = vtable.GetChildAtIndex(0) - self.assertEquals( + self.assertEqual( scribbled_child.GetValueAsUnsigned(0), 0x0101010101010101 if is_64bit else 0x01010101, ) - self.assertEquals(scribbled_child.GetSummary(), None) + self.assertEqual(scribbled_child.GetSummary(), None) def expected_vtable_addr(self, var: lldb.SBValue) -> int: load_addr = var.GetLoadAddress() @@ -179,7 +179,7 @@ def verify_vtable_entry( """ # Check function ptr vtable_entry_func_ptr = vtable_entry.GetValueAsUnsigned(0) - self.assertEquals( + self.assertEqual( vtable_entry_func_ptr, self.expected_vtable_entry_func_ptr(vtable_addr, idx), ) @@ -190,8 +190,8 @@ def verify_vtable_entry( # Make sure the type is the same as the function type func_type = sym_ctx.GetFunction().GetType() if func_type.IsValid(): - self.assertEquals(vtable_entry.GetType(), func_type.GetPointerType()) + self.assertEqual(vtable_entry.GetType(), func_type.GetPointerType()) # The summary should be the address description of the function pointer summary = vtable_entry.GetSummary() - self.assertEquals(str(sb_addr), summary) + self.assertEqual(str(sb_addr), summary) diff --git a/lldb/test/API/functionalities/wrong_commands/TestWrongCommands.py b/lldb/test/API/functionalities/wrong_commands/TestWrongCommands.py index 83900a307f52e..7a2e488a92ab4 100644 --- a/lldb/test/API/functionalities/wrong_commands/TestWrongCommands.py +++ b/lldb/test/API/functionalities/wrong_commands/TestWrongCommands.py @@ -23,7 +23,7 @@ def test_ambiguous_command(self): ) self.assertRegexpMatches(result.GetError(), "gui") self.assertRegexpMatches(result.GetError(), "gdb-remote") - self.assertEquals(1, result.GetError().count("gdb-remote")) + self.assertEqual(1, result.GetError().count("gdb-remote")) @no_debug_info_test def test_unknown_command(self): @@ -33,4 +33,4 @@ def test_unknown_command(self): command_interpreter.HandleCommand("qbert", result) self.assertFalse(result.Succeeded()) - self.assertEquals(result.GetError(), "error: 'qbert' is not a valid command.\n") + self.assertEqual(result.GetError(), "error: 'qbert' is not a valid command.\n") diff --git a/lldb/test/API/lang/c/array_types/TestArrayTypes.py b/lldb/test/API/lang/c/array_types/TestArrayTypes.py index 36fff4ce96152..fc234f5842508 100644 --- a/lldb/test/API/lang/c/array_types/TestArrayTypes.py +++ b/lldb/test/API/lang/c/array_types/TestArrayTypes.py @@ -175,7 +175,7 @@ def test_and_python_api(self): substrs=["%s" % variable.GetName()], ) self.DebugSBValue(variable) - self.assertEquals( + self.assertEqual( variable.GetNumChildren(), 4, "Variable 'strings' should have 4 children" ) byte_size = variable.GetByteSize() @@ -183,14 +183,14 @@ def test_and_python_api(self): child3 = variable.GetChildAtIndex(3) self.DebugSBValue(child3) - self.assertEquals( + self.assertEqual( child3.GetSummary(), '"Guten Tag"', 'strings[3] == "Guten Tag"' ) # Lookup the "char_16" char array variable. variable = frame.FindVariable("char_16") self.DebugSBValue(variable) - self.assertEquals( + self.assertEqual( variable.GetNumChildren(), 16, "Variable 'char_16' should have 16 children" ) @@ -200,31 +200,31 @@ def test_and_python_api(self): # of the string. Same applies to long(). variable = frame.FindVariable("ushort_matrix") self.DebugSBValue(variable) - self.assertEquals( + self.assertEqual( variable.GetNumChildren(), 2, "Variable 'ushort_matrix' should have 2 children", ) child0 = variable.GetChildAtIndex(0) self.DebugSBValue(child0) - self.assertEquals( + self.assertEqual( child0.GetNumChildren(), 3, "Variable 'ushort_matrix[0]' should have 3 children", ) child0_2 = child0.GetChildAtIndex(2) self.DebugSBValue(child0_2) - self.assertEquals(int(child0_2.GetValue(), 0), 3, "ushort_matrix[0][2] == 3") + self.assertEqual(int(child0_2.GetValue(), 0), 3, "ushort_matrix[0][2] == 3") # Lookup the "long_6" char array variable. variable = frame.FindVariable("long_6") self.DebugSBValue(variable) - self.assertEquals( + self.assertEqual( variable.GetNumChildren(), 6, "Variable 'long_6' should have 6 children" ) child5 = variable.GetChildAtIndex(5) self.DebugSBValue(child5) - self.assertEquals(int(child5.GetValue(), 0), 6, "long_6[5] == 6") + self.assertEqual(int(child5.GetValue(), 0), 6, "long_6[5] == 6") # Last, check that "long_6" has a value type of eValueTypeVariableLocal # and "argc" has eValueTypeVariableArgument. @@ -238,7 +238,7 @@ def test_and_python_api(self): ) argc = frame.FindVariable("argc") self.DebugSBValue(argc) - self.assertEquals( + self.assertEqual( argc.GetValueType(), lldb.eValueTypeVariableArgument, "Variable 'argc' should have '%s' value type." diff --git a/lldb/test/API/lang/cpp/dynamic-value/TestDynamicValue.py b/lldb/test/API/lang/cpp/dynamic-value/TestDynamicValue.py index 81557ecd2c222..44a584f7dd63e 100644 --- a/lldb/test/API/lang/cpp/dynamic-value/TestDynamicValue.py +++ b/lldb/test/API/lang/cpp/dynamic-value/TestDynamicValue.py @@ -62,7 +62,7 @@ def test_get_dynamic_vals(self): self.assertState(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED) threads = lldbutil.get_threads_stopped_at_breakpoint(process, first_call_bpt) - self.assertEquals(len(threads), 1) + self.assertEqual(len(threads), 1) thread = threads[0] frame = thread.GetFrameAtIndex(0) @@ -84,7 +84,7 @@ def test_get_dynamic_vals(self): # Okay now run to doSomething: threads = lldbutil.continue_to_breakpoint(process, do_something_bpt) - self.assertEquals(len(threads), 1) + self.assertEqual(len(threads), 1) thread = threads[0] frame = thread.GetFrameAtIndex(0) @@ -151,7 +151,7 @@ def test_get_dynamic_vals(self): ) self.assertTrue(anotherA_m_b_value_dynamic) anotherA_m_b_val = int(anotherA_m_b_value_dynamic.GetValue(), 10) - self.assertEquals(anotherA_m_b_val, 300) + self.assertEqual(anotherA_m_b_val, 300) anotherA_m_b_value_static = anotherA_static.GetChildMemberWithName( "m_b_value", True @@ -162,7 +162,7 @@ def test_get_dynamic_vals(self): # main threads = lldbutil.continue_to_breakpoint(process, second_call_bpt) - self.assertEquals(len(threads), 1) + self.assertEqual(len(threads), 1) thread = threads[0] frame = thread.GetFrameAtIndex(0) @@ -174,15 +174,15 @@ def test_get_dynamic_vals(self): # which this time around is just an "A". threads = lldbutil.continue_to_breakpoint(process, do_something_bpt) - self.assertEquals(len(threads), 1) + self.assertEqual(len(threads), 1) thread = threads[0] frame = thread.GetFrameAtIndex(0) anotherA_value = frame.FindVariable("anotherA", True) self.assertTrue(anotherA_value) anotherA_loc = int(anotherA_value.GetValue(), 16) - self.assertEquals(anotherA_loc, reallyA_loc) - self.assertEquals(anotherA_value.GetTypeName().find("B"), -1) + self.assertEqual(anotherA_loc, reallyA_loc) + self.assertEqual(anotherA_value.GetTypeName().find("B"), -1) def examine_value_object_of_this_ptr( self, this_static, this_dynamic, dynamic_location @@ -200,7 +200,7 @@ def examine_value_object_of_this_ptr( # Make sure we got the right address for "this" - self.assertEquals(this_dynamic_loc, dynamic_location) + self.assertEqual(this_dynamic_loc, dynamic_location) # And that the static address is greater than the dynamic one @@ -217,7 +217,7 @@ def examine_value_object_of_this_ptr( self.assertTrue(this_dynamic_m_b_value) m_b_value = int(this_dynamic_m_b_value.GetValue(), 0) - self.assertEquals(m_b_value, 10) + self.assertEqual(m_b_value, 10) # Make sure it is not in the static version diff --git a/lldb/test/API/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py b/lldb/test/API/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py index 7f93e9d15fc79..e9c7a48ea0a8c 100644 --- a/lldb/test/API/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py +++ b/lldb/test/API/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py @@ -65,7 +65,7 @@ def test(self): while frame_functions.count("throws_exception_on_even(int)") == 1: stopped_threads = lldbutil.continue_to_breakpoint(process, exception_bkpt) - self.assertEquals(len(stopped_threads), 1) + self.assertEqual(len(stopped_threads), 1) thread = stopped_threads[0] frame_functions = lldbutil.get_function_names(thread) diff --git a/lldb/test/API/lang/cpp/incomplete-types/members/TestCppIncompleteTypeMembers.py b/lldb/test/API/lang/cpp/incomplete-types/members/TestCppIncompleteTypeMembers.py index 106e33ff36636..35a8a87cec8ea 100644 --- a/lldb/test/API/lang/cpp/incomplete-types/members/TestCppIncompleteTypeMembers.py +++ b/lldb/test/API/lang/cpp/incomplete-types/members/TestCppIncompleteTypeMembers.py @@ -19,7 +19,7 @@ def test(self): # Sanity check that we really have to debug info for this type. this = self.expect_var_path("this", type="A *") - self.assertEquals( + self.assertEqual( this.GetType().GetPointeeType().GetNumberOfFields(), 0, str(this) ) diff --git a/lldb/test/API/lang/cpp/template-specialization-type/TestTemplateSpecializationType.py b/lldb/test/API/lang/cpp/template-specialization-type/TestTemplateSpecializationType.py index 9534ca9c149c9..cdc8211bcd636 100644 --- a/lldb/test/API/lang/cpp/template-specialization-type/TestTemplateSpecializationType.py +++ b/lldb/test/API/lang/cpp/template-specialization-type/TestTemplateSpecializationType.py @@ -15,14 +15,14 @@ def test_template_specialization_cast_children(self): ) v = self.frame().EvaluateExpression("t") - self.assertEquals(2, v.GetNumChildren()) - self.assertEquals("42", v.GetChildAtIndex(0).GetValue()) - self.assertEquals("21", v.GetChildAtIndex(1).GetValue()) + self.assertEqual(2, v.GetNumChildren()) + self.assertEqual("42", v.GetChildAtIndex(0).GetValue()) + self.assertEqual("21", v.GetChildAtIndex(1).GetValue()) # Test a value of the TemplateSpecialization type. We turn # RecordType into TemplateSpecializationType by casting and # dereferencing a pointer to a record. v = self.frame().EvaluateExpression("*((TestObj*)&t)") - self.assertEquals(2, v.GetNumChildren()) - self.assertEquals("42", v.GetChildAtIndex(0).GetValue()) - self.assertEquals("21", v.GetChildAtIndex(1).GetValue()) + self.assertEqual(2, v.GetNumChildren()) + self.assertEqual("42", v.GetChildAtIndex(0).GetValue()) + self.assertEqual("21", v.GetChildAtIndex(1).GetValue()) diff --git a/lldb/test/API/lang/cpp/template/TestTemplateArgs.py b/lldb/test/API/lang/cpp/template/TestTemplateArgs.py index 90d78ebeedea8..9708e98a59fce 100644 --- a/lldb/test/API/lang/cpp/template/TestTemplateArgs.py +++ b/lldb/test/API/lang/cpp/template/TestTemplateArgs.py @@ -50,14 +50,14 @@ def test_integer_args(self): self.assertTrue( testpos.IsValid(), 'make sure we find a local variabble named "testpos"' ) - self.assertEquals(testpos.GetType().GetName(), "TestObj<1>") + self.assertEqual(testpos.GetType().GetName(), "TestObj<1>") expr_result = frame.EvaluateExpression("testpos.getArg()") self.assertTrue( expr_result.IsValid(), 'got a valid expression result from expression "testpos.getArg()"', ) - self.assertEquals(expr_result.GetValue(), "1", "testpos.getArg() == 1") + self.assertEqual(expr_result.GetValue(), "1", "testpos.getArg() == 1") self.assertEqual( expr_result.GetType().GetName(), "int", @@ -68,7 +68,7 @@ def test_integer_args(self): self.assertTrue( testneg.IsValid(), 'make sure we find a local variabble named "testneg"' ) - self.assertEquals(testneg.GetType().GetName(), "TestObj<-1>") + self.assertEqual(testneg.GetType().GetName(), "TestObj<-1>") expr_result = frame.EvaluateExpression("testneg.getArg()") self.assertTrue( @@ -88,39 +88,39 @@ def test_template_template_args(self): c1 = frame.FindVariable("c1") self.assertTrue(c1.IsValid(), 'make sure we find a local variabble named "c1"') - self.assertEquals(c1.GetType().GetName(), "C") + self.assertEqual(c1.GetType().GetName(), "C") f1 = ( c1.GetChildMemberWithName("V") .GetChildAtIndex(0) .GetChildMemberWithName("f") ) - self.assertEquals(f1.GetType().GetName(), "float") - self.assertEquals(f1.GetValue(), "1.5") + self.assertEqual(f1.GetType().GetName(), "float") + self.assertEqual(f1.GetValue(), "1.5") c2 = frame.FindVariable("c2") self.assertTrue(c2.IsValid(), 'make sure we find a local variabble named "c2"') - self.assertEquals(c2.GetType().GetName(), "C") + self.assertEqual(c2.GetType().GetName(), "C") f2 = ( c2.GetChildMemberWithName("V") .GetChildAtIndex(0) .GetChildMemberWithName("f") ) - self.assertEquals(f2.GetType().GetName(), "double") - self.assertEquals(f2.GetValue(), "1.5") + self.assertEqual(f2.GetType().GetName(), "double") + self.assertEqual(f2.GetValue(), "1.5") f3 = ( c2.GetChildMemberWithName("V") .GetChildAtIndex(1) .GetChildMemberWithName("f") ) - self.assertEquals(f3.GetType().GetName(), "double") - self.assertEquals(f3.GetValue(), "2.5") + self.assertEqual(f3.GetType().GetName(), "double") + self.assertEqual(f3.GetValue(), "2.5") f4 = ( c2.GetChildMemberWithName("V") .GetChildAtIndex(1) .GetChildMemberWithName("i") ) - self.assertEquals(f4.GetType().GetName(), "int") - self.assertEquals(f4.GetValue(), "42") + self.assertEqual(f4.GetType().GetName(), "int") + self.assertEqual(f4.GetValue(), "42") # Gcc does not generate the necessary DWARF attribute for enum template # parameters. diff --git a/lldb/test/API/lang/objc/global_ptrs/TestGlobalObjects.py b/lldb/test/API/lang/objc/global_ptrs/TestGlobalObjects.py index 76ca9c6ba92c5..8838f86b4bf1d 100644 --- a/lldb/test/API/lang/objc/global_ptrs/TestGlobalObjects.py +++ b/lldb/test/API/lang/objc/global_ptrs/TestGlobalObjects.py @@ -46,4 +46,4 @@ def test_with_python_api(self): dyn_value = g_obj_ptr.GetDynamicValue(lldb.eDynamicCanRunTarget) self.assertTrue(dyn_value.GetError().Success(), "Dynamic value is valid") - self.assertEquals(dyn_value.GetObjectDescription(), "Some NSString") + self.assertEqual(dyn_value.GetObjectDescription(), "Some NSString") diff --git a/lldb/test/API/lang/objc/objc-baseclass-sbtype/TestObjCBaseClassSBType.py b/lldb/test/API/lang/objc/objc-baseclass-sbtype/TestObjCBaseClassSBType.py index 747f4ff6609c7..20fb264da5b5c 100644 --- a/lldb/test/API/lang/objc/objc-baseclass-sbtype/TestObjCBaseClassSBType.py +++ b/lldb/test/API/lang/objc/objc-baseclass-sbtype/TestObjCBaseClassSBType.py @@ -57,7 +57,7 @@ def test_get_baseclass(self): "Foo * has a valid base class", ) - self.assertEquals( + self.assertEqual( var_ptr_type.GetDirectBaseClassAtIndex(0).GetName(), var_pte_type.GetDirectBaseClassAtIndex(0).GetName(), "Foo and its pointer type don't agree on their base class", diff --git a/lldb/test/API/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py b/lldb/test/API/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py index fd497c25ba7a9..3ba68f4c35a5c 100644 --- a/lldb/test/API/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py +++ b/lldb/test/API/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py @@ -71,7 +71,7 @@ def test_get_objc_dynamic_vals(self): threads = lldbutil.get_threads_stopped_at_breakpoint( process, main_before_setProperty_bkpt ) - self.assertEquals(len(threads), 1) + self.assertEqual(len(threads), 1) thread = threads[0] # @@ -133,7 +133,7 @@ def test_get_objc_dynamic_vals(self): thread.StepInto() threads = lldbutil.get_stopped_threads(process, lldb.eStopReasonPlanComplete) - self.assertEquals(len(threads), 1) + self.assertEqual(len(threads), 1) line_entry = threads[0].GetFrameAtIndex(0).GetLineEntry() self.assertEqual(line_entry.GetLine(), self.set_property_line) @@ -143,7 +143,7 @@ def test_get_objc_dynamic_vals(self): # and make sure we get the correct dynamic value. threads = lldbutil.continue_to_breakpoint(process, handle_SourceBase_bkpt) - self.assertEquals(len(threads), 1) + self.assertEqual(len(threads), 1) thread = threads[0] frame = thread.GetFrameAtIndex(0) @@ -184,7 +184,7 @@ def test_get_objc_dynamic_vals(self): # whatever... threads = lldbutil.continue_to_breakpoint(process, handle_SourceBase_bkpt) - self.assertEquals(len(threads), 1) + self.assertEqual(len(threads), 1) thread = threads[0] frame = thread.GetFrameAtIndex(0) @@ -205,4 +205,4 @@ def examine_SourceDerived_ptr(self, object): self.assertNotEqual(object.GetTypeName().find("SourceDerived"), -1) derivedValue = object.GetChildMemberWithName("_derivedValue") self.assertTrue(derivedValue) - self.assertEquals(int(derivedValue.GetValue(), 0), 30) + self.assertEqual(int(derivedValue.GetValue(), 0), 30) diff --git a/lldb/test/API/lang/objc/objc-ivar-offsets/TestObjCIvarOffsets.py b/lldb/test/API/lang/objc/objc-ivar-offsets/TestObjCIvarOffsets.py index d77f646b2772b..cc9ddca5b5f52 100644 --- a/lldb/test/API/lang/objc/objc-ivar-offsets/TestObjCIvarOffsets.py +++ b/lldb/test/API/lang/objc/objc-ivar-offsets/TestObjCIvarOffsets.py @@ -32,7 +32,7 @@ def test_with_python_api(self): self.assertEqual(process.GetState(), lldb.eStateStopped, "Stopped it too.") thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint) - self.assertEquals(len(thread_list), 1) + self.assertEqual(len(thread_list), 1) thread = thread_list[0] frame = thread.GetFrameAtIndex(0) @@ -49,7 +49,7 @@ def test_with_python_api(self): self.assertTrue(mine_backed_int, "Found mine->backed_int local variable.") backed_value = mine_backed_int.GetValueAsSigned(error) self.assertSuccess(error) - self.assertEquals(backed_value, 1111) + self.assertEqual(backed_value, 1111) # Test the value object value for DerivedClass->_derived_backed_int @@ -59,7 +59,7 @@ def test_with_python_api(self): ) derived_backed_value = mine_derived_backed_int.GetValueAsSigned(error) self.assertSuccess(error) - self.assertEquals(derived_backed_value, 3333) + self.assertEqual(derived_backed_value, 3333) # Make sure we also get bit-field offsets correct: @@ -67,4 +67,4 @@ def test_with_python_api(self): self.assertTrue(mine_flag2, "Found mine->flag2 local variable.") flag2_value = mine_flag2.GetValueAsUnsigned(error) self.assertSuccess(error) - self.assertEquals(flag2_value, 7) + self.assertEqual(flag2_value, 7) diff --git a/lldb/test/API/lang/objc/objc-ivar-stripped/TestObjCIvarStripped.py b/lldb/test/API/lang/objc/objc-ivar-stripped/TestObjCIvarStripped.py index 128468d7add41..7ad321949b208 100644 --- a/lldb/test/API/lang/objc/objc-ivar-stripped/TestObjCIvarStripped.py +++ b/lldb/test/API/lang/objc/objc-ivar-stripped/TestObjCIvarStripped.py @@ -40,7 +40,7 @@ def test_with_python_api(self): self.assertEqual(process.GetState(), lldb.eStateStopped, "Stopped it too.") thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint) - self.assertEquals(len(thread_list), 1) + self.assertEqual(len(thread_list), 1) thread = thread_list[0] frame = thread.GetFrameAtIndex(0) @@ -54,4 +54,4 @@ def test_with_python_api(self): self.assertTrue(ivar, "Got result for mc->_foo") ivar_value = ivar.GetValueAsSigned(error) self.assertSuccess(error) - self.assertEquals(ivar_value, 3) + self.assertEqual(ivar_value, 3) diff --git a/lldb/test/API/lang/objc/objc-property/TestObjCProperty.py b/lldb/test/API/lang/objc/objc-property/TestObjCProperty.py index 2cbcd1551cb16..19740718711c7 100644 --- a/lldb/test/API/lang/objc/objc-property/TestObjCProperty.py +++ b/lldb/test/API/lang/objc/objc-property/TestObjCProperty.py @@ -46,7 +46,7 @@ def test_objc_properties(self): self.assertState(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED) threads = lldbutil.get_threads_stopped_at_breakpoint(process, main_bkpt) - self.assertEquals(len(threads), 1) + self.assertEqual(len(threads), 1) thread = threads[0] frame = thread.GetFrameAtIndex(0) @@ -66,13 +66,13 @@ def test_objc_properties(self): nonexistant_error = nonexistant_value.GetError() self.assertSuccess(nonexistant_error) nonexistant_int = nonexistant_value.GetValueAsUnsigned(123456) - self.assertEquals(nonexistant_int, 6) + self.assertEqual(nonexistant_int, 6) # Calling the getter function would up the access count, so make sure # that happened. new_access_count = access_count.GetValueAsUnsigned(123456) - self.assertEquals(new_access_count - start_access_count, 1) + self.assertEqual(new_access_count - start_access_count, 1) start_access_count = new_access_count # @@ -85,7 +85,7 @@ def test_objc_properties(self): # that happened. new_access_count = access_count.GetValueAsUnsigned(123456) - self.assertEquals(new_access_count - start_access_count, 1) + self.assertEqual(new_access_count - start_access_count, 1) start_access_count = new_access_count # @@ -117,12 +117,12 @@ def test_objc_properties(self): idWithProtocol_value = frame.EvaluateExpression("mine.idWithProtocol", False) idWithProtocol_error = idWithProtocol_value.GetError() self.assertSuccess(idWithProtocol_error) - self.assertEquals(idWithProtocol_value.GetTypeName(), "id") + self.assertEqual(idWithProtocol_value.GetTypeName(), "id") # Make sure that class property getter works as expected value = frame.EvaluateExpression("BaseClass.classInt", False) self.assertSuccess(value.GetError()) - self.assertEquals(value.GetValueAsUnsigned(11111), 123) + self.assertEqual(value.GetValueAsUnsigned(11111), 123) # Make sure that class property setter works as expected value = frame.EvaluateExpression("BaseClass.classInt = 234", False) @@ -131,7 +131,7 @@ def test_objc_properties(self): # Verify that setter above actually worked value = frame.EvaluateExpression("BaseClass.classInt", False) self.assertSuccess(value.GetError()) - self.assertEquals(value.GetValueAsUnsigned(11111), 234) + self.assertEqual(value.GetValueAsUnsigned(11111), 234) # Test that accessing two distinct class and instance properties that # share the same name works. diff --git a/lldb/test/API/lang/objc/objc-static-method-stripped/TestObjCStaticMethodStripped.py b/lldb/test/API/lang/objc/objc-static-method-stripped/TestObjCStaticMethodStripped.py index db575e60e1a11..2a7fad63985cd 100644 --- a/lldb/test/API/lang/objc/objc-static-method-stripped/TestObjCStaticMethodStripped.py +++ b/lldb/test/API/lang/objc/objc-static-method-stripped/TestObjCStaticMethodStripped.py @@ -44,7 +44,7 @@ def test_with_python_api(self): # Make sure we stopped at the first breakpoint. self.assertNotEqual(len(thread_list), 0, "No thread stopped at our breakpoint.") - self.assertEquals( + self.assertEqual( len(thread_list), 1, "More than one thread stopped at our breakpoint." ) diff --git a/lldb/test/API/lang/objc/objc-static-method/TestObjCStaticMethod.py b/lldb/test/API/lang/objc/objc-static-method/TestObjCStaticMethod.py index a811a2f6a82b4..0a94810da0cad 100644 --- a/lldb/test/API/lang/objc/objc-static-method/TestObjCStaticMethod.py +++ b/lldb/test/API/lang/objc/objc-static-method/TestObjCStaticMethod.py @@ -38,7 +38,7 @@ def test_with_python_api(self): # Make sure we stopped at the first breakpoint. self.assertNotEqual(len(thread_list), 0, "No thread stopped at our breakpoint.") - self.assertEquals( + self.assertEqual( len(thread_list), 1, "More than one thread stopped at our breakpoint." ) diff --git a/lldb/test/API/lang/objc/objc-struct-argument/TestObjCStructArgument.py b/lldb/test/API/lang/objc/objc-struct-argument/TestObjCStructArgument.py index 5fbbbf17b9736..9ffcc715ad830 100644 --- a/lldb/test/API/lang/objc/objc-struct-argument/TestObjCStructArgument.py +++ b/lldb/test/API/lang/objc/objc-struct-argument/TestObjCStructArgument.py @@ -39,7 +39,7 @@ def test_with_python_api(self): # Make sure we stopped at the first breakpoint. self.assertTrue(len(thread_list) != 0, "No thread stopped at our breakpoint.") - self.assertEquals( + self.assertEqual( len(thread_list), 1, "More than one thread stopped at our breakpoint." ) diff --git a/lldb/test/API/lang/objc/objc-struct-return/TestObjCStructReturn.py b/lldb/test/API/lang/objc/objc-struct-return/TestObjCStructReturn.py index a11846b3baf9d..d704ed2114f45 100644 --- a/lldb/test/API/lang/objc/objc-struct-return/TestObjCStructReturn.py +++ b/lldb/test/API/lang/objc/objc-struct-return/TestObjCStructReturn.py @@ -37,7 +37,7 @@ def test_with_python_api(self): # Make sure we stopped at the first breakpoint. self.assertTrue(len(thread_list) != 0, "No thread stopped at our breakpoint.") - self.assertEquals( + self.assertEqual( len(thread_list), 1, "More than one thread stopped at our breakpoint." ) diff --git a/lldb/test/API/lang/objc/objc-super/TestObjCSuper.py b/lldb/test/API/lang/objc/objc-super/TestObjCSuper.py index f89a2d1cdae99..8e446224c0ade 100644 --- a/lldb/test/API/lang/objc/objc-super/TestObjCSuper.py +++ b/lldb/test/API/lang/objc/objc-super/TestObjCSuper.py @@ -37,7 +37,7 @@ def test_with_python_api(self): # Make sure we stopped at the first breakpoint. self.assertTrue(len(thread_list) != 0, "No thread stopped at our breakpoint.") - self.assertEquals( + self.assertEqual( len(thread_list), 1, "More than one thread stopped at our breakpoint." ) @@ -48,8 +48,8 @@ def test_with_python_api(self): cmd_value = frame.EvaluateExpression("[self get]") self.assertTrue(cmd_value.IsValid()) - self.assertEquals(cmd_value.GetValueAsUnsigned(), 2) + self.assertEqual(cmd_value.GetValueAsUnsigned(), 2) cmd_value = frame.EvaluateExpression("[super get]") self.assertTrue(cmd_value.IsValid()) - self.assertEquals(cmd_value.GetValueAsUnsigned(), 1) + self.assertEqual(cmd_value.GetValueAsUnsigned(), 1) diff --git a/lldb/test/API/lang/objcxx/objc-builtin-types/TestObjCBuiltinTypes.py b/lldb/test/API/lang/objcxx/objc-builtin-types/TestObjCBuiltinTypes.py index 27b44ecf66e71..698b16df78360 100644 --- a/lldb/test/API/lang/objcxx/objc-builtin-types/TestObjCBuiltinTypes.py +++ b/lldb/test/API/lang/objcxx/objc-builtin-types/TestObjCBuiltinTypes.py @@ -36,7 +36,7 @@ def test_with_python_api(self): # Make sure we stopped at the first breakpoint. self.assertTrue(len(thread_list) != 0, "No thread stopped at our breakpoint.") - self.assertEquals( + self.assertEqual( len(thread_list), 1, "More than one thread stopped at our breakpoint." ) diff --git a/lldb/test/API/lua_api/TestBreakpointAPI.lua b/lldb/test/API/lua_api/TestBreakpointAPI.lua index 6e38dc3f975c6..a2bf657d8db7e 100644 --- a/lldb/test/API/lua_api/TestBreakpointAPI.lua +++ b/lldb/test/API/lua_api/TestBreakpointAPI.lua @@ -17,7 +17,7 @@ function _T:TestTargetDelete() assertTrue(breakpoint:IsValid() and breakpoint:GetNumLocations() == 1) local location = breakpoint:GetLocationAtIndex(0) assertTrue(location:IsValid()) - assertEquals(target, breakpoint:GetTarget()) + assertEqual(target, breakpoint:GetTarget()) assertTrue(self.debugger:DeleteTarget(target)) assertFalse(breakpoint:IsValid()) assertFalse(location:IsValid()) @@ -29,7 +29,7 @@ function _T:TestBreakpointHitCount() assertTrue(breakpoint:IsValid() and breakpoint:GetNumLocations() == 1) breakpoint:SetAutoContinue(true) target:LaunchSimple(nil, nil, nil) - assertEquals(breakpoint:GetHitCount(), 100) + assertEqual(breakpoint:GetHitCount(), 100) end function _T:TestBreakpointFrame() @@ -46,7 +46,7 @@ function _T:TestBreakpointFrame() local var_argc = frame:FindVariable('argc') local var_argc_value = var_argc:GetValueAsSigned(error, 0) assertTrue(error:Success()) - assertEquals(var_argc_value, 3) + assertEqual(var_argc_value, 3) end os.exit(_T:run()) diff --git a/lldb/test/API/lua_api/TestComprehensive.lua b/lldb/test/API/lua_api/TestComprehensive.lua index ccea559546958..b308f792df4ef 100644 --- a/lldb/test/API/lua_api/TestComprehensive.lua +++ b/lldb/test/API/lua_api/TestComprehensive.lua @@ -43,7 +43,7 @@ function _T:Test3_BreakpointFindVariables() assertTrue(var_argc:IsValid()) local var_argc_value = var_argc:GetValueAsSigned(error, 0) assertTrue(error:Success()) - assertEquals(var_argc_value, 2) + assertEqual(var_argc_value, 2) -- checking "inited" value local continue = self.process:Continue() @@ -59,7 +59,7 @@ function _T:Test3_BreakpointFindVariables() self.var_inited = var_inited local var_inited_value = var_inited:GetValueAsUnsigned(error, 0) assertTrue(error:Success()) - assertEquals(var_inited_value, 0xDEADBEEF) + assertEqual(var_inited_value, 0xDEADBEEF) end function _T:Test3_RawData() @@ -84,7 +84,7 @@ end function _T:Test5_FileOutput() local f = io.open(self.output, 'r') - assertEquals( + assertEqual( read_file_non_empty_lines(f), { self.exe, diff --git a/lldb/test/API/lua_api/TestFileHandle.lua b/lldb/test/API/lua_api/TestFileHandle.lua index e50a1fb3dc058..aed45be206ea6 100644 --- a/lldb/test/API/lua_api/TestFileHandle.lua +++ b/lldb/test/API/lua_api/TestFileHandle.lua @@ -9,7 +9,7 @@ function _T:TestLegacyFileOutScript() f:close() f = io.open(self.output, 'r') - assertEquals(read_file_non_empty_lines(f), {'2', 'FOO'}) + assertEqual(read_file_non_empty_lines(f), {'2', 'FOO'}) f:close() end diff --git a/lldb/test/API/lua_api/TestProcessAPI.lua b/lldb/test/API/lua_api/TestProcessAPI.lua index aa788ba741155..ff84cd9c7947c 100644 --- a/lldb/test/API/lua_api/TestProcessAPI.lua +++ b/lldb/test/API/lua_api/TestProcessAPI.lua @@ -13,7 +13,7 @@ function _T:TestProcessLaunchSimple() ) assertTrue(process:IsValid()) local stdout = process:GetSTDOUT(1000) - assertEquals(split_lines(stdout), {self.exe, table.unpack(args)}) + assertEqual(split_lines(stdout), {self.exe, table.unpack(args)}) end function _T:TestProcessLaunch() @@ -52,7 +52,7 @@ function _T:TestProcessLaunch() local continue = process:Continue() assertTrue(continue:Success()) local f = io.open(self.output, 'r') - assertEquals(read_file_non_empty_lines(f), {self.exe, table.unpack(args)}) + assertEqual(read_file_non_empty_lines(f), {self.exe, table.unpack(args)}) f:close() end diff --git a/lldb/test/API/lua_api/lua_lldb_test.lua b/lldb/test/API/lua_api/lua_lldb_test.lua index ebf4c7cbae2ac..8f03fdb55a5ee 100644 --- a/lldb/test/API/lua_api/lua_lldb_test.lua +++ b/lldb/test/API/lua_api/lua_lldb_test.lua @@ -14,15 +14,15 @@ function assertNotNil(x) if x == nil then error('assertNotNil failure') end end -function assertEquals(x, y) +function assertEqual(x, y) if type(x) == 'table' and type(y) == 'table' then for k, _ in pairs(x) do - assertEquals(x[k], y[k]) + assertEqual(x[k], y[k]) end elseif type(x) ~= type(y) then - error('assertEquals failure') + error('assertEqual failure') elseif x ~= y then - error('assertEquals failure') + error('assertEqual failure') end end diff --git a/lldb/test/API/macosx/find-dsym/bundle-with-dot-in-filename/TestBundleWithDotInFilename.py b/lldb/test/API/macosx/find-dsym/bundle-with-dot-in-filename/TestBundleWithDotInFilename.py index 3fe504999f368..cecdfd2673e37 100644 --- a/lldb/test/API/macosx/find-dsym/bundle-with-dot-in-filename/TestBundleWithDotInFilename.py +++ b/lldb/test/API/macosx/find-dsym/bundle-with-dot-in-filename/TestBundleWithDotInFilename.py @@ -65,7 +65,7 @@ def test_attach_and_check_dsyms(self): ) setup_complete = target.FindFirstGlobalVariable("setup_is_complete") - self.assertEquals( + self.assertEqual( setup_complete.GetValueAsUnsigned(), 1, "Check that inferior process has completed setup", diff --git a/lldb/test/API/macosx/find-dsym/deep-bundle/TestDeepBundle.py b/lldb/test/API/macosx/find-dsym/deep-bundle/TestDeepBundle.py index 4b405eef59d66..b7df2845c0d11 100644 --- a/lldb/test/API/macosx/find-dsym/deep-bundle/TestDeepBundle.py +++ b/lldb/test/API/macosx/find-dsym/deep-bundle/TestDeepBundle.py @@ -62,7 +62,7 @@ def test_attach_and_check_dsyms(self): ) setup_complete = target.FindFirstGlobalVariable("setup_is_complete") - self.assertEquals( + self.assertEqual( setup_complete.GetValueAsUnsigned(), 1, "Check that inferior process has completed setup", diff --git a/lldb/test/API/macosx/macCatalyst/TestMacCatalyst.py b/lldb/test/API/macosx/macCatalyst/TestMacCatalyst.py index f3797daf9183c..d3db99dc25000 100644 --- a/lldb/test/API/macosx/macCatalyst/TestMacCatalyst.py +++ b/lldb/test/API/macosx/macCatalyst/TestMacCatalyst.py @@ -27,7 +27,7 @@ def check_debugserver(self, log): """scan the debugserver packet log""" process_info = lldbutil.packetlog_get_process_info(log) self.assertIn("ostype", process_info) - self.assertEquals(process_info["ostype"], "maccatalyst") + self.assertEqual(process_info["ostype"], "maccatalyst") aout_info = None dylib_info = lldbutil.packetlog_get_dylib_info(log) @@ -35,4 +35,4 @@ def check_debugserver(self, log): if image["pathname"].endswith("a.out"): aout_info = image self.assertTrue(aout_info) - self.assertEquals(aout_info["min_version_os_name"], "maccatalyst") + self.assertEqual(aout_info["min_version_os_name"], "maccatalyst") diff --git a/lldb/test/API/macosx/macCatalystAppMacOSFramework/TestMacCatalystAppWithMacOSFramework.py b/lldb/test/API/macosx/macCatalystAppMacOSFramework/TestMacCatalystAppWithMacOSFramework.py index 65ba601a8f978..26b5c4354322f 100644 --- a/lldb/test/API/macosx/macCatalystAppMacOSFramework/TestMacCatalystAppWithMacOSFramework.py +++ b/lldb/test/API/macosx/macCatalystAppMacOSFramework/TestMacCatalystAppWithMacOSFramework.py @@ -33,7 +33,7 @@ def check_debugserver(self, log): """scan the debugserver packet log""" process_info = lldbutil.packetlog_get_process_info(log) self.assertIn("ostype", process_info) - self.assertEquals(process_info["ostype"], "maccatalyst") + self.assertEqual(process_info["ostype"], "maccatalyst") aout_info = None libfoo_info = None @@ -45,5 +45,5 @@ def check_debugserver(self, log): libfoo_info = image self.assertTrue(aout_info) self.assertTrue(libfoo_info) - self.assertEquals(aout_info["min_version_os_name"], "maccatalyst") - self.assertEquals(libfoo_info["min_version_os_name"], "macosx") + self.assertEqual(aout_info["min_version_os_name"], "maccatalyst") + self.assertEqual(libfoo_info["min_version_os_name"], "macosx") diff --git a/lldb/test/API/macosx/simulator/TestSimulatorPlatform.py b/lldb/test/API/macosx/simulator/TestSimulatorPlatform.py index 51a6b52212d7a..b712afdd7560a 100644 --- a/lldb/test/API/macosx/simulator/TestSimulatorPlatform.py +++ b/lldb/test/API/macosx/simulator/TestSimulatorPlatform.py @@ -17,7 +17,7 @@ def check_load_commands(self, expected_load_command): for line in load_cmds.split("\n"): if expected_load_command in line: found += 1 - self.assertEquals( + self.assertEqual( found, 1, "wrong number of load commands for {}".format(expected_load_command), @@ -27,7 +27,7 @@ def check_debugserver(self, log, expected_platform, expected_version): """scan the debugserver packet log""" process_info = lldbutil.packetlog_get_process_info(log) self.assertIn("ostype", process_info) - self.assertEquals(process_info["ostype"], expected_platform) + self.assertEqual(process_info["ostype"], expected_platform) dylib_info = lldbutil.packetlog_get_dylib_info(log) self.assertTrue(dylib_info) aout_info = None @@ -35,9 +35,9 @@ def check_debugserver(self, log, expected_platform, expected_version): if image["pathname"].endswith("a.out"): aout_info = image self.assertTrue(aout_info) - self.assertEquals(aout_info["min_version_os_name"], expected_platform) + self.assertEqual(aout_info["min_version_os_name"], expected_platform) if expected_version: - self.assertEquals(aout_info["min_version_os_sdk"], expected_version) + self.assertEqual(aout_info["min_version_os_sdk"], expected_version) @skipIf(bugnumber="rdar://76995109") def run_with(self, arch, os, vers, env, expected_load_command): diff --git a/lldb/test/API/macosx/thread-names/TestInterruptThreadNames.py b/lldb/test/API/macosx/thread-names/TestInterruptThreadNames.py index 78f5ccba73329..9a3339579de03 100644 --- a/lldb/test/API/macosx/thread-names/TestInterruptThreadNames.py +++ b/lldb/test/API/macosx/thread-names/TestInterruptThreadNames.py @@ -38,7 +38,7 @@ def test_with_python_api(self): # Check that the program was able to create its threads within the allotted time self.assertTrue(inferior_set_up.IsValid()) - self.assertEquals(inferior_set_up.GetValueAsSigned(), 1) + self.assertEqual(inferior_set_up.GetValueAsSigned(), 1) self.check_number_of_threads(process) diff --git a/lldb/test/API/macosx/universal/TestUniversal.py b/lldb/test/API/macosx/universal/TestUniversal.py index d988cc0923b27..8f5c4aa2a32c8 100644 --- a/lldb/test/API/macosx/universal/TestUniversal.py +++ b/lldb/test/API/macosx/universal/TestUniversal.py @@ -165,6 +165,6 @@ def test_process_attach_with_wrong_arch(self): # backtracing failed. threads = lldbutil.continue_to_breakpoint(process, bkpt) - self.assertEquals(len(threads), 1) + self.assertEqual(len(threads), 1) thread = threads[0] self.assertTrue(thread.GetNumFrames() > 1, "We were able to backtrace.") diff --git a/lldb/test/API/python_api/class_members/TestSBTypeClassMembers.py b/lldb/test/API/python_api/class_members/TestSBTypeClassMembers.py index 3a0483dc5d1e6..5ad2a073be585 100644 --- a/lldb/test/API/python_api/class_members/TestSBTypeClassMembers.py +++ b/lldb/test/API/python_api/class_members/TestSBTypeClassMembers.py @@ -52,10 +52,10 @@ def test(self): Derived = variable.GetType() Base = Derived.GetDirectBaseClassAtIndex(0).GetType() - self.assertEquals( + self.assertEqual( 2, Derived.GetNumberOfMemberFunctions(), "Derived declares two methods" ) - self.assertEquals( + self.assertEqual( "int", Derived.GetMemberFunctionAtIndex(0) .GetType() @@ -64,10 +64,10 @@ def test(self): "Derived::dImpl returns int", ) - self.assertEquals( + self.assertEqual( 4, Base.GetNumberOfMemberFunctions(), "Base declares three methods" ) - self.assertEquals( + self.assertEqual( 3, Base.GetMemberFunctionAtIndex(3) .GetType() @@ -75,15 +75,15 @@ def test(self): .GetSize(), "Base::sfunc takes three arguments", ) - self.assertEquals( + self.assertEqual( "sfunc", Base.GetMemberFunctionAtIndex(3).GetName(), "Base::sfunc not found" ) - self.assertEquals( + self.assertEqual( lldb.eMemberFunctionKindStaticMethod, Base.GetMemberFunctionAtIndex(3).GetKind(), "Base::sfunc is a static", ) - self.assertEquals( + self.assertEqual( 0, Base.GetMemberFunctionAtIndex(2) .GetType() @@ -91,7 +91,7 @@ def test(self): .GetSize(), "Base::dat takes no arguments", ) - self.assertEquals( + self.assertEqual( "char", Base.GetMemberFunctionAtIndex(1) .GetType() @@ -100,69 +100,69 @@ def test(self): .GetName(), "Base::bar takes a second 'char' argument", ) - self.assertEquals( + self.assertEqual( "bar", Base.GetMemberFunctionAtIndex(1).GetName(), "Base::bar not found" ) variable = frame0.FindVariable("thingy") Thingy = variable.GetType() - self.assertEquals( + self.assertEqual( 2, Thingy.GetNumberOfMemberFunctions(), "Thingy declares two methods" ) - self.assertEquals( + self.assertEqual( "id", Thingy.GetMemberFunctionAtIndex(0).GetReturnType().GetName(), "Thingy::init returns an id", ) - self.assertEquals( + self.assertEqual( 2, Thingy.GetMemberFunctionAtIndex(1).GetNumberOfArguments(), "Thingy::foo takes two arguments", ) - self.assertEquals( + self.assertEqual( "int", Thingy.GetMemberFunctionAtIndex(1).GetArgumentTypeAtIndex(0).GetName(), "Thingy::foo takes an int", ) - self.assertEquals( + self.assertEqual( "Derived::dImpl()", Derived.GetMemberFunctionAtIndex(0).GetDemangledName() ) - self.assertEquals( + self.assertEqual( "Derived::baz(float)", Derived.GetMemberFunctionAtIndex(1).GetDemangledName(), ) - self.assertEquals( + self.assertEqual( "Base::foo(int, int)", Base.GetMemberFunctionAtIndex(0).GetDemangledName() ) - self.assertEquals( + self.assertEqual( "Base::bar(int, char)", Base.GetMemberFunctionAtIndex(1).GetDemangledName() ) - self.assertEquals( + self.assertEqual( "Base::dat()", Base.GetMemberFunctionAtIndex(2).GetDemangledName() ) - self.assertEquals( + self.assertEqual( "Base::sfunc(char, int, float)", Base.GetMemberFunctionAtIndex(3).GetDemangledName(), ) - self.assertEquals( + self.assertEqual( "_ZN7Derived5dImplEv", Derived.GetMemberFunctionAtIndex(0).GetMangledName() ) - self.assertEquals( + self.assertEqual( "_ZN7Derived3bazEf", Derived.GetMemberFunctionAtIndex(1).GetMangledName() ) - self.assertEquals( + self.assertEqual( "_ZN4Base3fooEii", Base.GetMemberFunctionAtIndex(0).GetMangledName() ) - self.assertEquals( + self.assertEqual( "_ZN4Base3barEic", Base.GetMemberFunctionAtIndex(1).GetMangledName() ) - self.assertEquals( + self.assertEqual( "_ZN4Base3datEv", Base.GetMemberFunctionAtIndex(2).GetMangledName() ) - self.assertEquals( + self.assertEqual( "_ZN4Base5sfuncEcif", Base.GetMemberFunctionAtIndex(3).GetMangledName() ) diff --git a/lldb/test/API/python_api/debugger/TestDebuggerAPI.py b/lldb/test/API/python_api/debugger/TestDebuggerAPI.py index 0f440bd451dde..522de2466012e 100644 --- a/lldb/test/API/python_api/debugger/TestDebuggerAPI.py +++ b/lldb/test/API/python_api/debugger/TestDebuggerAPI.py @@ -32,7 +32,7 @@ def test_debugger_api_boundary_condition(self): self.dbg.SetCurrentPlatformSDKRoot(None) fresh_dbg = lldb.SBDebugger() - self.assertEquals(len(fresh_dbg), 0) + self.assertEqual(len(fresh_dbg), 0) def test_debugger_delete_invalid_target(self): """SBDebugger.DeleteTarget() should not crash LLDB given and invalid target.""" diff --git a/lldb/test/API/python_api/findvalue_duplist/TestSBFrameFindValue.py b/lldb/test/API/python_api/findvalue_duplist/TestSBFrameFindValue.py index df9da03a66bab..f989eb5b574b3 100644 --- a/lldb/test/API/python_api/findvalue_duplist/TestSBFrameFindValue.py +++ b/lldb/test/API/python_api/findvalue_duplist/TestSBFrameFindValue.py @@ -35,7 +35,7 @@ def test_formatters_api(self): # Frame #0 should be at our breakpoint. threads = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint) - self.assertEquals(len(threads), 1) + self.assertEqual(len(threads), 1) self.thread = threads[0] self.frame = self.thread.frames[0] self.assertTrue(self.frame, "Frame 0 is valid.") diff --git a/lldb/test/API/python_api/interpreter/TestCommandInterpreterAPI.py b/lldb/test/API/python_api/interpreter/TestCommandInterpreterAPI.py index 586e8da04556b..8f9fbfc255bb0 100644 --- a/lldb/test/API/python_api/interpreter/TestCommandInterpreterAPI.py +++ b/lldb/test/API/python_api/interpreter/TestCommandInterpreterAPI.py @@ -82,6 +82,6 @@ def test_command_output(self): ci.HandleCommand("settings set use-color false", res) self.assertTrue(res.Succeeded()) self.assertIsNotNone(res.GetOutput()) - self.assertEquals(res.GetOutput(), "") + self.assertEqual(res.GetOutput(), "") self.assertIsNotNone(res.GetError()) - self.assertEquals(res.GetError(), "") + self.assertEqual(res.GetError(), "") diff --git a/lldb/test/API/python_api/name_lookup/TestNameLookup.py b/lldb/test/API/python_api/name_lookup/TestNameLookup.py index 2af7226bf6ded..888c6339d7254 100644 --- a/lldb/test/API/python_api/name_lookup/TestNameLookup.py +++ b/lldb/test/API/python_api/name_lookup/TestNameLookup.py @@ -53,7 +53,7 @@ def test_target(self): self.assertGreaterEqual(len(mangled_to_symbol), 6) for mangled in mangled_to_symbol.keys(): symbol_contexts = target.FindFunctions(mangled, lldb.eFunctionNameTypeFull) - self.assertEquals(symbol_contexts.GetSize(), 1) + self.assertEqual(symbol_contexts.GetSize(), 1) for symbol_context in symbol_contexts: self.assertTrue(symbol_context.GetFunction().IsValid()) self.assertTrue(symbol_context.GetSymbol().IsValid()) diff --git a/lldb/test/API/python_api/objc_type/TestObjCType.py b/lldb/test/API/python_api/objc_type/TestObjCType.py index 5010d8aed26f9..3ff2552bee253 100644 --- a/lldb/test/API/python_api/objc_type/TestObjCType.py +++ b/lldb/test/API/python_api/objc_type/TestObjCType.py @@ -52,9 +52,9 @@ def test(self): aFooType = aBarType.GetDirectBaseClassAtIndex(0) self.assertTrue(aFooType.IsValid(), "Foo should be a valid data type") - self.assertEquals(aFooType.GetName(), "Foo", "Foo has the right name") + self.assertEqual(aFooType.GetName(), "Foo", "Foo has the right name") - self.assertEquals(aBarType.GetNumberOfFields(), 1, "Bar has a field") + self.assertEqual(aBarType.GetNumberOfFields(), 1, "Bar has a field") aBarField = aBarType.GetFieldAtIndex(0) self.assertEqual(aBarField.GetName(), "_iVar", "The field has the right name") diff --git a/lldb/test/API/python_api/sblaunchinfo/TestSBLaunchInfo.py b/lldb/test/API/python_api/sblaunchinfo/TestSBLaunchInfo.py index 7703666ea4947..6bf144e936517 100644 --- a/lldb/test/API/python_api/sblaunchinfo/TestSBLaunchInfo.py +++ b/lldb/test/API/python_api/sblaunchinfo/TestSBLaunchInfo.py @@ -21,8 +21,8 @@ class TestSBLaunchInfo(TestBase): def test_environment_getset(self): info = lldb.SBLaunchInfo(None) info.SetEnvironmentEntries(["FOO=BAR"], False) - self.assertEquals(1, info.GetNumEnvironmentEntries()) + self.assertEqual(1, info.GetNumEnvironmentEntries()) info.SetEnvironmentEntries(["BAR=BAZ"], True) - self.assertEquals(2, info.GetNumEnvironmentEntries()) - self.assertEquals("BAR", lookup(info, "FOO")) - self.assertEquals("BAZ", lookup(info, "BAR")) + self.assertEqual(2, info.GetNumEnvironmentEntries()) + self.assertEqual("BAR", lookup(info, "FOO")) + self.assertEqual("BAZ", lookup(info, "BAR")) diff --git a/lldb/test/API/python_api/sbvalue_persist/TestSBValuePersist.py b/lldb/test/API/python_api/sbvalue_persist/TestSBValuePersist.py index 38f3d3c984767..d441a9d121709 100644 --- a/lldb/test/API/python_api/sbvalue_persist/TestSBValuePersist.py +++ b/lldb/test/API/python_api/sbvalue_persist/TestSBValuePersist.py @@ -57,7 +57,7 @@ def cleanup(): self.assertEqual(fooPersist.GetValueAsUnsigned(0), 10, "fooPersist != 10") self.assertEqual(barPersist.GetPointeeData().sint32[0], 4, "barPersist != 4") - self.assertEquals(bazPersist.GetSummary(), '"85"', "bazPersist != 85") + self.assertEqual(bazPersist.GetSummary(), '"85"', "bazPersist != 85") self.runCmd("continue") @@ -67,6 +67,6 @@ def cleanup(): self.assertEqual(fooPersist.GetValueAsUnsigned(0), 10, "fooPersist != 10") self.assertEqual(barPersist.GetPointeeData().sint32[0], 4, "barPersist != 4") - self.assertEquals(bazPersist.GetSummary(), '"85"', "bazPersist != 85") + self.assertEqual(bazPersist.GetSummary(), '"85"', "bazPersist != 85") self.expect("expr *(%s)" % (barPersist.GetName()), substrs=["= 4"]) diff --git a/lldb/test/API/python_api/type/TestTypeList.py b/lldb/test/API/python_api/type/TestTypeList.py index 63ab958193574..8d82f7b022874 100644 --- a/lldb/test/API/python_api/type/TestTypeList.py +++ b/lldb/test/API/python_api/type/TestTypeList.py @@ -209,7 +209,7 @@ def test(self): int_scoped_enum_type = scoped_enum_type.GetEnumerationIntegerType() self.assertTrue(int_scoped_enum_type) self.DebugSBType(int_scoped_enum_type) - self.assertEquals(int_scoped_enum_type.GetName(), "int") + self.assertEqual(int_scoped_enum_type.GetName(), "int") enum_uchar = target.FindFirstType("EnumUChar") self.assertTrue(enum_uchar) @@ -217,4 +217,4 @@ def test(self): int_enum_uchar = enum_uchar.GetEnumerationIntegerType() self.assertTrue(int_enum_uchar) self.DebugSBType(int_enum_uchar) - self.assertEquals(int_enum_uchar.GetName(), "unsigned char") + self.assertEqual(int_enum_uchar.GetName(), "unsigned char") diff --git a/lldb/test/API/python_api/value/change_values/TestChangeValueAPI.py b/lldb/test/API/python_api/value/change_values/TestChangeValueAPI.py index 215feb358fb75..07250eb6a4830 100644 --- a/lldb/test/API/python_api/value/change_values/TestChangeValueAPI.py +++ b/lldb/test/API/python_api/value/change_values/TestChangeValueAPI.py @@ -66,7 +66,7 @@ def test_change_value(self): self.assertTrue(val_value.IsValid(), "Got the SBValue for val") actual_value = val_value.GetValueAsSigned(error, 0) self.assertSuccess(error, "Got a value from val") - self.assertEquals(actual_value, 100, "Got the right value from val") + self.assertEqual(actual_value, 100, "Got the right value from val") result = val_value.SetValueFromCString("12345") self.assertTrue(result, "Setting val returned True.") @@ -83,13 +83,13 @@ def test_change_value(self): self.assertTrue(mine_second_value.IsValid(), "Got second_val from mine") actual_value = mine_second_value.GetValueAsUnsigned(error, 0) self.assertTrue(error.Success(), "Got an unsigned value for second_val") - self.assertEquals(actual_value, 5555) + self.assertEqual(actual_value, 5555) result = mine_second_value.SetValueFromCString("98765") self.assertTrue(result, "Success setting mine.second_value.") actual_value = mine_second_value.GetValueAsSigned(error, 0) self.assertTrue(error.Success(), "Got a changed value from mine.second_val") - self.assertEquals( + self.assertEqual( actual_value, 98765, "Got the right changed value from mine.second_val" ) @@ -101,13 +101,13 @@ def test_change_value(self): self.assertTrue(ptr_second_value.IsValid(), "Got second_val from ptr") actual_value = ptr_second_value.GetValueAsUnsigned(error, 0) self.assertTrue(error.Success(), "Got an unsigned value for ptr->second_val") - self.assertEquals(actual_value, 6666) + self.assertEqual(actual_value, 6666) result = ptr_second_value.SetValueFromCString("98765") self.assertTrue(result, "Success setting ptr->second_value.") actual_value = ptr_second_value.GetValueAsSigned(error, 0) self.assertTrue(error.Success(), "Got a changed value from ptr->second_val") - self.assertEquals( + self.assertEqual( actual_value, 98765, "Got the right changed value from ptr->second_val" ) diff --git a/lldb/test/API/tools/lldb-dap/attach/TestDAP_attach.py b/lldb/test/API/tools/lldb-dap/attach/TestDAP_attach.py index 04017a0521e95..cab0067382caf 100644 --- a/lldb/test/API/tools/lldb-dap/attach/TestDAP_attach.py +++ b/lldb/test/API/tools/lldb-dap/attach/TestDAP_attach.py @@ -182,7 +182,7 @@ def test_commands(self): functions = ["main"] breakpoint_ids = self.set_function_breakpoints(functions) - self.assertEquals(len(breakpoint_ids), len(functions), "expect one breakpoint") + self.assertEqual(len(breakpoint_ids), len(functions), "expect one breakpoint") self.continue_to_breakpoints(breakpoint_ids) output = self.get_console(timeout=1.0) self.verify_commands("stopCommands", output, stopCommands) diff --git a/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_logpoints.py b/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_logpoints.py index 6010052cd07d6..cbf190f2b2bfc 100644 --- a/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_logpoints.py +++ b/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_logpoints.py @@ -34,7 +34,7 @@ def test_logmessage_basic(self): before_loop_breakpoint_ids = self.set_source_breakpoints( self.main_path, [before_loop_line] ) - self.assertEquals(len(before_loop_breakpoint_ids), 1, "expect one breakpoint") + self.assertEqual(len(before_loop_breakpoint_ids), 1, "expect one breakpoint") self.dap_server.request_continue() @@ -97,7 +97,7 @@ def test_logmessage_advanced(self): before_loop_breakpoint_ids = self.set_source_breakpoints( self.main_path, [before_loop_line] ) - self.assertEquals(len(before_loop_breakpoint_ids), 1, "expect one breakpoint") + self.assertEqual(len(before_loop_breakpoint_ids), 1, "expect one breakpoint") self.dap_server.request_continue() @@ -160,7 +160,7 @@ def test_logmessage_format(self): before_loop_breakpoint_ids = self.set_source_breakpoints( self.main_path, [before_loop_line] ) - self.assertEquals(len(before_loop_breakpoint_ids), 1, "expect one breakpoint") + self.assertEqual(len(before_loop_breakpoint_ids), 1, "expect one breakpoint") self.dap_server.request_continue() @@ -225,7 +225,7 @@ def test_logmessage_format_failure(self): before_loop_breakpoint_ids = self.set_source_breakpoints( self.main_path, [before_loop_line] ) - self.assertEquals(len(before_loop_breakpoint_ids), 1, "expect one breakpoint") + self.assertEqual(len(before_loop_breakpoint_ids), 1, "expect one breakpoint") self.dap_server.request_continue() diff --git a/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_setBreakpoints.py b/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_setBreakpoints.py index 3d3252a78b19a..6f57c05e43c8b 100644 --- a/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_setBreakpoints.py +++ b/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_setBreakpoints.py @@ -60,7 +60,7 @@ def test_source_map(self): # breakpoint in main.cpp response = self.dap_server.request_setBreakpoints(new_main_path, [main_line]) breakpoints = response["body"]["breakpoints"] - self.assertEquals(len(breakpoints), 1) + self.assertEqual(len(breakpoints), 1) breakpoint = breakpoints[0] self.assertEqual(breakpoint["line"], main_line) self.assertTrue(breakpoint["verified"]) @@ -129,7 +129,7 @@ def test_set_and_clear(self): line_to_id = {} if response: breakpoints = response["body"]["breakpoints"] - self.assertEquals( + self.assertEqual( len(breakpoints), len(lines), "expect %u source breakpoints" % (len(lines)), @@ -155,7 +155,7 @@ def test_set_and_clear(self): response = self.dap_server.request_setBreakpoints(self.main_path, lines) if response: breakpoints = response["body"]["breakpoints"] - self.assertEquals( + self.assertEqual( len(breakpoints), len(lines), "expect %u source breakpoints" % (len(lines)), @@ -165,7 +165,7 @@ def test_set_and_clear(self): self.assertTrue(line, lines[index]) # Verify the same breakpoints are still set within LLDB by # making sure the breakpoint ID didn't change - self.assertEquals( + self.assertEqual( line_to_id[line], breakpoint["id"], "verify previous breakpoints stayed the same", @@ -182,7 +182,7 @@ def test_set_and_clear(self): response = self.dap_server.request_testGetTargetBreakpoints() if response: breakpoints = response["body"]["breakpoints"] - self.assertEquals( + self.assertEqual( len(breakpoints), len(lines), "expect %u source breakpoints" % (len(lines)), @@ -191,7 +191,7 @@ def test_set_and_clear(self): line = breakpoint["line"] # Verify the same breakpoints are still set within LLDB by # making sure the breakpoint ID didn't change - self.assertEquals( + self.assertEqual( line_to_id[line], breakpoint["id"], "verify previous breakpoints stayed the same", @@ -207,7 +207,7 @@ def test_set_and_clear(self): response = self.dap_server.request_setBreakpoints(self.main_path, lines) if response: breakpoints = response["body"]["breakpoints"] - self.assertEquals( + self.assertEqual( len(breakpoints), len(lines), "expect %u source breakpoints" % (len(lines)), @@ -217,7 +217,7 @@ def test_set_and_clear(self): response = self.dap_server.request_testGetTargetBreakpoints() if response: breakpoints = response["body"]["breakpoints"] - self.assertEquals( + self.assertEqual( len(breakpoints), len(lines), "expect %u source breakpoints" % (len(lines)), @@ -229,7 +229,7 @@ def test_set_and_clear(self): response = self.dap_server.request_setBreakpoints(self.main_path, lines) if response: breakpoints = response["body"]["breakpoints"] - self.assertEquals( + self.assertEqual( len(breakpoints), len(lines), "expect %u source breakpoints" % (len(lines)), @@ -248,7 +248,7 @@ def test_set_and_clear(self): response = self.dap_server.request_testGetTargetBreakpoints() if response: breakpoints = response["body"]["breakpoints"] - self.assertEquals( + self.assertEqual( len(breakpoints), len(lines), "expect %u source breakpoints" % (len(lines)), @@ -281,7 +281,7 @@ def test_clear_breakpoints_unset_breakpoints(self): response = self.dap_server.request_setBreakpoints(self.main_path, lines) line_to_id = {} breakpoints = response["body"]["breakpoints"] - self.assertEquals( + self.assertEqual( len(breakpoints), len(lines), "expect %u source breakpoints" % (len(lines)) ) for breakpoint, index in zip(breakpoints, range(len(lines))): @@ -297,12 +297,12 @@ def test_clear_breakpoints_unset_breakpoints(self): lines = None response = self.dap_server.request_setBreakpoints(self.main_path, lines) breakpoints = response["body"]["breakpoints"] - self.assertEquals(len(breakpoints), 0, "expect no source breakpoints") + self.assertEqual(len(breakpoints), 0, "expect no source breakpoints") # Verify with the target that all breakpoints have been cleared. response = self.dap_server.request_testGetTargetBreakpoints() breakpoints = response["body"]["breakpoints"] - self.assertEquals(len(breakpoints), 0, "expect no source breakpoints") + self.assertEqual(len(breakpoints), 0, "expect no source breakpoints") @skipIfWindows @skipIfRemote @@ -316,7 +316,7 @@ def test_functionality(self): # Set a breakpoint at the loop line with no condition and no # hitCondition breakpoint_ids = self.set_source_breakpoints(self.main_path, [loop_line]) - self.assertEquals(len(breakpoint_ids), 1, "expect one breakpoint") + self.assertEqual(len(breakpoint_ids), 1, "expect one breakpoint") self.dap_server.request_continue() # Verify we hit the breakpoint we just set @@ -324,13 +324,13 @@ def test_functionality(self): # Make sure i is zero at first breakpoint i = int(self.dap_server.get_local_variable_value("i")) - self.assertEquals(i, 0, "i != 0 after hitting breakpoint") + self.assertEqual(i, 0, "i != 0 after hitting breakpoint") # Update the condition on our breakpoint new_breakpoint_ids = self.set_source_breakpoints( self.main_path, [loop_line], [{"condition": "i==4"}] ) - self.assertEquals( + self.assertEqual( breakpoint_ids, new_breakpoint_ids, "existing breakpoint should have its condition " "updated", @@ -338,13 +338,13 @@ def test_functionality(self): self.continue_to_breakpoints(breakpoint_ids) i = int(self.dap_server.get_local_variable_value("i")) - self.assertEquals(i, 4, "i != 4 showing conditional works") + self.assertEqual(i, 4, "i != 4 showing conditional works") new_breakpoint_ids = self.set_source_breakpoints( self.main_path, [loop_line], [{"hitCondition": "2"}] ) - self.assertEquals( + self.assertEqual( breakpoint_ids, new_breakpoint_ids, "existing breakpoint should have its condition " "updated", @@ -353,10 +353,10 @@ def test_functionality(self): # Continue with a hitCondition of 2 and expect it to skip 1 value self.continue_to_breakpoints(breakpoint_ids) i = int(self.dap_server.get_local_variable_value("i")) - self.assertEquals(i, 6, "i != 6 showing hitCondition works") + self.assertEqual(i, 6, "i != 6 showing hitCondition works") # continue after hitting our hitCondition and make sure it only goes # up by 1 self.continue_to_breakpoints(breakpoint_ids) i = int(self.dap_server.get_local_variable_value("i")) - self.assertEquals(i, 7, "i != 7 showing post hitCondition hits every time") + self.assertEqual(i, 7, "i != 7 showing post hitCondition hits every time") diff --git a/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_setFunctionBreakpoints.py b/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_setFunctionBreakpoints.py index f90dc0f041ecb..9708effb7a1a7 100644 --- a/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_setFunctionBreakpoints.py +++ b/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_setFunctionBreakpoints.py @@ -37,7 +37,7 @@ def test_set_and_clear(self): response = self.dap_server.request_setFunctionBreakpoints(functions) if response: breakpoints = response["body"]["breakpoints"] - self.assertEquals( + self.assertEqual( len(breakpoints), len(functions), "expect %u source breakpoints" % (len(functions)), @@ -51,7 +51,7 @@ def test_set_and_clear(self): response = self.dap_server.request_setFunctionBreakpoints(functions) if response: breakpoints = response["body"]["breakpoints"] - self.assertEquals( + self.assertEqual( len(breakpoints), len(functions), "expect %u source breakpoints" % (len(functions)), @@ -65,14 +65,14 @@ def test_set_and_clear(self): response = self.dap_server.request_setFunctionBreakpoints(functions) if response: breakpoints = response["body"]["breakpoints"] - self.assertEquals( + self.assertEqual( len(breakpoints), len(functions), "expect %u source breakpoints" % (len(functions)), ) for breakpoint in breakpoints: bp_id = breakpoint["id"] - self.assertEquals( + self.assertEqual( bp_id, bp_id_12, 'verify "twelve" breakpoint ID is same' ) self.assertTrue( @@ -86,14 +86,14 @@ def test_set_and_clear(self): response = self.dap_server.request_testGetTargetBreakpoints() if response: breakpoints = response["body"]["breakpoints"] - self.assertEquals( + self.assertEqual( len(breakpoints), len(functions), "expect %u source breakpoints" % (len(functions)), ) for breakpoint in breakpoints: bp_id = breakpoint["id"] - self.assertEquals( + self.assertEqual( bp_id, bp_id_12, 'verify "twelve" breakpoint ID is same' ) self.assertTrue( @@ -106,7 +106,7 @@ def test_set_and_clear(self): response = self.dap_server.request_setFunctionBreakpoints(functions) if response: breakpoints = response["body"]["breakpoints"] - self.assertEquals( + self.assertEqual( len(breakpoints), len(functions), "expect %u source breakpoints" % (len(functions)), @@ -116,7 +116,7 @@ def test_set_and_clear(self): response = self.dap_server.request_testGetTargetBreakpoints() if response: breakpoints = response["body"]["breakpoints"] - self.assertEquals( + self.assertEqual( len(breakpoints), len(functions), "expect %u source breakpoints" % (len(functions)), @@ -134,18 +134,18 @@ def test_functionality(self): functions = ["twelve"] breakpoint_ids = self.set_function_breakpoints(functions) - self.assertEquals(len(breakpoint_ids), len(functions), "expect one breakpoint") + self.assertEqual(len(breakpoint_ids), len(functions), "expect one breakpoint") # Verify we hit the breakpoint we just set self.continue_to_breakpoints(breakpoint_ids) # Make sure i is zero at first breakpoint i = int(self.dap_server.get_local_variable_value("i")) - self.assertEquals(i, 0, "i != 0 after hitting breakpoint") + self.assertEqual(i, 0, "i != 0 after hitting breakpoint") # Update the condition on our breakpoint new_breakpoint_ids = self.set_function_breakpoints(functions, condition="i==4") - self.assertEquals( + self.assertEqual( breakpoint_ids, new_breakpoint_ids, "existing breakpoint should have its condition " "updated", @@ -153,10 +153,10 @@ def test_functionality(self): self.continue_to_breakpoints(breakpoint_ids) i = int(self.dap_server.get_local_variable_value("i")) - self.assertEquals(i, 4, "i != 4 showing conditional works") + self.assertEqual(i, 4, "i != 4 showing conditional works") new_breakpoint_ids = self.set_function_breakpoints(functions, hitCondition="2") - self.assertEquals( + self.assertEqual( breakpoint_ids, new_breakpoint_ids, "existing breakpoint should have its condition " "updated", @@ -165,10 +165,10 @@ def test_functionality(self): # Continue with a hitCondition of 2 and expect it to skip 1 value self.continue_to_breakpoints(breakpoint_ids) i = int(self.dap_server.get_local_variable_value("i")) - self.assertEquals(i, 6, "i != 6 showing hitCondition works") + self.assertEqual(i, 6, "i != 6 showing hitCondition works") # continue after hitting our hitCondition and make sure it only goes # up by 1 self.continue_to_breakpoints(breakpoint_ids) i = int(self.dap_server.get_local_variable_value("i")) - self.assertEquals(i, 7, "i != 7 showing post hitCondition hits every time") + self.assertEqual(i, 7, "i != 7 showing post hitCondition hits every time") diff --git a/lldb/test/API/tools/lldb-dap/coreFile/TestDAP_coreFile.py b/lldb/test/API/tools/lldb-dap/coreFile/TestDAP_coreFile.py index 2ac1f39772bbc..3781f651325d3 100644 --- a/lldb/test/API/tools/lldb-dap/coreFile/TestDAP_coreFile.py +++ b/lldb/test/API/tools/lldb-dap/coreFile/TestDAP_coreFile.py @@ -47,14 +47,14 @@ def test_core_file(self): }, ] - self.assertEquals(self.get_stackFrames(), expected_frames) + self.assertEqual(self.get_stackFrames(), expected_frames) # Resuming should have no effect and keep the process stopped self.continue_to_next_stop() - self.assertEquals(self.get_stackFrames(), expected_frames) + self.assertEqual(self.get_stackFrames(), expected_frames) self.dap_server.request_next(threadId=32259) - self.assertEquals(self.get_stackFrames(), expected_frames) + self.assertEqual(self.get_stackFrames(), expected_frames) @skipIfWindows @skipIfRemote diff --git a/lldb/test/API/tools/lldb-dap/launch/TestDAP_launch.py b/lldb/test/API/tools/lldb-dap/launch/TestDAP_launch.py index 7895861225369..829fb3b7ba6a4 100644 --- a/lldb/test/API/tools/lldb-dap/launch/TestDAP_launch.py +++ b/lldb/test/API/tools/lldb-dap/launch/TestDAP_launch.py @@ -118,7 +118,7 @@ def test_debuggerRoot(self): for line in lines: if line.startswith(prefix): found = True - self.assertEquals( + self.assertEqual( program_parent_dir, line[len(prefix) :], "lldb-dap working dir '%s' == '%s'" @@ -145,7 +145,7 @@ def test_sourcePath(self): if line.startswith(prefix): found = True quoted_path = '"%s"' % (program_dir) - self.assertEquals( + self.assertEqual( quoted_path, line[len(prefix) :], "lldb-dap working dir %s == %s" % (quoted_path, line[6:]), @@ -164,7 +164,7 @@ def test_disableSTDIO(self): self.continue_to_exit() # Now get the STDOUT and verify our program argument is correct output = self.get_stdout() - self.assertEquals(output, None, "expect no program output") + self.assertEqual(output, None, "expect no program output") @skipIfWindows @skipIfLinux # shell argument expansion doesn't seem to work on Linux @@ -327,7 +327,7 @@ def test_commands(self): # Set 2 breakpoints so we can verify that "stopCommands" get run as the # breakpoints get hit breakpoint_ids = self.set_source_breakpoints(source, lines) - self.assertEquals( + self.assertEqual( len(breakpoint_ids), len(lines), "expect correct number of breakpoints" ) diff --git a/lldb/test/API/tools/lldb-dap/module/TestDAP_module.py b/lldb/test/API/tools/lldb-dap/module/TestDAP_module.py index 91321a00ed31c..3f3ead033ce94 100644 --- a/lldb/test/API/tools/lldb-dap/module/TestDAP_module.py +++ b/lldb/test/API/tools/lldb-dap/module/TestDAP_module.py @@ -17,7 +17,7 @@ def run_test(self, symbol_basename, expect_debug_info_size): self.build_and_launch(program) functions = ["foo"] breakpoint_ids = self.set_function_breakpoints(functions) - self.assertEquals(len(breakpoint_ids), len(functions), "expect one breakpoint") + self.assertEqual(len(breakpoint_ids), len(functions), "expect one breakpoint") self.continue_to_breakpoints(breakpoint_ids) active_modules = self.dap_server.get_modules() program_module = active_modules[program_basename] diff --git a/lldb/test/API/tools/lldb-dap/restart/TestDAP_restart.py b/lldb/test/API/tools/lldb-dap/restart/TestDAP_restart.py index b622792db5653..32dbc82a57296 100644 --- a/lldb/test/API/tools/lldb-dap/restart/TestDAP_restart.py +++ b/lldb/test/API/tools/lldb-dap/restart/TestDAP_restart.py @@ -29,7 +29,7 @@ def test_basic_functionality(self): self.verify_breakpoint_hit([bp_B]) # Make sure i has been modified from its initial value of 0. - self.assertEquals( + self.assertEqual( int(self.dap_server.get_local_variable_value("i")), 1234, "i != 1234 after hitting breakpoint B", @@ -38,7 +38,7 @@ def test_basic_functionality(self): # Restart then check we stop back at A and program state has been reset. self.dap_server.request_restart() self.verify_breakpoint_hit([bp_A]) - self.assertEquals( + self.assertEqual( int(self.dap_server.get_local_variable_value("i")), 0, "i != 0 after hitting breakpoint A on restart", @@ -105,7 +105,7 @@ def test_arguments(self): # We don't set any arguments in the initial launch request, so argc # should be 1. - self.assertEquals( + self.assertEqual( int(self.dap_server.get_local_variable_value("argc")), 1, "argc != 1 before restart", @@ -122,7 +122,7 @@ def test_arguments(self): } ) self.verify_breakpoint_hit([bp_A]) - self.assertEquals( + self.assertEqual( int(self.dap_server.get_local_variable_value("argc")), 5, "argc != 5 after restart", diff --git a/lldb/test/API/tools/lldb-dap/restart/TestDAP_restart_runInTerminal.py b/lldb/test/API/tools/lldb-dap/restart/TestDAP_restart_runInTerminal.py index 789f7b817dd9b..c19a6d5b54cdb 100644 --- a/lldb/test/API/tools/lldb-dap/restart/TestDAP_restart_runInTerminal.py +++ b/lldb/test/API/tools/lldb-dap/restart/TestDAP_restart_runInTerminal.py @@ -44,7 +44,7 @@ def test_basic_functionality(self): self.verify_breakpoint_hit([bp_B]) # Make sure i has been modified from its initial value of 0. - self.assertEquals( + self.assertEqual( int(self.dap_server.get_local_variable_value("i")), 1234, "i != 1234 after hitting breakpoint B", @@ -55,7 +55,7 @@ def test_basic_functionality(self): # Finally, check we stop back at A and program state has been reset. self.verify_breakpoint_hit([bp_A]) - self.assertEquals( + self.assertEqual( int(self.dap_server.get_local_variable_value("i")), 0, "i != 0 after hitting breakpoint A on restart", diff --git a/lldb/test/API/tools/lldb-dap/stackTrace/TestDAP_stackTrace.py b/lldb/test/API/tools/lldb-dap/stackTrace/TestDAP_stackTrace.py index c46d20c64c265..a51b2173f027d 100644 --- a/lldb/test/API/tools/lldb-dap/stackTrace/TestDAP_stackTrace.py +++ b/lldb/test/API/tools/lldb-dap/stackTrace/TestDAP_stackTrace.py @@ -39,18 +39,18 @@ def verify_stackFrame(self, frame_idx, stackFrame): else: expected_line = self.recurse_invocation expected_name = "main" - self.assertEquals( + self.assertEqual( frame_name, expected_name, 'frame #%i name "%s" == "%s"' % (frame_idx, frame_name, expected_name), ) - self.assertEquals( + self.assertEqual( frame_source, self.source_path, 'frame #%i source "%s" == "%s"' % (frame_idx, frame_source, self.source_path), ) - self.assertEquals( + self.assertEqual( frame_line, expected_line, "frame #%i line %i == %i" % (frame_idx, frame_line, expected_line), @@ -74,7 +74,7 @@ def test_stackTrace(self): # Set breakpoint at a point of deepest recuusion breakpoint_ids = self.set_source_breakpoints(source, lines) - self.assertEquals( + self.assertEqual( len(breakpoint_ids), len(lines), "expect correct number of breakpoints" ) @@ -86,7 +86,7 @@ def test_stackTrace(self): self.assertTrue( frameCount >= 20, "verify we get at least 20 frames for all frames" ) - self.assertEquals( + self.assertEqual( totalFrames, frameCount, "verify we get correct value for totalFrames count" ) self.verify_stackFrames(startFrame, stackFrames) @@ -94,7 +94,7 @@ def test_stackTrace(self): # Verify all stack frames by specifying startFrame = 0 and levels not # specified stackFrames = self.get_stackFrames(startFrame=startFrame) - self.assertEquals( + self.assertEqual( frameCount, len(stackFrames), ("verify same number of frames with startFrame=%i") % (startFrame), @@ -104,7 +104,7 @@ def test_stackTrace(self): # Verify all stack frames by specifying startFrame = 0 and levels = 0 levels = 0 stackFrames = self.get_stackFrames(startFrame=startFrame, levels=levels) - self.assertEquals( + self.assertEqual( frameCount, len(stackFrames), ("verify same number of frames with startFrame=%i and" " levels=%i") @@ -116,7 +116,7 @@ def test_stackTrace(self): # levels = 1 levels = 1 stackFrames = self.get_stackFrames(startFrame=startFrame, levels=levels) - self.assertEquals( + self.assertEqual( levels, len(stackFrames), ("verify one frame with startFrame=%i and" " levels=%i") @@ -128,7 +128,7 @@ def test_stackTrace(self): # levels = 3 levels = 3 stackFrames = self.get_stackFrames(startFrame=startFrame, levels=levels) - self.assertEquals( + self.assertEqual( levels, len(stackFrames), ("verify %i frames with startFrame=%i and" " levels=%i") @@ -141,7 +141,7 @@ def test_stackTrace(self): startFrame = 5 levels = 16 stackFrames = self.get_stackFrames(startFrame=startFrame, levels=levels) - self.assertEquals( + self.assertEqual( levels, len(stackFrames), ("verify %i frames with startFrame=%i and" " levels=%i") @@ -155,13 +155,13 @@ def test_stackTrace(self): (stackFrames, totalFrames) = self.get_stackFrames_and_totalFramesCount( startFrame=startFrame, levels=levels ) - self.assertEquals( + self.assertEqual( len(stackFrames), frameCount - startFrame, ("verify less than 1000 frames with startFrame=%i and" " levels=%i") % (startFrame, levels), ) - self.assertEquals( + self.assertEqual( totalFrames, frameCount, "verify we get correct value for totalFrames count " @@ -173,7 +173,7 @@ def test_stackTrace(self): startFrame = 5 levels = 0 stackFrames = self.get_stackFrames(startFrame=startFrame, levels=levels) - self.assertEquals( + self.assertEqual( len(stackFrames), frameCount - startFrame, ("verify less than 1000 frames with startFrame=%i and" " levels=%i") @@ -185,7 +185,7 @@ def test_stackTrace(self): startFrame = 1000 levels = 1 stackFrames = self.get_stackFrames(startFrame=startFrame, levels=levels) - self.assertEquals( + self.assertEqual( 0, len(stackFrames), "verify zero frames with startFrame out of bounds" ) @@ -203,4 +203,4 @@ def test_functionNameWithArgs(self): self.continue_to_next_stop() frame = self.get_stackFrames()[0] - self.assertEquals(frame["name"], "recurse(x=1)") + self.assertEqual(frame["name"], "recurse(x=1)") diff --git a/lldb/test/API/tools/lldb-dap/stackTraceMissingFunctionName/TestDAP_stackTraceMissingFunctionName.py b/lldb/test/API/tools/lldb-dap/stackTraceMissingFunctionName/TestDAP_stackTraceMissingFunctionName.py index 344629c1d5dad..0011c0f616e19 100644 --- a/lldb/test/API/tools/lldb-dap/stackTraceMissingFunctionName/TestDAP_stackTraceMissingFunctionName.py +++ b/lldb/test/API/tools/lldb-dap/stackTraceMissingFunctionName/TestDAP_stackTraceMissingFunctionName.py @@ -23,4 +23,4 @@ def test_missingFunctionName(self): self.continue_to_next_stop() frame_without_function_name = self.get_stackFrames()[0] - self.assertEquals(frame_without_function_name["name"], "0x0000000000000000") + self.assertEqual(frame_without_function_name["name"], "0x0000000000000000") diff --git a/lldb/test/API/tools/lldb-dap/terminated-event/TestDAP_terminatedEvent.py b/lldb/test/API/tools/lldb-dap/terminated-event/TestDAP_terminatedEvent.py index 78bc14c380f96..80a15dd4c9ab7 100644 --- a/lldb/test/API/tools/lldb-dap/terminated-event/TestDAP_terminatedEvent.py +++ b/lldb/test/API/tools/lldb-dap/terminated-event/TestDAP_terminatedEvent.py @@ -37,7 +37,7 @@ def test_terminated_event(self): # Set breakpoints functions = ["foo"] breakpoint_ids = self.set_function_breakpoints(functions) - self.assertEquals(len(breakpoint_ids), len(functions), "expect one breakpoint") + self.assertEqual(len(breakpoint_ids), len(functions), "expect one breakpoint") main_bp_line = line_number("main.cpp", "// main breakpoint 1") breakpoint_ids.append(self.set_source_breakpoints("main.cpp", [main_bp_line])) diff --git a/lldb/test/API/tools/lldb-dap/threads/TestDAP_threads.py b/lldb/test/API/tools/lldb-dap/threads/TestDAP_threads.py index 35d2d32eefdc5..f7f1ad7a3d507 100644 --- a/lldb/test/API/tools/lldb-dap/threads/TestDAP_threads.py +++ b/lldb/test/API/tools/lldb-dap/threads/TestDAP_threads.py @@ -65,5 +65,5 @@ def test_thread_format(self): self.continue_to_breakpoints(breakpoint_ids) # We are stopped at the second thread threads = self.dap_server.get_threads() - self.assertEquals(threads[0]["name"], "This is thread index #1") - self.assertEquals(threads[1]["name"], "This is thread index #2") + self.assertEqual(threads[0]["name"], "This is thread index #1") + self.assertEqual(threads[1]["name"], "This is thread index #2") diff --git a/lldb/test/API/tools/lldb-dap/variables/TestDAP_variables.py b/lldb/test/API/tools/lldb-dap/variables/TestDAP_variables.py index b6d9b865bb8b6..1f7dd7b2c42a8 100644 --- a/lldb/test/API/tools/lldb-dap/variables/TestDAP_variables.py +++ b/lldb/test/API/tools/lldb-dap/variables/TestDAP_variables.py @@ -120,7 +120,7 @@ def darwin_dwarf_missing_obj(self, initCommands): functions = ["main"] breakpoint_ids = self.set_function_breakpoints(functions) - self.assertEquals(len(breakpoint_ids), len(functions), "expect one breakpoint") + self.assertEqual(len(breakpoint_ids), len(functions), "expect one breakpoint") self.continue_to_breakpoints(breakpoint_ids) locals = self.dap_server.get_local_variables() @@ -607,9 +607,9 @@ def do_test_scopes_and_evaluate_expansion(self, enableAutoVariableSummaries: boo for scope in scopes: if scope["name"] == "Locals": - self.assertEquals(scope.get("presentationHint"), "locals") + self.assertEqual(scope.get("presentationHint"), "locals") if scope["name"] == "Registers": - self.assertEquals(scope.get("presentationHint"), "registers") + self.assertEqual(scope.get("presentationHint"), "registers") @skipIfWindows @skipIfRemote diff --git a/lldb/test/API/tools/lldb-server/TestAppleSimulatorOSType.py b/lldb/test/API/tools/lldb-server/TestAppleSimulatorOSType.py index a8c2f93aed0ae..ffac8de6f596a 100644 --- a/lldb/test/API/tools/lldb-server/TestAppleSimulatorOSType.py +++ b/lldb/test/API/tools/lldb-server/TestAppleSimulatorOSType.py @@ -135,7 +135,7 @@ def check_simulator_ostype(self, sdk, platform_name, arch=platform.machine()): self.assertIsNotNone(process_info) # Check that ostype is correct - self.assertEquals(process_info["ostype"], platform_name + "simulator") + self.assertEqual(process_info["ostype"], platform_name + "simulator") # Now for dylibs dylib_info_raw = context.get("dylib_info_raw") @@ -150,7 +150,7 @@ def check_simulator_ostype(self, sdk, platform_name, arch=platform.machine()): break self.assertIsNotNone(image_info) - self.assertEquals(image["min_version_os_name"], platform_name + "simulator") + self.assertEqual(image["min_version_os_name"], platform_name + "simulator") @apple_simulator_test("iphone") @skipIfRemote diff --git a/lldb/test/API/tools/lldb-server/TestGdbRemoteHostInfo.py b/lldb/test/API/tools/lldb-server/TestGdbRemoteHostInfo.py index 3e74eb854da8e..1b7c963550592 100644 --- a/lldb/test/API/tools/lldb-server/TestGdbRemoteHostInfo.py +++ b/lldb/test/API/tools/lldb-server/TestGdbRemoteHostInfo.py @@ -111,7 +111,7 @@ def validate_darwin_minimum_host_info_keys(self, host_info_dict): for key in self.DARWIN_REQUIRED_HOST_INFO_KEYS if key not in host_info_dict ] - self.assertEquals( + self.assertEqual( 0, len(missing_keys), "qHostInfo is missing the following required " "keys: " + str(missing_keys), diff --git a/lldb/test/API/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py b/lldb/test/API/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py index 0289d28b71ff9..17fc8c1a0f08c 100644 --- a/lldb/test/API/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py +++ b/lldb/test/API/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py @@ -58,7 +58,7 @@ def gather_stop_reply_pcs(self, thread_count): pcs_text = results["thread-pcs"] thread_ids = threads_text.split(",") pcs = pcs_text.split(",") - self.assertEquals(len(thread_ids), len(pcs)) + self.assertEqual(len(thread_ids), len(pcs)) thread_pcs = dict() for i in range(0, len(pcs)): diff --git a/lldb/test/API/tools/lldb-server/TestLldbGdbServer.py b/lldb/test/API/tools/lldb-server/TestLldbGdbServer.py index b6366d7fd170f..46ed59808eb66 100644 --- a/lldb/test/API/tools/lldb-server/TestLldbGdbServer.py +++ b/lldb/test/API/tools/lldb-server/TestLldbGdbServer.py @@ -560,12 +560,12 @@ def Hc_then_Csignal_signals_correct_thread(self, segfault_signo): # Ensure the stop signal is the signal we delivered. # stop_signo = context.get("stop_signo") # self.assertIsNotNone(stop_signo) - # self.assertEquals(int(stop_signo,16), lldbutil.get_signal_number('SIGUSR1')) + # self.assertEqual(int(stop_signo,16), lldbutil.get_signal_number('SIGUSR1')) # Ensure the stop thread is the thread to which we delivered the signal. # stop_thread_id = context.get("stop_thread_id") # self.assertIsNotNone(stop_thread_id) - # self.assertEquals(int(stop_thread_id,16), thread_id) + # self.assertEqual(int(stop_thread_id,16), thread_id) # Ensure we haven't seen this thread id yet. The inferior's # self-obtained thread ids are not guaranteed to match the stub