Add unit-tests for computing moving time with points missing timestamps

diff --git a/pom.xml b/pom.xml
index 2cb419374a729bd82b2a7965297ab7420b474a48..c7d70c66ea737e9a4c152e3ae80d5dd02746817c 100644 (file)
--- a/pom.xml
+++ b/pom.xml
@@ -44,12 +44,25 @@
                        <artifactId>j3dutils</artifactId>
                        <version>${j3dutils.version}</version>
                </dependency>
+               <dependency>
+                 <groupId>org.junit.jupiter</groupId>
+                 <artifactId>junit-jupiter-engine</artifactId>
+                 <version>5.7.1</version>
+                 <scope>test</scope>
+               </dependency>
+               <dependency>
+                 <groupId>org.junit.jupiter</groupId>
+                 <artifactId>junit-jupiter-api</artifactId>
+                 <version>5.7.1</version>
+                 <scope>test</scope>
+               </dependency>
        </dependencies>
 
        <build>
                <outputDirectory>${project.build.directory}/classes</outputDirectory>
                <finalName>${project.artifactId}_${project.version}</finalName>
-               <sourceDirectory>${project.basedir}/</sourceDirectory>
+               <sourceDirectory>${project.basedir}/src</sourceDirectory>
+               <testSourceDirectory>${project.basedir}/test</testSourceDirectory>
                <resources>
                        <resource>
                                <directory>${project.basedir}/src/</directory>
@@ -79,11 +92,11 @@
                                <plugin>
                                        <artifactId>maven-compiler-plugin</artifactId>
                                        <version>3.8.0</version>
-                                               <configuration>
-          <compilerArgs>
-            <arg>-Xlint:deprecation</arg>
-          </compilerArgs>
-        </configuration>
+                                       <configuration>
+                                         <compilerArgs>
+                                           <arg>-Xlint:deprecation</arg>
+                                         </compilerArgs>
+                                       </configuration>
                                </plugin>
                                <plugin>
                                        <artifactId>maven-jar-plugin</artifactId>
@@ -132,7 +145,14 @@
                                                <mainClass>${app.mainClass}</mainClass>
                                        </configuration>
                                </plugin>
-
+                               <plugin>
+                                 <artifactId>maven-surefire-plugin</artifactId>
+                                 <version>2.22.2</version>
+                               </plugin>
+                               <plugin>
+                                 <artifactId>maven-failsafe-plugin</artifactId>
+                                 <version>2.22.2</version>
+                               </plugin>
                        </plugins>
                </pluginManagement>
        </build>

