ATLAS-3347: fixed range-validation for primitive attribute types

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;
+    }
 }

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() {

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);

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);
         }

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);

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);

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);

intg/src/test/java/org/apache/atlas/type/TestAtlasShortType.java

-/**
+    /**
  * 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);