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