xref: /freebsd/contrib/atf/atf-c++/detail/auto_array_test.cpp (revision 63a938566d524836885917d95bd491aa4400b181) 
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 
28 extern "C" {
29 #include <sys/types.h>
30 }
31 
32 #include <iostream>
33 
34 #include <atf-c++.hpp>
35 
36 extern "C" {
37 #include "atf-c/defs.h"
38 }
39 
40 // ------------------------------------------------------------------------
41 // Tests for the "auto_array" class.
42 // ------------------------------------------------------------------------
43 
44 class test_array {
45 public:
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 
86 ssize_t test_array::m_nblocks = 0;
87 
88 ATF_TEST_CASE(auto_array_scope);
89 ATF_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 }
94 ATF_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 
106 ATF_TEST_CASE(auto_array_copy);
107 ATF_TEST_CASE_HEAD(auto_array_copy)
108 {
109     set_md_var("descr", "Tests the auto_array smart pointer class' copy "
110                "constructor");
111 }
112 ATF_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 
130 ATF_TEST_CASE(auto_array_copy_ref);
131 ATF_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 }
136 ATF_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 
154 ATF_TEST_CASE(auto_array_get);
155 ATF_TEST_CASE_HEAD(auto_array_get)
156 {
157     set_md_var("descr", "Tests the auto_array smart pointer class' get "
158                "method");
159 }
160 ATF_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 
169 ATF_TEST_CASE(auto_array_release);
170 ATF_TEST_CASE_HEAD(auto_array_release)
171 {
172     set_md_var("descr", "Tests the auto_array smart pointer class' release "
173                "method");
174 }
175 ATF_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 
191 ATF_TEST_CASE(auto_array_reset);
192 ATF_TEST_CASE_HEAD(auto_array_reset)
193 {
194     set_md_var("descr", "Tests the auto_array smart pointer class' reset "
195                "method");
196 }
197 ATF_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 
216 ATF_TEST_CASE(auto_array_assign);
217 ATF_TEST_CASE_HEAD(auto_array_assign)
218 {
219     set_md_var("descr", "Tests the auto_array smart pointer class' "
220                "assignment operator");
221 }
222 ATF_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 
241 ATF_TEST_CASE(auto_array_assign_ref);
242 ATF_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 }
248 ATF_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 
267 ATF_TEST_CASE(auto_array_access);
268 ATF_TEST_CASE_HEAD(auto_array_access)
269 {
270     set_md_var("descr", "Tests the auto_array smart pointer class' access "
271                "operator");
272 }
273 ATF_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 
290 ATF_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