Mercurial Hosting > traffic-intelligence
comparison trajectorymanagement/test/TrajectoryTest.h @ 1159:e1e7acef8eab
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_ */ |