From 185e7950e4f6ea5e77911d8688706739c2f39755 Mon Sep 17 00:00:00 2001 From: Robert von Burg Date: Tue, 25 Sep 2018 08:45:36 +0200 Subject: [PATCH] [New] Added new helper methods to Parameters --- .../model/parameter/BooleanParameter.java | 25 +- .../model/parameter/DateParameter.java | 44 ++- .../model/parameter/DurationParameter.java | 16 + .../model/parameter/FloatListParameter.java | 33 +- .../model/parameter/FloatParameter.java | 50 ++- .../model/parameter/IntegerListParameter.java | 32 ++ .../model/parameter/IntegerParameter.java | 50 ++- .../model/parameter/ListParameter.java | 18 + .../model/parameter/LongListParameter.java | 32 ++ .../model/parameter/LongParameter.java | 51 ++- .../li/strolch/model/parameter/Parameter.java | 34 +- .../model/parameter/StringListParameter.java | 32 ++ .../model/parameter/StringParameter.java | 18 +- .../model/parameter/ParameterTest.java | 316 ++++++++++++++++++ 14 files changed, 741 insertions(+), 10 deletions(-) create mode 100644 li.strolch.model/src/test/java/li/strolch/model/parameter/ParameterTest.java diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/BooleanParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/BooleanParameter.java index dea399f44..9ba7f1f8c 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/BooleanParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/BooleanParameter.java @@ -69,6 +69,12 @@ public class BooleanParameter extends AbstractParameter { this.value = value; } + @Override + public void setValue(Parameter parameter) { + assertNotReadonly(); + this.value = parameter.getValue(); + } + @Override public void setValueFromString(String valueAsString) { setValue(parseFromString(valueAsString)); @@ -85,11 +91,29 @@ public class BooleanParameter extends AbstractParameter { this.value = false; } + /** + * @return true if the value is false + */ @Override public boolean isEmpty() { return !this.value; } + @Override + public boolean isEqualTo(Parameter otherValue) { + return this.value.equals(otherValue.getValue()); + } + + @Override + public boolean isEqualTo(Boolean otherValue) { + return this.value.equals(otherValue); + } + + public void flip() { + assertNotReadonly(); + this.value = !this.value; + } + @Override public String getType() { return StrolchValueType.BOOLEAN.getType(); @@ -125,5 +149,4 @@ public class BooleanParameter extends AbstractParameter { DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return this.getValue().compareTo(((BooleanParameter) o).getValue()); } - } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/DateParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/DateParameter.java index 297c5754b..396271413 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/DateParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/DateParameter.java @@ -15,6 +15,9 @@ */ package li.strolch.model.parameter; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.ZonedDateTime; import java.util.Date; import li.strolch.model.StrolchValueType; @@ -72,6 +75,12 @@ public class DateParameter extends AbstractParameter { this.value = value; } + @Override + public void setValue(Parameter parameter) { + assertNotReadonly(); + this.value = parameter.getValue(); + } + @Override public void setValueFromString(String valueAsString) { setValue(parseFromString(valueAsString)); @@ -93,6 +102,40 @@ public class DateParameter extends AbstractParameter { return this.value.equals(EMPTY_VALUE); } + @Override + public boolean isEqualTo(Parameter otherValue) { + return this.value.equals(otherValue.getValue()); + } + + @Override + public boolean isEqualTo(Date otherValue) { + return this.value.equals(otherValue); + } + + public boolean isEqualTo(LocalDateTime otherValue) { + return this.value.equals(Date.from(otherValue.atZone(ZoneId.systemDefault()).toInstant())); + } + + public boolean isEqualTo(ZonedDateTime otherValue) { + return this.value.equals(Date.from(otherValue.toInstant())); + } + + public ZonedDateTime toZonedDateTime() { + return ZonedDateTime.ofInstant(this.value.toInstant(), ZoneId.systemDefault()); + } + + public LocalDateTime toLocalDateTime() { + return LocalDateTime.ofInstant(this.value.toInstant(), ZoneId.systemDefault()); + } + + public void setValueFromLocalDateTime(LocalDateTime localDateTime) { + this.value = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant()); + } + + public void setValueFromZonedDateTime(ZonedDateTime zonedDateTime) { + this.value = Date.from(zonedDateTime.toInstant()); + } + @Override public String getType() { return StrolchValueType.DATE.getType(); @@ -128,5 +171,4 @@ public class DateParameter extends AbstractParameter { DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return this.getValue().compareTo(((DateParameter) o).getValue()); } - } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/DurationParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/DurationParameter.java index 912135b14..387cbf9a5 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/DurationParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/DurationParameter.java @@ -69,6 +69,12 @@ public class DurationParameter extends AbstractParameter { this.value = value; } + @Override + public void setValue(Parameter parameter) { + assertNotReadonly(); + this.value = parameter.getValue(); + } + /** * Sets the value to 0 * @@ -85,6 +91,16 @@ public class DurationParameter extends AbstractParameter { return this.value == 0L; } + @Override + public boolean isEqualTo(Parameter otherValue) { + return this.value.equals(otherValue.getValue()); + } + + @Override + public boolean isEqualTo(Long otherValue) { + return this.value.equals(otherValue); + } + @Override public void setValueFromString(String valueAsString) { setValue(parseFromString(valueAsString)); diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatListParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatListParameter.java index 81da84ec7..213289a92 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatListParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatListParameter.java @@ -91,6 +91,12 @@ public class FloatListParameter extends AbstractParameter> implemen this.value = new ArrayList<>(value); } + @Override + public void setValue(Parameter> parameter) { + assertNotReadonly(); + this.value = new ArrayList<>(parameter.getValue()); + } + @Override public void setValueFromString(String valueAsString) { setValue(parseFromString(valueAsString)); @@ -102,6 +108,17 @@ public class FloatListParameter extends AbstractParameter> implemen this.value.add(value); } + @Override + public boolean addValueIfNotContains(Double value) { + assertNotReadonly(); + + if (this.value.contains(value)) + return false; + + this.value.add(value); + return true; + } + @Override public boolean removeValue(Double value) { assertNotReadonly(); @@ -119,6 +136,16 @@ public class FloatListParameter extends AbstractParameter> implemen return this.value.isEmpty(); } + @Override + public boolean isEqualTo(Parameter> otherValue) { + return this.value.equals(otherValue.getValue()); + } + + @Override + public boolean isEqualTo(List otherValue) { + return this.value.equals(otherValue); + } + @Override public int size() { return this.value.size(); @@ -129,6 +156,11 @@ public class FloatListParameter extends AbstractParameter> implemen return this.value.contains(value); } + @Override + public boolean containsAll(List values) { + return this.value.containsAll(values); + } + @Override public String getType() { return StrolchValueType.FLOAT_LIST.getType(); @@ -178,5 +210,4 @@ public class FloatListParameter extends AbstractParameter> implemen DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return Integer.compare(this.getValue().size(), ((FloatListParameter) o).getValue().size()); } - } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatParameter.java index 1bdbbe4d4..59bd6bdfb 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/FloatParameter.java @@ -70,6 +70,12 @@ public class FloatParameter extends AbstractParameter { this.value = value; } + @Override + public void setValue(Parameter parameter) { + assertNotReadonly(); + this.value = parameter.getValue(); + } + /** * Sets the value to 0 * @@ -81,11 +87,54 @@ public class FloatParameter extends AbstractParameter { this.value = 0.0D; } + /** + * @return true if the value == 0.0D + */ @Override public boolean isEmpty() { return this.value == 0.0D; } + @Override + public boolean isEqualTo(Parameter otherValue) { + return this.value.equals(otherValue.getValue()); + } + + @Override + public boolean isEqualTo(Double otherValue) { + return this.value.equals(otherValue); + } + + public void add(double value) { + assertNotReadonly(); + this.value += value; + } + + public void subtract(double value) { + assertNotReadonly(); + this.value -= value; + } + + public void multiply(double value) { + assertNotReadonly(); + this.value *= value; + } + + public void divide(double value) { + assertNotReadonly(); + this.value /= value; + } + + public void increment() { + assertNotReadonly(); + this.value++; + } + + public void decrement() { + assertNotReadonly(); + this.value--; + } + @Override public void setValueFromString(String valueAsString) { setValue(parseFromString(valueAsString)); @@ -126,5 +175,4 @@ public class FloatParameter extends AbstractParameter { DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return this.getValue().compareTo(((FloatParameter) o).getValue()); } - } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerListParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerListParameter.java index d55acf6e1..b65043a32 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerListParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerListParameter.java @@ -91,6 +91,12 @@ public class IntegerListParameter extends AbstractParameter> imple this.value = new ArrayList<>(value); } + @Override + public void setValue(Parameter> parameter) { + assertNotReadonly(); + this.value = new ArrayList<>(parameter.getValue()); + } + @Override public void setValueFromString(String valueAsString) { setValue(parseFromString(valueAsString)); @@ -102,6 +108,17 @@ public class IntegerListParameter extends AbstractParameter> imple this.value.add(value); } + @Override + public boolean addValueIfNotContains(Integer value) { + assertNotReadonly(); + + if (this.value.contains(value)) + return false; + + this.value.add(value); + return true; + } + @Override public boolean removeValue(Integer value) { assertNotReadonly(); @@ -119,6 +136,16 @@ public class IntegerListParameter extends AbstractParameter> imple return this.value.isEmpty(); } + @Override + public boolean isEqualTo(Parameter> otherValue) { + return this.value.equals(otherValue.getValue()); + } + + @Override + public boolean isEqualTo(List otherValue) { + return this.value.equals(otherValue); + } + @Override public int size() { return this.value.size(); @@ -129,6 +156,11 @@ public class IntegerListParameter extends AbstractParameter> imple return this.value.contains(value); } + @Override + public boolean containsAll(List values) { + return this.value.containsAll(values); + } + @Override public String getType() { return StrolchValueType.INTEGER_LIST.getType(); diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerParameter.java index e63241f70..a971c1e1e 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/IntegerParameter.java @@ -78,6 +78,12 @@ public class IntegerParameter extends AbstractParameter { this.value = value; } + @Override + public void setValue(Parameter parameter) { + assertNotReadonly(); + this.value = parameter.getValue(); + } + /** * Sets the value to 0 * @@ -89,11 +95,54 @@ public class IntegerParameter extends AbstractParameter { this.value = 0; } + /** + * @return true if the value == 0 + */ @Override public boolean isEmpty() { return this.value == 0; } + @Override + public boolean isEqualTo(Parameter otherValue) { + return this.value.equals(otherValue.getValue()); + } + + @Override + public boolean isEqualTo(Integer otherValue) { + return this.value.equals(otherValue); + } + + public void add(int value) { + assertNotReadonly(); + this.value += value; + } + + public void subtract(int value) { + assertNotReadonly(); + this.value -= value; + } + + public void multiply(int value) { + assertNotReadonly(); + this.value *= value; + } + + public void divide(int value) { + assertNotReadonly(); + this.value /= value; + } + + public void increment() { + assertNotReadonly(); + this.value++; + } + + public void decrement() { + assertNotReadonly(); + this.value--; + } + @Override public void setValueFromString(String valueAsString) { setValue(parseFromString(valueAsString)); @@ -124,5 +173,4 @@ public class IntegerParameter extends AbstractParameter { DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return this.getValue().compareTo(((IntegerParameter) o).getValue()); } - } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/ListParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/ListParameter.java index 98186249b..7789b7f63 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/ListParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/ListParameter.java @@ -35,6 +35,14 @@ public interface ListParameter extends Parameter> { */ public void addValue(E value); + /** + * Adds a single value to the {@link List} of values if the current list does not already contain the value + * + * @param value + * the value to add + */ + public boolean addValueIfNotContains(E value); + /** * Removes a single value from the {@link List} of values * @@ -73,4 +81,14 @@ public interface ListParameter extends Parameter> { * @return true if the list of values contains the given element, false if not */ public boolean contains(E value); + + /** + * Returns true if the list of values contains all of the given elements, false if not + * + * @param values + * the values to check if they are contained in the list of values + * + * @return true if the list of values contains all of the given elements, false if not + */ + public boolean containsAll(List values); } diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/LongListParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/LongListParameter.java index ae16bcc40..7cfe392ba 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/LongListParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/LongListParameter.java @@ -91,6 +91,12 @@ public class LongListParameter extends AbstractParameter> implements this.value = new ArrayList<>(value); } + @Override + public void setValue(Parameter> parameter) { + assertNotReadonly(); + this.value = new ArrayList<>(parameter.getValue()); + } + @Override public void setValueFromString(String valueAsString) { setValue(parseFromString(valueAsString)); @@ -102,6 +108,17 @@ public class LongListParameter extends AbstractParameter> implements this.value.add(value); } + @Override + public boolean addValueIfNotContains(Long value) { + assertNotReadonly(); + + if (this.value.contains(value)) + return false; + + this.value.add(value); + return true; + } + @Override public boolean removeValue(Long value) { assertNotReadonly(); @@ -119,6 +136,16 @@ public class LongListParameter extends AbstractParameter> implements return this.value.isEmpty(); } + @Override + public boolean isEqualTo(Parameter> otherValue) { + return this.value.equals(otherValue.getValue()); + } + + @Override + public boolean isEqualTo(List otherValue) { + return this.value.equals(otherValue); + } + @Override public int size() { return this.value.size(); @@ -129,6 +156,11 @@ public class LongListParameter extends AbstractParameter> implements return this.value.contains(value); } + @Override + public boolean containsAll(List values) { + return this.value.containsAll(values); + } + @Override public String getType() { return StrolchValueType.LONG_LIST.getType(); diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/LongParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/LongParameter.java index 07acfb094..95a1d110c 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/LongParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/LongParameter.java @@ -68,8 +68,14 @@ public class LongParameter extends AbstractParameter { this.value = value; } + @Override + public void setValue(Parameter parameter) { + assertNotReadonly(); + this.value = parameter.getValue(); + } + /** - * Sets the value to 0 + * Sets the value to 0L * * @see Parameter#clear() */ @@ -79,11 +85,54 @@ public class LongParameter extends AbstractParameter { this.value = 0L; } + /** + * @return true if the value == 0L + */ @Override public boolean isEmpty() { return this.value == 0L; } + @Override + public boolean isEqualTo(Parameter otherValue) { + return this.value.equals(otherValue.getValue()); + } + + @Override + public boolean isEqualTo(Long otherValue) { + return this.value.equals(otherValue); + } + + public void add(long value) { + assertNotReadonly(); + this.value += value; + } + + public void subtract(long value) { + assertNotReadonly(); + this.value -= value; + } + + public void multiply(long value) { + assertNotReadonly(); + this.value *= value; + } + + public void divide(long value) { + assertNotReadonly(); + this.value /= value; + } + + public void increment() { + assertNotReadonly(); + this.value++; + } + + public void decrement() { + assertNotReadonly(); + this.value--; + } + @Override public void setValueFromString(String valueAsString) { setValue(parseFromString(valueAsString)); diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/Parameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/Parameter.java index b7533920f..9ad021617 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/Parameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/Parameter.java @@ -48,24 +48,52 @@ public interface Parameter extends StrolchElement, Comparable> { public U getValue(); /** - * the value of the parameter + * set the value of the parameter * * @param value * the new value */ public void setValue(T value); + /** + * set the value of the parameter from another value, i.e. copying the value + * + * @param parameter + * the parameter from which to copy the new value + */ + public void setValue(Parameter parameter); + /** * Clears the value, dependent on the concrete class */ public void clear(); /** - * @return true if the value is empty, i.e. if the value is the same as the value which would be set if - * {@link #clear()} was called + * @return true if the value is empty, i.e. if the value is the same as the value which would be set if {@link + * #clear()} was called */ public boolean isEmpty(); + /** + * Returns true if the given parameter's value is equal to the current value + * + * @param otherValue + * the value to check on equality + * + * @return true if the given parameter's value is equal to the current value + */ + public boolean isEqualTo(Parameter otherValue); + + /** + * Returns true if the given value is equal to the current value + * + * @param otherValue + * the value to check on equality + * + * @return true if the given value is equal to the current value + */ + public boolean isEqualTo(T otherValue); + /** * get the hidden attribute * diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/StringListParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/StringListParameter.java index 6c669083b..45c0ecdde 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/StringListParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/StringListParameter.java @@ -91,6 +91,12 @@ public class StringListParameter extends AbstractParameter> impleme this.value = new ArrayList<>(value); } + @Override + public void setValue(Parameter> parameter) { + assertNotReadonly(); + this.value = new ArrayList<>(parameter.getValue()); + } + @Override public void setValueFromString(String valueAsString) { setValue(parseFromString(valueAsString)); @@ -102,6 +108,17 @@ public class StringListParameter extends AbstractParameter> impleme this.value.add(value); } + @Override + public boolean addValueIfNotContains(String value) { + assertNotReadonly(); + + if (this.value.contains(value)) + return false; + + this.value.add(value); + return true; + } + @Override public boolean removeValue(String value) { assertNotReadonly(); @@ -119,6 +136,16 @@ public class StringListParameter extends AbstractParameter> impleme return this.value.isEmpty(); } + @Override + public boolean isEqualTo(Parameter> otherValue) { + return this.value.equals(otherValue.getValue()); + } + + @Override + public boolean isEqualTo(List otherValue) { + return this.value.equals(otherValue); + } + @Override public int size() { return this.value.size(); @@ -129,6 +156,11 @@ public class StringListParameter extends AbstractParameter> impleme return this.value.contains(value); } + @Override + public boolean containsAll(List values) { + return this.value.containsAll(values); + } + @Override public String getType() { return StrolchValueType.STRING_LIST.getType(); diff --git a/li.strolch.model/src/main/java/li/strolch/model/parameter/StringParameter.java b/li.strolch.model/src/main/java/li/strolch/model/parameter/StringParameter.java index 3dc03f2a6..01cb46eeb 100644 --- a/li.strolch.model/src/main/java/li/strolch/model/parameter/StringParameter.java +++ b/li.strolch.model/src/main/java/li/strolch/model/parameter/StringParameter.java @@ -78,6 +78,12 @@ public class StringParameter extends AbstractParameter { this.value = value; } + @Override + public void setValue(Parameter parameter) { + assertNotReadonly(); + this.value = parameter.getValue(); + } + /** * Sets the value to the empty string * @@ -92,10 +98,21 @@ public class StringParameter extends AbstractParameter { /** * @return true if the string is empty */ + @Override public boolean isEmpty() { return this.value.isEmpty(); } + @Override + public boolean isEqualTo(Parameter otherValue) { + return this.value.equals(otherValue.getValue()); + } + + @Override + public boolean isEqualTo(String otherValue) { + return this.value.equals(otherValue); + } + @Override public void setValueFromString(String valueAsString) { setValue(valueAsString); @@ -122,5 +139,4 @@ public class StringParameter extends AbstractParameter { DBC.PRE.assertEquals("Not same Parameter types!", this.getType(), o.getType()); return this.getValue().compareToIgnoreCase(((StringParameter) o).getValue()); } - } diff --git a/li.strolch.model/src/test/java/li/strolch/model/parameter/ParameterTest.java b/li.strolch.model/src/test/java/li/strolch/model/parameter/ParameterTest.java new file mode 100644 index 000000000..5244e4b51 --- /dev/null +++ b/li.strolch.model/src/test/java/li/strolch/model/parameter/ParameterTest.java @@ -0,0 +1,316 @@ +package li.strolch.model.parameter; + +import static java.util.Arrays.asList; +import static java.util.Collections.emptyList; +import static li.strolch.model.ModelGenerator.*; +import static org.junit.Assert.*; + +import java.time.LocalDateTime; +import java.time.ZonedDateTime; +import java.util.Date; + +import li.strolch.model.ModelGenerator; +import li.strolch.model.Resource; +import li.strolch.utils.iso8601.ISO8601FormatFactory; +import org.junit.Before; +import org.junit.Test; + +public class ParameterTest { + + private Resource resource; + + @Before + public void before() { + this.resource = ModelGenerator.createResource("test", "Test", "Test"); + } + + @Test + public void testStringParam() { + + StringParameter other = new StringParameter("other", "other", "ab"); + StringParameter p = resource.getParameter(BAG_ID, PARAM_STRING_ID, true); + + assertEquals("Strolch", p.getValue()); + + p.clear(); + assertTrue(p.isEmpty()); + assertEquals("", p.getValue()); + + p.setValue(other); + assertTrue(p.isEqualTo(other.getValue())); + assertTrue(p.isEqualTo(other)); + } + + @Test + public void testIntegerParam() { + + IntegerParameter other = new IntegerParameter("other", "other", 42); + IntegerParameter p = resource.getParameter(BAG_ID, PARAM_INTEGER_ID, true); + + assertEquals(Integer.valueOf(77), p.getValue()); + + p.clear(); + assertTrue(p.isEmpty()); + assertEquals(Integer.valueOf(0), p.getValue()); + + p.setValue(other); + assertTrue(p.isEqualTo(other.getValue())); + assertTrue(p.isEqualTo(other)); + + p.add(2); + assertEquals(Integer.valueOf(44), p.getValue()); + p.subtract(1); + assertEquals(Integer.valueOf(43), p.getValue()); + p.multiply(2); + assertEquals(Integer.valueOf(86), p.getValue()); + p.divide(2); + assertEquals(Integer.valueOf(43), p.getValue()); + p.increment(); + assertEquals(Integer.valueOf(44), p.getValue()); + p.decrement(); + assertEquals(Integer.valueOf(43), p.getValue()); + } + + @Test + public void testLongParam() { + + LongParameter other = new LongParameter("other", "other", 4242424242424242L); + LongParameter p = resource.getParameter(BAG_ID, PARAM_LONG_ID, true); + + assertEquals(Long.valueOf(4453234566L), p.getValue()); + + p.clear(); + assertTrue(p.isEmpty()); + assertEquals(Long.valueOf(0L), p.getValue()); + + p.setValue(other); + assertTrue(p.isEqualTo(other.getValue())); + assertTrue(p.isEqualTo(other)); + + p.add(2); + assertEquals(Long.valueOf(4242424242424244L), p.getValue()); + p.subtract(1); + assertEquals(Long.valueOf(4242424242424243L), p.getValue()); + p.multiply(2); + assertEquals(Long.valueOf(8484848484848486L), p.getValue()); + p.divide(2); + assertEquals(Long.valueOf(4242424242424243L), p.getValue()); + p.increment(); + assertEquals(Long.valueOf(4242424242424244L), p.getValue()); + p.decrement(); + assertEquals(Long.valueOf(4242424242424243L), p.getValue()); + } + + @Test + public void testBooleanParam() { + + BooleanParameter other = new BooleanParameter("other", "other", true); + BooleanParameter p = resource.getParameter(BAG_ID, PARAM_BOOLEAN_ID, true); + + assertEquals(Boolean.TRUE, p.getValue()); + + p.clear(); + assertTrue(p.isEmpty()); + assertEquals(Boolean.FALSE, p.getValue()); + + p.setValue(other); + assertTrue(p.isEqualTo(other.getValue())); + assertTrue(p.isEqualTo(other)); + + p.flip(); + assertEquals(Boolean.FALSE, p.getValue()); + } + + @Test + public void testFloatParam() { + + FloatParameter other = new FloatParameter("other", "other", 42.42D); + FloatParameter p = resource.getParameter(BAG_ID, PARAM_FLOAT_ID, true); + + assertEquals(Double.valueOf(44.3), p.getValue()); + + p.clear(); + assertTrue(p.isEmpty()); + assertEquals(Double.valueOf(0.0D), p.getValue()); + + p.setValue(other); + assertTrue(p.isEqualTo(other.getValue())); + assertTrue(p.isEqualTo(other)); + + p.add(2.1D); + assertEquals(Double.valueOf(44.52D), p.getValue()); + p.subtract(1.2D); + assertEquals(Double.valueOf(43.32D), p.getValue()); + p.multiply(2.2D); + assertEquals(Double.valueOf(95.304D), p.getValue()); + p.divide(2.4D); + assertEquals(Double.valueOf(39.71D), p.getValue()); + p.increment(); + assertEquals(Double.valueOf(40.71D), p.getValue()); + p.decrement(); + assertEquals(Double.valueOf(39.71D), p.getValue()); + } + + @Test + public void testDateParam() { + + DateParameter other = new DateParameter("other", "other", new Date(42L)); + DateParameter p = resource.getParameter(BAG_ID, PARAM_DATE_ID, true); + + assertEquals(new Date(1354295525628L), p.getValue()); + + p.clear(); + assertTrue(p.isEmpty()); + assertEquals(new Date(0L), p.getValue()); + + p.setValue(other); + assertTrue(p.isEqualTo(other.getValue())); + assertTrue(p.isEqualTo(other)); + + LocalDateTime now = LocalDateTime.now(); + p.setValueFromLocalDateTime(now); + LocalDateTime localDateTime = p.toLocalDateTime(); + assertEquals(now, localDateTime); + + assertTrue(p.isEqualTo(now)); + + ZonedDateTime now1 = ZonedDateTime.now(); + p.setValueFromZonedDateTime(now1); + ZonedDateTime zonedDateTime = p.toZonedDateTime(); + assertEquals(now1, zonedDateTime); + assertTrue(p.isEqualTo(now1)); + } + + @Test + public void testDurationParam() { + + DurationParameter other = new DurationParameter("other", "other", 42L); + DurationParameter p = resource.getParameter(BAG_ID, PARAM_DURATION_ID, true); + + assertEquals(Long.valueOf(ISO8601FormatFactory.getInstance().getDurationFormat().parse("P1D")), p.getValue()); + + p.clear(); + assertTrue(p.isEmpty()); + assertEquals(Long.valueOf(0L), p.getValue()); + + p.setValue(other); + assertTrue(p.isEqualTo(other.getValue())); + assertTrue(p.isEqualTo(other)); + } + + @Test + public void testStringListParam() { + + StringListParameter other = new StringListParameter("other", "other", asList("ab", "ba")); + StringListParameter p = resource.getParameter(BAG_ID, PARAM_LIST_STRING_ID, true); + + assertEquals(asList("Hello", "World"), p.getValue()); + + p.clear(); + assertTrue(p.isEmpty()); + assertEquals(emptyList(), p.getValue()); + + p.setValue(other); + assertTrue(p.isEqualTo(other.getValue())); + assertTrue(p.isEqualTo(other)); + + p.addValue("ca"); + assertEquals(asList("ab", "ba", "ca"), p.getValue()); + p.removeValue("ba"); + assertEquals(asList("ab", "ca"), p.getValue()); + assertTrue(p.contains("ab")); + assertFalse(p.contains("ba")); + + p.addValueIfNotContains("ba"); + p.addValueIfNotContains("ba"); + assertTrue(p.containsAll(asList("ab", "ba", "ca"))); + assertEquals(asList("ab", "ca", "ba"), p.getValue()); + } + + @Test + public void testIntegerListParam() { + + IntegerListParameter other = new IntegerListParameter("other", "other", asList(42, 43)); + IntegerListParameter p = resource.getParameter(BAG_ID, PARAM_LIST_INTEGER_ID, true); + + assertEquals(asList(5, 10, 15), p.getValue()); + + p.clear(); + assertTrue(p.isEmpty()); + assertEquals(emptyList(), p.getValue()); + + p.setValue(other); + assertTrue(p.isEqualTo(other.getValue())); + assertTrue(p.isEqualTo(other)); + + p.addValue(44); + assertEquals(asList(42, 43, 44), p.getValue()); + p.removeValue(43); + assertEquals(asList(42, 44), p.getValue()); + assertTrue(p.contains(44)); + assertFalse(p.contains(43)); + + p.addValueIfNotContains(43); + p.addValueIfNotContains(43); + assertTrue(p.containsAll(asList(42, 43, 44))); + assertEquals(asList(42, 44, 43), p.getValue()); + } + + @Test + public void testLongListParam() { + + LongListParameter other = new LongListParameter("other", "other", asList(4242424242424242L, 4343434343434343L)); + LongListParameter p = resource.getParameter(BAG_ID, PARAM_LIST_LONG_ID, true); + + assertEquals(asList(7L, 12L, 17L), p.getValue()); + + p.clear(); + assertTrue(p.isEmpty()); + assertEquals(emptyList(), p.getValue()); + + p.setValue(other); + assertTrue(p.isEqualTo(other.getValue())); + assertTrue(p.isEqualTo(other)); + + p.addValue(5656565656565656L); + assertEquals(asList(4242424242424242L, 4343434343434343L, 5656565656565656L), p.getValue()); + p.removeValue(4343434343434343L); + assertEquals(asList(4242424242424242L, 5656565656565656L), p.getValue()); + assertTrue(p.contains(5656565656565656L)); + assertFalse(p.contains(4343434343434343L)); + + p.addValueIfNotContains(4343434343434343L); + p.addValueIfNotContains(4343434343434343L); + assertTrue(p.containsAll(asList(4242424242424242L, 5656565656565656L, 4343434343434343L))); + assertEquals(asList(4242424242424242L, 5656565656565656L, 4343434343434343L), p.getValue()); + } + + @Test + public void testFloatListParam() { + + FloatListParameter other = new FloatListParameter("other", "other", asList(42.42D, 43.43D)); + FloatListParameter p = resource.getParameter(BAG_ID, PARAM_LIST_FLOAT_ID, true); + + assertEquals(asList(6.0, 11.0, 16.0), p.getValue()); + + p.clear(); + assertTrue(p.isEmpty()); + assertEquals(emptyList(), p.getValue()); + + p.setValue(other); + assertTrue(p.isEqualTo(other.getValue())); + assertTrue(p.isEqualTo(other)); + + p.addValue(88.88D); + assertEquals(asList(42.42D, 43.43D, 88.88D), p.getValue()); + p.removeValue(43.43D); + assertEquals(asList(42.42D, 88.88D), p.getValue()); + assertTrue(p.contains(88.88D)); + assertFalse(p.contains(43.43D)); + + p.addValueIfNotContains(43.43D); + p.addValueIfNotContains(43.43D); + assertTrue(p.containsAll(asList(42.42D, 88.88D, 43.43D))); + assertEquals(asList(42.42D, 88.88D, 43.43D), p.getValue()); + } +}