Skip to content

A
atlas
Commit 6598c749 by Mandar Ambawane Committed by Madhan Neethiraj
Options

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

parent 620861e3
Showing with 498 additions and 26 deletions
intg/src/main/java/org/apache/atlas/type/AtlasBuiltInTypes.java
......@@ -57,19 +57,23 @@ public class AtlasBuiltInTypes {
@Override
public boolean isValidValue(Object obj) {
if (obj == null) {
return true;
}
return getNormalizedValue(obj) != null;
}
@Override
public Boolean getNormalizedValue(Object obj) {
if (obj != null) {
if (obj instanceof Boolean) {
return (Boolean)obj;
} else {
} else if (obj instanceof String){
if (obj.toString().equalsIgnoreCase("true") || obj.toString().equalsIgnoreCase("false")) {
return Boolean.valueOf(obj.toString());
}
}
}
return null;
}
}
......@@ -79,6 +83,8 @@ public class AtlasBuiltInTypes {
*/
public static class AtlasByteType extends AtlasType {
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,6 +127,24 @@ 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;
}
}
/**
......@@ -127,6 +152,8 @@ public class AtlasBuiltInTypes {
*/
public static class AtlasShortType extends AtlasType {
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,9 +188,26 @@ 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;
}
}
/**
......@@ -171,6 +215,8 @@ public class AtlasBuiltInTypes {
*/
public static class AtlasIntType extends AtlasType {
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,6 +255,24 @@ 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;
}
}
/**
......@@ -215,6 +280,8 @@ public class AtlasBuiltInTypes {
*/
public static class AtlasLongType extends AtlasType {
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,6 +319,20 @@ 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;
}
}
/**
......@@ -260,6 +341,8 @@ public class AtlasBuiltInTypes {
public static class AtlasFloatType extends AtlasType {
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) {
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,6 +416,22 @@ 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;
}
}
/**
......@@ -337,6 +440,8 @@ public class AtlasBuiltInTypes {
public static class AtlasDoubleType extends AtlasType {
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) {
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);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment