[WIP][lldb][test] 3 - Add gmodules decorator to API tests

lldb/test/API/commands/expression/import_builtin_fileid/Makefile

+MAKE_GMODULES = YES
 OBJC_SOURCES := main.m
 LD_EXTRAS := -framework Cocoa
 include Makefile.rules

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):
 
     @skipIfDarwinEmbedded
-    @add_test_categories(["gmodules", "objc"])
+    @add_test_categories(["objc"])
+    @gmodules_test
     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/Makefile

+MAKE_GMODULES = YES
 OBJCXX_SOURCES := main.mm util.mm
 
 
 LD_EXTRAS := -framework Foundation
 include Makefile.rules

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):
 
-    @add_test_categories(["gmodules", "objc"])
+    @add_test_categories(["objc"])
+    @gmodules_test
     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):
 
     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')
 
     @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
 

lldb/test/API/commands/expression/top-level/TestTopLevelExprs.py

def run_dummy(self):
             "dummy.cpp",
             self.dummy_line,
             num_expected_locations=1,
             loc_exact=False)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
     @add_test_categories(['pyapi'])
-    @skipIf(debug_info="gmodules")  # not relevant
     @skipIf(oslist=["windows"])  # Error in record layout on Windows
     def test_top_level_expressions(self):
         self.build_and_run()
 
         resultFromCode = self.frame().EvaluateExpression("doTest()").GetValueAsUnsigned()
 
         self.runCmd("kill")
 

lldb/test/API/functionalities/target_var/TestTargetVar.py

 """
 Test that target var can resolve complex DWARF expressions.
 """
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class targetCommandTestCase(TestBase):
 
     @skipUnlessDarwin
     @skipIfDarwinEmbedded           # needs x86_64
-    @skipIf(debug_info="gmodules")  # not relevant
     @skipIf(compiler="clang", compiler_version=['<', '7.0'])
     def testTargetVarExpr(self):
         self.build()
         lldbutil.run_to_name_breakpoint(self, 'main')
         self.expect("target variable i", substrs=['i', '42'])
         self.expect("target variable var", patterns=['\(incomplete \*\) var = 0[xX](0)*dead'])
         self.expect("target variable var[0]", error=True, substrs=["can't find global variable 'var[0]'"])

lldb/test/API/lang/cpp/abi_tag_lookup/TestAbiTagLookup.py

 """
 Test that we can call functions and use types
 annotated (and thus mangled) with ABI tags.
 """
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class AbiTagLookupTestCase(TestBase):
 
     @skipIfWindows
-    @expectedFailureAll(debug_info=["dwarf", "gmodules", "dwo"])
+    @expectedFailureAll(debug_info=["dwarf", "dwo"])
     def test_abi_tag_lookup(self):
         self.build()
         lldbutil.run_to_source_breakpoint(self, 'Break here',
                 lldb.SBFileSpec("main.cpp", False))
 
         # Qualified/unqualified lookup to templates in namespace
         self.expect_expr("operator<(b1, b2)", result_type="bool", result_value="true")
         self.expect_expr("A::operator<(b1, b2)", result_type="bool", result_value="true")

lldb/test/API/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/Makefile

+MAKE_GMODULES = YES
 CXX_SOURCES = main.cpp a.cpp
 CFLAGS_EXTRAS = $(MANDATORY_CXXMODULE_BUILD_CFLAGS)
 
 include Makefile.rules

lldb/test/API/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/TestBreakpointInMemberFuncWNonPrimitiveParams.py

 """
 This is a regression test for an assert that happens while setting a breakpoint.
 The root cause of the assert was attempting to add a ParmVarDecl to a CXXRecordDecl
 when it should have been added to a CXXMethodDecl.
 
 We can reproduce with a module build and setting a breakpoint in a member function
 of a class with a non-primitive type as a parameter.
 """
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class TestBreakpointInMemberFuncWNonPrimitiveParams(TestBase):
 
-    @add_test_categories(["gmodules"])
+    @gmodules_test
     def test_breakpint_in_member_func_w_non_primitie_params(self):
         self.build()
         lldbutil.run_to_source_breakpoint(self, '// break here',
                 lldb.SBFileSpec("main.cpp", False))
 
         self.runCmd("b a.cpp:11");

lldb/test/API/lang/cpp/gmodules/basic/Makefile

+MAKE_GMODULES = YES
 PCH_CXX_SOURCE = pch.h
 CXX_SOURCES = main.cpp
 CFLAGS_EXTRAS := $(MODULE_DEBUG_INFO_FLAGS)
 
 include Makefile.rules

lldb/test/API/lang/cpp/gmodules/basic/TestWithModuleDebugging.py

 import lldb
 import os
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestWithGmodulesDebugInfo(TestBase):
 
     @skipIf(bugnumber="llvm.org/pr36146", oslist=["linux"], archs=["i386"])
-    @add_test_categories(["gmodules"])
+    @gmodules_test
     def test_specialized_typedef_from_pch(self):
         self.build()
 
         src_file = os.path.join(self.getSourceDir(), "main.cpp")
         src_file_spec = lldb.SBFileSpec(src_file)
         self.assertTrue(src_file_spec.IsValid(), "breakpoint file")
 
         # Get the path of the executable

lldb/test/API/lang/cpp/gmodules/template-with-same-arg/Makefile

+MAKE_GMODULES  = YES
 CXX_SOURCES   := main.cpp module1.cpp module2.cpp base_module.cpp
 
 include Makefile.rules

lldb/test/API/lang/cpp/gmodules/template-with-same-arg/TestTemplateWithSameArg.py

 
 class TestTemplateWithSameArg(TestBase):
 
     def setUp(self):
         TestBase.setUp(self)
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.cpp")
 
