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

Fixed build dependency issues by moving hal core into hal-core folder/subproject

Browse source
This commit is contained in:
Ziver Koc 2020-11-10 18:36:02 +01:00
parent f1da2c5a4d
commit ded778fd11
138 changed files with 195 additions and 183 deletions
Download patch file Download diff file Expand all files Collapse all files

142
hal-core/test/se/hal/EventControllerManagerTest.java Normal file
View file

@ -0,0 +1,142 @@
package se.hal;
import org.junit.Test;
import se.hal.intf.*;
import se.hal.struct.Event;
import se.hal.struct.devicedata.SwitchEventData;
import java.util.Collections;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public class EventControllerManagerTest {
private ControllerManager manager = new ControllerManager();
@Test
public void addAvailableEvent(){
assertEquals(0, manager.getAvailableEvents().size());
manager.addAvailableEvent(TestEvent1.class);
assertEquals(1, manager.getAvailableEvents().size());
assertTrue(manager.getAvailableEvents().contains(TestEvent1.class));
manager.addAvailableEvent(TestEvent2.class);
assertEquals(2, manager.getAvailableEvents().size());
assertTrue(manager.getAvailableEvents().contains(TestEvent1.class));
assertTrue(manager.getAvailableEvents().contains(TestEvent2.class));
// Add duplicate Event
manager.addAvailableEvent(TestEvent1.class);
assertEquals("No duplicate check",2, manager.getAvailableEvents().size());
}
@Test
public void registerUnavailableEvent(){
assertEquals(Collections.EMPTY_LIST, manager.getAvailableEvents());
Event Event = new Event();
Event.setDeviceConfig(new TestEvent1());
manager.register(Event);
assertEquals("No Event registered", Collections.EMPTY_LIST, manager.getRegisteredEvents());
}
@Test
public void registerOneEvent() {
Event Event1 = registerEvent(new TestEvent1());
assertEquals(1, manager.getRegisteredEvents().size());
assertTrue(manager.getRegisteredEvents().contains(Event1));
}
public void registerTwoEvents(){
Event Event1 = registerEvent(new TestEvent1());
Event Event2 = registerEvent(new TestEvent2());
assertEquals(2, manager.getRegisteredEvents().size());
assertTrue(manager.getRegisteredEvents().contains(Event1));
assertTrue(manager.getRegisteredEvents().contains(Event2));
}
@Test
public void deregisterEvent(){
Event Event1 = registerEvent(new TestEvent1());
manager.deregister(Event1);
assertEquals(Collections.EMPTY_LIST, manager.getRegisteredEvents());
}
// TODO: TC for reportReceived
//////////////////////////////////////////////////////////
private Event registerEvent(HalEventConfig config){
Event Event = new Event();
Event.setDeviceConfig(config);
manager.addAvailableEvent(config.getClass());
manager.register(Event);
return Event;
}
public static class TestEvent1 implements HalEventConfig {
@Override
public Class<? extends HalEventController> getEventControllerClass() {
return TestController.class;
}
@Override
public Class<? extends HalEventData> getEventDataClass() {
return SwitchEventData.class;
}
}
public static class TestEvent2 implements HalEventConfig {
@Override
public Class<? extends HalEventController> getEventControllerClass() {
return TestController.class;
}
@Override
public Class<? extends HalEventData> getEventDataClass() {
return SwitchEventData.class;
}
}
public static class TestController implements HalEventController{
int size;
@Override
public void initialize() throws Exception { }
@Override
public void register(HalEventConfig event) {
size++;
}
@Override
public void deregister(HalEventConfig event) {
size--;
}
@Override
public void send(HalEventConfig eventConfig, HalEventData eventData) {
}
@Override
public int size() {
return size;
}
@Override
public void setListener(HalEventReportListener listener) { }
@Override
public void close() { }
}
}

160
hal-core/test/se/hal/SensorControllerManagerTest.java Normal file
View file

