From 46a05b1d449ee396728f5a347929435b3287430e Mon Sep 17 00:00:00 2001 From: John DeRegnaucourt Date: Mon, 26 Feb 2024 23:38:31 -0500 Subject: [PATCH] Everything tests for converter now captures which pairs have been tested (forward or reverse) and outputs which tests have not been run at all, in deterministic (alphabetical) order. Fixed the CharSequence issues of StringUtilities. Method signatures changed to CharSequence break existing users, as method signatures are statically bound, not dynamically bound, which means changing String parameters to CharSequence paramerters after the fact is a breaking API change. --- .../util/FastByteArrayOutputStream.java | 8 +- .../cedarsoftware/util/StringUtilities.java | 314 ++--- .../util/TestStringUtilities.java | 51 +- .../util/convert/ConverterEverythingTest.java | 1110 ++++++++--------- 4 files changed, 634 insertions(+), 849 deletions(-) diff --git a/src/main/java/com/cedarsoftware/util/FastByteArrayOutputStream.java b/src/main/java/com/cedarsoftware/util/FastByteArrayOutputStream.java index 0c925836..365e81e9 100644 --- a/src/main/java/com/cedarsoftware/util/FastByteArrayOutputStream.java +++ b/src/main/java/com/cedarsoftware/util/FastByteArrayOutputStream.java @@ -56,14 +56,12 @@ private void grow(int minCapacity) { buf = Arrays.copyOf(buf, newCapacity); } - @Override public void write(int b) { ensureCapacity(count + 1); buf[count] = (byte) b; count += 1; } - @Override public void write(byte[] b, int off, int len) { if ((b == null) || (off < 0) || (len < 0) || (off > b.length) || (off + len > b.length) || (off + len < 0)) { @@ -86,6 +84,11 @@ public byte[] toByteArray() { return Arrays.copyOf(buf, count); } + // Backwards compatibility + public byte[] getBuffer() { + return Arrays.copyOf(buf, count); + } + public int size() { return count; } @@ -98,7 +101,6 @@ public void writeTo(OutputStream out) throws IOException { out.write(buf, 0, count); } - @Override public void close() throws IOException { // No resources to close } diff --git a/src/main/java/com/cedarsoftware/util/StringUtilities.java b/src/main/java/com/cedarsoftware/util/StringUtilities.java index f70ef6b4..51f7eba5 100644 --- a/src/main/java/com/cedarsoftware/util/StringUtilities.java +++ b/src/main/java/com/cedarsoftware/util/StringUtilities.java @@ -24,22 +24,19 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -public final class StringUtilities -{ - private static final char[] _hex = { +public final class StringUtilities { + private static char[] _hex = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; - public static final String FOLDER_SEPARATOR = "/"; + public static String FOLDER_SEPARATOR = "/"; - public static final String EMPTY = ""; + public static String EMPTY = ""; /** *

Constructor is declared private since all methods are static.

*/ - private StringUtilities() - { - super(); + private StringUtilities() { } /** @@ -49,12 +46,12 @@ private StringUtilities() *

{@code null}s are handled without exceptions. Two {@code null} * references are considered to be equal. The comparison is case-sensitive.

* - * @param cs1 the first CharSequence, may be {@code null} - * @param cs2 the second CharSequence, may be {@code null} + * @param cs1 the first CharSequence, may be {@code null} + * @param cs2 the second CharSequence, may be {@code null} * @return {@code true} if the CharSequences are equal (case-sensitive), or both {@code null} * @see #equalsIgnoreCase(CharSequence, CharSequence) */ - public static boolean equals(final CharSequence cs1, final CharSequence cs2) { + public static boolean equals(CharSequence cs1, CharSequence cs2) { if (cs1 == cs2) { return true; } @@ -68,7 +65,7 @@ public static boolean equals(final CharSequence cs1, final CharSequence cs2) { return cs1.equals(cs2); } // Step-wise comparison - final int length = cs1.length(); + int length = cs1.length(); for (int i = 0; i < length; i++) { if (cs1.charAt(i) != cs2.charAt(i)) { return false; @@ -77,6 +74,13 @@ public static boolean equals(final CharSequence cs1, final CharSequence cs2) { return true; } + /** + * @see StringUtilities#equals(CharSequence, CharSequence) + */ + public static boolean equals(String s1, String s2) { + return equals((CharSequence) s1, (CharSequence) s2); + } + /** * Compares two CharSequences, returning {@code true} if they represent * equal sequences of characters, ignoring case. @@ -84,12 +88,12 @@ public static boolean equals(final CharSequence cs1, final CharSequence cs2) { *

{@code null}s are handled without exceptions. Two {@code null} * references are considered equal. The comparison is case insensitive.

* - * @param cs1 the first CharSequence, may be {@code null} - * @param cs2 the second CharSequence, may be {@code null} + * @param cs1 the first CharSequence, may be {@code null} + * @param cs2 the second CharSequence, may be {@code null} * @return {@code true} if the CharSequences are equal (case-insensitive), or both {@code null} * @see #equals(CharSequence, CharSequence) */ - public static boolean equalsIgnoreCase(final CharSequence cs1, final CharSequence cs2) { + public static boolean equalsIgnoreCase(CharSequence cs1, CharSequence cs2) { if (cs1 == cs2) { return true; } @@ -102,19 +106,26 @@ public static boolean equalsIgnoreCase(final CharSequence cs1, final CharSequenc return regionMatches(cs1, true, 0, cs2, 0, cs1.length()); } + /** + * @see StringUtilities@equalsIgnoreCase(CharSequence, CharSequence) + */ + public static boolean equalsIgnoreCase(String s1, String s2) { + return equalsIgnoreCase((CharSequence) s1, (CharSequence) s2); + } + /** * Green implementation of regionMatches. * - * @param cs the {@link CharSequence} to be processed - * @param ignoreCase whether or not to be case-insensitive - * @param thisStart the index to start on the {@code cs} CharSequence - * @param substring the {@link CharSequence} to be looked for - * @param start the index to start on the {@code substring} CharSequence - * @param length character length of the region + * @param cs the {@link CharSequence} to be processed + * @param ignoreCase whether to be case-insensitive + * @param thisStart the index to start on the {@code cs} CharSequence + * @param substring the {@link CharSequence} to be looked for + * @param start the index to start on the {@code substring} CharSequence + * @param length character length of the region * @return whether the region matched */ - static boolean regionMatches(final CharSequence cs, final boolean ignoreCase, final int thisStart, - final CharSequence substring, final int start, final int length) { + static boolean regionMatches(CharSequence cs, boolean ignoreCase, int thisStart, + CharSequence substring, int start, int length) { Convention.throwIfNull(cs, "cs to be processed cannot be null"); Convention.throwIfNull(substring, "substring cannot be null"); @@ -126,8 +137,8 @@ static boolean regionMatches(final CharSequence cs, final boolean ignoreCase, fi int tmpLen = length; // Extract these first so we detect NPEs the same as the java.lang.String version - final int srcLen = cs.length() - thisStart; - final int otherLen = substring.length() - start; + int srcLen = cs.length() - thisStart; + int otherLen = substring.length() - start; // Check for invalid parameters if (thisStart < 0 || start < 0 || length < 0) { @@ -140,8 +151,8 @@ static boolean regionMatches(final CharSequence cs, final boolean ignoreCase, fi } while (tmpLen-- > 0) { - final char c1 = cs.charAt(index1++); - final char c2 = substring.charAt(index2++); + char c1 = cs.charAt(index1++); + char c2 = substring.charAt(index2++); if (c1 == c2) { continue; @@ -152,8 +163,8 @@ static boolean regionMatches(final CharSequence cs, final boolean ignoreCase, fi } // The real same check as in String.regionMatches(): - final char u1 = Character.toUpperCase(c1); - final char u2 = Character.toUpperCase(c2); + char u1 = Character.toUpperCase(c1); + char u2 = Character.toUpperCase(c2); if (u1 != u2 && Character.toLowerCase(u1) != Character.toLowerCase(u2)) { return false; } @@ -162,19 +173,15 @@ static boolean regionMatches(final CharSequence cs, final boolean ignoreCase, fi return true; } - public static boolean equalsWithTrim(final String s1, final String s2) - { - if (s1 == null || s2 == null) - { + public static boolean equalsWithTrim(String s1, String s2) { + if (s1 == null || s2 == null) { return s1 == s2; } return s1.trim().equals(s2.trim()); } - public static boolean equalsIgnoreCaseWithTrim(final String s1, final String s2) - { - if (s1 == null || s2 == null) - { + public static boolean equalsIgnoreCaseWithTrim(String s1, String s2) { + if (s1 == null || s2 == null) { return s1 == s2; } return s1.trim().equalsIgnoreCase(s2.trim()); @@ -183,33 +190,28 @@ public static boolean equalsIgnoreCaseWithTrim(final String s1, final String s2) /** * Checks if a CharSequence is empty (""), null, or only whitespace. * - * @param cs the CharSequence to check, may be null + * @param cs the CharSequence to check, may be null * @return {@code true} if the CharSequence is empty or null */ - public static boolean isEmpty(CharSequence cs) - { + public static boolean isEmpty(CharSequence cs) { return isWhitespace(cs); } /** - * Checks if a CharSequence is not empty (""), not null and not whitespace only. - * - * @param cs the CharSequence to check, may be null - * @return {@code true} if the CharSequence is - * not empty and not null and not whitespace only + * @see StringUtilities#isEmpty(CharSequence) */ - public static boolean isNotWhitespace(final CharSequence cs) { - return !isWhitespace(cs); + public static boolean isEmpty(String s) { + return isWhitespace(s); } /** * Checks if a CharSequence is empty (""), null or whitespace only. * - * @param cs the CharSequence to check, may be null + * @param cs the CharSequence to check, may be null * @return {@code true} if the CharSequence is null, empty or whitespace only */ - public static boolean isWhitespace(final CharSequence cs) { - final int strLen = length(cs); + public static boolean isWhitespace(CharSequence cs) { + int strLen = length(cs); if (strLen == 0) { return true; } @@ -222,24 +224,14 @@ public static boolean isWhitespace(final CharSequence cs) { } /** - * Checks if a CharSequence is not null, not empty (""), and not only whitespace. - * - * @param cs the CharSequence to check, may be null - * @return {@code true} if the CharSequence is not empty and not null - */ - public static boolean isNotEmpty(final CharSequence cs) { - return !isWhitespace(cs); - } - - /** - * Checks if a CharSequence is not empty (""), not null and not whitespace only. + * Checks if a String is not empty (""), not null and not whitespace only. * - * @param cs the CharSequence to check, may be null + * @param s the CharSequence to check, may be null * @return {@code true} if the CharSequence is - * not empty and not null and not whitespace only + * not empty and not null and not whitespace only */ - public static boolean hasContent(final CharSequence cs) { - return !isWhitespace(cs); + public static boolean hasContent(String s) { + return !isWhitespace(s); } /** @@ -248,15 +240,22 @@ public static boolean hasContent(final CharSequence cs) { * @param cs a CharSequence or {@code null} * @return CharSequence length or {@code 0} if the CharSequence is {@code null}. */ - public static int length(final CharSequence cs) { + public static int length(CharSequence cs) { return cs == null ? 0 : cs.length(); } + /** + * @see StringUtilities#length(CharSequence) + */ + public static int length(String s) { + return s == null ? 0 : s.length(); + } + /** * @param s a String or {@code null} * @return the trimmed length of the String or 0 if the string is null. */ - public static int trimLength(final String s) { + public static int trimLength(String s) { return trimToEmpty(s).length(); } @@ -271,19 +270,16 @@ public static int lastIndexOf(String path, char ch) { // Turn hex String into byte[] // If string is not even length, return null. - public static byte[] decode(String s) - { - final int len = s.length(); - if (len % 2 != 0) - { + public static byte[] decode(String s) { + int len = s.length(); + if (len % 2 != 0) { return null; } byte[] bytes = new byte[len / 2]; int pos = 0; - for (int i = 0; i < len; i += 2) - { + for (int i = 0; i < len; i += 2) { byte hi = (byte) Character.digit(s.charAt(i), 16); byte lo = (byte) Character.digit(s.charAt(i + 1), 16); bytes[pos++] = (byte) (hi * 16 + lo); @@ -298,11 +294,9 @@ public static byte[] decode(String s) * * @param bytes array representation */ - public static String encode(byte[] bytes) - { + public static String encode(byte[] bytes) { StringBuilder sb = new StringBuilder(bytes.length << 1); - for (byte aByte : bytes) - { + for (byte aByte : bytes) { sb.append(convertDigit(aByte >> 4)); sb.append(convertDigit(aByte & 0x0f)); } @@ -315,66 +309,56 @@ public static String encode(byte[] bytes) * @param value to be converted * @return '0'..'F' in char format. */ - private static char convertDigit(int value) - { + private static char convertDigit(int value) { return _hex[value & 0x0f]; } - public static int count(String s, char c) - { - return count (s, EMPTY + c); + public static int count(String s, char c) { + return count(s, EMPTY + c); } /** * Count the number of times that 'token' occurs within 'content'. + * * @return int count (0 if it never occurs, null is the source string, or null is the token). */ - public static int count(CharSequence content, CharSequence token) - { - if (content == null || token == null) - { + public static int count(CharSequence content, CharSequence token) { + if (content == null || token == null) { return 0; } String source = content.toString(); - if (source.isEmpty()) - { + if (source.isEmpty()) { return 0; } String sub = token.toString(); - if (sub.isEmpty()) - { + if (sub.isEmpty()) { return 0; } int answer = 0; int idx = 0; - while (true) - { + while (true) { idx = source.indexOf(sub, idx); - if (idx < answer) - { + if (idx < answer) { return answer; } - answer = ++answer; - idx = ++idx; + ++answer; + ++idx; } } /** * Convert strings containing DOS-style '*' or '?' to a regex String. */ - public static String wildcardToRegexString(String wildcard) - { - final int len = wildcard.length(); + public static String wildcardToRegexString(String wildcard) { + int len = wildcard.length(); StringBuilder s = new StringBuilder(len); s.append('^'); - for (int i = 0; i < len; i++) - { + for (int i = 0; i < len; i++) { char c = wildcard.charAt(i); - switch (c) - { + switch (c) { case '*': s.append(".*"); break; @@ -418,15 +402,11 @@ public static String wildcardToRegexString(String wildcard) * @param t String two * @return the 'edit distance' (Levenshtein distance) between the two strings. */ - public static int levenshteinDistance(CharSequence s, CharSequence t) - { - // degenerate cases s - if (s == null || EMPTY.equals(s)) - { - return t == null || EMPTY.equals(t) ? 0 : t.length(); - } - else if (t == null || EMPTY.equals(t)) - { + public static int levenshteinDistance(CharSequence s, CharSequence t) { + // degenerate cases + if (s == null || EMPTY.contentEquals(s)) { + return t == null || EMPTY.contentEquals(t) ? 0 : t.length(); + } else if (t == null || EMPTY.contentEquals(t)) { return s.length(); } @@ -437,15 +417,13 @@ else if (t == null || EMPTY.equals(t)) // initialize v0 (the previous row of distances) // this row is A[0][i]: edit distance for an empty s // the distance is just the number of characters to delete from t - for (int i = 0; i < v0.length; i++) - { + for (int i = 0; i < v0.length; i++) { v0[i] = i; } int sLen = s.length(); int tLen = t.length(); - for (int i = 0; i < sLen; i++) - { + for (int i = 0; i < sLen; i++) { // calculate v1 (current row distances) from the previous row v0 // first element of v1 is A[i+1][0] @@ -453,8 +431,7 @@ else if (t == null || EMPTY.equals(t)) v1[0] = i + 1; // use formula to fill in the rest of the row - for (int j = 0; j < tLen; j++) - { + for (int j = 0; j < tLen; j++) { int cost = (s.charAt(i) == t.charAt(j)) ? 0 : 1; v1[j + 1] = (int) MathUtilities.minimum(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost); } @@ -480,14 +457,10 @@ else if (t == null || EMPTY.equals(t)) * to make the source string identical to the target * string */ - public static int damerauLevenshteinDistance(CharSequence source, CharSequence target) - { - if (source == null || EMPTY.equals(source)) - { - return target == null || EMPTY.equals(target) ? 0 : target.length(); - } - else if (target == null || EMPTY.equals(target)) - { + public static int damerauLevenshteinDistance(CharSequence source, CharSequence target) { + if (source == null || EMPTY.contentEquals(source)) { + return target == null || EMPTY.contentEquals(target) ? 0 : target.length(); + } else if (target == null || EMPTY.contentEquals(target)) { return source.length(); } @@ -498,25 +471,21 @@ else if (target == null || EMPTY.equals(target)) // We need indexers from 0 to the length of the source string. // This sequential set of numbers will be the row "headers" // in the matrix. - for (int srcIndex = 0; srcIndex <= srcLen; srcIndex++) - { + for (int srcIndex = 0; srcIndex <= srcLen; srcIndex++) { distanceMatrix[srcIndex][0] = srcIndex; } // We need indexers from 0 to the length of the target string. // This sequential set of numbers will be the // column "headers" in the matrix. - for (int targetIndex = 0; targetIndex <= targetLen; targetIndex++) - { + for (int targetIndex = 0; targetIndex <= targetLen; targetIndex++) { // Set the value of the first cell in the column // equivalent to the current value of the iterator distanceMatrix[0][targetIndex] = targetIndex; } - for (int srcIndex = 1; srcIndex <= srcLen; srcIndex++) - { - for (int targetIndex = 1; targetIndex <= targetLen; targetIndex++) - { + for (int srcIndex = 1; srcIndex <= srcLen; srcIndex++) { + for (int targetIndex = 1; targetIndex <= targetLen; targetIndex++) { // If the current characters in both strings are equal int cost = source.charAt(srcIndex - 1) == target.charAt(targetIndex - 1) ? 0 : 1; @@ -535,15 +504,13 @@ else if (target == null || EMPTY.equals(target)) // We don't want to do the next series of calculations on // the first pass because we would get an index out of bounds // exception. - if (srcIndex == 1 || targetIndex == 1) - { + if (srcIndex == 1 || targetIndex == 1) { continue; } // transposition check (if the current and previous // character are switched around (e.g.: t[se]t and t[es]t)... - if (source.charAt(srcIndex - 1) == target.charAt(targetIndex - 2) && source.charAt(srcIndex - 2) == target.charAt(targetIndex - 1)) - { + if (source.charAt(srcIndex - 1) == target.charAt(targetIndex - 2) && source.charAt(srcIndex - 2) == target.charAt(targetIndex - 1)) { // What's the minimum cost between the current distance // and a transposition. distanceMatrix[srcIndex][targetIndex] = (int) MathUtilities.minimum( @@ -564,22 +531,19 @@ else if (target == null || EMPTY.equals(target)) * @param maxLen maximum number of characters * @return String of alphabetical characters, with the first character uppercase (Proper case strings). */ - public static String getRandomString(Random random, int minLen, int maxLen) - { + public static String getRandomString(Random random, int minLen, int maxLen) { StringBuilder s = new StringBuilder(); - final int len = minLen + random.nextInt(maxLen - minLen + 1); + int len = minLen + random.nextInt(maxLen - minLen + 1); - for (int i=0; i < len; i++) - { + for (int i = 0; i < len; i++) { s.append(getRandomChar(random, i == 0)); } return s.toString(); } - public static String getRandomChar(Random random, boolean upper) - { + public static String getRandomChar(Random random, boolean upper) { int r = random.nextInt(26); - return upper ? EMPTY + (char)((int)'A' + r) : EMPTY + (char)((int)'a' + r); + return upper ? EMPTY + (char) ((int) 'A' + r) : EMPTY + (char) ((int) 'a' + r); } /** @@ -591,14 +555,11 @@ public static String getRandomChar(Random random, boolean upper) * @param s string to encode into bytes * @param encoding encoding to use */ - public static byte[] getBytes(String s, String encoding) - { - try - { + public static byte[] getBytes(String s, String encoding) { + try { return s == null ? null : s.getBytes(encoding); } - catch (UnsupportedEncodingException e) - { + catch (UnsupportedEncodingException e) { throw new IllegalArgumentException(String.format("Encoding (%s) is not supported by your JVM", encoding), e); } } @@ -611,18 +572,16 @@ public static byte[] getBytes(String s, String encoding) * * @param bytes bytes to encode into a string */ - public static String createUtf8String(byte[] bytes) - { + public static String createUtf8String(byte[] bytes) { return createString(bytes, "UTF-8"); } /** * Convert a String into a byte[] encoded by UTF-8. * - * @param s string to encode into bytes + * @param s string to encode into bytes */ - public static byte[] getUTF8Bytes(String s) - { + public static byte[] getUTF8Bytes(String s) { return getBytes(s, "UTF-8"); } @@ -635,14 +594,11 @@ public static byte[] getUTF8Bytes(String s) * @param bytes bytes to encode into a string * @param encoding encoding to use */ - public static String createString(byte[] bytes, String encoding) - { - try - { + public static String createString(byte[] bytes, String encoding) { + try { return bytes == null ? null : new String(bytes, encoding); } - catch (UnsupportedEncodingException e) - { + catch (UnsupportedEncodingException e) { throw new IllegalArgumentException(String.format("Encoding (%s) is not supported by your JVM", encoding), e); } } @@ -650,30 +606,27 @@ public static String createString(byte[] bytes, String encoding) /** * Convert a byte[] into a UTF-8 encoded String. * - * @param bytes bytes to encode into a string + * @param bytes bytes to encode into a string */ - public static String createUTF8String(byte[] bytes) - { + public static String createUTF8String(byte[] bytes) { return createString(bytes, "UTF-8"); } /** * Get the hashCode of a String, insensitive to case, without any new Strings * being created on the heap. + * * @param s String input * @return int hashCode of input String insensitive to case */ - public static int hashCodeIgnoreCase(String s) - { - if (s == null) - { + public static int hashCodeIgnoreCase(String s) { + if (s == null) { return 0; } - final int len = s.length(); + int len = s.length(); int hash = 0; - for (int i = 0; i < len; i++) - { - hash = 31 * hash + Character.toLowerCase((int)s.charAt(i)); + for (int i = 0; i < len; i++) { + hash = 31 * hash + Character.toLowerCase((int) s.charAt(i)); } return hash; } @@ -686,15 +639,16 @@ public static int hashCodeIgnoreCase(String s) *

The String is trimmed using {@link String#trim()}. * Trim removes start and end characters <= 32. * - * @param str the String to be trimmed, may be null + * @param str the String to be trimmed, may be null * @return the trimmed string, {@code null} if null String input */ - public static String trim(final String str) { + public static String trim(String str) { return str == null ? null : str.trim(); } /** * Trims a string, its null safe and null will return empty string here.. + * * @param value string input * @return String trimmed string, if value was null this will be empty */ @@ -704,17 +658,19 @@ public static String trimToEmpty(String value) { /** * Trims a string, If the string trims to empty then we return null. + * * @param value string input * @return String, trimmed from value. If the value was empty we return null. */ public static String trimToNull(String value) { - final String ts = trim(value); + String ts = trim(value); return isEmpty(ts) ? null : ts; } /** * Trims a string, If the string trims to empty then we return the default. - * @param value string input + * + * @param value string input * @param defaultValue value to return on empty or null * @return trimmed string, or defaultValue when null or empty */ diff --git a/src/test/java/com/cedarsoftware/util/TestStringUtilities.java b/src/test/java/com/cedarsoftware/util/TestStringUtilities.java index 7bd2c0a0..37a5e493 100644 --- a/src/test/java/com/cedarsoftware/util/TestStringUtilities.java +++ b/src/test/java/com/cedarsoftware/util/TestStringUtilities.java @@ -1,22 +1,18 @@ package com.cedarsoftware.util; +import javax.swing.text.Segment; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; -import java.nio.ByteBuffer; import java.util.Random; import java.util.Set; import java.util.TreeSet; import java.util.stream.Stream; -import com.cedarsoftware.util.convert.CommonValues; 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 org.junit.jupiter.params.provider.NullAndEmptySource; -import org.mockito.internal.util.StringUtil; - -import javax.swing.text.Segment; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatExceptionOfType; @@ -80,28 +76,7 @@ void testIsEmpty_whenNullOrEmpty_returnsTrue(String s) { assertTrue(StringUtilities.isEmpty(s)); } - - @ParameterizedTest - @MethodSource("stringsWithAllWhitespace") - void testIsNotEmpty_whenStringHasOnlyWhitespace_returnsFalse(String s) - { - assertFalse(StringUtilities.isNotEmpty(s)); - } - - @ParameterizedTest - @MethodSource("stringsWithContentOtherThanWhitespace") - void testIsNotEmpty_whenStringHasContent_returnsTrue(String s) - { - assertTrue(StringUtilities.isNotEmpty(s)); - } - - @ParameterizedTest - @NullAndEmptySource - void testIsNotEmpty_whenNullOrEmpty_returnsFalse(String s) - { - assertFalse(StringUtilities.isNotEmpty(s)); - } - + @ParameterizedTest @MethodSource("stringsWithAllWhitespace") void testIsWhiteSpace_whenStringHasWhitespace_returnsTrue(String s) @@ -144,27 +119,7 @@ void testHasContent_whenNullOrEmpty_returnsFalse(String s) { assertFalse(StringUtilities.hasContent(s)); } - - @ParameterizedTest - @MethodSource("stringsWithAllWhitespace") - void testIsNotWhitespace_whenStringHasWhitespace_returnsFalse(String s) - { - assertFalse(StringUtilities.isNotWhitespace(s)); - } - - @ParameterizedTest - @MethodSource("stringsWithContentOtherThanWhitespace") - void testIsNotWhitespace_whenStringHasContent_returnsTrue(String s) - { - assertTrue(StringUtilities.isNotWhitespace(s)); - } - - @ParameterizedTest - @NullAndEmptySource - void testIsNotWhitespace_whenNullOrEmpty_returnsFalse(String s) - { - assertFalse(StringUtilities.isNotWhitespace(s)); - } + @Test public void testIsEmpty() { diff --git a/src/test/java/com/cedarsoftware/util/convert/ConverterEverythingTest.java b/src/test/java/com/cedarsoftware/util/convert/ConverterEverythingTest.java index 8e873933..4f21e839 100644 --- a/src/test/java/com/cedarsoftware/util/convert/ConverterEverythingTest.java +++ b/src/test/java/com/cedarsoftware/util/convert/ConverterEverythingTest.java @@ -31,6 +31,7 @@ import java.util.Map; import java.util.Set; import java.util.TimeZone; +import java.util.TreeSet; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.atomic.AtomicBoolean; @@ -40,14 +41,14 @@ import java.util.stream.Stream; import com.cedarsoftware.util.ClassUtilities; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; 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 static com.cedarsoftware.util.MapUtilities.mapOf; -import static com.cedarsoftware.util.convert.Converter.getShortName; import static com.cedarsoftware.util.convert.Converter.pair; import static org.assertj.core.api.Assertions.assertThatExceptionOfType; import static org.junit.jupiter.api.Assertions.assertEquals; @@ -82,6 +83,7 @@ public ZoneId getZoneId() { } }; private static final Map, Class>, Object[][]> TEST_DB = new ConcurrentHashMap<>(500, .8f); + private static final Map, Class>, Boolean> STAT_DB = new ConcurrentHashMap<>(500, .8f); static { // Useful values for input @@ -124,25 +126,25 @@ private static void loadAtomicLongTests() { {null, null} }); TEST_DB.put(pair(Instant.class, AtomicLong.class), new Object[][]{ - { Instant.parse("0000-01-01T00:00:00Z"), new AtomicLong(-62167219200000L), true}, - { Instant.parse("0000-01-01T00:00:00.001Z"), new AtomicLong(-62167219199999L), true}, - { Instant.parse("1969-12-31T23:59:59Z"), new AtomicLong(-1000L), true}, - { Instant.parse("1969-12-31T23:59:59.999Z"), new AtomicLong(-1L), true}, - { Instant.parse("1970-01-01T00:00:00Z"), new AtomicLong(0L), true}, - { Instant.parse("1970-01-01T00:00:00.001Z"), new AtomicLong(1L), true}, - { Instant.parse("1970-01-01T00:00:00.999Z"), new AtomicLong(999L), true}, + {Instant.parse("0000-01-01T00:00:00Z"), new AtomicLong(-62167219200000L), true}, + {Instant.parse("0000-01-01T00:00:00.001Z"), new AtomicLong(-62167219199999L), true}, + {Instant.parse("1969-12-31T23:59:59Z"), new AtomicLong(-1000L), true}, + {Instant.parse("1969-12-31T23:59:59.999Z"), new AtomicLong(-1L), true}, + {Instant.parse("1970-01-01T00:00:00Z"), new AtomicLong(0L), true}, + {Instant.parse("1970-01-01T00:00:00.001Z"), new AtomicLong(1L), true}, + {Instant.parse("1970-01-01T00:00:00.999Z"), new AtomicLong(999L), true}, }); TEST_DB.put(pair(Duration.class, AtomicLong.class), new Object[][]{ - { Duration.ofMillis(Long.MIN_VALUE / 2), new AtomicLong(Long.MIN_VALUE / 2), true }, - { Duration.ofMillis(Integer.MIN_VALUE), new AtomicLong(Integer.MIN_VALUE), true }, - { Duration.ofMillis(-1), new AtomicLong(-1), true }, - { Duration.ofMillis(0), new AtomicLong(0), true }, - { Duration.ofMillis(1), new AtomicLong(1), true }, - { Duration.ofMillis(Integer.MAX_VALUE), new AtomicLong(Integer.MAX_VALUE), true }, - { Duration.ofMillis(Long.MAX_VALUE / 2), new AtomicLong(Long.MAX_VALUE / 2), true }, + {Duration.ofMillis(Long.MIN_VALUE / 2), new AtomicLong(Long.MIN_VALUE / 2), true}, + {Duration.ofMillis(Integer.MIN_VALUE), new AtomicLong(Integer.MIN_VALUE), true}, + {Duration.ofMillis(-1), new AtomicLong(-1), true}, + {Duration.ofMillis(0), new AtomicLong(0), true}, + {Duration.ofMillis(1), new AtomicLong(1), true}, + {Duration.ofMillis(Integer.MAX_VALUE), new AtomicLong(Integer.MAX_VALUE), true}, + {Duration.ofMillis(Long.MAX_VALUE / 2), new AtomicLong(Long.MAX_VALUE / 2), true}, }); } - + /** * String */ @@ -459,33 +461,33 @@ private static void loadZoneOffsetTests() { */ private static void loadZoneDateTimeTests() { TEST_DB.put(pair(Void.class, ZonedDateTime.class), new Object[][]{ - { null, null }, + {null, null}, }); TEST_DB.put(pair(ZonedDateTime.class, ZonedDateTime.class), new Object[][]{ - { ZonedDateTime.parse("1970-01-01T00:00:00.000000000Z").withZoneSameInstant(TOKYO_Z), ZonedDateTime.parse("1970-01-01T00:00:00.000000000Z").withZoneSameInstant(TOKYO_Z) }, + {ZonedDateTime.parse("1970-01-01T00:00:00.000000000Z").withZoneSameInstant(TOKYO_Z), ZonedDateTime.parse("1970-01-01T00:00:00.000000000Z").withZoneSameInstant(TOKYO_Z)}, }); TEST_DB.put(pair(Double.class, ZonedDateTime.class), new Object[][]{ - { -62167219200.0, ZonedDateTime.parse("0000-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z), true}, - { -0.000000001, ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(TOKYO_Z)}, // IEEE-754 limit prevents reverse test - { 0d, ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z), true}, - { 0.000000001, ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z), true}, - { 86400d, ZonedDateTime.parse("1970-01-02T00:00:00Z").withZoneSameInstant(TOKYO_Z), true}, - { 86400.000000001, ZonedDateTime.parse("1970-01-02T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z), true}, + {-62167219200.0, ZonedDateTime.parse("0000-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z), true}, + {-0.000000001, ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(TOKYO_Z)}, // IEEE-754 limit prevents reverse test + {0d, ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z), true}, + {0.000000001, ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z), true}, + {86400d, ZonedDateTime.parse("1970-01-02T00:00:00Z").withZoneSameInstant(TOKYO_Z), true}, + {86400.000000001, ZonedDateTime.parse("1970-01-02T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z), true}, }); TEST_DB.put(pair(BigInteger.class, ZonedDateTime.class), new Object[][]{ - { new BigInteger("-62167219200000000000"), ZonedDateTime.parse("0000-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z), true }, - { new BigInteger("-62167219199999999999"), ZonedDateTime.parse("0000-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z), true }, - { new BigInteger("-1"), ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(TOKYO_Z), true }, - { BigInteger.ZERO, ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z), true }, - { new BigInteger("1"), ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z), true }, + {new BigInteger("-62167219200000000000"), ZonedDateTime.parse("0000-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z), true}, + {new BigInteger("-62167219199999999999"), ZonedDateTime.parse("0000-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z), true}, + {new BigInteger("-1"), ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(TOKYO_Z), true}, + {BigInteger.ZERO, ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z), true}, + {new BigInteger("1"), ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z), true}, }); TEST_DB.put(pair(BigDecimal.class, ZonedDateTime.class), new Object[][]{ - { new BigDecimal("-62167219200"), ZonedDateTime.parse("0000-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z), true }, - { new BigDecimal("-0.000000001"), ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(TOKYO_Z), true}, - { BigDecimal.ZERO, ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z), true}, - { new BigDecimal("0.000000001"), ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z), true}, - { BigDecimal.valueOf(86400), ZonedDateTime.parse("1970-01-02T00:00:00Z").withZoneSameInstant(TOKYO_Z), true}, - { new BigDecimal("86400.000000001"), ZonedDateTime.parse("1970-01-02T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z), true}, + {new BigDecimal("-62167219200"), ZonedDateTime.parse("0000-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z), true}, + {new BigDecimal("-0.000000001"), ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(TOKYO_Z), true}, + {BigDecimal.ZERO, ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z), true}, + {new BigDecimal("0.000000001"), ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z), true}, + {BigDecimal.valueOf(86400), ZonedDateTime.parse("1970-01-02T00:00:00Z").withZoneSameInstant(TOKYO_Z), true}, + {new BigDecimal("86400.000000001"), ZonedDateTime.parse("1970-01-02T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z), true}, }); } @@ -493,34 +495,23 @@ private static void loadZoneDateTimeTests() { * LocalDateTime */ private static void loadLocalDateTimeTests() { - TEST_DB.put(pair(Void.class, LocalDateTime.class), new Object[][] { - { null, null } - }); - TEST_DB.put(pair(LocalDateTime.class, LocalDateTime.class), new Object[][] { - { LocalDateTime.of(1970, 1, 1, 0,0), LocalDateTime.of(1970, 1, 1, 0,0), true } - }); - TEST_DB.put(pair(Double.class, LocalDateTime.class), new Object[][] { - { -0.000000001, LocalDateTime.parse("1969-12-31T23:59:59.999999999").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime() }, // IEEE-754 prevents perfect symmetry - { 0d, LocalDateTime.parse("1970-01-01T00:00:00").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true }, - { 0.000000001, LocalDateTime.parse("1970-01-01T00:00:00.000000001").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true }, - }); - TEST_DB.put(pair(BigInteger.class, LocalDateTime.class), new Object[][]{ - { new BigInteger("-62167252739000000000"), ZonedDateTime.parse("0000-01-01T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), true }, - { new BigInteger("-62167252738999999999"), ZonedDateTime.parse("0000-01-01T00:00:00.000000001Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), true }, - { new BigInteger("-118800000000000"), ZonedDateTime.parse("1969-12-31T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), true }, - { new BigInteger("-118799999999999"), ZonedDateTime.parse("1969-12-31T00:00:00.000000001Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), true }, - { new BigInteger("-32400000000001"), ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), true }, - { new BigInteger("-32400000000000"), ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), true }, - { new BigInteger("-1"), ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true }, - { BigInteger.ZERO, ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true }, - { new BigInteger("1"), ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true }, - }); - TEST_DB.put(pair(BigDecimal.class, LocalDateTime.class), new Object[][] { - { new BigDecimal("-62167219200"), LocalDateTime.parse("0000-01-01T00:00:00").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true }, - { new BigDecimal("-62167219199.999999999"), LocalDateTime.parse("0000-01-01T00:00:00.000000001").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true }, - { new BigDecimal("-0.000000001"), LocalDateTime.parse("1969-12-31T23:59:59.999999999").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true }, - { BigDecimal.ZERO, LocalDateTime.parse("1970-01-01T00:00:00").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true }, - { new BigDecimal("0.000000001"), LocalDateTime.parse("1970-01-01T00:00:00.000000001").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true }, + TEST_DB.put(pair(Void.class, LocalDateTime.class), new Object[][]{ + {null, null} + }); + TEST_DB.put(pair(LocalDateTime.class, LocalDateTime.class), new Object[][]{ + {LocalDateTime.of(1970, 1, 1, 0, 0), LocalDateTime.of(1970, 1, 1, 0, 0), true} + }); + TEST_DB.put(pair(Double.class, LocalDateTime.class), new Object[][]{ + {-0.000000001, LocalDateTime.parse("1969-12-31T23:59:59.999999999").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime()}, // IEEE-754 prevents perfect symmetry + {0d, LocalDateTime.parse("1970-01-01T00:00:00").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true}, + {0.000000001, LocalDateTime.parse("1970-01-01T00:00:00.000000001").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true}, + }); + TEST_DB.put(pair(BigDecimal.class, LocalDateTime.class), new Object[][]{ + {new BigDecimal("-62167219200"), LocalDateTime.parse("0000-01-01T00:00:00").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true}, + {new BigDecimal("-62167219199.999999999"), LocalDateTime.parse("0000-01-01T00:00:00.000000001").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true}, + {new BigDecimal("-0.000000001"), LocalDateTime.parse("1969-12-31T23:59:59.999999999").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true}, + {BigDecimal.ZERO, LocalDateTime.parse("1970-01-01T00:00:00").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true}, + {new BigDecimal("0.000000001"), LocalDateTime.parse("1970-01-01T00:00:00.000000001").atZone(ZoneId.of("UTC")).withZoneSameInstant(TOKYO_Z).toLocalDateTime(), true}, }); } @@ -528,38 +519,33 @@ private static void loadLocalDateTimeTests() { * LocalDate */ private static void loadLocalDateTests() { - TEST_DB.put(pair(Void.class, LocalDate.class), new Object[][] { - { null, null } - }); - TEST_DB.put(pair(LocalDate.class, LocalDate.class), new Object[][] { - { LocalDate.parse("1970-01-01"), LocalDate.parse("1970-01-01"), true } - }); - TEST_DB.put(pair(Double.class, LocalDate.class), new Object[][] { // options timezone is factored in (86,400 seconds per day) - { -118800d, LocalDate.parse("1969-12-31"), true }, - { -32400d, LocalDate.parse("1970-01-01"), true }, - { 0d, LocalDate.parse("1970-01-01") }, // Showing that there is a wide range of numbers that will convert to this date - { 53999.999, LocalDate.parse("1970-01-01") }, // Showing that there is a wide range of numbers that will convert to this date - { 54000d, LocalDate.parse("1970-01-02"), true }, - }); - TEST_DB.put(pair(BigInteger.class, LocalDate.class), new Object[][] { // options timezone is factored in (86,400 seconds per day) - { new BigInteger("-62167252739000000000"), LocalDate.parse("0000-01-01"), true }, - { new BigInteger("-62167252739000000000"), ZonedDateTime.parse("0000-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDate(), true }, - { new BigInteger("-118800000000000"), LocalDate.parse("1969-12-31"), true }, - // These 4 are all in the same date range - { new BigInteger("-32400000000000"), LocalDate.parse("1970-01-01"), true }, - { BigInteger.ZERO, ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDate() }, - { new BigInteger("53999999000000"), LocalDate.parse("1970-01-01") }, - { new BigInteger("54000000000000"), LocalDate.parse("1970-01-02"), true }, - }); - TEST_DB.put(pair(BigDecimal.class, LocalDate.class), new Object[][] { // options timezone is factored in (86,400 seconds per day) - { new BigDecimal("-62167219200"), LocalDate.parse("0000-01-01") }, - { new BigDecimal("-62167219200"), ZonedDateTime.parse("0000-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDate() }, - { new BigDecimal("-118800"), LocalDate.parse("1969-12-31"), true }, + TEST_DB.put(pair(Void.class, LocalDate.class), new Object[][]{ + {null, null} + }); + TEST_DB.put(pair(LocalDate.class, LocalDate.class), new Object[][]{ + {LocalDate.parse("1970-01-01"), LocalDate.parse("1970-01-01"), true} + }); + TEST_DB.put(pair(Double.class, LocalDate.class), new Object[][]{ // options timezone is factored in (86,400 seconds per day) + {-118800d, LocalDate.parse("1969-12-31"), true}, + {-32400d, LocalDate.parse("1970-01-01"), true}, + {0d, LocalDate.parse("1970-01-01")}, // Showing that there is a wide range of numbers that will convert to this date + {53999.999, LocalDate.parse("1970-01-01")}, // Showing that there is a wide range of numbers that will convert to this date + {54000d, LocalDate.parse("1970-01-02"), true}, + }); + TEST_DB.put(pair(BigInteger.class, LocalDate.class), new Object[][]{ // options timezone is factored in (86,400 seconds per day) + // These are all in the same date range + {BigInteger.ZERO, ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDate() }, + {new BigInteger("53999999000000"), LocalDate.parse("1970-01-01")}, + }); + TEST_DB.put(pair(BigDecimal.class, LocalDate.class), new Object[][]{ // options timezone is factored in (86,400 seconds per day) + {new BigDecimal("-62167219200"), LocalDate.parse("0000-01-01")}, + {new BigDecimal("-62167219200"), ZonedDateTime.parse("0000-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDate()}, + {new BigDecimal("-118800"), LocalDate.parse("1969-12-31"), true}, // These 4 are all in the same date range - { new BigDecimal("-32400"), LocalDate.parse("1970-01-01"), true }, - { BigDecimal.ZERO, ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDate() }, - { new BigDecimal("53999.999"), LocalDate.parse("1970-01-01") }, - { new BigDecimal("54000"), LocalDate.parse("1970-01-02"), true }, + {new BigDecimal("-32400"), LocalDate.parse("1970-01-01"), true}, + {BigDecimal.ZERO, ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDate()}, + {new BigDecimal("53999.999"), LocalDate.parse("1970-01-01")}, + {new BigDecimal("54000"), LocalDate.parse("1970-01-02"), true}, }); } @@ -568,66 +554,66 @@ private static void loadLocalDateTests() { */ private static void loadTimestampTests(long now) { TEST_DB.put(pair(Void.class, Timestamp.class), new Object[][]{ - { null, null }, + {null, null}, }); // No identity test - Timestamp is mutable TEST_DB.put(pair(Double.class, Timestamp.class), new Object[][]{ - { -0.000000001, Timestamp.from(Instant.parse("1969-12-31T23:59:59.999999999Z"))}, // IEEE-754 limit prevents reverse test - { 0d, Timestamp.from(Instant.parse("1970-01-01T00:00:00Z")), true}, - { 0.000000001, Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")), true}, - { (double) now, new Timestamp((long)(now * 1000d)), true}, + {-0.000000001, Timestamp.from(Instant.parse("1969-12-31T23:59:59.999999999Z"))}, // IEEE-754 limit prevents reverse test + {0d, Timestamp.from(Instant.parse("1970-01-01T00:00:00Z")), true}, + {0.000000001, Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")), true}, + {(double) now, new Timestamp((long) (now * 1000d)), true}, }); TEST_DB.put(pair(BigInteger.class, Timestamp.class), new Object[][]{ - { new BigInteger("-62167219200000000000"), Timestamp.from(Instant.parse("0000-01-01T00:00:00.000000000Z")), true }, - { new BigInteger("-62131377719000000000"), Timestamp.from(Instant.parse("0001-02-18T19:58:01.000000000Z")), true }, - { BigInteger.valueOf(-1000000000), Timestamp.from(Instant.parse("1969-12-31T23:59:59.000000000Z")), true }, - { BigInteger.valueOf(-999999999), Timestamp.from(Instant.parse("1969-12-31T23:59:59.000000001Z")), true }, - { BigInteger.valueOf(-900000000), Timestamp.from(Instant.parse("1969-12-31T23:59:59.100000000Z")), true }, - { BigInteger.valueOf(-100000000), Timestamp.from(Instant.parse("1969-12-31T23:59:59.900000000Z")), true }, - { BigInteger.valueOf(-1), Timestamp.from(Instant.parse("1969-12-31T23:59:59.999999999Z")), true }, - { BigInteger.ZERO, Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000000Z")), true }, - { BigInteger.valueOf(1), Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")), true }, - { BigInteger.valueOf(100000000), Timestamp.from(Instant.parse("1970-01-01T00:00:00.100000000Z")), true }, - { BigInteger.valueOf(900000000), Timestamp.from(Instant.parse("1970-01-01T00:00:00.900000000Z")), true }, - { BigInteger.valueOf(999999999), Timestamp.from(Instant.parse("1970-01-01T00:00:00.999999999Z")), true }, - { BigInteger.valueOf(1000000000), Timestamp.from(Instant.parse("1970-01-01T00:00:01.000000000Z")), true }, - { new BigInteger("253374983881000000000"), Timestamp.from(Instant.parse("9999-02-18T19:58:01.000000000Z")), true }, - }); - TEST_DB.put(pair(BigDecimal.class, Timestamp.class), new Object[][] { - { new BigDecimal("-62167219200"), Timestamp.from(Instant.parse("0000-01-01T00:00:00Z")), true }, - { new BigDecimal("-62167219199.999999999"), Timestamp.from(Instant.parse("0000-01-01T00:00:00.000000001Z")), true }, - { new BigDecimal("-1.000000001"), Timestamp.from(Instant.parse("1969-12-31T23:59:58.999999999Z")), true }, - { new BigDecimal("-1"), Timestamp.from(Instant.parse("1969-12-31T23:59:59Z")), true }, - { new BigDecimal("-0.00000001"), Timestamp.from(Instant.parse("1969-12-31T23:59:59.99999999Z")), true }, - { new BigDecimal("-0.000000001"), Timestamp.from(Instant.parse("1969-12-31T23:59:59.999999999Z")), true }, - { BigDecimal.ZERO, Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000000Z")), true }, - { new BigDecimal("0.000000001"), Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")), true }, - { new BigDecimal(".999999999"), Timestamp.from(Instant.parse("1970-01-01T00:00:00.999999999Z")), true }, - { new BigDecimal("1"), Timestamp.from(Instant.parse("1970-01-01T00:00:01Z")), true }, - }); - TEST_DB.put(pair(Duration.class, Timestamp.class), new Object[][] { - { Duration.ofSeconds(-62167219200L), Timestamp.from(Instant.parse("0000-01-01T00:00:00Z")), true}, - { Duration.ofSeconds(-62167219200L, 1), Timestamp.from(Instant.parse("0000-01-01T00:00:00.000000001Z")), true}, - { Duration.ofNanos(-1000000001), Timestamp.from(Instant.parse("1969-12-31T23:59:58.999999999Z")), true}, - { Duration.ofNanos(-1000000000), Timestamp.from(Instant.parse("1969-12-31T23:59:59.000000000Z")), true}, - { Duration.ofNanos(-999999999), Timestamp.from(Instant.parse("1969-12-31T23:59:59.000000001Z")), true}, - { Duration.ofNanos(-1), Timestamp.from(Instant.parse("1969-12-31T23:59:59.999999999Z")), true}, - { Duration.ofNanos(0), Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000000Z")), true}, - { Duration.ofNanos(1), Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")), true}, - { Duration.ofNanos(999999999), Timestamp.from(Instant.parse("1970-01-01T00:00:00.999999999Z")), true}, - { Duration.ofNanos(1000000000), Timestamp.from(Instant.parse("1970-01-01T00:00:01.000000000Z")), true}, - { Duration.ofNanos(1000000001), Timestamp.from(Instant.parse("1970-01-01T00:00:01.000000001Z")), true}, - { Duration.ofNanos(686629800000000001L), Timestamp.from(Instant.parse("1991-10-05T02:30:00.000000001Z")), true }, - { Duration.ofNanos(1199145600000000001L), Timestamp.from(Instant.parse("2008-01-01T00:00:00.000000001Z")), true }, - { Duration.ofNanos(1708255140987654321L), Timestamp.from(Instant.parse("2024-02-18T11:19:00.987654321Z")), true }, - { Duration.ofNanos(2682374400000000001L), Timestamp.from(Instant.parse("2055-01-01T00:00:00.000000001Z")), true }, + {new BigInteger("-62167219200000000000"), Timestamp.from(Instant.parse("0000-01-01T00:00:00.000000000Z")), true}, + {new BigInteger("-62131377719000000000"), Timestamp.from(Instant.parse("0001-02-18T19:58:01.000000000Z")), true}, + {BigInteger.valueOf(-1000000000), Timestamp.from(Instant.parse("1969-12-31T23:59:59.000000000Z")), true}, + {BigInteger.valueOf(-999999999), Timestamp.from(Instant.parse("1969-12-31T23:59:59.000000001Z")), true}, + {BigInteger.valueOf(-900000000), Timestamp.from(Instant.parse("1969-12-31T23:59:59.100000000Z")), true}, + {BigInteger.valueOf(-100000000), Timestamp.from(Instant.parse("1969-12-31T23:59:59.900000000Z")), true}, + {BigInteger.valueOf(-1), Timestamp.from(Instant.parse("1969-12-31T23:59:59.999999999Z")), true}, + {BigInteger.ZERO, Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000000Z")), true}, + {BigInteger.valueOf(1), Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")), true}, + {BigInteger.valueOf(100000000), Timestamp.from(Instant.parse("1970-01-01T00:00:00.100000000Z")), true}, + {BigInteger.valueOf(900000000), Timestamp.from(Instant.parse("1970-01-01T00:00:00.900000000Z")), true}, + {BigInteger.valueOf(999999999), Timestamp.from(Instant.parse("1970-01-01T00:00:00.999999999Z")), true}, + {BigInteger.valueOf(1000000000), Timestamp.from(Instant.parse("1970-01-01T00:00:01.000000000Z")), true}, + {new BigInteger("253374983881000000000"), Timestamp.from(Instant.parse("9999-02-18T19:58:01.000000000Z")), true}, + }); + TEST_DB.put(pair(BigDecimal.class, Timestamp.class), new Object[][]{ + {new BigDecimal("-62167219200"), Timestamp.from(Instant.parse("0000-01-01T00:00:00Z")), true}, + {new BigDecimal("-62167219199.999999999"), Timestamp.from(Instant.parse("0000-01-01T00:00:00.000000001Z")), true}, + {new BigDecimal("-1.000000001"), Timestamp.from(Instant.parse("1969-12-31T23:59:58.999999999Z")), true}, + {new BigDecimal("-1"), Timestamp.from(Instant.parse("1969-12-31T23:59:59Z")), true}, + {new BigDecimal("-0.00000001"), Timestamp.from(Instant.parse("1969-12-31T23:59:59.99999999Z")), true}, + {new BigDecimal("-0.000000001"), Timestamp.from(Instant.parse("1969-12-31T23:59:59.999999999Z")), true}, + {BigDecimal.ZERO, Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000000Z")), true}, + {new BigDecimal("0.000000001"), Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")), true}, + {new BigDecimal(".999999999"), Timestamp.from(Instant.parse("1970-01-01T00:00:00.999999999Z")), true}, + {new BigDecimal("1"), Timestamp.from(Instant.parse("1970-01-01T00:00:01Z")), true}, + }); + TEST_DB.put(pair(Duration.class, Timestamp.class), new Object[][]{ + {Duration.ofSeconds(-62167219200L), Timestamp.from(Instant.parse("0000-01-01T00:00:00Z")), true}, + {Duration.ofSeconds(-62167219200L, 1), Timestamp.from(Instant.parse("0000-01-01T00:00:00.000000001Z")), true}, + {Duration.ofNanos(-1000000001), Timestamp.from(Instant.parse("1969-12-31T23:59:58.999999999Z")), true}, + {Duration.ofNanos(-1000000000), Timestamp.from(Instant.parse("1969-12-31T23:59:59.000000000Z")), true}, + {Duration.ofNanos(-999999999), Timestamp.from(Instant.parse("1969-12-31T23:59:59.000000001Z")), true}, + {Duration.ofNanos(-1), Timestamp.from(Instant.parse("1969-12-31T23:59:59.999999999Z")), true}, + {Duration.ofNanos(0), Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000000Z")), true}, + {Duration.ofNanos(1), Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")), true}, + {Duration.ofNanos(999999999), Timestamp.from(Instant.parse("1970-01-01T00:00:00.999999999Z")), true}, + {Duration.ofNanos(1000000000), Timestamp.from(Instant.parse("1970-01-01T00:00:01.000000000Z")), true}, + {Duration.ofNanos(1000000001), Timestamp.from(Instant.parse("1970-01-01T00:00:01.000000001Z")), true}, + {Duration.ofNanos(686629800000000001L), Timestamp.from(Instant.parse("1991-10-05T02:30:00.000000001Z")), true}, + {Duration.ofNanos(1199145600000000001L), Timestamp.from(Instant.parse("2008-01-01T00:00:00.000000001Z")), true}, + {Duration.ofNanos(1708255140987654321L), Timestamp.from(Instant.parse("2024-02-18T11:19:00.987654321Z")), true}, + {Duration.ofNanos(2682374400000000001L), Timestamp.from(Instant.parse("2055-01-01T00:00:00.000000001Z")), true}, }); // No symmetry checks - because an OffsetDateTime of "2024-02-18T06:31:55.987654321+00:00" and "2024-02-18T15:31:55.987654321+09:00" are equivalent but not equals. They both describe the same Instant. TEST_DB.put(pair(OffsetDateTime.class, Timestamp.class), new Object[][]{ - {OffsetDateTime.parse("1969-12-31T23:59:59.999999999Z"), Timestamp.from(Instant.parse("1969-12-31T23:59:59.999999999Z")) }, - {OffsetDateTime.parse("1970-01-01T00:00:00.000000000Z"), Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000000Z")) }, - {OffsetDateTime.parse("1970-01-01T00:00:00.000000001Z"), Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")) }, - {OffsetDateTime.parse("2024-02-18T06:31:55.987654321Z"), Timestamp.from(Instant.parse("2024-02-18T06:31:55.987654321Z")) }, + {OffsetDateTime.parse("1969-12-31T23:59:59.999999999Z"), Timestamp.from(Instant.parse("1969-12-31T23:59:59.999999999Z"))}, + {OffsetDateTime.parse("1970-01-01T00:00:00.000000000Z"), Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000000Z"))}, + {OffsetDateTime.parse("1970-01-01T00:00:00.000000001Z"), Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z"))}, + {OffsetDateTime.parse("2024-02-18T06:31:55.987654321Z"), Timestamp.from(Instant.parse("2024-02-18T06:31:55.987654321Z"))}, }); } @@ -801,27 +787,27 @@ private static void loadMonthDayTests() { */ private static void loadOffsetDateTimeTests() { ZoneOffset tokyoOffset = ZonedDateTime.now(TOKYO_Z).getOffset(); - + TEST_DB.put(pair(Void.class, OffsetDateTime.class), new Object[][]{ - { null, null } + {null, null} }); TEST_DB.put(pair(OffsetDateTime.class, OffsetDateTime.class), new Object[][]{ - {OffsetDateTime.parse("2024-02-18T06:31:55.987654321Z"), OffsetDateTime.parse("2024-02-18T06:31:55.987654321Z"), true }, + {OffsetDateTime.parse("2024-02-18T06:31:55.987654321Z"), OffsetDateTime.parse("2024-02-18T06:31:55.987654321Z"), true}, }); TEST_DB.put(pair(Double.class, OffsetDateTime.class), new Object[][]{ - {-0.000000001, OffsetDateTime.parse("1969-12-31T23:59:59.999999999Z").withOffsetSameInstant(tokyoOffset) }, // IEEE-754 resolution prevents perfect symmetry (close) - {0d, OffsetDateTime.parse("1970-01-01T00:00:00Z").withOffsetSameInstant(tokyoOffset), true }, - {0.000000001, OffsetDateTime.parse("1970-01-01T00:00:00.000000001Z").withOffsetSameInstant(tokyoOffset), true }, + {-0.000000001, OffsetDateTime.parse("1969-12-31T23:59:59.999999999Z").withOffsetSameInstant(tokyoOffset)}, // IEEE-754 resolution prevents perfect symmetry (close) + {0d, OffsetDateTime.parse("1970-01-01T00:00:00Z").withOffsetSameInstant(tokyoOffset), true}, + {0.000000001, OffsetDateTime.parse("1970-01-01T00:00:00.000000001Z").withOffsetSameInstant(tokyoOffset), true}, }); TEST_DB.put(pair(BigInteger.class, OffsetDateTime.class), new Object[][]{ - { new BigInteger("-1"), OffsetDateTime.parse("1969-12-31T23:59:59.999999999Z").withOffsetSameInstant(tokyoOffset) }, - { BigInteger.ZERO, OffsetDateTime.parse("1970-01-01T00:00:00Z").withOffsetSameInstant(tokyoOffset) }, - { new BigInteger("1"), OffsetDateTime.parse("1970-01-01T00:00:00.000000001Z").withOffsetSameInstant(tokyoOffset) }, + {new BigInteger("-1"), OffsetDateTime.parse("1969-12-31T23:59:59.999999999Z").withOffsetSameInstant(tokyoOffset)}, + {BigInteger.ZERO, OffsetDateTime.parse("1970-01-01T00:00:00Z").withOffsetSameInstant(tokyoOffset)}, + {new BigInteger("1"), OffsetDateTime.parse("1970-01-01T00:00:00.000000001Z").withOffsetSameInstant(tokyoOffset)}, }); TEST_DB.put(pair(BigDecimal.class, OffsetDateTime.class), new Object[][]{ - {new BigDecimal("-0.000000001"), OffsetDateTime.parse("1969-12-31T23:59:59.999999999Z").withOffsetSameInstant(ZonedDateTime.now(TOKYO_Z).getOffset()) }, // IEEE-754 resolution prevents perfect symmetry (close) - {BigDecimal.ZERO, OffsetDateTime.parse("1970-01-01T00:00:00Z").withOffsetSameInstant(ZonedDateTime.now(TOKYO_Z).getOffset()), true }, - {new BigDecimal(".000000001"), OffsetDateTime.parse("1970-01-01T00:00:00.000000001Z").withOffsetSameInstant(ZonedDateTime.now(TOKYO_Z).getOffset()), true }, + {new BigDecimal("-0.000000001"), OffsetDateTime.parse("1969-12-31T23:59:59.999999999Z").withOffsetSameInstant(ZonedDateTime.now(TOKYO_Z).getOffset())}, // IEEE-754 resolution prevents perfect symmetry (close) + {BigDecimal.ZERO, OffsetDateTime.parse("1970-01-01T00:00:00Z").withOffsetSameInstant(ZonedDateTime.now(TOKYO_Z).getOffset()), true}, + {new BigDecimal(".000000001"), OffsetDateTime.parse("1970-01-01T00:00:00.000000001Z").withOffsetSameInstant(ZonedDateTime.now(TOKYO_Z).getOffset()), true}, }); } @@ -830,7 +816,7 @@ private static void loadOffsetDateTimeTests() { */ private static void loadDurationTests() { TEST_DB.put(pair(Void.class, Duration.class), new Object[][]{ - { null, null } + {null, null} }); TEST_DB.put(pair(String.class, Duration.class), new Object[][]{ {"PT1S", Duration.ofSeconds(1), true}, @@ -840,54 +826,40 @@ private static void loadDurationTests() { {"PT2H46M40S", Duration.ofSeconds(10000), true}, }); TEST_DB.put(pair(Long.class, Duration.class), new Object[][]{ - { Long.MIN_VALUE / 2, Duration.ofMillis(Long.MIN_VALUE / 2), true }, - { (long)Integer.MIN_VALUE, Duration.ofMillis(Integer.MIN_VALUE), true }, - { -1L, Duration.ofMillis(-1), true }, - { 0L, Duration.ofMillis(0), true }, - { 1L, Duration.ofMillis(1), true }, - { (long)Integer.MAX_VALUE, Duration.ofMillis(Integer.MAX_VALUE), true }, - { Long.MAX_VALUE / 2, Duration.ofMillis(Long.MAX_VALUE / 2), true }, - }); - TEST_DB.put(pair(AtomicLong.class, Duration.class), new Object[][]{ - { new AtomicLong(Long.MIN_VALUE / 2), Duration.ofMillis(Long.MIN_VALUE / 2), true }, - { new AtomicLong(Integer.MIN_VALUE), Duration.ofMillis(Integer.MIN_VALUE), true }, - { new AtomicLong(-1), Duration.ofMillis(-1), true }, - { new AtomicLong(0), Duration.ofMillis(0), true }, - { new AtomicLong(1), Duration.ofMillis(1), true }, - { new AtomicLong(Integer.MAX_VALUE), Duration.ofMillis(Integer.MAX_VALUE), true }, - { new AtomicLong(Long.MAX_VALUE / 2), Duration.ofMillis(Long.MAX_VALUE / 2), true }, + {Long.MIN_VALUE / 2, Duration.ofMillis(Long.MIN_VALUE / 2), true}, + {(long) Integer.MIN_VALUE, Duration.ofMillis(Integer.MIN_VALUE), true}, + {-1L, Duration.ofMillis(-1), true}, + {0L, Duration.ofMillis(0), true}, + {1L, Duration.ofMillis(1), true}, + {(long) Integer.MAX_VALUE, Duration.ofMillis(Integer.MAX_VALUE), true}, + {Long.MAX_VALUE / 2, Duration.ofMillis(Long.MAX_VALUE / 2), true}, }); TEST_DB.put(pair(Double.class, Duration.class), new Object[][]{ - {-0.000000001, Duration.ofNanos(-1) }, // IEEE 754 prevents reverse - {0d, Duration.ofNanos(0), true}, - {0.000000001, Duration.ofNanos(1), true }, - {1d, Duration.ofSeconds(1), true}, - {10d, Duration.ofSeconds(10), true}, - {100d, Duration.ofSeconds(100), true}, - {3.000000006d, Duration.ofSeconds(3, 6) }, // IEEE 754 prevents reverse - }); - TEST_DB.put(pair(BigInteger.class, Duration.class), new Object[][] { - { BigInteger.valueOf(-1000000), Duration.ofNanos(-1000000), true }, - { BigInteger.valueOf(-1000), Duration.ofNanos(-1000), true }, - { BigInteger.valueOf(-1), Duration.ofNanos(-1), true }, - { BigInteger.ZERO, Duration.ofNanos(0), true }, - { BigInteger.valueOf(1), Duration.ofNanos(1), true }, - { BigInteger.valueOf(1000), Duration.ofNanos(1000), true }, - { BigInteger.valueOf(1000000), Duration.ofNanos(1000000), true }, - { BigInteger.valueOf(Integer.MAX_VALUE), Duration.ofNanos(Integer.MAX_VALUE), true }, - { BigInteger.valueOf(Integer.MIN_VALUE), Duration.ofNanos(Integer.MIN_VALUE), true }, - { BigInteger.valueOf(Long.MAX_VALUE), Duration.ofNanos(Long.MAX_VALUE), true }, - { BigInteger.valueOf(Long.MIN_VALUE), Duration.ofNanos(Long.MIN_VALUE), true }, + {-0.000000001, Duration.ofNanos(-1)}, // IEEE 754 prevents reverse + {3.000000006d, Duration.ofSeconds(3, 6)}, // IEEE 754 prevents reverse + }); + TEST_DB.put(pair(BigInteger.class, Duration.class), new Object[][]{ + {BigInteger.valueOf(-1000000), Duration.ofNanos(-1000000), true}, + {BigInteger.valueOf(-1000), Duration.ofNanos(-1000), true}, + {BigInteger.valueOf(-1), Duration.ofNanos(-1), true}, + {BigInteger.ZERO, Duration.ofNanos(0), true}, + {BigInteger.valueOf(1), Duration.ofNanos(1), true}, + {BigInteger.valueOf(1000), Duration.ofNanos(1000), true}, + {BigInteger.valueOf(1000000), Duration.ofNanos(1000000), true}, + {BigInteger.valueOf(Integer.MAX_VALUE), Duration.ofNanos(Integer.MAX_VALUE), true}, + {BigInteger.valueOf(Integer.MIN_VALUE), Duration.ofNanos(Integer.MIN_VALUE), true}, + {BigInteger.valueOf(Long.MAX_VALUE), Duration.ofNanos(Long.MAX_VALUE), true}, + {BigInteger.valueOf(Long.MIN_VALUE), Duration.ofNanos(Long.MIN_VALUE), true}, }); TEST_DB.put(pair(BigDecimal.class, Duration.class), new Object[][]{ - {new BigDecimal("-0.000000001"), Duration.ofNanos(-1), true }, + {new BigDecimal("-0.000000001"), Duration.ofNanos(-1), true}, {BigDecimal.ZERO, Duration.ofNanos(0), true}, - {new BigDecimal("0.000000001"), Duration.ofNanos(1), true }, + {new BigDecimal("0.000000001"), Duration.ofNanos(1), true}, {new BigDecimal("100"), Duration.ofSeconds(100), true}, {new BigDecimal("1"), Duration.ofSeconds(1), true}, {new BigDecimal("100"), Duration.ofSeconds(100), true}, {new BigDecimal("100"), Duration.ofSeconds(100), true}, - {new BigDecimal("3.000000006"), Duration.ofSeconds(3, 6), true }, + {new BigDecimal("3.000000006"), Duration.ofSeconds(3, 6), true}, }); } @@ -896,31 +868,31 @@ private static void loadDurationTests() { */ private static void loadSqlDateTests() { TEST_DB.put(pair(Void.class, java.sql.Date.class), new Object[][]{ - { null, null } + {null, null} }); // No identity test for Date, as it is mutable - TEST_DB.put(pair(Double.class, java.sql.Date.class), new Object[][] { - { -62167219200.0, new java.sql.Date(Instant.parse("0000-01-01T00:00:00Z").toEpochMilli()), true }, - { -62167219199.999, new java.sql.Date(Instant.parse("0000-01-01T00:00:00.001Z").toEpochMilli()), true }, - { -1.002d, new java.sql.Date(Instant.parse("1969-12-31T23:59:58.998Z").toEpochMilli()), true }, // IEEE754 resolution issue on -1.001 (-1.0009999999) - { -1d, new java.sql.Date(Instant.parse("1969-12-31T23:59:59Z").toEpochMilli()), true }, - { -0.002, new java.sql.Date(Instant.parse("1969-12-31T23:59:59.998Z").toEpochMilli()), true }, - { -0.001, new java.sql.Date(Instant.parse("1969-12-31T23:59:59.999Z").toEpochMilli()), true }, - { 0d, new java.sql.Date(Instant.parse("1970-01-01T00:00:00.000000000Z").toEpochMilli()), true }, - { 0.001, new java.sql.Date(Instant.parse("1970-01-01T00:00:00.001Z").toEpochMilli()), true }, - { 0.999, new java.sql.Date(Instant.parse("1970-01-01T00:00:00.999Z").toEpochMilli()), true }, - { 1d, new java.sql.Date(Instant.parse("1970-01-01T00:00:01Z").toEpochMilli()), true }, - }); - TEST_DB.put(pair(BigDecimal.class, java.sql.Date.class), new Object[][] { - { new BigDecimal("-62167219200"), new java.sql.Date(Instant.parse("0000-01-01T00:00:00Z").toEpochMilli()), true }, - { new BigDecimal("-62167219199.999"), new java.sql.Date(Instant.parse("0000-01-01T00:00:00.001Z").toEpochMilli()), true }, - { new BigDecimal("-1.001"), new java.sql.Date(Instant.parse("1969-12-31T23:59:58.999Z").toEpochMilli()), true }, - { new BigDecimal("-1"), new java.sql.Date(Instant.parse("1969-12-31T23:59:59Z").toEpochMilli()), true }, - { new BigDecimal("-0.001"), new java.sql.Date(Instant.parse("1969-12-31T23:59:59.999Z").toEpochMilli()), true }, - { BigDecimal.ZERO, new java.sql.Date(Instant.parse("1970-01-01T00:00:00.000000000Z").toEpochMilli()), true }, - { new BigDecimal("0.001"), new java.sql.Date(Instant.parse("1970-01-01T00:00:00.001Z").toEpochMilli()), true }, - { new BigDecimal(".999"), new java.sql.Date(Instant.parse("1970-01-01T00:00:00.999Z").toEpochMilli()), true }, - { new BigDecimal("1"), new java.sql.Date(Instant.parse("1970-01-01T00:00:01Z").toEpochMilli()), true }, + TEST_DB.put(pair(Double.class, java.sql.Date.class), new Object[][]{ + {-62167219200.0, new java.sql.Date(Instant.parse("0000-01-01T00:00:00Z").toEpochMilli()), true}, + {-62167219199.999, new java.sql.Date(Instant.parse("0000-01-01T00:00:00.001Z").toEpochMilli()), true}, + {-1.002d, new java.sql.Date(Instant.parse("1969-12-31T23:59:58.998Z").toEpochMilli()), true}, // IEEE754 resolution issue on -1.001 (-1.0009999999) + {-1d, new java.sql.Date(Instant.parse("1969-12-31T23:59:59Z").toEpochMilli()), true}, + {-0.002, new java.sql.Date(Instant.parse("1969-12-31T23:59:59.998Z").toEpochMilli()), true}, + {-0.001, new java.sql.Date(Instant.parse("1969-12-31T23:59:59.999Z").toEpochMilli()), true}, + {0d, new java.sql.Date(Instant.parse("1970-01-01T00:00:00.000000000Z").toEpochMilli()), true}, + {0.001, new java.sql.Date(Instant.parse("1970-01-01T00:00:00.001Z").toEpochMilli()), true}, + {0.999, new java.sql.Date(Instant.parse("1970-01-01T00:00:00.999Z").toEpochMilli()), true}, + {1d, new java.sql.Date(Instant.parse("1970-01-01T00:00:01Z").toEpochMilli()), true}, + }); + TEST_DB.put(pair(BigDecimal.class, java.sql.Date.class), new Object[][]{ + {new BigDecimal("-62167219200"), new java.sql.Date(Instant.parse("0000-01-01T00:00:00Z").toEpochMilli()), true}, + {new BigDecimal("-62167219199.999"), new java.sql.Date(Instant.parse("0000-01-01T00:00:00.001Z").toEpochMilli()), true}, + {new BigDecimal("-1.001"), new java.sql.Date(Instant.parse("1969-12-31T23:59:58.999Z").toEpochMilli()), true}, + {new BigDecimal("-1"), new java.sql.Date(Instant.parse("1969-12-31T23:59:59Z").toEpochMilli()), true}, + {new BigDecimal("-0.001"), new java.sql.Date(Instant.parse("1969-12-31T23:59:59.999Z").toEpochMilli()), true}, + {BigDecimal.ZERO, new java.sql.Date(Instant.parse("1970-01-01T00:00:00.000000000Z").toEpochMilli()), true}, + {new BigDecimal("0.001"), new java.sql.Date(Instant.parse("1970-01-01T00:00:00.001Z").toEpochMilli()), true}, + {new BigDecimal(".999"), new java.sql.Date(Instant.parse("1970-01-01T00:00:00.999Z").toEpochMilli()), true}, + {new BigDecimal("1"), new java.sql.Date(Instant.parse("1970-01-01T00:00:01Z").toEpochMilli()), true}, }); } @@ -929,44 +901,9 @@ private static void loadSqlDateTests() { */ private static void loadDateTests() { TEST_DB.put(pair(Void.class, Date.class), new Object[][]{ - { null, null } + {null, null} }); // No identity test for Date, as it is mutable - TEST_DB.put(pair(BigInteger.class, Date.class), new Object[][]{ - {new BigInteger("-62167219200000000000"), Date.from(Instant.parse("0000-01-01T00:00:00Z")), true}, - {new BigInteger("-62131377719000000000"), Date.from(Instant.parse("0001-02-18T19:58:01Z")), true}, - {BigInteger.valueOf(-1_000_000_000), Date.from(Instant.parse("1969-12-31T23:59:59Z")), true}, - {BigInteger.valueOf(-900_000_000), Date.from(Instant.parse("1969-12-31T23:59:59.1Z")), true}, - {BigInteger.valueOf(-100_000_000), Date.from(Instant.parse("1969-12-31T23:59:59.9Z")), true}, - {BigInteger.ZERO, Date.from(Instant.parse("1970-01-01T00:00:00Z")), true}, - {BigInteger.valueOf(100_000_000), Date.from(Instant.parse("1970-01-01T00:00:00.1Z")), true}, - {BigInteger.valueOf(900_000_000), Date.from(Instant.parse("1970-01-01T00:00:00.9Z")), true}, - {BigInteger.valueOf(1000_000_000), Date.from(Instant.parse("1970-01-01T00:00:01Z")), true}, - {new BigInteger("253374983881000000000"), Date.from(Instant.parse("9999-02-18T19:58:01Z")), true} - }); - TEST_DB.put(pair(BigInteger.class, java.sql.Date.class), new Object[][]{ - {new BigInteger("-62167219200000000000"), new java.sql.Date(Instant.parse("0000-01-01T00:00:00Z").toEpochMilli()), true}, - {new BigInteger("-62131377719000000000"), new java.sql.Date(Instant.parse("0001-02-18T19:58:01Z").toEpochMilli()), true}, - {BigInteger.valueOf(-1_000_000_000), new java.sql.Date(Instant.parse("1969-12-31T23:59:59Z").toEpochMilli()), true}, - {BigInteger.valueOf(-900_000_000), new java.sql.Date(Instant.parse("1969-12-31T23:59:59.1Z").toEpochMilli()), true}, - {BigInteger.valueOf(-100_000_000), new java.sql.Date(Instant.parse("1969-12-31T23:59:59.9Z").toEpochMilli()), true}, - {BigInteger.ZERO, new java.sql.Date(Instant.parse("1970-01-01T00:00:00Z").toEpochMilli()), true}, - {BigInteger.valueOf(100_000_000), new java.sql.Date(Instant.parse("1970-01-01T00:00:00.1Z").toEpochMilli()), true}, - {BigInteger.valueOf(900_000_000), new java.sql.Date(Instant.parse("1970-01-01T00:00:00.9Z").toEpochMilli()), true}, - {BigInteger.valueOf(1000_000_000), new java.sql.Date(Instant.parse("1970-01-01T00:00:01Z").toEpochMilli()), true}, - {new BigInteger("253374983881000000000"), new java.sql.Date(Instant.parse("9999-02-18T19:58:01Z").toEpochMilli()), true} - }); - TEST_DB.put(pair(BigDecimal.class, Date.class), new Object[][] { - { new BigDecimal("-62167219200"), Date.from(Instant.parse("0000-01-01T00:00:00Z")), true }, - { new BigDecimal("-62167219199.999"), Date.from(Instant.parse("0000-01-01T00:00:00.001Z")), true }, - { new BigDecimal("-1.001"), Date.from(Instant.parse("1969-12-31T23:59:58.999Z")), true }, - { new BigDecimal("-1"), Date.from(Instant.parse("1969-12-31T23:59:59Z")), true }, - { new BigDecimal("-0.001"), Date.from(Instant.parse("1969-12-31T23:59:59.999Z")), true }, - { BigDecimal.ZERO, Date.from(Instant.parse("1970-01-01T00:00:00.000000000Z")), true }, - { new BigDecimal("0.001"), Date.from(Instant.parse("1970-01-01T00:00:00.001Z")), true }, - { new BigDecimal(".999"), Date.from(Instant.parse("1970-01-01T00:00:00.999Z")), true }, - { new BigDecimal("1"), Date.from(Instant.parse("1970-01-01T00:00:01Z")), true }, - }); } /** @@ -974,60 +911,22 @@ private static void loadDateTests() { */ private static void loadInstantTests() { TEST_DB.put(pair(Void.class, Instant.class), new Object[][]{ - { null, null } + {null, null} + }); + TEST_DB.put(pair(Instant.class, Instant.class), new Object[][]{ + {Instant.parse("1996-12-24T00:00:00Z"), Instant.parse("1996-12-24T00:00:00Z")} }); TEST_DB.put(pair(String.class, Instant.class), new Object[][]{ - { "", null}, - { " ", null}, - { "1980-01-01T00:00:00Z", Instant.parse("1980-01-01T00:00:00Z"), true}, - { "2024-12-31T23:59:59.999999999Z", Instant.parse("2024-12-31T23:59:59.999999999Z")}, - }); - TEST_DB.put(pair(Long.class, Instant.class), new Object[][]{ - {-62167219200000L, Instant.parse("0000-01-01T00:00:00Z"), true}, - {-62167219199999L, Instant.parse("0000-01-01T00:00:00.001Z"), true}, - {-1000L, Instant.parse("1969-12-31T23:59:59Z"), true}, - {-1L, Instant.parse("1969-12-31T23:59:59.999Z"), true}, - {0L, Instant.parse("1970-01-01T00:00:00Z"), true}, - {1L, Instant.parse("1970-01-01T00:00:00.001Z"), true}, - {999L, Instant.parse("1970-01-01T00:00:00.999Z"), true}, - }); - TEST_DB.put(pair(AtomicLong.class, Instant.class), new Object[][]{ - {new AtomicLong(-62167219200000L), Instant.parse("0000-01-01T00:00:00Z"), true}, - {new AtomicLong(-62167219199999L), Instant.parse("0000-01-01T00:00:00.001Z"), true}, - {new AtomicLong(-1000L), Instant.parse("1969-12-31T23:59:59Z"), true}, - {new AtomicLong(-1L), Instant.parse("1969-12-31T23:59:59.999Z"), true}, - {new AtomicLong(0L), Instant.parse("1970-01-01T00:00:00Z"), true}, - {new AtomicLong(1L), Instant.parse("1970-01-01T00:00:00.001Z"), true}, - {new AtomicLong(999L), Instant.parse("1970-01-01T00:00:00.999Z"), true}, + {"", null}, + {" ", null}, + {"1980-01-01T00:00:00Z", Instant.parse("1980-01-01T00:00:00Z"), true}, + {"2024-12-31T23:59:59.999999999Z", Instant.parse("2024-12-31T23:59:59.999999999Z"), true}, }); TEST_DB.put(pair(Double.class, Instant.class), new Object[][]{ - { -62167219200d, Instant.parse("0000-01-01T00:00:00Z"), true}, - { -0.000000001, Instant.parse("1969-12-31T23:59:59.999999999Z")}, // IEEE-754 precision not good enough for reverse - { 0d, Instant.parse("1970-01-01T00:00:00Z"), true}, - { 0.000000001, Instant.parse("1970-01-01T00:00:00.000000001Z"), true}, - }); - TEST_DB.put(pair(BigInteger.class, Instant.class), new Object[][]{ - { new BigInteger("-62167219200000000000"), Instant.parse("0000-01-01T00:00:00.000000000Z"), true }, - { new BigInteger("-62167219199999999999"), Instant.parse("0000-01-01T00:00:00.000000001Z"), true }, - { BigInteger.valueOf(-1000000000), Instant.parse("1969-12-31T23:59:59.000000000Z"), true }, - { BigInteger.valueOf(-999999999), Instant.parse("1969-12-31T23:59:59.000000001Z"), true }, - { BigInteger.valueOf(-900000000), Instant.parse("1969-12-31T23:59:59.100000000Z"), true }, - { BigInteger.valueOf(-100000000), Instant.parse("1969-12-31T23:59:59.900000000Z"), true }, - { BigInteger.valueOf(-1), Instant.parse("1969-12-31T23:59:59.999999999Z"), true }, - { BigInteger.ZERO, Instant.parse("1970-01-01T00:00:00.000000000Z"), true }, - { BigInteger.valueOf(1), Instant.parse("1970-01-01T00:00:00.000000001Z"), true }, - { BigInteger.valueOf(100000000), Instant.parse("1970-01-01T00:00:00.100000000Z"), true }, - { BigInteger.valueOf(900000000), Instant.parse("1970-01-01T00:00:00.900000000Z"), true }, - { BigInteger.valueOf(999999999), Instant.parse("1970-01-01T00:00:00.999999999Z"), true }, - { BigInteger.valueOf(1000000000), Instant.parse("1970-01-01T00:00:01.000000000Z"), true }, - { new BigInteger("253374983881000000000"), Instant.parse("9999-02-18T19:58:01.000000000Z"), true }, - }); - TEST_DB.put(pair(BigDecimal.class, Instant.class), new Object[][]{ - { new BigDecimal("-62167219200"), Instant.parse("0000-01-01T00:00:00Z"), true}, - { new BigDecimal("-62167219199.999999999"), Instant.parse("0000-01-01T00:00:00.000000001Z"), true}, - { new BigDecimal("-0.000000001"), Instant.parse("1969-12-31T23:59:59.999999999Z"), true}, - { BigDecimal.ZERO, Instant.parse("1970-01-01T00:00:00Z"), true}, - { new BigDecimal("0.000000001"), Instant.parse("1970-01-01T00:00:00.000000001Z"), true}, + {-62167219200d, Instant.parse("0000-01-01T00:00:00Z"), true}, + {-0.000000001, Instant.parse("1969-12-31T23:59:59.999999999Z")}, // IEEE-754 precision not good enough for reverse + {0d, Instant.parse("1970-01-01T00:00:00Z"), true}, + {0.000000001, Instant.parse("1970-01-01T00:00:00.000000001Z"), true}, }); } @@ -1036,86 +935,79 @@ private static void loadInstantTests() { */ private static void loadBigDecimalTests() { TEST_DB.put(pair(Void.class, BigDecimal.class), new Object[][]{ - { null, null } + {null, null} }); TEST_DB.put(pair(String.class, BigDecimal.class), new Object[][]{ - { "3.1415926535897932384626433", new BigDecimal("3.1415926535897932384626433"), true} - }); - TEST_DB.put(pair(Date.class, BigDecimal.class), new Object[][] { - { Date.from(Instant.parse("0000-01-01T00:00:00Z")), new BigDecimal("-62167219200"), true }, - { Date.from(Instant.parse("0000-01-01T00:00:00.001Z")), new BigDecimal("-62167219199.999"), true }, - { Date.from(Instant.parse("1969-12-31T23:59:59.999Z")), new BigDecimal("-0.001"), true }, - { Date.from(Instant.parse("1970-01-01T00:00:00Z")), BigDecimal.ZERO, true }, - { Date.from(Instant.parse("1970-01-01T00:00:00.001Z")), new BigDecimal("0.001"), true }, - }); - TEST_DB.put(pair(java.sql.Date.class, BigDecimal.class), new Object[][] { - { new java.sql.Date(Instant.parse("0000-01-01T00:00:00Z").toEpochMilli()), new BigDecimal("-62167219200"), true }, - { new java.sql.Date(Instant.parse("0000-01-01T00:00:00.001Z").toEpochMilli()), new BigDecimal("-62167219199.999"), true }, - { new java.sql.Date(Instant.parse("1969-12-31T23:59:59.999Z").toEpochMilli()), new BigDecimal("-0.001"), true }, - { new java.sql.Date(Instant.parse("1970-01-01T00:00:00Z").toEpochMilli()), BigDecimal.ZERO, true }, - { new java.sql.Date(Instant.parse("1970-01-01T00:00:00.001Z").toEpochMilli()), new BigDecimal("0.001"), true }, - }); - TEST_DB.put(pair(Timestamp.class, BigDecimal.class), new Object[][] { - { Timestamp.from(Instant.parse("0000-01-01T00:00:00Z")), new BigDecimal("-62167219200"), true }, - { Timestamp.from(Instant.parse("0000-01-01T00:00:00.000000001Z")), new BigDecimal("-62167219199.999999999"), true }, - { Timestamp.from(Instant.parse("1969-12-31T23:59:59.999999999Z")), new BigDecimal("-0.000000001"), true }, - { Timestamp.from(Instant.parse("1970-01-01T00:00:00Z")), BigDecimal.ZERO, true }, - { Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")), new BigDecimal("0.000000001"), true }, + {"3.1415926535897932384626433", new BigDecimal("3.1415926535897932384626433"), true} + }); + TEST_DB.put(pair(Date.class, BigDecimal.class), new Object[][]{ + {Date.from(Instant.parse("0000-01-01T00:00:00Z")), new BigDecimal("-62167219200"), true}, + {Date.from(Instant.parse("0000-01-01T00:00:00.001Z")), new BigDecimal("-62167219199.999"), true}, + {Date.from(Instant.parse("1969-12-31T23:59:59.999Z")), new BigDecimal("-0.001"), true}, + {Date.from(Instant.parse("1970-01-01T00:00:00Z")), BigDecimal.ZERO, true}, + {Date.from(Instant.parse("1970-01-01T00:00:00.001Z")), new BigDecimal("0.001"), true}, + }); + TEST_DB.put(pair(java.sql.Date.class, BigDecimal.class), new Object[][]{ + {new java.sql.Date(Instant.parse("0000-01-01T00:00:00Z").toEpochMilli()), new BigDecimal("-62167219200"), true}, + {new java.sql.Date(Instant.parse("0000-01-01T00:00:00.001Z").toEpochMilli()), new BigDecimal("-62167219199.999"), true}, + {new java.sql.Date(Instant.parse("1969-12-31T23:59:59.999Z").toEpochMilli()), new BigDecimal("-0.001"), true}, + {new java.sql.Date(Instant.parse("1970-01-01T00:00:00Z").toEpochMilli()), BigDecimal.ZERO, true}, + {new java.sql.Date(Instant.parse("1970-01-01T00:00:00.001Z").toEpochMilli()), new BigDecimal("0.001"), true}, + }); + TEST_DB.put(pair(Timestamp.class, BigDecimal.class), new Object[][]{ + {Timestamp.from(Instant.parse("0000-01-01T00:00:00Z")), new BigDecimal("-62167219200"), true}, + {Timestamp.from(Instant.parse("0000-01-01T00:00:00.000000001Z")), new BigDecimal("-62167219199.999999999"), true}, + {Timestamp.from(Instant.parse("1969-12-31T23:59:59.999999999Z")), new BigDecimal("-0.000000001"), true}, + {Timestamp.from(Instant.parse("1970-01-01T00:00:00Z")), BigDecimal.ZERO, true}, + {Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")), new BigDecimal("0.000000001"), true}, }); TEST_DB.put(pair(LocalDate.class, BigDecimal.class), new Object[][]{ - { LocalDate.parse("0000-01-01"), new BigDecimal("-62167252739"), true}, // Proves it always works from "startOfDay", using the zoneId from options - { LocalDate.parse("1969-12-31"), new BigDecimal("-118800"), true}, - { LocalDate.parse("1970-01-01"), new BigDecimal("-32400"), true}, - { LocalDate.parse("1970-01-02"), new BigDecimal("54000"), true}, - { ZonedDateTime.parse("1969-12-31T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDate(), new BigDecimal("-118800"), true}, // Proves it always works from "startOfDay", using the zoneId from options - { ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDate(), new BigDecimal("-118800"), true}, // Proves it always works from "startOfDay", using the zoneId from options - { ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDate(), new BigDecimal("-32400"), true}, // Proves it always works from "startOfDay", using the zoneId from options - { ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDate(), new BigDecimal("-32400"), true}, - { ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z).toLocalDate(), new BigDecimal("-32400"), true}, + {LocalDate.parse("0000-01-01"), new BigDecimal("-62167252739"), true}, // Proves it always works from "startOfDay", using the zoneId from options + {LocalDate.parse("1969-12-31"), new BigDecimal("-118800"), true}, + {LocalDate.parse("1970-01-01"), new BigDecimal("-32400"), true}, + {LocalDate.parse("1970-01-02"), new BigDecimal("54000"), true}, + {ZonedDateTime.parse("1969-12-31T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDate(), new BigDecimal("-118800"), true}, // Proves it always works from "startOfDay", using the zoneId from options + {ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDate(), new BigDecimal("-118800"), true}, // Proves it always works from "startOfDay", using the zoneId from options + {ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDate(), new BigDecimal("-32400"), true}, // Proves it always works from "startOfDay", using the zoneId from options + {ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDate(), new BigDecimal("-32400"), true}, + {ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z).toLocalDate(), new BigDecimal("-32400"), true}, }); TEST_DB.put(pair(LocalDateTime.class, BigDecimal.class), new Object[][]{ - { ZonedDateTime.parse("0000-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), new BigDecimal("-62167219200.0"), true}, - { ZonedDateTime.parse("0000-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), new BigDecimal("-62167219199.999999999"), true}, - { ZonedDateTime.parse("1969-12-31T00:00:00.999999999Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), new BigDecimal("-86399.000000001"), true}, - { ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), new BigDecimal("-32400"), true}, // Time portion affects the answer unlike LocalDate - { ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), BigDecimal.ZERO, true}, - { ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), new BigDecimal("0.000000001"), true}, - }); - TEST_DB.put(pair(ZonedDateTime.class, BigDecimal.class), new Object[][] { // no reverse due to .toString adding zone offset - { ZonedDateTime.parse("0000-01-01T00:00:00Z"), new BigDecimal("-62167219200") }, - { ZonedDateTime.parse("0000-01-01T00:00:00.000000001Z"), new BigDecimal("-62167219199.999999999") }, - { ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z"), new BigDecimal("-0.000000001") }, - { ZonedDateTime.parse("1970-01-01T00:00:00Z"), BigDecimal.ZERO }, - { ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z"), new BigDecimal("0.000000001") }, - }); - TEST_DB.put(pair(OffsetDateTime.class, BigDecimal.class), new Object[][] { // no reverse due to .toString adding zone offset - { OffsetDateTime.parse("0000-01-01T00:00:00Z"), new BigDecimal("-62167219200") }, - { OffsetDateTime.parse("0000-01-01T00:00:00.000000001Z"), new BigDecimal("-62167219199.999999999") }, - { OffsetDateTime.parse("1969-12-31T23:59:59.999999999Z"), new BigDecimal("-0.000000001") }, - { OffsetDateTime.parse("1970-01-01T00:00:00Z"), BigDecimal.ZERO }, - { OffsetDateTime.parse("1970-01-01T00:00:00.000000001Z"), new BigDecimal("0.000000001") }, - }); - TEST_DB.put(pair(Duration.class, BigDecimal.class), new Object[][] { - { Duration.ofSeconds(-1, -1), new BigDecimal("-1.000000001"), true }, - { Duration.ofSeconds(-1), new BigDecimal("-1"), true }, - { Duration.ofSeconds(0), BigDecimal.ZERO, true }, - { Duration.ofSeconds(1), new BigDecimal("1"), true }, - { Duration.ofNanos(1), new BigDecimal("0.000000001"), true }, - { Duration.ofNanos(1_000_000_000), new BigDecimal("1"), true }, - { Duration.ofNanos(2_000_000_001), new BigDecimal("2.000000001"), true }, - { Duration.ofSeconds(10, 9), new BigDecimal("10.000000009"), true }, - { Duration.ofDays(1), new BigDecimal("86400"), true}, + {ZonedDateTime.parse("0000-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), new BigDecimal("-62167219200.0"), true}, + {ZonedDateTime.parse("0000-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), new BigDecimal("-62167219199.999999999"), true}, + {ZonedDateTime.parse("1969-12-31T00:00:00.999999999Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), new BigDecimal("-86399.000000001"), true}, + {ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), new BigDecimal("-32400"), true}, // Time portion affects the answer unlike LocalDate + {ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), BigDecimal.ZERO, true}, + {ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), new BigDecimal("0.000000001"), true}, + }); + TEST_DB.put(pair(OffsetDateTime.class, BigDecimal.class), new Object[][]{ // no reverse due to .toString adding zone offset + {OffsetDateTime.parse("0000-01-01T00:00:00Z"), new BigDecimal("-62167219200")}, + {OffsetDateTime.parse("0000-01-01T00:00:00.000000001Z"), new BigDecimal("-62167219199.999999999")}, + {OffsetDateTime.parse("1969-12-31T23:59:59.999999999Z"), new BigDecimal("-0.000000001")}, + {OffsetDateTime.parse("1970-01-01T00:00:00Z"), BigDecimal.ZERO}, + {OffsetDateTime.parse("1970-01-01T00:00:00.000000001Z"), new BigDecimal("0.000000001")}, + }); + TEST_DB.put(pair(Duration.class, BigDecimal.class), new Object[][]{ + {Duration.ofSeconds(-1, -1), new BigDecimal("-1.000000001"), true}, + {Duration.ofSeconds(-1), new BigDecimal("-1"), true}, + {Duration.ofSeconds(0), BigDecimal.ZERO, true}, + {Duration.ofSeconds(1), new BigDecimal("1"), true}, + {Duration.ofNanos(1), new BigDecimal("0.000000001"), true}, + {Duration.ofNanos(1_000_000_000), new BigDecimal("1"), true}, + {Duration.ofNanos(2_000_000_001), new BigDecimal("2.000000001"), true}, + {Duration.ofSeconds(10, 9), new BigDecimal("10.000000009"), true}, + {Duration.ofDays(1), new BigDecimal("86400"), true}, }); TEST_DB.put(pair(Instant.class, BigDecimal.class), new Object[][]{ // JDK 1.8 cannot handle the format +01:00 in Instant.parse(). JDK11+ handles it fine. - { Instant.parse("0000-01-01T00:00:00Z"), new BigDecimal("-62167219200.0"), true}, - { Instant.parse("0000-01-01T00:00:00.000000001Z"), new BigDecimal("-62167219199.999999999"), true}, - { Instant.parse("1969-12-31T00:00:00Z"), new BigDecimal("-86400"), true}, - { Instant.parse("1969-12-31T00:00:00.999999999Z"), new BigDecimal("-86399.000000001"), true }, - { Instant.parse("1969-12-31T23:59:59.999999999Z"), new BigDecimal("-0.000000001"), true }, - { Instant.parse("1970-01-01T00:00:00Z"), BigDecimal.ZERO, true}, - { Instant.parse("1970-01-01T00:00:00.000000001Z"), new BigDecimal("0.000000001"), true}, - { Instant.parse("1970-01-02T00:00:00Z"), new BigDecimal("86400"), true}, - { Instant.parse("1970-01-02T00:00:00.000000001Z"), new BigDecimal("86400.000000001"), true}, + {Instant.parse("0000-01-01T00:00:00Z"), new BigDecimal("-62167219200.0"), true}, + {Instant.parse("0000-01-01T00:00:00.000000001Z"), new BigDecimal("-62167219199.999999999"), true}, + {Instant.parse("1969-12-31T00:00:00Z"), new BigDecimal("-86400"), true}, + {Instant.parse("1969-12-31T00:00:00.999999999Z"), new BigDecimal("-86399.000000001"), true}, + {Instant.parse("1969-12-31T23:59:59.999999999Z"), new BigDecimal("-0.000000001"), true}, + {Instant.parse("1970-01-01T00:00:00Z"), BigDecimal.ZERO, true}, + {Instant.parse("1970-01-01T00:00:00.000000001Z"), new BigDecimal("0.000000001"), true}, + {Instant.parse("1970-01-02T00:00:00Z"), new BigDecimal("86400"), true}, + {Instant.parse("1970-01-02T00:00:00.000000001Z"), new BigDecimal("86400.000000001"), true}, }); } @@ -1124,192 +1016,172 @@ private static void loadBigDecimalTests() { */ private static void loadBigIntegerTests() { TEST_DB.put(pair(Void.class, BigInteger.class), new Object[][]{ - { null, null }, + {null, null}, }); TEST_DB.put(pair(Byte.class, BigInteger.class), new Object[][]{ - { (byte) -1, BigInteger.valueOf(-1), true }, - { (byte) 0, BigInteger.ZERO, true }, - { Byte.MIN_VALUE, BigInteger.valueOf(Byte.MIN_VALUE), true }, - { Byte.MAX_VALUE, BigInteger.valueOf(Byte.MAX_VALUE), true }, + {(byte) -1, BigInteger.valueOf(-1), true}, + {(byte) 0, BigInteger.ZERO, true}, + {Byte.MIN_VALUE, BigInteger.valueOf(Byte.MIN_VALUE), true}, + {Byte.MAX_VALUE, BigInteger.valueOf(Byte.MAX_VALUE), true}, }); TEST_DB.put(pair(Short.class, BigInteger.class), new Object[][]{ - { (short) -1, BigInteger.valueOf(-1), true }, - { (short) 0, BigInteger.ZERO, true }, - { Short.MIN_VALUE, BigInteger.valueOf(Short.MIN_VALUE), true }, - { Short.MAX_VALUE, BigInteger.valueOf(Short.MAX_VALUE), true }, + {(short) -1, BigInteger.valueOf(-1), true}, + {(short) 0, BigInteger.ZERO, true}, + {Short.MIN_VALUE, BigInteger.valueOf(Short.MIN_VALUE), true}, + {Short.MAX_VALUE, BigInteger.valueOf(Short.MAX_VALUE), true}, }); TEST_DB.put(pair(Integer.class, BigInteger.class), new Object[][]{ - { -1, BigInteger.valueOf(-1), true }, - { 0, BigInteger.ZERO, true }, - { Integer.MIN_VALUE, BigInteger.valueOf(Integer.MIN_VALUE), true }, - { Integer.MAX_VALUE, BigInteger.valueOf(Integer.MAX_VALUE), true }, + {-1, BigInteger.valueOf(-1), true}, + {0, BigInteger.ZERO, true}, + {Integer.MIN_VALUE, BigInteger.valueOf(Integer.MIN_VALUE), true}, + {Integer.MAX_VALUE, BigInteger.valueOf(Integer.MAX_VALUE), true}, }); TEST_DB.put(pair(Long.class, BigInteger.class), new Object[][]{ - { -1L, BigInteger.valueOf(-1), true }, - { 0L, BigInteger.ZERO, true }, - { Long.MIN_VALUE, BigInteger.valueOf(Long.MIN_VALUE), true }, - { Long.MAX_VALUE, BigInteger.valueOf(Long.MAX_VALUE), true }, + {-1L, BigInteger.valueOf(-1), true}, + {0L, BigInteger.ZERO, true}, + {Long.MIN_VALUE, BigInteger.valueOf(Long.MIN_VALUE), true}, + {Long.MAX_VALUE, BigInteger.valueOf(Long.MAX_VALUE), true}, }); TEST_DB.put(pair(Float.class, BigInteger.class), new Object[][]{ - { -1f, BigInteger.valueOf(-1), true }, - { 0f, BigInteger.ZERO, true }, - { 1.0e6f, new BigInteger("1000000"), true }, - { -16777216f, BigInteger.valueOf(-16777216), true }, - { 16777216f, BigInteger.valueOf(16777216), true }, + {-1f, BigInteger.valueOf(-1), true}, + {0f, BigInteger.ZERO, true}, + {1.0e6f, new BigInteger("1000000"), true}, + {-16777216f, BigInteger.valueOf(-16777216), true}, + {16777216f, BigInteger.valueOf(16777216), true}, }); TEST_DB.put(pair(Double.class, BigInteger.class), new Object[][]{ - { -1d, BigInteger.valueOf(-1), true }, - { 0d, BigInteger.ZERO, true }, - { 1.0e9d, new BigInteger("1000000000"), true }, - { -9007199254740991d, BigInteger.valueOf(-9007199254740991L), true }, - { 9007199254740991d, BigInteger.valueOf(9007199254740991L), true }, + {-1d, BigInteger.valueOf(-1), true}, + {0d, BigInteger.ZERO, true}, + {1.0e9d, new BigInteger("1000000000"), true}, + {-9007199254740991d, BigInteger.valueOf(-9007199254740991L), true}, + {9007199254740991d, BigInteger.valueOf(9007199254740991L), true}, }); TEST_DB.put(pair(Boolean.class, BigInteger.class), new Object[][]{ - { false, BigInteger.ZERO, true }, - { true, BigInteger.valueOf(1), true }, + {false, BigInteger.ZERO, true}, + {true, BigInteger.valueOf(1), true}, }); TEST_DB.put(pair(Character.class, BigInteger.class), new Object[][]{ - { (char) 0, BigInteger.ZERO, true }, - { (char) 1, BigInteger.valueOf(1), true }, - { (char) 65535, BigInteger.valueOf(65535), true }, + {(char) 0, BigInteger.ZERO, true}, + {(char) 1, BigInteger.valueOf(1), true}, + {(char) 65535, BigInteger.valueOf(65535), true}, }); TEST_DB.put(pair(BigInteger.class, BigInteger.class), new Object[][]{ - { new BigInteger("16"), BigInteger.valueOf(16), true }, + {new BigInteger("16"), BigInteger.valueOf(16), true}, }); TEST_DB.put(pair(BigDecimal.class, BigInteger.class), new Object[][]{ - { BigDecimal.ZERO, BigInteger.ZERO, true }, - { BigDecimal.valueOf(-1), BigInteger.valueOf(-1), true }, - { BigDecimal.valueOf(-1.1), BigInteger.valueOf(-1) }, - { BigDecimal.valueOf(-1.9), BigInteger.valueOf(-1) }, - { BigDecimal.valueOf(1.9), BigInteger.valueOf(1) }, - { BigDecimal.valueOf(1.1), BigInteger.valueOf(1) }, - { BigDecimal.valueOf(1.0e6d), new BigInteger("1000000") }, - { BigDecimal.valueOf(-16777216), BigInteger.valueOf(-16777216), true }, + {BigDecimal.ZERO, BigInteger.ZERO, true}, + {BigDecimal.valueOf(-1), BigInteger.valueOf(-1), true}, + {BigDecimal.valueOf(-1.1), BigInteger.valueOf(-1)}, + {BigDecimal.valueOf(-1.9), BigInteger.valueOf(-1)}, + {BigDecimal.valueOf(1.9), BigInteger.valueOf(1)}, + {BigDecimal.valueOf(1.1), BigInteger.valueOf(1)}, + {BigDecimal.valueOf(1.0e6d), new BigInteger("1000000")}, + {BigDecimal.valueOf(-16777216), BigInteger.valueOf(-16777216), true}, }); TEST_DB.put(pair(AtomicBoolean.class, BigInteger.class), new Object[][]{ - { new AtomicBoolean(false), BigInteger.ZERO }, - { new AtomicBoolean(true), BigInteger.valueOf(1) }, + {new AtomicBoolean(false), BigInteger.ZERO}, + {new AtomicBoolean(true), BigInteger.valueOf(1)}, }); TEST_DB.put(pair(AtomicInteger.class, BigInteger.class), new Object[][]{ - { new AtomicInteger(-1), BigInteger.valueOf(-1) }, - { new AtomicInteger(0), BigInteger.ZERO }, - { new AtomicInteger(Integer.MIN_VALUE), BigInteger.valueOf(Integer.MIN_VALUE) }, - { new AtomicInteger(Integer.MAX_VALUE), BigInteger.valueOf(Integer.MAX_VALUE) }, + {new AtomicInteger(-1), BigInteger.valueOf(-1)}, + {new AtomicInteger(0), BigInteger.ZERO}, + {new AtomicInteger(Integer.MIN_VALUE), BigInteger.valueOf(Integer.MIN_VALUE)}, + {new AtomicInteger(Integer.MAX_VALUE), BigInteger.valueOf(Integer.MAX_VALUE)}, }); TEST_DB.put(pair(AtomicLong.class, BigInteger.class), new Object[][]{ - { new AtomicLong(-1), BigInteger.valueOf(-1) }, - { new AtomicLong(0), BigInteger.ZERO }, - { new AtomicLong(Long.MIN_VALUE), BigInteger.valueOf(Long.MIN_VALUE) }, - { new AtomicLong(Long.MAX_VALUE), BigInteger.valueOf(Long.MAX_VALUE) }, + {new AtomicLong(-1), BigInteger.valueOf(-1)}, + {new AtomicLong(0), BigInteger.ZERO}, + {new AtomicLong(Long.MIN_VALUE), BigInteger.valueOf(Long.MIN_VALUE)}, + {new AtomicLong(Long.MAX_VALUE), BigInteger.valueOf(Long.MAX_VALUE)}, }); TEST_DB.put(pair(Date.class, BigInteger.class), new Object[][]{ - { Date.from(Instant.parse("0000-01-01T00:00:00Z")), new BigInteger("-62167219200000000000"), true }, - { Date.from(Instant.parse("0001-02-18T19:58:01Z")), new BigInteger("-62131377719000000000"), true }, - { Date.from(Instant.parse("1969-12-31T23:59:59Z")), BigInteger.valueOf(-1_000_000_000), true }, - { Date.from(Instant.parse("1969-12-31T23:59:59.1Z")), BigInteger.valueOf(-900000000), true }, - { Date.from(Instant.parse("1969-12-31T23:59:59.9Z")), BigInteger.valueOf(-100000000), true }, - { Date.from(Instant.parse("1970-01-01T00:00:00Z")), BigInteger.ZERO, true }, - { Date.from(Instant.parse("1970-01-01T00:00:00.1Z")), BigInteger.valueOf(100000000), true }, - { Date.from(Instant.parse("1970-01-01T00:00:00.9Z")), BigInteger.valueOf(900000000), true }, - { Date.from(Instant.parse("1970-01-01T00:00:01Z")), BigInteger.valueOf(1000000000), true }, - { Date.from(Instant.parse("9999-02-18T19:58:01Z")), new BigInteger("253374983881000000000"), true }, + {Date.from(Instant.parse("0000-01-01T00:00:00Z")), new BigInteger("-62167219200000000000"), true}, + {Date.from(Instant.parse("0001-02-18T19:58:01Z")), new BigInteger("-62131377719000000000"), true}, + {Date.from(Instant.parse("1969-12-31T23:59:59Z")), BigInteger.valueOf(-1_000_000_000), true}, + {Date.from(Instant.parse("1969-12-31T23:59:59.1Z")), BigInteger.valueOf(-900000000), true}, + {Date.from(Instant.parse("1969-12-31T23:59:59.9Z")), BigInteger.valueOf(-100000000), true}, + {Date.from(Instant.parse("1970-01-01T00:00:00Z")), BigInteger.ZERO, true}, + {Date.from(Instant.parse("1970-01-01T00:00:00.1Z")), BigInteger.valueOf(100000000), true}, + {Date.from(Instant.parse("1970-01-01T00:00:00.9Z")), BigInteger.valueOf(900000000), true}, + {Date.from(Instant.parse("1970-01-01T00:00:01Z")), BigInteger.valueOf(1000000000), true}, + {Date.from(Instant.parse("9999-02-18T19:58:01Z")), new BigInteger("253374983881000000000"), true}, }); TEST_DB.put(pair(java.sql.Date.class, BigInteger.class), new Object[][]{ - { new java.sql.Date(Instant.parse("0000-01-01T00:00:00Z").toEpochMilli()), new BigInteger("-62167219200000000000"), true }, - { new java.sql.Date(Instant.parse("0001-02-18T19:58:01Z").toEpochMilli()), new BigInteger("-62131377719000000000"), true }, - { new java.sql.Date(Instant.parse("1969-12-31T23:59:59Z").toEpochMilli()), BigInteger.valueOf(-1_000_000_000), true }, - { new java.sql.Date(Instant.parse("1969-12-31T23:59:59.1Z").toEpochMilli()), BigInteger.valueOf(-900000000), true }, - { new java.sql.Date(Instant.parse("1969-12-31T23:59:59.9Z").toEpochMilli()), BigInteger.valueOf(-100000000), true }, - { new java.sql.Date(Instant.parse("1970-01-01T00:00:00Z").toEpochMilli()), BigInteger.ZERO, true }, - { new java.sql.Date(Instant.parse("1970-01-01T00:00:00.1Z").toEpochMilli()), BigInteger.valueOf(100000000), true }, - { new java.sql.Date(Instant.parse("1970-01-01T00:00:00.9Z").toEpochMilli()), BigInteger.valueOf(900000000), true }, - { new java.sql.Date(Instant.parse("1970-01-01T00:00:01Z").toEpochMilli()), BigInteger.valueOf(1000000000), true }, - { new java.sql.Date(Instant.parse("9999-02-18T19:58:01Z").toEpochMilli()), new BigInteger("253374983881000000000"), true }, + {new java.sql.Date(Instant.parse("0000-01-01T00:00:00Z").toEpochMilli()), new BigInteger("-62167219200000000000"), true}, + {new java.sql.Date(Instant.parse("0001-02-18T19:58:01Z").toEpochMilli()), new BigInteger("-62131377719000000000"), true}, + {new java.sql.Date(Instant.parse("1969-12-31T23:59:59Z").toEpochMilli()), BigInteger.valueOf(-1_000_000_000), true}, + {new java.sql.Date(Instant.parse("1969-12-31T23:59:59.1Z").toEpochMilli()), BigInteger.valueOf(-900000000), true}, + {new java.sql.Date(Instant.parse("1969-12-31T23:59:59.9Z").toEpochMilli()), BigInteger.valueOf(-100000000), true}, + {new java.sql.Date(Instant.parse("1970-01-01T00:00:00Z").toEpochMilli()), BigInteger.ZERO, true}, + {new java.sql.Date(Instant.parse("1970-01-01T00:00:00.1Z").toEpochMilli()), BigInteger.valueOf(100000000), true}, + {new java.sql.Date(Instant.parse("1970-01-01T00:00:00.9Z").toEpochMilli()), BigInteger.valueOf(900000000), true}, + {new java.sql.Date(Instant.parse("1970-01-01T00:00:01Z").toEpochMilli()), BigInteger.valueOf(1000000000), true}, + {new java.sql.Date(Instant.parse("9999-02-18T19:58:01Z").toEpochMilli()), new BigInteger("253374983881000000000"), true}, }); TEST_DB.put(pair(Timestamp.class, BigInteger.class), new Object[][]{ - { Timestamp.from(Instant.parse("0000-01-01T00:00:00.000000000Z")), new BigInteger("-62167219200000000000"), true }, - { Timestamp.from(Instant.parse("0001-02-18T19:58:01.000000000Z")), new BigInteger("-62131377719000000000"), true }, - { Timestamp.from(Instant.parse("1969-12-31T23:59:59.000000000Z")), BigInteger.valueOf(-1000000000), true }, - { Timestamp.from(Instant.parse("1969-12-31T23:59:59.000000001Z")), BigInteger.valueOf(-999999999), true }, - { Timestamp.from(Instant.parse("1969-12-31T23:59:59.100000000Z")), BigInteger.valueOf(-900000000), true }, - { Timestamp.from(Instant.parse("1969-12-31T23:59:59.900000000Z")), BigInteger.valueOf(-100000000), true }, - { Timestamp.from(Instant.parse("1969-12-31T23:59:59.999999999Z")), BigInteger.valueOf(-1), true }, - { Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000000Z")), BigInteger.ZERO, true }, - { Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")), BigInteger.valueOf(1), true }, - { Timestamp.from(Instant.parse("1970-01-01T00:00:00.100000000Z")), BigInteger.valueOf(100000000), true }, - { Timestamp.from(Instant.parse("1970-01-01T00:00:00.900000000Z")), BigInteger.valueOf(900000000), true }, - { Timestamp.from(Instant.parse("1970-01-01T00:00:00.999999999Z")), BigInteger.valueOf(999999999), true }, - { Timestamp.from(Instant.parse("1970-01-01T00:00:01.000000000Z")), BigInteger.valueOf(1000000000), true }, - { Timestamp.from(Instant.parse("9999-02-18T19:58:01.000000000Z")), new BigInteger("253374983881000000000"), true }, - }); - TEST_DB.put(pair(Duration.class, BigInteger.class), new Object[][] { - { Duration.ofNanos(-1000000), BigInteger.valueOf(-1000000), true}, - { Duration.ofNanos(-1000), BigInteger.valueOf(-1000), true}, - { Duration.ofNanos(-1), BigInteger.valueOf(-1), true}, - { Duration.ofNanos(0), BigInteger.ZERO, true}, - { Duration.ofNanos(1), BigInteger.valueOf(1), true}, - { Duration.ofNanos(1000), BigInteger.valueOf(1000), true}, - { Duration.ofNanos(1000000), BigInteger.valueOf(1000000), true}, - { Duration.ofNanos(Integer.MAX_VALUE), BigInteger.valueOf(Integer.MAX_VALUE), true}, - { Duration.ofNanos(Integer.MIN_VALUE), BigInteger.valueOf(Integer.MIN_VALUE), true}, - { Duration.ofNanos(Long.MAX_VALUE), BigInteger.valueOf(Long.MAX_VALUE), true}, - { Duration.ofNanos(Long.MIN_VALUE), BigInteger.valueOf(Long.MIN_VALUE), true}, + {Timestamp.from(Instant.parse("0000-01-01T00:00:00.000000000Z")), new BigInteger("-62167219200000000000"), true}, + {Timestamp.from(Instant.parse("0001-02-18T19:58:01.000000000Z")), new BigInteger("-62131377719000000000"), true}, + {Timestamp.from(Instant.parse("1969-12-31T23:59:59.000000000Z")), BigInteger.valueOf(-1000000000), true}, + {Timestamp.from(Instant.parse("1969-12-31T23:59:59.000000001Z")), BigInteger.valueOf(-999999999), true}, + {Timestamp.from(Instant.parse("1969-12-31T23:59:59.100000000Z")), BigInteger.valueOf(-900000000), true}, + {Timestamp.from(Instant.parse("1969-12-31T23:59:59.900000000Z")), BigInteger.valueOf(-100000000), true}, + {Timestamp.from(Instant.parse("1969-12-31T23:59:59.999999999Z")), BigInteger.valueOf(-1), true}, + {Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000000Z")), BigInteger.ZERO, true}, + {Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")), BigInteger.valueOf(1), true}, + {Timestamp.from(Instant.parse("1970-01-01T00:00:00.100000000Z")), BigInteger.valueOf(100000000), true}, + {Timestamp.from(Instant.parse("1970-01-01T00:00:00.900000000Z")), BigInteger.valueOf(900000000), true}, + {Timestamp.from(Instant.parse("1970-01-01T00:00:00.999999999Z")), BigInteger.valueOf(999999999), true}, + {Timestamp.from(Instant.parse("1970-01-01T00:00:01.000000000Z")), BigInteger.valueOf(1000000000), true}, + {Timestamp.from(Instant.parse("9999-02-18T19:58:01.000000000Z")), new BigInteger("253374983881000000000"), true}, }); TEST_DB.put(pair(Instant.class, BigInteger.class), new Object[][]{ - { Instant.parse("0000-01-01T00:00:00.000000000Z"), new BigInteger("-62167219200000000000"), true }, - { Instant.parse("0000-01-01T00:00:00.000000001Z"), new BigInteger("-62167219199999999999"), true }, - { Instant.parse("1969-12-31T23:59:59.000000000Z"), BigInteger.valueOf(-1000000000), true }, - { Instant.parse("1969-12-31T23:59:59.000000001Z"), BigInteger.valueOf(-999999999), true }, - { Instant.parse("1969-12-31T23:59:59.100000000Z"), BigInteger.valueOf(-900000000), true }, - { Instant.parse("1969-12-31T23:59:59.900000000Z"), BigInteger.valueOf(-100000000), true }, - { Instant.parse("1969-12-31T23:59:59.999999999Z"), BigInteger.valueOf(-1), true }, - { Instant.parse("1970-01-01T00:00:00.000000000Z"), BigInteger.ZERO, true }, - { Instant.parse("1970-01-01T00:00:00.000000001Z"), BigInteger.valueOf(1), true }, - { Instant.parse("1970-01-01T00:00:00.100000000Z"), BigInteger.valueOf(100000000), true }, - { Instant.parse("1970-01-01T00:00:00.900000000Z"), BigInteger.valueOf(900000000), true }, - { Instant.parse("1970-01-01T00:00:00.999999999Z"), BigInteger.valueOf(999999999), true }, - { Instant.parse("1970-01-01T00:00:01.000000000Z"), BigInteger.valueOf(1000000000), true }, - { Instant.parse("9999-02-18T19:58:01.000000000Z"), new BigInteger("253374983881000000000"), true }, + {Instant.parse("0000-01-01T00:00:00.000000000Z"), new BigInteger("-62167219200000000000"), true}, + {Instant.parse("0000-01-01T00:00:00.000000001Z"), new BigInteger("-62167219199999999999"), true}, + {Instant.parse("1969-12-31T23:59:59.000000000Z"), BigInteger.valueOf(-1000000000), true}, + {Instant.parse("1969-12-31T23:59:59.000000001Z"), BigInteger.valueOf(-999999999), true}, + {Instant.parse("1969-12-31T23:59:59.100000000Z"), BigInteger.valueOf(-900000000), true}, + {Instant.parse("1969-12-31T23:59:59.900000000Z"), BigInteger.valueOf(-100000000), true}, + {Instant.parse("1969-12-31T23:59:59.999999999Z"), BigInteger.valueOf(-1), true}, + {Instant.parse("1970-01-01T00:00:00.000000000Z"), BigInteger.ZERO, true}, + {Instant.parse("1970-01-01T00:00:00.000000001Z"), BigInteger.valueOf(1), true}, + {Instant.parse("1970-01-01T00:00:00.100000000Z"), BigInteger.valueOf(100000000), true}, + {Instant.parse("1970-01-01T00:00:00.900000000Z"), BigInteger.valueOf(900000000), true}, + {Instant.parse("1970-01-01T00:00:00.999999999Z"), BigInteger.valueOf(999999999), true}, + {Instant.parse("1970-01-01T00:00:01.000000000Z"), BigInteger.valueOf(1000000000), true}, + {Instant.parse("9999-02-18T19:58:01.000000000Z"), new BigInteger("253374983881000000000"), true}, }); TEST_DB.put(pair(LocalDate.class, BigInteger.class), new Object[][]{ - { ZonedDateTime.parse("1969-12-31T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDate(), new BigInteger("-118800000000000"), true}, // Proves it always works from "startOfDay", using the zoneId from options - { ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDate(), new BigInteger("-118800000000000"), true}, // Proves it always works from "startOfDay", using the zoneId from options - { ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDate(), new BigInteger("-32400000000000"), true}, // Proves it always works from "startOfDay", using the zoneId from options - { ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDate(), new BigInteger("-32400000000000"), true}, - { ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z).toLocalDate(), new BigInteger("-32400000000000"), true}, + {ZonedDateTime.parse("1969-12-31T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDate(), new BigInteger("-118800000000000"), true}, // Proves it always works from "startOfDay", using the zoneId from options + {ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDate(), new BigInteger("-118800000000000"), true}, // Proves it always works from "startOfDay", using the zoneId from options + {ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDate(), new BigInteger("-32400000000000"), true}, // Proves it always works from "startOfDay", using the zoneId from options + {ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDate(), new BigInteger("-32400000000000"), true}, + {ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z).toLocalDate(), new BigInteger("-32400000000000"), true}, }); TEST_DB.put(pair(LocalDateTime.class, BigInteger.class), new Object[][]{ - { ZonedDateTime.parse("0000-01-01T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), new BigInteger("-62167252739000000000"), true}, - { ZonedDateTime.parse("0000-01-01T00:00:00.000000001Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), new BigInteger("-62167252738999999999"), true}, - { ZonedDateTime.parse("1969-12-31T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), new BigInteger("-118800000000000"), true}, - { ZonedDateTime.parse("1969-12-31T00:00:00.000000001Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), new BigInteger("-118799999999999"), true}, - { ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), new BigInteger("-32400000000001"), true}, - { ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), new BigInteger("-32400000000000"), true}, - { ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), new BigInteger("-1"), true}, - { ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), BigInteger.ZERO, true}, - { ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), new BigInteger("1"), true}, - }); - TEST_DB.put(pair(ZonedDateTime.class, BigInteger.class), new Object[][]{ // ZonedDateTime .toString() prevents reverse test - { ZonedDateTime.parse("0000-01-01T00:00:00Z"), new BigInteger("-62167219200000000000") }, - { ZonedDateTime.parse("0000-01-01T00:00:00.000000001Z"), new BigInteger("-62167219199999999999") }, - { ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z"), new BigInteger("-1") }, - { ZonedDateTime.parse("1970-01-01T00:00:00Z"), BigInteger.ZERO }, - { ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z"), new BigInteger("1") }, + {ZonedDateTime.parse("0000-01-01T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), new BigInteger("-62167252739000000000"), true}, + {ZonedDateTime.parse("0000-01-01T00:00:00.000000001Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), new BigInteger("-62167252738999999999"), true}, + {ZonedDateTime.parse("1969-12-31T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), new BigInteger("-118800000000000"), true}, + {ZonedDateTime.parse("1969-12-31T00:00:00.000000001Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), new BigInteger("-118799999999999"), true}, + {ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), new BigInteger("-32400000000001"), true}, + {ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(ZoneId.of("UTC")).toLocalDateTime(), new BigInteger("-32400000000000"), true}, + {ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), new BigInteger("-1"), true}, + {ZonedDateTime.parse("1970-01-01T00:00:00Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), BigInteger.ZERO, true}, + {ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), new BigInteger("1"), true}, }); TEST_DB.put(pair(UUID.class, BigInteger.class), new Object[][]{ - { new UUID(0L, 0L), BigInteger.ZERO, true }, - { new UUID(1L, 1L), new BigInteger("18446744073709551617"), true }, - { new UUID(Long.MAX_VALUE, Long.MAX_VALUE), new BigInteger("170141183460469231722463931679029329919"), true }, - { UUID.fromString("00000000-0000-0000-0000-000000000000"), BigInteger.ZERO, true }, - { UUID.fromString("00000000-0000-0000-0000-000000000001"), BigInteger.valueOf(1), true }, - { UUID.fromString("00000000-0000-0001-0000-000000000001"), new BigInteger("18446744073709551617"), true }, - { UUID.fromString("ffffffff-ffff-ffff-ffff-ffffffffffff"), new BigInteger("340282366920938463463374607431768211455"), true }, - { UUID.fromString("ffffffff-ffff-ffff-ffff-fffffffffffe"), new BigInteger("340282366920938463463374607431768211454"), true }, - { UUID.fromString("f0000000-0000-0000-0000-000000000000"), new BigInteger("319014718988379809496913694467282698240"), true }, - { UUID.fromString("f0000000-0000-0000-0000-000000000001"), new BigInteger("319014718988379809496913694467282698241"), true }, - { UUID.fromString("7fffffff-ffff-ffff-ffff-fffffffffffe"), new BigInteger("170141183460469231731687303715884105726"), true }, - { UUID.fromString("7fffffff-ffff-ffff-ffff-ffffffffffff"), new BigInteger("170141183460469231731687303715884105727"), true }, - { UUID.fromString("80000000-0000-0000-0000-000000000000"), new BigInteger("170141183460469231731687303715884105728"), true }, + {new UUID(0L, 0L), BigInteger.ZERO, true}, + {new UUID(1L, 1L), new BigInteger("18446744073709551617"), true}, + {new UUID(Long.MAX_VALUE, Long.MAX_VALUE), new BigInteger("170141183460469231722463931679029329919"), true}, + {UUID.fromString("00000000-0000-0000-0000-000000000000"), BigInteger.ZERO, true}, + {UUID.fromString("00000000-0000-0000-0000-000000000001"), BigInteger.valueOf(1), true}, + {UUID.fromString("00000000-0000-0001-0000-000000000001"), new BigInteger("18446744073709551617"), true}, + {UUID.fromString("ffffffff-ffff-ffff-ffff-ffffffffffff"), new BigInteger("340282366920938463463374607431768211455"), true}, + {UUID.fromString("ffffffff-ffff-ffff-ffff-fffffffffffe"), new BigInteger("340282366920938463463374607431768211454"), true}, + {UUID.fromString("f0000000-0000-0000-0000-000000000000"), new BigInteger("319014718988379809496913694467282698240"), true}, + {UUID.fromString("f0000000-0000-0000-0000-000000000001"), new BigInteger("319014718988379809496913694467282698241"), true}, + {UUID.fromString("7fffffff-ffff-ffff-ffff-fffffffffffe"), new BigInteger("170141183460469231731687303715884105726"), true}, + {UUID.fromString("7fffffff-ffff-ffff-ffff-ffffffffffff"), new BigInteger("170141183460469231731687303715884105727"), true}, + {UUID.fromString("80000000-0000-0000-0000-000000000000"), new BigInteger("170141183460469231731687303715884105728"), true}, }); TEST_DB.put(pair(Calendar.class, BigInteger.class), new Object[][]{ {(Supplier) () -> { @@ -1331,11 +1203,11 @@ private static void loadBigIntegerTests() { {"0.0", BigInteger.ZERO}, }); TEST_DB.put(pair(OffsetDateTime.class, BigInteger.class), new Object[][]{ - { OffsetDateTime.parse("0000-01-01T00:00:00Z"), new BigInteger("-62167219200000000000") }, - { OffsetDateTime.parse("0000-01-01T00:00:00.000000001Z"), new BigInteger("-62167219199999999999") }, - { OffsetDateTime.parse("1969-12-31T23:59:59.999999999Z"), new BigInteger("-1") }, - { OffsetDateTime.parse("1970-01-01T00:00:00Z"), BigInteger.ZERO }, - { OffsetDateTime.parse("1970-01-01T00:00:00.000000001Z"), new BigInteger("1") }, + {OffsetDateTime.parse("0000-01-01T00:00:00Z"), new BigInteger("-62167219200000000000")}, + {OffsetDateTime.parse("0000-01-01T00:00:00.000000001Z"), new BigInteger("-62167219199999999999")}, + {OffsetDateTime.parse("1969-12-31T23:59:59.999999999Z"), new BigInteger("-1")}, + {OffsetDateTime.parse("1970-01-01T00:00:00Z"), BigInteger.ZERO}, + {OffsetDateTime.parse("1970-01-01T00:00:00.000000001Z"), new BigInteger("1")}, }); TEST_DB.put(pair(Year.class, BigInteger.class), new Object[][]{ {Year.of(2024), BigInteger.valueOf(2024)}, @@ -1657,22 +1529,22 @@ private static void loadDoubleTests(long now) { {(char) 1, 1d}, {(char) 0, 0d}, }); - TEST_DB.put(pair(Duration.class, Double.class), new Object[][] { - { Duration.ofSeconds(-1, -1), -1.000000001, true }, - { Duration.ofSeconds(-1), -1d, true }, - { Duration.ofSeconds(0), 0d, true }, - { Duration.ofSeconds(1), 1d, true }, - { Duration.ofNanos(1), 0.000000001, true }, - { Duration.ofNanos(1_000_000_000), 1d, true }, - { Duration.ofNanos(2_000_000_001), 2.000000001, true }, - { Duration.ofSeconds(10, 9), 10.000000009, true }, - { Duration.ofDays(1), 86400d, true}, + TEST_DB.put(pair(Duration.class, Double.class), new Object[][]{ + {Duration.ofSeconds(-1, -1), -1.000000001, true}, + {Duration.ofSeconds(-1), -1d, true}, + {Duration.ofSeconds(0), 0d, true}, + {Duration.ofSeconds(1), 1d, true}, + {Duration.ofNanos(1), 0.000000001, true}, + {Duration.ofNanos(1_000_000_000), 1d, true}, + {Duration.ofNanos(2_000_000_001), 2.000000001, true}, + {Duration.ofSeconds(10, 9), 10.000000009, true}, + {Duration.ofDays(1), 86400d, true}, }); TEST_DB.put(pair(Instant.class, Double.class), new Object[][]{ // JDK 1.8 cannot handle the format +01:00 in Instant.parse(). JDK11+ handles it fine. {Instant.parse("0000-01-01T00:00:00Z"), -62167219200.0, true}, {Instant.parse("1969-12-31T00:00:00Z"), -86400d, true}, {Instant.parse("1969-12-31T00:00:00Z"), -86400d, true}, - {Instant.parse("1969-12-31T00:00:00.999999999Z"), -86399.000000001, true }, + {Instant.parse("1969-12-31T00:00:00.999999999Z"), -86399.000000001, true}, // {Instant.parse("1969-12-31T23:59:59.999999999Z"), -0.000000001 }, // IEEE-754 double cannot represent this number precisely {Instant.parse("1970-01-01T00:00:00Z"), 0d, true}, {Instant.parse("1970-01-01T00:00:00.000000001Z"), 0.000000001, true}, @@ -1698,29 +1570,29 @@ private static void loadDoubleTests(long now) { {ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z").withZoneSameInstant(TOKYO_Z).toLocalDateTime(), 0.000000001, true}, }); TEST_DB.put(pair(ZonedDateTime.class, Double.class), new Object[][]{ // no reverse due to .toString adding zone name - {ZonedDateTime.parse("0000-01-01T00:00:00Z"), -62167219200.0 }, - {ZonedDateTime.parse("1969-12-31T23:59:58.9Z"), -1.1 }, - {ZonedDateTime.parse("1969-12-31T23:59:59Z"), -1d }, + {ZonedDateTime.parse("0000-01-01T00:00:00Z"), -62167219200.0}, + {ZonedDateTime.parse("1969-12-31T23:59:58.9Z"), -1.1}, + {ZonedDateTime.parse("1969-12-31T23:59:59Z"), -1d}, // {ZonedDateTime.parse("1969-12-31T23:59:59.999999999Z"), -0.000000001}, // IEEE-754 double resolution not quite good enough to represent, but very close. {ZonedDateTime.parse("1970-01-01T00:00:00Z"), 0d}, {ZonedDateTime.parse("1970-01-01T00:00:00.000000001Z"), 0.000000001}, }); TEST_DB.put(pair(OffsetDateTime.class, Double.class), new Object[][]{ // OffsetDateTime .toString() method prevents reverse - {OffsetDateTime.parse("0000-01-01T00:00:00Z"), -62167219200.0 }, - {OffsetDateTime.parse("1969-12-31T23:59:58.9Z"), -1.1 }, - {OffsetDateTime.parse("1969-12-31T23:59:59.000000001Z"), -0.999999999 }, - {OffsetDateTime.parse("1969-12-31T23:59:59Z"), -1d }, + {OffsetDateTime.parse("0000-01-01T00:00:00Z"), -62167219200.0}, + {OffsetDateTime.parse("1969-12-31T23:59:58.9Z"), -1.1}, + {OffsetDateTime.parse("1969-12-31T23:59:59.000000001Z"), -0.999999999}, + {OffsetDateTime.parse("1969-12-31T23:59:59Z"), -1d}, // {OffsetDateTime.parse("1969-12-31T23:59:59.999999999Z"), -0.000000001}, // IEEE-754 double resolution not quite good enough to represent, but very close. - {OffsetDateTime.parse("1970-01-01T00:00:00Z"), 0d }, - {OffsetDateTime.parse("1970-01-01T00:00:00.000000001Z"), 0.000000001 }, + {OffsetDateTime.parse("1970-01-01T00:00:00Z"), 0d}, + {OffsetDateTime.parse("1970-01-01T00:00:00.000000001Z"), 0.000000001}, }); TEST_DB.put(pair(Date.class, Double.class), new Object[][]{ {new Date(Long.MIN_VALUE), (double) Long.MIN_VALUE / 1000d, true}, {new Date(Integer.MIN_VALUE), (double) Integer.MIN_VALUE / 1000d, true}, {new Date(0), 0d, true}, {new Date(now), (double) now / 1000d, true}, - {Date.from(Instant.parse("2024-02-18T06:31:55.987654321Z")), 1708237915.987, true }, // Date only has millisecond resolution - {Date.from(Instant.parse("2024-02-18T06:31:55.123456789Z")), 1708237915.123, true }, // Date only has millisecond resolution + {Date.from(Instant.parse("2024-02-18T06:31:55.987654321Z")), 1708237915.987, true}, // Date only has millisecond resolution + {Date.from(Instant.parse("2024-02-18T06:31:55.123456789Z")), 1708237915.123, true}, // Date only has millisecond resolution {new Date(Integer.MAX_VALUE), (double) Integer.MAX_VALUE / 1000d, true}, {new Date(Long.MAX_VALUE), (double) Long.MAX_VALUE / 1000d, true}, }); @@ -1729,22 +1601,22 @@ private static void loadDoubleTests(long now) { {new java.sql.Date(Integer.MIN_VALUE), (double) Integer.MIN_VALUE / 1000d, true}, {new java.sql.Date(0), 0d, true}, {new java.sql.Date(now), (double) now / 1000d, true}, - {new java.sql.Date(Instant.parse("2024-02-18T06:31:55.987654321Z").toEpochMilli()), 1708237915.987, true }, // java.sql.Date only has millisecond resolution - {new java.sql.Date(Instant.parse("2024-02-18T06:31:55.123456789Z").toEpochMilli()), 1708237915.123, true }, // java.sql.Date only has millisecond resolution + {new java.sql.Date(Instant.parse("2024-02-18T06:31:55.987654321Z").toEpochMilli()), 1708237915.987, true}, // java.sql.Date only has millisecond resolution + {new java.sql.Date(Instant.parse("2024-02-18T06:31:55.123456789Z").toEpochMilli()), 1708237915.123, true}, // java.sql.Date only has millisecond resolution {new java.sql.Date(Integer.MAX_VALUE), (double) Integer.MAX_VALUE / 1000d, true}, {new java.sql.Date(Long.MAX_VALUE), (double) Long.MAX_VALUE / 1000d, true}, }); TEST_DB.put(pair(Timestamp.class, Double.class), new Object[][]{ {new Timestamp(0), 0d, true}, - { Timestamp.from(Instant.parse("1969-12-31T00:00:00Z")), -86400d, true}, - { Timestamp.from(Instant.parse("1969-12-31T00:00:00.000000001Z")), -86399.999999999}, // IEEE-754 resolution issue (almost symmetrical) - { Timestamp.from(Instant.parse("1969-12-31T00:00:01Z")), -86399d, true }, - { Timestamp.from(Instant.parse("1969-12-31T23:59:58.9Z")), -1.1, true }, - { Timestamp.from(Instant.parse("1969-12-31T23:59:59Z")), -1.0, true }, - { Timestamp.from(Instant.parse("1970-01-01T00:00:00Z")), 0d, true}, - { Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")), 0.000000001, true }, - { Timestamp.from(Instant.parse("1970-01-01T00:00:00.9Z")), 0.9, true }, - { Timestamp.from(Instant.parse("1970-01-01T00:00:00.999999999Z")), 0.999999999, true }, + {Timestamp.from(Instant.parse("1969-12-31T00:00:00Z")), -86400d, true}, + {Timestamp.from(Instant.parse("1969-12-31T00:00:00.000000001Z")), -86399.999999999}, // IEEE-754 resolution issue (almost symmetrical) + {Timestamp.from(Instant.parse("1969-12-31T00:00:01Z")), -86399d, true}, + {Timestamp.from(Instant.parse("1969-12-31T23:59:58.9Z")), -1.1, true}, + {Timestamp.from(Instant.parse("1969-12-31T23:59:59Z")), -1.0, true}, + {Timestamp.from(Instant.parse("1970-01-01T00:00:00Z")), 0d, true}, + {Timestamp.from(Instant.parse("1970-01-01T00:00:00.000000001Z")), 0.000000001, true}, + {Timestamp.from(Instant.parse("1970-01-01T00:00:00.9Z")), 0.9, true}, + {Timestamp.from(Instant.parse("1970-01-01T00:00:00.999999999Z")), 0.999999999, true}, }); TEST_DB.put(pair(Calendar.class, Double.class), new Object[][]{ {(Supplier) () -> { @@ -2206,13 +2078,13 @@ private static void loadLongTests(long now) { {new Timestamp(Long.MAX_VALUE), Long.MAX_VALUE, true}, }); TEST_DB.put(pair(Duration.class, Long.class), new Object[][]{ - { Duration.ofMillis(Long.MIN_VALUE / 2), Long.MIN_VALUE / 2, true }, - { Duration.ofMillis(Integer.MIN_VALUE), (long)Integer.MIN_VALUE, true }, - { Duration.ofMillis(-1), -1L, true }, - { Duration.ofMillis(0), 0L, true }, - { Duration.ofMillis(1), 1L, true }, - { Duration.ofMillis(Integer.MAX_VALUE), (long)Integer.MAX_VALUE, true }, - { Duration.ofMillis(Long.MAX_VALUE / 2), Long.MAX_VALUE / 2, true }, + {Duration.ofMillis(Long.MIN_VALUE / 2), Long.MIN_VALUE / 2, true}, + {Duration.ofMillis(Integer.MIN_VALUE), (long) Integer.MIN_VALUE, true}, + {Duration.ofMillis(-1), -1L, true}, + {Duration.ofMillis(0), 0L, true}, + {Duration.ofMillis(1), 1L, true}, + {Duration.ofMillis(Integer.MAX_VALUE), (long) Integer.MAX_VALUE, true}, + {Duration.ofMillis(Long.MAX_VALUE / 2), Long.MAX_VALUE / 2, true}, }); TEST_DB.put(pair(Instant.class, Long.class), new Object[][]{ {Instant.parse("0000-01-01T00:00:00Z"), -62167219200000L, true}, @@ -2359,13 +2231,11 @@ private static void loadIntegerTests() { {new AtomicInteger(2147483647), Integer.MAX_VALUE}, }); TEST_DB.put(pair(AtomicLong.class, Integer.class), new Object[][]{ - {new AtomicLong(-1), -1}, - {new AtomicLong(0), 0}, - {new AtomicLong(1), 1}, - {new AtomicLong(-2147483648), Integer.MIN_VALUE}, - {new AtomicLong(2147483647), Integer.MAX_VALUE}, - {new AtomicLong(-2147483649L), Integer.MAX_VALUE}, - {new AtomicLong(2147483648L), Integer.MIN_VALUE}, + {new AtomicLong(-1), -1, true}, + {new AtomicLong(0), 0, true}, + {new AtomicLong(1), 1, true}, + {new AtomicLong(-2147483648), Integer.MIN_VALUE, true}, + {new AtomicLong(2147483647), Integer.MAX_VALUE, true}, }); TEST_DB.put(pair(BigInteger.class, Integer.class), new Object[][]{ {new BigInteger("-1"), -1}, @@ -2828,45 +2698,7 @@ void before() { // create converter with default options converter = new Converter(options); } - - @Test - 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(); - Set> targetClasses = entry.getValue(); - - 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 { - if (testData.length == 0) { - throw new IllegalStateException("No test instances for given pairing: " + Converter.getShortName(sourceClass) + " ==> " + Converter.getShortName(targetClass)); - } - testCount += testData.length; - } - } - } - - System.out.println("Total conversion pairs = " + conversionPairCount); - System.out.println("Total tests = " + testCount); - if (neededTests > 0) { - System.err.println("Conversion pairs not tested = " + neededTests); - System.err.flush(); - // fail(neededTests + " tests need to be added."); - } - } - + private static Object possiblyConvertSupplier(Object possibleSupplier) { if (possibleSupplier instanceof Supplier) { return ((Supplier) possibleSupplier).get(); @@ -2882,7 +2714,6 @@ private static Stream generateTestEverythingParams() { for (Map.Entry, Class>, Object[][]> entry : TEST_DB.entrySet()) { Class sourceClass = entry.getKey().getKey(); Class targetClass = entry.getKey().getValue(); - String sourceName = Converter.getShortName(sourceClass); String targetName = Converter.getShortName(targetClass); Object[][] testData = entry.getValue(); @@ -2938,7 +2769,7 @@ void testConvert(String shortNameSource, String shortNameTarget, Object source, assert ClassUtilities.toPrimitiveWrapperClass(sourceClass).isInstance(source) : "source type mismatch ==> Expected: " + shortNameSource + ", Actual: " + Converter.getShortName(source.getClass()); } assert target == null || target instanceof Throwable || ClassUtilities.toPrimitiveWrapperClass(targetClass).isInstance(target) : "target type mismatch ==> Expected: " + shortNameTarget + ", Actual: " + Converter.getShortName(target.getClass()); - + // if the source/target are the same Class, then ensure identity lambda is used. if (sourceClass.equals(targetClass)) { assertSame(source, converter.convert(source, targetClass)); @@ -2955,12 +2786,15 @@ void testConvert(String shortNameSource, String shortNameTarget, Object source, try { if (target instanceof AtomicLong) { assertEquals(((AtomicLong) target).get(), ((AtomicLong) actual).get()); + updateStat(pair(sourceClass, targetClass), true); } else if (target instanceof BigDecimal) { if (((BigDecimal) target).compareTo((BigDecimal) actual) != 0) { assertEquals(target, actual); } + updateStat(pair(sourceClass, targetClass), true); } else { assertEquals(target, actual); + updateStat(pair(sourceClass, targetClass), true); } } catch (Throwable e) { @@ -2970,6 +2804,44 @@ void testConvert(String shortNameSource, String shortNameTarget, Object source, } } + private static void updateStat(Map.Entry, Class> pair, boolean state) { + STAT_DB.put(pair, state); + } + + @BeforeAll + static void statPrep() { + Map, Set>> map = com.cedarsoftware.util.Converter.allSupportedConversions(); + + for (Map.Entry, Set>> entry : map.entrySet()) { + Class sourceClass = entry.getKey(); + Set> targetClasses = entry.getValue(); + for (Class targetClass : targetClasses) { + updateStat(pair(sourceClass, targetClass), false); + } + } + } + + @AfterAll + static void printStats() { + Set testPairNames = new TreeSet<>(); + int missing = 0; + + for (Map.Entry, Class>, Boolean> entry : STAT_DB.entrySet()) { + Map.Entry, Class> pair = entry.getKey(); + boolean value = entry.getValue(); + if (!value) { + missing++; + testPairNames.add("\n " + Converter.getShortName(pair.getKey()) + " ==> " + Converter.getShortName(pair.getValue())); + } + } + + System.out.println("Total conversion pairs = " + STAT_DB.size()); + System.out.println("Conversion pairs tested = " + (STAT_DB.size() - missing)); + System.out.println("Conversion pairs not tested = " + missing); + System.out.print("Tests needed "); + System.out.println(testPairNames); + } + @ParameterizedTest(name = "{0}[{2}] ==> {1}[{3}]") @MethodSource("generateTestEverythingParamsInReverse") void testConvertReverse(String shortNameSource, String shortNameTarget, Object source, Object target, Class sourceClass, Class targetClass) {