Allow ExpectedFailure* decorators to work with optional arguments

[chying]

Summary

-if the decorator functions called with optional arguments, return decorator to original method

[chaoren]

Can't you get rid of the if bugnumber: and just check for bugnumber is None inside expectedFailure()?

[chying]

Sorry for the delay. Had to spend some time to understand decorator in Python.
As suggested by Chaoren, removed bugnumber check from all caller functions, and handle None case in expectedFailure.

[chaoren]

LGTM

[chaoren]

test/lldbtest.py

553

Nit: "so it will be used to decorate original method"

[chying]

Submitted

test/lldbtest.py

 import re
 import signal
 from subprocess import *
 import StringIO
 import time
 import types
 import unittest2
 import lldb
+import functools
 from _pyio import __metaclass__
 
 # See also dotest.parseOptionsAndInitTestdirs(), where the environment variables
 # LLDB_COMMAND_TRACE and LLDB_DO_CLEANUP are set from '-t' and '-r dir' options.
 
 # By default, traceAlways is False.
 if "LLDB_COMMAND_TRACE" in os.environ and os.environ["LLDB_COMMAND_TRACE"]=="YES":
     traceAlways = True
def expectedFailure_impl(func):
             except Exception:
                 if expected_fn(self):
                     raise case._ExpectedFailure(sys.exc_info(), bugnumber)
                 else:
                     raise
             if expected_fn(self):
                 raise case._UnexpectedSuccess(sys.exc_info(), bugnumber)
         return wrapper
     if bugnumber: 
         if callable(bugnumber):
             return expectedFailure_impl(bugnumber)
         else:
             return expectedFailure_impl
 
 def expectedFailureCompiler(compiler, compiler_version=None, bugnumber=None):
     if compiler_version is None:
         compiler_version=['=', None]
     def fn(self):
         return compiler in self.getCompiler() and self.expectedCompilerVersion(compiler_version)
     if bugnumber: return expectedFailure(fn, bugnumber)
 
 # to XFAIL a specific clang versions, try this
 # @expectedFailureClang('bugnumber', ['<=', '3.4'])
 def expectedFailureClang(bugnumber=None, compiler_version=None):
+    if bugnumber is None:
+        return functools.partial(expectedFailureClang,compiler_version=compiler_version)
     if bugnumber: return expectedFailureCompiler('clang', compiler_version, bugnumber)
 
 def expectedFailureGcc(bugnumber=None, compiler_version=None):
+    if bugnumber is None:
+        return functools.partial(expectedFailureGcc,compiler_version=compiler_version)
     if bugnumber: return expectedFailureCompiler('gcc', compiler_version, bugnumber)
 
 def expectedFailureIcc(bugnumber=None):
     if bugnumber: return expectedFailureCompiler('icc', None, bugnumber)
 
 def expectedFailureArch(arch, bugnumber=None):
     def fn(self):
         return arch in self.getArchitecture()
     if bugnumber: return expectedFailure(fn, bugnumber)
 
 def expectedFailurei386(bugnumber=None):
     if bugnumber: return expectedFailureArch('i386', bugnumber)
 
 def expectedFailurex86_64(bugnumber=None):
     if bugnumber: return expectedFailureArch('x86_64', bugnumber)
 
 def expectedFailureOS(os, bugnumber=None, compilers=None):
     def fn(self):
         return os in sys.platform and self.expectedCompiler(compilers)
     if bugnumber: return expectedFailure(fn, bugnumber)
 
 def expectedFailureDarwin(bugnumber=None, compilers=None):
+    if bugnumber is None:
+        return functools.partial(expectedFailureDarwin,compilers=compilers)
     if bugnumber: return expectedFailureOS('darwin', bugnumber, compilers)
 
 def expectedFailureFreeBSD(bugnumber=None, compilers=None):
+    if bugnumber is None:
+        return functools.partial(expectedFailureFreeBSD,compilers=compilers)
     if bugnumber: return expectedFailureOS('freebsd', bugnumber, compilers)
 
 def expectedFailureLinux(bugnumber=None, compilers=None):
+    if bugnumber is None:
+        return functools.partial(expectedFailureLinux,compilers=compilers)
     if bugnumber: return expectedFailureOS('linux', bugnumber, compilers)
 
 def expectedFailureWindows(bugnumber=None, compilers=None):
+    if bugnumber is None:
+        return functools.partial(expectedFailureWindows,compilers=compilers)
     if bugnumber: return expectedFailureOS('win32', bugnumber, compilers)
 
 def expectedFailureLLGS(bugnumber=None, compilers=None):
+    if bugnumber is None:
+        return functools.partial(expectedFailureLLGS, compilers=compilers)
     def fn(self):
         # llgs local is only an option on Linux systems
         if 'linux' not in sys.platform:
             return False
         self.runCmd('settings show platform.plugin.linux.use-llgs-for-local')
         return 'true' in self.res.GetOutput() and self.expectedCompiler(compilers)
     if bugnumber: return expectedFailure(fn, bugnumber)