[lldb] [test] Mark failing tests XFAIL on NetBSD

[mgorny]

Summary

Add a convenience 'expectedFailureNetBSD' decorator and mark all tests
currently failing on NetBSD with it. Also skip a few tests that hang
the test suite. This should establish a baseline for the test suite
and get us closer to enabling tests on buildbot. This will help us
catch regressions while we still have a lot of work to do to get tests
working.

It seems that there are also some flaky tests. I am going to address
them later on.

[mgorny]

Remove leftover decorators import.

[mgorny]

Update the list of failing tests to include tsan tests, and to remove some false positives. I'll probably update it once more soon enough but I'd still appreciate a comment if the style is ok.

[labath]

In general, feel free to add/remove the netbsd decorators as you see fit (or in consulation with kamil or whatever).

[krytarowski]

Feel free to commit this and next without review.

[mgorny]

Thanks. I'm going to retest/update it for master first.

lldb/lit/ExecControl/StopHook/stop-hook-threads.test

 # RUN: %clangxx %p/Inputs/stop-hook-threads.cpp -g -o %t
 # RUN: %lldb -b -s %p/Inputs/stop-hook-threads-1.lldbinit -s %s -f %t \
 # RUN:     | FileCheck --check-prefix=CHECK --check-prefix=CHECK-NO-FILTER %s
 # RUN: %lldb -b -s %p/Inputs/stop-hook-threads-2.lldbinit -s %s -f %t \
 # RUN:     | FileCheck --check-prefix=CHECK --check-prefix=CHECK-FILTER %s
+# XFAIL: system-netbsd
 # XFAIL: system-windows
 # UNSUPPORTED: linux
 
 thread list
 break set -f stop-hook-threads.cpp -p "Set break point at this line"
 target stop-hook list
 
 # CHECK: Hook: 1

 continue
 
 # When we filter per thread, we expect exactly 4 identical "frame var" results
 # CHECK-FILTER: (uint32_t) thread_index = [[THREAD_INDEX:[0-9]*]]
 # CHECK-FILTER-COUNT-3: (uint32_t) thread_index = [[THREAD_INDEX]]
 # CHECK-FILTER-NOT: thread_index
 
 # When we don't filter, we expect to count 12 stopped threads in the thread list output
-# CHECK-NO-FILTER-COUNT-12: at stop-hook-threads.cpp{{.*}} stop reason = breakpoint
+# CHECK-NO-FILTER-COUNT-12: at stop-hook-threads.cpp{{.*}} stop reason = breakpoint
 

lldb/lit/SymbolFile/DWARF/debug-line-basic.s

 # REQUIRES: lld
+# XFAIL: system-netbsd
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: %lldb %t -o "image dump line-table -v a.c" -o exit | FileCheck %s
 
 
   .text
   .globl  _start

lldb/lit/SymbolFile/DWARF/dir-separator-no-comp-dir-relative-name.s

 # Test that parsing of line tables works reasonably. In this case the debug info
 # does not have enough information for our heuristics to determine the path
 # style, so we will just treat them as native host paths.
 
 # REQUIRES: lld
+# XFAIL: system-netbsd
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: %lldb %t -s %S/Inputs/dir-separator-no-comp-dir-relative-name.lldbinit -o exit | FileCheck %s
 
 # CHECK-LABEL: image dump line-table a.c
 # CHECK: Line table for foo{{.}}a.c
 # CHECK-NEXT: 0x0000000000201000: foo{{.}}a.c:1

lldb/lit/SymbolFile/DWARF/dir-separator-no-comp-dir.s

 # Test that we properly determine the path syntax of a compile unit even if the
 # compile unit does not have a DW_AT_comp_dir attribute.
 
 # REQUIRES: lld
+# XFAIL: system-netbsd
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: %lldb %t -s %S/Inputs/dir-separator-windows.lldbinit -o exit | FileCheck %s
 
 # CHECK-LABEL: image dump line-table a.c
 # CHECK: Line table for C:\tmp\a.c
 # CHECK-NEXT: 0x0000000000201000: C:\tmp\a.c:1

lldb/lit/SymbolFile/DWARF/dir-separator-posix.s

 # Test that parsing of line tables works reasonably, even if the host directory
 # separator does not match the separator of the compile unit.
 
 # REQUIRES: lld
+# XFAIL: system-netbsd
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: %lldb %t -s %S/Inputs/dir-separator-posix.lldbinit -o exit | FileCheck %s
 
 # CHECK-LABEL: image dump line-table a.c
 # CHECK: Line table for /tmp/a.c
 # CHECK-NEXT: 0x0000000000201000: /tmp/a.c:1

lldb/lit/SymbolFile/DWARF/dir-separator-windows.s

 # Test that parsing of line tables works reasonably, even if the host directory
 # separator does not match the separator of the compile unit.
 
 # REQUIRES: lld
+# XFAIL: system-netbsd
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: %lldb %t -s %S/Inputs/dir-separator-windows.lldbinit -o exit | FileCheck %s
 
 # CHECK-LABEL: image dump line-table a.c
 # CHECK: Line table for C:\tmp\a.c
 # CHECK-NEXT: 0x0000000000201000: C:\tmp\a.c:1

lldb/lit/SymbolFile/DWARF/find-inline-method.s

 # REQUIRES: lld
+# XFAIL: system-netbsd
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: lldb-test symbols --find=function --name=inl --function-flags=method %t \
 # RUN:   | FileCheck %s
 
 # CHECK: Function: {{.*}} mangled = "_Z8externali"
 # CHECK: Blocks: {{.*}} range = [0x00201000-0x00201002)

lldb/lit/tools/lldb-mi/breakpoint/break-insert-enable-pending.test

 # XFAIL: system-windows
 # -> llvm.org/pr24452
+# XFAIL: system-netbsd
 #
 # RUN: %clang -o %t %p/inputs/break-insert-pending.c -g
 # RUN: %lldbmi %t < %s | FileCheck %s
 
 # Test for enabling pending breakpoints globally
 
 -break-insert printf
 # CHECK: ^error,msg="Command 'break-insert'. Breakpoint location 'printf' not found

lldb/lit/tools/lldb-mi/breakpoint/break-insert.test

+# XFAIL: system-netbsd
+#
 # RUN: %build %p/inputs/break-insert.c --nodefaultlib -o a.exe
 # RUN: %lldbmi < %s | FileCheck %s
 
 # Test that a breakpoint can be inserted before creating a target.
 
 -break-insert breakpoint
 # CHECK: ^done,bkpt={number="1"
 
 -file-exec-and-symbols a.exe
 # CHECK: ^done
 
 -exec-run
 # CHECK: ^running
 # CHECK: *stopped,reason="breakpoint-hit"
 

lldb/lit/tools/lldb-mi/data/data-info-line.test

+# XFAIL: system-netbsd
+#
 # RUN: %build %p/inputs/data-info-line.c --nodefaultlib -o %t
 # RUN: %lldbmi %t < %s | FileCheck %s
 
 # Test lldb-mi -data-info-line command.
 
 # Check that we have a valid target created via '%lldbmi %t'.
 # CHECK: ^done
 

lldb/lit/tools/lldb-mi/exec/exec-continue.test

+# XFAIL: system-netbsd
+#
 # RUN: %build %p/inputs/main.c --nodefaultlib -o %t
 # RUN: %lldbmi %t < %s | FileCheck %s
 
 # Test lldb-mi -exec-continue command.
 
 # Check that we have a valid target created via '%lldbmi %t'.
 # CHECK: ^done
 

lldb/lit/tools/lldb-mi/exec/exec-interrupt.test

+# XFAIL: system-netbsd
+#
 # RUN: %build %p/inputs/main.c --nodefaultlib -o %t
 # RUN: %lldbmi %t < %s | FileCheck %s
 
 # Test lldb-mi -exec-interrupt command.
 
 # Check that we have a valid target created via '%lldbmi %t'.
 # CHECK: ^done
 

lldb/lit/tools/lldb-mi/exec/exec-next-instruction.test

+# XFAIL: system-netbsd
+#
 # RUN: %build %p/inputs/main.c --nodefaultlib -o %t
 # RUN: %lldbmi %t < %s | FileCheck %s
 
 # Test lldb-mi -exec-next-instruction command.
 
 # Check that we have a valid target created via '%lldbmi %t'.
 # CHECK: ^done
 

lldb/lit/tools/lldb-mi/exec/exec-next.test

+# XFAIL: system-netbsd
+#
 # RUN: %build %p/inputs/main.c --nodefaultlib -o %t
 # RUN: %lldbmi %t < %s | FileCheck %s
 
 # Test lldb-mi -exec-next command.
 
 # Check that we have a valid target created via '%lldbmi %t'.
 # CHECK: ^done
 

lldb/lit/tools/lldb-mi/exec/exec-step-instruction.test

+# XFAIL: system-netbsd
+#
 # RUN: %build %p/inputs/main.c --nodefaultlib -o %t
 # RUN: %lldbmi %t < %s | FileCheck %s
 
 # Test lldb-mi -exec-step-instruction command.
 
 # Check that we have a valid target created via '%lldbmi %t'.
 # CHECK: ^done
 

lldb/lit/tools/lldb-mi/exec/exec-step.test

+# XFAIL: system-netbsd
+#
 # RUN: %build %p/inputs/main.c --nodefaultlib -o %t
 # RUN: %lldbmi %t < %s | FileCheck %s
 
 # Test lldb-mi -exec-step command.
 
 # Check that we have a valid target created via '%lldbmi %t'.
 # CHECK: ^done
 

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

def expectedFailureAndroid(bugnumber=None, api_levels=None, archs=None):
     """
     return expectedFailure(
         _skip_for_android(
             "xfailing on android",
             api_levels,
             archs),
         bugnumber)
 
+
+def expectedFailureNetBSD(bugnumber=None):
+    return expectedFailureOS(
+        ['netbsd'],
+        bugnumber)
+
 # Flakey tests get two chances to run. If they fail the first time round, the result formatter
 # makes sure it is run one more time.
 
 
 def expectedFlakey(expected_fn, bugnumber=None):
     def expectedFailure_impl(func):
         @wraps(func)
         def wrapper(*args, **kwargs):

lldb/packages/Python/lldbsuite/test/driver/batch_mode/TestBatchMode.py

class DriverBatchModeTest (TestBase):
     def closeVictim(self):
         if self.victim is not None:
             self.victim.close()
             self.victim = None
 
     @skipIfRemote  # test not remote-ready llvm.org/pr24813
     @expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot")
     @expectedFlakeyLinux("llvm.org/pr25172")
+    @expectedFailureNetBSD
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     def test_batch_mode_attach_exit(self):
         """Test that the lldb driver's batch mode works correctly."""
         self.build()
         self.setTearDownCleanup()
 

lldb/packages/Python/lldbsuite/test/expression_command/call-restarts/TestCallThatRestarts.py

def setUp(self):
         TestBase.setUp(self)
 
         self.main_source = "lotta-signals.c"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
     @skipIfFreeBSD  # llvm.org/pr19246: intermittent failure
     @skipIfDarwin  # llvm.org/pr19246: intermittent failure
     @skipIfWindows  # Test relies on signals, unsupported on Windows
+    @expectedFailureNetBSD
     @expectedFlakeyAndroid(bugnumber="llvm.org/pr19246")
     def test(self):
         """Test calling function that hits a signal and restarts."""
         self.build()
         self.call_function()
 
     def check_after_call(self, num_sigchld):
         after_call = self.sigchld_no.GetValueAsSigned(-1)

lldb/packages/Python/lldbsuite/test/expression_command/expr-in-syscall/TestExpressionInSyscall.py

 
 class ExprSyscallTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr21765, getpid() does not exist on Windows")
+    @expectedFailureNetBSD
     def test_setpgid(self):
         self.build()
         self.expr_syscall()
 
     def expr_syscall(self):
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.

lldb/packages/Python/lldbsuite/test/expression_command/formatters/TestFormatters.py

class ExprFormattersTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.cpp.
         self.line = line_number('main.cpp',
                                 '// Stop here')
 
     @skipIfFreeBSD  # llvm.org/pr24691 skipping to avoid crashing the test runner
+    @expectedFailureNetBSD
     @expectedFailureAll(
         oslist=['freebsd'],
         bugnumber='llvm.org/pr19011 Newer Clang omits C1 complete object constructor')
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     @skipIfTargetAndroid()  # skipping to avoid crashing the test runner
     @expectedFailureAndroid('llvm.org/pr24691')  # we hit an assertion in clang
     def test(self):
         """Test expr + formatters for good interoperability."""

