Add initial NetBSD support in lldbsuite/test/lldbtest.py

[krytarowski]

Summary

Add new functions:

• expectedFailureNetBSD()
• expectedFlakeyNetBSD()
• skipIfNetBSD()

Add new NetBSD entry in:

• getPlatform()
• getHostPlatform()

Assume that libc++ is installed and use the GNU toolchain

[emaste]

packages/Python/lldbsuite/test/lldbtest.py

832–834

perhaps put after FlakeyLinux so we only have to move FreeBSD to put it in alpha order

2290–2291

This seems wrong; if a test needs libc++ it should either be skipped on NetBSD right now or use libc++

[joerg]

Two small cleanups, otherwise LGTM.

packages/Python/lldbsuite/test/lldbtest.py

1328

I'd prefer getPlatform() in ("linux", "freebsd", "netbsd") as more shorter.

2288

Same, self.getPlatform in ...

[krytarowski]

Thank you!

packages/Python/lldbsuite/test/lldbtest.py

def expectedFailureDarwin(bugnumber=None, compilers=None, debug_info=None):
     return expectedFailureOS(getDarwinOSTriples(), bugnumber, compilers, debug_info=debug_info)
 
 def expectedFailureFreeBSD(bugnumber=None, compilers=None, debug_info=None):
     return expectedFailureOS(['freebsd'], bugnumber, compilers, debug_info=debug_info)
 
 def expectedFailureLinux(bugnumber=None, compilers=None, debug_info=None):
     return expectedFailureOS(['linux'], bugnumber, compilers, debug_info=debug_info)
 
+def expectedFailureNetBSD(bugnumber=None, compilers=None, debug_info=None):
+    return expectedFailureOS(['netbsd'], bugnumber, compilers, debug_info=debug_info)
+
 def expectedFailureWindows(bugnumber=None, compilers=None, debug_info=None):
     return expectedFailureOS(['windows'], bugnumber, compilers, debug_info=debug_info)
 
 def expectedFailureHostWindows(bugnumber=None, compilers=None):
     return expectedFailureHostOS(['windows'], bugnumber, compilers)
 
 def matchAndroid(api_levels=None, archs=None):
     def match(self):
def fn(self):
         return (self.getPlatform() in oslist and
                 self.expectedCompiler(compilers))
     return expectedFlakey(fn, bugnumber)
 
 def expectedFlakeyDarwin(bugnumber=None, compilers=None):
     # For legacy reasons, we support both "darwin" and "macosx" as OS X triples.
     return expectedFlakeyOS(getDarwinOSTriples(), bugnumber, compilers)
 
+def expectedFlakeyFreeBSD(bugnumber=None, compilers=None):
+    return expectedFlakeyOS(['freebsd'], bugnumber, compilers)
+
 def expectedFlakeyLinux(bugnumber=None, compilers=None):
     return expectedFlakeyOS(['linux'], bugnumber, compilers)
 
-def expectedFlakeyFreeBSD(bugnumber=None, compilers=None):
-    return expectedFlakeyOS(['freebsd'], bugnumber, compilers)
+def expectedFlakeyNetBSD(bugnumber=None, compilers=None):
+    return expectedFlakeyOS(['netbsd'], bugnumber, compilers)
 
 def expectedFlakeyCompiler(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)
     return expectedFlakey(fn, bugnumber)
 

 def skipIfiOSSimulator(func):
     """Decorate the item to skip tests that should be skipped on the iOS Simulator."""
     return unittest2.skipIf(hasattr(lldb, 'remote_platform_name') and lldb.remote_platform_name == 'ios-simulator', 'skip on the iOS Simulator')(func)
 
 def skipIfFreeBSD(func):
     """Decorate the item to skip tests that should be skipped on FreeBSD."""
     return skipIfPlatform(["freebsd"])(func)
 
+def skipIfNetBSD(func):
+    """Decorate the item to skip tests that should be skipped on NetBSD."""
+    return skipIfPlatform(["netbsd"])(func)
+
 def getDarwinOSTriples():
     return ['darwin', 'macosx', 'ios']
 
 def skipIfDarwin(func):
     """Decorate the item to skip tests that should be skipped on Darwin."""
     return skipIfPlatform(getDarwinOSTriples())(func)
 
 def skipIfLinux(func):
