Author: cbrisson
Date: Tue Dec 3 16:57:12 2019
New Revision: 1870761
URL: http://svn.apache.org/viewvc?rev=1870761&view=rev
Log:
[core] Added implicit conversions from/to BigInteger and BigDecimal
Modified:
velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/Converter.java
velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/TypeConversionHandlerImpl.java
velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/UberspectImpl.java
velocity/engine/trunk/velocity-engine-core/src/test/java/org/apache/velocity/test/util/introspection/ConversionHandlerTestCase.java
velocity/engine/trunk/velocity-engine-core/src/test/resources/conversion/compare/matrix.cmp
velocity/engine/trunk/velocity-engine-core/src/test/resources/conversion/compare/test_conv_with_handler.cmp
velocity/engine/trunk/velocity-engine-core/src/test/resources/conversion/compare/test_conv_without_handler.cmp
velocity/engine/trunk/velocity-engine-core/src/test/resources/conversion/matrix.vhtml
velocity/engine/trunk/velocity-engine-core/src/test/resources/conversion/test_conv.vtl
Modified:
velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/Converter.java
URL:
http://svn.apache.org/viewvc/velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/Converter.java?rev=1870761&r1=1870760&r2=1870761&view=diff
==============================================================================
---
velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/Converter.java
(original)
+++
velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/Converter.java
Tue Dec 3 16:57:12 2019
@@ -27,6 +27,7 @@ package org.apache.velocity.util.introsp
* @version $Id$
*/
+@FunctionalInterface
public interface Converter<T>
{
/**
Modified:
velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/TypeConversionHandlerImpl.java
URL:
http://svn.apache.org/viewvc/velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/TypeConversionHandlerImpl.java?rev=1870761&r1=1870760&r2=1870761&view=diff
==============================================================================
---
velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/TypeConversionHandlerImpl.java
(original)
+++
velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/TypeConversionHandlerImpl.java
Tue Dec 3 16:57:12 2019
@@ -24,9 +24,12 @@ import org.apache.commons.lang3.reflect.
import org.apache.commons.lang3.tuple.Pair;
import java.lang.reflect.Type;
+import java.math.BigDecimal;
+import java.math.BigInteger;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
/**
@@ -57,18 +60,6 @@ public class TypeConversionHandlerImpl i
static Converter cacheMiss;
/**
- * min/max byte/short/int values as long
- */
- static final long minByte = Byte.MIN_VALUE, maxByte = Byte.MAX_VALUE,
- minShort = Short.MIN_VALUE, maxShort = Short.MAX_VALUE,
- minInt = Integer.MIN_VALUE, maxInt = Integer.MAX_VALUE;
-
- /**
- * min/max long values as double
- */
- static final double minLong = Long.MIN_VALUE, maxLong = Long.MAX_VALUE;
-
- /**
* a converters cache map, initialized with the standard narrowing and
string parsing conversions.
*/
Map<Pair<String, String>, Converter> converterCacheMap;
@@ -86,41 +77,53 @@ public class TypeConversionHandlerImpl i
static final String SHORT_CLASS = "java.lang.Short";
static final String INTEGER_CLASS = "java.lang.Integer";
static final String LONG_CLASS = "java.lang.Long";
+ static final String BIG_INTEGER_CLASS = "java.math.BigInteger";
static final String FLOAT_CLASS = "java.lang.Float";
static final String DOUBLE_CLASS = "java.lang.Double";
+ static final String BIG_DECIMAL_CLASS = "java.math.BigDecimal";
static final String NUMBER_CLASS = "java.lang.Number";
static final String CHARACTER_CLASS = "java.lang.Character";
static final String STRING_CLASS = "java.lang.String";
static final String LOCALE_CLASS = "java.util.Locale";
+ /*
+ * Bounds checking helper
+ */
+
+ static boolean checkBounds(Number n, double min, double max)
+ {
+ double d = n.doubleValue();
+ if (d < min || d > max)
+ {
+ throw new NumberFormatException("value out of range: " + n);
+ }
+ return true;
+ }
+
static
{
standardConverterMap = new HashMap<>();
- cacheMiss = new Converter<Object>()
- {
- @Override
- public Object convert(Object o)
- {
- return o;
- }
- };
+ cacheMiss = o -> o;
+
+ /*
+ * Conversions towards boolean
+ */
/* number -> boolean */
- Converter<Boolean> numberToBool = new Converter<Boolean>()
- {
- @Override
- public Boolean convert(Object o)
- {
- return o == null ? null : ((Number) o).intValue() != 0;
- }
- };
+
+ Converter<Boolean> numberToBool = o ->
Optional.ofNullable((Number)o).map(n -> Double.compare(n.doubleValue(), 0.0) !=
0).orElse(null);
+ Converter<Boolean> bigIntegerToBool = o ->
Optional.ofNullable((BigInteger)o).map(bi -> bi.signum() != 0).orElse(null);
+ Converter<Boolean> bigDecimalToBool = o ->
Optional.ofNullable((BigDecimal)o).map(bi -> bi.signum() != 0).orElse(null);
+
standardConverterMap.put(Pair.of(BOOLEAN_CLASS, BYTE_CLASS),
numberToBool);
standardConverterMap.put(Pair.of(BOOLEAN_CLASS, SHORT_CLASS),
numberToBool);
standardConverterMap.put(Pair.of(BOOLEAN_CLASS, INTEGER_CLASS),
numberToBool);
standardConverterMap.put(Pair.of(BOOLEAN_CLASS, LONG_CLASS),
numberToBool);
+ standardConverterMap.put(Pair.of(BOOLEAN_CLASS, BIG_INTEGER_CLASS),
bigIntegerToBool);
standardConverterMap.put(Pair.of(BOOLEAN_CLASS, FLOAT_CLASS),
numberToBool);
standardConverterMap.put(Pair.of(BOOLEAN_CLASS, DOUBLE_CLASS),
numberToBool);
+ standardConverterMap.put(Pair.of(BOOLEAN_CLASS, BIG_DECIMAL_CLASS),
bigDecimalToBool);
standardConverterMap.put(Pair.of(BOOLEAN_CLASS, NUMBER_CLASS),
numberToBool);
standardConverterMap.put(Pair.of(BOOLEAN_CLASS, BYTE_TYPE),
numberToBool);
standardConverterMap.put(Pair.of(BOOLEAN_CLASS, SHORT_TYPE),
numberToBool);
@@ -131,9 +134,11 @@ public class TypeConversionHandlerImpl i
standardConverterMap.put(Pair.of(BOOLEAN_TYPE, BYTE_CLASS),
numberToBool);
standardConverterMap.put(Pair.of(BOOLEAN_TYPE, SHORT_CLASS),
numberToBool);
standardConverterMap.put(Pair.of(BOOLEAN_TYPE, INTEGER_CLASS),
numberToBool);
+ standardConverterMap.put(Pair.of(BOOLEAN_TYPE, BIG_INTEGER_CLASS),
bigIntegerToBool);
standardConverterMap.put(Pair.of(BOOLEAN_TYPE, LONG_CLASS),
numberToBool);
standardConverterMap.put(Pair.of(BOOLEAN_TYPE, FLOAT_CLASS),
numberToBool);
standardConverterMap.put(Pair.of(BOOLEAN_TYPE, DOUBLE_CLASS),
numberToBool);
+ standardConverterMap.put(Pair.of(BOOLEAN_TYPE, BIG_DECIMAL_CLASS),
bigDecimalToBool);
standardConverterMap.put(Pair.of(BOOLEAN_TYPE, NUMBER_CLASS),
numberToBool);
standardConverterMap.put(Pair.of(BOOLEAN_TYPE, BYTE_TYPE),
numberToBool);
standardConverterMap.put(Pair.of(BOOLEAN_TYPE, SHORT_TYPE),
numberToBool);
@@ -143,51 +148,47 @@ public class TypeConversionHandlerImpl i
standardConverterMap.put(Pair.of(BOOLEAN_TYPE, DOUBLE_TYPE),
numberToBool);
/* character -> boolean */
- Converter<Boolean> charToBoolean = new Converter<Boolean>()
- {
- @Override
- public Boolean convert(Object o)
- {
- return o == null ? null : (Character) o != 0;
- }
- };
+
+ Converter<Boolean> charToBoolean = o ->
Optional.ofNullable((Character)o).map(c -> c != 0).orElse(null);
+
standardConverterMap.put(Pair.of(BOOLEAN_CLASS, CHARACTER_CLASS),
charToBoolean);
standardConverterMap.put(Pair.of(BOOLEAN_CLASS, CHARACTER_TYPE),
charToBoolean);
standardConverterMap.put(Pair.of(BOOLEAN_TYPE, CHARACTER_CLASS),
charToBoolean);
standardConverterMap.put(Pair.of(BOOLEAN_TYPE, CHARACTER_TYPE),
charToBoolean);
/* string -> boolean */
- Converter<Boolean> stringToBoolean = new Converter<Boolean>()
- {
- @Override
- public Boolean convert(Object o)
- {
- return Boolean.valueOf(String.valueOf(o));
- }
- };
+
+ Converter<Boolean> stringToBoolean = o ->
Boolean.valueOf(String.valueOf(o));
+
standardConverterMap.put(Pair.of(BOOLEAN_CLASS, STRING_CLASS),
stringToBoolean);
standardConverterMap.put(Pair.of(BOOLEAN_TYPE, STRING_CLASS),
stringToBoolean);
+ /*
+ * Conversions towards byte
+ */
+
/* narrowing towards byte */
- Converter<Byte> narrowingToByte = new Converter<Byte>()
- {
- @Override
- public Byte convert(Object o)
- {
- if (o == null) return null;
- long l = ((Number)o).longValue();
- if (l < minByte || l > maxByte)
- {
- throw new NumberFormatException("value out of range for
byte type: " + l);
- }
- return ((Number) o).byteValue();
- }
- };
+
+ Converter<Byte> narrowingToByte = o -> Optional.ofNullable((Number)o)
+ .filter(n -> checkBounds(n, Byte.MIN_VALUE, Byte.MAX_VALUE))
+ .map(Number::byteValue)
+ .orElse(null);
+
+ Converter<Byte> narrowingBigIntegerToByte = o ->
Optional.ofNullable((BigInteger)o)
+ .map(BigInteger::byteValueExact)
+ .orElse(null);
+
+ Converter<Byte> narrowingBigDecimalToByte = o ->
Optional.ofNullable((BigDecimal)o)
+ .map(BigDecimal::byteValueExact)
+ .orElse(null);
+
standardConverterMap.put(Pair.of(BYTE_CLASS, SHORT_CLASS),
narrowingToByte);
standardConverterMap.put(Pair.of(BYTE_CLASS, INTEGER_CLASS),
narrowingToByte);
standardConverterMap.put(Pair.of(BYTE_CLASS, LONG_CLASS),
narrowingToByte);
+ standardConverterMap.put(Pair.of(BYTE_CLASS, BIG_INTEGER_CLASS),
narrowingBigIntegerToByte);
standardConverterMap.put(Pair.of(BYTE_CLASS, FLOAT_CLASS),
narrowingToByte);
standardConverterMap.put(Pair.of(BYTE_CLASS, DOUBLE_CLASS),
narrowingToByte);
+ standardConverterMap.put(Pair.of(BYTE_CLASS, BIG_DECIMAL_CLASS),
narrowingBigDecimalToByte);
standardConverterMap.put(Pair.of(BYTE_CLASS, NUMBER_CLASS),
narrowingToByte);
standardConverterMap.put(Pair.of(BYTE_CLASS, SHORT_TYPE),
narrowingToByte);
standardConverterMap.put(Pair.of(BYTE_CLASS, INTEGER_TYPE),
narrowingToByte);
@@ -197,8 +198,10 @@ public class TypeConversionHandlerImpl i
standardConverterMap.put(Pair.of(BYTE_TYPE, SHORT_CLASS),
narrowingToByte);
standardConverterMap.put(Pair.of(BYTE_TYPE, INTEGER_CLASS),
narrowingToByte);
standardConverterMap.put(Pair.of(BYTE_TYPE, LONG_CLASS),
narrowingToByte);
+ standardConverterMap.put(Pair.of(BYTE_TYPE, BIG_INTEGER_CLASS),
narrowingBigIntegerToByte);
standardConverterMap.put(Pair.of(BYTE_TYPE, FLOAT_CLASS),
narrowingToByte);
standardConverterMap.put(Pair.of(BYTE_TYPE, DOUBLE_CLASS),
narrowingToByte);
+ standardConverterMap.put(Pair.of(BYTE_TYPE, BIG_DECIMAL_CLASS),
narrowingBigDecimalToByte);
standardConverterMap.put(Pair.of(BYTE_TYPE, NUMBER_CLASS),
narrowingToByte);
standardConverterMap.put(Pair.of(BYTE_TYPE, SHORT_TYPE),
narrowingToByte);
standardConverterMap.put(Pair.of(BYTE_TYPE, INTEGER_TYPE),
narrowingToByte);
@@ -207,36 +210,37 @@ public class TypeConversionHandlerImpl i
standardConverterMap.put(Pair.of(BYTE_TYPE, DOUBLE_TYPE),
narrowingToByte);
/* string to byte */
- Converter<Byte> stringToByte = new Converter<Byte>()
- {
- @Override
- public Byte convert(Object o)
- {
- return Byte.valueOf(String.valueOf(o));
- }
- };
+
+ Converter<Byte> stringToByte = o -> Byte.valueOf(String.valueOf(o));
+
standardConverterMap.put(Pair.of(BYTE_CLASS, STRING_CLASS),
stringToByte);
standardConverterMap.put(Pair.of(BYTE_TYPE, STRING_CLASS),
stringToByte);
+ /*
+ * Conversions towards short
+ */
+
/* narrowing towards short */
- Converter<Short> narrowingToShort = new Converter<Short>()
- {
- @Override
- public Short convert(Object o)
- {
- if (o == null) return null;
- long l = ((Number)o).longValue();
- if (l < minShort || l > maxShort)
- {
- throw new NumberFormatException("value out of range for
short type: " + l);
- }
- return ((Number) o).shortValue();
- }
- };
+
+ Converter<Short> narrowingToShort = o -> Optional.ofNullable((Number)o)
+ .filter(n -> checkBounds(n, Short.MIN_VALUE, Short.MAX_VALUE))
+ .map(Number::shortValue)
+ .orElse(null);
+
+ Converter<Short> narrowingBigIntegerToShort = o ->
Optional.ofNullable((BigInteger)o)
+ .map(BigInteger::shortValueExact)
+ .orElse(null);
+
+ Converter<Short> narrowingBigDecimalToShort = o ->
Optional.ofNullable((BigDecimal)o)
+ .map(BigDecimal::shortValueExact)
+ .orElse(null);
+
standardConverterMap.put(Pair.of(SHORT_CLASS, INTEGER_CLASS),
narrowingToShort);
standardConverterMap.put(Pair.of(SHORT_CLASS, LONG_CLASS),
narrowingToShort);
+ standardConverterMap.put(Pair.of(SHORT_CLASS, BIG_INTEGER_CLASS),
narrowingBigIntegerToShort);
standardConverterMap.put(Pair.of(SHORT_CLASS, FLOAT_CLASS),
narrowingToShort);
standardConverterMap.put(Pair.of(SHORT_CLASS, DOUBLE_CLASS),
narrowingToShort);
+ standardConverterMap.put(Pair.of(SHORT_CLASS, BIG_DECIMAL_CLASS),
narrowingBigDecimalToShort);
standardConverterMap.put(Pair.of(SHORT_CLASS, NUMBER_CLASS),
narrowingToShort);
standardConverterMap.put(Pair.of(SHORT_CLASS, INTEGER_TYPE),
narrowingToShort);
standardConverterMap.put(Pair.of(SHORT_CLASS, LONG_TYPE),
narrowingToShort);
@@ -244,194 +248,244 @@ public class TypeConversionHandlerImpl i
standardConverterMap.put(Pair.of(SHORT_CLASS, DOUBLE_TYPE),
narrowingToShort);
standardConverterMap.put(Pair.of(SHORT_TYPE, INTEGER_CLASS),
narrowingToShort);
standardConverterMap.put(Pair.of(SHORT_TYPE, LONG_CLASS),
narrowingToShort);
+ standardConverterMap.put(Pair.of(SHORT_TYPE, BIG_INTEGER_CLASS),
narrowingBigIntegerToShort);
standardConverterMap.put(Pair.of(SHORT_TYPE, FLOAT_CLASS),
narrowingToShort);
standardConverterMap.put(Pair.of(SHORT_TYPE, DOUBLE_CLASS),
narrowingToShort);
+ standardConverterMap.put(Pair.of(SHORT_TYPE, BIG_DECIMAL_CLASS),
narrowingBigDecimalToShort);
standardConverterMap.put(Pair.of(SHORT_TYPE, NUMBER_CLASS),
narrowingToShort);
standardConverterMap.put(Pair.of(SHORT_TYPE, INTEGER_TYPE),
narrowingToShort);
standardConverterMap.put(Pair.of(SHORT_TYPE, LONG_TYPE),
narrowingToShort);
standardConverterMap.put(Pair.of(SHORT_TYPE, FLOAT_TYPE),
narrowingToShort);
standardConverterMap.put(Pair.of(SHORT_TYPE, DOUBLE_TYPE),
narrowingToShort);
+ /* widening towards short */
+
+ Converter<Short> wideningToShort = o -> Optional.ofNullable((Number)o)
+ .map(Number::shortValue)
+ .orElse(null);
+
+ standardConverterMap.put(Pair.of(SHORT_CLASS, BYTE_CLASS),
wideningToShort);
+ standardConverterMap.put(Pair.of(SHORT_CLASS, BYTE_TYPE),
wideningToShort);
+
/* string to short */
- Converter<Short> stringToShort = new Converter<Short>()
- {
- @Override
- public Short convert(Object o)
- {
- return Short.valueOf(String.valueOf(o));
- }
- };
+
+ Converter<Short> stringToShort = o -> Short.valueOf(String.valueOf(o));
+
standardConverterMap.put(Pair.of(SHORT_CLASS, STRING_CLASS),
stringToShort);
standardConverterMap.put(Pair.of(SHORT_TYPE, STRING_CLASS),
stringToShort);
+ /*
+ * Conversions towards int
+ */
+
/* narrowing towards int */
- Converter<Integer> narrowingToInteger = new Converter<Integer>()
- {
- @Override
- public Integer convert(Object o)
- {
- if (o == null) return null;
- long l = ((Number)o).longValue();
- if (l < minInt || l > maxInt)
- {
- throw new NumberFormatException("value out of range for
integer type: " + l);
- }
- return ((Number) o).intValue();
- }
- };
+
+ Converter<Integer> narrowingToInteger = o ->
Optional.ofNullable((Number)o)
+ .filter(n -> checkBounds(n, Integer.MIN_VALUE, Integer.MAX_VALUE))
+ .map(Number::intValue)
+ .orElse(null);
+
+ Converter<Integer> narrowingBigIntegerToInteger = o ->
Optional.ofNullable((BigInteger)o)
+ .map(BigInteger::intValueExact)
+ .orElse(null);
+
+ Converter<Integer> narrowingBigDecimalToInteger = o ->
Optional.ofNullable((BigDecimal)o)
+ .map(BigDecimal::intValueExact)
+ .orElse(null);
+
standardConverterMap.put(Pair.of(INTEGER_CLASS, LONG_CLASS),
narrowingToInteger);
+ standardConverterMap.put(Pair.of(INTEGER_CLASS, BIG_INTEGER_CLASS),
narrowingBigIntegerToInteger);
standardConverterMap.put(Pair.of(INTEGER_CLASS, FLOAT_CLASS),
narrowingToInteger);
standardConverterMap.put(Pair.of(INTEGER_CLASS, DOUBLE_CLASS),
narrowingToInteger);
+ standardConverterMap.put(Pair.of(INTEGER_CLASS, BIG_DECIMAL_CLASS),
narrowingBigDecimalToInteger);
standardConverterMap.put(Pair.of(INTEGER_CLASS, NUMBER_CLASS),
narrowingToInteger);
standardConverterMap.put(Pair.of(INTEGER_CLASS, LONG_TYPE),
narrowingToInteger);
standardConverterMap.put(Pair.of(INTEGER_CLASS, FLOAT_TYPE),
narrowingToInteger);
standardConverterMap.put(Pair.of(INTEGER_CLASS, DOUBLE_TYPE),
narrowingToInteger);
standardConverterMap.put(Pair.of(INTEGER_TYPE, LONG_CLASS),
narrowingToInteger);
+ standardConverterMap.put(Pair.of(INTEGER_TYPE, BIG_INTEGER_CLASS),
narrowingBigIntegerToInteger);
standardConverterMap.put(Pair.of(INTEGER_TYPE, FLOAT_CLASS),
narrowingToInteger);
standardConverterMap.put(Pair.of(INTEGER_TYPE, DOUBLE_CLASS),
narrowingToInteger);
+ standardConverterMap.put(Pair.of(INTEGER_TYPE, BIG_DECIMAL_CLASS),
narrowingBigDecimalToInteger);
standardConverterMap.put(Pair.of(INTEGER_TYPE, NUMBER_CLASS),
narrowingToInteger);
standardConverterMap.put(Pair.of(INTEGER_TYPE, LONG_TYPE),
narrowingToInteger);
standardConverterMap.put(Pair.of(INTEGER_TYPE, FLOAT_TYPE),
narrowingToInteger);
standardConverterMap.put(Pair.of(INTEGER_TYPE, DOUBLE_TYPE),
narrowingToInteger);
- /* widening towards Integer */
- Converter<Integer> wideningToInteger = new Converter<Integer>()
- {
- @Override
- public Integer convert(Object o)
- {
- if (o == null) return null;
- return ((Number) o).intValue();
- }
- };
+ /* widening towards int */
+
+ Converter<Integer> wideningToInteger = o ->
Optional.ofNullable((Number)o)
+ .map(Number::intValue)
+ .orElse(null);
+
+ standardConverterMap.put(Pair.of(INTEGER_CLASS, BYTE_CLASS),
wideningToInteger);
standardConverterMap.put(Pair.of(INTEGER_CLASS, SHORT_CLASS),
wideningToInteger);
+ standardConverterMap.put(Pair.of(INTEGER_CLASS, BYTE_TYPE),
wideningToInteger);
standardConverterMap.put(Pair.of(INTEGER_CLASS, SHORT_TYPE),
wideningToInteger);
/* string to int */
- Converter<Integer> stringToInteger = new Converter<Integer>()
- {
- @Override
- public Integer convert(Object o)
- {
- return Integer.valueOf(String.valueOf(o));
- }
- };
+
+ Converter<Integer> stringToInteger = o ->
Integer.valueOf(String.valueOf(o));
+
standardConverterMap.put(Pair.of(INTEGER_CLASS, STRING_CLASS),
stringToInteger);
standardConverterMap.put(Pair.of(INTEGER_TYPE, STRING_CLASS),
stringToInteger);
+ /*
+ * Conversions towards long
+ */
+
/* narrowing towards long */
- Converter<Long> narrowingToLong = new Converter<Long>()
- {
- @Override
- public Long convert(Object o)
- {
- if (o == null) return null;
- double d = ((Number)o).doubleValue();
- if (d < minLong || d > maxLong)
- {
- throw new NumberFormatException("value out of range for
long type: " + d);
- }
- return ((Number) o).longValue();
- }
- };
+
+ Converter<Long> narrowingToLong = o -> Optional.ofNullable((Number)o)
+ .filter(n -> checkBounds(n, Long.MIN_VALUE, Long.MAX_VALUE))
+ .map(Number::longValue)
+ .orElse(null);
+
+ Converter<Long> narrowingBigIntegerToLong = o ->
Optional.ofNullable((BigInteger)o)
+ .map(BigInteger::longValueExact)
+ .orElse(null);
+
+ Converter<Long> narrowingBigDecimalToLong = o ->
Optional.ofNullable((BigDecimal)o)
+ .map(BigDecimal::longValueExact)
+ .orElse(null);
+
+ standardConverterMap.put(Pair.of(LONG_CLASS, BIG_INTEGER_CLASS),
narrowingBigIntegerToLong);
standardConverterMap.put(Pair.of(LONG_CLASS, FLOAT_CLASS),
narrowingToLong);
standardConverterMap.put(Pair.of(LONG_CLASS, DOUBLE_CLASS),
narrowingToLong);
+ standardConverterMap.put(Pair.of(LONG_CLASS, BIG_DECIMAL_CLASS),
narrowingBigDecimalToLong);
standardConverterMap.put(Pair.of(LONG_CLASS, NUMBER_CLASS),
narrowingToLong);
standardConverterMap.put(Pair.of(LONG_CLASS, FLOAT_TYPE),
narrowingToLong);
standardConverterMap.put(Pair.of(LONG_CLASS, DOUBLE_TYPE),
narrowingToLong);
+ standardConverterMap.put(Pair.of(LONG_TYPE, BIG_INTEGER_CLASS),
narrowingBigIntegerToLong);
standardConverterMap.put(Pair.of(LONG_TYPE, FLOAT_CLASS),
narrowingToLong);
standardConverterMap.put(Pair.of(LONG_TYPE, DOUBLE_CLASS),
narrowingToLong);
+ standardConverterMap.put(Pair.of(LONG_TYPE, BIG_DECIMAL_CLASS),
narrowingBigDecimalToLong);
standardConverterMap.put(Pair.of(LONG_TYPE, NUMBER_CLASS),
narrowingToLong);
standardConverterMap.put(Pair.of(LONG_TYPE, FLOAT_TYPE),
narrowingToLong);
standardConverterMap.put(Pair.of(LONG_TYPE, DOUBLE_TYPE),
narrowingToLong);
- /* widening towards Long */
- Converter<Long> wideningToLong = new Converter<Long>()
- {
- @Override
- public Long convert(Object o)
- {
- if (o == null) return null;
- return ((Number) o).longValue();
- }
- };
+ /* widening towards long */
+
+ Converter<Long> wideningToLong = o -> Optional.ofNullable((Number)o)
+ .map(Number::longValue)
+ .orElse(null);
+
+ standardConverterMap.put(Pair.of(LONG_CLASS, BYTE_CLASS),
wideningToLong);
standardConverterMap.put(Pair.of(LONG_CLASS, SHORT_CLASS),
wideningToLong);
standardConverterMap.put(Pair.of(LONG_CLASS, INTEGER_CLASS),
wideningToLong);
+ standardConverterMap.put(Pair.of(LONG_CLASS, BYTE_TYPE),
wideningToLong);
standardConverterMap.put(Pair.of(LONG_CLASS, SHORT_TYPE),
wideningToLong);
standardConverterMap.put(Pair.of(LONG_CLASS, INTEGER_TYPE),
wideningToLong);
/* string to long */
- Converter<Long> stringToLong = new Converter<Long>()
- {
- @Override
- public Long convert(Object o)
- {
- return Long.valueOf(String.valueOf(o));
- }
- };
+
+ Converter<Long> stringToLong = o -> Long.valueOf(String.valueOf(o));
+
standardConverterMap.put(Pair.of(LONG_CLASS, STRING_CLASS),
stringToLong);
standardConverterMap.put(Pair.of(LONG_TYPE, STRING_CLASS),
stringToLong);
+ /*
+ * Conversions towards BigInteger
+ */
+
+ /* exact types towards BigInteger */
+
+ Converter<BigInteger> toBigInteger = o ->
Optional.ofNullable((Number)o)
+ .map(n -> BigInteger.valueOf(n.longValue()))
+ .orElse(null);
+
+ standardConverterMap.put(Pair.of(BIG_INTEGER_CLASS, BYTE_CLASS),
toBigInteger);
+ standardConverterMap.put(Pair.of(BIG_INTEGER_CLASS, SHORT_CLASS),
toBigInteger);
+ standardConverterMap.put(Pair.of(BIG_INTEGER_CLASS, INTEGER_CLASS),
toBigInteger);
+ standardConverterMap.put(Pair.of(BIG_INTEGER_CLASS, LONG_CLASS),
toBigInteger);
+ standardConverterMap.put(Pair.of(BIG_INTEGER_CLASS, BYTE_TYPE),
toBigInteger);
+ standardConverterMap.put(Pair.of(BIG_INTEGER_CLASS, SHORT_TYPE),
toBigInteger);
+ standardConverterMap.put(Pair.of(BIG_INTEGER_CLASS, INTEGER_TYPE),
toBigInteger);
+ standardConverterMap.put(Pair.of(BIG_INTEGER_CLASS, LONG_TYPE),
toBigInteger);
+
+ /* approximate types towards BigInteger */
+
+ /* It makes no sense trying to convert from float or double towards
BigInteger
+ if we do care about precision loss..
+ */
+
+ Converter<BigInteger> bigDecimalToBigInteger = o ->
Optional.ofNullable((BigDecimal)o)
+ .map(BigDecimal::toBigIntegerExact)
+ .orElse(null);
+
+ standardConverterMap.put(Pair.of(BIG_INTEGER_CLASS,
BIG_DECIMAL_CLASS), bigDecimalToBigInteger);
+
+ /* string to BigInteger */
+
+ Converter<BigInteger> stringToBigInteger = o -> Optional.ofNullable(o)
+ .map(s -> new BigInteger(String.valueOf(s)))
+ .orElse(null);
+
+ standardConverterMap.put(Pair.of(BIG_INTEGER_CLASS, STRING_CLASS),
stringToBigInteger);
+
+ /*
+ * Conversions towards float
+ */
+
+ Converter<Float> toFloat = o -> Optional.ofNullable((Number)o)
+ .map(Number::floatValue)
+ .orElse(null);
+
/* narrowing towards float */
- Converter<Float> narrowingToFloat = new Converter<Float>()
- {
- @Override
- public Float convert(Object o)
- {
- return o == null ? null : ((Number) o).floatValue();
- }
- };
- standardConverterMap.put(Pair.of(FLOAT_CLASS, DOUBLE_CLASS),
narrowingToFloat);
- standardConverterMap.put(Pair.of(FLOAT_CLASS, NUMBER_CLASS),
narrowingToFloat);
- standardConverterMap.put(Pair.of(FLOAT_CLASS, DOUBLE_TYPE),
narrowingToFloat);
- standardConverterMap.put(Pair.of(FLOAT_TYPE, DOUBLE_CLASS),
narrowingToFloat);
- standardConverterMap.put(Pair.of(FLOAT_TYPE, NUMBER_CLASS),
narrowingToFloat);
- standardConverterMap.put(Pair.of(FLOAT_TYPE, DOUBLE_TYPE),
narrowingToFloat);
- /* exact towards Float */
- Converter<Float> toFloat = new Converter<Float>()
- {
- @Override
- public Float convert(Object o)
- {
- if (o == null) return null;
- return ((Number) o).floatValue();
- }
- };
+ standardConverterMap.put(Pair.of(FLOAT_CLASS, BIG_INTEGER_CLASS),
toFloat);
+ standardConverterMap.put(Pair.of(FLOAT_CLASS, DOUBLE_CLASS), toFloat);
+ standardConverterMap.put(Pair.of(FLOAT_CLASS, BIG_DECIMAL_CLASS),
toFloat);
+ standardConverterMap.put(Pair.of(FLOAT_CLASS, NUMBER_CLASS), toFloat);
+ standardConverterMap.put(Pair.of(FLOAT_CLASS, DOUBLE_TYPE), toFloat);
+ standardConverterMap.put(Pair.of(FLOAT_TYPE, BIG_INTEGER_CLASS),
toFloat);
+ standardConverterMap.put(Pair.of(FLOAT_TYPE, DOUBLE_CLASS), toFloat);
+ standardConverterMap.put(Pair.of(FLOAT_TYPE, BIG_DECIMAL_CLASS),
toFloat);
+ standardConverterMap.put(Pair.of(FLOAT_TYPE, NUMBER_CLASS), toFloat);
+ standardConverterMap.put(Pair.of(FLOAT_TYPE, DOUBLE_TYPE), toFloat);
+
+ /* exact types towards float */
+
+ standardConverterMap.put(Pair.of(FLOAT_CLASS, BYTE_CLASS), toFloat);
standardConverterMap.put(Pair.of(FLOAT_CLASS, SHORT_CLASS), toFloat);
standardConverterMap.put(Pair.of(FLOAT_CLASS, INTEGER_CLASS), toFloat);
standardConverterMap.put(Pair.of(FLOAT_CLASS, LONG_CLASS), toFloat);
+ standardConverterMap.put(Pair.of(FLOAT_CLASS, BYTE_TYPE), toFloat);
standardConverterMap.put(Pair.of(FLOAT_CLASS, SHORT_TYPE), toFloat);
standardConverterMap.put(Pair.of(FLOAT_CLASS, INTEGER_TYPE), toFloat);
standardConverterMap.put(Pair.of(FLOAT_CLASS, LONG_TYPE), toFloat);
/* string to float */
- Converter<Float> stringToFloat = new Converter<Float>()
- {
- @Override
- public Float convert(Object o)
- {
- return Float.valueOf(String.valueOf(o));
- }
- };
+
+ Converter<Float> stringToFloat = o -> Float.valueOf(String.valueOf(o));
+
standardConverterMap.put(Pair.of(FLOAT_CLASS, STRING_CLASS),
stringToFloat);
standardConverterMap.put(Pair.of(FLOAT_TYPE, STRING_CLASS),
stringToFloat);
- /* exact or widening towards Double */
- Converter<Double> toDouble = new Converter<Double>()
- {
- @Override
- public Double convert(Object o)
- {
- if (o == null) return null;
- return ((Number) o).doubleValue();
- }
- };
+ /*
+ * Conversions towards double
+ */
+
+ Converter<Double> toDouble = o -> Optional.ofNullable((Number)o)
+ .map(Number::doubleValue)
+ .orElse(null);
+
+ /* narrowing towards double */
+
+ standardConverterMap.put(Pair.of(DOUBLE_CLASS, BIG_INTEGER_CLASS),
toDouble);
+ standardConverterMap.put(Pair.of(DOUBLE_CLASS, BIG_DECIMAL_CLASS),
toDouble);
+ standardConverterMap.put(Pair.of(DOUBLE_TYPE, BIG_INTEGER_CLASS),
toDouble);
+ standardConverterMap.put(Pair.of(DOUBLE_TYPE, BIG_DECIMAL_CLASS),
toDouble);
+
+ /* exact types or widening towards double */
+
+ standardConverterMap.put(Pair.of(DOUBLE_CLASS, BYTE_CLASS), toDouble);
standardConverterMap.put(Pair.of(DOUBLE_CLASS, SHORT_CLASS), toDouble);
standardConverterMap.put(Pair.of(DOUBLE_CLASS, INTEGER_CLASS),
toDouble);
standardConverterMap.put(Pair.of(DOUBLE_CLASS, LONG_CLASS), toDouble);
standardConverterMap.put(Pair.of(DOUBLE_CLASS, FLOAT_CLASS), toDouble);
standardConverterMap.put(Pair.of(DOUBLE_CLASS, NUMBER_CLASS),
toDouble);
+ standardConverterMap.put(Pair.of(DOUBLE_CLASS, BYTE_TYPE), toDouble);
standardConverterMap.put(Pair.of(DOUBLE_CLASS, SHORT_TYPE), toDouble);
standardConverterMap.put(Pair.of(DOUBLE_CLASS, INTEGER_TYPE),
toDouble);
standardConverterMap.put(Pair.of(DOUBLE_CLASS, LONG_TYPE), toDouble);
@@ -439,92 +493,112 @@ public class TypeConversionHandlerImpl i
standardConverterMap.put(Pair.of(DOUBLE_TYPE, NUMBER_CLASS), toDouble);
/* string to double */
- Converter<Double> stringToDouble = new Converter<Double>()
- {
- @Override
- public Double convert(Object o)
- {
- return Double.valueOf(String.valueOf(o));
- }
- };
+
+ Converter<Double> stringToDouble = o ->
Double.valueOf(String.valueOf(o));
+
standardConverterMap.put(Pair.of(DOUBLE_CLASS, STRING_CLASS),
stringToDouble);
standardConverterMap.put(Pair.of(DOUBLE_TYPE, STRING_CLASS),
stringToDouble);
+ /*
+ * Conversions towards BigDecimal
+ */
+
+ /* exact types towards BigDecimal */
+
+ Converter<BigDecimal> exactToBigDecimal = o ->
Optional.ofNullable((Number)o)
+ .map(n -> BigDecimal.valueOf(n.longValue()))
+ .orElse(null);
+
+ Converter<BigDecimal> bigIntegerToBigDecimal = o ->
Optional.ofNullable((BigInteger)o)
+ .map(bi -> new BigDecimal(bi))
+ .orElse(null);
+
+ standardConverterMap.put(Pair.of(BIG_DECIMAL_CLASS, BYTE_CLASS),
exactToBigDecimal);
+ standardConverterMap.put(Pair.of(BIG_DECIMAL_CLASS, SHORT_CLASS),
exactToBigDecimal);
+ standardConverterMap.put(Pair.of(BIG_DECIMAL_CLASS, INTEGER_CLASS),
exactToBigDecimal);
+ standardConverterMap.put(Pair.of(BIG_DECIMAL_CLASS, LONG_CLASS),
exactToBigDecimal);
+ standardConverterMap.put(Pair.of(BIG_DECIMAL_CLASS,
BIG_INTEGER_CLASS), bigIntegerToBigDecimal);
+ standardConverterMap.put(Pair.of(BIG_DECIMAL_CLASS, BYTE_TYPE),
exactToBigDecimal);
+ standardConverterMap.put(Pair.of(BIG_DECIMAL_CLASS, SHORT_TYPE),
exactToBigDecimal);
+ standardConverterMap.put(Pair.of(BIG_DECIMAL_CLASS, INTEGER_TYPE),
exactToBigDecimal);
+ standardConverterMap.put(Pair.of(BIG_DECIMAL_CLASS, LONG_TYPE),
exactToBigDecimal);
+
+ /* approximate types towards BigDecimal */
+
+ Converter<BigDecimal> approxToBigDecimal = o ->
Optional.ofNullable((Number)o)
+ .map(n -> BigDecimal.valueOf(n.doubleValue()))
+ .orElse(null);
+
+ standardConverterMap.put(Pair.of(BIG_DECIMAL_CLASS, FLOAT_CLASS),
approxToBigDecimal);
+ standardConverterMap.put(Pair.of(BIG_DECIMAL_CLASS, DOUBLE_CLASS),
approxToBigDecimal);
+ standardConverterMap.put(Pair.of(BIG_DECIMAL_CLASS, FLOAT_TYPE),
approxToBigDecimal);
+ standardConverterMap.put(Pair.of(BIG_DECIMAL_CLASS, DOUBLE_TYPE),
approxToBigDecimal);
+
+ /* string to BigDecimal */
+
+ Converter<BigDecimal> stringToBigDecimal = o -> Optional.ofNullable(o)
+ .map(s -> new BigDecimal(String.valueOf(s)))
+ .orElse(null);
+
+ standardConverterMap.put(Pair.of(BIG_DECIMAL_CLASS, STRING_CLASS),
stringToBigDecimal);
+
+ /*
+ * Conversions from boolean to numeric type
+ */
+
/* boolean to byte */
- Converter<Byte> booleanToByte = new Converter<Byte>()
- {
- @Override
- public Byte convert(Object o)
- {
- return o == null ? null : (Boolean) o ? (byte)1 : (byte)0;
- }
- };
+
+ Converter<Byte> booleanToByte = o -> Optional.ofNullable((Boolean)o)
+ .map(b -> b ? (byte)1 : (byte)0)
+ .orElse(null);
+
standardConverterMap.put(Pair.of(BYTE_CLASS, BOOLEAN_CLASS),
booleanToByte);
standardConverterMap.put(Pair.of(BYTE_CLASS, BOOLEAN_TYPE),
booleanToByte);
standardConverterMap.put(Pair.of(BYTE_TYPE, BOOLEAN_CLASS),
booleanToByte);
standardConverterMap.put(Pair.of(BYTE_TYPE, BOOLEAN_TYPE),
booleanToByte);
/* boolean to short */
- Converter<Short> booleanToShort = new Converter<Short>()
- {
- @Override
- public Short convert(Object o)
- {
- return o == null ? null : (Boolean) o ? (short)1 : (short)0;
- }
- };
+
+ Converter<Short> booleanToShort = o -> Optional.ofNullable((Boolean)o)
+ .map(b -> b ? (short)1 : (short)0)
+ .orElse(null);
+
standardConverterMap.put(Pair.of(SHORT_CLASS, BOOLEAN_CLASS),
booleanToShort);
standardConverterMap.put(Pair.of(SHORT_CLASS, BOOLEAN_TYPE),
booleanToShort);
standardConverterMap.put(Pair.of(SHORT_TYPE, BOOLEAN_CLASS),
booleanToShort);
standardConverterMap.put(Pair.of(SHORT_TYPE, BOOLEAN_TYPE),
booleanToShort);
/* boolean to integer */
- Converter<Integer> booleanToInteger = new Converter<Integer>()
- {
- @Override
- public Integer convert(Object o)
- {
- return o == null ? null : (Boolean) o ? (Integer)1 :
(Integer)0;
- }
- };
+
+ Converter<Integer> booleanToInteger = o ->
Optional.ofNullable((Boolean)o)
+ .map(b -> b ? (int)1 : (int)0)
+ .orElse(null);
+
standardConverterMap.put(Pair.of(INTEGER_CLASS, BOOLEAN_CLASS),
booleanToInteger);
standardConverterMap.put(Pair.of(INTEGER_CLASS, BOOLEAN_TYPE),
booleanToInteger);
standardConverterMap.put(Pair.of(INTEGER_TYPE, BOOLEAN_CLASS),
booleanToInteger);
standardConverterMap.put(Pair.of(INTEGER_TYPE, BOOLEAN_TYPE),
booleanToInteger);
- /* boolean to lonf */
- Converter<Long> booleanToLong = new Converter<Long>()
- {
- @Override
- public Long convert(Object o)
- {
- return o == null ? null : (Boolean) o ? 1L : 0L;
- }
- };
+ /* boolean to long */
+
+ Converter<Long> booleanToLong = o -> Optional.ofNullable((Boolean)o)
+ .map(b -> b ? 1l : 0l)
+ .orElse(null);
+
standardConverterMap.put(Pair.of(LONG_CLASS, BOOLEAN_CLASS),
booleanToLong);
standardConverterMap.put(Pair.of(LONG_CLASS, BOOLEAN_TYPE),
booleanToLong);
standardConverterMap.put(Pair.of(LONG_TYPE, BOOLEAN_CLASS),
booleanToLong);
standardConverterMap.put(Pair.of(LONG_TYPE, BOOLEAN_TYPE),
booleanToLong);
/* to string */
- toString = new Converter<String>()
- {
- @Override
- public String convert(Object o)
- {
- return String.valueOf(o);
- }
- };
+
+ toString = o -> String.valueOf(o);
/* string to locale */
- Converter<Locale> stringToLocale = new Converter<Locale>()
- {
- @Override
- public Locale convert(Object o)
- {
- return o == null ? null : LocaleUtils.toLocale((String)o);
- }
- };
+ Converter<Locale> stringToLocale = o -> Optional.ofNullable(o)
+ .map(l -> LocaleUtils.toLocale(String.valueOf(l)))
+ .orElse(null);
+
standardConverterMap.put(Pair.of(LOCALE_CLASS, STRING_CLASS),
stringToLocale);
}
@@ -607,14 +681,7 @@ public class TypeConversionHandlerImpl i
else if (formalClass != null && formalClass.isEnum() && actual
== String.class)
{
final Class<Enum> enumClass = (Class<Enum>)formalClass;
- converter = new Converter()
- {
- @Override
- public Object convert(Object o)
- {
- return Enum.valueOf(enumClass, (String) o);
- }
- };
+ converter = o -> Enum.valueOf(enumClass, (String)o);
}
converterCacheMap.put(key, converter == null ? cacheMiss :
converter);
Modified:
velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/UberspectImpl.java
URL:
http://svn.apache.org/viewvc/velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/UberspectImpl.java?rev=1870761&r1=1870760&r2=1870761&view=diff
==============================================================================
---
velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/UberspectImpl.java
(original)
+++
velocity/engine/trunk/velocity-engine-core/src/main/java/org/apache/velocity/util/introspection/UberspectImpl.java
Tue Dec 3 16:57:12 2019
@@ -526,13 +526,22 @@ public class UberspectImpl implements Ub
if (converters != null)
{
- for (int i = 0; i < actual.length; ++i)
+ // some converters may throw an ArithmeticException
+ // which we want to wrap into an IllegalArgumentException
+ try
{
- if (converters[i] != null)
+ for (int i = 0; i < actual.length; ++i)
{
- actual[i] = converters[i].convert(actual[i]);
+ if (converters[i] != null)
+ {
+ actual[i] = converters[i].convert(actual[i]);
+ }
}
}
+ catch (ArithmeticException ae)
+ {
+ throw new IllegalArgumentException(ae);
+ }
}
// call extension point invocation
Modified:
velocity/engine/trunk/velocity-engine-core/src/test/java/org/apache/velocity/test/util/introspection/ConversionHandlerTestCase.java
URL:
http://svn.apache.org/viewvc/velocity/engine/trunk/velocity-engine-core/src/test/java/org/apache/velocity/test/util/introspection/ConversionHandlerTestCase.java?rev=1870761&r1=1870760&r2=1870761&view=diff
==============================================================================
---
velocity/engine/trunk/velocity-engine-core/src/test/java/org/apache/velocity/test/util/introspection/ConversionHandlerTestCase.java
(original)
+++
velocity/engine/trunk/velocity-engine-core/src/test/java/org/apache/velocity/test/util/introspection/ConversionHandlerTestCase.java
Tue Dec 3 16:57:12 2019
@@ -45,6 +45,8 @@ import java.io.OutputStreamWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.Type;
+import java.math.BigDecimal;
+import java.math.BigInteger;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
@@ -331,6 +333,14 @@ public class ConversionHandlerTestCase e
map.put("T. string-floating", new String("123.345"));
map.put("U. null", null);
map.put("V. locale", "fr_FR");
+ map.put("W. BigInteger zero", BigInteger.ZERO);
+ map.put("X. BigInteger one", BigInteger.ONE);
+ map.put("Y. BigInteger ten", BigInteger.TEN);
+ map.put("Y. BigInteger bigint", new
BigInteger("12345678901234567890"));
+ map.put("Z. BigDecimal zero", BigDecimal.ZERO);
+ map.put("ZA. BigDecimal one", BigDecimal.ONE);
+ map.put("ZB. BigDecimal ten", BigDecimal.TEN);
+ map.put("ZC. BigDecimal bigdec", new
BigDecimal("12345678901234567890.01234567890123456789"));
context.put("map", map);
context.put("target", new Obj());
Class[] types =
@@ -349,8 +359,10 @@ public class ConversionHandlerTestCase e
Short.class,
Integer.class,
Long.class,
+ BigInteger.class,
Float.class,
Double.class,
+ BigDecimal.class,
Number.class,
String.class,
Object.class
@@ -378,8 +390,10 @@ public class ConversionHandlerTestCase e
public String objectShort(Short s) { return "Short ok: " + s; }
public String objectInt(Integer i) { return "Integer ok: " + i; }
public String objectLong(Long l) { return "Long ok: " + l; }
+ public String objectBigInteger(BigInteger bi) { return "BigInteger ok:
" + bi; }
public String objectFloat(Float f) { return "Float ok: " + f; }
public String objectDouble(Double d) { return "Double ok: " + d; }
+ public String objectBigDecimal(BigDecimal bd) { return "BigDecimal ok:
" + bd; }
public String objectCharacter(Character c) { return "Character ok: " +
c; }
public String objectNumber(Number b) { return "Number ok: " + b; }
public String objectObject(Object o) { return "Object ok: " + o; }
Modified:
velocity/engine/trunk/velocity-engine-core/src/test/resources/conversion/compare/matrix.cmp
URL:
http://svn.apache.org/viewvc/velocity/engine/trunk/velocity-engine-core/src/test/resources/conversion/compare/matrix.cmp?rev=1870761&r1=1870760&r2=1870761&view=diff
==============================================================================
---
velocity/engine/trunk/velocity-engine-core/src/test/resources/conversion/compare/matrix.cmp
(original)
+++
velocity/engine/trunk/velocity-engine-core/src/test/resources/conversion/compare/matrix.cmp
Tue Dec 3 16:57:12 2019
@@ -1,3 +1,5 @@
+<!doctype html>
+
@@ -54,8 +56,10 @@
<th>Short</th>
<th>Integer</th>
<th>Long</th>
+ <th>BigInteger</th>
<th>Float</th>
<th>Double</th>
+ <th>BigDecimal</th>
<th>Number</th>
<th>String</th>
<th>Object</th>
@@ -81,6 +85,8 @@
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
</tr>
@@ -106,6 +112,8 @@
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
+ <td><span class="none">none</span></td>
+ <td><span class="none">none</span></td>
</tr>
<tr>
<th>byte</th>
@@ -127,6 +135,8 @@
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
</tr>
@@ -150,6 +160,8 @@
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
</tr>
@@ -173,6 +185,8 @@
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
</tr>
@@ -196,6 +210,8 @@
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
</tr>
@@ -215,10 +231,12 @@
<td><span class="implicit">implicit</span></td>
<td><span class="implicit">implicit</span></td>
<td><span class="implicit">implicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="implicit">implicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
</tr>
@@ -238,10 +256,12 @@
<td><span class="implicit">implicit</span></td>
<td><span class="implicit">implicit</span></td>
<td><span class="implicit">implicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="implicit">implicit</span></td>
<td><span class="implicit">implicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
</tr>
@@ -265,6 +285,8 @@
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
<td><span class="strict">strict</span></td>
</tr>
@@ -289,6 +311,8 @@
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
+ <td><span class="none">none</span></td>
+ <td><span class="none">none</span></td>
<td><span class="strict">strict</span></td>
</tr>
<tr>
@@ -311,6 +335,8 @@
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
<td><span class="strict">strict</span></td>
</tr>
@@ -318,7 +344,7 @@
<th>Short</th>
<td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
- <td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="implicit">implicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
@@ -326,7 +352,7 @@
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
- <td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="strict">strict</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
@@ -334,6 +360,8 @@
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
<td><span class="strict">strict</span></td>
</tr>
@@ -341,7 +369,7 @@
<th>Integer</th>
<td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
- <td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="implicit">implicit</span></td>
<td><span class="explicit">explicit</span></td>
@@ -349,7 +377,7 @@
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
- <td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="strict">strict</span></td>
<td><span class="explicit">explicit</span></td>
@@ -357,6 +385,8 @@
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
<td><span class="strict">strict</span></td>
</tr>
@@ -364,7 +394,7 @@
<th>Long</th>
<td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
- <td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="implicit">implicit</span></td>
@@ -372,7 +402,7 @@
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
- <td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="strict">strict</span></td>
@@ -380,29 +410,58 @@
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
<td><span class="strict">strict</span></td>
</tr>
<tr>
- <th>Float</th>
+ <th>BigInteger</th>
+ <td><span class="none">none</span></td>
+ <td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="none">none</span></td>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
- <td><span class="implicit">implicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="strict">strict</span></td>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="none">none</span></td>
+ <td><span class="strict">strict</span></td>
+ </tr>
+ <tr>
+ <th>Float</th>
+ <td><span class="none">none</span></td>
+ <td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="implicit">implicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="none">none</span></td>
<td><span class="none">none</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="strict">strict</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
<td><span class="strict">strict</span></td>
</tr>
@@ -410,7 +469,7 @@
<th>Double</th>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
- <td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
@@ -418,7 +477,8 @@
<td><span class="implicit">implicit</span></td>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
- <td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
@@ -426,6 +486,32 @@
<td><span class="strict">strict</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="none">none</span></td>
+ <td><span class="strict">strict</span></td>
+ </tr>
+ <tr>
+ <th>BigDecimal</th>
+ <td><span class="none">none</span></td>
+ <td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="none">none</span></td>
+ <td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="strict">strict</span></td>
+ <td><span class="none">none</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="none">none</span></td>
<td><span class="strict">strict</span></td>
</tr>
@@ -448,6 +534,8 @@
<td><span class="strict">strict</span></td>
<td><span class="strict">strict</span></td>
<td><span class="strict">strict</span></td>
+ <td><span class="strict">strict</span></td>
+ <td><span class="strict">strict</span></td>
<td><span class="none">none</span></td>
<td><span class="none">none</span></td>
<td><span class="strict">strict</span></td>
@@ -471,6 +559,8 @@
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
+ <td><span class="explicit">explicit</span></td>
<td><span class="strict">strict</span></td>
<td><span class="explicit">explicit</span></td>
<td><span class="strict">strict</span></td>
@@ -488,6 +578,8 @@
<td><span class="strict">strict</span></td>
<td><span class="strict">strict</span></td>
<td><span class="strict">strict</span></td>
+ <td><span class="strict">strict</span></td>
+ <td><span class="strict">strict</span></td>
<td><span class="strict">strict</span></td>
<td><span class="strict">strict</span></td>
<td><span class="strict">strict</span></td>
Modified:
velocity/engine/trunk/velocity-engine-core/src/test/resources/conversion/compare/test_conv_with_handler.cmp
URL:
http://svn.apache.org/viewvc/velocity/engine/trunk/velocity-engine-core/src/test/resources/conversion/compare/test_conv_with_handler.cmp?rev=1870761&r1=1870760&r2=1870761&view=diff
==============================================================================
---
velocity/engine/trunk/velocity-engine-core/src/test/resources/conversion/compare/test_conv_with_handler.cmp
(original)
+++
velocity/engine/trunk/velocity-engine-core/src/test/resources/conversion/compare/test_conv_with_handler.cmp
Tue Dec 3 16:57:12 2019
@@ -12,8 +12,10 @@ A. bool-true Value java.lang.Boolean tru
Short ok: 1
Integer ok: 1
Long ok: 1
+ $target.objectBigInteger($value)
$target.objectFloat($value)
$target.objectDouble($value)
+ $target.objectBigDecimal($value)
$target.objectCharacter($value)
$target.objectNumber($value)
Object ok: true
@@ -42,8 +44,10 @@ B. bool-false Value java.lang.Boolean fa
Short ok: 0
Integer ok: 0
Long ok: 0
+ $target.objectBigInteger($value)
$target.objectFloat($value)
$target.objectDouble($value)
+ $target.objectBigDecimal($value)
$target.objectCharacter($value)
$target.objectNumber($value)
Object ok: false
@@ -69,11 +73,13 @@ C. byte-0 Value java.lang.Byte 0
$target.integralChar($value)
Boolean ok: false
Byte ok: 0
- $target.objectShort($value)
- $target.objectInt($value)
- $target.objectLong($value)
- $target.objectFloat($value)
- $target.objectDouble($value)
+ Short ok: 0
+ Integer ok: 0
+ Long ok: 0
+ BigInteger ok: 0
+ Float ok: 0.0
+ Double ok: 0.0
+ BigDecimal ok: 0
$target.objectCharacter($value)
Number ok: 0
Object ok: 0
@@ -99,11 +105,13 @@ D. byte-1 Value java.lang.Byte 1
$target.integralChar($value)
Boolean ok: true
Byte ok: 1
- $target.objectShort($value)
- $target.objectInt($value)
- $target.objectLong($value)
- $target.objectFloat($value)
- $target.objectDouble($value)
+ Short ok: 1
+ Integer ok: 1
+ Long ok: 1
+ BigInteger ok: 1
+ Float ok: 1.0
+ Double ok: 1.0
+ BigDecimal ok: 1
$target.objectCharacter($value)
Number ok: 1
Object ok: 1
@@ -132,8 +140,10 @@ E. short Value java.lang.Short 125
Short ok: 125
Integer ok: 125
Long ok: 125
+ BigInteger ok: 125
Float ok: 125.0
Double ok: 125.0
+ BigDecimal ok: 125
$target.objectCharacter($value)
Number ok: 125
Object ok: 125
@@ -150,7 +160,7 @@ E. short Value java.lang.Short 125
$target.locale($value)
F. int Value java.lang.Integer 24323
boolean ok: true
- integralByte -> NumberFormatException: value out of range for byte type:
24323
+ integralByte -> NumberFormatException: value out of range: 24323
short ok: 24323
int ok: 24323
long ok: 24323
@@ -158,12 +168,14 @@ F. int Value java.lang.Integer 24323
double ok: 24323.0
$target.integralChar($value)
Boolean ok: true
- objectByte -> NumberFormatException: value out of range for byte type: 24323
+ objectByte -> NumberFormatException: value out of range: 24323
Short ok: 24323
Integer ok: 24323
Long ok: 24323
+ BigInteger ok: 24323
Float ok: 24323.0
Double ok: 24323.0
+ BigDecimal ok: 24323
$target.objectCharacter($value)
Number ok: 24323
Object ok: 24323
@@ -180,20 +192,22 @@ F. int Value java.lang.Integer 24323
$target.locale($value)
G. long Value java.lang.Long 5235235
boolean ok: true
- integralByte -> NumberFormatException: value out of range for byte type:
5235235
- integralShort -> NumberFormatException: value out of range for short type:
5235235
+ integralByte -> NumberFormatException: value out of range: 5235235
+ integralShort -> NumberFormatException: value out of range: 5235235
int ok: 5235235
long ok: 5235235
float ok: 5235235.0
double ok: 5235235.0
$target.integralChar($value)
Boolean ok: true
- objectByte -> NumberFormatException: value out of range for byte type:
5235235
- objectShort -> NumberFormatException: value out of range for short type:
5235235
+ objectByte -> NumberFormatException: value out of range: 5235235
+ objectShort -> NumberFormatException: value out of range: 5235235
Integer ok: 5235235
Long ok: 5235235
+ BigInteger ok: 5235235
Float ok: 5235235.0
Double ok: 5235235.0
+ BigDecimal ok: 5235235
$target.objectCharacter($value)
Number ok: 5235235
Object ok: 5235235
@@ -210,20 +224,22 @@ G. long Value java.lang.Long 5235235
$target.locale($value)
H. float Value java.lang.Float 34523.344
boolean ok: true
- integralByte -> NumberFormatException: value out of range for byte type:
34523
- integralShort -> NumberFormatException: value out of range for short type:
34523
+ integralByte -> NumberFormatException: value out of range: 34523.344
+ integralShort -> NumberFormatException: value out of range: 34523.344
int ok: 34523
long ok: 34523
float ok: 34523.344
double ok: 34523.34375
$target.integralChar($value)
Boolean ok: true
- objectByte -> NumberFormatException: value out of range for byte type: 34523
- objectShort -> NumberFormatException: value out of range for short type:
34523
+ objectByte -> NumberFormatException: value out of range: 34523.344
+ objectShort -> NumberFormatException: value out of range: 34523.344
Integer ok: 34523
Long ok: 34523
+ $target.objectBigInteger($value)
Float ok: 34523.344
Double ok: 34523.34375
+ BigDecimal ok: 34523.34375
$target.objectCharacter($value)
Number ok: 34523.344
Object ok: 34523.344
@@ -240,20 +256,22 @@ H. float Value java.lang.Float 34523.344
$target.locale($value)
I. double Value java.lang.Double 54235.3253
boolean ok: true
- integralByte -> NumberFormatException: value out of range for byte type:
54235
- integralShort -> NumberFormatException: value out of range for short type:
54235
+ integralByte -> NumberFormatException: value out of range: 54235.3253
+ integralShort -> NumberFormatException: value out of range: 54235.3253
int ok: 54235
long ok: 54235
float ok: 54235.324
double ok: 54235.3253
$target.integralChar($value)
Boolean ok: true
- objectByte -> NumberFormatException: value out of range for byte type: 54235
- objectShort -> NumberFormatException: value out of range for short type:
54235
+ objectByte -> NumberFormatException: value out of range: 54235.3253
+ objectShort -> NumberFormatException: value out of range: 54235.3253
Integer ok: 54235
Long ok: 54235
+ $target.objectBigInteger($value)
Float ok: 54235.324
Double ok: 54235.3253
+ BigDecimal ok: 54235.3253
$target.objectCharacter($value)
Number ok: 54235.3253
Object ok: 54235.3253
@@ -282,8 +300,10 @@ J. char Value java.lang.Character @
$target.objectShort($value)
$target.objectInt($value)
$target.objectLong($value)
+ $target.objectBigInteger($value)
$target.objectFloat($value)
$target.objectDouble($value)
+ $target.objectBigDecimal($value)
Character ok: @
$target.objectNumber($value)
Object ok: @
@@ -312,8 +332,10 @@ K. object Value org.apache.velocity.test
$target.objectShort($value)
$target.objectInt($value)
$target.objectLong($value)
+ $target.objectBigInteger($value)
$target.objectFloat($value)
$target.objectDouble($value)
+ $target.objectBigDecimal($value)
$target.objectCharacter($value)
$target.objectNumber($value)
Object ok: instance of Obj
@@ -342,8 +364,10 @@ L. enum Value org.apache.velocity.test.u
$target.objectShort($value)
$target.objectInt($value)
$target.objectLong($value)
+ $target.objectBigInteger($value)
$target.objectFloat($value)
$target.objectDouble($value)
+ $target.objectBigDecimal($value)
$target.objectCharacter($value)
$target.objectNumber($value)
Object ok: GREEN
@@ -372,8 +396,10 @@ M. string Value java.lang.String foo
objectShort -> NumberFormatException: For input string: "foo"
objectInt -> NumberFormatException: For input string: "foo"
objectLong -> NumberFormatException: For input string: "foo"
+ objectBigInteger -> NumberFormatException: For input string: "foo"
objectFloat -> NumberFormatException: For input string: "foo"
objectDouble -> NumberFormatException: For input string: "foo"
+ objectBigDecimal -> NumberFormatException: null
$target.objectCharacter($value)
$target.objectNumber($value)
Object ok: foo
@@ -402,8 +428,10 @@ M. string-green Value java.lang.String g
objectShort -> NumberFormatException: For input string: "green"
objectInt -> NumberFormatException: For input string: "green"
objectLong -> NumberFormatException: For input string: "green"
+ objectBigInteger -> NumberFormatException: For input string: "green"
objectFloat -> NumberFormatException: For input string: "green"
objectDouble -> NumberFormatException: For input string: "green"
+ objectBigDecimal -> NumberFormatException: null
$target.objectCharacter($value)
$target.objectNumber($value)
Object ok: green
@@ -432,8 +460,10 @@ N. string-empty Value java.lang.String
objectShort -> NumberFormatException: For input string: ""
objectInt -> NumberFormatException: For input string: ""
objectLong -> NumberFormatException: For input string: ""
+ objectBigInteger -> NumberFormatException: Zero length BigInteger
objectFloat -> NumberFormatException: empty String
objectDouble -> NumberFormatException: empty String
+ objectBigDecimal -> NumberFormatException: null
$target.objectCharacter($value)
$target.objectNumber($value)
Object ok:
@@ -462,8 +492,10 @@ O. string-false Value java.lang.String f
objectShort -> NumberFormatException: For input string: "false"
objectInt -> NumberFormatException: For input string: "false"
objectLong -> NumberFormatException: For input string: "false"
+ objectBigInteger -> NumberFormatException: For input string: "false"
objectFloat -> NumberFormatException: For input string: "false"
objectDouble -> NumberFormatException: For input string: "false"
+ objectBigDecimal -> NumberFormatException: null
$target.objectCharacter($value)
$target.objectNumber($value)
Object ok: false
@@ -492,8 +524,10 @@ P. string-true Value java.lang.String tr
objectShort -> NumberFormatException: For input string: "true"
objectInt -> NumberFormatException: For input string: "true"
objectLong -> NumberFormatException: For input string: "true"
+ objectBigInteger -> NumberFormatException: For input string: "true"
objectFloat -> NumberFormatException: For input string: "true"
objectDouble -> NumberFormatException: For input string: "true"
+ objectBigDecimal -> NumberFormatException: null
$target.objectCharacter($value)
$target.objectNumber($value)
Object ok: true
@@ -522,8 +556,10 @@ Q. string-zero Value java.lang.String 0
Short ok: 0
Integer ok: 0
Long ok: 0
+ BigInteger ok: 0
Float ok: 0.0
Double ok: 0.0
+ BigDecimal ok: 0
$target.objectCharacter($value)
$target.objectNumber($value)
Object ok: 0
@@ -552,8 +588,10 @@ R. string-integral Value java.lang.Strin
Short ok: 123
Integer ok: 123
Long ok: 123
+ BigInteger ok: 123
Float ok: 123.0
Double ok: 123.0
+ BigDecimal ok: 123
$target.objectCharacter($value)
$target.objectNumber($value)
Object ok: 123
@@ -582,8 +620,10 @@ S. string-big-integral Value java.lang.S
objectShort -> NumberFormatException: Value out of range. Value:"12345678"
Radix:10
Integer ok: 12345678
Long ok: 12345678
+ BigInteger ok: 12345678
Float ok: 1.2345678E7
Double ok: 1.2345678E7
+ BigDecimal ok: 12345678
$target.objectCharacter($value)
$target.objectNumber($value)
Object ok: 12345678
@@ -612,8 +652,10 @@ T. string-floating Value java.lang.Strin
objectShort -> NumberFormatException: For input string: "123.345"
objectInt -> NumberFormatException: For input string: "123.345"
objectLong -> NumberFormatException: For input string: "123.345"
+ objectBigInteger -> NumberFormatException: For input string: "123.345"
Float ok: 123.345
Double ok: 123.345
+ BigDecimal ok: 123.345
$target.objectCharacter($value)
$target.objectNumber($value)
Object ok: 123.345
@@ -642,8 +684,10 @@ U. null Value $value.class.name $value
Short ok: null
Integer ok: null
Long ok: null
+ BigInteger ok: null
Float ok: null
Double ok: null
+ BigDecimal ok: null
Character ok: null
Number ok: null
Object ok: null
@@ -672,8 +716,10 @@ V. locale Value java.lang.String fr_FR
objectShort -> NumberFormatException: For input string: "fr_FR"
objectInt -> NumberFormatException: For input string: "fr_FR"
objectLong -> NumberFormatException: For input string: "fr_FR"
+ objectBigInteger -> NumberFormatException: For input string: "fr_FR"
objectFloat -> NumberFormatException: For input string: "fr_FR"
objectDouble -> NumberFormatException: For input string: "fr_FR"
+ objectBigDecimal -> NumberFormatException: null
$target.objectCharacter($value)
$target.objectNumber($value)
Object ok: fr_FR
@@ -688,3 +734,259 @@ V. locale Value java.lang.String fr_FR
$target.valueOfDouble($value)
$target.valueOfString($value)
Locale ok: fr_FR
+W. BigInteger zero Value java.math.BigInteger 0
+ boolean ok: false
+ byte ok: 0
+ short ok: 0
+ int ok: 0
+ long ok: 0
+ float ok: 0.0
+ double ok: 0.0
+ $target.integralChar($value)
+ Boolean ok: false
+ Byte ok: 0
+ Short ok: 0
+ Integer ok: 0
+ Long ok: 0
+ BigInteger ok: 0
+ Float ok: 0.0
+ Double ok: 0.0
+ BigDecimal ok: 0
+ $target.objectCharacter($value)
+ Number ok: 0
+ Object ok: 0
+ $target.objectEnum($value)
+ String ok: 0
+ $target.valueOfBoolean($value)
+ $target.valueOfShort($value)
+ $target.valueOfByte($value)
+ $target.valueOfInt($value)
+ $target.valueOfLong($value)
+ $target.valueOfFloat($value)
+ $target.valueOfDouble($value)
+ $target.valueOfString($value)
+ $target.locale($value)
+X. BigInteger one Value java.math.BigInteger 1
+ boolean ok: true
+ byte ok: 1
+ short ok: 1
+ int ok: 1
+ long ok: 1
+ float ok: 1.0
+ double ok: 1.0
+ $target.integralChar($value)
+ Boolean ok: true
+ Byte ok: 1
+ Short ok: 1
+ Integer ok: 1
+ Long ok: 1
+ BigInteger ok: 1
+ Float ok: 1.0
+ Double ok: 1.0
+ BigDecimal ok: 1
+ $target.objectCharacter($value)
+ Number ok: 1
+ Object ok: 1
+ $target.objectEnum($value)
+ String ok: 1
+ $target.valueOfBoolean($value)
+ $target.valueOfShort($value)
+ $target.valueOfByte($value)
+ $target.valueOfInt($value)
+ $target.valueOfLong($value)
+ $target.valueOfFloat($value)
+ $target.valueOfDouble($value)
+ $target.valueOfString($value)
+ $target.locale($value)
+Y. BigInteger bigint Value java.math.BigInteger 12345678901234567890
+ boolean ok: true
+ integralByte -> IllegalArgumentException: java.lang.ArithmeticException:
BigInteger out of byte range
+ integralShort -> IllegalArgumentException: java.lang.ArithmeticException:
BigInteger out of short range
+ integralInt -> IllegalArgumentException: java.lang.ArithmeticException:
BigInteger out of int range
+ integralLong -> IllegalArgumentException: java.lang.ArithmeticException:
BigInteger out of long range
+ float ok: 1.2345679E19
+ double ok: 1.2345678901234567E19
+ $target.integralChar($value)
+ Boolean ok: true
+ objectByte -> IllegalArgumentException: java.lang.ArithmeticException:
BigInteger out of byte range
+ objectShort -> IllegalArgumentException: java.lang.ArithmeticException:
BigInteger out of short range
+ objectInt -> IllegalArgumentException: java.lang.ArithmeticException:
BigInteger out of int range
+ objectLong -> IllegalArgumentException: java.lang.ArithmeticException:
BigInteger out of long range
+ BigInteger ok: 12345678901234567890
+ Float ok: 1.2345679E19
+ Double ok: 1.2345678901234567E19
+ BigDecimal ok: 12345678901234567890
+ $target.objectCharacter($value)
+ Number ok: 12345678901234567890
+ Object ok: 12345678901234567890
+ $target.objectEnum($value)
+ String ok: 12345678901234567890
+ $target.valueOfBoolean($value)
+ $target.valueOfShort($value)
+ $target.valueOfByte($value)
+ $target.valueOfInt($value)
+ $target.valueOfLong($value)
+ $target.valueOfFloat($value)
+ $target.valueOfDouble($value)
+ $target.valueOfString($value)
+ $target.locale($value)
+Y. BigInteger ten Value java.math.BigInteger 10
+ boolean ok: true
+ byte ok: 10
+ short ok: 10
+ int ok: 10
+ long ok: 10
+ float ok: 10.0
+ double ok: 10.0
+ $target.integralChar($value)
+ Boolean ok: true
+ Byte ok: 10
+ Short ok: 10
+ Integer ok: 10
+ Long ok: 10
+ BigInteger ok: 10
+ Float ok: 10.0
+ Double ok: 10.0
+ BigDecimal ok: 10
+ $target.objectCharacter($value)
+ Number ok: 10
+ Object ok: 10
+ $target.objectEnum($value)
+ String ok: 10
+ $target.valueOfBoolean($value)
+ $target.valueOfShort($value)
+ $target.valueOfByte($value)
+ $target.valueOfInt($value)
+ $target.valueOfLong($value)
+ $target.valueOfFloat($value)
+ $target.valueOfDouble($value)
+ $target.valueOfString($value)
+ $target.locale($value)
+Z. BigDecimal zero Value java.math.BigDecimal 0
+ boolean ok: false
+ byte ok: 0
+ short ok: 0
+ int ok: 0
+ long ok: 0
+ float ok: 0.0
+ double ok: 0.0
+ $target.integralChar($value)
+ Boolean ok: false
+ Byte ok: 0
+ Short ok: 0
+ Integer ok: 0
+ Long ok: 0
+ BigInteger ok: 0
+ Float ok: 0.0
+ Double ok: 0.0
+ BigDecimal ok: 0
+ $target.objectCharacter($value)
+ Number ok: 0
+ Object ok: 0
+ $target.objectEnum($value)
+ String ok: 0
+ $target.valueOfBoolean($value)
+ $target.valueOfShort($value)
+ $target.valueOfByte($value)
+ $target.valueOfInt($value)
+ $target.valueOfLong($value)
+ $target.valueOfFloat($value)
+ $target.valueOfDouble($value)
+ $target.valueOfString($value)
+ $target.locale($value)
+ZA. BigDecimal one Value java.math.BigDecimal 1
+ boolean ok: true
+ byte ok: 1
+ short ok: 1
+ int ok: 1
+ long ok: 1
+ float ok: 1.0
+ double ok: 1.0
+ $target.integralChar($value)
+ Boolean ok: true
+ Byte ok: 1
+ Short ok: 1
+ Integer ok: 1
+ Long ok: 1
+ BigInteger ok: 1
+ Float ok: 1.0
+ Double ok: 1.0
+ BigDecimal ok: 1
+ $target.objectCharacter($value)
+ Number ok: 1
+ Object ok: 1
+ $target.objectEnum($value)
+ String ok: 1
+ $target.valueOfBoolean($value)
+ $target.valueOfShort($value)
+ $target.valueOfByte($value)
+ $target.valueOfInt($value)
+ $target.valueOfLong($value)
+ $target.valueOfFloat($value)
+ $target.valueOfDouble($value)
+ $target.valueOfString($value)
+ $target.locale($value)
+ZB. BigDecimal ten Value java.math.BigDecimal 10
+ boolean ok: true
+ byte ok: 10
+ short ok: 10
+ int ok: 10
+ long ok: 10
+ float ok: 10.0
+ double ok: 10.0
+ $target.integralChar($value)
+ Boolean ok: true
+ Byte ok: 10
+ Short ok: 10
+ Integer ok: 10
+ Long ok: 10
+ BigInteger ok: 10
+ Float ok: 10.0
+ Double ok: 10.0
+ BigDecimal ok: 10
+ $target.objectCharacter($value)
+ Number ok: 10
+ Object ok: 10
+ $target.objectEnum($value)
+ String ok: 10
+ $target.valueOfBoolean($value)
+ $target.valueOfShort($value)
+ $target.valueOfByte($value)
+ $target.valueOfInt($value)
+ $target.valueOfLong($value)
+ $target.valueOfFloat($value)
+ $target.valueOfDouble($value)
+ $target.valueOfString($value)
+ $target.locale($value)
+ZC. BigDecimal bigdec Value java.math.BigDecimal
12345678901234567890.01234567890123456789
+ boolean ok: true
+ integralByte -> IllegalArgumentException: java.lang.ArithmeticException:
Overflow
+ integralShort -> IllegalArgumentException: java.lang.ArithmeticException:
Overflow
+ integralInt -> IllegalArgumentException: java.lang.ArithmeticException:
Overflow
+ integralLong -> IllegalArgumentException: java.lang.ArithmeticException:
Overflow
+ float ok: 1.2345679E19
+ double ok: 1.2345678901234567E19
+ $target.integralChar($value)
+ Boolean ok: true
+ objectByte -> IllegalArgumentException: java.lang.ArithmeticException:
Overflow
+ objectShort -> IllegalArgumentException: java.lang.ArithmeticException:
Overflow
+ objectInt -> IllegalArgumentException: java.lang.ArithmeticException:
Overflow
+ objectLong -> IllegalArgumentException: java.lang.ArithmeticException:
Overflow
+ objectBigInteger -> IllegalArgumentException: java.lang.ArithmeticException:
Rounding necessary
+ Float ok: 1.2345679E19
+ Double ok: 1.2345678901234567E19
+ BigDecimal ok: 12345678901234567890.01234567890123456789
+ $target.objectCharacter($value)
+ Number ok: 12345678901234567890.01234567890123456789
+ Object ok: 12345678901234567890.01234567890123456789
+ $target.objectEnum($value)
+ String ok: 12345678901234567890.01234567890123456789
+ $target.valueOfBoolean($value)
+ $target.valueOfShort($value)
+ $target.valueOfByte($value)
+ $target.valueOfInt($value)
+ $target.valueOfLong($value)
+ $target.valueOfFloat($value)
+ $target.valueOfDouble($value)
+ $target.valueOfString($value)
+ $target.locale($value)
