cloudy trunk
Loading...
Searching...
No Matches
TestFlexArr.cpp
Go to the documentation of this file.
1/* This file is part of Cloudy and is copyright (C)1978-2013 by Gary J. Ferland and
2 * others. For conditions of distribution and use see copyright notice in license.txt */
3#include "cdstd.h"
4#include <UnitTest++.h>
5#include "cddefines.h"
6
7namespace {
8
9 struct LongIntFixtureBlank
10 {
11 flex_arr<long,false> arr;
12 LongIntFixtureBlank() {}
13 ~LongIntFixtureBlank() {}
14 };
15
16 template<bool lgBC>
17 struct LongIntFixtureGeneric
18 {
19 flex_arr<long,lgBC> arr;
20 LongIntFixtureGeneric()
21 {
22 arr.alloc(5,10);
23 for( int i=5; i < 10; ++i )
24 arr[i] = i;
25 }
26 ~LongIntFixtureGeneric() {}
27 };
28
29 typedef LongIntFixtureGeneric<false> LongIntFixture;
30 typedef LongIntFixtureGeneric<true> LongIntFixtureBC;
31
32 struct LongIntFixtureFill
33 {
34 flex_arr<long,false> arr;
35 LongIntFixtureFill()
36 {
37 arr.alloc(5,10);
38 for( int i=5; i < 10; ++i )
39 arr[i] = i;
40 }
41 ~LongIntFixtureFill() {}
42 void myfill()
43 {
44 long i = 0;
46 for( p=arr.begin(); p != arr.end(); ++p )
47 *p = ++i;
48 }
49 };
50
51 struct RealNumFixture
52 {
53 flex_arr<realnum,false> arr;
54 RealNumFixture()
55 {
56 arr.alloc(5,10);
57 for( int i=5; i < 10; ++i )
58 arr[i] = i;
59 }
60 ~RealNumFixture() {}
61 };
62
63 struct DoubleFixture
64 {
65 flex_arr<double,false> arr;
66 DoubleFixture()
67 {
68 arr.alloc(5,10);
69 for( int i=5; i < 10; ++i )
70 arr[i] = i;
71 }
72 ~DoubleFixture() {}
73 };
74
75 struct StructWithConstructorFixture
76 {
77 struct a
78 {
79 long n;
80 a() { n = 23; }
81 ~a() {}
82 };
83 flex_arr<a,false> arr;
84 StructWithConstructorFixture()
85 {
86 arr.alloc(7,12);
87 }
88 ~StructWithConstructorFixture() {}
89 };
90
91 struct TestAllocFixture
92 {
93 TestAllocFixture() {}
94 ~TestAllocFixture() {}
95 long mytest()
96 {
97 flex_arr<long,true> a(2,20);
98
100
101 a.zero();
102
103 long res = 0;
104 for (int i=2; i<20; ++i)
105 {
106 p = a.ptr(i);
107 res += ( *p != 0 );
108 }
109
110 return res;
111 }
112 };
113
114 TEST_FIXTURE(LongIntFixture,TestZero)
115 {
116 arr.zero();
117 for( int i=5; i < 10; ++i )
118 CHECK_EQUAL(0,arr[i]);
119 arr.clear();
120 arr.zero();
121 }
122
123 TEST_FIXTURE(LongIntFixture,TestInvalidate1)
124 {
125 arr.invalidate();
126 for( int i=5; i < 10; ++i )
127 CHECK_EQUAL(-1,arr[i]);
128 arr.clear();
129 arr.invalidate();
130 }
131
132 TEST_FIXTURE(RealNumFixture,TestInvalidate2)
133 {
134 arr.invalidate();
135 for( int i=5; i < 10; ++i )
136 CHECK(isnan(arr[i]));
137 arr.clear();
138 arr.invalidate();
139 }
140
141 TEST_FIXTURE(DoubleFixture,TestInvalidate3)
142 {
143 arr.invalidate();
144 for( int i=5; i < 10; ++i )
145 CHECK(isnan(arr[i]));
146 arr.clear();
147 arr.invalidate();
148 }
149
150 TEST_FIXTURE(LongIntFixtureBC,TestAccess1)
151 {
152 for( int i=5; i < 10; ++i )
153 CHECK_EQUAL(i,arr[i]);
154 CHECK_THROW(arr[4],out_of_range);
155 CHECK_THROW(arr[10],out_of_range);
156 const flex_arr<long,true>* carr = &arr;
157 for( int i=5; i < 10; ++i )
158 CHECK_EQUAL(i,(*carr)[i]);
159 CHECK_THROW((*carr)[4],out_of_range);
160 CHECK_THROW((*carr)[10],out_of_range);
161 }
162
163 TEST_FIXTURE(LongIntFixtureBC,TestAccess2)
164 {
165 for( int i=5; i < 10; ++i )
166 CHECK_EQUAL(i,arr[i]);
167 CHECK_THROW(arr[4],out_of_range);
168 CHECK_THROW(arr[10],out_of_range);
169 const flex_arr<long,true>* carr = &arr;
170 for( int i=5; i < 10; ++i )
171 CHECK_EQUAL(i,(*carr)[i]);
172 CHECK_THROW((*carr)[4],out_of_range);
173 CHECK_THROW((*carr)[10],out_of_range);
174 }
175
176 TEST_FIXTURE(LongIntFixture,TestAccess3)
177 {
178 for( int i=5; i < 10; ++i )
179 CHECK_EQUAL(i,*arr.ptr(i));
180 const flex_arr<long,false>* carr = &arr;
181 for( int i=5; i < 10; ++i )
182 CHECK_EQUAL(i,*carr->ptr(i));
183 }
184
185 TEST_FIXTURE(LongIntFixtureBC,TestAccess4)
186 {
187 for( int i=5; i < 10; ++i )
188 CHECK_EQUAL(i,*arr.ptr(i));
189 CHECK_THROW(*arr.ptr(4),out_of_range);
190 CHECK_THROW(*arr.ptr(10),out_of_range);
191 const flex_arr<long,true>* carr = &arr;
192 for( int i=5; i < 10; ++i )
193 CHECK_EQUAL(i,*carr->ptr(i));
194 CHECK_THROW(*carr->ptr(4),out_of_range);
195 CHECK_THROW(*carr->ptr(10),out_of_range);
196 }
197
198 TEST_FIXTURE(LongIntFixture,TestAccess5)
199 {
200 for( int i=5; i < 10; ++i )
201 CHECK_EQUAL(i,arr.at(i));
202 CHECK_THROW(arr.at(4),out_of_range);
203 CHECK_THROW(arr.at(10),out_of_range);
204 const flex_arr<long,false>* carr = &arr;
205 for( int i=5; i < 10; ++i )
206 CHECK_EQUAL(i,carr->at(i));
207 CHECK_THROW(carr->at(4),out_of_range);
208 CHECK_THROW(carr->at(10),out_of_range);
209 }
210
211 // test the state_do function
212 TEST_FIXTURE(LongIntFixture,TestStateDo)
213 {
214 const char *fnam = "tfa.872GqS";
215 FILE *io = fopen( fnam, "wb" );
216 CHECK( io != NULL );
217 arr.state_do( io, false ); // dump state
218 fclose( io );
219 arr.invalidate(); // trash contents
220 io = fopen( fnam, "rb" );
221 CHECK( io != NULL );
222 arr.state_do( io, true ); // restore state
223 fclose( io );
224 remove(fnam);
225 CHECK_EQUAL(7,arr[7]);
226 }
227
228 TEST_FIXTURE(LongIntFixtureBC,TestBoundaries)
229 {
230 CHECK( arr.begin() == arr.ptr(5) );
231 CHECK( arr.end() == arr.ptr(10) );
232 CHECK( &arr.front() == &arr[5] );
233 CHECK( &arr.back() == &arr[9] );
234 CHECK( arr.data() == &arr[5] );
235 const flex_arr<long,true>* carr = &arr;
236 CHECK( carr->begin() == arr.ptr(5) );
237 CHECK( carr->end() == arr.ptr(10) );
238 CHECK( &carr->front() == &arr[5] );
239 CHECK( &carr->back() == &arr[9] );
240 CHECK( carr->data() == &arr[5] );
241 }
242
243 TEST_FIXTURE(LongIntFixtureFill,TestRealloc)
244 {
245 myfill();
246 for( int i=5; i < 10; ++i )
247 CHECK_EQUAL( i-4, arr[i] );
248 long *pold = arr.data();
249 arr.realloc( 20 );
250 long *pnew = arr.data();
251 CHECK( pold != pnew );
252 for( int i=5; i < 10; ++i )
253 CHECK_EQUAL( i-4, arr[i] );
254 }
255
256 TEST_FIXTURE(LongIntFixtureBlank,TestAllocationWithoutReservation)
257 {
258 CHECK_EQUAL(0L,arr.size());
259 CHECK_EQUAL(0L,arr.capacity());
260 CHECK( arr.empty() );
261 arr.alloc(5,10);
262 CHECK_EQUAL(5L,arr.size());
263 CHECK_EQUAL(5L,arr.capacity());
264 CHECK( !arr.empty() );
265 arr.realloc(30);
266 CHECK_EQUAL(25L,arr.size());
267 CHECK_EQUAL(25L,arr.capacity());
268 CHECK( !arr.empty() );
269 arr.realloc(10);
270 CHECK_EQUAL(5L,arr.size());
271 CHECK_EQUAL(25L,arr.capacity());
272 CHECK( !arr.empty() );
273 arr.realloc(0);
274 CHECK_EQUAL(0L,arr.size());
275 CHECK_EQUAL(25L,arr.capacity());
276 CHECK( arr.empty() );
277 arr.clear();
278 CHECK_EQUAL(0L,arr.size());
279 CHECK_EQUAL(0L,arr.capacity());
280 CHECK( arr.empty() );
281 arr.alloc(-5,12);
282 CHECK_EQUAL(17L,arr.size());
283 CHECK_EQUAL(17L,arr.capacity());
284 CHECK( !arr.empty() );
285 arr.clear();
286 CHECK_EQUAL(0L,arr.size());
287 CHECK_EQUAL(0L,arr.capacity());
288 CHECK( arr.empty() );
289 arr.alloc(-5,-12);
290 CHECK_EQUAL(0L,arr.size());
291 CHECK_EQUAL(0L,arr.capacity());
292 CHECK( arr.empty() );
293 arr.realloc(30);
294 CHECK_EQUAL(35L,arr.size());
295 CHECK_EQUAL(35L,arr.capacity());
296 CHECK( !arr.empty() );
297 }
298
299 TEST_FIXTURE(LongIntFixtureBlank,TestAllocationWithReservation)
300 {
301 arr.reserve(100);
302 CHECK_EQUAL(0L,arr.size());
303 CHECK_EQUAL(100L,arr.capacity());
304 CHECK( arr.empty() );
305 arr.alloc(5,10);
306 CHECK_EQUAL(5L,arr.size());
307 CHECK_EQUAL(100L,arr.capacity());
308 CHECK( !arr.empty() );
309 arr.realloc(30);
310 CHECK_EQUAL(25L,arr.size());
311 CHECK_EQUAL(100L,arr.capacity());
312 CHECK( !arr.empty() );
313 arr.realloc(200);
314 CHECK_EQUAL(195L,arr.size());
315 CHECK_EQUAL(195L,arr.capacity());
316 CHECK( !arr.empty() );
317 arr.reserve(5);
318 CHECK_EQUAL(0L,arr.size());
319 CHECK_EQUAL(5L,arr.capacity());
320 CHECK( arr.empty() );
321 arr.alloc(-5,-10);
322 CHECK_EQUAL(0L,arr.size());
323 CHECK_EQUAL(5L,arr.capacity());
324 CHECK( arr.empty() );
325 arr.reserve(-5);
326 CHECK_EQUAL(0L,arr.size());
327 CHECK_EQUAL(0L,arr.capacity());
328 CHECK( arr.empty() );
329 arr.reserve(10);
330 CHECK_EQUAL(0L,arr.size());
331 CHECK_EQUAL(10L,arr.capacity());
332 CHECK( arr.empty() );
333 arr.alloc(-10,10);
334 CHECK_EQUAL(20L,arr.size());
335 CHECK_EQUAL(20L,arr.capacity());
336 CHECK( !arr.empty() );
337 }
338
339 TEST_FIXTURE(StructWithConstructorFixture,TestAllocationWithConstructor)
340 {
341 for( int i=7; i < 12; ++i )
342 CHECK_EQUAL(23,arr[i].n);
343 }
344
345 // check whether the variant form for allocating works correctly
346 // this also tests p_iterator in bounds-checking mode
347 TEST_FIXTURE(TestAllocFixture,TestVariantAlloc)
348 {
349 CHECK_EQUAL(0,mytest());
350 }
351
352 TEST_FIXTURE(LongIntFixtureBC,TestCopyOperator)
353 {
354 flex_arr<long,true> arr2(12,234);
355 CHECK( arr.size() != arr2.size() );
356 arr2.zero();
357 CHECK_EQUAL(0,arr2[114]);
358 arr2 = arr;
359 CHECK( arr.size() == arr2.size() );
360 // check that copies are distinct
361 CHECK( &arr[5] != &arr2[5] );
362 for (int i=5; i<10; ++i)
363 CHECK_EQUAL(i,arr2[i]);
364
365 CHECK_THROW(arr2[4],out_of_range);
366 CHECK_THROW(arr2[10],out_of_range);
367
368 // is it safe to copy to oneself?
369 arr2 = arr2;
370 // have the contents been preserved?
371 CHECK_EQUAL(9,arr2[9]);
372
373 // now copy using constructor
374 flex_arr<long,true> arr3 = arr;
375 CHECK( arr.size() == arr3.size() );
376 // check that copies are distinct
377 CHECK( &arr[5] != &arr3[5] );
378 for (int i=5; i<10; ++i)
379 CHECK_EQUAL(i,arr3[i]);
380
381 arr.clear();
382 arr2 = arr;
383 CHECK_EQUAL(0L,arr2.size());
384 arr2.reserve( 100 );
385 }
386
387}
#define isnan
Definition cddefines.h:620
void reserve(size_type size)
reference at(size_type i)
reference front()
void realloc(size_type end)
size_type capacity() const
pntr< T, lgBC > iterator
size_type size() const
iterator end()
bool empty() const
void state_do(FILE *out, bool lgGet)
reference back()
iterator ptr(size_type i)
void alloc(size_type begin, size_type end)
iterator begin()