Remove expectedFailureFreeBSD decorator

[emaste]

Summary

All invocations are updated to use the generic expectedFailureAll.

[zturner]

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

26–27

We have skipIfFreeBSD and then 2 instances of expectedFailureFreeBSD, the second of which is a duplicate of the skip. Maybe you could just delete the second line.

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

22

Missing closing ] after 'freebsd'

[emaste]

Address zturner feedback

[emaste]

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

26–28

Yes - I left two of them because they're different PRs, but didn't notice that the 2nd was a duplicate of the @skipIfFreeBSD. Thanks for catching it.

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

22

thanks, not sure how that slipped through.

packages/Python/lldbsuite/test/decorators.py

 
 def expectedFailureOS(oslist, bugnumber=None, compilers=None, debug_info=None, archs=None):
     return expectedFailureAll(oslist=oslist, bugnumber=bugnumber, compiler=compilers, archs=archs, debug_info=debug_info)
 
 def expectedFailureDarwin(bugnumber=None, compilers=None, debug_info=None):
     # For legacy reasons, we support both "darwin" and "macosx" as OS X triples.
     return expectedFailureOS(lldbplatform.darwin_all, bugnumber, compilers, debug_info=debug_info)
 
-def expectedFailureFreeBSD(bugnumber=None, compilers=None, debug_info=None):
-    return expectedFailureOS(lldbplatform.freebsd, bugnumber, compilers, debug_info=debug_info)
-
 def expectedFailureAndroid(bugnumber=None, api_levels=None, archs=None):
     """ Mark a test as xfail for Android.
 
     Arguments:
         bugnumber - The LLVM pr associated with the problem.
         api_levels - A sequence of numbers specifying the Android API levels
             for which a test is expected to fail. None means all API level.
         arch - A sequence of architecture names specifying the architectures

packages/Python/lldbsuite/test/expression_command/call-function/TestCallStdStringFunction.py

class ExprCommandCallFunctionTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.c.
         self.line = line_number('main.cpp',
                                 '// Please test these expressions while stopped at this line:')
 
     @expectedFailureAll(compiler="icc", bugnumber="llvm.org/pr14437, fails with ICC 13.1")
-    @expectedFailureFreeBSD('llvm.org/pr17807') # Fails on FreeBSD buildbot
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr17807 Fails on FreeBSD buildbot')
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_with(self):
         """Test calling std::String member function."""
         self.build()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         # Some versions of GCC encode two locations for the 'return' statement in main.cpp
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)

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
-    @expectedFailureFreeBSD('llvm.org/pr19011') # Newer Clang omits C1 complete object constructor
-    @expectedFailureFreeBSD('llvm.org/pr24691') # we hit an assertion in clang
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr19011 Newer Clang omits C1 complete object constructor')
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr24691 we hit an assertion in clang')
     @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."""
         self.build()
 
         # This is the function to remove the custom formats in order to have a
         # clean slate for the next test case.

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

 
 exe_name = "AttachResume"  # Must match Makefile
 
 class AttachResumeTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfRemote
