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 ↗

(On Diff #47052)

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 ↗

(On Diff #47052)

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).

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

 from lldbsuite.test import lldbutil
 
 class TestMultipleSimultaneousDebuggers(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @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()}
 
         self.driver_exe = os.path.join(os.getcwd(), "multi-process-driver")
         self.buildDriver('multi-process-driver.cpp', self.driver_exe)
         self.addTearDownHook(lambda: os.remove(self.driver_exe))
         self.signBinary(self.driver_exe)
 

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

def setUp(self):
         self.exe = lldbtest_config.lldbExec
         self.function = 'Driver::MainLoop()'
         self.lldb_avg = None
         self.gdb_avg = None
         self.count = 5
 
     @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()
         print("lldb path: %s" % lldbtest_config.lldbExec)
         print("gdb path: %s" % self.gdbExec)
 
         print()
         self.run_lldb_disassembly(self.exe, self.function, self.count)
         print("lldb benchmark:", self.stopwatch)
         self.run_gdb_disassembly(self.exe, self.function, self.count)
         print("gdb benchmark:", self.stopwatch)
         print("lldb_avg/gdb_avg: %f" % (self.lldb_avg/self.gdb_avg))
 
     @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()
         print("lldb path: %s" % lldbtest_config.lldbExec)
         print("gdb path: %s" % self.gdbExec)
 
         print()
         self.run_gdb_disassembly(self.exe, self.function, self.count)

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

def setUp(self):
         self.exe = lldbtest_config.lldbExec
         self.function = 'Driver::MainLoop()'
         self.gdb_41_avg = None
         self.gdb_42_avg = None
         self.count = 5
 
     @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()
         self.run_gdb_disassembly(self.gdb_41_exe, self.exe, self.function, self.count)
         print("4.1 gdb benchmark:", self.stopwatch)
         self.gdb_41_avg = self.stopwatch.avg()
         self.run_gdb_disassembly(self.gdb_42_exe, self.exe, self.function, self.count)
         print("4.2 gdb benchmark:", self.stopwatch)
         self.gdb_42_avg = self.stopwatch.avg()
         print("gdb_42_avg/gdb_41_avg: %f" % (self.gdb_42_avg/self.gdb_41_avg))
 
     @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()
         self.run_gdb_disassembly(self.gdb_42_exe, self.exe, self.function, self.count)
         print("4.2 gdb benchmark:", self.stopwatch)
         self.gdb_42_avg = self.stopwatch.avg()
         self.run_gdb_disassembly(self.gdb_41_exe, self.exe, self.function, self.count)
         print("4.1 gdb benchmark:", self.stopwatch)

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

class ExpressionEvaluationCase(BenchBase):
 
     def setUp(self):
         BenchBase.setUp(self)
         self.source = 'main.cpp'
         self.line_to_break = line_number(self.source, '// Set breakpoint here.')
         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()
         self.exe_name = 'a.out'
 
         print()
         self.run_lldb_repeated_exprs(self.exe_name, self.count)
         print("lldb expr cmd benchmark:", self.stopwatch)

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

def setUp(self):
         BenchBase.setUp(self)
         self.source = 'main.cpp'
         self.line_to_break = line_number(self.source, '// Set breakpoint here.')
         self.lldb_avg = None
         self.gdb_avg = None
         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()
         self.exe_name = 'a.out'
 
         print()
         self.run_lldb_repeated_exprs(self.exe_name, self.count)
         print("lldb benchmark:", self.stopwatch)

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

class FrameVariableResponseBench(BenchBase):
     def setUp(self):
         BenchBase.setUp(self)
         self.exe = lldbtest_config.lldbExec
         self.break_spec = '-n main'
         self.count = 20
 
     @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()
         self.run_frame_variable_bench(self.exe, self.break_spec, self.count)
         print("lldb frame variable benchmark:", self.stopwatch)
 
     def run_frame_variable_bench(self, exe, break_spec, count):
         import pexpect

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

def setUp(self):
         # Create self.stopwatch3 for measuring "run to breakpoint".
         self.stopwatch3 = Stopwatch()
         self.exe = lldbtest_config.lldbExec
         self.break_spec = '-n main'
         self.count = 30
 
     @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()
         self.run_startup_delays_bench(self.exe, self.break_spec, self.count)
         print("lldb startup delay (create fresh target) benchmark:", self.stopwatch)
         print("lldb startup delay (set first breakpoint) benchmark:", self.stopwatch2)
         print("lldb startup delay (run to breakpoint) benchmark:", self.stopwatch3)
 

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

def setUp(self):
         self.break_spec = '-n main'
         self.count = 50
 
         #print("self.exe=%s" % self.exe)
         #print("self.break_spec=%s" % self.break_spec)
 
     @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()
         self.run_lldb_steppings(self.exe, self.break_spec, self.count)
         print("lldb stepping benchmark:", self.stopwatch)
 
     def run_lldb_steppings(self, exe, break_spec, count):
         import pexpect

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

def setUp(self):
         self.function = 'Driver::MainLoop()'
         self.count = 3
 
         self.lldb_avg = None
         self.gdb_avg = None
 
     @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()
         self.run_lldb_turnaround(self.exe, self.function, self.count)
         print("lldb turnaround benchmark:", self.stopwatch)
         self.run_gdb_turnaround(self.exe, self.function, self.count)
         print("gdb turnaround benchmark:", self.stopwatch)
         print("lldb_avg/gdb_avg: %f" % (self.lldb_avg/self.gdb_avg))

lldb/trunk/packages/Python/lldbsuite/test/decorators.py

def fn(self):
         reason_str = None
         if final_skip_result:
             mode_str = {DecorateMode.Skip : "skipping", DecorateMode.Xfail : "xfailing"}[mode]
             if len(reasons) > 0:
                 reason_str = ",".join(reasons)
                 reason_str = "{} due to the following parameter(s): {}".format(mode_str, reason_str)
             else:
                 reason_str = "{} unconditionally"
+            if bugnumber is not None and not six.callable(bugnumber):
+                reason_str = reason_str + " [" + str(bugnumber) + "]"
         return reason_str
 
     if mode == DecorateMode.Skip:
         return skipTestIfFn(fn, bugnumber)
     elif mode == DecorateMode.Xfail:
         return expectedFailure(fn, bugnumber)
     else:
         return None
def expectedFailureFreeBSD(bugnumber=None, compilers=None, debug_info=None):
     return expectedFailureOS(['freebsd'], bugnumber, compilers, debug_info=debug_info)
 
 def expectedFailureLinux(bugnumber=None, compilers=None, debug_info=None, archs=None):
     return expectedFailureOS(['linux'], bugnumber, compilers, debug_info=debug_info, archs=archs)
 
 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)
 
 def expectedFailureAndroid(bugnumber=None, api_levels=None, archs=None):
     """ Mark a test as xfail for Android.
 
     Arguments:
         bugnumber - The LLVM pr associated with the problem.

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

def expect_string (self, string):
         except pexpect.EOF:
             self.fail ("Got EOF waiting for '%s'"%(string))
         except pexpect.TIMEOUT:
             self.fail ("Timed out waiting for '%s'"%(string))
 
     @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()
         self.setTearDownCleanup()
 
         import pexpect
         exe = os.path.join(os.getcwd(), "a.out")
         prompt = "(lldb) "
def test_batch_mode_run_crash (self):
         self.expect_string ('(char *) touch_me_not')
         
         self.deletePexpectChild()
 
 
     @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()
         self.setTearDownCleanup()
 
         import pexpect
         exe = os.path.join(os.getcwd(), "a.out")
         prompt = "(lldb) "
class DriverBatchModeTest (TestBase):
     def closeVictim(self):
         if self.victim != None:
             self.victim.close()
             self.victim = None
 
     @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()
         self.setTearDownCleanup()
  
         import pexpect
         exe = os.path.join(os.getcwd(), "a.out")
         prompt = "(lldb) "

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

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.c.
         self.line = line_number('main.cpp',
                                 '// Please test these expressions while stopped at this line:')
 
     @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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         # Some versions of GCC encode two locations for the 'return' statement in main.cpp
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
 

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

def setUp(self):
         TestBase.setUp(self)
         # Find the line number to break for main.c.
         self.line = line_number('main.cpp',
                                 '// Please test these expressions while stopped at this line:')
         self.func_line = line_number ('main.cpp', 
                                 '{ 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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         # Some versions of GCC encode two locations for the 'return' statement in main.cpp
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
 

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

class ExprCommandCallUserDefinedFunction(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.c.
         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()
 
         # Set breakpoint in main and run exe
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
 

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

def do_test(self, dictionary=None):
         self.assertTrue(value.GetError().Success())
         self.assertEqual(value.GetValueAsSigned(0), 2)
 
         value = frame.EvaluateExpression("foo(uc)")
         self.assertTrue(value.IsValid())
         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'})

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

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ExprSyscallTestCase(TestBase):
 
     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()
 
     def expr_syscall(self):
         exe = os.path.join(os.getcwd(), 'a.out')
 
         # Create a target by the debugger.

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

def setUp(self):
         TestBase.setUp(self)
         # Find the line number to break for main.cpp.
         self.line = line_number('main.cpp',
                                 '// Stop here')
 
     @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):
         """Test expr + formatters for good interoperability."""
         self.build()
 
         # This is the function to remove the custom formats in order to have a
         # clean slate for the next test case.

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

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class Issue11581TestCase(TestBase):
 
     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.
         def cleanup():
             self.runCmd('type synthetic clear', check=False)
 
 
         # Execute the cleanup function during test case tear down.

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

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class NestedPersistentTypesTestCase(TestBase):
 
     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()
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         self.runCmd("breakpoint set --name main")
 

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

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class PersistenttypesTestCase(TestBase):
 
     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()
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         self.runCmd("breakpoint set --name main")
 

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

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class Radar9531204TestCase(TestBase):
 
     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()
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_symbol (self, 'foo', sym_exact=True, num_expected_locations=1)
 

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

class Radar9673644TestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         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()
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, self.main_source, self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # rdar://problem/9673664 lldb expression evaluation problem
 
         self.expect('expr char c[] = "foo"; c[0]',
             substrs = ["'f'"])
         # runCmd: expr char c[] = "foo"; c[0]
         # output: (char) $0 = 'f'

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

class BasicExprCommandsTestCase(TestBase):
     @unittest2.expectedFailure("llvm.org/pr17135 <rdar://problem/14874559> APFloat::toString does not identify the correct (i.e. least) precision.")
     def test_floating_point_expr_commands(self):
         self.build_and_run()
 
         self.expect("expression 2.234f",
             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()
 
         self.expect("expression 2",
             patterns = ["\(int\) \$.* = 2"])
         # (int) $0 = 1
 
         self.expect("expression 2ull",
def test_many_expr_commands(self):
         # (const char *) $7 = ...
 
         self.expect("expression argv[0]",
             substrs = ["(const char *)", 
                        "a.out"])
         # (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()
 
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
def test_evaluate_expression_python(self):
         options.SetIgnoreBreakpoints(True)
         value = frame.EvaluateExpression('a_function_to_call()', options)
         self.assertTrue (value.IsValid())
         self.assertTrue (value.GetValueAsSigned(0) == 2)
         self.assertTrue (callee_break.GetHitCount() == 2)
 
     # 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()
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line, num_expected_locations=1,loc_exact=False)
 

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

class ExprCommands2TestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.c.
         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()
 
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line, num_expected_locations=1,loc_exact=False)
 

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

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
         self.main_source = "wait-a-while.cpp"
         self.main_source_spec = lldb.SBFileSpec (self.main_source)
 
 
     @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()
 
         exe_name = "a.out"
         exe = os.path.join(os.getcwd(), exe_name)
 
         target = self.dbg.CreateTarget(exe)

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

class BSDArchivesTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # 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()
 
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break inside a() by file and line first.

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

 exe_name = "AttachResume"  # Must match Makefile
 
 class AttachResumeTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @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()
         self.process_attach_continue_interrupt_detach()
 
     def process_attach_continue_interrupt_detach(self):
         """Test attach/continue/interrupt/detach"""
 

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

class BreakpointCommandTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     @classmethod
     def classCleanup(cls):
         """Cleanup the test byproduct of breakpoint_command_sequence(self)."""
         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()
         self.breakpoint_command_sequence()
         self.breakpoint_command_script_parameters ()
 
     def setUp(self):
         # Call super's setUp().

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

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class BreakpointLocationsTestCase(TestBase):
 
     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."""
         self.build()
         self.breakpoint_locations_test()
 
     def setUp(self):
         # Call super's setUp().

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

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestCPPBreakpointLocations(TestBase):
 
     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 ()
 
     def verify_breakpoint_locations(self, target, bp_dict):
         
         name = bp_dict['name']
         names = bp_dict['loc_names']

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

 from lldbsuite.test import lldbutil
 
 class TestCPPExceptionBreakpoint (TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     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()
         self.do_cpp_exception_bkpt ()
 
     def setUp (self):
         TestBase.setUp(self)
         self.main_source = "main.c"

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

class CommandScriptImmediateOutputTestCase (PExpectTest):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         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."""
         self.launch(timeout=5)
 
         script = os.path.join(os.getcwd(), 'custom_command.py')
         prompt = "(lldb)"
         
         self.sendline('command script import %s' % script, patterns=[prompt])
         self.sendline('command script add -f custom_command.command_function mycommand', patterns=[prompt])
         self.sendline('mycommand', patterns='this is a test string, just a test string')
         self.sendline('command script delete mycommand', patterns=[prompt])
         self.quit(gracefully=False)

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

def test_with_python(self):
         self.build()
         self.do_conditional_break()
 
     def test_with_command(self):
         """Simulate a user using lldb commands to break on c() if called from a()."""
         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")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByName("c", exe)

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

class CppDataFormatterTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # 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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)

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

class DataFormatterDisablingTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # 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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)

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

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class SkipSummaryDataFormatterTestCase(TestBase):
 
     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()
         self.data_formatter_commands()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

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

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class SmartArrayDataFormatterTestCase(TestBase):
 
     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()
         self.data_formatter_commands()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

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

class DataFormatterSynthValueTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break at.
         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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)

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

 from __future__ import absolute_import
 
 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")])

lldb/trunk/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")])

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

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class DeadStripTestCase(TestBase):
 
     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):
         """Test breakpoint works correctly with dead-code stripping."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

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

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class DisassemblyTestCase(TestBase):
 
     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")
         self.expect("file " + exe,
                     patterns = [ "Current executable set to .*a.out.*" ])
 
         match_object = lldbutil.run_break_set_command (self, "br s -n sum")
         lldbutil.check_breakpoint_result (self, match_object, symbol_name='sum', symbol_match_exact=False, num_locations=1)

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

def setUp(self):
                                                        '// Break here and check b has 0 children')
         self.main_fourth_call_line = line_number('pass-to-base.cpp',
                                                        '// Break here and check b still has 0 children')
         self.main_fifth_call_line = line_number('pass-to-base.cpp',
                                                        '// Break here and check b has one child now')
         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."""
         self.build(dictionary=self.getBuildFlags())
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target from the debugger.
 

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

class ConvenienceVariablesCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break on inside main.cpp.
         self.line = line_number('main.c', 'Hello world.')
 
     @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()
         import pexpect
         exe = os.path.join(os.getcwd(), "a.out")
         prompt = "(lldb) "
         python_prompt = ">>> "
 

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

class ExprDoesntDeadlockTestCase(TestBase):
 
     def getCategories(self):
         return ['basic_process']
 
     mydir = TestBase.compute_mydir(__file__)
 
     @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()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

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

 from lldbsuite.test import lldbplatformutil
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
 class AssertingInferiorTestCase(TestBase):
 
     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.build()
         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()."""
         self.build()
         self.inferior_asserting_step()
 
     def set_breakpoint(self, line):
         lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True)

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

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
 class CrashingInferiorTestCase(TestBase):
 
     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."""
         self.build()
         self.inferior_crashing_expr_step_expr()
 
     def set_breakpoint(self, line):
         lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True)

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

 from lldbsuite.test import lldbplatformutil
 from lldbsuite.test import lldbutil
 
 class CrashingRecursiveInferiorTestCase(TestBase):
 
     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."""
         self.build()
         self.recursive_inferior_crashing_step_after_break()
 
     @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()
         self.recursive_inferior_crashing_expr_step_expr()
 
     def set_breakpoint(self, line):
         lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True)
 

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

 from lldbsuite.test import lldbutil
 
 class LaunchWithShellExpandTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @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")
         
         self.runCmd("target create %s" % exe)
         
         # Create the target
         target = self.dbg.CreateTarget(exe)

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

class LongjmpTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
 
     @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()
         self.step_out()
 
     @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()
         self.step_over()
 
     @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()
         self.step_back_out()
 
     def start_test(self, symbol):
         exe = os.path.join(os.getcwd(), "a.out")
 

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

 from lldbsuite.test import lldbutil
 
 class PluginCommandTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @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."""
 
         plugin_name = "plugin"
         if sys.platform.startswith("darwin"):
             plugin_lib_name = "lib%s.dylib" % plugin_name
         else:

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

 
 class ReturnValueTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @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."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         error = lldb.SBError()
 
         self.target = self.dbg.CreateTarget(exe)

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

 class CreateDuringStepTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         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):
         """Test thread creation during step-inst handling."""
         self.build(dictionary=self.getBuildFlags())
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)

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

 
 class CreateDuringStepTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @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())
         self.create_during_step_base("thread step-inst -m all-threads", 'stop reason = instruction step')
 
     @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())
         self.create_during_step_base("thread step-over -m all-threads", 'stop reason = step over')
 
     @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())
         self.create_during_step_base("thread step-in -m all-threads", 'stop reason = step in')
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

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

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number for our breakpoint.
         self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
 
     @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())
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint in the main thread.
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.breakpoint, num_expected_locations=1)

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

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number for our breakpoint.
         self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
 
     @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())
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint in the main thread.
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.breakpoint, num_expected_locations=1)

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

class ThreadStateTestCase(TestBase):
     def test_state_after_breakpoint(self):
         """Test thread state after breakpoint."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         self.thread_state_after_breakpoint_test()
 
     @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))
         self.thread_state_after_continue_test()
 
     @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.build(dictionary=self.getBuildFlags(use_cpp11=False))
         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))
         self.thread_states_test()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

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

 
 class ThreadStepOutTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @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())
         self.step_out_test(self.step_out_single_thread_with_cmd)
 
     @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())
         self.step_out_test(self.step_out_all_threads_with_cmd)
 
     @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())
         self.step_out_test(self.step_out_with_python)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

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

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class ThreadSpecificBreakTestCase(TestBase):
 
     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()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

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

