Add target and host platform enums so we're not using strings everywhere

[zturner]

Summary

The original motivation for this came when I tried to combine two decorators:

@expectedFailureDarwin
@expectedFailureLinux

into a single decorator:

@expectedFailureAll(oslist=...)

This results in a really ugly syntax, because @expectedFailureDarwin calls getDarwinOsTriples() which is itself a list. So you would have to do something like this:

@expectedFailureAll(oslist=getDarwinOsTriples()+["linux"])

Not the end of the world, but not ideal either. Then I remembered that we've all had this ugliness surrounding the translation of python api calls such as sys.name, os.platform, and target names and host names into something consistent, so it occurred to me that many things would become cleaner and more elegant if we had actual enums for everything, and a centralized place where we can convert between enums and strings or whatever else we need.

So this patch introduces two enums. target and host, updates the common decorator to support these values from these enums, and changes two decorators to using these new values as a proof of concept.

One nice thing about these enums is that we can make standardized enum values for "combinations" of targets or hosts where it makes sense (such as is the case of with darwin, which is why the getDarwinOsTriples() function existed in the first place. So in that sense it works similarly to a flags enum in C / C++.

Eventually it would be nice if we could start using these enums all over the codebase instead of using strings everywhere, but this patch does not attempt to solve that problem.

[labath]

I like the idea. I think this could help us with the linux vs. android dilemma we've been having recently: currently, we consider android to be a flavour of linux, which means it's not possible to XFAIL tests passing on android but failing on linux. This should make expressing something like that easier.

I wonder, however, whether you need separate enums for host and target. I mean, any system can be used as one or the other, right? (Granted, nobody has tried bringing up lldb client on e.g., android, but I actually don't expect it would be so hard, and I don't see a reason to not support it here). What would you say to merging the two enums and calling it simply os, platform or something?

[zturner]

I think technically there are some platforms that cannot be both a host and a target. ios and anything involving a simulator comes to mind. But, if the only "gotcha" to having both of them be in the same enum is that it's up to the programmer to make sure he's using the right value in the context, then perhaps it's not the end of the world.

BTW, there were some things I wasn't sure whether to add to the enum here. android, remote_android, ios-simulator, etc. Should I add them, or should I leave it as is for now and let other people fix up their own platforms?

[labath]

In D17088#350005, @zturner wrote:

I think technically there are some platforms that cannot be both a host and a target. ios and anything involving a simulator comes to mind. But, if the only "gotcha" to having both of them be in the same enum is that it's up to the programmer to make sure he's using the right value in the context, then perhaps it's not the end of the world.

Although unlikely, I don't think there is an inherent reason lldb could not run there, so yeah, I think one list is better.

BTW, there were some things I wasn't sure whether to add to the enum here. android, remote_android, ios-simulator, etc. Should I add them, or should I leave it as is for now and let other people fix up their own platforms?

I think we should let people add targets when they need to, so let's leave these out for now. As I said, right now we treat android as a flavour of linux. When we change that we can add android and linux_all (or something like that) to the list.

[zturner]

Merged into one list. Also moved code into a new module lldbplatform.

[labath]

looks good.

[tfiala]

LGTM. Having the single list to cover host and target is a good way to go here, too.

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

 from __future__ import print_function
 from __future__ import absolute_import
 
 # System modules
 from distutils.version import LooseVersion, StrictVersion
 from functools import wraps
+import itertools
 import os
 import re
 import sys
 
 # Third-party modules
 import six
 import unittest2
 
 # LLDB modules
 import use_lldb_suite
 
 import lldb
 from . import configuration
 from . import test_categories
 from .result_formatter import EventBuilder
 from lldbsuite.support import funcutils
+from lldbsuite.test import lldbplatform
 from lldbsuite.test import lldbplatformutil
 
 class DecorateMode:
     Skip, Xfail = range(2)
 
     
 # You can use no_match to reverse the test of the conditional that is used to match keyword
 # arguments in the skip / xfail decorators.  If oslist=["windows", "linux"] skips windows

 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,
                  remote=None):
     def fn(self):
-        skip_for_os = _match_decorator_property(oslist, self.getPlatform())
-        skip_for_hostos = _match_decorator_property(hostoslist, lldbplatformutil.getHostPlatform())
+        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.debug_info)
         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_swig_version = (swig_version is None) or (not hasattr(lldb, 'swig_version')) or (_check_expected_version(swig_version[0], swig_version[1], lldb.swig_version))
         skip_for_py_version = (py_version is None) or _check_expected_version(py_version[0], py_version[1], sys.version_info)
def is_remote():
         return "Not ready for remote testsuite" if lldb.remote_platform else None
     return skipTestIfFn(is_remote)(func)
 
 def expectedFailureOS(oslist, bugnumber=None, compilers=None, debug_info=None, archs=None):
     return expectedFailureAll(oslist=oslist, bugnumber=bugnumber, compiler=compilers, archs=archs, debug_info=debug_info)
 
 def expectedFailureDarwin(bugnumber=None, compilers=None, debug_info=None):
     # For legacy reasons, we support both "darwin" and "macosx" as OS X triples.
