[lldb] [test] Skip ObjC-based tests via 'objc' category

[mgorny]

Summary

Replace the plethora of ObjC-implied 'skipUnlessDarwin' decorators
with marking tests as 'objc' category (whenever missing), and skip all
ObjC tests on non-Darwin platforms. I have used '.categories' file
wherever it was present already or all (>1) tests were relying on ObjC,
and explicit add_test_categories() where there was only one test.

[mgorny]

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCExpr.py

17

(this whole category has objc in .categories)

lldb/test/API/functionalities/tsan/multiple/TestTsanMultiple.py

16

This one's curious. I'm wondering why it's explicitly marked for all the platforms while it.s clearly a .m file ;-).

lldb/test/API/lang/objc/bitfield_ivars/TestBitfieldIvars.py

11

ditto

[mgorny]

Failed to git add one of the .categories files.

[teemperor]

LGTM. Thanks for cleaning this up, it's really appreciated!

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

839

nit: we do from lldbsuite.test import lldbplatformutil in the surrounding code, so that seems more consistent.

lldb/test/API/functionalities/tsan/multiple/TestTsanMultiple.py

16

For the record: I think those XFails were just copied to all sanitizers tests that were failing on Linux (independently of whether the issue was lacking sanitizer support on Linux or as here Obj-C support missing).

[mgorny]

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

839

Thanks, will fix it in place.

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

def checkWatchpointSupport():
     result, reason = canRunWatchpointTests()
     if result:
         return # watchpoints supported
     if "watchpoint" in configuration.categories_list:
         return # watchpoint category explicitly requested, let it run.
     print("watchpoint tests will not be run because: " + reason)
     configuration.skip_categories.append("watchpoint")
 
+def checkObjcSupport():
+    from . import lldbplatformutil
+    if not lldbplatformutil.platformIsDarwin():
+        print("objc tests will be skipped because of unsupported platform")
+        configuration.skip_categories.append("objc")
+
 def checkDebugInfoSupport():
     import lldb
 
     platform = lldb.selected_platform.GetTriple().split('-')[2]
     compiler = configuration.compiler
     skipped = []
     for cat in test_categories.debug_info_categories:
         if cat in configuration.categories_list:
def run_suite():
 
     from . import lldbplatformutil
     target_platform = lldbplatformutil.getPlatform()
 
     checkLibcxxSupport()
     checkLibstdcxxSupport()
     checkWatchpointSupport()
     checkDebugInfoSupport()
+    checkObjcSupport()
 
     # Perform LLGS tests only on platforms using it.
     configuration.llgs_platform = (
         target_platform in ["freebsd", "linux", "netbsd", "windows"])
 
     # Perform debugserver tests elsewhere (i.e. on Darwin platforms).
     configuration.debugserver_platform = not configuration.llgs_platform
 

lldb/test/API/commands/expression/call-throws/TestCallThatThrows.py

class ExprCommandWithThrowTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
         self.main_source = "call-throws.m"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
-    @skipUnlessDarwin
+    @add_test_categories(["objc"])
     def test(self):
         """Test calling a function that throws and ObjC exception."""
         self.build()
         self.call_function()
 
     def check_after_call(self):
         # Check that we are back where we were before:
         frame = self.thread.GetFrameAtIndex(0)

lldb/test/API/commands/expression/context-object-objc/TestContextObjectObjc.py

 """
 Tests expression evaluation in context of an objc class.
 """
 
 import lldb
 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
 class ContextObjectObjcTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
+    @add_test_categories(["objc"])
     def test_context_object_objc(self):
         """Tests expression evaluation in context of an objc class."""
         self.build()
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, '// Break here', self.main_source_spec)
         frame = thread.GetFrameAtIndex(0)
 
         #

lldb/test/API/commands/expression/diagnostics/TestExprDiagnostics.py

def test_source_and_caret_printing(self):
 
         # Redefine something that we defined in a user-expression. We should use the previous expression file name
         # for the original decl.
         value = frame.EvaluateExpression("struct Redef { double x; };", top_level_opts)
         value = frame.EvaluateExpression("struct Redef { float y; };", top_level_opts)
         self.assertFalse(value.GetError().Success())
         self.assertIn("error: <user expression 9>:1:8: redefinition of 'Redef'\nstruct Redef { float y; };\n       ^\n<user expression 8>:1:8: previous definition is here\nstruct Redef { double x; };\n       ^", value.GetError().GetCString())
 
-    @skipUnlessDarwin
+    @add_test_categories(["objc"])
     def test_source_locations_from_objc_modules(self):
         self.build()
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                           '// Break here', self.main_source_spec)
         frame = thread.GetFrameAtIndex(0)
 
         # Import foundation so that the Obj-C module is loaded (which contains source locations