class ValueMD5CrashTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # 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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)

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

def setUp(self):
         self.line = line_number(self.source, '// Set break point at this line.')
         # This is for verifying that watch location works.
         self.violating_func = "do_bad_thing_with_location";
         # Build dictionary to have unique executable names for each test method.
         self.exe_name = self.testMethodName
         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @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):
         """Test watching a location with '-s size' option."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         exe = os.path.join(os.getcwd(), self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)

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

def setUp(self):
         # Find the line number to break inside main().
         self.line = line_number(self.source, '// Set break point at this line.')
         # And the watchpoint variable declaration line number.
         self.decl = line_number(self.source, '// Watchpoint variable declaration.')
         self.exe_name = 'a.out'
         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)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = os.path.join(os.getcwd(), self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

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

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class WatchpointForMultipleThreadsTestCase(TestBase):
 
     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.setTearDownCleanup()
         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()
         self.setTearDownCleanup()
         self.hello_multiple_threads_wp_set_and_then_delete()
 
     def setUp(self):
         # Call super's setUp().

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

class TestStepOverWatchpoint(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def getCategories(self):
         return ['basic_process']
 
     @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()
         exe = os.path.join(os.getcwd(), 'a.out')
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.target, VALID_TARGET)
 

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

def setUp(self):
         self.line2 = line_number(self.source, '// Set 2nd break point for disable_then_enable test case.')
         # And the watchpoint variable declaration line number.
         self.decl = line_number(self.source, '// Watchpoint variable declaration.')
         # Build dictionary to have unique executable names for each test method.
         self.exe_name = self.testMethodName
         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)
         self.setTearDownCleanup(dictionary=self.d)
         
         exe = os.path.join(os.getcwd(), self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
def test_rw_watchpoint(self):
             substrs = ['exited'])
 
         # Use the '-v' option to do verbose listing of the watchpoint.
         # The hit count should now be 2.
         self.expect("watchpoint list -v",
             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)
         self.setTearDownCleanup(dictionary=self.d)
         
         exe = os.path.join(os.getcwd(), self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
def test_rw_watchpoint_delete(self):
         self.runCmd("process continue")
 
         # There should be no more watchpoint hit and the process status should
         # be 'exited'.
         self.expect("process status",
             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)
         self.setTearDownCleanup(dictionary=self.d)
         
         exe = os.path.join(os.getcwd(), self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
def test_rw_watchpoint_set_ignore_count(self):
             substrs = ['exited'])
 
         # Use the '-v' option to do verbose listing of the watchpoint.
         # Expect to find a hit_count of 2 as well.
         self.expect("watchpoint list -v",
             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)
         self.setTearDownCleanup(dictionary=self.d)
         
         exe = os.path.join(os.getcwd(), self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
def test_rw_disable_after_first_stop(self):
             substrs = ['exited'])
 
         # Use the '-v' option to do verbose listing of the watchpoint.
         # The hit count should be 1.
         self.expect("watchpoint list -v",
             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)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = os.path.join(os.getcwd(), self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

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

def setUp(self):
         self.line = line_number(self.source, '// Set break point at this line.')
         # And the watchpoint variable declaration line number.
         self.decl = line_number(self.source, '// Watchpoint variable declaration.')
         # Build dictionary to have unique executable names for each test method.
         self.exe_name = 'a%d.out' % self.test_number
         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)
         self.setTearDownCleanup(dictionary=self.d)
         
         exe = os.path.join(os.getcwd(), self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
def test_watchpoint_command(self):
             substrs = ['old value:', ' = 0',
                        'new value:', ' = 1'])
 
         # The watchpoint command "forced" our global variable 'cookie' to become 777.
         self.expect("frame variable --show-globals cookie",
             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)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = os.path.join(os.getcwd(), self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

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

def setUp(self):
         self.line = line_number(self.source, '// Set break point at this line.')
         # And the watchpoint variable declaration line number.
         self.decl = line_number(self.source, '// Watchpoint variable declaration.')
         # Build dictionary to have unique executable names for each test method.
         self.exe_name = self.testMethodName
         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @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'."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = os.path.join(os.getcwd(), self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)

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

def setUp(self):
         self.line = line_number(self.source, '// Set break point at this line.')
         # And the watchpoint variable declaration line number.
         self.decl = line_number(self.source, '// Watchpoint variable declaration.')
         # Build dictionary to have unique executable names for each test method.
         self.exe_name = self.testMethodName
         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @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)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = os.path.join(os.getcwd(), self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

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

class TestWatchpointEvents (TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "main.c"
 
     @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()
         
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

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

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestValueOfVectorVariableTestCase(TestBase):
 
     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)
         self.setTearDownCleanup(dictionary=self.d)
         self.value_of_vector_variable_with_watchpoint_set()
     
     def setUp(self):
         # Call super's setUp().

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

def setUp(self):
         # Find the line number to break inside main().
         self.line = line_number(self.source, '// Set break point at this line.')
         # This is for verifying that watch location works.
         self.violating_func = "do_bad_thing_with_location";
         # Build dictionary to have unique executable names for each test method.
 
     @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()
         self.setTearDownCleanup()
 
         exe = os.path.join(os.getcwd(), 'a.out')
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

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

def test_expr_parent(self):
 
         # These should display correctly.
         self.expect("expression pz", VARIABLES_DISPLAYED_CORRECTLY,
             substrs = ["(type_z *) $", " = 0x0000"])
 
         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)
 
         # This should fail because pz is 0, but it succeeds on OS/X.
         # This fails on Linux with an upstream error "Couldn't dematerialize struct", as does "p *n" with "int *n = 0".
         # Note that this can also trigger llvm.org/pr15036 when run interactively at the lldb command prompt.
         self.expect("expression *(type_z *)pz", error = True)

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

class ConstVariableTestCase(TestBase):
     @expectedFailureAll(
         oslist=["freebsd", "linux"],
         compiler="clang", compiler_version=["=", "3.7"])
     @expectedFailureAll(
         oslist=["freebsd", "linux"],
         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()
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break inside the main.
         lldbutil.run_break_set_by_symbol (self, "main", num_expected_locations=1)

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

def test(self):
         lldbutil.run_break_set_by_symbol (self, "string_not_empty", num_expected_locations=1, sym_exact=True)
         self.runCmd("continue")
 
         # Check that we do indeed stop on the string_not_empty function.
         self.expect("process status", STOPPED_DUE_TO_BREAKPOINT,
             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()
         self.runToBreakpoint()
 
         self.expect("expr string_not_empty",
                     substrs = ['(int (*)(const char *)) $0 = ', '(a.out`'])
 

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

class GlobalVariablesTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.source = 'main.c'
         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."""
         self.build()
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget("a.out")
         self.assertTrue(target, VALID_TARGET)

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

 
 class CModulesTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @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()
 
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

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

