Remove expectedFailureWindows decorator

[zturner]

Summary

Putting this up for review not because you guys are interested in windows, but just because I'm hoping to do this with more of the decorators. Assuming nobody has any issues with this, I will do the rest without review.

expectedFailureWindows is equivalent to using the general
expectedFailureAll decorator with oslist="windows".  Additionally,
by moving towards these common decorators we can solve the issue
of having to support decorators that can be called with or without
arguments.  Once all decorators are always called with arguments,
and this is enforced by design (because you can't specify the condition
you're decorating for without passing an argument) the implementation
of the decorators can become much simpler, which in turn will lead to
less difficulties when moving from `unittest2` to `unittest` as well as supporting
class level decorators for skip as well as xfail on all decorators.

[zturner]

One more thing. This patch also causes skips and xfails to include the bugnumber as part of the reason. So you can see bugnumbers on summary output. See the changes to decorators.py for the relevant code.

[tfiala]

I'll go ahead and run this before and after and compare totals.

[tfiala]

I'm seeing 8 errors after applying this diff:

ERROR: test_expr_stripped_dwarf (lang/objc/hidden-ivars/TestHiddenIvars.py)
ERROR: test_frame_variable_stripped_dwarf (lang/objc/hidden-ivars/TestHiddenIvars.py)
ERROR: test_with_python_api_dsym (lang/cpp/class_static/TestStaticVariables.py)
ERROR: test_with_python_api_dwarf (lang/objc/objc-static-method-stripped/TestObjCStaticMethodStripped.py)
ERROR: test_with_python_api_dwarf (lang/objc/objc-ivar-stripped/TestObjCIvarStripped.py)
ERROR: test_with_python_api_dwarf (lang/cpp/class_static/TestStaticVariables.py)
ERROR: test_with_run_command_dsym (lang/cpp/scope/TestCppScope.py)
ERROR: test_with_run_command_dwarf (lang/cpp/scope/TestCppScope.py)

I'll have a peek and see what they say.

[tfiala]

Here's one:

Traceback (most recent call last):
  File "/Users/tfiala/src/lldb-tot/lldb/packages/Python/lldbsuite/test/lldbtest.py", line 1442, in dsym_test_method
    return attrvalue(self)
  File "/Users/tfiala/src/lldb-tot/lldb/packages/Python/lldbsuite/test/decorators.py", line 74, in wrapper
    xfail_reason = expected_fn(self)
  File "/Users/tfiala/src/lldb-tot/lldb/packages/Python/lldbsuite/test/decorators.py", line 171, in fn
    reason_str = reason_str + " [" + bugnumber + "]"
TypeError: cannot concatenate 'str' and 'function' objects

Here's another:

Traceback (most recent call last):
  File "/Users/tfiala/src/lldb-tot/lldb/packages/Python/lldbsuite/test/lldbtest.py", line 1442, in dsym_test_method
    return attrvalue(self)
  File "/Users/tfiala/src/lldb-tot/lldb/packages/Python/lldbsuite/test/decorators.py", line 74, in wrapper
    xfail_reason = expected_fn(self)
  File "/Users/tfiala/src/lldb-tot/lldb/packages/Python/lldbsuite/test/decorators.py", line 171, in fn
    reason_str = reason_str + " [" + bugnumber + "]"
TypeError: cannot concatenate 'str' and 'int' objects
Config=x86_64-/usr/bin/clang

[zturner]

packages/Python/lldbsuite/test/decorators.py

170–171

Can you try changing this to this and see what happens:

if bugnumber is not None and not six.callable(bugnumber):
    reason_str = reason_str + " [" + str(bugnumber) + "]"

[tfiala]

Yep, I'll give that a shot now.

[tfiala]

LGTM with the change you suggested above. I tried that and it worked on OS X. The change itself looked fine as well.

packages/Python/lldbsuite/test/decorators.py

170–171

Yep, that fixed the errors.

[labath]

I agree with the idea in general, but I wanted to ask what is your plan with the android decorators: For them we use the additional api_levels flag, which does not exist on other platforms/decorators. I suppose we could add that flag to expectedFailureAll, but I am not sure if that would be a good idea...

Also, since we are doing all this refactoring, one more improvement I can think of is renaming expectedFailureAll to expectedFailure. It was named All because we already have an expectedFailure function, but I think that one is now more of an implementation detail and could be renamed to something else. Up to you...

[tberghammer]

In D16936#346182, @labath wrote:

I agree with the idea in general, but I wanted to ask what is your plan with the android decorators: For them we use the additional api_levels flag, which does not exist on other platforms/decorators. I suppose we could add that flag to expectedFailureAll, but I am not sure if that would be a good idea...

Also, since we are doing all this refactoring, one more improvement I can think of is renaming expectedFailureAll to expectedFailure. It was named All because we already have an expectedFailure function, but I think that one is now more of an implementation detail and could be renamed to something else. Up to you...

My suggestion for the android API level is to add an argument to expectedFailure where you can specify an arbitrary function and then we can write a function called android_device_matches(...) what will return a function checking for the API level. Then this can be used to create very specific xfail conditions what are checking some property of the target system (e.g. "@expectedFailure(fn=hardwareWatchpointsNotSupported)")

Something like this:

def android_device_matches(apis):
    def impl(apis):
        return get_device_api() in apis
    return impl

[zturner]

In D16936#346293, @tberghammer wrote:

In D16936#346182, @labath wrote:

I agree with the idea in general, but I wanted to ask what is your plan with the android decorators: For them we use the additional api_levels flag, which does not exist on other platforms/decorators. I suppose we could add that flag to expectedFailureAll, but I am not sure if that would be a good idea...

Also, since we are doing all this refactoring, one more improvement I can think of is renaming expectedFailureAll to expectedFailure. It was named All because we already have an expectedFailure function, but I think that one is now more of an implementation detail and could be renamed to something else. Up to you...

My suggestion for the android API level is to add an argument to expectedFailure where you can specify an arbitrary function and then we can write a function called android_device_matches(...) what will return a function checking for the API level. Then this can be used to create very specific xfail conditions what are checking some property of the target system (e.g. "@expectedFailure(fn=hardwareWatchpointsNotSupported)")

Yes, that's one option I thought of. And the function could be specified with any combination of other parameters at the same time, and the result of the function would just be one value checked in determining whether to skip / xfail.

[tberghammer]

In D16936#346408, @zturner wrote:

In D16936#346293, @tberghammer wrote:

In D16936#346182, @labath wrote:

I agree with the idea in general, but I wanted to ask what is your plan with the android decorators: For them we use the additional api_levels flag, which does not exist on other platforms/decorators. I suppose we could add that flag to expectedFailureAll, but I am not sure if that would be a good idea...

Also, since we are doing all this refactoring, one more improvement I can think of is renaming expectedFailureAll to expectedFailure. It was named All because we already have an expectedFailure function, but I think that one is now more of an implementation detail and could be renamed to something else. Up to you...

My suggestion for the android API level is to add an argument to expectedFailure where you can specify an arbitrary function and then we can write a function called android_device_matches(...) what will return a function checking for the API level. Then this can be used to create very specific xfail conditions what are checking some property of the target system (e.g. "@expectedFailure(fn=hardwareWatchpointsNotSupported)")

Yes, that's one option I thought of. And the function could be specified with any combination of other parameters at the same time, and the result of the function would just be one value checked in determining whether to skip / xfail.

I agree but I also might consider going further where the only thing you can specify is a function and we remove all arguments. Then we implement functions like architectureMatches, targetOsMatches, hostOsMatches, etc.. and some logical function what can combine them (e.g. not, any_of, all_of). This way we just build up the condition in the decorator and we don't have a lot of check inside expectedFailure. What do you think?

[tfiala]

I agree but I also might consider going further where the only thing you can specify is a function and we remove all arguments. Then we implement functions like architectureMatches, targetOsMatches, hostOsMatches, etc.. and some logical function what can combine them (e.g. not, any_of, all_of). This way we just build up the condition in the decorator and we don't have a lot of check inside expectedFailure. What do you think?

That does sound pretty appealing.

So then there would be some kind of combinator functions that do the equivalent of "or" and "and" logical operations? So you can get something like ((tes1() && test2()) or test3())?

-Todd

[tberghammer]

In D16936#346536, @tfiala wrote:

I agree but I also might consider going further where the only thing you can specify is a function and we remove all arguments. Then we implement functions like architectureMatches, targetOsMatches, hostOsMatches, etc.. and some logical function what can combine them (e.g. not, any_of, all_of). This way we just build up the condition in the decorator and we don't have a lot of check inside expectedFailure. What do you think?

That does sound pretty appealing.

So then there would be some kind of combinator functions that do the equivalent of "or" and "and" logical operations? So you can get something like ((tes1() && test2()) or test3())?

-Todd

I think we need an extra level of function nesting so the conditions only evaluated during the execution of the test. Because of it all test function will have to return a function (taking no argument) and we can't apply binary operators to them directly so I expect something like this: or(and(test1(), test2()), test3()) If you want to use binary operators then we have to use operator overloading what is a bit more work and I am not sure if it worth it but it is still possible.

[zturner]

I'm not opposed to it in principle, but I think we should optimize the design for conciseness at the point where you decorate a class or function. If it makes the point of decoration more verbose or harder to read, then I would probably be against it. I guess I'd need to see a proposed syntax for what you want it to look like when you decorate a function.

[zturner]

In D16936#346594, @zturner wrote:

I'm not opposed to it in principle, but I think we should optimize the design for conciseness at the point where you decorate a class or function. If it makes the point of decoration more verbose or harder to read, then I would probably be against it. I guess I'd need to see a proposed syntax for what you want it to look like when you decorate a function.

I did think of one possible way to make this elegant (at least in my opinion). I like the keyword argument syntax because it makes it clear at a glance what you are testing, and it's also very concise while still allowing complex conditionals to be built up.

But one area that is lacking is the ability for it to specify OR conditions. Basically if you say @skipIf(A=a, B=b, C=c) then it only skips if EVERY condition is true. You hinted at this above, but it would be nice if OR were somehow supported. So one possibility is something like this:

# Skips if all conditions are true.
@skipIf(all(A=a, B=b, C=c))

# Skips if any condition is true.
@skipIf(any(A=a, B=b, C=c))

# Skips if none of the conditions are true.
@skipIf(none(A=a, B=b, C=c))

Of course, the values here could be no_match objects as well, just as now, so you could write:

# skips if ~a || b || c
@skipIf(any(A=no_match(a), B=b, C=c))

but even better, they could be written to take *args and **kwargs as well, so that non-keyword arguments are treated as compound objects. This is easier to illustrate with an example:

# skips if ~a || b || c || ~(aa && bb)
@skipIf(any(A=no_match(a), B=b, C=c, none(A=aa, B=bb)))

This should support arbitrarily complex conditionals, but is still pretty concise IMO.

Thoughts?

[labath]

I think this is getting way too complicated. I haven't seen any test
which needs such complicated combinations of skip conditions (and I
hope I never see one).

[tberghammer]

My main concern is that we have a lot of named argument for skipIf/expectFailure and I expect it to increase even further as we support more and more configuration. In my opinion we can have some functional style solution as readable as the current solution with greater flexibility.

What do you think about having the skipIf decorator taking a list of functions as argument with *argc and it's meaning is that the test is skipped if all function returns true (skipIfAll)? To make it readable we can then write simple helper functions such as: archMatches, compilerMatches, hostMatches, etc....

In this case we can have decorators like this: @skipIf(archMatches("arm"), compilerMatches("clang", "3.7"))

If we need some more complicated condition then we can either introduce logical operators what can be used to negate functions, or/xor functions or do even more complicated things based on the existing basic functions or we can introduce new free standing functions what can be passed in to the decorator (they can be specified either locally or globally)

A few complicated function I think we will need: androidDeviceMatches, linuxDistributionMatches, deviceSupportsHardwareBreakpoints, etc...

I think this solution keeps the common decorators very readable while making the system easily extensible for extreme situations.

[zturner]

In D16936#347141, @labath wrote:

I think this is getting way too complicated. I haven't seen any test
which needs such complicated combinations of skip conditions (and I
hope I never see one).

I agree that you don't need arbitrary complexity, but I think there are some things we would greatly benefit from. For example, have you ever seen this?

@expectedFailureWindows
@expectedFailureGcc
@expectedFailureHostLinux

That's 3 decorators, when you could write it as 1:

@expectedFailure(or(oslist="windows", compiler="gcc", hostoslist="linux"))

The rest of the functionality I mentioned you practically get for free if you support this.

[zturner]

In D16936#347186, @tberghammer wrote:

My main concern is that we have a lot of named argument for skipIf/expectFailure and I expect it to increase even further as we support more and more configuration. In my opinion we can have some functional style solution as readable as the current solution with greater flexibility.

What do you think about having the skipIf decorator taking a list of functions as argument with *argc and it's meaning is that the test is skipped if all function returns true (skipIfAll)? To make it readable we can then write simple helper functions such as: archMatches, compilerMatches, hostMatches, etc....

In this case we can have decorators like this: @skipIf(archMatches("arm"), compilerMatches("clang", "3.7"))

If we need some more complicated condition then we can either introduce logical operators what can be used to negate functions, or/xor functions or do even more complicated things based on the existing basic functions or we can introduce new free standing functions what can be passed in to the decorator (they can be specified either locally or globally)

A few complicated function I think we will need: androidDeviceMatches, linuxDistributionMatches, deviceSupportsHardwareBreakpoints, etc...

I think this solution keeps the common decorators very readable while making the system easily extensible for extreme situations.

Something like that might be ok. I do agree that we can't support every use case through keyword arguments, that would be a little crazy. So we have to decide whether we want to use functional style for everything, or keep keyword style for some very common use cases and functional style for everything else. Maybe functional style for everything is better, I'll have to think about it some though.

[zturner]

True about the bugnumbers. Not always diferent bug numbers, but certainly
sometimes.

The reason I don't like writing them as separate decorators is because we
have tons of cases where the condition of multiple decorators pass, and the
best we can do is report one bugnumber / reason in the output because we
don't even evaluate the rest after that. If the entire conditional is
specified on one decorator, you can support that.

With functional style you could still support multiple bugnumbers on an or
conditional like this:

@xfail(or(compiler("gcc", [">=", 4.7], bugnumber=12345), hostos("windows",
bugnumber=23456)))

which is equivalent to:
@xfail(compiler="gcc", compiler_version=[">=", 4.7], bugnumber=12345)
@xfail(hostoslist="windows", bugnumber=23456)

I think also having many layers of decorator nesting provides an
implementation challenge. Ultimately we would like to re-use the skipif
functionality of unittest / unittest2 (especially since we want to port to
unittest). So it would be nice if we could write our decorator like this:

def skipIf(...):

def fn(...):
    ...
unittest2.skipIf(fn)

Right now we can't do this because the nature of the nested decorators
requires us to hack together our own implementation of skipif so that we
can manually call into the next decorator under the right conditions. If
we have just one decorator, it's much easier to write it in terms of
unittest.skipIf. Just construct the function that evaluates the condition,
and pass it in to unittest.

(For what it's worth, I'm not planning to do any of this extra stuff right
now, or even soon, so this is all theoretical at this point. Right now I
just want to remove low hanging fruit and reduce the number of decorators,
but not get it down all the way to 2).

packages/Python/lldbsuite/test/api/multiple-debuggers/TestMultipleDebuggers.py

 
     @skipIfi386
     @skipIfNoSBHeaders
-    @expectedFailureFreeBSD("llvm.org/pr20282")
-    @expectedFailureLinux("llvm.org/pr20282")
-    @expectedFailureWindows # Test crashes
     @expectedFlakeyDarwin()
+    @expectedFailureAll(oslist=["windows", "linux", "freebsd"], bugnumber="llvm.org/pr20282")
     def test_multiple_debuggers(self):
         env = {self.dylibPath : self.getLLDBLibraryEnvVal()}
 

packages/Python/lldbsuite/test/benchmarks/disassembly/TestDisassembly.py

 
     @benchmarks_test
     @no_debug_info_test
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_lldb_then_gdb(self):
         """Test disassembly on a large function with lldb vs. gdb."""
         print()

 
     @benchmarks_test
     @no_debug_info_test
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_gdb_then_lldb(self):
         """Test disassembly on a large function with lldb vs. gdb."""
         print()

packages/Python/lldbsuite/test/benchmarks/disassembly/TestXcode41Vs42GDBDisassembly.py

 
     @benchmarks_test
     @no_debug_info_test
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_41_then_42(self):
         """Test disassembly on a large function with 4.1 vs. 4.2's gdb."""
         print()

 
     @benchmarks_test
     @no_debug_info_test
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_42_then_41(self):
         """Test disassembly on a large function with 4.1 vs. 4.2's gdb."""
         print()

packages/Python/lldbsuite/test/benchmarks/expression/TestExpressionCmd.py

         self.count = 25
 
     @benchmarks_test
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_expr_cmd(self):
         """Test lldb's expression commands and collect statistics."""
         self.build()

packages/Python/lldbsuite/test/benchmarks/expression/TestRepeatedExprs.py

         self.count = 100
 
     @benchmarks_test
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_compare_lldb_to_gdb(self):
         """Test repeated expressions with lldb vs. gdb."""
         self.build()

packages/Python/lldbsuite/test/benchmarks/frame_variable/TestFrameVariableResponse.py

 
     @benchmarks_test
     @no_debug_info_test
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_startup_delay(self):
         """Test response time for the 'frame variable' command."""
         print()

packages/Python/lldbsuite/test/benchmarks/startup/TestStartupDelays.py

 
     @benchmarks_test
     @no_debug_info_test
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_startup_delay(self):
         """Test start up delays creating a target, setting a breakpoint, and run to breakpoint stop."""
         print()

packages/Python/lldbsuite/test/benchmarks/stepping/TestSteppingSpeed.py

 
     @benchmarks_test
     @no_debug_info_test
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_lldb_steppings(self):
         """Test lldb steppings on a large executable."""
         print()

packages/Python/lldbsuite/test/benchmarks/turnaround/TestCompileRunToBreakpointTurnaround.py

 
     @benchmarks_test
     @no_debug_info_test
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_run_lldb_then_gdb(self):
         """Benchmark turnaround time with lldb vs. gdb."""
         print()

packages/Python/lldbsuite/test/decorators.py

                 reason_str = "{} due to the following parameter(s): {}".format(mode_str, reason_str)
             else:
                 reason_str = "{} unconditionally"
+            if bugnumber is not None:
+                reason_str = reason_str + " [" + bugnumber + "]"
         return reason_str
 
     if mode == DecorateMode.Skip:

 def expectedFailureNetBSD(bugnumber=None, compilers=None, debug_info=None):
     return expectedFailureOS(['netbsd'], bugnumber, compilers, debug_info=debug_info)
 
-def expectedFailureWindows(bugnumber=None, compilers=None, debug_info=None):
-    return expectedFailureOS(['windows'], bugnumber, compilers, debug_info=debug_info)
-
 def expectedFailureHostWindows(bugnumber=None, compilers=None):
     return expectedFailureHostOS(['windows'], bugnumber, compilers)
 

packages/Python/lldbsuite/test/driver/batch_mode/TestBatchMode.py

     @skipIfRemote # test not remote-ready llvm.org/pr24813
     @expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot")
     @expectedFlakeyLinux("llvm.org/pr25172")
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_batch_mode_run_crash (self):
         """Test that the lldb driver's batch mode works correctly."""
         self.build()

     @skipIfRemote # test not remote-ready llvm.org/pr24813
     @expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot")
     @expectedFlakeyLinux("llvm.org/pr25172")
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_batch_mode_run_exit (self):
         """Test that the lldb driver's batch mode works correctly."""
         self.build()

     @skipIfRemote # test not remote-ready llvm.org/pr24813
     @expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot")
     @expectedFlakeyLinux("llvm.org/pr25172")
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_batch_mode_attach_exit (self):
         """Test that the lldb driver's batch mode works correctly."""
         self.build()

packages/Python/lldbsuite/test/expression_command/call-function/TestCallStdStringFunction.py

 
     @expectedFailureIcc # llvm.org/pr14437, fails with ICC 13.1
     @expectedFailureFreeBSD('llvm.org/pr17807') # Fails on FreeBSD buildbot
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_with(self):
         """Test calling std::String member function."""
         self.build()

packages/Python/lldbsuite/test/expression_command/call-function/TestCallStopAndContinue.py

                                 '{ 5, "five" }')
 
     @expectedFlakeyDarwin("llvm.org/pr20274")