-    @expectedFailureFreeBSD('llvm.org/pr19310')
+    @expectedFailureAll(oslist=['freebsd', bugnumber='llvm.org/pr19310')
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     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"""

packages/Python/lldbsuite/test/functionalities/avoids-fd-leak/TestFdLeak.py

return (sys.version_info >= (2, 7, 8) and sys.version_info < (2, 7, 10),
             "Python random module leaks file descriptors in this python version")
 
 
 class AvoidsFdLeakTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailure(python_leaky_fd_version, "bugs.freebsd.org/197376")
-    @expectedFailureFreeBSD("llvm.org/pr25624 still failing with Python 2.7.10")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr25624 still failing with Python 2.7.10")
     @skipIfWindows # The check for descriptor leakage needs to be implemented differently here.
     @skipIfTargetAndroid() # Android have some other file descriptors open by the shell
     def test_fd_leak_basic (self):
         self.do_test([])
 
     @expectedFailure(python_leaky_fd_version, "bugs.freebsd.org/197376")
-    @expectedFailureFreeBSD("llvm.org/pr25624 still failing with Python 2.7.10")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr25624 still failing with Python 2.7.10")
     @skipIfWindows # The check for descriptor leakage needs to be implemented differently here.
     @skipIfTargetAndroid() # Android have some other file descriptors open by the shell
     def test_fd_leak_log (self):
         self.do_test(["log enable -f '/dev/null' lldb commands"])
 
     def do_test (self, commands):
         self.build()
         exe = os.path.join (os.getcwd(), "a.out")
 
         for c in commands:
             self.runCmd(c)
 
         target = self.dbg.CreateTarget(exe)
 
         process = target.LaunchSimple (None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         self.assertTrue(process.GetState() == lldb.eStateExited, "Process should have exited.")
         self.assertTrue(process.GetExitStatus() == 0,
                 "Process returned non-zero status. Were incorrect file descriptors passed?")
 
     @expectedFailure(python_leaky_fd_version, "bugs.freebsd.org/197376")
-    @expectedFailureFreeBSD("llvm.org/pr25624 still failing with Python 2.7.10")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr25624 still failing with Python 2.7.10")
     @expectedFlakeyLinux
     @skipIfWindows # The check for descriptor leakage needs to be implemented differently here.
     @skipIfTargetAndroid() # Android have some other file descriptors open by the shell
     def test_fd_leak_multitarget (self):
         self.build()
         exe = os.path.join (os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-skip-summary/TestDataFormatterSkipSummary.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class SkipSummaryDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr20548 fails to build on lab.llvm.org buildbot")
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24462, Data formatters have problems on Windows")
     def test_with_run_command(self):
         """Test data formatter commands."""
         self.build()
         self.data_formatter_commands()
 
     def setUp(self):
         # Call super's setUp().

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/vbool/TestDataFormatterStdVBool.py

class StdVBoolDataFormatterTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
-    @expectedFailureFreeBSD("llvm.org/pr20548") # fails to build on lab.llvm.org buildbot
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr20548 fails to build on lab.llvm.org buildbot')
     @expectedFailureAll(compiler="icc", bugnumber="llvm.org/pr15301 LLDB prints incorrect sizes of STL containers")
     @skipIfWindows # libstdcpp not ported to Windows.
     @skipIfDarwin
     def test_with_run_command(self):
         """Test that that file and class static variables display correctly."""
         self.build()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 

packages/Python/lldbsuite/test/functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py

 
 class ExprDoesntDeadlockTestCase(TestBase):
 
     def getCategories(self):
         return ['basic_process']
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureFreeBSD('llvm.org/pr17946')
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr17946')
     @expectedFlakeyLinux # failed 1/365 test runs, line 61, thread.IsValid()
     @expectedFailureAll(oslist=["windows"], bugnumber="Windows doesn't have pthreads, test needs to be ported")
     def test_with_run_command(self):
         """Test that expr will time out and allow other threads to run if it blocks."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.

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

 from lldbsuite.test import lldbplatformutil
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
 class CrashingInferiorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureFreeBSD("llvm.org/pr23699 SIGSEGV is reported as exception, not signal")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr23699 SIGSEGV is reported as exception, not signal")
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     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, This actually works, but the test relies on the output format instead of the API")
     def test_inferior_crashing_register(self):
def test_inferior_crashing_expr(self):
         self.inferior_crashing_expr()
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     def test_inferior_crashing_step(self):
         """Test that stepping after a crash behaves correctly."""
         self.build()
         self.inferior_crashing_step()
 
-    @expectedFailureFreeBSD('llvm.org/pr24939')
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr24939')
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")
     @expectedFailureAndroid(archs=['aarch64'], api_levels=list(range(21 + 1))) # No eh_frame for sa_restorer
     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()
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778, This actually works, but the test relies on the output format instead of the API")

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

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbplatformutil
 from lldbsuite.test import lldbutil
 
 class CrashingRecursiveInferiorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureFreeBSD("llvm.org/pr23699 SIGSEGV is reported as exception, not signal")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr23699 SIGSEGV is reported as exception, not signal")
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     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):
def test_recursive_inferior_crashing_expr(self):
         self.recursive_inferior_crashing_expr()
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     def test_recursive_inferior_crashing_step(self):
         """Test that stepping after a crash behaves correctly."""
         self.build()
         self.recursive_inferior_crashing_step()
 
-    @expectedFailureFreeBSD('llvm.org/pr24939')
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr24939')
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     @expectedFailureAndroid(archs=['aarch64'], api_levels=list(range(21 + 1))) # No eh_frame for sa_restorer
     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()
 
     @skipIfLinux # Inferior exits after stepping after a segfault. This is working as intended IMHO.

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

class SendSignalTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.c', 'Put breakpoint here')
 