def setUp(self):
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.line1 = line_number('main.c', '// Set break point #1.')
         self.line2 = line_number('main.c', '// Set break point #2.')
         self.line3 = line_number('main.c', '// Set break point #3.')
         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()
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Set breakpoints on several places to set program variables.
         lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line1, num_expected_locations=1, loc_exact=True)

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

 """Test that types defined in shared libraries with stripped symbols work correctly."""
 
 from __future__ import print_function
 
 
 
 import unittest2
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class SharedLibStrippedTestCase(TestBase):
 
     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.skipTest("llvm.org/pr16214 -- clang emits partial DWARF for structures referenced via typedef")
 
         self.build()
         self.common_setup()
 
         # This should display correctly.
         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"""
         self.build()
         self.common_setup()
 
         # This should display correctly.
         self.expect("frame variable --show-types -- *my_foo_ptr", VARIABLES_DISPLAYED_CORRECTLY,

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

def getCategories(self):
         return ['basic_process']
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # 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()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

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

 """
 Tests that C strings work as expected in expressions
 """
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class CStringsTestCase(TestBase):
     
     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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         line = line_number('main.c', '// breakpoint 1')
         lldbutil.run_break_set_by_file_and_line (self, "main.c", line, num_expected_locations=1, loc_exact=True)
 

lldb/trunk/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")] )

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

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class CPPBreakpointCommandsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows
+    @expectedFailureAll(oslist=["windows"])
     def test(self):
         """Test a sequence of breakpoint command add, list, and delete."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target from the debugger.
 
         target = self.dbg.CreateTarget (exe)

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

 class CallCPPFunctionTestCase(TestBase):
     
     mydir = TestBase.compute_mydir(__file__)
     
     def setUp(self):
         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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("process launch", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list",
                     STOPPED_DUE_TO_BREAKPOINT,
                     substrs = ['stopped', 'stop reason = breakpoint'])
 
         self.expect("expression -- a_function_to_call()",
                     startstr = "(int) $0 = 0")

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

 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestCppChainedCalls(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_with_run_command(self):
         self.build()
 
         # Get main source file
         src_file = "main.cpp"
         src_file_spec = lldb.SBFileSpec(src_file)
         self.assertTrue(src_file_spec.IsValid(), "Main source file")
 

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

class StaticVariableTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # 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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)

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

def setUp(self):
         # Find the line number to break for main.c.                                                                                       
 
         self.do_something_line = line_number('pass-to-base.cpp', '// Break here in doSomething.')
         self.main_first_call_line = line_number('pass-to-base.cpp',
                                                  '// Break here and get real addresses of myB and otherB.')
         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())
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target from the debugger.
 
         target = self.dbg.CreateTarget (exe)

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

class CPPBreakpointTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         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()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target from the debugger.
 
         target = self.dbg.CreateTarget (exe)

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

 """
 Test that global operators are found and evaluated.
 """
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestCppGlobalOperators(TestBase):
     
     mydir = TestBase.compute_mydir(__file__)
     
-    @expectedFailureWindows("llvm.org/pr21765")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_with_run_command(self):
         self.build()
 
         # Get main source file
         src_file = "main.cpp"
         src_file_spec = lldb.SBFileSpec(src_file)
         self.assertTrue(src_file_spec.IsValid(), "Main source file")
         

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

class NamespaceTestCase(TestBase):
     def runToBkpt(self, command):
         self.runCmd(command, RUN_SUCCEEDED)
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
             substrs = ['stopped',
                        '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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line_break_ns1, num_expected_locations=1, loc_exact=True)
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line_break_ns2, num_expected_locations=1, loc_exact=True)
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line_break, num_expected_locations=1, loc_exact=True)

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

class NamespaceLookupTestCase(TestBase):
 
     def runToBkpt(self, command):
         self.runCmd(command, RUN_SUCCEEDED)
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
             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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "ns.cpp", self.line_break_global_scope, num_expected_locations=1, loc_exact=False)
         lldbutil.run_break_set_by_file_and_line (self, "ns2.cpp", self.line_break_ns_scope, num_expected_locations=1, loc_exact=False)
         lldbutil.run_break_set_by_file_and_line (self, "ns2.cpp", self.line_break_nested_ns_scope, num_expected_locations=1, loc_exact=False)