lldb/test/API/commands/expression/import_builtin_fileid/TestImportBuiltinFileID.py

 """
 They may be cases where an expression will import SourceLocation and if the
 SourceLocation ends up with a FileID that is a built-in we need to copy that
 buffer over correctly.
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestImportBuiltinFileID(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     @skipIfDarwinEmbedded
-    @add_test_categories(["gmodules"])
+    @add_test_categories(["gmodules", "objc"])
     def test_import_builtin_fileid(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self, '// break here',
                 lldb.SBFileSpec("main.m", False))
 
         self.expect("expr int (*DBG_CGImageGetRenderingIntent)(void *) = ((int (*)(void *))CGImageGetRenderingIntent); DBG_CGImageGetRenderingIntent((void *)0x00000000000000);", 
                 substrs=['$0 = 0'])

lldb/test/API/commands/expression/namespace_local_var_same_name_obj_c/TestNamespaceLocalVarSameNameObjC.py

 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestNamespaceLocalVarSameNameObjC(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
-    @add_test_categories(["gmodules"])
+    @add_test_categories(["gmodules", "objc"])
     def test_namespace_local_var_same_name_obj_c(self):
         self.build()
 
         (self.target, self.process, _, bkpt) = lldbutil.run_to_source_breakpoint(self, '// break here',
                 lldb.SBFileSpec("util.mm", False))
 
         self.expect("expr error",
                 substrs=['(NSError *) $0 ='])
 
         lldbutil.continue_to_breakpoint(self.process, bkpt)
 
         self.expect("expr error",
                 substrs=['(NSError *) $1 ='])

lldb/test/API/commands/expression/persist_objc_pointeetype/TestPersistObjCPointeeType.py

class PersistObjCPointeeType(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.cpp.
         self.line = line_number('main.m', '// break here')
 
-    @skipUnlessDarwin
     @skipIf(archs=["i386", "i686"])
     @skipIf(debug_info="gmodules", archs=['arm64', 'armv7', 'armv7k', 'arm64e', 'arm64_32'])  # compile error with gmodules for iOS
+    @add_test_categories(["objc"])
     def test_with(self):
         """Test that we can p *objcObject"""
         self.build()
 
         def cleanup():
             pass
 
         # Execute the cleanup function during test case tear down.

lldb/test/API/commands/expression/po_verbosity/TestPoVerbosity.py

class PoVerbosityTestCase(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.m',
                                 '// Stop here')
 
-    @skipUnlessDarwin
+    @add_test_categories(["objc"])
     def test(self):
         """Test that the po command acts correctly."""
         self.build()
 
         # This is the function to remove the custom formats in order to have a
         # clean slate for the next test case.
         def cleanup():
             self.runCmd('type summary clear', check=False)

lldb/test/API/commands/expression/two-files/TestObjCTypeQueryFromOtherCompileUnit.py

class ObjCTypeQueryTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.m.
         self.line = line_number(
             'main.m', "// Set breakpoint here, then do 'expr (NSArray*)array_token'.")
 
-    @skipUnlessDarwin
+    @add_test_categories(["objc"])
     def test(self):
         """The expression parser's type search should be wider than the current compilation unit."""
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(
             self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # Now do a NSArry type query from the 'main.m' compile uint.
         self.expect("expression (NSArray*)array_token",
                     substrs=['(NSArray *) $0 = 0x'])
         # (NSArray *) $0 = 0x00007fff70118398

lldb/test/API/functionalities/breakpoint/objc/TestObjCBreakpoints.py

 """
 Test that objective-c constant strings are generated correctly by the expression
 parser.
 """
 
 
 
 import shutil
 import subprocess
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-@skipUnlessDarwin
 class TestObjCBreakpoints(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
+    @add_test_categories(["objc"])
     def test_break(self):
         """Test setting Objective-C specific breakpoints (DWARF in .o files)."""
         self.build()
         self.setTearDownCleanup()
         self.check_objc_breakpoints(False)
 
     def setUp(self):
         # Call super's setUp().

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCCF.py

 # encoding: utf-8
 """
 Test lldb data formatter subsystem.
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterCF(ObjCDataFormatterTestCase):
 
-    @skipUnlessDarwin
     def test_coreframeworks_and_run_command(self):
         """Test formatters for Core OSX frameworks."""
         self.build()
         self.target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
             self, '// Set break point at this line.',
             lldb.SBFileSpec('main.m', False))
 
         # The stop reason of the thread should be breakpoint.

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCExpr.py

 # encoding: utf-8
 """
 Test lldb data formatter subsystem.
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterExpr(ObjCDataFormatterTestCase):
 
-    @skipUnlessDarwin
     def test_expr_with_run_command(self):
         """Test common cases of expression parser <--> formatters interaction."""
         self.build()
         self.target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
             self, '// Set break point at this line.',
             lldb.SBFileSpec('main.m', False))
 
         # The stop reason of the thread should be breakpoint.

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCKVO.py

 # encoding: utf-8
 """
 Test lldb data formatter subsystem.
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterKVO(ObjCDataFormatterTestCase):
 
-    @skipUnlessDarwin
     def test_kvo_with_run_command(self):
         """Test the behavior of formatters when KVO is in use."""
         self.build()
         self.target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
             self, '// Set break point at this line.',
             lldb.SBFileSpec('main.m', False))
 
         # The stop reason of the thread should be breakpoint.

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSBundle.py

 # encoding: utf-8
 """
 Test lldb data formatter subsystem.
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterNSBundle(ObjCDataFormatterTestCase):
 
-    @skipUnlessDarwin
     def test_nsbundle_with_run_command(self):
         """Test formatters for NSBundle."""
         self.appkit_tester_impl(self.nsbundle_data_formatter_commands)
 
     def nsbundle_data_formatter_commands(self):
         self.expect(
             'frame variable bundle_string bundle_url main_bundle',
             substrs=[
                 '(NSBundle *) bundle_string = ',
                 ' @"/System/Library/Frameworks/Accelerate.framework"',
                 '(NSBundle *) bundle_url = ',
                 ' @"/System/Library/Frameworks/Foundation.framework"',
                 '(NSBundle *) main_bundle = ', 'data-formatter-objc'
             ])

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSContainer.py

 # encoding: utf-8
 """
 Test lldb data formatter subsystem.
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterNSContainer(ObjCDataFormatterTestCase):
 
-    @skipUnlessDarwin
     def test_nscontainers_with_run_command(self):
         """Test formatters for  NS container classes."""
         self.appkit_tester_impl(self.nscontainers_data_formatter_commands)
 
     def nscontainers_data_formatter_commands(self):
         self.expect(
             'frame variable newArray nsDictionary newDictionary nscfDictionary cfDictionaryRef newMutableDictionary newMutableDictionaryRef cfarray_ref mutable_array_ref',
             substrs=[

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSData.py

 # encoding: utf-8
 """
 Test lldb data formatter subsystem.
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterNSData(ObjCDataFormatterTestCase):
 
-    @skipUnlessDarwin
     def test_nsdata_with_run_command(self):
         """Test formatters for  NSData."""
         self.appkit_tester_impl(self.nsdata_data_formatter_commands)
 
     def nsdata_data_formatter_commands(self):
         self.expect(
             'frame variable immutableData mutableData data_ref mutable_data_ref mutable_string_ref concreteData concreteMutableData',
             substrs=[

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSDate.py

 from lldbsuite.test import lldbutil
 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 import datetime
 
 class ObjCDataFormatterNSDate(ObjCDataFormatterTestCase):
 
-    @skipUnlessDarwin
     def test_nsdate_with_run_command(self):
         """Test formatters for  NSDate."""
         self.appkit_tester_impl(self.nsdate_data_formatter_commands)
 
     def nsdate_data_formatter_commands(self):
         self.expect(
             'frame variable date1 date2',
             patterns=[

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSError.py

 # encoding: utf-8
 """
 Test lldb data formatter subsystem.
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterNSError(ObjCDataFormatterTestCase):
 
-    @skipUnlessDarwin
     def test_nserror_with_run_command(self):
         """Test formatters for NSError."""
         self.appkit_tester_impl(self.nserror_data_formatter_commands)
 
     def nserror_data_formatter_commands(self):
         self.expect(
             'frame variable nserror', substrs=['domain: @"Foobar" - code: 12'])
 

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCNSURL.py

 # encoding: utf-8
 """
 Test lldb data formatter subsystem.
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterNSURL(ObjCDataFormatterTestCase):
 
-    @skipUnlessDarwin
     def test_nsurl_with_run_command(self):
         """Test formatters for NSURL."""
         self.appkit_tester_impl(self.nsurl_data_formatter_commands)
 
     def nsurl_data_formatter_commands(self):
         self.expect(
             'frame variable cfurl_ref cfchildurl_ref cfgchildurl_ref',
             substrs=[

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjCPlain.py

 # encoding: utf-8
 """
 Test lldb data formatter subsystem.
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterNSPlain(ObjCDataFormatterTestCase):
 
-    @skipUnlessDarwin
     def test_plain_objc_with_run_command(self):
         """Test basic ObjC formatting behavior."""
         self.build()
         self.target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(
             self, '// Set break point at this line.',
             lldb.SBFileSpec('main.m', False))
 
         # The stop reason of the thread should be breakpoint.

lldb/test/API/functionalities/data-formatter/data-formatter-objc/TestDataFormatterObjNSException.py

 # encoding: utf-8
 """
 Test lldb data formatter subsystem.
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 from ObjCDataFormatterTestCase import ObjCDataFormatterTestCase
 
 
 class ObjCDataFormatterNSException(ObjCDataFormatterTestCase):
 
-    @skipUnlessDarwin
     def test_nsexception_with_run_command(self):
         """Test formatters for NSException."""
         self.appkit_tester_impl(self.nsexception_data_formatter_commands)
 
     def nsexception_data_formatter_commands(self):
         self.expect(
             'frame variable except0 except1 except2 except3',
             substrs=[

lldb/test/API/functionalities/set-data/TestSetData.py

 """
 Set the contents of variables and registers using raw data
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class SetDataTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
+    @add_test_categories(["objc"])
     def test_set_data(self):
         """Test setting the contents of variables and registers using raw data."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("br s -p First")
         self.runCmd("br s -p Second")

lldb/test/API/functionalities/tsan/multiple/TestTsanMultiple.py

 """
 Test ThreadSanitizer when multiple different issues are found.
 """
 
 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 import lldbsuite.test.lldbutil as lldbutil
 import json
 
 
 class TsanMultipleTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAll(
         oslist=["linux"],
         bugnumber="non-core functionality, need to reenable and fix later (DES 2014.11.07)")
     @expectedFailureNetBSD
     @skipIfFreeBSD  # llvm.org/pr21136 runtimes not yet available by default
     @skipIfRemote
     @skipUnlessThreadSanitizer
+    @add_test_categories(["objc"])
     def test(self):
         self.build()
         self.tsan_tests()
 
     def tsan_tests(self):
         exe = self.getBuildArtifact("a.out")
         self.expect(
             "file " + exe,

lldb/test/API/lang/objc/bitfield_ivars/TestBitfieldIvars.py

 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestBitfieldIvars(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
 
-    @skipUnlessDarwin
     def test(self):
         self.build()
         lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("main.m"))
 
         self.expect_expr("chb->hb->field1", result_type="unsigned int", result_value="0")
         ## This should happen second
         self.expect_expr("chb->hb->field2", result_type="unsigned int", result_value="1")
 

lldb/test/API/lang/objc/blocks/TestObjCIvarsInBlocks.py

class TestObjCIvarsInBlocks(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "main.m"
         self.class_source = "ivars-in-blocks.m"
         self.class_source_file_spec = lldb.SBFileSpec(self.class_source)
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     @skipIf(dwarf_version=['<', '4'])
     @expectedFailureAll(
         archs=["i[3-6]86"],
         bugnumber="This test requires the 2.0 runtime, so it will fail on i386")
     def test_with_python_api(self):
         """Test printing the ivars of the self when captured in blocks"""
         self.build()

lldb/test/API/lang/objc/conflicting-definition/TestConflictingDefinition.py

 """Test that types defined in shared libraries work correctly."""
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestRealDefinition(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     def test_frame_var_after_stop_at_implementation(self):
         """Test that we can find the implementation for an objective C type"""
         if self.getArchitecture() == 'i386':
             self.skipTest("requires modern objc runtime")
         self.build()
         self.shlib_names = ["libTestExt.dylib", "libTest.dylib"]
         self.common_setup()
 

lldb/test/API/lang/objc/direct-dispatch-step/TestObjCDirectDispatchStepping.py

class TestObjCDirectDispatchStepping(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = lldb.SBFileSpec("stepping-tests.m")
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi', 'basic_process'])
     def test_with_python_api(self):
         """Test stepping through the 'direct dispatch' optimized method calls."""
         self.build()
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                                                             "Stop here to start stepping",
                                                                             self.main_source)

lldb/test/API/lang/objc/exceptions/TestObjCExceptions.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ObjCExceptionsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     def test_objc_exceptions_at_throw(self):
         self.build()
 
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)
 
         launch_info = lldb.SBLaunchInfo(["a.out", "0"])
         launch_info.SetLaunchFlags(lldb.eLaunchFlagInheritTCCFromParent)
def test_objc_exceptions_at_throw(self):
                 if reserved.GetChildAtIndex(i).GetChildAtIndex(0).description == "callStackReturnAddresses"][0].dynamic
         children = [callStackReturnAddresses.GetChildAtIndex(i) for i in range(0, callStackReturnAddresses.num_children)]
 
         pcs = [i.unsigned for i in children]
         names = [target.ResolveSymbolContextForAddress(lldb.SBAddress(pc, target), lldb.eSymbolContextSymbol).GetSymbol().name for pc in pcs]
         for n in ["objc_exception_throw", "foo(int)", "main"]:
             self.assertTrue(n in names, "%s is in the exception backtrace (%s)" % (n, names))
 
-    @skipUnlessDarwin
     def test_objc_exceptions_at_abort(self):
         self.build()
 
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)
 
         self.runCmd("run 0")
 
def test_objc_exceptions_at_abort(self):
         process = self.dbg.GetSelectedTarget().process
         thread = process.GetSelectedThread()
 
         history_thread = thread.GetCurrentExceptionBacktrace()
         self.assertGreaterEqual(history_thread.num_frames, 4)
         for n in ["objc_exception_throw", "foo(int)", "rethrow(int)", "main"]:
             self.assertEqual(len([f for f in history_thread.frames if f.GetFunctionName() == n]), 1)
 
-    @skipUnlessDarwin
     def test_cxx_exceptions_at_abort(self):
         self.build()
 
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)
 
         self.runCmd("run 2")
 

lldb/test/API/lang/objc/forward-decl/TestForwardDecl.py

def do_test(self, dictionary=None):
         # The breakpoint should have a hit count of 1.
         self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
                     substrs=[' resolved, hit count = 1'])
 
         # This should display correctly.
         self.expect("expression [j getMember]", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["= 0x"])
 
-    @skipUnlessDarwin
     def test_expr(self):
         self.do_test()
 
     @no_debug_info_test
-    @skipUnlessDarwin
     @skipIf(compiler=no_match("clang"))
     @skipIf(compiler_version=["<", "7.0"])
     def test_debug_names(self):
         """Test that we are able to find complete types when using DWARF v5
         accelerator tables"""
         self.do_test(
             dict(CFLAGS_EXTRAS="-dwarf-version=5 -mllvm -accel-tables=Dwarf"))

lldb/test/API/lang/objc/foundation/TestConstStrings.py

class ConstStringTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.main_source = "const-strings.m"
         self.line = line_number(self.main_source, '// Set breakpoint here.')
 
-    @skipUnlessDarwin
     def test_break(self):
         """Test constant string generation amd comparison by the expression parser."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(self.d)
 
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

lldb/test/API/lang/objc/foundation/TestFoundationDisassembly.py

 """
 Test the lldb disassemble command on foundation framework.
 """
 
 import unittest2
 import os
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-@skipUnlessDarwin
 class FoundationDisassembleTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfAsan
     def test_foundation_disasm(self):

lldb/test/API/lang/objc/foundation/TestObjCMethods.py

 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 file_index = 0
 
 
-@skipUnlessDarwin
 class FoundationTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().

lldb/test/API/lang/objc/foundation/TestObjCMethods2.py

 """
 Test more expression command sequences with objective-c.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-@skipUnlessDarwin
 class FoundationTestCase2(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_expr_commands(self):
         """More expression commands for objective-c."""

lldb/test/API/lang/objc/foundation/TestObjCMethodsNSArray.py

 """
 Test more expression command sequences with objective-c.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-@skipUnlessDarwin
 class FoundationTestCaseNSArray(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def test_NSArray_expr_commands(self):
         """Test expression commands for NSArray."""
         self.build()
         self.target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(

lldb/test/API/lang/objc/foundation/TestObjCMethodsNSError.py

 """
 Test more expression command sequences with objective-c.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-@skipUnlessDarwin
 class FoundationTestCaseNSError(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAll(archs=["i[3-6]86"], bugnumber="<rdar://problem/28814052>")
     def test_runtime_types(self):
         """Test commands that require runtime types"""
         self.build()

lldb/test/API/lang/objc/foundation/TestObjCMethodsString.py

 """
 Test more expression command sequences with objective-c.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-@skipUnlessDarwin
 class FoundationTestCaseString(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def test_NSString_expr_commands(self):
         """Test expression commands for NSString."""
         self.build()
         self.target, process, thread, bkpt = lldbutil.run_to_source_breakpoint(

lldb/test/API/lang/objc/foundation/TestObjectDescriptionAPI.py

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break at.
         self.source = 'main.m'
         self.line = line_number(
             self.source, '// Set break point at this line.')
 
     # rdar://problem/10857337
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     def test_find_global_variables_then_object_description(self):
         """Exercise SBTarget.FindGlobalVariables() API."""
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         exe = self.getBuildArtifact('b.out')
 

lldb/test/API/lang/objc/foundation/TestRuntimeTypes.py

 """
 Test that Objective-C methods from the runtime work correctly.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-@skipUnlessDarwin
 class RuntimeTypesTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAll(
         oslist=["macosx"],
         debug_info="gmodules",
         bugnumber="llvm.org/pr27862")

lldb/test/API/lang/objc/foundation/TestSymbolTable.py

 """
 Test symbol table access for main.m.
 """
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-@skipUnlessDarwin
 class FoundationSymtabTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     symbols_list = ['-[MyString initWithNSString:]',
                     '-[MyString dealloc]',
                     '-[MyString description]',
                     '-[MyString descriptionPauses]',     # synthesized property

lldb/test/API/lang/objc/global_ptrs/TestGlobalObjects.py

class TestObjCGlobalVar(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.main_source = lldb.SBFileSpec("main.m")
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test that a global ObjC object found before the process is started updates correctly."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/test/API/lang/objc/hidden-ivars/TestHiddenIvars.py

def setUp(self):
         # Find the line number to break inside main().
         self.source = 'main.m'
         self.line = line_number(self.source, '// breakpoint1')
         # The makefile names of the shared libraries as they appear in DYLIB_NAME.
         # The names should have no loading "lib" or extension as they will be
         # localized
         self.shlib_names = ["InternalDefiner"]
 
-    @skipUnlessDarwin
     @skipIf(
         debug_info=no_match("dsym"),
         bugnumber="This test requires a stripped binary and a dSYM")
     @skipIfReproducer # FIXME: Unexpected packet during (passive) replay
     def test_expr_stripped(self):
         if self.getArchitecture() == 'i386':
             self.skipTest("requires modern objc runtime")
         else:
             self.build()
             self.expr(True)
 
-    @skipUnlessDarwin
     @skipIfReproducer # FIXME: Unexpected packet during (passive) replay
     def test_expr(self):
         if self.getArchitecture() == 'i386':
             self.skipTest("requires modern objc runtime")
         else:
             self.build()
             self.expr(False)
 
-    @skipUnlessDarwin
     @skipIf(
         debug_info=no_match("dsym"),
         bugnumber="This test requires a stripped binary and a dSYM")
     def test_frame_variable_stripped(self):
         if self.getArchitecture() == 'i386':
             self.skipTest("requires modern objc runtime")
         else:
             self.build()
             self.frame_var(True)
 
-    @skipUnlessDarwin
     def test_frame_variable(self):
         if self.getArchitecture() == 'i386':
             self.skipTest("requires modern objc runtime")
         else:
             self.build()
             self.frame_var(False)
 
     @expectedFailure("rdar://18683637")
-    @skipUnlessDarwin
     def test_frame_variable_across_modules(self):
         if self.getArchitecture() == 'i386':
             self.skipTest("requires modern objc runtime")
         else:
             self.build()
             self.common_setup(False)
             self.expect(
                 "frame variable k->bar",

lldb/test/API/lang/objc/ivar-IMP/TestObjCiVarIMP.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ObjCiVarIMPTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     @skipIf(archs=['i386'])  # objc file does not build for i386
     @no_debug_info_test
     def test_imp_ivar_type(self):
         """Test that dynamically discovered ivars of type IMP do not crash LLDB"""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target from the debugger.

lldb/test/API/lang/objc/modules-app-update/TestClangModulesAppUpdate.py

 
 import unittest2
 import os
 import shutil
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestClangModuleAppUpdate(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     @skipIf(debug_info=no_match(["gmodules"]))
     def test_rebuild_app_modules_untouched(self):
         with open(self.getBuildArtifact("module.modulemap"), "w") as f:
             f.write("""
                     module Foo { header "f.h" }
                     """)
         with open(self.getBuildArtifact("f.h"), "w") as f:
             f.write("""

lldb/test/API/lang/objc/modules-auto-import/TestModulesAutoImport.py

class ObjCModulesAutoImportTestCase(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.m', '// Set breakpoint 0 here.')
 
-    @skipUnlessDarwin
     @skipIf(macos_version=["<", "10.12"])
     def test_expr(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break inside the foo function which takes a bar_ptr argument.
         lldbutil.run_break_set_by_file_and_line(

lldb/test/API/lang/objc/modules-cache/TestClangModulesCache.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ObjCModulesTestCase(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     def test_expr(self):
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.m")
         self.runCmd("settings set target.auto-import-clang-modules true")
         mod_cache = self.getBuildArtifact("my-clang-modules-cache")
         if os.path.isdir(mod_cache):
           shutil.rmtree(mod_cache)
         self.assertFalse(os.path.isdir(mod_cache),
                          "module cache should not exist")
         self.runCmd('settings set symbols.clang-modules-cache-path "%s"' % mod_cache)
         self.runCmd('settings set target.clang-module-search-paths "%s"'
                     % self.getSourceDir())
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
             self, "Set breakpoint here", self.main_source_file)
         self.runCmd("expr @import Foo")
         self.assertTrue(os.path.isdir(mod_cache), "module cache exists")

lldb/test/API/lang/objc/modules-compile-error/TestModulesCompileError.py

 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     def test(self):
         self.build()
         lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("main.m"))
 
         # Try importing our custom module. This will fail as LLDB won't define
         # the CLANG_ONLY define when it compiles the module for the expression
         # evaluator.
         # Check that the error message shows file/line/column, prints the relevant
         # line from the source code and mentions the module that failed to build.
         self.expect("expr @import LLDBTestModule", error=True,
                     substrs=["module.h:4:1: error: unknown type name 'syntax_error_for_lldb_to_find'",
                              "syntax_error_for_lldb_to_find // comment that tests source printing",
                              "could not build module 'LLDBTestModule'"])

lldb/test/API/lang/objc/modules-hash-mismatch/TestClangModulesHashMismatch.py

 
 import unittest2
 import os
 import shutil
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestClangModuleHashMismatch(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     @skipIf(debug_info=no_match(["gmodules"]))
     def test_expr(self):
         with open(self.getBuildArtifact("module.modulemap"), "w") as f:
             f.write("""
                     module Foo { header "f.h" }
                     """)
         with open(self.getBuildArtifact("f.h"), "w") as f:
             f.write("""

lldb/test/API/lang/objc/modules-incomplete/TestIncompleteModules.py

class IncompleteModulesTestCase(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.m', '// Set breakpoint 0 here.')
 
-    @skipUnlessDarwin
     @skipIf(debug_info=no_match(["gmodules"]))
     def test_expr(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
         lldbutil.run_break_set_by_file_and_line(
             self, "main.m", self.line, num_expected_locations=1, loc_exact=True)
 

lldb/test/API/lang/objc/modules-inline-functions/TestModulesInlineFunctions.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ModulesInlineFunctionsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     @skipIf(macos_version=["<", "10.12"], debug_info=no_match(["gmodules"]))
     def test_expr(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break inside the foo function which takes a bar_ptr argument.
         lldbutil.run_to_source_breakpoint(

lldb/test/API/lang/objc/modules-non-objc-target/TestObjCModulesNonObjCTarget.py

 """
 Tests that importing ObjC modules in a non-ObjC target doesn't crash LLDB.
 """
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     def test(self):
         self.build()
         lldbutil.run_to_source_breakpoint(self,"// break here", lldb.SBFileSpec("main.c"))
 
         # Import foundation to get some ObjC types.
         self.expect("expr --lang objc -- @import Foundation")
         # Do something with NSString (which requires special handling when
         # preparing to run in the target). The expression most likely can't
         # be prepared to run in the target but it should at least not crash LLDB.
         self.expect('expr --lang objc -- [NSString stringWithFormat:@"%d", 1];',
                     error=True,
                     substrs=["Rewriting an Objective-C constant string requires CFStringCreateWithBytes"])

lldb/test/API/lang/objc/modules-update/TestClangModulesUpdate.py

 
 import unittest2
 import os
 import shutil
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestClangModuleUpdate(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     @skipIf(debug_info=no_match(["gmodules"]))
     @skipIfReproducer # VFS is a snapshot.
     def test_expr(self):
         with open(self.getBuildArtifact("module.modulemap"), "w") as f:
             f.write("""
                     module Foo { header "f.h" }
                     """)
         with open(self.getBuildArtifact("f.h"), "w") as f:

lldb/test/API/lang/objc/modules/TestObjCModules.py

class ObjCModulesTestCase(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.m', '// Set breakpoint 0 here.')
 
-    @skipUnlessDarwin
     @skipIf(macos_version=["<", "10.12"])
     @skipIfReproducer # FIXME: Unexpected packet during (active) replay
     def test_expr(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break inside the foo function which takes a bar_ptr argument.

lldb/test/API/lang/objc/objc++/TestObjCXX.py

 """
 Make sure that ivars of Objective-C++ classes are visible in LLDB.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ObjCXXTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     def test_break(self):
         """Test ivars of Objective-C++ classes"""
         if self.getArchitecture() == 'i386':
             self.skipTest("requires Objective-C 2.0 runtime")
 
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_source_regexp(
             self, 'breakpoint 1', num_expected_locations=1)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         self.expect("expr f->f", "Found ivar in class",
                     substrs=["= 3"])

lldb/test/API/lang/objc/objc-baseclass-sbtype/TestObjCBaseClassSBType.py

class ObjCDynamicValueTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
         self.line = line_number('main.m', '// Set breakpoint here.')
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     def test_get_baseclass(self):
         """Test fetching ObjC dynamic values."""
         if self.getArchitecture() == 'i386':
             # rdar://problem/9946499
             self.skipTest("Dynamic types for ObjC V1 runtime not implemented")
 
         self.build()

lldb/test/API/lang/objc/objc-builtin-types/TestObjCBuiltinTypes.py

class TestObjCBuiltinTypes(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "main.cpp"
         self.break_line = line_number(
             self.main_source, '// Set breakpoint here.')
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     #<rdar://problem/10591460> [regression] Can't print ivar value: error: reference to 'id' is ambiguous
     def test_with_python_api(self):
         """Test expression parser respect for ObjC built-in types."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)

lldb/test/API/lang/objc/objc-checker/TestObjCCheckers.py

class ObjCCheckerTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
         # Find the line number to break for main.c.
         self.source_name = 'main.m'
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     def test_objc_checker(self):
         """Test that checkers catch unrecognized selectors"""
         if self.getArchitecture() == 'i386':
             self.skipTest("requires Objective-C 2.0 runtime")
 
         self.build()
         exe = self.getBuildArtifact("a.out")

lldb/test/API/lang/objc/objc-class-method/TestObjCClassMethod.py

class TestObjCClassMethod(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "class.m"
         self.break_line = line_number(
             self.main_source, '// Set breakpoint here.')
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test calling functions in class methods."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/test/API/lang/objc/objc-dyn-sbtype/TestObjCDynamicSBType.py

 """
 Test that we are able to properly report a usable dynamic type
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-@skipUnlessDarwin
 class ObjCDynamicSBTypeTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # We'll use the test method name as the exe_name.

lldb/test/API/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py

def setUp(self):
         self.set_property_line = line_number(
             self.source_name,
             '// This is the line in setProperty, make sure we step to here.')
         self.handle_SourceBase = line_number(
             self.source_name, '// Break here to check dynamic values.')
         self.main_before_setProperty_line = line_number(
             self.source_name, '// Break here to see if we can step into real method.')
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     @expectedFailureDarwin("llvm.org/pr20271 rdar://18684107")
     def test_get_objc_dynamic_vals(self):
         """Test fetching ObjC dynamic values."""
         if self.getArchitecture() == 'i386':
             # rdar://problem/9946499
             self.skipTest("Dynamic types for ObjC V1 runtime not implemented")
 

lldb/test/API/lang/objc/objc-foundation-dictionary-empty/TestNSDictionary0.py

 from lldbsuite.test import lldbinline
-from lldbsuite.test import decorators
 
-lldbinline.MakeInlineTest(
-    __file__, globals(), [decorators.skipUnlessDarwin])
+lldbinline.MakeInlineTest(__file__, globals(), [])

lldb/test/API/lang/objc/objc-ivar-offsets/TestObjCIvarOffsets.py

class TestObjCIvarOffsets(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "main.m"
         self.stop_line = line_number(
             self.main_source, '// Set breakpoint here.')
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test printing ObjC objects that use unbacked properties"""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/test/API/lang/objc/objc-ivar-protocols/TestIvarProtocols.py

 from lldbsuite.test import lldbinline
-from lldbsuite.test import decorators
 
-lldbinline.MakeInlineTest(
-    __file__, globals(), [decorators.skipUnlessDarwin])
+lldbinline.MakeInlineTest(__file__, globals(), [])

lldb/test/API/lang/objc/objc-ivar-stripped/TestObjCIvarStripped.py

class TestObjCIvarStripped(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "main.m"
         self.stop_line = line_number(
             self.main_source, '// Set breakpoint here.')
 
-    @skipUnlessDarwin
     @skipIf(
         debug_info=no_match("dsym"),
         bugnumber="This test requires a stripped binary and a dSYM")
     @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test that we can find stripped Objective-C ivars in the runtime"""
         self.build()
         exe = self.getBuildArtifact("a.out.stripped")

lldb/test/API/lang/objc/objc-new-syntax/TestObjCNewSyntaxArray.py

 """Test that the Objective-C syntax for dictionary/array literals and indexing works"""
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 from ObjCNewSyntaxTest import ObjCNewSyntaxTest
 
 
 class ObjCNewSyntaxTestCaseArray(ObjCNewSyntaxTest):
 
-    @skipUnlessDarwin
     @skipIf(macos_version=["<", "10.12"])
     @expectedFailureAll(archs=["i[3-6]86"])
     def test_read_array(self):
         self.runToBreakpoint()
 
         self.expect(
             "expr --object-description -- immutable_array[0]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["foo"])
 
         self.expect(
             "expr --object-description -- mutable_array[0]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["foo"])
 
-    @skipUnlessDarwin
     @skipIf(macos_version=["<", "10.12"])
     @expectedFailureAll(archs=["i[3-6]86"])
     def test_update_array(self):
         self.runToBreakpoint()
 
         self.expect(
             "expr --object-description -- mutable_array[0] = @\"bar\"",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["bar"])
 
         self.expect(
             "expr --object-description -- mutable_array[0]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["bar"])
 
-    @skipUnlessDarwin
     @skipIf(macos_version=["<", "10.12"])
     @expectedFailureAll(archs=["i[3-6]86"])
     def test_array_literal(self):
         self.runToBreakpoint()
 
         self.expect(
             "expr --object-description -- @[ @\"foo\", @\"bar\" ]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "NSArray",
                 "foo",
                 "bar"])

lldb/test/API/lang/objc/objc-new-syntax/TestObjCNewSyntaxDictionary.py

 """Test that the Objective-C syntax for dictionary/array literals and indexing works"""
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 from ObjCNewSyntaxTest import ObjCNewSyntaxTest
 
 
 class ObjCNewSyntaxTestCaseDictionary(ObjCNewSyntaxTest):
 
-    @skipUnlessDarwin
     @skipIf(macos_version=["<", "10.12"])
     @expectedFailureAll(archs=["i[3-6]86"])
     def test_read_dictionary(self):
         self.runToBreakpoint()
 
         self.expect(
             "expr --object-description -- immutable_dictionary[@\"key\"]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["value"])
 
         self.expect(
             "expr --object-description -- mutable_dictionary[@\"key\"]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["value"])
 
-    @skipUnlessDarwin
     @skipIf(macos_version=["<", "10.12"])
     @expectedFailureAll(archs=["i[3-6]86"])
     def test_update_dictionary(self):
         self.runToBreakpoint()
 
         self.expect(
             "expr --object-description -- mutable_dictionary[@\"key\"] = @\"object\"",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["object"])
 
         self.expect(
             "expr --object-description -- mutable_dictionary[@\"key\"]",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["object"])
 
-    @skipUnlessDarwin
     @skipIf(macos_version=["<", "10.12"])
     @expectedFailureAll(archs=["i[3-6]86"])
     def test_dictionary_literal(self):
         self.runToBreakpoint()
 
         self.expect(
             "expr --object-description -- @{ @\"key\" : @\"object\" }",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "key",
                 "object"])

lldb/test/API/lang/objc/objc-new-syntax/TestObjCNewSyntaxLiteral.py

 """Test that the Objective-C syntax for dictionary/array literals and indexing works"""
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 from ObjCNewSyntaxTest import ObjCNewSyntaxTest
 
 
 class ObjCNewSyntaxTestCaseLiteral(ObjCNewSyntaxTest):
 
-    @skipUnlessDarwin
     @skipIf(macos_version=["<", "10.12"])
     @expectedFailureAll(archs=["i[3-6]86"])
     def test_char_literal(self):
         self.runToBreakpoint()
 
         self.expect("expr --object-description -- @'a'",
                     VARIABLES_DISPLAYED_CORRECTLY, substrs=[str(ord('a'))])
 
-    @skipUnlessDarwin
     @skipIf(macos_version=["<", "10.12"])
     @expectedFailureAll(archs=["i[3-6]86"])
     def test_integer_literals(self):
         self.runToBreakpoint()
 
         self.expect(
             "expr --object-description -- @1",
             VARIABLES_DISPLAYED_CORRECTLY,
def test_integer_literals(self):
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["1"])
 
         self.expect(
             "expr --object-description -- @1ull",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["1"])
 
-    @skipUnlessDarwin
     @skipIf(macos_version=["<", "10.12"])
     @expectedFailureAll(archs=["i[3-6]86"])
     def test_float_literal(self):
         self.runToBreakpoint()
 
         self.expect("expr -- @123.45", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["NSNumber", "123.45"])
 
-    @skipUnlessDarwin
     @skipIf(macos_version=["<", "10.12"])
     @expectedFailureAll(archs=["i[3-6]86"])
     def test_expressions_in_literals(self):
         self.runToBreakpoint()
 
         self.expect(
             "expr --object-description -- @( 1 + 3 )",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=["4"])
         self.expect(
             "expr -- @((char*)\"Hello world\" + 6)",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "NSString",
                 "world"])

lldb/test/API/lang/objc/objc-optimized/TestObjcOptimized.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 # rdar://problem/9087739
 # test failure: objc_optimized does not work for "-C clang -A i386"
 
 
-@skipUnlessDarwin
 class ObjcOptimizedTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     myclass = "MyClass"
     mymethod = "description"
     method_spec = "-[%s %s]" % (myclass, mymethod)
 
     def test_break(self):

lldb/test/API/lang/objc/objc-property/TestObjCProperty.py

class ObjCPropertyTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
         # Find the line number to break for main.c.
         self.source_name = 'main.m'
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     def test_objc_properties(self):
         """Test that expr uses the correct property getters and setters"""
         if self.getArchitecture() == 'i386':
             self.skipTest("requires modern objc runtime")
 
         self.build()
         exe = self.getBuildArtifact("a.out")

lldb/test/API/lang/objc/objc-runtime-ivars/TestRuntimeIvars.py

 from lldbsuite.test import lldbinline
 from lldbsuite.test import decorators
 
 lldbinline.MakeInlineTest(
     __file__, globals(), [
-        decorators.skipUnlessDarwin,
         decorators.skipIf(archs=["i386", "i686"])])

lldb/test/API/lang/objc/objc-static-method-stripped/TestObjCStaticMethodStripped.py

class TestObjCStaticMethodStripped(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "static.m"
         self.break_line = line_number(
             self.main_source, '// Set breakpoint here.')
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     @skipIf(
         debug_info=no_match("dsym"),
         bugnumber="This test requires a stripped binary and a dSYM")
     #<rdar://problem/12042992>
     def test_with_python_api(self):
         """Test calling functions in static methods with a stripped binary."""
         if self.getArchitecture() == 'i386':

lldb/test/API/lang/objc/objc-static-method/TestObjCStaticMethod.py

class TestObjCStaticMethod(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "static.m"
         self.break_line = line_number(
             self.main_source, '// Set breakpoint here.')
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     #<rdar://problem/9745789> "expression" can't call functions in class methods
     def test_with_python_api(self):
         """Test calling functions in static methods."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)

lldb/test/API/lang/objc/objc-stepping/TestObjCStepping.py

def setUp(self):
             self.main_source, '// SourceBase randomMethod start line.')
         self.source_returnsStruct_start_line = line_number(
             self.main_source, '// Source returnsStruct start line.')
         self.sourceBase_returnsStruct_start_line = line_number(
             self.main_source, '// SourceBase returnsStruct start line.')
         self.stepped_past_nil_line = line_number(
             self.main_source, '// Step over nil should stop here.')
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi', 'basic_process'])
     def test_with_python_api(self):
         """Test stepping through ObjC method dispatch in various forms."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/test/API/lang/objc/objc-struct-argument/TestObjCStructArgument.py

class TestObjCStructArgument(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "test.m"
         self.break_line = line_number(
             self.main_source, '// Set breakpoint here.')
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     @skipIf(debug_info=no_match(["gmodules"]), oslist=['ios', 'watchos', 'tvos', 'bridgeos'], archs=['armv7', 'arm64'])  # this test program only builds for ios with -gmodules
     def test_with_python_api(self):
         """Test passing structs to Objective-C methods."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)

lldb/test/API/lang/objc/objc-struct-return/TestObjCStructReturn.py

class TestObjCClassMethod(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "test.m"
         self.break_line = line_number(
             self.main_source, '// Set breakpoint here.')
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test calling functions in class methods."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/test/API/lang/objc/objc-super/TestObjCSuper.py

class TestObjCSuperMethod(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "class.m"
         self.break_line = line_number(
             self.main_source, '// Set breakpoint here.')
 
-    @skipUnlessDarwin
     @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test calling methods on super."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/test/API/lang/objc/objc_direct-methods/TestObjCDirectMethods.py

 from lldbsuite.test import lldbinline
-from lldbsuite.test import decorators
 
 lldbinline.MakeInlineTest(
-    __file__, globals(), [decorators.skipUnlessDarwin])
+    __file__, globals(), [])

lldb/test/API/lang/objc/orderedset/TestOrderedSet.py

 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestOrderedSet(TestBase):
   mydir = TestBase.compute_mydir(__file__)
 
-  @skipUnlessDarwin
   def test_ordered_set(self):
     self.build()
     src_file = "main.m"
     src_file_spec = lldb.SBFileSpec(src_file)
     (target, process, thread, main_breakpoint) = lldbutil.run_to_source_breakpoint(self,
           "break here", src_file_spec, exe_name = "a.out")
     frame = thread.GetSelectedFrame()
     self.expect("expr -d run -- orderedSet", substrs=["3 elements"])
     self.expect("expr -d run -- *orderedSet", substrs=["(int)1", "(int)2", "(int)3"])

lldb/test/API/lang/objc/print-obj/TestPrintObj.py

 """
 Test "print object" where another thread blocks the print object from making progress.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-@skipUnlessDarwin
 class PrintObjTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # My source program.

lldb/test/API/lang/objc/ptr_refs/TestPtrRefsObjC.py

 """
 Test the ptr_refs tool on Darwin with Objective-C
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestPtrRefsObjC(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfAsan # The output looks different under ASAN.
-    @skipUnlessDarwin
     def test_ptr_refs(self):
         """Test the ptr_refs tool on Darwin with Objective-C"""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/test/API/lang/objc/radar-9691614/TestObjCMethodReturningBOOL.py

 """
 Test that objective-c method returning BOOL works correctly.
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-@skipUnlessDarwin
 class MethodReturningBOOLTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # We'll use the test method name as the exe_name.

lldb/test/API/lang/objc/rdar-10967107/TestRdar10967107.py

 """
 Test that CoreFoundation classes CFGregorianDate and CFRange are not improperly uniqued
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-@skipUnlessDarwin
 class Rdar10967107TestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # We'll use the test method name as the exe_name.

lldb/test/API/lang/objc/rdar-11355592/TestRdar11355592.py

 """
 Test that we do not attempt to make a dynamic type for a 'const char*'
 """
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-@skipUnlessDarwin
 class Rdar10967107TestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # We'll use the test method name as the exe_name.

lldb/test/API/lang/objc/rdar-12408181/TestRdar12408181.py

 from lldbsuite.test import lldbutil
 
 
 # TODO: The Jenkins testers on OS X fail running this test because they don't
 # have access to WindowServer so NSWindow doesn't work.  We should disable this
 # test if WindowServer isn't available.
 # Note: Simply applying the @skipIf decorator here confuses the test harness
 # and gives a spurious failure.
-@skipUnlessDarwin
 class Rdar12408181TestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # We'll use the test method name as the exe_name.

lldb/test/API/lang/objc/real-definition/TestRealDefinition.py

 """Test that types defined in shared libraries work correctly."""
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestRealDefinition(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     def test_frame_var_after_stop_at_interface(self):
         """Test that we can find the implementation for an objective C type"""
         if self.getArchitecture() == 'i386':
             self.skipTest("requires modern objc runtime")
         self.build()
         self.common_setup()
 
         line = line_number(
def test_frame_var_after_stop_at_interface(self):
         # This should display correctly.
         self.expect(
             "frame variable foo->_bar->_hidden_ivar",
             VARIABLES_DISPLAYED_CORRECTLY,
             substrs=[
                 "(NSString *)",
                 "foo->_bar->_hidden_ivar = 0x"])
 
-    @skipUnlessDarwin
     def test_frame_var_after_stop_at_implementation(self):
         """Test that we can find the implementation for an objective C type"""
         if self.getArchitecture() == 'i386':
             self.skipTest("requires modern objc runtime")
         self.build()
         self.common_setup()
 
         line = line_number(

lldb/test/API/lang/objc/self/TestObjCSelf.py

 """
 Tests that ObjC member variables are available where they should be.
 """
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ObjCSelfTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     def test_with_run_command(self):
         """Test that the appropriate member variables are available when stopped in Objective-C class and instance methods"""
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         self.set_breakpoint(line_number('main.m', '// breakpoint 1'))
         self.set_breakpoint(line_number('main.m', '// breakpoint 2'))
 

lldb/test/API/lang/objc/single-entry-dictionary/TestObjCSingleEntryDictionary.py

class ObjCSingleEntryDictionaryTestCase(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.m', '// break here')
 
-    @skipUnlessDarwin
     @expectedFailureAll(oslist=['watchos'], bugnumber="rdar://problem/34642736") # bug in NSDictionary formatting on watchos
     def test_single_entry_dict(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Break inside the foo function which takes a bar_ptr argument.
         lldbutil.run_break_set_by_file_and_line(

lldb/test/API/lang/objc/unicode-string/TestUnicodeString.py

 from lldbsuite.test import lldbinline
-from lldbsuite.test import decorators
 
 lldbinline.MakeInlineTest(
-    __file__, globals(), [
-        decorators.skipUnlessDarwin])
+    __file__, globals(), [])

lldb/test/API/lang/objc/variadic_methods/TestVariadicMethods.py

 from lldbsuite.test import lldbinline
-from lldbsuite.test import decorators
 
-lldbinline.MakeInlineTest(
-    __file__, globals(), [decorators.skipUnlessDarwin])
+lldbinline.MakeInlineTest(__file__, globals(), [])

lldb/test/API/lang/objcxx/.categories

+objc

lldb/test/API/lang/objcxx/class-name-clash/TestNameClash.py

 from lldbsuite.test import decorators
 from lldbsuite.test import lldbinline
 
-lldbinline.MakeInlineTest(
-    __file__, globals(), [decorators.skipUnlessDarwin])
+lldbinline.MakeInlineTest(__file__, globals(), [])

lldb/test/API/lang/objcxx/cxx-bridged-po/TestObjCXXBridgedPO.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 import lldbsuite.test.lldbutil as lldbutil
 
 class TestObjCXXBridgedPO(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     def test_bridged_type_po(self):
         self.build()
         lldbutil.run_to_source_breakpoint(
             self, 'break here', lldb.SBFileSpec('main.mm'))
         self.expect('po num',
                     "did not get the Objective-C object description",
                     substrs=['CFNumber', '0x', '42'])
         pointer_val = str(self.frame().FindVariable('num').GetValue())
         self.expect('po '+pointer_val,
                     "did not get the Objective-C object description",
                     substrs=['CFNumber', '0x', '42'])

lldb/test/API/lang/objcxx/hide-runtime-values/TestObjCXXHideRuntimeValues.py

 import lldb
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 import lldbsuite.test.lldbutil as lldbutil
 import unittest2
 
 
 class TestObjCXXHideRuntimeSupportValues(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
     def test_hide_runtime_support_values(self):
         self.build()
         _, process, _, _ = lldbutil.run_to_source_breakpoint(
             self, 'break here', lldb.SBFileSpec('main.mm'))
 
         var_opts = lldb.SBVariablesOptions()
         var_opts.SetIncludeArguments(True)
         var_opts.SetIncludeLocals(True)

lldb/test/API/lang/objcxx/objcxx-ivar-vector/TestIvarVector.py

 from lldbsuite.test import decorators
 from lldbsuite.test import lldbinline
 
-lldbinline.MakeInlineTest(
-    __file__, globals(), [decorators.skipUnlessDarwin])
+lldbinline.MakeInlineTest(__file__, globals(), [])

lldb/test/API/macosx/nslog/.categories

+objc

lldb/test/API/python_api/objc_type/TestObjCType.py

class ObjCSBTypeTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.line = line_number("main.m", '// Break at this line')
 
-    @skipUnlessDarwin
-    @add_test_categories(['pyapi'])
+    @add_test_categories(['objc', 'pyapi'])
     def test(self):
         """Test SBType for ObjC classes."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/test/API/python_api/sbtype_typeclass/TestSBTypeTypeClass.py

 from lldbsuite.test import decorators
 from lldbsuite.test import lldbinline
 
 lldbinline.MakeInlineTest(
     __file__, globals(), [
-        decorators.skipUnlessDarwin,
+        decorators.add_test_categories(["objc"]),
         decorators.expectedFailureAll(
             oslist=['macosx'], archs=['i386'],
             bugnumber='rdar://28656677')])