*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

1 files changed, 251 insertions, 191 deletions

diff --git a/lldb/packages/Python/lldbsuite/test/settings/TestSettings.py b/lldb/packages/Python/lldbsuite/test/settings/TestSettings.py
index 9592fa9d6df..577cac17753 100644
--- a/lldb/packages/Python/lldbsuite/test/settings/TestSettings.py
+++ b/lldb/packages/Python/lldbsuite/test/settings/TestSettings.py
@@ -5,13 +5,15 @@ Test lldb settings command.
 from __future__ import print_function
 
 
-
-import os, time, re
+import os
+import time
+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__)
@@ -29,9 +31,9 @@ class SettingsCommandTestCase(TestBase):
         """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"])
+                    substrs=["target.env-vars",
+                             "environment variables",
+                             "executable's environment"])
 
     @no_debug_info_test
     def test_append_target_env_vars(self):
@@ -44,7 +46,7 @@ class SettingsCommandTestCase(TestBase):
 
         # Check it immediately!
         self.expect('settings show target.env-vars',
-            substrs = ['MY_ENV_VAR=YES'])
+                    substrs=['MY_ENV_VAR=YES'])
 
     @no_debug_info_test
     def test_insert_before_and_after_target_run_args(self):
@@ -61,12 +63,12 @@ class SettingsCommandTestCase(TestBase):
         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"'])
+                    substrs=['target.run-args',
+                             '[0]: "__a__"',
+                             '[1]: "a"',
+                             '[2]: "__A__"',
+                             '[3]: "b"',
+                             '[4]: "c"'])
 
     @no_debug_info_test
     def test_replace_target_run_args(self):
@@ -81,10 +83,10 @@ class SettingsCommandTestCase(TestBase):
         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"'])
+                    substrs=['target.run-args (arguments) =',
+                             '[0]: "A"',
+                             '[1]: "b"',
+                             '[2]: "c"'])
 
     @no_debug_info_test
     def test_set_prompt(self):
@@ -95,11 +97,11 @@ class SettingsCommandTestCase(TestBase):
 
         # Immediately test the setting.
         self.expect("settings show prompt", SETTING_MSG("prompt"),
-            startstr = 'prompt (string) = "lldb2 "')
+                    startstr='prompt (string) = "lldb2 "')
 
         # The overall display should also reflect the new setting.
         self.expect("settings show", SETTING_MSG("prompt"),
-            substrs = ['prompt (string) = "lldb2 "'])
+                    substrs=['prompt (string) = "lldb2 "'])
 
         # Use '-r' option to reset to the original default prompt.
         self.runCmd("settings clear prompt")
@@ -112,13 +114,13 @@ class SettingsCommandTestCase(TestBase):
 
         # Immediately test the setting.
         self.expect("settings show term-width", SETTING_MSG("term-width"),
-            startstr = "term-width (int) = 70")
+                    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"])
+                    substrs=["term-width (int) = 70"])
 
-    #rdar://problem/10712130
+    # rdar://problem/10712130
     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()
@@ -127,30 +129,33 @@ class SettingsCommandTestCase(TestBase):
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         def cleanup():
-            self.runCmd("settings set frame-format %s" % self.format_string, check=False)
+            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())
+            '^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
+        # 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])
+                    substrs=[format_string])
 
         self.runCmd("breakpoint set -n main")
         self.runCmd("run")
         self.expect("thread backtrace",
-            substrs = ["`main", os.getcwd()])
+                    substrs=["`main", os.getcwd()])
 
     def test_set_auto_confirm(self):
         """Test that after 'set auto-confirm true', manual confirmation should not kick in."""
@@ -163,18 +168,18 @@ class SettingsCommandTestCase(TestBase):
 
         # Immediately test the setting.
         self.expect("settings show auto-confirm", SETTING_MSG("auto-confirm"),
-            startstr = "auto-confirm (boolean) = true")
+                    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")
+                    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")
+                    startstr="auto-confirm (boolean) = false")
 
     @skipIf(archs=no_match(['x86_64', 'i386', 'i686']))
     def test_disassembler_settings(self):
@@ -188,27 +193,27 @@ class SettingsCommandTestCase(TestBase):
         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"])
+                    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"])
+                    substrs=["$0x5a"])
         self.runCmd("settings set target.hex-immediate-style asm")
         self.expect("disassemble -n numberfn",
-            substrs = ["$5ah"])
+                    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"])
+                    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"])
+                    substrs=["0x5a"])
         self.runCmd("settings set target.hex-immediate-style asm")
         self.expect("disassemble -n numberfn",
-            substrs = ["5ah"])
+                    substrs=["5ah"])
 
     def test_run_args_and_env_vars(self):
         """Test that run-args and env-vars are passed to the launched process."""
@@ -233,13 +238,16 @@ class SettingsCommandTestCase(TestBase):
         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."])
+        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
+    @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()
@@ -248,8 +256,10 @@ class SettingsCommandTestCase(TestBase):
         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")
+        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"
@@ -269,9 +279,12 @@ class SettingsCommandTestCase(TestBase):
         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."])
+        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.error/output-path for the launched process works."""
@@ -291,11 +304,11 @@ class SettingsCommandTestCase(TestBase):
 
         self.expect("settings show target.error-path",
                     SETTING_MSG("target.error-path"),
-                    substrs = ['target.error-path (file) = "stderr.txt"'])
+                    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"'])
+                    substrs=['target.output-path (file) = "stdout.txt"'])
 
         self.runCmd("run", RUN_SUCCEEDED)
 
