root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 7 Packages Projects Releases Wiki Activity

Consistently use class literals for primitive types 

To improve consistency and avoid confusion regarding primitive types
and their wrapper types, this commit ensures that we always use class
literals for primitive types.

For example, instead of using the `Void.TYPE` constant, we now
consistently use `void.class`.
This commit is contained in:
Sam Brannen 2024-01-30 15:15:47 +01:00
parent 95a3f3bb6e
commit db535863dd
33 changed files with 231 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
integration-tests/src/test/java/org/springframework/expression/spel/support/BeanFactoryTypeConverter.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2012 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -94,7 +94,7 @@ class BeanFactoryTypeConverter implements TypeConverter, BeanFactoryAware {
@Override @Override
public Object convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType) { public Object convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType) {
if (targetType.getType() == Void.class || targetType.getType() == Void.TYPE) { if (targetType.getType() == Void.class || targetType.getType() == void.class) {
return null; return null;
} }
if (conversionService.canConvert(sourceType, targetType)) { if (conversionService.canConvert(sourceType, targetType)) {

4
spring-aop/src/main/java/org/springframework/aop/framework/CglibAopProxy.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -417,7 +417,7 @@ class CglibAopProxy implements AopProxy, Serializable {
returnValue = proxy; returnValue = proxy;
} }
Class<?> returnType = method.getReturnType(); Class<?> returnType = method.getReturnType();
if (returnValue == null && returnType != Void.TYPE && returnType.isPrimitive()) { if (returnValue == null && returnType != void.class && returnType.isPrimitive()) {
throw new AopInvocationException( throw new AopInvocationException(
"Null return value from advice does not match primitive return type for: " + method); "Null return value from advice does not match primitive return type for: " + method);
} }

4
spring-aop/src/main/java/org/springframework/aop/framework/JdkDynamicAopProxy.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -230,7 +230,7 @@ final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializa
// a reference to itself in another returned object. // a reference to itself in another returned object.
retVal = proxy; retVal = proxy;
} }
else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) { else if (retVal == null && returnType != void.class && returnType.isPrimitive()) {
throw new AopInvocationException( throw new AopInvocationException(
"Null return value from advice does not match primitive return type for: " + method); "Null return value from advice does not match primitive return type for: " + method);
} }

