XFAIL watchpoint tests on Android arm/aarch64

[tberghammer]

Summary

XFAIL watchpoint tests on Android arm/aarch64

[labath]

lgtm, with one request

test/lldbtest.py

707 ↗

(On Diff #30337)

Please update this comment.

lldb/trunk/test/functionalities/watchpoint/hello_watchlocation/TestWatchLocation.py

class HelloWatchLocationTestCase(TestBase):
     def test_hello_watchlocation_with_dsym(self):
         """Test watching a location with '-s size' option."""
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.hello_watchlocation()
 
     @expectedFailureFreeBSD("llvm.org/pr18832")
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_hello_watchlocation_with_dwarf(self):
         """Test watching a location with '-s size' option."""
         self.buildDwarf(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.hello_watchlocation()
 
     def setUp(self):
         # Call super's setUp().

lldb/trunk/test/functionalities/watchpoint/hello_watchpoint/TestMyFirstWatchpoint.py

class HelloWatchpointTestCase(TestBase):
     @dsym_test
     def test_hello_watchpoint_with_dsym_using_watchpoint_set(self):
         """Test a simple sequence of watchpoint creation and watchpoint hit."""
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.hello_watchpoint()
 
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_hello_watchpoint_with_dwarf_using_watchpoint_set(self):
         """Test a simple sequence of watchpoint creation and watchpoint hit."""
         self.buildDwarf(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.hello_watchpoint()
 
     def setUp(self):
         # Call super's setUp().

lldb/trunk/test/functionalities/watchpoint/multiple_threads/TestWatchpointMultipleThreads.py

class WatchpointForMultipleThreadsTestCase(TestBase):
     @dsym_test
     def test_watchpoint_multiple_threads_with_dsym(self):
         """Test that lldb watchpoint works for multiple threads."""
         self.buildDsym()
         self.setTearDownCleanup()
         self.hello_multiple_threads()
 
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_watchpoint_multiple_threads_with_dwarf(self):
         """Test that lldb watchpoint works for multiple threads."""
         self.buildDwarf()
         self.setTearDownCleanup()
         self.hello_multiple_threads()
 
     @skipUnlessDarwin
     @dsym_test
     def test_watchpoint_multiple_threads_wp_set_and_then_delete_with_dsym(self):
         """Test that lldb watchpoint works for multiple threads, and after the watchpoint is deleted, the watchpoint event should no longer fires."""
         self.buildDsym()
         self.setTearDownCleanup()
         self.hello_multiple_threads_wp_set_and_then_delete()
 
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_watchpoint_multiple_threads_wp_set_and_then_delete_with_dwarf(self):
         """Test that lldb watchpoint works for multiple threads, and after the watchpoint is deleted, the watchpoint event should no longer fires."""
         self.buildDwarf()
         self.setTearDownCleanup()
         self.hello_multiple_threads_wp_set_and_then_delete()
 
     def setUp(self):
         # Call super's setUp().

lldb/trunk/test/functionalities/watchpoint/step_over_watchpoint/TestStepOverWatchpoint.py

class TestStepOverWatchpoint(TestBase):
     @skipUnlessDarwin
     @dsym_test
     def test_with_dsym(self):
         """Test stepping over watchpoints."""
         self.buildDsym()
         self.step_over_watchpoint()
 
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_with_dwarf(self):
         """Test stepping over watchpoints."""
         self.buildDwarf()
         self.step_over_watchpoint()
 
     def setUp(self):
         TestBase.setUp(self)
 

lldb/trunk/test/functionalities/watchpoint/watchpoint_commands/TestWatchpointCommands.py

class WatchpointCommandsTestCase(TestBase):
     @dsym_test
     def test_rw_watchpoint_with_dsym(self):
         """Test read_write watchpoint and expect to stop two times."""
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.normal_read_write_watchpoint()
 
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_rw_watchpoint_with_dwarf(self):
         """Test read_write watchpoint and expect to stop two times."""
         self.buildDwarf(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.normal_read_write_watchpoint()
 
     @skipUnlessDarwin
     @dsym_test
     def test_rw_watchpoint_delete_with_dsym(self):
         """Test delete watchpoint and expect not to stop for watchpoint."""
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.delete_read_write_watchpoint()
 
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_rw_watchpoint_delete_with_dwarf(self):
         """Test delete watchpoint and expect not to stop for watchpoint."""
         self.buildDwarf(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.delete_read_write_watchpoint()
 
     @skipUnlessDarwin
     @dsym_test
     def test_rw_watchpoint_set_ignore_count_with_dsym(self):
         """Test watchpoint ignore count and expect to not to stop at all."""
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.ignore_read_write_watchpoint()
 
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_rw_watchpoint_set_ignore_count_with_dwarf(self):
         """Test watchpoint ignore count and expect to not to stop at all."""
         self.buildDwarf(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.ignore_read_write_watchpoint()
 
     @skipUnlessDarwin
     @dsym_test
     def test_rw_disable_after_first_stop_with_dsym(self):
         """Test read_write watchpoint but disable it after the first stop."""
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.read_write_watchpoint_disable_after_first_stop()
 
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_rw_disable_after_first_stop__with_dwarf(self):
         """Test read_write watchpoint but disable it after the first stop."""
         self.buildDwarf(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.read_write_watchpoint_disable_after_first_stop()
 
     @skipUnlessDarwin
     @dsym_test
     def test_rw_disable_then_enable_with_dsym(self):
         """Test read_write watchpoint, disable initially, then enable it."""
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.read_write_watchpoint_disable_then_enable()
 
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_rw_disable_then_enable_with_dwarf(self):
         """Test read_write watchpoint, disable initially, then enable it."""
         self.buildDwarf(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.read_write_watchpoint_disable_then_enable()
 
     def normal_read_write_watchpoint(self):
         """Do read_write watchpoint and expect to stop two times."""

lldb/trunk/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandLLDB.py

class WatchpointLLDBCommandTestCase(TestBase):
     @dsym_test
     def test_watchpoint_command_with_dsym(self):
         """Test 'watchpoint command'."""
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.watchpoint_command()
 
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_watchpoint_command_with_dwarf(self):
         """Test 'watchpoint command'."""
         self.buildDwarf(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.watchpoint_command()
 
     @skipUnlessDarwin
     @dsym_test
     def test_watchpoint_command_can_disable_a_watchpoint_with_dsym(self):
         """Test that 'watchpoint command' action can disable a watchpoint after it is triggered."""
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.watchpoint_command_can_disable_a_watchpoint()
 
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_watchpoint_command_can_disable_a_watchpoint_with_dwarf(self):
         """Test that 'watchpoint command' action can disable a watchpoint after it is triggered."""
         self.buildDwarf(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.watchpoint_command_can_disable_a_watchpoint()
 
     def watchpoint_command(self):
         """Do 'watchpoint command add'."""

lldb/trunk/test/functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandPython.py

class WatchpointPythonCommandTestCase(TestBase):
     def test_watchpoint_command_with_dsym(self):
         """Test 'watchpoint command'."""
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.watchpoint_command()
 
     @dwarf_test
     @skipIfFreeBSD # timing out on buildbot
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_watchpoint_command_with_dwarf(self):
         """Test 'watchpoint command'."""
         self.buildDwarf(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.watchpoint_command()
 
     def watchpoint_command(self):
         """Do 'watchpoint command add'."""

lldb/trunk/test/functionalities/watchpoint/watchpoint_commands/condition/TestWatchpointConditionCmd.py

class WatchpointConditionCmdTestCase(TestBase):
     @dsym_test
     def test_watchpoint_cond_with_dsym(self):
         """Test watchpoint condition."""
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.watchpoint_condition()
 
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_watchpoint_cond_with_dwarf(self):
         """Test watchpoint condition."""
         self.buildDwarf(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.watchpoint_condition()
 
     def watchpoint_condition(self):
         """Do watchpoint condition 'global==5'."""

lldb/trunk/test/functionalities/watchpoint/watchpoint_events/TestWatchpointEvents.py

class TestWatchpointEvents (TestBase):
     @dsym_test
     def test_with_dsym_and_python_api(self):
         """Test that adding, deleting and modifying watchpoints sends the appropriate events."""
         self.buildDsym()
         self.step_over_stepping()
 
     @python_api_test
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_with_dwarf_and_python_api(self):
         """Test that adding, deleting and modifying watchpoints sends the appropriate events."""
         self.buildDwarf()
         self.step_over_stepping()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

lldb/trunk/test/functionalities/watchpoint/watchpoint_set_command/TestWatchLocationWithWatchSet.py

class WatchLocationUsingWatchpointSetTestCase(TestBase):
     @skipUnlessDarwin
     @dsym_test
     def test_watchlocation_with_dsym_using_watchpoint_set(self):
         """Test watching a location with 'watchpoint set expression -w write -s size' option."""
         self.buildDsym()
         self.setTearDownCleanup()
         self.watchlocation_using_watchpoint_set()
 
-    @expectedFailureFreeBSD('llvm.org/pr18832')
     @dwarf_test
+    @expectedFailureFreeBSD('llvm.org/pr18832')
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_watchlocation_with_dwarf_using_watchpoint_set(self):
         """Test watching a location with 'watchpoint set expression -w write -s size' option."""
         self.buildDwarf()
         self.setTearDownCleanup()
         self.watchlocation_using_watchpoint_set()
 
     def setUp(self):
         # Call super's setUp().

lldb/trunk/test/lldbtest.py

def expectedFailureLinux(bugnumber=None, compilers=None):
     return expectedFailureOS(['linux'], bugnumber, compilers)
 
 def expectedFailureWindows(bugnumber=None, compilers=None):
     return expectedFailureOS(['windows'], bugnumber, compilers)
 
 def expectedFailureHostWindows(bugnumber=None, compilers=None):
     return expectedFailureHostOS(['windows'], bugnumber, compilers)
 
-def expectedFailureAndroid(bugnumber=None, api_levels=None):
+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.
+            for which a test is expected to fail. None means all API level.
+        arch - A sequence of architecture names specifying the architectures
+            for which a test is expected to fail. None means all architectures.
     """
     def fn(self):
         if target_is_android():
-            if not api_levels:
-                return True
-            device_api = android_device_api()
-            return device_api and (device_api in api_levels)
+            if archs is not None and self.getArchitecture() not in archs:
+                return False
+            if api_levels is not None and android_device_api() not in api_levels:
+                return False
 
     return expectedFailure(fn, bugnumber)
 
 # if the test passes on the first try, we're done (success)
 # if the test fails once, then passes on the second try, raise an ExpectedFailure
 # if the test fails twice in a row, re-throw the exception from the second test run
 def expectedFlakey(expected_fn, bugnumber=None):
     def expectedFailure_impl(func):

lldb/trunk/test/python_api/watchpoint/TestSetWatchpoint.py

class SetWatchpointAPITestCase(TestBase):
     @dsym_test
     def test_watch_val_with_dsym(self):
         """Exercise SBValue.Watch() API to set a watchpoint."""
         self.buildDsym()
         self.do_set_watchpoint()
 
     @python_api_test
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_watch_val_with_dwarf(self):
         """Exercise SBValue.Watch() API to set a watchpoint."""
         self.buildDwarf()
         self.do_set_watchpoint()
 
     def do_set_watchpoint(self):
         """Use SBFrame.WatchValue() to set a watchpoint and verify that the program stops later due to the watchpoint."""
         exe = os.path.join(os.getcwd(), "a.out")

lldb/trunk/test/python_api/watchpoint/TestWatchpointIgnoreCount.py

class WatchpointIgnoreCountTestCase(TestBase):
     @dsym_test
     def test_set_watch_ignore_count_with_dsym(self):
         """Test SBWatchpoint.SetIgnoreCount() API."""
         self.buildDsym()
         self.do_watchpoint_ignore_count()
 
     @python_api_test
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_set_watch_ignore_count_with_dwarf(self):
         """Test SBWatchpoint.SetIgnoreCount() API."""
         self.buildDwarf()
         self.do_watchpoint_ignore_count()
 
     def do_watchpoint_ignore_count(self):
         """Test SBWatchpoint.SetIgnoreCount() API."""
         exe = os.path.join(os.getcwd(), "a.out")

lldb/trunk/test/python_api/watchpoint/TestWatchpointIter.py

class WatchpointIteratorTestCase(TestBase):
     @dsym_test
     def test_watch_iter_with_dsym(self):
         """Exercise SBTarget.watchpoint_iter() API to iterate on the available watchpoints."""
         self.buildDsym()
         self.do_watchpoint_iter()
 
     @python_api_test
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_watch_iter_with_dwarf(self):
         """Exercise SBTarget.watchpoint_iter() API to iterate on the available watchpoints."""
         self.buildDwarf()
         self.do_watchpoint_iter()
 
     def do_watchpoint_iter(self):
         """Use SBTarget.watchpoint_iter() to do Pythonic iteration on the available watchpoints."""
         exe = os.path.join(os.getcwd(), "a.out")

lldb/trunk/test/python_api/watchpoint/condition/TestWatchpointConditionAPI.py

class WatchpointConditionAPITestCase(TestBase):
     @dsym_test
     def test_watchpoint_cond_api_with_dsym(self):
         """Test watchpoint condition API."""
         self.buildDsym(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.watchpoint_condition_api()
 
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_watchpoint_cond_api_with_dwarf(self):
         """Test watchpoint condition API."""
         self.buildDwarf(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         self.watchpoint_condition_api()
 
     def watchpoint_condition_api(self):
         """Do watchpoint condition API to set condition as 'global==5'."""

lldb/trunk/test/python_api/watchpoint/watchlocation/TestSetWatchlocation.py

class SetWatchlocationAPITestCase(TestBase):
     @dsym_test
     def test_watch_location_with_dsym(self):
         """Exercise SBValue.WatchPointee() API to set a watchpoint."""
         self.buildDsym()
         self.do_set_watchlocation()
 
     @python_api_test
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_watch_location_with_dwarf(self):
         """Exercise SBValue.WatchPointee() API to set a watchpoint."""
         self.buildDwarf()
         self.do_set_watchlocation()
 
     def do_set_watchlocation(self):
         """Use SBValue.WatchPointee() to set a watchpoint and verify that the program stops later due to the watchpoint."""
         exe = os.path.join(os.getcwd(), "a.out")

lldb/trunk/test/python_api/watchpoint/watchlocation/TestTargetWatchAddress.py

class TargetWatchAddressAPITestCase(TestBase):
     @dsym_test
     def test_watch_address_with_dsym(self):
         """Exercise SBTarget.WatchAddress() API to set a watchpoint."""
         self.buildDsym()
         self.do_set_watchaddress()
 
     @python_api_test
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_watch_address_with_dwarf(self):
         """Exercise SBTarget.WatchAddress() API to set a watchpoint."""
         self.buildDwarf()
         self.do_set_watchaddress()
 
     @skipUnlessDarwin
     @python_api_test
     @dsym_test
     def test_watch_address_with_invalid_watch_size_with_dsym(self):
         """Exercise SBTarget.WatchAddress() API but pass an invalid watch_size."""
         self.buildDsym()
         self.do_set_watchaddress_with_invalid_watch_size()
 
     @python_api_test
     @dwarf_test
+    @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     def test_watch_address_with_invalid_watch_size_with_dwarf(self):
         """Exercise SBTarget.WatchAddress() API but pass an invalid watch_size."""
         self.buildDwarf()
         self.do_set_watchaddress_with_invalid_watch_size()
 
     def do_set_watchaddress(self):
         """Use SBTarget.WatchAddress() to set a watchpoint and verify that the program stops later due to the watchpoint."""
         exe = os.path.join(os.getcwd(), "a.out")