Fix portability problems in lots of tests

[zturner]

Summary

99% of this CL is simply moving calls to "import pexpect" to a more narrow scope - i.e. the function that actually runs a particular test. This way the test suite can run on Windows, which doesn't have pexpect, and the individual tests that use pexpect can be disabled on a platform-specific basis.

There were a handful of other changes that address other portability issues. Notably, using "ps" to get the command line (changed to use ' '.join(sys.argv)), and using os.uname() which isn't on Windows.

[zturner]

Adds the builder_win32 module. Test suite runs!

[tfiala]

Sweet goodness. I will give this a shot tonight on a few systems.

[tfiala]

Tested:
MacOSX 10.9.4, Xcode 6 Beta 1, all tests passed.

I'll hit this on Linux tonight.

[tfiala]

Linux (Ubuntu 14.04 x86_64) local tests passed with nothing new broken. I did see the one test that I am seeing fail occasionally, TestStopHookMultipleThreads.py, but this has been failing independent of these test changes).

[zturner]

Closed by commit rL213343 (authored by @zturner).

lldb/trunk/test/benchmarks/disassembly/TestDisassembly.py

 """Disassemble lldb's Driver::MainLoop() functions comparing lldb against gdb."""
 
 import os, sys
 import unittest2
 import lldb
-import pexpect
 from lldbbench import *
 
 def is_exe(fpath):
     """Returns true if fpath is an executable."""
     return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
 
 class DisassembleDriverMainLoop(BenchBase):
 
def test_run_gdb_then_lldb(self):
         print
         self.run_gdb_disassembly(self.exe, self.function, self.count)
         print "gdb benchmark:", self.stopwatch
         self.run_lldb_disassembly(self.exe, self.function, self.count)
         print "lldb benchmark:", self.stopwatch
         print "lldb_avg/gdb_avg: %f" % (self.lldb_avg/self.gdb_avg)
 
     def run_lldb_disassembly(self, exe, function, count):
+        import pexpect
         # Set self.child_prompt, which is "(lldb) ".
         self.child_prompt = '(lldb) '
         prompt = self.child_prompt
 
         # So that the child gets torn down after the test.
         self.child = pexpect.spawn('%s %s %s' % (self.lldbExec, self.lldbOption, exe))
         child = self.child
 
def run_lldb_disassembly(self, exe, function, count):
             pass
 
         self.lldb_avg = self.stopwatch.avg()
         if self.TraceOn():
             print "lldb disassembly benchmark:", str(self.stopwatch)
         self.child = None
 
     def run_gdb_disassembly(self, exe, function, count):
+        import pexpect
         # Set self.child_prompt, which is "(gdb) ".
         self.child_prompt = '(gdb) '
         prompt = self.child_prompt
 
         # So that the child gets torn down after the test.
         self.child = pexpect.spawn('%s --nx %s' % (self.gdbExec, exe))
         child = self.child
 

lldb/trunk/test/benchmarks/disassembly/TestDoAttachThenDisassembly.py

 """Test lldb's disassemblt speed.  This bench deliberately attaches to an lldb
 inferior and traverses the stack for thread0 to arrive at frame with function
 'MainLoop'.  It is important to specify an lldb executable as the inferior."""
 
 import os, sys
 import unittest2
 import lldb
-import pexpect
 from lldbbench import *
 
 class AttachThenDisassemblyBench(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)

lldb/trunk/test/benchmarks/disassembly/TestXcode41Vs42GDBDisassembly.py

 """Disassemble lldb's Driver::MainLoop() functions comparing Xcode 4.1 vs. 4.2's gdb."""
 
 import os, sys
 import unittest2
 import lldb
-import pexpect
 from lldbbench import *
 
 class XCode41Vs42GDBDisassembly(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)
def test_run_42_then_41(self):
         print "4.2 gdb benchmark:", self.stopwatch
         self.gdb_42_avg = self.stopwatch.avg()
         self.run_gdb_disassembly(self.gdb_41_exe, self.exe, self.function, self.count)
         print "4.1 gdb benchmark:", self.stopwatch
         self.gdb_41_avg = self.stopwatch.avg()
         print "gdb_42_avg/gdb_41_avg: %f" % (self.gdb_42_avg/self.gdb_41_avg)
 
     def run_gdb_disassembly(self, gdb_exe_path, exe, function, count):
