lldb/test/API/commands/settings/TestSettings.py

   1 """
   2 Test lldb settings command.
   3 """
   4
   5 import json
   6 import os
   7 import re
   8
   9 import lldb
  10 from lldbsuite.test import lldbutil
  11 from lldbsuite.test.decorators import *
  12 from lldbsuite.test.lldbtest import *
  13
  14
  15 class SettingsCommandTestCase(TestBase):
  16     NO_DEBUG_INFO_TESTCASE = True
  17
  18     def test_apropos_should_also_search_settings_description(self):
  19         """Test that 'apropos' command should also search descriptions for the settings variables."""
  20
  21         self.expect(
  22             "apropos 'environment variable'",
  23             substrs=[
  24                 "target.env-vars",
  25                 "environment variables",
  26                 "executable's environment",
  27             ],
  28         )
  29
  30     def test_set_interpreter_repeat_prev_command(self):
  31         """Test the `interpreter.repeat-previous-command` setting."""
  32         self.build()
  33
  34         exe = self.getBuildArtifact("a.out")
  35         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
  36         setting = "interpreter.repeat-previous-command"
  37
  38         def cleanup(setting):
  39             self.runCmd("settings clear %s" % setting, check=False)
  40
  41         # Execute the cleanup function during test case tear down.
  42         self.addTearDownHook(cleanup(setting))
  43
  44         # First, check for the setting default value.
  45         self.expect(
  46             "setting show %s" % setting,
  47             substrs=["interpreter.repeat-previous-command (boolean) = true"],
  48         )
  49
  50         # Then, invert the setting, and check that was set correctly
  51         self.runCmd("setting set %s false" % setting)
  52         self.expect(
  53             "setting show %s" % setting,
  54             substrs=["interpreter.repeat-previous-command (boolean) = false"],
  55         )
  56
  57         ci = self.dbg.GetCommandInterpreter()
  58         self.assertTrue(ci.IsValid(), "Invalid command interpreter.")
  59         # Now, test the functionnality
  60         res = lldb.SBCommandReturnObject()
  61         ci.HandleCommand("breakpoint set -n main", res)
  62         self.assertTrue(res.Succeeded(), "Command failed.")
  63         ci.HandleCommand("", res)
  64         self.assertTrue(res.Succeeded(), "Empty command failed.")
  65         self.assertEqual(self.dbg.GetSelectedTarget().GetNumBreakpoints(), 1)
  66
  67     def test_append_target_env_vars(self):
  68         """Test that 'append target.env-vars' works."""
  69         # Append the env-vars.
  70         self.runCmd("settings append target.env-vars MY_ENV_VAR=YES")
  71         # And add hooks to restore the settings during tearDown().
  72         self.addTearDownHook(lambda: self.runCmd("settings clear target.env-vars"))
  73
  74         # Check it immediately!
  75         self.expect("settings show target.env-vars", substrs=["MY_ENV_VAR=YES"])
  76
  77     def test_insert_before_and_after_target_run_args(self):
  78         """Test that 'insert-before/after target.run-args' works."""
  79         # Set the run-args first.
  80         self.runCmd("settings set target.run-args a b c")
  81         # And add hooks to restore the settings during tearDown().
  82         self.addTearDownHook(lambda: self.runCmd("settings clear target.run-args"))
  83
  84         # Now insert-before the index-0 element with '__a__'.
  85         self.runCmd("settings insert-before target.run-args 0 __a__")
  86         # And insert-after the index-1 element with '__A__'.
  87         self.runCmd("settings insert-after target.run-args 1 __A__")
  88         # Check it immediately!
  89         self.expect(
  90             "settings show target.run-args",
  91             substrs=[
  92                 "target.run-args",
  93                 '[0]: "__a__"',
  94                 '[1]: "a"',
  95                 '[2]: "__A__"',
  96                 '[3]: "b"',
  97                 '[4]: "c"',
  98             ],
  99         )
 100
 101     def test_replace_target_run_args(self):
 102         """Test that 'replace target.run-args' works."""
 103         # Set the run-args and then replace the index-0 element.
 104         self.runCmd("settings set target.run-args a b c")
 105         # And add hooks to restore the settings during tearDown().
 106         self.addTearDownHook(lambda: self.runCmd("settings clear target.run-args"))
 107
 108         # Now replace the index-0 element with 'A', instead.
 109         self.runCmd("settings replace target.run-args 0 A")
 110         # Check it immediately!
 111         self.expect(
 112             "settings show target.run-args",
 113             substrs=[
 114                 "target.run-args (arguments) =",
 115                 '[0]: "A"',
 116                 '[1]: "b"',
 117                 '[2]: "c"',
 118             ],
 119         )
 120
 121     def test_set_prompt(self):
 122         """Test that 'set prompt' actually changes the prompt."""
 123
 124         # Set prompt to 'lldb2'.
 125         self.runCmd("settings set prompt 'lldb2 '")
 126
 127         # Immediately test the setting.
 128         self.expect(
 129             "settings show prompt",
 130             SETTING_MSG("prompt"),
 131             startstr='prompt (string) = "lldb2 "',
 132         )
 133
 134         # The overall display should also reflect the new setting.
 135         self.expect(
 136             "settings show",
 137             SETTING_MSG("prompt"),
 138             substrs=['prompt (string) = "lldb2 "'],
 139         )
 140
 141         # Use '-r' option to reset to the original default prompt.
 142         self.runCmd("settings clear prompt")
 143
 144     def test_set_term_width(self):
 145         """Test that 'set term-width' actually changes the term-width."""
 146
 147         self.runCmd("settings set term-width 70")
 148
 149         # Immediately test the setting.
 150         self.expect(
 151             "settings show term-width",
 152             SETTING_MSG("term-width"),
 153             startstr="term-width (unsigned) = 70",
 154         )
 155
 156         # The overall display should also reflect the new setting.
 157         self.expect(
 158             "settings show",
 159             SETTING_MSG("term-width"),
 160             substrs=["term-width (unsigned) = 70"],
 161         )
 162
 163         self.dbg.SetTerminalWidth(60)
 164
 165         self.expect(
 166             "settings show",
 167             SETTING_MSG("term-width"),
 168             substrs=["term-width (unsigned) = 60"],
 169         )
 170
 171     # rdar://problem/10712130
 172     @skipIf(oslist=["windows"], bugnumber="llvm.org/pr44431")
 173     def test_set_frame_format(self):
 174         """Test that 'set frame-format' with a backtick char in the format string works as well as fullpath."""
 175         self.build()
 176
 177         exe = self.getBuildArtifact("a.out")
 178         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 179
 180         def cleanup():
 181             self.runCmd(
 182                 "settings set frame-format %s" % self.format_string, check=False
 183             )
 184
 185         # Execute the cleanup function during test case tear down.
 186         self.addTearDownHook(cleanup)
 187
 188         self.runCmd("settings show frame-format")
 189         m = re.match('^frame-format \(format-string\) = "(.*)"$', self.res.GetOutput())
 190         self.assertTrue(m, "Bad settings string")
 191         self.format_string = m.group(1)
 192
 193         # Change the default format to print function.name rather than
 194         # function.name-with-args
 195         format_string = "frame #${frame.index}: ${frame.pc}{ ${module.file.basename}\`${function.name}{${function.pc-offset}}}{ at ${line.file.fullpath}:${line.number}}{, lang=${language}}\n"
 196         self.runCmd("settings set frame-format %s" % format_string)
 197
 198         # Immediately test the setting.
 199         self.expect(
 200             "settings show frame-format",
 201             SETTING_MSG("frame-format"),
 202             substrs=[format_string],
 203         )
 204
 205         self.runCmd("breakpoint set -n main")
 206         self.runCmd(
 207             "process launch --working-dir '{0}'".format(
 208                 self.get_process_working_directory()
 209             ),
 210             RUN_SUCCEEDED,
 211         )
 212         self.expect("thread backtrace", substrs=["`main", self.getSourceDir()])
 213
 214     def test_set_auto_confirm(self):
 215         """Test that after 'set auto-confirm true', manual confirmation should not kick in."""
 216         self.build()
 217
 218         exe = self.getBuildArtifact("a.out")
 219         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 220
 221         self.runCmd("settings set auto-confirm true")
 222
 223         # Immediately test the setting.
 224         self.expect(
 225             "settings show auto-confirm",
 226             SETTING_MSG("auto-confirm"),
 227             startstr="auto-confirm (boolean) = true",
 228         )
 229
 230         # Now 'breakpoint delete' should just work fine without confirmation
 231         # prompt from the command interpreter.
 232         self.runCmd("breakpoint set -n main")
 233         self.expect("breakpoint delete", startstr="All breakpoints removed")
 234
 235         # Restore the original setting of auto-confirm.
 236         self.runCmd("settings clear auto-confirm")
 237         self.expect(
 238             "settings show auto-confirm",
 239             SETTING_MSG("auto-confirm"),
 240             startstr="auto-confirm (boolean) = false",
 241         )
 242
 243     @skipIf(archs=no_match(["x86_64", "i386", "i686"]))
 244     def test_disassembler_settings(self):
 245         """Test that user options for the disassembler take effect."""
 246         self.build()
 247
 248         exe = self.getBuildArtifact("a.out")
 249         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 250
 251         # AT&T syntax
 252         self.runCmd("settings set target.x86-disassembly-flavor att")
 253         self.runCmd("settings set target.use-hex-immediates false")
 254         self.expect("disassemble -n numberfn", substrs=["$90"])
 255         self.runCmd("settings set target.use-hex-immediates true")
 256         self.runCmd("settings set target.hex-immediate-style c")
 257         self.expect("disassemble -n numberfn", substrs=["$0x5a"])
 258         self.runCmd("settings set target.hex-immediate-style asm")
 259         self.expect("disassemble -n numberfn", substrs=["$5ah"])
 260
 261         # Intel syntax
 262         self.runCmd("settings set target.x86-disassembly-flavor intel")
 263         self.runCmd("settings set target.use-hex-immediates false")
 264         self.expect("disassemble -n numberfn", substrs=["90"])
 265         self.runCmd("settings set target.use-hex-immediates true")
 266         self.runCmd("settings set target.hex-immediate-style c")
 267         self.expect("disassemble -n numberfn", substrs=["0x5a"])
 268         self.runCmd("settings set target.hex-immediate-style asm")
 269         self.expect("disassemble -n numberfn", substrs=["5ah"])
 270
 271     @skipIfDarwinEmbedded  # <rdar://problem/34446098> debugserver on ios etc can't write files
 272     def test_run_args_and_env_vars(self):
 273         self.do_test_run_args_and_env_vars(use_launchsimple=False)
 274
 275     @skipIfDarwinEmbedded  # <rdar://problem/34446098> debugserver on ios etc can't write files
 276     def test_launchsimple_args_and_env_vars(self):
 277         self.do_test_run_args_and_env_vars(use_launchsimple=True)
 278
 279     def do_test_run_args_and_env_vars(self, use_launchsimple):
 280         """Test that run-args and env-vars are passed to the launched process."""
 281         self.build()
 282
 283         # Set the run-args and the env-vars.
 284         # And add hooks to restore the settings during tearDown().
 285         self.runCmd("settings set target.run-args A B C")
 286         self.addTearDownHook(lambda: self.runCmd("settings clear target.run-args"))
 287         self.runCmd('settings set target.env-vars ["MY_ENV_VAR"]=YES')
 288         self.addTearDownHook(lambda: self.runCmd("settings clear target.env-vars"))
 289
 290         exe = self.getBuildArtifact("a.out")
 291         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 292
 293         target = self.dbg.GetTargetAtIndex(0)
 294         launch_info = target.GetLaunchInfo()
 295         found_env_var = False
 296         for i in range(0, launch_info.GetNumEnvironmentEntries()):
 297             if launch_info.GetEnvironmentEntryAtIndex(i) == "MY_ENV_VAR=YES":
 298                 found_env_var = True
 299                 break
 300         self.assertTrue(found_env_var, "MY_ENV_VAR was not set in LaunchInfo object")
 301
 302         self.assertEqual(launch_info.GetNumArguments(), 3)
 303         self.assertEqual(launch_info.GetArgumentAtIndex(0), "A")
 304         self.assertEqual(launch_info.GetArgumentAtIndex(1), "B")
 305         self.assertEqual(launch_info.GetArgumentAtIndex(2), "C")
 306
 307         self.expect("target show-launch-environment", substrs=["MY_ENV_VAR=YES"])
 308
 309         wd = self.get_process_working_directory()
 310         if use_launchsimple:
 311             process = target.LaunchSimple(None, None, wd)
 312             self.assertTrue(process)
 313         else:
 314             self.runCmd("process launch --working-dir '{0}'".format(wd), RUN_SUCCEEDED)
 315
 316         # Read the output file produced by running the program.
 317         output = lldbutil.read_file_from_process_wd(self, "output2.txt")
 318
 319         self.expect(
 320             output,
 321             exe=False,
 322             substrs=[
 323                 "argv[1] matches",
 324                 "argv[2] matches",
 325                 "argv[3] matches",
 326                 "Environment variable 'MY_ENV_VAR' successfully passed.",
 327             ],
 328         )
 329
 330         # Check that env-vars overrides unset-env-vars.
 331         self.runCmd("settings set target.unset-env-vars MY_ENV_VAR")
 332
 333         self.expect(
 334             "target show-launch-environment",
 335             "env-vars overrides unset-env-vars",
 336             substrs=["MY_ENV_VAR=YES"],
 337         )
 338
 339         wd = self.get_process_working_directory()
 340         if use_launchsimple:
 341             process = target.LaunchSimple(None, None, wd)
 342             self.assertTrue(process)
 343         else:
 344             self.runCmd("process launch --working-dir '{0}'".format(wd), RUN_SUCCEEDED)
 345
 346         # Read the output file produced by running the program.
 347         output = lldbutil.read_file_from_process_wd(self, "output2.txt")
 348
 349         self.expect(
 350             output,
 351             exe=False,
 352             substrs=["Environment variable 'MY_ENV_VAR' successfully passed."],
 353         )
 354
 355     @skipIfRemote  # it doesn't make sense to send host env to remote target
 356     def test_pass_host_env_vars(self):
 357         """Test that the host env vars are passed to the launched process."""
 358         self.build()
 359
 360         # Set some host environment variables now.
 361         os.environ["MY_HOST_ENV_VAR1"] = "VAR1"
 362         os.environ["MY_HOST_ENV_VAR2"] = "VAR2"
 363
 364         # This is the function to unset the two env variables set above.
 365         def unset_env_variables():
 366             os.environ.pop("MY_HOST_ENV_VAR1")
 367             os.environ.pop("MY_HOST_ENV_VAR2")
 368
 369         self.addTearDownHook(unset_env_variables)
 370
 371         exe = self.getBuildArtifact("a.out")
 372         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 373
 374         # By default, inherit-env is 'true'.
 375         self.expect(
 376             "settings show target.inherit-env",
 377             "Default inherit-env is 'true'",
 378             startstr="target.inherit-env (boolean) = true",
 379         )
 380
 381         self.expect(
 382             "target show-launch-environment",
 383             "Host environment is passed correctly",
 384             substrs=["MY_HOST_ENV_VAR1=VAR1", "MY_HOST_ENV_VAR2=VAR2"],
 385         )
 386         self.runCmd(
 387             "process launch --working-dir '{0}'".format(
 388                 self.get_process_working_directory()
 389             ),
 390             RUN_SUCCEEDED,
 391         )
 392
 393         # Read the output file produced by running the program.
 394         output = lldbutil.read_file_from_process_wd(self, "output1.txt")
 395
 396         self.expect(
 397             output,
 398             exe=False,
 399             substrs=[
 400                 "The host environment variable 'MY_HOST_ENV_VAR1' successfully passed.",
 401                 "The host environment variable 'MY_HOST_ENV_VAR2' successfully passed.",
 402             ],
 403         )
 404
 405         # Now test that we can prevent the inferior from inheriting the
 406         # environment.
 407         self.runCmd("settings set target.inherit-env false")
 408
 409         self.expect(
 410             "target show-launch-environment",
 411             "target.inherit-env affects `target show-launch-environment`",
 412             matching=False,
 413             substrs=["MY_HOST_ENV_VAR1=VAR1", "MY_HOST_ENV_VAR2=VAR2"],
 414         )
 415
 416         self.runCmd(
 417             "process launch --working-dir '{0}'".format(
 418                 self.get_process_working_directory()
 419             ),
 420             RUN_SUCCEEDED,
 421         )
 422
 423         # Read the output file produced by running the program.
 424         output = lldbutil.read_file_from_process_wd(self, "output1.txt")
 425
 426         self.expect(
 427             output,
 428             exe=False,
 429             matching=False,
 430             substrs=[
 431                 "The host environment variable 'MY_HOST_ENV_VAR1' successfully passed.",
 432                 "The host environment variable 'MY_HOST_ENV_VAR2' successfully passed.",
 433             ],
 434         )
 435
 436         # Now test that we can unset variables from the inherited environment.
 437         self.runCmd("settings set target.inherit-env true")
 438         self.runCmd("settings set target.unset-env-vars MY_HOST_ENV_VAR1")
 439         self.runCmd(
 440             "process launch --working-dir '{0}'".format(
 441                 self.get_process_working_directory()
 442             ),
 443             RUN_SUCCEEDED,
 444         )
 445
 446         # Read the output file produced by running the program.
 447         output = lldbutil.read_file_from_process_wd(self, "output1.txt")
 448
 449         self.expect(
 450             "target show-launch-environment",
 451             "MY_HOST_ENV_VAR1 is unset, it shouldn't be in `target show-launch-environment`",
 452             matching=False,
 453             substrs=["MY_HOST_ENV_VAR1=VAR1"],
 454         )
 455         self.expect(
 456             "target show-launch-environment",
 457             "MY_HOST_ENV_VAR2 shouldn be in `target show-launch-environment`",
 458             substrs=["MY_HOST_ENV_VAR2=VAR2"],
 459         )
 460
 461         self.expect(
 462             output,
 463             exe=False,
 464             matching=False,
 465             substrs=[
 466                 "The host environment variable 'MY_HOST_ENV_VAR1' successfully passed."
 467             ],
 468         )
 469         self.expect(
 470             output,
 471             exe=False,
 472             substrs=[
 473                 "The host environment variable 'MY_HOST_ENV_VAR2' successfully passed."
 474             ],
 475         )
 476
 477     @skipIfDarwinEmbedded  # <rdar://problem/34446098> debugserver on ios etc can't write files
 478     def test_set_error_output_path(self):
 479         """Test that setting target.error/output-path for the launched process works."""
 480         self.build()
 481
 482         exe = self.getBuildArtifact("a.out")
 483         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 484
 485         # Set the error-path and output-path and verify both are set.
 486         self.runCmd(
 487             "settings set target.error-path '{0}'".format(
 488                 lldbutil.append_to_process_working_directory(self, "stderr.txt")
 489             )
 490         )
 491         self.runCmd(
 492             "settings set target.output-path '{0}".format(
 493                 lldbutil.append_to_process_working_directory(self, "stdout.txt")
 494             )
 495         )
 496         # And add hooks to restore the original settings during tearDown().
 497         self.addTearDownHook(lambda: self.runCmd("settings clear target.output-path"))
 498         self.addTearDownHook(lambda: self.runCmd("settings clear target.error-path"))
 499
 500         self.expect(
 501             "settings show target.error-path",
 502             SETTING_MSG("target.error-path"),
 503             substrs=["target.error-path (file)", 'stderr.txt"'],
 504         )
 505
 506         self.expect(
 507             "settings show target.output-path",
 508             SETTING_MSG("target.output-path"),
 509             substrs=["target.output-path (file)", 'stdout.txt"'],
 510         )
 511
 512         self.runCmd(
 513             "process launch --working-dir '{0}'".format(
 514                 self.get_process_working_directory()
 515             ),
 516             RUN_SUCCEEDED,
 517         )
 518
 519         output = lldbutil.read_file_from_process_wd(self, "stderr.txt")
 520         message = "This message should go to standard error."
 521         if lldbplatformutil.hasChattyStderr(self):
 522             self.expect(output, exe=False, substrs=[message])
 523         else:
 524             self.expect(output, exe=False, startstr=message)
 525
 526         output = lldbutil.read_file_from_process_wd(self, "stdout.txt")
 527         self.expect(
 528             output, exe=False, startstr="This message should go to standard out."
 529         )
 530
 531     @skipIfDarwinEmbedded  # <rdar://problem/34446098> debugserver on ios etc can't write files
 532     def test_same_error_output_path(self):
 533         """Test that setting target.error and output-path to the same file path for the launched process works."""
 534         self.build()
 535
 536         exe = self.getBuildArtifact("a.out")
 537         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 538
 539         # Set the error-path and output-path and verify both are set.
 540         self.runCmd(
 541             "settings set target.error-path '{0}'".format(
 542                 lldbutil.append_to_process_working_directory(self, "output.txt")
 543             )
 544         )
 545         self.runCmd(
 546             "settings set target.output-path '{0}".format(
 547                 lldbutil.append_to_process_working_directory(self, "output.txt")
 548             )
 549         )
 550         # And add hooks to restore the original settings during tearDown().
 551         self.addTearDownHook(lambda: self.runCmd("settings clear target.output-path"))
 552         self.addTearDownHook(lambda: self.runCmd("settings clear target.error-path"))
 553
 554         self.expect(
 555             "settings show target.error-path",
 556             SETTING_MSG("target.error-path"),
 557             substrs=["target.error-path (file)", 'output.txt"'],
 558         )
 559
 560         self.expect(
 561             "settings show target.output-path",
 562             SETTING_MSG("target.output-path"),
 563             substrs=["target.output-path (file)", 'output.txt"'],
 564         )
 565
 566         self.runCmd(
 567             "process launch --working-dir '{0}'".format(
 568                 self.get_process_working_directory()
 569             ),
 570             RUN_SUCCEEDED,
 571         )
 572
 573         output = lldbutil.read_file_from_process_wd(self, "output.txt")
 574         err_message = "This message should go to standard error."
 575         out_message = "This message should go to standard out."
 576         # Error msg should get flushed by the output msg
 577         self.expect(output, exe=False, substrs=[out_message])
 578         self.assertNotIn(
 579             err_message,
 580             output,
 581             "Race condition when both stderr/stdout redirects to the same file",
 582         )
 583
 584     def test_print_dictionary_setting(self):
 585         self.runCmd("settings clear target.env-vars")
 586         self.runCmd('settings set target.env-vars ["MY_VAR"]=some-value')
 587         self.expect("settings show target.env-vars", substrs=["MY_VAR=some-value"])
 588         self.runCmd("settings clear target.env-vars")
 589
 590     def test_print_array_setting(self):
 591         self.runCmd("settings clear target.run-args")
 592         self.runCmd("settings set target.run-args gobbledy-gook")
 593         self.expect("settings show target.run-args", substrs=['[0]: "gobbledy-gook"'])
 594         self.runCmd("settings clear target.run-args")
 595
 596     def test_settings_with_quotes(self):
 597         self.runCmd("settings clear target.run-args")
 598         self.runCmd("settings set target.run-args a b c")
 599         self.expect(
 600             "settings show target.run-args",
 601             substrs=['[0]: "a"', '[1]: "b"', '[2]: "c"'],
 602         )
 603         self.runCmd("settings set target.run-args 'a b c'")
 604         self.expect("settings show target.run-args", substrs=['[0]: "a b c"'])
 605         self.runCmd("settings clear target.run-args")
 606         self.runCmd("settings clear target.env-vars")
 607         self.runCmd(
 608             'settings set target.env-vars ["MY_FILE"]="this is a file name with spaces.txt"'
 609         )
 610         self.expect(
 611             "settings show target.env-vars",
 612             substrs=["MY_FILE=this is a file name with spaces.txt"],
 613         )
 614         self.runCmd("settings clear target.env-vars")
 615         # Test and make sure that setting "format-string" settings obeys quotes
 616         # if they are provided
 617         self.runCmd("settings set thread-format    'abc def'   ")
 618         self.expect(
 619             "settings show thread-format",
 620             startstr='thread-format (format-string) = "abc def"',
 621         )
 622         self.runCmd('settings set thread-format    "abc def"   ')
 623         self.expect(
 624             "settings show thread-format",
 625             startstr='thread-format (format-string) = "abc def"',
 626         )
 627         # Make sure when no quotes are provided that we maintain any trailing
 628         # spaces
 629         self.runCmd("settings set thread-format abc def   ")
 630         self.expect(
 631             "settings show thread-format",
 632             startstr='thread-format (format-string) = "abc def   "',
 633         )
 634         self.runCmd("settings clear thread-format")
 635
 636     def test_settings_with_trailing_whitespace(self):
 637         # boolean
 638         # Set to known value
 639         self.runCmd("settings set target.skip-prologue true")
 640         # Set to new value with trailing whitespace
 641         self.runCmd("settings set target.skip-prologue false ")
 642         # Make sure the setting was correctly set to "false"
 643         self.expect(
 644             "settings show target.skip-prologue",
 645             SETTING_MSG("target.skip-prologue"),
 646             startstr="target.skip-prologue (boolean) = false",
 647         )
 648         self.runCmd("settings clear target.skip-prologue", check=False)
 649         # integer
 650         self.runCmd("settings set term-width 70")  # Set to known value
 651         # Set to new value with trailing whitespaces
 652         self.runCmd("settings set term-width 60 \t")
 653         self.expect(
 654             "settings show term-width",
 655             SETTING_MSG("term-width"),
 656             startstr="term-width (unsigned) = 60",
 657         )
 658         self.runCmd("settings clear term-width", check=False)
 659         # string
 660         self.runCmd("settings set target.arg0 abc")  # Set to known value
 661         # Set to new value with trailing whitespaces
 662         self.runCmd("settings set target.arg0 cde\t ")
 663         self.expect(
 664             "settings show target.arg0",
 665             SETTING_MSG("target.arg0"),
 666             startstr='target.arg0 (string) = "cde"',
 667         )
 668         self.runCmd("settings clear target.arg0", check=False)
 669         # file
 670         path1 = self.getBuildArtifact("path1.txt")
 671         path2 = self.getBuildArtifact("path2.txt")
 672         self.runCmd("settings set target.output-path %s" % path1)  # Set to known value
 673         self.expect(
 674             "settings show target.output-path",
 675             SETTING_MSG("target.output-path"),
 676             startstr="target.output-path (file) = ",
 677             substrs=[path1],
 678         )
 679         self.runCmd(
 680             "settings set target.output-path %s " % path2
 681         )  # Set to new value with trailing whitespaces
 682         self.expect(
 683             "settings show target.output-path",
 684             SETTING_MSG("target.output-path"),
 685             startstr="target.output-path (file) = ",
 686             substrs=[path2],
 687         )
 688         self.runCmd("settings clear target.output-path", check=False)
 689         # enum
 690         # Set to known value
 691         self.runCmd("settings set stop-disassembly-display never")
 692         # Set to new value with trailing whitespaces
 693         self.runCmd("settings set stop-disassembly-display always ")
 694         self.expect(
 695             "settings show stop-disassembly-display",
 696             SETTING_MSG("stop-disassembly-display"),
 697             startstr="stop-disassembly-display (enum) = always",
 698         )
 699         self.runCmd("settings clear stop-disassembly-display", check=False)
 700         # language
 701         # Set to known value
 702         self.runCmd("settings set target.language c89")
 703         # Set to new value with trailing whitespace
 704         self.runCmd("settings set target.language c11 ")
 705         self.expect(
 706             "settings show target.language",
 707             SETTING_MSG("target.language"),
 708             startstr="target.language (language) = c11",
 709         )
 710         self.runCmd("settings clear target.language", check=False)
 711         # arguments
 712         self.runCmd("settings set target.run-args 1 2 3")  # Set to known value
 713         # Set to new value with trailing whitespaces
 714         self.runCmd("settings set target.run-args 3 4 5 ")
 715         self.expect(
 716             "settings show target.run-args",
 717             SETTING_MSG("target.run-args"),
 718             substrs=[
 719                 "target.run-args (arguments) =",
 720                 '[0]: "3"',
 721                 '[1]: "4"',
 722                 '[2]: "5"',
 723             ],
 724         )
 725         self.runCmd("settings set target.run-args 1 2 3")  # Set to known value
 726         # Set to new value with trailing whitespaces
 727         self.runCmd("settings set target.run-args 3 \  \ ")
 728         self.expect(
 729             "settings show target.run-args",
 730             SETTING_MSG("target.run-args"),
 731             substrs=[
 732                 "target.run-args (arguments) =",
 733                 '[0]: "3"',
 734                 '[1]: " "',
 735                 '[2]: " "',
 736             ],
 737         )
 738         self.runCmd("settings clear target.run-args", check=False)
 739         # dictionaries
 740         self.runCmd("settings clear target.env-vars")  # Set to known value
 741         # Set to new value with trailing whitespaces
 742         self.runCmd("settings set target.env-vars A=B C=D\t ")
 743         self.expect(
 744             "settings show target.env-vars",
 745             SETTING_MSG("target.env-vars"),
 746             substrs=["target.env-vars (dictionary of strings) =", "A=B", "C=D"],
 747         )
 748         self.runCmd("settings clear target.env-vars", check=False)
 749         # regex
 750         # Set to known value
 751         self.runCmd("settings clear target.process.thread.step-avoid-regexp")
 752         # Set to new value with trailing whitespaces
 753         self.runCmd("settings set target.process.thread.step-avoid-regexp foo\\ ")
 754         self.expect(
 755             "settings show target.process.thread.step-avoid-regexp",
 756             SETTING_MSG("target.process.thread.step-avoid-regexp"),
 757             substrs=["target.process.thread.step-avoid-regexp (regex) = foo\\ "],
 758         )
 759         self.runCmd(
 760             "settings clear target.process.thread.step-avoid-regexp", check=False
 761         )
 762         # format-string
 763         self.runCmd("settings clear disassembly-format")  # Set to known value
 764         # Set to new value with trailing whitespaces
 765         self.runCmd("settings set disassembly-format foo ")
 766         self.expect(
 767             "settings show disassembly-format",
 768             SETTING_MSG("disassembly-format"),
 769             substrs=['disassembly-format (format-string) = "foo "'],
 770         )
 771         self.runCmd("settings clear disassembly-format", check=False)
 772
 773     def test_settings_list(self):
 774         # List settings (and optionally test the filter to only show 'target' settings).
 775         self.expect(
 776             "settings list target", substrs=["arg0", "detach-on-error", "language"]
 777         )
 778         self.expect("settings list target", matching=False, substrs=["packet-timeout"])
 779         self.expect(
 780             "settings list",
 781             substrs=["language", "arg0", "detach-on-error", "packet-timeout"],
 782         )
 783
 784     def test_settings_remove_single(self):
 785         # Set some environment variables and use 'remove' to delete them.
 786         self.runCmd("settings set target.env-vars a=b c=d")
 787         self.expect("settings show target.env-vars", substrs=["a=b", "c=d"])
 788         self.runCmd("settings remove target.env-vars a")
 789         self.expect("settings show target.env-vars", matching=False, substrs=["a=b"])
 790         self.expect("settings show target.env-vars", substrs=["c=d"])
 791         self.runCmd("settings remove target.env-vars c")
 792         self.expect(
 793             "settings show target.env-vars", matching=False, substrs=["a=b", "c=d"]
 794         )
 795
 796     def test_settings_remove_multiple(self):
 797         self.runCmd("settings set target.env-vars a=b c=d e=f")
 798         self.expect("settings show target.env-vars", substrs=["a=b", "c=d", "e=f"])
 799         self.runCmd("settings remove target.env-vars a e")
 800         self.expect(
 801             "settings show target.env-vars", matching=False, substrs=["a=b", "e=f"]
 802         )
 803         self.expect("settings show target.env-vars", substrs=["c=d"])
 804
 805     def test_settings_remove_nonexistent_value(self):
 806         self.expect(
 807             "settings remove target.env-vars doesntexist",
 808             error=True,
 809             substrs=["no value found named 'doesntexist'"],
 810         )
 811
 812     def test_settings_remove_nonexistent_settings(self):
 813         self.expect(
 814             "settings remove doesntexist alsodoesntexist",
 815             error=True,
 816             substrs=["error: invalid value path 'doesntexist'"],
 817         )
 818
 819     def test_settings_remove_missing_arg(self):
 820         self.expect(
 821             "settings remove",
 822             error=True,
 823             substrs=["'settings remove' takes an array or dictionary item, or"],
 824         )
 825
 826     def test_settings_remove_empty_arg(self):
 827         self.expect(
 828             "settings remove ''",
 829             error=True,
 830             substrs=["'settings remove' command requires a valid variable name"],
 831         )
 832
 833     def test_settings_clear_all(self):
 834         # Change a dictionary.
 835         self.runCmd("settings set target.env-vars a=1 b=2 c=3")
 836         # Change an array.
 837         self.runCmd("settings set target.run-args a1 b2 c3")
 838         # Change a single boolean value.
 839         self.runCmd("settings set auto-confirm true")
 840         # Change a single integer value.
 841         self.runCmd("settings set tab-size 4")
 842
 843         # Clear everything.
 844         self.runCmd("settings clear --all")
 845
 846         # Check that settings have their default values after clearing.
 847         self.expect(
 848             "settings show target.env-vars",
 849             patterns=["^target.env-vars \(dictionary of strings\) =\s*$"],
 850         )
 851         self.expect(
 852             "settings show target.run-args",
 853             patterns=["^target.run-args \(arguments\) =\s*$"],
 854         )
 855         self.expect("settings show auto-confirm", substrs=["false"])
 856         self.expect("settings show tab-size", substrs=["2"])
 857
 858         # Check that the command fails if we combine '--all' option with any arguments.
 859         self.expect(
 860             "settings clear --all auto-confirm",
 861             COMMAND_FAILED_AS_EXPECTED,
 862             error=True,
 863             substrs=["'settings clear --all' doesn't take any arguments"],
 864         )
 865
 866     def test_all_settings_exist(self):
 867         self.expect(
 868             "settings show",
 869             substrs=[
 870                 "auto-confirm",
 871                 "frame-format",
 872                 "notify-void",
 873                 "prompt",
 874                 "script-lang",
 875                 "stop-disassembly-count",
 876                 "stop-disassembly-display",
 877                 "stop-line-count-after",
 878                 "stop-line-count-before",
 879                 "stop-show-column",
 880                 "term-width",
 881                 "thread-format",
 882                 "use-external-editor",
 883                 "target.breakpoints-use-platform-avoid-list",
 884                 "target.default-arch",
 885                 "target.disable-aslr",
 886                 "target.disable-stdio",
 887                 "target.x86-disassembly-flavor",
 888                 "target.enable-synthetic-value",
 889                 "target.env-vars",
 890                 "target.error-path",
 891                 "target.exec-search-paths",
 892                 "target.expr-prefix",
 893                 "target.hex-immediate-style",
 894                 "target.inherit-env",
 895                 "target.input-path",
 896                 "target.language",
 897                 "target.max-children-count",
 898                 "target.max-string-summary-length",
 899                 "target.move-to-nearest-code",
 900                 "target.output-path",
 901                 "target.prefer-dynamic-value",
 902                 "target.run-args",
 903                 "target.skip-prologue",
 904                 "target.source-map",
 905                 "target.use-hex-immediates",
 906                 "target.process.disable-memory-cache",
 907                 "target.process.extra-startup-command",
 908                 "target.process.thread.trace-thread",
 909                 "target.process.thread.step-avoid-regexp",
 910             ],
 911         )
 912
 913     # settings under an ".experimental" domain should have two properties:
 914     #   1. If the name does not exist with "experimental" in the name path,
 915     #      the name lookup should try to find it without "experimental".  So
 916     #      a previously-experimental setting that has been promoted to a
 917     #      "real" setting will still be set by the original name.
 918     #   2. Changing a setting with .experimental., name, where the setting
 919     #      does not exist either with ".experimental." or without, should
 920     #      not generate an error.  So if an experimental setting is removed,
 921     #      people who may have that in their ~/.lldbinit files should not see
 922     #      any errors.
 923     def test_experimental_settings(self):
 924         cmdinterp = self.dbg.GetCommandInterpreter()
 925         result = lldb.SBCommandReturnObject()
 926
 927         # Set target.arg0 to a known value, check that we can retrieve it via
 928         # the actual name and via .experimental.
 929         self.expect("settings set target.arg0 first-value")
 930         self.expect("settings show target.arg0", substrs=["first-value"])
 931         self.expect(
 932             "settings show target.experimental.arg0",
 933             substrs=["first-value"],
 934             error=False,
 935         )
 936
 937         # Set target.arg0 to a new value via a target.experimental.arg0 name,
 938         # verify that we can read it back via both .experimental., and not.
 939         self.expect("settings set target.experimental.arg0 second-value", error=False)
 940         self.expect("settings show target.arg0", substrs=["second-value"])
 941         self.expect(
 942             "settings show target.experimental.arg0",
 943             substrs=["second-value"],
 944             error=False,
 945         )
 946
 947         # showing & setting an undefined .experimental. setting should generate no errors.
 948         self.expect(
 949             "settings show target.experimental.setting-which-does-not-exist",
 950             patterns=["^\s$"],
 951             error=False,
 952         )
 953         self.expect(
 954             "settings set target.experimental.setting-which-does-not-exist true",
 955             error=False,
 956         )
 957
 958         # A domain component before .experimental. which does not exist should give an error
 959         # But the code does not yet do that.
 960         # self.expect('settings set target.setting-which-does-not-exist.experimental.arg0 true', error=True)
 961
 962         # finally, confirm that trying to set a setting that does not exist still fails.
 963         # (SHOWING a setting that does not exist does not currently yield an error.)
 964         self.expect("settings set target.setting-which-does-not-exist true", error=True)
 965
 966     def test_settings_set_exists(self):
 967         cmdinterp = self.dbg.GetCommandInterpreter()
 968
 969         # An unknown option should succeed.
 970         self.expect("settings set -e foo bar")
 971         self.expect("settings set --exists foo bar")
 972
 973         # A known option should fail if its argument is invalid.
 974         self.expect("settings set auto-confirm bogus", error=True)
 975
 976     def get_setting_json(self, setting_path=None):
 977         settings_data = self.dbg.GetSetting(setting_path)
 978         stream = lldb.SBStream()
 979         settings_data.GetAsJSON(stream)
 980         return json.loads(stream.GetData())
 981
 982     def verify_setting_value_json(self, setting_path, setting_value):
 983         self.runCmd("settings set %s %s" % (setting_path, setting_value))
 984         settings_json = self.get_setting_json(setting_path)
 985         self.assertEqual(settings_json, setting_value)
 986
 987     def test_settings_api(self):
 988         """
 989         Test that ensures SBDebugger::GetSetting() APIs
 990         can correctly fetch settings.
 991         """
 992
 993         # Test basic values and embedding special JSON escaping characters.
 994         self.runCmd("settings set auto-confirm true")
 995         self.runCmd("settings set tab-size 4")
 996         arg_value = 'hello "world"'
 997         self.runCmd("settings set target.arg0 %s" % arg_value)
 998
 999         settings_json = self.get_setting_json()