@ -0,0 +1,160 @@
package se.hal;
import org.junit.Test;
import se.hal.intf.HalSensorConfig;
import se.hal.intf.HalSensorController;
import se.hal.intf.HalSensorData;
import se.hal.intf.HalSensorReportListener;
import se.hal.struct.Sensor;
import se.hal.struct.devicedata.HumiditySensorData;
import se.hal.struct.devicedata.TemperatureSensorData;
import java.util.Collections;
import static org.junit.Assert.*;
public class SensorControllerManagerTest {
private ControllerManager manager = new ControllerManager();
@Test
public void addAvailableSensor(){
assertEquals(Collections.EMPTY_LIST, manager.getAvailableSensors());
manager.addAvailableSensor(TestSensor1.class);
assertEquals(1, manager.getAvailableSensors().size());
assertTrue(manager.getAvailableSensors().contains(TestSensor1.class));
manager.addAvailableSensor(TestSensor2.class);
assertEquals(2, manager.getAvailableSensors().size());
assertTrue(manager.getAvailableSensors().contains(TestSensor1.class));
assertTrue(manager.getAvailableSensors().contains(TestSensor2.class));
// Add duplicate sensor
manager.addAvailableSensor(TestSensor1.class);
assertEquals("No duplicate check",2, manager.getAvailableSensors().size());
}
@Test
public void registerUnavailableSensor(){
assertEquals(Collections.EMPTY_LIST, manager.getAvailableSensors());
Sensor sensor = new Sensor();
sensor.setDeviceConfig(new TestSensor1());
manager.register(sensor);
assertEquals("No Sensor registered", Collections.EMPTY_LIST, manager.getRegisteredSensors());
}
@Test
public void registerOneSensor() {
Sensor sensor1 = registerSensor(new TestSensor1());
assertEquals(1, manager.getRegisteredSensors().size());
assertTrue(manager.getRegisteredSensors().contains(sensor1));
}
@Test
public void registerTwoSensors(){
Sensor sensor1 = registerSensor(new TestSensor1());
Sensor sensor2 = registerSensor(new TestSensor2());
assertEquals(2, manager.getRegisteredSensors().size());
assertTrue(manager.getRegisteredSensors().contains(sensor1));
assertTrue(manager.getRegisteredSensors().contains(sensor2));
}
@Test
public void deregisterSensor(){
Sensor sensor1 = registerSensor(new TestSensor1());
manager.deregister(sensor1);
assertEquals(Collections.EMPTY_LIST, manager.getRegisteredEvents());
}
// TODO: TC for reportReceived
//////////////////////////////////////////////////////////
private Sensor registerSensor(HalSensorConfig config){
Sensor sensor = new Sensor();
sensor.setDeviceConfig(config);
manager.addAvailableSensor(config.getClass());
manager.register(sensor);
return sensor;
}
public static class TestSensor1 implements HalSensorConfig {
@Override
public long getDataInterval() {
return 0;
}
@Override
public AggregationMethod getAggregationMethod() {
return AggregationMethod.AVERAGE;
}
@Override
public Class<? extends HalSensorController> getSensorControllerClass() {
return TestController.class;
}
@Override
public Class<? extends HalSensorData> getSensorDataClass() {
return TemperatureSensorData.class;
}
}
public static class TestSensor2 implements HalSensorConfig {
@Override
public long getDataInterval() {
return 0;
}
@Override
public AggregationMethod getAggregationMethod() {
return AggregationMethod.SUM;
}
@Override
public Class<? extends HalSensorController> getSensorControllerClass() {
return TestController.class;
}
@Override
public Class<? extends HalSensorData> getSensorDataClass() {
return HumiditySensorData.class;
}
}
public static class TestController implements HalSensorController{
int size;
@Override
public void initialize() throws Exception { }
@Override
public void register(HalSensorConfig sensor) {
size++;
}
@Override
public void deregister(HalSensorConfig sensor) {
size--;
}
@Override
public int size() {
return size;
}
@Override
public void setListener(HalSensorReportListener listener) { }
@Override
public void close() { }
}
}

97
hal-core/test/se/hal/TriggerManagerTest.java Normal file
View file

