You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@atlas.apache.org by ma...@apache.org on 2019/07/31 17:54:59 UTC
[atlas] branch branch-2.0 updated: ATLAS-3347: fixed
range-validation for primitive attribute types
This is an automated email from the ASF dual-hosted git repository.
madhan pushed a commit to branch branch-2.0
in repository https://gitbox.apache.org/repos/asf/atlas.git
The following commit(s) were added to refs/heads/branch-2.0 by this push:
new 2f6ce70 ATLAS-3347: fixed range-validation for primitive attribute types
2f6ce70 is described below
commit 2f6ce70859d2d2e7ccbdf5c655d904f8f927f527
Author: Mandar Ambawane <ma...@freestoneinfotech.com>
AuthorDate: Wed Jul 31 18:37:01 2019 +0530
ATLAS-3347: fixed range-validation for primitive attribute types
(cherry picked from commit 6598c749f18a7bcd40d1c0a434d8c06a68deaa72)
---
.../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);