1000         self.assertEqual(settings_json["auto-confirm"], True)
1001         self.assertEqual(settings_json["tab-size"], 4)
1002         self.assertEqual(settings_json["target"]["arg0"], arg_value)
1003
1004         settings_data = self.get_setting_json("target.arg0")
1005         self.assertEqual(settings_data, arg_value)
1006
1007         # Test OptionValueFileSpec
1008         self.verify_setting_value_json(
1009             "platform.module-cache-directory", self.getBuildDir()
1010         )
1011
1012         # Test OptionValueArray
1013         setting_path = "target.run-args"
1014         setting_value = ["value1", "value2", "value3"]
1015         self.runCmd("settings set %s %s" % (setting_path, " ".join(setting_value)))
1016         settings_json = self.get_setting_json(setting_path)
1017         self.assertEqual(settings_json, setting_value)
1018
1019         # Test OptionValueFormatEntity
1020         setting_value = """thread #${thread.index}{, name = \\'${thread.name}\\
1021         '}{, queue = ${ansi.fg.green}\\'${thread.queue}\\'${ansi.normal}}{,
1022         activity = ${ansi.fg.green}\\'${thread.info.activity.name}\\'${ansi.normal}}
1023         {, ${thread.info.trace_messages} messages}{, stop reason = ${ansi.fg.red}$
1024         {thread.stop-reason}${ansi.normal}}{\\\\nReturn value: ${thread.return-value}}
1025         {\\\\nCompleted expression: ${thread.completed-expression}}\\\\n"""
1026         self.verify_setting_value_json("thread-stop-format", setting_value)
1027
1028         # Test OptionValueRegex
1029         self.verify_setting_value_json(
1030             "target.process.thread.step-avoid-regexp", "^std::"
1031         )
1032
1033         # Test OptionValueLanguage
1034         self.verify_setting_value_json("repl-lang", "c++")
1035
1036     def test_global_option(self):
1037         # This command used to crash the settings because -g was signaled by a
1038         # NULL execution context (not one with an empty Target...) and in the
1039         # special handling for load-script-from-symbol-file this wasn't checked.
1040         self.runCmd("settings set -g target.load-script-from-symbol-file true")