@ -0,0 +1,97 @@
package se.hal;
import org.junit.Test;
import se.hal.intf.HalAction;
import se.hal.intf.HalTrigger;
import se.hal.struct.Action;
import se.hal.struct.Trigger;
import se.hal.struct.TriggerFlow;
import java.util.Collections;
import static org.junit.Assert.*;
/**
*
*/
public class TriggerManagerTest {
private TriggerManager manager = new TriggerManager();
@Test
public void registerAvailableTrigger(){
assertEquals(Collections.EMPTY_LIST, manager.getAvailableTriggers());
manager.addAvailableTrigger(TestTrigger.class);
manager.addAvailableTrigger(TestTrigger.class);
assertEquals(1, manager.getAvailableTriggers().size());
assertTrue(manager.getAvailableTriggers().contains(TestTrigger.class));
}
@Test
public void registerAvailableAction(){
assertEquals(Collections.EMPTY_LIST, manager.getAvailableActions());
manager.addAvailableAction(TestAction.class);
manager.addAvailableAction(TestAction.class);
assertEquals(1, manager.getAvailableActions().size());
assertTrue(manager.getAvailableActions().contains(TestAction.class));
}
@Test
public void register(){
registerAvailableTrigger();
TriggerFlow flow = new TriggerFlow();
flow.addTrigger(new Trigger(new TestTrigger(true)));
TestAction action = new TestAction();
flow.addAction(new Action(action));
manager.register(flow);
manager.evaluateAndExecute();
assertEquals(1, action.nrOfExecutions);
}
@Test
public void evaluateAndExecute(){
registerAvailableTrigger();
TriggerFlow flow = new TriggerFlow();
TestTrigger trigger = new TestTrigger(true);
flow.addTrigger(new Trigger(trigger));
TestAction action = new TestAction();
flow.addAction(new Action(action));
manager.register(flow);
manager.evaluateAndExecute();
assertEquals("Action executed nr of times",
1, action.nrOfExecutions);
manager.evaluateAndExecute();
assertEquals("Action executed nr of times",
1, action.nrOfExecutions);
}
/////////////////////////////////////////////////////////////////////////////
private static class TestTrigger implements HalTrigger {
boolean evaluation;
TestTrigger(boolean b){ evaluation = b; }
@Override
public boolean evaluate() { return evaluation; }
@Override
public void reset() { evaluation = false; }
}
private class TestAction implements HalAction {
int nrOfExecutions;
@Override
public void execute() { nrOfExecutions++; }
}
}

83
hal-core/test/se/hal/daemon/SensorDataAggregationDeamonTest.java Normal file
View file

@ -0,0 +1,83 @@
package se.hal.daemon;
import java.sql.PreparedStatement;
import org.junit.Before;
import org.junit.Test;
import se.hal.HalContext;
import se.hal.util.UTCTimeUtility;
import zutil.db.DBConnection;
import zutil.db.DBUpgradeHandler;
import zutil.log.LogUtil;
public class SensorDataAggregationDeamonTest {
private static final String DEFAULT_DB_FILE = "hal-default.db";
private static DBConnection db;
@Before
public void setupDatabase() throws Exception{
System.out.println("-----------------------------------------------");
//setup loggin
System.out.println("Setting up logging");
LogUtil.readConfiguration("logging.properties");
//create in memory database
System.out.println("Creating a in-memory databse for test");
db = new DBConnection(DBConnection.DBMS.SQLite, ":memory:");
HalContext.setDB(db);
//upgrade the database to latest version
System.out.println("Upgrading in-memory databse to latest version");
DBConnection referenceDB = new DBConnection(DBConnection.DBMS.SQLite, DEFAULT_DB_FILE);
final DBUpgradeHandler handler = new DBUpgradeHandler(referenceDB);
handler.addIgnoredTable("db_version_history");
handler.addIgnoredTable("sqlite_sequence"); //sqlite internal
handler.setTargetDB(db);
handler.upgrade();
//populate the database with data
System.out.println("Adding user to database");
db.exec("INSERT INTO user(id, external, username) VALUES(222, 0, 'test')"); //adding user
System.out.println("Adding sensor to database");
db.exec("INSERT INTO sensor(id, user_id, external_id, type) VALUES(111, 222, 333, 'se.hal.plugin.netscan.NetworkDevice')"); //adding sensor
System.out.println("Generating raw data and saving it to the database...");
PreparedStatement stmt = db.getPreparedStatement("INSERT INTO sensor_data_raw (timestamp, sensor_id, data) VALUES(?, ?, ?)");
try{
db.getConnection().setAutoCommit(false);
long startTime = System.currentTimeMillis();
for(int i = 0; i < 100000; ++i){
stmt.setLong(1, startTime-(UTCTimeUtility.MINUTE_IN_MS*i));
stmt.setLong(2, 111);
stmt.setFloat(3, 7.323f);
stmt.addBatch();
}
DBConnection.execBatch(stmt);
db.getConnection().commit();
}catch(Exception e){
db.getConnection().rollback();
throw e;
}finally{
db.getConnection().setAutoCommit(true);
}
System.out.println("Ready for test!");
}
@Test
public void testAggregation(){
System.out.println("Start testing raw data aggregation");
SensorDataAggregatorDaemon aggrDeamon = new SensorDataAggregatorDaemon();
aggrDeamon.run();
//TODO: verify the aggregation
System.out.println("Finished testing raw data aggregation");
}
}

