[lldb][test_suite] Update tests with unexpected pass on Android aarch64

[kusmour]

Summary

update some test decorates that can actually pass on andriod aarch64

[labath]

Whether a lot of these tests (e.g. all watchpoint related tests) pass or fail may depend on the exact android device you are running the tests against. However, you are the only ones running android tests ATM, so that does not matter much right now. If that ever changes, we'll have to do something smarter here...

[kusmour]

In D64767#1587311, @labath wrote:

Whether a lot of these tests (e.g. all watchpoint related tests) pass or fail may depend on the exact android device you are running the tests against. However, you are the only ones running android tests ATM, so that does not matter much right now. If that ever changes, we'll have to do something smarter here...

Thank you very much! I will test on more devices later.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/breakpoint/hardware_breakpoints/hardware_breakpoint_on_multiple_threads/TestHWBreakMultiThread.py

 @skipUnlessPlatform(oslist=['linux'])
 class HardwareBreakpointMultiThreadTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     mydir = TestBase.compute_mydir(__file__)
 
     # LLDB supports hardware breakpoints for arm and aarch64 architectures.
     @skipIf(archs=no_match(['arm', 'aarch64']))
-    @expectedFailureAndroid
     def test_hw_break_set_delete_multi_thread(self):
         self.build()
         self.setTearDownCleanup()
         self.break_multi_thread('delete')
 
     # LLDB supports hardware breakpoints for arm and aarch64 architectures.
     @skipIf(archs=no_match(['arm', 'aarch64']))
-    @expectedFailureAndroid
     def test_hw_break_set_disable_multi_thread(self):
         self.build()
         self.setTearDownCleanup()
         self.break_multi_thread('disable')
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

lldb/trunk/packages/Python/lldbsuite/test/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=["linux"]) # determining the architecture of the process fails
+    @expectedFailureAll(oslist=["linux"],
+        triple=no_match('aarch64-.*-android'))
+        # determining the architecture of the process fails
     @expectedFailureNetBSD
     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/trunk/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=[
             "aarch64",
             "arm"],
+        triple=no_match(".*-android"),
         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()
 
