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

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