128
hal-core/test/se/hal/util/TimePeriodTest.java Normal file
View file

@ -0,0 +1,128 @@
package se.hal.util;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import se.hal.daemon.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()));
}
}

474
hal-core/test/se/hal/util/TimeUtilityTest.java Normal file
View file

@ -0,0 +1,474 @@
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.daemon.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;
@RunWith(Parameterized.class)
public class TimeUtilityTest {
private final long currentTime_UTC;
/**
* Constructor
* @param timestamp
*/
public TimeUtilityTest(long timestamp){
this.currentTime_UTC = timestamp;
}
@Parameters
public static Collection<Object[]> data(){
return Arrays.asList(new Object[][] {
{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)
{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
{Long.MAX_VALUE-(60*UTCTimeUtility.WEEK_IN_MS)}, //max time - 60w
});
}
// Test flooring & ceiling UTC time to the closes year
@Test
public void testYear_UTC(){
System.out.println("Testing year with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
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(){
System.out.println("Testing month with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
Calendar tmpCal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
tmpCal.setTimeInMillis(currentTime_UTC);
long thisPeriodStartedAt = UTCTimeUtility.getTimestampPeriodStart(AggregationPeriodLength.MONTH, currentTime_UTC);
long thisPeriodEndedAt = UTCTimeUtility.getTimestampPeriodEnd(AggregationPeriodLength.MONTH, currentTime_UTC);
//verify period start is correct
System.out.println(" month start timestamp = " + thisPeriodStartedAt + " " + UTCTimeUtility.getDateString(thisPeriodStartedAt));
assertTrue("perdiod start is not before current time", thisPeriodStartedAt <= currentTime_UTC);
assertEquals("period start millisecond is wrong", 0, UTCTimeUtility.getMillisecondInSecondFromTimestamp(thisPeriodStartedAt));
assertEquals("period start second is wrong", 0, UTCTimeUtility.getSecondOfMinuteFromTimestamp(thisPeriodStartedAt));
assertEquals("period start minute is wrong", 0, UTCTimeUtility.getMinuteOfHourFromTimestamp(thisPeriodStartedAt));
assertEquals("period start hour is wrong", 0, UTCTimeUtility.getHourOfDayFromTimestamp(thisPeriodStartedAt));
assertEquals("period start day is wrong", 1, UTCTimeUtility.getDayOfMonthFromTimestamp(thisPeriodStartedAt));
assertEquals("period start month is wrong", UTCTimeUtility.getMonthOfYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getMonthOfYearFromTimestamp(thisPeriodStartedAt));
assertEquals("period start year is wrong", UTCTimeUtility.getYearFromTimestamp(currentTime_UTC), UTCTimeUtility.getYearFromTimestamp(thisPeriodStartedAt));
//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(){
System.out.println("Testing week with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
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("period 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("period end is not after 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));
System.out.println(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(){
System.out.println("Testing day with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
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("period 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("period end is not after 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(){
System.out.println("Testing hour with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
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("period 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("period end is not after 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(){
System.out.println("Testing 15-min with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
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("period 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("period end is not after 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(){
System.out.println("Testing 5-min with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
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("period 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("period end is not after 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(){
System.out.println("Testing minute with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
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("period 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("period end is not after 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(){
System.out.println("Testing second with timestamp " + currentTime_UTC + " " + UTCTimeUtility.getDateString(currentTime_UTC));
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("period 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("period end is not after 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", 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", 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", 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", 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
UTCTimeUtility.timeInMsToString(-1);
}
}