def test_file_scope_lookup_with_run_command(self):
 
         # Run to BP_file_scope at file scope
         self.runToBkpt("run")
         # Evaluate func() - should call static ns2.cpp:func()
         # FIXME: This test fails because lldb doesn't know about file scopes so
         # 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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "ns3.cpp", self.line_break_before_using_directive, num_expected_locations=1, loc_exact=False)
 
         # Run to BP_before_using_directive at global scope before using declaration
         self.runToBkpt("run")
         # Evaluate func() - should call ::func()
         self.expect("expr -- func()", startstr = "(int) $0 = 1")
 
     # 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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "ns3.cpp", self.line_break_after_using_directive, num_expected_locations=1, loc_exact=False)
 
         # Run to BP_after_using_directive at global scope after using declaration
def test_scope_ambiguity_after_using_lookup_with_run_command(self):
 
         # Run to BP_after_using_directive at global scope after using declaration
         self.runToBkpt("run")
         # Evaluate func() - should get error: ambiguous
         # FIXME: This test fails because lldb removes duplicates if they have
         # 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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "ns2.cpp", self.line_break_nested_ns_scope, num_expected_locations=1, loc_exact=False)
 
         # Run to BP_nested_ns_scope at nested ns scope
         self.runToBkpt("run")
         # Evaluate func(10) - should call A::func(10)
         # NOTE: Under the rules of C++, this test would normally get an error
         # because A::B::func() shadows A::func(), but lldb intentionally
         # disobeys these rules so that the intended overload can be found
         # by only removing duplicates if they have the same type.
         self.expect("expr -- func(10)", startstr = "(int) $0 = 13")
 

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

 class CPPStaticMethodsTestCase(TestBase):
     
     mydir = TestBase.compute_mydir(__file__)
     
     def setUp(self):
         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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("process launch", RUN_SUCCEEDED)

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

 #  [5] = e\0\0\0
 #}
 
 class Rdar12991846TestCase(TestBase):
 
     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()
         self.rdar12991846(expr=3)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

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

 """
 Tests that rvalue references are supported in C++
 """
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class RvalueReferencesTestCase(TestBase):
     
     mydir = TestBase.compute_mydir(__file__)
     
     #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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         self.set_breakpoint(line_number('main.cpp', '// breakpoint 1'))
         self.set_breakpoint(line_number('main.cpp', '// breakpoint 2'))
 

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

 """
 Test scopes in C++.
 """
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestCppScopes(TestBase):
 
     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()
 
         # Get main source file
         src_file = "main.cpp"
         src_file_spec = lldb.SBFileSpec(src_file)
         self.assertTrue(src_file_spec.IsValid(), "Main source file")
 

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

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class CPPStaticMembersTestCase(TestBase):
     
     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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         self.set_breakpoint(line_number('main.cpp', '// breakpoint 1'))
         self.set_breakpoint(line_number('main.cpp', '// breakpoint 2'))
 

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

 class CPPStaticMethodsTestCase(TestBase):
     
     mydir = TestBase.compute_mydir(__file__)
     
     def setUp(self):
         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()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("process launch", RUN_SUCCEEDED)

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

 """
 Tests that C++ member and static variables are available where they should be.
 """
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class CPPThisTestCase(TestBase):
     
     mydir = TestBase.compute_mydir(__file__)
     
     #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"""
         self.build()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         self.set_breakpoint(line_number('main.cpp', '// breakpoint 1'))
         self.set_breakpoint(line_number('main.cpp', '// breakpoint 2'))

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

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class Disassemble_VST1_64(TestBase):
 
     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):
         """Test disassembling invalid vst1.64 raw bytes with the API."""
         # Create a target from the debugger.
         target = self.dbg.CreateTargetWithFileAndTargetTriple ("", "thumbv7")
         self.assertTrue(target, VALID_TARGET)
 

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

