dotest.py: Remove useless AttributeError catches

[labath]

Summary

Test decorators were ignoring AttributeError exceptions. These were introduced three years ago,
and copied to all decorators. They seem to serve no purpose and removing them produces no errors.
Given that they have prevented us from noticing the problem in r249819, I think we should
remove them.

[tfiala]

Looks great. Thanks for tracking that down!

test/lldbtest.py

 
 from functools import wraps
 def python_api_test(func):
     """Decorate the item as a Python API only test."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@python_api_test can only be used to decorate a test method")
     @wraps(func)
     def wrapper(self, *args, **kwargs):
-        try:
-            if lldb.dont_do_python_api_test:
-                self.skipTest("python api tests")
-        except AttributeError:
-            pass
         return func(self, *args, **kwargs)
 
     # Mark this function as such to separate them from lldb command line tests.
     wrapper.__python_api_test__ = True
     return wrapper
 
 def lldbmi_test(func):
     """Decorate the item as a lldb-mi only test."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@lldbmi_test can only be used to decorate a test method")
     @wraps(func)
     def wrapper(self, *args, **kwargs):
-        try:
-            if lldb.dont_do_lldbmi_test:
-                self.skipTest("lldb-mi tests")
-        except AttributeError:
-            pass
         return func(self, *args, **kwargs)
 
     # Mark this function as such to separate them from lldb command line tests.
     wrapper.__lldbmi_test__ = True
     return wrapper
 
 def benchmarks_test(func):
     """Decorate the item as a benchmarks test."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@benchmarks_test can only be used to decorate a test method")
     @wraps(func)
     def wrapper(self, *args, **kwargs):
-        try:
-            if not lldb.just_do_benchmarks_test:
-                self.skipTest("benchmarks tests")
-        except AttributeError:
-            pass
         return func(self, *args, **kwargs)
 
     # Mark this function as such to separate them from the regular tests.
     wrapper.__benchmarks_test__ = True
     return wrapper
 
 def no_debug_info_test(func):
     """Decorate the item as a test what don't use any debug info. If this annotation is specified
def no_debug_info_test(func):
     return wrapper
 
 def dsym_test(func):
     """Decorate the item as a dsym test."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@dsym_test can only be used to decorate a test method")
     @wraps(func)
     def wrapper(self, *args, **kwargs):
-        try:
-            if lldb.dont_do_dsym_test:
-                self.skipTest("dsym tests")
-        except AttributeError:
-            pass
         return func(self, *args, **kwargs)
 
     # Mark this function as such to separate them from the regular tests.
     wrapper.__dsym_test__ = True
     return wrapper
 
 def dwarf_test(func):
     """Decorate the item as a dwarf test."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@dwarf_test can only be used to decorate a test method")
     @wraps(func)
     def wrapper(self, *args, **kwargs):
-        try:
-            if lldb.dont_do_dwarf_test:
-                self.skipTest("dwarf tests")
-        except AttributeError:
-            pass
         return func(self, *args, **kwargs)
 
     # Mark this function as such to separate them from the regular tests.
     wrapper.__dwarf_test__ = True
     return wrapper
 
 def dwo_test(func):
     """Decorate the item as a dwo test."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@dwo_test can only be used to decorate a test method")
     @wraps(func)
     def wrapper(self, *args, **kwargs):
-        try:
-            if lldb.dont_do_dwo_test:
-                self.skipTest("dwo tests")
-        except AttributeError:
-            pass
         return func(self, *args, **kwargs)
 
     # Mark this function as such to separate them from the regular tests.
     wrapper.__dwo_test__ = True
     return wrapper
 
 def debugserver_test(func):
     """Decorate the item as a debugserver test."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@debugserver_test can only be used to decorate a test method")
     @wraps(func)
     def wrapper(self, *args, **kwargs):
-        try:
-            if lldb.dont_do_debugserver_test:
-                self.skipTest("debugserver tests")
-        except AttributeError:
-            pass
         return func(self, *args, **kwargs)
 
     # Mark this function as such to separate them from the regular tests.
     wrapper.__debugserver_test__ = True
     return wrapper
 
 def llgs_test(func):
     """Decorate the item as a lldb-server test."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@llgs_test can only be used to decorate a test method")
     @wraps(func)
     def wrapper(self, *args, **kwargs):
-        try:
-            if lldb.dont_do_llgs_test:
-                self.skipTest("llgs tests")
-        except AttributeError:
-            pass
         return func(self, *args, **kwargs)
 
     # Mark this function as such to separate them from the regular tests.
     wrapper.__llgs_test__ = True
     return wrapper
 
 def not_remote_testsuite_ready(func):
     """Decorate the item as a test which is not ready yet for remote testsuite."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@not_remote_testsuite_ready can only be used to decorate a test method")
     @wraps(func)
     def wrapper(self, *args, **kwargs):
-        try:
-            if lldb.lldbtest_remote_sandbox or lldb.remote_platform:
-                self.skipTest("not ready for remote testsuite")
-        except AttributeError:
-            pass
         return func(self, *args, **kwargs)
 
     # Mark this function as such to separate them from the regular tests.
     wrapper.__not_ready_for_remote_testsuite_test__ = True
     return wrapper
 
 def expectedFailure(expected_fn, bugnumber=None):
     def expectedFailure_impl(func):