diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/FloatLiteral.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/FloatLiteral.java new file mode 100644 index 00000000000..c63ee9a8cec --- /dev/null +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/FloatLiteral.java @@ -0,0 +1,38 @@ +/* + * Copyright 2002-2012 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.expression.spel.ast; + +import org.springframework.expression.TypedValue; + +/** + * Expression language AST node that represents a float literal. + * + * @author Satyapal Reddy + * @since 3.2 + */ +public class FloatLiteral extends Literal { + private final TypedValue value; + + FloatLiteral(String payload, int pos, float value) { + super(payload, pos); + this.value = new TypedValue(value); + } + + @Override + public TypedValue getLiteralValue() { + return this.value; + } +} diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/Literal.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/Literal.java index 98d7284b333..7a8cbdf47cc 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/Literal.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/Literal.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2009 the original author or authors. + * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,11 +17,7 @@ package org.springframework.expression.spel.ast; import org.springframework.expression.TypedValue; -import org.springframework.expression.spel.ExpressionState; -import org.springframework.expression.spel.SpelEvaluationException; -import org.springframework.expression.spel.SpelMessage; -import org.springframework.expression.spel.SpelParseException; -import org.springframework.expression.spel.InternalParseException; +import org.springframework.expression.spel.*; /** * Common superclass for nodes representing literals (boolean, string, number, etc). @@ -80,12 +76,12 @@ public abstract class Literal extends SpelNodeImpl { } } - // TODO should allow for 'f' for float, not just double + public static Literal getRealLiteral(String numberToken, int pos, boolean isFloat) { try { if (isFloat) { float value = Float.parseFloat(numberToken); - return new RealLiteral(numberToken, pos, value); + return new FloatLiteral(numberToken, pos, value); } else { double value = Double.parseDouble(numberToken); return new RealLiteral(numberToken, pos, value); diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpDivide.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpDivide.java index 07aac10f382..ca8130dbff2 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpDivide.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpDivide.java @@ -43,8 +43,9 @@ public class OpDivide extends Operator { Number op2 = (Number) operandTwo; if (op1 instanceof Double || op2 instanceof Double) { return new TypedValue(op1.doubleValue() / op2.doubleValue()); - } - else if (op1 instanceof Long || op2 instanceof Long) { + } else if (op1 instanceof Float || op2 instanceof Float) { + return new TypedValue(op1.floatValue() / op2.floatValue()); + } else if (op1 instanceof Long || op2 instanceof Long) { return new TypedValue(op1.longValue() / op2.longValue()); } else { diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpEQ.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpEQ.java index 936f651cafc..17f9eb8faf4 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpEQ.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpEQ.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2009 the original author or authors. + * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -41,6 +41,8 @@ public class OpEQ extends Operator { Number op2 = (Number) right; if (op1 instanceof Double || op2 instanceof Double) { return BooleanTypedValue.forValue(op1.doubleValue() == op2.doubleValue()); + } else if (op1 instanceof Float || op2 instanceof Float) { + return BooleanTypedValue.forValue(op1.floatValue() == op2.floatValue()); } else if (op1 instanceof Long || op2 instanceof Long) { return BooleanTypedValue.forValue(op1.longValue() == op2.longValue()); } else { diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpGE.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpGE.java index d3cd0c9df7c..a267b7037e4 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpGE.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpGE.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2009 the original author or authors. + * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -40,6 +40,8 @@ public class OpGE extends Operator { Number rightNumber = (Number) right; if (leftNumber instanceof Double || rightNumber instanceof Double) { return BooleanTypedValue.forValue(leftNumber.doubleValue() >= rightNumber.doubleValue()); + } else if (leftNumber instanceof Float || rightNumber instanceof Float) { + return BooleanTypedValue.forValue(leftNumber.floatValue() >= rightNumber.floatValue()); } else if (leftNumber instanceof Long || rightNumber instanceof Long) { return BooleanTypedValue.forValue( leftNumber.longValue() >= rightNumber.longValue()); } else { diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpLE.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpLE.java index 559cd7ea440..a09c7c7fb7d 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpLE.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpLE.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2009 the original author or authors. + * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -41,6 +41,8 @@ public class OpLE extends Operator { Number rightNumber = (Number) right; if (leftNumber instanceof Double || rightNumber instanceof Double) { return BooleanTypedValue.forValue(leftNumber.doubleValue() <= rightNumber.doubleValue()); + } else if (leftNumber instanceof Float || rightNumber instanceof Float) { + return BooleanTypedValue.forValue(leftNumber.floatValue() <= rightNumber.floatValue()); } else if (leftNumber instanceof Long || rightNumber instanceof Long) { return BooleanTypedValue.forValue(leftNumber.longValue() <= rightNumber.longValue()); } else { diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpLT.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpLT.java index 4b708fbeedd..6fab393a19f 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpLT.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpLT.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2009 the original author or authors. + * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -42,6 +42,8 @@ public class OpLT extends Operator { Number rightNumber = (Number) right; if (leftNumber instanceof Double || rightNumber instanceof Double) { return BooleanTypedValue.forValue(leftNumber.doubleValue() < rightNumber.doubleValue()); + } else if (leftNumber instanceof Float || rightNumber instanceof Float) { + return BooleanTypedValue.forValue(leftNumber.floatValue() < rightNumber.floatValue()); } else if (leftNumber instanceof Long || rightNumber instanceof Long) { return BooleanTypedValue.forValue(leftNumber.longValue() < rightNumber.longValue()); } else { diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpMinus.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpMinus.java index 0843575cac6..c8eeb2b0f7b 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpMinus.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpMinus.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2009 the original author or authors. + * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -52,6 +52,8 @@ public class OpMinus extends Operator { Number n = (Number) operand; if (operand instanceof Double) { return new TypedValue(0 - n.doubleValue()); + } else if (operand instanceof Float) { + return new TypedValue(0 - n.floatValue()); } else if (operand instanceof Long) { return new TypedValue(0 - n.longValue()); } else { @@ -67,6 +69,8 @@ public class OpMinus extends Operator { Number op2 = (Number) right; if (op1 instanceof Double || op2 instanceof Double) { return new TypedValue(op1.doubleValue() - op2.doubleValue()); + } else if (op1 instanceof Float || op2 instanceof Float) { + return new TypedValue(op1.floatValue() - op2.floatValue()); } else if (op1 instanceof Long || op2 instanceof Long) { return new TypedValue(op1.longValue() - op2.longValue()); } else { diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpModulus.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpModulus.java index 04ef2ffaef3..559c43b55ee 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpModulus.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpModulus.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2009 the original author or authors. + * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -42,6 +42,8 @@ public class OpModulus extends Operator { Number op2 = (Number) operandTwo; if (op1 instanceof Double || op2 instanceof Double) { return new TypedValue(op1.doubleValue() % op2.doubleValue()); + } else if (op1 instanceof Float || op2 instanceof Float) { + return new TypedValue(op1.floatValue() % op2.floatValue()); } else if (op1 instanceof Long || op2 instanceof Long) { return new TypedValue(op1.longValue() % op2.longValue()); } else { diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpMultiply.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpMultiply.java index 050c514b977..507acac3ad3 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpMultiply.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpMultiply.java @@ -66,6 +66,9 @@ public class OpMultiply extends Operator { if (leftNumber instanceof Double || rightNumber instanceof Double) { return new TypedValue(leftNumber.doubleValue() * rightNumber.doubleValue()); } + else if (leftNumber instanceof Float || rightNumber instanceof Float) { + return new TypedValue(leftNumber.floatValue() * rightNumber.floatValue()); + } else if (leftNumber instanceof Long || rightNumber instanceof Long) { return new TypedValue(leftNumber.longValue() * rightNumber.longValue()); } diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpNE.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpNE.java index aebcb852777..558ccb97637 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpNE.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpNE.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2009 the original author or authors. + * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -41,6 +41,8 @@ public class OpNE extends Operator { Number op2 = (Number) right; if (op1 instanceof Double || op2 instanceof Double) { return BooleanTypedValue.forValue(op1.doubleValue() != op2.doubleValue()); + } else if (op1 instanceof Float || op2 instanceof Float) { + return BooleanTypedValue.forValue(op1.floatValue() != op2.floatValue()); } else if (op1 instanceof Long || op2 instanceof Long) { return BooleanTypedValue.forValue(op1.longValue() != op2.longValue()); } else { diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpPlus.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpPlus.java index 9ece563b23d..7443dd141ca 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpPlus.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OpPlus.java @@ -55,6 +55,8 @@ public class OpPlus extends Operator { if (operandOne instanceof Number) { if (operandOne instanceof Double || operandOne instanceof Long) { return new TypedValue(operandOne); + } else if (operandOne instanceof Float) { + return new TypedValue(((Number) operandOne).floatValue()); } else { return new TypedValue(((Number) operandOne).intValue()); } @@ -73,6 +75,8 @@ public class OpPlus extends Operator { Number op2 = (Number) operandTwo; if (op1 instanceof Double || op2 instanceof Double) { return new TypedValue(op1.doubleValue() + op2.doubleValue()); + } else if (op1 instanceof Float || op2 instanceof Float) { + return new TypedValue(op1.floatValue() + op2.floatValue()); } else if (op1 instanceof Long || op2 instanceof Long) { return new TypedValue(op1.longValue() + op2.longValue()); } else { // TODO what about overflow? diff --git a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OperatorPower.java b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OperatorPower.java index f15e7d04310..41c5cee0371 100644 --- a/spring-expression/src/main/java/org/springframework/expression/spel/ast/OperatorPower.java +++ b/spring-expression/src/main/java/org/springframework/expression/spel/ast/OperatorPower.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2009 the original author or authors. + * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -45,6 +45,8 @@ public class OperatorPower extends Operator { Number op2 = (Number) operandTwo; if (op1 instanceof Double || op2 instanceof Double) { return new TypedValue(Math.pow(op1.doubleValue(),op2.doubleValue())); + } else if (op1 instanceof Float || op2 instanceof Float) { + return new TypedValue(Math.pow(op1.floatValue(), op2.floatValue())); } else if (op1 instanceof Long || op2 instanceof Long) { double d= Math.pow(op1.longValue(), op2.longValue()); return new TypedValue((long)d); diff --git a/spring-expression/src/test/java/org/springframework/expression/spel/LiteralTests.java b/spring-expression/src/test/java/org/springframework/expression/spel/LiteralTests.java index ad7de562bca..b3330d7b9d4 100644 --- a/spring-expression/src/test/java/org/springframework/expression/spel/LiteralTests.java +++ b/spring-expression/src/test/java/org/springframework/expression/spel/LiteralTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2009 the original author or authors. + * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,10 +17,9 @@ package org.springframework.expression.spel; import junit.framework.Assert; - import org.junit.Test; -import org.springframework.expression.spel.support.StandardEvaluationContext; import org.springframework.expression.spel.standard.SpelExpression; +import org.springframework.expression.spel.support.StandardEvaluationContext; /** * Tests the evaluation of basic literals: boolean, integer, hex integer, long, real, null, date @@ -126,12 +125,12 @@ public class LiteralTests extends ExpressionTestCase { @Test public void testLiteralReal02_CreatingFloats() { // For now, everything becomes a double... - evaluate("1.25f", 1.25d, Double.class); - evaluate("2.5f", 2.5d, Double.class); - evaluate("-3.5f", -3.5d, Double.class); - evaluate("1.25F", 1.25d, Double.class); - evaluate("2.5F", 2.5d, Double.class); - evaluate("-3.5F", -3.5d, Double.class); + evaluate("1.25f", 1.25f, Float.class); + evaluate("2.5f", 2.5f, Float.class); + evaluate("-3.5f", -3.5f, Float.class); + evaluate("1.25F", 1.25f, Float.class); + evaluate("2.5F", 2.5f, Float.class); + evaluate("-3.5F", -3.5f, Float.class); } @Test @@ -140,7 +139,7 @@ public class LiteralTests extends ExpressionTestCase { evaluate("6.0221415e+23", "6.0221415E23", Double.class); evaluate("6.0221415E+23d", "6.0221415E23", Double.class); evaluate("6.0221415e+23D", "6.0221415E23", Double.class); - evaluate("6E2f", 600.0d, Double.class); + evaluate("6E2f", 6E2f, Float.class); } @Test diff --git a/spring-expression/src/test/java/org/springframework/expression/spel/OperatorTests.java b/spring-expression/src/test/java/org/springframework/expression/spel/OperatorTests.java index a174023fd4d..2c62030d6f0 100644 --- a/spring-expression/src/test/java/org/springframework/expression/spel/OperatorTests.java +++ b/spring-expression/src/test/java/org/springframework/expression/spel/OperatorTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2002-2009 the original author or authors. + * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,7 +17,6 @@ package org.springframework.expression.spel; import junit.framework.Assert; - import org.junit.Test; import org.springframework.expression.spel.ast.Operator; import org.springframework.expression.spel.standard.SpelExpression; @@ -187,7 +186,7 @@ public class OperatorTests extends ExpressionTestCase { evaluate("5 - 4", "1", Integer.class); evaluate("3 * 5", 15, Integer.class); evaluate("3.2d * 5", 16.0d, Double.class); - evaluate("3 * 5f", 15d, Double.class); + evaluate("3 * 5f", 15f, Float.class); evaluate("3 / 1", 3, Integer.class); evaluate("3 % 2", 1, Integer.class); evaluate("3 mod 2", 1, Integer.class); @@ -199,7 +198,7 @@ public class OperatorTests extends ExpressionTestCase { @Test public void testPlus() throws Exception { evaluate("7 + 2", "9", Integer.class); - evaluate("3.0f + 5.0f", 8.0d, Double.class); + evaluate("3.0f + 5.0f", 8.0f, Float.class); evaluate("3.0d + 5.0d", 8.0d, Double.class); evaluate("'ab' + 2", "ab2", String.class); @@ -229,7 +228,7 @@ public class OperatorTests extends ExpressionTestCase { @Test public void testMinus() throws Exception { evaluate("'c' - 2", "a", String.class); - evaluate("3.0f - 5.0f", -2.0d, Double.class); + evaluate("3.0f - 5.0f", -2.0f, Float.class); evaluateAndCheckError("'ab' - 2", SpelMessage.OPERATOR_NOT_SUPPORTED_BETWEEN_TYPES); evaluateAndCheckError("2-'ab'",SpelMessage.OPERATOR_NOT_SUPPORTED_BETWEEN_TYPES); SpelExpression expr = (SpelExpression)parser.parseExpression("-3"); @@ -247,16 +246,16 @@ public class OperatorTests extends ExpressionTestCase { public void testModulus() { evaluate("3%2",1,Integer.class); evaluate("3L%2L",1L,Long.class); - evaluate("3.0f%2.0f",1d,Double.class); + evaluate("3.0f%2.0f",1f,Float.class); evaluate("5.0d % 3.1d", 1.9d, Double.class); evaluateAndCheckError("'abc'%'def'",SpelMessage.OPERATOR_NOT_SUPPORTED_BETWEEN_TYPES); } @Test public void testDivide() { - evaluate("3.0f / 5.0f", 0.6d, Double.class); + evaluate("3.0f / 5.0f", 0.6f, Float.class); evaluate("4L/2L",2L,Long.class); - evaluate("3.0f div 5.0f", 0.6d, Double.class); + evaluate("3.0f div 5.0f", 0.6f, Float.class); evaluate("4L DIV 2L",2L,Long.class); evaluateAndCheckError("'abc'/'def'",SpelMessage.OPERATOR_NOT_SUPPORTED_BETWEEN_TYPES); } @@ -350,9 +349,9 @@ public class OperatorTests extends ExpressionTestCase { public void testMixedOperands_DoublesAndInts() { evaluate("3.0d + 5", 8.0d, Double.class); evaluate("3.0D - 5", -2.0d, Double.class); - evaluate("3.0f * 5", 15.0d, Double.class); - evaluate("6.0f / 2", 3.0, Double.class); - evaluate("6.0f / 4", 1.5d, Double.class); + evaluate("3.0f * 5", 15.0f, Float.class); + evaluate("6.0f / 2", 3.0f, Float.class); + evaluate("6.0f / 4", 1.5f, Float.class); evaluate("5.0D % 3", 2.0d, Double.class); evaluate("5.5D % 3", 2.5, Double.class); } diff --git a/spring-expression/src/test/java/org/springframework/expression/spel/SpringEL300Tests.java b/spring-expression/src/test/java/org/springframework/expression/spel/SpringEL300Tests.java index bbedf7513f5..9ccdd0eee7d 100644 --- a/spring-expression/src/test/java/org/springframework/expression/spel/SpringEL300Tests.java +++ b/spring-expression/src/test/java/org/springframework/expression/spel/SpringEL300Tests.java @@ -16,34 +16,11 @@ package org.springframework.expression.spel; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; - -import java.lang.reflect.Field; -import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Properties; - import junit.framework.Assert; - import org.junit.Ignore; import org.junit.Test; import org.springframework.core.convert.TypeDescriptor; -import org.springframework.expression.AccessException; -import org.springframework.expression.BeanResolver; -import org.springframework.expression.EvaluationContext; -import org.springframework.expression.EvaluationException; -import org.springframework.expression.Expression; -import org.springframework.expression.ExpressionParser; -import org.springframework.expression.MethodExecutor; -import org.springframework.expression.MethodResolver; -import org.springframework.expression.ParserContext; -import org.springframework.expression.PropertyAccessor; -import org.springframework.expression.TypedValue; +import org.springframework.expression.*; import org.springframework.expression.spel.standard.SpelExpression; import org.springframework.expression.spel.standard.SpelExpressionParser; import org.springframework.expression.spel.support.ReflectiveMethodResolver; @@ -51,6 +28,13 @@ import org.springframework.expression.spel.support.ReflectivePropertyAccessor; import org.springframework.expression.spel.support.StandardEvaluationContext; import org.springframework.expression.spel.support.StandardTypeLocator; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.*; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; + /** * Tests based on Jiras up to the release of Spring 3.0.0 * @@ -1204,6 +1188,425 @@ public class SpringEL300Tests extends ExpressionTestCase { assertEquals("Equal assertion failed: ", "class [[I", result.toString()); } + @Test + public void SPR_9486_floatFunctionResolverTest() { + try { + Number expectedResult = Math.abs(-10.2f); + ExpressionParser parser = new SpelExpressionParser(); + SPR_9486_FunctionsClass testObject = new SPR_9486_FunctionsClass(); + + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("abs(-10.2f)"); + Number result = expression.getValue(context, testObject, Number.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatFunctionResolverTest Test: ", expectedResult, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatFunctionResolverTest"); + } + } + + class SPR_9486_FunctionsClass { + public int abs(int value) { + return Math.abs(value); + } + + public float abs(float value) { + return Math.abs(value); + } + } + + @Test + public void SPR_9486_addFloatWithDoubleTest() { + try { + Number expectedNumber = 10.21f + 10.2; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("10.21f + 10.2"); + Number result = expression.getValue(context, null, Number.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_addFloatWithDoubleTest Test: ", expectedNumber, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_addFloatWithDoubleTest"); + } + } + + @Test + public void SPR_9486_addFloatWithFloatTest() { + try { + Number expectedNumber = 10.21f + 10.2f; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("10.21f + 10.2f"); + Number result = expression.getValue(context, null, Number.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_addFloatWithFloatTest Test: ", expectedNumber, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_addFloatWithFloatTest"); + } + } + + @Test + public void SPR_9486_subtractFloatWithDoubleTest() { + try { + Number expectedNumber = 10.21f - 10.2; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("10.21f - 10.2"); + Number result = expression.getValue(context, null, Number.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_subtractFloatWithDoubleTest Test: ", expectedNumber, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_subtractFloatWithDoubleTest"); + } + } + + @Test + public void SPR_9486_subtractFloatWithFloatTest() { + try { + Number expectedNumber = 10.21f - 10.2f; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("10.21f - 10.2f"); + Number result = expression.getValue(context, null, Number.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_subtractFloatWithFloatTest Test: ", expectedNumber, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_subtractFloatWithFloatTest"); + } + } + + @Test + public void SPR_9486_multiplyFloatWithDoubleTest() { + try { + Number expectedNumber = 10.21f * 10.2; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("10.21f * 10.2"); + Number result = expression.getValue(context, null, Number.class); + Assert.assertEquals("Equal assertion failed for float multiplied by double Test: ", expectedNumber, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_multiplyFloatWithDoubleTest"); + } + } + + @Test + public void SPR_9486_multiplyFloatWithFloatTest() { + try { + Number expectedNumber = 10.21f * 10.2f; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("10.21f * 10.2f"); + Number result = expression.getValue(context, null, Number.class); + Assert.assertEquals("Equal assertion failed for float multiply by another float Test: ", expectedNumber, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_multiplyFloatWithFloatTest"); + } + } + + @Test + public void SPR_9486_floatDivideByFloatTest() { + try { + Number expectedNumber = -10.21f/-10.2f; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("-10.21f / -10.2f"); + Number result = expression.getValue(context, null, Number.class); + Assert.assertEquals("Equal assertion failed for float divide Test: ", expectedNumber, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatDivideByFloatTest"); + } + } + + @Test + public void SPR_9486_floatDivideByDoubleTest() { + try { + Number expectedNumber = -10.21f/-10.2; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("-10.21f / -10.2"); + Number result = expression.getValue(context, null, Number.class); + Assert.assertEquals("Equal assertion failed for float divide Test: ", expectedNumber, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatDivideByDoubleTest"); + } + } + + @Test + public void SPR_9486_floatEqFloatUnaryMinusTest() { + try { + Boolean expectedResult = -10.21f == -10.2f; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("-10.21f == -10.2f"); + Boolean result = expression.getValue(context, null, Boolean.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatEqFloatUnaryMinusTest Test: ", expectedResult, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatEqFloatUnaryMinusTest"); + } + } + + @Test + public void SPR_9486_floatEqDoubleUnaryMinusTest() { + try { + Boolean expectedResult = -10.21f == -10.2; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("-10.21f == -10.2"); + Boolean result = expression.getValue(context, null, Boolean.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatEqDoubleUnaryMinusTest Test: ", expectedResult, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatEqDoubleUnaryMinusTest"); + } + } + + @Test + public void SPR_9486_floatEqFloatTest() { + try { + Boolean expectedResult = 10.215f == 10.2109f; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("10.215f == 10.2109f"); + Boolean result = expression.getValue(context, null, Boolean.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatEqFloatTest Test: ", expectedResult, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatEqFloatTest"); + } + } + + @Test + public void SPR_9486_floatEqDoubleTest() { + try { + Boolean expectedResult = 10.215f == 10.2109; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("10.215f == 10.2109"); + Boolean result = expression.getValue(context, null, Boolean.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatEqDoubleTest() Test: ", expectedResult, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatEqDoubleTest()"); + } + } + + @Test + public void SPR_9486_floatNotEqFloatTest() { + try { + Boolean expectedResult = 10.215f != 10.2109f; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("10.215f != 10.2109f"); + Boolean result = expression.getValue(context, null, Boolean.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatEqFloatTest Test: ", expectedResult, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatEqFloatTest"); + } + } + + @Test + public void SPR_9486_floatNotEqDoubleTest() { + try { + Boolean expectedResult = 10.215f != 10.2109; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("10.215f != 10.2109"); + Boolean result = expression.getValue(context, null, Boolean.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatNotEqDoubleTest Test: ", expectedResult, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatNotEqDoubleTest"); + } + } + + + + @Test + public void SPR_9486_floatLessThanFloatTest() { + try { + Boolean expectedNumber = -10.21f < -10.2f; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("-10.21f < -10.2f"); + Boolean result = expression.getValue(context, null, Boolean.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatLessThanFloatTest Test: ", expectedNumber, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatLessThanFloatTest()"); + } + } + + @Test + public void SPR_9486_floatLessThanDoubleTest() { + try { + Boolean expectedNumber = -10.21f < -10.2; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("-10.21f < -10.2"); + Boolean result = expression.getValue(context, null, Boolean.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatLessThanDoubleTest Test: ", expectedNumber, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatLessThanDoubleTest()"); + } + } + + @Test + public void SPR_9486_floatLessThanOrEqualFloatTest() { + try { + Boolean expectedNumber = -10.21f <= -10.22f; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("-10.21f <= -10.22f"); + Boolean result = expression.getValue(context, null, Boolean.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatLessThanOrEqualFloatTest Test: ", expectedNumber, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatLessThanOrEqualFloatTest"); + } + } + + @Test + public void SPR_9486_floatLessThanOrEqualDoubleTest() { + try { + Boolean expectedNumber = -10.21f <= -10.2; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("-10.21f <= -10.2"); + Boolean result = expression.getValue(context, null, Boolean.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatLessThanOrEqualDoubleTest Test: ", expectedNumber, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatLessThanOrEqualDoubleTest"); + } + } + + @Test + public void SPR_9486_floatGreaterThanFloatTest() { + try { + Boolean expectedNumber = -10.21f > -10.2f; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("-10.21f > -10.2f"); + Boolean result = expression.getValue(context, null, Boolean.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatGreaterThanFloatTest Test: ", expectedNumber, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatGreaterThanTest"); + } + } + + @Test + public void SPR_9486_floatGreaterThanDoubleTest() { + try { + Boolean expectedResult = -10.21f > -10.2; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("-10.21f > -10.2"); + Boolean result = expression.getValue(context, null, Boolean.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatGreaterThanDoubleTest Test: ", expectedResult, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatGreaterThanTest"); + } + } + + @Test + public void SPR_9486_floatGreaterThanOrEqualFloatTest() { + try { + Boolean expectedNumber = -10.21f >= -10.2f; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("-10.21f >= -10.2f"); + Boolean result = expression.getValue(context, null, Boolean.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatGreaterThanFloatTest Test: ", expectedNumber, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatGreaterThanTest"); + } + } + + @Test + public void SPR_9486_floatGreaterThanEqualDoubleTest() { + try { + Boolean expectedResult = -10.21f >= -10.2; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("-10.21f >= -10.2"); + Boolean result = expression.getValue(context, null, Boolean.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatGreaterThanDoubleTest Test: ", expectedResult, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatGreaterThanTest"); + } + } + + @Test + public void SPR_9486_floatModulusFloatTest() { + try { + Number expectedResult = 10.21f % 10.2f; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("10.21f % 10.2f"); + Number result = expression.getValue(context, null, Number.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatModulusFloatTest Test: ", expectedResult, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatModulusFloatTest"); + } + } + + @Test + public void SPR_9486_floatModulusDoubleTest() { + try { + Number expectedResult = 10.21f % 10.2; + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("10.21f % 10.2"); + Number result = expression.getValue(context, null, Number.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatModulusDoubleTest Test: ", expectedResult, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatModulusDoubleTest"); + } + } + + @Test + public void SPR_9486_floatPowerFloatTest() { + try { + Number expectedResult = Math.pow(10.21f, -10.2f); + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("10.21f ^ -10.2f"); + Number result = expression.getValue(context, null, Number.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatPowerFloatTest Test: ", expectedResult, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatPowerFloatTest"); + } + } + + @Test + public void SPR_9486_floatPowerDoubleTest() { + try { + Number expectedResult = Math.pow(10.21f, 10.2); + ExpressionParser parser = new SpelExpressionParser(); + StandardEvaluationContext context = new StandardEvaluationContext(); + org.springframework.expression.Expression expression = parser.parseExpression("10.21f ^ 10.2"); + Number result = expression.getValue(context, null, Number.class); + Assert.assertEquals("Equal assertion failed for SPR_9486_floatPowerDoubleTest Test: ", expectedResult, result); + } catch (Exception e) { + e.printStackTrace(); + Assert.fail("Test failed - SPR_9486_floatPowerDoubleTest"); + } + } + }