[lldb] [test] Link FreeBSD test failures to bugs

lldb/test/API/api/multithreaded/TestMultithreaded.py

def setUp(self):
         self.generateSource('test_stop-hook.cpp')
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfRemote
     @skipIfNoSBHeaders
     # clang-cl does not support throw or catch (llvm.org/pr24538)
     @skipIfWindows
-    @expectedFailureAll(oslist=['freebsd'])
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr48370')
     def test_python_stop_hook(self):
         """Test that you can run a python command in a stop-hook when stdin is File based. """
         self.build_and_test('driver.cpp test_stop-hook.cpp',
                             'test_python_stop_hook')
 
     @skipIfRemote
     @skipIfNoSBHeaders
     # clang-cl does not support throw or catch (llvm.org/pr24538)

lldb/test/API/commands/expression/multiline-navigation/TestMultilineNavigation.py

class TestCase(PExpectTest):
 
     arrow_up = "\033[A"
     arrow_down = "\033[B"
 
     # PExpect uses many timeouts internally and doesn't play well
     # under ASAN on a loaded machine..
     @skipIfAsan
     @skipIfEditlineSupportMissing
-    @expectedFailureAll(oslist=['freebsd'])
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr48316')
     def test_nav_arrow_up(self):
         """Tests that we can navigate back to the previous line with the up arrow"""
         self.launch()
 
         # Start multiline expression mode by just running 'expr'
         self.child.sendline("expr")
         self.child.expect_exact("terminate with an empty line to evaluate")
         # Create a simple integer expression '123' and press enter.
         self.child.send("123\n")
         # We should see the prompt for the second line of our expression.
         self.child.expect_exact("2: ")
         # Go back to the first line and change 123 to 124.
         # Then press enter twice to evaluate our expression.
         self.child.send(self.arrow_up + "\b4\n\n")
         # The result of our expression should be 124 (our edited expression)
         # and not 123 (the one we initially typed).
         self.child.expect_exact("(int) $0 = 124")
 
         self.quit()
 
     @skipIfAsan
     @skipIfEditlineSupportMissing
-    @expectedFailureAll(oslist=['freebsd'])
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr48316')
     def test_nav_arrow_down(self):
         """Tests that we can navigate to the next line with the down arrow"""
         self.launch()
 
         # Start multiline expression mode by just running 'expr'
         self.child.sendline("expr")
         self.child.expect_exact("terminate with an empty line to evaluate")
         # Create a simple integer expression '111' and press enter.

lldb/test/API/commands/process/launch-with-shellexpand/TestLaunchWithShellExpand.py

class LaunchWithShellExpandTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     @expectedFailureAll(
         oslist=[
             "windows",
             "linux",
             "freebsd"],
-        bugnumber="llvm.org/pr24778 llvm.org/pr22627")
+        bugnumber="llvm.org/pr24778 llvm.org/pr22627 llvm.org/pr48349")
     @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)
 

lldb/test/API/commands/register/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']))
-    @expectedFailureAll(oslist=["freebsd", "netbsd"])
+    @expectedFailureAll(oslist=["freebsd", "netbsd"],
+                        bugnumber='llvm.org/pr48371')
     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")
 

lldb/test/API/commands/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=["freebsd", "linux"],
+    @expectedFailureAll(oslist=["freebsd", "linux", "netbsd"],
+                        bugnumber='llvm.org/pr48372',
                         triple=no_match(".*-android"))
-        #linux does not support loading dependent files, but android does
-    @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=["freebsd", "linux"],
+    @expectedFailureAll(oslist=["freebsd", "linux", "netbsd"],
+                        bugnumber='llvm.org/pr48372',
                         triple=no_match(".*-android"))
-        #linux does not support loading dependent files, but android does
-    @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=["freebsd", "linux"],
+    @expectedFailureAll(oslist=["freebsd", "linux", "netbsd"],
+                        bugnumber='llvm.org/pr48372',
                         triple=no_match(".*-android"))
-        #linux does not support loading dependent files, but android does
-    @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=["freebsd", "linux"],
+    @expectedFailureAll(oslist=["freebsd", "linux", "netbsd"],
+                        bugnumber='llvm.org/pr48372',
                         triple=no_match(".*-android"))
-        #linux does not support loading dependent files, but android does
-    @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/test/API/functionalities/breakpoint/breakpoint_callback_command_source/TestBreakpointCallbackCommandSource.py

class BreakpointCallbackCommandSource(PExpectTest):
 
     mydir = TestBase.compute_mydir(__file__)
     file_to_source = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'source.lldb')
 
     # PExpect uses many timeouts internally and doesn't play well
     # under ASAN on a loaded machine..
     @skipIfAsan
     @skipIfEditlineSupportMissing
