[dotest] Add ability to skip tests based on build configuration

[labath]

Summary

Some lldb features depend on xml support. Tests exercising that
functionality can only succeed if lldb was built with xml support. Right
now we have one such test, and another waiting in a patch that's blocked
on this.

This patch implements that functionality by exporting the build
configuration from cmake via configure_file (for the XCode build, I add
a hard-coded configuration file). Then, in dotest we parse this file and
use it to initialize a "feature" configuration variable. I chose a
fairly generic name as other as I anticipate adding other things here,
for example, the list of configured llvm targets. Lastly, I add a
new "features" option to the skipIf decorator enable skipping based on
configured features

The TestTargetXMLArch is updated to match on the xml feature instead of
incorrectly matching on the host platform.

[davide]

After all the work he did on the testsuite I think Adrian is in a good position to review this one.

[labath]

It looks like we'll do something like D43333 instead...

lldb.xcodeproj/lldb_build_config.py

+have_libxml2 = 1

packages/Python/lldbsuite/test/configuration.py

 # Test rerun configuration vars
 rerun_all_issues = False
 rerun_max_file_threhold = 0
 
 # The names of all tests. Used to assert we don't have two tests with the
 # same base name.
 all_tests = set()
 
+# The set of features
+features = set()
+
 def shouldSkipBecauseOfCategories(test_categories):
     if useCategories:
         if len(test_categories) == 0 or len(
                 categoriesList & set(test_categories)) == 0:
             return True
 
     for category in skipCategories:
         if category in test_categories:
             return True
 
     return False
+
+def import_build_config(config):
+    if config.have_libxml2: features.add("xml")

packages/Python/lldbsuite/test/decorators.py

def _match_decorator_property(expected, actual):
     elif isinstance(expected, (re._pattern_type,) + six.string_types):
         return re.search(expected, actual) is not None
     elif hasattr(expected, "__iter__"):
         return any([x is not None and _match_decorator_property(x, actual)
                     for x in expected])
     else:
         return expected == actual
 
+def _match_features(features):
+    if features is None:
+        return True
+
+    if isinstance(features, no_match):
+        return not _match_features(features.item)
+
+    return any([f in configuration.features for f in features])
+
 
 def expectedFailure(expected_fn, bugnumber=None):
     def expectedFailure_impl(func):
         if isinstance(func, type) and issubclass(func, unittest2.TestCase):
             raise Exception(
                 "Decorator can only be used to decorate a test method")
 
         @wraps(func)

 
 def _decorateTest(mode,
                   bugnumber=None, oslist=None, hostoslist=None,
                   compiler=None, compiler_version=None,
                   archs=None, triple=None,
                   debug_info=None,
                   swig_version=None, py_version=None,
                   macos_version=None,
-                  remote=None):
+                  remote=None, features=None):
     def fn(self):
         skip_for_os = _match_decorator_property(
             lldbplatform.translate(oslist), self.getPlatform())
         skip_for_hostos = _match_decorator_property(
             lldbplatform.translate(hostoslist),
             lldbplatformutil.getHostPlatform())
         skip_for_compiler = _match_decorator_property(
             compiler, self.getCompiler()) and self.expectedCompilerVersion(compiler_version)
         skip_for_arch = _match_decorator_property(
             archs, self.getArchitecture())
         skip_for_debug_info = _match_decorator_property(
             debug_info, self.getDebugInfo())
         skip_for_triple = _match_decorator_property(
             triple, lldb.DBG.GetSelectedPlatform().GetTriple())
         skip_for_remote = _match_decorator_property(
             remote, lldb.remote_platform is not None)
+        skip_for_features = _match_features(features)
 
         skip_for_swig_version = (
             swig_version is None) or (
             not hasattr(
                 lldb,
                 'swig_version')) or (
                 _check_expected_version(
                     swig_version[0],
def fn(self):
                       (hostoslist, skip_for_hostos, "host o/s"),
                       (compiler, skip_for_compiler, "compiler or version"),
                       (archs, skip_for_arch, "architecture"),
                       (debug_info, skip_for_debug_info, "debug info format"),
                       (triple, skip_for_triple, "target triple"),
                       (swig_version, skip_for_swig_version, "swig version"),
                       (py_version, skip_for_py_version, "python version"),
                       (macos_version, skip_for_macos_version, "macOS version"),
-                      (remote, skip_for_remote, "platform locality (remote/local)")]
+                      (remote, skip_for_remote, "platform locality (remote/local)"),
+                      (features, skip_for_features, "features"),
+                    ]
         reasons = []
         final_skip_result = True
         for this_condition in conditions:
             final_skip_result = final_skip_result and this_condition[1]
             if this_condition[0] is not None and this_condition[1]:
                 reasons.append(this_condition[2])
         reason_str = None
         if final_skip_result:

 # provide a function to xfail on defined oslist, compiler version, and archs
 # if none is specified for any argument, that argument won't be checked and thus means for all
 # for example,
 # @expectedFailureAll, xfail for all platform/compiler/arch,
 # @expectedFailureAll(compiler='gcc'), xfail for gcc on all platform/architecture
 # @expectedFailureAll(bugnumber, ["linux"], "gcc", ['>=', '4.9'], ['i386']), xfail for gcc>=4.9 on linux with i386
 
 
