1 /******************************************************************************** 2 * ReactPhysics3D physics library, http://www.reactphysics3d.com * 3 * Copyright (c) 2010-2016 Daniel Chappuis * 4 ********************************************************************************* 5 * * 6 * This software is provided 'as-is', without any express or implied warranty. * 7 * In no event will the authors be held liable for any damages arising from the * 8 * use of this software. * 9 * * 10 * Permission is granted to anyone to use this software for any purpose, * 11 * including commercial applications, and to alter it and redistribute it * 12 * freely, subject to the following restrictions: * 13 * * 14 * 1. The origin of this software must not be misrepresented; you must not claim * 15 * that you wrote the original software. If you use this software in a * 16 * product, an acknowledgment in the product documentation would be * 17 * appreciated but is not required. * 18 * * 19 * 2. Altered source versions must be plainly marked as such, and must not be * 20 * misrepresented as being the original software. * 21 * * 22 * 3. This notice may not be removed or altered from any source distribution. * 23 * * 24 ********************************************************************************/ 25 26 #ifndef TEST_DEQUE_H 27 #define TEST_DEQUE_H 28 29 // Libraries 30 #include "Test.h" 31 #include <reactphysics3d/containers/Deque.h> 32 #include <reactphysics3d/memory/DefaultAllocator.h> 33 34 /// Reactphysics3D namespace 35 namespace reactphysics3d { 36 37 // Class TestDeque 38 /** 39 * Unit test for the Deque class 40 */ 41 class TestDeque : public Test { 42 43 private : 44 45 // ---------- Atributes ---------- // 46 47 DefaultAllocator mAllocator; 48 49 public : 50 51 // ---------- Methods ---------- // 52 53 /// Constructor TestDeque(const std::string & name)54 TestDeque(const std::string& name) : Test(name) { 55 56 } 57 58 /// Run the tests run()59 void run() { 60 61 testConstructors(); 62 testAddPopClear(); 63 testAssignment(); 64 testEquality(); 65 testIterators(); 66 } 67 testConstructors()68 void testConstructors() { 69 70 // ----- Constructors ----- // 71 72 Deque<int> deque1(mAllocator); 73 rp3d_test(deque1.size() == 0); 74 75 Deque<int> deque2(mAllocator); 76 deque2.addBack(1); 77 deque2.addBack(2); 78 deque2.addBack(3); 79 rp3d_test(deque2.size() == 3); 80 81 // ----- Copy Constructors ----- // 82 83 Deque<int> deque3(deque1); 84 rp3d_test(deque3.size() == 0); 85 86 Deque<int> deque4(deque2); 87 rp3d_test(deque4.size() == deque2.size()); 88 Deque<int>::Iterator it3 = deque2.begin(); 89 Deque<int>::Iterator it5 = deque4.begin(); 90 for (uint i=0; i<deque2.size(); i++) { 91 rp3d_test((*it3) == (*it5)); 92 ++it3; 93 ++it5; 94 } 95 96 // ----- Test capacity grow ----- // 97 Deque<std::string> deque5(mAllocator); 98 for (uint i=0; i<300; i++) { 99 deque5.addBack("test"); 100 } 101 102 // ----- Test [] operator ----- // 103 Deque<int> deque6(deque2); 104 deque6.addBack(1); 105 rp3d_test(deque6[0] == 1); 106 deque6.addBack(2); 107 rp3d_test(deque6[0] == 1); 108 rp3d_test(deque6[1] == 2); 109 deque6.addFront(5); 110 rp3d_test(deque6[0] == 5); 111 rp3d_test(deque6[1] == 1); 112 rp3d_test(deque6[2] == 2); 113 deque6.addFront(7); 114 rp3d_test(deque6[0] == 7); 115 rp3d_test(deque6[1] == 5); 116 rp3d_test(deque6[2] == 1); 117 rp3d_test(deque6[3] == 2); 118 deque6.popFront(); 119 rp3d_test(deque6[0] == 5); 120 rp3d_test(deque6[1] == 1); 121 rp3d_test(deque6[2] == 2); 122 } 123 testAddPopClear()124 void testAddPopClear() { 125 126 // ----- Test addBack() ----- // 127 128 Deque<int> deque1(mAllocator); 129 deque1.addBack(4); 130 rp3d_test(deque1.size() == 1); 131 rp3d_test(deque1.getBack() == 4); 132 rp3d_test(deque1.getFront() == 4); 133 deque1.addBack(9); 134 rp3d_test(deque1.size() == 2); 135 rp3d_test(deque1.getBack() == 9); 136 rp3d_test(deque1.getFront() == 4); 137 deque1.addBack(1); 138 rp3d_test(deque1.size() == 3); 139 rp3d_test(deque1.getBack() == 1); 140 rp3d_test(deque1.getFront() == 4); 141 142 // ----- Test addFront() ----- // 143 144 Deque<int> deque2(mAllocator); 145 deque2.addFront(4); 146 rp3d_test(deque2.size() == 1); 147 rp3d_test(deque2.getBack() == 4); 148 rp3d_test(deque2.getFront() == 4); 149 deque2.addFront(9); 150 rp3d_test(deque2.size() == 2); 151 rp3d_test(deque2.getBack() == 4); 152 rp3d_test(deque2.getFront() == 9); 153 deque2.addFront(1); 154 rp3d_test(deque2.size() == 3); 155 rp3d_test(deque2.getBack() == 4); 156 rp3d_test(deque2.getFront() == 1); 157 158 // ----- Test popFront() ----- // 159 160 deque1.popFront(); 161 rp3d_test(deque1.size() == 2); 162 rp3d_test(deque1.getFront() == 9); 163 deque1.popFront(); 164 rp3d_test(deque1.size() == 1); 165 rp3d_test(deque1.getFront() == 1); 166 deque1.popFront(); 167 rp3d_test(deque1.size() == 0); 168 169 // ----- Test popBack() ----- // 170 171 deque2.popBack(); 172 rp3d_test(deque2.size() == 2); 173 rp3d_test(deque2.getBack() == 9); 174 deque2.popBack(); 175 rp3d_test(deque2.size() == 1); 176 rp3d_test(deque2.getBack() == 1); 177 deque2.popBack(); 178 rp3d_test(deque2.size() == 0); 179 180 deque2.addBack(1); 181 deque2.addFront(2); 182 rp3d_test(deque2.getBack() == 1); 183 rp3d_test(deque2.getFront() == 2); 184 deque2.addBack(3); 185 deque2.addFront(4); 186 rp3d_test(deque2.getBack() == 3); 187 rp3d_test(deque2.getFront() == 4); 188 deque2.popBack(); 189 deque2.popFront(); 190 rp3d_test(deque2.getBack() == 1); 191 rp3d_test(deque2.getFront() == 2); 192 193 // ----- Test clear() ----- // 194 195 deque1.clear(); 196 deque2.clear(); 197 rp3d_test(deque1.size() == 0); 198 rp3d_test(deque2.size() == 0); 199 200 deque1.addBack(1); 201 deque1.addFront(2); 202 deque1.addBack(3); 203 deque1.addFront(4); 204 rp3d_test(deque1.getBack() == 3); 205 rp3d_test(deque1.getFront() == 4); 206 deque1.clear(); 207 rp3d_test(deque1.size() == 0); 208 209 } 210 testAssignment()211 void testAssignment() { 212 213 Deque<int> deque1(mAllocator); 214 deque1.addBack(1); 215 deque1.addBack(2); 216 deque1.addBack(3); 217 218 Deque<int> deque2(mAllocator); 219 deque2.addFront(5); 220 deque2.addBack(6); 221 222 Deque<int> deque3(mAllocator); 223 Deque<int> deque4(mAllocator); 224 deque4.addBack(7); 225 deque4.addBack(9); 226 227 deque3 = deque2; 228 rp3d_test(deque2.size() == deque3.size()); 229 rp3d_test(deque2.size() == 2); 230 rp3d_test(deque2.getBack() == deque3.getBack()); 231 rp3d_test(deque2.getFront() == deque3.getFront()); 232 233 deque4 = deque1; 234 rp3d_test(deque4.size() == deque1.size()) 235 rp3d_test(deque4.size() == 3) 236 rp3d_test(deque4.getFront() == 1); 237 rp3d_test(deque4.getBack() == 3); 238 } 239 testEquality()240 void testEquality() { 241 242 Deque<int> deque1(mAllocator); 243 deque1.addFront(1); 244 deque1.addBack(2); 245 deque1.addBack(3); 246 247 Deque<int> deque2(mAllocator); 248 deque2.addBack(1); 249 deque2.addBack(2); 250 251 Deque<int> deque3(mAllocator); 252 deque3.addBack(1); 253 deque3.addBack(2); 254 deque3.addBack(3); 255 256 Deque<int> deque4(mAllocator); 257 deque4.addFront(1); 258 deque4.addFront(5); 259 deque4.addFront(3); 260 261 Deque<int> deque5(mAllocator); 262 deque5.addFront(3); 263 deque5.addFront(2); 264 deque5.addFront(1); 265 266 rp3d_test(deque1 == deque1); 267 rp3d_test(deque1 != deque2); 268 rp3d_test(deque1 == deque3); 269 rp3d_test(deque1 != deque4); 270 rp3d_test(deque2 != deque4); 271 rp3d_test(deque1 == deque5); 272 } 273 testIterators()274 void testIterators() { 275 276 Deque<int> deque1(mAllocator); 277 278 rp3d_test(deque1.begin() == deque1.end()); 279 280 deque1.addBack(5); 281 deque1.addBack(6); 282 deque1.addBack(8); 283 deque1.addBack(-1); 284 285 Deque<int>::Iterator itBegin = deque1.begin(); 286 Deque<int>::Iterator itEnd = deque1.end(); 287 Deque<int>::Iterator it = deque1.begin(); 288 289 rp3d_test(itBegin < itEnd); 290 rp3d_test(itBegin <= itEnd); 291 rp3d_test(itEnd > itBegin); 292 rp3d_test(itEnd >= itBegin); 293 294 rp3d_test(itBegin == it); 295 rp3d_test(*it == 5); 296 rp3d_test(*(it++) == 5); 297 rp3d_test(*it == 6); 298 rp3d_test(*(it--) == 6); 299 rp3d_test(*it == 5); 300 rp3d_test(*(++it) == 6); 301 rp3d_test(*it == 6); 302 rp3d_test(*(--it) == 5); 303 rp3d_test(*it == 5); 304 rp3d_test(it == itBegin); 305 306 it = deque1.end(); 307 rp3d_test(it == itEnd); 308 it--; 309 rp3d_test(*it == -1); 310 it++; 311 rp3d_test(it == itEnd); 312 313 Deque<int> deque2(mAllocator); 314 for (auto it = deque1.begin(); it != deque1.end(); ++it) { 315 deque2.addBack(*it); 316 } 317 318 rp3d_test(deque1 == deque2); 319 320 it = itBegin; 321 rp3d_test(*(it + 2) == 8); 322 it += 2; 323 rp3d_test(*it == 8); 324 rp3d_test(*(it - 2) == 5); 325 it -= 2; 326 rp3d_test(*it == 5); 327 rp3d_test((itEnd - itBegin) == 4); 328 329 it = itBegin; 330 *it = 19; 331 rp3d_test(*it == 19); 332 } 333 334 }; 335 336 } 337 338 #endif 339