Mercurial Hosting > traffic-intelligence
diff 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 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/trajectorymanagement/test/TrajectoryTest.h Mon Feb 22 22:09:35 2021 -0500 @@ -0,0 +1,1604 @@ +#ifndef TRAJECTORYTEST_H_ +#define TRAJECTORYTEST_H_ + +#include "../src/Trajectory.h" + +#include <cppunit/extensions/HelperMacros.h> + +using namespace std; + +template<class T> +class TrajectoryTest: public CPPUNIT_NS::TestCase +{ +CPPUNIT_TEST_SUITE(TrajectoryTest); + CPPUNIT_TEST(testTrajectory1); + CPPUNIT_TEST(testTrajectory2); + CPPUNIT_TEST(testTrajectory3); + CPPUNIT_TEST(testSetId); + CPPUNIT_TEST(testGetTrajectoryElement); + CPPUNIT_TEST(testAdd1); + CPPUNIT_TEST(testAdd2); + CPPUNIT_TEST(testAdd3); + CPPUNIT_TEST(testAdd4); + CPPUNIT_TEST(testAdd5); + CPPUNIT_TEST(testAdd6); + CPPUNIT_TEST(testAdd7); + CPPUNIT_TEST(testAdd8); + CPPUNIT_TEST(testAdd9); + CPPUNIT_TEST(testAdd10); + CPPUNIT_TEST(testAdd11); + CPPUNIT_TEST(testAdd12); + CPPUNIT_TEST(testAdd13); + CPPUNIT_TEST(testAdd14); + CPPUNIT_TEST(testAdd15); + CPPUNIT_TEST(testAdd16); + CPPUNIT_TEST(testAdd17); + CPPUNIT_TEST(testAdd18); + CPPUNIT_TEST(testAdd19); + CPPUNIT_TEST(testAdd20); + CPPUNIT_TEST(testAdd21); + CPPUNIT_TEST(testAdd22); + CPPUNIT_TEST(testAdd23); + CPPUNIT_TEST(testAdd24); + CPPUNIT_TEST(testAdd25); + CPPUNIT_TEST(testAdd26); + CPPUNIT_TEST(testAdd27); + CPPUNIT_TEST(testAdd28); + CPPUNIT_TEST(testAdd29); + CPPUNIT_TEST(testAdd30); + CPPUNIT_TEST(testAdd31); + CPPUNIT_TEST(testAdd32); + CPPUNIT_TEST(testAdd33); + CPPUNIT_TEST(testAdd34); + CPPUNIT_TEST(testAdd35); + CPPUNIT_TEST(testAdd36); + CPPUNIT_TEST(testAdd37); + CPPUNIT_TEST(testAdd38); + CPPUNIT_TEST(testAdd39); + CPPUNIT_TEST(testGetFrameNumber); + CPPUNIT_TEST(testGetPoint); + CPPUNIT_TEST(testGetCheckAscFrameNumber1); + CPPUNIT_TEST(testGetCheckAscFrameNumber2); + CPPUNIT_TEST(testSetCheckAscFrameNumber1); + CPPUNIT_TEST(testSetCheckAscFrameNumber2); + CPPUNIT_TEST(testSetCheckAscFrameNumber3); + CPPUNIT_TEST(testSetCheckAscFrameNumber4); + CPPUNIT_TEST(testSetCheckAscFrameNumber5); + CPPUNIT_TEST(testSetCheckAscFrameNumber6); + CPPUNIT_TEST(testSetCheckAscFrameNumber7); + CPPUNIT_TEST(testSetCheckAscFrameNumber8); + CPPUNIT_TEST(testSetCheckAscFrameNumber9); + CPPUNIT_TEST(testSetCheckAscFrameNumber10); + CPPUNIT_TEST(testSize1); + CPPUNIT_TEST(testSize2); + CPPUNIT_TEST(testSizeInc); + CPPUNIT_TEST(testSizeDec); + CPPUNIT_TEST(testSizeClear); + CPPUNIT_TEST(testEmptySizeInc); + CPPUNIT_TEST(testEmptySizeDec); + CPPUNIT_TEST(testInsert1); + CPPUNIT_TEST(testInsert2); + CPPUNIT_TEST(testInsert3); + CPPUNIT_TEST(testInsert4); + CPPUNIT_TEST(testInsert5); + CPPUNIT_TEST(testInsert6); + CPPUNIT_TEST(testInsert7); + CPPUNIT_TEST(testInsert8); + CPPUNIT_TEST(testInsert9); + CPPUNIT_TEST(testErase1); + CPPUNIT_TEST(testErase2); + CPPUNIT_TEST(testErase3); + CPPUNIT_TEST(testErase4); + CPPUNIT_TEST(testErase5); + CPPUNIT_TEST(testErase6); + CPPUNIT_TEST(testErase7); + CPPUNIT_TEST(testErase8); + CPPUNIT_TEST(testErase9); + CPPUNIT_TEST(testErase10); + CPPUNIT_TEST(testErase11); + CPPUNIT_TEST(testErase12); + CPPUNIT_TEST(testErase13); + CPPUNIT_TEST(testErase14); + CPPUNIT_TEST(testPop_back1); + CPPUNIT_TEST(testPop_back2); + CPPUNIT_TEST(testPop_back3); + CPPUNIT_TEST(testPop_back4); + CPPUNIT_TEST(testOperatorGet); + CPPUNIT_TEST(testAt1); + CPPUNIT_TEST(testAt2); + CPPUNIT_TEST(testAt3); + CPPUNIT_TEST(testAt4); + CPPUNIT_TEST(testAt5); + CPPUNIT_TEST(testAt6); + CPPUNIT_TEST(testAt7); + CPPUNIT_TEST(testShift1); + CPPUNIT_TEST(testShift2); + CPPUNIT_TEST(testOperatorEq1); + CPPUNIT_TEST(testOperatorEq2); + CPPUNIT_TEST(testOperatorEq3); + CPPUNIT_TEST(testOperatorEq4); + CPPUNIT_TEST(testOperatorEq5); + CPPUNIT_TEST(testOperatorEq6); + CPPUNIT_TEST(testOperatorEq7); + CPPUNIT_TEST(testOperatorEq8); + CPPUNIT_TEST(testOperatorAdd1); + CPPUNIT_TEST(testOperatorAdd2); +// CPPUNIT_TEST(testOperatorIn1); +// CPPUNIT_TEST(testOperatorIn2); +// CPPUNIT_TEST(testOperatorIn3); +// CPPUNIT_TEST(testOperatorOut1); +// CPPUNIT_TEST(testOperatorOut2); +// CPPUNIT_TEST(testOperatorOut3); + CPPUNIT_TEST(testMin1); + CPPUNIT_TEST(testMin2); + CPPUNIT_TEST(testMin3); + CPPUNIT_TEST(testMin4); + CPPUNIT_TEST(testMax1); + CPPUNIT_TEST(testMax2); + CPPUNIT_TEST(testMax3); + CPPUNIT_TEST(testMax4); + CPPUNIT_TEST_SUITE_END(); + +public: + void setUp(void) + { + sampleTrajectory.setId(1); + + const unsigned int n = 100; + for (unsigned int i = 0; i < n; ++i) + { + T point; + initPoint(point, int(i), int(i + 10), int(i + 20)); + sampleTrajectory.add(i + 1, point); + } + } + + void tearDown(void) + { + sampleTrajectory.clear(); + } + +protected: + void testTrajectory1(void) + { + Trajectory<T> trajectory; + CPPUNIT_ASSERT_EQUAL(trajectory.getId(), (unsigned int) 0); + } + + void testTrajectory2(void) + { + Trajectory<T> trajectory; + CPPUNIT_ASSERT_EQUAL(trajectory.getCheckAscFrameNumber(), false); + } + + void testTrajectory3(void) + { + Trajectory<T> trajectory(sampleTrajectory); + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + } + + void testSetId(void) + { + const unsigned int id = 123; + sampleTrajectory.setId(id); + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.getId(), id); + } + + void testGetTrajectoryElement(void) + { + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + TrajectoryElement<T> trajectoryElement1 = sampleTrajectory.getTrajectoryElement(i); + T point; + initPoint(point, int(i), int(i + 10), int(i + 20)); + TrajectoryElement<T> trajectoryElement2(i + 1, point); + CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2); + } + } + + void testAdd1(void) + { + Trajectory<T> trajectory; + trajectory.setId(1); + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + const unsigned int frameNumber = sampleTrajectory.getFrameNumber(i); + const T point = sampleTrajectory.getPoint(i); + + trajectory.add(frameNumber, point); + + TrajectoryElement<T> trajectoryElement1 = trajectory.getTrajectoryElement(i); + TrajectoryElement<T> trajectoryElement2(frameNumber, point); + + CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2); + } + + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + } + + void testAdd2(void) + { + Trajectory<T> trajectory; + trajectory.setId(1); + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + const unsigned int frameNumber = sampleTrajectory.getFrameNumber(i); + const T point = sampleTrajectory.getPoint(i); + + //trajectory.add(point); + trajectory.add(frameNumber, point); + + const TrajectoryElement<T> trajectoryElement1(frameNumber, point); + const TrajectoryElement<T> trajectoryElement2 = trajectory.getTrajectoryElement(i); + + CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2); + } + + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + } + + void testAdd3(void) + { + Trajectory<T> trajectory; + trajectory.setId(1); + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + const unsigned int frameNumber = sampleTrajectory.getFrameNumber(i); + const T point = sampleTrajectory.getPoint(i); + + const TrajectoryElement<T> trajectoryElement1(frameNumber, point); + + trajectory.add(trajectoryElement1); + + const TrajectoryElement<T> trajectoryElement2 = trajectory.getTrajectoryElement(i); + + CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2); + } + + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + } + + void testAdd4(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(0, point)); + } + + void testAdd5(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(0, point)); + } + + void testAdd6(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(0, point)); + CPPUNIT_ASSERT_THROW(trajectory.add(0, point), TrajectoryFrameNumberErrorException); + } + + void testAdd7(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(0, point)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(0, point)); + } + + void testAdd8(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(0, point)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(1, point)); + } + + void testAdd9(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(0, point)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(1, point)); + } + + void testAdd10(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point)); + } + + void testAdd11(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point)); + } + + void testAdd12(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point)); + CPPUNIT_ASSERT_THROW(trajectory.add(2, point), TrajectoryFrameNumberErrorException); + } + + void testAdd13(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point)); + } + + void testAdd14(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(3, point)); + } + + void testAdd15(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(3, point)); + } + + void testAdd16(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(4, point)); + } + + void testAdd17(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(2, point)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(4, point)); + } + + void testAdd18(void) + { + const T point = sampleTrajectory.getPoint(0); + + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + trajectory.add(10, point); + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + CPPUNIT_ASSERT_THROW(trajectory.add(10 + i - 1, point), TrajectoryFrameNumberErrorException); + CPPUNIT_ASSERT_THROW(trajectory.add(10 + i, point), TrajectoryFrameNumberErrorException); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(10 + i + 1, point)); + } + + CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) (sampleTrajectory.size() + 1)); + } + + void testAdd19(void) + { + const T point = sampleTrajectory.getPoint(0); + + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + trajectory.add(10, point); + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + CPPUNIT_ASSERT_NO_THROW(trajectory.add(10 + i - 1, point)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(10 + i, point)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(10 + i + 1, point)); + } + + CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) (3 * sampleTrajectory.size() + 1)); + } + + void testAdd20(void) + { + sampleTrajectory.setCheckAscFrameNumber(true); + const unsigned int frameNumber = sampleTrajectory.getFrameNumber(sampleTrajectory.size() - 1); + const T point = sampleTrajectory.getPoint(sampleTrajectory.size() - 1); + + for (unsigned int i = 0; i <= frameNumber; ++i) + { + CPPUNIT_ASSERT_THROW(sampleTrajectory.add(i, point), TrajectoryFrameNumberErrorException); + } + + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.add(frameNumber + 1, point)); + + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 101); + } + + void testAdd21(void) + { + sampleTrajectory.setCheckAscFrameNumber(false); + const unsigned int frameNumber = sampleTrajectory.getFrameNumber(sampleTrajectory.size() - 1); + const T point = sampleTrajectory.getPoint(sampleTrajectory.size() - 1); + + for (unsigned int i = 0; i <= frameNumber; ++i) + { + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.add(i, point)); + } + + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.add(frameNumber + 1, point)); + + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 202); + } + + void testAdd22(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + const TrajectoryElement<T> trajectoryElement(0, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement)); + } + + void testAdd23(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + const TrajectoryElement<T> trajectoryElement(0, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement)); + } + + void testAdd24(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + const TrajectoryElement<T> trajectoryElement(0, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement)); + CPPUNIT_ASSERT_THROW(trajectory.add(trajectoryElement), TrajectoryFrameNumberErrorException); + } + + void testAdd25(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + const TrajectoryElement<T> trajectoryElement(0, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement)); + } + + void testAdd26(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + const TrajectoryElement<T> trajectoryElement1(0, point); + const TrajectoryElement<T> trajectoryElement2(1, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement2)); + } + + void testAdd27(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + const TrajectoryElement<T> trajectoryElement1(0, point); + const TrajectoryElement<T> trajectoryElement2(1, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement2)); + } + + void testAdd28(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + const TrajectoryElement<T> trajectoryElement(2, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement)); + } + + void testAdd29(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + const TrajectoryElement<T> trajectoryElement(2, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement)); + } + + void testAdd30(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + const TrajectoryElement<T> trajectoryElement(2, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement)); + CPPUNIT_ASSERT_THROW(trajectory.add(trajectoryElement), TrajectoryFrameNumberErrorException); + } + + void testAdd31(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + const TrajectoryElement<T> trajectoryElement(2, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement)); + } + + void testAdd32(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + const TrajectoryElement<T> trajectoryElement1(2, point); + const TrajectoryElement<T> trajectoryElement2(3, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1) ); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement2)); + } + + void testAdd33(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + const TrajectoryElement<T> trajectoryElement1(2, point); + const TrajectoryElement<T> trajectoryElement2(3, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement2)); + } + + void testAdd34(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + const TrajectoryElement<T> trajectoryElement1(2, point); + const TrajectoryElement<T> trajectoryElement2(4, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement2)); + } + + void testAdd35(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + const TrajectoryElement<T> trajectoryElement1(2, point); + const TrajectoryElement<T> trajectoryElement2(4, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement2)); + } + + void testAdd36(void) + { + const T point = sampleTrajectory.getPoint(0); + + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(true); + const TrajectoryElement<T> trajectoryElement1(10, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1)); + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + const TrajectoryElement<T> trajectoryElement2(10 + i - 1, point); + const TrajectoryElement<T> trajectoryElement3(10 + i, point); + const TrajectoryElement<T> trajectoryElement4(10 + i + 1, point); + CPPUNIT_ASSERT_THROW(trajectory.add(trajectoryElement2), TrajectoryFrameNumberErrorException); + CPPUNIT_ASSERT_THROW(trajectory.add(trajectoryElement3), TrajectoryFrameNumberErrorException); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement4)); + } + + CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) (sampleTrajectory.size() + 1)); + } + + void testAdd37(void) + { + const T point = sampleTrajectory.getPoint(0); + + Trajectory<T> trajectory; + trajectory.setCheckAscFrameNumber(false); + const TrajectoryElement<T> trajectoryElement1(10, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement1)); + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + const TrajectoryElement<T> trajectoryElement2(10 + i - 1, point); + const TrajectoryElement<T> trajectoryElement3(10 + i, point); + const TrajectoryElement<T> trajectoryElement4(10 + i + 1, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement2)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement3)); + CPPUNIT_ASSERT_NO_THROW(trajectory.add(trajectoryElement4)); + } + + CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) (3 * sampleTrajectory.size() + 1)); + } + + void testAdd38(void) + { + sampleTrajectory.setCheckAscFrameNumber(true); + const unsigned int frameNumber = sampleTrajectory.getFrameNumber(sampleTrajectory.size() - 1); + const T point = sampleTrajectory.getPoint(sampleTrajectory.size() - 1); + + for (unsigned int i = 0; i <= frameNumber; ++i) + { + const TrajectoryElement<T> trajectoryElement(i, point); + CPPUNIT_ASSERT_THROW(sampleTrajectory.add(trajectoryElement), TrajectoryFrameNumberErrorException); + } + + const TrajectoryElement<T> trajectoryElement(frameNumber + 1, point); + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.add(trajectoryElement)); + + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 101); + } + + void testAdd39(void) + { + sampleTrajectory.setCheckAscFrameNumber(false); + const unsigned int frameNumber = sampleTrajectory.getFrameNumber(sampleTrajectory.size() - 1); + const T point = sampleTrajectory.getPoint(sampleTrajectory.size() - 1); + + for (unsigned int i = 0; i <= frameNumber; ++i) + { + const TrajectoryElement<T> trajectoryElement(i, point); + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.add(trajectoryElement)); + } + + const TrajectoryElement<T> trajectoryElement(frameNumber + 1, point); + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.add(trajectoryElement)); + + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 202); + } + + void testGetFrameNumber(void) + { + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + unsigned int frameNumber = sampleTrajectory.getFrameNumber(i); + CPPUNIT_ASSERT_EQUAL(frameNumber, i + 1); + } + } + + void testGetPoint(void) + { + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + T point1 = sampleTrajectory.getPoint(i); + T point2; + initPoint(point2, int(i), int(i + 10), int(i + 20)); + CPPUNIT_ASSERT_EQUAL(point1, point2); + } + } + + void testGetCheckAscFrameNumber1(void) + { + sampleTrajectory.setCheckAscFrameNumber(false); + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.getCheckAscFrameNumber(), false); + } + + void testGetCheckAscFrameNumber2(void) + { + sampleTrajectory.setCheckAscFrameNumber(true); + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.getCheckAscFrameNumber(), true); + } + + void testSetCheckAscFrameNumber1(void) + { + Trajectory<T> trajectory; + CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(false)); + CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(true)); + } + + void testSetCheckAscFrameNumber2(void) + { + T point; + initPoint(point, int(10), int(20), int(30)); + Trajectory<T> trajectory; + trajectory.add(0, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(false)); + CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(true)); + } + + void testSetCheckAscFrameNumber3(void) + { + T point; + initPoint(point, int(10), int(20), int(30)); + Trajectory<T> trajectory; + trajectory.add(1, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(false)); + CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(true)); + } + + void testSetCheckAscFrameNumber4(void) + { + T point; + initPoint(point, int(10), int(20), int(30)); + Trajectory<T> trajectory; + trajectory.add(1, point); + trajectory.add(2, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(false)); + CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(true)); + } + + void testSetCheckAscFrameNumber5(void) + { + T point; + initPoint(point, int(10), int(20), int(30)); + Trajectory<T> trajectory; + trajectory.add(1, point); + trajectory.add(1, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(false)); + CPPUNIT_ASSERT_THROW(trajectory.setCheckAscFrameNumber(true), TrajectoryFrameNumberErrorException); + } + + void testSetCheckAscFrameNumber6(void) + { + T point; + initPoint(point, int(10), int(20), int(30)); + Trajectory<T> trajectory; + trajectory.add(2, point); + trajectory.add(1, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(false)); + CPPUNIT_ASSERT_THROW(trajectory.setCheckAscFrameNumber(true), TrajectoryFrameNumberErrorException); + } + + void testSetCheckAscFrameNumber7(void) + { + T point; + initPoint(point, int(10), int(20), int(30)); + Trajectory<T> trajectory; + trajectory.add(1, point); + trajectory.add(2, point); + trajectory.add(2, point); + trajectory.add(3, point); + CPPUNIT_ASSERT_NO_THROW(trajectory.setCheckAscFrameNumber(false)); + CPPUNIT_ASSERT_THROW(trajectory.setCheckAscFrameNumber(true), TrajectoryFrameNumberErrorException); + } + + void testSetCheckAscFrameNumber8(void) + { + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.setCheckAscFrameNumber(false)); + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.setCheckAscFrameNumber(true)); + } + + void testSetCheckAscFrameNumber9(void) + { + T point; + initPoint(point, int(10), int(20), int(30)); + sampleTrajectory.add(100, point); + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.setCheckAscFrameNumber(false)); + CPPUNIT_ASSERT_THROW(sampleTrajectory.setCheckAscFrameNumber(true), TrajectoryFrameNumberErrorException); + } + + void testSetCheckAscFrameNumber10(void) + { + T point; + initPoint(point, int(10), int(20), int(30)); + sampleTrajectory.add(101, point); + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.setCheckAscFrameNumber(false)); + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.setCheckAscFrameNumber(true)); + } + + void testSize1(void) + { + Trajectory<T> trajectory; + CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) 0); + } + + void testSize2(void) + { + Trajectory<T> trajectory; + trajectory = sampleTrajectory; + CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) 100); + } + + void testSizeInc(void) + { + Trajectory<T> trajectory; + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) i); + + T point = (sampleTrajectory)[i]; + trajectory.add(point); + } + + CPPUNIT_ASSERT_EQUAL(trajectory.size(), sampleTrajectory.size()); + } + + void testSizeDec(void) + { + unsigned int size = sampleTrajectory.size(); + + for (unsigned int i = 0; i < size; ++i) + { + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int)(size - i)); + + sampleTrajectory.pop_back(); + } + + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 0); + } + + void testSizeClear(void) + { + sampleTrajectory.clear(); + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 0); + } + + void testEmptySizeInc(void) + { + Trajectory<T> trajectory; + CPPUNIT_ASSERT_EQUAL(trajectory.empty(), true); + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + const TrajectoryElement<T> trajectoryElement = sampleTrajectory.getTrajectoryElement(i); + trajectory.add(trajectoryElement); + CPPUNIT_ASSERT_EQUAL(trajectory.empty(), false); + } + } + + void testEmptySizeDec(void) + { + Trajectory<T> trajectory; + CPPUNIT_ASSERT_EQUAL(trajectory.empty(), true); + + trajectory = sampleTrajectory; + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + CPPUNIT_ASSERT_EQUAL(trajectory.empty(), false); + trajectory.pop_back(); + } + + CPPUNIT_ASSERT_EQUAL(trajectory.empty(), true); + } + + void testInsert1(void) + { + T point; + initPoint(point, int(10), int(40), int(80)); + + Trajectory<T> trajectory; + CPPUNIT_ASSERT_THROW(trajectory.insert(1, 4, point), TrajectoryOutOfRangeErrorException); + } + + void testInsert2(void) + { + T point; + initPoint(point, int(10), int(40), int(80)); + + Trajectory<T> trajectory; + CPPUNIT_ASSERT_NO_THROW(trajectory.insert(0, 4, point)); + + CPPUNIT_ASSERT_EQUAL(trajectory.size(), (unsigned int) 1); + + const TrajectoryElement<T> trajectoryElement1 = trajectory.getTrajectoryElement(0); + const TrajectoryElement<T> trajectoryElement2(4, point); + CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2); + } + + void testInsert3(void) + { + T point; + initPoint(point, int(10), int(40), int(80)); + + Trajectory<T> trajectory; + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.insert(sampleTrajectory.size(), 4, point)); + } + + void testInsert4(void) + { + T point; + initPoint(point, int(10), int(40), int(80)); + + Trajectory<T> trajectory; + CPPUNIT_ASSERT_THROW(sampleTrajectory.insert(sampleTrajectory.size() + 1, 4, point), TrajectoryOutOfRangeErrorException); + } + + void testInsert5(void) + { + T point; + initPoint(point, int(10), int(40), int(80)); + + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.insert(sampleTrajectory.size() - 1, 20, point)); + + const TrajectoryElement<T> trajectoryElement1 = sampleTrajectory.getTrajectoryElement(sampleTrajectory.size() - 1); + const TrajectoryElement<T> trajectoryElement2(20, point); + CPPUNIT_ASSERT (trajectoryElement1 != trajectoryElement2); + } + + void testInsert6(void) + { + T point; + initPoint(point, int(10), int(40), int(80)); + + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.insert(sampleTrajectory.size(), 20, point)); + + const TrajectoryElement<T> trajectoryElement1 = sampleTrajectory.getTrajectoryElement(sampleTrajectory.size()); + const TrajectoryElement<T> trajectoryElement2(20, point); + CPPUNIT_ASSERT(trajectoryElement1 != trajectoryElement2); + } + + void testInsert7(void) + { + T point; + initPoint(point, int(10), int(40), int(80)); + + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.insert(10, 20, point)); + + const TrajectoryElement<T> trajectoryElement1 = sampleTrajectory.getTrajectoryElement(10); + const TrajectoryElement<T> trajectoryElement2(20, point); + CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2); + } + + void testInsert8(void) + { + sampleTrajectory.setCheckAscFrameNumber(true); + + T point; + initPoint(point, int(10), int(40), int(80)); + + CPPUNIT_ASSERT_THROW(sampleTrajectory.insert(sampleTrajectory.size() + 1, 100, point), TrajectoryOutOfRangeErrorException); + CPPUNIT_ASSERT_THROW(sampleTrajectory.insert(sampleTrajectory.size(), 100, point), TrajectoryFrameNumberErrorException); + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.insert(sampleTrajectory.size(), 101, point)); + } + + void testInsert9(void) + { + sampleTrajectory.setCheckAscFrameNumber(true); + + T point; + initPoint(point, int(10), int(40), int(80)); + + for (unsigned int i = 0; i < sampleTrajectory.size() - 1; ++i) + { + CPPUNIT_ASSERT_THROW(sampleTrajectory.insert(i, 20, point), TrajectoryFrameNumberErrorException); + CPPUNIT_ASSERT_THROW(sampleTrajectory.insert(i, 200, point), TrajectoryFrameNumberErrorException); + } + } + + void testErase1(void) + { + Trajectory<T> trajectory; + CPPUNIT_ASSERT_THROW(trajectory.erase(0), TrajectoryOutOfRangeErrorException); + } + + void testErase2(void) + { + Trajectory<T> trajectory; + CPPUNIT_ASSERT_THROW(trajectory.erase(1), TrajectoryOutOfRangeErrorException); + } + + void testErase3(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.add(point); + CPPUNIT_ASSERT_NO_THROW(trajectory.erase(0)); + + Trajectory<T> emptyTrajectory; + CPPUNIT_ASSERT_EQUAL(trajectory, emptyTrajectory); + } + + void testErase4(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.add(point); + CPPUNIT_ASSERT_THROW(trajectory.erase(1), TrajectoryOutOfRangeErrorException); + } + + void testErase5(void) + { + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(0)); + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 99); + } + + void testErase6(void) + { + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(1)); + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 99); + } + + void testErase7(void) + { + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(0)); + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(0)); + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 98); + } + + void testErase8(void) + { + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(sampleTrajectory.size() - 1)); + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(sampleTrajectory.size() - 1)); + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 98); + } + + void testErase9(void) + { + CPPUNIT_ASSERT_THROW(sampleTrajectory.erase(sampleTrajectory.size()), TrajectoryOutOfRangeErrorException); + } + + void testErase10(void) + { + CPPUNIT_ASSERT_THROW(sampleTrajectory.erase(sampleTrajectory.size() + 1), TrajectoryOutOfRangeErrorException); + } + + void testErase11(void) + { + for (unsigned int i = 0; i < 100; ++i) + { + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(0)); + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), 100 - i - 1); + } + + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 0); + + CPPUNIT_ASSERT_THROW(sampleTrajectory.erase(0), TrajectoryOutOfRangeErrorException); + } + + void testErase12(void) + { + for (unsigned int i = 0; i < 100; ++i) + { + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.erase(sampleTrajectory.size() - 1)); + } + + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 0); + + CPPUNIT_ASSERT_THROW(sampleTrajectory.erase(0), TrajectoryOutOfRangeErrorException); + } + + void testErase13(void) + { + T point; + initPoint(point, int(10), int(40), int(80)); + + Trajectory<T> trajectory = sampleTrajectory; + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + + trajectory.insert(20, 20, point); + CPPUNIT_ASSERT(trajectory != sampleTrajectory); + + trajectory.erase(20); + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + } + + void testErase14(void) + { + T point; + initPoint(point, int(10), int(40), int(80)); + + Trajectory<T> trajectory = sampleTrajectory; + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + + trajectory.insert(20, 20, point); + CPPUNIT_ASSERT(trajectory != sampleTrajectory); + + trajectory.erase(10); + CPPUNIT_ASSERT(trajectory != sampleTrajectory); + } + + void testPop_back1(void) + { + Trajectory<T> trajectory; + CPPUNIT_ASSERT_THROW(trajectory.pop_back(), TrajectoryLengthErrorException); + } + + void testPop_back2(void) + { + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int) 100); + + for (int i = 100; i > 0; --i) + { + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.pop_back()); + CPPUNIT_ASSERT_EQUAL(sampleTrajectory.size(), (unsigned int)(i - 1)); + } + + CPPUNIT_ASSERT_THROW(sampleTrajectory.pop_back(), TrajectoryLengthErrorException); + } + + void testPop_back3(void) + { + T point; + initPoint(point, int(10), int(40), int(80)); + + Trajectory<T> trajectory = sampleTrajectory; + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + + trajectory.add(point); + CPPUNIT_ASSERT(trajectory != sampleTrajectory); + + trajectory.pop_back(); + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + } + + void testPop_back4(void) + { + T point; + initPoint(point, int(10), int(40), int(80)); + + Trajectory<T> trajectory = sampleTrajectory; + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + + trajectory.insert(trajectory.size(), 20, point); + CPPUNIT_ASSERT(trajectory != sampleTrajectory); + + trajectory.pop_back(); + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + } + + void testOperatorGet(void) + { + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + T point1 = sampleTrajectory[i]; + T point2; + initPoint(point2, int(i), int(i + 10), int(i + 20)); + CPPUNIT_ASSERT_EQUAL(point1, point2); + } + } + + void testAt1(void) + { + Trajectory<T> trajectory; + CPPUNIT_ASSERT_THROW(trajectory.at(0), TrajectoryOutOfRangeErrorException); + CPPUNIT_ASSERT_THROW(trajectory.at(1), TrajectoryOutOfRangeErrorException); + CPPUNIT_ASSERT_THROW(trajectory.at(2), TrajectoryOutOfRangeErrorException); + } + + void testAt2(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.add(point); + CPPUNIT_ASSERT_NO_THROW(trajectory.at(0)); + CPPUNIT_ASSERT_THROW(trajectory.at(1), TrajectoryOutOfRangeErrorException); + CPPUNIT_ASSERT_THROW(trajectory.at(2), TrajectoryOutOfRangeErrorException); + } + + void testAt3(void) + { + const T point = sampleTrajectory.getPoint(0); + Trajectory<T> trajectory; + trajectory.add(point); + trajectory.add(point); + CPPUNIT_ASSERT_NO_THROW(trajectory.at(0)); + CPPUNIT_ASSERT_NO_THROW(trajectory.at(1)); + CPPUNIT_ASSERT_THROW(trajectory.at(2), TrajectoryOutOfRangeErrorException); + } + + void testAt4(void) + { + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + T point1; + CPPUNIT_ASSERT_NO_THROW(point1 = sampleTrajectory.at(i)); + T point2; + initPoint(point2, int(i), int(i + 10), int(i + 20)); + CPPUNIT_ASSERT_EQUAL(point1, point2); + } + } + + void testAt5(void) + { + CPPUNIT_ASSERT_NO_THROW(sampleTrajectory.at(sampleTrajectory.size() - 1)); + } + + void testAt6(void) + { + CPPUNIT_ASSERT_THROW(sampleTrajectory.at(sampleTrajectory.size()), TrajectoryOutOfRangeErrorException); + } + + void testAt7(void) + { + CPPUNIT_ASSERT_THROW(sampleTrajectory.at(sampleTrajectory.size() + 1), TrajectoryOutOfRangeErrorException); + } + + void testShift1(void) + { + const int shiftX = 8; + const int shiftY = 4; + const int shiftZ = 2; + + T shiftPoint; + initPoint(shiftPoint, shiftX, shiftY, shiftZ); + sampleTrajectory.shift(shiftPoint); + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + const T p1 = sampleTrajectory.getPoint(i); + T p2; + initPoint(p2, int(i) + shiftX, int(i + 10) + shiftY, int(i + 20) + shiftZ); + CPPUNIT_ASSERT_EQUAL(p1, p2); + } + } + + void testShift2(void) + { + const int shiftX1 = 1; + const int shiftX2 = 10; + const int shiftY1 = 2; + const int shiftY2 = 20; + const int shiftZ1 = 3; + const int shiftZ2 = 30; + + T shiftPoint1; + T shiftPoint2; + T shiftPoint3; + initPoint(shiftPoint1, shiftX1, shiftY1, shiftZ1); + initPoint(shiftPoint2, shiftX2, shiftY2, shiftZ2); + initPoint(shiftPoint3, shiftX1 + shiftX2, shiftY1 + shiftY2, shiftZ1 + shiftZ2); + + Trajectory<T> trajectory = sampleTrajectory; + + trajectory.shift(shiftPoint1); + trajectory.shift(shiftPoint2); + + sampleTrajectory.shift(shiftPoint3); + + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + } + + void testOperatorEq1(void) + { + CPPUNIT_ASSERT(sampleTrajectory == sampleTrajectory); + } + + void testOperatorEq2(void) + { + Trajectory<T> trajectory = sampleTrajectory; + CPPUNIT_ASSERT(trajectory == sampleTrajectory); + } + + void testOperatorEq3(void) + { + Trajectory<T> trajectory = sampleTrajectory; + trajectory.pop_back(); + CPPUNIT_ASSERT(trajectory != sampleTrajectory); + } + + void testOperatorEq4(void) + { + Trajectory<T> trajectory = sampleTrajectory; + trajectory.setId(2); + CPPUNIT_ASSERT(trajectory != sampleTrajectory); + } + + void testOperatorEq5(void) + { + Trajectory<T> trajectory = sampleTrajectory; + trajectory.setCheckAscFrameNumber(true); + CPPUNIT_ASSERT(trajectory != sampleTrajectory); + } + + void testOperatorEq6(void) + { + Trajectory<T> trajectory = sampleTrajectory; + trajectory.pop_back(); + const TrajectoryElement<T> trajectoryElement = sampleTrajectory.getTrajectoryElement(sampleTrajectory.size() - 1); + trajectory.add(trajectoryElement); + CPPUNIT_ASSERT(trajectory == sampleTrajectory); + } + + void testOperatorEq7(void) + { + Trajectory<T> trajectory = sampleTrajectory; + trajectory.pop_back(); + TrajectoryElement<T> trajectoryElement = sampleTrajectory.getTrajectoryElement(sampleTrajectory.size() - 1); + trajectoryElement.setFrameNumber(2); + trajectory.add(trajectoryElement); + CPPUNIT_ASSERT(trajectory != sampleTrajectory); + } + + void testOperatorEq8(void) + { + const Trajectory<T> trajectory = sampleTrajectory; + + T point; + + initPoint(point, int(99), int(99 + 10), int(99 + 20)); + sampleTrajectory.pop_back(); + sampleTrajectory.add(100, point); + CPPUNIT_ASSERT(sampleTrajectory == trajectory); + + initPoint(point, int(99 + 1), int(99 + 10), int(99 + 20)); + sampleTrajectory.pop_back(); + sampleTrajectory.add(100, point); + CPPUNIT_ASSERT(sampleTrajectory != trajectory); + + initPoint(point, int(99), int(99 + 10 + 1), int(99 + 20)); + sampleTrajectory.pop_back(); + sampleTrajectory.add(100, point); + CPPUNIT_ASSERT(sampleTrajectory != trajectory); + + initPoint(point, int(99), int(99 + 10), int(99 + 20 + 1)); + sampleTrajectory.pop_back(); + sampleTrajectory.add(100, point); + if (dim(point) == 2) + { + CPPUNIT_ASSERT(sampleTrajectory == trajectory); + } + else if (dim(point) == 3) + { + CPPUNIT_ASSERT(sampleTrajectory != trajectory); + } + } + + void testOperatorAdd1(void) + { + Trajectory<T> trajectory; + trajectory.setId(1); + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + const unsigned int frameNumber = sampleTrajectory.getFrameNumber(i); + const T point = sampleTrajectory.getPoint(i); + + trajectory += point; + + const TrajectoryElement<T> trajectoryElement1(frameNumber, point); + const TrajectoryElement<T> trajectoryElement2 = trajectory.getTrajectoryElement(i); + + CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2); + } + + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + } + + void testOperatorAdd2(void) + { + Trajectory<T> trajectory; + trajectory.setId(1); + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + const unsigned int frameNumber = sampleTrajectory.getFrameNumber(i); + const T point = sampleTrajectory.getPoint(i); + + const TrajectoryElement<T> trajectoryElement1(frameNumber, point); + + trajectory += trajectoryElement1; + + const TrajectoryElement<T> trajectoryElement2 = trajectory.getTrajectoryElement(i); + + CPPUNIT_ASSERT_EQUAL(trajectoryElement1, trajectoryElement2); + } + + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + } + + void testOperatorIn1(void) + { + Trajectory<T> trajectory; + stringstream ss; + ss << trajectory; + CPPUNIT_ASSERT_EQUAL(ss.str(), string("0")); + } + + void testOperatorIn2(void) + { + T point; + initPoint(point, int(10), int(20), int(30)); + + Trajectory<T> trajectory; + trajectory.setId(2); + trajectory.add(4, point); + + string s("2 4 10 20"); + if (dim(point) == 3) + { + s += string(" 30"); + } + + stringstream ss; + ss << trajectory; + + CPPUNIT_ASSERT_EQUAL(ss.str(), s); + } + + void testOperatorIn3(void) + { + sampleTrajectory.setId(20); + + string s("20"); + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + stringstream ss; + ss << string(" ") << i + 1 << string(" ") << i << string(" ") << i + 10; + if (dim(sampleTrajectory.getPoint(0)) == 3) + { + ss << string(" ") << i + 20; + } + s += ss.str(); + } + + stringstream ss; + ss << sampleTrajectory; + + CPPUNIT_ASSERT_EQUAL(ss.str(), s); + } + + void testOperatorOut1(void) + { + Trajectory<T> trajectory1; + stringstream ss; + ss << trajectory1; + + Trajectory<T> trajectory2; + istringstream is(ss.str()); + is >> trajectory2; + + CPPUNIT_ASSERT_EQUAL(trajectory1, trajectory2); + } + + void testOperatorOut2(void) + { + T point; + initPoint(point, int(10), int(20), int(30)); + + Trajectory<T> trajectory1; + trajectory1.setId(2); + trajectory1.add(4, point); + + string s("2 4 10 20"); + if (dim(point) == 3) + { + s += " 30"; + } + + stringstream ss; + ss << trajectory1; + + Trajectory<T> trajectory2; + istringstream is(ss.str()); + is >> trajectory2; + + CPPUNIT_ASSERT_EQUAL(trajectory1, trajectory2); + } + + void testOperatorOut3(void) + { + sampleTrajectory.setId(20); + + string s("20"); + + for (unsigned int i = 0; i < sampleTrajectory.size(); ++i) + { + stringstream ss; + ss << " " << i + 1 << " " << i << " " << i + 10; + if (dim(sampleTrajectory.getPoint(0)) == 3) + { + ss << " " << i + 20; + } + s += ss.str(); + } + + stringstream ss; + ss << sampleTrajectory; + + Trajectory<T> trajectory; + istringstream is(ss.str()); + is >> trajectory; + + CPPUNIT_ASSERT_EQUAL(trajectory, sampleTrajectory); + } + + void testMin1(void) + { + T point1; + initPoint(point1, 0, 10, 20); + T point2; + CPPUNIT_ASSERT_NO_THROW(point2 = min(sampleTrajectory)); + CPPUNIT_ASSERT_EQUAL(point1, point2); + } + + void testMin2(void) + { + Trajectory<T> trajectory; + T point1; + for (unsigned int i = 0; i < 100; ++i) + { + initPoint(point1, i + 4, 104 - i, i % 24 + 1); + trajectory += point1; + } + + initPoint(point1, 4, 5, 1); + + T point2; + CPPUNIT_ASSERT_NO_THROW(point2 = min(trajectory)); + + CPPUNIT_ASSERT_EQUAL(point1, point2); + } + + void testMin3(void) + { + Trajectory<T> trajectory; + CPPUNIT_ASSERT_THROW(min(trajectory), TrajectoryLengthErrorException); + } + + void testMin4(void) + { + Trajectory<T> trajectory; + T point1, point2; + initPoint(point1, 8, 4, 2); + trajectory.add(point1); + CPPUNIT_ASSERT_NO_THROW(point2 = min(trajectory)); + CPPUNIT_ASSERT_EQUAL(point1, point2); + } + + void testMax1(void) + { + T point1; + initPoint(point1, int(99), int(109), int(119)); + T point2; + CPPUNIT_ASSERT_NO_THROW(point2 = max(sampleTrajectory)); + CPPUNIT_ASSERT_EQUAL(point1, point2); + } + + void testMax2(void) + { + Trajectory<T> trajectory; + T point1; + for (unsigned int i = 0; i < 100; ++i) + { + initPoint(point1, int(i + 4), int(104 - i), int(i % 24 + 1)); + trajectory += point1; + } + + initPoint(point1, 103, 104, 24); + + T point2; + CPPUNIT_ASSERT_NO_THROW(point2 = max(trajectory)); + + CPPUNIT_ASSERT_EQUAL(point1, point2); + } + + void testMax3(void) + { + Trajectory<T> trajectory; + CPPUNIT_ASSERT_THROW(max(trajectory), TrajectoryLengthErrorException); + } + + void testMax4(void) + { + Trajectory<T> trajectory; + T point1, point2; + initPoint(point1, 8, 4, 2); + trajectory.add(point1); + CPPUNIT_ASSERT_NO_THROW(point2 = max(trajectory)); + CPPUNIT_ASSERT_EQUAL(point1, point2); + } + +private: + Trajectory<T> sampleTrajectory; +}; + +#endif /* TRAJECTORYTEST_H_ */