Make LLDB-MI tests wait for LLDB-MI to start up before sending any MI commands

[enlight]

Summary

This set of changes addresses the issue I described in Bug 23403, in short most LLDB-MI tests fail unexpectedly due to timeout on my Ubuntu 14.10 x86_64 VirtualBox VM. I have no idea why the Ubuntu buildbots don't seem to suffer from this issue. This patch just makes MiTestCaseBase.spawnLldbMi() block until the spawned LLDB-MI child process outputs the (gdb) prompt, which ensures that MI commands aren't sent to the LLDB-MI child process until it's ready.

Before these changes 52 LLDB-MI tests failed unexpectedly (all but one due to timeouts), after these changes no tests fail due to timeouts. I still get one unexpected failure in test_lldbmi_source_option_start_script_error in TestMiStartupOptions.py, but that's due to a file error, that test should be skipped on Linux just like the other two start_script tests until the file error is fixed.

[ki.stfu]

lgtm

lldb/trunk/test/tools/lldb-mi/TestMiPrompt.py

class MiPromptTestCase(lldbmi_testcase.MiTestCaseBase):
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_prompt(self):
         """Test that 'lldb-mi --interpreter' echos '(gdb)' after commands and events."""
 
         self.spawnLldbMi(args = None)
 
-        # Test that lldb-mi is ready after startup
-        self.expect(self.child_prompt, exactly = True)
-
         # Test that lldb-mi is ready after unknown command
         self.runCmd("-unknown-command")
         self.expect("\^error,msg=\"Driver\. Received command '-unknown-command'\. It was not handled\. Command 'unknown-command' not in Command Factory\"")
         self.expect(self.child_prompt, exactly = True)
 
         # Test that lldb-mi is ready after -file-exec-and-symbols
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")

lldb/trunk/test/tools/lldb-mi/data/TestMiData.py

class MiDataTestCase(lldbmi_testcase.MiTestCaseBase):
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_data_read_memory_bytes_local(self):
         """Test that -data-read-memory-bytes can access local buffers."""
 
         self.spawnLldbMi(args = None)
-        self.expect(self.child_prompt, exactly = True)
 
         # Load executable
         self.runCmd('-file-exec-and-symbols %s' % self.myexe)
         self.expect(r'\^done')
 
         # Run to BP_local_array_test_inner
         line = line_number('main.cpp', '// BP_local_array_test_inner')
         self.runCmd('-break-insert main.cpp:%d' % line)

lldb/trunk/test/tools/lldb-mi/lldbmi_testcase.py

def tearDown(self):
                 pass
         Base.tearDown(self)
 
     def spawnLldbMi(self, args=None):
         self.child = pexpect.spawn("%s --interpreter %s" % (
             self.lldbMiExec, args if args else ""))
         self.child.setecho(True)
         self.child.logfile_read = open(self.mylog, "w")
+        # wait until lldb-mi has started up and is ready to go
+        self.expect(self.child_prompt, exactly = True)
 
     def runCmd(self, cmd):
         self.child.sendline(cmd)
 
     def expect(self, pattern, exactly=False, *args, **kwargs):
         if exactly:
             return self.child.expect_exact(pattern, *args, **kwargs)
         return self.child.expect(pattern, *args, **kwargs)

lldb/trunk/test/tools/lldb-mi/startup_options/TestMiStartupOptions.py

class MiStartupOptionsTestCase(lldbmi_testcase.MiTestCaseBase):
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_executable_option_file(self):
         """Test that 'lldb-mi --interpreter %s' loads executable file."""
 
         self.spawnLldbMi(args = "%s" % self.myexe)
 
-        # Test that lldb-mi is ready after startup
-        self.expect(self.child_prompt, exactly = True)
-
         # Test that the executable is loaded when file was specified
         self.expect("-file-exec-and-symbols \"%s\"" % self.myexe)
         self.expect("\^done")
 
         # Test that lldb-mi is ready when executable was loaded
         self.expect(self.child_prompt, exactly = True)
 
         # Run
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_executable_option_unknown_file(self):
         """Test that 'lldb-mi --interpreter %s' fails on unknown executable file."""
 
         # Prepare path to executable
         path = "unknown_file"
 
         self.spawnLldbMi(args = "%s" % path)
 
