test/tim/prune/data/RangeStatsTest.java

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