-    @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     def test(self):
         """Test gathering result from interrupted function call."""
         self.build()

packages/Python/lldbsuite/test/expression_command/call-function/TestCallUserDefinedFunction.py

         self.line = line_number('main.cpp',
                                 '// Please test these expressions while stopped at this line:')
     @expectedFlakeyDsym("llvm.org/pr20274")
-    @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     def test(self):
         """Test return values of user defined function calls."""
         self.build()

packages/Python/lldbsuite/test/expression_command/char/TestExprsChar.py

         self.assertTrue(value.GetError().Success())
         self.assertEqual(value.GetValueAsSigned(0), 3)
 
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_default_char(self):
         self.do_test()
 
     @expectedFailureArch("arm", "llvm.org/pr23069")
     @expectedFailureArch("aarch64", "llvm.org/pr23069")
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_signed_char(self):
         self.do_test(dictionary={'CFLAGS_EXTRAS': '-fsigned-char'})
 
     @expectedFailurei386("llvm.org/pr23069")
     @expectedFailurex86_64("llvm.org/pr23069")
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     @expectedFailureAll(bugnumber="llvm.org/pr23069", triple = 'mips*')
     def test_unsigned_char(self):
         self.do_test(dictionary={'CFLAGS_EXTRAS': '-funsigned-char'})

