1 files changed, 0 insertions, 298 deletions

diff --git a/packages/Python/lldbsuite/test/lang/c/stepping/TestStepAndBreakpoints.py b/packages/Python/lldbsuite/test/lang/c/stepping/TestStepAndBreakpoints.py
deleted file mode 100644
index 4a4052cfa335..000000000000
--- a/packages/Python/lldbsuite/test/lang/c/stepping/TestStepAndBreakpoints.py
+++ /dev/null
@@ -1,298 +0,0 @@
-"""Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
-
-from __future__ import print_function
-
-
-import os
-import time
-import lldb
-from lldbsuite.test.decorators import *
-from lldbsuite.test.lldbtest import *
-from lldbsuite.test import lldbutil
-
-
-class TestCStepping(TestBase):
-
-    mydir = TestBase.compute_mydir(__file__)
-
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-        # Find the line numbers that we will step to in main:
-        self.main_source = "main.c"
-
-    @add_test_categories(['pyapi', 'basic_process'])
-    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr17932')
-    @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr14437")
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24777")
-    def test_and_python_api(self):
-        """Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
-        self.build()
-        exe = self.getBuildArtifact("a.out")
-
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
-
-        self.main_source_spec = lldb.SBFileSpec(self.main_source)
-
-        breakpoints_to_disable = []
-
-        break_1_in_main = target.BreakpointCreateBySourceRegex(
-            '// frame select 2, thread step-out while stopped at .c.1..',
-            self.main_source_spec)
-        self.assertTrue(break_1_in_main, VALID_BREAKPOINT)
-        breakpoints_to_disable.append(break_1_in_main)
-
-        break_in_a = target.BreakpointCreateBySourceRegex(
-            '// break here to stop in a before calling b', self.main_source_spec)
-        self.assertTrue(break_in_a, VALID_BREAKPOINT)
-        breakpoints_to_disable.append(break_in_a)
-
-        break_in_b = target.BreakpointCreateBySourceRegex(
-            '// thread step-out while stopped at .c.2..', self.main_source_spec)
-        self.assertTrue(break_in_b, VALID_BREAKPOINT)
-        breakpoints_to_disable.append(break_in_b)
-
-        break_in_c = target.BreakpointCreateBySourceRegex(
-            '// Find the line number of function .c. here.', self.main_source_spec)
-        self.assertTrue(break_in_c, VALID_BREAKPOINT)
-        breakpoints_to_disable.append(break_in_c)
-
-        # Now launch the process, and do not stop at entry point.
-        process = target.LaunchSimple(
-            None, None, self.get_process_working_directory())
-
-        self.assertTrue(process, PROCESS_IS_VALID)
-
-        # The stop reason of the thread should be breakpoint.
-        threads = lldbutil.get_threads_stopped_at_breakpoint(
-            process, break_1_in_main)
-
-        if len(threads) != 1:
-            self.fail("Failed to stop at first breakpoint in main.")
-
-        thread = threads[0]
-
-        # Get the stop id and for fun make sure it increases:
-        old_stop_id = process.GetStopID()
-
-        # Now step over, which should cause us to hit the breakpoint in "a"
-        thread.StepOver()
-
-        # The stop reason of the thread should be breakpoint.
-        threads = lldbutil.get_threads_stopped_at_breakpoint(
-            process, break_in_a)
-        if len(threads) != 1:
-            self.fail("Failed to stop at breakpoint in a.")
-
-        # Check that the stop ID increases:
-        new_stop_id = process.GetStopID()
-        self.assertTrue(
-            new_stop_id > old_stop_id,
-            "Stop ID increases monotonically.")
-
-        thread = threads[0]
-
-        # Step over, and we should hit the breakpoint in b:
-        thread.StepOver()
-
-        threads = lldbutil.get_threads_stopped_at_breakpoint(
-            process, break_in_b)
-        if len(threads) != 1:
-            self.fail("Failed to stop at breakpoint in b.")
-        thread = threads[0]
-
-        # Now try running some function, and make sure that we still end up in the same place
-        # and with the same stop reason.
-        frame = thread.GetFrameAtIndex(0)
-        current_line = frame.GetLineEntry().GetLine()
-        current_file = frame.GetLineEntry().GetFileSpec()
-        current_bp = []
-        current_bp.append(thread.GetStopReasonDataAtIndex(0))
-        current_bp.append(thread.GetStopReasonDataAtIndex(1))
-
-        stop_id_before_expression = process.GetStopID()
-        stop_id_before_including_expressions = process.GetStopID(True)
-
-        frame.EvaluateExpression("(int) printf (print_string)")
-
-        frame = thread.GetFrameAtIndex(0)
-        self.assertTrue(
-            current_line == frame.GetLineEntry().GetLine(),
-            "The line stayed the same after expression.")
-        self.assertTrue(
-            current_file == frame.GetLineEntry().GetFileSpec(),
-            "The file stayed the same after expression.")
-        self.assertTrue(
-            thread.GetStopReason() == lldb.eStopReasonBreakpoint,
-            "We still say we stopped for a breakpoint.")
-        self.assertTrue(thread.GetStopReasonDataAtIndex(0) == current_bp[
-                        0] and thread.GetStopReasonDataAtIndex(1) == current_bp[1], "And it is the same breakpoint.")
-
-        # Also make sure running the expression didn't change the public stop id
-        # but did change if we are asking for expression stops as well.
-        stop_id_after_expression = process.GetStopID()
-        stop_id_after_including_expressions = process.GetStopID(True)
-
-        self.assertTrue(
-            stop_id_before_expression == stop_id_after_expression,
-            "Expression calling doesn't change stop ID")
-
-        self.assertTrue(
-            stop_id_after_including_expressions > stop_id_before_including_expressions,
-            "Stop ID including expressions increments over expression call.")
-
-        # Do the same thing with an expression that's going to crash, and make
-        # sure we are still unchanged.
-
-        frame.EvaluateExpression("((char *) 0)[0] = 'a'")
-
-        frame = thread.GetFrameAtIndex(0)
-        self.assertTrue(
-            current_line == frame.GetLineEntry().GetLine(),
-            "The line stayed the same after expression.")
-        self.assertTrue(
-            current_file == frame.GetLineEntry().GetFileSpec(),
-            "The file stayed the same after expression.")
-        self.assertTrue(
-            thread.GetStopReason() == lldb.eStopReasonBreakpoint,
-            "We still say we stopped for a breakpoint.")
-        self.assertTrue(thread.GetStopReasonDataAtIndex(0) == current_bp[
-                        0] and thread.GetStopReasonDataAtIndex(1) == current_bp[1], "And it is the same breakpoint.")
-
-        # Now continue and make sure we just complete the step:
-        # Disable all our breakpoints first - sometimes the compiler puts two line table entries in for the
-        # breakpoint a "b" and we don't want to hit that.
-        for bkpt in breakpoints_to_disable:
-            bkpt.SetEnabled(False)
-
-        process.Continue()
-
-        self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "a")
-        self.assertTrue(thread.GetStopReason() == lldb.eStopReasonPlanComplete)
-
-        # And one more time should get us back to main:
-        process.Continue()
-
-        self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "main")
-        self.assertTrue(thread.GetStopReason() == lldb.eStopReasonPlanComplete)
-
-        # Now make sure we can call a function, break in the called function,
-        # then have "continue" get us back out again:
-        frame = thread.GetFrameAtIndex(0)
-        frame = thread.GetFrameAtIndex(0)
-        current_line = frame.GetLineEntry().GetLine()
-        current_file = frame.GetLineEntry().GetFileSpec()
-
-        break_in_b.SetEnabled(True)
-        options = lldb.SBExpressionOptions()
-        options.SetIgnoreBreakpoints(False)
-        options.SetFetchDynamicValue(False)
-        options.SetUnwindOnError(False)
-        frame.EvaluateExpression("b (4)", options)
-
-        threads = lldbutil.get_threads_stopped_at_breakpoint(
-            process, break_in_b)
-
-        if len(threads) != 1:
-            self.fail("Failed to stop at breakpoint in b when calling b.")
-        thread = threads[0]
-
-        # So do a step over here to make sure we can still do that:
-
-        thread.StepOver()
-
-        # See that we are still in b:
-        func_name = thread.GetFrameAtIndex(0).GetFunctionName()
-        self.assertTrue(
-            func_name == "b",
-            "Should be in 'b', were in %s" %
-            (func_name))
-
-        # Okay, now if we continue, we will finish off our function call and we
-        # should end up back in "a" as if nothing had happened:
-        process.Continue()
-
-        self.assertTrue(thread.GetFrameAtIndex(
-            0).GetLineEntry().GetLine() == current_line)
-        self.assertTrue(thread.GetFrameAtIndex(
-            0).GetLineEntry().GetFileSpec() == current_file)
-
-        # Now we are going to test step in targeting a function:
-
-        break_in_b.SetEnabled(False)
-
-        break_before_complex_1 = target.BreakpointCreateBySourceRegex(
-            '// Stop here to try step in targeting b.', self.main_source_spec)
-        self.assertTrue(break_before_complex_1, VALID_BREAKPOINT)
-
-        break_before_complex_2 = target.BreakpointCreateBySourceRegex(
-            '// Stop here to try step in targeting complex.', self.main_source_spec)
-        self.assertTrue(break_before_complex_2, VALID_BREAKPOINT)
-
-        break_before_complex_3 = target.BreakpointCreateBySourceRegex(
-            '// Stop here to step targeting b and hitting breakpoint.', self.main_source_spec)
-        self.assertTrue(break_before_complex_3, VALID_BREAKPOINT)
-
-        break_before_complex_4 = target.BreakpointCreateBySourceRegex(
-            '// Stop here to make sure bogus target steps over.', self.main_source_spec)
-        self.assertTrue(break_before_complex_4, VALID_BREAKPOINT)
-
-        threads = lldbutil.continue_to_breakpoint(
-            process, break_before_complex_1)
-        self.assertTrue(len(threads) == 1)
-        thread = threads[0]
-        break_before_complex_1.SetEnabled(False)
-
-        thread.StepInto("b")
-        self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "b")
-
-        # Now continue out and stop at the next call to complex.  This time
-        # step all the way into complex:
-        threads = lldbutil.continue_to_breakpoint(
-            process, break_before_complex_2)
-        self.assertTrue(len(threads) == 1)
-        thread = threads[0]
-        break_before_complex_2.SetEnabled(False)
-
-        thread.StepInto("complex")
-        self.assertTrue(thread.GetFrameAtIndex(
-            0).GetFunctionName() == "complex")
-
-        # Now continue out and stop at the next call to complex.  This time
-        # enable breakpoints in a and c and then step targeting b:
-        threads = lldbutil.continue_to_breakpoint(
-            process, break_before_complex_3)
-        self.assertTrue(len(threads) == 1)
-        thread = threads[0]
-        break_before_complex_3.SetEnabled(False)
-
-        break_at_start_of_a = target.BreakpointCreateByName('a')
-        break_at_start_of_c = target.BreakpointCreateByName('c')
-
-        thread.StepInto("b")
-        threads = lldbutil.get_stopped_threads(
-            process, lldb.eStopReasonBreakpoint)
-
-        self.assertTrue(len(threads) == 1)
-        thread = threads[0]
-        stop_break_id = thread.GetStopReasonDataAtIndex(0)
-        self.assertTrue(stop_break_id == break_at_start_of_a.GetID()
-                        or stop_break_id == break_at_start_of_c.GetID())
-
-        break_at_start_of_a.SetEnabled(False)
-        break_at_start_of_c.SetEnabled(False)
-
-        process.Continue()
-        self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "b")
-
-        # Now continue out and stop at the next call to complex.  This time
-        # enable breakpoints in a and c and then step targeting b:
-        threads = lldbutil.continue_to_breakpoint(
-            process, break_before_complex_4)
-        self.assertTrue(len(threads) == 1)
-        thread = threads[0]
-        break_before_complex_4.SetEnabled(False)
-
-        thread.StepInto("NoSuchFunction")
-        self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "main")