6
spring-aop/src/main/java/org/springframework/aop/support/Pointcuts.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -101,7 +101,7 @@ public abstract class Pointcuts {
public boolean matches(Method method, Class<?> targetClass) { public boolean matches(Method method, Class<?> targetClass) {
return (method.getName().startsWith("set") && return (method.getName().startsWith("set") &&
method.getParameterCount() == 1 && method.getParameterCount() == 1 &&
method.getReturnType() == Void.TYPE); method.getReturnType() == void.class);
} }
private Object readResolve() { private Object readResolve() {
@ -127,7 +127,7 @@ public abstract class Pointcuts {
public boolean matches(Method method, Class<?> targetClass) { public boolean matches(Method method, Class<?> targetClass) {
return (method.getName().startsWith("get") && return (method.getName().startsWith("get") &&
method.getParameterCount() == 0 && method.getParameterCount() == 0 &&
method.getReturnType() != Void.TYPE); method.getReturnType() != void.class);
} }
private Object readResolve() { private Object readResolve() {

12
spring-beans/src/main/java/org/springframework/beans/PropertyDescriptorUtils.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -68,7 +68,7 @@ abstract class PropertyDescriptorUtils {
setter = true; setter = true;
nameIndex = 3; nameIndex = 3;
} }
else if (methodName.startsWith("get") && method.getParameterCount() == 0 && method.getReturnType() != Void.TYPE) { else if (methodName.startsWith("get") && method.getParameterCount() == 0 && method.getReturnType() != void.class) {
setter = false; setter = false;
nameIndex = 3; nameIndex = 3;
} }
@ -152,7 +152,7 @@ abstract class PropertyDescriptorUtils {
throw new IntrospectionException("Bad read method arg count: " + readMethod); throw new IntrospectionException("Bad read method arg count: " + readMethod);
} }
propertyType = readMethod.getReturnType(); propertyType = readMethod.getReturnType();
if (propertyType == Void.TYPE) { if (propertyType == void.class) {
throw new IntrospectionException("Read method returns void: " + readMethod); throw new IntrospectionException("Read method returns void: " + readMethod);
} }
} }
@ -197,11 +197,11 @@ abstract class PropertyDescriptorUtils {
if (params.length != 1) { if (params.length != 1) {
throw new IntrospectionException("Bad indexed read method arg count: " + indexedReadMethod); throw new IntrospectionException("Bad indexed read method arg count: " + indexedReadMethod);
} }
if (params[0] != Integer.TYPE) { if (params[0] != int.class) {
throw new IntrospectionException("Non int index to indexed read method: " + indexedReadMethod); throw new IntrospectionException("Non int index to indexed read method: " + indexedReadMethod);
} }
indexedPropertyType = indexedReadMethod.getReturnType(); indexedPropertyType = indexedReadMethod.getReturnType();
if (indexedPropertyType == Void.TYPE) { if (indexedPropertyType == void.class) {
throw new IntrospectionException("Indexed read method returns void: " + indexedReadMethod); throw new IntrospectionException("Indexed read method returns void: " + indexedReadMethod);
} }
} }
@ -211,7 +211,7 @@ abstract class PropertyDescriptorUtils {
if (params.length != 2) { if (params.length != 2) {
throw new IntrospectionException("Bad indexed write method arg count: " + indexedWriteMethod); throw new IntrospectionException("Bad indexed write method arg count: " + indexedWriteMethod);
} }
if (params[0] != Integer.TYPE) { if (params[0] != int.class) {
throw new IntrospectionException("Non int index to indexed write method: " + indexedWriteMethod); throw new IntrospectionException("Non int index to indexed write method: " + indexedWriteMethod);
} }
if (indexedPropertyType != null) { if (indexedPropertyType != null) {

2
spring-context/src/test/java/org/springframework/aop/framework/ProxyFactoryBeanTests.java
View File

@ -698,7 +698,7 @@ class ProxyFactoryBeanTests {
setPointcut(new DynamicMethodMatcherPointcut() { setPointcut(new DynamicMethodMatcherPointcut() {
@Override @Override
public boolean matches(Method m, @Nullable Class<?> targetClass, Object... args) { public boolean matches(Method m, @Nullable Class<?> targetClass, Object... args) {
return m.getReturnType() == Void.TYPE; return m.getReturnType() == void.class;
} }
}); });
} }

4
spring-core/src/main/java/org/springframework/aot/hint/BindingReflectionHintsRegistrar.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -107,7 +107,7 @@ public class BindingReflectionHintsRegistrar {
if (methodName.startsWith("set") && method.getParameterCount() == 1) { if (methodName.startsWith("set") && method.getParameterCount() == 1) {
registerPropertyHints(hints, seen, method, 0); registerPropertyHints(hints, seen, method, 0);
} }
else if ((methodName.startsWith("get") && method.getParameterCount() == 0 && method.getReturnType() != Void.TYPE) || else if ((methodName.startsWith("get") && method.getParameterCount() == 0 && method.getReturnType() != void.class) ||
(methodName.startsWith("is") && method.getParameterCount() == 0 && method.getReturnType() == boolean.class)) { (methodName.startsWith("is") && method.getParameterCount() == 0 && method.getReturnType() == boolean.class)) {
registerPropertyHints(hints, seen, method, -1); registerPropertyHints(hints, seen, method, -1);
} }

2
spring-core/src/main/java/org/springframework/core/annotation/AnnotatedMethod.java
View File

@ -137,7 +137,7 @@ public class AnnotatedMethod {
* Return {@code true} if the method's return type is void, {@code false} otherwise. * Return {@code true} if the method's return type is void, {@code false} otherwise.
*/ */
public boolean isVoid() { public boolean isVoid() {
return Void.TYPE.equals(getReturnType().getParameterType()); return (getReturnType().getParameterType() == void.class);
} }
/** /**

8
spring-core/src/test/java/org/springframework/core/MethodParameterTests.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -52,7 +52,7 @@ class MethodParameterTests {
@BeforeEach @BeforeEach
void setup() throws NoSuchMethodException { void setup() throws NoSuchMethodException {
method = getClass().getMethod("method", String.class, Long.TYPE); method = getClass().getMethod("method", String.class, long.class);
stringParameter = new MethodParameter(method, 0); stringParameter = new MethodParameter(method, 0);
longParameter = new MethodParameter(method, 1); longParameter = new MethodParameter(method, 1);
intReturnType = new MethodParameter(method, -1); intReturnType = new MethodParameter(method, -1);
@ -72,7 +72,7 @@ class MethodParameterTests {
assertThat(intReturnType).isNotEqualTo(stringParameter); assertThat(intReturnType).isNotEqualTo(stringParameter);
assertThat(intReturnType).isNotEqualTo(longParameter); assertThat(intReturnType).isNotEqualTo(longParameter);
Method method = getClass().getMethod("method", String.class, Long.TYPE); Method method = getClass().getMethod("method", String.class, long.class);
MethodParameter methodParameter = new MethodParameter(method, 0); MethodParameter methodParameter = new MethodParameter(method, 0);
assertThat(methodParameter).isEqualTo(stringParameter); assertThat(methodParameter).isEqualTo(stringParameter);
assertThat(stringParameter).isEqualTo(methodParameter); assertThat(stringParameter).isEqualTo(methodParameter);
@ -86,7 +86,7 @@ class MethodParameterTests {
assertThat(longParameter.hashCode()).isEqualTo(longParameter.hashCode()); assertThat(longParameter.hashCode()).isEqualTo(longParameter.hashCode());
assertThat(intReturnType.hashCode()).isEqualTo(intReturnType.hashCode()); assertThat(intReturnType.hashCode()).isEqualTo(intReturnType.hashCode());
Method method = getClass().getMethod("method", String.class, Long.TYPE); Method method = getClass().getMethod("method", String.class, long.class);
MethodParameter methodParameter = new MethodParameter(method, 0); MethodParameter methodParameter = new MethodParameter(method, 0);
assertThat(methodParameter.hashCode()).isEqualTo(stringParameter.hashCode()); assertThat(methodParameter.hashCode()).isEqualTo(stringParameter.hashCode());
assertThat(methodParameter.hashCode()).isNotEqualTo(longParameter.hashCode()); assertThat(methodParameter.hashCode()).isNotEqualTo(longParameter.hashCode());

8
spring-core/src/test/java/org/springframework/core/annotation/SynthesizingMethodParameterTests.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -43,7 +43,7 @@ class SynthesizingMethodParameterTests {
@BeforeEach @BeforeEach
void setUp() throws NoSuchMethodException { void setUp() throws NoSuchMethodException {
method = getClass().getMethod("method", String.class, Long.TYPE); method = getClass().getMethod("method", String.class, long.class);
stringParameter = new SynthesizingMethodParameter(method, 0); stringParameter = new SynthesizingMethodParameter(method, 0);
longParameter = new SynthesizingMethodParameter(method, 1); longParameter = new SynthesizingMethodParameter(method, 1);
intReturnType = new SynthesizingMethodParameter(method, -1); intReturnType = new SynthesizingMethodParameter(method, -1);
@ -63,7 +63,7 @@ class SynthesizingMethodParameterTests {
assertThat(intReturnType).isNotEqualTo(stringParameter); assertThat(intReturnType).isNotEqualTo(stringParameter);
assertThat(intReturnType).isNotEqualTo(longParameter); assertThat(intReturnType).isNotEqualTo(longParameter);
Method method = getClass().getMethod("method", String.class, Long.TYPE); Method method = getClass().getMethod("method", String.class, long.class);
MethodParameter methodParameter = new SynthesizingMethodParameter(method, 0); MethodParameter methodParameter = new SynthesizingMethodParameter(method, 0);
assertThat(methodParameter).isEqualTo(stringParameter); assertThat(methodParameter).isEqualTo(stringParameter);
assertThat(stringParameter).isEqualTo(methodParameter); assertThat(stringParameter).isEqualTo(methodParameter);
@ -83,7 +83,7 @@ class SynthesizingMethodParameterTests {
assertThat(longParameter.hashCode()).isEqualTo(longParameter.hashCode()); assertThat(longParameter.hashCode()).isEqualTo(longParameter.hashCode());
assertThat(intReturnType.hashCode()).isEqualTo(intReturnType.hashCode()); assertThat(intReturnType.hashCode()).isEqualTo(intReturnType.hashCode());
Method method = getClass().getMethod("method", String.class, Long.TYPE); Method method = getClass().getMethod("method", String.class, long.class);
SynthesizingMethodParameter methodParameter = new SynthesizingMethodParameter(method, 0); SynthesizingMethodParameter methodParameter = new SynthesizingMethodParameter(method, 0);
assertThat(methodParameter.hashCode()).isEqualTo(stringParameter.hashCode()); assertThat(methodParameter.hashCode()).isEqualTo(stringParameter.hashCode());
assertThat(methodParameter.hashCode()).isNotEqualTo(longParameter.hashCode()); assertThat(methodParameter.hashCode()).isNotEqualTo(longParameter.hashCode());

8
spring-core/src/test/java/org/springframework/core/convert/TypeDescriptorTests.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -303,7 +303,7 @@ class TypeDescriptorTests {
void fieldArray() throws Exception { void fieldArray() throws Exception {
TypeDescriptor typeDescriptor = new TypeDescriptor(TypeDescriptorTests.class.getDeclaredField("intArray")); TypeDescriptor typeDescriptor = new TypeDescriptor(TypeDescriptorTests.class.getDeclaredField("intArray"));
assertThat(typeDescriptor.isArray()).isTrue(); assertThat(typeDescriptor.isArray()).isTrue();
assertThat(typeDescriptor.getElementTypeDescriptor().getType()).isEqualTo(Integer.TYPE); assertThat(typeDescriptor.getElementTypeDescriptor().getType()).isEqualTo(int.class);
assertThat(typeDescriptor.toString()).isEqualTo("int[]"); assertThat(typeDescriptor.toString()).isEqualTo("int[]");
} }
@ -359,7 +359,7 @@ class TypeDescriptorTests {
assertThat(typeDescriptor.isArray()).isFalse(); assertThat(typeDescriptor.isArray()).isFalse();
assertThat(typeDescriptor.isCollection()).isFalse(); assertThat(typeDescriptor.isCollection()).isFalse();
assertThat(typeDescriptor.isMap()).isFalse(); assertThat(typeDescriptor.isMap()).isFalse();
assertThat(typeDescriptor.getType()).isEqualTo(Integer.TYPE); assertThat(typeDescriptor.getType()).isEqualTo(int.class);
assertThat(typeDescriptor.getObjectType()).isEqualTo(Integer.class); assertThat(typeDescriptor.getObjectType()).isEqualTo(Integer.class);
} }
@ -369,7 +369,7 @@ class TypeDescriptorTests {
assertThat(typeDescriptor.isArray()).isTrue(); assertThat(typeDescriptor.isArray()).isTrue();
assertThat(typeDescriptor.isCollection()).isFalse(); assertThat(typeDescriptor.isCollection()).isFalse();
assertThat(typeDescriptor.isMap()).isFalse(); assertThat(typeDescriptor.isMap()).isFalse();
assertThat(typeDescriptor.getElementTypeDescriptor().getType()).isEqualTo(Integer.TYPE); assertThat(typeDescriptor.getElementTypeDescriptor().getType()).isEqualTo(int.class);
} }
@Test @Test

20
spring-expression/src/main/java/org/springframework/expression/spel/CodeFlow.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -454,31 +454,31 @@ public class CodeFlow implements Opcodes {
} }
} }
if (clazz.isPrimitive()) { if (clazz.isPrimitive()) {
if (clazz == Boolean.TYPE) { if (clazz == boolean.class) {
sb.append('Z'); sb.append('Z');
} }
else if (clazz == Byte.TYPE) { else if (clazz == byte.class) {
sb.append('B'); sb.append('B');
} }
else if (clazz == Character.TYPE) { else if (clazz == char.class) {
sb.append('C'); sb.append('C');
} }
else if (clazz == Double.TYPE) { else if (clazz == double.class) {
sb.append('D'); sb.append('D');
} }
else if (clazz == Float.TYPE) { else if (clazz == float.class) {
sb.append('F'); sb.append('F');
} }
else if (clazz == Integer.TYPE) { else if (clazz == int.class) {
sb.append('I'); sb.append('I');
} }
else if (clazz == Long.TYPE) { else if (clazz == long.class) {
sb.append('J'); sb.append('J');
} }
else if (clazz == Short.TYPE) { else if (clazz == short.class) {
sb.append('S'); sb.append('S');
} }
else if (clazz == Void.TYPE) { else if (clazz == void.class) {
sb.append('V'); sb.append('V');
} }
} }

16
spring-expression/src/main/java/org/springframework/expression/spel/ast/Indexer.java
View File

@ -385,49 +385,49 @@ public class Indexer extends SpelNodeImpl {
private Object accessArrayElement(Object ctx, int idx) throws SpelEvaluationException { private Object accessArrayElement(Object ctx, int idx) throws SpelEvaluationException {
Class<?> arrayComponentType = ctx.getClass().componentType(); Class<?> arrayComponentType = ctx.getClass().componentType();
if (arrayComponentType == Boolean.TYPE) { if (arrayComponentType == boolean.class) {
boolean[] array = (boolean[]) ctx; boolean[] array = (boolean[]) ctx;
checkAccess(array.length, idx); checkAccess(array.length, idx);
this.exitTypeDescriptor = "Z"; this.exitTypeDescriptor = "Z";
return array[idx]; return array[idx];
} }
else if (arrayComponentType == Byte.TYPE) { else if (arrayComponentType == byte.class) {
byte[] array = (byte[]) ctx; byte[] array = (byte[]) ctx;
checkAccess(array.length, idx); checkAccess(array.length, idx);
this.exitTypeDescriptor = "B"; this.exitTypeDescriptor = "B";
return array[idx]; return array[idx];
} }
else if (arrayComponentType == Character.TYPE) { else if (arrayComponentType == char.class) {
char[] array = (char[]) ctx; char[] array = (char[]) ctx;
checkAccess(array.length, idx); checkAccess(array.length, idx);
this.exitTypeDescriptor = "C"; this.exitTypeDescriptor = "C";
return array[idx]; return array[idx];
} }
else if (arrayComponentType == Double.TYPE) { else if (arrayComponentType == double.class) {
double[] array = (double[]) ctx; double[] array = (double[]) ctx;
checkAccess(array.length, idx); checkAccess(array.length, idx);
this.exitTypeDescriptor = "D"; this.exitTypeDescriptor = "D";
return array[idx]; return array[idx];
} }
else if (arrayComponentType == Float.TYPE) { else if (arrayComponentType == float.class) {
float[] array = (float[]) ctx; float[] array = (float[]) ctx;
checkAccess(array.length, idx); checkAccess(array.length, idx);
this.exitTypeDescriptor = "F"; this.exitTypeDescriptor = "F";
return array[idx]; return array[idx];
} }
else if (arrayComponentType == Integer.TYPE) { else if (arrayComponentType == int.class) {
int[] array = (int[]) ctx; int[] array = (int[]) ctx;
checkAccess(array.length, idx); checkAccess(array.length, idx);
this.exitTypeDescriptor = "I"; this.exitTypeDescriptor = "I";
return array[idx]; return array[idx];
} }
else if (arrayComponentType == Long.TYPE) { else if (arrayComponentType == long.class) {
long[] array = (long[]) ctx; long[] array = (long[]) ctx;
checkAccess(array.length, idx); checkAccess(array.length, idx);
this.exitTypeDescriptor = "J"; this.exitTypeDescriptor = "J";
return array[idx]; return array[idx];
} }
else if (arrayComponentType == Short.TYPE) { else if (arrayComponentType == short.class) {
short[] array = (short[]) ctx; short[] array = (short[]) ctx;
checkAccess(array.length, idx); checkAccess(array.length, idx);
this.exitTypeDescriptor = "S"; this.exitTypeDescriptor = "S";

18
spring-expression/src/main/java/org/springframework/expression/spel/ast/TypeCode.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -33,42 +33,42 @@ public enum TypeCode {
/** /**
* A {@code boolean}. * A {@code boolean}.
*/ */
BOOLEAN(Boolean.TYPE), BOOLEAN(boolean.class),
/** /**
* A {@code char}. * A {@code char}.
*/ */
CHAR(Character.TYPE), CHAR(char.class),
/** /**
* A {@code byte}. * A {@code byte}.
*/ */
BYTE(Byte.TYPE), BYTE(byte.class),
/** /**
* A {@code short}. * A {@code short}.
*/ */
SHORT(Short.TYPE), SHORT(short.class),
/** /**
* An {@code int}. * An {@code int}.
*/ */
INT(Integer.TYPE), INT(int.class),
/** /**
* A {@code long}. * A {@code long}.
*/ */
LONG(Long.TYPE), LONG(long.class),
/** /**
* A {@code float}. * A {@code float}.
*/ */
FLOAT(Float.TYPE), FLOAT(float.class),
/** /**
* A {@code double}. * A {@code double}.
*/ */
DOUBLE(Double.TYPE); DOUBLE(double.class);
private final Class<?> type; private final Class<?> type;

18
spring-expression/src/main/java/org/springframework/expression/spel/ast/TypeReference.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -102,28 +102,28 @@ public class TypeReference extends SpelNodeImpl {
// TODO Future optimization - if followed by a static method call, skip generating code here // TODO Future optimization - if followed by a static method call, skip generating code here
Assert.state(this.type != null, "No type available"); Assert.state(this.type != null, "No type available");
if (this.type.isPrimitive()) { if (this.type.isPrimitive()) {
if (this.type == Boolean.TYPE) { if (this.type == boolean.class) {
mv.visitFieldInsn(GETSTATIC, "java/lang/Boolean", "TYPE", "Ljava/lang/Class;"); mv.visitFieldInsn(GETSTATIC, "java/lang/Boolean", "TYPE", "Ljava/lang/Class;");
} }
else if (this.type == Byte.TYPE) { else if (this.type == byte.class) {
mv.visitFieldInsn(GETSTATIC, "java/lang/Byte", "TYPE", "Ljava/lang/Class;"); mv.visitFieldInsn(GETSTATIC, "java/lang/Byte", "TYPE", "Ljava/lang/Class;");
} }
else if (this.type == Character.TYPE) { else if (this.type == char.class) {
mv.visitFieldInsn(GETSTATIC, "java/lang/Character", "TYPE", "Ljava/lang/Class;"); mv.visitFieldInsn(GETSTATIC, "java/lang/Character", "TYPE", "Ljava/lang/Class;");
} }
else if (this.type == Double.TYPE) { else if (this.type == double.class) {
mv.visitFieldInsn(GETSTATIC, "java/lang/Double", "TYPE", "Ljava/lang/Class;"); mv.visitFieldInsn(GETSTATIC, "java/lang/Double", "TYPE", "Ljava/lang/Class;");
} }
else if (this.type == Float.TYPE) { else if (this.type == float.class) {
mv.visitFieldInsn(GETSTATIC, "java/lang/Float", "TYPE", "Ljava/lang/Class;"); mv.visitFieldInsn(GETSTATIC, "java/lang/Float", "TYPE", "Ljava/lang/Class;");
} }
else if (this.type == Integer.TYPE) { else if (this.type == int.class) {
mv.visitFieldInsn(GETSTATIC, "java/lang/Integer", "TYPE", "Ljava/lang/Class;"); mv.visitFieldInsn(GETSTATIC, "java/lang/Integer", "TYPE", "Ljava/lang/Class;");
} }
else if (this.type == Long.TYPE) { else if (this.type == long.class) {
mv.visitFieldInsn(GETSTATIC, "java/lang/Long", "TYPE", "Ljava/lang/Class;"); mv.visitFieldInsn(GETSTATIC, "java/lang/Long", "TYPE", "Ljava/lang/Class;");
} }
else if (this.type == Short.TYPE) { else if (this.type == short.class) {
mv.visitFieldInsn(GETSTATIC, "java/lang/Short", "TYPE", "Ljava/lang/Class;"); mv.visitFieldInsn(GETSTATIC, "java/lang/Short", "TYPE", "Ljava/lang/Class;");
} }
} }

6
spring-expression/src/main/java/org/springframework/expression/spel/support/ReflectivePropertyAccessor.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -73,7 +73,7 @@ public class ReflectivePropertyAccessor implements PropertyAccessor {
private static final Set<Class<?>> ANY_TYPES = Collections.emptySet(); private static final Set<Class<?>> ANY_TYPES = Collections.emptySet();
private static final Set<Class<?>> BOOLEAN_TYPES = Set.of(Boolean.class, Boolean.TYPE); private static final Set<Class<?>> BOOLEAN_TYPES = Set.of(Boolean.class, boolean.class);
private final boolean allowWrite; private final boolean allowWrite;
@ -338,7 +338,7 @@ public class ReflectivePropertyAccessor implements PropertyAccessor {
Class<?> type = (target instanceof Class<?> clazz ? clazz : target.getClass()); Class<?> type = (target instanceof Class<?> clazz ? clazz : target.getClass());
if (type.isArray() && name.equals("length")) { if (type.isArray() && name.equals("length")) {
return TypeDescriptor.valueOf(Integer.TYPE); return TypeDescriptor.valueOf(int.class);
} }
PropertyCacheKey cacheKey = new PropertyCacheKey(type, name, target instanceof Class); PropertyCacheKey cacheKey = new PropertyCacheKey(type, name, target instanceof Class);
TypeDescriptor typeDescriptor = this.typeDescriptorCache.get(cacheKey); TypeDescriptor typeDescriptor = this.typeDescriptorCache.get(cacheKey);

4
spring-expression/src/test/java/org/springframework/expression/spel/AbstractExpressionTests.java
View File

@ -260,7 +260,7 @@ public abstract class AbstractExpressionTests {
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
if (value.getClass().componentType().isPrimitive()) { if (value.getClass().componentType().isPrimitive()) {
Class<?> primitiveType = value.getClass().componentType(); Class<?> primitiveType = value.getClass().componentType();
if (primitiveType == Integer.TYPE) { if (primitiveType == int.class) {
int[] l = (int[]) value; int[] l = (int[]) value;
sb.append("int[").append(l.length).append("]{"); sb.append("int[").append(l.length).append("]{");
for (int j = 0; j < l.length; j++) { for (int j = 0; j < l.length; j++) {
@ -271,7 +271,7 @@ public abstract class AbstractExpressionTests {
} }
sb.append('}'); sb.append('}');
} }
else if (primitiveType == Long.TYPE) { else if (primitiveType == long.class) {
long[] l = (long[]) value; long[] l = (long[]) value;
sb.append("long[").append(l.length).append("]{"); sb.append("long[").append(l.length).append("]{");
for (int j = 0; j < l.length; j++) { for (int j = 0; j < l.length; j++) {

84
spring-expression/src/test/java/org/springframework/expression/spel/EvaluationTests.java
View File

@ -894,38 +894,38 @@ class EvaluationTests extends AbstractExpressionTests {
// double // double
e = parser.parseExpression("ddd++"); e = parser.parseExpression("ddd++");
assertThat((float) helper.ddd).isCloseTo((float) 2.0d, within((float) 0d)); assertThat((float) helper.ddd).isCloseTo((float) 2.0d, within((float) 0d));
double return_ddd = e.getValue(ctx, Double.TYPE); double return_ddd = e.getValue(ctx, double.class);
assertThat((float) return_ddd).isCloseTo((float) 2.0d, within((float) 0d)); assertThat((float) return_ddd).isCloseTo((float) 2.0d, within((float) 0d));
assertThat((float) helper.ddd).isCloseTo((float) 3.0d, within((float) 0d)); assertThat((float) helper.ddd).isCloseTo((float) 3.0d, within((float) 0d));
// float // float
e = parser.parseExpression("fff++"); e = parser.parseExpression("fff++");
assertThat(helper.fff).isCloseTo(3.0f, within((float) 0d)); assertThat(helper.fff).isCloseTo(3.0f, within((float) 0d));
float return_fff = e.getValue(ctx, Float.TYPE); float return_fff = e.getValue(ctx, float.class);
assertThat(return_fff).isCloseTo(3.0f, within((float) 0d)); assertThat(return_fff).isCloseTo(3.0f, within((float) 0d));
assertThat(helper.fff).isCloseTo(4.0f, within((float) 0d)); assertThat(helper.fff).isCloseTo(4.0f, within((float) 0d));
// long // long
e = parser.parseExpression("lll++"); e = parser.parseExpression("lll++");
assertThat(helper.lll).isEqualTo(66666L); assertThat(helper.lll).isEqualTo(66666L);
long return_lll = e.getValue(ctx, Long.TYPE); long return_lll = e.getValue(ctx, long.class);
assertThat(return_lll).isEqualTo(66666L); assertThat(return_lll).isEqualTo(66666L);
assertThat(helper.lll).isEqualTo(66667L); assertThat(helper.lll).isEqualTo(66667L);
// int // int
e = parser.parseExpression("iii++"); e = parser.parseExpression("iii++");
assertThat(helper.iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(42);
int return_iii = e.getValue(ctx, Integer.TYPE); int return_iii = e.getValue(ctx, int.class);
assertThat(return_iii).isEqualTo(42); assertThat(return_iii).isEqualTo(42);
assertThat(helper.iii).isEqualTo(43); assertThat(helper.iii).isEqualTo(43);
return_iii = e.getValue(ctx, Integer.TYPE); return_iii = e.getValue(ctx, int.class);
assertThat(return_iii).isEqualTo(43); assertThat(return_iii).isEqualTo(43);
assertThat(helper.iii).isEqualTo(44); assertThat(helper.iii).isEqualTo(44);
// short // short
e = parser.parseExpression("sss++"); e = parser.parseExpression("sss++");
assertThat(helper.sss).isEqualTo((short) 15); assertThat(helper.sss).isEqualTo((short) 15);
short return_sss = e.getValue(ctx, Short.TYPE); short return_sss = e.getValue(ctx, short.class);
assertThat(return_sss).isEqualTo((short) 15); assertThat(return_sss).isEqualTo((short) 15);
assertThat(helper.sss).isEqualTo((short) 16); assertThat(helper.sss).isEqualTo((short) 16);
} }
@ -947,31 +947,31 @@ class EvaluationTests extends AbstractExpressionTests {
// double // double
e = parser.parseExpression("++ddd"); e = parser.parseExpression("++ddd");
assertThat((float) helper.ddd).isCloseTo((float) 2.0d, within((float) 0d)); assertThat((float) helper.ddd).isCloseTo((float) 2.0d, within((float) 0d));
double return_ddd = e.getValue(ctx, Double.TYPE); double return_ddd = e.getValue(ctx, double.class);
assertThat((float) return_ddd).isCloseTo((float) 3.0d, within((float) 0d)); assertThat((float) return_ddd).isCloseTo((float) 3.0d, within((float) 0d));
assertThat((float) helper.ddd).isCloseTo((float) 3.0d, within((float) 0d)); assertThat((float) helper.ddd).isCloseTo((float) 3.0d, within((float) 0d));
// float // float
e = parser.parseExpression("++fff"); e = parser.parseExpression("++fff");
assertThat(helper.fff).isCloseTo(3.0f, within((float) 0d)); assertThat(helper.fff).isCloseTo(3.0f, within((float) 0d));
float return_fff = e.getValue(ctx, Float.TYPE); float return_fff = e.getValue(ctx, float.class);
assertThat(return_fff).isCloseTo(4.0f, within((float) 0d)); assertThat(return_fff).isCloseTo(4.0f, within((float) 0d));
assertThat(helper.fff).isCloseTo(4.0f, within((float) 0d)); assertThat(helper.fff).isCloseTo(4.0f, within((float) 0d));
// long // long
e = parser.parseExpression("++lll"); e = parser.parseExpression("++lll");
assertThat(helper.lll).isEqualTo(66666L); assertThat(helper.lll).isEqualTo(66666L);
long return_lll = e.getValue(ctx, Long.TYPE); long return_lll = e.getValue(ctx, long.class);
assertThat(return_lll).isEqualTo(66667L); assertThat(return_lll).isEqualTo(66667L);
assertThat(helper.lll).isEqualTo(66667L); assertThat(helper.lll).isEqualTo(66667L);
// int // int
e = parser.parseExpression("++iii"); e = parser.parseExpression("++iii");
assertThat(helper.iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(42);
int return_iii = e.getValue(ctx, Integer.TYPE); int return_iii = e.getValue(ctx, int.class);
assertThat(return_iii).isEqualTo(43); assertThat(return_iii).isEqualTo(43);
assertThat(helper.iii).isEqualTo(43); assertThat(helper.iii).isEqualTo(43);
return_iii = e.getValue(ctx, Integer.TYPE); return_iii = e.getValue(ctx, int.class);
assertThat(return_iii).isEqualTo(44); assertThat(return_iii).isEqualTo(44);
assertThat(helper.iii).isEqualTo(44); assertThat(helper.iii).isEqualTo(44);
@ -991,12 +991,12 @@ class EvaluationTests extends AbstractExpressionTests {
Expression e1 = parser.parseExpression("m()++"); Expression e1 = parser.parseExpression("m()++");
assertThatExceptionOfType(SpelEvaluationException.class) assertThatExceptionOfType(SpelEvaluationException.class)
.isThrownBy(() -> e1.getValue(ctx, Double.TYPE)) .isThrownBy(() -> e1.getValue(ctx, double.class))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_INCREMENTABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_INCREMENTABLE));
Expression e2 = parser.parseExpression("++m()"); Expression e2 = parser.parseExpression("++m()");
assertThatExceptionOfType(SpelEvaluationException.class) assertThatExceptionOfType(SpelEvaluationException.class)
.isThrownBy(() -> e2.getValue(ctx, Double.TYPE)) .isThrownBy(() -> e2.getValue(ctx, double.class))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_INCREMENTABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_INCREMENTABLE));
} }
@ -1007,11 +1007,11 @@ class EvaluationTests extends AbstractExpressionTests {
ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true)); ExpressionParser parser = new SpelExpressionParser(new SpelParserConfiguration(true, true));
Expression e1 = parser.parseExpression("++1"); Expression e1 = parser.parseExpression("++1");
assertThatExceptionOfType(SpelEvaluationException.class) assertThatExceptionOfType(SpelEvaluationException.class)
.isThrownBy(() -> e1.getValue(ctx, Double.TYPE)) .isThrownBy(() -> e1.getValue(ctx, double.class))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE));
Expression e2 = parser.parseExpression("1++"); Expression e2 = parser.parseExpression("1++");
assertThatExceptionOfType(SpelEvaluationException.class) assertThatExceptionOfType(SpelEvaluationException.class)
.isThrownBy(() -> e2.getValue(ctx, Double.TYPE)) .isThrownBy(() -> e2.getValue(ctx, double.class))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.NOT_ASSIGNABLE));
} }
@ -1044,38 +1044,38 @@ class EvaluationTests extends AbstractExpressionTests {
// double // double
e = parser.parseExpression("ddd--"); e = parser.parseExpression("ddd--");
assertThat((float) helper.ddd).isCloseTo((float) 2.0d, within((float) 0d)); assertThat((float) helper.ddd).isCloseTo((float) 2.0d, within((float) 0d));
double return_ddd = e.getValue(ctx, Double.TYPE); double return_ddd = e.getValue(ctx, double.class);
assertThat((float) return_ddd).isCloseTo((float) 2.0d, within((float) 0d)); assertThat((float) return_ddd).isCloseTo((float) 2.0d, within((float) 0d));
assertThat((float) helper.ddd).isCloseTo((float) 1.0d, within((float) 0d)); assertThat((float) helper.ddd).isCloseTo((float) 1.0d, within((float) 0d));
// float // float
e = parser.parseExpression("fff--"); e = parser.parseExpression("fff--");
assertThat(helper.fff).isCloseTo(3.0f, within((float) 0d)); assertThat(helper.fff).isCloseTo(3.0f, within((float) 0d));
float return_fff = e.getValue(ctx, Float.TYPE); float return_fff = e.getValue(ctx, float.class);
assertThat(return_fff).isCloseTo(3.0f, within((float) 0d)); assertThat(return_fff).isCloseTo(3.0f, within((float) 0d));
assertThat(helper.fff).isCloseTo(2.0f, within((float) 0d)); assertThat(helper.fff).isCloseTo(2.0f, within((float) 0d));
// long // long
e = parser.parseExpression("lll--"); e = parser.parseExpression("lll--");
assertThat(helper.lll).isEqualTo(66666L); assertThat(helper.lll).isEqualTo(66666L);
long return_lll = e.getValue(ctx, Long.TYPE); long return_lll = e.getValue(ctx, long.class);
assertThat(return_lll).isEqualTo(66666L); assertThat(return_lll).isEqualTo(66666L);
assertThat(helper.lll).isEqualTo(66665L); assertThat(helper.lll).isEqualTo(66665L);
// int // int
e = parser.parseExpression("iii--"); e = parser.parseExpression("iii--");
assertThat(helper.iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(42);
int return_iii = e.getValue(ctx, Integer.TYPE); int return_iii = e.getValue(ctx, int.class);
assertThat(return_iii).isEqualTo(42); assertThat(return_iii).isEqualTo(42);
assertThat(helper.iii).isEqualTo(41); assertThat(helper.iii).isEqualTo(41);
return_iii = e.getValue(ctx, Integer.TYPE); return_iii = e.getValue(ctx, int.class);
assertThat(return_iii).isEqualTo(41); assertThat(return_iii).isEqualTo(41);
assertThat(helper.iii).isEqualTo(40); assertThat(helper.iii).isEqualTo(40);
// short // short
e = parser.parseExpression("sss--"); e = parser.parseExpression("sss--");
assertThat(helper.sss).isEqualTo((short) 15); assertThat(helper.sss).isEqualTo((short) 15);
short return_sss = e.getValue(ctx, Short.TYPE); short return_sss = e.getValue(ctx, short.class);
assertThat(return_sss).isEqualTo((short) 15); assertThat(return_sss).isEqualTo((short) 15);
assertThat(helper.sss).isEqualTo((short) 14); assertThat(helper.sss).isEqualTo((short) 14);
} }
@ -1097,31 +1097,31 @@ class EvaluationTests extends AbstractExpressionTests {
// double // double
e = parser.parseExpression("--ddd"); e = parser.parseExpression("--ddd");
assertThat((float) helper.ddd).isCloseTo((float) 2.0d, within((float) 0d)); assertThat((float) helper.ddd).isCloseTo((float) 2.0d, within((float) 0d));
double return_ddd = e.getValue(ctx, Double.TYPE); double return_ddd = e.getValue(ctx, double.class);
assertThat((float) return_ddd).isCloseTo((float) 1.0d, within((float) 0d)); assertThat((float) return_ddd).isCloseTo((float) 1.0d, within((float) 0d));
assertThat((float) helper.ddd).isCloseTo((float) 1.0d, within((float) 0d)); assertThat((float) helper.ddd).isCloseTo((float) 1.0d, within((float) 0d));
// float // float
e = parser.parseExpression("--fff"); e = parser.parseExpression("--fff");
assertThat(helper.fff).isCloseTo(3.0f, within((float) 0d)); assertThat(helper.fff).isCloseTo(3.0f, within((float) 0d));
float return_fff = e.getValue(ctx, Float.TYPE); float return_fff = e.getValue(ctx, float.class);
assertThat(return_fff).isCloseTo(2.0f, within((float) 0d)); assertThat(return_fff).isCloseTo(2.0f, within((float) 0d));
assertThat(helper.fff).isCloseTo(2.0f, within((float) 0d)); assertThat(helper.fff).isCloseTo(2.0f, within((float) 0d));
// long // long
e = parser.parseExpression("--lll"); e = parser.parseExpression("--lll");
assertThat(helper.lll).isEqualTo(66666L); assertThat(helper.lll).isEqualTo(66666L);
long return_lll = e.getValue(ctx, Long.TYPE); long return_lll = e.getValue(ctx, long.class);
assertThat(return_lll).isEqualTo(66665L); assertThat(return_lll).isEqualTo(66665L);
assertThat(helper.lll).isEqualTo(66665L); assertThat(helper.lll).isEqualTo(66665L);
// int // int
e = parser.parseExpression("--iii"); e = parser.parseExpression("--iii");
assertThat(helper.iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(42);
int return_iii = e.getValue(ctx, Integer.TYPE); int return_iii = e.getValue(ctx, int.class);
assertThat(return_iii).isEqualTo(41); assertThat(return_iii).isEqualTo(41);
assertThat(helper.iii).isEqualTo(41); assertThat(helper.iii).isEqualTo(41);
return_iii = e.getValue(ctx, Integer.TYPE); return_iii = e.getValue(ctx, int.class);
assertThat(return_iii).isEqualTo(40); assertThat(return_iii).isEqualTo(40);
assertThat(helper.iii).isEqualTo(40); assertThat(helper.iii).isEqualTo(40);
@ -1141,12 +1141,12 @@ class EvaluationTests extends AbstractExpressionTests {
Expression e1 = parser.parseExpression("m()--"); Expression e1 = parser.parseExpression("m()--");
assertThatExceptionOfType(SpelEvaluationException.class) assertThatExceptionOfType(SpelEvaluationException.class)
.isThrownBy(() -> e1.getValue(ctx, Double.TYPE)) .isThrownBy(() -> e1.getValue(ctx, double.class))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_DECREMENTABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_DECREMENTABLE));
Expression e2 = parser.parseExpression("--m()"); Expression e2 = parser.parseExpression("--m()");
assertThatExceptionOfType(SpelEvaluationException.class) assertThatExceptionOfType(SpelEvaluationException.class)
.isThrownBy(() -> e2.getValue(ctx, Double.TYPE)) .isThrownBy(() -> e2.getValue(ctx, double.class))
.satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_DECREMENTABLE)); .satisfies(ex -> assertThat(ex.getMessageCode()).isEqualTo(SpelMessage.OPERAND_NOT_DECREMENTABLE));
} }
@ -1349,26 +1349,26 @@ class EvaluationTests extends AbstractExpressionTests {
// iii=42 // iii=42
e = parser.parseExpression("iii=iii++"); e = parser.parseExpression("iii=iii++");
assertThat(helper.iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(42);
int return_iii = e.getValue(ctx, Integer.TYPE); int return_iii = e.getValue(ctx, int.class);
assertThat(helper.iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(42);
assertThat(return_iii).isEqualTo(42); assertThat(return_iii).isEqualTo(42);
// Identifier // Identifier
e = parser.parseExpression("iii++"); e = parser.parseExpression("iii++");
assertThat(helper.iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(42);
return_iii = e.getValue(ctx, Integer.TYPE); return_iii = e.getValue(ctx, int.class);
assertThat(return_iii).isEqualTo(42); assertThat(return_iii).isEqualTo(42);
assertThat(helper.iii).isEqualTo(43); assertThat(helper.iii).isEqualTo(43);
e = parser.parseExpression("--iii"); e = parser.parseExpression("--iii");
assertThat(helper.iii).isEqualTo(43); assertThat(helper.iii).isEqualTo(43);
return_iii = e.getValue(ctx, Integer.TYPE); return_iii = e.getValue(ctx, int.class);
assertThat(return_iii).isEqualTo(42); assertThat(return_iii).isEqualTo(42);
assertThat(helper.iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(42);
e = parser.parseExpression("iii=99"); e = parser.parseExpression("iii=99");
assertThat(helper.iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(42);
return_iii = e.getValue(ctx, Integer.TYPE); return_iii = e.getValue(ctx, int.class);
assertThat(return_iii).isEqualTo(99); assertThat(return_iii).isEqualTo(99);
assertThat(helper.iii).isEqualTo(99); assertThat(helper.iii).isEqualTo(99);
@ -1376,19 +1376,19 @@ class EvaluationTests extends AbstractExpressionTests {
// foo.iii == 99 // foo.iii == 99
e = parser.parseExpression("foo.iii++"); e = parser.parseExpression("foo.iii++");
assertThat(helper.foo.iii).isEqualTo(99); assertThat(helper.foo.iii).isEqualTo(99);
int return_foo_iii = e.getValue(ctx, Integer.TYPE); int return_foo_iii = e.getValue(ctx, int.class);
assertThat(return_foo_iii).isEqualTo(99); assertThat(return_foo_iii).isEqualTo(99);
assertThat(helper.foo.iii).isEqualTo(100); assertThat(helper.foo.iii).isEqualTo(100);
e = parser.parseExpression("--foo.iii"); e = parser.parseExpression("--foo.iii");
assertThat(helper.foo.iii).isEqualTo(100); assertThat(helper.foo.iii).isEqualTo(100);
return_foo_iii = e.getValue(ctx, Integer.TYPE); return_foo_iii = e.getValue(ctx, int.class);
assertThat(return_foo_iii).isEqualTo(99); assertThat(return_foo_iii).isEqualTo(99);
assertThat(helper.foo.iii).isEqualTo(99); assertThat(helper.foo.iii).isEqualTo(99);
e = parser.parseExpression("foo.iii=999"); e = parser.parseExpression("foo.iii=999");
assertThat(helper.foo.iii).isEqualTo(99); assertThat(helper.foo.iii).isEqualTo(99);
return_foo_iii = e.getValue(ctx, Integer.TYPE); return_foo_iii = e.getValue(ctx, int.class);
assertThat(return_foo_iii).isEqualTo(999); assertThat(return_foo_iii).isEqualTo(999);
assertThat(helper.foo.iii).isEqualTo(999); assertThat(helper.foo.iii).isEqualTo(999);
@ -1408,7 +1408,7 @@ class EvaluationTests extends AbstractExpressionTests {
expectFailSetValueNotSupported(parser, ctx, "('abc' matches '^a..')=('abc' matches '^a..')"); expectFailSetValueNotSupported(parser, ctx, "('abc' matches '^a..')=('abc' matches '^a..')");
// Selection // Selection
ctx.registerFunction("isEven", Spr9751.class.getDeclaredMethod("isEven", Integer.TYPE)); ctx.registerFunction("isEven", Spr9751.class.getDeclaredMethod("isEven", int.class));
expectFailNotIncrementable(parser, ctx, "({1,2,3}.?[#isEven(#this)])++"); expectFailNotIncrementable(parser, ctx, "({1,2,3}.?[#isEven(#this)])++");
expectFailNotDecrementable(parser, ctx, "--({1,2,3}.?[#isEven(#this)])"); expectFailNotDecrementable(parser, ctx, "--({1,2,3}.?[#isEven(#this)])");
@ -1440,19 +1440,19 @@ class EvaluationTests extends AbstractExpressionTests {
ctx.setVariable("wobble", 3); ctx.setVariable("wobble", 3);
e = parser.parseExpression("#wobble++"); e = parser.parseExpression("#wobble++");
assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(3); assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(3);
int r = e.getValue(ctx, Integer.TYPE); int r = e.getValue(ctx, int.class);
assertThat(r).isEqualTo(3); assertThat(r).isEqualTo(3);
assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(4); assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(4);
e = parser.parseExpression("--#wobble"); e = parser.parseExpression("--#wobble");
assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(4); assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(4);
r = e.getValue(ctx, Integer.TYPE); r = e.getValue(ctx, int.class);
assertThat(r).isEqualTo(3); assertThat(r).isEqualTo(3);
assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(3); assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(3);
e = parser.parseExpression("#wobble=34"); e = parser.parseExpression("#wobble=34");
assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(3); assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(3);
r = e.getValue(ctx, Integer.TYPE); r = e.getValue(ctx, int.class);
assertThat(r).isEqualTo(34); assertThat(r).isEqualTo(34);
assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(34); assertThat(((Integer) ctx.lookupVariable("wobble"))).isEqualTo(34);
@ -1487,19 +1487,19 @@ class EvaluationTests extends AbstractExpressionTests {
helper.iii = 42; helper.iii = 42;
e = parser.parseExpression("iii++"); e = parser.parseExpression("iii++");
assertThat(helper.iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(42);
r = e.getValue(ctx, Integer.TYPE); r = e.getValue(ctx, int.class);
assertThat(r).isEqualTo(42); assertThat(r).isEqualTo(42);
assertThat(helper.iii).isEqualTo(43); assertThat(helper.iii).isEqualTo(43);
e = parser.parseExpression("--iii"); e = parser.parseExpression("--iii");
assertThat(helper.iii).isEqualTo(43); assertThat(helper.iii).isEqualTo(43);
r = e.getValue(ctx, Integer.TYPE); r = e.getValue(ctx, int.class);
assertThat(r).isEqualTo(42); assertThat(r).isEqualTo(42);
assertThat(helper.iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(42);
e = parser.parseExpression("iii=100"); e = parser.parseExpression("iii=100");
assertThat(helper.iii).isEqualTo(42); assertThat(helper.iii).isEqualTo(42);
r = e.getValue(ctx, Integer.TYPE); r = e.getValue(ctx, int.class);
assertThat(r).isEqualTo(100); assertThat(r).isEqualTo(100);
assertThat(helper.iii).isEqualTo(100); assertThat(helper.iii).isEqualTo(100);
} }

166
spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationCoverageTests.java
View File

@ -156,44 +156,44 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
assertThat(expression.getValue()).isEqualTo(int[][].class); assertThat(expression.getValue()).isEqualTo(int[][].class);
expression = parse("T(int)"); expression = parse("T(int)");
assertThat(expression.getValue()).isEqualTo(Integer.TYPE); assertThat(expression.getValue()).isEqualTo(int.class);
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue()).isEqualTo(Integer.TYPE); assertThat(expression.getValue()).isEqualTo(int.class);
expression = parse("T(byte)"); expression = parse("T(byte)");
assertThat(expression.getValue()).isEqualTo(Byte.TYPE); assertThat(expression.getValue()).isEqualTo(byte.class);
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue()).isEqualTo(Byte.TYPE); assertThat(expression.getValue()).isEqualTo(byte.class);
expression = parse("T(char)"); expression = parse("T(char)");
assertThat(expression.getValue()).isEqualTo(Character.TYPE); assertThat(expression.getValue()).isEqualTo(char.class);
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue()).isEqualTo(Character.TYPE); assertThat(expression.getValue()).isEqualTo(char.class);
expression = parse("T(short)"); expression = parse("T(short)");
assertThat(expression.getValue()).isEqualTo(Short.TYPE); assertThat(expression.getValue()).isEqualTo(short.class);
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue()).isEqualTo(Short.TYPE); assertThat(expression.getValue()).isEqualTo(short.class);
expression = parse("T(long)"); expression = parse("T(long)");
assertThat(expression.getValue()).isEqualTo(Long.TYPE); assertThat(expression.getValue()).isEqualTo(long.class);
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue()).isEqualTo(Long.TYPE); assertThat(expression.getValue()).isEqualTo(long.class);
expression = parse("T(float)"); expression = parse("T(float)");
assertThat(expression.getValue()).isEqualTo(Float.TYPE); assertThat(expression.getValue()).isEqualTo(float.class);
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue()).isEqualTo(Float.TYPE); assertThat(expression.getValue()).isEqualTo(float.class);
expression = parse("T(double)"); expression = parse("T(double)");
assertThat(expression.getValue()).isEqualTo(Double.TYPE); assertThat(expression.getValue()).isEqualTo(double.class);
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue()).isEqualTo(Double.TYPE); assertThat(expression.getValue()).isEqualTo(double.class);
expression = parse("T(boolean)"); expression = parse("T(boolean)");
assertThat(expression.getValue()).isEqualTo(Boolean.TYPE); assertThat(expression.getValue()).isEqualTo(boolean.class);
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue()).isEqualTo(Boolean.TYPE); assertThat(expression.getValue()).isEqualTo(boolean.class);
expression = parse("T(Missing)"); expression = parse("T(Missing)");
assertGetValueFail(expression); assertGetValueFail(expression);
@ -326,9 +326,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
@Test @Test
void realLiteral() { void realLiteral() {
expression = parser.parseExpression("3.4d"); expression = parser.parseExpression("3.4d");
double resultI = expression.getValue(new TestClass1(), Double.TYPE); double resultI = expression.getValue(new TestClass1(), double.class);
assertCanCompile(expression); assertCanCompile(expression);
double resultC = expression.getValue(new TestClass1(), Double.TYPE); double resultC = expression.getValue(new TestClass1(), double.class);
assertThat(resultI).isCloseTo(3.4d, within(0.1d)); assertThat(resultI).isCloseTo(3.4d, within(0.1d));
assertThat(resultC).isCloseTo(3.4d, within(0.1d)); assertThat(resultC).isCloseTo(3.4d, within(0.1d));
@ -454,9 +454,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
@Test @Test
void intLiteral() { void intLiteral() {
expression = parser.parseExpression("42"); expression = parser.parseExpression("42");
int resultI = expression.getValue(new TestClass1(), Integer.TYPE); int resultI = expression.getValue(new TestClass1(), int.class);
assertCanCompile(expression); assertCanCompile(expression);
int resultC = expression.getValue(new TestClass1(), Integer.TYPE); int resultC = expression.getValue(new TestClass1(), int.class);
assertThat(resultI).isEqualTo(42); assertThat(resultI).isEqualTo(42);
assertThat(resultC).isEqualTo(42); assertThat(resultC).isEqualTo(42);
@ -485,9 +485,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
@Test @Test
void longLiteral() { void longLiteral() {
expression = parser.parseExpression("99L"); expression = parser.parseExpression("99L");
long resultI = expression.getValue(new TestClass1(), Long.TYPE); long resultI = expression.getValue(new TestClass1(), long.class);
assertCanCompile(expression); assertCanCompile(expression);
long resultC = expression.getValue(new TestClass1(), Long.TYPE); long resultC = expression.getValue(new TestClass1(), long.class);
assertThat(resultI).isEqualTo(99L); assertThat(resultI).isEqualTo(99L);
assertThat(resultC).isEqualTo(99L); assertThat(resultC).isEqualTo(99L);
} }
@ -495,26 +495,26 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
@Test @Test
void booleanLiteral() { void booleanLiteral() {
expression = parser.parseExpression("true"); expression = parser.parseExpression("true");
boolean resultI = expression.getValue(1, Boolean.TYPE); boolean resultI = expression.getValue(1, boolean.class);
assertThat(resultI).isTrue(); assertThat(resultI).isTrue();
assertThat(SpelCompiler.compile(expression)).isTrue(); assertThat(SpelCompiler.compile(expression)).isTrue();
boolean resultC = expression.getValue(1, Boolean.TYPE); boolean resultC = expression.getValue(1, boolean.class);
assertThat(resultC).isTrue(); assertThat(resultC).isTrue();
expression = parser.parseExpression("false"); expression = parser.parseExpression("false");
resultI = expression.getValue(1, Boolean.TYPE); resultI = expression.getValue(1, boolean.class);
assertThat(resultI).isFalse(); assertThat(resultI).isFalse();
assertThat(SpelCompiler.compile(expression)).isTrue(); assertThat(SpelCompiler.compile(expression)).isTrue();
resultC = expression.getValue(1, Boolean.TYPE); resultC = expression.getValue(1, boolean.class);
assertThat(resultC).isFalse(); assertThat(resultC).isFalse();
} }
@Test @Test
void floatLiteral() { void floatLiteral() {
expression = parser.parseExpression("3.4f"); expression = parser.parseExpression("3.4f");
float resultI = expression.getValue(new TestClass1(), Float.TYPE); float resultI = expression.getValue(new TestClass1(), float.class);
assertCanCompile(expression); assertCanCompile(expression);
float resultC = expression.getValue(new TestClass1(), Float.TYPE); float resultC = expression.getValue(new TestClass1(), float.class);
assertThat(resultI).isCloseTo(3.4f, within(0.1f)); assertThat(resultI).isCloseTo(3.4f, within(0.1f));
assertThat(resultC).isCloseTo(3.4f, within(0.1f)); assertThat(resultC).isCloseTo(3.4f, within(0.1f));
@ -525,54 +525,54 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
@Test @Test
void opOr() { void opOr() {
Expression expression = parser.parseExpression("false or false"); Expression expression = parser.parseExpression("false or false");
boolean resultI = expression.getValue(1, Boolean.TYPE); boolean resultI = expression.getValue(1, boolean.class);
SpelCompiler.compile(expression); SpelCompiler.compile(expression);
boolean resultC = expression.getValue(1, Boolean.TYPE); boolean resultC = expression.getValue(1, boolean.class);
assertThat(resultI).isFalse(); assertThat(resultI).isFalse();
assertThat(resultC).isFalse(); assertThat(resultC).isFalse();
expression = parser.parseExpression("false or true"); expression = parser.parseExpression("false or true");
resultI = expression.getValue(1, Boolean.TYPE); resultI = expression.getValue(1, boolean.class);
assertCanCompile(expression); assertCanCompile(expression);
resultC = expression.getValue(1, Boolean.TYPE); resultC = expression.getValue(1, boolean.class);
assertThat(resultI).isTrue(); assertThat(resultI).isTrue();
assertThat(resultC).isTrue(); assertThat(resultC).isTrue();
expression = parser.parseExpression("true or false"); expression = parser.parseExpression("true or false");
resultI = expression.getValue(1, Boolean.TYPE); resultI = expression.getValue(1, boolean.class);
assertCanCompile(expression); assertCanCompile(expression);
resultC = expression.getValue(1, Boolean.TYPE); resultC = expression.getValue(1, boolean.class);
assertThat(resultI).isTrue(); assertThat(resultI).isTrue();
assertThat(resultC).isTrue(); assertThat(resultC).isTrue();
expression = parser.parseExpression("true or true"); expression = parser.parseExpression("true or true");
resultI = expression.getValue(1, Boolean.TYPE); resultI = expression.getValue(1, boolean.class);
assertCanCompile(expression); assertCanCompile(expression);
resultC = expression.getValue(1, Boolean.TYPE); resultC = expression.getValue(1, boolean.class);
assertThat(resultI).isTrue(); assertThat(resultI).isTrue();
assertThat(resultC).isTrue(); assertThat(resultC).isTrue();
TestClass4 tc = new TestClass4(); TestClass4 tc = new TestClass4();
expression = parser.parseExpression("getfalse() or gettrue()"); expression = parser.parseExpression("getfalse() or gettrue()");
resultI = expression.getValue(tc, Boolean.TYPE); resultI = expression.getValue(tc, boolean.class);
assertCanCompile(expression); assertCanCompile(expression);
resultC = expression.getValue(tc, Boolean.TYPE); resultC = expression.getValue(tc, boolean.class);
assertThat(resultI).isTrue(); assertThat(resultI).isTrue();
assertThat(resultC).isTrue(); assertThat(resultC).isTrue();
// Can't compile this as we aren't going down the getfalse() branch in our evaluation // Can't compile this as we aren't going down the getfalse() branch in our evaluation
expression = parser.parseExpression("gettrue() or getfalse()"); expression = parser.parseExpression("gettrue() or getfalse()");
resultI = expression.getValue(tc, Boolean.TYPE); resultI = expression.getValue(tc, boolean.class);
assertCantCompile(expression); assertCantCompile(expression);
expression = parser.parseExpression("getA() or getB()"); expression = parser.parseExpression("getA() or getB()");
tc.a = true; tc.a = true;
tc.b = true; tc.b = true;
resultI = expression.getValue(tc, Boolean.TYPE); resultI = expression.getValue(tc, boolean.class);
assertCantCompile(expression); // Haven't yet been into second branch assertCantCompile(expression); // Haven't yet been into second branch
tc.a = false; tc.a = false;
tc.b = true; tc.b = true;
resultI = expression.getValue(tc, Boolean.TYPE); resultI = expression.getValue(tc, boolean.class);
assertCanCompile(expression); // Now been down both assertCanCompile(expression); // Now been down both
assertThat(resultI).isTrue(); assertThat(resultI).isTrue();
@ -587,30 +587,30 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
@Test @Test
void opAnd() { void opAnd() {
Expression expression = parser.parseExpression("false and false"); Expression expression = parser.parseExpression("false and false");
boolean resultI = expression.getValue(1, Boolean.TYPE); boolean resultI = expression.getValue(1, boolean.class);
SpelCompiler.compile(expression); SpelCompiler.compile(expression);
boolean resultC = expression.getValue(1, Boolean.TYPE); boolean resultC = expression.getValue(1, boolean.class);
assertThat(resultI).isFalse(); assertThat(resultI).isFalse();
assertThat(resultC).isFalse(); assertThat(resultC).isFalse();
expression = parser.parseExpression("false and true"); expression = parser.parseExpression("false and true");
resultI = expression.getValue(1, Boolean.TYPE); resultI = expression.getValue(1, boolean.class);
SpelCompiler.compile(expression); SpelCompiler.compile(expression);
resultC = expression.getValue(1, Boolean.TYPE); resultC = expression.getValue(1, boolean.class);
assertThat(resultI).isFalse(); assertThat(resultI).isFalse();
assertThat(resultC).isFalse(); assertThat(resultC).isFalse();
expression = parser.parseExpression("true and false"); expression = parser.parseExpression("true and false");
resultI = expression.getValue(1, Boolean.TYPE); resultI = expression.getValue(1, boolean.class);
SpelCompiler.compile(expression); SpelCompiler.compile(expression);
resultC = expression.getValue(1, Boolean.TYPE); resultC = expression.getValue(1, boolean.class);
assertThat(resultI).isFalse(); assertThat(resultI).isFalse();
assertThat(resultC).isFalse(); assertThat(resultC).isFalse();
expression = parser.parseExpression("true and true"); expression = parser.parseExpression("true and true");
resultI = expression.getValue(1, Boolean.TYPE); resultI = expression.getValue(1, boolean.class);
SpelCompiler.compile(expression); SpelCompiler.compile(expression);
resultC = expression.getValue(1, Boolean.TYPE); resultC = expression.getValue(1, boolean.class);
assertThat(resultI).isTrue(); assertThat(resultI).isTrue();
assertThat(resultC).isTrue(); assertThat(resultC).isTrue();
@ -618,22 +618,22 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
// Can't compile this as we aren't going down the gettrue() branch in our evaluation // Can't compile this as we aren't going down the gettrue() branch in our evaluation
expression = parser.parseExpression("getfalse() and gettrue()"); expression = parser.parseExpression("getfalse() and gettrue()");
resultI = expression.getValue(tc, Boolean.TYPE); resultI = expression.getValue(tc, boolean.class);
assertCantCompile(expression); assertCantCompile(expression);
expression = parser.parseExpression("getA() and getB()"); expression = parser.parseExpression("getA() and getB()");
tc.a = false; tc.a = false;
tc.b = false; tc.b = false;
resultI = expression.getValue(tc, Boolean.TYPE); resultI = expression.getValue(tc, boolean.class);
assertCantCompile(expression); // Haven't yet been into second branch assertCantCompile(expression); // Haven't yet been into second branch
tc.a = true; tc.a = true;
tc.b = false; tc.b = false;
resultI = expression.getValue(tc, Boolean.TYPE); resultI = expression.getValue(tc, boolean.class);
assertCanCompile(expression); // Now been down both assertCanCompile(expression); // Now been down both
assertThat(resultI).isFalse(); assertThat(resultI).isFalse();
tc.a = true; tc.a = true;
tc.b = true; tc.b = true;
resultI = expression.getValue(tc, Boolean.TYPE); resultI = expression.getValue(tc, boolean.class);
assertThat(resultI).isTrue(); assertThat(resultI).isTrue();
boolean b = true; boolean b = true;
@ -1021,7 +1021,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
ctx.setVariable("b", "boo"); ctx.setVariable("b", "boo");
assertThat(expression.getValue(ctx)).isEqualTo("fooboo"); assertThat(expression.getValue(ctx)).isEqualTo("fooboo");
m = Math.class.getDeclaredMethod("pow", Double.TYPE, Double.TYPE); m = Math.class.getDeclaredMethod("pow", double.class, double.class);
ctx.setVariable("kapow",m); ctx.setVariable("kapow",m);
expression = parser.parseExpression("#kapow(2.0d,2.0d)"); expression = parser.parseExpression("#kapow(2.0d,2.0d)");
assertThat(expression.getValue(ctx).toString()).isEqualTo("4.0"); assertThat(expression.getValue(ctx).toString()).isEqualTo("4.0");
@ -1109,7 +1109,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
void functionReferenceNonCompilableArguments_SPR12359() throws Exception { void functionReferenceNonCompilableArguments_SPR12359() throws Exception {
StandardEvaluationContext context = new StandardEvaluationContext(new Object[] {"1"}); StandardEvaluationContext context = new StandardEvaluationContext(new Object[] {"1"});
context.registerFunction("negate", SomeCompareMethod2.class.getDeclaredMethod( context.registerFunction("negate", SomeCompareMethod2.class.getDeclaredMethod(
"negate", Integer.TYPE)); "negate", int.class));
context.setVariable("arg", "2"); context.setVariable("arg", "2");
int[] ints = new int[] {1,2,3}; int[] ints = new int[] {1,2,3};
context.setVariable("ints",ints); context.setVariable("ints",ints);
@ -3242,11 +3242,11 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
assertThat(expression.getValue()).isEqualTo(0); assertThat(expression.getValue()).isEqualTo(0);
expression = parse("payload%2==0"); expression = parse("payload%2==0");
assertThat(expression.getValue(new GenericMessageTestHelper<>(4), Boolean.TYPE)).isTrue(); assertThat(expression.getValue(new GenericMessageTestHelper<>(4), boolean.class)).isTrue();
assertThat(expression.getValue(new GenericMessageTestHelper<>(5), Boolean.TYPE)).isFalse(); assertThat(expression.getValue(new GenericMessageTestHelper<>(5), boolean.class)).isFalse();
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue(new GenericMessageTestHelper<>(4), Boolean.TYPE)).isTrue(); assertThat(expression.getValue(new GenericMessageTestHelper<>(4), boolean.class)).isTrue();
assertThat(expression.getValue(new GenericMessageTestHelper<>(5), Boolean.TYPE)).isFalse(); assertThat(expression.getValue(new GenericMessageTestHelper<>(5), boolean.class)).isFalse();
expression = parse("8%3"); expression = parse("8%3");
assertThat(expression.getValue()).isEqualTo(2); assertThat(expression.getValue()).isEqualTo(2);
@ -4198,9 +4198,9 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
@Test @Test
void methodReference_staticMethod() { void methodReference_staticMethod() {
Expression expression = parser.parseExpression("T(Integer).valueOf(42)"); Expression expression = parser.parseExpression("T(Integer).valueOf(42)");
int resultI = expression.getValue(new TestClass1(), Integer.TYPE); int resultI = expression.getValue(new TestClass1(), int.class);
assertCanCompile(expression); assertCanCompile(expression);
int resultC = expression.getValue(new TestClass1(), Integer.TYPE); int resultC = expression.getValue(new TestClass1(), int.class);
assertThat(resultI).isEqualTo(42); assertThat(resultI).isEqualTo(42);
assertThat(resultC).isEqualTo(42); assertThat(resultC).isEqualTo(42);
} }
@ -4228,19 +4228,19 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
@Test @Test
void methodReference_simpleInstanceMethodNoArgReturnPrimitive() { void methodReference_simpleInstanceMethodNoArgReturnPrimitive() {
expression = parser.parseExpression("intValue()"); expression = parser.parseExpression("intValue()");
int resultI = expression.getValue(42, Integer.TYPE); int resultI = expression.getValue(42, int.class);
assertThat(resultI).isEqualTo(42); assertThat(resultI).isEqualTo(42);
assertCanCompile(expression); assertCanCompile(expression);
int resultC = expression.getValue(42, Integer.TYPE); int resultC = expression.getValue(42, int.class);
assertThat(resultC).isEqualTo(42); assertThat(resultC).isEqualTo(42);
} }
@Test @Test
void methodReference_simpleInstanceMethodOneArgReturnPrimitive1() { void methodReference_simpleInstanceMethodOneArgReturnPrimitive1() {
Expression expression = parser.parseExpression("indexOf('b')"); Expression expression = parser.parseExpression("indexOf('b')");
int resultI = expression.getValue("abc", Integer.TYPE); int resultI = expression.getValue("abc", int.class);
assertCanCompile(expression); assertCanCompile(expression);
int resultC = expression.getValue("abc", Integer.TYPE); int resultC = expression.getValue("abc", int.class);
assertThat(resultI).isEqualTo(1); assertThat(resultI).isEqualTo(1);
assertThat(resultC).isEqualTo(1); assertThat(resultC).isEqualTo(1);
} }
@ -4248,10 +4248,10 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
@Test @Test
void methodReference_simpleInstanceMethodOneArgReturnPrimitive2() { void methodReference_simpleInstanceMethodOneArgReturnPrimitive2() {
expression = parser.parseExpression("charAt(2)"); expression = parser.parseExpression("charAt(2)");
char resultI = expression.getValue("abc", Character.TYPE); char resultI = expression.getValue("abc", char.class);
assertThat(resultI).isEqualTo('c'); assertThat(resultI).isEqualTo('c');
assertCanCompile(expression); assertCanCompile(expression);
char resultC = expression.getValue("abc", Character.TYPE); char resultC = expression.getValue("abc", char.class);
assertThat(resultC).isEqualTo('c'); assertThat(resultC).isEqualTo('c');
} }
@ -4877,44 +4877,44 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
@Test @Test
void compilerWithGenerics_12040_3() { void compilerWithGenerics_12040_3() {
expression = parser.parseExpression("payload >= 2"); expression = parser.parseExpression("payload >= 2");
assertThat(expression.getValue(new GenericMessageTestHelper2<>(4), Boolean.TYPE)).isTrue(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(4), boolean.class)).isTrue();
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isFalse(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isFalse();
expression = parser.parseExpression("2 >= payload"); expression = parser.parseExpression("2 >= payload");
assertThat(expression.getValue(new GenericMessageTestHelper2<>(5), Boolean.TYPE)).isFalse(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(5), boolean.class)).isFalse();
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isTrue(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isTrue();
expression = parser.parseExpression("payload > 2"); expression = parser.parseExpression("payload > 2");
assertThat(expression.getValue(new GenericMessageTestHelper2<>(4), Boolean.TYPE)).isTrue(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(4), boolean.class)).isTrue();
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isFalse(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isFalse();
expression = parser.parseExpression("2 > payload"); expression = parser.parseExpression("2 > payload");
assertThat(expression.getValue(new GenericMessageTestHelper2<>(5), Boolean.TYPE)).isFalse(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(5), boolean.class)).isFalse();
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isTrue(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isTrue();
expression = parser.parseExpression("payload <=2"); expression = parser.parseExpression("payload <=2");
assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isTrue(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isTrue();
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), Boolean.TYPE)).isFalse(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), boolean.class)).isFalse();
expression = parser.parseExpression("2 <= payload"); expression = parser.parseExpression("2 <= payload");
assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isFalse(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isFalse();
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), Boolean.TYPE)).isTrue(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), boolean.class)).isTrue();
expression = parser.parseExpression("payload < 2"); expression = parser.parseExpression("payload < 2");
assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isTrue(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isTrue();
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), Boolean.TYPE)).isFalse(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), boolean.class)).isFalse();
expression = parser.parseExpression("2 < payload"); expression = parser.parseExpression("2 < payload");
assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), Boolean.TYPE)).isFalse(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(1), boolean.class)).isFalse();
assertCanCompile(expression); assertCanCompile(expression);
assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), Boolean.TYPE)).isTrue(); assertThat(expression.getValue(new GenericMessageTestHelper2<>(6), boolean.class)).isTrue();
} }
@Test @Test

10
spring-expression/src/test/java/org/springframework/expression/spel/SpelCompilationPerformanceTests.java
View File

@ -274,14 +274,14 @@ public class SpelCompilationPerformanceTests extends AbstractExpressionTests {
// warmup // warmup
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
b = expression.getValue(payload, Boolean.TYPE); b = expression.getValue(payload, boolean.class);
} }
log("timing interpreted: "); log("timing interpreted: ");
for (int i = 0; i < iterations; i++) { for (int i = 0; i < iterations; i++) {
long stime = System.currentTimeMillis(); long stime = System.currentTimeMillis();
for (int j = 0; j < count; j++) { for (int j = 0; j < count; j++) {
b = expression.getValue(payload, Boolean.TYPE); b = expression.getValue(payload, boolean.class);
} }
long etime = System.currentTimeMillis(); long etime = System.currentTimeMillis();
long interpretedSpeed = (etime - stime); long interpretedSpeed = (etime - stime);
@ -292,12 +292,12 @@ public class SpelCompilationPerformanceTests extends AbstractExpressionTests {
compile(expression); compile(expression);
boolean bc = false; boolean bc = false;
expression.getValue(payload, Boolean.TYPE); expression.getValue(payload, boolean.class);
log("timing compiled: "); log("timing compiled: ");
for (int i = 0; i < iterations; i++) { for (int i = 0; i < iterations; i++) {
long stime = System.currentTimeMillis(); long stime = System.currentTimeMillis();
for (int j = 0; j < count; j++) { for (int j = 0; j < count; j++) {
bc = expression.getValue(payload, Boolean.TYPE); bc = expression.getValue(payload, boolean.class);
} }
long etime = System.currentTimeMillis(); long etime = System.currentTimeMillis();
long compiledSpeed = (etime - stime); long compiledSpeed = (etime - stime);
@ -316,7 +316,7 @@ public class SpelCompilationPerformanceTests extends AbstractExpressionTests {
// Verify if the input changes, the result changes // Verify if the input changes, the result changes
payload.DR[0].DRFixedSection.duration = 0.04d; payload.DR[0].DRFixedSection.duration = 0.04d;
bc = expression.getValue(payload, Boolean.TYPE); bc = expression.getValue(payload, boolean.class);
assertThat(bc).isTrue(); assertThat(bc).isTrue();
} }

6
spring-expression/src/test/java/org/springframework/expression/spel/TestScenarioCreator.java
View File

@ -57,15 +57,15 @@ class TestScenarioCreator {
private static void populateFunctions(StandardEvaluationContext testContext) { private static void populateFunctions(StandardEvaluationContext testContext) {
try { try {
testContext.registerFunction("isEven", testContext.registerFunction("isEven",
TestScenarioCreator.class.getDeclaredMethod("isEven", Integer.TYPE)); TestScenarioCreator.class.getDeclaredMethod("isEven", int.class));
testContext.registerFunction("reverseInt", testContext.registerFunction("reverseInt",
TestScenarioCreator.class.getDeclaredMethod("reverseInt", Integer.TYPE, Integer.TYPE, Integer.TYPE)); TestScenarioCreator.class.getDeclaredMethod("reverseInt", int.class, int.class, int.class));
testContext.registerFunction("reverseString", testContext.registerFunction("reverseString",
TestScenarioCreator.class.getDeclaredMethod("reverseString", String.class)); TestScenarioCreator.class.getDeclaredMethod("reverseString", String.class));
testContext.registerFunction("varargsFunction", testContext.registerFunction("varargsFunction",
TestScenarioCreator.class.getDeclaredMethod("varargsFunction", String[].class)); TestScenarioCreator.class.getDeclaredMethod("varargsFunction", String[].class));
testContext.registerFunction("varargsFunction2", testContext.registerFunction("varargsFunction2",
TestScenarioCreator.class.getDeclaredMethod("varargsFunction2", Integer.TYPE, String[].class)); TestScenarioCreator.class.getDeclaredMethod("varargsFunction2", int.class, String[].class));
} }
catch (Exception ex) { catch (Exception ex) {
throw new IllegalStateException(ex); throw new IllegalStateException(ex);

10
spring-expression/src/test/java/org/springframework/expression/spel/support/ReflectionHelperTests.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -128,16 +128,16 @@ class ReflectionHelperTests extends AbstractExpressionTests {
StandardTypeConverter tc = new StandardTypeConverter(); StandardTypeConverter tc = new StandardTypeConverter();
// Calling foo(String,int) with (String,Integer) requires boxing conversion of argument one // Calling foo(String,int) with (String,Integer) requires boxing conversion of argument one
checkMatch(new Class<?>[] {String.class, Integer.TYPE}, new Class<?>[] {String.class,Integer.class},tc, ArgumentsMatchKind.CLOSE); checkMatch(new Class<?>[] {String.class, int.class}, new Class<?>[] {String.class,Integer.class},tc, ArgumentsMatchKind.CLOSE);
// Passing (int,String) on call to foo(Integer,String) requires boxing conversion of argument zero // Passing (int,String) on call to foo(Integer,String) requires boxing conversion of argument zero
checkMatch(new Class<?>[] {Integer.TYPE, String.class}, new Class<?>[] {Integer.class, String.class},tc, ArgumentsMatchKind.CLOSE); checkMatch(new Class<?>[] {int.class, String.class}, new Class<?>[] {Integer.class, String.class},tc, ArgumentsMatchKind.CLOSE);
// Passing (int,Sub) on call to foo(Integer,Super) requires boxing conversion of argument zero // Passing (int,Sub) on call to foo(Integer,Super) requires boxing conversion of argument zero
checkMatch(new Class<?>[] {Integer.TYPE, Sub.class}, new Class<?>[] {Integer.class, Super.class}, tc, ArgumentsMatchKind.CLOSE); checkMatch(new Class<?>[] {int.class, Sub.class}, new Class<?>[] {Integer.class, Super.class}, tc, ArgumentsMatchKind.CLOSE);
// Passing (int,Sub,boolean) on call to foo(Integer,Super,Boolean) requires boxing conversion of arguments zero and two // Passing (int,Sub,boolean) on call to foo(Integer,Super,Boolean) requires boxing conversion of arguments zero and two
// TODO checkMatch(new Class<?>[] {Integer.TYPE, Sub.class, Boolean.TYPE}, new Class<?>[] {Integer.class, Super.class, Boolean.class}, tc, ArgsMatchKind.REQUIRES_CONVERSION); // TODO checkMatch(new Class<?>[] {int.class, Sub.class, boolean.class}, new Class<?>[] {Integer.class, Super.class, Boolean.class}, tc, ArgsMatchKind.REQUIRES_CONVERSION);
} }
@Test @Test

4
spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/reactive/AbstractNamedValueMethodArgumentResolver.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -207,7 +207,7 @@ public abstract class AbstractNamedValueMethodArgumentResolver implements SyncHa
@Nullable @Nullable
private Object handleNullValue(String name, @Nullable Object value, Class<?> paramType) { private Object handleNullValue(String name, @Nullable Object value, Class<?> paramType) {
if (value == null) { if (value == null) {
if (Boolean.TYPE.equals(paramType)) { if (paramType == boolean.class) {
return Boolean.FALSE; return Boolean.FALSE;
} }
else if (paramType.isPrimitive()) { else if (paramType.isPrimitive()) {

4
spring-messaging/src/main/java/org/springframework/messaging/handler/annotation/support/AbstractNamedValueMethodArgumentResolver.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -219,7 +219,7 @@ public abstract class AbstractNamedValueMethodArgumentResolver implements Handle
@Nullable @Nullable
private Object handleNullValue(String name, @Nullable Object value, Class<?> paramType) { private Object handleNullValue(String name, @Nullable Object value, Class<?> paramType) {
if (value == null) { if (value == null) {
if (Boolean.TYPE.equals(paramType)) { if (paramType == boolean.class) {
return Boolean.FALSE; return Boolean.FALSE;
} }
else if (paramType.isPrimitive()) { else if (paramType.isPrimitive()) {

4
spring-messaging/src/main/java/org/springframework/messaging/handler/invocation/reactive/InvocableHandlerMethod.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2021 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -214,7 +214,7 @@ public class InvocableHandlerMethod extends HandlerMethod {
} }
Method method = returnType.getMethod(); Method method = returnType.getMethod();
return method != null && KotlinDetector.isSuspendingFunction(method) && return method != null && KotlinDetector.isSuspendingFunction(method) &&
Void.TYPE.equals(returnType.getParameterType()); (returnType.getParameterType() == void.class);
} }
} }

6
spring-oxm/src/main/java/org/springframework/oxm/jaxb/Jaxb2Marshaller.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -619,12 +619,12 @@ public class Jaxb2Marshaller implements MimeMarshaller, MimeUnmarshaller, Generi
parameterizedType.getActualTypeArguments().length == 1) { parameterizedType.getActualTypeArguments().length == 1) {
Type typeArgument = parameterizedType.getActualTypeArguments()[0]; Type typeArgument = parameterizedType.getActualTypeArguments()[0];
if (typeArgument instanceof Class<?> classArgument) { if (typeArgument instanceof Class<?> classArgument) {
return ((classArgument.isArray() && Byte.TYPE == classArgument.componentType()) || return ((classArgument.isArray() && byte.class == classArgument.componentType()) ||
isPrimitiveWrapper(classArgument) || isStandardClass(classArgument) || isPrimitiveWrapper(classArgument) || isStandardClass(classArgument) ||
supportsInternal(classArgument, false)); supportsInternal(classArgument, false));
} }
else if (typeArgument instanceof GenericArrayType arrayType) { else if (typeArgument instanceof GenericArrayType arrayType) {
return (Byte.TYPE == arrayType.getGenericComponentType()); return (byte.class == arrayType.getGenericComponentType());
} }
} }
} }

6
spring-oxm/src/test/java/org/springframework/oxm/xstream/XStreamMarshallerTests.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -230,7 +230,7 @@ class XStreamMarshallerTests {
@Test @Test
void useAttributesFor() throws Exception { void useAttributesFor() throws Exception {
marshaller.setUseAttributeForTypes(Long.TYPE); marshaller.setUseAttributeForTypes(long.class);
Writer writer = new StringWriter(); Writer writer = new StringWriter();
marshaller.marshal(flight, new StreamResult(writer)); marshaller.marshal(flight, new StreamResult(writer));
String expected = "<flight flightNumber=\"42\" />"; String expected = "<flight flightNumber=\"42\" />";
@ -239,7 +239,7 @@ class XStreamMarshallerTests {
@Test @Test
void useAttributesForStringClassMap() throws Exception { void useAttributesForStringClassMap() throws Exception {
marshaller.setUseAttributeFor(Collections.singletonMap("flightNumber", Long.TYPE)); marshaller.setUseAttributeFor(Collections.singletonMap("flightNumber", long.class));
Writer writer = new StringWriter(); Writer writer = new StringWriter();
marshaller.marshal(flight, new StreamResult(writer)); marshaller.marshal(flight, new StreamResult(writer));
String expected = "<flight flightNumber=\"42\" />"; String expected = "<flight flightNumber=\"42\" />";

2
spring-tx/src/test/java/org/springframework/transaction/annotation/AnnotationTransactionAttributeSourceTests.java
View File

@ -203,7 +203,7 @@ class AnnotationTransactionAttributeSourceTests {
assertThat(actual.getLabels()).containsOnly("retryable", "long-running"); assertThat(actual.getLabels()).containsOnly("retryable", "long-running");
method = TestBean11.class.getMethod("setAge", Integer.TYPE); method = TestBean11.class.getMethod("setAge", int.class);
actual = atas.getTransactionAttribute(method, method.getDeclaringClass()); actual = atas.getTransactionAttribute(method, method.getDeclaringClass());
assertThat(actual.getLabels()).containsOnly("short-running"); assertThat(actual.getLabels()).containsOnly("short-running");

4
spring-web/src/main/java/org/springframework/web/method/annotation/AbstractNamedValueMethodArgumentResolver.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -263,7 +263,7 @@ public abstract class AbstractNamedValueMethodArgumentResolver implements Handle
@Nullable @Nullable
private Object handleNullValue(String name, @Nullable Object value, Class<?> paramType) { private Object handleNullValue(String name, @Nullable Object value, Class<?> paramType) {
if (value == null) { if (value == null) {
if (Boolean.TYPE.equals(paramType)) { if (paramType == boolean.class) {
return Boolean.FALSE; return Boolean.FALSE;
} }
else if (paramType.isPrimitive()) { else if (paramType.isPrimitive()) {

4
spring-web/src/test/java/org/springframework/web/method/annotation/WebArgumentResolverAdapterTests.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -53,7 +53,7 @@ class WebArgumentResolverAdapterTests {
@BeforeEach @BeforeEach
void setUp() throws Exception { void setUp() throws Exception {
parameter = new MethodParameter(getClass().getMethod("handle", Integer.TYPE), 0); parameter = new MethodParameter(getClass().getMethod("handle", int.class), 0);
// Expose request to the current thread (for SpEL expressions) // Expose request to the current thread (for SpEL expressions)
RequestContextHolder.setRequestAttributes(webRequest); RequestContextHolder.setRequestAttributes(webRequest);

4
spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/AbstractNamedValueArgumentResolver.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2023 the original author or authors. * Copyright 2002-2024 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -272,7 +272,7 @@ public abstract class AbstractNamedValueArgumentResolver extends HandlerMethodAr
@Nullable @Nullable
private Object handleNullValue(String name, @Nullable Object value, Class<?> paramType) { private Object handleNullValue(String name, @Nullable Object value, Class<?> paramType) {
if (value == null) { if (value == null) {
if (Boolean.TYPE.equals(paramType)) { if (paramType == boolean.class) {
return Boolean.FALSE; return Boolean.FALSE;
} }
else if (paramType.isPrimitive()) { else if (paramType.isPrimitive()) {

2
spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/HttpEntityMethodProcessorMockTests.java
View File

@ -160,7 +160,7 @@ class HttpEntityMethodProcessorMockTests {
stringHttpMessageConverter, resourceMessageConverter, resourceRegionMessageConverter, jsonMessageConverter)); stringHttpMessageConverter, resourceMessageConverter, resourceRegionMessageConverter, jsonMessageConverter));
Method handle1 = getClass().getMethod("handle1", HttpEntity.class, ResponseEntity.class, Method handle1 = getClass().getMethod("handle1", HttpEntity.class, ResponseEntity.class,
Integer.TYPE, RequestEntity.class); int.class, RequestEntity.class);
paramHttpEntity = new MethodParameter(handle1, 0); paramHttpEntity = new MethodParameter(handle1, 0);
paramRequestEntity = new MethodParameter(handle1, 3); paramRequestEntity = new MethodParameter(handle1, 3);

2
spring-webmvc/src/test/java/org/springframework/web/servlet/mvc/method/annotation/RequestResponseBodyMethodProcessorMockTests.java
View File

@ -121,7 +121,7 @@ class RequestResponseBodyMethodProcessorMockTests {
servletRequest.setMethod("POST"); servletRequest.setMethod("POST");
Method methodHandle1 = getClass().getMethod("handle1", String.class, Integer.TYPE); Method methodHandle1 = getClass().getMethod("handle1", String.class, int.class);
paramRequestBodyString = new MethodParameter(methodHandle1, 0); paramRequestBodyString = new MethodParameter(methodHandle1, 0);
paramInt = new MethodParameter(methodHandle1, 1); paramInt = new MethodParameter(methodHandle1, 1);
paramValidBean = new MethodParameter(getClass().getMethod("handle2", SimpleBean.class), 0); paramValidBean = new MethodParameter(getClass().getMethod("handle2", SimpleBean.class), 0);