Fix abbreviation test on Windows

[amccarth]

Summary

1. Demangler was including function return types, which foiled the pattern matching tests.

2. Demangler was not putting spaces after commas (e.g., in parameter lists), which also foiled the pattern matching.

3. Checking to see if dis -f does the same thing as disassemble -f was overly complicated and architecture specific (and didn't account for arch = i686).

4. Environment variables aren't always inherited all the way down to always making it down the make commands to build the targets, causing OS to resolve to "" which then defaulted to "windows32" which didn't match the tests for "Windows_NT". While not specific to the abbreviations test, this was important for debugging the Python through Visual Studio.

[zturner]

source/Core/Mangled.cpp

5283 ↗

(On Diff #23786)

I kind of want to block this. I know it's the most straightforward solution, but I don't think it's safe to make assumptions about the format of a mangled name. Even the __cxa_demangle function that is used on other platforms that have it, there is no guarantee that a particualr implementation of __cxa_demangle will separate arguments with spaces. Plus, this would mean changing an actual implementation to satisfy the peculiarities of a particular test.

I think we should consider any test that uses a regex to match a demangled name to be broken. A test should never regex match a demangled name. If it's trying to extract the function name or argument list, we should use SBFunction or something like that. We can probably extend the API wherever necessary to introduce the things we need. Or alternatively, it's possible the test is regex matching more than it actually needs to verify that the test was successful. You might see if there's a way to reduce (or even better, eliminate) the regex and change the code to use other SB apis to verify that the actual state of the thing is as expected.

test/functionalities/abbreviation/TestAbbreviations.py

53–54

I'm starting to think this *entire function* could just be re-written. If the point of this test is to test abbreviations, then all it should be doing is checking that running the abbreviation does the same thing as running the full command. For example, do we actually care that "dis -f" begins with the word "disassembly"? Or do we just care that "dis -f" does the same thing as "disassemble -f"? We (should) already have tests that verify that disassemble -f does the correct thing, so as long as dis -f does whatever disassemble -f does, we should be fine.

The same goes for all the tests in this file. I think maybe every one of these checks should be converted to the following pattern:

1. Run a sequence of non aliased command
2. save the output
3. Run the same sequence of aliased commands
4. Verify that the output matches that from step 2.

That's it. If you want to check that the command behaves *correctly*, leave that for a test that understands the command better.

test/make/Makefile.rules

40–45 ↗

(On Diff #23786)

Can you investigate this a little more? Can you dump your environment variables from inside of a Visual Studio instance (using the embedded PowerShell Console) to see if the OS environment variable is set?

[zturner]

+Jim and Greg for their thoughts, especially on the first two points (regex matching a demangled name being fundamentally broken, and re-writing TestAbbreviations to just compare output of aliased and non-aliased commands.

[amccarth]

source/Core/Mangled.cpp

5283 ↗

(On Diff #23786)

I mostly agree with you, but I convinced myself it was a good idea to make the demangled names on Windows be as consistent as possible with demangled names on any other platform, regardless of how we test it.

test/functionalities/abbreviation/TestAbbreviations.py

53–54

I considered that approach, but it's a tad more complicated with most of the other commands because they change the state of the target process. You'd have to do a pass of all the commands without abbreviating them and then a pass with abbreviations. This has the disadvantage of moving the reference for any particular command far away from the actual test, and you'd have a bunch of housekeeping to keep track of all the outputs. Either that or test each abbreviation as a separate run, which would be a lot slower.

test/make/Makefile.rules

40–45 ↗

(On Diff #23786)

I already verified that the Python test saw the variable, but make did not.

[zturner]

source/Core/Mangled.cpp

5283 ↗

(On Diff #23786)

I actually wonder if they should be as different as possible just so that we can find bugs like this more easily. :) It seems kind of similar to saying "we should make our undefined behavior act like their undefined behavior". I definitely see the advantages of doing that, but since it's undefined (or implementation-defined, more specifically), we have no guarantee that someone else won't come along again later with a perfectly valid implementation of __cxa_demangle (or a hand-written demangler) and this will all break again.

test/functionalities/abbreviation/TestAbbreviations.py

53–54

Yes, that's certainly a problem.

Jim / Greg, can we add a flag to "command alias" like "command alias -s <alias>" that returns the thing which it is aliased to? For example:

(lldb) command alias -s sc
script
(lldb)

Then this whole file just becomes a test that "command alias -s <alias>" returns the correct unaliased command. We have other tests for verifying that functionality actually works.

If we want to verify that you can run a command through an alias, then we can get by with a one liner that only tests a single trivial command that doesn't modify any debugger state. Like sc print "Hello" and just verify that you see Hello in the command output. And all the rest of the tests can simply verify that the alias is set up correctly.

I think this should be sufficient test coverage and less flaky than the current scenario.

[clayborg]

We could skip adding the "command alias -s" and just use "help <alias>":

(lldb) help run
....
'run' is an abbreviation for 'process launch -X true --'

We could just check the output of "help" instead?

[amccarth]

I'm happy to rewrite the test using the help trick.

I'm also happy to back off on the spaces-after-commas solution, though it would help in resolving other test failures on Windows.

[zturner]

In D9033#156691, @clayborg wrote:

We could skip adding the "command alias -s" and just use "help <alias>":

(lldb) help run
....
'run' is an abbreviation for 'process launch -X true --'

We could just check the output of "help" instead?

I just noticed we also have test/functionalities/alias/TestAliases.py.

Now I'm wondering if we can simply delete this whole file as it's not needed and can just be covered by TestAliases.

Regarding the help output, that would work (and be better than what we're currently doing). However we had a lengthy discussion earlier, and I think at least on this side we all feel like things would be better off if tests were matching strings less frequently. It's kind of unfortunate being in a situation where you don't ever want to change the way a command prints its output because it will mean fixing a bunch of tests. If this were a GUI application, it would be like testing by simulating mouse clicks vs. just invoking the functions behind the mouse clicks.

So with that in mind, wherever possible it would be nice if we could stop using regexes in the test suite and instead using the SB APIs to check the actual state of the thing we care about. One way to do this is to add a function to SBCommandInterpreter called ResolveAlias. We already have similar methods there, like AliasExists, CommandExists, but nothing to actually do this conversion. If we had this, all of these tests just become something like self.expect("script" == SBCommandInterpreter.ResolveAlias("sc"))

If you don't like this though, checking the output of help would be the next best thing.

[jingham]

Seems to me getting a "resolves to" method would be a fine addition to the SBCommandInterpreter. You could use this to do tooltips for the current command, for instance. At present the command alias mechanism is a little picky and requires you to spell out command and option identifiers fully when making the alias. So a straight-up compare would work as Zachary suggests. If we ever relax this the alias mechanism should canonicalize the alias when it makes it to avoid collisions with commands added later on. But so long as the tests keep spelling out the names in full, this shouldn't be a problem.

[zturner]

In D9033#156737, @jingham wrote:

Seems to me getting a "resolves to" method would be a fine addition to the SBCommandInterpreter. You could use this to do tooltips for the current command, for instance. At present the command alias mechanism is a little picky and requires you to spell out command and option identifiers fully when making the alias. So a straight-up compare would work as Zachary suggests. If we ever relax this the alias mechanism should canonicalize the alias when it makes it to avoid collisions with commands added later on. But so long as the tests keep spelling out the names in full, this shouldn't be a problem.

Regarding TestAliases vs TestAbbreviations. Do you see a reason why we need both of these or can we delete one? One seems to be testing that aliases resolve to the correct thing (which it seems like we agree can be better done by adding a ResolveAlias() to SBCommandInterpreter), and the other seems to be testing that running alias commands produces the same output as running unaliased commands. So can we just change the former to use ResolveAlias() everywhere, and outright delete the latter? (or change the latter to test only 1 trivial command like sc print "Hello"?

[clayborg]

I like the SBCommandInterpreter::ResolveAlias(...) approach. The question is should it expand the current command you passed in and return the expanded form? Or just find the alias and return the template. I would say it should resolve all arguments and place them where you want them to go and return the actual command that would be executed.

I agree we should be adding SB API for anything that might be depending on regex and string scraping...

[zturner]

Cool, sounds like we're all in agreement!

Adrian, maybe you can break this up and commit just the make / $(OS) portion of this change now, and then work on the ResolveAlias change separately? I'd rather not commit the demangling change at all. It's probably more work, but I think everyone will benefit if we reduce the amount of regex scraping the test suite uses and add methods where necessary to the public API if it isn't currently sufficient to find out what we need.

[amccarth]

Sounds good to me.

[jingham]

In D9033#156738, @zturner wrote:

Regarding TestAliases vs TestAbbreviations. Do you see a reason why we need both of these or can we delete one? One seems to be testing that aliases resolve to the correct thing (which it seems like we agree can be better done by adding a ResolveAlias() to SBCommandInterpreter), and the other seems to be testing that running alias commands produces the same output as running unaliased commands. So can we just change the former to use ResolveAlias() everywhere, and outright delete the latter? (or change the latter to test only 1 trivial command like sc print "Hello"?

Testing the aliases just tests that the string with substitutions got properly registered and reported. But that doesn't tell you whether the %1, %2, etc substitution mechanism is still working properly when the alias is run. So we should keep some tests that test that. You want to make sure that the % substitutions work for option values and arguments, that they work when the options are supplied out of order, and a few other things like that.

[amccarth]

Per our earlier conversation ...

1. I factored the command resolution phase out of CommandInterpreter::HandleCommand and exposed it through SBCommandInterpreter.
2. I changed the abbreviations test to use that API to directly test resolution of both abbreviations and aliases.

If we proceed with this, I would then:

1. Follow up with a patch to eliminate the old alias test, which would become obsolete.
2. Remove the test app from lldb/test/functionalities/abbrevation. (With my change, it's no longer built, but lldbtest.py seems to still want to issue make clean commands.)
3. Find a new home for testing the dynamic prompt (which was being tested as part of abbreviations).

I need guidance to finish this patch up.

1. I'm not fond of using the result type to stash the resolved command text, but I didn't see another way to return a dynamically generated string, nor could I find any precedent for doing so.
2. There may be other things I'm doing that go against the grain of lldb design that I'm not yet aware of.

On the plus side, I believe this eliminates most--if not all--of the platform issues: one test for Darwin and Dwarf, no architecture problems on Windows.

[zturner]

I like the way the tests are written now. It's much more obvious that the conditions being verified correspond to making sure the aliases resolve correctly.

include/lldb/API/SBCommandInterpreter.h

233

No space between function name and argument list (existing code that does this can be fixed over time as it is touched)

include/lldb/Interpreter/CommandInterpreter.h

632–633

Any reason for the line break here? Also no space between function name and argument list again. (I won't mention this again, even though it occurs in other places as well).

source/Interpreter/CommandInterpreter.cpp

1274

If you make an llvm::StringRef out of this, you can use StringRef::ltrim which actually finds even more types of whitespace characters. Seems better than duplicating this whitespace-finding logic.

[clayborg]

Fix the things that Zachary pointed out and we are good to go.

[amccarth]

include/lldb/API/SBCommandInterpreter.h

233

Done. I was just trying to be consistent with the code in this file. I'll nix the extra spaces throughout my change.

include/lldb/Interpreter/CommandInterpreter.h

632–633

Line break was to keep the line below 80 columns, which, as it turns out, is a hard habit to break. Fixed.

source/Interpreter/CommandInterpreter.cpp

1274

But it's not actually trimming the string; it's finding the range of the first whitespace-delimited token. Look below where it find the end of the token.

This isn't really part of this refactor. The only reason I even touched this code was to reduce the repetition of yet another white_space string, given that this translation unit already had one. (My change originally needed more white space scanning, but it doesn't currently.)

[amccarth]

Addresses earlier comments.

[zturner]

Looks good as long as Greg and Jim are ok with it.

[clayborg]

Looks fine.

[amccarth]

http://reviews.llvm.org/rL235633

include/lldb/API/SBCommandInterpreter.h

public:
     GetIOHandlerControlSequence(char ch);
 
     bool
     GetPromptOnQuit();
 
     void
     SetPromptOnQuit(bool b);
 
+    //----------------------------------------------------------------------
+    /// Resolve the command just as HandleCommand would, expanding abbreviations
+    /// and aliases.  If successful, result->GetOutput has the full expansion.
+    //----------------------------------------------------------------------
+    void
+    ResolveCommand (const char *command_line, SBCommandReturnObject &result);
+
 protected:
 
     lldb_private::CommandInterpreter &
     ref ();
 
     lldb_private::CommandInterpreter *
     get ();
 

include/lldb/Interpreter/CommandInterpreter.h

public:
     GetExpandRegexAliases () const;
     
     bool
     GetPromptOnQuit () const;
 
     void
     SetPromptOnQuit (bool b);
 
+    void
+    ResolveCommand (const char *command_line,
+                    CommandReturnObject &result);
+
     bool
     GetStopCmdSourceOnError () const;
 
     uint32_t
     GetNumErrors() const
     {
         return m_num_errors;
     }
protected:
     GetCommandSP (const char *cmd, bool include_aliases = true, bool exact = true, StringList *matches = NULL);
 
     
 private:
     
     Error
     PreprocessCommand (std::string &command);
 
+    // Completely resolves aliases and abbreviations, returning a pointer to the
+    // final command object and updating command_line to the fully substituted
+    // and translated command.
+    CommandObject *
+    ResolveCommandImpl(std::string &command_line, CommandReturnObject &result);
+
+
     Debugger &m_debugger;                       // The debugger session that this interpreter is associated with
     ExecutionContextRef m_exe_ctx_ref;          // The current execution context to use when handling commands
     bool m_synchronous_execution;
     bool m_skip_lldbinit_files;
     bool m_skip_app_init_files;
     CommandObject::CommandMap m_command_dict;   // Stores basic built-in commands (they cannot be deleted, removed or overwritten).
     CommandObject::CommandMap m_alias_dict;     // Stores user aliases/abbreviations for commands
     CommandObject::CommandMap m_user_dict;      // Stores user-defined commands

scripts/Python/interface/SBCommandInterpreter.i

public:
     GetIOHandlerControlSequence(char ch);
 
     bool
     GetPromptOnQuit();
 
     void
     SetPromptOnQuit(bool b);
 
+    void
+    ResolveCommand (const char *command_line, SBCommandReturnObject &result);
+
     bool
     CommandExists (const char *cmd);
 
     bool
     AliasExists (const char *cmd);
 
     lldb::SBBroadcaster
     GetBroadcaster ();

source/API/SBCommandInterpreter.cpp

 
 void
 SBCommandInterpreter::SetPromptOnQuit (bool b)
 {
     if (m_opaque_ptr)
         m_opaque_ptr->SetPromptOnQuit(b);
 }
 
+void
+SBCommandInterpreter::ResolveCommand (const char *command_line, SBCommandReturnObject &result)
+{
+    result.Clear();
+    if (command_line && m_opaque_ptr)
+    {
+        m_opaque_ptr->ResolveCommand (command_line, result.ref());
+    }
+    else
+    {
+        result->AppendError ("SBCommandInterpreter or the command line is not valid");
+        result->SetStatus (eReturnStatusFailed);
+    }
+}
+
+
 CommandInterpreter *
 SBCommandInterpreter::get ()
 {
     return m_opaque_ptr;
 }
 
 CommandInterpreter &
 SBCommandInterpreter::ref ()

source/Commands/CommandObjectMultiword.cpp

else
                         error_msg.assign ("ambiguous command ");
                     else
                         error_msg.assign ("invalid command ");
 
                     error_msg.append ("'");
                     error_msg.append (GetCommandName());
                     error_msg.append (" ");
                     error_msg.append (sub_command);
-                    error_msg.append ("'");
+                    error_msg.append ("'.");
 
                     if (num_subcmd_matches > 0)
                     {
                         error_msg.append (" Possible completions:");
                         for (size_t i = 0; i < num_subcmd_matches; i++)
                         {
                             error_msg.append ("\n\t");
                             error_msg.append (matches.GetStringAtIndex (i));

source/Interpreter/CommandInterpreter.cpp

 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Path.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+static const char *k_white_space = " \t\v";
 
 static PropertyDefinition
 g_properties[] =
 {
     { "expand-regex-aliases", OptionValue::eTypeBoolean, true, false, nullptr, nullptr, "If true, regular expression alias commands will show the expanded command that will be executed. This can be used to debug new regular expression alias commands." },
     { "prompt-on-quit", OptionValue::eTypeBoolean, true, true, nullptr, nullptr, "If true, LLDB will prompt you before quitting if there are any live processes being debugged. If false, LLDB will quit without asking in any case." },
     { "stop-command-source-on-error", OptionValue::eTypeBoolean, true, true, nullptr, nullptr, "If true, LLDB will stop running a 'command source' script upon encountering an error." },
     { nullptr                  , OptionValue::eTypeInvalid, true, 0    , nullptr, nullptr, nullptr }

 
 void
 CommandInterpreter::SetPromptOnQuit (bool b)
 {
     const uint32_t idx = ePropertyPromptOnQuit;
     m_collection_sp->SetPropertyAtIndexAsBoolean (nullptr, idx, b);
 }
 
+void
+CommandInterpreter::ResolveCommand (const char *command_line,
+                                    CommandReturnObject &result)
+{
+    std::string command = command_line;
+    if (ResolveCommandImpl (command, result) != nullptr) {
+        result.AppendMessageWithFormat ("%s", command.c_str());
+        result.SetStatus (eReturnStatusSuccessFinishResult);
+    }
+}
+
+
 bool
 CommandInterpreter::GetStopCmdSourceOnError () const
 {
     const uint32_t idx = ePropertyStopCmdSourceOnError;
     return m_collection_sp->GetPropertyAtIndexAsBoolean (nullptr, idx, g_properties[idx].default_uint_value != 0);
 }
 
 void

 
 CommandObject *
 CommandInterpreter::GetCommandObjectForCommand (std::string &command_string)
 {
     // This function finds the final, lowest-level, alias-resolved command object whose 'Execute' function will
     // eventually be invoked by the given command line.
     
     CommandObject *cmd_obj = nullptr;
-    std::string white_space (" \t\v");
-    size_t start = command_string.find_first_not_of (white_space);
+    size_t start = command_string.find_first_not_of (k_white_space);
     size_t end = 0;
     bool done = false;
     while (!done)
     {
         if (start != std::string::npos)
         {
             // Get the next word from command_string.
-            end = command_string.find_first_of (white_space, start);
+            end = command_string.find_first_of (k_white_space, start);
             if (end == std::string::npos)
                 end = command_string.size();
             std::string cmd_word = command_string.substr (start, end - start);
             
             if (cmd_obj == nullptr)
                 // Since cmd_obj is NULL we are on our first time through this loop. Check to see if cmd_word is a valid 
                 // command or alias.
                 cmd_obj = GetCommandObject (cmd_word.c_str());
while (!done)
 
             // If we didn't find a valid command object, or our command object is not a multi-word object, or
             // we are at the end of the command_string, then we are done.  Otherwise, find the start of the
             // next word.
             
             if (!cmd_obj || !cmd_obj->IsMultiwordObject() || end >= command_string.size())
                 done = true;
             else
-                start = command_string.find_first_not_of (white_space, end);
+                start = command_string.find_first_not_of (k_white_space, end);
         }
         else
             // Unable to find any more words.
             done = true;
     }
     
     if (end == command_string.size())
         command_string.clear();
     else
         command_string = command_string.substr(end);
     
     return cmd_obj;
 }
 
-static const char *k_white_space = " \t\v";
 static const char *k_valid_command_chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
 static void
 StripLeadingSpaces (std::string &s)
 {
     if (!s.empty())
     {
         size_t pos = s.find_first_not_of (k_white_space);
         if (pos == std::string::npos)
if (alias_cmd_obj)
                             result_str.Printf ("%s", value.c_str());
                         else if (static_cast<size_t>(index) >= cmd_args.GetArgumentCount())
                         {
                             
                             result.AppendErrorWithFormat
                             ("Not enough arguments provided; you need at least %d arguments to use this alias.\n",
                              index);
                             result.SetStatus (eReturnStatusFailed);
-                            return alias_cmd_obj;
+                            return nullptr;
                         }
                         else
                         {
                             size_t strpos = raw_input_string.find (cmd_args.GetArgumentAtIndex (index));
                             if (strpos != std::string::npos)
                                 raw_input_string = raw_input_string.erase (strpos, 
                                                                           strlen (cmd_args.GetArgumentAtIndex (index)));
                             result_str.Printf ("%s", cmd_args.GetArgumentAtIndex (index));
                         }
                     }
                 }
             }
         }
         
         alias_result = result_str.GetData();
     }
     return alias_cmd_obj;
 }
 
 Error
 CommandInterpreter::PreprocessCommand (std::string &command)
 {
     // The command preprocessor needs to do things to the command 
     // line before any parsing of arguments or anything else is done.
-    // The only current stuff that gets proprocessed is anyting enclosed
+    // The only current stuff that gets preprocessed is anything enclosed
     // in backtick ('`') characters is evaluated as an expression and
     // the result of the expression must be a scalar that can be substituted
     // into the command. An example would be:
     // (lldb) memory read `$rsp + 20`
     Error error; // Error for any expressions that might not evaluate
     size_t start_backtick;
     size_t pos = 0;
     while ((start_backtick = command.find ('`', pos)) != std::string::npos)
CommandInterpreter::HandleCommand (const char *command_line,
                                    LazyBool lazy_add_to_history,
                                    CommandReturnObject &result,
                                    ExecutionContext *override_context,
                                    bool repeat_on_empty_command,
                                    bool no_context_switching)
 
 {
 
-    bool done = false;
-    CommandObject *cmd_obj = nullptr;
-    bool wants_raw_input = false;
     std::string command_string (command_line);
     std::string original_command_string (command_line);
     
     Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_COMMANDS));
     Host::SetCrashDescriptionWithFormat ("HandleCommand(command = \"%s\")", command_line);
     
     // Make a scoped cleanup object that will clear the crash description string 
     // on exit of this function.
CommandInterpreter::HandleCommand (const char *command_line,
     Error error (PreprocessCommand (command_string));
     
     if (error.Fail())
     {
         result.AppendError (error.AsCString());
         result.SetStatus(eReturnStatusFailed);
         return false;
     }
-    // Phase 1.
-    
-    // Before we do ANY kind of argument processing, etc. we need to figure out what the real/final command object
-    // is for the specified command, and whether or not it wants raw input.  This gets complicated by the fact that
-    // the user could have specified an alias, and in translating the alias there may also be command options and/or
-    // even data (including raw text strings) that need to be found and inserted into the command line as part of
-    // the translation.  So this first step is plain look-up & replacement, resulting in three things:  1). the command
-    // object whose Execute method will actually be called; 2). a revised command string, with all substitutions &
-    // replacements taken care of; 3). whether or not the Execute function wants raw input or not.
-
-    StreamString revised_command_line;
-    size_t actual_cmd_name_len = 0;
-    std::string next_word;
-    StringList matches;
-    while (!done)
-    {
-        char quote_char = '\0';
-        std::string suffix;
-        ExtractCommand (command_string, next_word, suffix, quote_char);
-        if (cmd_obj == nullptr)
-        {
-            std::string full_name;
-            if (GetAliasFullName(next_word.c_str(), full_name))
-            {
-                std::string alias_result;
-                cmd_obj = BuildAliasResult (full_name.c_str(), command_string, alias_result, result);
-                revised_command_line.Printf ("%s", alias_result.c_str());
-                if (cmd_obj)
-                {
-                    wants_raw_input = cmd_obj->WantsRawCommandString ();
-                    actual_cmd_name_len = strlen (cmd_obj->GetCommandName());
-                }
-            }
-            else
-            {
-                cmd_obj = GetCommandObject (next_word.c_str(), &matches);
-                if (cmd_obj)
-                {
-                    actual_cmd_name_len += next_word.length();
-                    revised_command_line.Printf ("%s", next_word.c_str());
-                    wants_raw_input = cmd_obj->WantsRawCommandString ();
-                }
-                else
-                {
-                    revised_command_line.Printf ("%s", next_word.c_str());
-                }
-            }
-        }
-        else
-        {
-            if (cmd_obj->IsMultiwordObject ())
-            {
-                CommandObject *sub_cmd_obj = cmd_obj->GetSubcommandObject (next_word.c_str());
-                if (sub_cmd_obj)
-                {
-                    actual_cmd_name_len += next_word.length() + 1;
-                    revised_command_line.Printf (" %s", next_word.c_str());
-                    cmd_obj = sub_cmd_obj;
-                    wants_raw_input = cmd_obj->WantsRawCommandString ();
-                }
-                else
-                {
-                    if (quote_char)
-                        revised_command_line.Printf (" %c%s%s%c", quote_char, next_word.c_str(), suffix.c_str(), quote_char);
-                    else
-                        revised_command_line.Printf (" %s%s", next_word.c_str(), suffix.c_str());
-                    done = true;
-                }
-            }
-            else
-            {
-                if (quote_char)
-                    revised_command_line.Printf (" %c%s%s%c", quote_char, next_word.c_str(), suffix.c_str(), quote_char);
-                else
-                    revised_command_line.Printf (" %s%s", next_word.c_str(), suffix.c_str());
-                done = true;
-            }
-        }
-
-        if (cmd_obj == nullptr)
-        {
-            const size_t num_matches = matches.GetSize();
-            if (matches.GetSize() > 1) {
-                StreamString error_msg;
-                error_msg.Printf ("Ambiguous command '%s'. Possible matches:\n", next_word.c_str());
-
-                for (uint32_t i = 0; i < num_matches; ++i) {
-                    error_msg.Printf ("\t%s\n", matches.GetStringAtIndex(i));
-                }
-                result.AppendRawError (error_msg.GetString().c_str());
-            } else {
-                // We didn't have only one match, otherwise we wouldn't get here.
-                assert(num_matches == 0);
-                result.AppendErrorWithFormat ("'%s' is not a valid command.\n", next_word.c_str());
-            }
-            result.SetStatus (eReturnStatusFailed);
-            return false;
-        }
-
-        if (cmd_obj->IsMultiwordObject ())
-        {
-            if (!suffix.empty())
-            {
-
-                result.AppendErrorWithFormat ("command '%s' did not recognize '%s%s%s' as valid (subcommand might be invalid).\n",
-                                              cmd_obj->GetCommandName(),
-                                              next_word.empty() ? "" : next_word.c_str(),
-                                              next_word.empty() ? " -- " : " ",
-                                              suffix.c_str());
-                result.SetStatus (eReturnStatusFailed);
-                return false;
-            }
-        }
-        else
-        {
-            // If we found a normal command, we are done
-            done = true;
-            if (!suffix.empty())
-            {
-                switch (suffix[0])
-                {
-                case '/':
-                    // GDB format suffixes
-                    {
-                        Options *command_options = cmd_obj->GetOptions();
-                        if (command_options && command_options->SupportsLongOption("gdb-format"))
-                        {
-                            std::string gdb_format_option ("--gdb-format=");
-                            gdb_format_option += (suffix.c_str() + 1);
-    
-                            bool inserted = false;
-                            std::string &cmd = revised_command_line.GetString();
-                            size_t arg_terminator_idx = FindArgumentTerminator (cmd);
-                            if (arg_terminator_idx != std::string::npos)
-                            {
-                                // Insert the gdb format option before the "--" that terminates options
-                                gdb_format_option.append(1,' ');
-                                cmd.insert(arg_terminator_idx, gdb_format_option);
-                                inserted = true;
-                            }
-
-                            if (!inserted)
-                                revised_command_line.Printf (" %s", gdb_format_option.c_str());
-                        
-                            if (wants_raw_input && FindArgumentTerminator(cmd) == std::string::npos)
-                                revised_command_line.PutCString (" --");
-                        }
-                        else
-                        {
-                            result.AppendErrorWithFormat ("the '%s' command doesn't support the --gdb-format option\n", 
-                                                          cmd_obj->GetCommandName());
-                            result.SetStatus (eReturnStatusFailed);
-                            return false;
-                        }
-                    }
-                    break;
-
-                default:
-                    result.AppendErrorWithFormat ("unknown command shorthand suffix: '%s'\n", 
-                                                  suffix.c_str());
-                    result.SetStatus (eReturnStatusFailed);
-                    return false;
-        
-                }
-            }
-        }
-        if (command_string.length() == 0)
-            done = true;
-            
-    }
-
-    if (!command_string.empty())
-        revised_command_line.Printf (" %s", command_string.c_str());
-
-    // End of Phase 1.
-    // At this point cmd_obj should contain the CommandObject whose Execute method will be called, if the command
-    // specified was valid; revised_command_line contains the complete command line (including command name(s)),
-    // fully translated with all substitutions & translations taken care of (still in raw text format); and
-    // wants_raw_input specifies whether the Execute method expects raw input or not.
+    // Phase 1.
     
- 
+    // Before we do ANY kind of argument processing, we need to figure out what
+    // the real/final command object is for the specified command.  This gets
+    // complicated by the fact that the user could have specified an alias, and,
+    // in translating the alias, there may also be command options and/or even
+    // data (including raw text strings) that need to be found and inserted into
+    // the command line as part of the translation.  So this first step is plain
+    // look-up and replacement, resulting in:
+    //    1. the command object whose Execute method will actually be called
+    //    2. a revised command string, with all substitutions and replacements
+    //       taken care of
+    // From 1 above, we can determine whether the Execute function wants raw
+    // input or not.
+
+    CommandObject *cmd_obj = ResolveCommandImpl (command_string, result);
+
+    // Although the user may have abbreviated the command, the command_string now
+    // has the command expanded to the full name.  For example, if the input
+    // was "br s -n main", command_string is now "breakpoint set -n main".
     if (log)
     {
         log->Printf ("HandleCommand, cmd_obj : '%s'", cmd_obj ? cmd_obj->GetCommandName() : "<not found>");
-        log->Printf ("HandleCommand, revised_command_line: '%s'", revised_command_line.GetData());
+        log->Printf ("HandleCommand, (revised) command_string: '%s'", command_string.c_str());
+        const bool wants_raw_input = (cmd_obj != NULL) ? cmd_obj->WantsRawCommandString() : false;
         log->Printf ("HandleCommand, wants_raw_input:'%s'", wants_raw_input ? "True" : "False");
     }
 
     // Phase 2.
     // Take care of things like setting up the history command & calling the appropriate Execute method on the
     // CommandObject, with the appropriate arguments.
     
     if (cmd_obj != nullptr)
     {
         if (add_to_history)
         {
-            Args command_args (revised_command_line.GetData());
+            Args command_args (command_string);
             const char *repeat_command = cmd_obj->GetRepeatCommand(command_args, 0);
             if (repeat_command != nullptr)
                 m_repeat_command.assign(repeat_command);
             else
                 m_repeat_command.assign(original_command_string.c_str());
             
             m_command_history.AppendString (original_command_string);
         }
         
-        command_string = revised_command_line.GetData();
-        std::string command_name (cmd_obj->GetCommandName());
         std::string remainder;
+        const std::size_t actual_cmd_name_len = strlen (cmd_obj->GetCommandName());
         if (actual_cmd_name_len < command_string.length()) 
-            remainder = command_string.substr (actual_cmd_name_len);  // Note: 'actual_cmd_name_len' may be considerably shorter
-                                                           // than cmd_obj->GetCommandName(), because name completion
-                                                           // allows users to enter short versions of the names,
-                                                           // e.g. 'br s' for 'breakpoint set'.
+            remainder = command_string.substr (actual_cmd_name_len);
         
         // Remove any initial spaces
-        std::string white_space (" \t\v");
-        size_t pos = remainder.find_first_not_of (white_space);
+        size_t pos = remainder.find_first_not_of (k_white_space);
         if (pos != 0 && pos != std::string::npos)
             remainder.erase(0, pos);
 
         if (log)
             log->Printf ("HandleCommand, command line after removing command name(s): '%s'", remainder.c_str());
     
         cmd_obj->Execute (remainder.c_str(), result);
     }
     else
     {
         // We didn't find the first command object, so complete the first argument.
-        Args command_args (revised_command_line.GetData());
+        Args command_args (command_string);
         StringList matches;
         int num_matches;
         int cursor_index = 0;
         int cursor_char_position = strlen (command_args.GetArgumentAtIndex(0));
         bool word_complete;
         num_matches = HandleCompletionMatches (command_args, 
                                                cursor_index,
                                                cursor_char_position,
else
         m_debugger.ExecuteIOHandlers();
         
         if (auto_handle_events)
             m_debugger.StopEventHandlerThread();
     }
     
 }
 
+CommandObject *
+CommandInterpreter::ResolveCommandImpl (std::string &command_line, CommandReturnObject &result)
+{
+    std::string scratch_command(command_line);  // working copy so we don't modify command_line unless we succeed
+    CommandObject *cmd_obj = nullptr;
+    StreamString revised_command_line;
+    bool wants_raw_input = false;
+    size_t actual_cmd_name_len = 0;
+    std::string next_word;
+    StringList matches;
+    bool done = false;
+    while (!done)
+    {
+        char quote_char = '\0';
+        std::string suffix;
+        ExtractCommand (scratch_command, next_word, suffix, quote_char);
+        if (cmd_obj == nullptr)
+        {
+            std::string full_name;
+            if (GetAliasFullName(next_word.c_str(), full_name))
+            {
+                std::string alias_result;
+                cmd_obj = BuildAliasResult (full_name.c_str(), scratch_command, alias_result, result);
+                revised_command_line.Printf ("%s", alias_result.c_str());
+                if (cmd_obj)
+                {
+                    wants_raw_input = cmd_obj->WantsRawCommandString ();
+                    actual_cmd_name_len = strlen (cmd_obj->GetCommandName());
+                }
+            }
+            else
+            {
+                cmd_obj = GetCommandObject (next_word.c_str(), &matches);
+                if (cmd_obj)
+                {
+                    actual_cmd_name_len += strlen (cmd_obj->GetCommandName());
+                    revised_command_line.Printf ("%s", cmd_obj->GetCommandName());
+                    wants_raw_input = cmd_obj->WantsRawCommandString ();
+                }
+                else
+                {
+                    revised_command_line.Printf ("%s", next_word.c_str());
+                }
+            }
+        }
+        else
+        {
+            if (cmd_obj->IsMultiwordObject ())
+            {
+                CommandObject *sub_cmd_obj = cmd_obj->GetSubcommandObject (next_word.c_str());
+                if (sub_cmd_obj)
+                {
+                    // The subcommand's name includes the parent command's name,
+                    // so restart rather than append to the revised_command_line.
+                    actual_cmd_name_len = strlen (sub_cmd_obj->GetCommandName()) + 1;
+                    revised_command_line.Clear();
+                    revised_command_line.Printf ("%s", sub_cmd_obj->GetCommandName());
+                    cmd_obj = sub_cmd_obj;
+                    wants_raw_input = cmd_obj->WantsRawCommandString ();
+                }
+                else
+                {
+                    if (quote_char)
+                        revised_command_line.Printf (" %c%s%s%c", quote_char, next_word.c_str(), suffix.c_str(), quote_char);
+                    else
+                        revised_command_line.Printf (" %s%s", next_word.c_str(), suffix.c_str());
+                    done = true;
+                }
+            }
+            else
+            {
+                if (quote_char)
+                    revised_command_line.Printf (" %c%s%s%c", quote_char, next_word.c_str(), suffix.c_str(), quote_char);
+                else
+                    revised_command_line.Printf (" %s%s", next_word.c_str(), suffix.c_str());
+                done = true;
+            }
+        }
+
+        if (cmd_obj == nullptr)
+        {
+            const size_t num_matches = matches.GetSize();
+            if (matches.GetSize() > 1) {
+                StreamString error_msg;
+                error_msg.Printf ("Ambiguous command '%s'. Possible matches:\n", next_word.c_str());
+
+                for (uint32_t i = 0; i < num_matches; ++i) {
+                    error_msg.Printf ("\t%s\n", matches.GetStringAtIndex(i));
+                }
+                result.AppendRawError (error_msg.GetString().c_str());
+            } else {
+                // We didn't have only one match, otherwise we wouldn't get here.
+                assert(num_matches == 0);
+                result.AppendErrorWithFormat ("'%s' is not a valid command.\n", next_word.c_str());
+            }
+            result.SetStatus (eReturnStatusFailed);
+            return nullptr;
+        }
+
+        if (cmd_obj->IsMultiwordObject ())
+        {
+            if (!suffix.empty())
+            {
+                result.AppendErrorWithFormat ("command '%s' did not recognize '%s%s%s' as valid (subcommand might be invalid).\n",
+                                              cmd_obj->GetCommandName(),
+                                              next_word.empty() ? "" : next_word.c_str(),
+                                              next_word.empty() ? " -- " : " ",
+                                              suffix.c_str());
+                result.SetStatus (eReturnStatusFailed);
+                return nullptr;
+            }
+        }
+        else
+        {
+            // If we found a normal command, we are done
+            done = true;
+            if (!suffix.empty())
+            {
+                switch (suffix[0])
+                {
+                case '/':
+                    // GDB format suffixes
+                    {
+                        Options *command_options = cmd_obj->GetOptions();
+                        if (command_options && command_options->SupportsLongOption("gdb-format"))
+                        {
+                            std::string gdb_format_option ("--gdb-format=");
+                            gdb_format_option += (suffix.c_str() + 1);
+
+                            bool inserted = false;
+                            std::string &cmd = revised_command_line.GetString();
+                            size_t arg_terminator_idx = FindArgumentTerminator (cmd);
+                            if (arg_terminator_idx != std::string::npos)
+                            {
+                                // Insert the gdb format option before the "--" that terminates options
+                                gdb_format_option.append(1,' ');
+                                cmd.insert(arg_terminator_idx, gdb_format_option);
+                                inserted = true;
+                            }
+
+                            if (!inserted)
+                                revised_command_line.Printf (" %s", gdb_format_option.c_str());
+
+                            if (wants_raw_input && FindArgumentTerminator(cmd) == std::string::npos)
+                                revised_command_line.PutCString (" --");
+                        }
+                        else
+                        {
+                            result.AppendErrorWithFormat ("the '%s' command doesn't support the --gdb-format option\n",
+                                                          cmd_obj->GetCommandName());
+                            result.SetStatus (eReturnStatusFailed);
+                            return nullptr;
+                        }
+                    }
+                    break;
+
+                default:
+                    result.AppendErrorWithFormat ("unknown command shorthand suffix: '%s'\n",
+                                                  suffix.c_str());
+                    result.SetStatus (eReturnStatusFailed);
+                    return nullptr;
+                }
+            }
+        }
+        if (scratch_command.empty())
+            done = true;
+    }
+
+    if (!scratch_command.empty())
+        revised_command_line.Printf (" %s", scratch_command.c_str());
+
+    if (cmd_obj != NULL)
+        command_line = revised_command_line.GetData();
+
+    return cmd_obj;
+}

test/functionalities/abbreviation/TestAbbreviations.py

 """
-Test some lldb command abbreviations.
+Test some lldb command abbreviations and aliases for proper resolution.
 """
 
 import os, time
 import unittest2
 import lldb
 from lldbtest import *
 import lldbutil
 
 class AbbreviationsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureFreeBSD("llvm.org/pr22611 thread race condition breaks prompt setting")
-    @skipIfWindows # one-shot script commands deadlock on Windows.
-    def test_nonrunning_command_abbreviations (self):
-        self.expect("ap script",
-                    startstr = "The following built-in commands may relate to 'script':",
-                    substrs = ['breakpoint command add',
-                               'breakpoint command list',
-                               'breakpoint list',
-                               'command alias',
-                               'expression',
-                               'script'])
+    def test_command_abbreviations_and_aliases (self):
+        command_interpreter = self.dbg.GetCommandInterpreter()
+        self.assertTrue(command_interpreter, VALID_COMMAND_INTERPRETER)
+        result = lldb.SBCommandReturnObject()
+
+        # Check that abbreviations are expanded to the full command.
+        command_interpreter.ResolveCommand("ap script", result)
+        self.assertTrue(result.Succeeded())
+        self.assertEqual("apropos script", result.GetOutput())
+
+        command_interpreter.ResolveCommand("h", result)
+        self.assertTrue(result.Succeeded())
+        self.assertEqual("help", result.GetOutput())
+
+        # Check resolution of abbreviations for multi-word commands.
+        command_interpreter.ResolveCommand("lo li", result)
+        self.assertTrue(result.Succeeded())
+        self.assertEqual("log list", result.GetOutput())
+
+        command_interpreter.ResolveCommand("br s", result)
+        self.assertTrue(result.Succeeded())
+        self.assertEqual("breakpoint set", result.GetOutput())
+
+        # Try an ambiguous abbreviation.
+        # "pl" could be "platform" or "plugin".
+        command_interpreter.ResolveCommand("pl", result)
+        self.assertFalse(result.Succeeded())
+        self.assertTrue(result.GetError().startswith("Ambiguous command"))
+
+        # Make sure an unabbreviated command is not mangled.
+        command_interpreter.ResolveCommand("breakpoint set --name main --line 123", result)
+        self.assertTrue(result.Succeeded())
+        self.assertEqual("breakpoint set --name main --line 123", result.GetOutput())
 
+        # Create some aliases.
         self.runCmd("com a alias com al")
         self.runCmd("alias gurp help")
-        self.expect("gurp target create",
-                    substrs = ['Syntax: target create <cmd-options> <filename>'])
+
+        # Check that an alias is replaced with the actual command
+        command_interpreter.ResolveCommand("gurp target create", result)
+        self.assertTrue(result.Succeeded())
+        self.assertEqual("help target create", result.GetOutput())
+
+        # Delete the alias and make sure it no longer has an effect.
         self.runCmd("com u gurp")
-        self.expect("gurp",
-                    COMMAND_FAILED_AS_EXPECTED, error = True,
-                    substrs = ["error: 'gurp' is not a valid command."])
-
-        # Only one matching command: execute it.
-        self.expect("h",
-                    startstr = "Debugger commands:")
-
-        # Execute cleanup function during test tear down
-        def cleanup():
-            self.runCmd("command alias t thread select")
-        self.addTearDownHook(cleanup)
-
-        # Several matching commands: list them and error out.
-        self.runCmd("command unalias t")
-        self.expect("t",
-                    COMMAND_FAILED_AS_EXPECTED, error = True,
-                    substrs = ["Ambiguous command 't'. Possible matches:",
-                               "target", "thread", "type"])
-
-        self.runCmd("com sou ./change_prompt.lldb")
-
-        self.expect("settings show prompt",
-                    startstr = 'prompt (string) = "[with-three-trailing-spaces]   "')
-
-
-        self.runCmd("settings clear prompt")
-        self.expect("settings show prompt",
-                    startstr = 'prompt (string) = "(lldb) "')
-
-
-        self.expect("lo li",
-                    startstr = "Logging categories for ")
-
-        self.runCmd("se se prompt 'Sycamore> '")
-        self.expect("se sh prompt",
-                    startstr = 'prompt (string) = "Sycamore> "')
-
-        self.runCmd("se cl prompt")
-        self.expect("set sh prompt",
-                    startstr = 'prompt (string) = "(lldb) "')
-
-        # We don't want to display the stdout if not in TraceOn() mode.
-        if not self.TraceOn():
-            self.HideStdout()
-
-        self.runCmd (r'''sc print "\n\n\tHello!\n"''')
-
-
-    @skipUnlessDarwin
-    @dsym_test
-    def test_with_dsym (self):
-        self.buildDsym ()
-        self.running_abbreviations ()
-
-    @dwarf_test
-    @expectedFailureLinux # not related to abbreviations, "dis -f" output has int3 in it
-    def test_with_dwarf (self):
-        self.buildDwarf ()
-        self.running_abbreviations ()
-
-    def running_abbreviations (self):
-        exe = os.path.join (os.getcwd(), "a.out")
-        # Use "file", i.e., no abbreviation.  We're exactly matching the command
-        # verbatim when dealing with remote testsuite execution.
-        # For more details, see TestBase.runCmd().
-        self.expect("file " + exe,
-                    patterns = [ "Current executable set to .*a.out.*" ])
-
-        # By default, the setting interpreter.expand-regex-aliases is false.
-        self.expect("_regexp-br product", matching=False,
-                    substrs = [ "breakpoint set --name" ])
-
-        match_object = lldbutil.run_break_set_command (self, "br s -n sum")
-        lldbutil.check_breakpoint_result (self, match_object, symbol_name='sum', symbol_match_exact=False, num_locations=1)
-
-        match_object = lldbutil.run_break_set_command (self, "br s -f main.cpp -l 32")
-        lldbutil.check_breakpoint_result (self, match_object, file_name='main.cpp', line_number=32, num_locations=1)
-
-        self.runCmd("br co a -s python 1 -o 'print frame'")
-        self.expect("br co l 1",
-                    substrs = [ "Breakpoint 1:",
-                                "Breakpoint commands:",
-                                "print frame" ])
-
-        self.runCmd("br co del 1")
-        self.expect("breakpoint command list 1",
-                    startstr = "Breakpoint 1 does not have an associated command.")
-
-        self.expect("br di",
-                    startstr = 'All breakpoints disabled. (3 breakpoints)')
-
-        self.expect("bre e",
-                    startstr = "All breakpoints enabled. (3 breakpoints)")
-
-        self.expect("break list",
-                    substrs = ["1: name = 'product', locations = 1",
-                               "2: name = 'sum', locations = 1",
-                               "3: file = 'main.cpp', line = 32, locations = 1"])
-        self.expect("br cl -l 32 -f main.cpp",
-                    startstr = "1 breakpoints cleared:",
-                    substrs = ["3: file = 'main.cpp', line = 32, locations = 1"])
-
-        # Add a future to terminate the current process being debugged.
-        #
-        # The test framework relies on detecting either "run" or "process launch"
-        # command to automatically kill the inferior upon tear down.
-        # But we'll be using "pro la" command to launch the inferior.
-        self.expect("pro la",
-                    patterns = [ "Process .* launched: "])
-
-        self.expect("pro st",
-                    patterns = [ "Process .* stopped",
-                                 "thread #1:",
-                                 "a.out",
-                                 "sum\(a=1238, b=78392\)",
-                                 "at main.cpp\:25",
-                                 "stop reason = breakpoint 2.1" ])
-
-        # ARCH, if not specified, defaults to x86_64.
-        self.runCmd("dis -f")
-        disassembly = self.res.GetOutput()
-        if self.getArchitecture() in ["", 'x86_64', 'i386']:
-            # hey! we shouldn't have a software breakpoint in here
-            self.assertFalse("int3" in disassembly)
-            self.expect(disassembly, exe=False,
-                        startstr = "a.out`sum(int, int)",
-                        substrs = [' mov',
-                                   ' addl ',
-                                   'ret'])
-        else:
-            self.fail('unimplemented for arch = "{arch}"'.format(arch=self.getArchitecture()))
-
-        self.expect("i d l main.cpp",
-                    patterns = ["Line table for .*main.cpp in `a.out"])
-
-        self.expect("i d se",
-                    patterns = ["Dumping sections for [0-9]+ modules."])
-
-        self.expect("i d symf",
-                    patterns = ["Dumping debug symbols for [0-9]+ modules."])
-
-        self.expect("i d symt",
-                    patterns = ["Dumping symbol table for [0-9]+ modules."])
-
-        if self.platformIsDarwin():
-            self.expect("i li",
-                        substrs = [ 'a.out',
-                                    '/usr/lib/dyld',
-                                    '/usr/lib/libSystem.B.dylib'])
+        command_interpreter.ResolveCommand("gurp", result)
+        self.assertFalse(result.Succeeded())
+
+        # Check aliases with text replacement.
+        self.runCmd("alias pltty process launch -s -o %1 -e %1")
+        command_interpreter.ResolveCommand("pltty /dev/tty0", result)
+        self.assertTrue(result.Succeeded())
+        self.assertEqual("process launch -s -o /dev/tty0 -e /dev/tty0", result.GetOutput())
+
+        self.runCmd("alias xyzzy breakpoint set -n %1 -l %2")
+        command_interpreter.ResolveCommand("xyzzy main 123", result)
+        self.assertTrue(result.Succeeded())
+        self.assertEqual("breakpoint set -n main -l 123", result.GetOutput().strip())
+
+        # And again, without enough parameters.
+        command_interpreter.ResolveCommand("xyzzy main", result)
+        self.assertFalse(result.Succeeded())
+
+        # Check a command that wants the raw input.
+        command_interpreter.ResolveCommand(r'''sc print "\n\n\tHello!\n"''', result)
+        self.assertTrue(result.Succeeded())
+        self.assertEqual(r'''script print "\n\n\tHello!\n"''', result.GetOutput())
+
+        # Prompt changing stuff should be tested, but this doesn't seem like the
+        # right test to do it in.  It has nothing to do with aliases or abbreviations.
+        #self.runCmd("com sou ./change_prompt.lldb")
+        #self.expect("settings show prompt",
+        #            startstr = 'prompt (string) = "[with-three-trailing-spaces]   "')
+        #self.runCmd("settings clear prompt")
+        #self.expect("settings show prompt",
+        #            startstr = 'prompt (string) = "(lldb) "')
+        #self.runCmd("se se prompt 'Sycamore> '")
+        #self.expect("se sh prompt",
+        #            startstr = 'prompt (string) = "Sycamore> "')
+        #self.runCmd("se cl prompt")
+        #self.expect("set sh prompt",
+        #            startstr = 'prompt (string) = "(lldb) "')
 
 
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()