def test_CreateTarget_platform(self): exe = self.getBuildArtifact("a.out") self.yaml2obj("elf.yaml", exe) error = lldb.SBError() target1 = self.dbg.CreateTarget(exe, None, "remote-linux", False, error) self.assertSuccess(error) platform1 = target1.GetPlatform() platform1.SetWorkingDirectory("/foo/bar") # Reuse a platform if it matches the currently selected one... target2 = self.dbg.CreateTarget(exe, None, "remote-linux", False, error) self.assertSuccess(error) platform2 = target2.GetPlatform() self.assertTrue(platform2.GetWorkingDirectory().endswith("bar"), platform2.GetWorkingDirectory()) # ... but create a new one if it doesn't. self.dbg.SetSelectedPlatform(lldb.SBPlatform("remote-windows")) target3 = self.dbg.CreateTarget(exe, None, "remote-linux", False, error) self.assertSuccess(error) platform3 = target3.GetPlatform() self.assertIsNone(platform3.GetWorkingDirectory())
def test_CreateTarget_arch(self): exe = self.getBuildArtifact("a.out") if lldbplatformutil.getHostPlatform() == 'linux': self.yaml2obj("macho.yaml", exe) arch = "x86_64-apple-macosx" expected_platform = "remote-macosx" else: self.yaml2obj("elf.yaml", exe) arch = "x86_64-pc-linux" expected_platform = "remote-linux" fbsd = lldb.SBPlatform("remote-freebsd") self.dbg.SetSelectedPlatform(fbsd) error = lldb.SBError() target1 = self.dbg.CreateTarget(exe, arch, None, False, error) self.assertSuccess(error) platform1 = target1.GetPlatform() self.assertEqual(platform1.GetName(), expected_platform) platform1.SetWorkingDirectory("/foo/bar") # Reuse a platform even if it is not currently selected. self.dbg.SetSelectedPlatform(fbsd) target2 = self.dbg.CreateTarget(exe, arch, None, False, error) self.assertSuccess(error) platform2 = target2.GetPlatform() self.assertEqual(platform2.GetName(), expected_platform) self.assertTrue(platform2.GetWorkingDirectory().endswith("bar"), platform2.GetWorkingDirectory())
def test_timeout(self): """Test that we honor the timeout setting. With a small timeout, CWD retrieval should fail.""" self.server.responder = TestPlatformClient.TimeoutResponder() self.runCmd("settings set plugin.process.gdb-remote.packet-timeout 3") plat = lldb.SBPlatform("remote-linux") try: self.assertSuccess(plat.ConnectRemote(lldb.SBPlatformConnectOptions( self.server.get_connect_url()))) self.assertIsNone(plat.GetWorkingDirectory()) finally: plat.DisconnectRemote()
def test_no_timeout(self): """Test that we honor the timeout setting. With a large enough timeout, we should get the CWD successfully.""" self.server.responder = TestPlatformClient.TimeoutResponder() self.runCmd("settings set plugin.process.gdb-remote.packet-timeout 30") plat = lldb.SBPlatform("remote-linux") try: self.assertSuccess(plat.ConnectRemote(lldb.SBPlatformConnectOptions( self.server.get_connect_url()))) self.assertEqual(plat.GetWorkingDirectory(), "/foo/bar") finally: plat.DisconnectRemote()
def test_file_api(self): qemu = lldb.SBPlatform("qemu-user") host = lldb.SBPlatform.GetHostPlatform() target = self.getBuildArtifact("target.c") main_c = lldb.SBFileSpec(self.getSourcePath("main.c")) self.assertSuccess(qemu.Put(main_c, lldb.SBFileSpec(target))) self.assertTrue(os.path.exists(target)) self.assertEqual(qemu.GetFilePermissions(target), host.GetFilePermissions(target)) self.assertSuccess( qemu.MakeDirectory(self.getBuildArtifact("target_dir"))) self.assertTrue(os.path.isdir(self.getBuildArtifact("target_dir")))
def test_kill_different_platform(self): """Test connecting to a remote linux platform""" self.build(dictionary={"CXX_SOURCES": "sleep.cpp"}) host_process = self.spawnSubprocess(self.getBuildArtifact()) # Create a fake remote process with the same PID as host_process class MyResponder(MockGDBServerResponder): def __init__(self): MockGDBServerResponder.__init__(self) self.got_kill = False def qC(self): return "QC%x" % host_process.pid def k(self): self.got_kill = True return "X09" self.server.responder = MyResponder() error = lldb.SBError() target = self.dbg.CreateTarget("", "x86_64-pc-linux", "remote-linux", False, error) self.assertSuccess(error) process = self.connect(target) self.assertEqual(process.GetProcessID(), host_process.pid) host_platform = lldb.SBPlatform("host") self.assertSuccess(host_platform.Kill(host_process.pid)) # Host dies, remote process lives. self.assertFalse(self.server.responder.got_kill) self.assertIsNotNone(host_process.wait(timeout=10)) # Now kill the remote one as well self.assertSuccess(process.Kill()) self.assertTrue(self.server.responder.got_kill)
def run_suite(): # On MacOS X, check to make sure that domain for com.apple.DebugSymbols defaults # does not exist before proceeding to running the test suite. if sys.platform.startswith("darwin"): checkDsymForUUIDIsNotOn() # Start the actions by first parsing the options while setting up the test # directories, followed by setting up the search paths for lldb utilities; # then, we walk the directory trees and collect the tests into our test suite. # parseOptionsAndInitTestdirs() setupSysPath() import lldbconfig if configuration.capture_path or configuration.replay_path: lldbconfig.INITIALIZE = False import lldb if configuration.capture_path: lldb.SBReproducer.Capture(configuration.capture_path) lldb.SBReproducer.SetAutoGenerate(True) elif configuration.replay_path: lldb.SBReproducer.PassiveReplay(configuration.replay_path) if not lldbconfig.INITIALIZE: lldb.SBDebugger.Initialize() # Use host platform by default. lldb.selected_platform = lldb.SBPlatform.GetHostPlatform() # Now we can also import lldbutil from lldbsuite.test import lldbutil if configuration.lldb_platform_name: print("Setting up remote platform '%s'" % (configuration.lldb_platform_name)) lldb.remote_platform = lldb.SBPlatform( configuration.lldb_platform_name) if not lldb.remote_platform.IsValid(): print( "error: unable to create the LLDB platform named '%s'." % (configuration.lldb_platform_name)) exitTestSuite(1) if configuration.lldb_platform_url: # We must connect to a remote platform if a LLDB platform URL was # specified print( "Connecting to remote platform '%s' at '%s'..." % (configuration.lldb_platform_name, configuration.lldb_platform_url)) platform_connect_options = lldb.SBPlatformConnectOptions( configuration.lldb_platform_url) err = lldb.remote_platform.ConnectRemote(platform_connect_options) if err.Success(): print("Connected.") else: print("error: failed to connect to remote platform using URL '%s': %s" % ( configuration.lldb_platform_url, err)) exitTestSuite(1) else: configuration.lldb_platform_url = None if configuration.lldb_platform_working_dir: print("Setting remote platform working directory to '%s'..." % (configuration.lldb_platform_working_dir)) error = lldb.remote_platform.MakeDirectory( configuration.lldb_platform_working_dir, 448) # 448 = 0o700 if error.Fail(): raise Exception("making remote directory '%s': %s" % ( configuration.lldb_platform_working_dir, error)) if not lldb.remote_platform.SetWorkingDirectory( configuration.lldb_platform_working_dir): raise Exception("failed to set working directory '%s'" % configuration.lldb_platform_working_dir) lldb.selected_platform = lldb.remote_platform else: lldb.remote_platform = None configuration.lldb_platform_working_dir = None configuration.lldb_platform_url = None # Set up the working directory. # Note that it's not dotest's job to clean this directory. lldbutil.mkdir_p(configuration.test_build_dir) target_platform = lldb.selected_platform.GetTriple().split('-')[2] checkLibcxxSupport() checkLibstdcxxSupport() checkWatchpointSupport() checkDebugInfoSupport() # Don't do debugserver tests on anything except OS X. configuration.dont_do_debugserver_test = ( "linux" in target_platform or "freebsd" in target_platform or "netbsd" in target_platform or "windows" in target_platform) # Don't do lldb-server (llgs) tests on anything except Linux and Windows. configuration.dont_do_llgs_test = not ( "linux" in target_platform or "netbsd" in target_platform or "windows" in target_platform) for testdir in configuration.testdirs: for (dirpath, dirnames, filenames) in os.walk(testdir): visit('Test', dirpath, filenames) # # Now that we have loaded all the test cases, run the whole test suite. # # Install the control-c handler. unittest2.signals.installHandler() lldbutil.mkdir_p(configuration.sdir_name) os.environ["LLDB_SESSION_DIRNAME"] = configuration.sdir_name sys.stderr.write( "\nSession logs for test failures/errors/unexpected successes" " will go into directory '%s'\n" % configuration.sdir_name) # # Invoke the default TextTestRunner to run the test suite # checkCompiler() if configuration.verbose: print("compiler=%s" % configuration.compiler) # Iterating over all possible architecture and compiler combinations. os.environ["ARCH"] = configuration.arch os.environ["CC"] = configuration.compiler if configuration.swiftCompiler: os.environ["SWIFTC"] = configuration.swiftCompiler configString = "arch=%s compiler=%s" % (configuration.arch, configuration.compiler) # Output the configuration. if configuration.verbose: sys.stderr.write("\nConfiguration: " + configString + "\n") # First, write out the number of collected test cases. if configuration.verbose: sys.stderr.write(configuration.separator + "\n") sys.stderr.write( "Collected %d test%s\n\n" % (configuration.suite.countTestCases(), configuration.suite.countTestCases() != 1 and "s" or "")) # Invoke the test runner. if configuration.count == 1: result = unittest2.TextTestRunner( stream=sys.stderr, verbosity=configuration.verbose, resultclass=test_result.LLDBTestResult).run( configuration.suite) else: # We are invoking the same test suite more than once. In this case, # mark __ignore_singleton__ flag as True so the signleton pattern is # not enforced. test_result.LLDBTestResult.__ignore_singleton__ = True for i in range(configuration.count): result = unittest2.TextTestRunner( stream=sys.stderr, verbosity=configuration.verbose, resultclass=test_result.LLDBTestResult).run( configuration.suite) configuration.failed = not result.wasSuccessful() if configuration.sdir_has_content and configuration.verbose: sys.stderr.write( "Session logs for test failures/errors/unexpected successes" " can be found in directory '%s'\n" % configuration.sdir_name) if configuration.use_categories and len( configuration.failures_per_category) > 0: sys.stderr.write("Failures per category:\n") for category in configuration.failures_per_category: sys.stderr.write( "%s - %d\n" % (category, configuration.failures_per_category[category])) # Exiting. exitTestSuite(configuration.failed)
def run_suite(): # On MacOS X, check to make sure that domain for com.apple.DebugSymbols defaults # does not exist before proceeding to running the test suite. if sys.platform.startswith("darwin"): checkDsymForUUIDIsNotOn() # Start the actions by first parsing the options while setting up the test # directories, followed by setting up the search paths for lldb utilities; # then, we walk the directory trees and collect the tests into our test suite. # parseOptionsAndInitTestdirs() # Print a stack trace if the test hangs or is passed SIGTERM. registerFaulthandler() setupSysPath() import lldb lldb.SBDebugger.Initialize() # Use host platform by default. lldb.selected_platform = lldb.SBPlatform.GetHostPlatform() # Now we can also import lldbutil from lldbsuite.test import lldbutil if configuration.lldb_platform_name: print("Setting up remote platform '%s'" % (configuration.lldb_platform_name)) lldb.remote_platform = lldb.SBPlatform( configuration.lldb_platform_name) if not lldb.remote_platform.IsValid(): print("error: unable to create the LLDB platform named '%s'." % (configuration.lldb_platform_name)) exitTestSuite(1) if configuration.lldb_platform_url: # We must connect to a remote platform if a LLDB platform URL was # specified print("Connecting to remote platform '%s' at '%s'..." % (configuration.lldb_platform_name, configuration.lldb_platform_url)) platform_connect_options = lldb.SBPlatformConnectOptions( configuration.lldb_platform_url) err = lldb.remote_platform.ConnectRemote(platform_connect_options) if err.Success(): print("Connected.") lldb.selected_platform = lldb.remote_platform else: print( "error: failed to connect to remote platform using URL '%s': %s" % (configuration.lldb_platform_url, err)) exitTestSuite(1) else: configuration.lldb_platform_url = None if configuration.lldb_platform_working_dir: print("Setting remote platform working directory to '%s'..." % (configuration.lldb_platform_working_dir)) error = lldb.remote_platform.MakeDirectory( configuration.lldb_platform_working_dir, 448) # 448 = 0o700 if error.Fail(): raise Exception("making remote directory '%s': %s" % (configuration.lldb_platform_working_dir, error)) if not lldb.remote_platform.SetWorkingDirectory( configuration.lldb_platform_working_dir): raise Exception("failed to set working directory '%s'" % configuration.lldb_platform_working_dir) lldb.selected_platform = lldb.remote_platform else: lldb.remote_platform = None configuration.lldb_platform_working_dir = None configuration.lldb_platform_url = None # Set up the working directory. # Note that it's not dotest's job to clean this directory. lldbutil.mkdir_p(configuration.test_build_dir) checkLibcxxSupport() checkLibstdcxxSupport() checkWatchpointSupport() checkDebugInfoSupport() checkDebugServerSupport() checkObjcSupport() checkForkVForkSupport() print("Skipping the following test categories: {}".format( configuration.skip_categories)) for testdir in configuration.testdirs: for (dirpath, dirnames, filenames) in os.walk(testdir): visit('Test', dirpath, filenames) # # Now that we have loaded all the test cases, run the whole test suite. # # Install the control-c handler. unittest2.signals.installHandler() # # Invoke the default TextTestRunner to run the test suite # checkCompiler() if configuration.verbose: print("compiler=%s" % configuration.compiler) # Iterating over all possible architecture and compiler combinations. configString = "arch=%s compiler=%s" % (configuration.arch, configuration.compiler) # Output the configuration. if configuration.verbose: sys.stderr.write("\nConfiguration: " + configString + "\n") # First, write out the number of collected test cases. if configuration.verbose: sys.stderr.write(configuration.separator + "\n") sys.stderr.write( "Collected %d test%s\n\n" % (configuration.suite.countTestCases(), configuration.suite.countTestCases() != 1 and "s" or "")) if configuration.suite.countTestCases() == 0: logging.error("did not discover any matching tests") exitTestSuite(1) # Invoke the test runner. if configuration.count == 1: result = unittest2.TextTestRunner( stream=sys.stderr, verbosity=configuration.verbose, resultclass=test_result.LLDBTestResult).run(configuration.suite) else: # We are invoking the same test suite more than once. In this case, # mark __ignore_singleton__ flag as True so the signleton pattern is # not enforced. test_result.LLDBTestResult.__ignore_singleton__ = True for i in range(configuration.count): result = unittest2.TextTestRunner( stream=sys.stderr, verbosity=configuration.verbose, resultclass=test_result.LLDBTestResult).run( configuration.suite) configuration.failed = not result.wasSuccessful() if configuration.sdir_has_content and configuration.verbose: sys.stderr.write( "Session logs for test failures/errors/unexpected successes" " can be found in the test build directory\n") if configuration.use_categories and len( configuration.failures_per_category) > 0: sys.stderr.write("Failures per category:\n") for category in configuration.failures_per_category: sys.stderr.write( "%s - %d\n" % (category, configuration.failures_per_category[category])) # Exiting. exitTestSuite(configuration.failed)
def run_suite(): # On MacOS X, check to make sure that domain for com.apple.DebugSymbols defaults # does not exist before proceeding to running the test suite. if sys.platform.startswith("darwin"): checkDsymForUUIDIsNotOn() # Start the actions by first parsing the options while setting up the test # directories, followed by setting up the search paths for lldb utilities; # then, we walk the directory trees and collect the tests into our test suite. # parseOptionsAndInitTestdirs() # Setup test results (test results formatter and output handling). setupTestResults() setupSysPath() # For the time being, let's bracket the test runner within the # lldb.SBDebugger.Initialize()/Terminate() pair. import lldb # Now we can also import lldbutil from lldbsuite.test import lldbutil # Create a singleton SBDebugger in the lldb namespace. lldb.DBG = lldb.SBDebugger.Create() if configuration.lldb_platform_name: print("Setting up remote platform '%s'" % (configuration.lldb_platform_name)) lldb.remote_platform = lldb.SBPlatform( configuration.lldb_platform_name) if not lldb.remote_platform.IsValid(): print( "error: unable to create the LLDB platform named '%s'." % (configuration.lldb_platform_name)) exitTestSuite(1) if configuration.lldb_platform_url: # We must connect to a remote platform if a LLDB platform URL was # specified print( "Connecting to remote platform '%s' at '%s'..." % (configuration.lldb_platform_name, configuration.lldb_platform_url)) platform_connect_options = lldb.SBPlatformConnectOptions( configuration.lldb_platform_url) err = lldb.remote_platform.ConnectRemote(platform_connect_options) if err.Success(): print("Connected.") else: print("error: failed to connect to remote platform using URL '%s': %s" % ( configuration.lldb_platform_url, err)) exitTestSuite(1) else: configuration.lldb_platform_url = None platform_changes = setDefaultTripleForPlatform() first = True for key in platform_changes: if first: print("Environment variables setup for platform support:") first = False print("%s = %s" % (key, platform_changes[key])) if configuration.lldb_platform_working_dir: print("Setting remote platform working directory to '%s'..." % (configuration.lldb_platform_working_dir)) error = lldb.remote_platform.MakeDirectory( configuration.lldb_platform_working_dir, 448) # 448 = 0o700 if error.Fail(): raise Exception("making remote directory '%s': %s" % ( configuration.lldb_platform_working_dir, error)) if not lldb.remote_platform.SetWorkingDirectory( configuration.lldb_platform_working_dir): raise Exception("failed to set working directory '%s'" % configuration.lldb_platform_working_dir) lldb.DBG.SetSelectedPlatform(lldb.remote_platform) else: lldb.remote_platform = None configuration.lldb_platform_working_dir = None configuration.lldb_platform_url = None # Set up the working directory. # Note that it's not dotest's job to clean this directory. build_dir = configuration.test_build_dir lldbutil.mkdir_p(build_dir) target_platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2] checkLibcxxSupport() checkLibstdcxxSupport() checkWatchpointSupport() checkDebugInfoSupport() # Don't do debugserver tests on anything except OS X. configuration.dont_do_debugserver_test = ( "linux" in target_platform or "freebsd" in target_platform or "netbsd" in target_platform or "windows" in target_platform) # Don't do lldb-server (llgs) tests on anything except Linux and Windows. configuration.dont_do_llgs_test = not ( "linux" in target_platform or "netbsd" in target_platform or "windows" in target_platform) # Collect tests from the specified testing directories. If a test # subdirectory filter is explicitly specified, limit the search to that # subdirectory. exclusive_test_subdir = configuration.get_absolute_path_to_exclusive_test_subdir() if exclusive_test_subdir: dirs_to_search = [exclusive_test_subdir] else: dirs_to_search = configuration.testdirs for testdir in dirs_to_search: for (dirpath, dirnames, filenames) in os.walk(testdir): visit('Test', dirpath, filenames) # # Now that we have loaded all the test cases, run the whole test suite. # # Disable default dynamic types for testing purposes disabledynamics() # Install the control-c handler. unittest2.signals.installHandler() lldbutil.mkdir_p(configuration.sdir_name) os.environ["LLDB_SESSION_DIRNAME"] = configuration.sdir_name sys.stderr.write( "\nSession logs for test failures/errors/unexpected successes" " will go into directory '%s'\n" % configuration.sdir_name) sys.stderr.write("Command invoked: %s\n" % get_dotest_invocation()) # # Invoke the default TextTestRunner to run the test suite # checkCompiler() if configuration.verbose: print("compiler=%s" % configuration.compiler) # Iterating over all possible architecture and compiler combinations. os.environ["ARCH"] = configuration.arch os.environ["CC"] = configuration.compiler configString = "arch=%s compiler=%s" % (configuration.arch, configuration.compiler) # Output the configuration. if configuration.verbose: sys.stderr.write("\nConfiguration: " + configString + "\n") # First, write out the number of collected test cases. if configuration.verbose: sys.stderr.write(configuration.separator + "\n") sys.stderr.write( "Collected %d test%s\n\n" % (configuration.suite.countTestCases(), configuration.suite.countTestCases() != 1 and "s" or "")) # Invoke the test runner. if configuration.count == 1: result = unittest2.TextTestRunner( stream=sys.stderr, verbosity=configuration.verbose, resultclass=test_result.LLDBTestResult).run( configuration.suite) else: # We are invoking the same test suite more than once. In this case, # mark __ignore_singleton__ flag as True so the signleton pattern is # not enforced. test_result.LLDBTestResult.__ignore_singleton__ = True for i in range(configuration.count): result = unittest2.TextTestRunner( stream=sys.stderr, verbosity=configuration.verbose, resultclass=test_result.LLDBTestResult).run( configuration.suite) configuration.failed = not result.wasSuccessful() if configuration.sdir_has_content and configuration.verbose: sys.stderr.write( "Session logs for test failures/errors/unexpected successes" " can be found in directory '%s'\n" % configuration.sdir_name) if configuration.useCategories and len( configuration.failuresPerCategory) > 0: sys.stderr.write("Failures per category:\n") for category in configuration.failuresPerCategory: sys.stderr.write( "%s - %d\n" % (category, configuration.failuresPerCategory[category])) # Exiting. exitTestSuite(configuration.failed)
def run_suite(): # On MacOS X, check to make sure that domain for com.apple.DebugSymbols defaults # does not exist before proceeding to running the test suite. if sys.platform.startswith("darwin"): checkDsymForUUIDIsNotOn() # # Start the actions by first parsing the options while setting up the test # directories, followed by setting up the search paths for lldb utilities; # then, we walk the directory trees and collect the tests into our test suite. # parseOptionsAndInitTestdirs() # Setup test results (test results formatter and output handling). setupTestResults() # If we are running as the multiprocess test runner, kick off the # multiprocess test runner here. if isMultiprocessTestRunner(): from . import dosep dosep.main(configuration.num_threads, configuration.multiprocess_test_subdir, configuration.test_runner_name, configuration.results_formatter_object) raise Exception("should never get here") elif configuration.is_inferior_test_runner: # Shut off Ctrl-C processing in inferiors. The parallel # test runner handles this more holistically. signal.signal(signal.SIGINT, signal.SIG_IGN) setupSysPath() configuration.setupCrashInfoHook() # # If '-l' is specified, do not skip the long running tests. if not configuration.skip_long_running_test: os.environ["LLDB_SKIP_LONG_RUNNING_TEST"] = "NO" # For the time being, let's bracket the test runner within the # lldb.SBDebugger.Initialize()/Terminate() pair. import lldb # Create a singleton SBDebugger in the lldb namespace. lldb.DBG = lldb.SBDebugger.Create() if configuration.lldb_platform_name: print("Setting up remote platform '%s'" % (configuration.lldb_platform_name)) lldb.remote_platform = lldb.SBPlatform( configuration.lldb_platform_name) if not lldb.remote_platform.IsValid(): print("error: unable to create the LLDB platform named '%s'." % (configuration.lldb_platform_name)) exitTestSuite(1) if configuration.lldb_platform_url: # We must connect to a remote platform if a LLDB platform URL was specified print("Connecting to remote platform '%s' at '%s'..." % (configuration.lldb_platform_name, configuration.lldb_platform_url)) platform_connect_options = lldb.SBPlatformConnectOptions( configuration.lldb_platform_url) err = lldb.remote_platform.ConnectRemote(platform_connect_options) if err.Success(): print("Connected.") else: print( "error: failed to connect to remote platform using URL '%s': %s" % (configuration.lldb_platform_url, err)) exitTestSuite(1) else: configuration.lldb_platform_url = None platform_changes = setDefaultTripleForPlatform() first = True for key in platform_changes: if first: print("Environment variables setup for platform support:") first = False print("%s = %s" % (key, platform_changes[key])) if configuration.lldb_platform_working_dir: print("Setting remote platform working directory to '%s'..." % (configuration.lldb_platform_working_dir)) lldb.remote_platform.SetWorkingDirectory( configuration.lldb_platform_working_dir) lldb.DBG.SetSelectedPlatform(lldb.remote_platform) else: lldb.remote_platform = None configuration.lldb_platform_working_dir = None configuration.lldb_platform_url = None target_platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2] # Don't do debugserver tests on everything except OS X. configuration.dont_do_debugserver_test = "linux" in target_platform or "freebsd" in target_platform or "windows" in target_platform # Don't do lldb-server (llgs) tests on anything except Linux. configuration.dont_do_llgs_test = not ("linux" in target_platform) # # Walk through the testdirs while collecting tests. # for testdir in configuration.testdirs: for (dirpath, dirnames, filenames) in os.walk(testdir): visit('Test', dirpath, filenames) # # Now that we have loaded all the test cases, run the whole test suite. # # Turn on lldb loggings if necessary. lldbLoggings() # Disable default dynamic types for testing purposes disabledynamics() # Install the control-c handler. unittest2.signals.installHandler() # If sdir_name is not specified through the '-s sdir_name' option, get a # timestamp string and export it as LLDB_SESSION_DIR environment var. This will # be used when/if we want to dump the session info of individual test cases # later on. # # See also TestBase.dumpSessionInfo() in lldbtest.py. import datetime # The windows platforms don't like ':' in the pathname. timestamp_started = datetime.datetime.now().strftime("%Y-%m-%d-%H_%M_%S") if not configuration.sdir_name: configuration.sdir_name = timestamp_started os.environ["LLDB_SESSION_DIRNAME"] = os.path.join(os.getcwd(), configuration.sdir_name) sys.stderr.write( "\nSession logs for test failures/errors/unexpected successes" " will go into directory '%s'\n" % configuration.sdir_name) sys.stderr.write("Command invoked: %s\n" % getMyCommandLine()) if not os.path.isdir(configuration.sdir_name): try: os.mkdir(configuration.sdir_name) except OSError as exception: if exception.errno != errno.EEXIST: raise # # Invoke the default TextTestRunner to run the test suite, possibly iterating # over different configurations. # iterArchs = False iterCompilers = False if isinstance(configuration.archs, list) and len(configuration.archs) >= 1: iterArchs = True # # Add some intervention here to sanity check that the compilers requested are sane. # If found not to be an executable program, the invalid one is dropped from the list. for i in range(len(configuration.compilers)): c = configuration.compilers[i] if which(c): continue else: if sys.platform.startswith("darwin"): pipe = subprocess.Popen(['xcrun', '-find', c], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) cmd_output = pipe.stdout.read() if cmd_output: if "not found" in cmd_output: print("dropping %s from the compilers used" % c) configuration.compilers.remove(i) else: configuration.compilers[i] = cmd_output.split('\n')[0] print("'xcrun -find %s' returning %s" % (c, configuration.compilers[i])) if not configuration.parsable: print("compilers=%s" % str(configuration.compilers)) if not configuration.compilers or len(configuration.compilers) == 0: print("No eligible compiler found, exiting.") exitTestSuite(1) if isinstance(configuration.compilers, list) and len(configuration.compilers) >= 1: iterCompilers = True # If we iterate on archs or compilers, there is a chance we want to split stderr/stdout. if iterArchs or iterCompilers: old_stderr = sys.stderr old_stdout = sys.stdout new_stderr = None new_stdout = None # Iterating over all possible architecture and compiler combinations. for ia in range(len(configuration.archs) if iterArchs else 1): archConfig = "" if iterArchs: os.environ["ARCH"] = configuration.archs[ia] archConfig = "arch=%s" % configuration.archs[ia] for ic in range(len(configuration.compilers) if iterCompilers else 1): if iterCompilers: os.environ["CC"] = configuration.compilers[ic] configString = "%s compiler=%s" % (archConfig, configuration.compilers[ic]) else: configString = archConfig if iterArchs or iterCompilers: # Translate ' ' to '-' for pathname component. if six.PY2: import string tbl = string.maketrans(' ', '-') else: tbl = str.maketrans(' ', '-') configPostfix = configString.translate(tbl) # Output the configuration. if not configuration.parsable: sys.stderr.write("\nConfiguration: " + configString + "\n") #print("sys.stderr name is", sys.stderr.name) #print("sys.stdout name is", sys.stdout.name) # First, write out the number of collected test cases. if not configuration.parsable: sys.stderr.write(configuration.separator + "\n") sys.stderr.write( "Collected %d test%s\n\n" % (configuration.suite.countTestCases(), configuration.suite.countTestCases() != 1 and "s" or "")) if configuration.parsable: v = 0 else: v = configuration.verbose # Invoke the test runner. if configuration.count == 1: result = unittest2.TextTestRunner( stream=sys.stderr, verbosity=v, resultclass=test_result.LLDBTestResult).run( configuration.suite) else: # We are invoking the same test suite more than once. In this case, # mark __ignore_singleton__ flag as True so the signleton pattern is # not enforced. test_result.LLDBTestResult.__ignore_singleton__ = True for i in range(count): result = unittest2.TextTestRunner( stream=sys.stderr, verbosity=v, resultclass=test_result.LLDBTestResult).run( configuration.suite) configuration.failed = configuration.failed or not result.wasSuccessful( ) if configuration.sdir_has_content and not configuration.parsable: sys.stderr.write( "Session logs for test failures/errors/unexpected successes" " can be found in directory '%s'\n" % configuration.sdir_name) if configuration.useCategories and len( configuration.failuresPerCategory) > 0: sys.stderr.write("Failures per category:\n") for category in configuration.failuresPerCategory: sys.stderr.write( "%s - %d\n" % (category, configuration.failuresPerCategory[category])) # Terminate the test suite if ${LLDB_TESTSUITE_FORCE_FINISH} is defined. # This should not be necessary now. if ("LLDB_TESTSUITE_FORCE_FINISH" in os.environ): print("Terminating Test suite...") subprocess.Popen(["/bin/sh", "-c", "kill %s; exit 0" % (os.getpid())]) # Exiting. exitTestSuite(configuration.failed)
# #Lots of code taken from: # #https://opensource.apple.com/source/lldb/lldb-159/www/python-reference.html # # Create a new debugger instance debugger = lldb.SBDebugger.Create() #debugger.SetAsync(False) set_plat_error = debugger.SetCurrentPlatform("remote-linux") assert (False == set_plat_error.Fail()) print(debugger.GetSelectedPlatform().GetName()) #curr_plat = debugger.GetSelectedPlatform() curr_plat = lldb.SBPlatform("remote-linux") print("Plat valid? {}".format(curr_plat.IsValid())) connection_params = lldb.SBPlatformConnectOptions("connect://{}".format( urls[0])) con_error = curr_plat.ConnectRemote(connection_params) print("Connection successs? {}".format(con_error.Success())) print("Platform connected? {} Still Valid? {}".format(curr_plat.IsConnected(), curr_plat.IsValid())) target = debugger.CreateTarget('') target.BreakpointCreateByName("main") target_error = lldb.SBError() a_process = target.ConnectRemote(debugger.GetListener(), "connect://{}".format(urls[0]),