-    @add_test_categories(["gmodules"])
+    @gmodules_test
     def test_same_template_arg(self):
         lldbutil.run_to_source_breakpoint(self, "Break here", self.main_source_file)
 
         self.expect_expr("FromMod1", result_type="ClassInMod1", result_children=[
                 ValueCheck(name="VecInMod1", children=[
                             ValueCheck(name="Member", value="137")
                     ])
             ])
 
         self.expect_expr("FromMod2", result_type="ClassInMod2", result_children=[
                 ValueCheck(name="VecInMod2", children=[
                             ValueCheck(name="Member", value="42")
                     ])
             ])
 
-    @add_test_categories(["gmodules"])
+    @gmodules_test
     def test_duplicate_decls(self):
         lldbutil.run_to_source_breakpoint(self, "Break here", self.main_source_file)
 
         self.expect_expr("(intptr_t)&FromMod1 + (intptr_t)&FromMod2")
 
         # Make sure we only have a single 'Member' decl on the AST
         self.filecheck("target module dump ast", __file__)
 # CHECK:      ClassTemplateSpecializationDecl {{.*}} imported in Module2 struct ClassInMod3 definition

lldb/test/API/lang/cpp/template-function/TestTemplateFunctions.py

def do_test_template_function(self, add_cast):
           self.expect_expr("d1 << d2", result_type="bool", result_value="true")
           self.expect_expr("d1 == d2", result_type="bool", result_value="true")
 
     @skipIfWindows
     def test_template_function_with_cast(self):
         self.do_test_template_function(True)
 
     @skipIfWindows
-    @expectedFailureAll(debug_info=["dwarf", "gmodules", "dwo"])
+    @expectedFailureAll(debug_info=["dwarf", "dwo"])
     def test_template_function_without_cast(self):
         self.do_test_template_function(False)

lldb/test/API/lang/objc/modules-app-update/Makefile

+MAKE_GMODULES = YES
 CFLAGS_EXTRAS = -I$(BUILDDIR)
 USE_PRIVATE_MODULE_CACHE := YES
 OBJC_SOURCES := main.m foo.m
 
 include Makefile.rules

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

 
 import os
 import shutil
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestClangModuleAppUpdate(TestBase):
 
-    @skipIf(debug_info=no_match(["gmodules"]))
+    @gmodules_test
     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("""
                     @import ObjectiveC;

lldb/test/API/lang/objc/modules-hash-mismatch/Makefile

+MAKE_GMODULES = YES
 OBJC_SOURCES := main.m
 CFLAGS_EXTRAS = -I$(BUILDDIR)
 USE_PRIVATE_MODULE_CACHE = YES
 
 .PHONY: update-module
 
 all: $(EXE)
   $(MAKE) -f $(SRCDIR)/Makefile update-module
 
 include Makefile.rules
 
 update-module:
   echo "forcing an update of f.pcm"
   echo "typedef int something_other;" > $(BUILDDIR)/f.h
   $(CC) $(CFLAGS) $(MANDATORY_MODULE_BUILD_CFLAGS) \
     -c $(SRCDIR)/other.m -o $(BUILDDIR)/other.o

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

 
 import os
 import shutil
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestClangModuleHashMismatch(TestBase):
 
-    @skipIf(debug_info=no_match(["gmodules"]))
+    @gmodules_test
     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("""
                     typedef int my_int;

lldb/test/API/lang/objc/modules-incomplete/Makefile

+MAKE_GMODULES = YES
 OBJC_SOURCES := main.m myModule.m
 
 CFLAGS_EXTRAS = $(MANDATORY_MODULE_BUILD_CFLAGS)
 LD_EXTRAS := -framework Foundation
 include Makefile.rules

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

 class IncompleteModulesTestCase(TestBase):
 
     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.')
 
-    @skipIf(debug_info=no_match(["gmodules"]))
+    @gmodules_test
     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)
 
         self.runCmd("run", RUN_SUCCEEDED)

lldb/test/API/lang/objc/modules-inline-functions/Makefile

+MAKE_GMODULES = YES
 C_SOURCES := myModule.c
 
 OBJC_SOURCES := main.m
 
 CFLAGS_EXTRAS = $(MANDATORY_MODULE_BUILD_CFLAGS) -I$(BUILDDIR)
 
 include Makefile.rules

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

 """Test that inline functions from modules are imported correctly"""
 
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ModulesInlineFunctionsTestCase(TestBase):
 
-    @skipIf(macos_version=["<", "10.12"], debug_info=no_match(["gmodules"]))
+    @skipIf(macos_version=["<", "10.12"])
+    @gmodules_test
     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(
             self, '// Set breakpoint here.', lldb.SBFileSpec('main.m'))

lldb/test/API/lang/objc/modules-update/Makefile

+MAKE_GMODULES = YES
 CFLAGS_EXTRAS = -I$(BUILDDIR)
 USE_PRIVATE_MODULE_CACHE = YES
 include Makefile.rules

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

 
 import os
 import shutil
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestClangModuleUpdate(TestBase):
 
-    @skipIf(debug_info=no_match(["gmodules"]))
+    @gmodules_test
     @skipIfDarwin # rdar://76540904
     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/objc-struct-argument/Makefile

+MAKE_GMODULES = YES
 OBJC_SOURCES := test.m
 LD_EXTRAS := -lobjc -framework Foundation
 
 include Makefile.rules

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

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.')
 
     @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
+    @gmodules_test
     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)
         self.assertTrue(target, VALID_TARGET)