# TestSwiftStepping.py # # This source file is part of the Swift.org open source project # # Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors # Licensed under Apache License v2.0 with Runtime Library Exception # # See https://swift.org/LICENSE.txt for license information # See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors # # ------------------------------------------------------------------------------ """ Tests simple swift stepping """ import lldb from lldbsuite.test.decorators import * import lldbsuite.test.lldbtest as lldbtest import lldbsuite.test.lldbutil as lldbutil import os import platform import unittest2 class TestSwiftStepping(lldbtest.TestBase): mydir = lldbtest.TestBase.compute_mydir(__file__) @swiftTest @skipIfLinux def test_swift_stepping(self): """Tests that we can step reliably in swift code.""" self.build() self.do_test() def setUp(self): lldbtest.TestBase.setUp(self) self.main_source = "main.swift" self.main_source_spec = lldb.SBFileSpec(self.main_source) # If you are running against a debug swift you are going to # end up stepping into the stdlib and that will make stepping # tests impossible to write. So avoid that. if platform.system() == 'Darwin': lib_name = "libswiftCore.dylib" else: lib_name = "libswiftCore.so" self.dbg.HandleCommand( "settings set " "target.process.thread.step-avoid-libraries {}".format(lib_name)) def correct_stop_reason(self, thread): # We are always just stepping, so that should be the thread stop reason: stop_reason = thread.GetStopReason() self.assertEqual(stop_reason, lldb.eStopReasonPlanComplete) def hit_correct_line(self, thread, pattern, fail_if_wrong=True): # print "Check if we got to: ", pattern self.correct_stop_reason(thread) target_line = lldbtest.line_number(self.main_source, pattern) self.assertTrue( target_line != 0, "Could not find source pattern " + pattern) cur_line = thread.frames[0].GetLineEntry().GetLine() hit_line = cur_line == target_line if fail_if_wrong: self.assertTrue( hit_line, "Stepped to line %d instead of expected %d " "with pattern '%s'." % (cur_line, target_line, pattern)) return hit_line def hit_correct_function(self, thread, pattern): # print "Check if we got to: ", pattern self.correct_stop_reason(thread) name = thread.frames[0].GetFunctionName() line_entry = thread.frames[0].GetLineEntry() desc = lldb.SBStream() if line_entry.IsValid(): line_entry.GetDescription(desc) else: desc.Print(name) self.assertTrue( pattern in name, "Got to '%s' not the expected function '%s'." % (desc.GetData(), pattern)) def do_test(self): """Tests that we can step reliably in swift code.""" exe_name = "a.out" exe = self.getBuildArtifact(exe_name) # Create the target target = self.dbg.CreateTarget(exe) self.assertTrue(target, lldbtest.VALID_TARGET) # Set the breakpoints breakpoint = target.BreakpointCreateBySourceRegex( 'Stop here first in main', self.main_source_spec) self.assertTrue( breakpoint.GetNumLocations() > 0, lldbtest.VALID_BREAKPOINT) # Launch the process, and do not stop at the entry point. process = target.LaunchSimple(None, None, os.getcwd()) self.assertTrue(process, lldbtest.PROCESS_IS_VALID) # Frame #0 should be at our breakpoint. threads = lldbutil.get_threads_stopped_at_breakpoint( process, breakpoint) self.assertTrue(len(threads) == 1) thread = threads[0] frame = thread.frames[0] self.assertTrue(frame, "Frame 0 is valid.") # We are before using an int to set an enum value (which has a # toSomeValues function). So step into should go into the # toSomeValues function. thread.StepInto() self.hit_correct_function(thread, "toSomeValues") thread.StepOut() self.hit_correct_function(thread, "main") thread.StepOver() thread.StepOver() # That should take me to the equals operator. self.hit_correct_line(thread, "Stop here to get into equality") thread.StepInto() self.hit_correct_function(thread, "==") thread.StepOut() thread.StepOver() self.hit_correct_line(thread, "Step over the if should get here") thread.StepOver() self.hit_correct_line(thread, "Step over the print should get here.") thread.StepOver() self.hit_correct_line(thread, "Stop here to step into B constructor.") thread.StepInto() prologue_at_first_line = self.hit_correct_line( thread, "At the first line of B constructor.", False) if prologue_at_first_line: thread.StepOver() self.hit_correct_line( thread, "In the B constructor about to call super.") # Make sure we can follow super into the parent constructor. thread.StepInto() prologue_at_first_line = self.hit_correct_line( thread, "Here is the A constructor.", False) if prologue_at_first_line: thread.StepOver() self.hit_correct_line(thread, "A init: x assignment.") thread.StepOver() self.hit_correct_line(thread, "A init: y assignment.") thread.StepOver() self.hit_correct_line(thread, "A init: end of function.") # Now two step outs should take us back where we started from: thread.StepOut() thread.StepOut() name = thread.frames[0].GetFunctionName() if "allocating_init" in name: thread.StepOut() self.hit_correct_line(thread, "Stop here to step into B constructor.") thread.StepOver() self.hit_correct_line( thread, "Stop here to step into call_overridden.") # Make sure we get into the overridden call as expected: thread.StepInto() self.hit_correct_function(thread, "call_overridden") stopped_at_func_defn = self.hit_correct_line( thread, "call_overridden func def", False) if stopped_at_func_defn: thread.StepOver() thread.StepInto() self.hit_correct_function(thread, "ClassB.do_something") # Now step out twice to get back to main: thread.StepOut() self.hit_correct_function(thread, "call_overridden") thread.StepOut() self.hit_correct_line( thread, "Stop here to step into call_overridden.") # Two steps should get us to the switch: thread.StepOver() self.hit_correct_line(thread, "At point initializer.") thread.StepOver() stopped_at_switch = self.hit_correct_line (thread, "At the beginning of the switch.", False) if stopped_at_switch: thread.StepOver() stopped_at_case = self.hit_correct_line( thread, "case (let x, let y) where", False) if stopped_at_case: thread.StepOver() self.hit_correct_line(thread, "First case with a where statement.") thread.StepOver() self.hit_correct_line(thread, "Second case with a where statement") thread.StepInto() self.hit_correct_line( thread, "return_same gets called in both where statements") thread.StepOut() self.hit_correct_line(thread, "Second case with a where statement") thread.StepOver() thread.StepOver() self.hit_correct_line( thread, "print in second case with where statement.") # # For some reason, we don't step from the body of the case to # the end of the switch, but back to the case: statement, and # then directly out of the switch. # thread.StepOver() steps_back_to_case = self.hit_correct_line( thread, "Sometimes the line table steps to here " "after the body of the case.", False) if steps_back_to_case: self.fail( "Stepping past a taken body of a case statement should not " "step back to the case statement.") if self.hit_correct_line( thread, "This is the end of the switch statement", False): thread.StepOver() elif not self.hit_correct_line( thread, "Make a version of P that conforms directly", False): self.fail( "Stepping past the body of the case didn't stop " "where expected.") self.hit_correct_line( thread, "Make a version of P that conforms directly") # FIXME: Stepping into constructors is kind of a mess, # I'm going to just step over for these tests. thread.StepOver() self.hit_correct_line(thread, "direct.protocol_func(10)") # This tests stepping in through the protocol thunk: thread.StepInto() stop_at_prologue = self.hit_correct_line( thread, "We stopped at the protocol_func declaration instead.", False) if stop_at_prologue: thread.StepOver() self.hit_correct_line( thread, "This is where we will stop in the protocol dispatch") # Step out of the protocol functions, one step should get us # past any dispatch thunk. thread.StepOut() # Finish may not get us past the line we were on, since it # stops immediately on returning # to the caller frame. If so we will need to step again: stop_in_caller_line = self.hit_correct_line( thread, "direct.protocol_func(10)", False) if stop_in_caller_line: thread.StepOver() self.hit_correct_line( thread, "Make a version of P that conforms through a subclass") # This steps into another protocol dispatch. thread.StepOver() thread.StepInto() stop_at_prologue = self.hit_correct_line( thread, "We stopped at the protocol_func declaration instead.", False) if stop_at_prologue: thread.StepOver() self.hit_correct_line( thread, "This is where we will stop in the protocol dispatch") # Step out of the protocol function, one step out should also # get us past any dispatch thunk. thread.StepOut() stop_on_caller = self.hit_correct_line(thread, "indirect.protocol_func(20)", False) stop_at_cd_maker = self.hit_correct_line(thread, "var cd_maker", False) # In swift-4.0 U before, one step over is necessary because step out doesn't # finish off the line. # In swift-4.1 we now step over the line but we also stop on the "var cd_maker" # line, which we didn't with swift-4.0. So we check for either of these. if stop_on_caller or stop_at_cd_maker: thread.StepOver() # Step over the assignment. stop_on_partial_apply = self.hit_correct_line(thread, "var cd_maker =", False) if stop_on_partial_apply: thread.StepOver() stop_at_brace = self.hit_correct_line(thread, "Opening brace", False) if stop_at_brace: thread.StepOver() self.hit_correct_line(thread, "doSomethingWithFunction(cd_maker, 10)") thread.StepInto() stop_in_prologue = self.hit_correct_line( thread, "Stopped in doSomethingWithFunctionResult decl.", False) if stop_in_prologue: thread.StepOver() self.hit_correct_line( thread, "Calling doSomethingWithFunction with value") thread.StepOver() self.hit_correct_line(thread, "let result = f(other_value)") # Now try stepping into calling a closure, there's several # layers of goo to get through: thread.StepInto() stop_in_prologue = self.hit_correct_line( thread, "Step into cd_maker stops at closure decl instead.", False) if stop_in_prologue: thread.StepOver() self.hit_correct_line(thread, "Step into should stop here in closure.") # Then make sure we can get back out: thread.StepOut() # Again, step out may not have completed the source line we # stepped in FROM... stop_in_caller_line = self.hit_correct_line( thread, "let result = f(other_value)", False) if stop_in_caller_line: thread.StepOver() self.hit_correct_line( thread, "result.protocol_func(other_value)") def tearDown(self): self.dbg.HandleCommand( "settings clear target.process.thread.step-avoid-libraries") super(TestSwiftStepping, self).tearDown()