lldb/packages/Python/lldbsuite/test/expression_command/ir-interpreter/TestIRInterpreter.py

def build_and_run(self):
 
         self.runCmd("run", RUN_SUCCEEDED)
 
     @add_test_categories(['pyapi'])
     # getpid() is POSIX, among other problems, see bug
     @expectedFailureAll(
         oslist=['windows'],
         bugnumber="http://llvm.org/pr21765")
+    @expectedFailureNetBSD
     @expectedFailureAll(
         oslist=['linux'],
         archs=['arm'],
         bugnumber="llvm.org/pr27868")
     def test_ir_interpreter(self):
         self.build_and_run()
 
         options = lldb.SBExpressionOptions()

lldb/packages/Python/lldbsuite/test/expression_command/radar_9531204/TestPrintfAfterUp.py

 from lldbsuite.test import lldbutil
 
 
 class Radar9531204TestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     # rdar://problem/9531204
+    @expectedFailureNetBSD
     def test_expr_commands(self):
         """The evaluating printf(...) after break stop and then up a stack frame."""
         self.build()
 
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_symbol(
             self, 'foo', sym_exact=True, num_expected_locations=1)

lldb/packages/Python/lldbsuite/test/expression_command/save_jit_objects/TestSaveJITObjects.py

def countJITFiles(self):
         return len(self.enumerateJITFiles())
 
     def cleanJITFiles(self):
         for j in self.enumerateJITFiles():
             os.remove(j)
         return
 
     @expectedFailureAll(oslist=["windows"])
+    @expectedFailureNetBSD
     def test_save_jit_objects(self):
         self.build()
         os.chdir(self.getBuildDir())
         src_file = "main.c"
         src_file_spec = lldb.SBFileSpec(src_file)
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
             self, "break", src_file_spec)

lldb/packages/Python/lldbsuite/test/expression_command/test/TestExprs.py

def test_evaluate_expression_python(self):
         value = frame.EvaluateExpression('a_function_to_call()', options)
         self.assertTrue(value.IsValid())
         self.assertTrue(value.GetValueAsSigned(0) == 2)
         self.assertTrue(callee_break.GetHitCount() == 2)
 
     # rdar://problem/8686536
     # CommandInterpreter::HandleCommand is stripping \'s from input for
     # WantsRawCommand commands
+    @expectedFailureNetBSD
     def test_expr_commands_can_handle_quotes(self):
         """Throw some expression commands with quotes at lldb."""
         self.build()
 
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False)

lldb/packages/Python/lldbsuite/test/expression_command/timeout/TestCallWithTimeout.py

def setUp(self):
         self.main_source = "wait-a-while.cpp"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
     @expectedFlakeyFreeBSD("llvm.org/pr19605")
     @expectedFailureAll(
         oslist=[
             "windows"],
         bugnumber="llvm.org/pr21765")
+    @expectedFailureNetBSD
     def test(self):
         """Test calling std::String member function."""
         self.build()
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
             self, 'stop here in main.', self.main_source_spec)
 
         # First set the timeout too short, and make sure we fail.

lldb/packages/Python/lldbsuite/test/functionalities/attach_resume/TestAttachResume.py

 
 
 class AttachResumeTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfRemote
     @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr19310')
+    @expectedFailureNetBSD
     @skipIfWindows # llvm.org/pr24778, llvm.org/pr21753
     def test_attach_continue_interrupt_detach(self):
         """Test attach/continue/interrupt/detach"""
         self.build()
         self.process_attach_continue_interrupt_detach()
 
     def process_attach_continue_interrupt_detach(self):
         """Test attach/continue/interrupt/detach"""

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_set_restart/TestBreakpointSetRestart.py

 """
 Test inferior restart when breakpoint is set on running target.
 """
 
 import os
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
 
 class BreakpointSetRestart(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     BREAKPOINT_TEXT = 'Set a breakpoint here'
 
+    @expectedFailureNetBSD
     def test_breakpoint_set_restart(self):
         self.build()
 
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py

 
 class TestCPPExceptionBreakpoint (TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     my_var = 10
 
     @add_test_categories(['pyapi'])
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24538")
+    @expectedFailureNetBSD
     def test_cpp_exception_breakpoint(self):
         """Test setting and hitting the C++ exception breakpoint."""
         self.build()
         self.do_cpp_exception_bkpt()
 
     def setUp(self):
         TestBase.setUp(self)
         self.main_source = "main.c"

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/global_constructor/TestBreakpointInGlobalConstructor.py

 from lldbsuite.test import lldbutil
 
 
 class TestBreakpointInGlobalConstructors(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
+    @expectedFailureNetBSD
     def test(self):
         self.build()
         self.line_foo = line_number('foo.cpp', '// !BR_foo')
         self.line_main = line_number('main.cpp', '// !BR_main')
 
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)
 

lldb/packages/Python/lldbsuite/test/functionalities/data-formatter/setvaluefromcstring/TestSetValueFromCString.py

 from lldbsuite.test import lldbinline
 from lldbsuite.test import decorators
 
 lldbinline.MakeInlineTest(
     __file__, globals(), [
-        decorators.skipIfFreeBSD, decorators.skipIfLinux, decorators.skipIfWindows])
+        decorators.skipIfFreeBSD, decorators.skipIfLinux,
+        decorators.skipIfNetBSD, decorators.skipIfWindows])

lldb/packages/Python/lldbsuite/test/functionalities/data-formatter/summary-string-onfail/Test-rdar-9974002.py

 """
 Test lldb data formatter subsystem.
 """
 
 from __future__ import print_function
 
 
 import os
 import time
 import lldb
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 import lldbsuite.test.lldbutil as lldbutil
 
 
 class Radar9974002DataFormatterTestCase(TestBase):
 
     # test for rdar://problem/9974002 ()
     mydir = TestBase.compute_mydir(__file__)