packages/Python/lldbsuite/test/expression_command/expr-in-syscall/TestExpressionInSyscall.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr21765") # Also getpid() is not a function on Windows anyway
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765, getpid() does not exist on Windows")
     def test_setpgid(self):
         self.build()
         self.expr_syscall()

packages/Python/lldbsuite/test/expression_command/formatters/TestFormatters.py

     @skipIfFreeBSD # llvm.org/pr24691 skipping to avoid crashing the test runner
     @expectedFailureFreeBSD('llvm.org/pr19011') # Newer Clang omits C1 complete object constructor
     @expectedFailureFreeBSD('llvm.org/pr24691') # we hit an assertion in clang
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     @skipIfTargetAndroid() # skipping to avoid crashing the test runner
     @expectedFailureAndroid('llvm.org/pr24691') # we hit an assertion in clang
     def test(self):

packages/Python/lldbsuite/test/expression_command/issue_11588/Test11588.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_11581_commands(self):
         # This is the function to remove the custom commands in order to have a
         # clean slate for the next test case.

packages/Python/lldbsuite/test/expression_command/persistent_types/TestNestedPersistentTypes.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_persistent_types(self):
         """Test that nested persistent types work."""
         self.build()

packages/Python/lldbsuite/test/expression_command/persistent_types/TestPersistentTypes.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_persistent_types(self):
         """Test that lldb persistent types works correctly."""
         self.build()

packages/Python/lldbsuite/test/expression_command/radar_9531204/TestPrintfAfterUp.py

     mydir = TestBase.compute_mydir(__file__)
 
     # rdar://problem/9531204
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_expr_commands(self):
         """The evaluating printf(...) after break stop and then up a stack frame."""
         self.build()

packages/Python/lldbsuite/test/expression_command/radar_9673664/TestExprHelpExamples.py

         self.main_source = "main.c"
         self.line = line_number(self.main_source, '// Set breakpoint here.')
 
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_expr_commands(self):
         """The following expression commands should just work."""
         self.build()

packages/Python/lldbsuite/test/expression_command/test/TestExprs.py

             patterns = ["\(float\) \$.* = 2\.234"])
         # (float) $2 = 2.234
 
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_many_expr_commands(self):
         self.build_and_run()
 

         # (const char *) $8 = 0x... "/Volumes/data/lldb/svn/trunk/test/expression_command/test/a.out"
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows # Test crashes
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_evaluate_expression_python(self):
         """Test SBFrame.EvaluateExpression() API for evaluating an expression."""
         self.build()

 
     # rdar://problem/8686536
     # CommandInterpreter::HandleCommand is stripping \'s from input for WantsRawCommand commands
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_expr_commands_can_handle_quotes(self):
         """Throw some expression commands with quotes at lldb."""
         self.build()

packages/Python/lldbsuite/test/expression_command/test/TestExprs2.py

         self.line = line_number('main.cpp',
                                 '// Please test many expressions while stopped at this line:')
 
-    @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     def test_more_expr_commands(self):
         """Test some more expression commands."""
         self.build()

packages/Python/lldbsuite/test/expression_command/timeout/TestCallWithTimeout.py

 
 
     @expectedFlakeyFreeBSD("llvm.org/pr19605")
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test(self):
         """Test calling std::String member function."""
         self.build()

packages/Python/lldbsuite/test/functionalities/archives/TestBSDArchives.py

         # Find the line number in a(int) to break at.
         self.line = line_number('a.c', '// Set file and line breakpoint inside a().')
 
-    @expectedFailureWindows("llvm.org/pr24527") # Makefile.rules doesn't know how to build static libs on Windows.
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24527.  Makefile.rules doesn't know how to build static libs on Windows")
     def test(self):
         """Break inside a() and b() defined within libfoo.a."""
         self.build()

packages/Python/lldbsuite/test/functionalities/attach_resume/TestAttachResume.py

 
     @skipIfRemote
     @expectedFailureFreeBSD('llvm.org/pr19310')
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_attach_continue_interrupt_detach(self):
         """Test attach/continue/interrupt/detach"""
         self.build()

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py

         cls.RemoveTempFile("output.txt")
         cls.RemoveTempFile("output2.txt")
 
-    @expectedFailureWindows("llvm.org/pr24528")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24528")
     def test(self):
         """Test a sequence of breakpoint command add, list, and delete."""
         self.build()

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr24528")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24528")
     @expectedFailureAll(oslist=["linux"], compiler="clang", compiler_version=[">=", "3.8"], archs=["i386"], debug_info="dwo")
     def test(self):
         """Test breakpoint enable/disable for a breakpoint ID with multiple locations."""