-    # times out
-    @skipIfFreeBSD
+    @skipIf(oslist=["freebsd"], bugnumber="llvm.org/pr48316")
     def test_breakpoint_callback_command_source(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         self.launch(exe)
         self.expect("b main", substrs=["Breakpoint 1"])
         self.child.send("breakpoint command add -s python\n")
         self.child.send(
             "frame.GetThread().GetProcess().GetTarget().GetDebugger().HandleCommand('command source -s true {}')\n"
             .format(self.file_to_source))
         self.child.send("DONE\n")
         self.expect_prompt()
         self.expect("run", substrs=["Process", "stopped"])
         self.expect("script print(foo)", substrs=["95126"])

lldb/test/API/functionalities/breakpoint/global_constructor/TestBreakpointInGlobalConstructor.py

 from lldbsuite.test import lldbutil
 
 
 class TestBreakpointInGlobalConstructors(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
-    @expectedFailureAll(oslist=["freebsd"])
+    @expectedFailureAll(oslist=["freebsd"], bugnumber='llvm.org/pr48373')
     @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/test/API/functionalities/deleted-executable/TestDeletedExecutable.py

 from lldbsuite.test import lldbutil
 
 class TestDeletedExecutable(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfWindows # cannot delete a running executable
-    @expectedFailureAll(oslist=["freebsd", "linux"],
+    @expectedFailureAll(oslist=["linux"],
         triple=no_match('aarch64-.*-android'))
         # determining the architecture of the process fails
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48374")
     @skipIfReproducer # File synchronization is not supported during replay.
     def test(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,
             "token_pid_%d" % (int(os.getpid())))

lldb/test/API/functionalities/dlopen_other_executable/TestDlopenOtherExecutable.py

 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfRemote
     @skipIfWindows
     # glibc's dlopen doesn't support opening executables.
     # https://sourceware.org/bugzilla/show_bug.cgi?id=11754
     @skipIfLinux
+    # freebsd's dlopen ditto
     @expectedFailureAll(oslist=["freebsd"])
     @no_debug_info_test
     def test(self):
         self.build()
         # Launch and stop before the dlopen call.
         lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("main.c"))
 
         # Delete the breakpoint we no longer need.

lldb/test/API/functionalities/plugins/python_os_plugin/stepping_plugin_threads/TestOSPluginStepping.py

 
 
 class TestOSPluginStepping(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfWindows
-    @skipIfFreeBSD  # hangs
+    @skipIf(oslist=["freebsd"], bugnumber="llvm.org/pr48352")
     def test_python_os_plugin(self):
         """Test that stepping works when the OS Plugin doesn't report all
            threads at every stop"""
         self.build()
         self.main_file = lldb.SBFileSpec('main.cpp')
         self.run_python_os_step_missing_thread(False)
 
     @skipIfWindows
-    @skipIfFreeBSD  # hangs
+    @skipIf(oslist=["freebsd"], bugnumber="llvm.org/pr48352")
     def test_python_os_plugin_prune(self):
         """Test that pruning the unreported PlanStacks works"""
         self.build()
         self.main_file = lldb.SBFileSpec('main.cpp')
         self.run_python_os_step_missing_thread(True)
 
     def get_os_thread(self):
         return self.process.GetThreadByID(0x111111111)

lldb/test/API/functionalities/return-value/TestReturnValue.py

class ReturnValueTestCase(TestBase):
 
     def affected_by_pr44132(self):
         return ((self.getArchitecture() == "aarch64" or self.getArchitecture() == 'arm') and self.getPlatform() == "linux")
 
     # ABIMacOSX_arm can't fetch simple values inside a structure
     def affected_by_radar_34562999(self):
         return (self.getArchitecture() == 'armv7' or self.getArchitecture() == 'armv7k') and self.platformIsDarwin()
 
-    @expectedFailureAll(oslist=["freebsd"], archs=["i386"])
+    @expectedFailureAll(oslist=["freebsd"], archs=["i386"],
+                        bugnumber="llvm.org/pr48376")
     @expectedFailureAll(oslist=["macosx"], archs=["i386"], bugnumber="<rdar://problem/28719652>")
     @expectedFailureAll(
         oslist=["linux"],
         compiler="clang",
         compiler_version=[
             "<=",
             "3.6"],
         archs=["i386"])
def test_with_python(self):
                 "return_one_short_one_double_one_short")
             self.return_and_test_struct_value("return_one_float_one_int_one_float")
             self.return_and_test_struct_value("return_two_float")
             # I am leaving out the packed test until we have a way to tell CLANG
             # about alignment when reading DWARF for packed types.
             #self.return_and_test_struct_value ("return_one_int_one_double_packed")
             self.return_and_test_struct_value("return_one_int_one_long")
 
-    @expectedFailureAll(oslist=["freebsd"], archs=["i386"])
+    @expectedFailureAll(oslist=["freebsd"], archs=["i386"],
+                        bugnumber="llvm.org/pr48376")
     @expectedFailureAll(oslist=["macosx"], archs=["i386"], bugnumber="<rdar://problem/28719652>")
     @expectedFailureAll(
         oslist=["linux"],
         compiler="clang",
         compiler_version=[
             "<=",
             "3.6"],
         archs=["i386"])

lldb/test/API/functionalities/thread/create_after_attach/TestCreateAfterAttach.py

def 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')
 
     # Occasionally hangs on Windows, may be same as other issues.
     @skipIfWindows
     @skipIfiOSSimulator
-    # FreeBSD: Hangs.  May be the same as Linux issue llvm.org/pr16229
-    # but not yet investigated.  Revisit once required functionality is
-    # implemented for FreeBSD.
-    @expectedFailureAll(oslist=["freebsd", "netbsd"])
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48376")
+    @expectedFailureNetBSD
     def test_create_after_attach(self):
         """Test thread creation after process attach."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         exe = self.getBuildArtifact("a.out")
 
         # Spawn a new process
         popen = self.spawnSubprocess(exe)
         pid = popen.pid

lldb/test/API/functionalities/thread/exit_during_expression/TestExitDuringExpression.py

 
 class TestExitDuringExpression(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfWindows
-    @expectedFailureAll(oslist=["freebsd"])
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48414")
     def test_exit_before_one_thread_unwind(self):
         """Test the case where we exit within the one thread timeout"""
         self.exiting_expression_test(True, True)
 
     @skipIfWindows
-    @expectedFailureAll(oslist=["freebsd"])
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48414")
     def test_exit_before_one_thread_no_unwind(self):
         """Test the case where we exit within the one thread timeout"""
         self.exiting_expression_test(True, False)
 
     @skipIfWindows
     def test_exit_after_one_thread_unwind(self):
         """Test the case where we exit within the one thread timeout"""
         self.exiting_expression_test(False, True)

lldb/test/API/functionalities/thread/state_after_expression/TestStateAfterExpression.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 
 class TestStopReasonAfterExpression(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfWindows
-    @expectedFailureAll(oslist=["freebsd"])
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48415")
     def test_thread_state_after_expr(self):
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.cpp")
         self.do_test()
 
     def do_test(self):
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
             "Set a breakpoint here", self.main_source_file)

lldb/test/API/lang/c/conflicting-symbol/TestConflictingSymbol.py

class TestConflictingSymbols(TestBase):
     mydir = TestBase.compute_mydir(__file__)
     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=["freebsd", "windows"], bugnumber="llvm.org/pr24489")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48416")
     @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

lldb/test/API/python_api/event/TestEvents.py

def test_wait_for_event(self):
         self.assertTrue(event,
                         "My listening thread successfully received an event")
 
     @add_test_categories(['pyapi'])
     @expectedFailureAll(
         oslist=["linux"],
         bugnumber="llvm.org/pr23617 Flaky, fails ~1/10 cases")
     @skipIfWindows # This is flakey on Windows AND when it fails, it hangs: llvm.org/pr38373
-    @expectedFailureAll(oslist=["freebsd"])
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48417")
     @expectedFlakeyNetBSD
     def test_add_listener_to_broadcaster(self):
         """Exercise some SBBroadcaster APIs."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         self.dbg.SetAsync(True)
 

lldb/test/API/tools/lldb-server/TestGdbRemote_qThreadStopInfo.py

class TestGdbRemote_qThreadStopInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
     def test_qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt_debugserver(
             self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt(
             self.THREAD_COUNT)
 
-    @expectedFailureAll(oslist=["freebsd", "netbsd"])
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48418")
+    @expectedFailureNetBSD
     @llgs_test
     def test_qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt_llgs(
             self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt(
             self.THREAD_COUNT)

lldb/test/API/tools/lldb-server/TestLldbGdbServer.py

def test_Hc_then_Csignal_signals_correct_thread_launch_debugserver(self):
         self.init_debugserver_test()
         self.build()
         self.set_inferior_startup_launch()
         # Darwin debugserver translates some signals like SIGSEGV into some gdb
         # expectations about fixed signal numbers.
         self.Hc_then_Csignal_signals_correct_thread(self.TARGET_EXC_BAD_ACCESS)
 
     @skipIfWindows # no SIGSEGV support
-    @expectedFailureAll(oslist=["freebsd", "netbsd"])
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48419")
+    @expectedFailureNetBSD
     @llgs_test
     def test_Hc_then_Csignal_signals_correct_thread_launch_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.Hc_then_Csignal_signals_correct_thread(
             lldbutil.get_signal_number('SIGSEGV'))
 

lldb/test/API/tools/lldb-server/register-reading/TestGdbRemoteGPacket.py

def g_returns_correct_data(self, with_suffix):
             ['0x424446484a4c4e41', '0x434547494b4d4f40'], get_reg_value('xmm12'))
         self.assertEqual(
             ['0x525456585a5c5e51', '0x535557595b5d5f50'], get_reg_value('xmm13'))
         self.assertEqual(
             ['0x626466686a6c6e61', '0x636567696b6d6f60'], get_reg_value('xmm14'))
         self.assertEqual(
             ['0x727476787a7c7e71', '0x737577797b7d7f70'], get_reg_value('xmm15'))
 
-    @expectedFailureAll(oslist=["freebsd", "netbsd"])
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48420")
+    @expectedFailureNetBSD
     @llgs_test
     def test_g_returns_correct_data_with_suffix_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.g_returns_correct_data(True)
 
-    @expectedFailureAll(oslist=["freebsd", "netbsd"])
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48420")
+    @expectedFailureNetBSD
     @llgs_test
     def test_g_returns_correct_data_no_suffix_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.g_returns_correct_data(False)

lldb/test/API/tools/lldb-vscode/breakpoint/TestVSCode_setBreakpoints.py

class TestVSCode_setBreakpoints(lldbvscode_testcase.VSCodeTestCaseBase):
     def setUp(self):
         lldbvscode_testcase.VSCodeTestCaseBase.setUp(self)
 
         self.main_basename = 'main-copy.cpp'
         self.main_path = self.getBuildArtifact(self.main_basename)
 
     @skipIfWindows
     @skipIfRemote
-    @expectedFailureAll(oslist=["freebsd"])
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48421")
     def test_source_map(self):
         self.build_and_create_debug_adaptor()
 
         other_basename = 'other-copy.c'
         other_path = self.getBuildArtifact(other_basename)
 
         source_folder = os.path.dirname(self.main_path)
 
def test_source_map(self):
         breakpoint = breakpoints[0]
         self.assertEqual(breakpoint['line'], other_line)
         self.assertTrue(breakpoint['verified'])
         self.assertEqual(other_basename, breakpoint['source']['name'])
         self.assertEqual(new_other_path, breakpoint['source']['path'])
 
     @skipIfWindows
     @skipIfRemote
-    @expectedFailureAll(oslist=["freebsd"])
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48421")
     def test_set_and_clear(self):
         '''Tests setting and clearing source file and line breakpoints.
            This packet is a bit tricky on the debug adaptor side since there
            is no "clearBreakpoints" packet. Source file and line breakpoints
            are set by sending a "setBreakpoints" packet with a source file
            specified and zero or more source lines. If breakpoints have been
            set in the source file before, any existing breakpoints must remain
            set, and any new breakpoints must be created, and any breakpoints
def test_set_and_clear(self):
             for breakpoint in breakpoints:
                 line = breakpoint['line']
                 self.assertTrue(line in lines, "line expected in lines array")
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint still verified")
 
     @skipIfWindows
     @skipIfRemote
-    @expectedFailureAll(oslist=["freebsd"])
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48421")
     def test_clear_breakpoints_unset_breakpoints(self):
         '''Test clearing breakpoints like test_set_and_clear, but clear
            breakpoints by omitting the breakpoints array instead of sending an
            empty one.'''
         lines = [line_number('main.cpp', 'break 12'),
                  line_number('main.cpp', 'break 13')]
 
         # Visual Studio Code Debug Adaptors have no way to specify the file
def test_clear_breakpoints_unset_breakpoints(self):
 
         # Verify with the target that all breakpoints have been cleared.
         response = self.vscode.request_testGetTargetBreakpoints()
         breakpoints = response['body']['breakpoints']
         self.assertEquals(len(breakpoints), 0, "expect no source breakpoints")
 
     @skipIfWindows
     @skipIfRemote
-    @expectedFailureAll(oslist=["freebsd"])
+    @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48421")
     def test_functionality(self):
         '''Tests hitting breakpoints and the functionality of a single
            breakpoint, like 'conditions' and 'hitCondition' settings.'''
         loop_line = line_number('main.cpp', '// break loop')
 
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
         # Set a breakpoint at the loop line with no condition and no

lldb/test/API/tools/lldb-vscode/launch/TestVSCode_launch.py

def test_disableSTDIO(self):
         self.continue_to_exit()
         # Now get the STDOUT and verify our program argument is correct
         output = self.get_stdout()
         self.assertEquals(output, None,
                         "expect no program output")
 
     @skipIfWindows
     @skipIfLinux # shell argument expansion doesn't seem to work on Linux
-    @expectedFailureNetBSD
-    @expectedFailureAll(oslist=["freebsd"])
+    @expectedFailureAll(oslist=["freebsd", "netbsd"],
+                        bugnumber="llvm.org/pr48349")
     @skipIfRemote
     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.dirname(program)