-    return expectedFailureOS(lldbplatformutil.getDarwinOSTriples(), bugnumber, compilers, debug_info=debug_info)
+    return expectedFailureOS(lldbplatform.darwin_all, bugnumber, compilers, debug_info=debug_info)
 
 def expectedFailureFreeBSD(bugnumber=None, compilers=None, debug_info=None):
-    return expectedFailureOS(['freebsd'], bugnumber, compilers, debug_info=debug_info)
+    return expectedFailureOS(lldbplatform.freebsd, bugnumber, compilers, debug_info=debug_info)
 
 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.
         api_levels - A sequence of numbers specifying the Android API levels
             for which a test is expected to fail. None means all API level.
def skipIfFreeBSD(func):
     return skipIfPlatform(["freebsd"])(func)
 
 def skipIfNetBSD(func):
     """Decorate the item to skip tests that should be skipped on NetBSD."""
     return skipIfPlatform(["netbsd"])(func)
 
 def skipIfDarwin(func):
     """Decorate the item to skip tests that should be skipped on Darwin."""
-    return skipIfPlatform(lldbplatformutil.getDarwinOSTriples())(func)
+    return skipIfPlatform(lldbplatform.translate(lldbplatform.darwin_all))(func)
 
 def skipIfLinux(func):
     """Decorate the item to skip tests that should be skipped on Linux."""
     return skipIfPlatform(["linux"])(func)
 
 def skipIfWindows(func):
     """Decorate the item to skip tests that should be skipped on Windows."""
     return skipIfPlatform(["windows"])(func)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/asan/TestMemoryHistory.py

 """
 Test that ASan memory history provider returns correct stack traces
 """
 
 from __future__ import print_function
 
 
 
 import os, time
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbplatform
 from lldbsuite.test import lldbutil
 
 class AsanTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAll(oslist=["linux"], bugnumber="non-core functionality, need to reenable and fix later (DES 2014.11.07)")
     @skipIfFreeBSD # llvm.org/pr21136 runtimes not yet available by default
     @skipIfRemote
     @skipUnlessCompilerRt
-    @expectedFailureDarwin
+    @expectedFailureAll(oslist=lldbplatform.darwin_all)
     def test (self):
         self.build ()
         self.asan_tests ()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.line_malloc = line_number('main.c', '// malloc line')

lldb/trunk/packages/Python/lldbsuite/test/functionalities/completion/TestCompletion.py

 """
 Test the lldb command line completion mechanism.
 """
 
 from __future__ import print_function
 
 
 
 import os
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbplatform
 from lldbsuite.test import lldbutil
 
 class CommandLineCompletionTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @classmethod
     def classCleanup(cls):
class CommandLineCompletionTestCase(TestBase):
     @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr24679")
     @skipIfFreeBSD # timing out on the FreeBSD buildbot
     @no_debug_info_test
     def test_target_va(self):
         """Test that 'target va' completes to 'target variable '."""
         self.complete_from_to('target va', 'target variable ')
 
     @expectedFailureAll(hostoslist=["windows"], bugnumber="llvm.org/pr24679")
-    @expectedFailureDarwin("llvm.org/pr25485")
+    @expectedFailureAll(oslist=lldbplatform.darwin_all, bugnumber="llvm.org/pr25485")
     def test_symbol_name(self):
         self.build()
         self.complete_from_to('''file a.out
                                  breakpoint set -n Fo''',
                               'breakpoint set -n Foo::Bar(int,\\ int)',
                               turn_off_re_match=True)
 
     def complete_from_to(self, str_input, patterns, turn_off_re_match=False):

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

+""" This module represents an abstraction of an lldb target / host platform. """
+
+from __future__ import absolute_import
+
+# System modules
+import itertools
+
+# Third-party modules
+import six
+
+# LLDB modules
+import use_lldb_suite
+import lldb
+
+windows, linux, macosx, darwin, ios, darwin_all, freebsd, netbsd, bsd_all, android = range(10)
+
+__name_lookup = {
+    windows : ["windows"],
+    linux : ["linux"],
+    macosx : ["macosx"],
+    darwin : ["darwin"],
+    ios : ["ios"],
+    darwin_all : ["macosx", "darwin", "ios"],
+    freebsd : ["freebsd"],
+    netbsd : ["netbsd"],
+    bsd_all : ["freebsd", "netbsd"],
+    android : ["android"]
+}
+
+
+def translate(values):
+
+    if isinstance(values, six.integer_types):
+        # This is a value from the platform enumeration, translate it.
+        return __name_lookup[values]
+    elif isinstance(values, six.string_types):
+        # This is a raw string, return it.
+        return [values]
+    elif hasattr(values, "__iter__"):
+        # This is an iterable, convert each item.
+        result = [translate(x) for x in values]
+        result = list(itertools.chain(*result))
+        return result
+    return values

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

 """ This module contains functions used by the test cases to hide the
 architecture and/or the platform dependent nature of the tests. """
 
 from __future__ import absolute_import
 
 # System modules
+import itertools
 import re
 import subprocess
 import sys
 
 # Third-party modules
+import six
 from six.moves.urllib import parse as urlparse
 
 # LLDB modules
 from . import configuration
 import use_lldb_suite
 import lldb
 
 def check_first_register_readable(test_case):