From 2c01b7033657a5415ab6712bf97dda00d26ea26a Mon Sep 17 00:00:00 2001 From: John DeRegnaucourt Date: Thu, 15 Feb 2024 18:39:56 -0500 Subject: [PATCH] Added Boolean and Character tests to everything test. Added missing Map tests. Added new stats/info to Everything test output. --- .../convert/AtomicBooleanConversions.java | 2 +- .../util/convert/BooleanConversions.java | 2 +- .../cedarsoftware/util/convert/Converter.java | 21 +- .../util/convert/LocalDateConversions.java | 10 - .../util/convert/MapConversions.java | 46 +-- .../util/convert/VoidConversions.java | 2 +- .../util/convert/YearConversions.java | 18 +- .../AtomicBooleanConversionsTests.java | 2 +- .../util/convert/BooleanConversionsTests.java | 2 +- .../util/convert/ConverterEverythingTest.java | 261 +++++++++++++++++- 10 files changed, 305 insertions(+), 61 deletions(-) diff --git a/src/main/java/com/cedarsoftware/util/convert/AtomicBooleanConversions.java b/src/main/java/com/cedarsoftware/util/convert/AtomicBooleanConversions.java index b527fd71..1794ae67 100644 --- a/src/main/java/com/cedarsoftware/util/convert/AtomicBooleanConversions.java +++ b/src/main/java/com/cedarsoftware/util/convert/AtomicBooleanConversions.java @@ -37,7 +37,7 @@ static Short toShort(Object from, Converter converter) { return b.get() ? CommonValues.SHORT_ONE : CommonValues.SHORT_ZERO; } - static Integer toInteger(Object from, Converter converter) { + static Integer toInt(Object from, Converter converter) { AtomicBoolean b = (AtomicBoolean) from; return b.get() ? CommonValues.INTEGER_ONE : CommonValues.INTEGER_ZERO; } diff --git a/src/main/java/com/cedarsoftware/util/convert/BooleanConversions.java b/src/main/java/com/cedarsoftware/util/convert/BooleanConversions.java index 4ed6248f..8cb74791 100644 --- a/src/main/java/com/cedarsoftware/util/convert/BooleanConversions.java +++ b/src/main/java/com/cedarsoftware/util/convert/BooleanConversions.java @@ -37,7 +37,7 @@ static Short toShort(Object from, Converter converter) { return b ? CommonValues.SHORT_ONE : CommonValues.SHORT_ZERO; } - static Integer toInteger(Object from, Converter converter) { + static Integer toInt(Object from, Converter converter) { Boolean b = (Boolean) from; return b ? CommonValues.INTEGER_ONE : CommonValues.INTEGER_ZERO; } diff --git a/src/main/java/com/cedarsoftware/util/convert/Converter.java b/src/main/java/com/cedarsoftware/util/convert/Converter.java index f3759b07..909eae90 100644 --- a/src/main/java/com/cedarsoftware/util/convert/Converter.java +++ b/src/main/java/com/cedarsoftware/util/convert/Converter.java @@ -77,7 +77,7 @@ */ public final class Converter { - public static final Convert UNSUPPORTED = Converter::unsupported; + private static final Convert UNSUPPORTED = Converter::unsupported; static final String VALUE = "_v"; private final Map, Class>, Convert> factory; @@ -150,9 +150,9 @@ private static void buildFactoryConversions() { CONVERSION_DB.put(pair(Long.class, Integer.class), NumberConversions::toInt); CONVERSION_DB.put(pair(Float.class, Integer.class), NumberConversions::toInt); CONVERSION_DB.put(pair(Double.class, Integer.class), NumberConversions::toInt); - CONVERSION_DB.put(pair(Boolean.class, Integer.class), BooleanConversions::toInteger); + CONVERSION_DB.put(pair(Boolean.class, Integer.class), BooleanConversions::toInt); CONVERSION_DB.put(pair(Character.class, Integer.class), CharacterConversions::toInt); - CONVERSION_DB.put(pair(AtomicBoolean.class, Integer.class), AtomicBooleanConversions::toInteger); + CONVERSION_DB.put(pair(AtomicBoolean.class, Integer.class), AtomicBooleanConversions::toInt); CONVERSION_DB.put(pair(AtomicInteger.class, Integer.class), NumberConversions::toInt); CONVERSION_DB.put(pair(AtomicLong.class, Integer.class), NumberConversions::toInt); CONVERSION_DB.put(pair(BigInteger.class, Integer.class), NumberConversions::toInt); @@ -261,10 +261,9 @@ private static void buildFactoryConversions() { CONVERSION_DB.put(pair(Number.class, Boolean.class), NumberConversions::isIntTypeNotZero); CONVERSION_DB.put(pair(Map.class, Boolean.class), MapConversions::toBoolean); CONVERSION_DB.put(pair(String.class, Boolean.class), StringConversions::toBoolean); - CONVERSION_DB.put(pair(Year.class, Boolean.class), YearConversions::toBoolean); // Character/char conversions supported - CONVERSION_DB.put(pair(Void.class, char.class), VoidConversions::toChar); + CONVERSION_DB.put(pair(Void.class, char.class), VoidConversions::toCharacter); CONVERSION_DB.put(pair(Void.class, Character.class), VoidConversions::toNull); CONVERSION_DB.put(pair(Byte.class, Character.class), NumberConversions::toCharacter); CONVERSION_DB.put(pair(Short.class, Character.class), NumberConversions::toCharacter); @@ -690,30 +689,29 @@ private static void buildFactoryConversions() { CONVERSION_DB.put(pair(TimeZone.class, String.class), TimeZoneConversions::toString); try { - Class zoneInfoClass = Class.forName("sun.util.calendar.ZoneInfo"); + Class zoneInfoClass = Class.forName("sun.util.calendar.ZoneInfo"); CONVERSION_DB.put(pair(zoneInfoClass, String.class), TimeZoneConversions::toString); CONVERSION_DB.put(pair(Void.class, zoneInfoClass), VoidConversions::toNull); CONVERSION_DB.put(pair(String.class, zoneInfoClass), StringConversions::toTimeZone); CONVERSION_DB.put(pair(Map.class, zoneInfoClass), MapConversions::toTimeZone); - - - - } catch (Exception e) { - // ignore + } catch (Exception ignore) { } // URL conversions CONVERSION_DB.put(pair(Void.class, URL.class), VoidConversions::toNull); + CONVERSION_DB.put(pair(URL.class, URL.class), Converter::identity); CONVERSION_DB.put(pair(String.class, URL.class), StringConversions::toURL); CONVERSION_DB.put(pair(Map.class, URL.class), MapConversions::toURL); // URI Conversions CONVERSION_DB.put(pair(Void.class, URI.class), VoidConversions::toNull); + CONVERSION_DB.put(pair(URI.class, URI.class), Converter::identity); CONVERSION_DB.put(pair(String.class, URI.class), StringConversions::toURI); CONVERSION_DB.put(pair(Map.class, URI.class), MapConversions::toURI); // TimeZone Conversions CONVERSION_DB.put(pair(Void.class, TimeZone.class), VoidConversions::toNull); + CONVERSION_DB.put(pair(TimeZone.class, TimeZone.class), Converter::identity); CONVERSION_DB.put(pair(String.class, TimeZone.class), StringConversions::toTimeZone); CONVERSION_DB.put(pair(Map.class, TimeZone.class), MapConversions::toTimeZone); @@ -884,6 +882,7 @@ private static void buildFactoryConversions() { CONVERSION_DB.put(pair(Map.class, Map.class), MapConversions::toMap); CONVERSION_DB.put(pair(Enum.class, Map.class), MapConversions::initMap); CONVERSION_DB.put(pair(OffsetDateTime.class, Map.class), OffsetDateTimeConversions::toMap); + CONVERSION_DB.put(pair(Year.class, Map.class), YearConversions::toMap); } public Converter(ConverterOptions options) { diff --git a/src/main/java/com/cedarsoftware/util/convert/LocalDateConversions.java b/src/main/java/com/cedarsoftware/util/convert/LocalDateConversions.java index 63824941..bd75fd25 100644 --- a/src/main/java/com/cedarsoftware/util/convert/LocalDateConversions.java +++ b/src/main/java/com/cedarsoftware/util/convert/LocalDateConversions.java @@ -61,16 +61,6 @@ static ZonedDateTime toZonedDateTime(Object from, Converter converter) { return ((LocalDate) from).atStartOfDay(zoneId); } - /** - * Warning: Can lose precision going from a full long down to a floating point number - * @param from instance to convert - * @param converter converter instance - * @return the floating point number cast from a long. - */ - static float toFloat(Object from, Converter converter) { - return toLong(from, converter); - } - static double toDouble(Object from, Converter converter) { return toLong(from, converter); } diff --git a/src/main/java/com/cedarsoftware/util/convert/MapConversions.java b/src/main/java/com/cedarsoftware/util/convert/MapConversions.java index 547081e8..a585010a 100644 --- a/src/main/java/com/cedarsoftware/util/convert/MapConversions.java +++ b/src/main/java/com/cedarsoftware/util/convert/MapConversions.java @@ -54,29 +54,29 @@ * limitations under the License. */ final class MapConversions { - private static final String V = "_v"; - private static final String VALUE = "value"; - private static final String DATE = "date"; - private static final String TIME = "time"; - private static final String ZONE = "zone"; - private static final String YEAR = "year"; - private static final String YEARS = "years"; - private static final String MONTH = "month"; - private static final String MONTHS = "months"; - private static final String DAY = "day"; - private static final String DAYS = "days"; - private static final String HOUR = "hour"; - private static final String HOURS = "hours"; - private static final String MINUTE = "minute"; - private static final String MINUTES = "minutes"; - private static final String SECOND = "second"; - private static final String SECONDS = "seconds"; - private static final String NANO = "nano"; - private static final String NANOS = "nanos"; - private static final String OFFSET_HOUR = "offsetHour"; - private static final String OFFSET_MINUTE = "offsetMinute"; - private static final String MOST_SIG_BITS = "mostSigBits"; - private static final String LEAST_SIG_BITS = "leastSigBits"; + static final String V = "_v"; + static final String VALUE = "value"; + static final String DATE = "date"; + static final String TIME = "time"; + static final String ZONE = "zone"; + static final String YEAR = "year"; + static final String YEARS = "years"; + static final String MONTH = "month"; + static final String MONTHS = "months"; + static final String DAY = "day"; + static final String DAYS = "days"; + static final String HOUR = "hour"; + static final String HOURS = "hours"; + static final String MINUTE = "minute"; + static final String MINUTES = "minutes"; + static final String SECOND = "second"; + static final String SECONDS = "seconds"; + static final String NANO = "nano"; + static final String NANOS = "nanos"; + static final String OFFSET_HOUR = "offsetHour"; + static final String OFFSET_MINUTE = "offsetMinute"; + static final String MOST_SIG_BITS = "mostSigBits"; + static final String LEAST_SIG_BITS = "leastSigBits"; static final String OFFSET = "offset"; diff --git a/src/main/java/com/cedarsoftware/util/convert/VoidConversions.java b/src/main/java/com/cedarsoftware/util/convert/VoidConversions.java index d23967ce..1c53dc2f 100644 --- a/src/main/java/com/cedarsoftware/util/convert/VoidConversions.java +++ b/src/main/java/com/cedarsoftware/util/convert/VoidConversions.java @@ -28,7 +28,7 @@ static Boolean toBoolean(Object from, Converter converter) { return Boolean.FALSE; } - static Character toChar(Object from, Converter converter) { + static Character toCharacter(Object from, Converter converter) { return Character.MIN_VALUE; } } diff --git a/src/main/java/com/cedarsoftware/util/convert/YearConversions.java b/src/main/java/com/cedarsoftware/util/convert/YearConversions.java index a76155d4..519c48b3 100644 --- a/src/main/java/com/cedarsoftware/util/convert/YearConversions.java +++ b/src/main/java/com/cedarsoftware/util/convert/YearConversions.java @@ -3,10 +3,15 @@ import java.math.BigDecimal; import java.math.BigInteger; import java.time.Year; +import java.util.Map; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; +import com.cedarsoftware.util.CompactLinkedMap; + +import static com.cedarsoftware.util.convert.MapConversions.YEAR; + /** * @author Kenny Partlow (kpartlow@gmail.com) *
@@ -54,11 +59,7 @@ static double toDouble(Object from, Converter converter) { static float toFloat(Object from, Converter converter) { return toInt(from, converter); } - - static boolean toBoolean(Object from, Converter converter) { - return toInt(from, converter) == 0; - } - + static AtomicBoolean toAtomicBoolean(Object from, Converter converter) { return new AtomicBoolean(toInt(from, converter) == 0); } @@ -74,4 +75,11 @@ static BigDecimal toBigDecimal(Object from, Converter converter) { static String toString(Object from, Converter converter) { return ((Year)from).toString(); } + + static Map toMap(Object from, Converter converter) { + Year year = (Year) from; + Map map = new CompactLinkedMap<>(); + map.put(YEAR, year.getValue()); + return map; + } } diff --git a/src/test/java/com/cedarsoftware/util/convert/AtomicBooleanConversionsTests.java b/src/test/java/com/cedarsoftware/util/convert/AtomicBooleanConversionsTests.java index 517be299..439feaf6 100644 --- a/src/test/java/com/cedarsoftware/util/convert/AtomicBooleanConversionsTests.java +++ b/src/test/java/com/cedarsoftware/util/convert/AtomicBooleanConversionsTests.java @@ -53,7 +53,7 @@ private static Stream toIntegerParams() { @ParameterizedTest @MethodSource("toIntegerParams") void testToInteger(boolean value, Integer expected) { - Integer actual = AtomicBooleanConversions.toInteger(new AtomicBoolean(value), null); + Integer actual = AtomicBooleanConversions.toInt(new AtomicBoolean(value), null); assertThat(actual).isSameAs(expected); } diff --git a/src/test/java/com/cedarsoftware/util/convert/BooleanConversionsTests.java b/src/test/java/com/cedarsoftware/util/convert/BooleanConversionsTests.java index c5b14635..9b3a69fa 100644 --- a/src/test/java/com/cedarsoftware/util/convert/BooleanConversionsTests.java +++ b/src/test/java/com/cedarsoftware/util/convert/BooleanConversionsTests.java @@ -63,7 +63,7 @@ private static Stream toIntegerParams() { @ParameterizedTest @MethodSource("toIntegerParams") void testToInteger(boolean value, Integer expected) { - Integer actual = BooleanConversions.toInteger(value, null); + Integer actual = BooleanConversions.toInt(value, null); assertThat(actual).isSameAs(expected); } diff --git a/src/test/java/com/cedarsoftware/util/convert/ConverterEverythingTest.java b/src/test/java/com/cedarsoftware/util/convert/ConverterEverythingTest.java index 26775fed..975fdd11 100644 --- a/src/test/java/com/cedarsoftware/util/convert/ConverterEverythingTest.java +++ b/src/test/java/com/cedarsoftware/util/convert/ConverterEverythingTest.java @@ -39,14 +39,13 @@ import java.util.function.Supplier; import java.util.stream.Stream; +import com.cedarsoftware.util.ClassUtilities; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; -import com.cedarsoftware.util.ClassUtilities; - import static com.cedarsoftware.util.MapUtilities.mapOf; import static com.cedarsoftware.util.convert.Converter.getShortName; import static com.cedarsoftware.util.convert.Converter.pair; @@ -1179,6 +1178,249 @@ public ZoneId getZoneId() { { Year.of(2024), 2024d } }); + ///////////////////////////////////////////////////////////// + // Boolean/boolean + ///////////////////////////////////////////////////////////// + TEST_DB.put(pair(Void.class, boolean.class), new Object[][] { + { null, false }, + }); + TEST_DB.put(pair(Void.class, Boolean.class), new Object[][] { + { null, null }, + }); + TEST_DB.put(pair(Byte.class, Boolean.class), new Object[][] { + { (byte) -2, true }, + { (byte) -1, true }, + { (byte) 0, false }, + { (byte) 1, true }, + { (byte) 2, true }, + }); + TEST_DB.put(pair(Short.class, Boolean.class), new Object[][] { + { (short) -2, true }, + { (short) -1, true }, + { (short) 0, false }, + { (short) 1, true }, + { (short) 2, true }, + }); + TEST_DB.put(pair(Integer.class, Boolean.class), new Object[][] { + { -2, true }, + { -1, true }, + { 0, false }, + { 1, true }, + { 2, true }, + }); + TEST_DB.put(pair(Long.class, Boolean.class), new Object[][] { + { -2L, true }, + { -1L, true }, + { 0L, false }, + { 1L, true }, + { 2L, true }, + }); + TEST_DB.put(pair(Float.class, Boolean.class), new Object[][] { + { -2f, true }, + { -1.5f, true }, + { -1f, true }, + { 0f, false }, + { 1f, true }, + { 1.5f, true }, + { 2f, true }, + }); + TEST_DB.put(pair(Double.class, Boolean.class), new Object[][] { + { -2d, true }, + { -1.5d, true }, + { -1d, true }, + { 0d, false }, + { 1d, true }, + { 1.5d, true }, + { 2d, true }, + }); + TEST_DB.put(pair(Boolean.class, Boolean.class), new Object[][] { + { true, true }, + { false, false }, + }); + TEST_DB.put(pair(Character.class, Boolean.class), new Object[][] { + { (char) 1, true }, + { '1', true }, + { '2', false }, + { 'a', false }, + { 'z', false }, + { (char) 0, false }, + { '0', false }, + }); + TEST_DB.put(pair(AtomicBoolean.class, Boolean.class), new Object[][] { + { new AtomicBoolean(true), true }, + { new AtomicBoolean(false), false }, + }); + TEST_DB.put(pair(AtomicInteger.class, Boolean.class), new Object[][] { + { new AtomicInteger(-2), true }, + { new AtomicInteger(-1), true }, + { new AtomicInteger(0), false }, + { new AtomicInteger(1), true }, + { new AtomicInteger(2), true }, + }); + TEST_DB.put(pair(AtomicLong.class, Boolean.class), new Object[][] { + { new AtomicLong(-2), true }, + { new AtomicLong(-1), true }, + { new AtomicLong(0), false }, + { new AtomicLong(1), true }, + { new AtomicLong(2), true }, + }); + TEST_DB.put(pair(BigInteger.class, Boolean.class), new Object[][] { + { BigInteger.valueOf(-2), true }, + { BigInteger.valueOf(-1), true }, + { BigInteger.valueOf(0), false }, + { BigInteger.valueOf(1), true }, + { BigInteger.valueOf(2), true }, + }); + TEST_DB.put(pair(BigDecimal.class, Boolean.class), new Object[][] { + { BigDecimal.valueOf(-2L), true }, + { BigDecimal.valueOf(-1L), true }, + { BigDecimal.valueOf(0L), false }, + { BigDecimal.valueOf(1L), true }, + { BigDecimal.valueOf(2L), true }, + }); + TEST_DB.put(pair(Number.class, Boolean.class), new Object[][] { + { -2, true }, + { -1L, true }, + { 0.0d, false }, + { 1.0f, true }, + { BigInteger.valueOf(2), true }, + }); + TEST_DB.put(pair(Map.class, Boolean.class), new Object[][] { + { mapOf("_v", 16), true }, + { mapOf("_v", 0), false }, + { mapOf("_v", "0"), false }, + { mapOf("_v", "1"), true }, + { mapOf("_v", mapOf("_v", 5.0d)), true }, + }); + TEST_DB.put(pair(String.class, Boolean.class), new Object[][] { + { "0", false }, + { "false", false }, + { "FaLse", false }, + { "FALSE", false }, + { "F", false }, + { "f", false }, + { "1", true }, + { "true", true }, + { "TrUe", true }, + { "TRUE", true }, + { "T", true }, + { "t", true }, + }); + + ///////////////////////////////////////////////////////////// + // Character/char + ///////////////////////////////////////////////////////////// + TEST_DB.put(pair(Void.class, char.class), new Object[][] { + { null, (char) 0 }, + }); + TEST_DB.put(pair(Void.class, Character.class), new Object[][] { + { null, null }, + }); + TEST_DB.put(pair(Byte.class, Character.class), new Object[][] { + { (byte) -1, new IllegalArgumentException("Value '-1' out of range to be converted to character"), }, + { (byte) 0, (char) 0, true }, + { (byte) 1, (char) 1, true }, + { Byte.MAX_VALUE, (char) Byte.MAX_VALUE, true }, + }); + TEST_DB.put(pair(Short.class, Character.class), new Object[][] { + { (short) -1, new IllegalArgumentException("Value '-1' out of range to be converted to character"), }, + { (short) 0, (char) 0, true }, + { (short) 1, (char) 1, true }, + { Short.MAX_VALUE, (char) Short.MAX_VALUE, true }, + }); + TEST_DB.put(pair(Integer.class, Character.class), new Object[][] { + { -1, new IllegalArgumentException("Value '-1' out of range to be converted to character"), }, + { 0, (char) 0, true }, + { 1, (char) 1, true }, + { 65535, (char) 65535, true }, + { 65536, new IllegalArgumentException("Value '65536' out of range to be converted to character") }, + }); + TEST_DB.put(pair(Long.class, Character.class), new Object[][] { + { -1L, new IllegalArgumentException("Value '-1' out of range to be converted to character"), }, + { 0L, (char) 0L, true }, + { 1L, (char) 1L, true }, + { 65535L, (char) 65535L, true }, + { 65536L, new IllegalArgumentException("Value '65536' out of range to be converted to character") }, + }); + TEST_DB.put(pair(Float.class, Character.class), new Object[][] { + { -1f, new IllegalArgumentException("Value '-1' out of range to be converted to character"), }, + { 0f, (char) 0, true }, + { 1f, (char) 1, true }, + { 65535f, (char) 65535f, true }, + { 65536f, new IllegalArgumentException("Value '65536' out of range to be converted to character") }, + }); + TEST_DB.put(pair(Double.class, Character.class), new Object[][] { + { -1d, new IllegalArgumentException("Value '-1' out of range to be converted to character") }, + { 0d, (char) 0, true }, + { 1d, (char) 1, true }, + { 65535d, (char) 65535d, true }, + { 65536d, new IllegalArgumentException("Value '65536' out of range to be converted to character") }, + }); + TEST_DB.put(pair(Boolean.class, Character.class), new Object[][] { + { false, (char) 0, true }, + { true, (char) 1, true }, + }); + TEST_DB.put(pair(Character.class, Character.class), new Object[][] { + { (char) 0, (char) 0, true }, + { (char) 1, (char) 1, true }, + { (char) 65535, (char) 65535, true }, + }); + TEST_DB.put(pair(AtomicBoolean.class, Character.class), new Object[][] { + { new AtomicBoolean(true), (char) 1 }, // can't run reverse because equals() on AtomicBoolean is not implemented, it needs .get() called first. + { new AtomicBoolean(false), (char) 0 }, + }); + TEST_DB.put(pair(AtomicInteger.class, Character.class), new Object[][] { + { new AtomicInteger(-1), new IllegalArgumentException("Value '-1' out of range to be converted to character") }, + { new AtomicInteger(0), (char) 0 }, + { new AtomicInteger(1), (char) 1 }, + { new AtomicInteger(65535), (char) 65535 }, + { new AtomicInteger(65536), new IllegalArgumentException("Value '65536' out of range to be converted to character") }, + }); + TEST_DB.put(pair(AtomicLong.class, Character.class), new Object[][] { + { new AtomicLong(-1), new IllegalArgumentException("Value '-1' out of range to be converted to character") }, + { new AtomicLong(0), (char) 0 }, + { new AtomicLong(1), (char) 1 }, + { new AtomicLong(65535), (char) 65535 }, + { new AtomicLong(65536), new IllegalArgumentException("Value '65536' out of range to be converted to character") }, + }); + TEST_DB.put(pair(BigInteger.class, Character.class), new Object[][] { + { BigInteger.valueOf(-1), new IllegalArgumentException("Value '-1' out of range to be converted to character") }, + { BigInteger.valueOf(0), (char) 0, true }, + { BigInteger.valueOf(1), (char) 1, true }, + { BigInteger.valueOf(65535), (char) 65535, true }, + { BigInteger.valueOf(65536), new IllegalArgumentException("Value '65536' out of range to be converted to character") }, + }); + TEST_DB.put(pair(BigDecimal.class, Character.class), new Object[][] { + { BigDecimal.valueOf(-1), new IllegalArgumentException("Value '-1' out of range to be converted to character") }, + { BigDecimal.valueOf(0), (char) 0, true }, + { BigDecimal.valueOf(1), (char) 1, true }, + { BigDecimal.valueOf(65535), (char) 65535, true }, + { BigDecimal.valueOf(65536), new IllegalArgumentException("Value '65536' out of range to be converted to character") }, + }); + TEST_DB.put(pair(Number.class, Character.class), new Object[][] { + { BigDecimal.valueOf(-1), new IllegalArgumentException("Value '-1' out of range to be converted to character") }, + { BigDecimal.valueOf(0), (char) 0 }, + { BigInteger.valueOf(1), (char) 1 }, + { BigInteger.valueOf(65535), (char) 65535 }, + { BigInteger.valueOf(65536), new IllegalArgumentException("Value '65536' out of range to be converted to character") }, + }); + TEST_DB.put(pair(Map.class, Character.class), new Object[][] { + { mapOf("_v", -1), new IllegalArgumentException("Value '-1' out of range to be converted to character") }, + { mapOf("value", 0), (char) 0 }, + { mapOf("_v", 1), (char) 1 }, + { mapOf("_v", 65535), (char) 65535 }, + { mapOf("_v", mapOf("_v", 65535)), (char) 65535 }, + { mapOf("_v", "0"), (char) 48 }, + { mapOf("_v", 65536), new IllegalArgumentException("Value '65536' out of range to be converted to character") }, + }); + TEST_DB.put(pair(String.class, Character.class), new Object[][] { + { "0", '0', true }, + { "A", 'A', true }, + { "{", '{', true }, + { "\uD83C", '\uD83C', true }, + { "\uFFFF", '\uFFFF', true }, + }); + ///////////////////////////////////////////////////////////// // Instant ///////////////////////////////////////////////////////////// @@ -1294,7 +1536,7 @@ public ZoneId getZoneId() { { null, null }, }); TEST_DB.put(pair(Year.class, Year.class), new Object[][] { - { Year.of(1970), Year.of(1970) }, + { Year.of(1970), Year.of(1970), true }, }); TEST_DB.put(pair(String.class, Year.class), new Object[][] { { "1970", Year.of(1970), true }, @@ -1307,7 +1549,7 @@ public ZoneId getZoneId() { TEST_DB.put(pair(Map.class, Year.class), new Object[][] { { mapOf("_v", "1984"), Year.of(1984) }, { mapOf("value", 1984L), Year.of(1984) }, - { mapOf("year", 1492), Year.of(1492) }, + { mapOf("year", 1492), Year.of(1492), true }, { mapOf("year", mapOf("_v", (short) 2024)), Year.of(2024) }, // recursion }); TEST_DB.put(pair(Number.class, Year.class), new Object[][] { @@ -1680,6 +1922,8 @@ void before() { void testForMissingTests() { Map, Set>> map = converter.allSupportedConversions(); int neededTests = 0; + int conversionPairCount = 0; + int testCount = 0; for (Map.Entry, Set>> entry : map.entrySet()) { Class sourceClass = entry.getKey(); @@ -1687,18 +1931,23 @@ void testForMissingTests() { for (Class targetClass : targetClasses) { Object[][] testData = TEST_DB.get(pair(sourceClass, targetClass)); + conversionPairCount++; if (testData == null) { // data set needs added // Change to throw exception, so that when new conversions are added, the tests will fail until // an "everything" test entry is added. System.err.println("No test data for: " + getShortName(sourceClass) + " ==> " + getShortName(targetClass)); neededTests++; + } else { + testCount += testData.length; } } } + System.out.println("Total conversion pairs = " + conversionPairCount); + System.out.println("Total tests = " + testCount); if (neededTests > 0) { - System.err.println(neededTests + " tests need to be added."); + System.err.println("Conversion pairs not tested = " + neededTests); System.err.flush(); // fail(neededTests + " tests need to be added."); } @@ -1831,6 +2080,4 @@ void testConvertReverse(String shortNameSource, String shortNameTarget, Object s } } } - - }