1 /* Unit tests for unique-ptr.h. 2 Copyright (C) 2017-2020 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #include "config.h" 21 #define INCLUDE_UNIQUE_PTR 22 #include "system.h" 23 #include "coretypes.h" 24 #include "selftest.h" 25 26 #if CHECKING_P 27 28 namespace selftest { 29 30 namespace { 31 32 /* A class for counting ctor and dtor invocations. */ 33 34 class stats 35 { 36 public: 37 stats () : ctor_count (0), dtor_count (0) {} 38 39 int ctor_count; 40 int dtor_count; 41 }; 42 43 /* A class that uses "stats" to track its ctor and dtor invocations. */ 44 45 class foo 46 { 47 public: 48 foo (stats &s) : m_s (s) { ++m_s.ctor_count; } 49 ~foo () { ++m_s.dtor_count; } 50 51 int example_method () const { return 42; } 52 53 private: 54 foo (const foo&); 55 foo & operator= (const foo &); 56 57 private: 58 stats &m_s; 59 }; 60 61 /* A struct for testing unique_ptr<T[]>. */ 62 63 class has_default_ctor 64 { 65 public: 66 has_default_ctor () : m_field (42) {} 67 int m_field; 68 }; 69 70 /* A dummy struct for testing unique_xmalloc_ptr. */ 71 72 struct dummy 73 { 74 int field; 75 }; 76 77 } // anonymous namespace 78 79 /* Verify that the default ctor inits ptrs to NULL. */ 80 81 static void 82 test_null_ptr () 83 { 84 gnu::unique_ptr<void *> p; 85 ASSERT_EQ (NULL, p); 86 87 gnu::unique_xmalloc_ptr<void *> q; 88 ASSERT_EQ (NULL, q); 89 } 90 91 /* Verify that deletion happens when a unique_ptr goes out of scope. */ 92 93 static void 94 test_implicit_deletion () 95 { 96 stats s; 97 ASSERT_EQ (0, s.ctor_count); 98 ASSERT_EQ (0, s.dtor_count); 99 100 { 101 gnu::unique_ptr<foo> f (new foo (s)); 102 ASSERT_NE (NULL, f); 103 ASSERT_EQ (1, s.ctor_count); 104 ASSERT_EQ (0, s.dtor_count); 105 } 106 107 /* Verify that the foo was implicitly deleted. */ 108 ASSERT_EQ (1, s.ctor_count); 109 ASSERT_EQ (1, s.dtor_count); 110 } 111 112 /* Verify that we can assign to a NULL unique_ptr. */ 113 114 static void 115 test_overwrite_of_null () 116 { 117 stats s; 118 ASSERT_EQ (0, s.ctor_count); 119 ASSERT_EQ (0, s.dtor_count); 120 121 { 122 gnu::unique_ptr<foo> f; 123 ASSERT_EQ (NULL, f); 124 ASSERT_EQ (0, s.ctor_count); 125 ASSERT_EQ (0, s.dtor_count); 126 127 /* Overwrite with a non-NULL value. */ 128 f = gnu::unique_ptr<foo> (new foo (s)); 129 ASSERT_EQ (1, s.ctor_count); 130 ASSERT_EQ (0, s.dtor_count); 131 } 132 133 /* Verify that the foo is implicitly deleted. */ 134 ASSERT_EQ (1, s.ctor_count); 135 ASSERT_EQ (1, s.dtor_count); 136 } 137 138 /* Verify that we can assign to a non-NULL unique_ptr. */ 139 140 static void 141 test_overwrite_of_non_null () 142 { 143 stats s; 144 ASSERT_EQ (0, s.ctor_count); 145 ASSERT_EQ (0, s.dtor_count); 146 147 { 148 gnu::unique_ptr<foo> f (new foo (s)); 149 ASSERT_NE (NULL, f); 150 ASSERT_EQ (1, s.ctor_count); 151 ASSERT_EQ (0, s.dtor_count); 152 153 /* Overwrite with a different value. */ 154 f = gnu::unique_ptr<foo> (new foo (s)); 155 ASSERT_EQ (2, s.ctor_count); 156 ASSERT_EQ (1, s.dtor_count); 157 } 158 159 /* Verify that the 2nd foo was implicitly deleted. */ 160 ASSERT_EQ (2, s.ctor_count); 161 ASSERT_EQ (2, s.dtor_count); 162 } 163 164 /* Verify that unique_ptr's overloaded ops work. */ 165 166 static void 167 test_overloaded_ops () 168 { 169 stats s; 170 gnu::unique_ptr<foo> f (new foo (s)); 171 ASSERT_EQ (42, f->example_method ()); 172 ASSERT_EQ (42, (*f).example_method ()); 173 ASSERT_EQ (f, f); 174 ASSERT_NE (NULL, f.get ()); 175 176 gnu::unique_ptr<foo> g (new foo (s)); 177 ASSERT_NE (f, g); 178 } 179 180 /* Verify that the gnu::unique_ptr specialization for T[] works. */ 181 182 static void 183 test_array_new () 184 { 185 const int num = 10; 186 gnu::unique_ptr<has_default_ctor[]> p (new has_default_ctor[num]); 187 ASSERT_NE (NULL, p.get ()); 188 /* Verify that operator[] works, and that the default ctor was called 189 on each element. */ 190 for (int i = 0; i < num; i++) 191 ASSERT_EQ (42, p[i].m_field); 192 } 193 194 /* Verify that gnu::unique_xmalloc_ptr works. */ 195 196 static void 197 test_xmalloc () 198 { 199 gnu::unique_xmalloc_ptr<dummy> p (XNEW (dummy)); 200 ASSERT_NE (NULL, p.get ()); 201 } 202 203 /* Verify the gnu::unique_xmalloc_ptr specialization for T[]. */ 204 205 static void 206 test_xmalloc_array () 207 { 208 const int num = 10; 209 gnu::unique_xmalloc_ptr<dummy[]> p (XNEWVEC (dummy, num)); 210 ASSERT_NE (NULL, p.get ()); 211 212 /* Verify that operator[] works. */ 213 for (int i = 0; i < num; i++) 214 p[i].field = 42; 215 for (int i = 0; i < num; i++) 216 ASSERT_EQ (42, p[i].field); 217 } 218 219 /* Run all of the selftests within this file. */ 220 221 void 222 unique_ptr_tests_cc_tests () 223 { 224 test_null_ptr (); 225 test_implicit_deletion (); 226 test_overwrite_of_null (); 227 test_overwrite_of_non_null (); 228 test_overloaded_ops (); 229 test_array_new (); 230 test_xmalloc (); 231 test_xmalloc_array (); 232 } 233 234 } // namespace selftest 235 236 #endif /* #if CHECKING_P */ 237