class AssertingInferiorTestCase(TestBase):
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     @expectedFailureAll(
         oslist=["linux"],
         archs=[
             "aarch64",
             "arm"],
+        triple=no_match(".*-android"),
         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"],
+        triple=no_match(".*-android"),
         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()
 

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

def test_step_over_load(self):
 
         # The stop reason should be step end.
         self.expect("thread list", "step over succeeded.",
                     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"])
+    @expectedFailureAll(oslist=["linux"], triple=no_match('aarch64-.*-android'))
     @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")

lldb/trunk/packages/Python/lldbsuite/test/functionalities/target_command/TestTargetCommand.py

def test_target_command(self):
         self.addTearDownCleanup(dictionary=db)
 
         dc = {'C_SOURCES': 'c.c', 'EXE': self.getBuildArtifact('c.out')}
         self.build(dictionary=dc)
         self.addTearDownCleanup(dictionary=dc)
 
         self.do_target_command()
 
-    # rdar://problem/9763907
-    # 'target variable' command fails if the target program has been run
-    @expectedFailureAndroid(archs=['aarch64'])
     def test_target_variable_command(self):
         """Test 'target variable' command before and after starting the inferior."""
         d = {'C_SOURCES': 'globals.c', 'EXE': self.getBuildArtifact('globals')}
         self.build(dictionary=d)
         self.addTearDownCleanup(dictionary=d)
 
         self.do_target_variable_command('globals')
 
-    @expectedFailureAndroid(archs=['aarch64'])
     def test_target_variable_command_no_fail(self):
         """Test 'target variable' command before and after starting the inferior."""
         d = {'C_SOURCES': 'globals.c', 'EXE': self.getBuildArtifact('globals')}
         self.build(dictionary=d)
         self.addTearDownCleanup(dictionary=d)
 
         self.do_target_variable_command_no_fail('globals')
 

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

def has_exactly_one_image(self, matching, msg=""):
         self.expect(
             "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
+
+    @expectedFailureAll(oslist=["linux"],
+        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=["linux"]) #linux does not support loading dependent files
+    @expectedFailureAll(oslist=["linux"],
+        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=["linux"]) #linux does not support loading dependent files
+    @expectedFailureAll(oslist=["linux"],
+        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"""
         exe = self.getBuildArtifact("a.out")
         self.runCmd("target create  -d " + exe, CURRENT_EXECUTABLE_SET)
         self.has_exactly_one_image(True)
 
+    @expectedFailureAndroid # android will return mutiple images
     def test_dependents_implicit_default_lib(self):
         ctx = self.platformContext
         dylibName = ctx.shlib_prefix + 'load_a.' + ctx.shlib_extension
         lib = self.getBuildArtifact(dylibName)
         self.runCmd("target create " + lib, CURRENT_EXECUTABLE_SET)
         self.has_exactly_one_image(True)
 
     def test_dependents_explicit_default_lib(self):
         ctx = self.platformContext
         dylibName = ctx.shlib_prefix + 'load_a.' + ctx.shlib_extension
         lib = self.getBuildArtifact(dylibName)
         self.runCmd("target create -ddefault " + lib, CURRENT_EXECUTABLE_SET)
         self.has_exactly_one_image(True)
 
     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
+    @expectedFailureAll(oslist=["linux"],
+        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/trunk/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandLLDB.py

def setUp(self):
         # Build dictionary to have unique executable names for each test
         # method.
         self.exe_name = 'a%d.out' % self.test_number
         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAll(
         oslist=["linux"],
         archs=["aarch64"],
-        bugnumber="llvm.org/pr27710")
+        triple=no_match(".*-android"),
+        bugnumber="llvm.org/pr27710") # work on android
     @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)
def test_watchpoint_command(self):
         # The watchpoint command "forced" our global variable 'cookie' to
         # become 777.
         self.expect("frame variable --show-globals cookie",
                     substrs=['(int32_t)', 'cookie = 777'])
 
     @expectedFailureAll(
         oslist=["linux"],
         archs=["aarch64"],
-        bugnumber="llvm.org/pr27710")
+        triple=no_match(".*-android"),
+        bugnumber="llvm.org/pr27710") # work on android
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     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)
 

lldb/trunk/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")
+        triple=no_match(".*-android"),
+        bugnumber="llvm.org/pr27710") # work on android
     @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")
+        triple=no_match(".*-android"),
+        bugnumber="llvm.org/pr27710") # work on android
     @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/trunk/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_commands/condition/TestWatchpointConditionCmd.py

def setUp(self):
         # Build dictionary to have unique executable names for each test
         # method.
         self.exe_name = self.testMethodName
         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAll(
         oslist=["linux"],
         archs=["aarch64"],
+        triple=no_match(".*-android"),
         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)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_events/TestWatchpointEvents.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'])
     @expectedFailureAll(
         oslist=["linux"],
         archs=["aarch64"],
+        triple=no_match(".*-android"),
         bugnumber="llvm.org/pr27710")
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     def test_with_python_api(self):
         """Test that adding, deleting and modifying watchpoints sends the appropriate events."""
         self.build()
 

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

@expectedFailureAll(
         compiler="clang", compiler_version=["=", "3.8"])
     @expectedFailureAll(oslist=["freebsd", "linux"], compiler="icc")
     @expectedFailureAll(archs=['mips', 'mipsel', 'mips64', 'mips64el'])
     @expectedFailureAll(
         oslist=["linux"],
         archs=[
             'arm',
             'aarch64'],
+        triple=no_match(".*-android"),
         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()

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

def setUp(self):
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.source = 'main.c'
         self.line = line_number(
             self.source, '// Set break point at this line.')
         self.shlib_names = ["a"]
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
-    @expectedFailureAll(oslist=["linux"], archs=["aarch64"], bugnumber="llvm.org/pr37301")
+    @expectedFailureAll(oslist=["linux"],
+                        archs=["aarch64"],
+                        triple=no_match(".*-android"),
+                        bugnumber="llvm.org/pr37301")
     def test_without_process(self):
         """Test that static initialized variables can be inspected without
         process."""
         self.build()
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
 

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

def setUp(self):
         # Build dictionary to have unique executable names for each test
         # method.
         self.exe_name = self.testMethodName
         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAll(
         oslist=["linux"],
         archs=["aarch64"],
+        triple=no_match(".*-android"),
         bugnumber="llvm.org/pr27710")
     @skipIfWindows  # Watchpoints not supported on Windows, and this test hangs
     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)
 

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestLldbGdbServer.py

def test_hardware_breakpoint_set_and_remove_work_debugserver(self):
             self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
         else:
             self.build()
         self.set_inferior_startup_launch()
         self.breakpoint_set_and_remove_work(want_hardware=True)
 
     @llgs_test
     @skipUnlessPlatform(oslist=['linux'])
-    @expectedFailureAndroid
     @skipIf(archs=no_match(['arm', 'aarch64']))
     def test_hardware_breakpoint_set_and_remove_work_llgs(self):
         self.init_llgs_test()
         if self.getArchitecture() == "arm":
             # TODO: Handle case when setting breakpoint in thumb code
             self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
         else:
             self.build()