libStatGen Software 1
Loading...
Searching...
No Matches
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
23int ReusableVectorTestDataType::ourValue = 0;
24int ReusableVectorTestDataType::ourNumDestructs = 0;
25
26int main(int argc, char ** argv)
27{
28
29 ReusableVectorTest myTest;
30
31 myTest.test();
32}
33
34void ReusableVectorTest::test()
35{
36 assert(ReusableVectorTestDataType::ourNumDestructs == 0);
37 testReuse();
38 assert(ReusableVectorTestDataType::ourNumDestructs == 8);
39}
40
41
42void 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
167bool 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
183ReusableVectorTestDataType::ReusableVectorTestDataType()
184{
185 myValue = ourValue++;
186}
187
188
189ReusableVectorTestDataType::~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.