""" Test lldb settings command. """ import os, time import unittest2 import lldb from lldbtest import * class SettingsCommandTestCase(TestBase): mydir = "settings" @classmethod def classCleanup(cls): """Cleanup the test byproducts.""" system(["/bin/sh", "-c", "rm -f output1.txt"]) system(["/bin/sh", "-c", "rm -f output2.txt"]) system(["/bin/sh", "-c", "rm -f stderr.txt"]) system(["/bin/sh", "-c", "rm -f stdout.txt"]) 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.process.env-vars", "environment variables", "executable's environment"]) 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 set -r 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"]) def test_set_auto_confirm(self): """Test that after 'set auto-confirm true', manual confirmation should not kick in.""" self.buildDefault() exe = os.path.join(os.getcwd(), "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 set -r auto-confirm") self.expect("settings show auto-confirm", SETTING_MSG("auto-confirm"), startstr = "auto-confirm (boolean) = false") @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") def test_run_args_and_env_vars_with_dsym(self): """Test that run-args and env-vars are passed to the launched process.""" self.buildDsym() self.pass_run_args_and_env_vars() def test_run_args_and_env_vars_with_dwarf(self): """Test that run-args and env-vars are passed to the launched process.""" self.buildDwarf() self.pass_run_args_and_env_vars() def pass_run_args_and_env_vars(self): """Test that run-args and env-vars are passed to the launched process.""" exe = os.path.join(os.getcwd(), "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.process.run-args A B C') self.addTearDownHook( lambda: self.runCmd("settings set -r target.process.run-args")) self.runCmd('settings set target.process.env-vars ["MY_ENV_VAR"]=YES') self.addTearDownHook( lambda: self.runCmd("settings set -r target.process.env-vars")) self.runCmd("run", RUN_SUCCEEDED) # Read the output file produced by running the program. with open('output2.txt', 'r') as f: output = f.read() self.expect(output, exe=False, substrs = ["argv[1] matches", "argv[2] matches", "argv[3] matches", "Environment variable 'MY_ENV_VAR' successfully passed."]) def test_pass_host_env_vars(self): """Test that the host env vars are passed to the launched process.""" self.buildDefault() exe = os.path.join(os.getcwd(), "a.out") self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) # By default, inherit-env is 'true'. self.expect('settings show target.process.inherit-env', "Default inherit-env is 'true'", startstr = "target.process.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("run", RUN_SUCCEEDED) # Read the output file produced by running the program. with open('output1.txt', 'r') as f: output = f.read() 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."]) def test_set_error_output_path(self): """Test that setting target.process.error/output-path for the launched process works.""" self.buildDefault() exe = os.path.join(os.getcwd(), "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.process.error-path stderr.txt") self.runCmd("settings set target.process.output-path stdout.txt") # And add hooks to restore the original settings during tearDown(). self.addTearDownHook( lambda: self.runCmd("settings set -r target.process.output-path")) self.addTearDownHook( lambda: self.runCmd("settings set -r target.process.error-path")) self.expect("settings show target.process.error-path", SETTING_MSG("target.process.error-path"), startstr = 'target.process.error-path (string) = "stderr.txt"') self.expect("settings show target.process.output-path", SETTING_MSG("target.process.output-path"), startstr = 'target.process.output-path (string) = "stdout.txt"') self.runCmd("run", RUN_SUCCEEDED) # The 'stderr.txt' file should now exist. self.assertTrue(os.path.isfile("stderr.txt"), "'stderr.txt' exists due to target.process.error-path.") # Read the output file produced by running the program. with open('stderr.txt', 'r') as f: output = f.read() self.expect(output, exe=False, startstr = "This message should go to standard error.") # The 'stdout.txt' file should now exist. self.assertTrue(os.path.isfile("stdout.txt"), "'stdout.txt' exists due to target.process.output-path.") # Read the output file produced by running the program. with open('stdout.txt', 'r') as f: output = f.read() self.expect(output, exe=False, startstr = "This message should go to standard out.") def test_print_dictionary_setting(self): self.runCmd ("settings set -r target.process.env-vars") self.runCmd ("settings set target.process.env-vars [\"MY_VAR\"]=some-value") self.expect ("settings show target.process.env-vars", substrs = [ "MY_VAR=some-value" ]) self.runCmd ("settings set -r target.process.env-vars") def test_print_array_setting(self): self.runCmd ("settings set -r target.process.run-args") self.runCmd ("settings set target.process.run-args gobbledy-gook") self.expect ("settings show target.process.run-args", substrs = [ '[0]: "gobbledy-gook"' ]) self.runCmd ("settings set -r target.process.run-args") def test_settings_with_quotes (self): self.runCmd ("settings set -r target.process.run-args") self.runCmd ("settings set target.process.run-args a b c") self.expect ("settings show target.process.run-args", substrs = [ '[0]: "a"', '[1]: "b"', '[2]: "c"' ]) self.runCmd ("settings set target.process.run-args 'a b c'") self.expect ("settings show target.process.run-args", substrs = [ '[0]: "a b c"' ]) self.runCmd ("settings set -r target.process.run-args") self.runCmd ("settings set -r target.process.env-vars") self.runCmd ('settings set target.process.env-vars ["MY_FILE"]="this is a file name with spaces.txt"') self.expect ("settings show target.process.env-vars", substrs = [ 'MY_FILE=this is a file name with spaces.txt' ]) self.runCmd ("settings set -r target.process.env-vars") def test_all_settings_exist (self): self.expect ("settings show", substrs = [ "frame-format (string) = ", "prompt (string) = ", "script-lang (string) = ", "term-width (int) = ", "thread-format (string) = ", "use-external-editor (boolean) = ", "auto-confirm (boolean) = ", "target.default-arch (string) =", "target.expr-prefix (string) = ", "target.process.run-args (array) =", "target.process.env-vars (dictionary) =", "target.process.inherit-env (boolean) = ", "target.process.input-path (string) = ", "target.process.output-path (string) = ", "target.process.error-path (string) = ", "target.process.plugin (enum) =", "target.process.disable-aslr (boolean) = ", "target.process.disable-stdio (boolean) = ", "target.process.thread.step-avoid-regexp (string) =", "target.process.thread.trace-thread (boolean) =" ]) if __name__ == '__main__': import atexit lldb.SBDebugger.Initialize() atexit.register(lambda: lldb.SBDebugger.Terminate()) unittest2.main()