Adds expectedFailureArmLinux test decorator

[omjavaid]

Summary

This patch adds a new expectedFailureArmLinux which marks arm-linux tests as xfails.

Also marked a couple of failing tests to use expectedFailureArmLinux decorator.

[clayborg]

Seems like it would be better to mimic how @expectedFailureAndroid works. See inlined comments.

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

20 ↗

(On Diff #44016)

Seems like it would be better to do things like @expectedFailureAndroid that is just above:

@expectedFailureLinux(archs=['arm'], bug="llvm.org/pr26031")

I would like to avoid having new variants of the @expectedFailure that contain the architecture in the name.

[labath]

Yes, please don't insert new decorators, we have enough as it is. You can achieve the behavior you want with the correct arguments to expectedFailureAll decorator.

[omjavaid]

Removed expectedFailureArmLinux and updated expectedFailureLinux decorator to reflect architecture if needed.

Marked some triaged failures as xfails on arm with updated expectedFailureLinux decorator.

LGTM?

[clayborg]

Looks good.

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

 from lldbsuite.test.lldbtest import *
 
 class AssertingInferiorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailurei386("llvm.org/pr25338")
+    @expectedFailureLinux("llvm.org/pr25338", archs=['arm', 'i386'])
     def test_inferior_asserting(self):
         """Test that lldb reliably catches the inferior asserting (command)."""
         self.build()
         self.inferior_asserting()
 
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailureAndroid(api_levels=list(range(16 + 1))) # b.android.com/179836
     def test_inferior_asserting_register(self):
         """Test that lldb reliably reads registers from the inferior after asserting (command)."""
         self.build()
         self.inferior_asserting_registers()
 
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailurei386("llvm.org/pr25338")
+    @expectedFailureLinux("llvm.org/pr25338", archs=['arm', 'i386'])
     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'])
     @expectedFailureWindows("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()
 
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailurei386("llvm.org/pr25338")
+    @expectedFailureLinux("llvm.org/pr25338", archs=['arm', 'i386'])
     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()
 
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailurei386("llvm.org/pr25338")
+    @expectedFailureLinux("llvm.org/pr25338", archs=['arm', 'i386'])
     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/trunk/packages/Python/lldbsuite/test/functionalities/watchpoint/step_over_watchpoint/TestStepOverWatchpoint.py

 class TestStepOverWatchpoint(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def getCategories(self):
         return ['basic_process']
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
+    @expectedFailureLinux(bugnumber="llvm.org/pr26031", archs=['arm'])
     @expectedFailureWindows("llvm.org/pr24446")
     def test(self):
         """Test stepping over watchpoints."""
         self.build()
         exe = os.path.join(os.getcwd(), 'a.out')
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.target, VALID_TARGET)

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

def setUp(self):
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(self.source, '// Set break point at this line.')
         # This is for verifying that watch location works.
         self.violating_func = "do_bad_thing_with_location";
         # Build dictionary to have unique executable names for each test method.
 
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
+    @expectedFailureLinux(bugnumber="llvm.org/pr26031", archs=['arm'])
     @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
     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 = os.path.join(os.getcwd(), 'a.out')
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)

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

def expectedFailureArch(arch, bugnumber=None):
     return expectedFailure(fn, bugnumber)
 
 def expectedFailurei386(bugnumber=None):
     return expectedFailureArch('i386', bugnumber)
 
 def expectedFailurex86_64(bugnumber=None):
     return expectedFailureArch('x86_64', bugnumber)
 
-def expectedFailureOS(oslist, bugnumber=None, compilers=None, debug_info=None):
+def expectedFailureOS(oslist, bugnumber=None, compilers=None, debug_info=None, archs=None):
     def fn(self):
         return (self.getPlatform() in oslist and
                 self.expectedCompiler(compilers) and
+                (archs is None or self.getArchitecture() in archs) and
                 (debug_info is None or self.debug_info in debug_info))
     return expectedFailure(fn, bugnumber)
 
 def expectedFailureHostOS(oslist, bugnumber=None, compilers=None):
     def fn(self):
         return (getHostPlatform() in oslist and
                 self.expectedCompiler(compilers))
     return expectedFailure(fn, bugnumber)
 
 def expectedFailureDarwin(bugnumber=None, compilers=None, debug_info=None):
     # For legacy reasons, we support both "darwin" and "macosx" as OS X triples.
     return expectedFailureOS(getDarwinOSTriples(), bugnumber, compilers, debug_info=debug_info)
 
 def expectedFailureFreeBSD(bugnumber=None, compilers=None, debug_info=None):
     return expectedFailureOS(['freebsd'], bugnumber, compilers, debug_info=debug_info)
 
-def expectedFailureLinux(bugnumber=None, compilers=None, debug_info=None):
-    return expectedFailureOS(['linux'], bugnumber, compilers, debug_info=debug_info)
+def expectedFailureLinux(bugnumber=None, compilers=None, debug_info=None, archs=None):
+    return expectedFailureOS(['linux'], bugnumber, compilers, debug_info=debug_info, archs=archs)
 
 def expectedFailureNetBSD(bugnumber=None, compilers=None, debug_info=None):
     return expectedFailureOS(['netbsd'], bugnumber, compilers, debug_info=debug_info)
 
 def expectedFailureWindows(bugnumber=None, compilers=None, debug_info=None):
     return expectedFailureOS(['windows'], bugnumber, compilers, debug_info=debug_info)
 
 def expectedFailureHostWindows(bugnumber=None, compilers=None):