+        import pexpect
         # Set self.child_prompt, which is "(gdb) ".
         self.child_prompt = '(gdb) '
         prompt = self.child_prompt
 
         # So that the child gets torn down after the test.
         self.child = pexpect.spawn('%s --nx %s' % (gdb_exe_path, exe))
         child = self.child
 

lldb/trunk/test/benchmarks/expression/TestExpressionCmd.py

 """Test lldb's expression evaluations and collect statistics."""
 
 import os, sys
 import unittest2
 import lldb
-import pexpect
 from lldbbench import *
 
 class ExpressionEvaluationCase(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)
def test_expr_cmd(self):
         self.buildDefault()
         self.exe_name = 'a.out'
 
         print
         self.run_lldb_repeated_exprs(self.exe_name, self.count)
         print "lldb expr cmd benchmark:", self.stopwatch
 
     def run_lldb_repeated_exprs(self, exe_name, count):
+        import pexpect
         exe = os.path.join(os.getcwd(), exe_name)
 
         # Set self.child_prompt, which is "(lldb) ".
         self.child_prompt = '(lldb) '
         prompt = self.child_prompt
 
         # Reset the stopwatch now.
         self.stopwatch.reset()

lldb/trunk/test/benchmarks/expression/TestRepeatedExprs.py

 """Test evaluating expressions repeatedly comparing lldb against gdb."""
 
 import os, sys
 import unittest2
 import lldb
-import pexpect
 from lldbbench import *
 
 class RepeatedExprsCase(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)
def test_compare_lldb_to_gdb(self):
         print
         self.run_lldb_repeated_exprs(self.exe_name, self.count)
         print "lldb benchmark:", self.stopwatch
         self.run_gdb_repeated_exprs(self.exe_name, self.count)
         print "gdb benchmark:", self.stopwatch
         print "lldb_avg/gdb_avg: %f" % (self.lldb_avg/self.gdb_avg)
 
     def run_lldb_repeated_exprs(self, exe_name, count):
+        import pexpect
         exe = os.path.join(os.getcwd(), exe_name)
 
         # Set self.child_prompt, which is "(lldb) ".
         self.child_prompt = '(lldb) '
         prompt = self.child_prompt
 
         # So that the child gets torn down after the test.
         self.child = pexpect.spawn('%s %s %s' % (self.lldbExec, self.lldbOption, exe))
def run_lldb_repeated_exprs(self, exe_name, count):
             pass
 
         self.lldb_avg = self.stopwatch.avg()
         if self.TraceOn():
             print "lldb expression benchmark:", str(self.stopwatch)
         self.child = None
 
     def run_gdb_repeated_exprs(self, exe_name, count):
+        import pexpect
         exe = os.path.join(os.getcwd(), exe_name)
 
         # Set self.child_prompt, which is "(gdb) ".
         self.child_prompt = '(gdb) '
         prompt = self.child_prompt
 
         # So that the child gets torn down after the test.
         self.child = pexpect.spawn('gdb --nx %s' % exe)

lldb/trunk/test/benchmarks/frame_variable/TestFrameVariableResponse.py

 """Test lldb's response time for 'frame variable' command."""
 
 import os, sys
 import unittest2
 import lldb
-import pexpect
 from lldbbench import *
 
 class FrameVariableResponseBench(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)
class FrameVariableResponseBench(BenchBase):
     @benchmarks_test
     def test_startup_delay(self):
         """Test response time for the 'frame variable' command."""
         print
         self.run_frame_variable_bench(self.exe, self.break_spec, self.count)
         print "lldb frame variable benchmark:", self.stopwatch
 
     def run_frame_variable_bench(self, exe, break_spec, count):
+        import pexpect
         # Set self.child_prompt, which is "(lldb) ".
         self.child_prompt = '(lldb) '
         prompt = self.child_prompt
 
         # Reset the stopwatchs now.
         self.stopwatch.reset()
         for i in range(count):
             # So that the child gets torn down after the test.

lldb/trunk/test/benchmarks/startup/TestStartupDelays.py

 """Test lldb's startup delays creating a target, setting a breakpoint, and run to breakpoint stop."""
 
 import os, sys
 import unittest2
 import lldb
-import pexpect
 from lldbbench import *
 
 class StartupDelaysBench(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)
def test_startup_delay(self):
         """Test start up delays creating a target, setting a breakpoint, and run to breakpoint stop."""
         print
         self.run_startup_delays_bench(self.exe, self.break_spec, self.count)
         print "lldb startup delay (create fresh target) benchmark:", self.stopwatch
         print "lldb startup delay (set first breakpoint) benchmark:", self.stopwatch2
         print "lldb startup delay (run to breakpoint) benchmark:", self.stopwatch3
 
     def run_startup_delays_bench(self, exe, break_spec, count):
+        import pexpect
         # Set self.child_prompt, which is "(lldb) ".
         self.child_prompt = '(lldb) '
         prompt = self.child_prompt
 
         # Reset the stopwatchs now.
         self.stopwatch.reset()
         self.stopwatch2.reset()
         for i in range(count):

lldb/trunk/test/benchmarks/stepping/TestRunHooksThenSteppings.py

 """Test lldb's stepping speed."""
 
 import os, sys
 import unittest2
 import lldb
-import pexpect
 from lldbbench import *
 
 class RunHooksThenSteppingsBench(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)
         self.count = lldb.bmIterationCount
         if self.count <= 0:
             self.count = 50
 
     @benchmarks_test
     def test_lldb_runhooks_then_steppings(self):
         """Test lldb steppings on a large executable."""
         print
         self.run_lldb_runhooks_then_steppings(self.count)
         print "lldb stepping benchmark:", self.stopwatch
 
     def run_lldb_runhooks_then_steppings(self, count):
+        import pexpect
         # Set self.child_prompt, which is "(lldb) ".
         self.child_prompt = '(lldb) '
         prompt = self.child_prompt
 
         self.child = pexpect.spawn('%s %s' % (self.lldbHere, self.lldbOption))
         self.child.expect_exact(prompt)
         # So that the child gets torn down after the test.
         child = self.child

lldb/trunk/test/benchmarks/stepping/TestSteppingSpeed.py

 """Test lldb's stepping speed."""
 
 import os, sys
 import unittest2
 import lldb
-import pexpect
 from lldbbench import *
 
 class SteppingSpeedBench(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)
class SteppingSpeedBench(BenchBase):
     @benchmarks_test
     def test_run_lldb_steppings(self):
         """Test lldb steppings on a large executable."""
         print
         self.run_lldb_steppings(self.exe, self.break_spec, self.count)
         print "lldb stepping benchmark:", self.stopwatch
 
     def run_lldb_steppings(self, exe, break_spec, count):
+        import pexpect
         # Set self.child_prompt, which is "(lldb) ".
         self.child_prompt = '(lldb) '
         prompt = self.child_prompt
 
         # So that the child gets torn down after the test.
         self.child = pexpect.spawn('%s %s %s' % (self.lldbHere, self.lldbOption, exe))
         child = self.child
 

lldb/trunk/test/benchmarks/turnaround/TestCompileRunToBreakpointTurnaround.py

 """Benchmark the turnaround time starting a debugger and run to the breakpont with lldb vs. gdb."""
 
 import os, sys
 import unittest2
 import lldb