packages/Python/lldbsuite/test/functionalities/breakpoint/cpp/TestCPPBreakpointLocations.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr24764")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
     def test (self):
         self.build ()
         self.breakpoint_id_tests ()

packages/Python/lldbsuite/test/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py

     my_var = 10
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows("llvm.org/pr24538") # clang-cl does not support throw or catch
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24538")
     def test_cpp_exception_breakpoint(self):
         """Test setting and hitting the C++ exception breakpoint."""
         self.build()

packages/Python/lldbsuite/test/functionalities/command_script_immediate_output/TestCommandScriptImmediateOutput.py

         PExpectTest.setUp(self)
 
     @skipIfRemote # test not remote-ready llvm.org/pr24813
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @expectedFailureLinux("llvm.org/pr26139")
     def test_command_script_immediate_output (self):
         """Test that LLDB correctly allows scripted commands to set an immediate output file."""

packages/Python/lldbsuite/test/functionalities/conditional_break/TestConditionalBreak.py

         self.build()
         self.simulate_conditional_break_by_user()
 
-    @expectedFailureWindows("llvm.org/pr26265")  # args in frames other than #0 are not evaluated correctly
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr26265: args in frames other than #0 are not evaluated correctly")
     def do_conditional_break(self):
         """Exercise some thread and frame APIs to break if c() is called by a()."""
         exe = os.path.join(os.getcwd(), "a.out")

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-cpp/TestDataFormatterCpp.py

         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
-    @expectedFailureWindows("llvm.org/pr24462") # Data formatters have problems on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24462: Data formatters have problems on Windows")
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-disabling/TestDataFormatterDisabling.py

         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
-    @expectedFailureWindows("llvm.org/pr24462") # Data formatters have problems on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24462, Data formatters have problems on Windows")
     def test_with_run_command(self):
         """Check that we can properly disable all data formatter categories."""
         self.build()

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-skip-summary/TestDataFormatterSkipSummary.py

     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot
-    @expectedFailureWindows("llvm.org/pr24462") # Data formatters have problems on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24462, Data formatters have problems on Windows")
     def test_with_run_command(self):
         """Test data formatter commands."""
         self.build()

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-smart-array/TestDataFormatterSmartArray.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr24462") # Data formatters have problems on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24462, Data formatters have problems on Windows")
     def test_with_run_command(self):
         """Test data formatter commands."""
         self.build()

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-synthval/TestDataFormatterSynthVal.py

         self.line = line_number('main.cpp', 'break here')
 
     @skipIfFreeBSD # llvm.org/pr20545 bogus output confuses buildbot parser
-    @expectedFailureWindows("llvm.org/pr24462") # Data formatters have problems on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24462, Data formatters have problems on Windows")
     def test_with_run_command(self):
         """Test using Python synthetic children provider to provide a value."""
         self.build()

packages/Python/lldbsuite/test/functionalities/data-formatter/dump_dynamic/TestDumpDynamic.py

 
 from lldbsuite.test import lldbinline
 
