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 extern "C" {
31 #include <sys/types.h>
32 }
33
34 #include <iostream>
35
36 #include "atf-c/defs.h"
37
38 #include "../macros.hpp"
39
40 #include "auto_array.hpp"
41
42 // ------------------------------------------------------------------------
43 // Tests for the "auto_array" class.
44 // ------------------------------------------------------------------------
45
46 class test_array {
47 public:
48 int m_value;
49
50 static ssize_t m_nblocks;
51
52 static
53 atf::auto_array< test_array >
do_copy(atf::auto_array<test_array> & ta)54 do_copy(atf::auto_array< test_array >& ta)
55 {
56 return atf::auto_array< test_array >(ta);
57 }
58
operator new(size_t size ATF_DEFS_ATTRIBUTE_UNUSED)59 void* operator new(size_t size ATF_DEFS_ATTRIBUTE_UNUSED)
60 {
61 ATF_FAIL("New called but should have been new[]");
62 return new int(5);
63 }
64
operator new[](size_t size)65 void* operator new[](size_t size)
66 {
67 m_nblocks++;
68 void* mem = ::operator new(size);
69 std::cout << "Allocated 'test_array' object " << mem << "\n";
70 return mem;
71 }
72
operator delete(void * mem ATF_DEFS_ATTRIBUTE_UNUSED)73 void operator delete(void* mem ATF_DEFS_ATTRIBUTE_UNUSED)
74 {
75 ATF_FAIL("Delete called but should have been delete[]");
76 }
77
operator delete[](void * mem)78 void operator delete[](void* mem)
79 {
80 std::cout << "Releasing 'test_array' object " << mem << "\n";
81 if (m_nblocks == 0)
82 ATF_FAIL("Unbalanced delete[]");
83 m_nblocks--;
84 ::operator delete(mem);
85 }
86 };
87
88 ssize_t test_array::m_nblocks = 0;
89
90 ATF_TEST_CASE(auto_array_scope);
ATF_TEST_CASE_HEAD(auto_array_scope)91 ATF_TEST_CASE_HEAD(auto_array_scope)
92 {
93 set_md_var("descr", "Tests the automatic scope handling in the "
94 "auto_array smart pointer class");
95 }
ATF_TEST_CASE_BODY(auto_array_scope)96 ATF_TEST_CASE_BODY(auto_array_scope)
97 {
98 using atf::auto_array;
99
100 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
101 {
102 auto_array< test_array > t(new test_array[10]);
103 ATF_REQUIRE_EQ(test_array::m_nblocks, 1);
104 }
105 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
106 }
107
108 ATF_TEST_CASE(auto_array_copy);
ATF_TEST_CASE_HEAD(auto_array_copy)109 ATF_TEST_CASE_HEAD(auto_array_copy)
110 {
111 set_md_var("descr", "Tests the auto_array smart pointer class' copy "
112 "constructor");
113 }
ATF_TEST_CASE_BODY(auto_array_copy)114 ATF_TEST_CASE_BODY(auto_array_copy)
115 {
116 using atf::auto_array;
117
118 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
119 {
120 auto_array< test_array > t1(new test_array[10]);
121 ATF_REQUIRE_EQ(test_array::m_nblocks, 1);
122
123 {
124 auto_array< test_array > t2(t1);
125 ATF_REQUIRE_EQ(test_array::m_nblocks, 1);
126 }
127 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
128 }
129 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
130 }
131
132 ATF_TEST_CASE(auto_array_copy_ref);
ATF_TEST_CASE_HEAD(auto_array_copy_ref)133 ATF_TEST_CASE_HEAD(auto_array_copy_ref)
134 {
135 set_md_var("descr", "Tests the auto_array smart pointer class' copy "
136 "constructor through the auxiliary auto_array_ref object");
137 }
ATF_TEST_CASE_BODY(auto_array_copy_ref)138 ATF_TEST_CASE_BODY(auto_array_copy_ref)
139 {
140 using atf::auto_array;
141
142 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
143 {
144 auto_array< test_array > t1(new test_array[10]);
145 ATF_REQUIRE_EQ(test_array::m_nblocks, 1);
146
147 {
148 auto_array< test_array > t2 = test_array::do_copy(t1);
149 ATF_REQUIRE_EQ(test_array::m_nblocks, 1);
150 }
151 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
152 }
153 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
154 }
155
156 ATF_TEST_CASE(auto_array_get);
ATF_TEST_CASE_HEAD(auto_array_get)157 ATF_TEST_CASE_HEAD(auto_array_get)
158 {
159 set_md_var("descr", "Tests the auto_array smart pointer class' get "
160 "method");
161 }
ATF_TEST_CASE_BODY(auto_array_get)162 ATF_TEST_CASE_BODY(auto_array_get)
163 {
164 using atf::auto_array;
165
166 test_array* ta = new test_array[10];
167 auto_array< test_array > t(ta);
168 ATF_REQUIRE_EQ(t.get(), ta);
169 }
170
171 ATF_TEST_CASE(auto_array_release);
ATF_TEST_CASE_HEAD(auto_array_release)172 ATF_TEST_CASE_HEAD(auto_array_release)
173 {
174 set_md_var("descr", "Tests the auto_array smart pointer class' release "
175 "method");
176 }
ATF_TEST_CASE_BODY(auto_array_release)177 ATF_TEST_CASE_BODY(auto_array_release)
178 {
179 using atf::auto_array;
180
181 test_array* ta1 = new test_array[10];
182 {
183 auto_array< test_array > t(ta1);
184 ATF_REQUIRE_EQ(test_array::m_nblocks, 1);
185 test_array* ta2 = t.release();
186 ATF_REQUIRE_EQ(ta2, ta1);
187 ATF_REQUIRE_EQ(test_array::m_nblocks, 1);
188 }
189 ATF_REQUIRE_EQ(test_array::m_nblocks, 1);
190 delete [] ta1;
191 }
192
193 ATF_TEST_CASE(auto_array_reset);
ATF_TEST_CASE_HEAD(auto_array_reset)194 ATF_TEST_CASE_HEAD(auto_array_reset)
195 {
196 set_md_var("descr", "Tests the auto_array smart pointer class' reset "
197 "method");
198 }
ATF_TEST_CASE_BODY(auto_array_reset)199 ATF_TEST_CASE_BODY(auto_array_reset)
200 {
201 using atf::auto_array;
202
203 test_array* ta1 = new test_array[10];
204 test_array* ta2 = new test_array[10];
205 ATF_REQUIRE_EQ(test_array::m_nblocks, 2);
206
207 {
208 auto_array< test_array > t(ta1);
209 ATF_REQUIRE_EQ(test_array::m_nblocks, 2);
210 t.reset(ta2);
211 ATF_REQUIRE_EQ(test_array::m_nblocks, 1);
212 t.reset();
213 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
214 }
215 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
216 }
217
218 ATF_TEST_CASE(auto_array_assign);
ATF_TEST_CASE_HEAD(auto_array_assign)219 ATF_TEST_CASE_HEAD(auto_array_assign)
220 {
221 set_md_var("descr", "Tests the auto_array smart pointer class' "
222 "assignment operator");
223 }
ATF_TEST_CASE_BODY(auto_array_assign)224 ATF_TEST_CASE_BODY(auto_array_assign)
225 {
226 using atf::auto_array;
227
228 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
229 {
230 auto_array< test_array > t1(new test_array[10]);
231 ATF_REQUIRE_EQ(test_array::m_nblocks, 1);
232
233 {
234 auto_array< test_array > t2;
235 t2 = t1;
236 ATF_REQUIRE_EQ(test_array::m_nblocks, 1);
237 }
238 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
239 }
240 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
241 }
242
243 ATF_TEST_CASE(auto_array_assign_ref);
ATF_TEST_CASE_HEAD(auto_array_assign_ref)244 ATF_TEST_CASE_HEAD(auto_array_assign_ref)
245 {
246 set_md_var("descr", "Tests the auto_array smart pointer class' "
247 "assignment operator through the auxiliary auto_array_ref "
248 "object");
249 }
ATF_TEST_CASE_BODY(auto_array_assign_ref)250 ATF_TEST_CASE_BODY(auto_array_assign_ref)
251 {
252 using atf::auto_array;
253
254 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
255 {
256 auto_array< test_array > t1(new test_array[10]);
257 ATF_REQUIRE_EQ(test_array::m_nblocks, 1);
258
259 {
260 auto_array< test_array > t2;
261 t2 = test_array::do_copy(t1);
262 ATF_REQUIRE_EQ(test_array::m_nblocks, 1);
263 }
264 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
265 }
266 ATF_REQUIRE_EQ(test_array::m_nblocks, 0);
267 }
268
269 ATF_TEST_CASE(auto_array_access);
ATF_TEST_CASE_HEAD(auto_array_access)270 ATF_TEST_CASE_HEAD(auto_array_access)
271 {
272 set_md_var("descr", "Tests the auto_array smart pointer class' access "
273 "operator");
274 }
ATF_TEST_CASE_BODY(auto_array_access)275 ATF_TEST_CASE_BODY(auto_array_access)
276 {
277 using atf::auto_array;
278
279 auto_array< test_array > t(new test_array[10]);
280
281 for (int i = 0; i < 10; i++)
282 t[i].m_value = i * 2;
283
284 for (int i = 0; i < 10; i++)
285 ATF_REQUIRE_EQ(t[i].m_value, i * 2);
286 }
287
288 // ------------------------------------------------------------------------
289 // Main.
290 // ------------------------------------------------------------------------
291
ATF_INIT_TEST_CASES(tcs)292 ATF_INIT_TEST_CASES(tcs)
293 {
294 // Add the test for the "auto_array" class.
295 ATF_ADD_TEST_CASE(tcs, auto_array_scope);
296 ATF_ADD_TEST_CASE(tcs, auto_array_copy);
297 ATF_ADD_TEST_CASE(tcs, auto_array_copy_ref);
298 ATF_ADD_TEST_CASE(tcs, auto_array_get);
299 ATF_ADD_TEST_CASE(tcs, auto_array_release);
300 ATF_ADD_TEST_CASE(tcs, auto_array_reset);
301 ATF_ADD_TEST_CASE(tcs, auto_array_assign);
302 ATF_ADD_TEST_CASE(tcs, auto_array_assign_ref);
303 ATF_ADD_TEST_CASE(tcs, auto_array_access);
304 }
305