[lldb][Test] Check compiler in data formatter compiler version checks

[Michael137]

Summary

Summary

The compiler version check wouldn't make sense for non-GCC
compilers, so check for the compiler too.

[Michael137]

Fixes condition introduced in https://reviews.llvm.org/D141828

lldb/test/API/commands/expression/import-std-module/deque-basic/TestDequeFromStdModule.py

def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 
         self.runCmd("settings set target.import-std-module true")
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             deque_type = "std::deque<int>"
         else:
             deque_type = "std::deque<int, std::allocator<int> >"
 
         size_type = "size_type"
         value_type = "value_type"
         iterator = "iterator"
         iterator_children = [

lldb/test/API/commands/expression/import-std-module/deque-dbg-info-content/TestDbgInfoContentDequeFromStdModule.py

def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 
         self.runCmd("settings set target.import-std-module true")
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             deque_type = "std::deque<Foo>"
         else:
             deque_type = "std::deque<Foo, std::allocator<Foo> >"
 
         size_type = "size_type"
         value_type = "value_type"
 
         iterator_type = "iterator"

lldb/test/API/commands/expression/import-std-module/forward_list-dbg-info-content/TestDbgInfoContentForwardListFromStdModule.py

def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 
         self.runCmd("settings set target.import-std-module true")
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             list_type = "std::forward_list<Foo>"
         else:
             list_type = "std::forward_list<Foo, std::allocator<Foo> >"
 
         value_type = "value_type"
 
         # FIXME: This has three elements in it but the formatter seems to
         # calculate the wrong size and contents.
         self.expect_expr("a", result_type=list_type, result_summary="size=1")
         self.expect_expr("std::distance(a.begin(), a.end())", result_value="3")
         self.expect_expr("a.front().a", result_type="int", result_value="3")
         self.expect_expr("a.begin()->a", result_type="int", result_value="3")

lldb/test/API/commands/expression/import-std-module/forward_list/TestForwardListFromStdModule.py

def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 
         self.runCmd("settings set target.import-std-module true")
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             list_type = "std::forward_list<int>"
         else:
             list_type = "std::forward_list<int, std::allocator<int> >"
 
         value_type = "value_type"
 
         # FIXME: This has three elements in it but the formatter seems to
         # calculate the wrong size and contents.

lldb/test/API/commands/expression/import-std-module/list-dbg-info-content/TestDbgInfoContentListFromStdModule.py

def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 
         self.runCmd("settings set target.import-std-module true")
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             list_type = "std::list<Foo>"
         else:
             list_type = "std::list<Foo, std::allocator<Foo> >"
 
         size_type = "size_type"
         value_type = "value_type"
 
         self.expect_expr("a",

lldb/test/API/commands/expression/import-std-module/list/TestListFromStdModule.py

def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 
         self.runCmd("settings set target.import-std-module true")
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             list_type = "std::list<int>"
         else:
             list_type = "std::list<int, std::allocator<int> >"
 
         size_type = "size_type"
         value_type = "value_type"
 
         iteratorvalue = "value_type"

lldb/test/API/commands/expression/import-std-module/non-module-type-separation/TestNonModuleTypeSeparation.py

def test(self):
                                           lldb.SBFileSpec("main.cpp"))
 
         children = [
             ValueCheck(value="3"),
             ValueCheck(value="1"),
             ValueCheck(value="2"),
         ]
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             vector_type = "std::vector<int>"
             dbg_vec_type = "std::vector<DbgInfoClass>"
             module_vector_type = "std::vector<int>"
         else:
             vector_type = "std::vector<int, std::allocator<int> >"
             dbg_vec_type = "std::vector<DbgInfoClass, std::allocator<DbgInfoClass> >"
             module_vector_type = "std::vector<int>"
 

lldb/test/API/commands/expression/import-std-module/queue/TestQueueFromStdModule.py

def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 
         self.runCmd("settings set target.import-std-module true")
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             queue_type = "std::queue<C>"
         else:
             queue_type = "std::queue<C, std::deque<C, std::allocator<C> > >"
 
         size_type = "size_type"
         value_type = "value_type"
 
         # Test std::queue functionality with a std::deque.
def test(self):
                          result_value="false")
         self.expect("expr q_deque.pop()")
         self.expect("expr q_deque.emplace(5)")
         self.expect_expr("q_deque.front().i",
                          result_type="int",
                          result_value="5")
 
         # Test std::queue functionality with a std::list.
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             queue_type = "std::queue<C, std::list<C> >"
         else:
             queue_type = "std::queue<C, std::list<C, std::allocator<C> > >"
 
         self.expect_expr(
             "q_list",
             result_type=queue_type,
             result_children=[ValueCheck(children=[ValueCheck(value="1")])])

lldb/test/API/commands/expression/import-std-module/retry-with-std-module/TestRetryWithStdModule.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestCase(TestBase):
 
     @add_test_categories(["libc++"])
     @skipIf(compiler=no_match("clang"))
     def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             vec_type = "std::vector<int>"
         else:
             vec_type = "std::vector<int, std::allocator<int> >"
 
         # Test printing the vector before enabling any C++ module setting.
         self.expect_expr("a", result_type=vec_type)
 
         # Set loading the import-std-module to 'fallback' which loads the module

lldb/test/API/commands/expression/import-std-module/unique_ptr-dbg-info-content/TestUniquePtrDbgInfoContent.py

