From: Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>
Date: Sat, 15 Mar 2025 15:04:45 +0000 (+0100)
Subject: libstdc++: centralize and improve testing of shared_ptr/weak_ptr conversions
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=0416ac5ae0a97b09b8d4ab6617ae1c7802d2aa7f;p=thirdparty%2Fgcc.git

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 --git a/libstdc++-v3/testsuite/20_util/shared_ptr/requirements/1.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/requirements/1.cc
index 8ddb5d220ac..19090d1e860 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 04ea837d85a..00000000000
--- 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
-}