-lldbinline.MakeInlineTest(__file__, globals(), [lldbinline.expectedFailureWindows("llvm.org/pr24663")])
+lldbinline.MakeInlineTest(__file__, globals(), [lldbinline.expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24663")])

packages/Python/lldbsuite/test/functionalities/data-formatter/stringprinter/TestStringPrinter.py

 from lldbsuite.test import lldbinline
 from lldbsuite.test import decorators
 
-lldbinline.MakeInlineTest(__file__, globals(), [decorators.expectedFailureWindows("llvm.org/pr24772")])
+lldbinline.MakeInlineTest(__file__, globals(), [decorators.expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772")])

packages/Python/lldbsuite/test/functionalities/dead-strip/TestDeadStrip.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     @expectedFailureDwo("llvm.org/pr25087")
     @skipIfFreeBSD # The -dead_strip linker option isn't supported on FreeBSD versions of ld.
     def test(self):

packages/Python/lldbsuite/test/functionalities/disassembly/TestDisassembleBreakpoint.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows # Function name prints fully demangled instead of name-only
+    @expectedFailureAll(oslist=["windows"], bugnumber="function names print fully demangled instead of name-only")
     def test(self):
         self.build()
         exe = os.path.join (os.getcwd(), "a.out")

packages/Python/lldbsuite/test/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py

         self.main_sixth_call_line = line_number('pass-to-base.cpp',
                                                        '// Break here and check b has 0 children again')
 
-    @expectedFailureWindows("llvm.org/pr24663")
     @add_test_categories(['pyapi'])
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24663")
     def test_get_dynamic_vals(self):
         """Test fetching C++ dynamic values from pointers & references."""
         """Get argument vals for the call stack when stopped on a breakpoint."""

packages/Python/lldbsuite/test/functionalities/embedded_interpreter/TestConvenienceVariables.py

 
     @skipIfFreeBSD # llvm.org/pr17228
     @skipIfRemote
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_with_run_commands(self):
         """Test convenience variables lldb.debugger, lldb.target, lldb.process, lldb.thread, and lldb.frame."""
         self.build()

packages/Python/lldbsuite/test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py

 
     @expectedFailureFreeBSD('llvm.org/pr17946')
     @expectedFlakeyLinux # failed 1/365 test runs, line 61, thread.IsValid()
-    @expectedFailureWindows # Windows doesn't have pthreads, need to port this test.
+    @expectedFailureAll(oslist=["windows"], bugnumber="Windows doesn't have pthreads, test needs to be ported")
     def test_with_run_command(self):
         """Test that expr will time out and allow other threads to run if it blocks."""
         self.build()

packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailureLinux("llvm.org/pr25338", archs=['arm'])
     def test_inferior_asserting(self):
         """Test that lldb reliably catches the inferior asserting (command)."""
         self.build()
         self.inferior_asserting()
 
-    @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailureAndroid(api_levels=list(range(16 + 1))) # b.android.com/179836
     def test_inferior_asserting_register(self):
         """Test that lldb reliably reads registers from the inferior after asserting (command)."""
         self.build()
         self.inferior_asserting_registers()
 
-    @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailureLinux("llvm.org/pr25338", archs=['aarch64', 'arm'])
     def test_inferior_asserting_disassemble(self):
         """Test that lldb reliably disassembles frames after asserting (command)."""

         self.inferior_asserting_disassemble()
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     def test_inferior_asserting_python(self):
         """Test that lldb reliably catches the inferior asserting (Python API)."""
         self.build()
         self.inferior_asserting_python()
 
-    @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailureLinux("llvm.org/pr25338", archs=['aarch64', 'arm'])
     def test_inferior_asserting_expr(self):
         """Test that the lldb expression interpreter can read from the inferior after asserting (command)."""
         self.build()
         self.inferior_asserting_expr()
 
-    @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailureLinux("llvm.org/pr25338", archs=['aarch64', 'arm'])
     def test_inferior_asserting_step(self):
         """Test that lldb functions correctly after stepping through a call to assert()."""

packages/Python/lldbsuite/test/functionalities/inferior-crashing/TestInferiorCrashing.py

     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureFreeBSD("llvm.org/pr23699 SIGSEGV is reported as exception, not signal")
-    @expectedFailureWindows("llvm.org/pr24778") # This actually works, but the test relies on the output format instead of the API
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     def test_inferior_crashing(self):
         """Test that lldb reliably catches the inferior crashing (command)."""
         self.build()
         self.inferior_crashing()
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     def test_inferior_crashing_register(self):
         """Test that lldb reliably reads registers from the inferior after crashing (command)."""
         self.build()
         self.inferior_crashing_registers()
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     def test_inferior_crashing_python(self):
         """Test that lldb reliably catches the inferior crashing (Python API)."""
         self.build()
         self.inferior_crashing_python()
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     def test_inferior_crashing_expr(self):
         """Test that the lldb expression interpreter can read from the inferior after crashing (command)."""
         self.build()
         self.inferior_crashing_expr()
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     def test_inferior_crashing_step(self):
         """Test that stepping after a crash behaves correctly."""
         self.build()
         self.inferior_crashing_step()
 
     @expectedFailureFreeBSD('llvm.org/pr24939')
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     @expectedFailureAndroid(archs=['aarch64'], api_levels=list(range(21 + 1))) # No eh_frame for sa_restorer
     def test_inferior_crashing_step_after_break(self):
         """Test that lldb functions correctly after stepping through a crash."""
         self.build()
         self.inferior_crashing_step_after_break()
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     @skipIfLinux # Inferior exits after stepping after a segfault. This is working as intended IMHO.
     def test_inferior_crashing_expr_step_and_expr(self):
         """Test that lldb expressions work before and after stepping after a crash."""

packages/Python/lldbsuite/test/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py

     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureFreeBSD("llvm.org/pr23699 SIGSEGV is reported as exception, not signal")
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_recursive_inferior_crashing(self):
         """Test that lldb reliably catches the inferior crashing (command)."""
         self.build()
         self.recursive_inferior_crashing()
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_recursive_inferior_crashing_register(self):
         """Test that lldb reliably reads registers from the inferior after crashing (command)."""
         self.build()
         self.recursive_inferior_crashing_registers()
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_recursive_inferior_crashing_python(self):
         """Test that lldb reliably catches the inferior crashing (Python API)."""
         self.build()
         self.recursive_inferior_crashing_python()
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_recursive_inferior_crashing_expr(self):
         """Test that the lldb expression interpreter can read from the inferior after crashing (command)."""
         self.build()
         self.recursive_inferior_crashing_expr()
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_recursive_inferior_crashing_step(self):
         """Test that stepping after a crash behaves correctly."""
         self.build()
         self.recursive_inferior_crashing_step()
 
     @expectedFailureFreeBSD('llvm.org/pr24939')
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     @expectedFailureAndroid(archs=['aarch64'], api_levels=list(range(21 + 1))) # No eh_frame for sa_restorer
     def test_recursive_inferior_crashing_step_after_break(self):
         """Test that lldb functions correctly after stepping through a crash."""

 
     @expectedFailureFreeBSD('llvm.org/pr15989') # Couldn't allocate space for the stack frame
     @skipIfLinux # Inferior exits after stepping after a segfault. This is working as intended IMHO.
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_recursive_inferior_crashing_expr_step_and_expr(self):
         """Test that lldb expressions work before and after stepping after a crash."""
         self.build()

packages/Python/lldbsuite/test/functionalities/launch_with_shellexpand/TestLaunchWithShellExpand.py

 
     @expectedFailureFreeBSD("llvm.org/pr22627 process launch w/ shell expansion not working")
     @expectedFailureLinux("llvm.org/pr22627 process launch w/ shell expansion not working")
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test(self):
         self.build()
         exe = os.path.join (os.getcwd(), "a.out")

packages/Python/lldbsuite/test/functionalities/longjmp/TestLongjmp.py

     @skipIfDarwin # llvm.org/pr16769: LLDB on Mac OS X dies in function ReadRegisterBytes in GDBRemoteRegisterContext.cpp
     @skipIfFreeBSD # llvm.org/pr17214
     @expectedFailureLinux("llvm.org/pr20231")
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_step_out(self):
         """Test stepping when the inferior calls setjmp/longjmp, in particular, thread step-out."""
         self.build()

     @skipIfDarwin # llvm.org/pr16769: LLDB on Mac OS X dies in function ReadRegisterBytes in GDBRemoteRegisterContext.cpp
     @skipIfFreeBSD # llvm.org/pr17214
     @expectedFailureLinux("llvm.org/pr20231")
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_step_over(self):
         """Test stepping when the inferior calls setjmp/longjmp, in particular, thread step-over a longjmp."""
         self.build()

     @skipIfDarwin # llvm.org/pr16769: LLDB on Mac OS X dies in function ReadRegisterBytes in GDBRemoteRegisterContext.cpp
     @skipIfFreeBSD # llvm.org/pr17214
     @expectedFailureLinux("llvm.org/pr20231")
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_step_back_out(self):
         """Test stepping when the inferior calls setjmp/longjmp, in particular, thread step-out after thread step-in."""
         self.build()

packages/Python/lldbsuite/test/functionalities/plugins/commands/TestPluginCommands.py

 
     @skipIfNoSBHeaders
     @skipIfHostIncompatibleWithRemote # Requires a compatible arch and platform to link against the host's built lldb lib.
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     @no_debug_info_test
     def test_load_plugin(self):
         """Test that plugins that load commands work correctly."""

packages/Python/lldbsuite/test/functionalities/return-value/TestReturnValue.py

     @expectedFailureAll(oslist=["macosx","freebsd"], archs=["i386"])
     @expectedFailureAll(oslist=["linux"], compiler="clang", compiler_version=["<=", "3.6"], archs=["i386"])
     @expectedFailureAll(bugnumber="llvm.org/pr25785", hostoslist=["windows"], compiler="gcc", archs=["i386"], triple='.*-android')
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     @add_test_categories(['pyapi'])
     def test_with_python(self):
         """Test getting return values from stepping out."""

packages/Python/lldbsuite/test/functionalities/thread/crash_during_step/TestCrashDuringStep.py

         TestBase.setUp(self)
         self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
 
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     @expectedFailureAndroid("llvm.org/pr24497", archs=['arm', 'aarch64'])
     @expectedFailureAll(archs=['mips', 'mipsel', 'mips64', 'mips64el'])    # IO error due to breakpoint at invalid address
     def test_step_inst_with(self):

packages/Python/lldbsuite/test/functionalities/thread/create_during_step/TestCreateDuringStep.py

     @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
     @expectedFailureFreeBSD("llvm.org/pr18190") # thread states not properly maintained
     @expectedFailureLinux("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     def test_step_inst(self):
         """Test thread creation during step-inst handling."""
         self.build(dictionary=self.getBuildFlags())

     @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
     @expectedFailureFreeBSD("llvm.org/pr18190") # thread states not properly maintained
     @expectedFailureLinux("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     def test_step_over(self):
         """Test thread creation during step-over handling."""
         self.build(dictionary=self.getBuildFlags())

     @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
     @expectedFailureFreeBSD("llvm.org/pr18190") # thread states not properly maintained
     @expectedFailureLinux("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     def test_step_in(self):
         """Test thread creation during step-in handling."""
         self.build(dictionary=self.getBuildFlags())

packages/Python/lldbsuite/test/functionalities/thread/exit_during_break/TestExitDuringBreak.py

     @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
     @expectedFailureFreeBSD("llvm.org/pr18190") # thread states not properly maintained
     @expectedFailureLinux("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     def test(self):
         """Test thread exit during breakpoint handling."""
         self.build(dictionary=self.getBuildFlags())

packages/Python/lldbsuite/test/functionalities/thread/multi_break/TestMultipleBreakpoints.py

     @expectedFailureDarwin("llvm.org/pr15824") # thread states not properly maintained
     @expectedFailureFreeBSD("llvm.org/pr18190") # thread states not properly maintained
     @expectedFailureLinux("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     def test(self):
         """Test simultaneous breakpoints in multiple threads."""
         self.build(dictionary=self.getBuildFlags())

packages/Python/lldbsuite/test/functionalities/thread/state/TestThreadStates.py

     @skipIfDarwin # 'llvm.org/pr23669', cause Python crash randomly
     @expectedFailureDarwin('llvm.org/pr23669')
     @expectedFailureFreeBSD('llvm.org/pr15824')
-    @expectedFailureWindows("llvm.org/pr24660")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24660")
     def test_state_after_continue(self):
         """Test thread state after continue."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))

 
     @skipIfDarwin # 'llvm.org/pr23669', cause Python crash randomly
     @expectedFailureDarwin('llvm.org/pr23669')
-    @expectedFailureWindows("llvm.org/pr24660")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24660")
     @unittest2.expectedFailure("llvm.org/pr16712") # thread states not properly maintained
     def test_state_after_expression(self):
         """Test thread state after expression."""

         self.thread_state_after_expression_test()
 
     @unittest2.expectedFailure("llvm.org/pr16712") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     def test_process_interrupt(self):
         """Test process interrupt."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         self.process_interrupt_test()
 
     @unittest2.expectedFailure("llvm.org/pr15824") # thread states not properly maintained
-    @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     def test_process_state(self):
         """Test thread states (comprehensive)."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))

packages/Python/lldbsuite/test/functionalities/thread/step_out/TestThreadStepOut.py

     @skipIfLinux                              # Test occasionally times out on the Linux build bot
     @expectedFailureLinux("llvm.org/pr23477") # Test occasionally times out on the Linux build bot
     @expectedFailureFreeBSD("llvm.org/pr18066") # inferior does not exit
-    @expectedFailureWindows # Test crashes
+    @expectedFailureAll(oslist=["windows"])
     def test_step_single_thread(self):
         """Test thread step out on one thread via command interpreter. """
         self.build(dictionary=self.getBuildFlags())

     @skipIfLinux                              # Test occasionally times out on the Linux build bot
     @expectedFailureLinux("llvm.org/pr23477") # Test occasionally times out on the Linux build bot
     @expectedFailureFreeBSD("llvm.org/pr19347") # 2nd thread stops at breakpoint
-    @expectedFailureWindows # Test crashes
+    @expectedFailureAll(oslist=["windows"])
     def test_step_all_threads(self):
         """Test thread step out on all threads via command interpreter. """
         self.build(dictionary=self.getBuildFlags())

     @skipIfLinux                              # Test occasionally times out on the Linux build bot
     @expectedFailureLinux("llvm.org/pr23477") # Test occasionally times out on the Linux build bot
     @expectedFailureFreeBSD("llvm.org/pr19347")
-    @expectedFailureWindows("llvm.org/pr24681")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24681")
     def test_python(self):
         """Test thread step out on one thread via Python API (dwarf)."""
         self.build(dictionary=self.getBuildFlags())

packages/Python/lldbsuite/test/functionalities/thread/thread_specific_break/TestThreadSpecificBreakpoint.py

     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows # Thread specific breakpoints cause the inferior to crash
+    @expectedFailureAll(oslist=["windows"])
     def test_python(self):
         """Test that we obey thread conditioned breakpoints."""
         self.build()

packages/Python/lldbsuite/test/functionalities/value_md5_crash/TestValueMD5Crash.py

         # Find the line number to break at.
         self.line = line_number('main.cpp', '// break here')
 
-    @expectedFailureWindows("llvm.org/pr24663")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24663")
     def test_with_run_command(self):
         """Verify that the hash computing logic for ValueObject's values can't crash us."""
         self.build()

packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchlocation/TestWatchLocation.py

         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     @expectedFailureAll(archs=['mips', 'mipsel', 'mips64', 'mips64el']) # Most of the MIPS boards provide only one H/W watchpoints, and S/W watchpoints are not supported yet
     @skipIfDarwin
     def test_hello_watchlocation(self):

packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchpoint/TestMyFirstWatchpoint.py

         self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_hello_watchpoint_using_watchpoint_set(self):
         """Test a simple sequence of watchpoint creation and watchpoint hit."""
         self.build(dictionary=self.d)

packages/Python/lldbsuite/test/functionalities/watchpoint/multiple_threads/TestWatchpointMultipleThreads.py

     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchpoint_multiple_threads(self):
         """Test that lldb watchpoint works for multiple threads."""
         self.build()

         self.hello_multiple_threads()
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchpoint_multiple_threads_wp_set_and_then_delete(self):
         """Test that lldb watchpoint works for multiple threads, and after the watchpoint is deleted, the watchpoint event should no longer fires."""
         self.build()

packages/Python/lldbsuite/test/functionalities/watchpoint/step_over_watchpoint/TestStepOverWatchpoint.py

 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     @expectedFailureLinux(bugnumber="llvm.org/pr26031", archs=['aarch64', 'arm'])
-    @expectedFailureWindows("llvm.org/pr24446")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test(self):
         """Test stepping over watchpoints."""
         self.build()

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/TestWatchpointCommands.py

         self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_rw_watchpoint(self):
         """Test read_write watchpoint and expect to stop two times."""
         self.build(dictionary=self.d)

             substrs = ['hit_count = 2'])
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_rw_watchpoint_delete(self):
         """Test delete watchpoint and expect not to stop for watchpoint."""
         self.build(dictionary=self.d)

             substrs = ['exited'])
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_rw_watchpoint_set_ignore_count(self):
         """Test watchpoint ignore count and expect to not to stop at all."""
         self.build(dictionary=self.d)

             substrs = ['hit_count = 2', 'ignore_count = 2'])
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_rw_disable_after_first_stop(self):
         """Test read_write watchpoint but disable it after the first stop."""
         self.build(dictionary=self.d)

             substrs = ['hit_count = 1'])
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_rw_disable_then_enable(self):
         """Test read_write watchpoint, disable initially, then enable it."""
         self.build(dictionary=self.d)

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandLLDB.py

         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchpoint_command(self):
         """Test 'watchpoint command'."""
         self.build(dictionary=self.d)

             substrs = ['(int32_t)', 'cookie = 777'])
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchpoint_command_can_disable_a_watchpoint(self):
         """Test that 'watchpoint command' action can disable a watchpoint after it is triggered."""
         self.build(dictionary=self.d)

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandPython.py

         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @skipIfFreeBSD # timing out on buildbot
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_watchpoint_command(self):
         """Test 'watchpoint command'."""

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/condition/TestWatchpointConditionCmd.py

         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchpoint_cond(self):
         """Test watchpoint condition."""
         self.build(dictionary=self.d)

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_events/TestWatchpointEvents.py

 
     @add_test_categories(['pyapi'])
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_with_python_api(self):
         """Test that adding, deleting and modifying watchpoints sends the appropriate events."""
         self.build()

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_on_vectors/TestValueOfVectorVariable.py

     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_value_of_vector_variable_using_watchpoint_set(self):
         """Test verify displayed value of vector variable."""
         self.build(dictionary=self.d)

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_set_command/TestWatchLocationWithWatchSet.py

 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     @expectedFailureLinux(bugnumber="llvm.org/pr26031", archs=['aarch64', 'arm'])
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watchlocation_using_watchpoint_set(self):
         """Test watching a location with 'watchpoint set expression -w write -s size' option."""
         self.build()

packages/Python/lldbsuite/test/lang/c/anonymous/TestAnonymous.py

         self.expect("expression z.y", VARIABLES_DISPLAYED_CORRECTLY,
             substrs = ["(type_y) $", "dummy = 2"])
 
-    @expectedFailureWindows('llvm.org/pr21550')
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21550")
     def test_expr_null(self):
         self.build()
         self.common_setup(self.line2)

packages/Python/lldbsuite/test/lang/c/const_variables/TestConstVariables.py

         compiler="clang", compiler_version=[">=", "3.8"])
     @expectedFailureAll(oslist=["freebsd", "linux"], compiler="icc")
     @expectedFailureAll(archs=['mips', 'mipsel', 'mips64', 'mips64el'])
-    @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
-    @expectedFailureWindows("llvm.org/pr24490: We shouldn't be using platform-specific names like `getpid` in tests")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     def test_and_run_command(self):
         """Test interpreted and JITted expressions on constant values."""
         self.build()

packages/Python/lldbsuite/test/lang/c/function_types/TestFunctionTypes.py

             substrs = ['a.out`string_not_empty',
                        'stop reason = breakpoint'])
     
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_pointers(self):
         """Test that a function pointer to 'printf' works and can be called."""
         self.build()

packages/Python/lldbsuite/test/lang/c/global_variables/TestGlobalVariables.py

         self.line = line_number(self.source, '// Set break point at this line.')
         self.shlib_names = ["a"]
 
-    @expectedFailureWindows("llvm.org/pr24764")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
     @expectedFailureAll("llvm.org/pr25872", oslist=["macosx"], debug_info="dwarf")
     def test_c_global_variables(self):
         """Test 'frame variable --scope --no-args' which omits args and shows scopes."""

packages/Python/lldbsuite/test/lang/c/modules/TestCModules.py

     @skipIfFreeBSD
     @expectedFailureDarwin('http://llvm.org/pr24302')
     @expectedFailureLinux('http://llvm.org/pr23456') # 'fopen' has unknown return type
-    @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     def test_expr(self):
         if platform.system() == "Darwin" and platform.release() < StrictVersion('12.0.0'):
             self.skipTest()

packages/Python/lldbsuite/test/lang/c/set_values/TestSetValues.py

         self.line4 = line_number('main.c', '// Set break point #4.')
         self.line5 = line_number('main.c', '// Set break point #5.')
 
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test(self):
         """Test settings and readings of program variables."""
         self.build()

packages/Python/lldbsuite/test/lang/c/shared_lib_stripped_symbols/TestSharedLibStrippedSymbols.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows # Test crashes
+    @expectedFailureAll(oslist=["windows"])
     def test_expr(self):
         """Test that types work when defined in a shared library and forward-declared in the main executable"""
         if "clang" in self.getCompiler() and "3.4" in self.getCompilerVersion():

         self.expect("expression --show-types -- *my_foo_ptr", VARIABLES_DISPLAYED_CORRECTLY,
             substrs = ["(foo)", "(sub_foo)", "other_element = 3"])
 
-    @expectedFailureWindows # Test crashes
+    @expectedFailureAll(oslist=["windows"])
     @unittest2.expectedFailure("rdar://problem/10381325")
     def test_frame_variable(self):
         """Test that types work when defined in a shared library and forward-declared in the main executable"""

packages/Python/lldbsuite/test/lang/c/stepping/TestStepAndBreakpoints.py

         # Find the line numbers that we will step to in main:
         self.main_source = "main.c"
 
+    @add_test_categories(['pyapi'])
     @expectedFailureFreeBSD('llvm.org/pr17932')
     @expectedFailureLinux # llvm.org/pr14437
-    @expectedFailureWindows("llvm.org/pr24777")
-    @add_test_categories(['pyapi'])
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24777")
     def test_and_python_api(self):
         """Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
         self.build()

packages/Python/lldbsuite/test/lang/c/strings/TestCStrings.py

     
     mydir = TestBase.compute_mydir(__file__)
     
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_with_run_command(self):
         """Tests that C strings work as expected in expressions"""
         self.build()

packages/Python/lldbsuite/test/lang/c/struct_types/TestStructTypes.py

 from lldbsuite.test import lldbinline
 from lldbsuite.test import decorators
 
-lldbinline.MakeInlineTest(__file__, globals(), [decorators.expectedFailureWindows("llvm.org/pr24764")] )
+lldbinline.MakeInlineTest(__file__, globals(), [decorators.expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")] )

packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/TestCPPBreakpointCommands.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows
+    @expectedFailureAll(oslist=["windows"])
     def test(self):
         """Test a sequence of breakpoint command add, list, and delete."""
         self.build()

packages/Python/lldbsuite/test/lang/cpp/call-function/TestCallCPPFunction.py

         TestBase.setUp(self)
         self.line = line_number('main.cpp', '// breakpoint')
     
-    @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     def test_with_run_command(self):
         """Test calling a function by basename"""
         self.build()

packages/Python/lldbsuite/test/lang/cpp/chained-calls/TestCppChainedCalls.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_with_run_command(self):
         self.build()
 

packages/Python/lldbsuite/test/lang/cpp/class_static/TestStaticVariables.py

         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
-    @expectedFailureWindows("llvm.org/pr24764")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
     def test_with_run_command(self):
         """Test that file and class static variables display correctly."""
         self.build()

packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestDynamicValue.py

         self.main_second_call_line = line_number('pass-to-base.cpp',
                                                        '// Break here and get real address of reallyA.')
 
-    @expectedFailureFreeBSD # FIXME: This needs to be root-caused.
-    @expectedFailureWindows("llvm.org/pr24663")
     @add_test_categories(['pyapi'])
+    @expectedFailureFreeBSD # FIXME: This needs to be root-caused.
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24663")
     def test_get_dynamic_vals(self):
         """Test fetching C++ dynamic values from pointers & references."""
         self.build(dictionary=self.getBuildFlags())

packages/Python/lldbsuite/test/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py

         self.source = 'exceptions.cpp'
         self.catch_line = line_number(self.source, '// This is the line you should stop at for catch')
 
-    @expectedFailureWindows("llvm.org/pr24538") # clang-cl does not support throw or catch
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24538, clang-cl does not support throw or catch")
     def test(self):
         """Test lldb exception breakpoint command for CPP."""
         self.build()

packages/Python/lldbsuite/test/lang/cpp/global_operators/TestCppGlobalOperators.py

     
     mydir = TestBase.compute_mydir(__file__)
     
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_with_run_command(self):
         self.build()
 

packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespace.py

                        'stop reason = breakpoint'])
 
     # rdar://problem/8668674
-    @expectedFailureWindows("llvm.org/pr24764")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
     def test_with_run_command(self):
         """Test that anonymous and named namespace variables display correctly."""
         self.build()

packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespaceLookup.py

             substrs = ['stopped',
                        'stop reason = breakpoint'])
 
-    @expectedFailureFreeBSD("llvm.org/pr25819")
-    @expectedFailureLinux("llvm.org/pr25819")
-    @expectedFailureWindows("llvm.org/pr25819")
+    @expectedFailureAll(oslist=["windows", "linux", "freebsd"], bugnumber="llvm.org/pr25819")
     def test_scope_lookup_with_run_command(self):
         """Test scope lookup of functions in lldb."""
         self.build()

         # finds the global ::func().
         self.expect("expr -- func()", startstr = "(int) $0 = 2")
 
-    @expectedFailureLinux("llvm.org/pr25819")
-    @expectedFailureWindows("llvm.org/pr25819")
+    @expectedFailureAll(oslist=["windows", "linux"], bugnumber="llvm.org/pr25819")
     def test_scope_lookup_before_using_with_run_command(self):
         """Test scope lookup before using in lldb."""
         self.build()

 
     # NOTE: this test may fail on older systems that don't emit import
     # entries in DWARF - may need to add checks for compiler versions here.
-    @expectedFailureFreeBSD("llvm.org/pr25819")
-    @expectedFailureLinux("llvm.org/pr25819")
-    @expectedFailureWindows("llvm.org/pr25819")
+    @expectedFailureAll(oslist=["windows", "linux", "freebsd"], bugnumber="llvm.org/pr25819")
     def test_scope_after_using_directive_lookup_with_run_command(self):
         """Test scope lookup after using directive in lldb."""
         self.build()

         # the same type.
         self.expect("expr -- func()", startstr = "error")
 
-    @expectedFailureFreeBSD("llvm.org/pr25819")
-    @expectedFailureLinux("llvm.org/pr25819")
-    @expectedFailureWindows("llvm.org/pr25819")
+    @expectedFailureAll(oslist=["windows", "linux", "freebsd"], bugnumber="llvm.org/pr25819")
     def test_scope_lookup_shadowed_by_using_with_run_command(self):
         """Test scope lookup shadowed by using in lldb."""
         self.build()

packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/TestOverloadedFunctions.py

         TestBase.setUp(self)
         self.line = line_number('main.cpp', '// breakpoint')
 
-    @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     def test_with_run_command(self):
         """Test that functions with the same name are resolved correctly"""
         self.build()

packages/Python/lldbsuite/test/lang/cpp/rdar12991846/TestRdar12991846.py

     mydir = TestBase.compute_mydir(__file__)
 
     @unittest2.expectedFailure("rdar://18684408")
-    @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     def test_expr1(self):
         """Test that the expression parser returns proper Unicode strings."""
         self.build()
         self.rdar12991846(expr=1)
 
     @unittest2.expectedFailure("rdar://18684408")
-    @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     def test_expr2(self):
         """Test that the expression parser returns proper Unicode strings."""
         self.build()
         self.rdar12991846(expr=2)
 
     @unittest2.expectedFailure("rdar://18684408")
-    @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     def test_expr3(self):
         """Test that the expression parser returns proper Unicode strings."""
         self.build()

packages/Python/lldbsuite/test/lang/cpp/rvalue-references/TestRvalueReferences.py

     
     #rdar://problem/11479676
     @expectedFailureIcc("ICC (13.1, 14-beta) do not emit DW_TAG_rvalue_reference_type.")
-    @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     def test_with_run_command(self):
         """Test that rvalues are supported in the C++ expression parser"""
         self.build()

packages/Python/lldbsuite/test/lang/cpp/scope/TestCppScope.py

     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureDarwin
-    @expectedFailureWindows("llvm.org/pr24764")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
     def test_with_run_command(self):
         self.build()
 

packages/Python/lldbsuite/test/lang/cpp/static_members/TestCPPStaticMembers.py

     mydir = TestBase.compute_mydir(__file__)
     
     @unittest2.expectedFailure # llvm.org/pr15401
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_with_run_command(self):
         """Test that member variables have the correct layout, scope and qualifiers when stopped inside and outside C++ methods"""
         self.build()

packages/Python/lldbsuite/test/lang/cpp/static_methods/TestCPPStaticMethods.py

         TestBase.setUp(self)
         self.line = line_number('main.cpp', '// Break at this line')
 
-    @expectedFailureWindows
+    @expectedFailureAll(oslist=["windows"])
     def test_with_run_command(self):
         """Test that static methods are properly distinguished from regular methods"""
         self.build()

packages/Python/lldbsuite/test/lang/cpp/this/TestCPPThis.py

     #rdar://problem/9962849
     @expectedFailureGcc # llvm.org/pr15439 The 'this' pointer isn't available during expression evaluation when stopped in an inlined member function.
     @expectedFailureIcc # ICC doesn't emit correct DWARF inline debug info for inlined member functions
-    @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows")
-    @expectedFailureWindows("llvm.org/pr24490: We shouldn't be using platform-specific names like `getpid` in tests")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     @expectedFlakeyClang(bugnumber='llvm.org/pr23012', compiler_version=['>=','3.6']) # failed with totclang - clang3.7
     def test_with_run_command(self):
         """Test that the appropriate member variables are available when stopped in C++ static, inline, and const methods"""

packages/Python/lldbsuite/test/python_api/disassemble-raw-data/TestDisassemble_VST1_64.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipIf(True) # llvm.org/pr24575: all tests get ERRORs in dotest.py after this
+    @skipTestIfFn(lambda : True, "llvm.org/pr24575: all tests get ERRORs in dotest.py after this")
     @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_disassemble_invalid_vst_1_64_raw_data(self):

packages/Python/lldbsuite/test/python_api/event/TestEvents.py

     @skipIfFreeBSD # llvm.org/pr21325
     @add_test_categories(['pyapi'])
     @expectedFailureLinux("llvm.org/pr23617")  # Flaky, fails ~1/10 cases
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_add_listener_to_broadcaster(self):
         """Exercise some SBBroadcaster APIs."""
         self.build()

packages/Python/lldbsuite/test/python_api/frame/TestFrames.py

     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_get_arg_vals_for_call_stack(self):
         """Exercise SBFrame.GetVariables() API to get argument vals."""
         self.build()

packages/Python/lldbsuite/test/python_api/hello_world/TestHelloWorld.py

         self.assertEqual(breakpoint.GetHitCount(), 1, BREAKPOINT_HIT_ONCE)
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows("llvm.org/pr24600")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24600")
     @skipIfiOSSimulator
     def test_with_attach_to_process_with_id_api(self):
         """Create target, spawn a process, and attach to it with process id."""

                        '(int)argc=3'])
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows("llvm.org/pr24600")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24600")
     @skipIfiOSSimulator
     def test_with_attach_to_process_with_name_api(self):
         """Create target, spawn a process, and attach to it with process name."""

packages/Python/lldbsuite/test/python_api/lldbutil/iter/TestRegistersIterator.py

         self.line1 = line_number('main.cpp', '// Set break point at this line.')
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows # Test crashes
+    @expectedFailureAll(oslist=["windows"])
     def test_iter_registers(self):
         """Test iterator works correctly for lldbutil.iter_registers()."""
         self.build()

packages/Python/lldbsuite/test/python_api/lldbutil/process/TestPrintStackTraces.py

     #The __thread_start function in libc doesn't contain any epilogue and prologue instructions 
     #hence unwinding fail when we are stopped in __thread_start
     @expectedFailureAll(triple = 'mips*')
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     @add_test_categories(['pyapi'])
     def test_stack_traces(self):
         """Test SBprocess and SBThread APIs with printing of the stack traces."""

packages/Python/lldbsuite/test/python_api/sbvalue_persist/TestSBValuePersist.py

     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows("llvm.org/pr24772")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772")
     def test(self):
         """Test SBValue::Persist"""
         self.build()

packages/Python/lldbsuite/test/python_api/symbol-context/TestSymbolContext.py

         self.line = line_number('main.c', '// Find the line number of function "c" here.')
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test(self):
         """Exercise SBSymbolContext API extensively."""
         self.build()

packages/Python/lldbsuite/test/python_api/target/TestTargetAPI.py

         self.find_global_variables('b.out')
 
     @add_test_categories(['pyapi'])
-    @expectedFailureWindows("llvm.org/pr24778")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_find_functions(self):
         """Exercise SBTarget.FindFunctions() API."""
         d = {'EXE': 'b.out'}

packages/Python/lldbsuite/test/python_api/thread/TestThreadAPI.py

 
     @add_test_categories(['pyapi'])
     @expectedFailureFreeBSD # llvm.org/pr20476
-    @expectedFailureWindows # Test crashes
+    @expectedFailureAll(oslist=["windows"])
     def test_step_out_of_malloc_into_function_b(self):
         """Test Python SBThread.StepOut() API to step out of a malloc call where the call site is at function b()."""
         # We build a different executable than the default build() does.

packages/Python/lldbsuite/test/python_api/value/TestValueAPI.py

         # Find the line number to of function 'c'.
         self.line = line_number('main.c', '// Break at this line')
 
-    @expectedFailureWindows("llvm.org/pr24772")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772")
     @add_test_categories(['pyapi'])
     def test(self):
         """Exercise some SBValue APIs."""

packages/Python/lldbsuite/test/python_api/value/change_values/TestChangeValueAPI.py

         self.check_line = line_number('main.c', '// Stop here and check values')
         self.end_line = line_number ('main.c', '// Set a breakpoint here at the end')
 
-    @expectedFailureWindows("llvm.org/pr24772")
     @add_test_categories(['pyapi'])
     @expectedFlakeyLinux("llvm.org/pr25652")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24772")
     def test_change_value(self):
         """Exercise the SBValue::SetValueFromCString API."""
         d = {'EXE': self.exe_name}

packages/Python/lldbsuite/test/python_api/watchpoint/TestSetWatchpoint.py

 
     @add_test_categories(['pyapi'])
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watch_val(self):
         """Exercise SBValue.Watch() API to set a watchpoint."""
         self.build()

packages/Python/lldbsuite/test/python_api/watchpoint/TestWatchpointIgnoreCount.py

 
     @add_test_categories(['pyapi'])
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_set_watch_ignore_count(self):
         """Test SBWatchpoint.SetIgnoreCount() API."""
         self.build()

packages/Python/lldbsuite/test/python_api/watchpoint/TestWatchpointIter.py

 
     @add_test_categories(['pyapi'])
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watch_iter(self):
         """Exercise SBTarget.watchpoint_iter() API to iterate on the available watchpoints."""
         self.build()

packages/Python/lldbsuite/test/python_api/watchpoint/watchlocation/TestSetWatchlocation.py

 
     @add_test_categories(['pyapi'])
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watch_location(self):
         """Exercise SBValue.WatchPointee() API to set a watchpoint."""
         self.build()

packages/Python/lldbsuite/test/python_api/watchpoint/watchlocation/TestTargetWatchAddress.py

 
     @add_test_categories(['pyapi'])
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
-    @expectedFailureWindows("llvm.org/pr24446")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_watch_address(self):
         """Exercise SBTarget.WatchAddress() API to set a watchpoint."""
         self.build()

packages/Python/lldbsuite/test/settings/quoting/TestQuoting.py

     def test_no_quote(self):
         self.do_test_args("a b c", "a\0b\0c\0")
 
-    @expectedFailureWindows("http://llvm.org/pr24557")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24557")
     @no_debug_info_test
     def test_single_quote(self):
         self.do_test_args("'a b c'", "a b c\0")

     def test_double_quote(self):
         self.do_test_args('"a b c"', "a b c\0")
 
-    @expectedFailureWindows("http://llvm.org/pr24557")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24557")
     @no_debug_info_test
     def test_single_quote_escape(self):
         self.do_test_args("'a b\\' c", "a b\\\0c\0")
 
-    @expectedFailureWindows("http://llvm.org/pr24557")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24557")
     @no_debug_info_test
     def test_double_quote_escape(self):
         self.do_test_args('"a b\\" c"', 'a b" c\0')
 
-    @expectedFailureWindows("http://llvm.org/pr24557")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24557")
     @no_debug_info_test
     def test_double_quote_escape2(self):
         self.do_test_args('"a b\\\\" c', 'a b\\\0c\0')

     def test_single_in_double(self):
         self.do_test_args('"a\'b"', "a'b\0")
 
-    @expectedFailureWindows("http://llvm.org/pr24557")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24557")
     @no_debug_info_test
     def test_double_in_single(self):
         self.do_test_args("'a\"b'", 'a"b\0')

     def test_bare_single(self):
         self.do_test_args("a\\'b", "a'b\0")
 
-    @expectedFailureWindows("http://llvm.org/pr24557")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24557")
     @no_debug_info_test
     def test_bare_double(self):
         self.do_test_args('a\\"b', 'a"b\0')

packages/Python/lldbsuite/test/tools/lldb-mi/TestMiExit.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_gdb_exit(self):
         """Test that '-gdb-exit' terminates local debug session and exits."""

         import pexpect
         self.expect(pexpect.EOF)
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_quit(self):
         """Test that 'quit' exits immediately."""

         import pexpect
         self.expect(pexpect.EOF)
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_q(self):
         """Test that 'q' exits immediately."""

packages/Python/lldbsuite/test/tools/lldb-mi/TestMiGdbSetShow.py

 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_gdb_set_target_async_default(self):
         """Test that 'lldb-mi --interpreter' switches to async mode by default."""

         self.runCmd("-gdb-show target-async")
         self.expect("\^done,value=\"on\"")
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFlakeyLinux("llvm.org/pr26028") # Fails in ~1% of cases
     def test_lldbmi_gdb_set_target_async_on(self):

         self.expect("\*running")
         self.expect("@\"argc=1")
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailureLinux # Failing in ~11/600 dosep runs (build 3120-3122)
     def test_lldbmi_gdb_set_target_async_off(self):

         if it < len(unexpected):
             self.fail("unexpected found: %s" % unexpected[it])
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_gdb_show_target_async(self):
         """Test that 'lldb-mi --interpreter' in async mode by default."""

         self.runCmd("-gdb-show target-async")
         self.expect("\^done,value=\"on\"")
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_gdb_show_language(self):
         """Test that 'lldb-mi --interpreter' can get current language."""

         self.runCmd("-gdb-show language")
         self.expect("\^done,value=\"c\+\+\"")
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @unittest2.expectedFailure("-gdb-set ignores unknown properties")
     def test_lldbmi_gdb_set_unknown(self):
         """Test that 'lldb-mi --interpreter' fails when setting an unknown property."""

         self.runCmd("-gdb-set unknown some_value")
         self.expect("\^error")
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @unittest2.expectedFailure("-gdb-show ignores unknown properties")
     def test_lldbmi_gdb_show_unknown(self):
         """Test that 'lldb-mi --interpreter' fails when showing an unknown property."""

         self.expect("\^error")
 
 
-    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_gdb_set_ouptut_radix(self):