diff --git a/core/src/main/java/zingg/hash/HashFunctionRegistry.java b/core/src/main/java/zingg/hash/HashFunctionRegistry.java index 28f8a0e5e..05c3cb504 100644 --- a/core/src/main/java/zingg/hash/HashFunctionRegistry.java +++ b/core/src/main/java/zingg/hash/HashFunctionRegistry.java @@ -22,10 +22,29 @@ public static HashFunction getFunction(String key) { init(new Last2Chars()); init(new Last3Chars()); init(new Round()); + init(new TruncateDoubleTo1Place()); + init(new TruncateDoubleTo2Places()); + init(new TruncateDoubleTo3Places()); init(new LastWord()); init(new First2CharsBox()); init(new First3CharsBox()); init(new IsNullOrEmpty()); + init(new LessThanZeroDbl()); + init(new LessThanZeroInt()); + init(new TrimLast1DigitDbl()); + init(new TrimLast2DigitsDbl()); + init(new TrimLast3DigitsDbl()); + init(new TrimLast1DigitInt()); + init(new TrimLast2DigitsInt()); + init(new TrimLast3DigitsInt()); + init(new RangeBetween0And10Int()); + init(new RangeBetween10And100Int()); + init(new RangeBetween100And1000Int()); + init(new RangeBetween1000And10000Int()); + init(new RangeBetween0And10Dbl()); + init(new RangeBetween10And100Dbl()); + init(new RangeBetween100And1000Dbl()); + init(new RangeBetween1000And10000Dbl()); } public static void init(HashFunction fn) { diff --git a/core/src/main/java/zingg/hash/LessThanZeroDbl.java b/core/src/main/java/zingg/hash/LessThanZeroDbl.java new file mode 100644 index 000000000..57310962b --- /dev/null +++ b/core/src/main/java/zingg/hash/LessThanZeroDbl.java @@ -0,0 +1,25 @@ +package zingg.hash; + +import org.apache.spark.sql.Row; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.types.DataTypes; + +public class LessThanZeroDbl extends HashFunction implements UDF1 { + public LessThanZeroDbl() { + super("lessThanZeroDbl", DataTypes.DoubleType, DataTypes.BooleanType, true); + } + + @Override + public Boolean call(Double field) { + Boolean r = false; + if (field != null) { + r = field < 0 ? true : false; + } + return r; + } + + public Object apply(Row ds, String column) { + return call((Double) ds.getAs(column)); + } + +} diff --git a/core/src/main/java/zingg/hash/LessThanZeroInt.java b/core/src/main/java/zingg/hash/LessThanZeroInt.java new file mode 100644 index 000000000..e68f46dbe --- /dev/null +++ b/core/src/main/java/zingg/hash/LessThanZeroInt.java @@ -0,0 +1,25 @@ +package zingg.hash; + +import org.apache.spark.sql.Row; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.types.DataTypes; + +public class LessThanZeroInt extends HashFunction implements UDF1 { + public LessThanZeroInt() { + super("lessThanZeroInt", DataTypes.IntegerType, DataTypes.BooleanType, true); + } + + @Override + public Boolean call(Integer field) { + Boolean r = false; + if (field != null) { + r = field < 0 ? true : false; + } + return r; + } + + public Object apply(Row ds, String column) { + return call((Integer) ds.getAs(column)); + } + +} diff --git a/core/src/main/java/zingg/hash/RangeBetween0And10Dbl.java b/core/src/main/java/zingg/hash/RangeBetween0And10Dbl.java new file mode 100644 index 000000000..fe0f09a74 --- /dev/null +++ b/core/src/main/java/zingg/hash/RangeBetween0And10Dbl.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class RangeBetween0And10Dbl extends RangeDbl { + + public RangeBetween0And10Dbl() { + super(0, 10); + } + +} diff --git a/core/src/main/java/zingg/hash/RangeBetween0And10Int.java b/core/src/main/java/zingg/hash/RangeBetween0And10Int.java new file mode 100644 index 000000000..8c1dfdde2 --- /dev/null +++ b/core/src/main/java/zingg/hash/RangeBetween0And10Int.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class RangeBetween0And10Int extends RangeInt { + + public RangeBetween0And10Int() { + super(0, 10); + } + +} diff --git a/core/src/main/java/zingg/hash/RangeBetween1000And10000Dbl.java b/core/src/main/java/zingg/hash/RangeBetween1000And10000Dbl.java new file mode 100644 index 000000000..7fe507e7b --- /dev/null +++ b/core/src/main/java/zingg/hash/RangeBetween1000And10000Dbl.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class RangeBetween1000And10000Dbl extends RangeDbl { + + public RangeBetween1000And10000Dbl() { + super(1000, 10000); + } + +} diff --git a/core/src/main/java/zingg/hash/RangeBetween1000And10000Int.java b/core/src/main/java/zingg/hash/RangeBetween1000And10000Int.java new file mode 100644 index 000000000..feec81ca5 --- /dev/null +++ b/core/src/main/java/zingg/hash/RangeBetween1000And10000Int.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class RangeBetween1000And10000Int extends RangeInt { + + public RangeBetween1000And10000Int() { + super(1000, 10000); + } + +} diff --git a/core/src/main/java/zingg/hash/RangeBetween100And1000Dbl.java b/core/src/main/java/zingg/hash/RangeBetween100And1000Dbl.java new file mode 100644 index 000000000..5cfc467f8 --- /dev/null +++ b/core/src/main/java/zingg/hash/RangeBetween100And1000Dbl.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class RangeBetween100And1000Dbl extends RangeDbl { + + public RangeBetween100And1000Dbl() { + super(100, 1000); + } + +} diff --git a/core/src/main/java/zingg/hash/RangeBetween100And1000Int.java b/core/src/main/java/zingg/hash/RangeBetween100And1000Int.java new file mode 100644 index 000000000..065e0e413 --- /dev/null +++ b/core/src/main/java/zingg/hash/RangeBetween100And1000Int.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class RangeBetween100And1000Int extends RangeInt { + + public RangeBetween100And1000Int() { + super(100, 1000); + } + +} diff --git a/core/src/main/java/zingg/hash/RangeBetween10And100Dbl.java b/core/src/main/java/zingg/hash/RangeBetween10And100Dbl.java new file mode 100644 index 000000000..9e3adc031 --- /dev/null +++ b/core/src/main/java/zingg/hash/RangeBetween10And100Dbl.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class RangeBetween10And100Dbl extends RangeDbl { + + public RangeBetween10And100Dbl() { + super(10, 100); + } + +} diff --git a/core/src/main/java/zingg/hash/RangeBetween10And100Int.java b/core/src/main/java/zingg/hash/RangeBetween10And100Int.java new file mode 100644 index 000000000..36d4baa7e --- /dev/null +++ b/core/src/main/java/zingg/hash/RangeBetween10And100Int.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class RangeBetween10And100Int extends RangeInt { + + public RangeBetween10And100Int() { + super(10, 100); + } + +} diff --git a/core/src/main/java/zingg/hash/RangeDbl.java b/core/src/main/java/zingg/hash/RangeDbl.java new file mode 100644 index 000000000..e6a035f42 --- /dev/null +++ b/core/src/main/java/zingg/hash/RangeDbl.java @@ -0,0 +1,30 @@ +package zingg.hash; + +import org.apache.spark.sql.Row; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.types.DataTypes; + +public class RangeDbl extends HashFunction implements UDF1 { + int lowerLimit; + int upperLimit; + + public RangeDbl(int lower, int upper) { + super("rangeBetween" + lower + "And" + upper + "Dbl", DataTypes.DoubleType, DataTypes.IntegerType, true); + this.lowerLimit = lower; + this.upperLimit = upper; + } + + @Override + public Integer call(Double field) { + int withinRange = 0; + if (field >= lowerLimit && field < upperLimit) { + withinRange = 1; + } + return withinRange; + } + + public Object apply(Row ds, String column) { + return call((Double) ds.getAs(column)); + } + +} diff --git a/core/src/main/java/zingg/hash/RangeInt.java b/core/src/main/java/zingg/hash/RangeInt.java new file mode 100644 index 000000000..7fe8ab279 --- /dev/null +++ b/core/src/main/java/zingg/hash/RangeInt.java @@ -0,0 +1,30 @@ +package zingg.hash; + +import org.apache.spark.sql.Row; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.types.DataTypes; + +public class RangeInt extends HashFunction implements UDF1 { + int lowerLimit; + int upperLimit; + + public RangeInt(int lower, int upper) { + super("rangeBetween" + lower + "And" + upper + "Int", DataTypes.IntegerType, DataTypes.IntegerType, true); + this.lowerLimit = lower; + this.upperLimit = upper; + } + + @Override + public Integer call(Integer field) { + int withinRange = 0; + if (field >= lowerLimit && field < upperLimit) { + withinRange = 1; + } + return withinRange; + } + + public Object apply(Row ds, String column) { + return call((Integer) ds.getAs(column)); + } + +} diff --git a/core/src/main/java/zingg/hash/TrimLast1DigitDbl.java b/core/src/main/java/zingg/hash/TrimLast1DigitDbl.java new file mode 100644 index 000000000..d38eb9882 --- /dev/null +++ b/core/src/main/java/zingg/hash/TrimLast1DigitDbl.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class TrimLast1DigitDbl extends TrimLastDigitsDbl { + + public TrimLast1DigitDbl() { + super(1); + } + +} diff --git a/core/src/main/java/zingg/hash/TrimLast1DigitInt.java b/core/src/main/java/zingg/hash/TrimLast1DigitInt.java new file mode 100644 index 000000000..b941bf0cc --- /dev/null +++ b/core/src/main/java/zingg/hash/TrimLast1DigitInt.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class TrimLast1DigitInt extends TrimLastDigitsInt { + + public TrimLast1DigitInt() { + super(1); + } + +} diff --git a/core/src/main/java/zingg/hash/TrimLast2DigitsDbl.java b/core/src/main/java/zingg/hash/TrimLast2DigitsDbl.java new file mode 100644 index 000000000..de5674419 --- /dev/null +++ b/core/src/main/java/zingg/hash/TrimLast2DigitsDbl.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class TrimLast2DigitsDbl extends TrimLastDigitsDbl { + + public TrimLast2DigitsDbl() { + super(2); + } + +} diff --git a/core/src/main/java/zingg/hash/TrimLast2DigitsInt.java b/core/src/main/java/zingg/hash/TrimLast2DigitsInt.java new file mode 100644 index 000000000..089a24072 --- /dev/null +++ b/core/src/main/java/zingg/hash/TrimLast2DigitsInt.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class TrimLast2DigitsInt extends TrimLastDigitsInt { + + public TrimLast2DigitsInt() { + super(2); + } + +} diff --git a/core/src/main/java/zingg/hash/TrimLast3DigitsDbl.java b/core/src/main/java/zingg/hash/TrimLast3DigitsDbl.java new file mode 100644 index 000000000..50262c34c --- /dev/null +++ b/core/src/main/java/zingg/hash/TrimLast3DigitsDbl.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class TrimLast3DigitsDbl extends TrimLastDigitsDbl { + + public TrimLast3DigitsDbl() { + super(3); + } + +} diff --git a/core/src/main/java/zingg/hash/TrimLast3DigitsInt.java b/core/src/main/java/zingg/hash/TrimLast3DigitsInt.java new file mode 100644 index 000000000..2c5ed5942 --- /dev/null +++ b/core/src/main/java/zingg/hash/TrimLast3DigitsInt.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class TrimLast3DigitsInt extends TrimLastDigitsInt { + + public TrimLast3DigitsInt() { + super(3); + } + +} diff --git a/core/src/main/java/zingg/hash/TrimLastDigitsDbl.java b/core/src/main/java/zingg/hash/TrimLastDigitsDbl.java new file mode 100644 index 000000000..aace59a72 --- /dev/null +++ b/core/src/main/java/zingg/hash/TrimLastDigitsDbl.java @@ -0,0 +1,30 @@ +package zingg.hash; + +import org.apache.spark.sql.Row; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.types.DataTypes; + +public class TrimLastDigitsDbl extends HashFunction implements UDF1 { + int numDigits; + static final int[] POWERS_OF_10 = {1, 10, 100, 1000, 10000, 100000}; + public TrimLastDigitsDbl(int count) { + super("trimLast" + count + "DigitsDbl", DataTypes.DoubleType, DataTypes.DoubleType, true); + this.numDigits = count; + } + + @Override + public Double call(Double field) { + Double r = null; + if (field == null) { + r = field; + } else { + r = Math.floor(field / POWERS_OF_10[numDigits]); + } + return r; + } + + public Object apply(Row ds, String column) { + return call((Double) ds.getAs(column)); + } + +} diff --git a/core/src/main/java/zingg/hash/TrimLastDigitsInt.java b/core/src/main/java/zingg/hash/TrimLastDigitsInt.java new file mode 100644 index 000000000..b0c4556c3 --- /dev/null +++ b/core/src/main/java/zingg/hash/TrimLastDigitsInt.java @@ -0,0 +1,30 @@ +package zingg.hash; + +import org.apache.spark.sql.Row; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.types.DataTypes; + +public class TrimLastDigitsInt extends HashFunction implements UDF1 { + int numDigits; + static final int[] POWERS_OF_10 = {1, 10, 100, 1000, 10000, 100000}; + public TrimLastDigitsInt(int count) { + super("trimLast" + count + "DigitsInt", DataTypes.IntegerType, DataTypes.IntegerType, true); + this.numDigits = count; + } + + @Override + public Integer call(Integer field) { + Integer r = null; + if (field == null) { + r = field; + } else { + r = field / POWERS_OF_10[numDigits]; + } + return r; + } + + public Object apply(Row ds, String column) { + return call((Integer) ds.getAs(column)); + } + +} diff --git a/core/src/main/java/zingg/hash/TruncateDouble.java b/core/src/main/java/zingg/hash/TruncateDouble.java new file mode 100644 index 000000000..f7640d349 --- /dev/null +++ b/core/src/main/java/zingg/hash/TruncateDouble.java @@ -0,0 +1,31 @@ +package zingg.hash; + +import org.apache.spark.sql.Row; +import org.apache.spark.sql.api.java.UDF1; +import org.apache.spark.sql.types.DataTypes; + +public class TruncateDouble extends HashFunction implements UDF1 { + int numDecimalPlaces; + static final int[] POWERS_OF_10 = {1, 10, 100, 1000, 10000, 100000}; + public TruncateDouble(int numDecimalPlaces) { + super("truncateDoubleTo" + numDecimalPlaces + "Places", DataTypes.DoubleType, DataTypes.DoubleType, true); + this.numDecimalPlaces = numDecimalPlaces; + } + + @Override + public Double call(Double field) { + Double r = null; + if (field == null) { + r = field; + } else { + r = Math.floor(field * POWERS_OF_10[numDecimalPlaces]) / POWERS_OF_10[numDecimalPlaces]; + } + return r; + } + + @Override + public Object apply(Row ds, String column) { + return call((Double) ds.getAs(column)); + } + +} diff --git a/core/src/main/java/zingg/hash/TruncateDoubleTo1Place.java b/core/src/main/java/zingg/hash/TruncateDoubleTo1Place.java new file mode 100644 index 000000000..a31372b6a --- /dev/null +++ b/core/src/main/java/zingg/hash/TruncateDoubleTo1Place.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class TruncateDoubleTo1Place extends TruncateDouble { + + public TruncateDoubleTo1Place() { + super(1); + } + +} diff --git a/core/src/main/java/zingg/hash/TruncateDoubleTo2Places.java b/core/src/main/java/zingg/hash/TruncateDoubleTo2Places.java new file mode 100644 index 000000000..2c7c7a462 --- /dev/null +++ b/core/src/main/java/zingg/hash/TruncateDoubleTo2Places.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class TruncateDoubleTo2Places extends TruncateDouble { + + public TruncateDoubleTo2Places() { + super(2); + } + +} diff --git a/core/src/main/java/zingg/hash/TruncateDoubleTo3Places.java b/core/src/main/java/zingg/hash/TruncateDoubleTo3Places.java new file mode 100644 index 000000000..2ab88f70e --- /dev/null +++ b/core/src/main/java/zingg/hash/TruncateDoubleTo3Places.java @@ -0,0 +1,9 @@ +package zingg.hash; + +public class TruncateDoubleTo3Places extends TruncateDouble { + + public TruncateDoubleTo3Places() { + super(3); + } + +} diff --git a/core/src/main/resources/hashFunctions.json b/core/src/main/resources/hashFunctions.json index dc84ddce7..41686cc71 100644 --- a/core/src/main/resources/hashFunctions.json +++ b/core/src/main/resources/hashFunctions.json @@ -40,6 +40,63 @@ { "name":"identityInteger" }, +{ + "name":"truncateDoubleTo1Places" +}, +{ + "name":"truncateDoubleTo2Places" +}, +{ + "name":"truncateDoubleTo3Places" +}, +{ + "name":"lessThanZeroDbl" +}, +{ + "name":"lessThanZeroInt" +}, +{ + "name":"trimLast1DigitsDbl" +}, +{ + "name":"trimLast2DigitsDbl" +}, +{ + "name":"trimLast3DigitsDbl" +}, +{ + "name":"trimLast1DigitsInt" +}, +{ + "name":"trimLast2DigitsInt" +}, +{ + "name":"trimLast3DigitsInt" +}, +{ + "name":"rangeBetween0And10Int" +}, +{ + "name":"rangeBetween0And10Dbl" +}, +{ + "name":"rangeBetween10And100Int" +}, +{ + "name":"rangeBetween10And100Dbl" +}, +{ + "name":"rangeBetween100And1000Int" +}, +{ + "name":"rangeBetween100And1000Dbl" +}, +{ + "name":"rangeBetween1000And10000Int" +}, +{ + "name":"rangeBetween1000And10000Dbl" +}, { "name":"round" } diff --git a/core/src/test/java/zingg/hash/TestLessThanZeroDbl.java b/core/src/test/java/zingg/hash/TestLessThanZeroDbl.java new file mode 100644 index 000000000..44f8b9e42 --- /dev/null +++ b/core/src/test/java/zingg/hash/TestLessThanZeroDbl.java @@ -0,0 +1,40 @@ +package zingg.hash; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class TestLessThanZeroDbl { + + @Test + public void testLessThanZeroDblForValueZero() { + LessThanZeroDbl value = new LessThanZeroDbl(); + assertFalse(value.call(0d)); + } + + @Test + public void testLessThanZeroDblForValueNaN() { + LessThanZeroDbl value = new LessThanZeroDbl(); + assertFalse(value.call(Double.NaN)); + } + + @Test + public void testLessThanZeroDblForValueNull() { + LessThanZeroDbl value = new LessThanZeroDbl(); + assertFalse(value.call(null)); + } + + @Test + public void testLessThanZeroDblForPositiveDoubleValue() { + LessThanZeroDbl value = new LessThanZeroDbl(); + assertFalse(value.call(543534.67734)); + } + + @Test + public void testLessThanZeroDblNegativeDoubleValue() { + LessThanZeroDbl value = new LessThanZeroDbl(); + assertTrue(value.call(-543534.67734)); + } + +} diff --git a/core/src/test/java/zingg/hash/TestLessThanZeroInt.java b/core/src/test/java/zingg/hash/TestLessThanZeroInt.java new file mode 100644 index 000000000..ae64648f6 --- /dev/null +++ b/core/src/test/java/zingg/hash/TestLessThanZeroInt.java @@ -0,0 +1,34 @@ +package zingg.hash; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class TestLessThanZeroInt { + + @Test + public void testLessThanZeroIntForValueZero() { + LessThanZeroInt value = new LessThanZeroInt(); + assertFalse(value.call(0)); + } + + @Test + public void testLessThanZeroDblForValueNull() { + LessThanZeroDbl value = new LessThanZeroDbl(); + assertFalse(value.call(null)); + } + + @Test + public void testLessThanZeroIntNegativeInteger() { + LessThanZeroInt value = new LessThanZeroInt(); + assertTrue(value.call(-5435)); + } + + @Test + public void testLessThanZeroIntPositiveInteger() { + LessThanZeroInt value = new LessThanZeroInt(); + assertFalse(value.call(5435)); + } + +} diff --git a/core/src/test/java/zingg/hash/TestRangeBetween0And10Dbl.java b/core/src/test/java/zingg/hash/TestRangeBetween0And10Dbl.java new file mode 100644 index 000000000..00467b369 --- /dev/null +++ b/core/src/test/java/zingg/hash/TestRangeBetween0And10Dbl.java @@ -0,0 +1,52 @@ +package zingg.hash; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class TestRangeBetween0And10Dbl { + + @Test + public void testRangeForValueZero() { + RangeDbl value = new RangeBetween0And10Dbl(); + assertEquals(1, value.call(0d)); + } + + @Test + public void testRangeForNegativeValue() { + Double input = -100d; + RangeDbl value = new RangeBetween0And10Dbl(); + assertEquals(0, value.call(input)); + } + + @Test + public void testRangeForVeryHighValue() { + Double input = 999999d; + RangeDbl value = new RangeBetween0And10Dbl(); + assertEquals(0, value.call(input)); + } + + @Test + public void testRangeForValue8() { + RangeDbl value = new RangeBetween0And10Dbl(); + assertEquals(1, value.call(8d)); + } + + @Test + public void testRangeForValue65() { + RangeDbl value = new RangeBetween0And10Dbl(); + assertEquals(0, value.call(65d)); + } + + @Test + public void testRangeForValue867() { + RangeDbl value = new RangeBetween0And10Dbl(); + assertEquals(0, value.call(867d)); + } + @Test + public void testRangeForValue8637() { + RangeDbl value = new RangeBetween0And10Dbl(); + assertEquals(0, value.call(8637d)); + } + +} diff --git a/core/src/test/java/zingg/hash/TestRangeBetween0And10Int.java b/core/src/test/java/zingg/hash/TestRangeBetween0And10Int.java new file mode 100644 index 000000000..e82edd87e --- /dev/null +++ b/core/src/test/java/zingg/hash/TestRangeBetween0And10Int.java @@ -0,0 +1,50 @@ +package zingg.hash; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class TestRangeBetween0And10Int { + + @Test + public void testRangeForValueZero() { + RangeInt value = new RangeBetween0And10Int(); + assertEquals(1, value.call(0)); + } + + @Test + public void testRangeForNegativeValue() { + RangeInt value = new RangeBetween0And10Int(); + assertEquals(0, value.call(-100)); + } + + @Test + public void testRangeForVeryHighValue() { + RangeInt value = new RangeBetween0And10Int(); + assertEquals(0, value.call(999999)); + } + + @Test + public void testRangeForValue8() { + RangeInt value = new RangeBetween0And10Int(); + assertEquals(1, value.call(8)); + } + + @Test + public void testRangeForValue65() { + RangeInt value = new RangeBetween0And10Int(); + assertEquals(0, value.call(65)); + } + + @Test + public void testRangeForValue867() { + RangeInt value = new RangeBetween0And10Int(); + assertEquals(0, value.call(867)); + } + @Test + public void testRangeForValue8637() { + RangeInt value = new RangeBetween0And10Int(); + assertEquals(0, value.call(8637)); + } + +} diff --git a/core/src/test/java/zingg/hash/TestRangeBetween1000And10000Dbl.java b/core/src/test/java/zingg/hash/TestRangeBetween1000And10000Dbl.java new file mode 100644 index 000000000..e782d0d76 --- /dev/null +++ b/core/src/test/java/zingg/hash/TestRangeBetween1000And10000Dbl.java @@ -0,0 +1,52 @@ +package zingg.hash; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class TestRangeBetween1000And10000Dbl { + + @Test + public void testRangeForValueZero() { + RangeDbl value = new RangeBetween1000And10000Dbl(); + assertEquals(0, value.call(0d)); + } + + @Test + public void testRangeForNegativeValue() { + Double input = -100d; + RangeDbl value = new RangeBetween1000And10000Dbl(); + assertEquals(0, value.call(input)); + } + + @Test + public void testRangeForVeryHighValue() { + Double input = 999999d; + RangeDbl value = new RangeBetween1000And10000Dbl(); + assertEquals(0, value.call(input)); + } + + @Test + public void testRangeForValue8() { + RangeDbl value = new RangeBetween1000And10000Dbl(); + assertEquals(0, value.call(8d)); + } + + @Test + public void testRangeForValue65() { + RangeDbl value = new RangeBetween1000And10000Dbl(); + assertEquals(0, value.call(65d)); + } + + @Test + public void testRangeForValue867() { + RangeDbl value = new RangeBetween1000And10000Dbl(); + assertEquals(0, value.call(867d)); + } + @Test + public void testRangeLessThan10000() { + RangeDbl value = new RangeBetween1000And10000Dbl(); + assertEquals(1, value.call(8637d)); + } + +} diff --git a/core/src/test/java/zingg/hash/TestRangeBetween1000And10000Int.java b/core/src/test/java/zingg/hash/TestRangeBetween1000And10000Int.java new file mode 100644 index 000000000..1b56af4d5 --- /dev/null +++ b/core/src/test/java/zingg/hash/TestRangeBetween1000And10000Int.java @@ -0,0 +1,51 @@ +package zingg.hash; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class TestRangeBetween1000And10000Int { + + @Test + public void testRangeForValueZero() { + RangeInt value = new RangeBetween1000And10000Int(); + assertEquals(0, value.call(0)); + } + + @Test + public void testRangeForNegativeValue() { + RangeInt value = new RangeBetween1000And10000Int(); + assertEquals(0, value.call(-100)); + } + + @Test + public void testRangeForVeryHighValue() { + RangeInt value = new RangeBetween1000And10000Int(); + assertEquals(0, value.call(999999)); + } + + @Test + public void testRangeForValue8() { + RangeInt value = new RangeBetween1000And10000Int(); + assertEquals(0, value.call(8)); + } + + @Test + public void testRangeForValue65() { + RangeInt value = new RangeBetween1000And10000Int(); + assertEquals(0, value.call(65)); + } + + @Test + public void testRangeForValue867() { + RangeInt value = new RangeBetween1000And10000Int(); + assertEquals(0, value.call(867)); + } + + @Test + public void testRangeForValue8637() { + RangeInt value = new RangeBetween1000And10000Int(); + assertEquals(1, value.call(8637)); + } + +} diff --git a/core/src/test/java/zingg/hash/TestRangeBetween100And1000Dbl.java b/core/src/test/java/zingg/hash/TestRangeBetween100And1000Dbl.java new file mode 100644 index 000000000..6900f410f --- /dev/null +++ b/core/src/test/java/zingg/hash/TestRangeBetween100And1000Dbl.java @@ -0,0 +1,53 @@ +package zingg.hash; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class TestRangeBetween100And1000Dbl { + + @Test + public void testRangeForValueZero() { + RangeDbl value = new RangeBetween100And1000Dbl(); + assertEquals(0, value.call(0d)); + } + + @Test + public void testRangeForNegativeValue() { + Double input = -100d; + RangeDbl value = new RangeBetween100And1000Dbl(); + assertEquals(0, value.call(input)); + } + + @Test + public void testRangeForVeryHighValue() { + Double input = 999999d; + RangeDbl value = new RangeBetween100And1000Dbl(); + assertEquals(0, value.call(input)); + } + + @Test + public void testRangeForValue8() { + RangeDbl value = new RangeBetween100And1000Dbl(); + assertEquals(0, value.call(8d)); + } + + @Test + public void testRangeForValue65() { + RangeDbl value = new RangeBetween100And1000Dbl(); + assertEquals(0, value.call(65d)); + } + + @Test + public void testRangeForValue867() { + RangeDbl value = new RangeBetween100And1000Dbl(); + assertEquals(1, value.call(867d)); + } + + @Test + public void testRangeForValue8637() { + RangeDbl value = new RangeBetween100And1000Dbl(); + assertEquals(0, value.call(8637d)); + } + +} diff --git a/core/src/test/java/zingg/hash/TestRangeBetween100And1000Int.java b/core/src/test/java/zingg/hash/TestRangeBetween100And1000Int.java new file mode 100644 index 000000000..ff4dd8f58 --- /dev/null +++ b/core/src/test/java/zingg/hash/TestRangeBetween100And1000Int.java @@ -0,0 +1,50 @@ +package zingg.hash; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class TestRangeBetween100And1000Int { + + @Test + public void testRangeForValueZero() { + RangeInt value = new RangeBetween100And1000Int(); + assertEquals(0, value.call(0)); + } + + @Test + public void testRangeForNegativeValue() { + RangeInt value = new RangeBetween100And1000Int(); + assertEquals(0, value.call(-100)); + } + + @Test + public void testRangeForVeryHighValue() { + RangeInt value = new RangeBetween100And1000Int(); + assertEquals(0, value.call(999999)); + } + + @Test + public void testRangeForValue8() { + RangeInt value = new RangeBetween100And1000Int(); + assertEquals(0, value.call(8)); + } + + @Test + public void testRangeForValue65() { + RangeInt value = new RangeBetween100And1000Int(); + assertEquals(0, value.call(65)); + } + + @Test + public void testRangeForValue867() { + RangeInt value = new RangeBetween100And1000Int(); + assertEquals(1, value.call(867)); + } + @Test + public void testRangeForValue8637() { + RangeInt value = new RangeBetween100And1000Int(); + assertEquals(0, value.call(8637)); + } + +} diff --git a/core/src/test/java/zingg/hash/TestRangeBetween10And100Dbl.java b/core/src/test/java/zingg/hash/TestRangeBetween10And100Dbl.java new file mode 100644 index 000000000..5ac178ded --- /dev/null +++ b/core/src/test/java/zingg/hash/TestRangeBetween10And100Dbl.java @@ -0,0 +1,53 @@ +package zingg.hash; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class TestRangeBetween10And100Dbl { + + @Test + public void testRangeForValueZero() { + RangeDbl value = new RangeBetween10And100Dbl(); + assertEquals(0, value.call(0d)); + } + + @Test + public void testRangeForNegativeValue() { + Double input = -100d; + RangeDbl value = new RangeBetween10And100Dbl(); + assertEquals(0, value.call(input)); + + } + + @Test + public void testRangeForVeryHighValue() { + Double input = 999999d; + RangeDbl value = new RangeBetween10And100Dbl(); + assertEquals(0, value.call(input)); + } + + @Test + public void testRangeForValue8() { + RangeDbl value = new RangeBetween10And100Dbl(); + assertEquals(0, value.call(8d)); + } + + @Test + public void testRangeForValue65() { + RangeDbl value = new RangeBetween10And100Dbl(); + assertEquals(1, value.call(65d)); + } + + @Test + public void testRangeForValue867() { + RangeDbl value = new RangeBetween10And100Dbl(); + assertEquals(0, value.call(867d)); + } + @Test + public void testRangeForValue8637() { + RangeDbl value = new RangeBetween10And100Dbl(); + assertEquals(0, value.call(8637d)); + } + +} diff --git a/core/src/test/java/zingg/hash/TestRangeBetween10And100Int.java b/core/src/test/java/zingg/hash/TestRangeBetween10And100Int.java new file mode 100644 index 000000000..b01f26aba --- /dev/null +++ b/core/src/test/java/zingg/hash/TestRangeBetween10And100Int.java @@ -0,0 +1,50 @@ +package zingg.hash; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class TestRangeBetween10And100Int { + + @Test + public void testRangeForValueZero() { + RangeInt value = new RangeBetween10And100Int(); + assertEquals(0, value.call(0)); + } + + @Test + public void testRangeForNegativeValue() { + RangeInt value = new RangeBetween10And100Int(); + assertEquals(0, value.call(-100)); + } + + @Test + public void testRangeForVeryHighValue() { + RangeInt value = new RangeBetween10And100Int(); + assertEquals(0, value.call(999999)); + } + + @Test + public void testRangeForValue8() { + RangeInt value = new RangeBetween10And100Int(); + assertEquals(0, value.call(8)); + } + + @Test + public void testRangeForValue65() { + RangeInt value = new RangeBetween10And100Int(); + assertEquals(1, value.call(65)); + } + + @Test + public void testRangeForValue867() { + RangeInt value = new RangeBetween10And100Int(); + assertEquals(0, value.call(867)); + } + @Test + public void testRangeForValue8637() { + RangeInt value = new RangeBetween10And100Int(); + assertEquals(0, value.call(8637)); + } + +} diff --git a/core/src/test/java/zingg/hash/TestTrimLastDigitsDbl.java b/core/src/test/java/zingg/hash/TestTrimLastDigitsDbl.java new file mode 100644 index 000000000..ad1146a07 --- /dev/null +++ b/core/src/test/java/zingg/hash/TestTrimLastDigitsDbl.java @@ -0,0 +1,39 @@ +package zingg.hash; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class TestTrimLastDigitsDbl { + + @Test + public void testTrimLast1DigitDbl() { + TrimLast1DigitDbl value = new TrimLast1DigitDbl(); + assertEquals(54353d, value.call(543534.677)); + } + + @Test + public void testTrimLast2DigitsDbl() { + TrimLast2DigitsDbl value = new TrimLast2DigitsDbl(); + assertEquals(5435d, value.call(543534.677)); + } + + @Test + public void testTrimLast3DigitsDbl() { + TrimLast3DigitsDbl value = new TrimLast3DigitsDbl(); + assertEquals(543d, value.call(543534.677)); + } + + @Test + public void testTrimLast3DigitsDblNaNValue() { + TrimLast3DigitsDbl value = new TrimLast3DigitsDbl(); + assertEquals(Double.NaN, value.call(Double.NaN)); + } + + @Test + public void testTrimLast3DigitsDblNullValue() { + TrimLast3DigitsDbl value = new TrimLast3DigitsDbl(); + assertEquals(null, value.call(null)); + } + +} diff --git a/core/src/test/java/zingg/hash/TestTrimLastDigitsInt.java b/core/src/test/java/zingg/hash/TestTrimLastDigitsInt.java new file mode 100644 index 000000000..408da6e3d --- /dev/null +++ b/core/src/test/java/zingg/hash/TestTrimLastDigitsInt.java @@ -0,0 +1,33 @@ +package zingg.hash; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class TestTrimLastDigitsInt { + + @Test + public void testTrimLast1Digit() { + TrimLast1DigitInt value = new TrimLast1DigitInt(); + assertEquals(54353, value.call(543534)); + } + + @Test + public void testTrimLast2DigitsInt() { + TrimLast2DigitsInt value = new TrimLast2DigitsInt(); + assertEquals(5435, value.call(543534)); + } + + @Test + public void testTrimLast3DigitsInt() { + TrimLast3DigitsInt value = new TrimLast3DigitsInt(); + assertEquals(543, value.call(543534)); + } + + @Test + public void testTrimLast3DigitsIntNullValue() { + TrimLast3DigitsInt value = new TrimLast3DigitsInt(); + assertEquals(null, value.call(null)); + } + +} diff --git a/core/src/test/java/zingg/hash/TestTruncateDouble.java b/core/src/test/java/zingg/hash/TestTruncateDouble.java new file mode 100644 index 000000000..e74553c46 --- /dev/null +++ b/core/src/test/java/zingg/hash/TestTruncateDouble.java @@ -0,0 +1,57 @@ +package zingg.hash; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class TestTruncateDouble { + + @Test + public void testTruncateDoubleTo1Place() { + TruncateDoubleTo1Place value = new TruncateDoubleTo1Place(); + assertEquals(543534.6d, value.call(543534.67734)); + } + + @Test + public void testTruncateDoubleTo2Place() { + TruncateDoubleTo2Places value = new TruncateDoubleTo2Places(); + assertEquals(543534.67d, value.call(543534.67734)); + } + + @Test + public void testTruncateDoubleTo3Place() { + TruncateDoubleTo3Places value = new TruncateDoubleTo3Places(); + assertEquals(543534.677d, value.call(543534.67734)); + } + + @Test + public void testTruncateDoubleTo3PlaceWhenNumberhas2DecimalPlaces() { + TruncateDoubleTo3Places value = new TruncateDoubleTo3Places(); + assertEquals(543534.670d, value.call(543534.67)); + } + + @Test + public void testTruncateDoubleTo3PlaceForNumberWithNoDecimalPlaces() { + TruncateDoubleTo3Places value = new TruncateDoubleTo3Places(); + assertEquals(543534.000d, value.call(543534d)); + } + + @Test + public void testTruncateDoubleTo3PlaceForNumberNAN() { + TruncateDoubleTo3Places value = new TruncateDoubleTo3Places(); + assertEquals(Double.NaN, value.call(Double.NaN)); + } + + @Test + public void testTruncateDoubleTo3PlaceForNumber0() { + TruncateDoubleTo3Places value = new TruncateDoubleTo3Places(); + assertEquals(0d, value.call(0d)); + } + + @Test + public void testTruncateDoubleTo3PlaceForNull() { + TruncateDoubleTo3Places value = new TruncateDoubleTo3Places(); + assertEquals(null, value.call(null)); + } + +}