[lldb][test] Remove not_remote_testsuite_ready in favor of skipIfRemote decorator

[teemperor]

Summary

Those two decorators have identical behaviour. This removes not_remote_testsuite_ready
as skipIfRemote seems more consistent with the other decorator names we have

[teemperor]

• Rebased

[JDevlieghere]

Still looks good

lldb/packages/Python/lldbsuite/test/decorators.py

def llgs_test(func):
     """Decorate the item as a lldb-server test."""
     def should_skip_llgs_tests():
         return ("llgs tests"
                 if not configuration.llgs_platform
                 else None)
     return skipTestIfFn(should_skip_llgs_tests)(func)
 
 
-def not_remote_testsuite_ready(func):
-    """Decorate the item as a test which is not ready yet for remote testsuite."""
-    def is_remote():
-        return "Not ready for remote testsuite" if lldb.remote_platform else None
-    return skipTestIfFn(is_remote)(func)
-
-
 def expectedFailureOS(
         oslist,
         bugnumber=None,
         compilers=None,
         debug_info=None,
         archs=None):
     return expectedFailureAll(
         oslist=oslist,

lldb/test/API/commands/process/launch/TestProcessLaunch.py

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.runCmd("settings set auto-confirm true")
 
     def tearDown(self):
         self.runCmd("settings clear auto-confirm")
         TestBase.tearDown(self)
 
-    @not_remote_testsuite_ready
+    @skipIfRemote
     @skipIfReproducer
     def test_io(self):
         """Test that process launch I/O redirection flags work properly."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.expect("file " + exe,
                     patterns=["Current executable set to .*a.out"])
 
def test_io(self):
             err_msg = err_msg + "    ERROR: stderr file does not contain correct output.\n"
 
         if not success:
             self.fail(err_msg)
 
     # rdar://problem/9056462
     # The process launch flag '-w' for setting the current working directory
     # not working?
-    @not_remote_testsuite_ready
+    @skipIfRemote
     @expectedFailureAll(oslist=["freebsd", "linux"], bugnumber="llvm.org/pr20265")
     @expectedFailureNetBSD
     @skipIfReproducer
     def test_set_working_dir_nonexisting(self):
         """Test that '-w dir' fails to set the working dir when running the inferior with a dir which doesn't exist."""
         d = {'CXX_SOURCES': 'print_cwd.cpp'}
         self.build(dictionary=d)
         self.setTearDownCleanup(d)
def test_set_working_dir_nonexisting(self):
         launch_command = "process launch -w %s -o %s -e %s" % (
             invalid_dir_path, out_file_path, err_file_path)
 
         self.expect(
             launch_command, error=True, patterns=[
                 "error:.* No such file or directory: %s" %
                 invalid_dir_path])
 
-    @not_remote_testsuite_ready
+    @skipIfRemote
     @skipIfReproducer
     def test_set_working_dir_existing(self):
         """Test that '-w dir' sets the working dir when running the inferior."""
         d = {'CXX_SOURCES': 'print_cwd.cpp'}
         self.build(dictionary=d)
         self.setTearDownCleanup(d)
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe)

lldb/test/API/functionalities/load_unload/TestLoadUnload.py

def setSvr4Support(self, enabled):
             "settings set plugin.process.gdb-remote.use-libraries-svr4 {enabled}".format(
                 enabled="true" if enabled else "false"
             )
         )
 
     # libloadunload_d.so does not appear in the image list because executable
     # dependencies are resolved relative to the debuggers PWD. Bug?
     @expectedFailureAll(oslist=["freebsd", "linux", "netbsd"])
-    @not_remote_testsuite_ready
+    @skipIfRemote
     @skipIfWindows  # Windows doesn't have dlopen and friends, dynamic libraries work differently
     @skipIfReproducer # VFS is a snapshot.
     def test_modules_search_paths(self):
         """Test target modules list after loading a different copy of the library libd.dylib, and verifies that it works with 'target modules search-paths add'."""
         if self.platformIsDarwin():
             dylibName = 'libloadunload_d.dylib'
         else:
             dylibName = 'libloadunload_d.so'

lldb/test/API/functionalities/load_using_paths/TestLoadUsingPaths.py

def setUp(self):
         if self.platformIsDarwin():
             ext = 'dylib'
         self.lib_name = 'libloadunload.' + ext
 
         self.wd = os.path.realpath(self.getBuildDir())
         self.hidden_dir = os.path.join(self.wd, 'hidden')
         self.hidden_lib = os.path.join(self.hidden_dir, self.lib_name)
 
-    @not_remote_testsuite_ready
+    @skipIfRemote
     @skipIfWindows  # Windows doesn't have dlopen and friends, dynamic libraries work differently
     @expectedFlakeyNetBSD
     @expectedFailureAll(oslist=["linux"], archs=['arm'], bugnumber="llvm.org/pr45894")
     @skipIfReproducer # FIXME: Unexpected packet during (passive) replay
     def test_load_using_paths(self):
         """Test that we can load a module by providing a set of search paths."""
         if self.platformIsDarwin():
             dylibName = 'libloadunload_d.dylib'

lldb/test/API/functionalities/process_save_core/TestProcessSaveCore.py

 """
 Test saving a core file (or mini dump).
 """
 
 
 import os
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ProcessSaveCoreTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @not_remote_testsuite_ready
+    @skipIfRemote
     @skipUnlessWindows
     def test_cannot_save_core_unless_process_stopped(self):
         """Test that SaveCore fails if the process isn't stopped."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         core = self.getBuildArtifact("core.dmp")
         target = self.dbg.CreateTarget(exe)
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertNotEqual(process.GetState(), lldb.eStateStopped)
         error = process.SaveCore(core)
         self.assertTrue(error.Fail())
 
-    @not_remote_testsuite_ready
+    @skipIfRemote
     @skipUnlessWindows
     def test_save_windows_mini_dump(self):
         """Test that we can save a Windows mini dump."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         core = self.getBuildArtifact("core.dmp")
         try:
             target = self.dbg.CreateTarget(exe)

lldb/test/API/python_api/target/TestTargetAPI.py

def get_description(self):
                     substrs=['Target', 'Module', 'Breakpoint'])
 
         desc = get_description(target, option=lldb.eDescriptionLevelFull)
         if not desc:
             self.fail("SBTarget.GetDescription() failed")
         self.expect(desc, exe=False,
                     substrs=['Target', 'Module', 'a.out', 'Breakpoint'])
 
-    @not_remote_testsuite_ready
+    @skipIfRemote
     @add_test_categories(['pyapi'])
     @no_debug_info_test
     @skipIfReproducer # Inferior doesn't run during replay.
     def test_launch_new_process_and_redirect_stdout(self):
         """Exercise SBTaget.Launch() API with redirected stdout."""
         self.build()
         exe = self.getBuildArtifact("a.out")