1 // 2 // Automated Testing Framework (atf) 3 // 4 // Copyright (c) 2007 The NetBSD Foundation, Inc. 5 // All rights reserved. 6 // 7 // Redistribution and use in source and binary forms, with or without 8 // modification, are permitted provided that the following conditions 9 // are met: 10 // 1. Redistributions of source code must retain the above copyright 11 // notice, this list of conditions and the following disclaimer. 12 // 2. Redistributions in binary form must reproduce the above copyright 13 // notice, this list of conditions and the following disclaimer in the 14 // documentation and/or other materials provided with the distribution. 15 // 16 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 17 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 18 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY 21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 23 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 26 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 // 29 30 #include <iostream> 31 32 #include "atf-c/defs.h" 33 34 #include "macros.hpp" 35 #include "utils.hpp" 36 37 #include "detail/test_helpers.hpp" 38 39 // ------------------------------------------------------------------------ 40 // Tests for the "auto_array" class. 41 // ------------------------------------------------------------------------ 42 43 class test_array { 44 public: 45 int m_value; 46 47 static ssize_t m_nblocks; 48 49 static 50 atf::utils::auto_array< test_array > 51 do_copy(atf::utils::auto_array< test_array >& ta) 52 { 53 return atf::utils::auto_array< test_array >(ta); 54 } 55 56 void* operator new(size_t size ATF_DEFS_ATTRIBUTE_UNUSED) 57 { 58 ATF_FAIL("New called but should have been new[]"); 59 return new int(5); 60 } 61 62 void* operator new[](size_t size) 63 { 64 m_nblocks++; 65 void* mem = ::operator new(size); 66 std::cout << "Allocated 'test_array' object " << mem << "\n"; 67 return mem; 68 } 69 70 void operator delete(void* mem ATF_DEFS_ATTRIBUTE_UNUSED) 71 { 72 ATF_FAIL("Delete called but should have been delete[]"); 73 } 74 75 void operator delete[](void* mem) 76 { 77 std::cout << "Releasing 'test_array' object " << mem << "\n"; 78 if (m_nblocks == 0) 79 ATF_FAIL("Unbalanced delete[]"); 80 m_nblocks--; 81 ::operator delete(mem); 82 } 83 }; 84 85 ssize_t test_array::m_nblocks = 0; 86 87 ATF_TEST_CASE(auto_array_scope); 88 ATF_TEST_CASE_HEAD(auto_array_scope) 89 { 90 set_md_var("descr", "Tests the automatic scope handling in the " 91 "auto_array smart pointer class"); 92 } 93 ATF_TEST_CASE_BODY(auto_array_scope) 94 { 95 using atf::utils::auto_array; 96 97 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 98 { 99 auto_array< test_array > t(new test_array[10]); 100 ATF_REQUIRE_EQ(test_array::m_nblocks, 1); 101 } 102 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 103 } 104 105 ATF_TEST_CASE(auto_array_copy); 106 ATF_TEST_CASE_HEAD(auto_array_copy) 107 { 108 set_md_var("descr", "Tests the auto_array smart pointer class' copy " 109 "constructor"); 110 } 111 ATF_TEST_CASE_BODY(auto_array_copy) 112 { 113 using atf::utils::auto_array; 114 115 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 116 { 117 auto_array< test_array > t1(new test_array[10]); 118 ATF_REQUIRE_EQ(test_array::m_nblocks, 1); 119 120 { 121 auto_array< test_array > t2(t1); 122 ATF_REQUIRE_EQ(test_array::m_nblocks, 1); 123 } 124 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 125 } 126 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 127 } 128 129 ATF_TEST_CASE(auto_array_copy_ref); 130 ATF_TEST_CASE_HEAD(auto_array_copy_ref) 131 { 132 set_md_var("descr", "Tests the auto_array smart pointer class' copy " 133 "constructor through the auxiliary auto_array_ref object"); 134 } 135 ATF_TEST_CASE_BODY(auto_array_copy_ref) 136 { 137 using atf::utils::auto_array; 138 139 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 140 { 141 auto_array< test_array > t1(new test_array[10]); 142 ATF_REQUIRE_EQ(test_array::m_nblocks, 1); 143 144 { 145 auto_array< test_array > t2 = test_array::do_copy(t1); 146 ATF_REQUIRE_EQ(test_array::m_nblocks, 1); 147 } 148 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 149 } 150 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 151 } 152 153 ATF_TEST_CASE(auto_array_get); 154 ATF_TEST_CASE_HEAD(auto_array_get) 155 { 156 set_md_var("descr", "Tests the auto_array smart pointer class' get " 157 "method"); 158 } 159 ATF_TEST_CASE_BODY(auto_array_get) 160 { 161 using atf::utils::auto_array; 162 163 test_array* ta = new test_array[10]; 164 auto_array< test_array > t(ta); 165 ATF_REQUIRE_EQ(t.get(), ta); 166 } 167 168 ATF_TEST_CASE(auto_array_release); 169 ATF_TEST_CASE_HEAD(auto_array_release) 170 { 171 set_md_var("descr", "Tests the auto_array smart pointer class' release " 172 "method"); 173 } 174 ATF_TEST_CASE_BODY(auto_array_release) 175 { 176 using atf::utils::auto_array; 177 178 test_array* ta1 = new test_array[10]; 179 { 180 auto_array< test_array > t(ta1); 181 ATF_REQUIRE_EQ(test_array::m_nblocks, 1); 182 test_array* ta2 = t.release(); 183 ATF_REQUIRE_EQ(ta2, ta1); 184 ATF_REQUIRE_EQ(test_array::m_nblocks, 1); 185 } 186 ATF_REQUIRE_EQ(test_array::m_nblocks, 1); 187 delete [] ta1; 188 } 189 190 ATF_TEST_CASE(auto_array_reset); 191 ATF_TEST_CASE_HEAD(auto_array_reset) 192 { 193 set_md_var("descr", "Tests the auto_array smart pointer class' reset " 194 "method"); 195 } 196 ATF_TEST_CASE_BODY(auto_array_reset) 197 { 198 using atf::utils::auto_array; 199 200 test_array* ta1 = new test_array[10]; 201 test_array* ta2 = new test_array[10]; 202 ATF_REQUIRE_EQ(test_array::m_nblocks, 2); 203 204 { 205 auto_array< test_array > t(ta1); 206 ATF_REQUIRE_EQ(test_array::m_nblocks, 2); 207 t.reset(ta2); 208 ATF_REQUIRE_EQ(test_array::m_nblocks, 1); 209 t.reset(); 210 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 211 } 212 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 213 } 214 215 ATF_TEST_CASE(auto_array_assign); 216 ATF_TEST_CASE_HEAD(auto_array_assign) 217 { 218 set_md_var("descr", "Tests the auto_array smart pointer class' " 219 "assignment operator"); 220 } 221 ATF_TEST_CASE_BODY(auto_array_assign) 222 { 223 using atf::utils::auto_array; 224 225 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 226 { 227 auto_array< test_array > t1(new test_array[10]); 228 ATF_REQUIRE_EQ(test_array::m_nblocks, 1); 229 230 { 231 auto_array< test_array > t2; 232 t2 = t1; 233 ATF_REQUIRE_EQ(test_array::m_nblocks, 1); 234 } 235 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 236 } 237 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 238 } 239 240 ATF_TEST_CASE(auto_array_assign_ref); 241 ATF_TEST_CASE_HEAD(auto_array_assign_ref) 242 { 243 set_md_var("descr", "Tests the auto_array smart pointer class' " 244 "assignment operator through the auxiliary auto_array_ref " 245 "object"); 246 } 247 ATF_TEST_CASE_BODY(auto_array_assign_ref) 248 { 249 using atf::utils::auto_array; 250 251 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 252 { 253 auto_array< test_array > t1(new test_array[10]); 254 ATF_REQUIRE_EQ(test_array::m_nblocks, 1); 255 256 { 257 auto_array< test_array > t2; 258 t2 = test_array::do_copy(t1); 259 ATF_REQUIRE_EQ(test_array::m_nblocks, 1); 260 } 261 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 262 } 263 ATF_REQUIRE_EQ(test_array::m_nblocks, 0); 264 } 265 266 ATF_TEST_CASE(auto_array_access); 267 ATF_TEST_CASE_HEAD(auto_array_access) 268 { 269 set_md_var("descr", "Tests the auto_array smart pointer class' access " 270 "operator"); 271 } 272 ATF_TEST_CASE_BODY(auto_array_access) 273 { 274 using atf::utils::auto_array; 275 276 auto_array< test_array > t(new test_array[10]); 277 278 for (int i = 0; i < 10; i++) 279 t[i].m_value = i * 2; 280 281 for (int i = 0; i < 10; i++) 282 ATF_REQUIRE_EQ(t[i].m_value, i * 2); 283 } 284 285 // ------------------------------------------------------------------------ 286 // Tests cases for the header file. 287 // ------------------------------------------------------------------------ 288 289 HEADER_TC(include, "atf-c++/utils.hpp"); 290 291 // ------------------------------------------------------------------------ 292 // Main. 293 // ------------------------------------------------------------------------ 294 295 ATF_INIT_TEST_CASES(tcs) 296 { 297 // Add the test for the "auto_array" class. 298 ATF_ADD_TEST_CASE(tcs, auto_array_scope); 299 ATF_ADD_TEST_CASE(tcs, auto_array_copy); 300 ATF_ADD_TEST_CASE(tcs, auto_array_copy_ref); 301 ATF_ADD_TEST_CASE(tcs, auto_array_get); 302 ATF_ADD_TEST_CASE(tcs, auto_array_release); 303 ATF_ADD_TEST_CASE(tcs, auto_array_reset); 304 ATF_ADD_TEST_CASE(tcs, auto_array_assign); 305 ATF_ADD_TEST_CASE(tcs, auto_array_assign_ref); 306 ATF_ADD_TEST_CASE(tcs, auto_array_access); 307 308 // Add the test cases for the header file. 309 ATF_ADD_TEST_CASE(tcs, include); 310 } 311