-    @expectedFailureFreeBSD("llvm.org/pr23318: does not report running state")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr23318: does not report running state")
     @skipIfWindows # Windows does not support signals
     def test_with_run_command(self):
         """Test that lldb command 'process signal SIGUSR1' sends a signal to the inferior process."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)

packages/Python/lldbsuite/test/functionalities/signal/handle-segv/TestHandleSegv.py

 
 
 class HandleSegvTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfWindows # signals do not exist on Windows
     @skipIfDarwin
-    @expectedFailureFreeBSD("llvm.org/pr23699 SIGSEGV is reported as exception, not signal")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr23699 SIGSEGV is reported as exception, not signal")
     def test_inferior_handle_sigsegv(self):
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

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

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class ThreadSpecificBreakPlusConditionTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfFreeBSD # test frequently times out or hangs
-    @expectedFailureFreeBSD('llvm.org/pr18522') # hits break in another thread in testrun
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr18522') # hits break in another thread in testrun
     @add_test_categories(['pyapi'])
     @expectedFlakeyLinux # this test fails 6/100 dosep runs
     def test_python(self):
         """Test that we obey thread conditioned breakpoints."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)

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

class TestCStepping(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "main.c"
 
     @add_test_categories(['pyapi'])
-    @expectedFailureFreeBSD('llvm.org/pr17932')
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr17932')
     @expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr14437")
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24777")
     def test_and_python_api(self):
         """Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)

packages/Python/lldbsuite/test/lang/cpp/class_static/TestStaticVariables.py

def test_with_run_command(self):
         # On Mac OS X, gcc 4.2 emits the wrong debug info for A::g_points.
         # A::g_points is an array of two elements.
         if self.platformIsDarwin() or self.getPlatform() == "linux":
             self.expect("target variable A::g_points[1].x", VARIABLES_DISPLAYED_CORRECTLY,
                 startstr = "(int) A::g_points[1].x = 11")
 
     @expectedFailureDarwin(9980907)
     @expectedFailureAll(compiler=["clang", "gcc"], bugnumber="Compiler emits incomplete debug info")
-    @expectedFailureFreeBSD('llvm.org/pr20550 failing on FreeBSD-11')
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr20550 failing on FreeBSD-11')
     @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test Python APIs on file and class static variables."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

packages/Python/lldbsuite/test/lang/cpp/nsimport/TestCppNsImport.py

 """
 Tests imported namespaces in C++.
 """
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestCppNsImport(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureFreeBSD("llvm.org/pr25925")
+    @expectedFailureAll(oslist=['freebsd'], bugnumber="llvm.org/pr25925")
     @expectedFailureAll(compiler="gcc", compiler_version=[">", "4.9"])
     def test_with_run_command(self):
         """Tests imported namespaces in C++."""
         self.build()
 
         # Get main source file
         src_file = "main.cpp"
         src_file_spec = lldb.SBFileSpec(src_file)

packages/Python/lldbsuite/test/lang/go/runtime/TestGoLanguageRuntime

 """Test the go dynamic type handling."""
 
 import os, time
 import unittest2
 import lldb
 import lldbutil
 from lldbtest import *
 
 class TestGoLanguageRuntime(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @python_api_test
-    @expectedFailureFreeBSD('llvm.org/pr24895')
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr24895')
     @skipIfRemote # Not remote test suite ready
     @skipUnlessGoInstalled
     def test_with_dsym_and_python_api(self):
         """Test GoASTContext dwarf parsing."""
         self.buildGo()
         self.launchProcess()
         self.go_interface_types()
 

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

def test_run_to_address(self):
         """Test Python SBThread.RunToAddress() API."""
         # 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.run_to_address(self.exe_name)
 
     @add_test_categories(['pyapi'])
-    @expectedFailureFreeBSD # llvm.org/pr20476
+    @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr20476')
     @expectedFailureAll(oslist=["windows"])
     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)

packages/Python/lldbsuite/test/tools/lldb-server/commandline/TestStubSetSID.py

class TestStubSetSIDTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
     @skipIfRemote # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
     def test_sid_is_same_without_setsid_debugserver(self):
         self.init_debugserver_test()
         self.set_inferior_startup_launch()
         self.sid_is_same_without_setsid()
 
     @llgs_test
     @skipIfRemote # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
-    @expectedFailureFreeBSD()
+    @expectedFailureAll(oslist=['freebsd'])
     def test_sid_is_same_without_setsid_llgs(self):
         self.init_llgs_test()
         self.set_inferior_startup_launch()
         self.sid_is_same_without_setsid()
 
     @debugserver_test
     @skipIfRemote # --setsid not used on remote platform and currently it is also impossible to get the sid of lldb-platform running on a remote target
     def test_sid_is_different_with_setsid_debugserver(self):