test/tim/prune/data/TestRangeStats.java

   1 package tim.prune;
   2
   3 import tim.prune.data.DataPoint;
   4 import tim.prune.data.Field;
   5 import tim.prune.data.FieldList;
   6 import tim.prune.data.RangeStats;
   7 import tim.prune.data.TimestampUtc;
   8 import tim.prune.data.Track;
   9
  10 import org.junit.jupiter.api.Test;
  11 import static org.junit.jupiter.api.Assertions.assertEquals;
  12 import static org.junit.jupiter.api.Assertions.assertTrue;
  13 import static org.junit.jupiter.api.Assertions.assertFalse;
  14
  15 public class TestRangeStats {
  16         @Test
  17         void movingTime() {
  18                 Track track = new Track();
  19                 DataPoint[] points = {
  20                         new DataPoint(
  21                                 new String[] {
  22                                         "01-Jan-2020 00:00:00",
  23                                 },
  24                                 new FieldList(new Field[] {
  25                                         Field.TIMESTAMP,
  26                                 }),
  27                                 null),
  28                         new DataPoint(
  29                                 new String[] {
  30                                         "01-Jan-2020 00:00:05",
  31                                 },
  32                                 new FieldList(new Field[] {
  33                                         Field.TIMESTAMP,
  34                                 }),
  35                                 null),
  36                 };
  37                 track.appendPoints(points);
  38
  39                 RangeStats range = new RangeStats(track, 0, track.getNumPoints() - 1);
  40                 assertEquals(5, range.getMovingDurationInSeconds());
  41                 assertEquals(5, range.getTotalDurationInSeconds());
  42                 assertFalse(range.getTimestampsIncomplete());
  43                 assertFalse(range.getTimestampsOutOfSequence());
  44         }
  45
  46         @Test
  47         void movingTimeWithGap() {
  48                 Track track = new Track();
  49                 DataPoint[] points = {
  50                         new DataPoint(
  51                                 new String[] {
  52                                         "01-Jan-2020 00:00:00",
  53                                 },
  54                                 new FieldList(new Field[] {
  55                                         Field.TIMESTAMP,
  56                                 }),
  57                                 null),
  58                         new DataPoint(
  59                                 new String[] {},
  60                                 new FieldList(new Field[] {}),
  61                                 null),
  62                         new DataPoint(
  63                                 new String[] {
  64                                         "01-Jan-2020 00:00:05",
  65                                 },
  66                                 new FieldList(new Field[] {
  67                                         Field.TIMESTAMP,
  68                                 }),
  69                                 null),
  70                 };
  71                 track.appendPoints(points);
  72
  73                 RangeStats range = new RangeStats(track, 0, track.getNumPoints() - 1);
  74                 assertEquals(5, range.getMovingDurationInSeconds());
  75                 assertEquals(5, range.getTotalDurationInSeconds());
  76                 assertTrue(range.getTimestampsIncomplete());
  77                 assertFalse(range.getTimestampsOutOfSequence());
  78         }
  79
  80         @Test
  81         void movingTimeSeveralSegments() {
  82                 Track track = new Track();
  83                 DataPoint[] points = {
  84                         new DataPoint(
  85                                 new String[] {
  86                                         "01-Jan-2020 00:01:00",
  87                                 },
  88                                 new FieldList(new Field[] {
  89                                         Field.TIMESTAMP,
  90                                 }),
  91                                 null),
  92                         new DataPoint(
  93                                 new String[] {},
  94                                 new FieldList(new Field[] {}),
  95                                 null),
  96                         new DataPoint(
  97                                 new String[] {
  98                                         "01-Jan-2020 00:01:05",
  99                                 },
 100                                 new FieldList(new Field[] {
 101                                         Field.TIMESTAMP,
 102                                 }),
 103                                 null),
 104                         // start a second segment
 105                         new DataPoint(
 106                                 new String[] {
 107                                         "01-Jan-2020 00:00:20",
 108                                         "1",
 109                                 },
 110                                 new FieldList(new Field[] {
 111                                         Field.TIMESTAMP,
 112                                         Field.NEW_SEGMENT,
 113                                 }),
 114                                 null),
 115                         new DataPoint(
 116                                 new String[] {
 117                                         "01-Jan-2020 00:00:27",
 118                                 },
 119                                 new FieldList(new Field[] {
 120                                         Field.TIMESTAMP,
 121                                 }),
 122                                 null),
 123                 };
 124                 track.appendPoints(points);
 125
 126                 RangeStats range = new RangeStats(track, 0, track.getNumPoints() - 1);
 127                 assertEquals(5 + 7, range.getMovingDurationInSeconds());
 128                 assertEquals(45, range.getTotalDurationInSeconds());
 129                 assertTrue(range.getEarliestTimestamp().isEqual(new TimestampUtc("01-Jan-2020 00:00:20")));
 130                 assertTrue(range.getLatestTimestamp().isEqual(new TimestampUtc("01-Jan-2020 00:01:05")));
 131                 assertTrue(range.getTimestampsIncomplete());
 132
 133                 // even though segment 2 is earlier than segment 1, timestamps
 134                 // within each segment are normally ordered
 135                 assertFalse(range.getTimestampsOutOfSequence());
 136         }
 137
 138         @Test
 139         void movingTimeMissingFirstTimestamp() {
 140                 Track track = new Track();
 141                 DataPoint[] points = {
 142                         new DataPoint(
 143                                 new String[] {},
 144                                 new FieldList(new Field[] {}),
 145                                 null),
 146                         new DataPoint(
 147                                 new String[] {
 148                                         "01-Jan-2020 00:00:00",
 149                                 },
 150                                 new FieldList(new Field[] {
 151                                         Field.TIMESTAMP,
 152                                 }),
 153                                 null),
 154                         new DataPoint(
 155                                 new String[] {
 156                                         "01-Jan-2020 00:00:05",
 157                                 },
 158                                 new FieldList(new Field[] {
 159                                         Field.TIMESTAMP,
 160                                 }),
 161                                 null),
 162                 };
 163                 track.appendPoints(points);
 164
 165                 RangeStats range = new RangeStats(track, 0, track.getNumPoints() - 1);
 166                 assertEquals(5, range.getMovingDurationInSeconds());
 167                 assertEquals(5, range.getTotalDurationInSeconds());
 168                 assertTrue(range.getTimestampsIncomplete());
 169                 assertFalse(range.getTimestampsOutOfSequence());
 170         }
 171
 172 }