From 77a2b9ccb493aaccc9656b8b5c382d0baf502f8a Mon Sep 17 00:00:00 2001 From: Daniel Collin Date: Thu, 18 Feb 2016 11:10:27 +0100 Subject: [PATCH] Renamed Timeutility class to UTCTimeUtility Added TimePeriod class for high level reprensentation of a period of time --- .../deamon/SensorDataAggregatorDaemon.java | 68 +-- .../hal/deamon/SensorDataCleanupDaemon.java | 24 +- src/se/hal/page/PCOverviewHttpPage.java | 10 +- src/se/hal/page/SensorOverviewHttpPage.java | 4 +- .../hal/util/AggregateDataListSqlResult.java | 14 +- src/se/hal/util/UTCTimePeriod.java | 48 ++ .../{TimeUtility.java => UTCTimeUtility.java} | 62 +- test/se/hal/util/TimePeriodTest.java | 128 ++++ test/se/hal/util/TimeUtilityTest.java | 564 ++++++++++++------ 9 files changed, 655 insertions(+), 267 deletions(-) create mode 100755 src/se/hal/util/UTCTimePeriod.java rename src/se/hal/util/{TimeUtility.java => UTCTimeUtility.java} (75%) create mode 100755 test/se/hal/util/TimePeriodTest.java diff --git a/src/se/hal/deamon/SensorDataAggregatorDaemon.java b/src/se/hal/deamon/SensorDataAggregatorDaemon.java index 143ad6b2..19d288b1 100755 --- a/src/se/hal/deamon/SensorDataAggregatorDaemon.java +++ b/src/se/hal/deamon/SensorDataAggregatorDaemon.java @@ -4,7 +4,8 @@ import se.hal.HalContext; import se.hal.intf.HalDaemon; import se.hal.struct.Sensor; import se.hal.intf.HalSensorData.AggregationMethod; -import se.hal.util.TimeUtility; +import se.hal.util.UTCTimePeriod; +import se.hal.util.UTCTimeUtility; import zutil.db.DBConnection; import zutil.db.SQLResultHandler; import zutil.db.handler.SimpleSQLResult; @@ -36,7 +37,7 @@ public class SensorDataAggregatorDaemon implements HalDaemon { } public void initiate(ScheduledExecutorService executor){ - executor.scheduleAtFixedRate(this, 0, TimeUtility.FIVE_MINUTES_IN_MS, TimeUnit.MILLISECONDS); + executor.scheduleAtFixedRate(this, 0, UTCTimeUtility.FIVE_MINUTES_IN_MS, TimeUnit.MILLISECONDS); } @Override @@ -61,16 +62,16 @@ public class SensorDataAggregatorDaemon implements HalDaemon { logger.fine("The sensor is of type: " + sensor.getDeviceData().getClass().getName()); logger.fine("aggregating raw data up to a day old into five minute periods"); - aggregateRawData(sensor, AggregationPeriodLength.FIVE_MINUTES, TimeUtility.DAY_IN_MS, 5); + aggregateRawData(sensor, AggregationPeriodLength.FIVE_MINUTES, UTCTimeUtility.DAY_IN_MS, 5); logger.fine("aggregating raw data up to a week old into one hour periods"); - aggregateRawData(sensor, AggregationPeriodLength.HOUR, TimeUtility.WEEK_IN_MS, 60); + aggregateRawData(sensor, AggregationPeriodLength.HOUR, UTCTimeUtility.WEEK_IN_MS, 60); logger.fine("aggregating raw data into one day periods"); - aggregateRawData(sensor, AggregationPeriodLength.DAY, TimeUtility.INFINITY, 60*24); + aggregateRawData(sensor, AggregationPeriodLength.DAY, UTCTimeUtility.INFINITY, 60*24); logger.fine("aggregating raw data into one week periods"); - aggregateRawData(sensor, AggregationPeriodLength.WEEK, TimeUtility.INFINITY, 60*24*7); + aggregateRawData(sensor, AggregationPeriodLength.WEEK, UTCTimeUtility.INFINITY, 60*24*7); } /** @@ -91,33 +92,34 @@ public class SensorDataAggregatorDaemon implements HalDaemon { + " AND timestamp_end-timestamp_start == ?"); stmt.setLong(1, sensorId); switch(aggrPeriodLength){ - case SECOND: stmt.setLong(2, TimeUtility.SECOND_IN_MS-1); break; - case MINUTE: stmt.setLong(2, TimeUtility.MINUTE_IN_MS-1); break; - case FIVE_MINUTES: stmt.setLong(2, TimeUtility.FIVE_MINUTES_IN_MS-1); break; - case FIFTEEN_MINUTES: stmt.setLong(2, TimeUtility.FIFTEEN_MINUTES_IN_MS-1); break; - case HOUR: stmt.setLong(2, TimeUtility.HOUR_IN_MS-1); break; - case DAY: stmt.setLong(2, TimeUtility.DAY_IN_MS-1); break; - case WEEK: stmt.setLong(2, TimeUtility.WEEK_IN_MS-1); break; + case SECOND: stmt.setLong(2, UTCTimeUtility.SECOND_IN_MS-1); break; + case MINUTE: stmt.setLong(2, UTCTimeUtility.MINUTE_IN_MS-1); break; + case FIVE_MINUTES: stmt.setLong(2, UTCTimeUtility.FIVE_MINUTES_IN_MS-1); break; + case FIFTEEN_MINUTES: stmt.setLong(2, UTCTimeUtility.FIFTEEN_MINUTES_IN_MS-1); break; + case HOUR: stmt.setLong(2, UTCTimeUtility.HOUR_IN_MS-1); break; + case DAY: stmt.setLong(2, UTCTimeUtility.DAY_IN_MS-1); break; + case WEEK: stmt.setLong(2, UTCTimeUtility.WEEK_IN_MS-1); break; default: logger.warning("aggregation period length is not supported."); return; } Long maxTimestampFoundForSensor = DBConnection.exec(stmt, new SimpleSQLResult()); if(maxTimestampFoundForSensor == null) maxTimestampFoundForSensor = 0l; - long currentPeriodStartTimestamp = TimeUtility.getTimestampPeriodStart_UTC(aggrPeriodLength, System.currentTimeMillis()); + long latestCompletePeriodEndTimestamp = new UTCTimePeriod(System.currentTimeMillis(), aggrPeriodLength).getPreviosPeriod().getEndTimestamp(); + long oldestPeriodStartTimestamp = new UTCTimePeriod(System.currentTimeMillis()-ageLimitInMs, aggrPeriodLength).getStartTimestamp(); - logger.fine("Calculating periods... (from:"+ maxTimestampFoundForSensor +", to:"+ currentPeriodStartTimestamp +") with expected sample count: " + expectedSampleCount); + logger.fine("Calculating periods... (from:"+ maxTimestampFoundForSensor +", to:"+ latestCompletePeriodEndTimestamp +") with expected sample count: " + expectedSampleCount); stmt = db.getPreparedStatement("SELECT *, 1 AS confidence FROM sensor_data_raw" +" WHERE sensor_id == ?" + " AND timestamp > ?" - + " AND timestamp < ? " + + " AND timestamp <= ? " + " AND timestamp >= ? " +" ORDER BY timestamp ASC"); stmt.setLong(1, sensorId); stmt.setLong(2, maxTimestampFoundForSensor); - stmt.setLong(3, currentPeriodStartTimestamp); - stmt.setLong(4, TimeUtility.getTimestampPeriodStart_UTC(aggrPeriodLength, System.currentTimeMillis()-ageLimitInMs)); + stmt.setLong(3, latestCompletePeriodEndTimestamp); + stmt.setLong(4, oldestPeriodStartTimestamp); DBConnection.exec(stmt, new DataAggregator(sensorId, aggrPeriodLength, expectedSampleCount, aggrMethod)); } catch (SQLException e) { logger.log(Level.SEVERE, null, e); @@ -145,8 +147,7 @@ public class SensorDataAggregatorDaemon implements HalDaemon { try{ HalContext.getDB().getConnection().setAutoCommit(false); - long currentPeriodTimestampStart = 0; - long currentPeriodTimestampEnd = 0; + UTCTimePeriod currentPeriod = null; float sum = 0; float confidenceSum = 0; int samples = 0; @@ -157,40 +158,35 @@ public class SensorDataAggregatorDaemon implements HalDaemon { if(sensorId != result.getInt("sensor_id")){ throw new IllegalArgumentException("found entry for aggregation for the wrong sensorId (expecting: "+sensorId+", but was: "+result.getInt("sensor_id")+")"); } - long timestamp = result.getLong("timestamp"); - long dataPeriodTimestampStart = TimeUtility.getTimestampPeriodStart_UTC(this.aggrPeriodLength, timestamp); - long dataPerionTimestampEnd = TimeUtility.getTimestampPeriodEnd_UTC(this.aggrPeriodLength, timestamp); - if(currentPeriodTimestampStart != 0 && currentPeriodTimestampEnd != 0 && dataPeriodTimestampStart != currentPeriodTimestampStart){ + long timestamp = result.getLong("timestamp"); + UTCTimePeriod dataPeriod = new UTCTimePeriod(timestamp, this.aggrPeriodLength); + + if(currentPeriod == null) + currentPeriod = dataPeriod; + + if(!dataPeriod.equals(currentPeriod)){ float aggrConfidence = confidenceSum / (float)this.expectedSampleCount; float data = -1; switch(aggrMethod){ case SUM: data = sum; break; case AVERAGE: data = sum/samples; break; } - logger.finer("Calculated period starting at timestamp: " + currentPeriodTimestampStart + ", data: " + sum + ", confidence: " + aggrConfidence + ", samples: " + samples + ", aggrMethod: " + aggrMethod); + logger.finer("Calculated period starting at timestamp: " + currentPeriod.getStartTimestamp() + ", data: " + sum + ", confidence: " + aggrConfidence + ", samples: " + samples + ", aggrMethod: " + aggrMethod); preparedInsertStmt.setInt(1, result.getInt("sensor_id")); preparedInsertStmt.setLong(2, ++highestSequenceId); - preparedInsertStmt.setLong(3, currentPeriodTimestampStart); - preparedInsertStmt.setLong(4, currentPeriodTimestampEnd); + preparedInsertStmt.setLong(3, currentPeriod.getStartTimestamp()); + preparedInsertStmt.setLong(4, currentPeriod.getEndTimestamp()); preparedInsertStmt.setFloat(5, data); preparedInsertStmt.setFloat(6, aggrConfidence); preparedInsertStmt.addBatch(); // Reset variables - currentPeriodTimestampStart = dataPeriodTimestampStart; - currentPeriodTimestampEnd = dataPerionTimestampEnd; + currentPeriod = dataPeriod; confidenceSum = 0; sum = 0; samples = 0; } - - if(currentPeriodTimestampStart == 0){ - currentPeriodTimestampStart = dataPeriodTimestampStart; - } - if(currentPeriodTimestampEnd == 0){ - currentPeriodTimestampEnd = dataPerionTimestampEnd; - } sum += result.getFloat("data"); confidenceSum += result.getFloat("confidence"); ++samples; diff --git a/src/se/hal/deamon/SensorDataCleanupDaemon.java b/src/se/hal/deamon/SensorDataCleanupDaemon.java index a1a7b249..c7721cc0 100755 --- a/src/se/hal/deamon/SensorDataCleanupDaemon.java +++ b/src/se/hal/deamon/SensorDataCleanupDaemon.java @@ -4,7 +4,7 @@ import se.hal.HalContext; import se.hal.deamon.SensorDataAggregatorDaemon.AggregationPeriodLength; import se.hal.intf.HalDaemon; import se.hal.struct.Sensor; -import se.hal.util.TimeUtility; +import se.hal.util.UTCTimeUtility; import zutil.db.DBConnection; import zutil.db.SQLResultHandler; import zutil.log.LogUtil; @@ -23,7 +23,7 @@ public class SensorDataCleanupDaemon implements HalDaemon { private static final Logger logger = LogUtil.getLogger(); public void initiate(ScheduledExecutorService executor){ - executor.scheduleAtFixedRate(this, 5000, TimeUtility.FIVE_MINUTES_IN_MS, TimeUnit.MILLISECONDS); + executor.scheduleAtFixedRate(this, 5000, UTCTimeUtility.FIVE_MINUTES_IN_MS, TimeUnit.MILLISECONDS); } @Override @@ -42,8 +42,8 @@ public class SensorDataCleanupDaemon implements HalDaemon { public void cleanupSensor(Sensor sensor) { if (sensor.getUser() != null) { - cleanupSensorData(sensor.getId(), AggregationPeriodLength.FIVE_MINUTES, TimeUtility.DAY_IN_MS); //clear 5-minute data older than a day - cleanupSensorData(sensor.getId(), AggregationPeriodLength.HOUR, TimeUtility.WEEK_IN_MS); //clear 1-hour data older than a week + cleanupSensorData(sensor.getId(), AggregationPeriodLength.FIVE_MINUTES, UTCTimeUtility.DAY_IN_MS); //clear 5-minute data older than a day + cleanupSensorData(sensor.getId(), AggregationPeriodLength.HOUR, UTCTimeUtility.WEEK_IN_MS); //clear 1-hour data older than a week //cleanupSensorData(sensor.getId(), AggregationPeriodLength.day, TimeUtility.INFINITY); //clear 1-day data older than infinity //cleanupSensorData(sensor.getId(), AggregationPeriodLength.week, TimeUtility.INFINITY); //clear 1-week data older than infinity } @@ -68,13 +68,13 @@ public class SensorDataCleanupDaemon implements HalDaemon { + "AND timestamp_end < ?"); stmt.setLong(1, sensorId); switch(cleanupPeriodlength){ - case SECOND: stmt.setLong(2, TimeUtility.SECOND_IN_MS-1); break; - case MINUTE: stmt.setLong(2, TimeUtility.MINUTE_IN_MS-1); break; - case FIVE_MINUTES: stmt.setLong(2, TimeUtility.FIVE_MINUTES_IN_MS-1); break; - case FIFTEEN_MINUTES: stmt.setLong(2, TimeUtility.FIFTEEN_MINUTES_IN_MS-1); break; - case HOUR: stmt.setLong(2, TimeUtility.HOUR_IN_MS-1); break; - case DAY: stmt.setLong(2, TimeUtility.DAY_IN_MS-1); break; - case WEEK: stmt.setLong(2, TimeUtility.WEEK_IN_MS-1); break; + case SECOND: stmt.setLong(2, UTCTimeUtility.SECOND_IN_MS-1); break; + case MINUTE: stmt.setLong(2, UTCTimeUtility.MINUTE_IN_MS-1); break; + case FIVE_MINUTES: stmt.setLong(2, UTCTimeUtility.FIVE_MINUTES_IN_MS-1); break; + case FIFTEEN_MINUTES: stmt.setLong(2, UTCTimeUtility.FIFTEEN_MINUTES_IN_MS-1); break; + case HOUR: stmt.setLong(2, UTCTimeUtility.HOUR_IN_MS-1); break; + case DAY: stmt.setLong(2, UTCTimeUtility.DAY_IN_MS-1); break; + case WEEK: stmt.setLong(2, UTCTimeUtility.WEEK_IN_MS-1); break; default: logger.warning("cleanup period length is not supported."); return; } stmt.setLong(3, System.currentTimeMillis()-olderThan); @@ -101,7 +101,7 @@ public class SensorDataCleanupDaemon implements HalDaemon { if(sensorId != result.getInt("sensor_id")){ throw new IllegalArgumentException("Found entry for aggregation for the wrong sensorId (expecting: "+sensorId+", but was: "+result.getInt("sensor_id")+")"); } - logger.finer("Deleting sensor(id: "+ sensorId +") aggregate entry timestamp: "+ result.getLong("timestamp_start") +" - "+ result.getLong("timestamp_end") + " (" + TimeUtility.timeInMsToString(result.getLong("timestamp_end")-result.getLong("timestamp_start")) + ")"); + logger.finer("Deleting sensor(id: "+ sensorId +") aggregate entry timestamp: "+ result.getLong("timestamp_start") +" - "+ result.getLong("timestamp_end") + " (" + UTCTimeUtility.timeInMsToString(result.getLong("timestamp_end")-result.getLong("timestamp_start")) + ")"); preparedDeleteStmt.setInt(1, result.getInt("sensor_id")); preparedDeleteStmt.setLong(2, result.getLong("sequence_id")); preparedDeleteStmt.addBatch(); diff --git a/src/se/hal/page/PCOverviewHttpPage.java b/src/se/hal/page/PCOverviewHttpPage.java index 228f4d71..ed4b1598 100755 --- a/src/se/hal/page/PCOverviewHttpPage.java +++ b/src/se/hal/page/PCOverviewHttpPage.java @@ -5,7 +5,7 @@ import se.hal.deamon.SensorDataAggregatorDaemon.AggregationPeriodLength; import se.hal.intf.HalHttpPage; import se.hal.util.AggregateDataListSqlResult; import se.hal.util.AggregateDataListSqlResult.*; -import se.hal.util.TimeUtility; +import se.hal.util.UTCTimeUtility; import se.hal.struct.Sensor; import se.hal.struct.User; import zutil.db.DBConnection; @@ -43,13 +43,13 @@ public class PCOverviewHttpPage extends HalHttpPage { for(User user : users){ List userSensors = Sensor.getSensors(db, user); for(Sensor sensor : userSensors){ - minDataList.addAll(AggregateDataListSqlResult.getAggregateDataForPeriod(db, sensor, AggregationPeriodLength.FIVE_MINUTES, TimeUtility.DAY_IN_MS)); + minDataList.addAll(AggregateDataListSqlResult.getAggregateDataForPeriod(db, sensor, AggregationPeriodLength.FIVE_MINUTES, UTCTimeUtility.DAY_IN_MS)); - hourDataList.addAll(AggregateDataListSqlResult.getAggregateDataForPeriod(db, sensor, AggregationPeriodLength.HOUR, TimeUtility.WEEK_IN_MS)); + hourDataList.addAll(AggregateDataListSqlResult.getAggregateDataForPeriod(db, sensor, AggregationPeriodLength.HOUR, UTCTimeUtility.WEEK_IN_MS)); - dayDataList.addAll(AggregateDataListSqlResult.getAggregateDataForPeriod(db, sensor, AggregationPeriodLength.DAY, TimeUtility.INFINITY)); + dayDataList.addAll(AggregateDataListSqlResult.getAggregateDataForPeriod(db, sensor, AggregationPeriodLength.DAY, UTCTimeUtility.INFINITY)); - weekDataList.addAll(AggregateDataListSqlResult.getAggregateDataForPeriod(db, sensor, AggregationPeriodLength.WEEK, TimeUtility.INFINITY)); + weekDataList.addAll(AggregateDataListSqlResult.getAggregateDataForPeriod(db, sensor, AggregationPeriodLength.WEEK, UTCTimeUtility.INFINITY)); } } diff --git a/src/se/hal/page/SensorOverviewHttpPage.java b/src/se/hal/page/SensorOverviewHttpPage.java index 65625021..f87c3328 100755 --- a/src/se/hal/page/SensorOverviewHttpPage.java +++ b/src/se/hal/page/SensorOverviewHttpPage.java @@ -8,7 +8,7 @@ import se.hal.util.AggregateDataListSqlResult; import zutil.db.DBConnection; import se.hal.util.HistoryDataListSqlResult; import se.hal.util.HistoryDataListSqlResult.*; -import se.hal.util.TimeUtility; +import se.hal.util.UTCTimeUtility; import zutil.io.file.FileUtil; import zutil.parser.Templator; @@ -51,7 +51,7 @@ public class SensorOverviewHttpPage extends HalHttpPage { Templator tmpl = new Templator(FileUtil.find(DETAIL_TEMPLATE)); tmpl.set("sensor", sensor); tmpl.set("history", history); - tmpl.set("aggregation", AggregateDataListSqlResult.getAggregateDataForPeriod(db, sensor, AggregationPeriodLength.HOUR, TimeUtility.WEEK_IN_MS)); + tmpl.set("aggregation", AggregateDataListSqlResult.getAggregateDataForPeriod(db, sensor, AggregationPeriodLength.HOUR, UTCTimeUtility.WEEK_IN_MS)); return tmpl; } else { diff --git a/src/se/hal/util/AggregateDataListSqlResult.java b/src/se/hal/util/AggregateDataListSqlResult.java index 3f57e248..e791cf3d 100755 --- a/src/se/hal/util/AggregateDataListSqlResult.java +++ b/src/se/hal/util/AggregateDataListSqlResult.java @@ -43,13 +43,13 @@ public class AggregateDataListSqlResult implements SQLResultHandler data(){ + return Arrays.asList(new Object[][] { + {694223999999L}, //1991-12-31 23:59:59.999 GMT (last ms of year 1991) + {694224000000L}, //1992-01-01 00:00:00.000 GMT (first ms of year 1992) + {1456703999999L}, //2016-02-28 23:59:59.999 GMT (last ms before a leap day) + {1456704000000L}, //2016-02-29 00:00:00.000 GMT (first ms of a leap day) + {1456749808000L}, //2016-02-29 12:43:28.000 GMT (random time during a leap day) + {1456790399999L}, //2016-02-29 23:59:59.999 GMT (last ms of a leap day) + {1456790400000L}, //2016-03-30 00:00:00.000 GMT (first ms after a leap day) + {System.currentTimeMillis()}, //current time + {System.currentTimeMillis()+UTCTimeUtility.MINUTE_IN_MS}, //current time + 1m + {System.currentTimeMillis()+(2*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 2m + {System.currentTimeMillis()+(3*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 3m + {System.currentTimeMillis()+(4*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 4m + {System.currentTimeMillis()+(5*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 5m + {System.currentTimeMillis()+(6*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 6m + {System.currentTimeMillis()+(7*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 7m + }); + } + + @Test + public void testYearTimePeriod(){ + testSeriesOfPeriods(AggregationPeriodLength.YEAR); + } + + @Test + public void testMonthTimePeriod(){ + testSeriesOfPeriods(AggregationPeriodLength.MONTH); + } + + @Test + public void testWeekTimePeriod(){ + testSeriesOfPeriods(AggregationPeriodLength.WEEK); + } + + @Test + public void testDayTimePeriod(){ + testSeriesOfPeriods(AggregationPeriodLength.DAY); + } + + @Test + public void testHourTimePeriod(){ + testSeriesOfPeriods(AggregationPeriodLength.HOUR); + } + + @Test + public void test15MiuteTimePeriod(){ + testSeriesOfPeriods(AggregationPeriodLength.FIFTEEN_MINUTES); + } + + @Test + public void test5MiuteTimePeriod(){ + testSeriesOfPeriods(AggregationPeriodLength.FIVE_MINUTES); + } + + @Test + public void testMiuteTimePeriod(){ + testSeriesOfPeriods(AggregationPeriodLength.MINUTE); + } + + @Test + public void testSecondTimePeriod(){ + testSeriesOfPeriods(AggregationPeriodLength.SECOND); + } + + private void testSeriesOfPeriods(AggregationPeriodLength periodLength){ + UTCTimePeriod tp = new UTCTimePeriod(currentTime_UTC, periodLength); + + //test next 50 periods + UTCTimePeriod prevTp = tp; + UTCTimePeriod nextTp = null; + for(int i = 0; i < 50; ++i){ + nextTp = prevTp.getNextPeriod(); + assertTrue("previos period end must be older than the next period end", prevTp.getEndTimestamp() < nextTp.getStartTimestamp()); + assertTrue("previous period +1ms must be equal to next period start", prevTp.getEndTimestamp()+1 == nextTp.getStartTimestamp()); + assertTrue("previous and next period should not be the same", !prevTp.equals(nextTp)); + testPeriod(nextTp, periodLength); + prevTp = nextTp; + } + + //test previous 50 periods + nextTp = tp; + for(int i = 0; i < 50; ++i){ + prevTp = nextTp.getPreviosPeriod(); + assertTrue("previos period end must be older than the next period end", prevTp.getEndTimestamp() < nextTp.getStartTimestamp()); + assertTrue("previous period +1ms must be equal to next period start", prevTp.getEndTimestamp()+1 == nextTp.getStartTimestamp()); + assertTrue("previous and next period should not be the same", !prevTp.equals(nextTp)); + testPeriod(nextTp, periodLength); + nextTp = prevTp; + } + } + + private void testPeriod(UTCTimePeriod period, AggregationPeriodLength periodLength){ + //verify that the period start and end is in the same period + assertEquals("start and/or end timestamp is not in the same period", period.getStartTimestamp(), UTCTimeUtility.getTimestampPeriodStart(periodLength, period.getEndTimestamp())); + assertEquals("start and/or end timestamp is not in the same period", period.getEndTimestamp(), UTCTimeUtility.getTimestampPeriodEnd(periodLength, period.getStartTimestamp())); + } + +} diff --git a/test/se/hal/util/TimeUtilityTest.java b/test/se/hal/util/TimeUtilityTest.java index 448cd24b..019a8e7c 100755 --- a/test/se/hal/util/TimeUtilityTest.java +++ b/test/se/hal/util/TimeUtilityTest.java @@ -1,6 +1,5 @@ package se.hal.util; -import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; @@ -11,6 +10,7 @@ import se.hal.deamon.SensorDataAggregatorDaemon.AggregationPeriodLength; import java.util.Arrays; import java.util.Calendar; import java.util.Collection; +import java.util.TimeZone; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; @@ -31,7 +31,7 @@ public class TimeUtilityTest { @Parameters public static Collection data(){ return Arrays.asList(new Object[][] { - {TimeUtility.WEEK_IN_MS}, //a week after 1970-01-01 00:00:00 + {60*UTCTimeUtility.WEEK_IN_MS}, //min time + 60w {694223999999L}, //1991-12-31 23:59:59.999 GMT (last ms of year 1991) {694224000000L}, //1992-01-01 00:00:00.000 GMT (first ms of year 1992) {1456703999999L}, //2016-02-28 23:59:59.999 GMT (last ms before a leap day) @@ -40,266 +40,450 @@ public class TimeUtilityTest { {1456790399999L}, //2016-02-29 23:59:59.999 GMT (last ms of a leap day) {1456790400000L}, //2016-03-30 00:00:00.000 GMT (first ms after a leap day) {System.currentTimeMillis()}, //current time - {System.currentTimeMillis()+TimeUtility.MINUTE_IN_MS}, //current time + 1m - {System.currentTimeMillis()+(2*TimeUtility.MINUTE_IN_MS)}, //current time + 2m - {System.currentTimeMillis()+(3*TimeUtility.MINUTE_IN_MS)}, //current time + 3m - {System.currentTimeMillis()+(4*TimeUtility.MINUTE_IN_MS)}, //current time + 4m - {System.currentTimeMillis()+(5*TimeUtility.MINUTE_IN_MS)}, //current time + 5m - {System.currentTimeMillis()+(6*TimeUtility.MINUTE_IN_MS)}, //current time + 6m - {System.currentTimeMillis()+(7*TimeUtility.MINUTE_IN_MS)}, //current time + 7m - {Long.MAX_VALUE-(60*TimeUtility.WEEK_IN_MS)}, //max time - 60w + {System.currentTimeMillis()+UTCTimeUtility.MINUTE_IN_MS}, //current time + 1m + {System.currentTimeMillis()+(2*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 2m + {System.currentTimeMillis()+(3*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 3m + {System.currentTimeMillis()+(4*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 4m + {System.currentTimeMillis()+(5*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 5m + {System.currentTimeMillis()+(6*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 6m + {System.currentTimeMillis()+(7*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 7m + {Long.MAX_VALUE-(60*UTCTimeUtility.WEEK_IN_MS)}, //max time - 60w }); } - @Before - public void printCurrentTimeStamp(){ - System.out.println("Testing with timestamp: " + currentTime_UTC); - } - // Test flooring & ceiling UTC time to the closes year @Test - public void testYear_UTC(){ - long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.YEAR, currentTime_UTC); - assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start minute is wrong", 0, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start hour is wrong", 0, TimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start day is wrong", 1, TimeUtility.getDayOfYearFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start month is wrong", Calendar.JANUARY, TimeUtility.getMonthOfYearFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + public void testYear_UTC(){ + System.out.println("Testing year with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC)); + Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC")); + tmpCal.setTimeInMillis(currentTime_UTC); - long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.YEAR, currentTime_UTC); - assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end second is wrong", 59, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end minute is wrong", 59, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end hour is wrong", 23, TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end day is wrong", 31, TimeUtility.getDayOfMonthFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end month is wrong", Calendar.DECEMBER, TimeUtility.getMonthOfYearFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.YEAR, currentTime_UTC); + long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.YEAR, currentTime_UTC); + + //verify period start is correct + System.out.println(" year start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt)); + assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC); + assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start second is wrong", 0, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start minute is wrong", 0, UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start hour is wrong", 0, UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start day is wrong", 1, UTCTimeUtility.getDayOfYearFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start month is wrong", Calendar.JANUARY, UTCTimeUtility.getMonthOfYearFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + + //verify period end is correct + System.out.println(" year end timestamp = " + thisPeriodEndedAt + " " + UTCTimeUtility.getDateString(thisPeriodEndedAt)); + assertTrue("perdiod end is not ater current time", thisPeriodEndedAt >= currentTime_UTC); + assertEquals("period end millisecond is wrong", 999, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end second is wrong", 59, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end minute is wrong", 59, UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end hour is wrong", 23, UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end day is wrong", 31, UTCTimeUtility.getDayOfMonthFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end month is wrong", Calendar.DECEMBER, UTCTimeUtility.getMonthOfYearFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + + //verify that start and end values are reasonable + assertTrue("start is zero", thisPeriodStartedAt != 0); + assertTrue("end is zero", thisPeriodEndedAt != 0); + assertTrue("start is not before end", thisPeriodStartedAt < thisPeriodEndedAt ); + assertTrue("start and end are equal", thisPeriodStartedAt != thisPeriodEndedAt ); + + //verify that the period start and end is in the same period + assertEquals("start and/or end timestamp is not in the same period", thisPeriodStartedAt, UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.YEAR, thisPeriodEndedAt)); + assertEquals("start and/or end timestamp is not in the same period", thisPeriodEndedAt, UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.YEAR, thisPeriodStartedAt)); } // Test flooring & ceiling UTC time to the closes month @Test public void testMonth_UTC(){ - long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.MONTH, currentTime_UTC); - assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start minute is wrong", 0, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start hour is wrong", 0, TimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start day is wrong", 1, TimeUtility.getDayOfMonthFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start month is wrong", TimeUtility.getMonthOfYearFromTimestamp(currentTime_UTC), TimeUtility.getMonthOfYearFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + System.out.println("Testing month with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC)); + Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC")); + tmpCal.setTimeInMillis(currentTime_UTC); + + long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.MONTH, currentTime_UTC); + long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.MONTH, currentTime_UTC); + + //verify period start is correct + System.out.println(" month start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt)); + assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC); + assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start second is wrong", 0, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start minute is wrong", 0, UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start hour is wrong", 0, UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start day is wrong", 1, UTCTimeUtility.getDayOfMonthFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start month is wrong", UTCTimeUtility.getMonthOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getMonthOfYearFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); - long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.MONTH, currentTime_UTC); - assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end second is wrong", 59, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end minute is wrong", 59, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end hour is wrong", 23, TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); - assertTrue("day of month is less than 28", TimeUtility.getDayOfMonthFromTimestamp(thisPeriodEndedAt) >= 28); - assertEquals("period end month is wrong", TimeUtility.getMonthOfYearFromTimestamp(currentTime_UTC), TimeUtility.getMonthOfYearFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + //verify period end is correct + System.out.println(" month end timestamp = " + thisPeriodEndedAt + " " + UTCTimeUtility.getDateString(thisPeriodEndedAt)); + assertTrue("perdiod end is not ater current time", thisPeriodEndedAt >= currentTime_UTC); + assertEquals("period end millisecond is wrong", 999, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end second is wrong", 59, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end minute is wrong", 59, UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end hour is wrong", 23, UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end day is wrong", tmpCal.getActualMaximum(Calendar.DAY_OF_MONTH), UTCTimeUtility.getDayOfMonthFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end month is wrong", UTCTimeUtility.getMonthOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getMonthOfYearFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + + //verify that start and end values are reasonable + assertTrue("start is zero", thisPeriodStartedAt != 0); + assertTrue("end is zero", thisPeriodEndedAt != 0); + assertTrue("start is not before end", thisPeriodStartedAt < thisPeriodEndedAt ); + assertTrue("start and end are equal", thisPeriodStartedAt != thisPeriodEndedAt ); + + //verify that the period start and end is in the same period + assertEquals("start and/or end timestamp is not in the same period", thisPeriodStartedAt, UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.MONTH, thisPeriodEndedAt)); + assertEquals("start and/or end timestamp is not in the same period", thisPeriodEndedAt, UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.MONTH, thisPeriodStartedAt)); } // Test flooring & ceiling UTC time to the closes week @Test public void testWeek_UTC(){ - long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.WEEK, currentTime_UTC); - assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start minute is wrong", 0, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start hour is wrong", 0, TimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start day is wrong", Calendar.MONDAY, TimeUtility.getDayOfWeekFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodStartedAt)); - assertTrue("period start year is more than one year off", TimeUtility.getYearFromTimestamp(currentTime_UTC)-TimeUtility.getYearFromTimestamp(thisPeriodStartedAt) <= 1); + System.out.println("Testing week with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC)); + Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC")); + tmpCal.setTimeInMillis(currentTime_UTC); - long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.WEEK, currentTime_UTC); - assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end second is wrong", 59, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end minute is wrong", 59, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end hour is wrong", 23, TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end day is wrong", Calendar.SUNDAY, TimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); - assertTrue("period end year is more than one year off", TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)-TimeUtility.getYearFromTimestamp(currentTime_UTC) <= 1); + long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.WEEK, currentTime_UTC); + long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.WEEK, currentTime_UTC); + + //verify period start is correct + System.out.println(" week start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt)); + assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC); + assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start second is wrong", 0, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start minute is wrong", 0, UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start hour is wrong", 0, UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start day is wrong", Calendar.MONDAY, UTCTimeUtility.getDayOfWeekFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start week is wrong", UTCTimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getWeekOfYearFromTimestamp(thisPeriodStartedAt)); + assertTrue("period start year is more than one year off", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC)-UTCTimeUtility.getYearFromTimestamp(thisPeriodStartedAt) <= 1); + + //verify period end is correct + System.out.println(" week end timestamp = " + thisPeriodEndedAt + " " + UTCTimeUtility.getDateString(thisPeriodEndedAt)); + assertTrue("perdiod end is not ater current time", thisPeriodEndedAt >= currentTime_UTC); + assertEquals("period end millisecond is wrong", 999, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end second is wrong", 59, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end minute is wrong", 59, UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end hour is wrong", 23, UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end day is wrong", Calendar.SUNDAY, UTCTimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end week is wrong", UTCTimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); + assertTrue("period end year is more than one year off", UTCTimeUtility.getYearFromTimestamp(thisPeriodEndedAt)-UTCTimeUtility.getYearFromTimestamp(currentTime_UTC) <= 1); + + //verify that start and end values are reasonable + assertTrue("start is zero", thisPeriodStartedAt != 0); + assertTrue("end is zero", thisPeriodEndedAt != 0); + assertTrue("start is not before end", thisPeriodStartedAt < thisPeriodEndedAt ); + assertTrue("start and end are equal", thisPeriodStartedAt != thisPeriodEndedAt ); + + //verify that the period start and end is in the same period + assertEquals("start and/or end timestamp is not in the same period", thisPeriodStartedAt, UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.WEEK, thisPeriodEndedAt)); + assertEquals("start and/or end timestamp is not in the same period", thisPeriodEndedAt, UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.WEEK, thisPeriodStartedAt)); } // Test flooring & ceiling UTC time to the closes day @Test public void testDay_UTC(){ - long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.DAY, currentTime_UTC); - assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start minute is wrong", 0, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start hour is wrong", 0, TimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start day is wrong", TimeUtility.getDayOfYearFromTimestamp(currentTime_UTC), TimeUtility.getDayOfYearFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + System.out.println("Testing day with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC)); + Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC")); + tmpCal.setTimeInMillis(currentTime_UTC); + + long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.DAY, currentTime_UTC); + long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.DAY, currentTime_UTC); - long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.DAY, currentTime_UTC); - assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end second is wrong", 59, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end minute is wrong", 59, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end hour is wrong", 23, TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end day is wrong", TimeUtility.getDayOfYearFromTimestamp(currentTime_UTC), TimeUtility.getDayOfYearFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end month is wrong", TimeUtility.getMonthOfYearFromTimestamp(currentTime_UTC), TimeUtility.getMonthOfYearFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + //verify period start is correct + System.out.println(" day start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt)); + assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC); + assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start second is wrong", 0, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start minute is wrong", 0, UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start hour is wrong", 0, UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start day is wrong", UTCTimeUtility.getDayOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getDayOfYearFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start week is wrong", UTCTimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getWeekOfYearFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + + //verify period end is correct + System.out.println(" day end timestamp = " + thisPeriodEndedAt + " " + UTCTimeUtility.getDateString(thisPeriodEndedAt)); + assertTrue("perdiod end is not ater current time", thisPeriodEndedAt >= currentTime_UTC); + assertEquals("period end millisecond is wrong", 999, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end second is wrong", 59, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end minute is wrong", 59, UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end hour is wrong", 23, UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end day is wrong", UTCTimeUtility.getDayOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getDayOfYearFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end week is wrong", UTCTimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end month is wrong", UTCTimeUtility.getMonthOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getMonthOfYearFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + + //verify that start and end values are reasonable + assertTrue("start is zero", thisPeriodStartedAt != 0); + assertTrue("end is zero", thisPeriodEndedAt != 0); + assertTrue("start is not before end", thisPeriodStartedAt < thisPeriodEndedAt ); + assertTrue("start and end are equal", thisPeriodStartedAt != thisPeriodEndedAt ); + + //verify that the period start and end is in the same period + assertEquals("start and/or end timestamp is not in the same period", thisPeriodStartedAt, UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.DAY, thisPeriodEndedAt)); + assertEquals("start and/or end timestamp is not in the same period", thisPeriodEndedAt, UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.DAY, thisPeriodStartedAt)); } // Test flooring & ceiling UTC time to the closes hour @Test public void testHour_UTC(){ - long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.HOUR, currentTime_UTC); - assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start minute is wrong", 0, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start day is wrong", TimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), TimeUtility.getDayOfWeekFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + System.out.println("Testing hour with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC)); + Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC")); + tmpCal.setTimeInMillis(currentTime_UTC); + + long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.HOUR, currentTime_UTC); + long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.HOUR, currentTime_UTC); - long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.HOUR, currentTime_UTC); - assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end second is wrong", 59, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end minute is wrong", 59, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end day is wrong", TimeUtility.getDayOfYearFromTimestamp(currentTime_UTC), TimeUtility.getDayOfYearFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end month is wrong", TimeUtility.getMonthOfYearFromTimestamp(currentTime_UTC), TimeUtility.getMonthOfYearFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + //verify period start is correct + System.out.println(" hour start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt)); + assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC); + assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start second is wrong", 0, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start minute is wrong", 0, UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start hour is wrong", UTCTimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start day is wrong", UTCTimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), UTCTimeUtility.getDayOfWeekFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start week is wrong", UTCTimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getWeekOfYearFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + + //verify period end is correct + System.out.println(" hour end timestamp = " + thisPeriodEndedAt + " " + UTCTimeUtility.getDateString(thisPeriodEndedAt)); + assertTrue("perdiod end is not ater current time", thisPeriodEndedAt >= currentTime_UTC); + assertEquals("period end millisecond is wrong", 999, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end second is wrong", 59, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end minute is wrong", 59, UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end hour is wrong", UTCTimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end day is wrong", UTCTimeUtility.getDayOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getDayOfYearFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end week is wrong", UTCTimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end month is wrong", UTCTimeUtility.getMonthOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getMonthOfYearFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + + //verify that start and end values are reasonable + assertTrue("start is zero", thisPeriodStartedAt != 0); + assertTrue("end is zero", thisPeriodEndedAt != 0); + assertTrue("start is not before end", thisPeriodStartedAt < thisPeriodEndedAt ); + assertTrue("start and end are equal", thisPeriodStartedAt != thisPeriodEndedAt ); + + //verify that the period start and end is in the same period + assertEquals("start and/or end timestamp is not in the same period", thisPeriodStartedAt, UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.HOUR, thisPeriodEndedAt)); + assertEquals("start and/or end timestamp is not in the same period", thisPeriodEndedAt, UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.HOUR, thisPeriodStartedAt)); } // Test flooring & ceiling UTC time to the closes 15-minute period @Test public void testFifteenMinute_UTC(){ - long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.FIFTEEN_MINUTES, currentTime_UTC); - assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); - assertTrue("the period start minute is in the future of the current time", TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) >= TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); - assertTrue("the period starts more than 5 minutes before the current time", TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC)-TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt) <= 14); - assertTrue("the period start minute is not a multiple of five", TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt) % 15 == 0); - assertEquals("period start hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start day is wrong", TimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), TimeUtility.getDayOfWeekFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + System.out.println("Testing 15-min with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC)); + Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC")); + tmpCal.setTimeInMillis(currentTime_UTC); - long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.FIFTEEN_MINUTES, currentTime_UTC); - assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end second is wrong", 59, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); - assertTrue("the period end minute is before of the current time", TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) <= TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); - assertTrue("the period ends more than 15 minutes after the current time", TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)-TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) <= 14); - assertTrue("the period end minute(+1) is not a multiple of fifteen", TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt+1) % 15 == 0); - assertEquals("period end hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end day is wrong", TimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), TimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.FIFTEEN_MINUTES, currentTime_UTC); + long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.FIFTEEN_MINUTES, currentTime_UTC); + + //verify period start is correct + System.out.println(" 15-min start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt)); + assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC); + assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start second is wrong", 0, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); + assertTrue("the period start minute is in the future of the current time", UTCTimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) >= UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); + assertTrue("the period starts more than 5 minutes before the current time", UTCTimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC)-UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt) <= 14); + assertTrue("the period start minute is not a multiple of five", UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt) % 15 == 0); + assertEquals("period start hour is wrong", UTCTimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start day is wrong", UTCTimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), UTCTimeUtility.getDayOfWeekFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start week is wrong", UTCTimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getWeekOfYearFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + + //verify period end is correct + System.out.println(" 15-min end timestamp = " + thisPeriodEndedAt + " " + UTCTimeUtility.getDateString(thisPeriodEndedAt)); + assertTrue("perdiod end is not ater current time", thisPeriodEndedAt >= currentTime_UTC); + assertEquals("period end millisecond is wrong", 999, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end second is wrong", 59, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); + assertTrue("the period end minute is before of the current time", UTCTimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) <= UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); + assertTrue("the period ends more than 15 minutes after the current time", UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)-UTCTimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) <= 14); + assertTrue("the period end minute(+1) is not a multiple of fifteen", UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt+1) % 15 == 0); + assertEquals("period end hour is wrong", UTCTimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end day is wrong", UTCTimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), UTCTimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end week is wrong", UTCTimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + + //verify that start and end values are reasonable + assertTrue("start is zero", thisPeriodStartedAt != 0); + assertTrue("end is zero", thisPeriodEndedAt != 0); + assertTrue("start is not before end", thisPeriodStartedAt < thisPeriodEndedAt ); + assertTrue("start and end are equal", thisPeriodStartedAt != thisPeriodEndedAt ); + + //verify that the period start and end is in the same period + assertEquals("start and/or end timestamp is not in the same period", thisPeriodStartedAt, UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.FIFTEEN_MINUTES, thisPeriodEndedAt)); + assertEquals("start and/or end timestamp is not in the same period", thisPeriodEndedAt, UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.FIFTEEN_MINUTES, thisPeriodStartedAt)); } // Test flooring & ceiling UTC time to the closes 5-minute period @Test public void testFiveMinute_UTC(){ - long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.FIVE_MINUTES, currentTime_UTC); - assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); - assertTrue("the period start minute is in the future of the current time", TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) >= TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); - assertTrue("the period starts more than 5 minutes before the current time", TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC)-TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt) <= 4); - assertTrue("the period start minute is not a multiple of five", TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt) % 5 == 0); - assertEquals("period start hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start day is wrong", TimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), TimeUtility.getDayOfWeekFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + System.out.println("Testing 5-min with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC)); + Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC")); + tmpCal.setTimeInMillis(currentTime_UTC); - long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.FIVE_MINUTES, currentTime_UTC); - assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end second is wrong", 59, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); - assertTrue("the period end minute is before of the current time", TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) <= TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); - assertTrue("the period ends more than 5 minutes after the current time", TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)-TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) <= 4); - assertTrue("the period end minute(+1) is not a multiple of five", TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt+1) % 5 == 0); - assertEquals("period end hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end day is wrong", TimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), TimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.FIVE_MINUTES, currentTime_UTC); + long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.FIVE_MINUTES, currentTime_UTC); + + //verify period start is correct + System.out.println(" 5-min start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt)); + assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC); + assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start second is wrong", 0, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); + assertTrue("the period start minute is in the future of the current time", UTCTimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) >= UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); + assertTrue("the period starts more than 5 minutes before the current time", UTCTimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC)-UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt) <= 4); + assertTrue("the period start minute is not a multiple of five", UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt) % 5 == 0); + assertEquals("period start hour is wrong", UTCTimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start day is wrong", UTCTimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), UTCTimeUtility.getDayOfWeekFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start week is wrong", UTCTimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getWeekOfYearFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + + //verify period end is correct + System.out.println(" 5-min end timestamp = " + thisPeriodEndedAt + " " + UTCTimeUtility.getDateString(thisPeriodEndedAt)); + assertTrue("perdiod end is not ater current time", thisPeriodEndedAt >= currentTime_UTC); + assertEquals("period end millisecond is wrong", 999, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end second is wrong", 59, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); + assertTrue("the period end minute is before of the current time", UTCTimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) <= UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); + assertTrue("the period ends more than 5 minutes after the current time", UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)-UTCTimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) <= 4); + assertTrue("the period end minute(+1) is not a multiple of five", UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt+1) % 5 == 0); + assertEquals("period end hour is wrong", UTCTimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end day is wrong", UTCTimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), UTCTimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end week is wrong", UTCTimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + + //verify that start and end values are reasonable + assertTrue("start is zero", thisPeriodStartedAt != 0); + assertTrue("end is zero", thisPeriodEndedAt != 0); + assertTrue("start is not before end", thisPeriodStartedAt < thisPeriodEndedAt ); + assertTrue("start and end are equal", thisPeriodStartedAt != thisPeriodEndedAt ); + + //verify that the period start and end is in the same period + assertEquals("start and/or end timestamp is not in the same period", thisPeriodStartedAt, UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.FIVE_MINUTES, thisPeriodEndedAt)); + assertEquals("start and/or end timestamp is not in the same period", thisPeriodEndedAt, UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.FIVE_MINUTES, thisPeriodStartedAt)); } // Test flooring & ceiling UTC time to the closes minute @Test public void testMinute_UTC(){ - long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.MINUTE, currentTime_UTC); - assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start minute is wrong", TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC), TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start day is wrong", TimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), TimeUtility.getDayOfWeekFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + System.out.println("Testing minute with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC)); + Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC")); + tmpCal.setTimeInMillis(currentTime_UTC); - long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.MINUTE, currentTime_UTC); - assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end second is wrong", 59, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end minute is wrong", TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC), TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end day is wrong", TimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), TimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.MINUTE, currentTime_UTC); + long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.MINUTE, currentTime_UTC); + + //verify period start is correct + System.out.println(" minute start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt)); + assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC); + assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start second is wrong", 0, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start minute is wrong", UTCTimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC), UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start hour is wrong", UTCTimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start day is wrong", UTCTimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), UTCTimeUtility.getDayOfWeekFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start week is wrong", UTCTimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getWeekOfYearFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + + //verify period end is correct + System.out.println(" minute end timestamp = " + thisPeriodEndedAt + " " + UTCTimeUtility.getDateString(thisPeriodEndedAt)); + assertTrue("perdiod end is not ater current time", thisPeriodEndedAt >= currentTime_UTC); + assertEquals("period end millisecond is wrong", 999, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end second is wrong", 59, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end minute is wrong", UTCTimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC), UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end hour is wrong", UTCTimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end day is wrong", UTCTimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), UTCTimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end week is wrong", UTCTimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + + //verify that start and end values are reasonable + assertTrue("start is zero", thisPeriodStartedAt != 0); + assertTrue("end is zero", thisPeriodEndedAt != 0); + assertTrue("start is not before end", thisPeriodStartedAt < thisPeriodEndedAt ); + assertTrue("start and end are equal", thisPeriodStartedAt != thisPeriodEndedAt ); + + //verify that the period start and end is in the same period + assertEquals("start and/or end timestamp is not in the same period", thisPeriodStartedAt, UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.MINUTE, thisPeriodEndedAt)); + assertEquals("start and/or end timestamp is not in the same period", thisPeriodEndedAt, UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.MINUTE, thisPeriodStartedAt)); } // Test flooring & ceiling UTC time to the closes second @Test public void testSecond_UTC(){ - long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.SECOND, currentTime_UTC); - assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start second is wrong", TimeUtility.getSecondOfMinuteFromTimestamp(currentTime_UTC), TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start minute is wrong", TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC), TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start day is wrong", TimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), TimeUtility.getDayOfWeekFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodStartedAt)); - assertEquals("period start year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + System.out.println("Testing second with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC)); + Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC")); + tmpCal.setTimeInMillis(currentTime_UTC); - long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.SECOND, currentTime_UTC); - assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end second is wrong", TimeUtility.getSecondOfMinuteFromTimestamp(currentTime_UTC), TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end minute is wrong", TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC), TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end day is wrong", TimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), TimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); - assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.SECOND, currentTime_UTC); + long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.SECOND, currentTime_UTC); + + //verify period start is correct + System.out.println(" second start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt)); + assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC); + assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start second is wrong", UTCTimeUtility.getSecondOfMinuteFromTimestamp(currentTime_UTC), UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start minute is wrong", UTCTimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC), UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start hour is wrong", UTCTimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start day is wrong", UTCTimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), UTCTimeUtility.getDayOfWeekFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start week is wrong", UTCTimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getWeekOfYearFromTimestamp(thisPeriodStartedAt)); + assertEquals("period start year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodStartedAt)); + + //verify period end is correct + System.out.println(" second end timestamp = " + thisPeriodEndedAt + " " + UTCTimeUtility.getDateString(thisPeriodEndedAt)); + assertTrue("perdiod end is not ater current time", thisPeriodEndedAt >= currentTime_UTC); + assertEquals("period end millisecond is wrong", 999, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end second is wrong", UTCTimeUtility.getSecondOfMinuteFromTimestamp(currentTime_UTC), UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end minute is wrong", UTCTimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC), UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end hour is wrong", UTCTimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end day is wrong", UTCTimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), UTCTimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end week is wrong", UTCTimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); + assertEquals("period end year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); + + //verify that start and end values are reasonable + assertTrue("start is zero", thisPeriodStartedAt != 0); + assertTrue("end is zero", thisPeriodEndedAt != 0); + assertTrue("start is not before end", thisPeriodStartedAt < thisPeriodEndedAt ); + assertTrue("start and end are equal", thisPeriodStartedAt != thisPeriodEndedAt ); + + //verify that the period start and end is in the same period + assertEquals("start and/or end timestamp is not in the same period", thisPeriodStartedAt, UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.SECOND, thisPeriodEndedAt)); + assertEquals("start and/or end timestamp is not in the same period", thisPeriodEndedAt, UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.SECOND, thisPeriodStartedAt)); } // Test printing converting milliseconds to text @Test public void testMsToString(){ //low values - assertEquals("00:00:00.000", TimeUtility.timeInMsToString(0)); - assertEquals("00:00:00.001", TimeUtility.timeInMsToString(1)); - assertEquals("00:00:01.000", TimeUtility.timeInMsToString(TimeUtility.SECOND_IN_MS)); - assertEquals("00:01:00.000", TimeUtility.timeInMsToString(TimeUtility.MINUTE_IN_MS)); - assertEquals("00:05:00.000", TimeUtility.timeInMsToString(TimeUtility.FIVE_MINUTES_IN_MS)); - assertEquals("01:00:00.000", TimeUtility.timeInMsToString(TimeUtility.HOUR_IN_MS)); - assertEquals("1d+00:00:00.000", TimeUtility.timeInMsToString(TimeUtility.DAY_IN_MS)); - assertEquals("1w+00:00:00.000", TimeUtility.timeInMsToString(TimeUtility.WEEK_IN_MS)); + assertEquals("00:00:00.000", UTCTimeUtility.timeInMsToString(0)); + assertEquals("00:00:00.001", UTCTimeUtility.timeInMsToString(1)); + assertEquals("00:00:01.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.SECOND_IN_MS)); + assertEquals("00:01:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.MINUTE_IN_MS)); + assertEquals("00:05:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.FIVE_MINUTES_IN_MS)); + assertEquals("01:00:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.HOUR_IN_MS)); + assertEquals("1d+00:00:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.DAY_IN_MS)); + assertEquals("1w+00:00:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.WEEK_IN_MS)); //high values - assertEquals("00:00:00.999", TimeUtility.timeInMsToString(999)); - assertEquals("00:00:59.000", TimeUtility.timeInMsToString(TimeUtility.SECOND_IN_MS*59)); - assertEquals("00:59:00.000", TimeUtility.timeInMsToString(TimeUtility.MINUTE_IN_MS*59)); - assertEquals("23:00:00.000", TimeUtility.timeInMsToString(TimeUtility.HOUR_IN_MS*23)); - assertEquals("52w+5d+00:00:00.000", TimeUtility.timeInMsToString(TimeUtility.DAY_IN_MS*369)); + assertEquals("00:00:00.999", UTCTimeUtility.timeInMsToString(999)); + assertEquals("00:00:59.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.SECOND_IN_MS*59)); + assertEquals("00:59:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.MINUTE_IN_MS*59)); + assertEquals("23:00:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.HOUR_IN_MS*23)); + assertEquals("52w+5d+00:00:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.DAY_IN_MS*369)); //high overflow values - assertEquals("00:00:01.999", TimeUtility.timeInMsToString(1999)); - assertEquals("00:02:39.000", TimeUtility.timeInMsToString(TimeUtility.SECOND_IN_MS*159)); - assertEquals("02:39:00.000", TimeUtility.timeInMsToString(TimeUtility.MINUTE_IN_MS*159)); - assertEquals("5d+03:00:00.000", TimeUtility.timeInMsToString(TimeUtility.HOUR_IN_MS*123)); + assertEquals("00:00:01.999", UTCTimeUtility.timeInMsToString(1999)); + assertEquals("00:02:39.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.SECOND_IN_MS*159)); + assertEquals("02:39:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.MINUTE_IN_MS*159)); + assertEquals("5d+03:00:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.HOUR_IN_MS*123)); //combinations - assertEquals("142w+5d+23:59:59.999", TimeUtility.timeInMsToString((TimeUtility.WEEK_IN_MS*142) + (TimeUtility.DAY_IN_MS*5) + (TimeUtility.HOUR_IN_MS*23) + (TimeUtility.MINUTE_IN_MS*59) + (TimeUtility.SECOND_IN_MS*59) + 999)); - assertEquals("6d+23:59:59.999", TimeUtility.timeInMsToString(TimeUtility.WEEK_IN_MS-1)); + assertEquals("142w+5d+23:59:59.999", UTCTimeUtility.timeInMsToString((UTCTimeUtility.WEEK_IN_MS*142) + (UTCTimeUtility.DAY_IN_MS*5) + (UTCTimeUtility.HOUR_IN_MS*23) + (UTCTimeUtility.MINUTE_IN_MS*59) + (UTCTimeUtility.SECOND_IN_MS*59) + 999)); + assertEquals("6d+23:59:59.999", UTCTimeUtility.timeInMsToString(UTCTimeUtility.WEEK_IN_MS-1)); } // Test printing converting milliseconds to text for a negative time @Test(expected=NumberFormatException.class) public void testMsToStringForNegativeArgument(){ //low values - TimeUtility.timeInMsToString(-1); + UTCTimeUtility.timeInMsToString(-1); } }