@@ -303,7 +316,6 @@ class SettingsCommandTestCase(TestBase):
             self.runCmd('platform get-file "stderr.txt" "stderr.txt"')
             self.runCmd('platform get-file "stdout.txt" "stdout.txt"')
 
-
         # The 'stderr.txt' file should now exist.
         self.assertTrue(os.path.isfile("stderr.txt"),
                         "'stderr.txt' exists due to target.error-path.")
@@ -314,9 +326,9 @@ class SettingsCommandTestCase(TestBase):
 
         message = "This message should go to standard error."
         if lldbplatformutil.hasChattyStderr(self):
-            self.expect(output, exe=False, substrs = [message])
+            self.expect(output, exe=False, substrs=[message])
         else:
-            self.expect(output, exe=False, startstr = message)
+            self.expect(output, exe=False, startstr=message)
 
         # The 'stdout.txt' file should now exist.
         self.assertTrue(os.path.isfile("stdout.txt"),
@@ -327,173 +339,221 @@ class SettingsCommandTestCase(TestBase):
             output = f.read()
 
         self.expect(output, exe=False,
-            startstr = "This message should go to standard out.")
+                    startstr="This message should go to standard out.")
 
     @no_debug_info_test
     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")
+        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")
 
     @no_debug_info_test
     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")
+        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")
 
     @no_debug_info_test
-    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')
+    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')
 
     @no_debug_info_test
-    def test_settings_with_trailing_whitespace (self):
-        
+    def test_settings_with_trailing_whitespace(self):
+
         # boolean
-        self.runCmd ("settings set target.skip-prologue true")      # Set to known value
-        self.runCmd ("settings set target.skip-prologue false ")    # Set to new value with trailing whitespace
+        # 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.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
-        self.runCmd ("settings set term-width 60 \t")   # Set to new value with trailing whitespaces
-        self.expect ("settings show term-width", SETTING_MSG("term-width"),
-            startstr = "term-width (int) = 60")
+        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
-        self.runCmd ("settings set target.arg0 cde\t ") # Set to new value with trailing whitespaces
-        self.expect ("settings show target.arg0", SETTING_MSG("target.arg0"),
-            startstr = 'target.arg0 (string) = "cde"')
+        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 = os.path.join(os.getcwd(), "path1.txt")
         path2 = os.path.join(os.getcwd(), "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 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
-        self.runCmd ("settings set stop-disassembly-display never")   # Set to known value
-        self.runCmd ("settings set stop-disassembly-display always ") # Set to new value with trailing whitespaces
-        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)        
+        # 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
-        self.runCmd ("settings set target.language c89")      # Set to known value
-        self.runCmd ("settings set target.language go ")      # Set to new value with trailing whitespace
-        self.expect ("settings show target.language", SETTING_MSG("target.language"),
-            startstr = "target.language (language) = go")
+        # Set to known value
+        self.runCmd("settings set target.language c89")
+        # Set to new value with trailing whitespace
+        self.runCmd("settings set target.language go ")
+        self.expect(
+            "settings show target.language",
+            SETTING_MSG("target.language"),
+            startstr="target.language (language) = go")
         self.runCmd("settings clear target.language", check=False)
         # arguments
-        self.runCmd ("settings set target.run-args 1 2 3")  # Set to known value
-        self.runCmd ("settings set target.run-args 3 4 5 ") # Set to new value with trailing whitespaces
-        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
-        self.runCmd ("settings set target.run-args 3 \  \ ") # Set to new value with trailing whitespaces
-        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)        
+        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
-        self.runCmd ("settings set target.env-vars A=B C=D\t ") # Set to new value with trailing whitespaces
-        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)        
+        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
-        self.runCmd ("settings clear target.process.thread.step-avoid-regexp")  # Set to known value
-        self.runCmd ("settings set target.process.thread.step-avoid-regexp foo\\ ") # Set to new value with trailing whitespaces
-        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)
+        # 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
-        self.runCmd ("settings set disassembly-format foo ") # Set to new value with trailing whitespaces
-        self.expect ("settings show disassembly-format",
-                SETTING_MSG("disassembly-format"),
-                substrs = [ 'disassembly-format (format-string) = "foo "'])
+        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)
 
     @no_debug_info_test
-    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",
-                                 "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"])
+    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",
+                             "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"])