You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2024/09/03 11:37:37 UTC
(commons-beanutils) branch master updated: Migrate AbstractNumberConverterTest to JUnit 5 (#285)
This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-beanutils.git
The following commit(s) were added to refs/heads/master by this push:
new 4c9a0cda Migrate AbstractNumberConverterTest to JUnit 5 (#285)
4c9a0cda is described below
commit 4c9a0cda01ba3ce7c372e63cd86950fdb3896dfd
Author: Steve Bosman <st...@gmail.com>
AuthorDate: Tue Sep 3 12:37:32 2024 +0100
Migrate AbstractNumberConverterTest to JUnit 5 (#285)
---
.../converters/AbstractNumberConverterTest.java | 224 +++++++++++----------
.../converters/BigDecimalConverterTestCase.java | 14 +-
.../converters/BigIntegerConverterTestCase.java | 14 +-
.../converters/ByteConverterTestCase.java | 41 ++--
.../converters/DoubleConverterTestCase.java | 16 +-
.../converters/FloatConverterTestCase.java | 30 +--
.../converters/IntegerConverterTestCase.java | 39 ++--
.../converters/LongConverterTestCase.java | 16 +-
.../converters/ShortConverterTestCase.java | 41 ++--
9 files changed, 240 insertions(+), 195 deletions(-)
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/AbstractNumberConverterTest.java b/src/test/java/org/apache/commons/beanutils2/converters/AbstractNumberConverterTest.java
index 345b303d..826121a8 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/AbstractNumberConverterTest.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/AbstractNumberConverterTest.java
@@ -17,21 +17,25 @@
package org.apache.commons.beanutils2.converters;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
-import junit.framework.TestCase;
-
import org.apache.commons.beanutils2.ConversionException;
+import org.junit.jupiter.api.Test;
/**
* Abstract base for <Number>Converter classes.
* @param <T> Number type.
*/
-public abstract class AbstractNumberConverterTest<T extends Number> extends TestCase {
+abstract class AbstractNumberConverterTest<T extends Number> {
/** Test Number values */
protected Number[] numbers = new Number[4];
@@ -45,17 +49,21 @@ public abstract class AbstractNumberConverterTest<T extends Number> extends Test
/**
* Convert Boolean --> Number (default conversion)
*/
+ @Test
public void testBooleanToNumberDefault() {
final NumberConverter<T> converter = makeConverter();
// Other type --> String conversion
- assertEquals("Boolean.FALSE to Number ", 0, ((Number) converter.convert(getExpectedType(), Boolean.FALSE)).intValue());
- assertEquals("Boolean.TRUE to Number ", 1, ((Number) converter.convert(getExpectedType(), Boolean.TRUE)).intValue());
+ assertEquals(0, ((Number) converter.convert(getExpectedType(), Boolean.FALSE)).intValue(),
+ "Boolean.FALSE to Number ");
+ assertEquals(1, ((Number) converter.convert(getExpectedType(), Boolean.TRUE)).intValue(),
+ "Boolean.TRUE to Number ");
}
/**
* Convert Calendar --> Long
*/
+ @Test
public void testCalendarToNumber() {
final NumberConverter<T> converter = makeConverter();
@@ -63,32 +71,29 @@ public abstract class AbstractNumberConverterTest<T extends Number> extends Test
final long longValue = calendarValue.getTime().getTime();
// Calendar --> Long conversion
- assertEquals("Calendar to Long", Long.valueOf(longValue), converter.convert(Long.class, calendarValue));
+ assertEquals(Long.valueOf(longValue), converter.convert(Long.class, calendarValue),
+ "Calendar to Long");
// Calendar --> Integer
- try {
- converter.convert(Integer.class, calendarValue);
- fail("Calendar to Integer - expected a ConversionException");
- } catch (final ConversionException e) {
- // expected result - too large for Integer
- }
+ assertThrows(ConversionException.class,
+ ()-> converter.convert(Integer.class, calendarValue),
+ "Calendar to Integer - expected a ConversionException");
}
/**
* Assumes ConversionException in response to covert(getExpectedType(),null).
*/
+ @Test
public void testConvertNull() {
- try {
- makeConverter().convert(getExpectedType(), null);
- fail("Expected ConversionException");
- } catch (final ConversionException e) {
- // expected
- }
+ assertThrows(ConversionException.class,
+ ()-> makeConverter().convert(getExpectedType(), null),
+ "Expected ConversionException");
}
/**
* Assumes convert(getExpectedType(),Number) returns some non-null instance of getExpectedType().
*/
+ @Test
public void testConvertNumber() {
final String[] message = { "from Byte", "from Short", "from Integer", "from Long", "from Float", "from Double", "from BigDecimal", "from BigInteger",
"from Integer array", };
@@ -99,14 +104,16 @@ public abstract class AbstractNumberConverterTest<T extends Number> extends Test
for (int i = 0; i < number.length; i++) {
final Object val = makeConverter().convert(getExpectedType(), number[i]);
- assertNotNull("Convert " + message[i] + " should not be null", val);
- assertTrue("Convert " + message[i] + " should return a " + getExpectedType().getName(), getExpectedType().isInstance(val));
+ assertNotNull(val, "Convert " + message[i] + " should not be null");
+ assertTrue(getExpectedType().isInstance(val),
+ "Convert " + message[i] + " should return a " + getExpectedType().getName());
}
}
/**
* Convert Date --> Long
*/
+ @Test
public void testDateToNumber() {
final NumberConverter<T> converter = makeConverter();
@@ -114,91 +121,85 @@ public abstract class AbstractNumberConverterTest<T extends Number> extends Test
final long longValue = dateValue.getTime();
// Date --> Long conversion
- assertEquals("Date to Long", Long.valueOf(longValue), converter.convert(Long.class, dateValue));
+ assertEquals(Long.valueOf(longValue), converter.convert(Long.class, dateValue), "Date to Long");
// Date --> Integer
- try {
- converter.convert(Integer.class, dateValue);
- fail("Date to Integer - expected a ConversionException");
- } catch (final ConversionException e) {
- // expected result - too large for Integer
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(Integer.class, dateValue),
+ "Date to Integer - expected a ConversionException");
}
/**
* Convert Number --> String (using default and specified Locales)
*/
+ @Test
public void testInvalidDefault() {
final T defaultvalue = (T) numbers[0];
final NumberConverter<T> converter = makeConverter(defaultvalue);
// Default String --> Number conversion
- assertEquals("Invalid null ", defaultvalue, converter.convert(getExpectedType(), null));
- assertEquals("Default XXXX ", defaultvalue, converter.convert(getExpectedType(), "XXXX"));
+ assertEquals(defaultvalue, converter.convert(getExpectedType(), null), "Invalid null ");
+ assertEquals(defaultvalue, converter.convert(getExpectedType(), "XXXX"), "Default XXXX ");
}
/**
* Convert Number --> String (using default and specified Locales)
*/
+ @Test
public void testInvalidException() {
final NumberConverter<T> converter = makeConverter();
- try {
- converter.convert(getExpectedType(), null);
- fail("Null test, expected ConversionException");
- } catch (final ConversionException e) {
- // expected result
- }
- try {
- converter.convert(getExpectedType(), "XXXX");
- fail("Invalid test, expected ConversionException");
- } catch (final ConversionException e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(getExpectedType(), null),
+ "Null test, expected ConversionException");
+
+ assertThrows(ConversionException.class,
+ () -> converter.convert(getExpectedType(), "XXXX"),
+ "Invalid test, expected ConversionException");
}
/**
* Test specifying an invalid type.
*/
+ @Test
public void testInvalidType() {
final NumberConverter<T> converter = makeConverter();
- try {
- converter.convert(Object.class, numbers[0]);
- fail("Invalid type test, expected ConversionException");
- } catch (final ConversionException e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(Object.class, numbers[0]),
+ "Invalid type test, expected ConversionException");
}
/**
* Tests a conversion to an unsupported type if a default value is set.
*/
+ @Test
public void testInvalidTypeWithDefault() {
final NumberConverter<T> converter = makeConverter((T) numbers[0]);
- try {
- converter.convert(Object.class, numbers[0]);
- fail("Invalid type with default test, expected ConversionException");
- } catch (final ConversionException e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(Object.class, numbers[0]),
+ "Invalid type with default test, expected ConversionException");
}
/**
* Convert Number --> String (default conversion)
*/
+ @Test
public void testNumberToStringDefault() {
final NumberConverter<T> converter = makeConverter();
// Default Number --> String conversion
- assertEquals("Default Convert " + numbers[0], numbers[0].toString(), converter.convert(String.class, numbers[0]));
- assertEquals("Default Convert " + numbers[1], numbers[1].toString(), converter.convert(String.class, numbers[1]));
+ assertEquals(numbers[0].toString(), converter.convert(String.class, numbers[0]),
+ () -> "Default Convert " + numbers[0]);
+ assertEquals(numbers[1].toString(), converter.convert(String.class, numbers[1]),
+ () -> "Default Convert " + numbers[1]);
}
/**
* Convert Number --> String (using default and specified Locales)
*/
+ @Test
public void testNumberToStringLocale() {
// Re-set the default Locale to Locale.US
final Locale defaultLocale = Locale.getDefault();
@@ -208,13 +209,13 @@ public abstract class AbstractNumberConverterTest<T extends Number> extends Test
converter.setUseLocaleFormat(true);
// Default Locale
- assertEquals("Default Locale " + numbers[0], "-12", converter.convert(String.class, numbers[0]));
- assertEquals("Default Locale " + numbers[1], "13", converter.convert(String.class, numbers[1]));
+ assertEquals("-12", converter.convert(String.class, numbers[0]), () -> "Default Locale " + numbers[0]);
+ assertEquals("13", converter.convert(String.class, numbers[1]), () -> "Default Locale " + numbers[1]);
// Locale.GERMAN
converter.setLocale(Locale.GERMAN);
- assertEquals("Locale.GERMAN " + numbers[2], "-22", converter.convert(String.class, numbers[2]));
- assertEquals("Locale.GERMAN " + numbers[3], "23", converter.convert(String.class, numbers[3]));
+ assertEquals("-22", converter.convert(String.class, numbers[2]), () -> "Locale.GERMAN " + numbers[2]);
+ assertEquals("23", converter.convert(String.class, numbers[3]), () -> "Locale.GERMAN " + numbers[3]);
// Restore the default Locale
Locale.setDefault(defaultLocale);
@@ -223,6 +224,7 @@ public abstract class AbstractNumberConverterTest<T extends Number> extends Test
/**
* Convert Number --> String (using a Pattern, with default and specified Locales)
*/
+ @Test
public void testNumberToStringPattern() {
// Re-set the default Locale to Locale.US
final Locale defaultLocale = Locale.getDefault();
@@ -232,13 +234,13 @@ public abstract class AbstractNumberConverterTest<T extends Number> extends Test
converter.setPattern("[0,0.0];(0,0.0)");
// Default Locale
- assertEquals("Default Locale " + numbers[0], "(12.0)", converter.convert(String.class, numbers[0]));
- assertEquals("Default Locale " + numbers[1], "[13.0]", converter.convert(String.class, numbers[1]));
+ assertEquals("(12.0)", converter.convert(String.class, numbers[0]), () -> "Default Locale " + numbers[0]);
+ assertEquals("[13.0]", converter.convert(String.class, numbers[1]), () -> "Default Locale " + numbers[1]);
// Locale.GERMAN
converter.setLocale(Locale.GERMAN);
- assertEquals("Locale.GERMAN " + numbers[2], "(22,0)", converter.convert(String.class, numbers[2]));
- assertEquals("Locale.GERMAN " + numbers[3], "[23,0]", converter.convert(String.class, numbers[3]));
+ assertEquals("(22,0)", converter.convert(String.class, numbers[2]), () -> "Locale.GERMAN " + numbers[2]);
+ assertEquals("[23,0]", converter.convert(String.class, numbers[3]), () -> "Locale.GERMAN " + numbers[3]);
// Restore the default Locale
Locale.setDefault(defaultLocale);
@@ -247,59 +249,67 @@ public abstract class AbstractNumberConverterTest<T extends Number> extends Test
/**
* Convert Other --> String (default conversion)
*/
+ @Test
public void testOtherToStringDefault() {
final NumberConverter<T> converter = makeConverter();
// Other type --> String conversion
- assertEquals("Default Convert ", "ABC", converter.convert(String.class, new StringBuilder("ABC")));
+ assertEquals("ABC", converter.convert(String.class, new StringBuilder("ABC")), "Default Convert ");
}
/**
* Convert Array --> Number
*/
+ @Test
public void testStringArrayToInteger() {
final Integer defaultValue = Integer.valueOf(-1);
final NumberConverter<Integer> converter = new IntegerConverterTestCase().makeConverter(defaultValue);
// Default Locale
- assertEquals("Valid First", Integer.valueOf(5), converter.convert(Integer.class, new String[] { "5", "4", "3" }));
- assertEquals("Invalid First", defaultValue, converter.convert(Integer.class, new String[] { "FOO", "1", "2" }));
- assertEquals("Null First", defaultValue, converter.convert(Integer.class, new String[] { null, "1", "2" }));
- assertEquals("Long Array", Integer.valueOf(9), converter.convert(Integer.class, new long[] { 9, 2, 6 }));
+ assertEquals(Integer.valueOf(5), converter.convert(Integer.class, new String[] { "5", "4", "3" }),
+ "Valid First");
+ assertEquals(defaultValue, converter.convert(Integer.class, new String[] { "FOO", "1", "2" }),
+ "Invalid First");
+ assertEquals(defaultValue, converter.convert(Integer.class, new String[] { null, "1", "2" }),
+ "Null First");
+ assertEquals(Integer.valueOf(9), converter.convert(Integer.class, new long[] { 9, 2, 6 }),
+ "Long Array");
}
/**
* Convert String --> Number (default conversion)
*/
+ @Test
public void testStringToNumberDefault() {
final NumberConverter<T> converter = makeConverter();
converter.setUseLocaleFormat(false);
// Default String --> Number conversion
- assertEquals("Default Convert " + numbers[0], numbers[0], converter.convert(getExpectedType(), numbers[0].toString()));
+ assertEquals(numbers[0], converter.convert(getExpectedType(), numbers[0].toString()),
+ () -> "Default Convert " + numbers[0]);
// Invalid
- try {
- converter.convert(getExpectedType(), "12x");
- fail("Expected invalid value to cause ConversionException");
- } catch (final Exception e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(getExpectedType(), "12x"),
+ "Expected invalid value to cause ConversionException");
}
/**
* Convert String --> Number if the target type is not defined. Then the default type should be used.
*/
+ @Test
public void testStringToNumberDefaultType() {
final NumberConverter<T> converter = makeConverter();
converter.setUseLocaleFormat(false);
- assertEquals("Default Convert " + numbers[0], numbers[0], converter.convert(null, numbers[0].toString()));
+ assertEquals(numbers[0], converter.convert(null, numbers[0].toString()),
+ () -> "Default Convert " + numbers[0]);
}
/**
* Convert String --> Number (using default and specified Locales)
*/
+ @Test
public void testStringToNumberLocale() {
// Re-set the default Locale to Locale.US
final Locale defaultLocale = Locale.getDefault();
@@ -309,29 +319,27 @@ public abstract class AbstractNumberConverterTest<T extends Number> extends Test
converter.setUseLocaleFormat(true);
// Default Locale
- assertEquals("Default Locale " + numbers[0], numbers[0], converter.convert(getExpectedType(), "-0,012"));
- assertEquals("Default Locale " + numbers[1], numbers[1], converter.convert(getExpectedType(), "0,013"));
+ assertEquals(numbers[0], converter.convert(getExpectedType(), "-0,012"),
+ () -> "Default Locale " + numbers[0]);
+ assertEquals(numbers[1], converter.convert(getExpectedType(), "0,013"),
+ () -> "Default Locale " + numbers[1]);
// Invalid Value
- try {
- converter.convert(getExpectedType(), "0,02x");
- fail("Expected invalid value to cause ConversionException");
- } catch (final Exception e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(getExpectedType(), "0,02x"),
+ "Expected invalid value to cause ConversionException");
// Locale.GERMAN
converter.setLocale(Locale.GERMAN);
- assertEquals("Locale.GERMAN " + numbers[2], numbers[2], converter.convert(getExpectedType(), "-0.022"));
- assertEquals("Locale.GERMAN " + numbers[3], numbers[3], converter.convert(getExpectedType(), "0.023"));
+ assertEquals(numbers[2], converter.convert(getExpectedType(), "-0.022"),
+ () -> "Locale.GERMAN " + numbers[2]);
+ assertEquals(numbers[3], converter.convert(getExpectedType(), "0.023"),
+ () -> "Locale.GERMAN " + numbers[3]);
// Invalid Value
- try {
- converter.convert(getExpectedType(), "0.02x");
- fail("Expected invalid value to cause ConversionException");
- } catch (final Exception e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(getExpectedType(), "0.02x"),
+ "Expected invalid value to cause ConversionException");
// Restore the default Locale
Locale.setDefault(defaultLocale);
@@ -340,6 +348,7 @@ public abstract class AbstractNumberConverterTest<T extends Number> extends Test
/**
* Convert String --> Number (using a Pattern, with default and specified Locales)
*/
+ @Test
public void testStringToNumberPattern() {
// Re-set the default Locale to Locale.US
@@ -350,21 +359,22 @@ public abstract class AbstractNumberConverterTest<T extends Number> extends Test
converter.setPattern("[0,0];(0,0)");
// Default Locale
- assertEquals("Default Locale " + numbers[0], numbers[0], converter.convert(getExpectedType(), "(1,2)"));
- assertEquals("Default Locale " + numbers[1], numbers[1], converter.convert(getExpectedType(), "[1,3]"));
+ assertEquals(numbers[0], converter.convert(getExpectedType(), "(1,2)"),
+ () -> "Default Locale " + numbers[0]);
+ assertEquals(numbers[1], converter.convert(getExpectedType(), "[1,3]"),
+ () -> "Default Locale " + numbers[1]);
// Locale.GERMAN
converter.setLocale(Locale.GERMAN);
- assertEquals("Locale.GERMAN " + numbers[2], numbers[2], converter.convert(getExpectedType(), "(2.2)"));
- assertEquals("Locale.GERMAN " + numbers[3], numbers[3], converter.convert(getExpectedType(), "[2.3]"));
+ assertEquals(numbers[2], converter.convert(getExpectedType(), "(2.2)"),
+ () -> "Locale.GERMAN " + numbers[2]);
+ assertEquals(numbers[3], converter.convert(getExpectedType(), "[2.3]"),
+ () -> "Locale.GERMAN " + numbers[3]);
// Invalid Value
- try {
- converter.convert(getExpectedType(), "1,2");
- fail("Expected invalid value to cause ConversionException");
- } catch (final Exception e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(getExpectedType(), "1,2"),
+ "Expected invalid value to cause ConversionException");
// Invalid Type (will try via String)
final Object obj = new Object() {
@@ -373,17 +383,15 @@ public abstract class AbstractNumberConverterTest<T extends Number> extends Test
return "dsdgsdsdg";
}
};
- try {
- converter.convert(getExpectedType(), obj);
- fail("Expected invalid value to cause ConversionException");
- } catch (final Exception e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(getExpectedType(), obj),
+ "Expected invalid value to cause ConversionException");
// Restore the default Locale
Locale.setDefault(defaultLocale);
}
+ @Test
public void testToString() {
assertNotNull(makeConverter().toString());
}
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/BigDecimalConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/BigDecimalConverterTestCase.java
index 4dd36782..b0a64bb4 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/BigDecimalConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/BigDecimalConverterTestCase.java
@@ -17,9 +17,14 @@
package org.apache.commons.beanutils2.converters;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
import java.math.BigDecimal;
import org.apache.commons.beanutils2.Converter;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Test Case for the DoubleConverter class.
@@ -54,7 +59,7 @@ public class BigDecimalConverterTestCase extends AbstractNumberConverterTest<Big
return new BigDecimalConverter(defaultValue);
}
- @Override
+ @BeforeEach
public void setUp() throws Exception {
converter = makeConverter();
numbers[0] = new BigDecimal("-12");
@@ -63,11 +68,12 @@ public class BigDecimalConverterTestCase extends AbstractNumberConverterTest<Big
numbers[3] = new BigDecimal("23");
}
- @Override
+ @AfterEach
public void tearDown() throws Exception {
converter = null;
}
+ @Test
public void testSimpleConversion() throws Exception {
final String[] message = { "from String", "from String", "from String", "from String", "from String", "from Byte", "from Short", "from Integer",
"from Long", "from Float", "from Double", "from BigDecimal", "from BigDecimal extension" };
@@ -80,8 +86,8 @@ public class BigDecimalConverterTestCase extends AbstractNumberConverterTest<Big
new BigDecimal("3200.11"), new BigDecimal("3200.11") };
for (int i = 0; i < expected.length; i++) {
- assertEquals(message[i] + " to BigDecimal", expected[i], converter.convert(BigDecimal.class, input[i]));
- assertEquals(message[i] + " to null type", expected[i], converter.convert(null, input[i]));
+ assertEquals(expected[i], converter.convert(BigDecimal.class, input[i]), message[i] + " to BigDecimal");
+ assertEquals(expected[i], converter.convert(null, input[i]), message[i] + " to null type");
}
}
}
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/BigIntegerConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/BigIntegerConverterTestCase.java
index 5141996d..e3f34966 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/BigIntegerConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/BigIntegerConverterTestCase.java
@@ -17,9 +17,14 @@
package org.apache.commons.beanutils2.converters;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
import java.math.BigInteger;
import org.apache.commons.beanutils2.Converter;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Test Case for the BigInteger class.
@@ -43,7 +48,7 @@ public class BigIntegerConverterTestCase extends AbstractNumberConverterTest<Big
return new BigIntegerConverter(defaultValue);
}
- @Override
+ @BeforeEach
public void setUp() throws Exception {
converter = makeConverter();
numbers[0] = new BigInteger("-12");
@@ -52,11 +57,12 @@ public class BigIntegerConverterTestCase extends AbstractNumberConverterTest<Big
numbers[3] = new BigInteger("23");
}
- @Override
+ @AfterEach
public void tearDown() throws Exception {
converter = null;
}
+ @Test
public void testSimpleConversion() throws Exception {
final String[] message = { "from String", "from String", "from String", "from String", "from String", "from String", "from String", "from Byte",
"from Short", "from Integer", "from Long", "from Float", "from Double" };
@@ -69,8 +75,8 @@ public class BigIntegerConverterTestCase extends AbstractNumberConverterTest<Big
BigInteger.valueOf(9), BigInteger.valueOf(10), BigInteger.valueOf(11), BigInteger.valueOf(12) };
for (int i = 0; i < expected.length; i++) {
- assertEquals(message[i] + " to BigInteger", expected[i], converter.convert(BigInteger.class, input[i]));
- assertEquals(message[i] + " to null type", expected[i], converter.convert(null, input[i]));
+ assertEquals(expected[i], converter.convert(BigInteger.class, input[i]), message[i] + " to BigInteger");
+ assertEquals(expected[i], converter.convert(null, input[i]), message[i] + " to null type");
}
}
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/ByteConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/ByteConverterTestCase.java
index 1fa49d31..8ad4621b 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/ByteConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/ByteConverterTestCase.java
@@ -17,7 +17,14 @@
package org.apache.commons.beanutils2.converters;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.apache.commons.beanutils2.ConversionException;
import org.apache.commons.beanutils2.Converter;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Test Case for the ByteConverter class.
@@ -41,7 +48,7 @@ public class ByteConverterTestCase extends AbstractNumberConverterTest<Byte> {
return new ByteConverter(defaultValue);
}
- @Override
+ @BeforeEach
public void setUp() throws Exception {
converter = makeConverter();
numbers[0] = Byte.valueOf("-12");
@@ -50,7 +57,7 @@ public class ByteConverterTestCase extends AbstractNumberConverterTest<Byte> {
numbers[3] = Byte.valueOf("23");
}
- @Override
+ @AfterEach
public void tearDown() throws Exception {
converter = null;
}
@@ -58,6 +65,7 @@ public class ByteConverterTestCase extends AbstractNumberConverterTest<Byte> {
/**
* Test Invalid Amounts (too big/small)
*/
+ @Test
public void testInvalidAmount() {
final Converter<Byte> converter = makeConverter();
final Class<Byte> clazz = Byte.class;
@@ -68,28 +76,23 @@ public class ByteConverterTestCase extends AbstractNumberConverterTest<Byte> {
final Long maxPlusOne = Long.valueOf(max.longValue() + 1);
// Minimum
- assertEquals("Minimum", Byte.valueOf(Byte.MIN_VALUE), converter.convert(clazz, min));
+ assertEquals(Byte.valueOf(Byte.MIN_VALUE), converter.convert(clazz, min), "Minimum");
// Maximum
- assertEquals("Maximum", Byte.valueOf(Byte.MAX_VALUE), converter.convert(clazz, max));
+ assertEquals(Byte.valueOf(Byte.MAX_VALUE), converter.convert(clazz, max), "Maximum");
// Too Small
- try {
- assertEquals("Minimum - 1", null, converter.convert(clazz, minMinusOne));
- fail("Less than minimum, expected ConversionException");
- } catch (final Exception e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(clazz, minMinusOne),
+ "Less than minimum, expected ConversionException");
// Too Large
- try {
- assertEquals("Maximum + 1", null, converter.convert(clazz, maxPlusOne));
- fail("More than maximum, expected ConversionException");
- } catch (final Exception e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(clazz, maxPlusOne),
+ "More than maximum, expected ConversionException");
}
+ @Test
public void testSimpleConversion() throws Exception {
final String[] message = { "from String", "from String", "from String", "from String", "from String", "from String", "from String", "from Byte",
"from Short", "from Integer", "from Long", "from Float", "from Double" };
@@ -102,9 +105,9 @@ public class ByteConverterTestCase extends AbstractNumberConverterTest<Byte> {
Byte.valueOf((byte) 9), Byte.valueOf((byte) 10), Byte.valueOf((byte) 11), Byte.valueOf((byte) 12) };
for (int i = 0; i < expected.length; i++) {
- assertEquals(message[i] + " to Byte", expected[i], converter.convert(Byte.class, input[i]));
- assertEquals(message[i] + " to byte", expected[i], converter.convert(Byte.TYPE, input[i]));
- assertEquals(message[i] + " to null type", expected[i], converter.convert(null, input[i]));
+ assertEquals(expected[i], converter.convert(Byte.class, input[i]), message[i] + " to Byte");
+ assertEquals(expected[i], converter.convert(Byte.TYPE, input[i]), message[i] + " to byte");
+ assertEquals(expected[i], converter.convert(null, input[i]), message[i] + " to null type");
}
}
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/DoubleConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/DoubleConverterTestCase.java
index b92a8e3d..ccd7971e 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/DoubleConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/DoubleConverterTestCase.java
@@ -17,7 +17,12 @@
package org.apache.commons.beanutils2.converters;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
import org.apache.commons.beanutils2.Converter;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Test Case for the DoubleConverter class.
@@ -41,7 +46,7 @@ public class DoubleConverterTestCase extends AbstractNumberConverterTest<Double>
return new DoubleConverter(defaultValue);
}
- @Override
+ @BeforeEach
public void setUp() throws Exception {
converter = makeConverter();
numbers[0] = Double.valueOf("-12");
@@ -50,11 +55,12 @@ public class DoubleConverterTestCase extends AbstractNumberConverterTest<Double>
numbers[3] = Double.valueOf("23");
}
- @Override
+ @AfterEach
public void tearDown() throws Exception {
converter = null;
}
+ @Test
public void testSimpleConversion() {
final String[] message = { "from String", "from String", "from String", "from String", "from String", "from String", "from String", "from Byte",
"from Short", "from Integer", "from Long", "from Float", "from Double" };
@@ -67,9 +73,9 @@ public class DoubleConverterTestCase extends AbstractNumberConverterTest<Double>
Double.valueOf(11.1), Double.valueOf(12.2) };
for (int i = 0; i < expected.length; i++) {
- assertEquals(message[i] + " to Double", expected[i].doubleValue(), converter.convert(Double.class, input[i]).doubleValue(), 0.00001D);
- assertEquals(message[i] + " to double", expected[i].doubleValue(), converter.convert(Double.TYPE, input[i]).doubleValue(), 0.00001D);
- assertEquals(message[i] + " to null type", expected[i].doubleValue(), converter.convert((Class<Double>) null, input[i]).doubleValue(), 0.00001D);
+ assertEquals(expected[i].doubleValue(), converter.convert(Double.class, input[i]).doubleValue(), 0.00001D, message[i] + " to Double");
+ assertEquals(expected[i].doubleValue(), converter.convert(Double.TYPE, input[i]).doubleValue(), 0.00001D, message[i] + " to double");
+ assertEquals(expected[i].doubleValue(), converter.convert((Class<Double>) null, input[i]).doubleValue(), 0.00001D, message[i] + " to null type");
}
}
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/FloatConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/FloatConverterTestCase.java
index 0055fb13..0ee9036b 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/FloatConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/FloatConverterTestCase.java
@@ -17,7 +17,14 @@
package org.apache.commons.beanutils2.converters;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.apache.commons.beanutils2.ConversionException;
import org.apache.commons.beanutils2.Converter;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Test Case for the FloatConverter class.
@@ -41,7 +48,7 @@ public class FloatConverterTestCase extends AbstractNumberConverterTest<Float> {
return new FloatConverter(defaultValue);
}
- @Override
+ @BeforeEach
public void setUp() throws Exception {
converter = makeConverter();
numbers[0] = Float.valueOf("-12");
@@ -50,7 +57,7 @@ public class FloatConverterTestCase extends AbstractNumberConverterTest<Float> {
numbers[3] = Float.valueOf("23");
}
- @Override
+ @AfterEach
public void tearDown() throws Exception {
converter = null;
}
@@ -58,6 +65,7 @@ public class FloatConverterTestCase extends AbstractNumberConverterTest<Float> {
/**
* Test Invalid Amounts (too big/small)
*/
+ @Test
public void testInvalidAmount() {
final Converter<Float> converter = makeConverter();
final Class<?> clazz = Float.class;
@@ -66,17 +74,15 @@ public class FloatConverterTestCase extends AbstractNumberConverterTest<Float> {
final Double tooBig = Double.valueOf(Double.MAX_VALUE);
// Maximum
- assertEquals("Maximum", Float.valueOf(Float.MAX_VALUE), converter.convert(clazz, max));
+ assertEquals(Float.valueOf(Float.MAX_VALUE), converter.convert(clazz, max), "Maximum");
// Too Large
- try {
- assertEquals("Too Big", null, converter.convert(clazz, tooBig));
- fail("More than maximum, expected ConversionException");
- } catch (final Exception e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(clazz, tooBig),
+ "More than maximum, expected ConversionException");
}
+ @Test
public void testSimpleConversion() {
final String[] message = { "from String", "from String", "from String", "from String", "from String", "from String", "from String", "from Byte",
"from Short", "from Integer", "from Long", "from Float", "from Double" };
@@ -89,9 +95,9 @@ public class FloatConverterTestCase extends AbstractNumberConverterTest<Float> {
Float.valueOf(10), Float.valueOf((float) 11.1), Float.valueOf((float) 12.2) };
for (int i = 0; i < expected.length; i++) {
- assertEquals(message[i] + " to Float", expected[i].floatValue(), converter.convert(Float.class, input[i]).floatValue(), 0.00001);
- assertEquals(message[i] + " to float", expected[i].floatValue(), converter.convert(Float.TYPE, input[i]).floatValue(), 0.00001);
- assertEquals(message[i] + " to null type", expected[i].floatValue(), converter.convert((Class<Float>) null, input[i]).floatValue(), 0.00001);
+ assertEquals(expected[i].floatValue(), converter.convert(Float.class, input[i]).floatValue(), 0.00001, message[i] + " to Float");
+ assertEquals(expected[i].floatValue(), converter.convert(Float.TYPE, input[i]).floatValue(), 0.00001, message[i] + " to float");
+ assertEquals(expected[i].floatValue(), converter.convert((Class<Float>) null, input[i]).floatValue(), 0.00001, message[i] + " to null type");
}
}
}
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/IntegerConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/IntegerConverterTestCase.java
index 93c6cfd3..4be6b575 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/IntegerConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/IntegerConverterTestCase.java
@@ -17,10 +17,14 @@
package org.apache.commons.beanutils2.converters;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.apache.commons.beanutils2.ConversionException;
import org.apache.commons.beanutils2.Converter;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Test Case for the IntegerConverter class.
@@ -44,7 +48,7 @@ public class IntegerConverterTestCase extends AbstractNumberConverterTest<Intege
return new IntegerConverter(defaultValue);
}
- @Override
+ @BeforeEach
public void setUp() throws Exception {
converter = makeConverter();
numbers[0] = Integer.valueOf("-12");
@@ -53,7 +57,7 @@ public class IntegerConverterTestCase extends AbstractNumberConverterTest<Intege
numbers[3] = Integer.valueOf("23");
}
- @Override
+ @AfterEach
public void tearDown() throws Exception {
converter = null;
}
@@ -61,6 +65,7 @@ public class IntegerConverterTestCase extends AbstractNumberConverterTest<Intege
/**
* Test Invalid Amounts (too big/small)
*/
+ @Test
public void testInvalidAmount() {
final Converter<Integer> converter = makeConverter();
final Class<?> clazz = Integer.class;
@@ -71,31 +76,26 @@ public class IntegerConverterTestCase extends AbstractNumberConverterTest<Intege
final Long maxPlusOne = Long.valueOf(max.longValue() + 1);
// Minimum
- assertEquals("Minimum", Integer.valueOf(Integer.MIN_VALUE), converter.convert(clazz, min));
+ assertEquals(Integer.valueOf(Integer.MIN_VALUE), converter.convert(clazz, min), "Minimum");
// Maximum
- assertEquals("Maximum", Integer.valueOf(Integer.MAX_VALUE), converter.convert(clazz, max));
+ assertEquals(Integer.valueOf(Integer.MAX_VALUE), converter.convert(clazz, max), "Maximum");
// Too Small
- try {
- assertEquals("Minimum - 1", null, converter.convert(clazz, minMinusOne));
- fail("Less than minimum, expected ConversionException");
- } catch (final Exception e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(clazz, minMinusOne),
+ "Less than minimum, expected ConversionException");
// Too Large
- try {
- assertEquals("Maximum + 1", null, converter.convert(clazz, maxPlusOne));
- fail("More than maximum, expected ConversionException");
- } catch (final Exception e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(clazz, maxPlusOne),
+ "More than maximum, expected ConversionException");
}
/**
* Tests whether an invalid default object causes an exception.
*/
+ @Test
@SuppressWarnings("unchecked") // raw to test throwing
public void testInvalidDefaultObject() {
@SuppressWarnings("rawtypes") // raw to test throwing
@@ -103,6 +103,7 @@ public class IntegerConverterTestCase extends AbstractNumberConverterTest<Intege
assertThrows(ConversionException.class, () -> converter.setDefaultValue("notANumber"), "Invalid default value not detected!");
}
+ @Test
public void testSimpleConversion() throws Exception {
final String[] message = { "from String", "from String", "from String", "from String", "from String", "from String", "from String", "from Byte",
"from Short", "from Integer", "from Long", "from Float", "from Double" };
@@ -115,9 +116,9 @@ public class IntegerConverterTestCase extends AbstractNumberConverterTest<Intege
Integer.valueOf(11), Integer.valueOf(12) };
for (int i = 0; i < expected.length; i++) {
- assertEquals(message[i] + " to Integer", expected[i], converter.convert(Integer.class, input[i]));
- assertEquals(message[i] + " to int", expected[i], converter.convert(Integer.TYPE, input[i]));
- assertEquals(message[i] + " to null type", expected[i], converter.convert(null, input[i]));
+ assertEquals(expected[i], converter.convert(Integer.class, input[i]), message[i] + " to Integer");
+ assertEquals(expected[i], converter.convert(Integer.TYPE, input[i]), message[i] + " to int");
+ assertEquals(expected[i], converter.convert(null, input[i]), message[i] + " to null type");
}
}
}
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/LongConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/LongConverterTestCase.java
index 1df8ddfd..3c3de17d 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/LongConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/LongConverterTestCase.java
@@ -17,7 +17,12 @@
package org.apache.commons.beanutils2.converters;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
import org.apache.commons.beanutils2.Converter;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Test Case for the LongConverter class.
@@ -41,7 +46,7 @@ public class LongConverterTestCase extends AbstractNumberConverterTest<Long> {
return new LongConverter(defaultValue);
}
- @Override
+ @BeforeEach
public void setUp() throws Exception {
converter = makeConverter();
numbers[0] = Long.valueOf("-12");
@@ -50,11 +55,12 @@ public class LongConverterTestCase extends AbstractNumberConverterTest<Long> {
numbers[3] = Long.valueOf("23");
}
- @Override
+ @AfterEach
public void tearDown() throws Exception {
converter = null;
}
+ @Test
public void testSimpleConversion() throws Exception {
final String[] message = { "from String", "from String", "from String", "from String", "from String", "from String", "from String", "from Byte",
"from Short", "from Integer", "from Long", "from Float", "from Double" };
@@ -66,9 +72,9 @@ public class LongConverterTestCase extends AbstractNumberConverterTest<Long> {
Long.valueOf(Long.MAX_VALUE), Long.valueOf(7), Long.valueOf(8), Long.valueOf(9), Long.valueOf(10), Long.valueOf(11), Long.valueOf(12) };
for (int i = 0; i < expected.length; i++) {
- assertEquals(message[i] + " to Long", expected[i], converter.convert(Long.class, input[i]));
- assertEquals(message[i] + " to long", expected[i], converter.convert(Long.TYPE, input[i]));
- assertEquals(message[i] + " to null type", expected[i], converter.convert(null, input[i]));
+ assertEquals(expected[i], converter.convert(Long.class, input[i]), message[i] + " to Long");
+ assertEquals(expected[i], converter.convert(Long.TYPE, input[i]), message[i] + " to long");
+ assertEquals(expected[i], converter.convert(null, input[i]), message[i] + " to null type");
}
}
diff --git a/src/test/java/org/apache/commons/beanutils2/converters/ShortConverterTestCase.java b/src/test/java/org/apache/commons/beanutils2/converters/ShortConverterTestCase.java
index 91eeb070..b4484845 100644
--- a/src/test/java/org/apache/commons/beanutils2/converters/ShortConverterTestCase.java
+++ b/src/test/java/org/apache/commons/beanutils2/converters/ShortConverterTestCase.java
@@ -17,7 +17,14 @@
package org.apache.commons.beanutils2.converters;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.apache.commons.beanutils2.ConversionException;
import org.apache.commons.beanutils2.Converter;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
/**
* Test Case for the ShortConverter class.
@@ -41,7 +48,7 @@ public class ShortConverterTestCase extends AbstractNumberConverterTest<Short> {
return new ShortConverter(defaultValue);
}
- @Override
+ @BeforeEach
public void setUp() throws Exception {
converter = makeConverter();
numbers[0] = Short.valueOf("-12");
@@ -50,7 +57,7 @@ public class ShortConverterTestCase extends AbstractNumberConverterTest<Short> {
numbers[3] = Short.valueOf("23");
}
- @Override
+ @AfterEach
public void tearDown() throws Exception {
converter = null;
}
@@ -58,6 +65,7 @@ public class ShortConverterTestCase extends AbstractNumberConverterTest<Short> {
/**
* Test Invalid Amounts (too big/small)
*/
+ @Test
public void testInvalidAmount() {
final Converter<Short> converter = makeConverter();
final Class<?> clazz = Short.class;
@@ -68,28 +76,23 @@ public class ShortConverterTestCase extends AbstractNumberConverterTest<Short> {
final Long maxPlusOne = Long.valueOf(max.longValue() + 1);
// Minimum
- assertEquals("Minimum", Short.valueOf(Short.MIN_VALUE), converter.convert(clazz, min));
+ assertEquals(Short.valueOf(Short.MIN_VALUE), converter.convert(clazz, min), "Minimum");
// Maximum
- assertEquals("Maximum", Short.valueOf(Short.MAX_VALUE), converter.convert(clazz, max));
+ assertEquals(Short.valueOf(Short.MAX_VALUE), converter.convert(clazz, max), "Maximum");
// Too Small
- try {
- assertEquals("Minimum - 1", null, converter.convert(clazz, minMinusOne));
- fail("Less than minimum, expected ConversionException");
- } catch (final Exception e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(clazz, minMinusOne),
+ "Less than minimum, expected ConversionException");
// Too Large
- try {
- assertEquals("Maximum + 1", null, converter.convert(clazz, maxPlusOne));
- fail("More than maximum, expected ConversionException");
- } catch (final Exception e) {
- // expected result
- }
+ assertThrows(ConversionException.class,
+ () -> converter.convert(clazz, maxPlusOne),
+ "More than maximum, expected ConversionException");
}
+ @Test
public void testSimpleConversion() throws Exception {
final String[] message = { "from String", "from String", "from String", "from String", "from String", "from String", "from String", "from Byte",
"from Short", "from Integer", "from Long", "from Float", "from Double" };
@@ -102,9 +105,9 @@ public class ShortConverterTestCase extends AbstractNumberConverterTest<Short> {
Short.valueOf((short) 9), Short.valueOf((short) 10), Short.valueOf((short) 11), Short.valueOf((short) 12) };
for (int i = 0; i < expected.length; i++) {
- assertEquals(message[i] + " to Short", expected[i], converter.convert(Short.class, input[i]));
- assertEquals(message[i] + " to short", expected[i], converter.convert(Short.TYPE, input[i]));
- assertEquals(message[i] + " to null type", expected[i], converter.convert(null, input[i]));
+ assertEquals(expected[i], converter.convert(Short.class, input[i]), message[i] + " to Short");
+ assertEquals(expected[i], converter.convert(Short.TYPE, input[i]), message[i] + " to short");
+ assertEquals(expected[i], converter.convert(null, input[i]), message[i] + " to null type");
}
}
}