diff options
Diffstat (limited to 'gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings')
6 files changed, 798 insertions, 0 deletions
diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/TestSettings.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/TestSettings.py new file mode 100644 index 00000000000..1130821bac0 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/TestSettings.py @@ -0,0 +1,604 @@ +""" +Test lldb settings command. +""" + + + +import os +import re +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class SettingsCommandTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + NO_DEBUG_INFO_TESTCASE = True + + def test_apropos_should_also_search_settings_description(self): + """Test that 'apropos' command should also search descriptions for the settings variables.""" + + self.expect("apropos 'environment variable'", + substrs=["target.env-vars", + "environment variables", + "executable's environment"]) + + def test_append_target_env_vars(self): + """Test that 'append target.run-args' works.""" + # Append the env-vars. + self.runCmd('settings append target.env-vars MY_ENV_VAR=YES') + # And add hooks to restore the settings during tearDown(). + self.addTearDownHook( + lambda: self.runCmd("settings clear target.env-vars")) + + # Check it immediately! + self.expect('settings show target.env-vars', + substrs=['MY_ENV_VAR=YES']) + + def test_insert_before_and_after_target_run_args(self): + """Test that 'insert-before/after target.run-args' works.""" + # Set the run-args first. + self.runCmd('settings set target.run-args a b c') + # And add hooks to restore the settings during tearDown(). + self.addTearDownHook( + lambda: self.runCmd("settings clear target.run-args")) + + # Now insert-before the index-0 element with '__a__'. + self.runCmd('settings insert-before target.run-args 0 __a__') + # And insert-after the index-1 element with '__A__'. + self.runCmd('settings insert-after target.run-args 1 __A__') + # Check it immediately! + self.expect('settings show target.run-args', + substrs=['target.run-args', + '[0]: "__a__"', + '[1]: "a"', + '[2]: "__A__"', + '[3]: "b"', + '[4]: "c"']) + + @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr44430") + def test_replace_target_run_args(self): + """Test that 'replace target.run-args' works.""" + # Set the run-args and then replace the index-0 element. + self.runCmd('settings set target.run-args a b c') + # And add hooks to restore the settings during tearDown(). + self.addTearDownHook( + lambda: self.runCmd("settings clear target.run-args")) + + # Now replace the index-0 element with 'A', instead. + self.runCmd('settings replace target.run-args 0 A') + # Check it immediately! + self.expect('settings show target.run-args', + substrs=['target.run-args (arguments) =', + '[0]: "A"', + '[1]: "b"', + '[2]: "c"']) + + def test_set_prompt(self): + """Test that 'set prompt' actually changes the prompt.""" + + # Set prompt to 'lldb2'. + self.runCmd("settings set prompt 'lldb2 '") + + # Immediately test the setting. + self.expect("settings show prompt", SETTING_MSG("prompt"), + startstr='prompt (string) = "lldb2 "') + + # The overall display should also reflect the new setting. + self.expect("settings show", SETTING_MSG("prompt"), + substrs=['prompt (string) = "lldb2 "']) + + # Use '-r' option to reset to the original default prompt. + self.runCmd("settings clear prompt") + + def test_set_term_width(self): + """Test that 'set term-width' actually changes the term-width.""" + + self.runCmd("settings set term-width 70") + + # Immediately test the setting. + self.expect("settings show term-width", SETTING_MSG("term-width"), + startstr="term-width (int) = 70") + + # The overall display should also reflect the new setting. + self.expect("settings show", SETTING_MSG("term-width"), + substrs=["term-width (int) = 70"]) + + # rdar://problem/10712130 + @skipIf(oslist=["windows"], bugnumber="llvm.org/pr44431") + def test_set_frame_format(self): + """Test that 'set frame-format' with a backtick char in the format string works as well as fullpath.""" + self.build() + + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + def cleanup(): + self.runCmd( + "settings set frame-format %s" % + self.format_string, check=False) + + # Execute the cleanup function during test case tear down. + self.addTearDownHook(cleanup) + + self.runCmd("settings show frame-format") + m = re.match( + '^frame-format \(format-string\) = "(.*)\"$', + self.res.GetOutput()) + self.assertTrue(m, "Bad settings string") + self.format_string = m.group(1) + + # Change the default format to print function.name rather than + # function.name-with-args + format_string = "frame #${frame.index}: ${frame.pc}{ ${module.file.basename}\`${function.name}{${function.pc-offset}}}{ at ${line.file.fullpath}:${line.number}}{, lang=${language}}\n" + self.runCmd("settings set frame-format %s" % format_string) + + # Immediately test the setting. + self.expect("settings show frame-format", SETTING_MSG("frame-format"), + substrs=[format_string]) + + self.runCmd("breakpoint set -n main") + self.runCmd("process launch --working-dir '{0}'".format(self.get_process_working_directory()), + RUN_SUCCEEDED) + self.expect("thread backtrace", + substrs=["`main", self.getSourceDir()]) + + def test_set_auto_confirm(self): + """Test that after 'set auto-confirm true', manual confirmation should not kick in.""" + self.build() + + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + self.runCmd("settings set auto-confirm true") + + # Immediately test the setting. + self.expect("settings show auto-confirm", SETTING_MSG("auto-confirm"), + startstr="auto-confirm (boolean) = true") + + # Now 'breakpoint delete' should just work fine without confirmation + # prompt from the command interpreter. + self.runCmd("breakpoint set -n main") + self.expect("breakpoint delete", + startstr="All breakpoints removed") + + # Restore the original setting of auto-confirm. + self.runCmd("settings clear auto-confirm") + self.expect("settings show auto-confirm", SETTING_MSG("auto-confirm"), + startstr="auto-confirm (boolean) = false") + + @skipIf(archs=no_match(['x86_64', 'i386', 'i686'])) + def test_disassembler_settings(self): + """Test that user options for the disassembler take effect.""" + self.build() + + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + # AT&T syntax + self.runCmd("settings set target.x86-disassembly-flavor att") + self.runCmd("settings set target.use-hex-immediates false") + self.expect("disassemble -n numberfn", + substrs=["$90"]) + self.runCmd("settings set target.use-hex-immediates true") + self.runCmd("settings set target.hex-immediate-style c") + self.expect("disassemble -n numberfn", + substrs=["$0x5a"]) + self.runCmd("settings set target.hex-immediate-style asm") + self.expect("disassemble -n numberfn", + substrs=["$5ah"]) + + # Intel syntax + self.runCmd("settings set target.x86-disassembly-flavor intel") + self.runCmd("settings set target.use-hex-immediates false") + self.expect("disassemble -n numberfn", + substrs=["90"]) + self.runCmd("settings set target.use-hex-immediates true") + self.runCmd("settings set target.hex-immediate-style c") + self.expect("disassemble -n numberfn", + substrs=["0x5a"]) + self.runCmd("settings set target.hex-immediate-style asm") + self.expect("disassemble -n numberfn", + substrs=["5ah"]) + + @skipIfDarwinEmbedded # <rdar://problem/34446098> debugserver on ios etc can't write files + def test_run_args_and_env_vars(self): + """Test that run-args and env-vars are passed to the launched process.""" + self.build() + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + # Set the run-args and the env-vars. + # And add hooks to restore the settings during tearDown(). + self.runCmd('settings set target.run-args A B C') + self.addTearDownHook( + lambda: self.runCmd("settings clear target.run-args")) + self.runCmd('settings set target.env-vars ["MY_ENV_VAR"]=YES') + self.addTearDownHook( + lambda: self.runCmd("settings clear target.env-vars")) + + self.runCmd("process launch --working-dir '{0}'".format(self.get_process_working_directory()), + RUN_SUCCEEDED) + + # Read the output file produced by running the program. + output = lldbutil.read_file_from_process_wd(self, "output2.txt") + + self.expect( + output, + exe=False, + substrs=[ + "argv[1] matches", + "argv[2] matches", + "argv[3] matches", + "Environment variable 'MY_ENV_VAR' successfully passed."]) + + @skipIfRemote # it doesn't make sense to send host env to remote target + def test_pass_host_env_vars(self): + """Test that the host env vars are passed to the launched process.""" + self.build() + + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + # By default, inherit-env is 'true'. + self.expect( + 'settings show target.inherit-env', + "Default inherit-env is 'true'", + startstr="target.inherit-env (boolean) = true") + + # Set some host environment variables now. + os.environ["MY_HOST_ENV_VAR1"] = "VAR1" + os.environ["MY_HOST_ENV_VAR2"] = "VAR2" + + # This is the function to unset the two env variables set above. + def unset_env_variables(): + os.environ.pop("MY_HOST_ENV_VAR1") + os.environ.pop("MY_HOST_ENV_VAR2") + + self.addTearDownHook(unset_env_variables) + self.runCmd("process launch --working-dir '{0}'".format(self.get_process_working_directory()), + RUN_SUCCEEDED) + + # Read the output file produced by running the program. + output = lldbutil.read_file_from_process_wd(self, "output1.txt") + + self.expect( + output, + exe=False, + substrs=[ + "The host environment variable 'MY_HOST_ENV_VAR1' successfully passed.", + "The host environment variable 'MY_HOST_ENV_VAR2' successfully passed."]) + + @skipIfDarwinEmbedded # <rdar://problem/34446098> debugserver on ios etc can't write files + def test_set_error_output_path(self): + """Test that setting target.error/output-path for the launched process works.""" + self.build() + + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + # Set the error-path and output-path and verify both are set. + self.runCmd("settings set target.error-path '{0}'".format( + lldbutil.append_to_process_working_directory(self, "stderr.txt"))) + self.runCmd("settings set target.output-path '{0}".format( + lldbutil.append_to_process_working_directory(self, "stdout.txt"))) + # And add hooks to restore the original settings during tearDown(). + self.addTearDownHook( + lambda: self.runCmd("settings clear target.output-path")) + self.addTearDownHook( + lambda: self.runCmd("settings clear target.error-path")) + + self.expect("settings show target.error-path", + SETTING_MSG("target.error-path"), + substrs=['target.error-path (file)', 'stderr.txt"']) + + self.expect("settings show target.output-path", + SETTING_MSG("target.output-path"), + substrs=['target.output-path (file)', 'stdout.txt"']) + + self.runCmd("process launch --working-dir '{0}'".format(self.get_process_working_directory()), + RUN_SUCCEEDED) + + output = lldbutil.read_file_from_process_wd(self, "stderr.txt") + message = "This message should go to standard error." + if lldbplatformutil.hasChattyStderr(self): + self.expect(output, exe=False, substrs=[message]) + else: + self.expect(output, exe=False, startstr=message) + + output = lldbutil.read_file_from_process_wd(self, "stdout.txt") + self.expect(output, exe=False, + startstr="This message should go to standard out.") + + def test_print_dictionary_setting(self): + self.runCmd("settings clear target.env-vars") + self.runCmd("settings set target.env-vars [\"MY_VAR\"]=some-value") + self.expect("settings show target.env-vars", + substrs=["MY_VAR=some-value"]) + self.runCmd("settings clear target.env-vars") + + def test_print_array_setting(self): + self.runCmd("settings clear target.run-args") + self.runCmd("settings set target.run-args gobbledy-gook") + self.expect("settings show target.run-args", + substrs=['[0]: "gobbledy-gook"']) + self.runCmd("settings clear target.run-args") + + def test_settings_with_quotes(self): + self.runCmd("settings clear target.run-args") + self.runCmd("settings set target.run-args a b c") + self.expect("settings show target.run-args", + substrs=['[0]: "a"', + '[1]: "b"', + '[2]: "c"']) + self.runCmd("settings set target.run-args 'a b c'") + self.expect("settings show target.run-args", + substrs=['[0]: "a b c"']) + self.runCmd("settings clear target.run-args") + self.runCmd("settings clear target.env-vars") + self.runCmd( + 'settings set target.env-vars ["MY_FILE"]="this is a file name with spaces.txt"') + self.expect("settings show target.env-vars", + substrs=['MY_FILE=this is a file name with spaces.txt']) + self.runCmd("settings clear target.env-vars") + # Test and make sure that setting "format-string" settings obeys quotes + # if they are provided + self.runCmd("settings set thread-format 'abc def' ") + self.expect("settings show thread-format", + 'thread-format (format-string) = "abc def"') + self.runCmd('settings set thread-format "abc def" ') + self.expect("settings show thread-format", + 'thread-format (format-string) = "abc def"') + # Make sure when no quotes are provided that we maintain any trailing + # spaces + self.runCmd('settings set thread-format abc def ') + self.expect("settings show thread-format", + 'thread-format (format-string) = "abc def "') + self.runCmd('settings clear thread-format') + + @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr44430") + def test_settings_with_trailing_whitespace(self): + + # boolean + # Set to known value + self.runCmd("settings set target.skip-prologue true") + # Set to new value with trailing whitespace + self.runCmd("settings set target.skip-prologue false ") + # Make sure the setting was correctly set to "false" + self.expect( + "settings show target.skip-prologue", + SETTING_MSG("target.skip-prologue"), + startstr="target.skip-prologue (boolean) = false") + self.runCmd("settings clear target.skip-prologue", check=False) + # integer + self.runCmd("settings set term-width 70") # Set to known value + # Set to new value with trailing whitespaces + self.runCmd("settings set term-width 60 \t") + self.expect("settings show term-width", SETTING_MSG("term-width"), + startstr="term-width (int) = 60") + self.runCmd("settings clear term-width", check=False) + # string + self.runCmd("settings set target.arg0 abc") # Set to known value + # Set to new value with trailing whitespaces + self.runCmd("settings set target.arg0 cde\t ") + self.expect("settings show target.arg0", SETTING_MSG("target.arg0"), + startstr='target.arg0 (string) = "cde"') + self.runCmd("settings clear target.arg0", check=False) + # file + path1 = self.getBuildArtifact("path1.txt") + path2 = self.getBuildArtifact("path2.txt") + self.runCmd( + "settings set target.output-path %s" % + path1) # Set to known value + self.expect( + "settings show target.output-path", + SETTING_MSG("target.output-path"), + startstr='target.output-path (file) = ', + substrs=[path1]) + self.runCmd("settings set target.output-path %s " % + path2) # Set to new value with trailing whitespaces + self.expect( + "settings show target.output-path", + SETTING_MSG("target.output-path"), + startstr='target.output-path (file) = ', + substrs=[path2]) + self.runCmd("settings clear target.output-path", check=False) + # enum + # Set to known value + self.runCmd("settings set stop-disassembly-display never") + # Set to new value with trailing whitespaces + self.runCmd("settings set stop-disassembly-display always ") + self.expect( + "settings show stop-disassembly-display", + SETTING_MSG("stop-disassembly-display"), + startstr='stop-disassembly-display (enum) = always') + self.runCmd("settings clear stop-disassembly-display", check=False) + # language + # Set to known value + self.runCmd("settings set target.language c89") + # Set to new value with trailing whitespace + self.runCmd("settings set target.language c11 ") + self.expect( + "settings show target.language", + SETTING_MSG("target.language"), + startstr="target.language (language) = c11") + self.runCmd("settings clear target.language", check=False) + # arguments + self.runCmd("settings set target.run-args 1 2 3") # Set to known value + # Set to new value with trailing whitespaces + self.runCmd("settings set target.run-args 3 4 5 ") + self.expect( + "settings show target.run-args", + SETTING_MSG("target.run-args"), + substrs=[ + 'target.run-args (arguments) =', + '[0]: "3"', + '[1]: "4"', + '[2]: "5"']) + self.runCmd("settings set target.run-args 1 2 3") # Set to known value + # Set to new value with trailing whitespaces + self.runCmd("settings set target.run-args 3 \ \ ") + self.expect( + "settings show target.run-args", + SETTING_MSG("target.run-args"), + substrs=[ + 'target.run-args (arguments) =', + '[0]: "3"', + '[1]: " "', + '[2]: " "']) + self.runCmd("settings clear target.run-args", check=False) + # dictionaries + self.runCmd("settings clear target.env-vars") # Set to known value + # Set to new value with trailing whitespaces + self.runCmd("settings set target.env-vars A=B C=D\t ") + self.expect( + "settings show target.env-vars", + SETTING_MSG("target.env-vars"), + substrs=[ + 'target.env-vars (dictionary of strings) =', + 'A=B', + 'C=D']) + self.runCmd("settings clear target.env-vars", check=False) + # regex + # Set to known value + self.runCmd("settings clear target.process.thread.step-avoid-regexp") + # Set to new value with trailing whitespaces + self.runCmd( + "settings set target.process.thread.step-avoid-regexp foo\\ ") + self.expect( + "settings show target.process.thread.step-avoid-regexp", + SETTING_MSG("target.process.thread.step-avoid-regexp"), + substrs=['target.process.thread.step-avoid-regexp (regex) = foo\\ ']) + self.runCmd( + "settings clear target.process.thread.step-avoid-regexp", + check=False) + # format-string + self.runCmd("settings clear disassembly-format") # Set to known value + # Set to new value with trailing whitespaces + self.runCmd("settings set disassembly-format foo ") + self.expect("settings show disassembly-format", + SETTING_MSG("disassembly-format"), + substrs=['disassembly-format (format-string) = "foo "']) + self.runCmd("settings clear disassembly-format", check=False) + + def test_settings_list(self): + # List settings (and optionally test the filter to only show 'target' settings). + self.expect("settings list target", substrs=["language", "arg0", "detach-on-error"]) + self.expect("settings list target", matching=False, substrs=["packet-timeout"]) + self.expect("settings list", substrs=["language", "arg0", "detach-on-error", "packet-timeout"]) + + def test_settings_remove_single(self): + # Set some environment variables and use 'remove' to delete them. + self.runCmd("settings set target.env-vars a=b c=d") + self.expect("settings show target.env-vars", substrs=["a=b", "c=d"]) + self.runCmd("settings remove target.env-vars a") + self.expect("settings show target.env-vars", matching=False, substrs=["a=b"]) + self.expect("settings show target.env-vars", substrs=["c=d"]) + self.runCmd("settings remove target.env-vars c") + self.expect("settings show target.env-vars", matching=False, substrs=["a=b", "c=d"]) + + def test_settings_remove_multiple(self): + self.runCmd("settings set target.env-vars a=b c=d e=f") + self.expect("settings show target.env-vars", substrs=["a=b", "c=d", "e=f"]) + self.runCmd("settings remove target.env-vars a e") + self.expect("settings show target.env-vars", matching=False, substrs=["a=b", "e=f"]) + self.expect("settings show target.env-vars", substrs=["c=d"]) + + def test_settings_remove_nonexistent_value(self): + self.expect("settings remove target.env-vars doesntexist", error=True, + substrs=["no value found named 'doesntexist'"]) + + def test_settings_remove_nonexistent_settings(self): + self.expect("settings remove doesntexist alsodoesntexist", error=True, + substrs=["error: invalid value path 'doesntexist'"]) + + def test_settings_remove_missing_arg(self): + self.expect("settings remove", error=True, + substrs=["'settings remove' takes an array or dictionary item, or"]) + + def test_settings_remove_empty_arg(self): + self.expect("settings remove ''", error=True, + substrs=["'settings remove' command requires a valid variable name"]) + + def test_all_settings_exist(self): + self.expect("settings show", + substrs=["auto-confirm", + "frame-format", + "notify-void", + "prompt", + "script-lang", + "stop-disassembly-count", + "stop-disassembly-display", + "stop-line-count-after", + "stop-line-count-before", + "stop-show-column", + "term-width", + "thread-format", + "use-external-editor", + "target.default-arch", + "target.move-to-nearest-code", + "target.expr-prefix", + "target.language", + "target.prefer-dynamic-value", + "target.enable-synthetic-value", + "target.skip-prologue", + "target.source-map", + "target.exec-search-paths", + "target.max-children-count", + "target.max-string-summary-length", + "target.breakpoints-use-platform-avoid-list", + "target.run-args", + "target.env-vars", + "target.inherit-env", + "target.input-path", + "target.output-path", + "target.error-path", + "target.disable-aslr", + "target.disable-stdio", + "target.x86-disassembly-flavor", + "target.use-hex-immediates", + "target.hex-immediate-style", + "target.process.disable-memory-cache", + "target.process.extra-startup-command", + "target.process.thread.step-avoid-regexp", + "target.process.thread.trace-thread"]) + + # settings under an ".experimental" domain should have two properties: + # 1. If the name does not exist with "experimental" in the name path, + # the name lookup should try to find it without "experimental". So + # a previously-experimental setting that has been promoted to a + # "real" setting will still be set by the original name. + # 2. Changing a setting with .experimental., name, where the setting + # does not exist either with ".experimental." or without, should + # not generate an error. So if an experimental setting is removed, + # people who may have that in their ~/.lldbinit files should not see + # any errors. + def test_experimental_settings(self): + cmdinterp = self.dbg.GetCommandInterpreter() + result = lldb.SBCommandReturnObject() + + # Set target.arg0 to a known value, check that we can retrieve it via + # the actual name and via .experimental. + self.expect('settings set target.arg0 first-value') + self.expect('settings show target.arg0', substrs=['first-value']) + self.expect('settings show target.experimental.arg0', substrs=['first-value'], error=False) + + # Set target.arg0 to a new value via a target.experimental.arg0 name, + # verify that we can read it back via both .experimental., and not. + self.expect('settings set target.experimental.arg0 second-value', error=False) + self.expect('settings show target.arg0', substrs=['second-value']) + self.expect('settings show target.experimental.arg0', substrs=['second-value'], error=False) + + # showing & setting an undefined .experimental. setting should generate no errors. + self.expect('settings show target.experimental.setting-which-does-not-exist', patterns=['^\s$'], error=False) + self.expect('settings set target.experimental.setting-which-does-not-exist true', error=False) + + # A domain component before .experimental. which does not exist should give an error + # But the code does not yet do that. + # self.expect('settings set target.setting-which-does-not-exist.experimental.arg0 true', error=True) + + # finally, confirm that trying to set a setting that does not exist still fails. + # (SHOWING a setting that does not exist does not currently yield an error.) + self.expect('settings set target.setting-which-does-not-exist true', error=True) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/main.cpp new file mode 100644 index 00000000000..5159eaa65b5 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/main.cpp @@ -0,0 +1,74 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <cstdlib> +#include <string> +#include <fstream> +#include <iostream> + +int numberfn() +{ + return 0x5a; +} + +int +main(int argc, char const *argv[]) +{ + // The program writes its output to the following file: + // + // o "output1.txt" for test_pass_host_env_vars() test case + // o "output2.txt" for test_run_args_and_env_vars_with_dsym() test case + // o "output2.txt" for test_run_args_and_env_vars_with_dwarf() test case + std::ofstream outfile; + if (argc == 1) + outfile.open("output1.txt"); + else + outfile.open("output2.txt"); + + for (unsigned i = 0; i < argc; ++i) { + std::string theArg(argv[i]); + if (i == 1 && "A" == theArg) + outfile << "argv[1] matches\n"; + + if (i == 2 && "B" == theArg) + outfile << "argv[2] matches\n"; + + if (i == 3 && "C" == theArg) + outfile << "argv[3] matches\n"; + } + + // For passing environment vars from the debugger to the launched process. + if (::getenv("MY_ENV_VAR")) { + std::string MY_ENV_VAR(getenv("MY_ENV_VAR")); + if ("YES" == MY_ENV_VAR) { + outfile << "Environment variable 'MY_ENV_VAR' successfully passed.\n"; + } + } + + + // For passing host environment vars to the launched process. + if (::getenv("MY_HOST_ENV_VAR1")) { + std::string MY_HOST_ENV_VAR1(getenv("MY_HOST_ENV_VAR1")); + if ("VAR1" == MY_HOST_ENV_VAR1) { + outfile << "The host environment variable 'MY_HOST_ENV_VAR1' successfully passed.\n"; + } + } + + if (::getenv("MY_HOST_ENV_VAR2")) { + std::string MY_HOST_ENV_VAR2(getenv("MY_HOST_ENV_VAR2")); + if ("VAR2" == MY_HOST_ENV_VAR2) { + outfile << "The host environment variable 'MY_HOST_ENV_VAR2' successfully passed.\n"; + } + } + + std::cerr << "This message should go to standard error.\n"; + std::cout << "This message should go to standard out.\n"; + + outfile.close(); + return numberfn(); +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/quoting/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/quoting/Makefile new file mode 100644 index 00000000000..10495940055 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/quoting/Makefile @@ -0,0 +1,3 @@ +C_SOURCES := main.c + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/quoting/TestQuoting.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/quoting/TestQuoting.py new file mode 100644 index 00000000000..5853313db6f --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/quoting/TestQuoting.py @@ -0,0 +1,93 @@ +""" +Test quoting of arguments to lldb commands +""" + + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class SettingsCommandTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @classmethod + def classCleanup(cls): + """Cleanup the test byproducts.""" + cls.RemoveTempFile("stdout.txt") + + @no_debug_info_test + def test_no_quote(self): + self.do_test_args("a b c", "a\0b\0c\0") + + @no_debug_info_test + def test_single_quote(self): + self.do_test_args("'a b c'", "a b c\0") + + @no_debug_info_test + def test_double_quote(self): + self.do_test_args('"a b c"', "a b c\0") + + @no_debug_info_test + def test_single_quote_escape(self): + self.do_test_args("'a b\\' c", "a b\\\0c\0") + + @no_debug_info_test + def test_double_quote_escape(self): + self.do_test_args('"a b\\" c"', 'a b" c\0') + + @no_debug_info_test + def test_double_quote_escape2(self): + self.do_test_args('"a b\\\\" c', 'a b\\\0c\0') + + @no_debug_info_test + def test_single_in_double(self): + self.do_test_args('"a\'b"', "a'b\0") + + @no_debug_info_test + def test_double_in_single(self): + self.do_test_args("'a\"b'", 'a"b\0') + + @no_debug_info_test + def test_combined(self): + self.do_test_args('"a b"c\'d e\'', 'a bcd e\0') + + @no_debug_info_test + def test_bare_single(self): + self.do_test_args("a\\'b", "a'b\0") + + @no_debug_info_test + def test_bare_double(self): + self.do_test_args('a\\"b', 'a"b\0') + + def do_test_args(self, args_in, args_out): + """Test argument parsing. Run the program with args_in. The program dumps its arguments + to stdout. Compare the stdout with args_out.""" + self.buildDefault() + + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + local_outfile = self.getBuildArtifact("output.txt") + if lldb.remote_platform: + remote_outfile = "output.txt" # Relative to platform's PWD + else: + remote_outfile = local_outfile + + self.runCmd("process launch -- %s %s" %(remote_outfile, args_in)) + + if lldb.remote_platform: + src_file_spec = lldb.SBFileSpec(remote_outfile, False) + dst_file_spec = lldb.SBFileSpec(local_outfile, True) + lldb.remote_platform.Get(src_file_spec, dst_file_spec) + + with open(local_outfile, 'r') as f: + output = f.read() + + self.RemoveTempFile(local_outfile) + + self.assertEqual(output, args_out) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/quoting/main.c b/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/quoting/main.c new file mode 100644 index 00000000000..2ebaa142bc5 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/commands/settings/quoting/main.c @@ -0,0 +1,21 @@ +#include <stdio.h> +#include <string.h> +#include <stdlib.h> + +/* This program writes its arguments (separated by '\0') to stdout. */ +int +main(int argc, char const *argv[]) +{ + int i; + + FILE *output = fopen (argv[1], "w"); + if (output == NULL) + exit (1); + + for (i = 2; i < argc; ++i) + fwrite(argv[i], strlen(argv[i])+1, 1, output); + + fclose (output); + + return 0; +} |