Rely on automatic boxing/unboxing in tests
Closes gh-29414
This commit is contained in:
Kulwant Singh
Sam Brannen
parent
7d68d0625c
commit
b2c8546013
|
|
@ -677,7 +677,7 @@ abstract class AbstractPropertyAccessorTests {
|
|||
assertThat(target.getMyLong().longValue()).isEqualTo(Long.MAX_VALUE);
|
||||
|
||||
assertThat((double) target.getMyPrimitiveFloat()).isCloseTo(Float.MAX_VALUE, within(0.001));
|
||||
assertThat((double) target.getMyFloat().floatValue()).isCloseTo(Float.MAX_VALUE, within(0.001));
|
||||
assertThat((double) target.getMyFloat()).isCloseTo(Float.MAX_VALUE, within(0.001));
|
||||
|
||||
assertThat(target.getMyPrimitiveDouble()).isCloseTo(Double.MAX_VALUE, within(0.001));
|
||||
assertThat(target.getMyDouble().doubleValue()).isCloseTo(Double.MAX_VALUE, within(0.001));
|
||||
|
|
|
|||
|
|
@ -273,7 +273,7 @@ class BeanUtilsTests {
|
|||
BeanUtils.copyProperties(integerListHolder1, numberListHolder);
|
||||
assertThat(integerListHolder1.getList()).containsOnly(42);
|
||||
assertThat(numberListHolder.getList()).hasSize(1);
|
||||
assertThat(numberListHolder.getList().contains(Integer.valueOf(42))).isTrue();
|
||||
assertThat(numberListHolder.getList().contains(42)).isTrue();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -282,7 +282,7 @@ class BeanUtilsTests {
|
|||
@Test
|
||||
void copyPropertiesDoesNotCopyFromSuperTypeToSubType() {
|
||||
NumberHolder numberHolder = new NumberHolder();
|
||||
numberHolder.setNumber(Integer.valueOf(42));
|
||||
numberHolder.setNumber(42);
|
||||
IntegerHolder integerHolder = new IntegerHolder();
|
||||
|
||||
BeanUtils.copyProperties(numberHolder, integerHolder);
|
||||
|
|
|
|||
|
|
@ -282,7 +282,7 @@ class BeanWrapperGenericsTests {
|
|||
gb.setMapOfMaps(map);
|
||||
BeanWrapper bw = new BeanWrapperImpl(gb);
|
||||
bw.setPropertyValue("mapOfMaps[mykey][10]", "5");
|
||||
assertThat(bw.getPropertyValue("mapOfMaps[mykey][10]")).isEqualTo(Long.valueOf(5));
|
||||
assertThat(bw.getPropertyValue("mapOfMaps[mykey][10]")).isEqualTo(5L);
|
||||
assertThat(gb.getMapOfMaps().get("mykey").get(10)).isEqualTo(Long.valueOf(5));
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -983,7 +983,7 @@ class DefaultListableBeanFactoryTests {
|
|||
bd.setPropertyValues(pvs);
|
||||
lbf.registerBeanDefinition("testBean", bd);
|
||||
TestBean testBean = (TestBean) lbf.getBean("testBean");
|
||||
assertThat(testBean.getMyFloat().floatValue() == 1.1f).isTrue();
|
||||
assertThat(testBean.getMyFloat() == 1.1f).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -1005,7 +1005,7 @@ class DefaultListableBeanFactoryTests {
|
|||
bd.setPropertyValues(pvs);
|
||||
lbf.registerBeanDefinition("testBean", bd);
|
||||
TestBean testBean = (TestBean) lbf.getBean("testBean");
|
||||
assertThat(testBean.getMyFloat().floatValue() == 1.1f).isTrue();
|
||||
assertThat(testBean.getMyFloat() == 1.1f).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -1021,7 +1021,7 @@ class DefaultListableBeanFactoryTests {
|
|||
lbf.registerBeanDefinition("testBean", bd);
|
||||
lbf.registerSingleton("myFloat", "1,1");
|
||||
TestBean testBean = (TestBean) lbf.getBean("testBean");
|
||||
assertThat(testBean.getMyFloat().floatValue() == 1.1f).isTrue();
|
||||
assertThat(testBean.getMyFloat() == 1.1f).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -1037,7 +1037,7 @@ class DefaultListableBeanFactoryTests {
|
|||
TestBean testBean = (TestBean) lbf.getBean("testBean");
|
||||
assertThat(testBean.getName()).isEqualTo("myName");
|
||||
assertThat(testBean.getAge()).isEqualTo(5);
|
||||
assertThat(testBean.getMyFloat().floatValue() == 1.1f).isTrue();
|
||||
assertThat(testBean.getMyFloat() == 1.1f).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -1054,7 +1054,7 @@ class DefaultListableBeanFactoryTests {
|
|||
TestBean testBean = (TestBean) lbf.getBean("testBean");
|
||||
assertThat(testBean.getName()).isEqualTo("myName");
|
||||
assertThat(testBean.getAge()).isEqualTo(5);
|
||||
assertThat(testBean.getMyFloat().floatValue() == 1.1f).isTrue();
|
||||
assertThat(testBean.getMyFloat() == 1.1f).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
|
|||
|
|
@ -120,7 +120,7 @@ public class YamlMapFactoryBeanTests {
|
|||
@SuppressWarnings("unchecked")
|
||||
Map<String, Object> sub = (Map<String, Object>) object;
|
||||
assertThat(sub.size()).isEqualTo(1);
|
||||
assertThat(sub.get("key1.key2")).isEqualTo(Integer.valueOf(3));
|
||||
assertThat(sub.get("key1.key2")).isEqualTo(3);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
|
|||
|
|
@ -332,9 +332,9 @@ public class XmlBeanCollectionTests {
|
|||
public void testIntegerArray() throws Exception {
|
||||
HasMap hasMap = (HasMap) this.beanFactory.getBean("integerArray");
|
||||
assertThat(hasMap.getIntegerArray().length == 3).isTrue();
|
||||
assertThat(hasMap.getIntegerArray()[0].intValue() == 0).isTrue();
|
||||
assertThat(hasMap.getIntegerArray()[1].intValue() == 1).isTrue();
|
||||
assertThat(hasMap.getIntegerArray()[2].intValue() == 2).isTrue();
|
||||
assertThat(hasMap.getIntegerArray()[0] == 0).isTrue();
|
||||
assertThat(hasMap.getIntegerArray()[1] == 1).isTrue();
|
||||
assertThat(hasMap.getIntegerArray()[2] == 2).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
|
|||
|
|
@ -502,7 +502,7 @@ class CustomEditorTests {
|
|||
CharBean cb = new CharBean();
|
||||
BeanWrapper bw = new BeanWrapperImpl(cb);
|
||||
|
||||
bw.setPropertyValue("myChar", Character.valueOf('c'));
|
||||
bw.setPropertyValue("myChar", 'c');
|
||||
assertThat(cb.getMyChar()).isEqualTo('c');
|
||||
|
||||
bw.setPropertyValue("myChar", "c");
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ public class TestBean implements BeanNameAware, BeanFactoryAware, ITestBean, IOt
|
|||
|
||||
private Date date = new Date();
|
||||
|
||||
private Float myFloat = Float.valueOf(0.0f);
|
||||
private Float myFloat = 0.0f;
|
||||
|
||||
private Collection<? super Object> friends = new ArrayList<>();
|
||||
|
||||
|
|
|
|||
|
|
@ -109,7 +109,7 @@ class AroundAdviceBindingTestAspect {
|
|||
|
||||
public int oneObjectArg(ProceedingJoinPoint pjp, Object bean) throws Throwable {
|
||||
this.collaborator.oneObjectArg(bean);
|
||||
return ((Integer) pjp.proceed()).intValue();
|
||||
return (Integer) pjp.proceed();
|
||||
}
|
||||
|
||||
public void oneIntAndOneObject(ProceedingJoinPoint pjp, int x , Object o) throws Throwable {
|
||||
|
|
@ -119,7 +119,7 @@ class AroundAdviceBindingTestAspect {
|
|||
|
||||
public int justJoinPoint(ProceedingJoinPoint pjp) throws Throwable {
|
||||
this.collaborator.justJoinPoint(pjp.getSignature().getName());
|
||||
return ((Integer) pjp.proceed()).intValue();
|
||||
return (Integer) pjp.proceed();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -189,7 +189,7 @@ class PrecedenceTestAspect implements BeanNameAware, Ordered {
|
|||
int ret = -1;
|
||||
this.collaborator.aroundAdviceOne(this.name);
|
||||
try {
|
||||
ret = ((Integer)pjp.proceed()).intValue();
|
||||
ret = (Integer) pjp.proceed();
|
||||
}
|
||||
catch (Throwable t) {
|
||||
throw new RuntimeException(t);
|
||||
|
|
@ -202,7 +202,7 @@ class PrecedenceTestAspect implements BeanNameAware, Ordered {
|
|||
int ret = -1;
|
||||
this.collaborator.aroundAdviceTwo(this.name);
|
||||
try {
|
||||
ret = ((Integer)pjp.proceed()).intValue();
|
||||
ret = (Integer) pjp.proceed();
|
||||
}
|
||||
catch (Throwable t) {
|
||||
throw new RuntimeException(t);
|
||||
|
|
|
|||
|
|
@ -167,14 +167,14 @@ class ProceedTestingAspect implements Ordered {
|
|||
}
|
||||
|
||||
public Object doubleOrQuits(ProceedingJoinPoint pjp) throws Throwable {
|
||||
int value = ((Integer) pjp.getArgs()[0]).intValue();
|
||||
pjp.getArgs()[0] = Integer.valueOf(value * 2);
|
||||
int value = (Integer) pjp.getArgs()[0];
|
||||
pjp.getArgs()[0] = value * 2;
|
||||
return pjp.proceed();
|
||||
}
|
||||
|
||||
public Object addOne(ProceedingJoinPoint pjp, Float value) throws Throwable {
|
||||
float fv = value.floatValue();
|
||||
return pjp.proceed(new Object[] {Float.valueOf(fv + 1.0F)});
|
||||
float fv = value;
|
||||
return pjp.proceed(new Object[] {fv + 1.0F});
|
||||
}
|
||||
|
||||
public void captureStringArgument(JoinPoint tjp, String arg) {
|
||||
|
|
@ -198,7 +198,7 @@ class ProceedTestingAspect implements Ordered {
|
|||
}
|
||||
|
||||
public void captureFloatArgument(JoinPoint tjp, float arg) {
|
||||
float tjpArg = ((Float) tjp.getArgs()[0]).floatValue();
|
||||
float tjpArg = (Float) tjp.getArgs()[0];
|
||||
if (Math.abs(tjpArg - arg) > 0.000001) {
|
||||
throw new IllegalStateException(
|
||||
"argument is '" + arg + "', " +
|
||||
|
|
|
|||
|
|
@ -1353,7 +1353,7 @@ public abstract class AbstractAopProxyTests {
|
|||
public int sum;
|
||||
@Override
|
||||
public void afterReturning(@Nullable Object returnValue, Method m, Object[] args, @Nullable Object target) throws Throwable {
|
||||
sum += ((Integer) returnValue).intValue();
|
||||
sum += (Integer) returnValue;
|
||||
}
|
||||
}
|
||||
SummingAfterAdvice aa = new SummingAfterAdvice();
|
||||
|
|
|
|||
|
|
@ -83,7 +83,7 @@ class PayloadApplicationEventTests {
|
|||
void testProgrammaticEventListener() {
|
||||
List<Auditable> events = new ArrayList<>();
|
||||
ApplicationListener<AuditablePayloadEvent<String>> listener = events::add;
|
||||
ApplicationListener<AuditablePayloadEvent<Integer>> mismatch = (event -> event.getPayload().intValue());
|
||||
ApplicationListener<AuditablePayloadEvent<Integer>> mismatch = (event -> event.getPayload());
|
||||
|
||||
ConfigurableApplicationContext ac = new GenericApplicationContext();
|
||||
ac.addApplicationListener(listener);
|
||||
|
|
|
|||
|
|
@ -455,7 +455,7 @@ public class NotificationListenerTests extends AbstractMBeanServerTests {
|
|||
Integer currentCount = (Integer) this.attributeCounts.get(attributeName);
|
||||
|
||||
if (currentCount != null) {
|
||||
int count = currentCount.intValue() + 1;
|
||||
int count = currentCount + 1;
|
||||
this.attributeCounts.put(attributeName, count);
|
||||
}
|
||||
else {
|
||||
|
|
@ -468,7 +468,7 @@ public class NotificationListenerTests extends AbstractMBeanServerTests {
|
|||
|
||||
public int getCount(String attribute) {
|
||||
Integer count = (Integer) this.attributeCounts.get(attribute);
|
||||
return (count == null) ? 0 : count.intValue();
|
||||
return (count == null) ? 0 : count;
|
||||
}
|
||||
|
||||
public Object getLastHandback(String attributeName) {
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ public class ScriptingDefaultsTests {
|
|||
((AbstractRefreshableTargetSource) advised.getTargetSource());
|
||||
Field field = AbstractRefreshableTargetSource.class.getDeclaredField("refreshCheckDelay");
|
||||
field.setAccessible(true);
|
||||
long delay = ((Long) field.get(targetSource)).longValue();
|
||||
long delay = (Long) field.get(targetSource);
|
||||
assertThat(delay).isEqualTo(5000L);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -76,23 +76,23 @@ class ConstantsTests {
|
|||
|
||||
Set<?> values = c.getValues("");
|
||||
assertThat(values.size()).isEqualTo(7);
|
||||
assertThat(values.contains(Integer.valueOf(0))).isTrue();
|
||||
assertThat(values.contains(Integer.valueOf(66))).isTrue();
|
||||
assertThat(values.contains(0)).isTrue();
|
||||
assertThat(values.contains(66)).isTrue();
|
||||
assertThat(values.contains("")).isTrue();
|
||||
|
||||
values = c.getValues("D");
|
||||
assertThat(values.size()).isEqualTo(1);
|
||||
assertThat(values.contains(Integer.valueOf(0))).isTrue();
|
||||
assertThat(values.contains(0)).isTrue();
|
||||
|
||||
values = c.getValues("prefix");
|
||||
assertThat(values.size()).isEqualTo(2);
|
||||
assertThat(values.contains(Integer.valueOf(1))).isTrue();
|
||||
assertThat(values.contains(Integer.valueOf(2))).isTrue();
|
||||
assertThat(values.contains(1)).isTrue();
|
||||
assertThat(values.contains(2)).isTrue();
|
||||
|
||||
values = c.getValuesForProperty("myProperty");
|
||||
assertThat(values.size()).isEqualTo(2);
|
||||
assertThat(values.contains(Integer.valueOf(1))).isTrue();
|
||||
assertThat(values.contains(Integer.valueOf(2))).isTrue();
|
||||
assertThat(values.contains(1)).isTrue();
|
||||
assertThat(values.contains(2)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -104,23 +104,23 @@ class ConstantsTests {
|
|||
|
||||
Set<?> values = c.getValues("");
|
||||
assertThat(values.size()).isEqualTo(7);
|
||||
assertThat(values.contains(Integer.valueOf(0))).isTrue();
|
||||
assertThat(values.contains(Integer.valueOf(66))).isTrue();
|
||||
assertThat(values.contains(0)).isTrue();
|
||||
assertThat(values.contains(66)).isTrue();
|
||||
assertThat(values.contains("")).isTrue();
|
||||
|
||||
values = c.getValues("D");
|
||||
assertThat(values.size()).isEqualTo(1);
|
||||
assertThat(values.contains(Integer.valueOf(0))).isTrue();
|
||||
assertThat(values.contains(0)).isTrue();
|
||||
|
||||
values = c.getValues("prefix");
|
||||
assertThat(values.size()).isEqualTo(2);
|
||||
assertThat(values.contains(Integer.valueOf(1))).isTrue();
|
||||
assertThat(values.contains(Integer.valueOf(2))).isTrue();
|
||||
assertThat(values.contains(1)).isTrue();
|
||||
assertThat(values.contains(2)).isTrue();
|
||||
|
||||
values = c.getValuesForProperty("myProperty");
|
||||
assertThat(values.size()).isEqualTo(2);
|
||||
assertThat(values.contains(Integer.valueOf(1))).isTrue();
|
||||
assertThat(values.contains(Integer.valueOf(2))).isTrue();
|
||||
assertThat(values.contains(1)).isTrue();
|
||||
assertThat(values.contains(2)).isTrue();
|
||||
}
|
||||
finally {
|
||||
Locale.setDefault(oldLocale);
|
||||
|
|
@ -138,24 +138,24 @@ class ConstantsTests {
|
|||
|
||||
Set<?> values = c.getValuesForSuffix("_PROPERTY");
|
||||
assertThat(values.size()).isEqualTo(2);
|
||||
assertThat(values.contains(Integer.valueOf(3))).isTrue();
|
||||
assertThat(values.contains(Integer.valueOf(4))).isTrue();
|
||||
assertThat(values.contains(3)).isTrue();
|
||||
assertThat(values.contains(4)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
void toCode() {
|
||||
Constants c = new Constants(A.class);
|
||||
|
||||
assertThat(c.toCode(Integer.valueOf(0), "")).isEqualTo("DOG");
|
||||
assertThat(c.toCode(Integer.valueOf(0), "D")).isEqualTo("DOG");
|
||||
assertThat(c.toCode(Integer.valueOf(0), "DO")).isEqualTo("DOG");
|
||||
assertThat(c.toCode(Integer.valueOf(0), "DoG")).isEqualTo("DOG");
|
||||
assertThat(c.toCode(Integer.valueOf(0), null)).isEqualTo("DOG");
|
||||
assertThat(c.toCode(Integer.valueOf(66), "")).isEqualTo("CAT");
|
||||
assertThat(c.toCode(Integer.valueOf(66), "C")).isEqualTo("CAT");
|
||||
assertThat(c.toCode(Integer.valueOf(66), "ca")).isEqualTo("CAT");
|
||||
assertThat(c.toCode(Integer.valueOf(66), "cAt")).isEqualTo("CAT");
|
||||
assertThat(c.toCode(Integer.valueOf(66), null)).isEqualTo("CAT");
|
||||
assertThat(c.toCode(0, "")).isEqualTo("DOG");
|
||||
assertThat(c.toCode(0, "D")).isEqualTo("DOG");
|
||||
assertThat(c.toCode(0, "DO")).isEqualTo("DOG");
|
||||
assertThat(c.toCode(0, "DoG")).isEqualTo("DOG");
|
||||
assertThat(c.toCode(0, null)).isEqualTo("DOG");
|
||||
assertThat(c.toCode(66, "")).isEqualTo("CAT");
|
||||
assertThat(c.toCode(66, "C")).isEqualTo("CAT");
|
||||
assertThat(c.toCode(66, "ca")).isEqualTo("CAT");
|
||||
assertThat(c.toCode(66, "cAt")).isEqualTo("CAT");
|
||||
assertThat(c.toCode(66, null)).isEqualTo("CAT");
|
||||
assertThat(c.toCode("", "")).isEqualTo("S1");
|
||||
assertThat(c.toCode("", "s")).isEqualTo("S1");
|
||||
assertThat(c.toCode("", "s1")).isEqualTo("S1");
|
||||
|
|
@ -165,21 +165,21 @@ class ConstantsTests {
|
|||
assertThatExceptionOfType(Constants.ConstantException.class).isThrownBy(() ->
|
||||
c.toCode("bogus", null));
|
||||
|
||||
assertThat(c.toCodeForProperty(Integer.valueOf(1), "myProperty")).isEqualTo("MY_PROPERTY_NO");
|
||||
assertThat(c.toCodeForProperty(Integer.valueOf(2), "myProperty")).isEqualTo("MY_PROPERTY_YES");
|
||||
assertThat(c.toCodeForProperty(1, "myProperty")).isEqualTo("MY_PROPERTY_NO");
|
||||
assertThat(c.toCodeForProperty(2, "myProperty")).isEqualTo("MY_PROPERTY_YES");
|
||||
assertThatExceptionOfType(Constants.ConstantException.class).isThrownBy(() ->
|
||||
c.toCodeForProperty("bogus", "bogus"));
|
||||
|
||||
assertThat(c.toCodeForSuffix(Integer.valueOf(0), "")).isEqualTo("DOG");
|
||||
assertThat(c.toCodeForSuffix(Integer.valueOf(0), "G")).isEqualTo("DOG");
|
||||
assertThat(c.toCodeForSuffix(Integer.valueOf(0), "OG")).isEqualTo("DOG");
|
||||
assertThat(c.toCodeForSuffix(Integer.valueOf(0), "DoG")).isEqualTo("DOG");
|
||||
assertThat(c.toCodeForSuffix(Integer.valueOf(0), null)).isEqualTo("DOG");
|
||||
assertThat(c.toCodeForSuffix(Integer.valueOf(66), "")).isEqualTo("CAT");
|
||||
assertThat(c.toCodeForSuffix(Integer.valueOf(66), "T")).isEqualTo("CAT");
|
||||
assertThat(c.toCodeForSuffix(Integer.valueOf(66), "at")).isEqualTo("CAT");
|
||||
assertThat(c.toCodeForSuffix(Integer.valueOf(66), "cAt")).isEqualTo("CAT");
|
||||
assertThat(c.toCodeForSuffix(Integer.valueOf(66), null)).isEqualTo("CAT");
|
||||
assertThat(c.toCodeForSuffix(0, "")).isEqualTo("DOG");
|
||||
assertThat(c.toCodeForSuffix(0, "G")).isEqualTo("DOG");
|
||||
assertThat(c.toCodeForSuffix(0, "OG")).isEqualTo("DOG");
|
||||
assertThat(c.toCodeForSuffix(0, "DoG")).isEqualTo("DOG");
|
||||
assertThat(c.toCodeForSuffix(0, null)).isEqualTo("DOG");
|
||||
assertThat(c.toCodeForSuffix(66, "")).isEqualTo("CAT");
|
||||
assertThat(c.toCodeForSuffix(66, "T")).isEqualTo("CAT");
|
||||
assertThat(c.toCodeForSuffix(66, "at")).isEqualTo("CAT");
|
||||
assertThat(c.toCodeForSuffix(66, "cAt")).isEqualTo("CAT");
|
||||
assertThat(c.toCodeForSuffix(66, null)).isEqualTo("CAT");
|
||||
assertThat(c.toCodeForSuffix("", "")).isEqualTo("S1");
|
||||
assertThat(c.toCodeForSuffix("", "1")).isEqualTo("S1");
|
||||
assertThat(c.toCodeForSuffix("", "s1")).isEqualTo("S1");
|
||||
|
|
|
|||
|
|
@ -524,7 +524,7 @@ class TypeDescriptorTests {
|
|||
@Test
|
||||
void narrow() {
|
||||
TypeDescriptor desc = TypeDescriptor.valueOf(Number.class);
|
||||
Integer value = Integer.valueOf(3);
|
||||
Integer value = 3;
|
||||
desc = desc.narrow(value);
|
||||
assertThat(desc.getType()).isEqualTo(Integer.class);
|
||||
}
|
||||
|
|
@ -532,7 +532,7 @@ class TypeDescriptorTests {
|
|||
@Test
|
||||
void elementType() {
|
||||
TypeDescriptor desc = TypeDescriptor.valueOf(List.class);
|
||||
Integer value = Integer.valueOf(3);
|
||||
Integer value = 3;
|
||||
desc = desc.elementTypeDescriptor(value);
|
||||
assertThat(desc.getType()).isEqualTo(Integer.class);
|
||||
}
|
||||
|
|
@ -550,7 +550,7 @@ class TypeDescriptorTests {
|
|||
@Test
|
||||
void mapKeyType() {
|
||||
TypeDescriptor desc = TypeDescriptor.valueOf(Map.class);
|
||||
Integer value = Integer.valueOf(3);
|
||||
Integer value = 3;
|
||||
desc = desc.getMapKeyTypeDescriptor(value);
|
||||
assertThat(desc.getType()).isEqualTo(Integer.class);
|
||||
}
|
||||
|
|
@ -568,7 +568,7 @@ class TypeDescriptorTests {
|
|||
@Test
|
||||
void mapValueType() {
|
||||
TypeDescriptor desc = TypeDescriptor.valueOf(Map.class);
|
||||
Integer value = Integer.valueOf(3);
|
||||
Integer value = 3;
|
||||
desc = desc.getMapValueTypeDescriptor(value);
|
||||
assertThat(desc.getType()).isEqualTo(Integer.class);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -154,7 +154,7 @@ class DefaultConversionServiceTests {
|
|||
|
||||
@Test
|
||||
void stringToInteger() {
|
||||
assertThat(conversionService.convert("1", Integer.class)).isEqualTo((int) Integer.valueOf(1));
|
||||
assertThat(conversionService.convert("1", Integer.class)).isEqualTo((int) 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -259,7 +259,7 @@ class DefaultConversionServiceTests {
|
|||
|
||||
@Test
|
||||
void enumToInteger() {
|
||||
assertThat(conversionService.convert(Foo.BAR, Integer.class)).isEqualTo((int) Integer.valueOf(0));
|
||||
assertThat(conversionService.convert(Foo.BAR, Integer.class)).isEqualTo((int) 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -353,9 +353,9 @@ class DefaultConversionServiceTests {
|
|||
@SuppressWarnings("unchecked")
|
||||
List<Integer> result = (List<Integer>) conversionService.convert(new String[] {"1", "2", "3"}, TypeDescriptor
|
||||
.valueOf(String[].class), new TypeDescriptor(getClass().getDeclaredField("genericList")));
|
||||
assertThat((int) result.get(0)).isEqualTo((int) Integer.valueOf(1));
|
||||
assertThat((int) result.get(1)).isEqualTo((int) Integer.valueOf(2));
|
||||
assertThat((int) result.get(2)).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat((int) result.get(0)).isEqualTo((int) 1);
|
||||
assertThat((int) result.get(1)).isEqualTo((int) 2);
|
||||
assertThat((int) result.get(2)).isEqualTo((int) 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -426,9 +426,9 @@ class DefaultConversionServiceTests {
|
|||
void convertStringToArrayWithElementConversion() {
|
||||
Integer[] result = conversionService.convert("1,2,3", Integer[].class);
|
||||
assertThat(result.length).isEqualTo(3);
|
||||
assertThat((int) result[0]).isEqualTo((int) Integer.valueOf(1));
|
||||
assertThat((int) result[1]).isEqualTo((int) Integer.valueOf(2));
|
||||
assertThat((int) result[2]).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat((int) result[0]).isEqualTo((int) 1);
|
||||
assertThat((int) result[1]).isEqualTo((int) 2);
|
||||
assertThat((int) result[2]).isEqualTo((int) 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -457,7 +457,7 @@ class DefaultConversionServiceTests {
|
|||
void convertArrayToObjectWithElementConversion() {
|
||||
String[] array = new String[] {"3"};
|
||||
Integer result = conversionService.convert(array, Integer.class);
|
||||
assertThat((int) result).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat((int) result).isEqualTo((int) 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -478,7 +478,7 @@ class DefaultConversionServiceTests {
|
|||
void convertObjectToArrayWithElementConversion() {
|
||||
Integer[] result = conversionService.convert(3L, Integer[].class);
|
||||
assertThat(result.length).isEqualTo(1);
|
||||
assertThat((int) result[0]).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat((int) result[0]).isEqualTo((int) 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -500,9 +500,9 @@ class DefaultConversionServiceTests {
|
|||
list.add("2");
|
||||
list.add("3");
|
||||
Integer[] result = conversionService.convert(list, Integer[].class);
|
||||
assertThat((int) result[0]).isEqualTo((int) Integer.valueOf(1));
|
||||
assertThat((int) result[1]).isEqualTo((int) Integer.valueOf(2));
|
||||
assertThat((int) result[2]).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat((int) result[0]).isEqualTo((int) 1);
|
||||
assertThat((int) result[1]).isEqualTo((int) 2);
|
||||
assertThat((int) result[2]).isEqualTo((int) 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -556,7 +556,7 @@ class DefaultConversionServiceTests {
|
|||
void convertCollectionToObjectWithElementConversion() {
|
||||
List<String> list = Collections.singletonList("3");
|
||||
Integer result = conversionService.convert(list, Integer.class);
|
||||
assertThat((int) result).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat((int) result).isEqualTo((int) 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -590,15 +590,15 @@ class DefaultConversionServiceTests {
|
|||
List<Integer> result = (List<Integer>) conversionService.convert(3L, TypeDescriptor.valueOf(Long.class),
|
||||
new TypeDescriptor(getClass().getField("genericList")));
|
||||
assertThat(result.size()).isEqualTo(1);
|
||||
assertThat((int) result.get(0)).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat((int) result.get(0)).isEqualTo((int) 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
void convertStringArrayToIntegerArray() {
|
||||
Integer[] result = conversionService.convert(new String[] {"1", "2", "3"}, Integer[].class);
|
||||
assertThat((int) result[0]).isEqualTo((int) Integer.valueOf(1));
|
||||
assertThat((int) result[1]).isEqualTo((int) Integer.valueOf(2));
|
||||
assertThat((int) result[2]).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat((int) result[0]).isEqualTo((int) 1);
|
||||
assertThat((int) result[1]).isEqualTo((int) 2);
|
||||
assertThat((int) result[2]).isEqualTo((int) 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -612,9 +612,9 @@ class DefaultConversionServiceTests {
|
|||
@Test
|
||||
void convertIntegerArrayToIntegerArray() {
|
||||
Integer[] result = conversionService.convert(new Integer[] {1, 2, 3}, Integer[].class);
|
||||
assertThat((int) result[0]).isEqualTo((int) Integer.valueOf(1));
|
||||
assertThat((int) result[1]).isEqualTo((int) Integer.valueOf(2));
|
||||
assertThat((int) result[2]).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat((int) result[0]).isEqualTo((int) 1);
|
||||
assertThat((int) result[1]).isEqualTo((int) 2);
|
||||
assertThat((int) result[2]).isEqualTo((int) 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -628,9 +628,9 @@ class DefaultConversionServiceTests {
|
|||
@Test
|
||||
void convertObjectArrayToIntegerArray() {
|
||||
Integer[] result = conversionService.convert(new Object[] {1, 2, 3}, Integer[].class);
|
||||
assertThat((int) result[0]).isEqualTo((int) Integer.valueOf(1));
|
||||
assertThat((int) result[1]).isEqualTo((int) Integer.valueOf(2));
|
||||
assertThat((int) result[2]).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat((int) result[0]).isEqualTo((int) 1);
|
||||
assertThat((int) result[1]).isEqualTo((int) 2);
|
||||
assertThat((int) result[2]).isEqualTo((int) 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -697,9 +697,9 @@ class DefaultConversionServiceTests {
|
|||
@SuppressWarnings("unchecked")
|
||||
List<Integer> bar = (List<Integer>) conversionService.convert(foo, TypeDescriptor.forObject(foo),
|
||||
new TypeDescriptor(getClass().getField("genericList")));
|
||||
assertThat((int) bar.get(0)).isEqualTo((int) Integer.valueOf(1));
|
||||
assertThat((int) bar.get(1)).isEqualTo((int) Integer.valueOf(2));
|
||||
assertThat((int) bar.get(2)).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat((int) bar.get(0)).isEqualTo((int) 1);
|
||||
assertThat((int) bar.get(1)).isEqualTo((int) 2);
|
||||
assertThat((int) bar.get(2)).isEqualTo((int) 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -735,9 +735,9 @@ class DefaultConversionServiceTests {
|
|||
List<Integer> bar = (List<Integer>) conversionService.convert(values,
|
||||
TypeDescriptor.forObject(values), new TypeDescriptor(getClass().getField("genericList")));
|
||||
assertThat(bar.size()).isEqualTo(3);
|
||||
assertThat((int) bar.get(0)).isEqualTo((int) Integer.valueOf(1));
|
||||
assertThat((int) bar.get(1)).isEqualTo((int) Integer.valueOf(2));
|
||||
assertThat((int) bar.get(2)).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat((int) bar.get(0)).isEqualTo((int) 1);
|
||||
assertThat((int) bar.get(1)).isEqualTo((int) 2);
|
||||
assertThat((int) bar.get(2)).isEqualTo((int) 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -748,8 +748,8 @@ class DefaultConversionServiceTests {
|
|||
@SuppressWarnings("unchecked")
|
||||
List<Integer> integers = (List<Integer>) conversionService.convert(strings,
|
||||
TypeDescriptor.collection(List.class, TypeDescriptor.valueOf(Integer.class)));
|
||||
assertThat((int) integers.get(0)).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat((int) integers.get(1)).isEqualTo((int) Integer.valueOf(9));
|
||||
assertThat((int) integers.get(0)).isEqualTo((int) 3);
|
||||
assertThat((int) integers.get(1)).isEqualTo((int) 9);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -781,8 +781,8 @@ class DefaultConversionServiceTests {
|
|||
@SuppressWarnings("unchecked")
|
||||
Map<Integer, Integer> integers = (Map<Integer, Integer>) conversionService.convert(strings,
|
||||
TypeDescriptor.map(Map.class, TypeDescriptor.valueOf(Integer.class), TypeDescriptor.valueOf(Integer.class)));
|
||||
assertThat((int) integers.get(3)).isEqualTo((int) Integer.valueOf(9));
|
||||
assertThat((int) integers.get(6)).isEqualTo((int) Integer.valueOf(31));
|
||||
assertThat((int) integers.get(3)).isEqualTo((int) 9);
|
||||
assertThat((int) integers.get(6)).isEqualTo((int) 31);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -879,7 +879,7 @@ class DefaultConversionServiceTests {
|
|||
@Test
|
||||
void convertObjectToObjectNoValueOfMethodOrConstructor() {
|
||||
assertThatExceptionOfType(ConverterNotFoundException.class).isThrownBy(() ->
|
||||
conversionService.convert(Long.valueOf(3), SSN.class));
|
||||
conversionService.convert(3L, SSN.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
|
|||
|
|
@ -104,7 +104,7 @@ class GenericConversionServiceTests {
|
|||
@Test
|
||||
void convert() {
|
||||
conversionService.addConverterFactory(new StringToNumberConverterFactory());
|
||||
assertThat(conversionService.convert("3", Integer.class)).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat(conversionService.convert("3", Integer.class)).isEqualTo((int) 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -192,7 +192,7 @@ class GenericConversionServiceTests {
|
|||
void convertSuperSourceType() {
|
||||
conversionService.addConverter(CharSequence.class, Integer.class, source -> Integer.valueOf(source.toString()));
|
||||
Integer result = conversionService.convert("3", Integer.class);
|
||||
assertThat((int) result).isEqualTo((int) Integer.valueOf(3));
|
||||
assertThat((int) result).isEqualTo((int) 3);
|
||||
}
|
||||
|
||||
// SPR-8718
|
||||
|
|
|
|||
|
|
@ -70,12 +70,12 @@ class CollectionUtilsTests {
|
|||
void mergePrimitiveArrayIntoCollection() {
|
||||
int[] arr = new int[] {1, 2};
|
||||
List<Comparable<?>> list = new ArrayList<>();
|
||||
list.add(Integer.valueOf(3));
|
||||
list.add(3);
|
||||
|
||||
CollectionUtils.mergeArrayIntoCollection(arr, list);
|
||||
assertThat(list.get(0)).isEqualTo(Integer.valueOf(3));
|
||||
assertThat(list.get(1)).isEqualTo(Integer.valueOf(1));
|
||||
assertThat(list.get(2)).isEqualTo(Integer.valueOf(2));
|
||||
assertThat(list.get(0)).isEqualTo(3);
|
||||
assertThat(list.get(1)).isEqualTo(1);
|
||||
assertThat(list.get(2)).isEqualTo(2);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -84,7 +84,7 @@ class CollectionUtilsTests {
|
|||
defaults.setProperty("prop1", "value1");
|
||||
Properties props = new Properties(defaults);
|
||||
props.setProperty("prop2", "value2");
|
||||
props.put("prop3", Integer.valueOf(3));
|
||||
props.put("prop3", 3);
|
||||
|
||||
Map<String, Object> map = new HashMap<>();
|
||||
map.put("prop4", "value4");
|
||||
|
|
@ -92,7 +92,7 @@ class CollectionUtilsTests {
|
|||
CollectionUtils.mergePropertiesIntoMap(props, map);
|
||||
assertThat(map.get("prop1")).isEqualTo("value1");
|
||||
assertThat(map.get("prop2")).isEqualTo("value2");
|
||||
assertThat(map.get("prop3")).isEqualTo(Integer.valueOf(3));
|
||||
assertThat(map.get("prop3")).isEqualTo(3);
|
||||
assertThat(map.get("prop4")).isEqualTo("value4");
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -134,7 +134,7 @@ class NumberUtilsTests {
|
|||
|
||||
@Test
|
||||
void convertDoubleToBigInteger() {
|
||||
Double decimal = Double.valueOf(3.14d);
|
||||
Double decimal = 3.14d;
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(decimal, BigInteger.class)).isEqualTo(new BigInteger("3"));
|
||||
}
|
||||
|
||||
|
|
@ -272,48 +272,48 @@ class NumberUtilsTests {
|
|||
|
||||
@Test
|
||||
void convertToInteger() {
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(-1), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(-1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(0), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(0)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(1), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(-1), Integer.class)).isEqualTo(Integer.valueOf(-1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(0), Integer.class)).isEqualTo(Integer.valueOf(0));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(1), Integer.class)).isEqualTo(Integer.valueOf(1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(Integer.MAX_VALUE), Integer.class)).isEqualTo(Integer.valueOf(Integer.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(Integer.MAX_VALUE + 1), Integer.class)).isEqualTo(Integer.valueOf(Integer.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(Integer.MIN_VALUE), Integer.class)).isEqualTo(Integer.valueOf(Integer.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(Integer.MIN_VALUE - 1), Integer.class)).isEqualTo(Integer.valueOf(Integer.MAX_VALUE));
|
||||
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.valueOf(-1), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(-1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.valueOf(0), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(0)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.valueOf(1), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((long) -1, Integer.class)).isEqualTo(Integer.valueOf(-1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(0L, Integer.class)).isEqualTo(Integer.valueOf(0));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(1L, Integer.class)).isEqualTo(Integer.valueOf(1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.valueOf(Integer.MAX_VALUE), Integer.class)).isEqualTo(Integer.valueOf(Integer.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.valueOf(Integer.MAX_VALUE + 1), Integer.class)).isEqualTo(Integer.valueOf(Integer.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.valueOf(Integer.MIN_VALUE), Integer.class)).isEqualTo(Integer.valueOf(Integer.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.valueOf(Integer.MIN_VALUE - 1), Integer.class)).isEqualTo(Integer.valueOf(Integer.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((long) (Integer.MAX_VALUE + 1), Integer.class)).isEqualTo(Integer.valueOf(Integer.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((long) Integer.MIN_VALUE, Integer.class)).isEqualTo(Integer.valueOf(Integer.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((long) (Integer.MIN_VALUE - 1), Integer.class)).isEqualTo(Integer.valueOf(Integer.MAX_VALUE));
|
||||
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.valueOf(-1), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(-1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.valueOf(0), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(0)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.valueOf(1), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.valueOf(Integer.MAX_VALUE), Integer.class)).isEqualTo(Integer.valueOf(Integer.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.valueOf(Integer.MAX_VALUE + 1), Integer.class)).isEqualTo(Integer.valueOf(Integer.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.valueOf(Integer.MIN_VALUE), Integer.class)).isEqualTo(Integer.valueOf(Integer.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.valueOf(Integer.MIN_VALUE - 1), Integer.class)).isEqualTo(Integer.valueOf(Integer.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(-1, Integer.class)).isEqualTo(Integer.valueOf(-1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(0, Integer.class)).isEqualTo(Integer.valueOf(0));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(1, Integer.class)).isEqualTo(Integer.valueOf(1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.MAX_VALUE, Integer.class)).isEqualTo(Integer.valueOf(Integer.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.MAX_VALUE + 1, Integer.class)).isEqualTo(Integer.valueOf(Integer.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.MIN_VALUE, Integer.class)).isEqualTo(Integer.valueOf(Integer.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.MIN_VALUE - 1, Integer.class)).isEqualTo(Integer.valueOf(Integer.MAX_VALUE));
|
||||
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.valueOf((short) -1), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(-1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.valueOf((short) 0), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(0)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.valueOf((short) 1), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.valueOf(Short.MAX_VALUE), Integer.class)).isEqualTo(Integer.valueOf(Short.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.valueOf((short) (Short.MAX_VALUE + 1)), Integer.class)).isEqualTo(Integer.valueOf(Short.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.valueOf(Short.MIN_VALUE), Integer.class)).isEqualTo(Integer.valueOf(Short.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.valueOf((short) (Short.MIN_VALUE - 1)), Integer.class)).isEqualTo(Integer.valueOf(Short.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((short) -1, Integer.class)).isEqualTo(Integer.valueOf(-1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((short) 0, Integer.class)).isEqualTo(Integer.valueOf(0));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((short) 1, Integer.class)).isEqualTo(Integer.valueOf(1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.MAX_VALUE, Integer.class)).isEqualTo(Integer.valueOf(Short.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((short) (Short.MAX_VALUE + 1), Integer.class)).isEqualTo(Integer.valueOf(Short.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.MIN_VALUE, Integer.class)).isEqualTo(Integer.valueOf(Short.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((short) (Short.MIN_VALUE - 1), Integer.class)).isEqualTo(Integer.valueOf(Short.MAX_VALUE));
|
||||
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.valueOf((byte) -1), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(-1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.valueOf((byte) 0), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(0)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.valueOf((byte) 1), Integer.class)).isEqualTo(Integer.valueOf(Integer.valueOf(1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.valueOf(Byte.MAX_VALUE), Integer.class)).isEqualTo(Integer.valueOf(Byte.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.valueOf((byte) (Byte.MAX_VALUE + 1)), Integer.class)).isEqualTo(Integer.valueOf(Byte.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.valueOf(Byte.MIN_VALUE), Integer.class)).isEqualTo(Integer.valueOf(Byte.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.valueOf((byte) (Byte.MIN_VALUE - 1)), Integer.class)).isEqualTo(Integer.valueOf(Byte.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((byte) -1, Integer.class)).isEqualTo(Integer.valueOf(-1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((byte) 0, Integer.class)).isEqualTo(Integer.valueOf(0));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((byte) 1, Integer.class)).isEqualTo(Integer.valueOf(1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.MAX_VALUE, Integer.class)).isEqualTo(Integer.valueOf(Byte.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((byte) (Byte.MAX_VALUE + 1), Integer.class)).isEqualTo(Integer.valueOf(Byte.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.MIN_VALUE, Integer.class)).isEqualTo(Integer.valueOf(Byte.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((byte) (Byte.MIN_VALUE - 1), Integer.class)).isEqualTo(Integer.valueOf(Byte.MAX_VALUE));
|
||||
|
||||
assertToNumberOverflow(Long.valueOf(Long.MAX_VALUE + 1), Integer.class);
|
||||
assertToNumberOverflow(Long.valueOf(Long.MIN_VALUE - 1), Integer.class);
|
||||
assertToNumberOverflow(Long.MAX_VALUE + 1, Integer.class);
|
||||
assertToNumberOverflow(Long.MIN_VALUE - 1, Integer.class);
|
||||
assertToNumberOverflow(BigInteger.valueOf(Integer.MAX_VALUE).add(BigInteger.ONE), Integer.class);
|
||||
assertToNumberOverflow(BigInteger.valueOf(Integer.MIN_VALUE).subtract(BigInteger.ONE), Integer.class);
|
||||
assertToNumberOverflow(new BigDecimal("18446744073709551611"), Integer.class);
|
||||
|
|
@ -321,45 +321,45 @@ class NumberUtilsTests {
|
|||
|
||||
@Test
|
||||
void convertToLong() {
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(-1), Long.class)).isEqualTo(Long.valueOf(Long.valueOf(-1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(0), Long.class)).isEqualTo(Long.valueOf(Long.valueOf(0)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(1), Long.class)).isEqualTo(Long.valueOf(Long.valueOf(1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(-1), Long.class)).isEqualTo(Long.valueOf(-1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(0), Long.class)).isEqualTo(Long.valueOf(0));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(1), Long.class)).isEqualTo(Long.valueOf(1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(Long.MAX_VALUE), Long.class)).isEqualTo(Long.valueOf(Long.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(Long.MAX_VALUE + 1), Long.class)).isEqualTo(Long.valueOf(Long.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(Long.MIN_VALUE), Long.class)).isEqualTo(Long.valueOf(Long.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(BigInteger.valueOf(Long.MIN_VALUE - 1), Long.class)).isEqualTo(Long.valueOf(Long.MAX_VALUE));
|
||||
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.valueOf(-1), Long.class)).isEqualTo(Long.valueOf(Long.valueOf(-1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.valueOf(0), Long.class)).isEqualTo(Long.valueOf(Long.valueOf(0)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.valueOf(1), Long.class)).isEqualTo(Long.valueOf(Long.valueOf(1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.valueOf(Long.MAX_VALUE), Long.class)).isEqualTo(Long.valueOf(Long.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.valueOf(Long.MAX_VALUE + 1), Long.class)).isEqualTo(Long.valueOf(Long.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.valueOf(Long.MIN_VALUE), Long.class)).isEqualTo(Long.valueOf(Long.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.valueOf(Long.MIN_VALUE - 1), Long.class)).isEqualTo(Long.valueOf(Long.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((long) -1, Long.class)).isEqualTo(Long.valueOf(-1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(0L, Long.class)).isEqualTo(Long.valueOf(0));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(1L, Long.class)).isEqualTo(Long.valueOf(1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.MAX_VALUE, Long.class)).isEqualTo(Long.valueOf(Long.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.MAX_VALUE + 1, Long.class)).isEqualTo(Long.valueOf(Long.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.MIN_VALUE, Long.class)).isEqualTo(Long.valueOf(Long.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Long.MIN_VALUE - 1, Long.class)).isEqualTo(Long.valueOf(Long.MAX_VALUE));
|
||||
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.valueOf(-1), Long.class)).isEqualTo(Long.valueOf(Integer.valueOf(-1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.valueOf(0), Long.class)).isEqualTo(Long.valueOf(Integer.valueOf(0)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.valueOf(1), Long.class)).isEqualTo(Long.valueOf(Integer.valueOf(1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.valueOf(Integer.MAX_VALUE), Long.class)).isEqualTo(Long.valueOf(Integer.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.valueOf(Integer.MAX_VALUE + 1), Long.class)).isEqualTo(Long.valueOf(Integer.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.valueOf(Integer.MIN_VALUE), Long.class)).isEqualTo(Long.valueOf(Integer.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.valueOf(Integer.MIN_VALUE - 1), Long.class)).isEqualTo(Long.valueOf(Integer.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(-1, Long.class)).isEqualTo(Long.valueOf(-1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(0, Long.class)).isEqualTo(Long.valueOf(0));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(1, Long.class)).isEqualTo(Long.valueOf(1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.MAX_VALUE, Long.class)).isEqualTo(Long.valueOf(Integer.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.MAX_VALUE + 1, Long.class)).isEqualTo(Long.valueOf(Integer.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.MIN_VALUE, Long.class)).isEqualTo(Long.valueOf(Integer.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Integer.MIN_VALUE - 1, Long.class)).isEqualTo(Long.valueOf(Integer.MAX_VALUE));
|
||||
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.valueOf((short) -1), Long.class)).isEqualTo(Long.valueOf(Integer.valueOf(-1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.valueOf((short) 0), Long.class)).isEqualTo(Long.valueOf(Integer.valueOf(0)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.valueOf((short) 1), Long.class)).isEqualTo(Long.valueOf(Integer.valueOf(1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.valueOf(Short.MAX_VALUE), Long.class)).isEqualTo(Long.valueOf(Short.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.valueOf((short) (Short.MAX_VALUE + 1)), Long.class)).isEqualTo(Long.valueOf(Short.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.valueOf(Short.MIN_VALUE), Long.class)).isEqualTo(Long.valueOf(Short.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.valueOf((short) (Short.MIN_VALUE - 1)), Long.class)).isEqualTo(Long.valueOf(Short.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((short) -1, Long.class)).isEqualTo(Long.valueOf(-1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((short) 0, Long.class)).isEqualTo(Long.valueOf(0));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((short) 1, Long.class)).isEqualTo(Long.valueOf(1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.MAX_VALUE, Long.class)).isEqualTo(Long.valueOf(Short.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((short) (Short.MAX_VALUE + 1), Long.class)).isEqualTo(Long.valueOf(Short.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Short.MIN_VALUE, Long.class)).isEqualTo(Long.valueOf(Short.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((short) (Short.MIN_VALUE - 1), Long.class)).isEqualTo(Long.valueOf(Short.MAX_VALUE));
|
||||
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.valueOf((byte) -1), Long.class)).isEqualTo(Long.valueOf(Integer.valueOf(-1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.valueOf((byte) 0), Long.class)).isEqualTo(Long.valueOf(Integer.valueOf(0)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.valueOf((byte) 1), Long.class)).isEqualTo(Long.valueOf(Integer.valueOf(1)));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.valueOf(Byte.MAX_VALUE), Long.class)).isEqualTo(Long.valueOf(Byte.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.valueOf((byte) (Byte.MAX_VALUE + 1)), Long.class)).isEqualTo(Long.valueOf(Byte.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.valueOf(Byte.MIN_VALUE), Long.class)).isEqualTo(Long.valueOf(Byte.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.valueOf((byte) (Byte.MIN_VALUE - 1)), Long.class)).isEqualTo(Long.valueOf(Byte.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((byte) -1, Long.class)).isEqualTo(Long.valueOf(-1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((byte) 0, Long.class)).isEqualTo(Long.valueOf(0));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((byte) 1, Long.class)).isEqualTo(Long.valueOf(1));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.MAX_VALUE, Long.class)).isEqualTo(Long.valueOf(Byte.MAX_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((byte) (Byte.MAX_VALUE + 1), Long.class)).isEqualTo(Long.valueOf(Byte.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass(Byte.MIN_VALUE, Long.class)).isEqualTo(Long.valueOf(Byte.MIN_VALUE));
|
||||
assertThat(NumberUtils.convertNumberToTargetClass((byte) (Byte.MIN_VALUE - 1), Long.class)).isEqualTo(Long.valueOf(Byte.MAX_VALUE));
|
||||
|
||||
assertToNumberOverflow(BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE), Long.class);
|
||||
assertToNumberOverflow(BigInteger.valueOf(Long.MIN_VALUE).subtract(BigInteger.ONE), Long.class);
|
||||
|
|
|
|||
|
|
@ -703,7 +703,7 @@ class ObjectUtilsTests {
|
|||
|
||||
@Test
|
||||
void nullSafeToStringWithObjectArray() {
|
||||
Object[] array = {"Han", Long.valueOf(43)};
|
||||
Object[] array = {"Han", 43L};
|
||||
assertThat(ObjectUtils.nullSafeToString(array)).isEqualTo("{Han, 43}");
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -305,13 +305,13 @@ class ReflectionUtilsTests {
|
|||
class Parent {
|
||||
@SuppressWarnings("unused")
|
||||
public Number m1() {
|
||||
return Integer.valueOf(42);
|
||||
return 42;
|
||||
}
|
||||
}
|
||||
class Leaf extends Parent {
|
||||
@Override
|
||||
public Integer m1() {
|
||||
return Integer.valueOf(42);
|
||||
return 42;
|
||||
}
|
||||
}
|
||||
Method[] methods = ReflectionUtils.getUniqueDeclaredMethods(Leaf.class);
|
||||
|
|
|
|||
|
|
@ -177,7 +177,7 @@ public abstract class AbstractExpressionTests {
|
|||
assertThat(ex.getMessageCode()).isEqualTo(expectedMessage);
|
||||
if (!ObjectUtils.isEmpty(otherProperties)) {
|
||||
// first one is expected position of the error within the string
|
||||
int pos = ((Integer) otherProperties[0]).intValue();
|
||||
int pos = (Integer) otherProperties[0];
|
||||
assertThat(ex.getPosition()).as("position").isEqualTo(pos);
|
||||
if (otherProperties.length > 1) {
|
||||
// Check inserts match
|
||||
|
|
@ -207,7 +207,7 @@ public abstract class AbstractExpressionTests {
|
|||
assertThat(ex.getMessageCode()).isEqualTo(expectedMessage);
|
||||
if (otherProperties != null && otherProperties.length != 0) {
|
||||
// first one is expected position of the error within the string
|
||||
int pos = ((Integer) otherProperties[0]).intValue();
|
||||
int pos = (Integer) otherProperties[0];
|
||||
assertThat(pos).as("reported position").isEqualTo(pos);
|
||||
if (otherProperties.length > 1) {
|
||||
// Check inserts match
|
||||
|
|
|
|||
|
|
@ -6203,7 +6203,7 @@ public class SpelCompilationCoverageTests extends AbstractExpressionTests {
|
|||
|
||||
public Reg(int v) {
|
||||
this._value = v;
|
||||
this._valueL = Long.valueOf(v);
|
||||
this._valueL = (long) v;
|
||||
this._valueD = (double) v;
|
||||
this._valueF = (float) v;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -637,7 +637,7 @@ class SpelReproTests extends AbstractExpressionTests {
|
|||
ConversionPriority1 target = new ConversionPriority1();
|
||||
MethodExecutor me = new ReflectiveMethodResolver(true).resolve(emptyEvalContext, target, "getX", args);
|
||||
// MethodInvoker chooses getX(int i) when passing Integer
|
||||
final int actual = (Integer) me.execute(emptyEvalContext, target, Integer.valueOf(42)).getValue();
|
||||
final int actual = (Integer) me.execute(emptyEvalContext, target, 42).getValue();
|
||||
// Compiler chooses getX(Number i) when passing Integer
|
||||
final int compiler = target.getX(INTEGER);
|
||||
// Fails!
|
||||
|
|
@ -646,7 +646,7 @@ class SpelReproTests extends AbstractExpressionTests {
|
|||
ConversionPriority2 target2 = new ConversionPriority2();
|
||||
MethodExecutor me2 = new ReflectiveMethodResolver(true).resolve(emptyEvalContext, target2, "getX", args);
|
||||
// MethodInvoker chooses getX(int i) when passing Integer
|
||||
int actual2 = (Integer) me2.execute(emptyEvalContext, target2, Integer.valueOf(42)).getValue();
|
||||
int actual2 = (Integer) me2.execute(emptyEvalContext, target2, 42).getValue();
|
||||
// Compiler chooses getX(Number i) when passing Integer
|
||||
int compiler2 = target2.getX(INTEGER);
|
||||
// Fails!
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ public class FormatHelperTests {
|
|||
|
||||
@Test
|
||||
public void formatMethodWithMultipleArgumentsForMessage() {
|
||||
String message = FormatHelper.formatMethodForMessage("foo", Arrays.asList(TypeDescriptor.forObject("a string"), TypeDescriptor.forObject(Integer.valueOf(5))));
|
||||
String message = FormatHelper.formatMethodForMessage("foo", Arrays.asList(TypeDescriptor.forObject("a string"), TypeDescriptor.forObject(5)));
|
||||
assertThat(message).isEqualTo("foo(java.lang.String,java.lang.Integer)");
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ public class OpPlusTests {
|
|||
|
||||
assertThat(value.getTypeDescriptor().getObjectType()).isEqualTo(Double.class);
|
||||
assertThat(value.getTypeDescriptor().getType()).isEqualTo(Double.class);
|
||||
assertThat(value.getValue()).isEqualTo(Double.valueOf(123.0 + 456.0));
|
||||
assertThat(value.getValue()).isEqualTo(123.0 + 456.0);
|
||||
}
|
||||
|
||||
{
|
||||
|
|
@ -119,7 +119,7 @@ public class OpPlusTests {
|
|||
|
||||
assertThat(value.getTypeDescriptor().getObjectType()).isEqualTo(Long.class);
|
||||
assertThat(value.getTypeDescriptor().getType()).isEqualTo(Long.class);
|
||||
assertThat(value.getValue()).isEqualTo(Long.valueOf(123L + 456L));
|
||||
assertThat(value.getValue()).isEqualTo(123L + 456L);
|
||||
}
|
||||
|
||||
{
|
||||
|
|
@ -130,7 +130,7 @@ public class OpPlusTests {
|
|||
|
||||
assertThat(value.getTypeDescriptor().getObjectType()).isEqualTo(Integer.class);
|
||||
assertThat(value.getTypeDescriptor().getType()).isEqualTo(Integer.class);
|
||||
assertThat(value.getValue()).isEqualTo(Integer.valueOf(123 + 456));
|
||||
assertThat(value.getValue()).isEqualTo(123 + 456);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -238,7 +238,7 @@ public class JdbcTemplateQueryTests {
|
|||
String sql = "SELECT AGE FROM CUSTMR WHERE ID = 3";
|
||||
given(this.resultSet.next()).willReturn(true, false);
|
||||
given(this.resultSet.getInt(1)).willReturn(22);
|
||||
int i = this.template.queryForObject(sql, Integer.class).intValue();
|
||||
int i = this.template.queryForObject(sql, Integer.class);
|
||||
assertThat(i).as("Return of an int").isEqualTo(22);
|
||||
verify(this.resultSet).close();
|
||||
verify(this.statement).close();
|
||||
|
|
@ -260,7 +260,7 @@ public class JdbcTemplateQueryTests {
|
|||
String sql = "SELECT AGE FROM CUSTMR WHERE ID = 3";
|
||||
given(this.resultSet.next()).willReturn(true, false);
|
||||
given(this.resultSet.getLong(1)).willReturn(87L);
|
||||
long l = this.template.queryForObject(sql, Long.class).longValue();
|
||||
long l = this.template.queryForObject(sql, Long.class);
|
||||
assertThat(l).as("Return of a long").isEqualTo(87);
|
||||
verify(this.resultSet).close();
|
||||
verify(this.statement).close();
|
||||
|
|
@ -395,7 +395,7 @@ public class JdbcTemplateQueryTests {
|
|||
String sql = "SELECT AGE FROM CUSTMR WHERE ID = ?";
|
||||
given(this.resultSet.next()).willReturn(true, false);
|
||||
given(this.resultSet.getInt(1)).willReturn(22);
|
||||
int i = this.template.queryForObject(sql, Integer.class, 3).intValue();
|
||||
int i = this.template.queryForObject(sql, Integer.class, 3);
|
||||
assertThat(i).as("Return of an int").isEqualTo(22);
|
||||
verify(this.preparedStatement).setObject(1, 3);
|
||||
verify(this.resultSet).close();
|
||||
|
|
@ -407,7 +407,7 @@ public class JdbcTemplateQueryTests {
|
|||
String sql = "SELECT AGE FROM CUSTMR WHERE ID = ?";
|
||||
given(this.resultSet.next()).willReturn(true, false);
|
||||
given(this.resultSet.getLong(1)).willReturn(87L);
|
||||
long l = this.template.queryForObject(sql, Long.class, 3).longValue();
|
||||
long l = this.template.queryForObject(sql, Long.class, 3);
|
||||
assertThat(l).as("Return of a long").isEqualTo(87);
|
||||
verify(this.preparedStatement).setObject(1, 3);
|
||||
verify(this.resultSet).close();
|
||||
|
|
|
|||
|
|
@ -214,13 +214,13 @@ public class JdbcTemplateTests {
|
|||
JdbcTemplate template = new JdbcTemplate();
|
||||
template.setDataSource(this.dataSource);
|
||||
if (fetchSize != null) {
|
||||
template.setFetchSize(fetchSize.intValue());
|
||||
template.setFetchSize(fetchSize);
|
||||
}
|
||||
if (maxRows != null) {
|
||||
template.setMaxRows(maxRows.intValue());
|
||||
template.setMaxRows(maxRows);
|
||||
}
|
||||
if (queryTimeout != null) {
|
||||
template.setQueryTimeout(queryTimeout.intValue());
|
||||
template.setQueryTimeout(queryTimeout);
|
||||
}
|
||||
jdbcTemplateCallback.doInJdbcTemplate(template, sql, sh);
|
||||
|
||||
|
|
@ -232,13 +232,13 @@ public class JdbcTemplateTests {
|
|||
}
|
||||
|
||||
if (fetchSize != null) {
|
||||
verify(this.preparedStatement).setFetchSize(fetchSize.intValue());
|
||||
verify(this.preparedStatement).setFetchSize(fetchSize);
|
||||
}
|
||||
if (maxRows != null) {
|
||||
verify(this.preparedStatement).setMaxRows(maxRows.intValue());
|
||||
verify(this.preparedStatement).setMaxRows(maxRows);
|
||||
}
|
||||
if (queryTimeout != null) {
|
||||
verify(this.preparedStatement).setQueryTimeout(queryTimeout.intValue());
|
||||
verify(this.preparedStatement).setQueryTimeout(queryTimeout);
|
||||
}
|
||||
if (argument != null) {
|
||||
verify(this.preparedStatement).setObject(1, argument);
|
||||
|
|
@ -362,10 +362,10 @@ public class JdbcTemplateTests {
|
|||
given(this.preparedStatement.executeUpdate()).willReturn(rowsAffected);
|
||||
|
||||
int actualRowsAffected = this.template.update(sql,
|
||||
4, new SqlParameterValue(Types.NUMERIC, 2, Float.valueOf(1.4142f)));
|
||||
4, new SqlParameterValue(Types.NUMERIC, 2, 1.4142f));
|
||||
assertThat(actualRowsAffected == rowsAffected).as("Actual rows affected is correct").isTrue();
|
||||
verify(this.preparedStatement).setObject(1, 4);
|
||||
verify(this.preparedStatement).setObject(2, Float.valueOf(1.4142f), Types.NUMERIC, 2);
|
||||
verify(this.preparedStatement).setObject(2, 1.4142f, Types.NUMERIC, 2);
|
||||
verify(this.preparedStatement).close();
|
||||
verify(this.connection).close();
|
||||
}
|
||||
|
|
@ -759,7 +759,7 @@ public class JdbcTemplateTests {
|
|||
given(this.preparedStatement.executeBatch()).willReturn(rowsAffected1, rowsAffected2);
|
||||
mockDatabaseMetaData(true);
|
||||
|
||||
ParameterizedPreparedStatementSetter<Integer> setter = (ps, argument) -> ps.setInt(1, argument.intValue());
|
||||
ParameterizedPreparedStatementSetter<Integer> setter = (ps, argument) -> ps.setInt(1, argument);
|
||||
JdbcTemplate template = new JdbcTemplate(this.dataSource, false);
|
||||
|
||||
int[][] actualRowsAffected = template.batchUpdate(sql, ids, 2, setter);
|
||||
|
|
|
|||
|
|
@ -265,7 +265,7 @@ public class NamedParameterQueryTests {
|
|||
|
||||
MapSqlParameterSource params = new MapSqlParameterSource();
|
||||
params.addValue("id", 3);
|
||||
int i = template.queryForObject("SELECT AGE FROM CUSTMR WHERE ID = :id", params, Integer.class).intValue();
|
||||
int i = template.queryForObject("SELECT AGE FROM CUSTMR WHERE ID = :id", params, Integer.class);
|
||||
|
||||
assertThat(i).as("Return of an int").isEqualTo(22);
|
||||
verify(connection).prepareStatement("SELECT AGE FROM CUSTMR WHERE ID = ?");
|
||||
|
|
@ -279,7 +279,7 @@ public class NamedParameterQueryTests {
|
|||
given(resultSet.getLong(1)).willReturn(87L);
|
||||
|
||||
BeanPropertySqlParameterSource params = new BeanPropertySqlParameterSource(new ParameterBean(3));
|
||||
long l = template.queryForObject("SELECT AGE FROM CUSTMR WHERE ID = :id", params, Long.class).longValue();
|
||||
long l = template.queryForObject("SELECT AGE FROM CUSTMR WHERE ID = :id", params, Long.class);
|
||||
|
||||
assertThat(l).as("Return of a long").isEqualTo(87);
|
||||
verify(connection).prepareStatement("SELECT AGE FROM CUSTMR WHERE ID = ?");
|
||||
|
|
@ -293,7 +293,7 @@ public class NamedParameterQueryTests {
|
|||
given(resultSet.getLong(1)).willReturn(87L);
|
||||
|
||||
BeanPropertySqlParameterSource params = new BeanPropertySqlParameterSource(new ParameterCollectionBean(3, 5));
|
||||
long l = template.queryForObject("SELECT AGE FROM CUSTMR WHERE ID IN (:ids)", params, Long.class).longValue();
|
||||
long l = template.queryForObject("SELECT AGE FROM CUSTMR WHERE ID IN (:ids)", params, Long.class);
|
||||
|
||||
assertThat(l).as("Return of a long").isEqualTo(87);
|
||||
verify(connection).prepareStatement("SELECT AGE FROM CUSTMR WHERE ID IN (?, ?)");
|
||||
|
|
|
|||
|
|
@ -121,7 +121,7 @@ public class DataAccessUtilsTests {
|
|||
|
||||
@Test
|
||||
public void withEquivalentIntegerInstanceTwice() {
|
||||
Collection<Integer> col = Arrays.asList(Integer.valueOf(555), Integer.valueOf(555));
|
||||
Collection<Integer> col = Arrays.asList(555, 555);
|
||||
|
||||
assertThatExceptionOfType(IncorrectResultSizeDataAccessException.class)
|
||||
.isThrownBy(() -> DataAccessUtils.uniqueResult(col))
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ public class ObjectToStringHttpMessageConverterTests {
|
|||
|
||||
@Test
|
||||
public void defaultCharset() throws IOException {
|
||||
this.converter.write(Integer.valueOf(5), null, response);
|
||||
this.converter.write(5, null, response);
|
||||
|
||||
assertThat(servletResponse.getCharacterEncoding()).isEqualTo("ISO-8859-1");
|
||||
}
|
||||
|
|
@ -124,20 +124,20 @@ public class ObjectToStringHttpMessageConverterTests {
|
|||
|
||||
@Test
|
||||
public void read() throws IOException {
|
||||
Short shortValue = Short.valueOf((short) 781);
|
||||
Short shortValue = (short) 781;
|
||||
MockHttpServletRequest request = new MockHttpServletRequest();
|
||||
request.setContentType(MediaType.TEXT_PLAIN_VALUE);
|
||||
request.setContent(shortValue.toString().getBytes(StringHttpMessageConverter.DEFAULT_CHARSET));
|
||||
assertThat(this.converter.read(Short.class, new ServletServerHttpRequest(request))).isEqualTo(shortValue);
|
||||
|
||||
Float floatValue = Float.valueOf(123);
|
||||
Float floatValue = 123F;
|
||||
request = new MockHttpServletRequest();
|
||||
request.setContentType(MediaType.TEXT_PLAIN_VALUE);
|
||||
request.setCharacterEncoding("UTF-16");
|
||||
request.setContent(floatValue.toString().getBytes("UTF-16"));
|
||||
assertThat(this.converter.read(Float.class, new ServletServerHttpRequest(request))).isEqualTo(floatValue);
|
||||
|
||||
Long longValue = Long.valueOf(55819182821331L);
|
||||
Long longValue = 55819182821331L;
|
||||
request = new MockHttpServletRequest();
|
||||
request.setContentType(MediaType.TEXT_PLAIN_VALUE);
|
||||
request.setCharacterEncoding("UTF-8");
|
||||
|
|
@ -158,7 +158,7 @@ public class ObjectToStringHttpMessageConverterTests {
|
|||
@Test
|
||||
public void writeUtf16() throws IOException {
|
||||
MediaType contentType = new MediaType("text", "plain", StandardCharsets.UTF_16);
|
||||
this.converter.write(Integer.valueOf(958), contentType, this.response);
|
||||
this.converter.write(958, contentType, this.response);
|
||||
|
||||
assertThat(this.servletResponse.getCharacterEncoding()).isEqualTo("UTF-16");
|
||||
assertThat(this.servletResponse.getContentType().startsWith(MediaType.TEXT_PLAIN_VALUE)).isTrue();
|
||||
|
|
|
|||
|
|
@ -152,7 +152,7 @@ public class ServletRequestAttributesTests {
|
|||
|
||||
@Test
|
||||
public void skipImmutableCharacter() {
|
||||
doSkipImmutableValue(Character.valueOf('x'));
|
||||
doSkipImmutableValue('x');
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
|
|||
|
|
@ -55,7 +55,7 @@ public class InputTagTests extends AbstractFormTagTests {
|
|||
// set up test data
|
||||
this.rob = new TestBean();
|
||||
this.rob.setName("Rob");
|
||||
this.rob.setMyFloat(Float.valueOf(12.34f));
|
||||
this.rob.setMyFloat(12.34f);
|
||||
|
||||
TestBean sally = new TestBean();
|
||||
sally.setName("Sally");
|
||||
|
|
|
|||
Loading…
Reference in New Issue