-        # Test that lldb-mi is ready after startup
-        self.expect(self.child_prompt, exactly = True)
-
         # Test that the executable isn't loaded when unknown file was specified
         self.expect("-file-exec-and-symbols \"%s\"" % path)
         self.expect("\^error,msg=\"Command 'file-exec-and-symbols'. Target binary '%s' is invalid. error: unable to find executable for '%s'\"" % (path, path))
 
         # Test that lldb-mi is ready when executable was loaded
         self.expect(self.child_prompt, exactly = True)
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_executable_option_absolute_path(self):
         """Test that 'lldb-mi --interpreter %s' loads executable which is specified via absolute path."""
 
         # Prepare path to executable
         import os
         path = os.path.join(os.getcwd(), self.myexe)
 
         self.spawnLldbMi(args = "%s" % path)
 
-        # Test that lldb-mi is ready after startup
-        self.expect(self.child_prompt, exactly = True)
-
         # Test that the executable is loaded when file was specified using absolute path
         self.expect("-file-exec-and-symbols \"%s\"" % path)
         self.expect("\^done")
 
         # Test that lldb-mi is ready when executable was loaded
         self.expect(self.child_prompt, exactly = True)
 
         # Run
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_executable_option_relative_path(self):
         """Test that 'lldb-mi --interpreter %s' loads executable which is specified via relative path."""
 
         # Prepare path to executable
         path = "./%s" % self.myexe
 
         self.spawnLldbMi(args = "%s" % path)
 
-        # Test that lldb-mi is ready after startup
-        self.expect(self.child_prompt, exactly = True)
-
         # Test that the executable is loaded when file was specified using relative path
         self.expect("-file-exec-and-symbols \"%s\"" % path)
         self.expect("\^done")
 
         # Test that lldb-mi is ready when executable was loaded
         self.expect(self.child_prompt, exactly = True)
 
         # Run
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_executable_option_unknown_path(self):
         """Test that 'lldb-mi --interpreter %s' fails on executable file which is specified via unknown path."""
 
         # Prepare path to executable
         path = "unknown_dir/%s" % self.myexe
 
         self.spawnLldbMi(args = "%s" % path)
 
-        # Test that lldb-mi is ready after startup
-        self.expect(self.child_prompt, exactly = True)
-
         # Test that the executable isn't loaded when file was specified using unknown path
         self.expect("-file-exec-and-symbols \"%s\"" % path)
         self.expect("\^error,msg=\"Command 'file-exec-and-symbols'. Target binary '%s' is invalid. error: unable to find executable for '%s'\"" % (path, path))
 
         # Test that lldb-mi is ready when executable was loaded
         self.expect(self.child_prompt, exactly = True)
 
     @lldbmi_test
class MiStartupOptionsTestCase(lldbmi_testcase.MiTestCaseBase):
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_log_option(self):
         """Test that 'lldb-mi --log' creates a log file in the current directory."""
     
         logDirectory = "."
         self.spawnLldbMi(args = "%s --log" % self.myexe)
 
-        # Test that lldb-mi is ready after startup
-        self.expect(self.child_prompt, exactly = True)
-
         # Test that the executable is loaded when file was specified
         self.expect("-file-exec-and-symbols \"%s\"" % self.myexe)
         self.expect("\^done")
 
         # Test that lldb-mi is ready when executable was loaded
         self.expect(self.child_prompt, exactly = True)
 
         # Run
def test_lldbmi_log_directory_option(self):
         """Test that 'lldb-mi --log --log-dir' creates a log file in the directory specified by --log-dir."""
     
         # Create log in temp directory
         import tempfile
         logDirectory = tempfile.gettempdir()
 
         self.spawnLldbMi(args = "%s --log --log-dir=%s" % (self.myexe,logDirectory))
 
-        # Test that lldb-mi is ready after startup
-        self.expect(self.child_prompt, exactly = True)
-
         # Test that the executable is loaded when file was specified
         self.expect("-file-exec-and-symbols \"%s\"" % self.myexe)
         self.expect("\^done")
 
         # Test that lldb-mi is ready when executable was loaded
         self.expect(self.child_prompt, exactly = True)
 
         # Run