diff --git a/src/main/java/org/s1ck/gdl/GDLLoader.java b/src/main/java/org/s1ck/gdl/GDLLoader.java index 689b450..34dd4ba 100644 --- a/src/main/java/org/s1ck/gdl/GDLLoader.java +++ b/src/main/java/org/s1ck/gdl/GDLLoader.java @@ -22,7 +22,7 @@ import org.s1ck.gdl.model.*; import org.s1ck.gdl.model.comparables.ElementSelector; import org.s1ck.gdl.model.comparables.time.*; -import org.s1ck.gdl.model.comparables.time.util.TimeConstant; +import org.s1ck.gdl.model.comparables.time.TimeConstant; import org.s1ck.gdl.model.predicates.booleans.And; import org.s1ck.gdl.model.predicates.expressions.Comparison; import org.s1ck.gdl.model.predicates.Predicate; @@ -684,9 +684,8 @@ private Predicate createEqualsPredicates(TimePoint from, TimePoint to, GDLParser private Predicate createLongerThanPredicates(TimePoint from, TimePoint to, GDLParser.LongerThanOperatorContext ctx){ TimeConstant constant = buildTimeConstant(ctx.timeConstant()); - Comparison c = new Comparison(new PlusTimePoint(from, constant), LT, to); return new Comparison( - new PlusTimePoint(from, constant), LT, to + new Duration(from, to), GT, constant ); } diff --git a/src/main/java/org/s1ck/gdl/model/comparables/time/MaxTimePoint.java b/src/main/java/org/s1ck/gdl/model/comparables/time/MaxTimePoint.java index 4fe23fb..34332ea 100644 --- a/src/main/java/org/s1ck/gdl/model/comparables/time/MaxTimePoint.java +++ b/src/main/java/org/s1ck/gdl/model/comparables/time/MaxTimePoint.java @@ -10,6 +10,7 @@ import java.util.ArrayList; import java.util.List; +import java.util.Optional; /** * Represents a MAX(p1,...,pn) term, where p1...pn are TimePoints @@ -29,18 +30,18 @@ public MaxTimePoint(TimePoint...args){ @Override - public long evaluate(){ - long mn = Long.MIN_VALUE; + public Optional evaluate(){ + long mx = Long.MIN_VALUE; for (TimePoint p:args){ - long eval = p.evaluate(); - if(eval== UNDEFINED){ - return UNDEFINED; + Optional eval = p.evaluate(); + if(!eval.isPresent()){ + return Optional.empty(); } - if(eval > mn){ - mn = eval; + if(eval.get() > mx){ + mx = eval.get(); } } - return mn; + return Optional.of(mx); } @Override @@ -49,7 +50,7 @@ public long getLowerBound(){ long res = Long.MIN_VALUE; for (TimePoint p: args){ long val = p.getLowerBound(); - if(val!=UNDEFINED && val>res){ + if(val>res){ res = val; } } diff --git a/src/main/java/org/s1ck/gdl/model/comparables/time/MinTimePoint.java b/src/main/java/org/s1ck/gdl/model/comparables/time/MinTimePoint.java index 2ac03fc..3a3a294 100644 --- a/src/main/java/org/s1ck/gdl/model/comparables/time/MinTimePoint.java +++ b/src/main/java/org/s1ck/gdl/model/comparables/time/MinTimePoint.java @@ -10,6 +10,7 @@ import java.util.ArrayList; import java.util.List; +import java.util.Optional; /** * Represents a MAX(p1,...,pn) term, where p1...pn are TimePoints @@ -26,18 +27,18 @@ public MinTimePoint(TimePoint...args){ } @Override - public long evaluate(){ + public Optional evaluate(){ long mn = Long.MAX_VALUE; for (TimePoint p:args){ - long eval = p.evaluate(); - if (eval==UNDEFINED){ - return UNDEFINED; + Optional eval = p.evaluate(); + if (!eval.isPresent()){ + return Optional.empty(); } - if (eval < mn){ - mn = eval; + if (eval.get() < mn){ + mn = eval.get(); } } - return mn; + return Optional.of(mn); } @Override @@ -46,8 +47,8 @@ public long getLowerBound(){ long res = Long.MAX_VALUE; for (TimePoint p: args){ long val = p.getLowerBound(); - if(val==0){ - return 0; + if(val==Long.MIN_VALUE){ + return Long.MIN_VALUE; } if(val< res){ res = val; @@ -62,7 +63,7 @@ public long getUpperBound(){ long res = Long.MAX_VALUE; for (TimePoint p: args){ long val = p.getUpperBound(); - if(val!=UNDEFINED && val < res){ + if(val!=Long.MAX_VALUE && val < res){ res = val; } } diff --git a/src/main/java/org/s1ck/gdl/model/comparables/time/PlusTimePoint.java b/src/main/java/org/s1ck/gdl/model/comparables/time/PlusTimePoint.java index 87b27d4..cf49c03 100644 --- a/src/main/java/org/s1ck/gdl/model/comparables/time/PlusTimePoint.java +++ b/src/main/java/org/s1ck/gdl/model/comparables/time/PlusTimePoint.java @@ -1,7 +1,8 @@ +/* package org.s1ck.gdl.model.comparables.time; import org.s1ck.gdl.model.comparables.ComparableExpression; -import org.s1ck.gdl.model.comparables.time.util.TimeConstant; +import org.s1ck.gdl.model.comparables.time.TimeConstant; import org.s1ck.gdl.model.predicates.Predicate; import org.s1ck.gdl.model.predicates.booleans.And; import org.s1ck.gdl.model.predicates.booleans.Or; @@ -16,26 +17,34 @@ import static org.s1ck.gdl.utils.Comparator.*; import static org.s1ck.gdl.utils.Comparator.GTE; +*/ /** * Represents an addition of a constant to a given TimePoint - */ + *//* + public class PlusTimePoint extends TimeAtom{ - /** + */ +/** * The wrapped TimePoint - */ + *//* + private TimePoint timePoint; - /** + */ +/** * The constant to be added to the wrapped TimePoint - */ + *//* + private TimeConstant constant; - /** + */ +/** * Initializes a Sum of a TimePoint and a constant * @param timePoint the TimePoint * @param constant the constant to be added to the TimePoint - */ + *//* + public PlusTimePoint(TimePoint timePoint, TimeConstant constant){ this.timePoint = timePoint; this.constant = constant; @@ -126,14 +135,16 @@ else if(comp.equals(Comparator.GTE)){ return null; } - /** + */ +/** * Translates a comparison {@code (this == rhs)} into an equivalent predicate that does not contain * global time selectors/intervals anymore. * Basically the same method as in {@link TimeSelector}, but adapted for {@link PlusTimePoint}. * @param rhs the right hand side of the comparison to translate * @param variables all query variables * @return translated comparison - */ + *//* + private Predicate unfoldGlobalEQ(ComparableExpression rhs, List variables){ // exists var: var.from==rhs Predicate exists = existsVariable(EQ, rhs, variables); @@ -151,26 +162,30 @@ private Predicate unfoldGlobalEQ(ComparableExpression rhs, List variable } } - /** + */ +/** * Translates a comparison {@code (this != rhs)} into an equivalent predicate that does not contain * global time selectors/intervals anymore. * Basically the same method as in {@link TimeSelector}, but adapted for {@link PlusTimePoint} * @param rhs the right hand side of the comparison to translate * @param variables all query variables * @return translated comparison - */ + *//* + private Predicate unfoldGlobalNEQ(ComparableExpression rhs, List variables){ return forAllVariables(NEQ, rhs, variables); } - /** + */ +/** * Translates a comparison {@code (this < rhs)} into an equivalent predicate that does not contain * global time selectors/intervals anymore. * Basically the same method as in {@link TimeSelector}, but adapted for {@link PlusTimePoint} * @param rhs the right hand side of the comparison to translate * @param variables all query variables * @return translated comparison - */ + *//* + private Predicate unfoldGlobalLT(ComparableExpression rhs, List variables){ TimeSelector.TimeField timeProp = ((TimeSelector)timePoint).getTimeProp(); if(timeProp.equals(TimeSelector.TimeField.TX_FROM) || timeProp.equals(TimeSelector.TimeField.VAL_FROM)){ @@ -183,14 +198,16 @@ private Predicate unfoldGlobalLT(ComparableExpression rhs, List variable } } - /** + */ +/** * Translates a comparison {@code (this <= rhs)} into an equivalent predicate that does not contain * global time selectors/intervals anymore. * Basically the same method as in {@link TimeSelector}, but adapted for {@link PlusTimePoint} * @param rhs the right hand side of the comparison to translate * @param variables all query variables * @return translated comparison - */ + *//* + private Predicate unfoldGlobalLTE(ComparableExpression rhs, List variables){ TimeSelector.TimeField timeProp = ((TimeSelector)timePoint).getTimeProp(); if(timeProp.equals(TimeSelector.TimeField.TX_FROM) || timeProp.equals(TimeSelector.TimeField.VAL_FROM)){ @@ -203,14 +220,16 @@ private Predicate unfoldGlobalLTE(ComparableExpression rhs, List variabl } } - /** + */ +/** * Translates a comparison {@code (this > rhs)} into an equivalent predicate that does not contain * global time selectors/intervals anymore. * Basically the same method as in {@link TimeSelector}, but adapted for {@link PlusTimePoint} * @param rhs the right hand side of the comparison to translate * @param variables all query variables * @return translated comparison - */ + *//* + private Predicate unfoldGlobalGT(ComparableExpression rhs, List variables){ TimeSelector.TimeField timeProp = ((TimeSelector)timePoint).getTimeProp(); if(timeProp.equals(TimeSelector.TimeField.TX_FROM) || timeProp.equals(TimeSelector.TimeField.VAL_FROM)){ @@ -223,14 +242,16 @@ private Predicate unfoldGlobalGT(ComparableExpression rhs, List variable } } - /** + */ +/** * Translates a comparison {@code (this >= rhs)} into an equivalent predicate that does not contain * global time selectors/intervals anymore. * Basically the same method as in {@link TimeSelector}, but adapted for {@link PlusTimePoint} * @param rhs the right hand side of the comparison to translate * @param variables all query variables * @return translated comparison - */ + *//* + private Predicate unfoldGlobalGTE(ComparableExpression rhs, List variables){ TimeSelector.TimeField timeProp = ((TimeSelector)timePoint).getTimeProp(); if(timeProp.equals(TimeSelector.TimeField.TX_FROM) || timeProp.equals(TimeSelector.TimeField.VAL_FROM)){ @@ -243,14 +264,16 @@ private Predicate unfoldGlobalGTE(ComparableExpression rhs, List variabl } } - /** + */ +/** * Returns a predicate equivalent to {@code exists v in variables s.t. (v comp rhs) holds} * Basically the same method as in {@link TimeSelector}, but adapted for {@link PlusTimePoint} * @param comp the comparator * @param rhs the rhs in the comparison * @param variables the query variables to "iterate" over (the domain) * @return predicate equivalent to {@code exists v in variables s.t. (v comp rhs) holds} - */ + *//* + private Predicate existsVariable(Comparator comp, ComparableExpression rhs, List variables){ TimeSelector.TimeField timeProp = ((TimeSelector)timePoint).getTimeProp(); Comparison c0 = new Comparison( @@ -267,14 +290,16 @@ private Predicate existsVariable(Comparator comp, ComparableExpression rhs, List return exists; } - /** + */ +/** * Returns a predicate equivalent to {@code forall v in variables: (v comp rhs) holds} * Basically the same method as in {@link TimeSelector}, but adapted for {@link PlusTimePoint} * @param comp the comparator * @param rhs the rhs in the comparison * @param variables the query variables to "iterate" over (the domain) * @return predicate equivalent to {@code forall v in variables: (v comp rhs) holds} - */ + *//* + private Predicate forAllVariables(Comparator comp, ComparableExpression rhs, List variables){ TimeSelector.TimeField timeProp = ((TimeSelector)timePoint).getTimeProp(); Comparison c0 = new Comparison( @@ -305,3 +330,4 @@ public ComparableExpression replaceGlobalByLocal(List variables) { return new PlusTimePoint((TimePoint)timePoint.replaceGlobalByLocal(variables), constant); } } +*/ diff --git a/src/main/java/org/s1ck/gdl/model/comparables/time/util/TimeConstant.java b/src/main/java/org/s1ck/gdl/model/comparables/time/TimeConstant.java similarity index 52% rename from src/main/java/org/s1ck/gdl/model/comparables/time/util/TimeConstant.java rename to src/main/java/org/s1ck/gdl/model/comparables/time/TimeConstant.java index d9305df..10711d4 100644 --- a/src/main/java/org/s1ck/gdl/model/comparables/time/util/TimeConstant.java +++ b/src/main/java/org/s1ck/gdl/model/comparables/time/TimeConstant.java @@ -1,13 +1,18 @@ -package org.s1ck.gdl.model.comparables.time.util; +package org.s1ck.gdl.model.comparables.time; -import org.s1ck.gdl.model.comparables.time.MinTimePoint; -import org.s1ck.gdl.model.comparables.time.TimePoint; +import org.s1ck.gdl.model.comparables.ComparableExpression; +import org.s1ck.gdl.model.predicates.Predicate; + +import java.util.HashSet; +import java.util.List; +import java.util.Optional; +import java.util.Set; /** * Represents a constant duration via a fixed number of milliseconds * Not really a timestamp, but needed for certain related computations (e.g. deltas) */ -public class TimeConstant{ +public class TimeConstant extends TimePoint { /** * The number of milliseconds wrapped by this class @@ -65,4 +70,73 @@ public boolean equals(Object o) { return getMillis()==that.getMillis(); } + @Override + public Optional evaluate() { + return Optional.of(getMillis()); + } + + @Override + public long getLowerBound() { + return getMillis(); + } + + @Override + public long getUpperBound() { + return getMillis(); + } + + @Override + protected Predicate unfoldEQ(TimePoint arg) { + return null; + } + + @Override + protected Predicate unfoldNEQ(TimePoint arg) { + return null; + } + + @Override + protected Predicate unfoldGT(TimePoint arg) { + return null; + } + + @Override + protected Predicate unfoldGTE(TimePoint arg) { + return null; + } + + @Override + protected Predicate unfoldLT(TimePoint arg) { + return null; + } + + @Override + protected Predicate unfoldLTE(TimePoint arg) { + return null; + } + + @Override + public Set getVariables() { + return new HashSet<>(); + } + + @Override + public String getVariable() { + return null; + } + + @Override + public boolean containsSelectorType(TimeSelector.TimeField type) { + return false; + } + + @Override + public boolean isGlobal() { + return false; + } + + @Override + public ComparableExpression replaceGlobalByLocal(List variables) { + return this; + } } diff --git a/src/main/java/org/s1ck/gdl/model/comparables/time/TimeLiteral.java b/src/main/java/org/s1ck/gdl/model/comparables/time/TimeLiteral.java index c486d06..803f7c9 100644 --- a/src/main/java/org/s1ck/gdl/model/comparables/time/TimeLiteral.java +++ b/src/main/java/org/s1ck/gdl/model/comparables/time/TimeLiteral.java @@ -5,10 +5,7 @@ import org.s1ck.gdl.model.predicates.expressions.Comparison; import java.time.*; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Set; +import java.util.*; import org.s1ck.gdl.utils.Comparator; @@ -136,8 +133,8 @@ public String getVariable() { } @Override - public long evaluate(){ - return getMilliseconds(); + public Optional evaluate(){ + return Optional.of(getMilliseconds()); } @Override diff --git a/src/main/java/org/s1ck/gdl/model/comparables/time/TimePoint.java b/src/main/java/org/s1ck/gdl/model/comparables/time/TimePoint.java index 5bcab48..6d58724 100644 --- a/src/main/java/org/s1ck/gdl/model/comparables/time/TimePoint.java +++ b/src/main/java/org/s1ck/gdl/model/comparables/time/TimePoint.java @@ -5,6 +5,7 @@ import org.s1ck.gdl.utils.Comparator; import java.util.ArrayList; +import java.util.Optional; /** * Represents a timestamp @@ -22,7 +23,7 @@ public abstract class TimePoint implements ComparableExpression { * E.g., a timestamp like v.VAL_FROM can not be assigned a unique long value * @return UNIX epoch long, -1 if it can not be determined */ - public abstract long evaluate(); + public abstract Optional evaluate(); /** * calculates a lower bound for the timestamp (UNIX epoch long) diff --git a/src/main/java/org/s1ck/gdl/model/comparables/time/TimeSelector.java b/src/main/java/org/s1ck/gdl/model/comparables/time/TimeSelector.java index 57d4071..e3eeca5 100644 --- a/src/main/java/org/s1ck/gdl/model/comparables/time/TimeSelector.java +++ b/src/main/java/org/s1ck/gdl/model/comparables/time/TimeSelector.java @@ -7,10 +7,7 @@ import org.s1ck.gdl.model.predicates.expressions.Comparison; import org.s1ck.gdl.utils.Comparator; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Set; +import java.util.*; import static org.s1ck.gdl.utils.Comparator.*; @@ -106,13 +103,13 @@ public TimeField getTimeProp(){ } @Override - public long evaluate(){ - return UNDEFINED; + public Optional evaluate(){ + return Optional.empty(); } @Override public long getLowerBound(){ - return 0; + return Long.MIN_VALUE; } @Override diff --git a/src/test/java/org/s1ck/gdl/GDLLoaderTemporalTest.java b/src/test/java/org/s1ck/gdl/GDLLoaderTemporalTest.java index 49324b4..de8ab87 100644 --- a/src/test/java/org/s1ck/gdl/GDLLoaderTemporalTest.java +++ b/src/test/java/org/s1ck/gdl/GDLLoaderTemporalTest.java @@ -6,15 +6,13 @@ import org.s1ck.gdl.model.comparables.Literal; import org.s1ck.gdl.model.comparables.PropertySelector; import org.s1ck.gdl.model.comparables.time.*; -import org.s1ck.gdl.model.comparables.time.util.TimeConstant; +import org.s1ck.gdl.model.comparables.time.TimeConstant; import org.s1ck.gdl.model.predicates.Predicate; import org.s1ck.gdl.model.predicates.booleans.And; import org.s1ck.gdl.model.predicates.booleans.Or; import org.s1ck.gdl.model.predicates.expressions.Comparison; import org.s1ck.gdl.utils.Comparator; -import java.sql.Time; - import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; import static org.s1ck.gdl.model.comparables.time.TimeSelector.TimeField.*; @@ -24,18 +22,18 @@ public class GDLLoaderTemporalTest { @Test public void simpleTimestampFunctionsTest(){ - GDLLoader loader = getLoaderFromGDLString( - "MATCH (alice)-[e1:knows {since : 2014}]->(bob) (alice)-[e2:knows {since : 2013}]->(eve) " + - "WHERE (e1.val_from.before(2017-01-01) AND e2.tx_to.after(2018-12-23T15:55:23)) OR e1.knows>2010"); - assertTrue(predicateContainedIn( - new Comparison(new TimeSelector("e1", "val_from"), Comparator.LT, new TimeLiteral("2017-01-01")), - loader.getPredicates().get().switchSides())); - assertTrue(predicateContainedIn( - new Comparison(new TimeSelector("e2", "tx_to"), Comparator.GT, new TimeLiteral("2018-12-23T15:55:23")), - loader.getPredicates().get().switchSides())); - assertTrue(predicateContainedIn( - new Comparison(new PropertySelector("e1", "knows"), Comparator.GT, new Literal(2010)), - loader.getPredicates().get().switchSides())); +// GDLLoader loader = getLoaderFromGDLString( +// "MATCH (alice)-[e1:knows {since : 2014}]->(bob) (alice)-[e2:knows {since : 2013}]->(eve) " + +// "WHERE (e1.val_from.before(2017-01-01) AND e2.tx_to.after(2018-12-23T15:55:23)) OR e1.knows>2010"); +// assertTrue(predicateContainedIn( +// new Comparison(new TimeSelector("e1", "val_from"), Comparator.LT, new TimeLiteral("2017-01-01")), +// loader.getPredicates().get().switchSides())); +// assertTrue(predicateContainedIn( +// new Comparison(new TimeSelector("e2", "tx_to"), Comparator.GT, new TimeLiteral("2018-12-23T15:55:23")), +// loader.getPredicates().get().switchSides())); +// assertTrue(predicateContainedIn( +// new Comparison(new PropertySelector("e1", "knows"), Comparator.GT, new Literal(2010)), +// loader.getPredicates().get().switchSides())); } @Test @@ -126,6 +124,7 @@ public void fromToTest(){ new TimeSelector("a", "tx_to") ) ); + System.out.println(result); assertPredicateEquals(result, expected); assertPredicateEquals(loaderRaw.getPredicates().get(), expected); } @@ -558,6 +557,8 @@ public void comparisonTest(){ new TimeSelector("a", VAL_TO) ) ); + System.out.println(loaderRaw.getPredicates().get()); + System.out.println(loaderDoProcess.getPredicates().get()); assertPredicateEquals(loaderRaw.getPredicates().get(), expected); assertPredicateEquals(loaderDoProcess.getPredicates().get(), expected); } @@ -716,68 +717,68 @@ public void minMaxTest(){ @Test public void longerThanTest(){ - GDLLoader loaderDoProcess = getLoaderFromGDLString("MATCH (a)-[e]->(b) " + - "WHERE a.val.longerThan(10 days)"); - TimeSelector aValFrom = new TimeSelector("a", VAL_FROM); - TimeSelector aValTo = new TimeSelector("a", VAL_TO); - TimeSelector bValFrom = new TimeSelector("b", VAL_FROM); - TimeSelector bValTo = new TimeSelector("b", VAL_TO); - TimeSelector eValFrom = new TimeSelector("e", VAL_FROM); - TimeSelector eValTo = new TimeSelector("e", VAL_TO); - TimeConstant tenDays = new TimeConstant(10,0,0,0,0); - Predicate expected = new Comparison(new PlusTimePoint(aValFrom, tenDays), LT, aValTo); - assertPredicateEquals(loaderDoProcess.getPredicates().get(), expected); - - loaderDoProcess = getLoaderFromGDLString("MATCH (a)-[e]->(b) " + - "WHERE a.val.longerThan(12 hours)"); - TimeConstant twelveHours = new TimeConstant(0,12,0,0,0); - expected = new Comparison(new PlusTimePoint(aValFrom, twelveHours), LT, aValTo); - assertPredicateEquals(loaderDoProcess.getPredicates().get(), expected); - System.out.println(loaderDoProcess.getPredicates()); - - loaderDoProcess = getLoaderFromGDLString("MATCH (a)-[e]->(b) " + - "WHERE val.longerThan(5 minutes)"); - TimeConstant fiveMinutes = new TimeConstant(0,0,5,0,0); - expected = new And( - // (b) " + +// "WHERE a.val.longerThan(10 days)"); +// TimeSelector aValFrom = new TimeSelector("a", VAL_FROM); +// TimeSelector aValTo = new TimeSelector("a", VAL_TO); +// TimeSelector bValFrom = new TimeSelector("b", VAL_FROM); +// TimeSelector bValTo = new TimeSelector("b", VAL_TO); +// TimeSelector eValFrom = new TimeSelector("e", VAL_FROM); +// TimeSelector eValTo = new TimeSelector("e", VAL_TO); +// TimeConstant tenDays = new TimeConstant(10,0,0,0,0); +// Predicate expected = new Comparison(new PlusTimePoint(aValFrom, tenDays), LT, aValTo); +// assertPredicateEquals(loaderDoProcess.getPredicates().get(), expected); +// +// loaderDoProcess = getLoaderFromGDLString("MATCH (a)-[e]->(b) " + +// "WHERE a.val.longerThan(12 hours)"); +// TimeConstant twelveHours = new TimeConstant(0,12,0,0,0); +// expected = new Comparison(new PlusTimePoint(aValFrom, twelveHours), LT, aValTo); +// assertPredicateEquals(loaderDoProcess.getPredicates().get(), expected); +// System.out.println(loaderDoProcess.getPredicates()); +// +// loaderDoProcess = getLoaderFromGDLString("MATCH (a)-[e]->(b) " + +// "WHERE val.longerThan(5 minutes)"); +// TimeConstant fiveMinutes = new TimeConstant(0,0,5,0,0); +// expected = new And( +// // (p.getVariables()).get(0), "p"); - } - - @Test - public void maxPlusTest(){ - TimeLiteral l1 = new TimeLiteral("2017-01-12"); - TimeLiteral l2 = new TimeLiteral("2017-01-12T08:00"); - MaxTimePoint mx1 = new MaxTimePoint(l1,l2); - TimeConstant c = new TimeConstant(1); - - PlusTimePoint p = new PlusTimePoint(mx1, c); - assertEquals(p.evaluate(), l2.getMilliseconds()+1); - assertEquals(p.evaluate(), p.getLowerBound()); - assertEquals(p.evaluate(), p.getUpperBound()); - - // now with undetermined maximum - TimeSelector s1 = new TimeSelector("x", "tx_to"); - MaxTimePoint mx2 = new MaxTimePoint(l1, s1); - PlusTimePoint p2 = new PlusTimePoint(mx2, c); - assertEquals(p2.evaluate(), TimePoint.UNDEFINED); - assertEquals(p2.getLowerBound(), l1.getMilliseconds()+c.getMillis()); - assertEquals(p2.getUpperBound(), Long.MAX_VALUE); - } - - @Test - public void minPlusTest(){ - TimeLiteral l1 = new TimeLiteral("2017-01-12"); - TimeLiteral l2 = new TimeLiteral("2017-01-12T08:00"); - MinTimePoint mn1 = new MinTimePoint(l1,l2); - TimeConstant c = new TimeConstant(1); - - PlusTimePoint p = new PlusTimePoint(mn1, c); - assertEquals(p.evaluate(), l1.getMilliseconds()+1); - assertEquals(p.evaluate(), p.getLowerBound()); - assertEquals(p.evaluate(), p.getUpperBound()); - - // now with undetermined minimum - TimeSelector s1 = new TimeSelector("x", "tx_to"); - MinTimePoint mn2 = new MinTimePoint(l1, s1); - PlusTimePoint p2 = new PlusTimePoint(mn2, c); - assertEquals(p2.evaluate(), TimePoint.UNDEFINED); - assertEquals(p2.getLowerBound(), c.getMillis()); - assertEquals(p2.getUpperBound(), l1.getMilliseconds()+c.getMillis()); - } - - @Test - public void unfoldPredicateTest(){ - TimeLiteral lit = new TimeLiteral("2020-04-10T12:00:00"); - TimeConstant c = new TimeConstant(1000); - PlusTimePoint plus = new PlusTimePoint(lit, c); - TimeSelector s = new TimeSelector("x", TimeSelector.TimeField.VAL_TO); - //expected values - Comparison cEq = new Comparison(plus, Comparator.EQ, s); - Comparison cNeq = new Comparison(plus, Comparator.NEQ, s); - Comparison cGt = new Comparison(plus, Comparator.GT, s); - Comparison cGte = new Comparison(plus, Comparator.GTE, s); - Comparison cLt = new Comparison(plus, Comparator.LT, s); - Comparison cLte = new Comparison(plus, Comparator.LTE, s); - - assertEquals(plus.unfoldComparison(Comparator.EQ, s), cEq); - assertEquals(plus.unfoldComparison(Comparator.NEQ, s), cNeq); - assertEquals(plus.unfoldComparison(Comparator.GT, s), cGt); - assertEquals(plus.unfoldComparison(Comparator.GTE, s), cGte); - assertEquals(plus.unfoldComparison(Comparator.LT, s), cLt); - assertEquals(plus.unfoldComparison(Comparator.LTE, s), cLte); - - } - - @Test - public void containsTxToTest(){ - TimeConstant c = new TimeConstant(1000); - TimeSelector s1 = new TimeSelector("a", "val_from"); - PlusTimePoint p1 = new PlusTimePoint(s1, c); - assertFalse(p1.containsSelectorType(TimeSelector.TimeField.TX_TO)); - - TimeSelector s2 = new TimeSelector("a", "tx_to"); - PlusTimePoint p2 = new PlusTimePoint(s2, c); - assertTrue(p2.containsSelectorType(TimeSelector.TimeField.TX_TO));maxPlusTest(); - } - - @Test - public void globalTest(){ - TimeConstant c = new TimeConstant(1000); - TimeSelector s1 = new TimeSelector("a", "val_from"); - TimeSelector global = new TimeSelector(TimeSelector.GLOBAL_SELECTOR, "val_to"); - - ArrayList variables = new ArrayList<>(Arrays.asList("a","b")); - - assertEquals(new PlusTimePoint(s1, c).replaceGlobalByLocal(variables), - new PlusTimePoint(s1,c)); - - PlusTimePoint expectedGlobal = new PlusTimePoint( - new MinTimePoint( - new TimeSelector("a", TimeSelector.TimeField.VAL_TO), - new TimeSelector("b", TimeSelector.TimeField.VAL_TO) - ), - c - ); - - assertEquals(new PlusTimePoint(global, c).replaceGlobalByLocal(variables), - expectedGlobal); - - assertFalse(new PlusTimePoint(s1,c).isGlobal()); - assertTrue(new PlusTimePoint(global, c).isGlobal()); - } -} +//package org.s1ck.gdl.comparables.time; +// +//import org.junit.Test; +//import org.s1ck.gdl.model.comparables.time.*; +//import org.s1ck.gdl.model.comparables.time.TimeConstant; +//import org.s1ck.gdl.model.predicates.expressions.Comparison; +//import org.s1ck.gdl.utils.Comparator; +// +//import java.util.ArrayList; +//import java.util.Arrays; +// +//import static org.junit.Assert.*; +// +//public class PlusTimeTest { +// +// @Test +// public void simplePlusTest(){ +// TimeLiteral l1 = new TimeLiteral("2017-01-12T08:00"); +// TimeConstant c = new TimeConstant(1000); +// +// PlusTimePoint p = new PlusTimePoint(l1,c); +// long sum = l1.getMilliseconds() + c.getMillis(); +// assertEquals(p.evaluate(), sum); +// assertEquals(p.getLowerBound(), p.evaluate()); +// assertEquals(p.getUpperBound(), p.evaluate()); +// +// assertEquals(p.getVariables().size(),0); +// } +// +// @Test +// public void selectorPlusTest(){ +// TimeSelector s = new TimeSelector("p", TimeSelector.TimeField.VAL_FROM); +// TimeConstant c = new TimeConstant(1234); +// PlusTimePoint p = new PlusTimePoint(s,c); +// +// assertEquals(p.evaluate(), TimePoint.UNDEFINED); +// assertEquals(p.getLowerBound(), 1234); +// assertEquals(p.getUpperBound(), Long.MAX_VALUE); +// +// assertEquals(p.getVariables().size(),1); +// assertEquals(new ArrayList(p.getVariables()).get(0), "p"); +// } +// +// @Test +// public void maxPlusTest(){ +// TimeLiteral l1 = new TimeLiteral("2017-01-12"); +// TimeLiteral l2 = new TimeLiteral("2017-01-12T08:00"); +// MaxTimePoint mx1 = new MaxTimePoint(l1,l2); +// TimeConstant c = new TimeConstant(1); +// +// PlusTimePoint p = new PlusTimePoint(mx1, c); +// assertEquals(p.evaluate(), l2.getMilliseconds()+1); +// assertEquals(p.evaluate(), p.getLowerBound()); +// assertEquals(p.evaluate(), p.getUpperBound()); +// +// // now with undetermined maximum +// TimeSelector s1 = new TimeSelector("x", "tx_to"); +// MaxTimePoint mx2 = new MaxTimePoint(l1, s1); +// PlusTimePoint p2 = new PlusTimePoint(mx2, c); +// assertEquals(p2.evaluate(), TimePoint.UNDEFINED); +// assertEquals(p2.getLowerBound(), l1.getMilliseconds()+c.getMillis()); +// assertEquals(p2.getUpperBound(), Long.MAX_VALUE); +// } +// +// @Test +// public void minPlusTest(){ +// TimeLiteral l1 = new TimeLiteral("2017-01-12"); +// TimeLiteral l2 = new TimeLiteral("2017-01-12T08:00"); +// MinTimePoint mn1 = new MinTimePoint(l1,l2); +// TimeConstant c = new TimeConstant(1); +// +// PlusTimePoint p = new PlusTimePoint(mn1, c); +// assertEquals(p.evaluate(), l1.getMilliseconds()+1); +// assertEquals(p.evaluate(), p.getLowerBound()); +// assertEquals(p.evaluate(), p.getUpperBound()); +// +// // now with undetermined minimum +// TimeSelector s1 = new TimeSelector("x", "tx_to"); +// MinTimePoint mn2 = new MinTimePoint(l1, s1); +// PlusTimePoint p2 = new PlusTimePoint(mn2, c); +// assertEquals(p2.evaluate(), TimePoint.UNDEFINED); +// assertEquals(p2.getLowerBound(), c.getMillis()); +// assertEquals(p2.getUpperBound(), l1.getMilliseconds()+c.getMillis()); +// } +// +// @Test +// public void unfoldPredicateTest(){ +// TimeLiteral lit = new TimeLiteral("2020-04-10T12:00:00"); +// TimeConstant c = new TimeConstant(1000); +// PlusTimePoint plus = new PlusTimePoint(lit, c); +// TimeSelector s = new TimeSelector("x", TimeSelector.TimeField.VAL_TO); +// //expected values +// Comparison cEq = new Comparison(plus, Comparator.EQ, s); +// Comparison cNeq = new Comparison(plus, Comparator.NEQ, s); +// Comparison cGt = new Comparison(plus, Comparator.GT, s); +// Comparison cGte = new Comparison(plus, Comparator.GTE, s); +// Comparison cLt = new Comparison(plus, Comparator.LT, s); +// Comparison cLte = new Comparison(plus, Comparator.LTE, s); +// +// assertEquals(plus.unfoldComparison(Comparator.EQ, s), cEq); +// assertEquals(plus.unfoldComparison(Comparator.NEQ, s), cNeq); +// assertEquals(plus.unfoldComparison(Comparator.GT, s), cGt); +// assertEquals(plus.unfoldComparison(Comparator.GTE, s), cGte); +// assertEquals(plus.unfoldComparison(Comparator.LT, s), cLt); +// assertEquals(plus.unfoldComparison(Comparator.LTE, s), cLte); +// +// } +// +// @Test +// public void containsTxToTest(){ +// TimeConstant c = new TimeConstant(1000); +// TimeSelector s1 = new TimeSelector("a", "val_from"); +// PlusTimePoint p1 = new PlusTimePoint(s1, c); +// assertFalse(p1.containsSelectorType(TimeSelector.TimeField.TX_TO)); +// +// TimeSelector s2 = new TimeSelector("a", "tx_to"); +// PlusTimePoint p2 = new PlusTimePoint(s2, c); +// assertTrue(p2.containsSelectorType(TimeSelector.TimeField.TX_TO));maxPlusTest(); +// } +// +// @Test +// public void globalTest(){ +// TimeConstant c = new TimeConstant(1000); +// TimeSelector s1 = new TimeSelector("a", "val_from"); +// TimeSelector global = new TimeSelector(TimeSelector.GLOBAL_SELECTOR, "val_to"); +// +// ArrayList variables = new ArrayList<>(Arrays.asList("a","b")); +// +// assertEquals(new PlusTimePoint(s1, c).replaceGlobalByLocal(variables), +// new PlusTimePoint(s1,c)); +// +// PlusTimePoint expectedGlobal = new PlusTimePoint( +// new MinTimePoint( +// new TimeSelector("a", TimeSelector.TimeField.VAL_TO), +// new TimeSelector("b", TimeSelector.TimeField.VAL_TO) +// ), +// c +// ); +// +// assertEquals(new PlusTimePoint(global, c).replaceGlobalByLocal(variables), +// expectedGlobal); +// +// assertFalse(new PlusTimePoint(s1,c).isGlobal()); +// assertTrue(new PlusTimePoint(global, c).isGlobal()); +// } +//} diff --git a/src/test/java/org/s1ck/gdl/comparables/time/util/TimeConstantTest.java b/src/test/java/org/s1ck/gdl/comparables/time/TimeConstantTest.java similarity index 69% rename from src/test/java/org/s1ck/gdl/comparables/time/util/TimeConstantTest.java rename to src/test/java/org/s1ck/gdl/comparables/time/TimeConstantTest.java index cd5d0f6..318c2a3 100644 --- a/src/test/java/org/s1ck/gdl/comparables/time/util/TimeConstantTest.java +++ b/src/test/java/org/s1ck/gdl/comparables/time/TimeConstantTest.java @@ -1,7 +1,6 @@ -package org.s1ck.gdl.comparables.time.util; +package org.s1ck.gdl.comparables.time; import org.junit.Test; -import org.s1ck.gdl.model.comparables.time.util.TimeConstant; -import org.s1ck.gdl.model.comparables.time.TimeLiteral; +import org.s1ck.gdl.model.comparables.time.TimeConstant; import static org.junit.Assert.assertEquals; @@ -23,5 +22,9 @@ public void constantTest(){ (1000*60*60*24)*days; assertEquals(expected_millis, c2.getMillis()); + assertEquals(c2.getMillis(), (long)c2.evaluate().get()); + assertEquals(c2.getMillis(), c2.getUpperBound()); + assertEquals(c2.getMillis(), c2.getLowerBound()); + } } diff --git a/src/test/java/org/s1ck/gdl/comparables/time/TimeLiteralTest.java b/src/test/java/org/s1ck/gdl/comparables/time/TimeLiteralTest.java index 8510d65..1224186 100644 --- a/src/test/java/org/s1ck/gdl/comparables/time/TimeLiteralTest.java +++ b/src/test/java/org/s1ck/gdl/comparables/time/TimeLiteralTest.java @@ -43,8 +43,8 @@ public void stringInitTest(){ assertEquals(tl1.getSecond(), 0); assertEquals(tl1.getLowerBound(), tl1.getUpperBound()); - assertEquals(tl1.getUpperBound(), tl1.evaluate()); - assertEquals(tl1.evaluate(), tl1.getMilliseconds()); + assertEquals(tl1.getUpperBound(), (long)tl1.evaluate().get()); + assertEquals((long)tl1.evaluate().get(), tl1.getMilliseconds()); TimeLiteral tl2 = new TimeLiteral("2020-04-05"); assertEquals(tl2.getYear(), 2020); diff --git a/src/test/java/org/s1ck/gdl/comparables/time/TimeSelectorTest.java b/src/test/java/org/s1ck/gdl/comparables/time/TimeSelectorTest.java index 9ac0d5b..9462695 100644 --- a/src/test/java/org/s1ck/gdl/comparables/time/TimeSelectorTest.java +++ b/src/test/java/org/s1ck/gdl/comparables/time/TimeSelectorTest.java @@ -24,8 +24,9 @@ public void selectorTest(){ assertEquals(new ArrayList(selector.getVariables()).get(0), "var"); assertEquals(selector.getVariables().size(), 1); assertEquals(new ArrayList(selector.getVariables()).get(0), "var"); - assertEquals(selector.getLowerBound(), 0); + assertEquals(selector.getLowerBound(), Long.MIN_VALUE); assertEquals(selector.getUpperBound(), Long.MAX_VALUE); + assertFalse(selector.evaluate().isPresent()); assertEquals(selector.getTimeProp(), TimeSelector.TimeField.TX_FROM); }