libStatGen Software  1
ReusableVectorTest.cpp
1 /*
2  * Copyright (C) 2011 Regents of the University of Michigan
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
16  */
17 #include "ReusableVector.h"
18 #include "ReusableVectorTest.h"
19 #include <assert.h>
20 #include <iostream>
21 #include <string.h>
22 
23 int ReusableVectorTestDataType::ourValue = 0;
24 int ReusableVectorTestDataType::ourNumDestructs = 0;
25 
26 int main(int argc, char ** argv)
27 {
28 
29  ReusableVectorTest myTest;
30 
31  myTest.test();
32 }
33 
34 void ReusableVectorTest::test()
35 {
36  assert(ReusableVectorTestDataType::ourNumDestructs == 0);
37  testReuse();
38  assert(ReusableVectorTestDataType::ourNumDestructs == 8);
39 }
40 
41 
42 void ReusableVectorTest::testReuse()
43 {
46  ReusableVectorTestDataType* dataPtr = NULL;
47 
48  assert(testVector.size() == 0);
49  assert(testInvalidGetIndex(testVector, 0));
50  assert(testInvalidGetIndex(testVector, 1));
51  testVector.reset();
52  assert(testVector.size() == 0);
53  assert(testInvalidGetIndex(testVector, 0));
54  assert(testInvalidGetIndex(testVector, 1));
55 
56  // Get three data pointers and check they are each new.
57  dataPtr = &(testVector.getNextEmpty());
58  assert(dataPtr->myValue == 0);
59  assert(dataPtr->ourValue == 1);
60  dataPtr = &(testVector.getNextEmpty());
61  assert(dataPtr->myValue == 1);
62  assert(dataPtr->ourValue == 2);
63  dataPtr = &(testVector.getNextEmpty());
64  assert(dataPtr->myValue == 2);
65  assert(dataPtr->ourValue == 3);
66  assert(testVector.size() == 3);
67 
68  // Check a 2nd test vector.
69  assert(testVector2.size() == 0);
70  assert(testInvalidGetIndex(testVector2, 0));
71  assert(testInvalidGetIndex(testVector2, 1));
72  testVector2.reset();
73  assert(testVector2.size() == 0);
74  assert(testInvalidGetIndex(testVector2, 0));
75  assert(testInvalidGetIndex(testVector2, 1));
76 
77  // Get data pointers and check they are each new.
78  dataPtr = &(testVector2.getNextEmpty());
79  assert(dataPtr->myValue == 3);
80  assert(dataPtr->ourValue == 4);
81  dataPtr = &(testVector2.getNextEmpty());
82  assert(dataPtr->myValue == 4);
83  assert(dataPtr->ourValue == 5);
84  assert(testVector2.size() == 2);
85 
86  // Test the get accessor.
87  assert(testVector2.get(1).myValue == 4);
88  assert(testVector2.get(0).myValue == 3);
89  assert(testInvalidGetIndex(testVector2, 2));
90  // Test the get accessor with the first vector.
91  assert(testVector.get(1).myValue == 1);
92  assert(testVector.get(0).myValue == 0);
93  assert(testVector.get(2).myValue == 2);
94  assert(testInvalidGetIndex(testVector, 3));
95 
96  // Clear the 1st vector.
97  testVector.clear();
98  assert(testVector.size() == 0);
99  assert(testInvalidGetIndex(testVector, 0));
100  assert(testInvalidGetIndex(testVector, 1));
101 
102  // Check the data values are reused.
103  dataPtr = &(testVector.getNextEmpty());
104  assert(dataPtr->myValue == 0);
105  assert(dataPtr->ourValue == 5);
106  assert(testVector.size() == 1);
107  dataPtr = &(testVector.getNextEmpty());
108  assert(dataPtr->myValue == 1);
109  assert(dataPtr->ourValue == 5);
110  assert(testVector.size() == 2);
111  dataPtr = &(testVector.getNextEmpty());
112  assert(dataPtr->myValue == 2);
113  assert(dataPtr->ourValue == 5);
114  assert(testVector.size() == 3);
115  // Test allocating a new value.
116  dataPtr = &(testVector.getNextEmpty());
117  assert(dataPtr->myValue == 5);
118  assert(dataPtr->ourValue == 6);
119  assert(testVector.size() == 4);
120 
121  // Clear both vectors.
122  testVector2.clear();
123  testVector.reset();
124  assert(testVector.size() == 0);
125  assert(testInvalidGetIndex(testVector, 0));
126  assert(testInvalidGetIndex(testVector, 1));
127  assert(testVector2.size() == 0);
128  assert(testInvalidGetIndex(testVector2, 0));
129  assert(testInvalidGetIndex(testVector2, 1));
130 
131  // Get values for the vectors and verify they are reused.
132  dataPtr = &(testVector2.getNextEmpty());
133  assert(dataPtr->myValue == 3);
134  assert(dataPtr->ourValue == 6);
135  assert(testVector2.size() == 1);
136  dataPtr = &(testVector.getNextEmpty());
137  assert(dataPtr->myValue == 0);
138  assert(dataPtr->ourValue == 6);
139  assert(testVector.size() == 1);
140  dataPtr = &(testVector2.getNextEmpty());
141  assert(dataPtr->myValue == 4);
142  assert(dataPtr->ourValue == 6);
143  assert(testVector2.size() == 2);
144  dataPtr = &(testVector2.getNextEmpty());
145  assert(dataPtr->myValue == 6);
146  assert(dataPtr->ourValue == 7);
147  assert(testVector2.size() == 3);
148  dataPtr = &(testVector.getNextEmpty());
149  assert(dataPtr->myValue == 1);
150  assert(dataPtr->ourValue == 7);
151  assert(testVector.size() == 2);
152  dataPtr = &(testVector.getNextEmpty());
153  assert(dataPtr->myValue == 2);
154  assert(dataPtr->ourValue == 7);
155  assert(testVector.size() == 3);
156  dataPtr = &(testVector.getNextEmpty());
157  assert(dataPtr->myValue == 5);
158  assert(dataPtr->ourValue == 7);
159  assert(testVector.size() == 4);
160  dataPtr = &(testVector.getNextEmpty());
161  assert(dataPtr->myValue == 7);
162  assert(dataPtr->ourValue == 8);
163  assert(testVector.size() == 5);
164 }
165 
166 
167 bool ReusableVectorTest::testInvalidGetIndex(ReusableVector<ReusableVectorTestDataType>& testVector, int index)
168 {
169  bool caught = false;
170  try
171  {
172  testVector.get(index);
173  }
174  catch(std::exception& e)
175  {
176  caught = true;
177  assert(strcmp(e.what(), "ReusableVector::get called with out of range index.") == 0);
178  }
179  return(caught);
180 }
181 
182 
183 ReusableVectorTestDataType::ReusableVectorTestDataType()
184 {
185  myValue = ourValue++;
186 }
187 
188 
189 ReusableVectorTestDataType::~ReusableVectorTestDataType()
190 {
191  ++ourNumDestructs;
192 }
193 
Create a vector of DATA_TYPE that reuses created objects to save on memory reallocations.
DATA_TYPE & getNextEmpty()
Get a reference to a new entry to be populated so the user can directly populate it rather than havin...
void clear()
Clear the vector contents.
DATA_TYPE & get(unsigned int index) const
Get a reference to the data at the specified index.
void reset()
Clear the vector contents.
int size() const
Return the number of populated entries in the vector.