[lldb][Test] Fix import-std-module and data-formatter tests on older compilers

[Michael137]

Summary

Fixes API tests for older compilers.
Since https://reviews.llvm.org/D141828 defaulted
arguments will be omitted, but older Clang's won't.

[Michael137]

• Defined missing variable

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']):
             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 = [
             ValueCheck(name="__m_iter_"),
             ValueCheck(name="__ptr_")
         ]
         riterator = "reverse_iterator"

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']):
             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"
         iterator_children = [
             ValueCheck(name="__m_iter_"),
             ValueCheck(name="__ptr_")
         ]

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']):
             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']):
             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.
         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()", result_type=value_type, result_value="3")
 
         self.expect("expr a.sort()")
         self.expect_expr("a.front()", result_type=value_type, result_value="1")
 
         # FIXME: Removing casting here causes LLDB to crash.
         self.expect_expr("(int)*a.begin()",
                          result_type="int",
                          result_value="1")

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']):
             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",
                          result_type=list_type,
                          result_children=[
                              ValueCheck(children=[ValueCheck(value="3")]),
                              ValueCheck(children=[ValueCheck(value="1")]),

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']):
             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"
         riterator_value = "value_type"
 
         self.expect_expr("a",
                          result_type=list_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']):
             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>"
 
         # First muddy the scratch AST with non-C++ module types.
         self.expect_expr("a", result_type=vector_type,
                          result_children=children)
         self.expect_expr("dbg_info_vec",
-                         result_type="std::vector<DbgInfoClass>",
+                         result_type=dbg_vec_type,
                          result_children=[
             ValueCheck(type="DbgInfoClass", children=[
                 ValueCheck(name="ints", type=vector_type, children=[
                     ValueCheck(value="1")
                 ])
             ])
         ])
 
         # Enable the C++ module import and get the module vector type.
         self.runCmd("settings set target.import-std-module true")
-        self.expect_expr("a", result_type=vector_type,
+        self.expect_expr("a", result_type=module_vector_type,
                          result_children=children)
 
         # Test mixed debug info/module types
         self.expect_expr("dbg_info_vec",
-                         result_type="std::vector<DbgInfoClass>",
+                         result_type=dbg_vec_type,
                          result_children=[
             ValueCheck(type="DbgInfoClass", children=[
-                ValueCheck(name="ints", type=vector_type, children=[
+                ValueCheck(name="ints", type=module_vector_type, children=[
                     ValueCheck(value="1")
                 ])
             ])
         ])
 
 
         # Turn off the C++ module import and use debug info types again.
         self.runCmd("settings set target.import-std-module false")
         self.expect_expr("a", result_type=vector_type,
                          result_children=children)
 
         # Test the types that were previoiusly mixed debug info/module types.
         self.expect_expr("dbg_info_vec",
-                         result_type="std::vector<DbgInfoClass>",
+                         result_type=dbg_vec_type,
                          result_children=[
             ValueCheck(type="DbgInfoClass", children=[
                 ValueCheck(name="ints", type=vector_type, children=[
                     ValueCheck(value="1")
                 ])
             ])
         ])

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']):
             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.
         self.expect_expr(
             "q_deque",
             result_type=queue_type,
             result_children=[ValueCheck(children=[ValueCheck(value="1")])])
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']):
             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")])])
 
         self.expect("expr q_list.pop()")
         self.expect("expr q_list.push({4})")
         self.expect_expr("q_list.size()",

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']):
+            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="std::vector<int>")
+        self.expect_expr("a", result_type=vec_type)
 
         # Set loading the import-std-module to 'fallback' which loads the module
         # and retries when an expression fails to parse.
         self.runCmd("settings set target.import-std-module fallback")
 
         # Printing the vector still works. This should return the same type
         # as before as this shouldn't use a C++ module type.
-        self.expect_expr("a", result_type="std::vector<int>")
+        self.expect_expr("a", result_type=vec_type)
 
         # This expression can only parse with a C++ module. LLDB should
         # automatically fall back to import the C++ module to get this working.
         self.expect_expr("std::max<std::size_t>(0U, a.size())", result_value="3")
 
 
         # The 'a' and 'local' part can be parsed without loading a C++ module and will
         # load type/runtime information. The 'std::max...' part will fail to

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']):
+            ptr_type = "std::unique_ptr<Foo>"
+        else:
+            ptr_type = "std::unique_ptr<Foo, std::default_delete<Foo> >"
+
         self.expect_expr(
             "s",
-            result_type="std::unique_ptr<Foo>",
+            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']):
+            ptr_type = "std::unique_ptr<int>"
+        else:
+            ptr_type = "std::unique_ptr<int, std::default_delete<int> >"
+
         self.expect_expr(
             "s",
-            result_type="std::unique_ptr<int>",
+            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']):
             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.
         iterator_children = [ValueCheck(name="item")]
         riterator = "reverse_iterator"
         riterator_children = [
             ValueCheck(), # Deprecated __t_ member; no need to check

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']):
             vector_type = "std::vector<int>"
-        vector_of_vector_type = "std::vector<" + vector_type + " >"
+        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"
 
         self.runCmd("settings set target.import-std-module true")
 
         self.expect_expr(
             "a",
             result_type=vector_of_vector_type,
             result_children=[
-                ValueCheck(type="std::vector<int>",
+                ValueCheck(type=vector_type,
                            children=[
                                ValueCheck(value='1'),
                                ValueCheck(value='2'),
                                ValueCheck(value='3'),
                            ]),
-                ValueCheck(type="std::vector<int>",
+                ValueCheck(type=vector_type,
                            children=[
                                ValueCheck(value='3'),
                                ValueCheck(value='2'),
                                ValueCheck(value='1'),
                            ]),
             ])
         self.expect_expr("a.size()", result_type=size_type, result_value="2")
         front = self.expect_expr("a.front().front()", result_type=value_type,
                                  result_value="1")
         self.expect_expr("a[1][1]", result_type=value_type, result_value="2")
         self.expect_expr("a.back().at(0)",
                          result_type=value_type,
                          result_value="3")

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']):
+            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<std::basic_string<char> >",
+            type="std::shared_ptr<" + string_type + " >",
             children=[ValueCheck(name="__ptr_", summary='"hello"')],
         )
         self.assertRegex(valobj.summary, r'^"hello"( strong=1)? weak=1$')
 
         valobj = self.expect_var_path("sp_user", type="std::shared_ptr<User>")
         self.assertRegex(
             valobj.summary,
             "^std(::__[^:]*)?::shared_ptr<User>::element_type @ 0x0*[1-9a-f][0-9a-f]+( strong=1)? weak=1",

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

def test_with_run_command(self):
                 check=False)
 
         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']):
+            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=[
                 '(%s::wstring) wempty = L""'%ns,
                 '(%s::wstring) s = L"hello world! מזל טוב!"'%ns,
                 '(%s::wstring) S = L"!!!!"'%ns,
                 '(const wchar_t *) mazeltov = 0x',
                 'L"מזל טוב"',
                 '(%s::string) empty = ""'%ns,
                 '(%s::string) q = "hello world"'%ns,
                 '(%s::string) Q = "quite a long std::strin with lots of info inside it"'%ns,
                 '(%s::string) IHaveEmbeddedZeros = "a\\0b\\0c\\0d"'%ns,
                 '(%s::wstring) IHaveEmbeddedZerosToo = L"hello world!\\0てざ ル゜䋨ミ㠧槊 きゅへ狦穤襩 じゃ馩リョ 䤦監"'%ns,
                 '(%s::u16string) u16_string = u"ß水氶"'%ns,
                 # FIXME: This should have a 'u' prefix.
                 '(%s::u16string) u16_empty = ""'%ns,
                 '(%s::u32string) u32_string = U"🍄🍅🍆🍌"'%ns,
                 # FIXME: This should have a 'U' prefix.
                 '(%s::u32string) u32_empty = ""'%ns,
-                '(%s::basic_string<unsigned char>) uchar = "aaaaa"'%(ns),
+                '(%s) uchar = "aaaaa"'%expected_basic_string,
                 '(%s::string *) null_str = nullptr'%ns,
         ])
 
         thread.StepOver()
 
         TheVeryLongOne = frame.FindVariable("TheVeryLongOne")
         summaryOptions = lldb.SBTypeSummaryOptions()
         summaryOptions.SetCapping(lldb.eTypeSummaryUncapped)
def test_with_run_command(self):
                 'L"מזל טוב"',
                 '(%s::string) q = "hello world"'%ns,
                 '(%s::string) Q = "quite a long std::strin with lots of info inside it"'%ns,
                 '(%s::string) IHaveEmbeddedZeros = "a\\0b\\0c\\0d"'%ns,
                 '(%s::wstring) IHaveEmbeddedZerosToo = L"hello world!\\0てざ ル゜䋨ミ㠧槊 きゅへ狦穤襩 じゃ馩リョ 䤦監"'%ns,
                 '(%s::u16string) u16_string = u"ß水氶"'%ns,
                 '(%s::u32string) u32_string = U"🍄🍅🍆🍌"'%ns,
                 '(%s::u32string) u32_empty = ""'%ns,
-                '(%s::basic_string<unsigned char>) uchar = "aaaaa"'%(ns),
+                '(%s) uchar = "aaaaa"'%expected_basic_string,
                 '(%s::string *) null_str = nullptr'%ns,
         ])
 
         # The test assumes that std::string is in its cap-size-data layout.
         is_alternate_layout = ('arm' in self.getArchitecture()) and self.platformIsDarwin()
         if is_64_bit and not is_alternate_layout:
             self.expect("frame variable garbage1", substrs=['garbage1 = Summary Unavailable'])
             self.expect("frame variable garbage2", substrs=[r'garbage2 = "\xfa\xfa\xfa\xfa"'])

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']):
+            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',
                              summary='L""')
         self.expect_var_path('s',
                              type='std::wstring_view',
                              summary='L"hello world! מזל טוב!"')
         self.expect_var_path('S',
                              type='std::wstring_view',
def test_with_run_command(self):
                              summary='""')
         self.expect_var_path('u32_string',
                              type='std::u32string_view',
                              summary='U"🍄🍅🍆🍌"')
         self.expect_var_path('u32_empty',
                              type='std::u32string_view',
                              summary='""')
         self.expect_var_path('uchar_source',
-                             type='std::basic_string<unsigned char>',
+                             type=expected_basic_string,
                              summary='"aaaaaaaaaa"')
         self.expect_var_path('uchar',
-                             type='std::basic_string_view<unsigned char>',
+                             type=expected_basic_string_view,
                              summary='"aaaaa"')
         self.expect_var_path('oops',
                              type='std::string_view',
                              summary='"Hellooo World\\n"')
 
         # GetSummary returns None so can't be checked by expect_var_path, so we
         # use the str representation instead
         null_obj = self.frame().GetValueForVariablePath('null_str')
def test_with_run_command(self):
                              summary='""')
         self.expect_var_path('u32_string',
                              type='std::u32string_view',
                              summary='U"🍄🍅🍆🍌"')
         self.expect_var_path('u32_empty',
                              type='std::u32string_view',
                              summary='""')
         self.expect_var_path('uchar_source',
-                             type='std::basic_string<unsigned char>',
+                             type=expected_basic_string,
                              summary='"aaaaaaaaaa"')
         self.expect_var_path('uchar',
-                             type='std::basic_string_view<unsigned char>',
+                             type=expected_basic_string_view,
                              summary='"aaaaa"')
  
         self.runCmd('cont')
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         broken_obj = self.frame().GetValueForVariablePath('in_str_view')
         self.assertEqual( broken_obj.GetSummary(), "Summary Unavailable" )

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

 """
 Test lldb data formatter for libc++ std::unique_ptr.
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestCase(TestBase):
 
+    def make_expected_type(self, pointee_type: str, qualifiers: str = "") -> str:
+        if qualifiers:
+            qualifiers = ' ' + qualifiers
+
+        if 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']):
+            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."""
         self.build()
 
         lldbutil.run_to_source_breakpoint(
             self, "// break here", lldb.SBFileSpec("main.cpp")
         )
 
         valobj = self.expect_var_path(
             "up_empty",
-            type="std::unique_ptr<int>",
+            type=self.make_expected_type("int"),
             summary="nullptr",
             children=[ValueCheck(name="__value_")],
         )
         self.assertEqual(
             valobj.child[0].GetValueAsUnsigned(lldb.LLDB_INVALID_ADDRESS), 0
         )
 
         self.expect(
             "frame variable *up_empty", substrs=["(int) *up_empty = <parent is NULL>"]
         )
 
         valobj = self.expect_var_path(
             "up_int",
-            type="std::unique_ptr<int>",
+            type=self.make_expected_type("int"),
             summary="10",
             children=[ValueCheck(name="__value_")],
         )
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
         valobj = self.expect_var_path(
             "up_int_ref",
-            type="std::unique_ptr<int> &",
+            type=self.make_expected_type("int", qualifiers="&"),
             summary="10",
             children=[ValueCheck(name="__value_")],
         )
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
         valobj = self.expect_var_path(
             "up_int_ref_ref",
-            type="std::unique_ptr<int> &&",
+            type=self.make_expected_type("int", qualifiers="&&"),
             summary="10",
             children=[ValueCheck(name="__value_")],
         )
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
         valobj = self.expect_var_path(
             "up_str",
-            type="std::unique_ptr<std::basic_string<char> >",
+            type=self.make_expected_basic_string_ptr(),
             summary='"hello"',
             children=[ValueCheck(name="__value_", summary='"hello"')],
         )
 
         valobj = self.expect_var_path(
-            "up_user", type="std::unique_ptr<User>"
+            "up_user", type=self.make_expected_type("User")
         )
         self.assertRegex(valobj.summary, "^User @ 0x0*[1-9a-f][0-9a-f]+$")
         self.assertNotEqual(valobj.child[0].unsigned, 0)
 
         valobj = self.expect_var_path(
             "*up_user",
             type="User",
             children=[
                 ValueCheck(name="id", value="30"),
                 ValueCheck(name="name", summary='"steph"'),
             ],
         )
         self.assertEqual(str(valobj), '(User) *__value_ = (id = 30, name = "steph")')
 
         self.expect_var_path("up_user->id", type="int", value="30")
         self.expect_var_path("up_user->name", type="std::string", summary='"steph"')