[gcc r16-267] libstdc++: centralize and improve testing of shared_ptr/weak_ptr conversions

[Giuseppe D'Angelo]

https://gcc.gnu.org/g:0416ac5ae0a97b09b8d4ab6617ae1c7802d2aa7f

commit r16-267-g0416ac5ae0a97b09b8d4ab6617ae1c7802d2aa7f
Author: Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
Date:   Sat Mar 15 16:04:45 2025 +0100

    libstdc++: centralize and improve testing of shared_ptr/weak_ptr conversions
    
    Since the conversions are under the same constraints, centralize the
    test in one file instead of two, testing both smart pointer classes, to
    ease future maintenance. This is used right away: more tests are added.
    Amends r15-8048-gdf0e6509bf7442.
    
    libstdc++-v3/ChangeLog:
    
            * testsuite/20_util/shared_ptr/requirements/1.cc: Test both
            shared_ptr and weak_ptr.
            Add more tests.
            * testsuite/20_util/weak_ptr/requirements/1.cc: Removed as
            superseded by the other test.
    
    Signed-off-by: Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>

Diff:
---
 .../testsuite/20_util/shared_ptr/requirements/1.cc | 111 +++++++++++++++++++--
 .../testsuite/20_util/weak_ptr/requirements/1.cc   |  33 ------
 2 files changed, 101 insertions(+), 43 deletions(-)

diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/requirements/1.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/requirements/1.cc
index 8ddb5d220ac7..19090d1e860a 100644
--- a/libstdc++-v3/testsuite/20_util/shared_ptr/requirements/1.cc
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/requirements/1.cc
@@ -3,31 +3,122 @@
 
 #include <memory>
 #include <testsuite_tr1.h>
+#include <type_traits>
 
 using namespace __gnu_test;
 
+template<template<class> class SmartPtr>
 void
 test01()
 {
-  std::shared_ptr<ClassType> ptr;
-  std::shared_ptr<const ClassType> ptr2 = ptr;
+  SmartPtr<ClassType> ptr;
+  SmartPtr<const ClassType> ptr2 = ptr;
 
 #if __cpp_lib_shared_ptr_arrays >= 201611L
-  std::shared_ptr<ClassType[10]> ptr_array;
-  std::shared_ptr<ClassType[]> ptr_array2 = ptr_array;
-  std::shared_ptr<ClassType const []> ptr_array3 = ptr_array;
+  SmartPtr<ClassType[10]> ptr_array;
+  SmartPtr<ClassType[]> ptr_array2 = ptr_array;
+  SmartPtr<ClassType const []> ptr_array3 = ptr_array;
 #endif
 }
 
+template<template<class> class SmartPtr>
 void
 test02()
 {
-  std::shared_ptr<IncompleteClass> ptr;
-  std::shared_ptr<const IncompleteClass> ptr2 = ptr;
+  SmartPtr<IncompleteClass> ptr;
+  SmartPtr<const IncompleteClass> ptr2 = ptr;
 
 #if __cpp_lib_shared_ptr_arrays >= 201611L
-  std::shared_ptr<IncompleteClass[10]> ptr_array;
-  std::shared_ptr<IncompleteClass[]> ptr_array2 = ptr_array;
-  std::shared_ptr<IncompleteClass const []> ptr_array3 = ptr_array;
+  SmartPtr<IncompleteClass[10]> ptr_array;
+  SmartPtr<IncompleteClass[]> ptr_array2 = ptr_array;
+  SmartPtr<IncompleteClass const []> ptr_array3 = ptr_array;
 #endif
 }
+
+template<template<class> class SmartPtr>
+void
+test03()
+{
+  static_assert( std::is_convertible<SmartPtr<int>, SmartPtr<const int>>::value);
+  static_assert(!std::is_convertible<SmartPtr<const int>, SmartPtr<int>>::value);
+  static_assert( std::is_convertible<SmartPtr<ClassType>, SmartPtr<const ClassType>>::value);
+  static_assert(!std::is_convertible<SmartPtr<const ClassType>, SmartPtr<ClassType>>::value);
+  static_assert( std::is_convertible<SmartPtr<IncompleteClass>, SmartPtr<const IncompleteClass>>::value);
+  static_assert(!std::is_convertible<SmartPtr<const IncompleteClass>, SmartPtr<IncompleteClass>>::value);
+  static_assert( std::is_convertible<SmartPtr<void>, SmartPtr<const void>>::value);
+  static_assert(!std::is_convertible<SmartPtr<const void>, SmartPtr<void>>::value);
+
+  static_assert( std::is_convertible<SmartPtr<int>, SmartPtr<void>>::value);
+  static_assert(!std::is_convertible<SmartPtr<void>, SmartPtr<int>>::value);
+  static_assert( std::is_convertible<SmartPtr<int>, SmartPtr<const void>>::value);
+  static_assert( std::is_convertible<SmartPtr<const int>, SmartPtr<const void>>::value);
+  static_assert(!std::is_convertible<SmartPtr<const int>, SmartPtr<void>>::value);
+  static_assert(!std::is_convertible<SmartPtr<const void>, SmartPtr<const int>>::value);
+  static_assert( std::is_convertible<SmartPtr<ClassType>, SmartPtr<void>>::value);
+  static_assert( std::is_convertible<SmartPtr<ClassType>, SmartPtr<const void>>::value);
+
+  static_assert(!std::is_convertible<SmartPtr<int*>, SmartPtr<const int*>>::value);
+  static_assert( std::is_convertible<SmartPtr<int*>, SmartPtr<const int* const>>::value);
+  static_assert(!std::is_convertible<SmartPtr<const int*>, SmartPtr<int*>>::value);
+  static_assert(!std::is_convertible<SmartPtr<const int* const>, SmartPtr<int*>>::value);
+
+  static_assert(!std::is_convertible<SmartPtr<ClassType*>, SmartPtr<const ClassType*>>::value);
+  static_assert( std::is_convertible<SmartPtr<ClassType*>, SmartPtr<const ClassType* const>>::value);
+  static_assert(!std::is_convertible<SmartPtr<const ClassType*>, SmartPtr<ClassType*>>::value);
+  static_assert(!std::is_convertible<SmartPtr<const ClassType* const>, SmartPtr<ClassType*>>::value);
+
+  static_assert(!std::is_convertible<SmartPtr<void*>, SmartPtr<const void*>>::value);
+  static_assert( std::is_convertible<SmartPtr<void*>, SmartPtr<const void* const>>::value);
+  static_assert(!std::is_convertible<SmartPtr<const void*>, SmartPtr<void*>>::value);
+  static_assert(!std::is_convertible<SmartPtr<const void* const>, SmartPtr<void*>>::value);
+
+#if __cpp_lib_shared_ptr_arrays >= 201611L
+  static_assert( std::is_convertible<SmartPtr<int[10]>, SmartPtr<int[]>>::value);
+  static_assert(!std::is_convertible<SmartPtr<int[]>, SmartPtr<int[10]>>::value);
+  static_assert( std::is_convertible<SmartPtr<int[10]>, SmartPtr<int const[]>>::value);
+  static_assert( std::is_convertible<SmartPtr<int[10]>, SmartPtr<int const[10]>>::value);
+  static_assert( std::is_convertible<SmartPtr<int[]>, SmartPtr<int const[]>>::value);
+  static_assert(!std::is_convertible<SmartPtr<int const[]>, SmartPtr<int[]>>::value);
+  static_assert( std::is_convertible<SmartPtr<int const[10]>, SmartPtr<int const[]>>::value);
+  static_assert(!std::is_convertible<SmartPtr<int const[]>, SmartPtr<int const[10]>>::value);
+
+  static_assert( std::is_convertible<SmartPtr<ClassType[10]>, SmartPtr<ClassType[]>>::value);
+  static_assert(!std::is_convertible<SmartPtr<ClassType[]>, SmartPtr<ClassType[10]>>::value);
+  static_assert( std::is_convertible<SmartPtr<ClassType[10]>, SmartPtr<ClassType const[]>>::value);
+  static_assert( std::is_convertible<SmartPtr<ClassType[10]>, SmartPtr<ClassType const[10]>>::value);
+  static_assert( std::is_convertible<SmartPtr<ClassType[]>, SmartPtr<ClassType const[]>>::value);
+  static_assert(!std::is_convertible<SmartPtr<ClassType const[]>, SmartPtr<ClassType[]>>::value);
+  static_assert( std::is_convertible<SmartPtr<ClassType const[10]>, SmartPtr<ClassType const[]>>::value);
+  static_assert(!std::is_convertible<SmartPtr<ClassType const[]>, SmartPtr<ClassType const[10]>>::value);
+
+  static_assert( std::is_convertible<SmartPtr<IncompleteClass[10]>, SmartPtr<IncompleteClass[]>>::value);
+  static_assert(!std::is_convertible<SmartPtr<IncompleteClass[]>, SmartPtr<IncompleteClass[10]>>::value);
+  static_assert( std::is_convertible<SmartPtr<IncompleteClass[10]>, SmartPtr<IncompleteClass const[]>>::value);
+  static_assert( std::is_convertible<SmartPtr<IncompleteClass[10]>, SmartPtr<IncompleteClass const[10]>>::value);
+  static_assert( std::is_convertible<SmartPtr<IncompleteClass[]>, SmartPtr<IncompleteClass const[]>>::value);
+  static_assert(!std::is_convertible<SmartPtr<IncompleteClass const[]>, SmartPtr<IncompleteClass[]>>::value);
+  static_assert( std::is_convertible<SmartPtr<IncompleteClass const[10]>, SmartPtr<IncompleteClass const[]>>::value);
+  static_assert(!std::is_convertible<SmartPtr<IncompleteClass const[]>, SmartPtr<IncompleteClass const[10]>>::value);
+
+  static_assert( std::is_convertible<SmartPtr<int*[10]>, SmartPtr<int*[]>>::value);
+  static_assert(!std::is_convertible<SmartPtr<int*[]>, SmartPtr<int*[10]>>::value);
+  static_assert( std::is_convertible<SmartPtr<int*[10]>, SmartPtr<int* const[10]>>::value);
+  static_assert( std::is_convertible<SmartPtr<int*[10]>, SmartPtr<int* const[]>>::value);
+
+  static_assert(!std::is_convertible<SmartPtr<int*[]>, SmartPtr<void*[]>>::value);
+  static_assert(!std::is_convertible<SmartPtr<int*[]>, SmartPtr<void const *[]>>::value);
+#endif
+}
+
+int
+main()
+{
+  test01<std::shared_ptr>();
+  test01<std::weak_ptr>();
+
+  test02<std::shared_ptr>();
+  test02<std::weak_ptr>();
+
+  test03<std::shared_ptr>();
+  test03<std::weak_ptr>();
+}
diff --git a/libstdc++-v3/testsuite/20_util/weak_ptr/requirements/1.cc b/libstdc++-v3/testsuite/20_util/weak_ptr/requirements/1.cc
deleted file mode 100644
index 04ea837d85a7..000000000000
--- a/libstdc++-v3/testsuite/20_util/weak_ptr/requirements/1.cc
+++ /dev/null
@@ -1,33 +0,0 @@
-// { dg-do compile { target c++11 } }
-// { dg-require-effective-target hosted }
-
-#include <memory>
-#include <testsuite_tr1.h>
-
-using namespace __gnu_test;
-
-void
-test01()
-{
-  std::weak_ptr<ClassType> ptr;
-  std::weak_ptr<const ClassType> ptr2 = ptr;
-
-#if __cpp_lib_shared_ptr_arrays >= 201611L
-  std::weak_ptr<ClassType[10]> ptr_array;
-  std::weak_ptr<ClassType[]> ptr_array2 = ptr_array;
-  std::weak_ptr<ClassType const []> ptr_array3 = ptr_array;
-#endif
-}
-
-void
-test02()
-{
-  std::weak_ptr<IncompleteClass> ptr;
-  std::weak_ptr<const IncompleteClass> ptr2 = ptr;
-
-#if __cpp_lib_shared_ptr_arrays >= 201611L
-  std::weak_ptr<IncompleteClass[10]> ptr_array;
-  std::weak_ptr<IncompleteClass[]> ptr_array2 = ptr_array;
-  std::weak_ptr<IncompleteClass const []> ptr_array3 = ptr_array;
-#endif
-}