""" Test lldb-vscode setBreakpoints request """ from __future__ import print_function import pprint import unittest2 import vscode from lldbsuite.test.decorators import * from lldbsuite.test.lldbtest import * from lldbsuite.test import lldbutil import lldbvscode_testcase import os import time class TestVSCode_launch(lldbvscode_testcase.VSCodeTestCaseBase): mydir = TestBase.compute_mydir(__file__) @skipIfWindows @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots @no_debug_info_test def test_default(self): ''' Tests the default launch of a simple program. No arguments, environment, or anything else is specified. ''' program = self.getBuildArtifact("a.out") self.build_and_launch(program) self.continue_to_exit() # Now get the STDOUT and verify our program argument is correct output = self.get_stdout() self.assertTrue(output and len(output) > 0, "expect program output") lines = output.splitlines() self.assertTrue(program in lines[0], "make sure program path is in first argument") @skipIfWindows @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots @no_debug_info_test def test_stopOnEntry(self): ''' Tests the default launch of a simple program that stops at the entry point instead of continuing. ''' program = self.getBuildArtifact("a.out") self.build_and_launch(program, stopOnEntry=True) self.set_function_breakpoints(['main']) stopped_events = self.continue_to_next_stop() for stopped_event in stopped_events: if 'body' in stopped_event: body = stopped_event['body'] if 'reason' in body: reason = body['reason'] self.assertTrue( reason != 'breakpoint', 'verify stop isn\'t "main" breakpoint') @skipIfWindows @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots @expectedFailureNetBSD @no_debug_info_test def test_cwd(self): ''' Tests the default launch of a simple program with a current working directory. ''' program = self.getBuildArtifact("a.out") program_parent_dir = os.path.split(os.path.split(program)[0])[0] self.build_and_launch(program, cwd=program_parent_dir) self.continue_to_exit() # Now get the STDOUT and verify our program argument is correct output = self.get_stdout() self.assertTrue(output and len(output) > 0, "expect program output") lines = output.splitlines() found = False for line in lines: if line.startswith('cwd = \"'): quote_path = '"%s"' % (program_parent_dir) found = True self.assertTrue(quote_path in line, "working directory '%s' not in '%s'" % ( program_parent_dir, line)) self.assertTrue(found, "verified program working directory") @skipIfWindows @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots @expectedFailureNetBSD @no_debug_info_test def test_debuggerRoot(self): ''' Tests the "debuggerRoot" will change the working directory of the lldb-vscode debug adaptor. ''' program = self.getBuildArtifact("a.out") program_parent_dir = os.path.split(os.path.split(program)[0])[0] commands = ['platform shell echo cwd = $PWD'] self.build_and_launch(program, debuggerRoot=program_parent_dir, initCommands=commands) output = self.get_console() self.assertTrue(output and len(output) > 0, "expect console output") lines = output.splitlines() prefix = 'cwd = ' found = False for line in lines: if line.startswith(prefix): found = True self.assertTrue(program_parent_dir == line[len(prefix):], "lldb-vscode working dir '%s' == '%s'" % ( program_parent_dir, line[6:])) self.assertTrue(found, "verified lldb-vscode working directory") self.continue_to_exit() @skipIfWindows @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots @no_debug_info_test def test_sourcePath(self): ''' Tests the "sourcePath" will set the target.source-map. ''' program = self.getBuildArtifact("a.out") program_dir = os.path.split(program)[0] self.build_and_launch(program, sourcePath=program_dir) output = self.get_console() self.assertTrue(output and len(output) > 0, "expect console output") lines = output.splitlines() prefix = '(lldb) settings set target.source-map "." ' found = False for line in lines: if line.startswith(prefix): found = True quoted_path = '"%s"' % (program_dir) self.assertTrue(quoted_path == line[len(prefix):], "lldb-vscode working dir %s == %s" % ( quoted_path, line[6:])) self.assertTrue(found, 'found "sourcePath" in console output') self.continue_to_exit() @skipIfWindows @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots @no_debug_info_test def test_disableSTDIO(self): ''' Tests the default launch of a simple program with STDIO disabled. ''' program = self.getBuildArtifact("a.out") self.build_and_launch(program, disableSTDIO=True) self.continue_to_exit() # Now get the STDOUT and verify our program argument is correct output = self.get_stdout() self.assertTrue(output is None or len(output) == 0, "expect no program output") @skipIfWindows @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots @skipIfLinux # shell argument expansion doesn't seem to work on Linux @expectedFailureNetBSD @no_debug_info_test def test_shellExpandArguments_enabled(self): ''' Tests the default launch of a simple program with shell expansion enabled. ''' program = self.getBuildArtifact("a.out") program_dir = os.path.split(program)[0] glob = os.path.join(program_dir, '*.out') self.build_and_launch(program, args=[glob], shellExpandArguments=True) self.continue_to_exit() # Now get the STDOUT and verify our program argument is correct output = self.get_stdout() self.assertTrue(output and len(output) > 0, "expect no program output") lines = output.splitlines() for line in lines: quote_path = '"%s"' % (program) if line.startswith("arg[1] ="): self.assertTrue(quote_path in line, 'verify "%s" expanded to "%s"' % ( glob, program)) @skipIfWindows @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots @no_debug_info_test def test_shellExpandArguments_disabled(self): ''' Tests the default launch of a simple program with shell expansion disabled. ''' program = self.getBuildArtifact("a.out") program_dir = os.path.split(program)[0] glob = os.path.join(program_dir, '*.out') self.build_and_launch(program, args=[glob], shellExpandArguments=False) self.continue_to_exit() # Now get the STDOUT and verify our program argument is correct output = self.get_stdout() self.assertTrue(output and len(output) > 0, "expect no program output") lines = output.splitlines() for line in lines: quote_path = '"%s"' % (glob) if line.startswith("arg[1] ="): self.assertTrue(quote_path in line, 'verify "%s" stayed to "%s"' % ( glob, glob)) @skipIfWindows @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots @no_debug_info_test def test_args(self): ''' Tests launch of a simple program with arguments ''' program = self.getBuildArtifact("a.out") args = ["one", "with space", "'with single quotes'", '"with double quotes"'] self.build_and_launch(program, args=args) self.continue_to_exit() # Now get the STDOUT and verify our arguments got passed correctly output = self.get_stdout() self.assertTrue(output and len(output) > 0, "expect program output") lines = output.splitlines() # Skip the first argument that contains the program name lines.pop(0) # Make sure arguments we specified are correct for (i, arg) in enumerate(args): quoted_arg = '"%s"' % (arg) self.assertTrue(quoted_arg in lines[i], 'arg[%i] "%s" not in "%s"' % (i+1, quoted_arg, lines[i])) @skipIfWindows @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots @no_debug_info_test def test_environment(self): ''' Tests launch of a simple program with environment variables ''' program = self.getBuildArtifact("a.out") env = ["NO_VALUE", "WITH_VALUE=BAR", "EMPTY_VALUE=", "SPACE=Hello World"] self.build_and_launch(program, env=env) self.continue_to_exit() # Now get the STDOUT and verify our arguments got passed correctly output = self.get_stdout() self.assertTrue(output and len(output) > 0, "expect program output") lines = output.splitlines() # Skip the all arguments so we have only environment vars left while len(lines) and lines[0].startswith("arg["): lines.pop(0) # Make sure each environment variable in "env" is actually set in the # program environment that was printed to STDOUT for var in env: found = False for program_var in lines: if var in program_var: found = True break self.assertTrue(found, '"%s" must exist in program environment (%s)' % ( var, lines)) @skipIfWindows @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots @no_debug_info_test def test_commands(self): ''' Tests the "initCommands", "preRunCommands", "stopCommands" and "exitCommands" that can be passed during launch. "initCommands" are a list of LLDB commands that get executed before the targt is created. "preRunCommands" are a list of LLDB commands that get executed after the target has been created and before the launch. "stopCommands" are a list of LLDB commands that get executed each time the program stops. "exitCommands" are a list of LLDB commands that get executed when the process exits ''' program = self.getBuildArtifact("a.out") initCommands = ['target list', 'platform list'] preRunCommands = ['image list a.out', 'image dump sections a.out'] stopCommands = ['frame variable', 'bt'] exitCommands = ['expr 2+3', 'expr 3+4'] self.build_and_launch(program, initCommands=initCommands, preRunCommands=preRunCommands, stopCommands=stopCommands, exitCommands=exitCommands) # Get output from the console. This should contain both the # "initCommands" and the "preRunCommands". output = self.get_console() # Verify all "initCommands" were found in console output self.verify_commands('initCommands', output, initCommands) # Verify all "preRunCommands" were found in console output self.verify_commands('preRunCommands', output, preRunCommands) source = 'main.c' first_line = line_number(source, '// breakpoint 1') second_line = line_number(source, '// breakpoint 2') lines = [first_line, second_line] # Set 2 breakoints so we can verify that "stopCommands" get run as the # breakpoints get hit breakpoint_ids = self.set_source_breakpoints(source, lines) self.assertTrue(len(breakpoint_ids) == len(lines), "expect correct number of breakpoints") # Continue after launch and hit the first breakpoint. # Get output from the console. This should contain both the # "stopCommands" that were run after the first breakpoint was hit self.continue_to_breakpoints(breakpoint_ids) output = self.get_console(timeout=1.0) self.verify_commands('stopCommands', output, stopCommands) # Continue again and hit the second breakpoint. # Get output from the console. This should contain both the # "stopCommands" that were run after the second breakpoint was hit self.continue_to_breakpoints(breakpoint_ids) output = self.get_console(timeout=1.0) self.verify_commands('stopCommands', output, stopCommands) # Continue until the program exits self.continue_to_exit() # Get output from the console. This should contain both the # "exitCommands" that were run after the second breakpoint was hit output = self.get_console(timeout=1.0) self.verify_commands('exitCommands', output, exitCommands)