ziver/hal
1
1
Fork 0
Code Pull requests Releases Activity

Renamed Timeutility class to UTCTimeUtility

Browse source 
Added TimePeriod class for high level reprensentation of a period of time
This commit is contained in:
Daniel Collin 2016-02-18 11:10:27 +01:00
parent f670d2ceb4
commit 77a2b9ccb4
9 changed files with 655 additions and 267 deletions
Download patch file Download diff file Expand all files Collapse all files

68
src/se/hal/deamon/SensorDataAggregatorDaemon.java
View file

@ -4,7 +4,8 @@ import se.hal.HalContext;
import se.hal.intf.HalDaemon; import se.hal.intf.HalDaemon;
import se.hal.struct.Sensor; import se.hal.struct.Sensor;
import se.hal.intf.HalSensorData.AggregationMethod; 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.DBConnection;
import zutil.db.SQLResultHandler; import zutil.db.SQLResultHandler;
import zutil.db.handler.SimpleSQLResult; import zutil.db.handler.SimpleSQLResult;
@ -36,7 +37,7 @@ public class SensorDataAggregatorDaemon implements HalDaemon {
} }
public void initiate(ScheduledExecutorService executor){ 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 @Override
@ -61,16 +62,16 @@ public class SensorDataAggregatorDaemon implements HalDaemon {
logger.fine("The sensor is of type: " + sensor.getDeviceData().getClass().getName()); 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"); 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"); 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"); 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"); 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 == ?"); + " AND timestamp_end-timestamp_start == ?");
stmt.setLong(1, sensorId); stmt.setLong(1, sensorId);
switch(aggrPeriodLength){ switch(aggrPeriodLength){
case SECOND: stmt.setLong(2, TimeUtility.SECOND_IN_MS-1); break; case SECOND: stmt.setLong(2, UTCTimeUtility.SECOND_IN_MS-1); break;
case MINUTE: stmt.setLong(2, TimeUtility.MINUTE_IN_MS-1); break; case MINUTE: stmt.setLong(2, UTCTimeUtility.MINUTE_IN_MS-1); break;
case FIVE_MINUTES: stmt.setLong(2, TimeUtility.FIVE_MINUTES_IN_MS-1); break; case FIVE_MINUTES: stmt.setLong(2, UTCTimeUtility.FIVE_MINUTES_IN_MS-1); break;
case FIFTEEN_MINUTES: stmt.setLong(2, TimeUtility.FIFTEEN_MINUTES_IN_MS-1); break; case FIFTEEN_MINUTES: stmt.setLong(2, UTCTimeUtility.FIFTEEN_MINUTES_IN_MS-1); break;
case HOUR: stmt.setLong(2, TimeUtility.HOUR_IN_MS-1); break; case HOUR: stmt.setLong(2, UTCTimeUtility.HOUR_IN_MS-1); break;
case DAY: stmt.setLong(2, TimeUtility.DAY_IN_MS-1); break; case DAY: stmt.setLong(2, UTCTimeUtility.DAY_IN_MS-1); break;
case WEEK: stmt.setLong(2, TimeUtility.WEEK_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; default: logger.warning("aggregation period length is not supported."); return;
} }
Long maxTimestampFoundForSensor = DBConnection.exec(stmt, new SimpleSQLResult<Long>()); Long maxTimestampFoundForSensor = DBConnection.exec(stmt, new SimpleSQLResult<Long>());
if(maxTimestampFoundForSensor == null) if(maxTimestampFoundForSensor == null)
maxTimestampFoundForSensor = 0l; 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" stmt = db.getPreparedStatement("SELECT *, 1 AS confidence FROM sensor_data_raw"
+" WHERE sensor_id == ?" +" WHERE sensor_id == ?"
+ " AND timestamp > ?" + " AND timestamp > ?"
+ " AND timestamp < ? " + " AND timestamp <= ? "
+ " AND timestamp >= ? " + " AND timestamp >= ? "
+" ORDER BY timestamp ASC"); +" ORDER BY timestamp ASC");
stmt.setLong(1, sensorId); stmt.setLong(1, sensorId);
stmt.setLong(2, maxTimestampFoundForSensor); stmt.setLong(2, maxTimestampFoundForSensor);
stmt.setLong(3, currentPeriodStartTimestamp); stmt.setLong(3, latestCompletePeriodEndTimestamp);
stmt.setLong(4, TimeUtility.getTimestampPeriodStart_UTC(aggrPeriodLength, System.currentTimeMillis()-ageLimitInMs)); stmt.setLong(4, oldestPeriodStartTimestamp);
DBConnection.exec(stmt, new DataAggregator(sensorId, aggrPeriodLength, expectedSampleCount, aggrMethod)); DBConnection.exec(stmt, new DataAggregator(sensorId, aggrPeriodLength, expectedSampleCount, aggrMethod));
} catch (SQLException e) { } catch (SQLException e) {
logger.log(Level.SEVERE, null, e); logger.log(Level.SEVERE, null, e);
@ -145,8 +147,7 @@ public class SensorDataAggregatorDaemon implements HalDaemon {
try{ try{
HalContext.getDB().getConnection().setAutoCommit(false); HalContext.getDB().getConnection().setAutoCommit(false);
long currentPeriodTimestampStart = 0; UTCTimePeriod currentPeriod = null;
long currentPeriodTimestampEnd = 0;
float sum = 0; float sum = 0;
float confidenceSum = 0; float confidenceSum = 0;
int samples = 0; int samples = 0;
@ -157,40 +158,35 @@ public class SensorDataAggregatorDaemon implements HalDaemon {
if(sensorId != result.getInt("sensor_id")){ 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")+")"); 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 aggrConfidence = confidenceSum / (float)this.expectedSampleCount;
float data = -1; float data = -1;
switch(aggrMethod){ switch(aggrMethod){
case SUM: data = sum; break; case SUM: data = sum; break;
case AVERAGE: data = sum/samples; 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.setInt(1, result.getInt("sensor_id"));
preparedInsertStmt.setLong(2, ++highestSequenceId); preparedInsertStmt.setLong(2, ++highestSequenceId);
preparedInsertStmt.setLong(3, currentPeriodTimestampStart); preparedInsertStmt.setLong(3, currentPeriod.getStartTimestamp());
preparedInsertStmt.setLong(4, currentPeriodTimestampEnd); preparedInsertStmt.setLong(4, currentPeriod.getEndTimestamp());
preparedInsertStmt.setFloat(5, data); preparedInsertStmt.setFloat(5, data);
preparedInsertStmt.setFloat(6, aggrConfidence); preparedInsertStmt.setFloat(6, aggrConfidence);
preparedInsertStmt.addBatch(); preparedInsertStmt.addBatch();
// Reset variables // Reset variables
currentPeriodTimestampStart = dataPeriodTimestampStart; currentPeriod = dataPeriod;
currentPeriodTimestampEnd = dataPerionTimestampEnd;
confidenceSum = 0; confidenceSum = 0;
sum = 0; sum = 0;
samples = 0; samples = 0;
} }
if(currentPeriodTimestampStart == 0){
currentPeriodTimestampStart = dataPeriodTimestampStart;
}
if(currentPeriodTimestampEnd == 0){
currentPeriodTimestampEnd = dataPerionTimestampEnd;
}
sum += result.getFloat("data"); sum += result.getFloat("data");
confidenceSum += result.getFloat("confidence"); confidenceSum += result.getFloat("confidence");
++samples; ++samples;

24
src/se/hal/deamon/SensorDataCleanupDaemon.java
View file

@ -4,7 +4,7 @@ import se.hal.HalContext;
import se.hal.deamon.SensorDataAggregatorDaemon.AggregationPeriodLength; import se.hal.deamon.SensorDataAggregatorDaemon.AggregationPeriodLength;
import se.hal.intf.HalDaemon; import se.hal.intf.HalDaemon;
import se.hal.struct.Sensor; import se.hal.struct.Sensor;
import se.hal.util.TimeUtility; import se.hal.util.UTCTimeUtility;
import zutil.db.DBConnection; import zutil.db.DBConnection;
import zutil.db.SQLResultHandler; import zutil.db.SQLResultHandler;
import zutil.log.LogUtil; import zutil.log.LogUtil;
@ -23,7 +23,7 @@ public class SensorDataCleanupDaemon implements HalDaemon {
private static final Logger logger = LogUtil.getLogger(); private static final Logger logger = LogUtil.getLogger();
public void initiate(ScheduledExecutorService executor){ 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 @Override
@ -42,8 +42,8 @@ public class SensorDataCleanupDaemon implements HalDaemon {
public void cleanupSensor(Sensor sensor) { public void cleanupSensor(Sensor sensor) {
if (sensor.getUser() != null) { 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.FIVE_MINUTES, UTCTimeUtility.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.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.day, TimeUtility.INFINITY); //clear 1-day data older than infinity
//cleanupSensorData(sensor.getId(), AggregationPeriodLength.week, TimeUtility.INFINITY); //clear 1-week 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 < ?"); + "AND timestamp_end < ?");
stmt.setLong(1, sensorId); stmt.setLong(1, sensorId);
switch(cleanupPeriodlength){ switch(cleanupPeriodlength){
case SECOND: stmt.setLong(2, TimeUtility.SECOND_IN_MS-1); break; case SECOND: stmt.setLong(2, UTCTimeUtility.SECOND_IN_MS-1); break;
case MINUTE: stmt.setLong(2, TimeUtility.MINUTE_IN_MS-1); break; case MINUTE: stmt.setLong(2, UTCTimeUtility.MINUTE_IN_MS-1); break;
case FIVE_MINUTES: stmt.setLong(2, TimeUtility.FIVE_MINUTES_IN_MS-1); break; case FIVE_MINUTES: stmt.setLong(2, UTCTimeUtility.FIVE_MINUTES_IN_MS-1); break;
case FIFTEEN_MINUTES: stmt.setLong(2, TimeUtility.FIFTEEN_MINUTES_IN_MS-1); break; case FIFTEEN_MINUTES: stmt.setLong(2, UTCTimeUtility.FIFTEEN_MINUTES_IN_MS-1); break;
case HOUR: stmt.setLong(2, TimeUtility.HOUR_IN_MS-1); break; case HOUR: stmt.setLong(2, UTCTimeUtility.HOUR_IN_MS-1); break;
case DAY: stmt.setLong(2, TimeUtility.DAY_IN_MS-1); break; case DAY: stmt.setLong(2, UTCTimeUtility.DAY_IN_MS-1); break;
case WEEK: stmt.setLong(2, TimeUtility.WEEK_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; default: logger.warning("cleanup period length is not supported."); return;
} }
stmt.setLong(3, System.currentTimeMillis()-olderThan); stmt.setLong(3, System.currentTimeMillis()-olderThan);
@ -101,7 +101,7 @@ public class SensorDataCleanupDaemon implements HalDaemon {
if(sensorId != result.getInt("sensor_id")){ 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")+")"); 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.setInt(1, result.getInt("sensor_id"));
preparedDeleteStmt.setLong(2, result.getLong("sequence_id")); preparedDeleteStmt.setLong(2, result.getLong("sequence_id"));
preparedDeleteStmt.addBatch(); preparedDeleteStmt.addBatch();

10
src/se/hal/page/PCOverviewHttpPage.java
View file

@ -5,7 +5,7 @@ import se.hal.deamon.SensorDataAggregatorDaemon.AggregationPeriodLength;
import se.hal.intf.HalHttpPage; import se.hal.intf.HalHttpPage;
import se.hal.util.AggregateDataListSqlResult; import se.hal.util.AggregateDataListSqlResult;
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.Sensor;
import se.hal.struct.User; import se.hal.struct.User;
import zutil.db.DBConnection; import zutil.db.DBConnection;
@ -43,13 +43,13 @@ public class PCOverviewHttpPage extends HalHttpPage {
for(User user : users){ for(User user : users){
List<Sensor> userSensors = Sensor.getSensors(db, user); List<Sensor> userSensors = Sensor.getSensors(db, user);
for(Sensor sensor : userSensors){ 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));
} }
} }

4
src/se/hal/page/SensorOverviewHttpPage.java
View file

@ -8,7 +8,7 @@ import se.hal.util.AggregateDataListSqlResult;
import zutil.db.DBConnection; import zutil.db.DBConnection;
import se.hal.util.HistoryDataListSqlResult; import se.hal.util.HistoryDataListSqlResult;
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.io.file.FileUtil;
import zutil.parser.Templator; import zutil.parser.Templator;
@ -51,7 +51,7 @@ public class SensorOverviewHttpPage extends HalHttpPage {
Templator tmpl = new Templator(FileUtil.find(DETAIL_TEMPLATE)); Templator tmpl = new Templator(FileUtil.find(DETAIL_TEMPLATE));
tmpl.set("sensor", sensor); tmpl.set("sensor", sensor);
tmpl.set("history", history); 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; return tmpl;
} }
else { else {

14
src/se/hal/util/AggregateDataListSqlResult.java
View file

@ -43,13 +43,13 @@ public class AggregateDataListSqlResult implements SQLResultHandler<ArrayList<Ag
stmt.setLong(1, sensor.getId()); stmt.setLong(1, sensor.getId());
stmt.setLong(2, sensor.getUser().getId()); stmt.setLong(2, sensor.getUser().getId());
switch(aggrPeriodLength){ switch(aggrPeriodLength){
case SECOND: stmt.setLong(3, TimeUtility.SECOND_IN_MS-1); break; case SECOND: stmt.setLong(3, UTCTimeUtility.SECOND_IN_MS-1); break;
case MINUTE: stmt.setLong(3, TimeUtility.MINUTE_IN_MS-1); break; case MINUTE: stmt.setLong(3, UTCTimeUtility.MINUTE_IN_MS-1); break;
case FIVE_MINUTES: stmt.setLong(3, TimeUtility.FIVE_MINUTES_IN_MS-1); break; case FIVE_MINUTES: stmt.setLong(3, UTCTimeUtility.FIVE_MINUTES_IN_MS-1); break;
case FIFTEEN_MINUTES: stmt.setLong(3, TimeUtility.FIFTEEN_MINUTES_IN_MS-1); break; case FIFTEEN_MINUTES: stmt.setLong(3, UTCTimeUtility.FIFTEEN_MINUTES_IN_MS-1); break;
case HOUR: stmt.setLong(3, TimeUtility.HOUR_IN_MS-1); break; case HOUR: stmt.setLong(3, UTCTimeUtility.HOUR_IN_MS-1); break;
case DAY: stmt.setLong(3, TimeUtility.DAY_IN_MS-1); break; case DAY: stmt.setLong(3, UTCTimeUtility.DAY_IN_MS-1); break;
case WEEK: stmt.setLong(3, TimeUtility.WEEK_IN_MS-1); break; case WEEK: stmt.setLong(3, UTCTimeUtility.WEEK_IN_MS-1); break;
default: throw new IllegalArgumentException("selected aggrPeriodLength is not supported"); default: throw new IllegalArgumentException("selected aggrPeriodLength is not supported");
} }
stmt.setLong(4, (System.currentTimeMillis() - ageLimitInMs) ); stmt.setLong(4, (System.currentTimeMillis() - ageLimitInMs) );

48
src/se/hal/util/UTCTimePeriod.java Executable file
View file

@ -0,0 +1,48 @@
package se.hal.util;
import se.hal.deamon.SensorDataAggregatorDaemon.AggregationPeriodLength;
public class UTCTimePeriod{
private final long start;
private final long end;
private final AggregationPeriodLength periodLength;
public UTCTimePeriod(long timestamp, AggregationPeriodLength periodLength){
start = UTCTimeUtility.getTimestampPeriodStart(periodLength, timestamp);
end = UTCTimeUtility.getTimestampPeriodEnd(periodLength, timestamp);
this.periodLength = periodLength;
}
public long getStartTimestamp(){
return start;
}
public long getEndTimestamp(){
return end;
}
public UTCTimePeriod getNextPeriod(){
return new UTCTimePeriod(end+1, periodLength);
}
public UTCTimePeriod getPreviosPeriod(){
return new UTCTimePeriod(start-1, periodLength);
}
public boolean containsTimestamp(long timestamp){
return start <= timestamp && timestamp <= end;
}
public boolean equals(Object other){
if(other == null)
return false;
if(other instanceof UTCTimePeriod){
UTCTimePeriod o = (UTCTimePeriod)other;
return start == o.start
&& end == o.end
&& periodLength == o.periodLength;
}
return false;
}
}

62
src/se/hal/util/TimeUtility.java → src/se/hal/util/UTCTimeUtility.java
View file

@ -1,11 +1,12 @@
package se.hal.util; package se.hal.util;
import java.text.SimpleDateFormat;
import java.util.Calendar; import java.util.Calendar;
import java.util.TimeZone; import java.util.TimeZone;
import se.hal.deamon.SensorDataAggregatorDaemon.AggregationPeriodLength; import se.hal.deamon.SensorDataAggregatorDaemon.AggregationPeriodLength;
public class TimeUtility { public class UTCTimeUtility {
public static final long SECOND_IN_MS = 1000; public static final long SECOND_IN_MS = 1000;
public static final long MINUTE_IN_MS = SECOND_IN_MS * 60; public static final long MINUTE_IN_MS = SECOND_IN_MS * 60;
public static final long FIVE_MINUTES_IN_MS = MINUTE_IN_MS * 5; public static final long FIVE_MINUTES_IN_MS = MINUTE_IN_MS * 5;
@ -15,9 +16,10 @@ public class TimeUtility {
public static final long WEEK_IN_MS = DAY_IN_MS * 7; public static final long WEEK_IN_MS = DAY_IN_MS * 7;
public static final long INFINITY = Long.MAX_VALUE; //sort of true public static final long INFINITY = Long.MAX_VALUE; //sort of true
public static long getTimestampPeriodStart_UTC(AggregationPeriodLength aggrPeriodLength, long timestamp) throws NumberFormatException{ public static long getTimestampPeriodStart(AggregationPeriodLength aggrPeriodLength, long timestamp) throws NumberFormatException{
Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC")); Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
cal.setTimeInMillis(timestamp); cal.setTimeInMillis(timestamp);
cal.setFirstDayOfWeek(Calendar.MONDAY);
switch(aggrPeriodLength){ switch(aggrPeriodLength){
case YEAR: case YEAR:
cal.set(Calendar.DAY_OF_YEAR, 1); cal.set(Calendar.DAY_OF_YEAR, 1);
@ -72,42 +74,64 @@ public class TimeUtility {
return cal.getTimeInMillis(); return cal.getTimeInMillis();
} }
public static long getTimestampPeriodEnd_UTC(AggregationPeriodLength aggrPeriodLength, long timestamp) throws NumberFormatException{ public static long getTimestampPeriodEnd(AggregationPeriodLength aggrPeriodLength, long timestamp) throws NumberFormatException{
long start = getTimestampPeriodStart_UTC(aggrPeriodLength, timestamp);
Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC")); Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
cal.setTimeInMillis(start); cal.setTimeInMillis(timestamp);
cal.setFirstDayOfWeek(Calendar.MONDAY);
switch(aggrPeriodLength){ switch(aggrPeriodLength){
case YEAR: case YEAR:
cal.add(Calendar.YEAR, 1); cal.set(Calendar.DAY_OF_YEAR, cal.getActualMaximum(Calendar.DAY_OF_YEAR));
cal.set(Calendar.HOUR_OF_DAY, 23);
cal.set(Calendar.MINUTE, 59);
cal.set(Calendar.SECOND, 59);
cal.set(Calendar.MILLISECOND, 1000);
break; break;
case MONTH: case MONTH:
cal.add(Calendar.MONTH, 1); cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
cal.set(Calendar.HOUR_OF_DAY, 23);
cal.set(Calendar.MINUTE, 59);
cal.set(Calendar.SECOND, 59);
cal.set(Calendar.MILLISECOND, 1000);
break; break;
case WEEK: case WEEK:
cal.add(Calendar.WEEK_OF_YEAR, 1); cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
cal.set(Calendar.HOUR_OF_DAY, 23);
cal.set(Calendar.MINUTE, 59);
cal.set(Calendar.SECOND, 59);
cal.set(Calendar.MILLISECOND, 1000);
break; break;
case DAY: case DAY:
cal.add(Calendar.DAY_OF_YEAR, 1); cal.set(Calendar.HOUR_OF_DAY, 23);
cal.set(Calendar.MINUTE, 59);
cal.set(Calendar.SECOND, 59);
cal.set(Calendar.MILLISECOND, 1000);
break; break;
case HOUR: case HOUR:
cal.add(Calendar.HOUR, 1); cal.set(Calendar.MINUTE, 59);
cal.set(Calendar.SECOND, 59);
cal.set(Calendar.MILLISECOND, 1000);
break; break;
case FIVE_MINUTES: case FIVE_MINUTES:
cal.add(Calendar.MINUTE, 5); cal.set(Calendar.MINUTE, 4+(cal.get(Calendar.MINUTE)/5)*5);
cal.set(Calendar.SECOND, 59);
cal.set(Calendar.MILLISECOND, 1000);
break; break;
case FIFTEEN_MINUTES: case FIFTEEN_MINUTES:
cal.add(Calendar.MINUTE, 15); cal.set(Calendar.MINUTE, 14+(cal.get(Calendar.MINUTE)/15)*15);
cal.set(Calendar.SECOND, 59);
cal.set(Calendar.MILLISECOND, 1000);
break; break;
case MINUTE: case MINUTE:
cal.add(Calendar.MINUTE, 1); cal.set(Calendar.SECOND, 59);
cal.set(Calendar.MILLISECOND, 1000);
break; break;
case SECOND: case SECOND:
cal.add(Calendar.SECOND, 1); cal.set(Calendar.MILLISECOND, 1000);
break; break;
} }
return cal.getTimeInMillis()-1; //subtract one return cal.getTimeInMillis()-1; //subtract one
} }
public static int getMillisecondInSecondFromTimestamp(long ms) throws NumberFormatException{ public static int getMillisecondInSecondFromTimestamp(long ms) throws NumberFormatException{
if(ms < 0) if(ms < 0)
throw new NumberFormatException("argument must be positive"); throw new NumberFormatException("argument must be positive");
@ -211,4 +235,12 @@ public class TimeUtility {
return retval; return retval;
} }
public static String getDateString(long timestamp){
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
format.setTimeZone(TimeZone.getTimeZone("UTC"));
Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
cal.setTimeInMillis(timestamp);
return format.format(cal.getTime());
}
} }

128
test/se/hal/util/TimePeriodTest.java Executable file
View file

@ -0,0 +1,128 @@
package se.hal.util;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import se.hal.deamon.SensorDataAggregatorDaemon.AggregationPeriodLength;
import java.util.Arrays;
import java.util.Collection;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
@RunWith(Parameterized.class)
public class TimePeriodTest {
private final long currentTime_UTC;
/**
* Constructor
* @param timestamp
*/
public TimePeriodTest(long timestamp){
this.currentTime_UTC = timestamp;
}
@Parameters
public static Collection<Object[]> 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()));
}
}

564
test/se/hal/util/TimeUtilityTest.java
View file

@ -1,6 +1,5 @@
package se.hal.util; package se.hal.util;
import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.junit.runners.Parameterized; import org.junit.runners.Parameterized;
@ -11,6 +10,7 @@ import se.hal.deamon.SensorDataAggregatorDaemon.AggregationPeriodLength;
import java.util.Arrays; import java.util.Arrays;
import java.util.Calendar; import java.util.Calendar;
import java.util.Collection; import java.util.Collection;
import java.util.TimeZone;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
@ -31,7 +31,7 @@ public class TimeUtilityTest {
@Parameters @Parameters
public static Collection<Object[]> data(){ public static Collection<Object[]> data(){
return Arrays.asList(new Object[][] { 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) {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) {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) {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) {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) {1456790400000L}, //2016-03-30 00:00:00.000 GMT (first ms after a leap day)
{System.currentTimeMillis()}, //current time {System.currentTimeMillis()}, //current time
{System.currentTimeMillis()+TimeUtility.MINUTE_IN_MS}, //current time + 1m {System.currentTimeMillis()+UTCTimeUtility.MINUTE_IN_MS}, //current time + 1m
{System.currentTimeMillis()+(2*TimeUtility.MINUTE_IN_MS)}, //current time + 2m {System.currentTimeMillis()+(2*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 2m
{System.currentTimeMillis()+(3*TimeUtility.MINUTE_IN_MS)}, //current time + 3m {System.currentTimeMillis()+(3*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 3m
{System.currentTimeMillis()+(4*TimeUtility.MINUTE_IN_MS)}, //current time + 4m {System.currentTimeMillis()+(4*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 4m
{System.currentTimeMillis()+(5*TimeUtility.MINUTE_IN_MS)}, //current time + 5m {System.currentTimeMillis()+(5*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 5m
{System.currentTimeMillis()+(6*TimeUtility.MINUTE_IN_MS)}, //current time + 6m {System.currentTimeMillis()+(6*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 6m
{System.currentTimeMillis()+(7*TimeUtility.MINUTE_IN_MS)}, //current time + 7m {System.currentTimeMillis()+(7*UTCTimeUtility.MINUTE_IN_MS)}, //current time + 7m
{Long.MAX_VALUE-(60*TimeUtility.WEEK_IN_MS)}, //max time - 60w {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 flooring & ceiling UTC time to the closes year
@Test @Test
public void testYear_UTC(){ public void testYear_UTC(){
long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.YEAR, currentTime_UTC); System.out.println("Testing year with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); tmpCal.setTimeInMillis(currentTime_UTC);
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));
long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.YEAR, currentTime_UTC); long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.YEAR, currentTime_UTC);
assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.YEAR, currentTime_UTC);
assertEquals("period end second is wrong", 59, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt));
assertEquals("period end minute is wrong", 59, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); //verify period start is correct
assertEquals("period end hour is wrong", 23, TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); System.out.println(" year start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt));
assertEquals("period end day is wrong", 31, TimeUtility.getDayOfMonthFromTimestamp(thisPeriodEndedAt)); assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC);
assertEquals("period end month is wrong", Calendar.DECEMBER, TimeUtility.getMonthOfYearFromTimestamp(thisPeriodEndedAt)); assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt));
assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); 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 flooring & ceiling UTC time to the closes month
@Test @Test
public void testMonth_UTC(){ public void testMonth_UTC(){
long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.MONTH, currentTime_UTC); System.out.println("Testing month with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); tmpCal.setTimeInMillis(currentTime_UTC);
assertEquals("period start minute is wrong", 0, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt));
assertEquals("period start hour is wrong", 0, TimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.MONTH, currentTime_UTC);
assertEquals("period start day is wrong", 1, TimeUtility.getDayOfMonthFromTimestamp(thisPeriodStartedAt)); long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.MONTH, currentTime_UTC);
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)); //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); //verify period end is correct
assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); System.out.println(" month end timestamp = " + thisPeriodEndedAt + " " + UTCTimeUtility.getDateString(thisPeriodEndedAt));
assertEquals("period end second is wrong", 59, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); assertTrue("perdiod end is not ater current time", thisPeriodEndedAt >= currentTime_UTC);
assertEquals("period end minute is wrong", 59, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); assertEquals("period end millisecond is wrong", 999, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt));
assertEquals("period end hour is wrong", 23, TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); assertEquals("period end second is wrong", 59, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt));
assertTrue("day of month is less than 28", TimeUtility.getDayOfMonthFromTimestamp(thisPeriodEndedAt) >= 28); assertEquals("period end minute is wrong", 59, UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt));
assertEquals("period end month is wrong", TimeUtility.getMonthOfYearFromTimestamp(currentTime_UTC), TimeUtility.getMonthOfYearFromTimestamp(thisPeriodEndedAt)); assertEquals("period end hour is wrong", 23, UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt));
assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(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 flooring & ceiling UTC time to the closes week
@Test @Test
public void testWeek_UTC(){ public void testWeek_UTC(){
long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.WEEK, currentTime_UTC); System.out.println("Testing week with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); tmpCal.setTimeInMillis(currentTime_UTC);
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);
long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.WEEK, currentTime_UTC); long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.WEEK, currentTime_UTC);
assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.WEEK, currentTime_UTC);
assertEquals("period end second is wrong", 59, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt));
assertEquals("period end minute is wrong", 59, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); //verify period start is correct
assertEquals("period end hour is wrong", 23, TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); System.out.println(" week start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt));
assertEquals("period end day is wrong", Calendar.SUNDAY, TimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC);
assertEquals("period end week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt));
assertTrue("period end year is more than one year off", TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)-TimeUtility.getYearFromTimestamp(currentTime_UTC) <= 1); 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 flooring & ceiling UTC time to the closes day
@Test @Test
public void testDay_UTC(){ public void testDay_UTC(){
long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.DAY, currentTime_UTC); System.out.println("Testing day with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); tmpCal.setTimeInMillis(currentTime_UTC);
assertEquals("period start minute is wrong", 0, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt));
assertEquals("period start hour is wrong", 0, TimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.DAY, currentTime_UTC);
assertEquals("period start day is wrong", TimeUtility.getDayOfYearFromTimestamp(currentTime_UTC), TimeUtility.getDayOfYearFromTimestamp(thisPeriodStartedAt)); long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.DAY, currentTime_UTC);
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));
long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.DAY, currentTime_UTC); //verify period start is correct
assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); System.out.println(" day start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt));
assertEquals("period end second is wrong", 59, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC);
assertEquals("period end minute is wrong", 59, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt));
assertEquals("period end hour is wrong", 23, TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); assertEquals("period start second is wrong", 0, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt));
assertEquals("period end day is wrong", TimeUtility.getDayOfYearFromTimestamp(currentTime_UTC), TimeUtility.getDayOfYearFromTimestamp(thisPeriodEndedAt)); assertEquals("period start minute is wrong", 0, UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt));
assertEquals("period end week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); assertEquals("period start hour is wrong", 0, UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt));
assertEquals("period end month is wrong", TimeUtility.getMonthOfYearFromTimestamp(currentTime_UTC), TimeUtility.getMonthOfYearFromTimestamp(thisPeriodEndedAt)); assertEquals("period start day is wrong", UTCTimeUtility.getDayOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getDayOfYearFromTimestamp(thisPeriodStartedAt));
assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); 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 flooring & ceiling UTC time to the closes hour
@Test @Test
public void testHour_UTC(){ public void testHour_UTC(){
long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.HOUR, currentTime_UTC); System.out.println("Testing hour with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); tmpCal.setTimeInMillis(currentTime_UTC);
assertEquals("period start minute is wrong", 0, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt));
assertEquals("period start hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt)); long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.HOUR, currentTime_UTC);
assertEquals("period start day is wrong", TimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), TimeUtility.getDayOfWeekFromTimestamp(thisPeriodStartedAt)); long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.HOUR, currentTime_UTC);
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));
long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.HOUR, currentTime_UTC); //verify period start is correct
assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); System.out.println(" hour start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt));
assertEquals("period end second is wrong", 59, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt)); assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC);
assertEquals("period end minute is wrong", 59, TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt));
assertEquals("period end hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); assertEquals("period start second is wrong", 0, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt));
assertEquals("period end day is wrong", TimeUtility.getDayOfYearFromTimestamp(currentTime_UTC), TimeUtility.getDayOfYearFromTimestamp(thisPeriodEndedAt)); assertEquals("period start minute is wrong", 0, UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt));
assertEquals("period end week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); assertEquals("period start hour is wrong", UTCTimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt));
assertEquals("period end month is wrong", TimeUtility.getMonthOfYearFromTimestamp(currentTime_UTC), TimeUtility.getMonthOfYearFromTimestamp(thisPeriodEndedAt)); assertEquals("period start day is wrong", UTCTimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), UTCTimeUtility.getDayOfWeekFromTimestamp(thisPeriodStartedAt));
assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); 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 flooring & ceiling UTC time to the closes 15-minute period
@Test @Test
public void testFifteenMinute_UTC(){ public void testFifteenMinute_UTC(){
long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.FIFTEEN_MINUTES, currentTime_UTC); System.out.println("Testing 15-min with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); tmpCal.setTimeInMillis(currentTime_UTC);
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));
long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.FIFTEEN_MINUTES, currentTime_UTC); long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.FIFTEEN_MINUTES, currentTime_UTC);
assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.FIFTEEN_MINUTES, currentTime_UTC);
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)); //verify period start is correct
assertTrue("the period ends more than 15 minutes after the current time", TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)-TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) <= 14); System.out.println(" 15-min start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt));
assertTrue("the period end minute(+1) is not a multiple of fifteen", TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt+1) % 15 == 0); assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC);
assertEquals("period end hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt));
assertEquals("period end day is wrong", TimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), TimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); assertEquals("period start second is wrong", 0, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt));
assertEquals("period end week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); assertTrue("the period start minute is in the future of the current time", UTCTimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) >= UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt));
assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); 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 flooring & ceiling UTC time to the closes 5-minute period
@Test @Test
public void testFiveMinute_UTC(){ public void testFiveMinute_UTC(){
long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.FIVE_MINUTES, currentTime_UTC); System.out.println("Testing 5-min with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); tmpCal.setTimeInMillis(currentTime_UTC);
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));
long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.FIVE_MINUTES, currentTime_UTC); long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.FIVE_MINUTES, currentTime_UTC);
assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.FIVE_MINUTES, currentTime_UTC);
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)); //verify period start is correct
assertTrue("the period ends more than 5 minutes after the current time", TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)-TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) <= 4); System.out.println(" 5-min start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt));
assertTrue("the period end minute(+1) is not a multiple of five", TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt+1) % 5 == 0); assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC);
assertEquals("period end hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt));
assertEquals("period end day is wrong", TimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), TimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); assertEquals("period start second is wrong", 0, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt));
assertEquals("period end week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); assertTrue("the period start minute is in the future of the current time", UTCTimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC) >= UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt));
assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); 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 flooring & ceiling UTC time to the closes minute
@Test @Test
public void testMinute_UTC(){ public void testMinute_UTC(){
long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.MINUTE, currentTime_UTC); System.out.println("Testing minute with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
assertEquals("period start second is wrong", 0, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); tmpCal.setTimeInMillis(currentTime_UTC);
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));
long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.MINUTE, currentTime_UTC); long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.MINUTE, currentTime_UTC);
assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.MINUTE, currentTime_UTC);
assertEquals("period end second is wrong", 59, TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodEndedAt));
assertEquals("period end minute is wrong", TimeUtility.getMinuteOfHourFromTimestamp(currentTime_UTC), TimeUtility.getMinuteOfHourFromTimestamp(thisPeriodEndedAt)); //verify period start is correct
assertEquals("period end hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); System.out.println(" minute start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt));
assertEquals("period end day is wrong", TimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), TimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC);
assertEquals("period end week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt));
assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); 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 flooring & ceiling UTC time to the closes second
@Test @Test
public void testSecond_UTC(){ public void testSecond_UTC(){
long thisPeriodStartedAt = TimeUtility.getTimestampPeriodStart_UTC(AggregationPeriodLength.SECOND, currentTime_UTC); System.out.println("Testing second with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
assertEquals("period start millisecond is wrong", 0, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt)); Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
assertEquals("period start second is wrong", TimeUtility.getSecondOfMinuteFromTimestamp(currentTime_UTC), TimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt)); tmpCal.setTimeInMillis(currentTime_UTC);
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));
long thisPeriodEndedAt = TimeUtility.getTimestampPeriodEnd_UTC(AggregationPeriodLength.SECOND, currentTime_UTC); long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.SECOND, currentTime_UTC);
assertEquals("period end millisecond is wrong", 999, TimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodEndedAt)); long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.SECOND, currentTime_UTC);
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)); //verify period start is correct
assertEquals("period end hour is wrong", TimeUtility.getHourOfDayFromTimestamp(currentTime_UTC), TimeUtility.getHourOfDayFromTimestamp(thisPeriodEndedAt)); System.out.println(" second start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt));
assertEquals("period end day is wrong", TimeUtility.getDayOfWeekFromTimestamp(currentTime_UTC), TimeUtility.getDayOfWeekFromTimestamp(thisPeriodEndedAt)); assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC);
assertEquals("period end week is wrong", TimeUtility.getWeekOfYearFromTimestamp(currentTime_UTC), TimeUtility.getWeekOfYearFromTimestamp(thisPeriodEndedAt)); assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt));
assertEquals("period end year is wrong", TimeUtility.getYearFromTimestamp(currentTime_UTC), TimeUtility.getYearFromTimestamp(thisPeriodEndedAt)); 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 printing converting milliseconds to text
@Test @Test
public void testMsToString(){ public void testMsToString(){
//low values //low values
assertEquals("00:00:00.000", TimeUtility.timeInMsToString(0)); assertEquals("00:00:00.000", UTCTimeUtility.timeInMsToString(0));
assertEquals("00:00:00.001", TimeUtility.timeInMsToString(1)); assertEquals("00:00:00.001", UTCTimeUtility.timeInMsToString(1));
assertEquals("00:00:01.000", TimeUtility.timeInMsToString(TimeUtility.SECOND_IN_MS)); assertEquals("00:00:01.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.SECOND_IN_MS));
assertEquals("00:01:00.000", TimeUtility.timeInMsToString(TimeUtility.MINUTE_IN_MS)); assertEquals("00:01:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.MINUTE_IN_MS));
assertEquals("00:05:00.000", TimeUtility.timeInMsToString(TimeUtility.FIVE_MINUTES_IN_MS)); assertEquals("00:05:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.FIVE_MINUTES_IN_MS));
assertEquals("01:00:00.000", TimeUtility.timeInMsToString(TimeUtility.HOUR_IN_MS)); assertEquals("01:00:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.HOUR_IN_MS));
assertEquals("1d+00:00:00.000", TimeUtility.timeInMsToString(TimeUtility.DAY_IN_MS)); assertEquals("1d+00:00:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.DAY_IN_MS));
assertEquals("1w+00:00:00.000", TimeUtility.timeInMsToString(TimeUtility.WEEK_IN_MS)); assertEquals("1w+00:00:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.WEEK_IN_MS));
//high values //high values
assertEquals("00:00:00.999", TimeUtility.timeInMsToString(999)); assertEquals("00:00:00.999", UTCTimeUtility.timeInMsToString(999));
assertEquals("00:00:59.000", TimeUtility.timeInMsToString(TimeUtility.SECOND_IN_MS*59)); assertEquals("00:00:59.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.SECOND_IN_MS*59));
assertEquals("00:59:00.000", TimeUtility.timeInMsToString(TimeUtility.MINUTE_IN_MS*59)); assertEquals("00:59:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.MINUTE_IN_MS*59));
assertEquals("23:00:00.000", TimeUtility.timeInMsToString(TimeUtility.HOUR_IN_MS*23)); assertEquals("23:00:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.HOUR_IN_MS*23));
assertEquals("52w+5d+00:00:00.000", TimeUtility.timeInMsToString(TimeUtility.DAY_IN_MS*369)); assertEquals("52w+5d+00:00:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.DAY_IN_MS*369));
//high overflow values //high overflow values
assertEquals("00:00:01.999", TimeUtility.timeInMsToString(1999)); assertEquals("00:00:01.999", UTCTimeUtility.timeInMsToString(1999));
assertEquals("00:02:39.000", TimeUtility.timeInMsToString(TimeUtility.SECOND_IN_MS*159)); assertEquals("00:02:39.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.SECOND_IN_MS*159));
assertEquals("02:39:00.000", TimeUtility.timeInMsToString(TimeUtility.MINUTE_IN_MS*159)); assertEquals("02:39:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.MINUTE_IN_MS*159));
assertEquals("5d+03:00:00.000", TimeUtility.timeInMsToString(TimeUtility.HOUR_IN_MS*123)); assertEquals("5d+03:00:00.000", UTCTimeUtility.timeInMsToString(UTCTimeUtility.HOUR_IN_MS*123));
//combinations //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("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", TimeUtility.timeInMsToString(TimeUtility.WEEK_IN_MS-1)); assertEquals("6d+23:59:59.999", UTCTimeUtility.timeInMsToString(UTCTimeUtility.WEEK_IN_MS-1));
} }
// Test printing converting milliseconds to text for a negative time // Test printing converting milliseconds to text for a negative time
@Test(expected=NumberFormatException.class) @Test(expected=NumberFormatException.class)
public void testMsToStringForNegativeArgument(){ public void testMsToStringForNegativeArgument(){
//low values //low values
TimeUtility.timeInMsToString(-1); UTCTimeUtility.timeInMsToString(-1);
} }
} }