This is an archive of the discontinued LLVM Phabricator instance.

Differential D3452

Remove excessive copy-and-paste from expectedFailure decorators
ClosedPublic

Authored by emaste on Apr 22 2014, 9:16 AM.

Details

Reviewers
emaste
Commits
rG433790a69c8d: Remove duplication in expectedFailure* decorators
rLLDB206976: Remove duplication in expectedFailure* decorators
rL206976: Remove duplication in expectedFailure* decorators
Summary

The 7 expectedFailureClang,Gcc,Icc etc. decorators were almost entirely copy-and-pasted. Each of those in turn had two copies of the implementation. Refactor this to an expectedFailure decorator that takes a callback function for the failure expectation.

Diff Detail

Event Timeline

emaste updated this revision to Diff 8732.Apr 22 2014, 9:16 AM
emaste retitled this revision from to Remove excessive copy-and-paste from expectedFailure decorators.
emaste updated this object.
emaste edited the test plan for this revision. (Show Details)
emaste added a subscriber: Unknown Object (MLST).
emaste accepted this revision.Apr 23 2014, 6:44 AM
emaste added a reviewer: emaste.
This revision is now accepted and ready to land.Apr 23 2014, 6:44 AM
emaste closed this revision.Apr 23 2014, 6:44 AM

committed as r206976
URL: http://llvm.org/viewvc/llvm-project?rev=206976&view=rev

Revision Contents

PathSize
test/
311 lines

Diff 8732

test/lldbtest.py

