Mercurial Hosting > traffic-intelligence

comparison trajectorymanagement/test/TrajectoryTest.h @ 1159:e1e7acef8eab

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
moved trajectory management library into Traffic Intelligence
author Nicolas Saunier <nicolas.saunier@polymtl.ca>
date Mon, 22 Feb 2021 22:09:35 -0500
parents
children
comparison
equal deleted inserted replaced
1158:7eb972942f22 1159:e1e7acef8eab
1 #ifndef TRAJECTORYTEST_H_
2 #define TRAJECTORYTEST_H_
3
4 #include "../src/Trajectory.h"
5
6 #include <cppunit/extensions/HelperMacros.h>
7
8 using namespace std;
9
10 template<class T>
11 class TrajectoryTest: public CPPUNIT_NS::TestCase
12 {
13 CPPUNIT_TEST_SUITE(TrajectoryTest);
14 CPPUNIT_TEST(testTrajectory1);
15 CPPUNIT_TEST(testTrajectory2);
16 CPPUNIT_TEST(testTrajectory3);
17 CPPUNIT_TEST(testSetId);
18 CPPUNIT_TEST(testGetTrajectoryElement);
19 CPPUNIT_TEST(testAdd1);
20 CPPUNIT_TEST(testAdd2);
21 CPPUNIT_TEST(testAdd3);
22 CPPUNIT_TEST(testAdd4);
23 CPPUNIT_TEST(testAdd5);
24 CPPUNIT_TEST(testAdd6);
25 CPPUNIT_TEST(testAdd7);
26 CPPUNIT_TEST(testAdd8);
27 CPPUNIT_TEST(testAdd9);
28 CPPUNIT_TEST(testAdd10);
29 CPPUNIT_TEST(testAdd11);
30 CPPUNIT_TEST(testAdd12);
31 CPPUNIT_TEST(testAdd13);
32 CPPUNIT_TEST(testAdd14);
33 CPPUNIT_TEST(testAdd15);
34 CPPUNIT_TEST(testAdd16);
35 CPPUNIT_TEST(testAdd17);
36 CPPUNIT_TEST(testAdd18);
37 CPPUNIT_TEST(testAdd19);
38 CPPUNIT_TEST(testAdd20);
39 CPPUNIT_TEST(testAdd21);
40 CPPUNIT_TEST(testAdd22);
41 CPPUNIT_TEST(testAdd23);
42 CPPUNIT_TEST(testAdd24);
43 CPPUNIT_TEST(testAdd25);
44 CPPUNIT_TEST(testAdd26);
45 CPPUNIT_TEST(testAdd27);
46 CPPUNIT_TEST(testAdd28);
47 CPPUNIT_TEST(testAdd29);
48 CPPUNIT_TEST(testAdd30);
49 CPPUNIT_TEST(testAdd31);
50 CPPUNIT_TEST(testAdd32);
51 CPPUNIT_TEST(testAdd33);
52 CPPUNIT_TEST(testAdd34);
53 CPPUNIT_TEST(testAdd35);
54 CPPUNIT_TEST(testAdd36);
55 CPPUNIT_TEST(testAdd37);
56 CPPUNIT_TEST(testAdd38);
57 CPPUNIT_TEST(testAdd39);
58 CPPUNIT_TEST(testGetFrameNumber);
59 CPPUNIT_TEST(testGetPoint);
60 CPPUNIT_TEST(testGetCheckAscFrameNumber1);
61 CPPUNIT_TEST(testGetCheckAscFrameNumber2);
62 CPPUNIT_TEST(testSetCheckAscFrameNumber1);
63 CPPUNIT_TEST(testSetCheckAscFrameNumber2);
64 CPPUNIT_TEST(testSetCheckAscFrameNumber3);
65 CPPUNIT_TEST(testSetCheckAscFrameNumber4);
66 CPPUNIT_TEST(testSetCheckAscFrameNumber5);
67 CPPUNIT_TEST(testSetCheckAscFrameNumber6);
68 CPPUNIT_TEST(testSetCheckAscFrameNumber7);
69 CPPUNIT_TEST(testSetCheckAscFrameNumber8);
70 CPPUNIT_TEST(testSetCheckAscFrameNumber9);
71 CPPUNIT_TEST(testSetCheckAscFrameNumber10);
72 CPPUNIT_TEST(testSize1);
73 CPPUNIT_TEST(testSize2);
74 CPPUNIT_TEST(testSizeInc);
75 CPPUNIT_TEST(testSizeDec);
76 CPPUNIT_TEST(testSizeClear);
77 CPPUNIT_TEST(testEmptySizeInc);
78 CPPUNIT_TEST(testEmptySizeDec);
79 CPPUNIT_TEST(testInsert1);
80 CPPUNIT_TEST(testInsert2);
81 CPPUNIT_TEST(testInsert3);
82 CPPUNIT_TEST(testInsert4);
83 CPPUNIT_TEST(testInsert5);
84 CPPUNIT_TEST(testInsert6);
85 CPPUNIT_TEST(testInsert7);
86 CPPUNIT_TEST(testInsert8);
87 CPPUNIT_TEST(testInsert9);
88 CPPUNIT_TEST(testErase1);
89 CPPUNIT_TEST(testErase2);
90 CPPUNIT_TEST(testErase3);
91 CPPUNIT_TEST(testErase4);
92 CPPUNIT_TEST(testErase5);
93 CPPUNIT_TEST(testErase6);
94 CPPUNIT_TEST(testErase7);
95 CPPUNIT_TEST(testErase8);
96 CPPUNIT_TEST(testErase9);
97 CPPUNIT_TEST(testErase10);
98 CPPUNIT_TEST(testErase11);
99 CPPUNIT_TEST(testErase12);
100 CPPUNIT_TEST(testErase13);
101 CPPUNIT_TEST(testErase14);
102 CPPUNIT_TEST(testPop_back1);
103 CPPUNIT_TEST(testPop_back2);
104 CPPUNIT_TEST(testPop_back3);
105 CPPUNIT_TEST(testPop_back4);
106 CPPUNIT_TEST(testOperatorGet);
107 CPPUNIT_TEST(testAt1);
108 CPPUNIT_TEST(testAt2);
109 CPPUNIT_TEST(testAt3);
110 CPPUNIT_TEST(testAt4);
111 CPPUNIT_TEST(testAt5);
112 CPPUNIT_TEST(testAt6);
113 CPPUNIT_TEST(testAt7);
114 CPPUNIT_TEST(testShift1);
115 CPPUNIT_TEST(testShift2);
116 CPPUNIT_TEST(testOperatorEq1);
117 CPPUNIT_TEST(testOperatorEq2);
118 CPPUNIT_TEST(testOperatorEq3);
119 CPPUNIT_TEST(testOperatorEq4);
120 CPPUNIT_TEST(testOperatorEq5);
121 CPPUNIT_TEST(testOperatorEq6);
122 CPPUNIT_TEST(testOperatorEq7);
123 CPPUNIT_TEST(testOperatorEq8);
124 CPPUNIT_TEST(testOperatorAdd1);
125 CPPUNIT_TEST(testOperatorAdd2);
126 // CPPUNIT_TEST(testOperatorIn1);
127 // CPPUNIT_TEST(testOperatorIn2);
128 // CPPUNIT_TEST(testOperatorIn3);
129 // CPPUNIT_TEST(testOperatorOut1);
130 // CPPUNIT_TEST(testOperatorOut2);
131 // CPPUNIT_TEST(testOperatorOut3);
132 CPPUNIT_TEST(testMin1);
133 CPPUNIT_TEST(testMin2);
134 CPPUNIT_TEST(testMin3);
135 CPPUNIT_TEST(testMin4);
136 CPPUNIT_TEST(testMax1);
137 CPPUNIT_TEST(testMax2);
138 CPPUNIT_TEST(testMax3);
139 CPPUNIT_TEST(testMax4);
140 CPPUNIT_TEST_SUITE_END();
141
142 public:
143 void setUp(void)
144 {
145 sampleTrajectory.setId(1);
146
147 const unsigned int n = 100;
148 for (unsigned int i = 0; i < n; ++i)
149 {
150 T point;
151 initPoint(point, int(i), int(i + 10), int(i + 20));
152 sampleTrajectory.add(i + 1, point);
153 }
154 }
155
156 void tearDown(void)
157 {
158 sampleTrajectory.clear();
159 }
160
161 protected:
162 void testTrajectory1(void)
163 {
164 Trajectory<T> trajectory;
165 CPPUNIT_ASSERT_EQUAL(trajectory.getId(), (unsigned int) 0);
166 }
167
168 void testTrajectory2(void)
169 {
170 Trajectory<T> trajectory;
171 CPPUNIT_ASSERT_EQUAL(trajectory.getCheckAscFrameNumber(), false);
172 }
173
174 void testTrajectory3(void)
175 {
176 Trajectory<T> trajectory(sampleTrajectory);
177 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
178 }
179
180 void testSetId(void)
181 {
182 const unsigned int id = 123;
183 sampleTrajectory.setId(id);
184 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.getId(), id);
185 }
186
187 void testGetTrajectoryElement(void)
188 {
189 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
190 {
191 TrajectoryElement<T> trajectoryElement1 = sampleTrajectory.getTrajectoryElement(i);
192 T point;
193 initPoint(point, int(i), int(i + 10), int(i + 20));
194 TrajectoryElement<T> trajectoryElement2(i + 1, point);
195 CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2);
196 }
197 }
198
199 void testAdd1(void)
200 {
201 Trajectory<T> trajectory;
202 trajectory.setId(1);
203
204 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
205 {
206 const unsigned int frameNumber = sampleTrajectory.getFrameNumber(i);
207 const T point = sampleTrajectory.getPoint(i);
208
209 trajectory.add(frameNumber, point);
210
211 TrajectoryElement<T> trajectoryElement1 = trajectory.getTrajectoryElement(i);
212 TrajectoryElement<T> trajectoryElement2(frameNumber, point);
213
214 CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2);
215 }
216
217 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
218 }
219
220 void testAdd2(void)
221 {
222 Trajectory<T> trajectory;
223 trajectory.setId(1);
224
225 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
226 {
227 const unsigned int frameNumber = sampleTrajectory.getFrameNumber(i);
228 const T point = sampleTrajectory.getPoint(i);
229
230 //trajectory.add(point);
231 trajectory.add(frameNumber, point);
232
233 const TrajectoryElement<T> trajectoryElement1(frameNumber, point);
234 const TrajectoryElement<T> trajectoryElement2 = trajectory.getTrajectoryElement(i);
235
236 CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2);
237 }
238
239 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
240 }
241
242 void testAdd3(void)
243 {
244 Trajectory<T> trajectory;
245 trajectory.setId(1);
246
247 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
248 {
249 const unsigned int frameNumber = sampleTrajectory.getFrameNumber(i);
250 const T point = sampleTrajectory.getPoint(i);
251
252 const TrajectoryElement<T> trajectoryElement1(frameNumber, point);
253
254 trajectory.add(trajectoryElement1);
255
256 const TrajectoryElement<T> trajectoryElement2 = trajectory.getTrajectoryElement(i);
257
258 CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2);
259 }
260
261 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
262 }
263
264 void testAdd4(void)
265 {
266 const T point = sampleTrajectory.getPoint(0);
267 Trajectory<T> trajectory;
268 trajectory.setCheckAscFrameNumber(true);
269 CPPUNIT_ASSERT_NO_THROW(trajectory.add(0, point));
270 }
271
272 void testAdd5(void)
273 {
274 const T point = sampleTrajectory.getPoint(0);
275 Trajectory<T> trajectory;
276 trajectory.setCheckAscFrameNumber(false);
277 CPPUNIT_ASSERT_NO_THROW(trajectory.add(0, point));
278 }
279
280 void testAdd6(void)
281 {
282 const T point = sampleTrajectory.getPoint(0);
283 Trajectory<T> trajectory;
284 trajectory.setCheckAscFrameNumber(true);
285 CPPUNIT_ASSERT_NO_THROW(trajectory.add(0, point));
286 CPPUNIT_ASSERT_THROW(trajectory.add(0, point), TrajectoryFrameNumberErrorException);
287 }
288
289 void testAdd7(void)
290 {
291 const T point = sampleTrajectory.getPoint(0);
292 Trajectory<T> trajectory;
293 trajectory.setCheckAscFrameNumber(false);
294 CPPUNIT_ASSERT_NO_THROW(trajectory.add(0, point));
295 CPPUNIT_ASSERT_NO_THROW(trajectory.add(0, point));
296 }
297
298 void testAdd8(void)
299 {
300 const T point = sampleTrajectory.getPoint(0);
301 Trajectory<T> trajectory;
302 trajectory.setCheckAscFrameNumber(true);
303 CPPUNIT_ASSERT_NO_THROW(trajectory.add(0, point));
304 CPPUNIT_ASSERT_NO_THROW(trajectory.add(1, point));
305 }
306
307 void testAdd9(void)
308 {
309 const T point = sampleTrajectory.getPoint(0);
310 Trajectory<T> trajectory;
311 trajectory.setCheckAscFrameNumber(false);
312 CPPUNIT_ASSERT_NO_THROW(trajectory.add(0, point));
313 CPPUNIT_ASSERT_NO_THROW(trajectory.add(1, point));
314 }
315
316 void testAdd10(void)
317 {
318 const T point = sampleTrajectory.getPoint(0);
319 Trajectory<T> trajectory;
320 trajectory.setCheckAscFrameNumber(true);
321 CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point));
322 }
323
324 void testAdd11(void)
325 {
326 const T point = sampleTrajectory.getPoint(0);
327 Trajectory<T> trajectory;
328 trajectory.setCheckAscFrameNumber(false);
329 CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point));
330 }
331
332 void testAdd12(void)
333 {
334 const T point = sampleTrajectory.getPoint(0);
335 Trajectory<T> trajectory;
336 trajectory.setCheckAscFrameNumber(true);
337 CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point));
338 CPPUNIT_ASSERT_THROW(trajectory.add(2, point), TrajectoryFrameNumberErrorException);
339 }
340
341 void testAdd13(void)
342 {
343 const T point = sampleTrajectory.getPoint(0);
344 Trajectory<T> trajectory;
345 trajectory.setCheckAscFrameNumber(false);
346 CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point));
347 CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point));
348 }
349
350 void testAdd14(void)
351 {
352 const T point = sampleTrajectory.getPoint(0);
353 Trajectory<T> trajectory;
354 trajectory.setCheckAscFrameNumber(true);
355 CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point));
356 CPPUNIT_ASSERT_NO_THROW(trajectory.add(3, point));
357 }
358
359 void testAdd15(void)
360 {
361 const T point = sampleTrajectory.getPoint(0);
362 Trajectory<T> trajectory;
363 trajectory.setCheckAscFrameNumber(false);
364 CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point));
365 CPPUNIT_ASSERT_NO_THROW(trajectory.add(3, point));
366 }
367
368 void testAdd16(void)
369 {
370 const T point = sampleTrajectory.getPoint(0);
371 Trajectory<T> trajectory;
372 trajectory.setCheckAscFrameNumber(true);
373 CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point));
374 CPPUNIT_ASSERT_NO_THROW(trajectory.add(4, point));
375 }
376
377 void testAdd17(void)
378 {
379 const T point = sampleTrajectory.getPoint(0);
380 Trajectory<T> trajectory;
381 trajectory.setCheckAscFrameNumber(false);
382 CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point));
383 CPPUNIT_ASSERT_NO_THROW(trajectory.add(4, point));
384 }
385
386 void testAdd18(void)
387 {
388 const T point = sampleTrajectory.getPoint(0);
389
390 Trajectory<T> trajectory;
391 trajectory.setCheckAscFrameNumber(true);
392 trajectory.add(10, point);
393
394 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
395 {
396 CPPUNIT_ASSERT_THROW(trajectory.add(10 + i - 1, point), TrajectoryFrameNumberErrorException);
397 CPPUNIT_ASSERT_THROW(trajectory.add(10 + i, point), TrajectoryFrameNumberErrorException);
398 CPPUNIT_ASSERT_NO_THROW(trajectory.add(10 + i + 1, point));
399 }
400
401 CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) (sampleTrajectory.size() + 1));
402 }
403
404 void testAdd19(void)
405 {
406 const T point = sampleTrajectory.getPoint(0);
407
408 Trajectory<T> trajectory;
409 trajectory.setCheckAscFrameNumber(false);
410 trajectory.add(10, point);
411
412 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
413 {
414 CPPUNIT_ASSERT_NO_THROW(trajectory.add(10 + i - 1, point));
415 CPPUNIT_ASSERT_NO_THROW(trajectory.add(10 + i, point));
416 CPPUNIT_ASSERT_NO_THROW(trajectory.add(10 + i + 1, point));
417 }
418
419 CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) (3 * sampleTrajectory.size() + 1));
420 }
421
422 void testAdd20(void)
423 {
424 sampleTrajectory.setCheckAscFrameNumber(true);
425 const unsigned int frameNumber = sampleTrajectory.getFrameNumber(sampleTrajectory.size() - 1);
426 const T point = sampleTrajectory.getPoint(sampleTrajectory.size() - 1);
427
428 for (unsigned int i = 0; i <= frameNumber; ++i)
429 {
430 CPPUNIT_ASSERT_THROW(sampleTrajectory.add(i, point), TrajectoryFrameNumberErrorException);
431 }
432
433 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.add(frameNumber + 1, point));
434
435 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 101);
436 }
437
438 void testAdd21(void)
439 {
440 sampleTrajectory.setCheckAscFrameNumber(false);
441 const unsigned int frameNumber = sampleTrajectory.getFrameNumber(sampleTrajectory.size() - 1);
442 const T point = sampleTrajectory.getPoint(sampleTrajectory.size() - 1);
443
444 for (unsigned int i = 0; i <= frameNumber; ++i)
445 {
446 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.add(i, point));
447 }
448
449 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.add(frameNumber + 1, point));
450
451 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 202);
452 }
453
454 void testAdd22(void)
455 {
456 const T point = sampleTrajectory.getPoint(0);
457 Trajectory<T> trajectory;
458 trajectory.setCheckAscFrameNumber(true);
459 const TrajectoryElement<T> trajectoryElement(0, point);
460 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement));
461 }
462
463 void testAdd23(void)
464 {
465 const T point = sampleTrajectory.getPoint(0);
466 Trajectory<T> trajectory;
467 trajectory.setCheckAscFrameNumber(false);
468 const TrajectoryElement<T> trajectoryElement(0, point);
469 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement));
470 }
471
472 void testAdd24(void)
473 {
474 const T point = sampleTrajectory.getPoint(0);
475 Trajectory<T> trajectory;
476 trajectory.setCheckAscFrameNumber(true);
477 const TrajectoryElement<T> trajectoryElement(0, point);
478 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement));
479 CPPUNIT_ASSERT_THROW(trajectory.add(trajectoryElement), TrajectoryFrameNumberErrorException);
480 }
481
482 void testAdd25(void)
483 {
484 const T point = sampleTrajectory.getPoint(0);
485 Trajectory<T> trajectory;
486 trajectory.setCheckAscFrameNumber(false);
487 const TrajectoryElement<T> trajectoryElement(0, point);
488 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement));
489 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement));
490 }
491
492 void testAdd26(void)
493 {
494 const T point = sampleTrajectory.getPoint(0);
495 Trajectory<T> trajectory;
496 trajectory.setCheckAscFrameNumber(true);
497 const TrajectoryElement<T> trajectoryElement1(0, point);
498 const TrajectoryElement<T> trajectoryElement2(1, point);
499 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1));
500 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement2));
501 }
502
503 void testAdd27(void)
504 {
505 const T point = sampleTrajectory.getPoint(0);
506 Trajectory<T> trajectory;
507 trajectory.setCheckAscFrameNumber(false);
508 const TrajectoryElement<T> trajectoryElement1(0, point);
509 const TrajectoryElement<T> trajectoryElement2(1, point);
510 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1));
511 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement2));
512 }
513
514 void testAdd28(void)
515 {
516 const T point = sampleTrajectory.getPoint(0);
517 Trajectory<T> trajectory;
518 trajectory.setCheckAscFrameNumber(true);
519 const TrajectoryElement<T> trajectoryElement(2, point);
520 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement));
521 }
522
523 void testAdd29(void)
524 {
525 const T point = sampleTrajectory.getPoint(0);
526 Trajectory<T> trajectory;
527 trajectory.setCheckAscFrameNumber(false);
528 const TrajectoryElement<T> trajectoryElement(2, point);
529 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement));
530 }
531
532 void testAdd30(void)
533 {
534 const T point = sampleTrajectory.getPoint(0);
535 Trajectory<T> trajectory;
536 trajectory.setCheckAscFrameNumber(true);
537 const TrajectoryElement<T> trajectoryElement(2, point);
538 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement));
539 CPPUNIT_ASSERT_THROW(trajectory.add(trajectoryElement), TrajectoryFrameNumberErrorException);
540 }
541
542 void testAdd31(void)
543 {
544 const T point = sampleTrajectory.getPoint(0);
545 Trajectory<T> trajectory;
546 trajectory.setCheckAscFrameNumber(false);
547 const TrajectoryElement<T> trajectoryElement(2, point);
548 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement));
549 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement));
550 }
551
552 void testAdd32(void)
553 {
554 const T point = sampleTrajectory.getPoint(0);
555 Trajectory<T> trajectory;
556 trajectory.setCheckAscFrameNumber(true);
557 const TrajectoryElement<T> trajectoryElement1(2, point);
558 const TrajectoryElement<T> trajectoryElement2(3, point);
559 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1) );
560 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement2));
561 }
562
563 void testAdd33(void)
564 {
565 const T point = sampleTrajectory.getPoint(0);
566 Trajectory<T> trajectory;
567 trajectory.setCheckAscFrameNumber(false);
568 const TrajectoryElement<T> trajectoryElement1(2, point);
569 const TrajectoryElement<T> trajectoryElement2(3, point);
570 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1));
571 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement2));
572 }
573
574 void testAdd34(void)
575 {
576 const T point = sampleTrajectory.getPoint(0);
577 Trajectory<T> trajectory;
578 trajectory.setCheckAscFrameNumber(true);
579 const TrajectoryElement<T> trajectoryElement1(2, point);
580 const TrajectoryElement<T> trajectoryElement2(4, point);
581 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1));
582 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement2));
583 }
584
585 void testAdd35(void)
586 {
587 const T point = sampleTrajectory.getPoint(0);
588 Trajectory<T> trajectory;
589 trajectory.setCheckAscFrameNumber(false);
590 const TrajectoryElement<T> trajectoryElement1(2, point);
591 const TrajectoryElement<T> trajectoryElement2(4, point);
592 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1));
593 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement2));
594 }
595
596 void testAdd36(void)
597 {
598 const T point = sampleTrajectory.getPoint(0);
599
600 Trajectory<T> trajectory;
601 trajectory.setCheckAscFrameNumber(true);
602 const TrajectoryElement<T> trajectoryElement1(10, point);
603 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1));
604
605 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
606 {
607 const TrajectoryElement<T> trajectoryElement2(10 + i - 1, point);
608 const TrajectoryElement<T> trajectoryElement3(10 + i, point);
609 const TrajectoryElement<T> trajectoryElement4(10 + i + 1, point);
610 CPPUNIT_ASSERT_THROW(trajectory.add(trajectoryElement2), TrajectoryFrameNumberErrorException);
611 CPPUNIT_ASSERT_THROW(trajectory.add(trajectoryElement3), TrajectoryFrameNumberErrorException);
612 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement4));
613 }
614
615 CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) (sampleTrajectory.size() + 1));
616 }
617
618 void testAdd37(void)
619 {
620 const T point = sampleTrajectory.getPoint(0);
621
622 Trajectory<T> trajectory;
623 trajectory.setCheckAscFrameNumber(false);
624 const TrajectoryElement<T> trajectoryElement1(10, point);
625 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1));
626
627 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
628 {
629 const TrajectoryElement<T> trajectoryElement2(10 + i - 1, point);
630 const TrajectoryElement<T> trajectoryElement3(10 + i, point);
631 const TrajectoryElement<T> trajectoryElement4(10 + i + 1, point);
632 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement2));
633 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement3));
634 CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement4));
635 }
636
637 CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) (3 * sampleTrajectory.size() + 1));
638 }
639
640 void testAdd38(void)
641 {
642 sampleTrajectory.setCheckAscFrameNumber(true);
643 const unsigned int frameNumber = sampleTrajectory.getFrameNumber(sampleTrajectory.size() - 1);
644 const T point = sampleTrajectory.getPoint(sampleTrajectory.size() - 1);
645
646 for (unsigned int i = 0; i <= frameNumber; ++i)
647 {
648 const TrajectoryElement<T> trajectoryElement(i, point);
649 CPPUNIT_ASSERT_THROW(sampleTrajectory.add(trajectoryElement), TrajectoryFrameNumberErrorException);
650 }
651
652 const TrajectoryElement<T> trajectoryElement(frameNumber + 1, point);
653 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.add(trajectoryElement));
654
655 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 101);
656 }
657
658 void testAdd39(void)
659 {
660 sampleTrajectory.setCheckAscFrameNumber(false);
661 const unsigned int frameNumber = sampleTrajectory.getFrameNumber(sampleTrajectory.size() - 1);
662 const T point = sampleTrajectory.getPoint(sampleTrajectory.size() - 1);
663
664 for (unsigned int i = 0; i <= frameNumber; ++i)
665 {
666 const TrajectoryElement<T> trajectoryElement(i, point);
667 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.add(trajectoryElement));
668 }
669
670 const TrajectoryElement<T> trajectoryElement(frameNumber + 1, point);
671 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.add(trajectoryElement));
672
673 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 202);
674 }
675
676 void testGetFrameNumber(void)
677 {
678 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
679 {
680 unsigned int frameNumber = sampleTrajectory.getFrameNumber(i);
681 CPPUNIT_ASSERT_EQUAL(frameNumber, i + 1);
682 }
683 }
684
685 void testGetPoint(void)
686 {
687 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
688 {
689 T point1 = sampleTrajectory.getPoint(i);
690 T point2;
691 initPoint(point2, int(i), int(i + 10), int(i + 20));
692 CPPUNIT_ASSERT_EQUAL(point1, point2);
693 }
694 }
695
696 void testGetCheckAscFrameNumber1(void)
697 {
698 sampleTrajectory.setCheckAscFrameNumber(false);
699 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.getCheckAscFrameNumber(), false);
700 }
701
702 void testGetCheckAscFrameNumber2(void)
703 {
704 sampleTrajectory.setCheckAscFrameNumber(true);
705 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.getCheckAscFrameNumber(), true);
706 }
707
708 void testSetCheckAscFrameNumber1(void)
709 {
710 Trajectory<T> trajectory;
711 CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(false));
712 CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(true));
713 }
714
715 void testSetCheckAscFrameNumber2(void)
716 {
717 T point;
718 initPoint(point, int(10), int(20), int(30));
719 Trajectory<T> trajectory;
720 trajectory.add(0, point);
721 CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(false));
722 CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(true));
723 }
724
725 void testSetCheckAscFrameNumber3(void)
726 {
727 T point;
728 initPoint(point, int(10), int(20), int(30));
729 Trajectory<T> trajectory;
730 trajectory.add(1, point);
731 CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(false));
732 CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(true));
733 }
734
735 void testSetCheckAscFrameNumber4(void)
736 {
737 T point;
738 initPoint(point, int(10), int(20), int(30));
739 Trajectory<T> trajectory;
740 trajectory.add(1, point);
741 trajectory.add(2, point);
742 CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(false));
743 CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(true));
744 }
745
746 void testSetCheckAscFrameNumber5(void)
747 {
748 T point;
749 initPoint(point, int(10), int(20), int(30));
750 Trajectory<T> trajectory;
751 trajectory.add(1, point);
752 trajectory.add(1, point);
753 CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(false));
754 CPPUNIT_ASSERT_THROW(trajectory.setCheckAscFrameNumber(true), TrajectoryFrameNumberErrorException);
755 }
756
757 void testSetCheckAscFrameNumber6(void)
758 {
759 T point;
760 initPoint(point, int(10), int(20), int(30));
761 Trajectory<T> trajectory;
762 trajectory.add(2, point);
763 trajectory.add(1, point);
764 CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(false));
765 CPPUNIT_ASSERT_THROW(trajectory.setCheckAscFrameNumber(true), TrajectoryFrameNumberErrorException);
766 }
767
768 void testSetCheckAscFrameNumber7(void)
769 {
770 T point;
771 initPoint(point, int(10), int(20), int(30));
772 Trajectory<T> trajectory;
773 trajectory.add(1, point);
774 trajectory.add(2, point);
775 trajectory.add(2, point);
776 trajectory.add(3, point);
777 CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(false));
778 CPPUNIT_ASSERT_THROW(trajectory.setCheckAscFrameNumber(true), TrajectoryFrameNumberErrorException);
779 }
780
781 void testSetCheckAscFrameNumber8(void)
782 {
783 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.setCheckAscFrameNumber(false));
784 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.setCheckAscFrameNumber(true));
785 }
786
787 void testSetCheckAscFrameNumber9(void)
788 {
789 T point;
790 initPoint(point, int(10), int(20), int(30));
791 sampleTrajectory.add(100, point);
792 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.setCheckAscFrameNumber(false));
793 CPPUNIT_ASSERT_THROW(sampleTrajectory.setCheckAscFrameNumber(true), TrajectoryFrameNumberErrorException);
794 }
795
796 void testSetCheckAscFrameNumber10(void)
797 {
798 T point;
799 initPoint(point, int(10), int(20), int(30));
800 sampleTrajectory.add(101, point);
801 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.setCheckAscFrameNumber(false));
802 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.setCheckAscFrameNumber(true));
803 }
804
805 void testSize1(void)
806 {
807 Trajectory<T> trajectory;
808 CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) 0);
809 }
810
811 void testSize2(void)
812 {
813 Trajectory<T> trajectory;
814 trajectory = sampleTrajectory;
815 CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) 100);
816 }
817
818 void testSizeInc(void)
819 {
820 Trajectory<T> trajectory;
821
822 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
823 {
824 CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) i);
825
826 T point = (sampleTrajectory)[i];
827 trajectory.add(point);
828 }
829
830 CPPUNIT_ASSERT_EQUAL(trajectory.size(), sampleTrajectory.size());
831 }
832
833 void testSizeDec(void)
834 {
835 unsigned int size = sampleTrajectory.size();
836
837 for (unsigned int i = 0; i < size; ++i)
838 {
839 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int)(size - i));
840
841 sampleTrajectory.pop_back();
842 }
843
844 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 0);
845 }
846
847 void testSizeClear(void)
848 {
849 sampleTrajectory.clear();
850 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 0);
851 }
852
853 void testEmptySizeInc(void)
854 {
855 Trajectory<T> trajectory;
856 CPPUNIT_ASSERT_EQUAL(trajectory.empty(), true);
857
858 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
859 {
860 const TrajectoryElement<T> trajectoryElement = sampleTrajectory.getTrajectoryElement(i);
861 trajectory.add(trajectoryElement);
862 CPPUNIT_ASSERT_EQUAL(trajectory.empty(), false);
863 }
864 }
865
866 void testEmptySizeDec(void)
867 {
868 Trajectory<T> trajectory;
869 CPPUNIT_ASSERT_EQUAL(trajectory.empty(), true);
870
871 trajectory = sampleTrajectory;
872
873 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
874 {
875 CPPUNIT_ASSERT_EQUAL(trajectory.empty(), false);
876 trajectory.pop_back();
877 }
878
879 CPPUNIT_ASSERT_EQUAL(trajectory.empty(), true);
880 }
881
882 void testInsert1(void)
883 {
884 T point;
885 initPoint(point, int(10), int(40), int(80));
886
887 Trajectory<T> trajectory;
888 CPPUNIT_ASSERT_THROW(trajectory.insert(1, 4, point), TrajectoryOutOfRangeErrorException);
889 }
890
891 void testInsert2(void)
892 {
893 T point;
894 initPoint(point, int(10), int(40), int(80));
895
896 Trajectory<T> trajectory;
897 CPPUNIT_ASSERT_NO_THROW(trajectory.insert(0, 4, point));
898
899 CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) 1);
900
901 const TrajectoryElement<T> trajectoryElement1 = trajectory.getTrajectoryElement(0);
902 const TrajectoryElement<T> trajectoryElement2(4, point);
903 CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2);
904 }
905
906 void testInsert3(void)
907 {
908 T point;
909 initPoint(point, int(10), int(40), int(80));
910
911 Trajectory<T> trajectory;
912 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.insert(sampleTrajectory.size(), 4, point));
913 }
914
915 void testInsert4(void)
916 {
917 T point;
918 initPoint(point, int(10), int(40), int(80));
919
920 Trajectory<T> trajectory;
921 CPPUNIT_ASSERT_THROW(sampleTrajectory.insert(sampleTrajectory.size() + 1, 4, point), TrajectoryOutOfRangeErrorException);
922 }
923
924 void testInsert5(void)
925 {
926 T point;
927 initPoint(point, int(10), int(40), int(80));
928
929 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.insert(sampleTrajectory.size() - 1, 20, point));
930
931 const TrajectoryElement<T> trajectoryElement1 = sampleTrajectory.getTrajectoryElement(sampleTrajectory.size() - 1);
932 const TrajectoryElement<T> trajectoryElement2(20, point);
933 CPPUNIT_ASSERT (trajectoryElement1 != trajectoryElement2);
934 }
935
936 void testInsert6(void)
937 {
938 T point;
939 initPoint(point, int(10), int(40), int(80));
940
941 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.insert(sampleTrajectory.size(), 20, point));
942
943 const TrajectoryElement<T> trajectoryElement1 = sampleTrajectory.getTrajectoryElement(sampleTrajectory.size());
944 const TrajectoryElement<T> trajectoryElement2(20, point);
945 CPPUNIT_ASSERT(trajectoryElement1 != trajectoryElement2);
946 }
947
948 void testInsert7(void)
949 {
950 T point;
951 initPoint(point, int(10), int(40), int(80));
952
953 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.insert(10, 20, point));
954
955 const TrajectoryElement<T> trajectoryElement1 = sampleTrajectory.getTrajectoryElement(10);
956 const TrajectoryElement<T> trajectoryElement2(20, point);
957 CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2);
958 }
959
960 void testInsert8(void)
961 {
962 sampleTrajectory.setCheckAscFrameNumber(true);
963
964 T point;
965 initPoint(point, int(10), int(40), int(80));
966
967 CPPUNIT_ASSERT_THROW(sampleTrajectory.insert(sampleTrajectory.size() + 1, 100, point), TrajectoryOutOfRangeErrorException);
968 CPPUNIT_ASSERT_THROW(sampleTrajectory.insert(sampleTrajectory.size(), 100, point), TrajectoryFrameNumberErrorException);
969 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.insert(sampleTrajectory.size(), 101, point));
970 }
971
972 void testInsert9(void)
973 {
974 sampleTrajectory.setCheckAscFrameNumber(true);
975
976 T point;
977 initPoint(point, int(10), int(40), int(80));
978
979 for (unsigned int i = 0; i < sampleTrajectory.size() - 1; ++i)
980 {
981 CPPUNIT_ASSERT_THROW(sampleTrajectory.insert(i, 20, point), TrajectoryFrameNumberErrorException);
982 CPPUNIT_ASSERT_THROW(sampleTrajectory.insert(i, 200, point), TrajectoryFrameNumberErrorException);
983 }
984 }
985
986 void testErase1(void)
987 {
988 Trajectory<T> trajectory;
989 CPPUNIT_ASSERT_THROW(trajectory.erase(0), TrajectoryOutOfRangeErrorException);
990 }
991
992 void testErase2(void)
993 {
994 Trajectory<T> trajectory;
995 CPPUNIT_ASSERT_THROW(trajectory.erase(1), TrajectoryOutOfRangeErrorException);
996 }
997
998 void testErase3(void)
999 {
1000 const T point = sampleTrajectory.getPoint(0);
1001 Trajectory<T> trajectory;
1002 trajectory.add(point);
1003 CPPUNIT_ASSERT_NO_THROW(trajectory.erase(0));
1004
1005 Trajectory<T> emptyTrajectory;
1006 CPPUNIT_ASSERT_EQUAL(trajectory, emptyTrajectory);
1007 }
1008
1009 void testErase4(void)
1010 {
1011 const T point = sampleTrajectory.getPoint(0);
1012 Trajectory<T> trajectory;
1013 trajectory.add(point);
1014 CPPUNIT_ASSERT_THROW(trajectory.erase(1), TrajectoryOutOfRangeErrorException);
1015 }
1016
1017 void testErase5(void)
1018 {
1019 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(0));
1020 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 99);
1021 }
1022
1023 void testErase6(void)
1024 {
1025 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(1));
1026 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 99);
1027 }
1028
1029 void testErase7(void)
1030 {
1031 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(0));
1032 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(0));
1033 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 98);
1034 }
1035
1036 void testErase8(void)
1037 {
1038 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(sampleTrajectory.size() - 1));
1039 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(sampleTrajectory.size() - 1));
1040 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 98);
1041 }
1042
1043 void testErase9(void)
1044 {
1045 CPPUNIT_ASSERT_THROW(sampleTrajectory.erase(sampleTrajectory.size()), TrajectoryOutOfRangeErrorException);
1046 }
1047
1048 void testErase10(void)
1049 {
1050 CPPUNIT_ASSERT_THROW(sampleTrajectory.erase(sampleTrajectory.size() + 1), TrajectoryOutOfRangeErrorException);
1051 }
1052
1053 void testErase11(void)
1054 {
1055 for (unsigned int i = 0; i < 100; ++i)
1056 {
1057 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(0));
1058 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), 100 - i - 1);
1059 }
1060
1061 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 0);
1062
1063 CPPUNIT_ASSERT_THROW(sampleTrajectory.erase(0), TrajectoryOutOfRangeErrorException);
1064 }
1065
1066 void testErase12(void)
1067 {
1068 for (unsigned int i = 0; i < 100; ++i)
1069 {
1070 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(sampleTrajectory.size() - 1));
1071 }
1072
1073 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 0);
1074
1075 CPPUNIT_ASSERT_THROW(sampleTrajectory.erase(0), TrajectoryOutOfRangeErrorException);
1076 }
1077
1078 void testErase13(void)
1079 {
1080 T point;
1081 initPoint(point, int(10), int(40), int(80));
1082
1083 Trajectory<T> trajectory = sampleTrajectory;
1084 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
1085
1086 trajectory.insert(20, 20, point);
1087 CPPUNIT_ASSERT(trajectory != sampleTrajectory);
1088
1089 trajectory.erase(20);
1090 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
1091 }
1092
1093 void testErase14(void)
1094 {
1095 T point;
1096 initPoint(point, int(10), int(40), int(80));
1097
1098 Trajectory<T> trajectory = sampleTrajectory;
1099 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
1100
1101 trajectory.insert(20, 20, point);
1102 CPPUNIT_ASSERT(trajectory != sampleTrajectory);
1103
1104 trajectory.erase(10);
1105 CPPUNIT_ASSERT(trajectory != sampleTrajectory);
1106 }
1107
1108 void testPop_back1(void)
1109 {
1110 Trajectory<T> trajectory;
1111 CPPUNIT_ASSERT_THROW(trajectory.pop_back(), TrajectoryLengthErrorException);
1112 }
1113
1114 void testPop_back2(void)
1115 {
1116 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 100);
1117
1118 for (int i = 100; i > 0; --i)
1119 {
1120 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.pop_back());
1121 CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int)(i - 1));
1122 }
1123
1124 CPPUNIT_ASSERT_THROW(sampleTrajectory.pop_back(), TrajectoryLengthErrorException);
1125 }
1126
1127 void testPop_back3(void)
1128 {
1129 T point;
1130 initPoint(point, int(10), int(40), int(80));
1131
1132 Trajectory<T> trajectory = sampleTrajectory;
1133 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
1134
1135 trajectory.add(point);
1136 CPPUNIT_ASSERT(trajectory != sampleTrajectory);
1137
1138 trajectory.pop_back();
1139 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
1140 }
1141
1142 void testPop_back4(void)
1143 {
1144 T point;
1145 initPoint(point, int(10), int(40), int(80));
1146
1147 Trajectory<T> trajectory = sampleTrajectory;
1148 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
1149
1150 trajectory.insert(trajectory.size(), 20, point);
1151 CPPUNIT_ASSERT(trajectory != sampleTrajectory);
1152
1153 trajectory.pop_back();
1154 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
1155 }
1156
1157 void testOperatorGet(void)
1158 {
1159 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
1160 {
1161 T point1 = sampleTrajectory[i];
1162 T point2;
1163 initPoint(point2, int(i), int(i + 10), int(i + 20));
1164 CPPUNIT_ASSERT_EQUAL(point1, point2);
1165 }
1166 }
1167
1168 void testAt1(void)
1169 {
1170 Trajectory<T> trajectory;
1171 CPPUNIT_ASSERT_THROW(trajectory.at(0), TrajectoryOutOfRangeErrorException);
1172 CPPUNIT_ASSERT_THROW(trajectory.at(1), TrajectoryOutOfRangeErrorException);
1173 CPPUNIT_ASSERT_THROW(trajectory.at(2), TrajectoryOutOfRangeErrorException);
1174 }
1175
1176 void testAt2(void)
1177 {
1178 const T point = sampleTrajectory.getPoint(0);
1179 Trajectory<T> trajectory;
1180 trajectory.add(point);
1181 CPPUNIT_ASSERT_NO_THROW(trajectory.at(0));
1182 CPPUNIT_ASSERT_THROW(trajectory.at(1), TrajectoryOutOfRangeErrorException);
1183 CPPUNIT_ASSERT_THROW(trajectory.at(2), TrajectoryOutOfRangeErrorException);
1184 }
1185
1186 void testAt3(void)
1187 {
1188 const T point = sampleTrajectory.getPoint(0);
1189 Trajectory<T> trajectory;
1190 trajectory.add(point);
1191 trajectory.add(point);
1192 CPPUNIT_ASSERT_NO_THROW(trajectory.at(0));
1193 CPPUNIT_ASSERT_NO_THROW(trajectory.at(1));
1194 CPPUNIT_ASSERT_THROW(trajectory.at(2), TrajectoryOutOfRangeErrorException);
1195 }
1196
1197 void testAt4(void)
1198 {
1199 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
1200 {
1201 T point1;
1202 CPPUNIT_ASSERT_NO_THROW(point1 = sampleTrajectory.at(i));
1203 T point2;
1204 initPoint(point2, int(i), int(i + 10), int(i + 20));
1205 CPPUNIT_ASSERT_EQUAL(point1, point2);
1206 }
1207 }
1208
1209 void testAt5(void)
1210 {
1211 CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.at(sampleTrajectory.size() - 1));
1212 }
1213
1214 void testAt6(void)
1215 {
1216 CPPUNIT_ASSERT_THROW(sampleTrajectory.at(sampleTrajectory.size()), TrajectoryOutOfRangeErrorException);
1217 }
1218
1219 void testAt7(void)
1220 {
1221 CPPUNIT_ASSERT_THROW(sampleTrajectory.at(sampleTrajectory.size() + 1), TrajectoryOutOfRangeErrorException);
1222 }
1223
1224 void testShift1(void)
1225 {
1226 const int shiftX = 8;
1227 const int shiftY = 4;
1228 const int shiftZ = 2;
1229
1230 T shiftPoint;
1231 initPoint(shiftPoint, shiftX, shiftY, shiftZ);
1232 sampleTrajectory.shift(shiftPoint);
1233
1234 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
1235 {
1236 const T p1 = sampleTrajectory.getPoint(i);
1237 T p2;
1238 initPoint(p2, int(i) + shiftX, int(i + 10) + shiftY, int(i + 20) + shiftZ);
1239 CPPUNIT_ASSERT_EQUAL(p1, p2);
1240 }
1241 }
1242
1243 void testShift2(void)
1244 {
1245 const int shiftX1 = 1;
1246 const int shiftX2 = 10;
1247 const int shiftY1 = 2;
1248 const int shiftY2 = 20;
1249 const int shiftZ1 = 3;
1250 const int shiftZ2 = 30;
1251
1252 T shiftPoint1;
1253 T shiftPoint2;
1254 T shiftPoint3;
1255 initPoint(shiftPoint1, shiftX1, shiftY1, shiftZ1);
1256 initPoint(shiftPoint2, shiftX2, shiftY2, shiftZ2);
1257 initPoint(shiftPoint3, shiftX1 + shiftX2, shiftY1 + shiftY2, shiftZ1 + shiftZ2);
1258
1259 Trajectory<T> trajectory = sampleTrajectory;
1260
1261 trajectory.shift(shiftPoint1);
1262 trajectory.shift(shiftPoint2);
1263
1264 sampleTrajectory.shift(shiftPoint3);
1265
1266 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
1267 }
1268
1269 void testOperatorEq1(void)
1270 {
1271 CPPUNIT_ASSERT(sampleTrajectory == sampleTrajectory);
1272 }
1273
1274 void testOperatorEq2(void)
1275 {
1276 Trajectory<T> trajectory = sampleTrajectory;
1277 CPPUNIT_ASSERT(trajectory == sampleTrajectory);
1278 }
1279
1280 void testOperatorEq3(void)
1281 {
1282 Trajectory<T> trajectory = sampleTrajectory;
1283 trajectory.pop_back();
1284 CPPUNIT_ASSERT(trajectory != sampleTrajectory);
1285 }
1286
1287 void testOperatorEq4(void)
1288 {
1289 Trajectory<T> trajectory = sampleTrajectory;
1290 trajectory.setId(2);
1291 CPPUNIT_ASSERT(trajectory != sampleTrajectory);
1292 }
1293
1294 void testOperatorEq5(void)
1295 {
1296 Trajectory<T> trajectory = sampleTrajectory;
1297 trajectory.setCheckAscFrameNumber(true);
1298 CPPUNIT_ASSERT(trajectory != sampleTrajectory);
1299 }
1300
1301 void testOperatorEq6(void)
1302 {
1303 Trajectory<T> trajectory = sampleTrajectory;
1304 trajectory.pop_back();
1305 const TrajectoryElement<T> trajectoryElement = sampleTrajectory.getTrajectoryElement(sampleTrajectory.size() - 1);
1306 trajectory.add(trajectoryElement);
1307 CPPUNIT_ASSERT(trajectory == sampleTrajectory);
1308 }
1309
1310 void testOperatorEq7(void)
1311 {
1312 Trajectory<T> trajectory = sampleTrajectory;
1313 trajectory.pop_back();
1314 TrajectoryElement<T> trajectoryElement = sampleTrajectory.getTrajectoryElement(sampleTrajectory.size() - 1);
1315 trajectoryElement.setFrameNumber(2);
1316 trajectory.add(trajectoryElement);
1317 CPPUNIT_ASSERT(trajectory != sampleTrajectory);
1318 }
1319
1320 void testOperatorEq8(void)
1321 {
1322 const Trajectory<T> trajectory = sampleTrajectory;
1323
1324 T point;
1325
1326 initPoint(point, int(99), int(99 + 10), int(99 + 20));
1327 sampleTrajectory.pop_back();
1328 sampleTrajectory.add(100, point);
1329 CPPUNIT_ASSERT(sampleTrajectory == trajectory);
1330
1331 initPoint(point, int(99 + 1), int(99 + 10), int(99 + 20));
1332 sampleTrajectory.pop_back();
1333 sampleTrajectory.add(100, point);
1334 CPPUNIT_ASSERT(sampleTrajectory != trajectory);
1335
1336 initPoint(point, int(99), int(99 + 10 + 1), int(99 + 20));
1337 sampleTrajectory.pop_back();
1338 sampleTrajectory.add(100, point);
1339 CPPUNIT_ASSERT(sampleTrajectory != trajectory);
1340
1341 initPoint(point, int(99), int(99 + 10), int(99 + 20 + 1));
1342 sampleTrajectory.pop_back();
1343 sampleTrajectory.add(100, point);
1344 if (dim(point) == 2)
1345 {
1346 CPPUNIT_ASSERT(sampleTrajectory == trajectory);
1347 }
1348 else if (dim(point) == 3)
1349 {
1350 CPPUNIT_ASSERT(sampleTrajectory != trajectory);
1351 }
1352 }
1353
1354 void testOperatorAdd1(void)
1355 {
1356 Trajectory<T> trajectory;
1357 trajectory.setId(1);
1358
1359 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
1360 {
1361 const unsigned int frameNumber = sampleTrajectory.getFrameNumber(i);
1362 const T point = sampleTrajectory.getPoint(i);
1363
1364 trajectory += point;
1365
1366 const TrajectoryElement<T> trajectoryElement1(frameNumber, point);
1367 const TrajectoryElement<T> trajectoryElement2 = trajectory.getTrajectoryElement(i);
1368
1369 CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2);
1370 }
1371
1372 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
1373 }
1374
1375 void testOperatorAdd2(void)
1376 {
1377 Trajectory<T> trajectory;
1378 trajectory.setId(1);
1379
1380 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
1381 {
1382 const unsigned int frameNumber = sampleTrajectory.getFrameNumber(i);
1383 const T point = sampleTrajectory.getPoint(i);
1384
1385 const TrajectoryElement<T> trajectoryElement1(frameNumber, point);
1386
1387 trajectory += trajectoryElement1;
1388
1389 const TrajectoryElement<T> trajectoryElement2 = trajectory.getTrajectoryElement(i);
1390
1391 CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2);
1392 }
1393
1394 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
1395 }
1396
1397 void testOperatorIn1(void)
1398 {
1399 Trajectory<T> trajectory;
1400 stringstream ss;
1401 ss << trajectory;
1402 CPPUNIT_ASSERT_EQUAL(ss.str(), string("0"));
1403 }
1404
1405 void testOperatorIn2(void)
1406 {
1407 T point;
1408 initPoint(point, int(10), int(20), int(30));
1409
1410 Trajectory<T> trajectory;
1411 trajectory.setId(2);
1412 trajectory.add(4, point);
1413
1414 string s("2 4 10 20");
1415 if (dim(point) == 3)
1416 {
1417 s += string(" 30");
1418 }
1419
1420 stringstream ss;
1421 ss << trajectory;
1422
1423 CPPUNIT_ASSERT_EQUAL(ss.str(), s);
1424 }
1425
1426 void testOperatorIn3(void)
1427 {
1428 sampleTrajectory.setId(20);
1429
1430 string s("20");
1431
1432 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
1433 {
1434 stringstream ss;
1435 ss << string(" ") << i + 1 << string(" ") << i << string(" ") << i + 10;
1436 if (dim(sampleTrajectory.getPoint(0)) == 3)
1437 {
1438 ss << string(" ") << i + 20;
1439 }
1440 s += ss.str();
1441 }
1442
1443 stringstream ss;
1444 ss << sampleTrajectory;
1445
1446 CPPUNIT_ASSERT_EQUAL(ss.str(), s);
1447 }
1448
1449 void testOperatorOut1(void)
1450 {
1451 Trajectory<T> trajectory1;
1452 stringstream ss;
1453 ss << trajectory1;
1454
1455 Trajectory<T> trajectory2;
1456 istringstream is(ss.str());
1457 is >> trajectory2;
1458
1459 CPPUNIT_ASSERT_EQUAL(trajectory1, trajectory2);
1460 }
1461
1462 void testOperatorOut2(void)
1463 {
1464 T point;
1465 initPoint(point, int(10), int(20), int(30));
1466
1467 Trajectory<T> trajectory1;
1468 trajectory1.setId(2);
1469 trajectory1.add(4, point);
1470
1471 string s("2 4 10 20");
1472 if (dim(point) == 3)
1473 {
1474 s += " 30";
1475 }
1476
1477 stringstream ss;
1478 ss << trajectory1;
1479
1480 Trajectory<T> trajectory2;
1481 istringstream is(ss.str());
1482 is >> trajectory2;
1483
1484 CPPUNIT_ASSERT_EQUAL(trajectory1, trajectory2);
1485 }
1486
1487 void testOperatorOut3(void)
1488 {
1489 sampleTrajectory.setId(20);
1490
1491 string s("20");
1492
1493 for (unsigned int i = 0; i < sampleTrajectory.size(); ++i)
1494 {
1495 stringstream ss;
1496 ss << " " << i + 1 << " " << i << " " << i + 10;
1497 if (dim(sampleTrajectory.getPoint(0)) == 3)
1498 {
1499 ss << " " << i + 20;
1500 }
1501 s += ss.str();
1502 }
1503
1504 stringstream ss;
1505 ss << sampleTrajectory;
1506
1507 Trajectory<T> trajectory;
1508 istringstream is(ss.str());
1509 is >> trajectory;
1510
1511 CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory);
1512 }
1513
1514 void testMin1(void)
1515 {
1516 T point1;
1517 initPoint(point1, 0, 10, 20);
1518 T point2;
1519 CPPUNIT_ASSERT_NO_THROW(point2 = min(sampleTrajectory));
1520 CPPUNIT_ASSERT_EQUAL(point1, point2);
1521 }
1522
1523 void testMin2(void)
1524 {
1525 Trajectory<T> trajectory;
1526 T point1;
1527 for (unsigned int i = 0; i < 100; ++i)
1528 {
1529 initPoint(point1, i + 4, 104 - i, i % 24 + 1);
1530 trajectory += point1;
1531 }
1532
1533 initPoint(point1, 4, 5, 1);
1534
1535 T point2;
1536 CPPUNIT_ASSERT_NO_THROW(point2 = min(trajectory));
1537
1538 CPPUNIT_ASSERT_EQUAL(point1, point2);
1539 }
1540
1541 void testMin3(void)
1542 {
1543 Trajectory<T> trajectory;
1544 CPPUNIT_ASSERT_THROW(min(trajectory), TrajectoryLengthErrorException);
1545 }
1546
1547 void testMin4(void)
1548 {
1549 Trajectory<T> trajectory;
1550 T point1, point2;
1551 initPoint(point1, 8, 4, 2);
1552 trajectory.add(point1);
1553 CPPUNIT_ASSERT_NO_THROW(point2 = min(trajectory));
1554 CPPUNIT_ASSERT_EQUAL(point1, point2);
1555 }
1556
1557 void testMax1(void)
1558 {
1559 T point1;
1560 initPoint(point1, int(99), int(109), int(119));
1561 T point2;
1562 CPPUNIT_ASSERT_NO_THROW(point2 = max(sampleTrajectory));
1563 CPPUNIT_ASSERT_EQUAL(point1, point2);
1564 }
1565
1566 void testMax2(void)
1567 {
1568 Trajectory<T> trajectory;
1569 T point1;
1570 for (unsigned int i = 0; i < 100; ++i)
1571 {
1572 initPoint(point1, int(i + 4), int(104 - i), int(i % 24 + 1));
1573 trajectory += point1;
1574 }
1575
1576 initPoint(point1, 103, 104, 24);
1577
1578 T point2;
1579 CPPUNIT_ASSERT_NO_THROW(point2 = max(trajectory));
1580
1581 CPPUNIT_ASSERT_EQUAL(point1, point2);
1582 }
1583
1584 void testMax3(void)
1585 {
1586 Trajectory<T> trajectory;
1587 CPPUNIT_ASSERT_THROW(max(trajectory), TrajectoryLengthErrorException);
1588 }
1589
1590 void testMax4(void)
1591 {
1592 Trajectory<T> trajectory;
1593 T point1, point2;
1594 initPoint(point1, 8, 4, 2);
1595 trajectory.add(point1);
1596 CPPUNIT_ASSERT_NO_THROW(point2 = max(trajectory));
1597 CPPUNIT_ASSERT_EQUAL(point1, point2);
1598 }
1599
1600 private:
1601 Trajectory<T> sampleTrajectory;
1602 };
1603
1604 #endif /* TRAJECTORYTEST_H_ */