def wrapper(*args, **kwargs):
             func(*args, **kwargs)
     return wrapper
 
 def getPlatform():
     """Returns the target platform which the tests are running on."""
     platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
     if platform.startswith('freebsd'):
         platform = 'freebsd'
+    elif platform.startswith('netbsd'):
+        platform = 'netbsd'
     return platform
 
 def getHostPlatform():
     """Returns the host platform running the test suite."""
     # Attempts to return a platform name matching a target Triple platform.
     if sys.platform.startswith('linux'):
         return 'linux'
     elif sys.platform.startswith('win32'):
         return 'windows'
     elif sys.platform.startswith('darwin'):
         return 'darwin'
     elif sys.platform.startswith('freebsd'):
         return 'freebsd'
+    elif sys.platform.startswith('netbsd'):
+        return 'netbsd'
     else:
         return sys.platform
 
 def platformIsDarwin():
     """Returns true if the OS triple for the selected platform is any valid apple OS"""
     return getPlatform() in getDarwinOSTriples()
 
 def skipIfHostIncompatibleWithRemote(func):
def setUpClass(cls):
                 # read the previous owner from the lock file
                 lock_id = cls.dir_lock.handle.read()
                 print("LOCK ERROR: {} wants to lock '{}' but it is already locked by '{}'".format(cls.__name__, full_dir, lock_id), file=sys.stderr)
                 raise ioerror
 
         # Set platform context.
         if platformIsDarwin():
             cls.platformContext = _PlatformContext('DYLD_LIBRARY_PATH', 'lib', 'dylib')
-        elif getPlatform() == "linux" or getPlatform() == "freebsd":
+        elif getPlatform() in ("freebsd", "linux", "netbsd"):
             cls.platformContext = _PlatformContext('LD_LIBRARY_PATH', 'lib', 'so')
         else:
             cls.platformContext = None
 
     @classmethod
     def tearDownClass(cls):
         """
         Python unittest framework class teardown fixture.
class Base(unittest2.TestCase):
     # ==================================================
     # Build methods supported through a plugin interface
     # ==================================================
 
     def getstdlibFlag(self):
         """ Returns the proper -stdlib flag, or empty if not required."""
         if self.platformIsDarwin() or self.getPlatform() == "freebsd":
             stdlibflag = "-stdlib=libc++"
-        else:
+        else: # this includes NetBSD
             stdlibflag = ""
         return stdlibflag
 
     def getstdFlag(self):
         """ Returns the proper stdflag. """
         if "gcc" in self.getCompiler() and "4.6" in self.getCompilerVersion():
           stdflag = "-std=c++0x"
         else:
def getBuildFlags(self, use_cpp11=True, use_libcxx=False, use_libstdcxx=False):
         if use_cpp11:
             cflags += "-std="
             if "gcc" in self.getCompiler() and "4.6" in self.getCompilerVersion():
                 cflags += "c++0x"
             else:
                 cflags += "c++11"
         if self.platformIsDarwin() or self.getPlatform() == "freebsd":
             cflags += " -stdlib=libc++"
+        elif self.getPlatform() == "netbsd":
+            cflags += " -stdlib=libstdc++"
         elif "clang" in self.getCompiler():
             cflags += " -stdlib=libstdc++"
 
         return {'CFLAGS_EXTRAS' : cflags,
                 'LD_EXTRAS' : ldflags,
                }
 
     def cleanup(self, dictionary=None):
def getLLDBLibraryEnvVal(self):
         if existing_library_path:
             return "%s:%s" % (existing_library_path, lib_dir)
         elif sys.platform.startswith("darwin"):
             return os.path.join(lib_dir, 'LLDB.framework')
         else:
             return lib_dir
 
     def getLibcPlusPlusLibs(self):
-        if self.getPlatform() == 'freebsd' or self.getPlatform() == 'linux':
+        if self.getPlatform() in ('freebsd', 'linux', 'netbsd'):
             return ['libc++.so.1']
         else:
             return ['libc++.1.dylib','libc++abi.dylib']
 
 # Metaclass for TestBase to change the list of test metods when a new TestCase is loaded.
 # We change the test methods to create a new test method for each test for each debug info we are
 # testing. The name of the new test method will be '<original-name>_<debug-info>' and with adding
 # the new test method we remove the old method at the same time.
 class LLDBTestCaseFactory(type):
     def __new__(cls, name, bases, attrs):
         newattrs = {}