def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 
         self.runCmd("settings set target.import-std-module true")
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             ptr_type = "std::unique_ptr<Foo>"
         else:
             ptr_type = "std::unique_ptr<Foo, std::default_delete<Foo> >"
 
         self.expect_expr(
             "s",
             result_type=ptr_type,
             result_children=[ValueCheck(children=[ValueCheck(value="3")])])
         self.expect_expr("s->a", result_type="int", result_value="3")
         self.expect_expr("s->a = 5", result_type="int", result_value="5")
         self.expect_expr("(int)s->a", result_type="int", result_value="5")
         self.expect_expr("(bool)s", result_type="bool", result_value="true")
         self.expect("expr s.reset()")
         self.expect_expr("(bool)s", result_type="bool", result_value="false")

lldb/test/API/commands/expression/import-std-module/unique_ptr/TestUniquePtrFromStdModule.py

def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 
         self.runCmd("settings set target.import-std-module true")
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             ptr_type = "std::unique_ptr<int>"
         else:
             ptr_type = "std::unique_ptr<int, std::default_delete<int> >"
 
         self.expect_expr(
             "s",
             result_type=ptr_type,
             result_summary="3",
             result_children=[ValueCheck(name="__value_")])
         self.expect_expr("*s", result_type="int", result_value="3")
         self.expect_expr("*s = 5", result_type="int", result_value="5")
         self.expect_expr("*s", result_type="int", result_value="5")
         self.expect_expr("(bool)s", result_type="bool", result_value="true")
         self.expect("expr s.reset()")
         self.expect_expr("(bool)s", result_type="bool", result_value="false")

lldb/test/API/commands/expression/import-std-module/vector-dbg-info-content/TestDbgInfoContentVectorFromStdModule.py

def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 
         self.runCmd("settings set target.import-std-module true")
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             vector_type = "std::vector<Foo>"
         else:
             vector_type = "std::vector<Foo, std::allocator<Foo> >"
 
         size_type = "size_type"
         value_type = "value_type"
         iterator = "iterator"
         # LLDB's formatter provides us with a artificial 'item' member.

lldb/test/API/commands/expression/import-std-module/vector-of-vectors/TestVectorOfVectorsFromStdModule.py

class TestVectorOfVectors(TestBase):
     @skipIf(compiler=no_match("clang"))
     def test(self):
         self.build()
 
         lldbutil.run_to_source_breakpoint(self,
                                           "// Set break point at this line.",
                                           lldb.SBFileSpec("main.cpp"))
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             vector_type = "std::vector<int>"
             vector_of_vector_type = "std::vector<std::vector<int> >"
         else:
             vector_type = "std::vector<int>"
             vector_of_vector_type = "std::vector<std::vector<int>, std::allocator<std::vector<int> > >"
 
         size_type = "size_type"
         value_type = "value_type"

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/shared_ptr/TestDataFormatterLibcxxSharedPtr.py

def test_shared_ptr_variables(self):
         valobj = self.expect_var_path(
             "sp_int_ref_ref",
             type="std::shared_ptr<int> &&",
             children=[ValueCheck(name="__ptr_")],
         )
         self.assertRegex(valobj.summary, r"^10( strong=1)? weak=1$")
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             string_type = "std::basic_string<char>"
         else:
             string_type = "std::basic_string<char, std::char_traits<char>, std::allocator<char> >"
 
         valobj = self.expect_var_path(
             "sp_str",
             type="std::shared_ptr<" + string_type + " >",
             children=[ValueCheck(name="__ptr_", summary='"hello"')],

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/string/TestDataFormatterLibcxxString.py

def test_with_run_command(self):
 
         is_64_bit = self.process().GetAddressByteSize() == 8
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
 
         ns = self.namespace
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             expected_basic_string = '%s::basic_string<unsigned char>'%ns
         else:
             expected_basic_string = '%s::basic_string<unsigned char, %s::char_traits<unsigned char>, ' \
                                     '%s::allocator<unsigned char> >'%(ns,ns,ns)
 
         self.expect(
             "frame variable",
             substrs=[

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/string_view/TestDataFormatterLibcxxStringView.py

def test_with_run_command(self):
             self.runCmd('type synth clear', check=False)
             self.runCmd(
                 "settings set target.max-children-count 256",
                 check=False)
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             expected_basic_string = 'std::basic_string<unsigned char>'
             expected_basic_string_view = 'std::basic_string_view<unsigned char>'
         else:
             expected_basic_string = 'std::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char> >'
             expected_basic_string_view = 'std::basic_string_view<unsigned char, std::char_traits<unsigned char> >'
 
         self.expect_var_path('wempty',
                              type='std::wstring_view',

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/unique_ptr/TestDataFormatterLibcxxUniquePtr.py

 
 
 class TestCase(TestBase):
 
     def make_expected_type(self, pointee_type: str, qualifiers: str = "") -> str:
         if qualifiers:
             qualifiers = ' ' + qualifiers
 
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             return f'std::unique_ptr<{pointee_type}>{qualifiers}'
         else:
             return f'std::unique_ptr<{pointee_type}, std::default_delete<{pointee_type}> >{qualifiers}'
 
     def make_expected_basic_string_ptr(self) -> str:
-        if self.expectedCompilerVersion(['>', '16.0']):
+        if self.expectedCompiler(["clang"]) and self.expectedCompilerVersion(['>', '16.0']):
             return f'std::unique_ptr<std::basic_string<char> >'
         else:
             return 'std::unique_ptr<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, ' \
                    'std::default_delete<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >'
 
     @add_test_categories(["libc++"])
     def test_unique_ptr_variables(self):
         """Test `frame variable` output for `std::unique_ptr` types."""