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