-def expectedFailureAll(bugnumber=None,
-                       oslist=None, hostoslist=None,
-                       compiler=None, compiler_version=None,
-                       archs=None, triple=None,
-                       debug_info=None,
-                       swig_version=None, py_version=None,
-                       macos_version=None,
-                       remote=None):
-    return _decorateTest(DecorateMode.Xfail,
-                         bugnumber=bugnumber,
-                         oslist=oslist, hostoslist=hostoslist,
-                         compiler=compiler, compiler_version=compiler_version,
-                         archs=archs, triple=triple,
-                         debug_info=debug_info,
-                         swig_version=swig_version, py_version=py_version,
-                         macos_version=None,
-                         remote=remote)
+def expectedFailureAll(*args, **kwargs):
+    return _decorateTest(DecorateMode.Xfail, *args, **kwargs)
 
 
 # provide a function to skip on defined oslist, compiler version, and archs
 # if none is specified for any argument, that argument won't be checked and thus means for all
 # for example,
 # @skipIf, skip for all platform/compiler/arch,
 # @skipIf(compiler='gcc'), skip for gcc on all platform/architecture
 # @skipIf(bugnumber, ["linux"], "gcc", ['>=', '4.9'], ['i386']), skip for gcc>=4.9 on linux with i386
-def skipIf(bugnumber=None,
-           oslist=None, hostoslist=None,
-           compiler=None, compiler_version=None,
-           archs=None, triple=None,
-           debug_info=None,
-           swig_version=None, py_version=None,
-           macos_version=None,
-           remote=None):
-    return _decorateTest(DecorateMode.Skip,
-                         bugnumber=bugnumber,
-                         oslist=oslist, hostoslist=hostoslist,
-                         compiler=compiler, compiler_version=compiler_version,
-                         archs=archs, triple=triple,
-                         debug_info=debug_info,
-                         swig_version=swig_version, py_version=py_version,
-                         macos_version=macos_version,
-                         remote=remote)
+def skipIf(*args, **kwargs):
+    return _decorateTest(DecorateMode.Skip, *args, **kwargs)
 
 
 def _skip_for_android(reason, api_levels, archs):
     def impl(obj):
         result = lldbplatformutil.match_android_device(
             obj.getArchitecture(), valid_archs=archs, valid_api_levels=api_levels)
         return reason if result else None
     return impl

packages/Python/lldbsuite/test/dotest.py

if lldbPythonDir:
         # If tests need to find LLDB_FRAMEWORK, now they can do it
         os.environ["LLDB_FRAMEWORK"] = os.path.dirname(
             os.path.dirname(lldbPythonDir))
 
         # This is to locate the lldb.py module.  Insert it right after
         # sys.path[0].
         sys.path[1:1] = [lldbPythonDir]
 
+    # Import our build configuration
+    build_config_file = None
+    candidates = [
+            os.path.join(lldbLibDir, '..'), # Standalone build
+            os.path.join(lldbLibDir, '..', 'tools', 'lldb'), # Built as a part of llvm
+        ]
+    for c in candidates:
+        c = os.path.join(c, 'test', 'lldb_build_config.py')
+        if os.path.exists(c):
+            build_config_file = c
+            break
+
+    if build_config_file is None:
+        print("Could not find lldb_build_config.py")
+        print("Assuming an XCode build and loading defaults")
+        build_config_file = os.path.join(lldbRootDirectory, 'lldb.xcodeproj',
+                'lldb_build_config.py')
+
+    sys.path.append(os.path.dirname(build_config_file))
+    configuration.import_build_config(__import__("lldb_build_config"))
+    sys.path.pop()
+
 
 def visit_file(dir, name):
     # Try to match the regexp pattern, if specified.
     if configuration.regexp:
         if not re.search(configuration.regexp, name):
             # We didn't match the regex, we're done.
             return
 

packages/Python/lldbsuite/test/functionalities/gdb_remote_client/TestTargetXMLArch.py

 from __future__ import print_function
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from gdbclientutils import *
 
 class TestTargetXMLArch(GDBRemoteTestBase):
 
-    @skipIf(hostoslist=no_match(lldbplatformutil.getDarwinOSTriples()))
+    @skipIf(features=no_match(["xml"]))
     @expectedFailureAll(archs=["i386"])
     def test(self):
         """
         Test lldb's parsing of the <architecture> tag in the target.xml register
         description packet.
         """
         class MyResponder(MockGDBServerResponder):
 

test/CMakeLists.txt

else ()
     message(WARNING "lld required to test LLDB on Windows")
   endif ()
 endif ()
 
 add_custom_target(lldb-test-depends DEPENDS ${LLDB_TEST_DEPENDS})
 # This will add LLDB's test dependencies to the depenednecies for check-all and
 # include them in the test-depends target.
 set_property(GLOBAL APPEND PROPERTY LLVM_LIT_DEPENDS ${ARG_DEPENDS})
+
+llvm_canonicalize_cmake_booleans(LIBXML2_FOUND)
+configure_file(lldb_build_config.py.in lldb_build_config.py @ONLY)

test/lldb_build_config.py.in

+have_libxml2 = @LIBXML2_FOUND@