lldb/packages/Python/lldbsuite/test/functionalities/deleted-executable/TestDeletedExecutable.py

 
 class TestDeletedExecutable(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfWindows # cannot delete a running executable
     @expectedFailureAll(oslist=["linux"]) # determining the architecture of the process fails
+    @expectedFailureNetBSD
     def test(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         popen = self.spawnSubprocess(exe)
         self.addTearDownHook(self.cleanupSubprocesses)
         os.remove(exe)
 
         self.runCmd("process attach -p " + str(popen.pid))
         self.runCmd("kill")

lldb/packages/Python/lldbsuite/test/functionalities/inferior-assert/TestInferiorAssert.py

class AssertingInferiorTestCase(TestBase):
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailureAll(
         oslist=["linux"],
         archs=["arm"],
         bugnumber="llvm.org/pr25338")
     @expectedFailureAll(bugnumber="llvm.org/pr26592", triple='^mips')
+    @expectedFailureNetBSD
     def test_inferior_asserting(self):
         """Test that lldb reliably catches the inferior asserting (command)."""
         self.build()
         self.inferior_asserting()
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
@expectedFailureAll(
         bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailureAll(
         oslist=["linux"],
         archs=[
             "aarch64",
             "arm"],
         bugnumber="llvm.org/pr25338")
     @expectedFailureAll(bugnumber="llvm.org/pr26592", triple='^mips')
+    @expectedFailureNetBSD
     def test_inferior_asserting_disassemble(self):
         """Test that lldb reliably disassembles frames after asserting (command)."""
         self.build()
         self.inferior_asserting_disassemble()
 
     @add_test_categories(['pyapi'])
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     def test_inferior_asserting_python(self):
         """Test that lldb reliably catches the inferior asserting (Python API)."""
         self.build()
         self.inferior_asserting_python()
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailureAll(
         oslist=["linux"],
         archs=[
             "aarch64",
             "arm"],
         bugnumber="llvm.org/pr25338")
     @expectedFailureAll(bugnumber="llvm.org/pr26592", triple='^mips')
+    @expectedFailureNetBSD
     def test_inferior_asserting_expr(self):
         """Test that the lldb expression interpreter can read from the inferior after asserting (command)."""
         self.build()
         self.inferior_asserting_expr()
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailureAll(
         oslist=["linux"],
         archs=[
             "aarch64",
             "arm"],
         bugnumber="llvm.org/pr25338")
     @expectedFailureAll(bugnumber="llvm.org/pr26592", triple='^mips')
+    @expectedFailureNetBSD
     def test_inferior_asserting_step(self):
         """Test that lldb functions correctly after stepping through a call to assert()."""
         self.build()
         self.inferior_asserting_step()
 
     def set_breakpoint(self, line):
         lldbutil.run_break_set_by_file_and_line(
             self, "main.c", line, num_expected_locations=1, loc_exact=True)

lldb/packages/Python/lldbsuite/test/functionalities/inferior-crashing/TestInferiorCrashing.py

 from lldbsuite.test.lldbtest import *
 
 
 class CrashingInferiorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
+    @expectedFailureNetBSD
     def test_inferior_crashing(self):
         """Test that lldb reliably catches the inferior crashing (command)."""
         self.build()
         self.inferior_crashing()
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_inferior_crashing_register(self):
         """Test that lldb reliably reads registers from the inferior after crashing (command)."""
def test_inferior_crashing_step_after_break(self):
         """Test that lldb functions correctly after stepping through a crash."""
         self.build()
         self.inferior_crashing_step_after_break()
 
     # Inferior exits after stepping after a segfault. This is working as
     # intended IMHO.
     @skipIfLinux
     @skipIfFreeBSD
+    @expectedFailureNetBSD
     def test_inferior_crashing_expr_step_and_expr(self):
         """Test that lldb expressions work before and after stepping after a crash."""
         self.build()
         self.inferior_crashing_expr_step_expr()
 
     def set_breakpoint(self, line):
         lldbutil.run_break_set_by_file_and_line(
             self, "main.c", line, num_expected_locations=1, loc_exact=True)

lldb/packages/Python/lldbsuite/test/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py

 from lldbsuite.test import lldbutil
 
 
 class CrashingRecursiveInferiorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
+    @expectedFailureNetBSD
     def test_recursive_inferior_crashing(self):
         """Test that lldb reliably catches the inferior crashing (command)."""
         self.build()
         self.recursive_inferior_crashing()
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_recursive_inferior_crashing_register(self):
         """Test that lldb reliably reads registers from the inferior after crashing (command)."""
def test_recursive_inferior_crashing_step_after_break(self):
         """Test that lldb functions correctly after stepping through a crash."""
         self.build()
         self.recursive_inferior_crashing_step_after_break()
 
     # Inferior exits after stepping after a segfault. This is working as
     # intended IMHO.
     @skipIfLinux
     @skipIfFreeBSD
+    @expectedFailureNetBSD
     def test_recursive_inferior_crashing_expr_step_and_expr(self):
         """Test that lldb expressions work before and after stepping after a crash."""
         self.build()
         self.recursive_inferior_crashing_expr_step_expr()
 
     def set_breakpoint(self, line):
         lldbutil.run_break_set_by_file_and_line(
             self, "main.c", line, num_expected_locations=1, loc_exact=True)

lldb/packages/Python/lldbsuite/test/functionalities/launch_with_shellexpand/TestLaunchWithShellExpand.py

class LaunchWithShellExpandTestCase(TestBase):
 
     @expectedFailureAll(
         oslist=[
             "windows",
             "linux",
             "freebsd"],
         bugnumber="llvm.org/pr24778 llvm.org/pr22627")
     @skipIfDarwinEmbedded # iOS etc don't launch the binary via a shell, so arg expansion won't happen
+    @expectedFailureNetBSD
     def test(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         self.runCmd("target create %s" % exe)
 
         # Create the target
         target = self.dbg.CreateTarget(exe)

lldb/packages/Python/lldbsuite/test/functionalities/load_unload/TestLoadUnload.py

def copy_shlibs_to_remote(self, hidden_dir=False):
                         (wd, err.GetCString()))
 
     # libloadunload_d.so does not appear in the image list because executable
     # dependencies are resolved relative to the debuggers PWD. Bug?
     @expectedFailureAll(oslist=["linux"])
     @skipIfFreeBSD  # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
     @not_remote_testsuite_ready
     @skipIfWindows  # Windows doesn't have dlopen and friends, dynamic libraries work differently
+    @expectedFailureNetBSD
     def test_modules_search_paths(self):
         """Test target modules list after loading a different copy of the library libd.dylib, and verifies that it works with 'target modules search-paths add'."""
         if self.platformIsDarwin():
             dylibName = 'libloadunload_d.dylib'
         else:
             dylibName = 'libloadunload_d.so'
 
         # The directory with the dynamic library we did not link to.
class LoadUnloadTestCase(TestBase):
 
     # libloadunload_d.so does not appear in the image list because executable
     # dependencies are resolved relative to the debuggers PWD. Bug?
     @expectedFailureAll(oslist=["linux"])
     @skipIfFreeBSD  # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
     @expectedFailureAndroid  # wrong source file shows up for hidden library
     @skipIfWindows  # Windows doesn't have dlopen and friends, dynamic libraries work differently
     @skipIfDarwinEmbedded
+    @expectedFailureNetBSD
     def test_dyld_library_path(self):
         """Test (DY)LD_LIBRARY_PATH after moving libd.dylib, which defines d_function, somewhere else."""
         self.copy_shlibs_to_remote(hidden_dir=True)
 
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Shut off ANSI color usage so we don't get ANSI escape sequences
def test_step_over_load(self):
                     substrs=['stopped',
                              'stop reason = step over'])
 
     # We can't find a breakpoint location for d_init before launching because
     # executable dependencies are resolved relative to the debuggers PWD. Bug?
     @expectedFailureAll(oslist=["linux"])
     @skipIfFreeBSD  # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support
     @skipIfWindows  # Windows doesn't have dlopen and friends, dynamic libraries work differently
+    @expectedFailureNetBSD
     def test_static_init_during_load(self):
         """Test that we can set breakpoints correctly in static initializers"""
         self.copy_shlibs_to_remote()
 
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         a_init_bp_num = lldbutil.run_break_set_by_symbol(

lldb/packages/Python/lldbsuite/test/functionalities/longjmp/TestLongjmp.py

class LongjmpTestCase(TestBase):
 
     def setUp(self):
         TestBase.setUp(self)
 
     @skipIfDarwin  # llvm.org/pr16769: LLDB on Mac OS X dies in function ReadRegisterBytes in GDBRemoteRegisterContext.cpp
     @skipIfFreeBSD  # llvm.org/pr17214
     @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr20231")
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
+    @expectedFailureNetBSD
     def test_step_out(self):
         """Test stepping when the inferior calls setjmp/longjmp, in particular, thread step-out."""
         self.build()
         self.step_out()
 
     @skipIfDarwin  # llvm.org/pr16769: LLDB on Mac OS X dies in function ReadRegisterBytes in GDBRemoteRegisterContext.cpp
     @skipIfFreeBSD  # llvm.org/pr17214
     @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr20231")
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
+    @expectedFailureNetBSD
     def test_step_over(self):
         """Test stepping when the inferior calls setjmp/longjmp, in particular, thread step-over a longjmp."""
         self.build()
         self.step_over()
 
     @skipIfDarwin  # llvm.org/pr16769: LLDB on Mac OS X dies in function ReadRegisterBytes in GDBRemoteRegisterContext.cpp
     @skipIfFreeBSD  # llvm.org/pr17214
     @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr20231")
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
+    @expectedFailureNetBSD
     def test_step_back_out(self):
         """Test stepping when the inferior calls setjmp/longjmp, in particular, thread step-out after thread step-in."""
         self.build()
         self.step_back_out()
 
     def start_test(self, symbol):
         exe = self.getBuildArtifact("a.out")
 

lldb/packages/Python/lldbsuite/test/functionalities/object-file/TestImageListMultiArchitecture.py

 
 
 class TestImageListMultiArchitecture(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @no_debug_info_test
     @skipIfRemote
+    @expectedFailureNetBSD
     def test_image_list_shows_multiple_architectures(self):
         """Test that image list properly shows the correct architecture for a set of different architecture object files."""
         images = {
             "hello-freebsd-10.0-x86_64-clang-3.3": re.compile(r"x86_64-(\*)?-freebsd10.0(-unknown)? x86_64"),
             "hello-freebsd-10.0-x86_64-gcc-4.7.3": re.compile(r"x86_64-(\*)?-freebsd10.0(-unknown)? x86_64"),
             "hello-netbsd-6.1-x86_64-gcc-4.5.3": re.compile(r"x86_64-(\*)?-netbsd6.1.4(-unknown)? x86_64"),
             "hello-ubuntu-14.04-x86_64-gcc-4.8.2": re.compile(r"x86_64-(\*)?-linux(-unknown)? x86_64"),
             "hello-ubuntu-14.04-x86_64-clang-3.5pre": re.compile(r"x86_64-(\*)?-linux(-unknown)? x86_64"),

lldb/packages/Python/lldbsuite/test/functionalities/process_attach/TestProcessAttach.py

 
 class ProcessAttachTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfiOSSimulator
+    @expectedFailureNetBSD
     def test_attach_to_process_by_id(self):
         """Test attach by process id"""
         self.build()
         exe = self.getBuildArtifact(exe_name)
 
         # Spawn a new process
         popen = self.spawnSubprocess(exe)
         self.addTearDownHook(self.cleanupSubprocesses)
 
         self.runCmd("process attach -p " + str(popen.pid))
 
         target = self.dbg.GetSelectedTarget()
 
         process = target.GetProcess()
         self.assertTrue(process, PROCESS_IS_VALID)
 
+    @expectedFailureNetBSD
     def test_attach_to_process_from_different_dir_by_id(self):
         """Test attach by process id"""
         newdir = self.getBuildArtifact("newdir")
         try:
             os.mkdir(newdir)
         except OSError as e:
             if e.errno != os.errno.EEXIST:
                 raise
def test_attach_to_process_from_different_dir_by_id(self):
         self.addTearDownHook(lambda: os.chdir(testdir))
         self.runCmd("process attach -p " + str(popen.pid))
 
         target = self.dbg.GetSelectedTarget()
 
         process = target.GetProcess()
         self.assertTrue(process, PROCESS_IS_VALID)
 
+    @expectedFailureNetBSD
     def test_attach_to_process_by_name(self):
         """Test attach by process name"""
         self.build()
         exe = self.getBuildArtifact(exe_name)
 
         # Spawn a new process
         popen = self.spawnSubprocess(exe)
         self.addTearDownHook(self.cleanupSubprocesses)

lldb/packages/Python/lldbsuite/test/functionalities/process_group/TestChangeProcessGroup.py

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.c.
         self.line = line_number('main.c', '// Set breakpoint here')
 
     @skipIfFreeBSD  # Times out on FreeBSD llvm.org/pr23731
     @skipIfWindows  # setpgid call does not exist on Windows
     @expectedFailureAndroid("http://llvm.org/pr23762", api_levels=[16])
+    @expectedFailureNetBSD
     def test_setpgid(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Use a file as a synchronization point between test and inferior.
         pid_file_path = lldbutil.append_to_process_working_directory(self,
             "pid_file_%d" % (int(time.time())))
         self.addTearDownHook(

lldb/packages/Python/lldbsuite/test/functionalities/process_launch/TestProcessLaunch.py

def test_io(self):
         if not success:
             self.fail(err_msg)
 
     # rdar://problem/9056462
     # The process launch flag '-w' for setting the current working directory
     # not working?
     @not_remote_testsuite_ready
     @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr20265")
+    @expectedFailureNetBSD
     def test_set_working_dir_nonexisting(self):
         """Test that '-w dir' fails to set the working dir when running the inferior with a dir which doesn't exist."""
         d = {'CXX_SOURCES': 'print_cwd.cpp'}
         self.build(dictionary=d)
         self.setTearDownCleanup(d)
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe)
 
def test_set_working_dir_existing(self):
             os.remove(err_file_path)
             pass
         except OSError:
             pass
 
         if not success:
             self.fail(err_msg)
 
+    @expectedFailureNetBSD
     def test_environment_with_special_char(self):
         """Test that environment variables containing '*' and '}' are handled correctly by the inferior."""
         source = 'print_env.cpp'
         d = {'CXX_SOURCES': source}
         self.build(dictionary=d)
         self.setTearDownCleanup(d)
         exe = self.getBuildArtifact("a.out")
 

lldb/packages/Python/lldbsuite/test/functionalities/register/intel_avx/TestYMMRegister.py

class TestYMMRegister(TestBase):
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfFreeBSD
     @skipIfiOSSimulator
     @skipIfTargetAndroid()
     @skipIf(archs=no_match(['i386', 'x86_64']))
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37995")
+    @expectedFailureNetBSD
     def test(self):
         self.build(dictionary={"CFLAGS_EXTRAS": "-march=haswell"})
         self.setTearDownCleanup()
 
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
 
         self.assertTrue(target, VALID_TARGET)

lldb/packages/Python/lldbsuite/test/functionalities/register/register_command/TestRegisters.py

def setUp(self):
         self.has_teardown = False
 
     def tearDown(self):
         self.dbg.GetSelectedTarget().GetProcess().Destroy()
         TestBase.tearDown(self)
 
     @skipIfiOSSimulator
     @skipIf(archs=no_match(['amd64', 'arm', 'i386', 'x86_64']))
+    @expectedFailureNetBSD
     def test_register_commands(self):
         """Test commands related to registers, in particular vector registers."""
         self.build()
         self.common_setup()
 
         # verify that logging does not assert
         self.log_enable("registers")
 
def test_register_commands(self):
             error=True)
 
     @skipIfiOSSimulator
     # Writing of mxcsr register fails, presumably due to a kernel/hardware
     # problem
     @skipIfTargetAndroid(archs=["i386"])
     @skipIf(archs=no_match(['amd64', 'arm', 'i386', 'x86_64']))
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37995")
+    @expectedFailureNetBSD
     def test_fp_register_write(self):
         """Test commands that write to registers, in particular floating-point registers."""
         self.build()
         self.fp_register_write()
 
     @skipIfiOSSimulator
     # "register read fstat" always return 0xffff
     @expectedFailureAndroid(archs=["i386"])
     @skipIfFreeBSD  # llvm.org/pr25057
     @skipIf(archs=no_match(['amd64', 'i386', 'x86_64']))
     @skipIfOutOfTreeDebugserver
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37995")
+    @expectedFailureNetBSD
     def test_fp_special_purpose_register_read(self):
         """Test commands that read fpu special purpose registers."""
         self.build()
         self.fp_special_purpose_register_read()
 
     @skipIfiOSSimulator
     @skipIf(archs=no_match(['amd64', 'arm', 'i386', 'x86_64']))
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")
class RegisterCommandsTestCase(TestBase):
     def test_convenience_registers(self):
         """Test convenience registers."""
         self.build()
         self.convenience_registers()
 
     @skipIfiOSSimulator
     @skipIf(archs=no_match(['amd64', 'x86_64']))
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")
+    @expectedFailureNetBSD
     def test_convenience_registers_with_process_attach(self):
         """Test convenience registers after a 'process attach'."""
         self.build()
         self.convenience_registers_with_process_attach(test_16bit_regs=False)
 
     @skipIfiOSSimulator
     @skipIf(archs=no_match(['amd64', 'x86_64']))
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37683")
+    @expectedFailureNetBSD
     def test_convenience_registers_16bit_with_process_attach(self):
         """Test convenience registers after a 'process attach'."""
         self.build()
         self.convenience_registers_with_process_attach(test_16bit_regs=True)
 
     def common_setup(self):
         exe = self.getBuildArtifact("a.out")
 

lldb/packages/Python/lldbsuite/test/functionalities/signal/TestSendSignal.py

def setUp(self):
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.c', 'Put breakpoint here')
 
     @expectedFailureAll(
         oslist=['freebsd'],
         bugnumber="llvm.org/pr23318: does not report running state")
     @skipIfWindows  # Windows does not support signals
+    @expectedFailureNetBSD
     def test_with_run_command(self):
         """Test that lldb command 'process signal SIGUSR1' sends a signal to the inferior process."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/packages/Python/lldbsuite/test/functionalities/signal/raise/TestRaise.py

 
 
 @skipIfWindows  # signals do not exist on Windows
 class RaiseTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
+    @skipIfNetBSD  # Hangs on NetBSD
     def test_sigstop(self):
         self.build()
         self.signal_test('SIGSTOP', False)
         # passing of SIGSTOP is not correctly handled, so not testing that
         # scenario: https://llvm.org/bugs/show_bug.cgi?id=23574
 
     @skipIfDarwin  # darwin does not support real time signals
     @skipIfTargetAndroid()
     def test_sigsigrtmin(self):
         self.build()
         self.signal_test('SIGRTMIN', True)
 
+    @skipIfNetBSD  # Hangs on NetBSD
     def test_sigtrap(self):
         self.build()
         self.signal_test('SIGTRAP', True)
 
     def launch(self, target, signal):
         # launch the process, do not stop at entry point.
         process = target.LaunchSimple(
             [signal], None, self.get_process_working_directory())

lldb/packages/Python/lldbsuite/test/functionalities/target_create_deps/TestTargetCreateDeps.py

def has_exactly_one_image(self, matching, msg=""):
             "image list",
             "image list should contain at least one image",
             substrs=['[  0]'])
         should_match = not matching
         self.expect(
             "image list", msg, matching=should_match, substrs=['[  1]'])
 
     @expectedFailureAll(oslist=["linux"]) #linux does not support loading dependent files
+    @expectedFailureNetBSD
     def test_dependents_implicit_default_exe(self):
         """Test default behavior"""
         exe = self.getBuildArtifact("a.out")
         self.runCmd("target create  " + exe, CURRENT_EXECUTABLE_SET)
         self.has_exactly_one_image(False)
 
     @expectedFailureAll(oslist=["linux"]) #linux does not support loading dependent files
+    @expectedFailureNetBSD
     def test_dependents_explicit_default_exe(self):
         """Test default behavior"""
         exe = self.getBuildArtifact("a.out")
         self.runCmd("target create -ddefault " + exe, CURRENT_EXECUTABLE_SET)
         self.has_exactly_one_image(False)
 
     def test_dependents_explicit_true_exe(self):
         """Test default behavior"""
         exe = self.getBuildArtifact("a.out")
         self.runCmd("target create -dtrue " + exe, CURRENT_EXECUTABLE_SET)
         self.has_exactly_one_image(True)
 
     @expectedFailureAll(oslist=["linux"]) #linux does not support loading dependent files
+    @expectedFailureNetBSD
     def test_dependents_explicit_false_exe(self):
         """Test default behavior"""
         exe = self.getBuildArtifact("a.out")
         self.runCmd("target create -dfalse " + exe, CURRENT_EXECUTABLE_SET)
         self.has_exactly_one_image(False)
 
     def test_dependents_implicit_false_exe(self):
         """Test default behavior"""
class TargetDependentsTestCase(TestBase):
     def test_dependents_explicit_true_lib(self):
         ctx = self.platformContext
         dylibName = ctx.shlib_prefix + 'load_a.' + ctx.shlib_extension
         lib = self.getBuildArtifact(dylibName)
         self.runCmd("target create -dtrue " + lib, CURRENT_EXECUTABLE_SET)
         self.has_exactly_one_image(True)
 
     @expectedFailureAll(oslist=["linux"]) #linux does not support loading dependent files
+    @expectedFailureNetBSD
     def test_dependents_explicit_false_lib(self):
         ctx = self.platformContext
         dylibName = ctx.shlib_prefix + 'load_a.' + ctx.shlib_extension
         lib = self.getBuildArtifact(dylibName)
         self.runCmd("target create -dfalse " + lib, CURRENT_EXECUTABLE_SET)
         self.has_exactly_one_image(False)
 
     def test_dependents_implicit_false_lib(self):
         ctx = self.platformContext
         dylibName = ctx.shlib_prefix + 'load_a.' + ctx.shlib_extension
         lib = self.getBuildArtifact(dylibName)
         self.runCmd("target create -d " + lib, CURRENT_EXECUTABLE_SET)
         self.has_exactly_one_image(True)

lldb/packages/Python/lldbsuite/test/functionalities/thread/backtrace_all/TestBacktraceAll.py

def setUp(self):
         # Find the line number for our breakpoint.
         self.breakpoint = line_number(
             'ParallelTask.cpp', '// Set breakpoint here')
 
     # The android-arm compiler can't compile the inferior
     @skipIfTargetAndroid(archs=["arm"])
     # because of an issue around std::future.
     # TODO: Change the test to don't depend on std::future<T>
+    @expectedFailureNetBSD
     def test(self):
         """Test breakpoint handling after a thread join."""
         self.build(dictionary=self.getBuildFlags())
 
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint

lldb/packages/Python/lldbsuite/test/functionalities/thread/break_after_join/TestBreakAfterJoin.py

@expectedFailureAll(
         oslist=["linux"],
         bugnumber="llvm.org/pr15824 thread states not properly maintained")
     @expectedFailureAll(
         oslist=lldbplatformutil.getDarwinOSTriples(),
         bugnumber="llvm.org/pr15824 thread states not properly maintained and <rdar://problem/28557237>")
     @expectedFailureAll(
         oslist=["freebsd"],
         bugnumber="llvm.org/pr18190 thread states not properly maintained")
+    @expectedFailureNetBSD
     def test(self):
         """Test breakpoint handling after a thread join."""
         self.build(dictionary=self.getBuildFlags())
 
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint in the main thread.

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentBreakpointDelayBreakpointOneSignal.py

 @skipIfWindows
 class ConcurrentBreakpointDelayBreakpointOneSignal(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     def test(self):
         """Test two threads that trigger a breakpoint (one with a 1 second delay) and one signal thread. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_breakpoint_threads=1,
                                num_delay_breakpoint_threads=1,
                                num_signal_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentBreakpointOneDelayBreakpointThreads.py

 @skipIfWindows
 class ConcurrentBreakpointOneDelayBreakpointThreads(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     def test(self):
         """Test threads that trigger a breakpoint where one thread has a 1 second delay. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_breakpoint_threads=1,
                                num_delay_breakpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentBreakpointsDelayedBreakpointOneWatchpoint.py

 class ConcurrentBreakpointsDelayedBreakpointOneWatchpoint(
         ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test a breakpoint, a delayed breakpoint, and one watchpoint thread. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_breakpoint_threads=1,
                                num_delay_breakpoint_threads=1,
                                num_watchpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentCrashWithBreak.py

 @skipIfWindows
 class ConcurrentCrashWithBreak(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     def test(self):
         """ Test a thread that crashes while another thread hits a breakpoint."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_crash_threads=1, num_breakpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentCrashWithSignal.py

 @skipIfWindows
 class ConcurrentCrashWithSignal(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     def test(self):
         """ Test a thread that crashes while another thread generates a signal."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_crash_threads=1, num_signal_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentCrashWithWatchpoint.py

 @skipIfWindows
 class ConcurrentCrashWithWatchpoint(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """ Test a thread that crashes while another thread hits a watchpoint."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_crash_threads=1, num_watchpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentCrashWithWatchpointBreakpointSignal.py

 @skipIfWindows
 class ConcurrentCrashWithWatchpointBreakpointSignal(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """ Test a thread that crashes while other threads generate a signal and hit a watchpoint and breakpoint. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_crash_threads=1,
                                num_breakpoint_threads=1,
                                num_signal_threads=1,
                                num_watchpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentDelaySignalBreak.py

 @skipIfWindows
 class ConcurrentDelaySignalBreak(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     def test(self):
         """Test (1-second delay) signal and a breakpoint in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(
             num_breakpoint_threads=1,
             num_delay_signal_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentDelaySignalWatch.py

 @skipIfWindows
 class ConcurrentDelaySignalWatch(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test a watchpoint and a (1 second delay) signal in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(
             num_delay_signal_threads=1,
             num_watchpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentDelayWatchBreak.py

 @skipIfWindows
 class ConcurrentDelayWatchBreak(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test (1-second delay) watchpoint and a breakpoint in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(
             num_breakpoint_threads=1,
             num_delay_watchpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentDelayedCrashWithBreakpointSignal.py

 @skipIfWindows
 class ConcurrentDelayedCrashWithBreakpointSignal(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     def test(self):
         """ Test a thread with a delayed crash while other threads generate a signal and hit a breakpoint. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_delay_crash_threads=1,
                                num_breakpoint_threads=1,
                                num_signal_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentDelayedCrashWithBreakpointWatchpoint.py

 @skipIfWindows
 class ConcurrentDelayedCrashWithBreakpointWatchpoint(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """ Test a thread with a delayed crash while other threads hit a watchpoint and a breakpoint. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_delay_crash_threads=1,
                                num_breakpoint_threads=1,
                                num_watchpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentNWatchNBreak.py

 @skipIfWindows
 class ConcurrentNWatchNBreak(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test with 5 watchpoint and breakpoint threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_watchpoint_threads=5,
                                num_breakpoint_threads=5)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentSignalBreak.py

 @skipIfWindows
 class ConcurrentSignalBreak(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     def test(self):
         """Test signal and a breakpoint in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_breakpoint_threads=1, num_signal_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentSignalDelayBreak.py

 @skipIfWindows
 class ConcurrentSignalDelayBreak(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     def test(self):
         """Test signal and a (1 second delay) breakpoint in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(
             num_delay_breakpoint_threads=1,
             num_signal_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentSignalDelayWatch.py

 @skipIfWindows
 class ConcurrentSignalDelayWatch(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test a (1 second delay) watchpoint and a signal in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(
             num_signal_threads=1,
             num_delay_watchpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentSignalNWatchNBreak.py

 @skipIfWindows
 class ConcurrentSignalNWatchNBreak(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test one signal thread with 5 watchpoint and breakpoint threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_signal_threads=1,
                                num_watchpoint_threads=5,
                                num_breakpoint_threads=5)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentSignalWatch.py

 @skipIfWindows
 class ConcurrentSignalWatch(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test a watchpoint and a signal in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_signal_threads=1, num_watchpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentSignalWatchBreak.py

 @skipIfWindows
 class ConcurrentSignalWatchBreak(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test a signal/watchpoint/breakpoint in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_signal_threads=1,
                                num_watchpoint_threads=1,
                                num_breakpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentTwoBreakpointThreads.py

 @skipIfWindows
 class ConcurrentTwoBreakpointThreads(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     def test(self):
         """Test two threads that trigger a breakpoint. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_breakpoint_threads=2)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentTwoBreakpointsOneDelaySignal.py

 @skipIfWindows
 class ConcurrentTwoBreakpointsOneDelaySignal(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     def test(self):
         """Test two threads that trigger a breakpoint and one (1 second delay) signal thread. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(
             num_breakpoint_threads=2,
             num_delay_signal_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentTwoBreakpointsOneSignal.py

 @skipIfWindows
 class ConcurrentTwoBreakpointsOneSignal(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     def test(self):
         """Test two threads that trigger a breakpoint and one signal thread. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_breakpoint_threads=2, num_signal_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentTwoBreakpointsOneWatchpoint.py

 @skipIfWindows
 class ConcurrentTwoBreakpointsOneWatchpoint(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test two threads that trigger a breakpoint and one watchpoint thread. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(
             num_breakpoint_threads=2,
             num_watchpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointThreads.py

 @skipIfWindows
 class ConcurrentTwoWatchpointThreads(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test two threads that trigger a watchpoint. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_watchpoint_threads=2)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneBreakpoint.py

 @skipIfWindows
 class ConcurrentTwoWatchpointsOneBreakpoint(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test two threads that trigger a watchpoint and one breakpoint thread. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(
             num_watchpoint_threads=2,
             num_breakpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneDelayBreakpoint.py

 @skipIfWindows
 class ConcurrentTwoWatchpointsOneDelayBreakpoint(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test two threads that trigger a watchpoint and one (1 second delay) breakpoint thread. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(
             num_watchpoint_threads=2,
             num_delay_breakpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentTwoWatchpointsOneSignal.py

 class ConcurrentTwoWatchpointsOneSignal(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
     @expectedFailureAll(bugnumber="llvm.org/pr35228", archs=["arm", "aarch64"])
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test two threads that trigger a watchpoint and one signal thread. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_watchpoint_threads=2, num_signal_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentWatchBreak.py

 @skipIfWindows
 class ConcurrentWatchBreak(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test watchpoint and a breakpoint in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(
             num_breakpoint_threads=1,
             num_watchpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentWatchBreakDelay.py

 @skipIfWindows
 class ConcurrentWatchBreakDelay(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test watchpoint and a (1 second delay) breakpoint in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(
             num_delay_breakpoint_threads=1,
             num_watchpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentWatchpointDelayWatchpointOneBreakpoint.py

 @skipIfWindows
 class ConcurrentWatchpointDelayWatchpointOneBreakpoint(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test two threads that trigger a watchpoint (one with a 1 second delay) and one breakpoint thread. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_watchpoint_threads=1,
                                num_delay_watchpoint_threads=1,
                                num_breakpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/TestConcurrentWatchpointWithDelayWatchpointThreads.py

 @skipIfWindows
 class ConcurrentWatchpointWithDelayWatchpointThreads(ConcurrentEventsBase):
 
     mydir = ConcurrentEventsBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # timing out on buildbot
     # Atomic sequences are not supported yet for MIPS in LLDB.
     @skipIf(triple='^mips')
+    @expectedFailureNetBSD
     @add_test_categories(["watchpoint"])
     def test(self):
         """Test two threads that trigger a watchpoint where one thread has a 1 second delay. """
         self.build(dictionary=self.getBuildFlags())
         self.do_thread_actions(num_watchpoint_threads=1,
                                num_delay_watchpoint_threads=1)

lldb/packages/Python/lldbsuite/test/functionalities/thread/create_after_attach/TestCreateAfterAttach.py

class CreateAfterAttachTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # Hangs.  May be the same as Linux issue llvm.org/pr16229 but
     # not yet investigated.  Revisit once required functionality
     # is implemented for FreeBSD.
     # Occasionally hangs on Windows, may be same as other issues.
     @skipIfWindows
     @skipIfiOSSimulator
+    @expectedFailureNetBSD
     def test_create_after_attach_with_popen(self):
         """Test thread creation after process attach."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         self.create_after_attach(use_fork=False)
 
     @skipIfFreeBSD  # Hangs. Revisit once required functionality is implemented
     # for FreeBSD.
     @skipIfRemote
     @skipIfWindows  # Windows doesn't have fork.
     @skipIfiOSSimulator
+    @expectedFailureNetBSD
     def test_create_after_attach_with_fork(self):
         """Test thread creation after process attach."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         self.create_after_attach(use_fork=True)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

lldb/packages/Python/lldbsuite/test/functionalities/thread/create_during_step/TestCreateDuringStep.py

@expectedFailureAll(
         oslist=lldbplatformutil.getDarwinOSTriples(),
         bugnumber="llvm.org/pr15824 thread states not properly maintained, <rdar://problem/28557237>")
     @expectedFailureAll(
         oslist=["freebsd"],
         bugnumber="llvm.org/pr18190 thread states not properly maintained")
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
+    @expectedFailureNetBSD
     def test_step_inst(self):
         """Test thread creation during step-inst handling."""
         self.build(dictionary=self.getBuildFlags())
         self.create_during_step_base(
             "thread step-inst -m all-threads",
             'stop reason = instruction step')
 
     @expectedFailureAll(
         oslist=["linux"],
         bugnumber="llvm.org/pr15824 thread states not properly maintained")
     @expectedFailureAll(
         oslist=lldbplatformutil.getDarwinOSTriples(),
         bugnumber="llvm.org/pr15824 thread states not properly maintained, <rdar://problem/28557237>")
     @expectedFailureAll(
         oslist=["freebsd"],
         bugnumber="llvm.org/pr18190 thread states not properly maintained")
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
+    @expectedFailureNetBSD
     def test_step_over(self):
         """Test thread creation during step-over handling."""
         self.build(dictionary=self.getBuildFlags())
         self.create_during_step_base(
             "thread step-over -m all-threads",
             'stop reason = step over')
 
     @expectedFailureAll(
         oslist=["linux"],
         bugnumber="llvm.org/pr15824 thread states not properly maintained")
     @expectedFailureAll(
         oslist=lldbplatformutil.getDarwinOSTriples(),
         bugnumber="<rdar://problem/28574077>")
     @expectedFailureAll(
         oslist=["freebsd"],
         bugnumber="llvm.org/pr18190 thread states not properly maintained")
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
+    @expectedFailureNetBSD
     def test_step_in(self):
         """Test thread creation during step-in handling."""
         self.build(dictionary=self.getBuildFlags())
         self.create_during_step_base(
             "thread step-in -m all-threads",
             'stop reason = step in')
 
     def setUp(self):

lldb/packages/Python/lldbsuite/test/functionalities/thread/exit_during_break/TestExitDuringBreak.py

class ExitDuringBreakpointTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number for our breakpoint.
         self.breakpoint = line_number('main.cpp', '// Set breakpoint here')
 
+    @expectedFailureNetBSD
     def test(self):
         """Test thread exit during breakpoint handling."""
         self.build(dictionary=self.getBuildFlags())
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint in the main thread.
         lldbutil.run_break_set_by_file_and_line(

lldb/packages/Python/lldbsuite/test/functionalities/thread/exit_during_step/TestExitDuringStep.py

 
 
 class ExitDuringStepTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfFreeBSD  # llvm.org/pr21411: test is hanging
     @skipIfWindows # This is flakey on Windows: llvm.org/pr38373
+    @expectedFailureNetBSD
     def test(self):
         """Test thread exit during step handling."""
         self.build(dictionary=self.getBuildFlags())
         self.exit_during_step_base(
             "thread step-inst -m all-threads",
             'stop reason = instruction step',
             True)
 
     @skipIfFreeBSD  # llvm.org/pr21411: test is hanging
     @skipIfWindows # This is flakey on Windows: llvm.org/pr38373
+    @expectedFailureNetBSD
     def test_step_over(self):
         """Test thread exit during step-over handling."""
         self.build(dictionary=self.getBuildFlags())
         self.exit_during_step_base(
             "thread step-over -m all-threads",
             'stop reason = step over',
             False)
 
     @skipIfFreeBSD  # llvm.org/pr21411: test is hanging
     @skipIfWindows # This is flakey on Windows: llvm.org/pr38373
+    @expectedFailureNetBSD
     def test_step_in(self):
         """Test thread exit during step-in handling."""
         self.build(dictionary=self.getBuildFlags())
         self.exit_during_step_base(
             "thread step-in -m all-threads",
             'stop reason = step in',
             False)
 

lldb/packages/Python/lldbsuite/test/functionalities/thread/multi_break/TestMultipleBreakpoints.py

@expectedFailureAll(
         bugnumber="llvm.org/pr15824 thread states not properly maintained")
     @expectedFailureAll(
         oslist=lldbplatformutil.getDarwinOSTriples(),
         bugnumber="llvm.org/pr15824 thread states not properly maintained and <rdar://problem/28557237>")
     @expectedFailureAll(
         oslist=["freebsd"],
         bugnumber="llvm.org/pr18190 thread states not properly maintained")
     @skipIfWindows # This is flakey on Windows: llvm.org/pr24668, llvm.org/pr38373
+    @expectedFailureNetBSD
     def test(self):
         """Test simultaneous breakpoints in multiple threads."""
         self.build(dictionary=self.getBuildFlags())
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint in the main thread.
         lldbutil.run_break_set_by_file_and_line(

lldb/packages/Python/lldbsuite/test/functionalities/thread/num_threads/TestNumThreads.py

class NumberOfThreadsTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers for our break points.
         self.thread3_notify_all_line = line_number('main.cpp', '// Set thread3 break point on notify_all at this line.')
         self.thread3_before_lock_line = line_number('main.cpp', '// thread3-before-lock')
 
+    @expectedFailureNetBSD
     def test_number_of_threads(self):
         """Test number of threads."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint with 1 location.
         lldbutil.run_break_set_by_file_and_line(
def test_number_of_threads(self):
         # Using std::thread may involve extra threads, so we assert that there are
         # at least 4 rather than exactly 4.
         self.assertTrue(
             num_threads >= 13,
             'Number of expected threads and actual threads do not match.')
 
     @skipIfDarwin # rdar://33462362
     @skipIfWindows # This is flakey on Windows: llvm.org/pr37658, llvm.org/pr38373
+    @expectedFailureNetBSD
     def test_unique_stacks(self):
         """Test backtrace unique with multiple threads executing the same stack."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Set a break point on the thread3 notify all (should get hit on threads 4-13).
         lldbutil.run_break_set_by_file_and_line(

lldb/packages/Python/lldbsuite/test/functionalities/thread/state/TestThreadStates.py

class ThreadStateTestCase(TestBase):
 
     @expectedFailureAll(
         oslist=["linux"],
         bugnumber="llvm.org/pr15824 thread states not properly maintained")
     @skipIfDarwin # llvm.org/pr15824 thread states not properly maintained and <rdar://problem/28557237>
     @expectedFailureAll(
         oslist=["freebsd"],
         bugnumber="llvm.org/pr18190 thread states not properly maintained")
+    @expectedFailureNetBSD
     def test_state_after_breakpoint(self):
         """Test thread state after breakpoint."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         self.thread_state_after_breakpoint_test()
 
     @skipIfDarwin  # 'llvm.org/pr23669', cause Python crash randomly
     @expectedFailureAll(
         oslist=lldbplatformutil.getDarwinOSTriples(),
         bugnumber="llvm.org/pr23669")
     @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr15824")
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24660")
+    @expectedFailureNetBSD
     def test_state_after_continue(self):
         """Test thread state after continue."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         self.thread_state_after_continue_test()
 
     @skipIfDarwin  # 'llvm.org/pr23669', cause Python crash randomly
     @expectedFailureDarwin('llvm.org/pr23669')
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24660")
+    @expectedFailureNetBSD
     # thread states not properly maintained
     @unittest2.expectedFailure("llvm.org/pr16712")
     def test_state_after_expression(self):
         """Test thread state after expression."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         self.thread_state_after_expression_test()
 
     # thread states not properly maintained
     @unittest2.expectedFailure("llvm.org/pr15824 and <rdar://problem/28557237>")
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     @skipIfDarwin # llvm.org/pr15824 thread states not properly maintained and <rdar://problem/28557237>
+    @expectedFailureNetBSD
     def test_process_state(self):
         """Test thread states (comprehensive)."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         self.thread_states_test()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
def thread_state_after_expression_test(self):
 
         # Let the process run to completion
         self.runCmd("process continue")
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24668: Breakpoints not resolved correctly")
     @skipIfDarwin # llvm.org/pr15824 thread states not properly maintained and <rdar://problem/28557237>
+    @expectedFailureNetBSD
     @no_debug_info_test
     def test_process_interrupt(self):
         """Test process interrupt and continue."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint in the main thread.

lldb/packages/Python/lldbsuite/test/functionalities/thread/step_out/TestThreadStepOut.py

class ThreadStepOutTestCase(TestBase):
     @expectedFailureAll(
         oslist=["linux"],
         bugnumber="llvm.org/pr23477 Test occasionally times out on the Linux build bot")
     @expectedFailureAll(
         oslist=["freebsd"],
         bugnumber="llvm.org/pr18066 inferior does not exit")
     @skipIfWindows # This test will hang on windows llvm.org/pr21753
     @expectedFailureAll(oslist=["windows"])
+    @expectedFailureNetBSD
     def test_step_single_thread(self):
         """Test thread step out on one thread via command interpreter. """
         self.build(dictionary=self.getBuildFlags())
         self.step_out_test(self.step_out_single_thread_with_cmd)
 
     # Test occasionally times out on the Linux build bot
     @skipIfLinux
     @expectedFailureAll(
         oslist=["linux"],
         bugnumber="llvm.org/pr23477 Test occasionally times out on the Linux build bot")
     @expectedFailureAll(
         oslist=["freebsd"],
         bugnumber="llvm.org/pr19347 2nd thread stops at breakpoint")
     @skipIfWindows # This test will hang on windows llvm.org/pr21753
     @expectedFailureAll(oslist=["windows"])
     @expectedFailureAll(oslist=["watchos"], archs=['armv7k'], bugnumber="rdar://problem/34674488") # stop reason is trace when it should be step-out
+    @expectedFailureNetBSD
     def test_step_all_threads(self):
         """Test thread step out on all threads via command interpreter. """
         self.build(dictionary=self.getBuildFlags())
         self.step_out_test(self.step_out_all_threads_with_cmd)
 
     # Test occasionally times out on the Linux build bot
     @skipIfLinux
     @expectedFailureAll(
         oslist=["linux"],
         bugnumber="llvm.org/pr23477 Test occasionally times out on the Linux build bot")
     @expectedFailureAll(
         oslist=["freebsd"],
         bugnumber="llvm.org/pr19347 2nd thread stops at breakpoint")
     @skipIfWindows # This test will hang on windows llvm.org/pr21753
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24681")
+    @expectedFailureNetBSD
     def test_python(self):
         """Test thread step out on one thread via Python API (dwarf)."""
         self.build(dictionary=self.getBuildFlags())
         self.step_out_test(self.step_out_with_python)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

lldb/packages/Python/lldbsuite/test/functionalities/thread/thread_exit/TestThreadExit.py

def setUp(self):
         TestBase.setUp(self)
         # Find the line numbers for our breakpoints.
         self.break_1 = line_number('main.cpp', '// Set first breakpoint here')
         self.break_2 = line_number('main.cpp', '// Set second breakpoint here')
         self.break_3 = line_number('main.cpp', '// Set third breakpoint here')
         self.break_4 = line_number('main.cpp', '// Set fourth breakpoint here')
 
     @skipIfWindows # This is flakey on Windows: llvm.org/pr38373
+    @expectedFailureNetBSD
     def test(self):
         """Test thread exit handling."""
         self.build(dictionary=self.getBuildFlags())
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint with 1 location.
         bp1_id = lldbutil.run_break_set_by_file_and_line(

lldb/packages/Python/lldbsuite/test/functionalities/thread/thread_specific_break/TestThreadSpecificBreakpoint.py

class ThreadSpecificBreakTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     @add_test_categories(['pyapi'])
 
     @expectedFailureAll(oslist=["windows"])
     @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'armv7k'], bugnumber='rdar://problem/34563920') # armv7 ios problem - breakpoint with tid qualifier isn't working
+    @expectedFailureNetBSD
     def test_thread_id(self):
         self.do_test(set_thread_id)
 
     @skipUnlessDarwin
     @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'armv7k'], bugnumber='rdar://problem/34563920') # armv7 ios problem - breakpoint with tid qualifier isn't working
+    @expectedFailureNetBSD
     def test_thread_name(self):
         self.do_test(set_thread_name)
 
     def do_test(self, setter_method):
         """Test that we obey thread conditioned breakpoints."""
         self.build()
         main_source_spec = lldb.SBFileSpec("main.cpp")
         (target, process, main_thread, main_breakpoint) = lldbutil.run_to_source_breakpoint(self,

lldb/packages/Python/lldbsuite/test/functionalities/thread/thread_specific_break_plus_condition/TestThreadSpecificBpPlusCondition.py

class ThreadSpecificBreakPlusConditionTestCase(TestBase):
 
     # test frequently times out or hangs
     @skipIf(oslist=['windows', 'freebsd'])
     @skipIfDarwin
     # hits break in another thread in testrun
     @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr18522')
     @add_test_categories(['pyapi'])
     @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'armv7k'], bugnumber='rdar://problem/34563348') # Two threads seem to end up with the same my_value when built for armv7.
+    @expectedFailureNetBSD
     def test_python(self):
         """Test that we obey thread conditioned breakpoints."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/packages/Python/lldbsuite/test/functionalities/unwind/noreturn/TestNoreturnUnwind.py

 
 class NoreturnUnwind(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfWindows  # clang-cl does not support gcc style attributes.
     # clang does not preserve LR in noreturn functions, making unwinding impossible
     @skipIf(compiler="clang", archs=['arm'], oslist=['linux'])
     @expectedFailureAll(bugnumber="llvm.org/pr33452", triple='^mips')
+    @expectedFailureNetBSD
     def test(self):
         """Test that we can backtrace correctly with 'noreturn' functions on the stack"""
         self.build()
         self.setTearDownCleanup()
 
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchlocation/TestWatchLocation.py

@expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Most of the MIPS boards provide only one H/W watchpoints, and S/W
     # watchpoints are not supported yet
     @expectedFailureAll(triple=re.compile('^mips'))
     # SystemZ and PowerPC also currently supports only one H/W watchpoint
     @expectedFailureAll(archs=['powerpc64le', 's390x'])
     @skipIfDarwin
+    @expectedFailureNetBSD
     def test_hello_watchlocation(self):
         """Test watching a location with '-s size' option."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Add a breakpoint to set a watchpoint when stopped on the breakpoint.

lldb/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchpoint/TestMyFirstWatchpoint.py

def setUp(self):
         self.decl = line_number(self.source,
                                 '// Watchpoint variable declaration.')
         self.exe_name = self.getBuildArtifact('a.out')
         self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureNetBSD
     @add_test_categories(["basic_process"])
     def test_hello_watchpoint_using_watchpoint_set(self):
         """Test a simple sequence of watchpoint creation and watchpoint hit."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)

lldb/packages/Python/lldbsuite/test/functionalities/watchpoint/multiple_hits/TestMultipleHits.py

class MultipleHitsTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     @skipIf(bugnumber="llvm.org/pr30758", oslist=["linux"], archs=["arm", "aarch64", "powerpc64le"])
     @skipIfwatchOS
+    @expectedFailureNetBSD
     def test(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target and target.IsValid(), VALID_TARGET)
 
         bp = target.BreakpointCreateByName("main")
         self.assertTrue(bp and bp.IsValid(), "Breakpoint is valid")

lldb/packages/Python/lldbsuite/test/functionalities/watchpoint/multiple_threads/TestWatchpointMultipleThreads.py

class WatchpointForMultipleThreadsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
     main_spec = lldb.SBFileSpec("main.cpp", False)
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureNetBSD
     def test_watchpoint_before_thread_start(self):
         """Test that we can hit a watchpoint we set before starting another thread"""
         self.do_watchpoint_test("Before running the thread")
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureNetBSD
     def test_watchpoint_after_thread_start(self):
         """Test that we can hit a watchpoint we set after starting another thread"""
         self.do_watchpoint_test("After running the thread")
 
     def do_watchpoint_test(self, line):
         self.build()
         lldbutil.run_to_source_breakpoint(self, line, self.main_spec)
 

lldb/packages/Python/lldbsuite/test/functionalities/watchpoint/step_over_watchpoint/TestStepOverWatchpoint.py

@expectedFailureAll(
             'arm'],
         bugnumber="llvm.org/pr26031")
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
     @expectedFailureAll(oslist=["ios", "watchos", "tvos", "bridgeos"], bugnumber="<rdar://problem/34027183>")  # watchpoint tests aren't working on arm64
+    @expectedFailureNetBSD
     @add_test_categories(["basic_process"])
     def test(self):
         """Test stepping over watchpoints."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.target, VALID_TARGET)

lldb/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/TestWatchpointCommands.py

def setUp(self):
         self.exe_name = self.testMethodName
         self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
+    @expectedFailureNetBSD
     def test_rw_watchpoint(self):
         """Test read_write watchpoint and expect to stop two times."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
def test_rw_watchpoint_delete(self):
         self.expect("process status",
                     substrs=['exited'])
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
+    @expectedFailureNetBSD
     def test_rw_watchpoint_set_ignore_count(self):
         """Test watchpoint ignore count and expect to not to stop at all."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
def test_rw_watchpoint_set_ignore_count(self):
         self.expect("watchpoint list -v",
                     substrs=['hit_count = 2', 'ignore_count = 2'])
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
+    @expectedFailureNetBSD
     def test_rw_disable_after_first_stop(self):
         """Test read_write watchpoint but disable it after the first stop."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
def test_rw_disable_after_first_stop(self):
         self.expect("watchpoint list -v",
                     substrs=['hit_count = 1'])
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
+    @expectedFailureNetBSD
     def test_rw_disable_then_enable(self):
         """Test read_write watchpoint, disable initially, then enable it."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

lldb/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandLLDB.py

class WatchpointLLDBCommandTestCase(TestBase):
 
     @expectedFailureAll(
         oslist=["linux"],
         archs=["aarch64"],
         bugnumber="llvm.org/pr27710")
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureNetBSD
     def test_watchpoint_command(self):
         """Test 'watchpoint command'."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
class WatchpointLLDBCommandTestCase(TestBase):
 
     @expectedFailureAll(
         oslist=["linux"],
         archs=["aarch64"],
         bugnumber="llvm.org/pr27710")
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureNetBSD
     def test_watchpoint_command_can_disable_a_watchpoint(self):
         """Test that 'watchpoint command' action can disable a watchpoint after it is triggered."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

lldb/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandPython.py

class WatchpointPythonCommandTestCase(TestBase):
     @skipIfFreeBSD  # timing out on buildbot
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     @expectedFailureAll(
         oslist=["linux"],
         archs=["aarch64"],
         bugnumber="llvm.org/pr27710")
+    @expectedFailureNetBSD
     def test_watchpoint_command(self):
         """Test 'watchpoint command'."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
class WatchpointPythonCommandTestCase(TestBase):
     @skipIfFreeBSD  # timing out on buildbot
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     @expectedFailureAll(
         oslist=["linux"],
         archs=["aarch64"],
         bugnumber="llvm.org/pr27710")
+    @expectedFailureNetBSD
     def test_continue_in_watchpoint_command(self):
         """Test continue in a watchpoint command."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

lldb/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/condition/TestWatchpointConditionCmd.py

class WatchpointConditionCmdTestCase(TestBase):
 
     @expectedFailureAll(
         oslist=["linux"],
         archs=["aarch64"],
         bugnumber="llvm.org/pr27710")
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureNetBSD
     def test_watchpoint_cond(self):
         """Test watchpoint condition."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 
         exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

lldb/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_disable/TestWatchpointDisable.py

class TestWatchpointSetEnable(TestBase):
     def test_disable_works (self):
         """Set a watchpoint, disable it, and make sure it doesn't get hit."""
         self.build()
         self.do_test(False)
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureNetBSD
     def test_disable_enable_works (self):
         """Set a watchpoint, disable it, and make sure it doesn't get hit."""
         self.build()
         self.do_test(True)
 
     def do_test(self, test_enable):
         """Set a watchpoint, disable it and make sure it doesn't get hit."""
 

lldb/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_set_command/TestWatchLocationWithWatchSet.py

@expectedFailureAll(
         oslist=["linux"],
         archs=[
             'aarch64',
             'arm'],
         bugnumber="llvm.org/pr26031")
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureNetBSD
     def test_watchlocation_using_watchpoint_set(self):
         """Test watching a location with 'watchpoint set expression -w write -s size' option."""
         self.build()
         self.setTearDownCleanup()
 
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

lldb/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_size/TestWatchpointSizes.py

def setUp(self):
         self.exe_name = self.getBuildArtifact("a.out")
         self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
+    @expectedFailureNetBSD
     def test_byte_size_watchpoints_with_byte_selection(self):
         """Test to selectively watch different bytes in a 8-byte array."""
         self.run_watchpoint_size_test('byteArray', 8, '1')
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
+    @expectedFailureNetBSD
     def test_two_byte_watchpoints_with_word_selection(self):
         """Test to selectively watch different words in an 8-byte word array."""
         self.run_watchpoint_size_test('wordArray', 4, '2')
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
+    @expectedFailureNetBSD
     def test_four_byte_watchpoints_with_dword_selection(self):
         """Test to selectively watch two double words in an 8-byte dword array."""
         self.run_watchpoint_size_test('dwordArray', 2, '4')
 
     def run_watchpoint_size_test(self, arrayName, array_size, watchsize):
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
 

lldb/packages/Python/lldbsuite/test/lang/c/array_types/TestArrayTypes.py

def test_and_run_command(self):
             VARIABLES_DISPLAYED_CORRECTLY,
             startstr='(unsigned short [2][3])')
 
         self.expect(
             "frame variable --show-types long_6",
             VARIABLES_DISPLAYED_CORRECTLY,
             startstr='(long [6])')
 
+    @expectedFailureNetBSD
     @add_test_categories(['pyapi'])
     def test_and_python_api(self):
         """Use Python APIs to inspect variables with array types."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/packages/Python/lldbsuite/test/lang/c/conflicting-symbol/TestConflictingSymbol.py

class TestConflictingSymbols(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         TestBase.setUp(self)
         lldbutil.mkdir_p(self.getBuildArtifact("One"))
         lldbutil.mkdir_p(self.getBuildArtifact("Two"))
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
+    @expectedFailureNetBSD
     def test_conflicting_symbols(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Register our shared libraries for remote targets so they get
         # automatically uploaded

lldb/packages/Python/lldbsuite/test/lang/c/const_variables/TestConstVariables.py

@expectedFailureAll(
         oslist=["linux"],
         archs=[
             'arm',
             'aarch64'],
         bugnumber="llvm.org/pr27883")
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
+    @expectedFailureNetBSD
     def test_and_run_command(self):
         """Test interpreted and JITted expressions on constant values."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break inside the main.
         lldbutil.run_break_set_by_symbol(

lldb/packages/Python/lldbsuite/test/lang/c/function_types/TestFunctionTypes.py

def test(self):
         self.runCmd("continue")
 
         # Check that we do indeed stop on the string_not_empty function.
         self.expect("process status", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['a.out`string_not_empty',
                              'stop reason = breakpoint'])
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
+    @expectedFailureNetBSD
     def test_pointers(self):
         """Test that a function pointer to 'printf' works and can be called."""
         self.build()
         self.runToBreakpoint()
 
         self.expect("expr string_not_empty",
                     substrs=['(int (*)(const char *)) $0 = ', '(a.out`'])
 

lldb/packages/Python/lldbsuite/test/lang/c/global_variables/TestGlobalVariables.py

def test_without_process(self):
 
         self.assertTrue(target, VALID_TARGET)
         self.expect("target variable g_ptr", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['(int *)'])
         self.expect("target variable *g_ptr", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['42'])
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
+    @expectedFailureNetBSD
     def test_c_global_variables(self):
         """Test 'frame variable --scope --no-args' which omits args and shows scopes."""
         self.build()
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)
 

lldb/packages/Python/lldbsuite/test/lang/c/modules/TestCModules.py

class CModulesTestCase(TestBase):
     @skipIfFreeBSD
     @expectedFailureAll(
         oslist=["linux"],
         bugnumber="http://llvm.org/pr23456 'fopen' has unknown return type")
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     @skipIf(macos_version=["<", "10.12"])
+    @expectedFailureNetBSD
     def test_expr(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break inside the foo function which takes a bar_ptr argument.
         lldbutil.run_break_set_by_file_and_line(
             self, "main.c", self.line, num_expected_locations=1, loc_exact=True)

lldb/packages/Python/lldbsuite/test/lang/c/shared_lib/TestSharedLib.py

def common_test_expr(self, preload_symbols):
                 "(foo)",
                 "(sub_foo)",
                 "other_element = 3"])
 
         self.expect(
             "expression GetMeASubFoo(my_foo_ptr)",
             startstr="(sub_foo *) $")
 
+    @expectedFailureNetBSD
     def test_expr(self):
         """Test that types work when defined in a shared library and forward-declared in the main executable"""
         self.common_test_expr(True)
 
+    @expectedFailureNetBSD
     def test_expr_no_preload(self):
         """Test that types work when defined in a shared library and forward-declared in the main executable, but with preloading disabled"""
         self.common_test_expr(False)
 
     @unittest2.expectedFailure("llvm.org/PR36712")
     def test_frame_variable(self):
         """Test that types work when defined in a shared library and forward-declared in the main executable"""
         self.build()

lldb/packages/Python/lldbsuite/test/lang/c/stepping/TestStepAndBreakpoints.py

def setUp(self):
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "main.c"
 
     @add_test_categories(['pyapi', 'basic_process'])
     @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr17932')
     @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr14437")
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24777")
+    @expectedFailureNetBSD
     def test_and_python_api(self):
         """Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/packages/Python/lldbsuite/test/lang/cpp/auto/TestCPPAuto.py

 class CPPAutoTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAll(
         compiler="gcc",
         bugnumber="GCC generates incomplete debug info")
     @expectedFailureAll(oslist=['windows'], bugnumber="llvm.org/pr26339")
+    @expectedFailureNetBSD
     def test_with_run_command(self):
         """Test that auto types work in the expression parser"""
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         line = line_number('main.cpp', '// break here')
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", line, num_expected_locations=-1, loc_exact=False)

lldb/packages/Python/lldbsuite/test/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py

def setUp(self):
         TestBase.setUp(self)
         self.source = 'exceptions.cpp'
         self.catch_line = line_number(
             self.source, '// This is the line you should stop at for catch')
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24538, clang-cl does not support throw or catch")
+    @expectedFailureNetBSD
     def test(self):
         """Test lldb exception breakpoint command for CPP."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target from the debugger.
 
         target = self.dbg.CreateTarget(exe)

lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/TestNamespaceDefinitions.py

@expectedFailureAll(
         compiler="gcc",
         compiler_version=[
             "<",
             "4.9"])
     @expectedFailureAll(
         bugnumber="llvm.org/pr28948",
         oslist=['linux'], compiler="gcc", archs=['arm','aarch64'])
     @expectedFailureAll(oslist=["windows"])
+    @expectedFailureNetBSD
     def test_expr(self):
         self.build()
         self.common_setup()
 
         self.expect(
             "expression -- Foo::MyClass()",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=['thing = '])

lldb/packages/Python/lldbsuite/test/lang/cpp/this/TestCPPThis.py

@expectedFailureAll(
         compiler="gcc",
         bugnumber="llvm.org/pr15439 The 'this' pointer isn't available during expression evaluation when stopped in an inlined member function")
     @expectedFailureAll(
         compiler="icc",
         bugnumber="ICC doesn't emit correct DWARF inline debug info for inlined member functions.")
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
+    @expectedFailureNetBSD
     def test_with_run_command(self):
         """Test that the appropriate member variables are available when stopped in C++ static, inline, and const methods"""
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         self.set_breakpoint(line_number('main.cpp', '// breakpoint 1'))
         self.set_breakpoint(line_number('main.cpp', '// breakpoint 2'))
         self.set_breakpoint(line_number('main.cpp', '// breakpoint 3'))

lldb/packages/Python/lldbsuite/test/lang/objc/objc-foundation-dictionary-empty/TestNSDictionary0.py

 from lldbsuite.test import lldbinline
 from lldbsuite.test import decorators
 
 lldbinline.MakeInlineTest(
     __file__, globals(), [
-        decorators.skipIfFreeBSD, decorators.skipIfLinux, decorators.skipIfWindows])
+        decorators.skipIfFreeBSD, decorators.skipIfLinux,
+        decorators.skipIfWindows, decorators.skipIfNetBSD])

lldb/packages/Python/lldbsuite/test/lang/objc/objc-ivar-protocols/TestIvarProtocols.py

 from lldbsuite.test import lldbinline
 from lldbsuite.test import decorators
 
 lldbinline.MakeInlineTest(
     __file__, globals(), [
-        decorators.skipIfFreeBSD, decorators.skipIfLinux, decorators.skipIfWindows])
+        decorators.skipIfFreeBSD, decorators.skipIfLinux,
+        decorators.skipIfWindows, decorators.skipIfNetBSD])

lldb/packages/Python/lldbsuite/test/lang/objc/objc-runtime-ivars/TestRuntimeIvars.py

 from lldbsuite.test import lldbinline
 from lldbsuite.test import decorators
 
 lldbinline.MakeInlineTest(
     __file__, globals(), [
-        decorators.skipIfFreeBSD, decorators.skipIfLinux, decorators.skipIfWindows, decorators.skipIf(archs=["i386", "i686"])])
+        decorators.skipIfFreeBSD, decorators.skipIfLinux,
+        decorators.skipIfWindows, decorators.skipIfNetBSD,
+        decorators.skipIf(archs=["i386", "i686"])])

lldb/packages/Python/lldbsuite/test/lang/objc/variadic_methods/TestVariadicMethods.py

 from lldbsuite.test import lldbinline
 from lldbsuite.test import decorators
 
 lldbinline.MakeInlineTest(
     __file__, globals(), [
-        decorators.skipIfFreeBSD, decorators.skipIfLinux, decorators.skipIfWindows])
+        decorators.skipIfFreeBSD, decorators.skipIfLinux,
+        decorators.skipIfWindows, decorators.skipIfNetBSD])

lldb/packages/Python/lldbsuite/test/lang/objcxx/class-name-clash/TestNameClash.py

 from lldbsuite.test import decorators
 from lldbsuite.test import lldbinline
 
 lldbinline.MakeInlineTest(
     __file__, globals(), [
-        decorators.skipIfFreeBSD, decorators.skipIfLinux, decorators.skipIfWindows])
+        decorators.skipIfFreeBSD, decorators.skipIfLinux,
+        decorators.skipIfWindows, decorators.skipIfNetBSD])

lldb/packages/Python/lldbsuite/test/lang/objcxx/objcxx-ivar-vector/TestIvarVector.py

 from lldbsuite.test import decorators
 from lldbsuite.test import lldbinline
 
 lldbinline.MakeInlineTest(
     __file__, globals(), [
-        decorators.skipIfFreeBSD, decorators.skipIfLinux, decorators.skipIfWindows])
+        decorators.skipIfFreeBSD, decorators.skipIfLinux,
+        decorators.skipIfWindows, decorators.skipIfNetBSD])

lldb/packages/Python/lldbsuite/test/python_api/exprpath_synthetic/TestExprPathSynthetic.py

 from lldbsuite.test import decorators
 from lldbsuite.test import lldbinline
 
 lldbinline.MakeInlineTest(
     __file__, globals(), [
-        decorators.skipIfFreeBSD, decorators.skipIfLinux, decorators.skipIfWindows])
+        decorators.skipIfFreeBSD, decorators.skipIfLinux,
+        decorators.skipIfWindows, decorators.skipIfNetBSD])

lldb/packages/Python/lldbsuite/test/python_api/hello_world/TestHelloWorld.py

def test_with_process_launch_api(self):
             process, lldb.eStopReasonBreakpoint)
         self.assertIsNotNone(thread)
 
         # The breakpoint should have a hit count of 1.
         self.assertEqual(breakpoint.GetHitCount(), 1, BREAKPOINT_HIT_ONCE)
 
     @add_test_categories(['pyapi'])
     @skipIfiOSSimulator
+    @expectedFailureNetBSD
     def test_with_attach_to_process_with_id_api(self):
         """Create target, spawn a process, and attach to it with process id."""
         exe = '%s_%d'%(self.getBuildArtifact(self.testMethodName), os.getpid())
         d = {'EXE': exe}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         target = self.dbg.CreateTarget(exe)
 

lldb/packages/Python/lldbsuite/test/python_api/lldbutil/iter/TestLLDBIterator.py

def test_lldb_iter_breakpoint(self):
         self.assertTrue(len(yours) == len(mine))
         for i in range(len(yours)):
             if self.TraceOn():
                 print("yours[%d]='%s'" % (i, get_description(yours[i])))
                 print("mine[%d]='%s'" % (i, get_description(mine[i])))
             self.assertTrue(yours[i] == mine[i],
                             "ID of yours[{0}] and mine[{0}] matches".format(i))
 
+    @expectedFailureNetBSD
     @add_test_categories(['pyapi'])
     def test_lldb_iter_frame(self):
         """Test iterator works correctly for SBProcess->SBThread->SBFrame."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/packages/Python/lldbsuite/test/python_api/lldbutil/process/TestPrintStackTraces.py

class ThreadsStackTracesTestCase(TestBase):
     # is blocked in fgets
     @expectedFailureAll("llvm.org/pr23043", ["linux"], archs=["i386"])
     # The __thread_start function in libc doesn't contain any epilogue and prologue instructions
     # hence unwinding fail when we are stopped in __thread_start
     @expectedFailureAll(triple='mips*')
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     @expectedFlakeyAndroid("llvm.org/26492", archs=["arm"])
     @expectedFlakeyLinux("llvm.org/pr27687")
+    @expectedFailureNetBSD
     @add_test_categories(['pyapi'])
     def test_stack_traces(self):
         """Test SBprocess and SBThread APIs with printing of the stack traces."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/packages/Python/lldbsuite/test/python_api/sbtype_typeclass/TestSBTypeTypeClass.py

 from lldbsuite.test import decorators
 from lldbsuite.test import lldbinline
 
 lldbinline.MakeInlineTest(
     __file__, globals(), [
         decorators.skipIfFreeBSD, decorators.skipIfLinux,
-        decorators.skipIfWindows,
+        decorators.skipIfWindows, decorators.skipIfNetBSD,
         decorators.expectedFailureAll(
             oslist=['macosx'], archs=['i386'],
             bugnumber='rdar://28656677')])

lldb/packages/Python/lldbsuite/test/python_api/thread/TestThreadAPI.py

def test_run_to_address(self):
         d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.run_to_address(self.exe_name)
 
     @add_test_categories(['pyapi'])
     @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr20476')
     @expectedFailureAll(oslist=["windows"])
+    @expectedFailureNetBSD
     def test_step_out_of_malloc_into_function_b(self):
         """Test Python SBThread.StepOut() API to step out of a malloc call where the call site is at function b()."""
         # We build a different executable than the default build() does.
         d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.step_out_of_malloc_into_function_b(self.exe_name)
 

lldb/packages/Python/lldbsuite/test/python_api/watchpoint/TestSetWatchpoint.py

def setUp(self):
             self.source, '// Set break point at this line.')
 
     @add_test_categories(['pyapi'])
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
+    @expectedFailureNetBSD
     def test_watch_val(self):
         """Exercise SBValue.Watch() API to set a watchpoint."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/packages/Python/lldbsuite/test/python_api/watchpoint/TestWatchpointIgnoreCount.py

def setUp(self):
             self.source, '// Set break point at this line.')
 
     @add_test_categories(['pyapi'])
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
+    @expectedFailureNetBSD
     def test_set_watch_ignore_count(self):
         """Test SBWatchpoint.SetIgnoreCount() API."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/packages/Python/lldbsuite/test/python_api/watchpoint/TestWatchpointIter.py

def setUp(self):
         # Find the line number to break inside main().
         self.line = line_number(
             self.source, '// Set break point at this line.')
 
     @add_test_categories(['pyapi'])
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureNetBSD
     def test_watch_iter(self):
         """Exercise SBTarget.watchpoint_iter() API to iterate on the available watchpoints."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/packages/Python/lldbsuite/test/python_api/watchpoint/condition/TestWatchpointConditionAPI.py

def setUp(self):
         self.exe_name = self.testMethodName
         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAll(
         oslist=["linux"],
         archs=["aarch64"],
         bugnumber="llvm.org/pr27710")
     @skipIfWindows  # Watchpoints not supported on Windows, and this test hangs
+    @expectedFailureNetBSD
     def test_watchpoint_cond_api(self):
         """Test watchpoint condition API."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         exe = self.getBuildArtifact(self.exe_name)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)

lldb/packages/Python/lldbsuite/test/python_api/watchpoint/watchlocation/TestSetWatchlocation.py

def setUp(self):
             self.source, '// Set break point at this line.')
         # This is for verifying that watch location works.
         self.violating_func = "do_bad_thing_with_location"
 
     @add_test_categories(['pyapi'])
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureNetBSD
     def test_watch_location(self):
         """Exercise SBValue.WatchPointee() API to set a watchpoint."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/packages/Python/lldbsuite/test/python_api/watchpoint/watchlocation/TestTargetWatchAddress.py

def setUp(self):
             self.source, '// Set break point at this line.')
         # This is for verifying that watch location works.
         self.violating_func = "do_bad_thing_with_location"
 
     @add_test_categories(['pyapi'])
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
+    @expectedFailureNetBSD
     def test_watch_address(self):
         """Exercise SBTarget.WatchAddress() API to set a watchpoint."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/packages/Python/lldbsuite/test/tools/lldb-mi/breakpoint/TestMiBreak.py

 
 class MiBreakTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFlakeyLinux("llvm.org/pr24717")
+    @expectedFailureNetBSD
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     def test_lldbmi_break_insert_function_pending(self):
         """Test that 'lldb-mi --interpreter' works for pending function breakpoints."""
 
         self.spawnLldbMi(args=None)
 
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
def test_lldbmi_break_insert_function_pending(self):
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect(
             "=breakpoint-modified,bkpt={number=\"1\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"(?!0xffffffffffffffff)0x[0-9a-f]+\",func=\".+?\",file=\".+?\",fullname=\".+?\",line=\"(-1|\d+)\",pending=\[\"printf\"\],times=\"0\",original-location=\"printf\"}")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
+    @expectedFailureNetBSD
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     def test_lldbmi_break_insert_function(self):
         """Test that 'lldb-mi --interpreter' works for function breakpoints."""
 
         self.spawnLldbMi(args=None)
 
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")

lldb/packages/Python/lldbsuite/test/tools/lldb-mi/signal/TestMiSignal.py

 
 
 class MiSignalTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Fails on FreeBSD apparently due to thread race conditions
+    @expectedFailureNetBSD
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     def test_lldbmi_stopped_when_interrupt(self):
         """Test that 'lldb-mi --interpreter' interrupt and resume a looping app."""
 
         self.spawnLldbMi(args=None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
def test_lldbmi_stopped_when_interrupt(self):
         # Test that Ctrl+C can interrupt an execution
         self.child.sendintr()  # FIXME: here uses self.child directly
         self.expect(
             "\*stopped,reason=\"signal-received\",signal-name=\"SIGINT\",signal-meaning=\"Interrupt\",.*thread-id=\"1\",stopped-threads=\"all\"")
 
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Fails on FreeBSD apparently due to thread race conditions
     @skipIfLinux  # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
+    @expectedFailureNetBSD
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     def test_lldbmi_stopped_when_stopatentry_local(self):
         """Test that 'lldb-mi --interpreter' notifies after it was stopped on entry (local)."""
 
         self.spawnLldbMi(args=None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
def test_lldbmi_stopped_when_stopatentry_remote(self):
 
         # Exit
         self.runCmd("-gdb-exit")
         self.expect("\^exit")
 
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux  # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
+    @expectedFailureNetBSD
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     def test_lldbmi_stopped_when_segfault_local(self):
         """Test that 'lldb-mi --interpreter' notifies after it was stopped when segfault occurred (local)."""
 
         self.spawnLldbMi(args=None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)

lldb/packages/Python/lldbsuite/test/tools/lldb-mi/startup_options/TestMiStartupOptions.py

def copyScript(self, sourceFile):
             with open(destFile, 'w+') as dest:
                 dest.write(src.read().replace("a.out", self.myexe))
         return destFile
 
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux  # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
+    @expectedFailureNetBSD
     @skipIfDarwin
     def test_lldbmi_source_option_start_script(self):
         """Test that 'lldb-mi --interpreter' can execute user's commands after initial commands were executed."""
 
         # Prepared source file
         sourceFile = self.copyScript("start_script")
         self.spawnLldbMi(args="--source %s" % sourceFile)
 
def test_lldbmi_source_option_start_script(self):
         self.expect("\^done,value=\"10\"")
         self.expect(self.child_prompt, exactly=True)
         os.unlink(sourceFile)
 
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux  # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
+    @expectedFailureNetBSD
     @skipIfDarwin
     def test_lldbmi_source_option_start_script_exit(self):
         """Test that 'lldb-mi --interpreter' can execute a prepared file which passed via --source option."""
 
         # Prepared source file
         sourceFile = self.copyScript("start_script_exit")
         self.spawnLldbMi(args="--source %s" % sourceFile)
 

lldb/packages/Python/lldbsuite/test/tools/lldb-mi/target/TestMiTarget.py

class MiTargetTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux  # cannot attach to process on linux
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     @skipIfDarwin
+    @expectedFailureNetBSD
     def test_lldbmi_target_attach_wait_for(self):
         """Test that 'lldb-mi --interpreter' works for -target-attach -n <name> --waitfor."""
 
         # Build target executable with unique name
         exeName = self.testMethodName
         d = {'EXE': exeName}
         self.buildProgram("test_attach.cpp", exeName)
         self.addTearDownCleanup(dictionary=d)
def test_lldbmi_target_attach_wait_for(self):
         self.runCmd("-target-detach")
         self.expect("\^done")
 
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux  # cannot attach to process on linux
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     @skipIfDarwin
+    @expectedFailureNetBSD
     def test_lldbmi_target_attach_name(self):
         """Test that 'lldb-mi --interpreter' works for -target-attach -n <name>."""
 
         # Build target executable with unique name
         exeName = self.testMethodName
         d = {'EXE': exeName}
         self.buildProgram("test_attach.cpp", exeName)
         self.addTearDownCleanup(dictionary=d)
def test_lldbmi_target_attach_name(self):
         self.runCmd("-target-detach")
         self.expect("\^done")
 
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux  # cannot attach to process on linux
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     @skipIfDarwin
+    @expectedFailureNetBSD
     def test_lldbmi_target_attach_pid(self):
         """Test that 'lldb-mi --interpreter' works for -target-attach <pid>."""
 
         # Build target executable with unique name
         exeName = self.testMethodName
         d = {'EXE': exeName}
         self.buildProgram("test_attach.cpp", exeName)
         self.addTearDownCleanup(dictionary=d)

lldb/packages/Python/lldbsuite/test/tools/lldb-mi/threadinfo/TestMiThreadInfo.py

 
 
 class MiThreadInfoTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfWindows  # pthreads not supported on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
+    @expectedFailureNetBSD
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     def test_lldbmi_thread_info(self):
         """Test that -thread-info prints thread info and the current-thread-id"""
 
         self.spawnLldbMi(args=None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/attach/TestVSCode_attach.py

def set_and_hit_breakpoint(self, continueToExit=True):
         self.continue_to_breakpoints(breakpoint_ids)
         if continueToExit:
             self.continue_to_exit()
 
 
     @skipIfWindows
     @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
     @skipIfLinux # This test is timing out and/or failing on Linux as well as Darwin
+    @skipIfNetBSD # Hangs on NetBSD as well
     @no_debug_info_test
     def test_by_pid(self):
         '''
             Tests attaching to a process by process ID.
         '''
         self.build_and_create_debug_adaptor()
         program = self.getBuildArtifact("a.out")
         self.process = subprocess.Popen([program],
                                         stdin=subprocess.PIPE,
                                         stdout=subprocess.PIPE,
                                         stderr=subprocess.PIPE)
         self.attach(pid=self.process.pid)
         self.set_and_hit_breakpoint(continueToExit=True)
 
     @skipIfWindows
     @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
     @skipIfLinux # This test is timing out and/or failing on Linux as well as Darwin
+    @skipIfNetBSD # Hangs on NetBSD as well
     @no_debug_info_test
     def test_by_name(self):
         '''
             Tests attaching to a process by process name.
         '''
         self.build_and_create_debug_adaptor()
         orig_program = self.getBuildArtifact("a.out")
         # Since we are going to attach by process name, we need a unique
def test_by_name(self):
         # Wait for a bit to ensure the process is launched
         time.sleep(5)
         self.attach(program=program)
         self.set_and_hit_breakpoint(continueToExit=True)
 
     @skipUnlessDarwin
     @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
     @skipIfLinux # This test is timing out and/or failing on Linux as well as Darwin
+    @skipIfNetBSD # Hangs on NetBSD as well
     @no_debug_info_test
     def test_by_name_waitFor(self):
         '''
             Tests attaching to a process by process name and waiting for the
             next instance of a process to be launched, ingoring all current
             ones.
         '''
         self.build_and_create_debug_adaptor()
         program = self.getBuildArtifact("a.out")
         self.spawn_thread = threading.Thread(target=spawn_and_wait,
                                              args=(program, 1.0,))
         self.spawn_thread.start()
         self.attach(program=program, waitFor=True)
         self.set_and_hit_breakpoint(continueToExit=True)
 
     @skipIfWindows
     @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
     @skipIfLinux # This test is timing out and/or failing on Linux as well as Darwin
+    @skipIfNetBSD # Hangs on NetBSD as well
     @no_debug_info_test
     def test_commands(self):
         '''
             Tests the "initCommands", "preRunCommands", "stopCommands",
             "exitCommands", and "attachCommands" that can be passed during
             attach.
 
             "initCommands" are a list of LLDB commands that get executed

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/breakpoint/TestVSCode_setExceptionBreakpoints.py

 
 class TestVSCode_setExceptionBreakpoints(
         lldbvscode_testcase.VSCodeTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfWindows
     @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
+    @expectedFailureNetBSD
     @no_debug_info_test
     def test_functionality(self):
         '''Tests setting and clearing exception breakpoints.
            This packet is a bit tricky on the debug adaptor side since there
            is no "clear exception breakpoints" packet. Exception breakpoints
            are set by sending a "setExceptionBreakpoints" packet with zero or
            more exception filters. If exception breakpoints have been set
            before, any exising breakpoints must remain set, and any new

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/launch/TestVSCode_launch.py

def test_disableSTDIO(self):
         # Now get the STDOUT and verify our program argument is correct
         output = self.get_stdout()
         self.assertTrue(output is None or len(output) == 0,
                         "expect no program output")
 
     @skipIfWindows
     @skipIfDarwin # Skip this test for now until we can figure out why tings aren't working on build bots
     @skipIfLinux # This test is timing out and/or failing on Linux as well as Darwin
+    @expectedFailureNetBSD
     @no_debug_info_test
     def test_shellExpandArguments_enabled(self):
         '''
             Tests the default launch of a simple program with shell expansion
             enabled.
         '''
         program = self.getBuildArtifact("a.out")
         program_dir = os.path.split(program)[0]