def test_wait_for_event(self):
         my_thread.join()
 
         self.assertTrue(event,
                         "My listening thread successfully received an event")
 
     @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()
         exe = os.path.join(os.getcwd(), "a.out")
 
         self.dbg.SetAsync(True)
 
         # Create a target by the debugger.

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

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class FrameAPITestCase(TestBase):
 
     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()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

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

def test_with_process_launch_api(self):
 
         thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
         self.assertIsNotNone(thread)
 
         # The breakpoint should have a hit count of 1.
         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."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         target = self.dbg.CreateTarget(self.exe)
 
         # Spawn a new process
def test_with_attach_to_process_with_id_api(self):
         # Let's check the stack traces of the attached process.
         import lldbsuite.test.lldbutil as lldbutil
         stacktraces = lldbutil.print_stacktraces(process, string_buffer=True)
         self.expect(stacktraces, exe=False,
             substrs = ['main.c:%d' % self.line2,
                        '(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."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         target = self.dbg.CreateTarget(self.exe)
 
         # Spawn a new process

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

class RegistersIteratorTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         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()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

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

def setUp(self):
         # Find the line number to break inside main().
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
     @expectedFailureAll("llvm.org/pr23043", ["linux"], archs=["i386"]) # We are unable to produce a backtrace of the main thread when the thread is blocked in fgets
 
     #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."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

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

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class SBValuePersistTestCase(TestBase):
 
     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()
         self.setTearDownCleanup()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_source_regexp (self, "break here")
 

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

class SymbolContextAPITestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to of function 'c'.
         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()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

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

class TargetAPITestCase(TestBase):
     def test_find_global_variables(self):
         """Exercise SBTarget.FindGlobalVariables() API."""
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         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'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.find_functions('b.out')
 
     @add_test_categories(['pyapi'])

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

def test_run_to_address(self):
         # We build a different executable than the default build() does.
         d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.run_to_address(self.exe_name)
 
     @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.
         d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.step_out_of_malloc_into_function_b(self.exe_name)
 

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

class ValueAPITestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # We'll use the test method name as the exe_name.
         self.exe_name = self.testMethodName
         # 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."""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         exe = os.path.join(os.getcwd(), self.exe_name)
 

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

def setUp(self):
         TestBase.setUp(self)
         # We'll use the test method name as the exe_name.
         self.exe_name = self.testMethodName
         # Find the line number to of function 'c'.
         self.line = line_number('main.c', '// Stop here and set values')
         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}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         exe = os.path.join(os.getcwd(), self.exe_name)
 
         # Create a target by the debugger.

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

def setUp(self):
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
         # Find the line number to break inside main().
         self.line = line_number(self.source, '// Set break point at this line.')
 
     @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()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

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

def setUp(self):
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
         # Find the line number to break inside main().
         self.line = line_number(self.source, '// Set break point at this line.')
 
     @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()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

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

def setUp(self):
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
         # Find the line number to break inside main().
         self.line = line_number(self.source, '// Set break point at this line.')
 
     @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()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

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

def setUp(self):
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(self.source, '// Set break point at this line.')
         # This is for verifying that watch location works.
         self.violating_func = "do_bad_thing_with_location";
 
     @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()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

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

def setUp(self):
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(self.source, '// Set break point at this line.')
         # This is for verifying that watch location works.
         self.violating_func = "do_bad_thing_with_location";
 
     @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()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

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

class SettingsCommandTestCase(TestBase):
     def classCleanup(cls):
         """Cleanup the test byproducts."""
         cls.RemoveTempFile("stdout.txt")
 
     @no_debug_info_test
     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")
 
     @no_debug_info_test
     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')
 
     @no_debug_info_test
     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')
 
     @no_debug_info_test
     def test_combined(self):
         self.do_test_args('"a b"c\'d e\'', 'a bcd e\0')
 
     @no_debug_info_test
     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')
 
     def do_test_args(self, args_in, args_out):
         """Test argument parsing. Run the program with args_in. The program dumps its arguments
         to stdout. Compare the stdout with args_out."""
         self.buildDefault()

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

 """
 Test that the lldb-mi driver exits properly.
 """
 
 from __future__ import print_function
 
 import lldbmi_testcase
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class MiExitTestCase(lldbmi_testcase.MiTestCaseBase):
 
     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."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Run to main
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Test -gdb-exit: try to exit and check that program is finished
         self.runCmd("-gdb-exit")
         self.expect("\^exit")
         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."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Run to main
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Test quit: try to exit and check that program is finished
         self.runCmd("quit")
         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."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)

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

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class MiGdbSetShowTestCase(lldbmi_testcase.MiTestCaseBase):
 
     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.spawnLldbMi(args = None)
 
         # Switch to sync mode
         self.runCmd("-gdb-set target-async off")
         self.expect("\^done")
         self.runCmd("-gdb-show target-async")
         self.expect("\^done,value=\"off\"")
 
         # Test that -gdb-set switches to async by default
         self.runCmd("-gdb-set target-async")
         self.expect("\^done")
         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):
         """Test that 'lldb-mi --interpreter' can execute commands in async mode."""
 
         self.spawnLldbMi(args = None)
 
         # Switch to sync mode
def test_lldbmi_gdb_set_target_async_on(self):
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Test that program is executed in async mode
         self.runCmd("-exec-run")
         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):
         """Test that 'lldb-mi --interpreter' can execute commands in sync mode."""
 
         self.spawnLldbMi(args = None)
 
         # Test that -gdb-set can switch to sync mode
         self.runCmd("-gdb-set target-async off")
         self.expect("\^done")
         self.runCmd("-gdb-show target-async")
         self.expect("\^done,value=\"off\"")
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Test that program is executed in async mode
         self.runCmd("-exec-run")
         unexpected = [ "\*running" ] # "\*running" is async notification
         it = self.expect(unexpected + [ "@\"argc=1\\\\r\\\\n" ])
         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.spawnLldbMi(args = None)
 
         # Test that default target-async value is "on"
         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.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Run to main
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Test that -gdb-show language gets 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.spawnLldbMi(args = None)
 
         # Test that -gdb-set fails if property is unknown
         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.spawnLldbMi(args = None)
 
         # Test that -gdb-show fails if property is unknown
         self.runCmd("-gdb-show unknown")
         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):
         """Test that 'lldb-mi --interpreter' works for -gdb-set output-radix."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable