XFail pexpect tests for Windows hosts.

[zturner]

Looks good

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
 from lldbtest import *
 
 class CommandRegexTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureFreeBSD("llvm.org/pr22784: pexpect failing on the FreeBSD buildbot")
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     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' % (lldbtest_config.lldbExec, self.lldbOption))

test/functionalities/completion/TestCompletion.py

class CommandLineCompletionTestCase(TestBase):
     def classCleanup(cls):
         """Cleanup the test byproducts."""
         try:
             os.remove("child_send.txt")
             os.remove("child_read.txt")
         except:
             pass
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_at(self):
         """Test that 'at' completes to 'attach '."""
         self.complete_from_to('at', 'attach ')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_de(self):
         """Test that 'de' completes to 'detach '."""
         self.complete_from_to('de', 'detach ')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_process_attach_dash_dash_con(self):
         """Test that 'process attach --con' completes to 'process attach --continue '."""
         self.complete_from_to('process attach --con', 'process attach --continue ')
 
     # <rdar://problem/11052829>
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_infinite_loop_while_completing(self):
         """Test that 'process print hello\' completes to itself and does not infinite loop."""
         self.complete_from_to('process print hello\\', 'process print hello\\',
                               turn_off_re_match=True)
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_watchpoint_co(self):
         """Test that 'watchpoint co' completes to 'watchpoint command '."""
         self.complete_from_to('watchpoint co', 'watchpoint command ')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_watchpoint_command_space(self):
         """Test that 'watchpoint command ' completes to ['Available completions:', 'add', 'delete', 'list']."""
         self.complete_from_to('watchpoint command ', ['Available completions:', 'add', 'delete', 'list'])
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_watchpoint_command_a(self):
         """Test that 'watchpoint command a' completes to 'watchpoint command add '."""
         self.complete_from_to('watchpoint command a', 'watchpoint command add ')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_watchpoint_set_variable_dash_w(self):
         """Test that 'watchpoint set variable -w' completes to 'watchpoint set variable -w '."""
         self.complete_from_to('watchpoint set variable -w', 'watchpoint set variable -w ')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_watchpoint_set_variable_dash_w_space(self):
         """Test that 'watchpoint set variable -w ' completes to ['Available completions:', 'read', 'write', 'read_write']."""
         self.complete_from_to('watchpoint set variable -w ', ['Available completions:', 'read', 'write', 'read_write'])
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_watchpoint_set_ex(self):
         """Test that 'watchpoint set ex' completes to 'watchpoint set expression '."""
         self.complete_from_to('watchpoint set ex', 'watchpoint set expression ')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_watchpoint_set_var(self):
         """Test that 'watchpoint set var' completes to 'watchpoint set variable '."""
         self.complete_from_to('watchpoint set var', 'watchpoint set variable ')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_watchpoint_set_variable_dash_w_read_underbar(self):
         """Test that 'watchpoint set variable -w read_' completes to 'watchpoint set variable -w read_write'."""
         self.complete_from_to('watchpoint set variable -w read_', 'watchpoint set variable -w read_write')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_help_fi(self):
         """Test that 'help fi' completes to ['Available completions:', 'file', 'finish']."""
         self.complete_from_to('help fi', ['Available completions:', 'file', 'finish'])
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_help_watchpoint_s(self):
         """Test that 'help watchpoint s' completes to 'help watchpoint set '."""
         self.complete_from_to('help watchpoint s', 'help watchpoint set ')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_settings_append_target_er(self):
         """Test that 'settings append target.er' completes to 'settings append target.error-path'."""
         self.complete_from_to('settings append target.er', 'settings append target.error-path')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_settings_insert_after_target_en(self):
         """Test that 'settings insert-after target.env' completes to 'settings insert-after target.env-vars'."""
         self.complete_from_to('settings insert-after target.env', 'settings insert-after target.env-vars')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_settings_insert_before_target_en(self):
         """Test that 'settings insert-before target.env' completes to 'settings insert-before target.env-vars'."""
         self.complete_from_to('settings insert-before target.env', 'settings insert-before target.env-vars')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_settings_replace_target_ru(self):
         """Test that 'settings replace target.ru' completes to 'settings replace target.run-args'."""
         self.complete_from_to('settings replace target.ru', 'settings replace target.run-args')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_settings_s(self):
         """Test that 'settings s' completes to ['Available completions:', 'set', 'show']."""
         self.complete_from_to('settings s', ['Available completions:', 'set', 'show'])
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_settings_set_th(self):
         """Test that 'settings set th' completes to 'settings set thread-format'."""
         self.complete_from_to('settings set th', 'settings set thread-format')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_settings_s_dash(self):
         """Test that 'settings set -' completes to 'settings set -g'."""
         self.complete_from_to('settings set -', 'settings set -g')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_settings_clear_th(self):
         """Test that 'settings clear th' completes to 'settings clear thread-format'."""
         self.complete_from_to('settings clear th', 'settings clear thread-format')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_settings_set_ta(self):
         """Test that 'settings set ta' completes to 'settings set target.'."""
         self.complete_from_to('settings set ta', 'settings set target.')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_settings_set_target_exec(self):
         """Test that 'settings set target.exec' completes to 'settings set target.exec-search-paths '."""
         self.complete_from_to('settings set target.exec', 'settings set target.exec-search-paths')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_settings_set_target_pr(self):
         """Test that 'settings set target.pr' completes to ['Available completions:',
         'target.prefer-dynamic-value', 'target.process.']."""
         self.complete_from_to('settings set target.pr',
                               ['Available completions:',
                                'target.prefer-dynamic-value',
                                'target.process.'])
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_settings_set_target_process(self):
         """Test that 'settings set target.process' completes to 'settings set target.process.'."""
         self.complete_from_to('settings set target.process', 'settings set target.process.')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_settings_set_target_process_dot(self):
         """Test that 'settings set target.process.t' completes to 'settings set target.process.thread.'."""
         self.complete_from_to('settings set target.process.t', 'settings set target.process.thread.')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_settings_set_target_process_thread_dot(self):
         """Test that 'settings set target.process.thread.' completes to ['Available completions:',
         'target.process.thread.step-avoid-regexp', 'target.process.thread.trace-thread']."""
         self.complete_from_to('settings set target.process.thread.',
                               ['Available completions:',
                                'target.process.thread.step-avoid-regexp',
                                'target.process.thread.trace-thread'])
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_target_space(self):
         """Test that 'target ' completes to ['Available completions:', 'create', 'delete', 'list',
         'modules', 'select', 'stop-hook', 'variable']."""
         self.complete_from_to('target ',
                               ['Available completions:', 'create', 'delete', 'list',
                                'modules', 'select', 'stop-hook', 'variable'])
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     def test_target_create_dash_co(self):
         """Test that 'target create --co' completes to 'target variable --core '."""
         self.complete_from_to('target create --co', 'target create --core ')
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     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"""

test/functionalities/format/TestFormats.py

 """
 Test the command history mechanism
 """
 
 import os
 import unittest2
 import lldb
 from lldbtest import *
 
 class TestFormats(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureFreeBSD("llvm.org/pr22784: pexpect failing on the FreeBSD buildbot")
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_formats(self):
         """Test format string functionality."""
         self.buildDwarf ()
         import pexpect
         prompt = "(lldb) "
         child = pexpect.spawn('%s %s -x -o "b main" -o r a.out' % (lldbtest_config.lldbExec, self.lldbOption))
         # Turn on logging for what the child sends back.
         if self.TraceOn():

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

def classCleanup(cls):
         try:
             os.remove("child_send.txt")
             os.remove("child_read.txt")
             os.remove(cls.myexe)
         except:
             pass
 
     @expectedFailureFreeBSD("llvm.org/pr22784: pexpect failing on the FreeBSD buildbot")
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     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([["cp", "a.out", "\"%s\"" % self.myexe]])
 
         # The default lldb prompt.
         prompt = "(lldb) "

test/lldbtest.py

def expectedFailurex86_64(bugnumber=None):
     return expectedFailureArch('x86_64', bugnumber)
 
 def expectedFailureOS(oslist, bugnumber=None, compilers=None):
     def fn(self):
         return (self.getPlatform() in oslist and
                 self.expectedCompiler(compilers))
     return expectedFailure(fn, bugnumber)
 
+def expectedFailureHostOS(oslist, bugnumber=None, compilers=None):
+    def fn(self):
+        return (getHostPlatform() in oslist and
+                self.expectedCompiler(compilers))
+    return expectedFailure(fn, bugnumber)
+
 def expectedFailureDarwin(bugnumber=None, compilers=None):
     # For legacy reasons, we support both "darwin" and "macosx" as OS X triples.
     return expectedFailureOS(getDarwinOSTriples(), bugnumber, compilers)
 
 def expectedFailureFreeBSD(bugnumber=None, compilers=None):
     return expectedFailureOS(['freebsd'], bugnumber, compilers)
 
 def expectedFailureLinux(bugnumber=None, compilers=None):
     return expectedFailureOS(['linux'], bugnumber, compilers)
 
 def expectedFailureWindows(bugnumber=None, compilers=None):
     return expectedFailureOS(['windows'], bugnumber, compilers)
 
+def expectedFailureHostWindows(bugnumber=None, compilers=None):
+    return expectedFailureHostOS(['windows'], bugnumber, compilers)
+
 def expectedFailureAndroid(bugnumber=None, api_levels=None):
     """ Mark a test as xfail for Android.
 
     Arguments:
         bugnumber - The LLVM pr associated with the problem.
         api_levels - A sequence of numbers specifying the Android API levels
             for which a test is expected to fail.
     """

test/terminal/TestSTTYBeforeAndAfter.py

class CommandLineCompletionTestCase(TestBase):
     @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")
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureHostWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     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.]+> "