Show First 20 Lines • Show All 384 Lines • ▼ Show 20 Lines def wrapper(self, *args, **kwargs):
except AttributeError: except AttributeError:
pass pass
return func(self, *args, **kwargs) return func(self, *args, **kwargs)
# Mark this function as such to separate them from the regular tests. # Mark this function as such to separate them from the regular tests.
wrapper.__not_ready_for_remote_testsuite_test__ = True wrapper.__not_ready_for_remote_testsuite_test__ = True
return wrapper return wrapper
def expectedFailureGcc(bugnumber=None, compiler_version=["=", None]): def expectedFailure(expected_fn, bugnumber=None):
if callable(bugnumber): def expectedFailure_impl(func):
@wraps(bugnumber)
def expectedFailureGcc_easy_wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
test_compiler = self.getCompiler()
try:
bugnumber(*args, **kwargs)
except Exception:
if "gcc" in test_compiler and self.expectedCompilerVersion(compiler_version):
raise case._ExpectedFailure(sys.exc_info(),None)
else:
raise
if "gcc" in test_compiler:
raise case._UnexpectedSuccess(sys.exc_info(),None)
return expectedFailureGcc_easy_wrapper
else:
def expectedFailureGcc_impl(func):
@wraps(func) @wraps(func)
def wrapper(*args, **kwargs): def wrapper(*args, **kwargs):
from unittest2 import case from unittest2 import case
self = args[0] self = args[0]
test_compiler = self.getCompiler()
try: try:
func(*args, **kwargs) func(*args, **kwargs)
except Exception: except Exception:
if "gcc" in test_compiler and self.expectedCompilerVersion(compiler_version): if expected_fn(self):
raise case._ExpectedFailure(sys.exc_info(),bugnumber) raise case._ExpectedFailure(sys.exc_info(), bugnumber)
else: else:
raise raise
if "gcc" in test_compiler: if expected_fn(self):
raise case._UnexpectedSuccess(sys.exc_info(),bugnumber) raise case._UnexpectedSuccess(sys.exc_info(), bugnumber)
return wrapper return wrapper
return expectedFailureGcc_impl
def expectedFailureClang(bugnumber=None):
if callable(bugnumber): if callable(bugnumber):
@wraps(bugnumber) return expectedFailure_impl(bugnumber)
def expectedFailureClang_easy_wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
test_compiler = self.getCompiler()
try:
bugnumber(*args, **kwargs)
except Exception:
if "clang" in test_compiler:
raise case._ExpectedFailure(sys.exc_info(),None)
else: else:
raise return expectedFailure_impl
if "clang" in test_compiler:
raise case._UnexpectedSuccess(sys.exc_info(),None) def expectedFailureCompiler(compiler, compiler_version=None, bugnumber=None):
return expectedFailureClang_easy_wrapper if compiler_version is None:
else: compiler_version=['=', None]
def expectedFailureClang_impl(func): def fn(self):
@wraps(func) return compiler in self.getCompiler() and self.expectedCompilerVersion(compiler_version)
def wrapper(*args, **kwargs): return expectedFailure(fn, bugnumber)
from unittest2 import case
self = args[0] def expectedFailureClang(bugnumber=None):
test_compiler = self.getCompiler() return expectedFailureCompiler('clang', None, bugnumber)
try:
func(*args, **kwargs) def expectedFailureGcc(bugnumber=None, compiler_version=None):
except Exception: return expectedFailureCompiler('gcc', compiler_version, bugnumber)
if "clang" in test_compiler:
raise case._ExpectedFailure(sys.exc_info(),bugnumber)
else:
raise
if "clang" in test_compiler:
raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
return wrapper
return expectedFailureClang_impl
def expectedFailureIcc(bugnumber=None): def expectedFailureIcc(bugnumber=None):
if callable(bugnumber): return expectedFailureCompiler('icc', None, bugnumber)
@wraps(bugnumber)
def expectedFailureIcc_easy_wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
test_compiler = self.getCompiler()
try:
bugnumber(*args, **kwargs)
except Exception:
if "icc" in test_compiler:
raise case._ExpectedFailure(sys.exc_info(),None)
else:
raise
if "icc" in test_compiler:
raise case._UnexpectedSuccess(sys.exc_info(),None)
return expectedFailureIcc_easy_wrapper
else:
def expectedFailureIcc_impl(func):
@wraps(func)
def wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
test_compiler = self.getCompiler()
try:
func(*args, **kwargs)
except Exception:
if "icc" in test_compiler:
raise case._ExpectedFailure(sys.exc_info(),bugnumber)
else:
raise
if "icc" in test_compiler:
raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
return wrapper
return expectedFailureIcc_impl
def expectedFailureArch(arch, bugnumber=None):
def fn(self):
return arch in self.getArchitecture()
return expectedFailure(fn, bugnumber)
def expectedFailurei386(bugnumber=None): def expectedFailurei386(bugnumber=None):
if callable(bugnumber): return expectedFailureArch('i386', bugnumber)
@wraps(bugnumber)
def expectedFailurei386_easy_wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
arch = self.getArchitecture()
try:
bugnumber(*args, **kwargs)
except Exception:
if "i386" in arch:
raise case._ExpectedFailure(sys.exc_info(),None)
else:
raise
if "i386" in arch:
raise case._UnexpectedSuccess(sys.exc_info(),None)
return expectedFailurei386_easy_wrapper
else:
def expectedFailurei386_impl(func):
@wraps(func)
def wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
arch = self.getArchitecture()
try:
func(*args, **kwargs)
except Exception:
if "i386" in arch:
raise case._ExpectedFailure(sys.exc_info(),bugnumber)
else:
raise
if "i386" in arch:
raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
return wrapper
return expectedFailurei386_impl
def expectedFailurex86_64(bugnumber=None): def expectedFailurex86_64(bugnumber=None):
if callable(bugnumber): return expectedFailureArch('x86_64', bugnumber)
@wraps(bugnumber)
def expectedFailurex86_64_easy_wrapper(*args, **kwargs): def expectedFailureOS(os, bugnumber=None, compilers=None):
from unittest2 import case def fn(self):
self = args[0] return os in sys.platform and self.expectedCompiler(compilers)
arch = self.getArchitecture() return expectedFailure(fn, bugnumber)
try:
bugnumber(*args, **kwargs) def expectedFailureDarwin(bugnumber=None, compilers=None):
except Exception: return expectedFailureOS('darwin', bugnumber, compilers)
if "x86_64" in arch:
raise case._ExpectedFailure(sys.exc_info(),None)
else:
raise
if "x86_64" in arch:
raise case._UnexpectedSuccess(sys.exc_info(),None)
return expectedFailurex86_64_easy_wrapper
else:
def expectedFailurex86_64_impl(func):
@wraps(func)
def wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
arch = self.getArchitecture()
try:
func(*args, **kwargs)
except Exception:
if "x86_64" in arch:
raise case._ExpectedFailure(sys.exc_info(),bugnumber)
else:
raise
if "x86_64" in arch:
raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
return wrapper
return expectedFailurex86_64_impl
def expectedFailureFreeBSD(bugnumber=None, compilers=None): def expectedFailureFreeBSD(bugnumber=None, compilers=None):
if callable(bugnumber): return expectedFailureOS('freebsd', bugnumber, compilers)
@wraps(bugnumber)
def expectedFailureFreeBSD_easy_wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
platform = sys.platform
try:
bugnumber(*args, **kwargs)
except Exception:
if "freebsd" in platform and self.expectedCompiler(compilers):
raise case._ExpectedFailure(sys.exc_info(),None)
else:
raise
if "freebsd" in platform and self.expectedCompiler(compilers):
raise case._UnexpectedSuccess(sys.exc_info(),None)
return expectedFailureFreeBSD_easy_wrapper
else:
def expectedFailureFreeBSD_impl(func):
@wraps(func)
def wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
platform = sys.platform
try:
func(*args, **kwargs)
except Exception:
if "freebsd" in platform and self.expectedCompiler(compilers):
raise case._ExpectedFailure(sys.exc_info(),bugnumber)
else:
raise
if "freebsd" in platform and self.expectedCompiler(compilers):
raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
return wrapper
return expectedFailureFreeBSD_impl
def expectedFailureLinux(bugnumber=None, compilers=None): def expectedFailureLinux(bugnumber=None, compilers=None):
if callable(bugnumber): return expectedFailureOS('linux', bugnumber, compilers)
@wraps(bugnumber)
def expectedFailureLinux_easy_wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
platform = sys.platform
try:
bugnumber(*args, **kwargs)
except Exception:
if "linux" in platform and self.expectedCompiler(compilers):
raise case._ExpectedFailure(sys.exc_info(),None)
else:
raise
if "linux" in platform and self.expectedCompiler(compilers):
raise case._UnexpectedSuccess(sys.exc_info(),None)
return expectedFailureLinux_easy_wrapper
else:
def expectedFailureLinux_impl(func):
@wraps(func)
def wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
platform = sys.platform
try:
func(*args, **kwargs)
except Exception:
if "linux" in platform and self.expectedCompiler(compilers):
raise case._ExpectedFailure(sys.exc_info(),bugnumber)
else:
raise
if "linux" in platform and self.expectedCompiler(compilers):
raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
return wrapper
return expectedFailureLinux_impl
def expectedFailureDarwin(bugnumber=None):
if callable(bugnumber):
@wraps(bugnumber)
def expectedFailureDarwin_easy_wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
platform = sys.platform
try:
bugnumber(*args, **kwargs)
except Exception:
if "darwin" in platform:
raise case._ExpectedFailure(sys.exc_info(),None)
else:
raise
if "darwin" in platform:
raise case._UnexpectedSuccess(sys.exc_info(),None)
return expectedFailureDarwin_easy_wrapper
else:
def expectedFailureDarwin_impl(func):
@wraps(func)
def wrapper(*args, **kwargs):
from unittest2 import case
self = args[0]
platform = sys.platform
try:
func(*args, **kwargs)
except Exception:
if "darwin" in platform:
raise case._ExpectedFailure(sys.exc_info(),bugnumber)
else:
raise
if "darwin" in platform:
raise case._UnexpectedSuccess(sys.exc_info(),bugnumber)
return wrapper
return expectedFailureDarwin_impl
def skipIfRemote(func): def skipIfRemote(func):
"""Decorate the item to skip tests if testing remotely.""" """Decorate the item to skip tests if testing remotely."""
if isinstance(func, type) and issubclass(func, unittest2.TestCase): if isinstance(func, type) and issubclass(func, unittest2.TestCase):
raise Exception("@skipIfRemote can only be used to decorate a test method") raise Exception("@skipIfRemote can only be used to decorate a test method")
@wraps(func) @wraps(func)
def wrapper(*args, **kwargs): def wrapper(*args, **kwargs):
from unittest2 import case from unittest2 import case
▲ Show 20 Lines • Show All 1,393 Lines • Show Last 20 Lines