diff --git a/test/tim/prune/data/TestRangeStats.java b/test/tim/prune/data/TestRangeStats.java
new file mode 100644 (file)
index 0000000..1493895
--- /dev/null
+++ b/test/tim/prune/data/TestRangeStats.java
@@ -0,0 +1,172 @@
+package tim.prune;
+
+import tim.prune.data.DataPoint;
+import tim.prune.data.Field;
+import tim.prune.data.FieldList;
+import tim.prune.data.RangeStats;
+import tim.prune.data.TimestampUtc;
+import tim.prune.data.Track;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+public class TestRangeStats {
+       @Test
+       void movingTime() {
+               Track track = new Track();
+               DataPoint[] points = {
+                       new DataPoint(
+                               new String[] {
+                                       "01-Jan-2020 00:00:00",
+                               },
+                               new FieldList(new Field[] {
+                                       Field.TIMESTAMP,
+                               }),
+                               null),
+                       new DataPoint(
+                               new String[] {
+                                       "01-Jan-2020 00:00:05",
+                               },
+                               new FieldList(new Field[] {
+                                       Field.TIMESTAMP,
+                               }),
+                               null),
+               };
+               track.appendPoints(points);
+
+               RangeStats range = new RangeStats(track, 0, track.getNumPoints() - 1);
+               assertEquals(5, range.getMovingDurationInSeconds());
+               assertEquals(5, range.getTotalDurationInSeconds());
+               assertFalse(range.getTimestampsIncomplete());
+               assertFalse(range.getTimestampsOutOfSequence());
+       }
+
+       @Test
+       void movingTimeWithGap() {
+               Track track = new Track();
+               DataPoint[] points = {
+                       new DataPoint(
+                               new String[] {
+                                       "01-Jan-2020 00:00:00",
+                               },
+                               new FieldList(new Field[] {
+                                       Field.TIMESTAMP,
+                               }),
+                               null),
+                       new DataPoint(
+                               new String[] {},
+                               new FieldList(new Field[] {}),
+                               null),
+                       new DataPoint(
+                               new String[] {
+                                       "01-Jan-2020 00:00:05",
+                               },
+                               new FieldList(new Field[] {
+                                       Field.TIMESTAMP,
+                               }),
+                               null),
+               };
+               track.appendPoints(points);
+
+               RangeStats range = new RangeStats(track, 0, track.getNumPoints() - 1);
+               assertEquals(5, range.getMovingDurationInSeconds());
+               assertEquals(5, range.getTotalDurationInSeconds());
+               assertTrue(range.getTimestampsIncomplete());
+               assertFalse(range.getTimestampsOutOfSequence());
+       }
+
+       @Test
+       void movingTimeSeveralSegments() {
+               Track track = new Track();
+               DataPoint[] points = {
+                       new DataPoint(
+                               new String[] {
+                                       "01-Jan-2020 00:01:00",
+                               },
+                               new FieldList(new Field[] {
+                                       Field.TIMESTAMP,
+                               }),
+                               null),
+                       new DataPoint(
+                               new String[] {},
+                               new FieldList(new Field[] {}),
+                               null),
+                       new DataPoint(
+                               new String[] {
+                                       "01-Jan-2020 00:01:05",
+                               },
+                               new FieldList(new Field[] {
+                                       Field.TIMESTAMP,
+                               }),
+                               null),
+                       // start a second segment
+                       new DataPoint(
+                               new String[] {
+                                       "01-Jan-2020 00:00:20",
+                                       "1",
+                               },
+                               new FieldList(new Field[] {
+                                       Field.TIMESTAMP,
+                                       Field.NEW_SEGMENT,
+                               }),
+                               null),
+                       new DataPoint(
+                               new String[] {
+                                       "01-Jan-2020 00:00:27",
+                               },
+                               new FieldList(new Field[] {
+                                       Field.TIMESTAMP,
+                               }),
+                               null),
+               };
+               track.appendPoints(points);
+
+               RangeStats range = new RangeStats(track, 0, track.getNumPoints() - 1);
+               assertEquals(5 + 7, range.getMovingDurationInSeconds());
+               assertEquals(45, range.getTotalDurationInSeconds());
+               assertTrue(range.getEarliestTimestamp().isEqual(new TimestampUtc("01-Jan-2020 00:00:20")));
+               assertTrue(range.getLatestTimestamp().isEqual(new TimestampUtc("01-Jan-2020 00:01:05")));
+               assertTrue(range.getTimestampsIncomplete());
+
+               // even though segment 2 is earlier than segment 1, timestamps
+               // within each segment are normally ordered
+               assertFalse(range.getTimestampsOutOfSequence());
+       }
+
+       @Test
+       void movingTimeMissingFirstTimestamp() {
+               Track track = new Track();
+               DataPoint[] points = {
+                       new DataPoint(
+                               new String[] {},
+                               new FieldList(new Field[] {}),
+                               null),
+                       new DataPoint(
+                               new String[] {
+                                       "01-Jan-2020 00:00:00",
+                               },
+                               new FieldList(new Field[] {
+                                       Field.TIMESTAMP,
+                               }),
+                               null),
+                       new DataPoint(
+                               new String[] {
+                                       "01-Jan-2020 00:00:05",
+                               },
+                               new FieldList(new Field[] {
+                                       Field.TIMESTAMP,
+                               }),
+                               null),
+               };
+               track.appendPoints(points);
+
+               RangeStats range = new RangeStats(track, 0, track.getNumPoints() - 1);
+               assertEquals(5, range.getMovingDurationInSeconds());
+               assertEquals(5, range.getTotalDurationInSeconds());
+               assertTrue(range.getTimestampsIncomplete());
+               assertFalse(range.getTimestampsOutOfSequence());
+       }
+
+}