This is an automated email from the ASF dual-hosted git repository. madhan pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/atlas.git
The following commit(s) were added to refs/heads/master by this push: new 6598c74 ATLAS-3347: fixed range-validation for primitive attribute types 6598c74 is described below commit 6598c749f18a7bcd40d1c0a434d8c06a68deaa72 Author: Mandar Ambawane <mandar.ambaw...@freestoneinfotech.com> AuthorDate: Wed Jul 31 18:37:01 2019 +0530 ATLAS-3347: fixed range-validation for primitive attribute types --- .../org/apache/atlas/type/AtlasBuiltInTypes.java | 195 ++++++++++++++++++--- .../apache/atlas/type/TestAtlasBooleanType.java | 4 +- .../org/apache/atlas/type/TestAtlasByteType.java | 60 ++++++- .../org/apache/atlas/type/TestAtlasDoubleType.java | 48 ++++- .../org/apache/atlas/type/TestAtlasFloatType.java | 59 ++++++- .../org/apache/atlas/type/TestAtlasIntType.java | 60 ++++++- .../org/apache/atlas/type/TestAtlasLongType.java | 61 ++++++- .../org/apache/atlas/type/TestAtlasShortType.java | 61 ++++++- 8 files changed, 510 insertions(+), 38 deletions(-) diff --git a/intg/src/main/java/org/apache/atlas/type/AtlasBuiltInTypes.java b/intg/src/main/java/org/apache/atlas/type/AtlasBuiltInTypes.java index ce14b5b..ed1e5de 100644 --- a/intg/src/main/java/org/apache/atlas/type/AtlasBuiltInTypes.java +++ b/intg/src/main/java/org/apache/atlas/type/AtlasBuiltInTypes.java @@ -57,7 +57,10 @@ public class AtlasBuiltInTypes { @Override public boolean isValidValue(Object obj) { - return true; + if (obj == null) { + return true; + } + return getNormalizedValue(obj) != null; } @Override @@ -65,11 +68,12 @@ public class AtlasBuiltInTypes { if (obj != null) { if (obj instanceof Boolean) { return (Boolean)obj; - } else { - return Boolean.valueOf(obj.toString()); + } else if (obj instanceof String){ + if (obj.toString().equalsIgnoreCase("true") || obj.toString().equalsIgnoreCase("false")) { + return Boolean.valueOf(obj.toString()); + } } } - return null; } } @@ -78,7 +82,9 @@ public class AtlasBuiltInTypes { * class that implements behaviour of byte type. */ public static class AtlasByteType extends AtlasType { - private static final Byte DEFAULT_VALUE = (byte) 0; + private static final Byte DEFAULT_VALUE = (byte) 0; + private static final BigInteger MIN_VALUE = BigInteger.valueOf(Byte.MIN_VALUE); + private static final BigInteger MAX_VALUE = BigInteger.valueOf(Byte.MAX_VALUE); public AtlasByteType() { super(AtlasBaseTypeDef.ATLAS_TYPE_BYTE, TypeCategory.PRIMITIVE, SERVICE_TYPE_ATLAS_CORE); @@ -91,7 +97,7 @@ public class AtlasBuiltInTypes { @Override public boolean isValidValue(Object obj) { - if (obj == null || obj instanceof Number) { + if (obj == null || obj instanceof Byte) { return true; } @@ -100,11 +106,12 @@ public class AtlasBuiltInTypes { @Override public Byte getNormalizedValue(Object obj) { + if (obj != null) { if (obj instanceof Byte) { return (Byte) obj; } else if (obj instanceof Number) { - return ((Number) obj).byteValue(); + return isValidRange((Number) obj) ? ((Number) obj).byteValue() : null; } else { String strValue = obj.toString(); @@ -120,13 +127,33 @@ public class AtlasBuiltInTypes { return null; } + + private boolean isValidRange(Number num) { + final boolean ret; + + if (num instanceof Byte) { + ret = true; + } else if (num instanceof Double || num instanceof Float || num instanceof Long || num instanceof Integer || num instanceof Short) { + long longVal = num.longValue(); + + ret = longVal >= Byte.MIN_VALUE && longVal <= Byte.MAX_VALUE; + } else { + BigInteger bigInt = toBigInteger(num); + + ret = bigInt.compareTo(MIN_VALUE) >= 0 && bigInt.compareTo(MAX_VALUE) <= 0; + } + + return ret; + } } /** * class that implements behaviour of short type. */ public static class AtlasShortType extends AtlasType { - private static final Short DEFAULT_VALUE = (short) 0; + private static final Short DEFAULT_VALUE = (short) 0; + private static final BigInteger MIN_VALUE = BigInteger.valueOf(Short.MIN_VALUE); + private static final BigInteger MAX_VALUE = BigInteger.valueOf(Short.MAX_VALUE); public AtlasShortType() { super(AtlasBaseTypeDef.ATLAS_TYPE_SHORT, TypeCategory.PRIMITIVE, SERVICE_TYPE_ATLAS_CORE); @@ -139,7 +166,7 @@ public class AtlasBuiltInTypes { @Override public boolean isValidValue(Object obj) { - if (obj == null || obj instanceof Number) { + if (obj == null || obj instanceof Short) { return true; } @@ -152,7 +179,7 @@ public class AtlasBuiltInTypes { if (obj instanceof Short) { return (Short)obj; } else if (obj instanceof Number) { - return ((Number) obj).shortValue(); + return isValidRange((Number) obj) ? ((Number) obj).shortValue() : null; } else { try { return Short.valueOf(obj.toString()); @@ -161,16 +188,35 @@ public class AtlasBuiltInTypes { } } } - return null; } + + private boolean isValidRange(Number num) { + final boolean ret; + + if (num instanceof Short || num instanceof Byte) { + ret = true; + } else if (num instanceof Double || num instanceof Float || num instanceof Long || num instanceof Integer) { + long longVal = num.longValue(); + + ret = longVal >= Short.MIN_VALUE && longVal <= Short.MAX_VALUE; + } else { + BigInteger bigInt = toBigInteger(num); + + ret = bigInt.compareTo(MIN_VALUE) >= 0 && bigInt.compareTo(MAX_VALUE) <= 0; + } + + return ret; + } } /** * class that implements behaviour of integer type. */ public static class AtlasIntType extends AtlasType { - private static final Integer DEFAULT_VALUE = 0; + private static final Integer DEFAULT_VALUE = 0; + private static final BigInteger MIN_VALUE = BigInteger.valueOf(Integer.MIN_VALUE); + private static final BigInteger MAX_VALUE = BigInteger.valueOf(Integer.MAX_VALUE); public AtlasIntType() { super(AtlasBaseTypeDef.ATLAS_TYPE_INT, TypeCategory.PRIMITIVE, SERVICE_TYPE_ATLAS_CORE); @@ -183,7 +229,7 @@ public class AtlasBuiltInTypes { @Override public boolean isValidValue(Object obj) { - if (obj == null || obj instanceof Number) { + if (obj == null || obj instanceof Integer) { return true; } @@ -192,11 +238,12 @@ public class AtlasBuiltInTypes { @Override public Integer getNormalizedValue(Object obj) { + if (obj != null) { if (obj instanceof Integer) { return (Integer) obj; } else if (obj instanceof Number) { - return ((Number) obj).intValue(); + return isValidRange((Number) obj) ? ((Number) obj).intValue() : null; } else { try { return Integer.valueOf(obj.toString()); @@ -208,13 +255,33 @@ public class AtlasBuiltInTypes { return null; } + + private boolean isValidRange(Number num) { + final boolean ret; + + if (num instanceof Integer || num instanceof Short || num instanceof Byte) { + ret = true; + } else if (num instanceof Double || num instanceof Float || num instanceof Long) { + long longVal = num.longValue(); + + ret = longVal >= Integer.MIN_VALUE && longVal <= Integer.MAX_VALUE; + } else { + BigInteger bigInt = toBigInteger(num); + + ret = bigInt.compareTo(MIN_VALUE) >= 0 && bigInt.compareTo(MAX_VALUE) <= 0; + } + + return ret; + } } /** * class that implements behaviour of long type. */ public static class AtlasLongType extends AtlasType { - private static final Long DEFAULT_VALUE = 0L; + private static final Long DEFAULT_VALUE = 0L; + private static final BigInteger MIN_VALUE = BigInteger.valueOf(Long.MIN_VALUE); + private static final BigInteger MAX_VALUE = BigInteger.valueOf(Long.MAX_VALUE); public AtlasLongType() { super(AtlasBaseTypeDef.ATLAS_TYPE_LONG, TypeCategory.PRIMITIVE, SERVICE_TYPE_ATLAS_CORE); @@ -227,7 +294,7 @@ public class AtlasBuiltInTypes { @Override public boolean isValidValue(Object obj) { - if (obj == null || obj instanceof Number) { + if (obj == null || obj instanceof Long) { return true; } @@ -240,7 +307,7 @@ public class AtlasBuiltInTypes { if (obj instanceof Long) { return (Long) obj; } else if (obj instanceof Number) { - return ((Number) obj).longValue(); + return isValidRange((Number) obj) ? ((Number) obj).longValue() : null; } else { try { return Long.valueOf(obj.toString()); @@ -252,14 +319,30 @@ public class AtlasBuiltInTypes { return null; } + + private boolean isValidRange(Number num) { + final boolean ret; + + if (num instanceof Long || num instanceof Integer || num instanceof Short || num instanceof Byte) { + ret = true; + } else { + BigInteger number = toBigInteger(num); + + ret = (number.compareTo(MIN_VALUE) >= 0) && (number.compareTo(MAX_VALUE) <= 0); + } + + return ret; + } } /** * class that implements behaviour of float type. */ public static class AtlasFloatType extends AtlasType { - private static final Float DEFAULT_VALUE = 0f; - private static final Float FLOAT_EPSILON = 0.00000001f; + private static final Float DEFAULT_VALUE = 0f; + private static final Float FLOAT_EPSILON = 0.00000001f; + private static final BigDecimal MIN_VALUE = BigDecimal.valueOf(-Float.MAX_VALUE); + private static final BigDecimal MAX_VALUE = BigDecimal.valueOf(Float.MAX_VALUE); public AtlasFloatType() { super(AtlasBaseTypeDef.ATLAS_TYPE_FLOAT, TypeCategory.PRIMITIVE, SERVICE_TYPE_ATLAS_CORE); @@ -272,7 +355,7 @@ public class AtlasBuiltInTypes { @Override public boolean isValidValue(Object obj) { - if (obj == null || obj instanceof Number) { + if (obj == null) { return true; } @@ -310,9 +393,13 @@ public class AtlasBuiltInTypes { public Float getNormalizedValue(Object obj) { if (obj != null) { if (obj instanceof Float) { - return (Float) obj; + if (!Float.isInfinite((float) obj)) { + return (Float) obj; + } else { + return null; + } } else if (obj instanceof Number) { - return ((Number) obj).floatValue(); + return isValidRange((Number) obj) ? ((Number) obj).floatValue() : null; } else { try { Float f = Float.valueOf(obj.toString()); @@ -329,14 +416,32 @@ public class AtlasBuiltInTypes { return null; } + + private boolean isValidRange(Number num) { + final boolean ret; + + if (num instanceof Float || num instanceof Long || num instanceof Integer || num instanceof Short || num instanceof Byte) { + ret = true; + } else if (num instanceof Double) { + ret = num.floatValue() >= MIN_VALUE.floatValue() && num.floatValue() <= MAX_VALUE.floatValue(); + } else { + BigDecimal number = new BigDecimal(num.doubleValue()); + + ret = (number.compareTo(MIN_VALUE) >= 0) && (number.compareTo(MAX_VALUE) <= 0); + } + + return ret; + } } /** * class that implements behaviour of double type. */ public static class AtlasDoubleType extends AtlasType { - private static final Double DEFAULT_VALUE = 0d; - private static final Double DOUBLE_EPSILON = 0.00000001d; + private static final Double DEFAULT_VALUE = 0d; + private static final Double DOUBLE_EPSILON = 0.00000001d; + private static final BigDecimal MIN_VALUE = BigDecimal.valueOf(-Double.MAX_VALUE); + private static final BigDecimal MAX_VALUE = BigDecimal.valueOf(Double.MAX_VALUE); public AtlasDoubleType() { super(AtlasBaseTypeDef.ATLAS_TYPE_DOUBLE, TypeCategory.PRIMITIVE, SERVICE_TYPE_ATLAS_CORE); @@ -349,7 +454,7 @@ public class AtlasBuiltInTypes { @Override public boolean isValidValue(Object obj) { - if (obj == null || obj instanceof Number) { + if (obj == null) { return true; } @@ -389,9 +494,13 @@ public class AtlasBuiltInTypes { if (obj != null) { if (obj instanceof Double) { - return (Double) obj; + if (!Double.isInfinite((double) obj)) { + return (Double) obj; + } else { + return null; + } } else if (obj instanceof Number) { - return ((Number) obj).doubleValue(); + return isValidRange((Number) obj) ? ((Number) obj).doubleValue() : null; } else { try { Double d = Double.valueOf(obj.toString()); @@ -408,6 +517,20 @@ public class AtlasBuiltInTypes { return null; } + + private boolean isValidRange(Number num) { + final boolean ret; + + if (num instanceof Double || num instanceof Float || num instanceof Long || num instanceof Integer || num instanceof Short || num instanceof Byte) { + ret = true; + } else { + BigDecimal number = new BigDecimal(num.toString()); + + ret = (number.compareTo(MIN_VALUE) >= 0) && (number.compareTo(MAX_VALUE) <= 0); + } + + return ret; + } } /** @@ -427,7 +550,7 @@ public class AtlasBuiltInTypes { @Override public boolean isValidValue(Object obj) { - if (obj == null || obj instanceof Number) { + if (obj == null || obj instanceof BigInteger) { return true; } @@ -713,4 +836,20 @@ public class AtlasBuiltInTypes { return false; } } + + private static BigInteger toBigInteger(Number num) { + final BigInteger ret; + + if (num instanceof BigInteger) { + ret = (BigInteger) num; + } else if (num instanceof Byte || num instanceof Short || num instanceof Integer || num instanceof Long) { + ret = BigInteger.valueOf(num.longValue()); + } else if (num instanceof BigDecimal) { + ret = ((BigDecimal) num).toBigInteger(); + } else { + ret = new BigDecimal(num.toString()).toBigInteger(); + } + + return ret; + } } diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasBooleanType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasBooleanType.java index ec5f75a..f45e4ae 100644 --- a/intg/src/test/java/org/apache/atlas/type/TestAtlasBooleanType.java +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasBooleanType.java @@ -28,8 +28,8 @@ import static org.testng.Assert.*; public class TestAtlasBooleanType { private final AtlasBooleanType booleanType = new AtlasBooleanType(); - private final Object[] validValues = { null, Boolean.TRUE, Boolean.FALSE, "true", "false", "TRUE", "FALSE", }; - private final Object[] invalidValues = { }; + private final Object[] validValues = { null, Boolean.TRUE, Boolean.FALSE, "true", "false", "TRUE", "FALSE", "tRue", "FaLse" }; + private final Object[] invalidValues = {1, 0.5,123456789, "abcd", "101010" }; @Test public void testBooleanTypeDefaultValue() { diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasByteType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasByteType.java index a7ada38..0314086 100644 --- a/intg/src/test/java/org/apache/atlas/type/TestAtlasByteType.java +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasByteType.java @@ -36,12 +36,17 @@ public class TestAtlasByteType { Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", }; + private final Object[] validValuesLimitCheck = {Byte.MIN_VALUE, Byte.MAX_VALUE, Float.MIN_VALUE, Double.MIN_VALUE}; + private final Object[] negativeValues = { Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1), Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1", }; - private final Object[] invalidValues = { "", }; + private final Object[] negativeValuesLimitCheck = {-Float.MIN_VALUE, -Double.MIN_VALUE}; + + private final Object[] invalidValues = {"", Byte.MIN_VALUE - 1, Byte.MAX_VALUE + 1, Short.MIN_VALUE, Short.MAX_VALUE, Integer.MIN_VALUE, Integer.MAX_VALUE, + Long.MIN_VALUE, Long.MAX_VALUE, Float.MAX_VALUE, Double.MAX_VALUE, -Float.MAX_VALUE, -Double.MAX_VALUE}; @Test @@ -57,10 +62,18 @@ public class TestAtlasByteType { assertTrue(byteType.isValidValue(value), "value=" + value); } + for (Object value : validValuesLimitCheck) { + assertTrue(byteType.isValidValue(value), "value=" + value); + } + for (Object value : negativeValues) { assertTrue(byteType.isValidValue(value), "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + assertTrue(byteType.isValidValue(value), "value=" + value); + } + for (Object value : invalidValues) { assertFalse(byteType.isValidValue(value), "value=" + value); } @@ -81,11 +94,44 @@ public class TestAtlasByteType { assertEquals(normalizedValue, Byte.valueOf((byte)1), "value=" + value); } + for (Object value : validValuesLimitCheck) { + if (value == null) { + continue; + } + + Byte normalizedValue = byteType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + + byte b; + if (value instanceof Float) { + b = ((Float) value).byteValue(); + assertEquals(normalizedValue, Byte.valueOf(b), "value=" + value); + } else if (value instanceof Double) { + b = ((Double) value).byteValue(); + assertEquals(normalizedValue, Byte.valueOf(b), "value=" + value); + } else { + assertEquals(normalizedValue, Byte.valueOf((byte) value), "value=" + value); + } + } + for (Object value : negativeValues) { Byte normalizedValue = byteType.getNormalizedValue(value); assertNotNull(normalizedValue, "value=" + value); - assertEquals(normalizedValue, Byte.valueOf((byte)-1), "value=" + value); + assertEquals(normalizedValue, Byte.valueOf((byte) -1), "value=" + value); + } + + for (Object value : negativeValuesLimitCheck) { + Byte normalizedValue = byteType.getNormalizedValue(value); + byte b; + if (value instanceof Float) { + b = ((Float) value).byteValue(); + assertEquals(normalizedValue, Byte.valueOf(b), "value=" + value); + } else if (value instanceof Double) { + b = ((Double) value).byteValue(); + assertEquals(normalizedValue, Byte.valueOf(b), "value=" + value); + } } for (Object value : invalidValues) { @@ -101,11 +147,21 @@ public class TestAtlasByteType { assertEquals(messages.size(), 0, "value=" + value); } + for (Object value : validValuesLimitCheck) { + assertTrue(byteType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + for (Object value : negativeValues) { assertTrue(byteType.validateValue(value, "testObj", messages)); assertEquals(messages.size(), 0, "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + assertTrue(byteType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + for (Object value : invalidValues) { assertFalse(byteType.validateValue(value, "testObj", messages)); assertEquals(messages.size(), 1, "value=" + value); diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasDoubleType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasDoubleType.java index b3cbe72..4a6cc54 100644 --- a/intg/src/test/java/org/apache/atlas/type/TestAtlasDoubleType.java +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasDoubleType.java @@ -36,12 +36,17 @@ public class TestAtlasDoubleType { Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", }; + private final Object[] validValuesLimitCheck = {Byte.MIN_VALUE, Byte.MAX_VALUE, Short.MIN_VALUE, Short.MAX_VALUE, + Integer.MIN_VALUE, Integer.MAX_VALUE, Long.MIN_VALUE, Long.MAX_VALUE, Float.MIN_VALUE, Float.MAX_VALUE, Double.MIN_VALUE, Double.MAX_VALUE}; + private final Object[] negativeValues = { Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1), Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1", }; - private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab", }; + private final Object[] negativeValuesLimitCheck = {-Double.MIN_VALUE, -Double.MAX_VALUE, -Float.MIN_VALUE, -Float.MAX_VALUE,}; + + private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab", (Double.MAX_VALUE + Double.MAX_VALUE), -(Double.MAX_VALUE+Double.MAX_VALUE)}; @Test @@ -57,10 +62,18 @@ public class TestAtlasDoubleType { assertTrue(doubleType.isValidValue(value), "value=" + value); } + for (Object value : validValuesLimitCheck) { + assertTrue(doubleType.isValidValue(value), "value=" + value); + } + for (Object value : negativeValues) { assertTrue(doubleType.isValidValue(value), "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + assertTrue(doubleType.isValidValue(value), "value=" + value); + } + for (Object value : invalidValues) { assertFalse(doubleType.isValidValue(value), "value=" + value); } @@ -81,6 +94,27 @@ public class TestAtlasDoubleType { assertEquals(normalizedValue, Double.valueOf(1), "value=" + value); } + for (Object value : validValuesLimitCheck) { + if (value == null) { + continue; + } + + Double normalizedValue = doubleType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + + double d; + if (value instanceof Float) { + d = ((Float) value).doubleValue(); + assertEquals(normalizedValue, Double.valueOf(d), "value=" + value); + } else if (value instanceof Double) { + d = ((Double) value).doubleValue(); + assertEquals(normalizedValue, Double.valueOf(d), "value=" + value); + } else { + assertEquals(normalizedValue, Double.valueOf(value.toString()), "value=" + value); + } + } + for (Object value : negativeValues) { Double normalizedValue = doubleType.getNormalizedValue(value); @@ -88,6 +122,18 @@ public class TestAtlasDoubleType { assertEquals(normalizedValue, Double.valueOf(-1), "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + Double normalizedValue = doubleType.getNormalizedValue(value); + double d; + if (value instanceof Float) { + d = ((Float) value).doubleValue(); + assertEquals(normalizedValue, Double.valueOf(d), "value=" + value); + } else if (value instanceof Double) { + d = ((Double) value).doubleValue(); + assertEquals(normalizedValue, Double.valueOf(d), "value=" + value); + } + } + for (Object value : invalidValues) { assertNull(doubleType.getNormalizedValue(value), "value=" + value); } diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasFloatType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasFloatType.java index 64fc3e3..a3e8b8c 100644 --- a/intg/src/test/java/org/apache/atlas/type/TestAtlasFloatType.java +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasFloatType.java @@ -36,12 +36,18 @@ public class TestAtlasFloatType { Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", }; + private final Object[] validValuesLimitCheck = {Byte.MIN_VALUE, Byte.MAX_VALUE, Short.MIN_VALUE, Short.MAX_VALUE, + Integer.MIN_VALUE, Integer.MAX_VALUE, Long.MIN_VALUE, Long.MAX_VALUE, Float.MIN_VALUE, Float.MAX_VALUE, Double.MIN_VALUE}; + private final Object[] negativeValues = { Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1), Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1", }; - private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab", }; + private final Object[] negativeValuesLimitCheck = {-Float.MIN_VALUE, -Float.MAX_VALUE, -Double.MIN_VALUE}; + + private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab", (Float.MAX_VALUE + Float.MAX_VALUE)/*+Infinity*/, -(Float.MAX_VALUE + Float.MAX_VALUE)/*-Infinity*/ + , Double.MAX_VALUE, -Double.MAX_VALUE}; @Test @@ -57,10 +63,18 @@ public class TestAtlasFloatType { assertTrue(floatType.isValidValue(value), "value=" + value); } + for (Object value : validValuesLimitCheck) { + assertTrue(floatType.isValidValue(value), "value=" + value); + } + for (Object value : negativeValues) { assertTrue(floatType.isValidValue(value), "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + assertTrue(floatType.isValidValue(value), "value=" + value); + } + for (Object value : invalidValues) { assertFalse(floatType.isValidValue(value), "value=" + value); } @@ -81,6 +95,27 @@ public class TestAtlasFloatType { assertEquals(normalizedValue, Float.valueOf(1), "value=" + value); } + for (Object value : validValuesLimitCheck) { + if (value == null) { + continue; + } + + Float normalizedValue = floatType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + + float f; + if (value instanceof Float) { + f = ((Float) value).floatValue(); + assertEquals(normalizedValue, Float.valueOf(f), "value=" + value); + } else if (value instanceof Double) { + f = ((Double) value).floatValue(); + assertEquals(normalizedValue, Float.valueOf(f), "value=" + value); + } else { + assertEquals(normalizedValue, Float.valueOf(value.toString()), "value=" + value); + } + } + for (Object value : negativeValues) { Float normalizedValue = floatType.getNormalizedValue(value); @@ -88,6 +123,18 @@ public class TestAtlasFloatType { assertEquals(normalizedValue, Float.valueOf(-1), "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + Float normalizedValue = floatType.getNormalizedValue(value); + float f; + if (value instanceof Float) { + f = ((Float) value).floatValue(); + assertEquals(normalizedValue, Float.valueOf(f), "value=" + value); + } else if (value instanceof Double) { + f = ((Double) value).floatValue(); + assertEquals(normalizedValue, Float.valueOf(f), "value=" + value); + } + } + for (Object value : invalidValues) { assertNull(floatType.getNormalizedValue(value), "value=" + value); } @@ -101,11 +148,21 @@ public class TestAtlasFloatType { assertEquals(messages.size(), 0, "value=" + value); } + for (Object value : validValuesLimitCheck) { + assertTrue(floatType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + for (Object value : negativeValues) { assertTrue(floatType.validateValue(value, "testObj", messages)); assertEquals(messages.size(), 0, "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + assertTrue(floatType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + for (Object value : invalidValues) { assertFalse(floatType.validateValue(value, "testObj", messages)); assertEquals(messages.size(), 1, "value=" + value); diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasIntType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasIntType.java index c2b5eb4..cd8c14a 100644 --- a/intg/src/test/java/org/apache/atlas/type/TestAtlasIntType.java +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasIntType.java @@ -36,12 +36,19 @@ public class TestAtlasIntType { Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", }; + private final Object[] validValuesLimitCheck = {Byte.MIN_VALUE, Byte.MAX_VALUE, Short.MIN_VALUE, Short.MAX_VALUE, + Integer.MIN_VALUE, Integer.MAX_VALUE, Float.MIN_VALUE, Double.MIN_VALUE}; + private final Object[] negativeValues = { Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1), Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1", }; - private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab", }; + private final Object[] negativeValuesLimitCheck = {-Float.MIN_VALUE, -Double.MIN_VALUE}; + + private final Object[] invalidValues = {"", "12ab", "abcd", "-12ab", + (long)Integer.MIN_VALUE - 1, (long)Integer.MAX_VALUE + 1, + Long.MIN_VALUE, Long.MAX_VALUE, Float.MAX_VALUE, Double.MAX_VALUE, -Float.MAX_VALUE, -Double.MAX_VALUE}; @Test @@ -57,10 +64,18 @@ public class TestAtlasIntType { assertTrue(intType.isValidValue(value), "value=" + value); } + for (Object value : validValuesLimitCheck) { + assertTrue(intType.isValidValue(value), "value=" + value); + } + for (Object value : negativeValues) { assertTrue(intType.isValidValue(value), "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + assertTrue(intType.isValidValue(value), "value=" + value); + } + for (Object value : invalidValues) { assertFalse(intType.isValidValue(value), "value=" + value); } @@ -81,6 +96,27 @@ public class TestAtlasIntType { assertEquals(normalizedValue, Integer.valueOf(1), "value=" + value); } + for (Object value : validValuesLimitCheck) { + if (value == null) { + continue; + } + + Integer normalizedValue = intType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + + int i; + if (value instanceof Float) { + i = ((Float) value).intValue(); + assertEquals(normalizedValue, Integer.valueOf(i), "value=" + value); + } else if (value instanceof Double) { + i = ((Double) value).intValue(); + assertEquals(normalizedValue, Integer.valueOf(i), "value=" + value); + } else { + assertEquals(normalizedValue, Integer.valueOf(value.toString()), "value=" + value); + } + } + for (Object value : negativeValues) { Integer normalizedValue = intType.getNormalizedValue(value); @@ -88,6 +124,18 @@ public class TestAtlasIntType { assertEquals(normalizedValue, Integer.valueOf(-1), "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + Integer normalizedValue = intType.getNormalizedValue(value); + int i; + if (value instanceof Float) { + i = ((Float) value).intValue(); + assertEquals(normalizedValue, Integer.valueOf(i), "value=" + value); + } else if (value instanceof Double) { + i = ((Double) value).intValue(); + assertEquals(normalizedValue, Integer.valueOf(i), "value=" + value); + } + } + for (Object value : invalidValues) { assertNull(intType.getNormalizedValue(value), "value=" + value); } @@ -101,11 +149,21 @@ public class TestAtlasIntType { assertEquals(messages.size(), 0, "value=" + value); } + for (Object value : validValuesLimitCheck) { + assertTrue(intType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + for (Object value : negativeValues) { assertTrue(intType.validateValue(value, "testObj", messages)); assertEquals(messages.size(), 0, "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + assertTrue(intType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + for (Object value : invalidValues) { assertFalse(intType.validateValue(value, "testObj", messages)); assertEquals(messages.size(), 1, "value=" + value); diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasLongType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasLongType.java index 7eefcc2..aef1e27 100644 --- a/intg/src/test/java/org/apache/atlas/type/TestAtlasLongType.java +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasLongType.java @@ -36,12 +36,20 @@ public class TestAtlasLongType { Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", }; + private final Object[] validValuesLimitCheck = {Byte.MIN_VALUE, Byte.MAX_VALUE, Short.MIN_VALUE, Short.MAX_VALUE, + Integer.MIN_VALUE, Integer.MAX_VALUE, Long.MIN_VALUE, Long.MAX_VALUE, Float.MIN_VALUE, Double.MIN_VALUE}; + private final Object[] negativeValues = { Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1), Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1", }; - private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab", }; + private final Object[] negativeValuesLimitCheck = {-Float.MIN_VALUE, -Double.MIN_VALUE}; + + BigInteger bgIntLongMaxPlus1 = new BigInteger("9223372036854775808"); + BigInteger bgIntLongMinMinus1 = new BigInteger("-9223372036854775809"); + private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab" + , bgIntLongMinMinus1, bgIntLongMaxPlus1, Float.MAX_VALUE, Double.MAX_VALUE, -Float.MAX_VALUE, -Double.MAX_VALUE}; @Test @@ -57,10 +65,18 @@ public class TestAtlasLongType { assertTrue(longType.isValidValue(value), "value=" + value); } + for (Object value : validValuesLimitCheck) { + assertTrue(longType.isValidValue(value), "value=" + value); + } + for (Object value : negativeValues) { assertTrue(longType.isValidValue(value), "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + assertTrue(longType.isValidValue(value), "value=" + value); + } + for (Object value : invalidValues) { assertFalse(longType.isValidValue(value), "value=" + value); } @@ -81,6 +97,27 @@ public class TestAtlasLongType { assertEquals(normalizedValue, Long.valueOf(1), "value=" + value); } + for (Object value : validValuesLimitCheck) { + if (value == null) { + continue; + } + + Long normalizedValue = longType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + + long l; + if (value instanceof Float) { + l = ((Float) value).longValue(); + assertEquals(normalizedValue, Long.valueOf(l), "value=" + value); + } else if (value instanceof Double) { + l = ((Double) value).longValue(); + assertEquals(normalizedValue, Long.valueOf(l), "value=" + value); + } else { + assertEquals(normalizedValue, Long.valueOf(value.toString()), "value=" + value); + } + } + for (Object value : negativeValues) { Long normalizedValue = longType.getNormalizedValue(value); @@ -88,6 +125,18 @@ public class TestAtlasLongType { assertEquals(normalizedValue, Long.valueOf(-1), "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + Long normalizedValue = longType.getNormalizedValue(value); + long l; + if (value instanceof Float) { + l = ((Float) value).longValue(); + assertEquals(normalizedValue, Long.valueOf(l), "value=" + value); + } else if (value instanceof Double) { + l = ((Double) value).longValue(); + assertEquals(normalizedValue, Long.valueOf(l), "value=" + value); + } + } + for (Object value : invalidValues) { assertNull(longType.getNormalizedValue(value), "value=" + value); } @@ -101,11 +150,21 @@ public class TestAtlasLongType { assertEquals(messages.size(), 0, "value=" + value); } + for (Object value : validValuesLimitCheck) { + assertTrue(longType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + for (Object value : negativeValues) { assertTrue(longType.validateValue(value, "testObj", messages)); assertEquals(messages.size(), 0, "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + assertTrue(longType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + for (Object value : invalidValues) { assertFalse(longType.validateValue(value, "testObj", messages)); assertEquals(messages.size(), 1, "value=" + value); diff --git a/intg/src/test/java/org/apache/atlas/type/TestAtlasShortType.java b/intg/src/test/java/org/apache/atlas/type/TestAtlasShortType.java index 2b15ba0..61a2d11 100644 --- a/intg/src/test/java/org/apache/atlas/type/TestAtlasShortType.java +++ b/intg/src/test/java/org/apache/atlas/type/TestAtlasShortType.java @@ -1,4 +1,4 @@ -/** + /** * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information @@ -36,12 +36,18 @@ public class TestAtlasShortType { Double.valueOf(1), BigInteger.valueOf(1), BigDecimal.valueOf(1), "1", }; + private final Object[] validValuesLimitCheck = {Byte.MIN_VALUE, Byte.MAX_VALUE, Short.MIN_VALUE, Short.MAX_VALUE, Float.MIN_VALUE, Double.MIN_VALUE}; + private final Object[] negativeValues = { Byte.valueOf((byte)-1), Short.valueOf((short)-1), Integer.valueOf(-1), Long.valueOf(-1L), Float.valueOf(-1), Double.valueOf(-1), BigInteger.valueOf(-1), BigDecimal.valueOf(-1), "-1", }; - private final Object[] invalidValues = { "", "12ab", "abcd", "-12ab", }; + private final Object[] negativeValuesLimitCheck = {-Float.MIN_VALUE, -Double.MIN_VALUE}; + + private final Object[] invalidValues = {"", "12ab", "abcd", "-12ab", Short.MIN_VALUE - 1, Short.MAX_VALUE + 1, Integer.MIN_VALUE, Integer.MAX_VALUE, + Long.MIN_VALUE, Long.MAX_VALUE, Float.MAX_VALUE, Double.MAX_VALUE, -Float.MAX_VALUE, -Double.MAX_VALUE + }; @Test @@ -57,10 +63,18 @@ public class TestAtlasShortType { assertTrue(shortType.isValidValue(value), "value=" + value); } + for (Object value : validValuesLimitCheck) { + assertTrue(shortType.isValidValue(value), "value=" + value); + } + for (Object value : negativeValues) { assertTrue(shortType.isValidValue(value), "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + assertTrue(shortType.isValidValue(value), "value=" + value); + } + for (Object value : invalidValues) { assertFalse(shortType.isValidValue(value), "value=" + value); } @@ -81,6 +95,27 @@ public class TestAtlasShortType { assertEquals(normalizedValue, Short.valueOf((short)1), "value=" + value); } + for (Object value : validValuesLimitCheck) { + if (value == null) { + continue; + } + + Short normalizedValue = shortType.getNormalizedValue(value); + + assertNotNull(normalizedValue, "value=" + value); + + short s; + if (value instanceof Float) { + s = ((Float) value).shortValue(); + assertEquals(normalizedValue, Short.valueOf(s), "value=" + value); + } else if (value instanceof Double) { + s = ((Double) value).shortValue(); + assertEquals(normalizedValue, Short.valueOf(s), "value=" + value); + } else { + assertEquals(normalizedValue, Short.valueOf(value.toString()), "value=" + value); + } + } + for (Object value : negativeValues) { Short normalizedValue = shortType.getNormalizedValue(value); @@ -88,6 +123,18 @@ public class TestAtlasShortType { assertEquals(normalizedValue, Short.valueOf((short)-1), "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + Short normalizedValue = shortType.getNormalizedValue(value); + short s; + if (value instanceof Float) { + s = ((Float) value).shortValue(); + assertEquals(normalizedValue, Short.valueOf(s), "value=" + value); + } else if (value instanceof Double) { + s = ((Double) value).shortValue(); + assertEquals(normalizedValue, Short.valueOf(s), "value=" + value); + } + } + for (Object value : invalidValues) { assertNull(shortType.getNormalizedValue(value), "value=" + value); } @@ -101,11 +148,21 @@ public class TestAtlasShortType { assertEquals(messages.size(), 0, "value=" + value); } + for (Object value : validValuesLimitCheck) { + assertTrue(shortType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + for (Object value : negativeValues) { assertTrue(shortType.validateValue(value, "testObj", messages)); assertEquals(messages.size(), 0, "value=" + value); } + for (Object value : negativeValuesLimitCheck) { + assertTrue(shortType.validateValue(value, "testObj", messages)); + assertEquals(messages.size(), 0, "value=" + value); + } + for (Object value : invalidValues) { assertFalse(shortType.validateValue(value, "testObj", messages)); assertEquals(messages.size(), 1, "value=" + value);