-import pexpect
 from lldbbench import *
 
 class CompileRunToBreakpointBench(BenchBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         BenchBase.setUp(self)
def test_run_lldb_then_gdb(self):
         print
         self.run_lldb_turnaround(self.exe, self.function, self.count)
         print "lldb turnaround benchmark:", self.stopwatch
         self.run_gdb_turnaround(self.exe, self.function, self.count)
         print "gdb turnaround benchmark:", self.stopwatch
         print "lldb_avg/gdb_avg: %f" % (self.lldb_avg/self.gdb_avg)
 
     def run_lldb_turnaround(self, exe, function, count):
+        import pexpect
         def run_one_round():
             prompt = self.child_prompt
 
             # So that the child gets torn down after the test.
             self.child = pexpect.spawn('%s %s %s' % (self.lldbExec, self.lldbOption, exe))
             child = self.child
 
             # Turn on logging for what the child sends back.
def run_lldb_turnaround(self, exe, function, count):
                 self.child.expect(pexpect.EOF)
             except:
                 pass
 
         self.lldb_avg = self.stopwatch.avg()
         self.child = None
 
     def run_gdb_turnaround(self, exe, function, count):
+        import pexpect
         def run_one_round():
             prompt = self.child_prompt
 
             # So that the child gets torn down after the test.
             self.child = pexpect.spawn('gdb --nx %s' % exe)
             child = self.child
 
             # Turn on logging for what the child sends back.

lldb/trunk/test/dotest.py

if ("GDB_REMOTE_LOG" in os.environ):
         ci.HandleCommand(
             "log enable -n -f " + os.environ["GDB_REMOTE_LOG"] + " gdb-remote "
             + gdb_remote_log_option,
             res)
         if not res.Succeeded():
             raise Exception('log enable failed (check GDB_REMOTE_LOG env variable)')
 
 def getMyCommandLine():
-    ps = subprocess.Popen([which('ps'), '-o', "command=CMD", str(os.getpid())], stdout=subprocess.PIPE).communicate()[0]
-    lines = ps.split('\n')
-    cmd_line = lines[1]
-    return cmd_line
+    return ' '.join(sys.argv)
 
 # ======================================== #
 #                                          #
 # Execution of the test driver starts here #
 #                                          #
 # ======================================== #
 
 def checkDsymForUUIDIsNotOn():

lldb/trunk/test/functionalities/command_history/TestCommandHistory.py

 """
 Test the command history mechanism
 """
 
 import os
 import unittest2
 import lldb
-import pexpect
 from lldbtest import *
 
 class CommandHistoryTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def test_history(self):
         self.runCmd('command history --clear', inHistory=False)

lldb/trunk/test/functionalities/command_regex/TestCommandRegex.py

 """
 Test lldb 'commands regex' command which allows the user to create a regular expression command.
 """
 
 import os
 import unittest2
 import lldb
-import pexpect
 from lldbtest import *
 
 class CommandRegexTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def test_command_regex(self):
         """Test a simple scenario of 'command regex' invocation and subsequent use."""
+        import pexpect
         prompt = "(lldb) "
         regex_prompt = "Enter one of more sed substitution commands in the form: 's/<regex>/<subst>/'.\r\nTerminate the substitution list with an empty line.\r\n"
         regex_prompt1 = "\r\n"
 
         child = pexpect.spawn('%s %s' % (self.lldbHere, self.lldbOption))
         # Turn on logging for what the child sends back.
         if self.TraceOn():
             child.logfile_read = sys.stdout

lldb/trunk/test/functionalities/completion/TestCompletion.py

 """
 Test the lldb command line completion mechanism.
 """
 
 import os
 import unittest2
 import lldb
-import pexpect
 from lldbtest import *
 
 class CommandLineCompletionTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @classmethod
     def classCleanup(cls):
class CommandLineCompletionTestCase(TestBase):
 
     def test_target_va(self):
         """Test that 'target va' completes to 'target variable '."""
         self.complete_from_to('target va', 'target variable ')
 
     def complete_from_to(self, str_input, patterns, turn_off_re_match=False):
         """Test that the completion mechanism completes str_input to patterns,
         where patterns could be a pattern-string or a list of pattern-strings"""
+        import pexpect
         # Patterns should not be None in order to proceed.
         self.assertFalse(patterns is None)
         # And should be either a string or list of strings.  Check for list type
         # below, if not, make a list out of the singleton string.  If patterns
         # is not a string or not a list of strings, there'll be runtime errors
         # later on.
         if not isinstance(patterns, list):
             patterns = [patterns]

lldb/trunk/test/functionalities/connect_remote/TestConnectRemote.py

 """
 Test lldb 'process connect' command.
 """
 
 import os
 import unittest2
 import lldb
-import pexpect
 from lldbtest import *
 
 class ConnectRemoteTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def test_connect_remote(self):
         """Test "process connect connect:://localhost:12345"."""
 
+        import pexpect
         # First, we'll start a fake debugserver (a simple echo server).
         fakeserver = pexpect.spawn('./EchoServer.py')
 
         # Turn on logging for what the child sends back.
         if self.TraceOn():
             fakeserver.logfile_read = sys.stdout
 
         # Schedule the fake debugserver to be shutting down during teardown.

lldb/trunk/test/functionalities/embedded_interpreter/TestConvenienceVariables.py

 """Test convenience variables when you drop in from lldb prompt into an embedded interpreter."""
 
 import os
 import unittest2
 import lldb
-import pexpect
 from lldbtest import *
 
 class ConvenienceVariablesCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     @dsym_test
class ConvenienceVariablesCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break on inside main.cpp.
         self.line = line_number('main.c', 'Hello world.')
 
     def convenience_variables(self):
         """Test convenience variables lldb.debugger, lldb.target, lldb.process, lldb.thread, and lldb.frame."""
+        import pexpect
         exe = os.path.join(os.getcwd(), "a.out")
         prompt = "(lldb) "
         python_prompt = ">>> "
 
         # So that the child gets torn down after the test.
         self.child = pexpect.spawn('%s %s %s' % (self.lldbHere, self.lldbOption, exe))
         child = self.child
         # Turn on logging for what the child sends back.

lldb/trunk/test/functionalities/single-quote-in-filename-to-lldb/TestSingleQuoteInFilename.py

 """
 Test the lldb command line takes a filename with single quote chars.
 """
 
 import os
 import unittest2
 import lldb
-import pexpect
 from lldbtest import *
 
 class SingleQuoteInCommandLineTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     myexe = "path with '09/a.out"
 
     @classmethod
     def classCleanup(cls):
         """Cleanup the test byproducts."""
         try:
             os.remove("child_send.txt")
             os.remove("child_read.txt")
             os.remove(cls.myexe)
         except:
             pass
 
     def test_lldb_invocation_with_single_quote_in_filename(self):
         """Test that 'lldb my_file_name' works where my_file_name is a string with a single quote char in it."""
+        import pexpect
         self.buildDefault()
         system(["/bin/sh", "-c", "cp a.out \"%s\"" % self.myexe])
 
         # The default lldb prompt.
         prompt = "(lldb) "
 
         # So that the child gets torn down after the test.
         self.child = pexpect.spawn('%s %s "%s"' % (self.lldbHere, self.lldbOption, self.myexe))

lldb/trunk/test/functionalities/stop-hook/TestStopHookMechanism.py

 """
 Test lldb target stop-hook mechanism to see whether it fires off correctly .
 """
 
 import os
 import unittest2
 import lldb
-import pexpect
 from lldbtest import *
 
 class StopHookMechanismTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     @dsym_test
def setUp(self):
         # Find the line numbers inside main.cpp.
         self.begl = line_number('main.cpp', '// Set breakpoint here to test target stop-hook.')
         self.endl = line_number('main.cpp', '// End of the line range for which stop-hook is to be run.')
         self.correct_step_line = line_number ('main.cpp', '// We should stop here after stepping.')
         self.line = line_number('main.cpp', '// Another breakpoint which is outside of the stop-hook range.')
 
     def stop_hook_firing(self):
         """Test the stop-hook mechanism."""
+        import pexpect
         exe = os.path.join(os.getcwd(), "a.out")
         prompt = "(lldb) "
         add_prompt = "Enter your stop hook command(s).  Type 'DONE' to end.\r\n> "
         add_prompt1 = "\r\n> "
 
         # So that the child gets torn down after the test.
         self.child = pexpect.spawn('%s %s %s' % (self.lldbHere, self.lldbOption, exe))
         child = self.child

lldb/trunk/test/functionalities/stop-hook/multiple_threads/TestStopHookMultipleThreads.py

 """
 Test that lldb stop-hook works for multiple threads.
 """
 
 import os, time
 import unittest2
 import lldb
-import pexpect
 from lldbtest import *
 
 class StopHookForMultipleThreadsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     @dsym_test
def setUp(self):
         self.first_stop = line_number(self.source, '// Set break point at this line, and add a stop-hook.')
         self.thread_function = line_number(self.source, '// Break here to test that the stop-hook mechanism works for multiple threads.')
         # Build dictionary to have unique executable names for each test method.
         self.exe_name = self.testMethodName
         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     def stop_hook_multiple_threads(self):
         """Test that lldb stop-hook works for multiple threads."""
+        import pexpect
         exe = os.path.join(os.getcwd(), self.exe_name)
         prompt = "(lldb) "
 
         # So that the child gets torn down after the test.
         self.child = pexpect.spawn('%s %s %s' % (self.lldbHere, self.lldbOption, exe))
         child = self.child
         # Turn on logging for what the child sends back.
         if self.TraceOn():

lldb/trunk/test/macosx/add-dsym/TestAddDsymMidExecutionCommand.py

 """Test that the 'add-dsym', aka 'target symbols add', succeeds in the middle of debug session."""
 
 import os, time
 import unittest2
 import lldb
-import pexpect
 import sys
 from lldbtest import *
 
 @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
 class AddDsymMidExecutionCommandCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 

lldb/trunk/test/plugins/builder_win32.py

+from builder_base import *
+
+def buildDsym(sender=None, architecture=None, compiler=None, dictionary=None, clean=True):
+    return False

lldb/trunk/test/python_api/interpreter/TestCommandInterpreterAPI.py

 """Test the SBCommandInterpreter APIs."""
 
 import os
 import unittest2
 import lldb
-import pexpect
 from lldbtest import *
 
 class CommandInterpreterAPICase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     @python_api_test

lldb/trunk/test/python_api/sbdata/TestSBData.py

 """Test the SBData APIs."""
 
 import os
 import unittest2
 import lldb
-import pexpect
 from lldbtest import *
 from math import fabs
 import lldbutil
 
 class SBDataAPICase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 

lldb/trunk/test/settings/TestSettings.py

def test_set_auto_confirm(self):
         self.expect("breakpoint delete",
             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")
 
-    @unittest2.skipUnless(os.uname()[4] in ['amd64', 'i386', 'x86_64'], "requires x86 or x86_64")
+    @unittest2.skipUnless(os.name != "nt" and os.uname()[4] in ['amd64', 'i386', 'x86_64'], "requires x86 or x86_64")
     def test_disassembler_settings(self):
         """Test that user options for the disassembler take effect."""
         self.buildDefault()
 
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # AT&T syntax

lldb/trunk/test/terminal/TestSTTYBeforeAndAfter.py

 """
 Test that 'stty -a' displays the same output before and after running the lldb command.
 """
 
 import os
 import unittest2
 import lldb
-import pexpect
 from lldbtest import *
 
 class CommandLineCompletionTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @classmethod
     def classCleanup(cls):
         """Cleanup the test byproducts."""
         cls.RemoveTempFile("child_send1.txt")
         cls.RemoveTempFile("child_read1.txt")
         cls.RemoveTempFile("child_send2.txt")
         cls.RemoveTempFile("child_read2.txt")
 
     def test_stty_dash_a_before_and_afetr_invoking_lldb_command(self):
         """Test that 'stty -a' displays the same output before and after running the lldb command."""
-
+        import pexpect
         if not which('expect'):
             self.skipTest("The 'expect' program cannot be located, skip the test")
 
         # The expect prompt.
         expect_prompt = "expect[0-9.]+> "
         # The default lldb prompt.
         lldb_prompt = "(lldb) "
 

lldb/trunk/test/tools/lldb-gdbserver/gdbremote_testcase.py

 """
 Base class for gdb-remote test cases.
 """
 
 import errno
 import os
 import os.path
-import pexpect
 import platform
 import random
 import re
 import sets
 import signal
 import socket
 import subprocess
 import sys
class GdbRemoteTestCaseBase(TestBase):
     def set_inferior_startup_launch(self):
         self._inferior_startup = self._STARTUP_LAUNCH
 
     def set_inferior_startup_attach(self):
         self._inferior_startup = self._STARTUP_ATTACH
 
     def launch_debug_monitor(self, attach_pid=None):
         # Create the command line.
+        import pexpect
         commandline = "{}{} localhost:{}".format(self.debug_monitor_exe, self.debug_monitor_extra_args, self.port)
         if attach_pid:
             commandline += " --attach=%d" % attach_pid
         if self.named_pipe_path:
             commandline += " --named-pipe %s" % self.named_pipe_path
 
         # Start the server.
         server = pexpect.spawn(commandline)

lldb/trunk/test/warnings/uuid/TestAddDsymCommand.py

 """Test that the 'add-dsym', aka 'target symbols add', command informs the user about success or failure."""
 
 import os, time
 import unittest2
 import lldb
-import pexpect
 from lldbtest import *
 
 @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
 class AddDsymCommandCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):