diff options
author | Gary Gregory <garydgregory@gmail.com> | 2021-05-25 13:34:53 -0400 |
---|---|---|
committer | Gary Gregory <garydgregory@gmail.com> | 2021-05-25 13:34:53 -0400 |
commit | e8fe1a941ccd469750a509d6d7e91d727cca83a1 (patch) | |
tree | 93b936ea7d8b4a5dcffea12bbba068fdd17ed0fe /src/test/java/org | |
parent | 24957f9934cee310debd2005bdbd78e21e857e7e (diff) | |
download | apache-commons-lang-e8fe1a941ccd469750a509d6d7e91d727cca83a1.tar.gz |
Create array with curly.
Diffstat (limited to 'src/test/java/org')
32 files changed, 488 insertions, 488 deletions
diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java index 3030308d8..60dc090b8 100644 --- a/src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java +++ b/src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java @@ -40,7 +40,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.addFirst(null, true); assertArrayEquals(new boolean[]{true}, newArray); assertEquals(Boolean.TYPE, newArray.getClass().getComponentType()); - final boolean[] array1 = new boolean[]{true, false, true}; + final boolean[] array1 = {true, false, true}; newArray = ArrayUtils.addFirst(array1, false); assertArrayEquals(new boolean[]{false, true, false, true}, newArray); assertEquals(Boolean.TYPE, newArray.getClass().getComponentType()); @@ -55,7 +55,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.addFirst((byte[]) null, (byte) 1); assertArrayEquals(new byte[]{1}, newArray); assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); - final byte[] array1 = new byte[]{1, 2, 3}; + final byte[] array1 = {1, 2, 3}; newArray = ArrayUtils.addFirst(array1, (byte) 0); assertArrayEquals(new byte[]{0, 1, 2, 3}, newArray); assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); @@ -73,7 +73,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.addFirst((char[]) null, (char) 1); assertArrayEquals(new char[]{1}, newArray); assertEquals(Character.TYPE, newArray.getClass().getComponentType()); - final char[] array1 = new char[]{1, 2, 3}; + final char[] array1 = {1, 2, 3}; newArray = ArrayUtils.addFirst(array1, (char) 0); assertArrayEquals(new char[]{0, 1, 2, 3}, newArray); assertEquals(Character.TYPE, newArray.getClass().getComponentType()); @@ -91,7 +91,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.addFirst((double[]) null, 1); assertArrayEquals(new double[]{1}, newArray); assertEquals(Double.TYPE, newArray.getClass().getComponentType()); - final double[] array1 = new double[]{1, 2, 3}; + final double[] array1 = {1, 2, 3}; newArray = ArrayUtils.addFirst(array1, 0); assertArrayEquals(new double[]{0, 1, 2, 3}, newArray); assertEquals(Double.TYPE, newArray.getClass().getComponentType()); @@ -109,7 +109,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.addFirst((float[]) null, 1); assertArrayEquals(new float[]{1}, newArray); assertEquals(Float.TYPE, newArray.getClass().getComponentType()); - final float[] array1 = new float[]{1, 2, 3}; + final float[] array1 = {1, 2, 3}; newArray = ArrayUtils.addFirst(array1, 0); assertArrayEquals(new float[]{0, 1, 2, 3}, newArray); assertEquals(Float.TYPE, newArray.getClass().getComponentType()); @@ -127,7 +127,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.addFirst((int[]) null, 1); assertArrayEquals(new int[]{1}, newArray); assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); - final int[] array1 = new int[]{1, 2, 3}; + final int[] array1 = {1, 2, 3}; newArray = ArrayUtils.addFirst(array1, 0); assertArrayEquals(new int[]{0, 1, 2, 3}, newArray); assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); @@ -145,7 +145,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.addFirst((long[]) null, 1); assertArrayEquals(new long[]{1}, newArray); assertEquals(Long.TYPE, newArray.getClass().getComponentType()); - final long[] array1 = new long[]{1, 2, 3}; + final long[] array1 = {1, 2, 3}; newArray = ArrayUtils.addFirst(array1, 0); assertArrayEquals(new long[]{0, 1, 2, 3}, newArray); assertEquals(Long.TYPE, newArray.getClass().getComponentType()); @@ -170,7 +170,7 @@ public class ArrayUtilsAddTest { assertArrayEquals(new Object[]{"a"}, newStringArray); assertEquals(String.class, newStringArray.getClass().getComponentType()); - final String[] stringArray1 = new String[] { "a", "b", "c" }; + final String[] stringArray1 = { "a", "b", "c" }; newArray = ArrayUtils.addFirst(stringArray1, null); assertArrayEquals(new String[] { null, "a", "b", "c" }, newArray); assertEquals(String.class, newArray.getClass().getComponentType()); @@ -179,7 +179,7 @@ public class ArrayUtilsAddTest { assertArrayEquals(new String[] { "d", "a", "b", "c" }, newArray); assertEquals(String.class, newArray.getClass().getComponentType()); - Number[] numberArray1 = new Number[] { Integer.valueOf(1), Double.valueOf(2) }; + Number[] numberArray1 = { Integer.valueOf(1), Double.valueOf(2) }; newArray = ArrayUtils.addFirst(numberArray1, Float.valueOf(3)); assertArrayEquals(new Number[] { Float.valueOf(3), Integer.valueOf(1), Double.valueOf(2) }, newArray); assertEquals(Number.class, newArray.getClass().getComponentType()); @@ -199,7 +199,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.addFirst((short[]) null, (short) 1); assertArrayEquals(new short[]{1}, newArray); assertEquals(Short.TYPE, newArray.getClass().getComponentType()); - final short[] array1 = new short[]{1, 2, 3}; + final short[] array1 = {1, 2, 3}; newArray = ArrayUtils.addFirst(array1, (short) 0); assertArrayEquals(new short[]{0, 1, 2, 3}, newArray); assertEquals(Short.TYPE, newArray.getClass().getComponentType()); @@ -217,7 +217,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.add(null, true); assertArrayEquals(new boolean[]{true}, newArray); assertEquals(Boolean.TYPE, newArray.getClass().getComponentType()); - final boolean[] array1 = new boolean[]{true, false, true}; + final boolean[] array1 = {true, false, true}; newArray = ArrayUtils.add(array1, false); assertArrayEquals(new boolean[]{true, false, true, false}, newArray); assertEquals(Boolean.TYPE, newArray.getClass().getComponentType()); @@ -232,7 +232,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.add((byte[]) null, (byte) 1); assertArrayEquals(new byte[]{1}, newArray); assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); - final byte[] array1 = new byte[]{1, 2, 3}; + final byte[] array1 = {1, 2, 3}; newArray = ArrayUtils.add(array1, (byte) 0); assertArrayEquals(new byte[]{1, 2, 3, 0}, newArray); assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); @@ -250,7 +250,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.add((char[]) null, (char) 1); assertArrayEquals(new char[]{1}, newArray); assertEquals(Character.TYPE, newArray.getClass().getComponentType()); - final char[] array1 = new char[]{1, 2, 3}; + final char[] array1 = {1, 2, 3}; newArray = ArrayUtils.add(array1, (char) 0); assertArrayEquals(new char[]{1, 2, 3, 0}, newArray); assertEquals(Character.TYPE, newArray.getClass().getComponentType()); @@ -268,7 +268,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.add((double[]) null, 1); assertArrayEquals(new double[]{1}, newArray); assertEquals(Double.TYPE, newArray.getClass().getComponentType()); - final double[] array1 = new double[]{1, 2, 3}; + final double[] array1 = {1, 2, 3}; newArray = ArrayUtils.add(array1, 0); assertArrayEquals(new double[]{1, 2, 3, 0}, newArray); assertEquals(Double.TYPE, newArray.getClass().getComponentType()); @@ -286,7 +286,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.add((float[]) null, 1); assertArrayEquals(new float[]{1}, newArray); assertEquals(Float.TYPE, newArray.getClass().getComponentType()); - final float[] array1 = new float[]{1, 2, 3}; + final float[] array1 = {1, 2, 3}; newArray = ArrayUtils.add(array1, 0); assertArrayEquals(new float[]{1, 2, 3, 0}, newArray); assertEquals(Float.TYPE, newArray.getClass().getComponentType()); @@ -304,7 +304,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.add((int[]) null, 1); assertArrayEquals(new int[]{1}, newArray); assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); - final int[] array1 = new int[]{1, 2, 3}; + final int[] array1 = {1, 2, 3}; newArray = ArrayUtils.add(array1, 0); assertArrayEquals(new int[]{1, 2, 3, 0}, newArray); assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); @@ -322,7 +322,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.add((long[]) null, 1); assertArrayEquals(new long[]{1}, newArray); assertEquals(Long.TYPE, newArray.getClass().getComponentType()); - final long[] array1 = new long[]{1, 2, 3}; + final long[] array1 = {1, 2, 3}; newArray = ArrayUtils.add(array1, 0); assertArrayEquals(new long[]{1, 2, 3, 0}, newArray); assertEquals(Long.TYPE, newArray.getClass().getComponentType()); @@ -347,7 +347,7 @@ public class ArrayUtilsAddTest { assertArrayEquals(new Object[]{"a"}, newStringArray); assertEquals(String.class, newStringArray.getClass().getComponentType()); - final String[] stringArray1 = new String[]{"a", "b", "c"}; + final String[] stringArray1 = {"a", "b", "c"}; newArray = ArrayUtils.add(stringArray1, null); assertArrayEquals(new String[]{"a", "b", "c", null}, newArray); assertEquals(String.class, newArray.getClass().getComponentType()); @@ -356,7 +356,7 @@ public class ArrayUtilsAddTest { assertArrayEquals(new String[]{"a", "b", "c", "d"}, newArray); assertEquals(String.class, newArray.getClass().getComponentType()); - Number[] numberArray1 = new Number[]{Integer.valueOf(1), Double.valueOf(2)}; + Number[] numberArray1 = {Integer.valueOf(1), Double.valueOf(2)}; newArray = ArrayUtils.add(numberArray1, Float.valueOf(3)); assertArrayEquals(new Number[]{Integer.valueOf(1), Double.valueOf(2), Float.valueOf(3)}, newArray); assertEquals(Number.class, newArray.getClass().getComponentType()); @@ -376,7 +376,7 @@ public class ArrayUtilsAddTest { newArray = ArrayUtils.add((short[]) null, (short) 1); assertArrayEquals(new short[]{1}, newArray); assertEquals(Short.TYPE, newArray.getClass().getComponentType()); - final short[] array1 = new short[]{1, 2, 3}; + final short[] array1 = {1, 2, 3}; newArray = ArrayUtils.add(array1, (short) 0); assertArrayEquals(new short[]{1, 2, 3, 0}, newArray); assertEquals(Short.TYPE, newArray.getClass().getComponentType()); @@ -389,8 +389,8 @@ public class ArrayUtilsAddTest { public void testAddObjectArrayToObjectArray() { assertNull(ArrayUtils.addAll(null, (Object[]) null)); Object[] newArray; - final String[] stringArray1 = new String[]{"a", "b", "c"}; - final String[] stringArray2 = new String[]{"1", "2", "3"}; + final String[] stringArray1 = {"a", "b", "c"}; + final String[] stringArray2 = {"1", "2", "3"}; newArray = ArrayUtils.addAll(stringArray1, (String[]) null); assertNotSame(stringArray1, newArray); assertArrayEquals(stringArray1, newArray); @@ -416,7 +416,7 @@ public class ArrayUtilsAddTest { assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, newArray); assertArrayEquals(new String[]{}, newArray); assertEquals(String.class, newArray.getClass().getComponentType()); - final String[] stringArrayNull = new String []{null}; + final String[] stringArrayNull = {null}; newArray = ArrayUtils.addAll(stringArrayNull, stringArrayNull); assertArrayEquals(new String[]{null, null}, newArray); assertEquals(String.class, newArray.getClass().getComponentType()); @@ -487,7 +487,7 @@ public class ArrayUtilsAddTest { assertArrayEquals(new String[]{"a"}, newArray); assertArrayEquals(new Object[]{"a"}, newArray); assertEquals(String.class, newArray.getClass().getComponentType()); - final String[] stringArray1 = new String[]{"a", "b", "c"}; + final String[] stringArray1 = {"a", "b", "c"}; newArray = ArrayUtils.add(stringArray1, 0, null); assertArrayEquals(new String[]{null, "a", "b", "c"}, newArray); assertEquals(String.class, newArray.getClass().getComponentType()); @@ -502,7 +502,7 @@ public class ArrayUtilsAddTest { assertEquals(String.class, newArray.getClass().getComponentType()); assertEquals(String.class, newArray.getClass().getComponentType()); - final Object[] o = new Object[] {"1", "2", "4"}; + final Object[] o = {"1", "2", "4"}; final Object[] result = ArrayUtils.add(o, 2, "3"); final Object[] result2 = ArrayUtils.add(o, 3, "5"); diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java index b5d30aa79..8ae503bdb 100644 --- a/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java +++ b/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java @@ -103,7 +103,7 @@ public class ArrayUtilsRemoveMultipleTest { @Test public void testRemoveAllBooleanArrayRemoveNone() { - final boolean[] array1 = new boolean[] { true, false }; + final boolean[] array1 = { true, false }; final boolean[] array2 = ArrayUtils.removeAll(array1); assertNotSame(array1, array2); assertArrayEquals(array1, array2); @@ -175,7 +175,7 @@ public class ArrayUtilsRemoveMultipleTest { @Test public void testRemoveAllByteArrayRemoveNone() { - final byte[] array1 = new byte[] { 1, 2 }; + final byte[] array1 = { 1, 2 }; final byte[] array2 = ArrayUtils.removeAll(array1); assertNotSame(array1, array2); assertArrayEquals(array1, array2); @@ -247,7 +247,7 @@ public class ArrayUtilsRemoveMultipleTest { @Test public void testRemoveAllCharArrayRemoveNone() { - final char[] array1 = new char[] { 'a', 'b' }; + final char[] array1 = { 'a', 'b' }; final char[] array2 = ArrayUtils.removeAll(array1); assertNotSame(array1, array2); assertArrayEquals(array1, array2); @@ -319,7 +319,7 @@ public class ArrayUtilsRemoveMultipleTest { @Test public void testRemoveAllDoubleArrayRemoveNone() { - final double[] array1 = new double[] { 1, 2 }; + final double[] array1 = { 1, 2 }; final double[] array2 = ArrayUtils.removeAll(array1); assertNotSame(array1, array2); assertArrayEquals(array1, array2); @@ -391,7 +391,7 @@ public class ArrayUtilsRemoveMultipleTest { @Test public void testRemoveAllFloatArrayRemoveNone() { - final float[] array1 = new float[] { 1, 2 }; + final float[] array1 = { 1, 2 }; final float[] array2 = ArrayUtils.removeAll(array1); assertNotSame(array1, array2); assertArrayEquals(array1, array2); @@ -469,7 +469,7 @@ public class ArrayUtilsRemoveMultipleTest { @Test public void testRemoveAllIntArrayRemoveNone() { - final int[] array1 = new int[] { 1, 2 }; + final int[] array1 = { 1, 2 }; final int[] array2 = ArrayUtils.removeAll(array1); assertNotSame(array1, array2); assertArrayEquals(array1, array2); @@ -541,7 +541,7 @@ public class ArrayUtilsRemoveMultipleTest { @Test public void testRemoveAllLongArrayRemoveNone() { - final long[] array1 = new long[] { 1, 2 }; + final long[] array1 = { 1, 2 }; final long[] array2 = ArrayUtils.removeAll(array1); assertNotSame(array1, array2); assertArrayEquals(array1, array2); @@ -685,7 +685,7 @@ public class ArrayUtilsRemoveMultipleTest { @Test public void testRemoveAllObjectArrayRemoveNone() { - final Object[] array1 = new Object[] { "foo", "bar", "baz" }; + final Object[] array1 = { "foo", "bar", "baz" }; final Object[] array2 = ArrayUtils.removeAll(array1); assertNotSame(array1, array2); assertArrayEquals(array1, array2); @@ -757,7 +757,7 @@ public class ArrayUtilsRemoveMultipleTest { @Test public void testRemoveAllShortArrayRemoveNone() { - final short[] array1 = new short[] { 1, 2 }; + final short[] array1 = { 1, 2 }; final short[] array2 = ArrayUtils.removeAll(array1); assertNotSame(array1, array2); assertArrayEquals(array1, array2); diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java index c69cd393a..405845d02 100644 --- a/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java @@ -102,7 +102,7 @@ public class ArrayUtilsTest { @Test public void testClone() { assertArrayEquals(null, ArrayUtils.clone((Object[]) null)); - Object[] original1 = new Object[0]; + Object[] original1 = {}; Object[] cloned1 = ArrayUtils.clone(original1); assertArrayEquals(original1, cloned1); assertNotSame(original1, cloned1); @@ -120,7 +120,7 @@ public class ArrayUtilsTest { @Test public void testCloneBoolean() { assertNull(ArrayUtils.clone((boolean[]) null)); - final boolean[] original = new boolean[]{true, false}; + final boolean[] original = {true, false}; final boolean[] cloned = ArrayUtils.clone(original); assertArrayEquals(original, cloned); assertNotSame(original, cloned); @@ -129,7 +129,7 @@ public class ArrayUtilsTest { @Test public void testCloneByte() { assertNull(ArrayUtils.clone((byte[]) null)); - final byte[] original = new byte[]{1, 6}; + final byte[] original = {1, 6}; final byte[] cloned = ArrayUtils.clone(original); assertArrayEquals(original, cloned); assertNotSame(original, cloned); @@ -138,7 +138,7 @@ public class ArrayUtilsTest { @Test public void testCloneChar() { assertNull(ArrayUtils.clone((char[]) null)); - final char[] original = new char[]{'a', '4'}; + final char[] original = {'a', '4'}; final char[] cloned = ArrayUtils.clone(original); assertArrayEquals(original, cloned); assertNotSame(original, cloned); @@ -147,7 +147,7 @@ public class ArrayUtilsTest { @Test public void testCloneDouble() { assertNull(ArrayUtils.clone((double[]) null)); - final double[] original = new double[]{2.4d, 5.7d}; + final double[] original = {2.4d, 5.7d}; final double[] cloned = ArrayUtils.clone(original); assertArrayEquals(original, cloned); assertNotSame(original, cloned); @@ -156,7 +156,7 @@ public class ArrayUtilsTest { @Test public void testCloneFloat() { assertNull(ArrayUtils.clone((float[]) null)); - final float[] original = new float[]{2.6f, 6.4f}; + final float[] original = {2.6f, 6.4f}; final float[] cloned = ArrayUtils.clone(original); assertArrayEquals(original, cloned); assertNotSame(original, cloned); @@ -165,7 +165,7 @@ public class ArrayUtilsTest { @Test public void testCloneInt() { assertNull(ArrayUtils.clone((int[]) null)); - final int[] original = new int[]{5, 8}; + final int[] original = {5, 8}; final int[] cloned = ArrayUtils.clone(original); assertArrayEquals(original, cloned); assertNotSame(original, cloned); @@ -174,7 +174,7 @@ public class ArrayUtilsTest { @Test public void testCloneLong() { assertNull(ArrayUtils.clone((long[]) null)); - final long[] original = new long[]{0L, 1L}; + final long[] original = {0L, 1L}; final long[] cloned = ArrayUtils.clone(original); assertArrayEquals(original, cloned); assertNotSame(original, cloned); @@ -183,7 +183,7 @@ public class ArrayUtilsTest { @Test public void testCloneShort() { assertNull(ArrayUtils.clone((short[]) null)); - final short[] original = new short[]{1, 4}; + final short[] original = {1, 4}; final short[] cloned = ArrayUtils.clone(original); assertArrayEquals(original, cloned); assertNotSame(original, cloned); @@ -201,7 +201,7 @@ public class ArrayUtilsTest { @Test public void testContains() { - final Object[] array = new Object[]{"0", "1", "2", "3", null, "0"}; + final Object[] array = {"0", "1", "2", "3", null, "0"}; assertFalse(ArrayUtils.contains(null, null)); assertFalse(ArrayUtils.contains(null, "1")); assertTrue(ArrayUtils.contains(array, "0")); @@ -282,7 +282,7 @@ public class ArrayUtilsTest { @Test public void testContainsDoubleNaN() { - final double[] a = new double[] { Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY }; + final double[] a = { Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY }; assertTrue(ArrayUtils.contains(a, Double.POSITIVE_INFINITY)); assertTrue(ArrayUtils.contains(a, Double.NEGATIVE_INFINITY)); assertTrue(ArrayUtils.contains(a, Double.NaN)); @@ -315,7 +315,7 @@ public class ArrayUtilsTest { @Test public void testContainsFloatNaN() { - final float[] array = new float[] { Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY }; + final float[] array = { Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY }; assertTrue(ArrayUtils.contains(array, Float.POSITIVE_INFINITY)); assertTrue(ArrayUtils.contains(array, Float.NEGATIVE_INFINITY)); assertTrue(ArrayUtils.contains(array, Float.NaN)); @@ -446,50 +446,50 @@ public class ArrayUtilsTest { public void testGetLength() { assertEquals(0, ArrayUtils.getLength(null)); - final Object[] emptyObjectArray = new Object[0]; - final Object[] notEmptyObjectArray = new Object[]{"aValue"}; + final Object[] emptyObjectArray = {}; + final Object[] notEmptyObjectArray = {"aValue"}; assertEquals(0, ArrayUtils.getLength(null)); assertEquals(0, ArrayUtils.getLength(emptyObjectArray)); assertEquals(1, ArrayUtils.getLength(notEmptyObjectArray)); - final int[] emptyIntArray = new int[]{}; - final int[] notEmptyIntArray = new int[]{1}; + final int[] emptyIntArray = {}; + final int[] notEmptyIntArray = {1}; assertEquals(0, ArrayUtils.getLength(null)); assertEquals(0, ArrayUtils.getLength(emptyIntArray)); assertEquals(1, ArrayUtils.getLength(notEmptyIntArray)); - final short[] emptyShortArray = new short[]{}; - final short[] notEmptyShortArray = new short[]{1}; + final short[] emptyShortArray = {}; + final short[] notEmptyShortArray = {1}; assertEquals(0, ArrayUtils.getLength(null)); assertEquals(0, ArrayUtils.getLength(emptyShortArray)); assertEquals(1, ArrayUtils.getLength(notEmptyShortArray)); - final char[] emptyCharArray = new char[]{}; - final char[] notEmptyCharArray = new char[]{1}; + final char[] emptyCharArray = {}; + final char[] notEmptyCharArray = {1}; assertEquals(0, ArrayUtils.getLength(null)); assertEquals(0, ArrayUtils.getLength(emptyCharArray)); assertEquals(1, ArrayUtils.getLength(notEmptyCharArray)); - final byte[] emptyByteArray = new byte[]{}; - final byte[] notEmptyByteArray = new byte[]{1}; + final byte[] emptyByteArray = {}; + final byte[] notEmptyByteArray = {1}; assertEquals(0, ArrayUtils.getLength(null)); assertEquals(0, ArrayUtils.getLength(emptyByteArray)); assertEquals(1, ArrayUtils.getLength(notEmptyByteArray)); - final double[] emptyDoubleArray = new double[]{}; - final double[] notEmptyDoubleArray = new double[]{1.0}; + final double[] emptyDoubleArray = {}; + final double[] notEmptyDoubleArray = {1.0}; assertEquals(0, ArrayUtils.getLength(null)); assertEquals(0, ArrayUtils.getLength(emptyDoubleArray)); assertEquals(1, ArrayUtils.getLength(notEmptyDoubleArray)); - final float[] emptyFloatArray = new float[]{}; - final float[] notEmptyFloatArray = new float[]{1.0F}; + final float[] emptyFloatArray = {}; + final float[] notEmptyFloatArray = {1.0F}; assertEquals(0, ArrayUtils.getLength(null)); assertEquals(0, ArrayUtils.getLength(emptyFloatArray)); assertEquals(1, ArrayUtils.getLength(notEmptyFloatArray)); - final boolean[] emptyBooleanArray = new boolean[]{}; - final boolean[] notEmptyBooleanArray = new boolean[]{true}; + final boolean[] emptyBooleanArray = {}; + final boolean[] notEmptyBooleanArray = {true}; assertEquals(0, ArrayUtils.getLength(null)); assertEquals(0, ArrayUtils.getLength(emptyBooleanArray)); assertEquals(1, ArrayUtils.getLength(notEmptyBooleanArray)); @@ -499,24 +499,24 @@ public class ArrayUtilsTest { @Test public void testHashCode() { - final long[][] array1 = new long[][]{{2, 5}, {4, 5}}; - final long[][] array2 = new long[][]{{2, 5}, {4, 6}}; + final long[][] array1 = {{2, 5}, {4, 5}}; + final long[][] array2 = {{2, 5}, {4, 6}}; assertEquals(ArrayUtils.hashCode(array1), ArrayUtils.hashCode(array1)); assertNotEquals(ArrayUtils.hashCode(array1), ArrayUtils.hashCode(array2)); - final Object[] array3 = new Object[]{new String(new char[]{'A', 'B'})}; - final Object[] array4 = new Object[]{"AB"}; + final Object[] array3 = {new String(new char[]{'A', 'B'})}; + final Object[] array4 = {"AB"}; assertEquals(ArrayUtils.hashCode(array3), ArrayUtils.hashCode(array3)); assertEquals(ArrayUtils.hashCode(array3), ArrayUtils.hashCode(array4)); - final Object[] arrayA = new Object[]{new boolean[]{true, false}, new int[]{6, 7}}; - final Object[] arrayB = new Object[]{new boolean[]{true, false}, new int[]{6, 7}}; + final Object[] arrayA = {new boolean[]{true, false}, new int[]{6, 7}}; + final Object[] arrayB = {new boolean[]{true, false}, new int[]{6, 7}}; assertEquals(ArrayUtils.hashCode(arrayB), ArrayUtils.hashCode(arrayA)); } @Test public void testIndexesOf() { - final Object[] array = new Object[]{"0", "1", "2", "3", null, "0"}; + final Object[] array = {"0", "1", "2", "3", null, "0"}; final BitSet emptySet = new BitSet(); final BitSet testSet = new BitSet(); assertEquals(emptySet, ArrayUtils.indexesOf((Object[]) null, null)); @@ -836,7 +836,7 @@ public class ArrayUtilsTest { @Test public void testIndexesOfLong() { - final long[] array = new long[]{0, 1, 2, 3}; + final long[] array = {0, 1, 2, 3}; final BitSet emptySet = new BitSet(); final BitSet testSet = new BitSet(); assertEquals(emptySet, ArrayUtils.indexesOf((long[]) null, 0)); @@ -856,7 +856,7 @@ public class ArrayUtilsTest { @Test public void testIndexesOfLongWithStartIndex() { - final long[] array = new long[]{0, 1, 2, 3, 2, 1, 0, 1}; + final long[] array = {0, 1, 2, 3, 2, 1, 0, 1}; final BitSet emptySet = new BitSet(); final BitSet testSet = new BitSet(); assertEquals(emptySet, ArrayUtils.indexesOf((long[]) null, 0, 0)); @@ -928,7 +928,7 @@ public class ArrayUtilsTest { @Test public void testIndexesOfWithStartIndex() { - final Object[] array = new Object[]{"0", "1", "2", "3", "2", "3", "1", null, "0"}; + final Object[] array = {"0", "1", "2", "3", "2", "3", "1", null, "0"}; final BitSet emptySet = new BitSet(); final BitSet testSet = new BitSet(); assertEquals(emptySet, ArrayUtils.indexesOf(null, null, 2)); @@ -960,7 +960,7 @@ public class ArrayUtilsTest { @Test public void testIndexOf() { - final Object[] array = new Object[]{"0", "1", "2", "3", null, "0"}; + final Object[] array = {"0", "1", "2", "3", null, "0"}; assertEquals(-1, ArrayUtils.indexOf(null, null)); assertEquals(-1, ArrayUtils.indexOf(null, "0")); assertEquals(-1, ArrayUtils.indexOf(new Object[0], "0")); @@ -1071,7 +1071,7 @@ public class ArrayUtilsTest { @Test public void testIndexOfDoubleNaN() { - final double[] array = new double[] { Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY, Double.NaN }; + final double[] array = { Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY, Double.NaN }; assertEquals(0, ArrayUtils.indexOf(array, Double.NEGATIVE_INFINITY)); assertEquals(1, ArrayUtils.indexOf(array, Double.NaN)); assertEquals(2, ArrayUtils.indexOf(array, Double.POSITIVE_INFINITY)); @@ -1143,7 +1143,7 @@ public class ArrayUtilsTest { @Test public void testIndexOfFloatNaN() { - final float[] array = new float[] { Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY, Float.NaN }; + final float[] array = { Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY, Float.NaN }; assertEquals(0, ArrayUtils.indexOf(array, Float.NEGATIVE_INFINITY)); assertEquals(1, ArrayUtils.indexOf(array, Float.NaN)); assertEquals(2, ArrayUtils.indexOf(array, Float.POSITIVE_INFINITY)); @@ -1246,7 +1246,7 @@ public class ArrayUtilsTest { @Test public void testIndexOfWithStartIndex() { - final Object[] array = new Object[]{"0", "1", "2", "3", null, "0"}; + final Object[] array = {"0", "1", "2", "3", null, "0"}; assertEquals(-1, ArrayUtils.indexOf(null, null, 2)); assertEquals(-1, ArrayUtils.indexOf(new Object[0], "0", 0)); assertEquals(-1, ArrayUtils.indexOf(null, "0", 2)); @@ -1302,8 +1302,8 @@ public class ArrayUtilsTest { */ @Test public void testIsEmptyObject() { - final Object[] emptyArray = new Object[]{}; - final Object[] notEmptyArray = new Object[]{"Value"}; + final Object[] emptyArray = {}; + final Object[] notEmptyArray = {"Value"}; assertTrue(ArrayUtils.isEmpty((Object[]) null)); assertTrue(ArrayUtils.isEmpty(emptyArray)); assertFalse(ArrayUtils.isEmpty(notEmptyArray)); @@ -1321,50 +1321,50 @@ public class ArrayUtilsTest { */ @Test public void testIsEmptyPrimitives() { - final long[] emptyLongArray = new long[]{}; - final long[] notEmptyLongArray = new long[]{1L}; + final long[] emptyLongArray = {}; + final long[] notEmptyLongArray = {1L}; assertTrue(ArrayUtils.isEmpty((long[]) null)); assertTrue(ArrayUtils.isEmpty(emptyLongArray)); assertFalse(ArrayUtils.isEmpty(notEmptyLongArray)); - final int[] emptyIntArray = new int[]{}; - final int[] notEmptyIntArray = new int[]{1}; + final int[] emptyIntArray = {}; + final int[] notEmptyIntArray = {1}; assertTrue(ArrayUtils.isEmpty((int[]) null)); assertTrue(ArrayUtils.isEmpty(emptyIntArray)); assertFalse(ArrayUtils.isEmpty(notEmptyIntArray)); - final short[] emptyShortArray = new short[]{}; - final short[] notEmptyShortArray = new short[]{1}; + final short[] emptyShortArray = {}; + final short[] notEmptyShortArray = {1}; assertTrue(ArrayUtils.isEmpty((short[]) null)); assertTrue(ArrayUtils.isEmpty(emptyShortArray)); assertFalse(ArrayUtils.isEmpty(notEmptyShortArray)); - final char[] emptyCharArray = new char[]{}; - final char[] notEmptyCharArray = new char[]{1}; + final char[] emptyCharArray = {}; + final char[] notEmptyCharArray = {1}; assertTrue(ArrayUtils.isEmpty((char[]) null)); assertTrue(ArrayUtils.isEmpty(emptyCharArray)); assertFalse(ArrayUtils.isEmpty(notEmptyCharArray)); - final byte[] emptyByteArray = new byte[]{}; - final byte[] notEmptyByteArray = new byte[]{1}; + final byte[] emptyByteArray = {}; + final byte[] notEmptyByteArray = {1}; assertTrue(ArrayUtils.isEmpty((byte[]) null)); assertTrue(ArrayUtils.isEmpty(emptyByteArray)); assertFalse(ArrayUtils.isEmpty(notEmptyByteArray)); - final double[] emptyDoubleArray = new double[]{}; - final double[] notEmptyDoubleArray = new double[]{1.0}; + final double[] emptyDoubleArray = {}; + final double[] notEmptyDoubleArray = {1.0}; assertTrue(ArrayUtils.isEmpty((double[]) null)); assertTrue(ArrayUtils.isEmpty(emptyDoubleArray)); assertFalse(ArrayUtils.isEmpty(notEmptyDoubleArray)); - final float[] emptyFloatArray = new float[]{}; - final float[] notEmptyFloatArray = new float[]{1.0F}; + final float[] emptyFloatArray = {}; + final float[] notEmptyFloatArray = {1.0F}; assertTrue(ArrayUtils.isEmpty((float[]) null)); assertTrue(ArrayUtils.isEmpty(emptyFloatArray)); assertFalse(ArrayUtils.isEmpty(notEmptyFloatArray)); - final boolean[] emptyBooleanArray = new boolean[]{}; - final boolean[] notEmptyBooleanArray = new boolean[]{true}; + final boolean[] emptyBooleanArray = {}; + final boolean[] notEmptyBooleanArray = {true}; assertTrue(ArrayUtils.isEmpty((boolean[]) null)); assertTrue(ArrayUtils.isEmpty(emptyBooleanArray)); assertFalse(ArrayUtils.isEmpty(notEmptyBooleanArray)); @@ -1372,48 +1372,48 @@ public class ArrayUtilsTest { @Test public void testIsEquals() { - final long[][] larray1 = new long[][]{{2, 5}, {4, 5}}; - final long[][] larray2 = new long[][]{{2, 5}, {4, 6}}; - final long[] larray3 = new long[]{2, 5}; + final long[][] larray1 = {{2, 5}, {4, 5}}; + final long[][] larray2 = {{2, 5}, {4, 6}}; + final long[] larray3 = {2, 5}; this.assertIsEquals(larray1, larray2, larray3); - final int[][] iarray1 = new int[][]{{2, 5}, {4, 5}}; - final int[][] iarray2 = new int[][]{{2, 5}, {4, 6}}; - final int[] iarray3 = new int[]{2, 5}; + final int[][] iarray1 = {{2, 5}, {4, 5}}; + final int[][] iarray2 = {{2, 5}, {4, 6}}; + final int[] iarray3 = {2, 5}; this.assertIsEquals(iarray1, iarray2, iarray3); - final short[][] sarray1 = new short[][]{{2, 5}, {4, 5}}; - final short[][] sarray2 = new short[][]{{2, 5}, {4, 6}}; - final short[] sarray3 = new short[]{2, 5}; + final short[][] sarray1 = {{2, 5}, {4, 5}}; + final short[][] sarray2 = {{2, 5}, {4, 6}}; + final short[] sarray3 = {2, 5}; this.assertIsEquals(sarray1, sarray2, sarray3); - final float[][] farray1 = new float[][]{{2, 5}, {4, 5}}; - final float[][] farray2 = new float[][]{{2, 5}, {4, 6}}; - final float[] farray3 = new float[]{2, 5}; + final float[][] farray1 = {{2, 5}, {4, 5}}; + final float[][] farray2 = {{2, 5}, {4, 6}}; + final float[] farray3 = {2, 5}; this.assertIsEquals(farray1, farray2, farray3); - final double[][] darray1 = new double[][]{{2, 5}, {4, 5}}; - final double[][] darray2 = new double[][]{{2, 5}, {4, 6}}; - final double[] darray3 = new double[]{2, 5}; + final double[][] darray1 = {{2, 5}, {4, 5}}; + final double[][] darray2 = {{2, 5}, {4, 6}}; + final double[] darray3 = {2, 5}; this.assertIsEquals(darray1, darray2, darray3); - final byte[][] byteArray1 = new byte[][]{{2, 5}, {4, 5}}; - final byte[][] byteArray2 = new byte[][]{{2, 5}, {4, 6}}; - final byte[] byteArray3 = new byte[]{2, 5}; + final byte[][] byteArray1 = {{2, 5}, {4, 5}}; + final byte[][] byteArray2 = {{2, 5}, {4, 6}}; + final byte[] byteArray3 = {2, 5}; this.assertIsEquals(byteArray1, byteArray2, byteArray3); - final char[][] charArray1 = new char[][]{{2, 5}, {4, 5}}; - final char[][] charArray2 = new char[][]{{2, 5}, {4, 6}}; - final char[] charArray3 = new char[]{2, 5}; + final char[][] charArray1 = {{2, 5}, {4, 5}}; + final char[][] charArray2 = {{2, 5}, {4, 6}}; + final char[] charArray3 = {2, 5}; this.assertIsEquals(charArray1, charArray2, charArray3); - final boolean[][] barray1 = new boolean[][]{{true, false}, {true, true}}; - final boolean[][] barray2 = new boolean[][]{{true, false}, {true, false}}; - final boolean[] barray3 = new boolean[]{false, true}; + final boolean[][] barray1 = {{true, false}, {true, true}}; + final boolean[][] barray2 = {{true, false}, {true, false}}; + final boolean[] barray3 = {false, true}; this.assertIsEquals(barray1, barray2, barray3); - final Object[] array3 = new Object[]{new String(new char[]{'A', 'B'})}; - final Object[] array4 = new Object[]{"AB"}; + final Object[] array3 = {new String(new char[]{'A', 'B'})}; + final Object[] array4 = {"AB"}; assertTrue(ArrayUtils.isEquals(array3, array3)); assertTrue(ArrayUtils.isEquals(array3, array4)); @@ -1426,8 +1426,8 @@ public class ArrayUtilsTest { */ @Test public void testIsNotEmptyObject() { - final Object[] emptyArray = new Object[]{}; - final Object[] notEmptyArray = new Object[]{"Value"}; + final Object[] emptyArray = {}; + final Object[] notEmptyArray = {"Value"}; assertFalse(ArrayUtils.isNotEmpty((Object[]) null)); assertFalse(ArrayUtils.isNotEmpty(emptyArray)); assertTrue(ArrayUtils.isNotEmpty(notEmptyArray)); @@ -1445,50 +1445,50 @@ public class ArrayUtilsTest { */ @Test public void testIsNotEmptyPrimitives() { - final long[] emptyLongArray = new long[]{}; - final long[] notEmptyLongArray = new long[]{1L}; + final long[] emptyLongArray = {}; + final long[] notEmptyLongArray = {1L}; assertFalse(ArrayUtils.isNotEmpty((long[]) null)); assertFalse(ArrayUtils.isNotEmpty(emptyLongArray)); assertTrue(ArrayUtils.isNotEmpty(notEmptyLongArray)); - final int[] emptyIntArray = new int[]{}; - final int[] notEmptyIntArray = new int[]{1}; + final int[] emptyIntArray = {}; + final int[] notEmptyIntArray = {1}; assertFalse(ArrayUtils.isNotEmpty((int[]) null)); assertFalse(ArrayUtils.isNotEmpty(emptyIntArray)); assertTrue(ArrayUtils.isNotEmpty(notEmptyIntArray)); - final short[] emptyShortArray = new short[]{}; - final short[] notEmptyShortArray = new short[]{1}; + final short[] emptyShortArray = {}; + final short[] notEmptyShortArray = {1}; assertFalse(ArrayUtils.isNotEmpty((short[]) null)); assertFalse(ArrayUtils.isNotEmpty(emptyShortArray)); assertTrue(ArrayUtils.isNotEmpty(notEmptyShortArray)); - final char[] emptyCharArray = new char[]{}; - final char[] notEmptyCharArray = new char[]{1}; + final char[] emptyCharArray = {}; + final char[] notEmptyCharArray = {1}; assertFalse(ArrayUtils.isNotEmpty((char[]) null)); assertFalse(ArrayUtils.isNotEmpty(emptyCharArray)); assertTrue(ArrayUtils.isNotEmpty(notEmptyCharArray)); - final byte[] emptyByteArray = new byte[]{}; - final byte[] notEmptyByteArray = new byte[]{1}; + final byte[] emptyByteArray = {}; + final byte[] notEmptyByteArray = {1}; assertFalse(ArrayUtils.isNotEmpty((byte[]) null)); assertFalse(ArrayUtils.isNotEmpty(emptyByteArray)); assertTrue(ArrayUtils.isNotEmpty(notEmptyByteArray)); - final double[] emptyDoubleArray = new double[]{}; - final double[] notEmptyDoubleArray = new double[]{1.0}; + final double[] emptyDoubleArray = {}; + final double[] notEmptyDoubleArray = {1.0}; assertFalse(ArrayUtils.isNotEmpty((double[]) null)); assertFalse(ArrayUtils.isNotEmpty(emptyDoubleArray)); assertTrue(ArrayUtils.isNotEmpty(notEmptyDoubleArray)); - final float[] emptyFloatArray = new float[]{}; - final float[] notEmptyFloatArray = new float[]{1.0F}; + final float[] emptyFloatArray = {}; + final float[] notEmptyFloatArray = {1.0F}; assertFalse(ArrayUtils.isNotEmpty((float[]) null)); assertFalse(ArrayUtils.isNotEmpty(emptyFloatArray)); assertTrue(ArrayUtils.isNotEmpty(notEmptyFloatArray)); - final boolean[] emptyBooleanArray = new boolean[]{}; - final boolean[] notEmptyBooleanArray = new boolean[]{true}; + final boolean[] emptyBooleanArray = {}; + final boolean[] notEmptyBooleanArray = {true}; assertFalse(ArrayUtils.isNotEmpty((boolean[]) null)); assertFalse(ArrayUtils.isNotEmpty(emptyBooleanArray)); assertTrue(ArrayUtils.isNotEmpty(notEmptyBooleanArray)); @@ -1653,7 +1653,7 @@ public class ArrayUtilsTest { @Test public void testLastIndexOf() { - final Object[] array = new Object[]{"0", "1", "2", "3", null, "0"}; + final Object[] array = {"0", "1", "2", "3", null, "0"}; assertEquals(-1, ArrayUtils.lastIndexOf(null, null)); assertEquals(-1, ArrayUtils.lastIndexOf(null, "0")); assertEquals(5, ArrayUtils.lastIndexOf(array, "0")); @@ -1921,7 +1921,7 @@ public class ArrayUtilsTest { @Test public void testLastIndexOfWithStartIndex() { - final Object[] array = new Object[]{"0", "1", "2", "3", null, "0"}; + final Object[] array = {"0", "1", "2", "3", null, "0"}; assertEquals(-1, ArrayUtils.lastIndexOf(null, null, 2)); assertEquals(-1, ArrayUtils.lastIndexOf(null, "0", 2)); assertEquals(0, ArrayUtils.lastIndexOf(array, "0", 2)); @@ -1939,13 +1939,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyBoolean() { - final boolean[] original = new boolean[]{true, false}; + final boolean[] original = {true, false}; assertEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyBooleanEmptyArray() { - final boolean[] empty = new boolean[]{}; + final boolean[] empty = {}; final boolean[] result = ArrayUtils.nullToEmpty(empty); assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, result); assertNotSame(empty, result); @@ -1958,13 +1958,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyBooleanObject() { - final Boolean[] original = new Boolean[]{Boolean.TRUE, Boolean.FALSE}; + final Boolean[] original = {Boolean.TRUE, Boolean.FALSE}; assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyBooleanObjectEmptyArray() { - final Boolean[] empty = new Boolean[]{}; + final Boolean[] empty = {}; final Boolean[] result = ArrayUtils.nullToEmpty(empty); assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, result); assertNotSame(empty, result); @@ -1977,13 +1977,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyByte() { - final byte[] original = new byte[]{0x0F, 0x0E}; + final byte[] original = {0x0F, 0x0E}; assertEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyByteEmptyArray() { - final byte[] empty = new byte[]{}; + final byte[] empty = {}; final byte[] result = ArrayUtils.nullToEmpty(empty); assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, result); assertNotSame(empty, result); @@ -1996,13 +1996,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyByteObject() { - final Byte[] original = new Byte[]{0x0F, 0x0E}; + final Byte[] original = {0x0F, 0x0E}; assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyByteObjectEmptyArray() { - final Byte[] empty = new Byte[]{}; + final Byte[] empty = {}; final Byte[] result = ArrayUtils.nullToEmpty(empty); assertArrayEquals(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, result); assertNotSame(empty, result); @@ -2015,13 +2015,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyChar() { - final char[] original = new char[]{'a', 'b'}; + final char[] original = {'a', 'b'}; assertEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyCharEmptyArray() { - final char[] empty = new char[]{}; + final char[] empty = {}; final char[] result = ArrayUtils.nullToEmpty(empty); assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, result); assertNotSame(empty, result); @@ -2034,13 +2034,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyCharObject() { - final Character[] original = new Character[]{'a', 'b'}; + final Character[] original = {'a', 'b'}; assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyCharObjectEmptyArray() { - final Character[] empty = new Character[]{}; + final Character[] empty = {}; final Character[] result = ArrayUtils.nullToEmpty(empty); assertArrayEquals(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, result); assertNotSame(empty, result); @@ -2072,13 +2072,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyDouble() { - final double[] original = new double[]{1L, 2L}; + final double[] original = {1L, 2L}; assertEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyDoubleEmptyArray() { - final double[] empty = new double[]{}; + final double[] empty = {}; final double[] result = ArrayUtils.nullToEmpty(empty); assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, result); assertNotSame(empty, result); @@ -2091,13 +2091,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyDoubleObject() { - final Double[] original = new Double[]{1D, 2D}; + final Double[] original = {1D, 2D}; assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyDoubleObjectEmptyArray() { - final Double[] empty = new Double[]{}; + final Double[] empty = {}; final Double[] result = ArrayUtils.nullToEmpty(empty); assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, result); assertNotSame(empty, result); @@ -2110,13 +2110,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyFloat() { - final float[] original = new float[]{2.6f, 3.8f}; + final float[] original = {2.6f, 3.8f}; assertEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyFloatEmptyArray() { - final float[] empty = new float[]{}; + final float[] empty = {}; final float[] result = ArrayUtils.nullToEmpty(empty); assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, result); assertNotSame(empty, result); @@ -2129,13 +2129,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyFloatObject() { - final Float[] original = new Float[]{2.6f, 3.8f}; + final Float[] original = {2.6f, 3.8f}; assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyFloatObjectEmptyArray() { - final Float[] empty = new Float[]{}; + final Float[] empty = {}; final Float[] result = ArrayUtils.nullToEmpty(empty); assertArrayEquals(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, result); assertNotSame(empty, result); @@ -2148,7 +2148,7 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyGeneric() { - final TestClass[] input = new TestClass[]{new TestClass(), new TestClass()}; + final TestClass[] input = {new TestClass(), new TestClass()}; final TestClass[] output = ArrayUtils.nullToEmpty(input, TestClass[].class); assertSame(input, output); @@ -2156,7 +2156,7 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyGenericEmpty() { - final TestClass[] input = new TestClass[]{}; + final TestClass[] input = {}; final TestClass[] output = ArrayUtils.nullToEmpty(input, TestClass[].class); assertSame(input, output); @@ -2172,19 +2172,19 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyGenericNullType() { - final TestClass[] input = new TestClass[]{}; + final TestClass[] input = {}; assertThrows(IllegalArgumentException.class, () -> ArrayUtils.nullToEmpty(input, null)); } @Test public void testNullToEmptyInt() { - final int[] original = new int[]{1, 2}; + final int[] original = {1, 2}; assertEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyIntEmptyArray() { - final int[] empty = new int[]{}; + final int[] empty = {}; final int[] result = ArrayUtils.nullToEmpty(empty); assertEquals(ArrayUtils.EMPTY_INT_ARRAY, result); assertNotSame(empty, result); @@ -2197,13 +2197,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyIntObject() { - final Integer[] original = new Integer[]{1, 2}; + final Integer[] original = {1, 2}; assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyIntObjectEmptyArray() { - final Integer[] empty = new Integer[]{}; + final Integer[] empty = {}; final Integer[] result = ArrayUtils.nullToEmpty(empty); assertArrayEquals(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, result); assertNotSame(empty, result); @@ -2216,13 +2216,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyLong() { - final long[] original = new long[]{1L, 2L}; + final long[] original = {1L, 2L}; assertEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyLongEmptyArray() { - final long[] empty = new long[]{}; + final long[] empty = {}; final long[] result = ArrayUtils.nullToEmpty(empty); assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, result); assertNotSame(empty, result); @@ -2235,13 +2235,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyLongObject() { - @SuppressWarnings("boxing") final Long[] original = new Long[]{1L, 2L}; + @SuppressWarnings("boxing") final Long[] original = {1L, 2L}; assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyLongObjectEmptyArray() { - final Long[] empty = new Long[]{}; + final Long[] empty = {}; final Long[] result = ArrayUtils.nullToEmpty(empty); assertArrayEquals(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, result); assertNotSame(empty, result); @@ -2254,13 +2254,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyObject() { - final Object[] original = new Object[]{Boolean.TRUE, Boolean.FALSE}; + final Object[] original = {Boolean.TRUE, Boolean.FALSE}; assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyObjectEmptyArray() { - final Object[] empty = new Object[]{}; + final Object[] empty = {}; final Object[] result = ArrayUtils.nullToEmpty(empty); assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, result); assertNotSame(empty, result); @@ -2273,13 +2273,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyShort() { - final short[] original = new short[]{1, 2}; + final short[] original = {1, 2}; assertEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyShortEmptyArray() { - final short[] empty = new short[]{}; + final short[] empty = {}; final short[] result = ArrayUtils.nullToEmpty(empty); assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, result); assertNotSame(empty, result); @@ -2292,13 +2292,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyShortObject() { - @SuppressWarnings("boxing") final Short[] original = new Short[]{1, 2}; + @SuppressWarnings("boxing") final Short[] original = {1, 2}; assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyShortObjectEmptyArray() { - final Short[] empty = new Short[]{}; + final Short[] empty = {}; final Short[] result = ArrayUtils.nullToEmpty(empty); assertArrayEquals(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, result); assertNotSame(empty, result); @@ -2311,13 +2311,13 @@ public class ArrayUtilsTest { @Test public void testNullToEmptyString() { - final String[] original = new String[]{"abc", "def"}; + final String[] original = {"abc", "def"}; assertArrayEquals(original, ArrayUtils.nullToEmpty(original)); } @Test public void testNullToEmptyStringEmptyArray() { - final String[] empty = new String[]{}; + final String[] empty = {}; final String[] result = ArrayUtils.nullToEmpty(empty); assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, result); assertNotSame(empty, result); @@ -2332,10 +2332,10 @@ public class ArrayUtilsTest { public void testReverse() { final StringBuffer str1 = new StringBuffer("pick"); final String str2 = "a"; - final String[] str3 = new String[]{"stick"}; + final String[] str3 = {"stick"}; final String str4 = "up"; - Object[] array = new Object[]{str1, str2, str3}; + Object[] array = {str1, str2, str3}; ArrayUtils.reverse(array); assertEquals(array[0], str3); assertEquals(array[1], str2); @@ -2355,7 +2355,7 @@ public class ArrayUtilsTest { @Test public void testReverseBoolean() { - boolean[] array = new boolean[]{false, false, true}; + boolean[] array = {false, false, true}; ArrayUtils.reverse(array); assertTrue(array[0]); assertFalse(array[1]); @@ -2368,7 +2368,7 @@ public class ArrayUtilsTest { @Test public void testReverseBooleanRange() { - boolean[] array = new boolean[]{false, false, true}; + boolean[] array = {false, false, true}; // The whole array ArrayUtils.reverse(array, 0, 3); assertTrue(array[0]); @@ -2400,7 +2400,7 @@ public class ArrayUtilsTest { @Test public void testReverseByte() { - byte[] array = new byte[]{2, 3, 4}; + byte[] array = {2, 3, 4}; ArrayUtils.reverse(array); assertEquals(array[0], 4); assertEquals(array[1], 3); @@ -2413,7 +2413,7 @@ public class ArrayUtilsTest { @Test public void testReverseByteRange() { - byte[] array = new byte[]{1, 2, 3}; + byte[] array = {1, 2, 3}; // The whole array ArrayUtils.reverse(array, 0, 3); assertEquals(3, array[0]); @@ -2445,7 +2445,7 @@ public class ArrayUtilsTest { @Test public void testReverseChar() { - char[] array = new char[]{'a', 'f', 'C'}; + char[] array = {'a', 'f', 'C'}; ArrayUtils.reverse(array); assertEquals(array[0], 'C'); assertEquals(array[1], 'f'); @@ -2458,7 +2458,7 @@ public class ArrayUtilsTest { @Test public void testReverseCharRange() { - char[] array = new char[]{1, 2, 3}; + char[] array = {1, 2, 3}; // The whole array ArrayUtils.reverse(array, 0, 3); assertEquals(3, array[0]); @@ -2490,7 +2490,7 @@ public class ArrayUtilsTest { @Test public void testReverseDouble() { - double[] array = new double[]{0.3d, 0.4d, 0.5d}; + double[] array = {0.3d, 0.4d, 0.5d}; ArrayUtils.reverse(array); assertEquals(0.5d, array[0]); assertEquals(0.4d, array[1]); @@ -2503,7 +2503,7 @@ public class ArrayUtilsTest { @Test public void testReverseDoubleRange() { - double[] array = new double[]{1, 2, 3}; + double[] array = {1, 2, 3}; // The whole array ArrayUtils.reverse(array, 0, 3); assertEquals(3, array[0]); @@ -2535,7 +2535,7 @@ public class ArrayUtilsTest { @Test public void testReverseFloat() { - float[] array = new float[]{0.3f, 0.4f, 0.5f}; + float[] array = {0.3f, 0.4f, 0.5f}; ArrayUtils.reverse(array); assertEquals(0.5f, array[0]); assertEquals(0.4f, array[1]); @@ -2548,7 +2548,7 @@ public class ArrayUtilsTest { @Test public void testReverseFloatRange() { - float[] array = new float[]{1, 2, 3}; + float[] array = {1, 2, 3}; // The whole array ArrayUtils.reverse(array, 0, 3); assertEquals(3, array[0]); @@ -2580,7 +2580,7 @@ public class ArrayUtilsTest { @Test public void testReverseInt() { - int[] array = new int[]{1, 2, 3}; + int[] array = {1, 2, 3}; ArrayUtils.reverse(array); assertEquals(array[0], 3); assertEquals(array[1], 2); @@ -2593,7 +2593,7 @@ public class ArrayUtilsTest { @Test public void testReverseIntRange() { - int[] array = new int[]{1, 2, 3}; + int[] array = {1, 2, 3}; // The whole array ArrayUtils.reverse(array, 0, 3); assertEquals(3, array[0]); @@ -2625,7 +2625,7 @@ public class ArrayUtilsTest { @Test public void testReverseLong() { - long[] array = new long[]{1L, 2L, 3L}; + long[] array = {1L, 2L, 3L}; ArrayUtils.reverse(array); assertEquals(array[0], 3L); assertEquals(array[1], 2L); @@ -2638,7 +2638,7 @@ public class ArrayUtilsTest { @Test public void testReverseLongRange() { - long[] array = new long[]{1, 2, 3}; + long[] array = {1, 2, 3}; // The whole array ArrayUtils.reverse(array, 0, 3); assertEquals(3, array[0]); @@ -2670,7 +2670,7 @@ public class ArrayUtilsTest { @Test public void testReverseObjectRange() { - String[] array = new String[]{"1", "2", "3"}; + String[] array = {"1", "2", "3"}; // The whole array ArrayUtils.reverse(array, 0, 3); assertEquals("3", array[0]); @@ -2702,7 +2702,7 @@ public class ArrayUtilsTest { @Test public void testReverseShort() { - short[] array = new short[]{1, 2, 3}; + short[] array = {1, 2, 3}; ArrayUtils.reverse(array); assertEquals(array[0], 3); assertEquals(array[1], 2); @@ -2715,7 +2715,7 @@ public class ArrayUtilsTest { @Test public void testReverseShortRange() { - short[] array = new short[]{1, 2, 3}; + short[] array = {1, 2, 3}; // The whole array ArrayUtils.reverse(array, 0, 3); assertEquals(3, array[0]); @@ -2748,9 +2748,9 @@ public class ArrayUtilsTest { @Test public void testSameLength() { final Object[] nullArray = null; - final Object[] emptyArray = new Object[0]; - final Object[] oneArray = new Object[]{"pick"}; - final Object[] twoArray = new Object[]{"pick", "stick"}; + final Object[] emptyArray = {}; + final Object[] oneArray = {"pick"}; + final Object[] twoArray = {"pick", "stick"}; assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); @@ -2776,41 +2776,41 @@ public class ArrayUtilsTest { @Test public void testSameLengthAll() { final Object[] nullArrayObject = null; - final Object[] emptyArrayObject = new Object[0]; - final Object[] oneArrayObject = new Object[]{"pick"}; - final Object[] twoArrayObject = new Object[]{"pick", "stick"}; + final Object[] emptyArrayObject = {}; + final Object[] oneArrayObject = {"pick"}; + final Object[] twoArrayObject = {"pick", "stick"}; final boolean[] nullArrayBoolean = null; - final boolean[] emptyArrayBoolean = new boolean[0]; - final boolean[] oneArrayBoolean = new boolean[]{true}; - final boolean[] twoArrayBoolean = new boolean[]{true, false}; + final boolean[] emptyArrayBoolean = {}; + final boolean[] oneArrayBoolean = {true}; + final boolean[] twoArrayBoolean = {true, false}; final long[] nullArrayLong = null; - final long[] emptyArrayLong = new long[0]; - final long[] oneArrayLong = new long[]{0L}; - final long[] twoArrayLong = new long[]{0L, 76L}; + final long[] emptyArrayLong = {}; + final long[] oneArrayLong = {0L}; + final long[] twoArrayLong = {0L, 76L}; final int[] nullArrayInt = null; - final int[] emptyArrayInt = new int[0]; - final int[] oneArrayInt = new int[]{4}; - final int[] twoArrayInt = new int[]{5, 7}; + final int[] emptyArrayInt = {}; + final int[] oneArrayInt = {4}; + final int[] twoArrayInt = {5, 7}; final short[] nullArrayShort = null; - final short[] emptyArrayShort = new short[0]; - final short[] oneArrayShort = new short[]{4}; - final short[] twoArrayShort = new short[]{6, 8}; + final short[] emptyArrayShort = {}; + final short[] oneArrayShort = {4}; + final short[] twoArrayShort = {6, 8}; final char[] nullArrayChar = null; - final char[] emptyArrayChar = new char[0]; - final char[] oneArrayChar = new char[]{'f'}; - final char[] twoArrayChar = new char[]{'d', 't'}; + final char[] emptyArrayChar = {}; + final char[] oneArrayChar = {'f'}; + final char[] twoArrayChar = {'d', 't'}; final byte[] nullArrayByte = null; - final byte[] emptyArrayByte = new byte[0]; - final byte[] oneArrayByte = new byte[]{3}; - final byte[] twoArrayByte = new byte[]{4, 6}; + final byte[] emptyArrayByte = {}; + final byte[] oneArrayByte = {3}; + final byte[] twoArrayByte = {4, 6}; final double[] nullArrayDouble = null; - final double[] emptyArrayDouble = new double[0]; - final double[] oneArrayDouble = new double[]{1.3d}; - final double[] twoArrayDouble = new double[]{4.5d, 6.3d}; + final double[] emptyArrayDouble = {}; + final double[] oneArrayDouble = {1.3d}; + final double[] twoArrayDouble = {4.5d, 6.3d}; final float[] nullArrayFloat = null; - final float[] emptyArrayFloat = new float[0]; - final float[] oneArrayFloat = new float[]{2.5f}; - final float[] twoArrayFloat = new float[]{6.4f, 5.8f}; + final float[] emptyArrayFloat = {}; + final float[] oneArrayFloat = {2.5f}; + final float[] twoArrayFloat = {6.4f, 5.8f}; assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayObject)); assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayBoolean)); assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayLong)); @@ -4112,9 +4112,9 @@ public class ArrayUtilsTest { @Test public void testSameLengthBoolean() { final boolean[] nullArray = null; - final boolean[] emptyArray = new boolean[0]; - final boolean[] oneArray = new boolean[]{true}; - final boolean[] twoArray = new boolean[]{true, false}; + final boolean[] emptyArray = {}; + final boolean[] oneArray = {true}; + final boolean[] twoArray = {true, false}; assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); @@ -4140,9 +4140,9 @@ public class ArrayUtilsTest { @Test public void testSameLengthByte() { final byte[] nullArray = null; - final byte[] emptyArray = new byte[0]; - final byte[] oneArray = new byte[]{3}; - final byte[] twoArray = new byte[]{4, 6}; + final byte[] emptyArray = {}; + final byte[] oneArray = {3}; + final byte[] twoArray = {4, 6}; assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); @@ -4168,9 +4168,9 @@ public class ArrayUtilsTest { @Test public void testSameLengthChar() { final char[] nullArray = null; - final char[] emptyArray = new char[0]; - final char[] oneArray = new char[]{'f'}; - final char[] twoArray = new char[]{'d', 't'}; + final char[] emptyArray = {}; + final char[] oneArray = {'f'}; + final char[] twoArray = {'d', 't'}; assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); @@ -4196,9 +4196,9 @@ public class ArrayUtilsTest { @Test public void testSameLengthDouble() { final double[] nullArray = null; - final double[] emptyArray = new double[0]; - final double[] oneArray = new double[]{1.3d}; - final double[] twoArray = new double[]{4.5d, 6.3d}; + final double[] emptyArray = {}; + final double[] oneArray = {1.3d}; + final double[] twoArray = {4.5d, 6.3d}; assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); @@ -4224,9 +4224,9 @@ public class ArrayUtilsTest { @Test public void testSameLengthFloat() { final float[] nullArray = null; - final float[] emptyArray = new float[0]; - final float[] oneArray = new float[]{2.5f}; - final float[] twoArray = new float[]{6.4f, 5.8f}; + final float[] emptyArray = {}; + final float[] oneArray = {2.5f}; + final float[] twoArray = {6.4f, 5.8f}; assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); @@ -4252,9 +4252,9 @@ public class ArrayUtilsTest { @Test public void testSameLengthInt() { final int[] nullArray = null; - final int[] emptyArray = new int[0]; - final int[] oneArray = new int[]{4}; - final int[] twoArray = new int[]{5, 7}; + final int[] emptyArray = {}; + final int[] oneArray = {4}; + final int[] twoArray = {5, 7}; assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); @@ -4280,9 +4280,9 @@ public class ArrayUtilsTest { @Test public void testSameLengthLong() { final long[] nullArray = null; - final long[] emptyArray = new long[0]; - final long[] oneArray = new long[]{0L}; - final long[] twoArray = new long[]{0L, 76L}; + final long[] emptyArray = {}; + final long[] oneArray = {0L}; + final long[] twoArray = {0L, 76L}; assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); @@ -4308,9 +4308,9 @@ public class ArrayUtilsTest { @Test public void testSameLengthShort() { final short[] nullArray = null; - final short[] emptyArray = new short[0]; - final short[] oneArray = new short[]{4}; - final short[] twoArray = new short[]{6, 8}; + final short[] emptyArray = {}; + final short[] oneArray = {4}; + final short[] twoArray = {6, 8}; assertTrue(ArrayUtils.isSameLength(nullArray, nullArray)); assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray)); @@ -4348,7 +4348,7 @@ public class ArrayUtilsTest { @Test public void testShiftAllByte() { - final byte[] array = new byte[]{1, 2, 3, 4}; + final byte[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 4); assertEquals(1, array[0]); assertEquals(2, array[1]); @@ -4363,7 +4363,7 @@ public class ArrayUtilsTest { @Test public void testShiftAllChar() { - final char[] array = new char[]{1, 2, 3, 4}; + final char[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 4); assertEquals(1, array[0]); assertEquals(2, array[1]); @@ -4378,7 +4378,7 @@ public class ArrayUtilsTest { @Test public void testShiftAllDouble() { - final double[] array = new double[]{1, 2, 3, 4}; + final double[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 4); assertEquals(1, array[0]); assertEquals(2, array[1]); @@ -4393,7 +4393,7 @@ public class ArrayUtilsTest { @Test public void testShiftAllFloat() { - final float[] array = new float[]{1, 2, 3, 4}; + final float[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 4); assertEquals(1, array[0]); assertEquals(2, array[1]); @@ -4408,7 +4408,7 @@ public class ArrayUtilsTest { @Test public void testShiftAllInt() { - final int[] array = new int[]{1, 2, 3, 4}; + final int[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 4); assertEquals(1, array[0]); assertEquals(2, array[1]); @@ -4423,7 +4423,7 @@ public class ArrayUtilsTest { @Test public void testShiftAllLong() { - final long[] array = new long[]{1, 2, 3, 4}; + final long[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 4); assertEquals(1, array[0]); assertEquals(2, array[1]); @@ -4438,7 +4438,7 @@ public class ArrayUtilsTest { @Test public void testShiftAllObject() { - final String[] array = new String[]{"1", "2", "3", "4"}; + final String[] array = {"1", "2", "3", "4"}; ArrayUtils.shift(array, 4); assertEquals("1", array[0]); assertEquals("2", array[1]); @@ -4453,7 +4453,7 @@ public class ArrayUtilsTest { @Test public void testShiftAllShort() { - final short[] array = new short[]{1, 2, 3, 4}; + final short[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 4); assertEquals(1, array[0]); assertEquals(2, array[1]); @@ -4468,7 +4468,7 @@ public class ArrayUtilsTest { @Test public void testShiftBoolean() { - final boolean[] array = new boolean[]{true, true, false, false}; + final boolean[] array = {true, true, false, false}; ArrayUtils.shift(array, 1); assertFalse(array[0]); @@ -4497,7 +4497,7 @@ public class ArrayUtilsTest { @Test public void testShiftByte() { - final byte[] array = new byte[]{1, 2, 3, 4}; + final byte[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 1); assertEquals(4, array[0]); assertEquals(1, array[1]); @@ -4522,7 +4522,7 @@ public class ArrayUtilsTest { @Test public void testShiftChar() { - final char[] array = new char[]{1, 2, 3, 4}; + final char[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 1); assertEquals(4, array[0]); assertEquals(1, array[1]); @@ -4547,7 +4547,7 @@ public class ArrayUtilsTest { @Test public void testShiftDouble() { - final double[] array = new double[]{1, 2, 3, 4}; + final double[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 1); assertEquals(4, array[0]); assertEquals(1, array[1]); @@ -4572,7 +4572,7 @@ public class ArrayUtilsTest { @Test public void testShiftFloat() { - final float[] array = new float[]{1, 2, 3, 4}; + final float[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 1); assertEquals(4, array[0]); assertEquals(1, array[1]); @@ -4598,7 +4598,7 @@ public class ArrayUtilsTest { @Test public void testShiftInt() { - final int[] array = new int[]{1, 2, 3, 4}; + final int[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 1); assertEquals(4, array[0]); assertEquals(1, array[1]); @@ -4623,7 +4623,7 @@ public class ArrayUtilsTest { @Test public void testShiftLong() { - final long[] array = new long[]{1, 2, 3, 4}; + final long[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 1); assertEquals(4, array[0]); assertEquals(1, array[1]); @@ -4704,7 +4704,7 @@ public class ArrayUtilsTest { @Test public void testShiftObject() { - final String[] array = new String[]{"1", "2", "3", "4"}; + final String[] array = {"1", "2", "3", "4"}; ArrayUtils.shift(array, 1); assertEquals("4", array[0]); assertEquals("1", array[1]); @@ -4729,7 +4729,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeByte() { - final byte[] array = new byte[]{1, 2, 3, 4, 5}; + final byte[] array = {1, 2, 3, 4, 5}; ArrayUtils.shift(array, 1, 3, 1); assertEquals(1, array[0]); assertEquals(3, array[1]); @@ -4746,7 +4746,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeChar() { - final char[] array = new char[]{1, 2, 3, 4, 5}; + final char[] array = {1, 2, 3, 4, 5}; ArrayUtils.shift(array, 1, 3, 1); assertEquals(1, array[0]); assertEquals(3, array[1]); @@ -4763,7 +4763,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeDouble() { - final double[] array = new double[]{1, 2, 3, 4, 5}; + final double[] array = {1, 2, 3, 4, 5}; ArrayUtils.shift(array, 1, 3, 1); assertEquals(1, array[0]); assertEquals(3, array[1]); @@ -4780,7 +4780,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeFloat() { - final float[] array = new float[]{1, 2, 3, 4, 5}; + final float[] array = {1, 2, 3, 4, 5}; ArrayUtils.shift(array, 1, 3, 1); assertEquals(1, array[0]); assertEquals(3, array[1]); @@ -4797,7 +4797,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeInt() { - final int[] array = new int[]{1, 2, 3, 4, 5}; + final int[] array = {1, 2, 3, 4, 5}; ArrayUtils.shift(array, 1, 3, 1); assertEquals(1, array[0]); assertEquals(3, array[1]); @@ -4814,7 +4814,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeLong() { - final long[] array = new long[]{1, 2, 3, 4, 5}; + final long[] array = {1, 2, 3, 4, 5}; ArrayUtils.shift(array, 1, 3, 1); assertEquals(1, array[0]); assertEquals(3, array[1]); @@ -4831,7 +4831,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeNoElemByte() { - final byte[] array = new byte[]{1, 2, 3, 4}; + final byte[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 1, 1, 1); assertEquals(1, array[0]); assertEquals(2, array[1]); @@ -4841,7 +4841,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeNoElemChar() { - final char[] array = new char[]{1, 2, 3, 4}; + final char[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 1, 1, 1); assertEquals(1, array[0]); assertEquals(2, array[1]); @@ -4851,7 +4851,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeNoElemDouble() { - final double[] array = new double[]{1, 2, 3, 4}; + final double[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 1, 1, 1); assertEquals(1, array[0]); assertEquals(2, array[1]); @@ -4861,7 +4861,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeNoElemFloat() { - final float[] array = new float[]{1, 2, 3, 4}; + final float[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 1, 1, 1); assertEquals(1, array[0]); assertEquals(2, array[1]); @@ -4871,7 +4871,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeNoElemInt() { - final int[] array = new int[]{1, 2, 3, 4}; + final int[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 1, 1, 1); assertEquals(1, array[0]); assertEquals(2, array[1]); @@ -4881,7 +4881,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeNoElemLong() { - final long[] array = new long[]{1, 2, 3, 4}; + final long[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 1, 1, 1); assertEquals(1, array[0]); assertEquals(2, array[1]); @@ -4891,7 +4891,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeNoElemObject() { - final String[] array = new String[]{"1", "2", "3", "4"}; + final String[] array = {"1", "2", "3", "4"}; ArrayUtils.shift(array, 1, 1, 1); assertEquals("1", array[0]); assertEquals("2", array[1]); @@ -4901,7 +4901,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeNoElemShort() { - final short[] array = new short[]{1, 2, 3, 4}; + final short[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 1, 1, 1); assertEquals(1, array[0]); assertEquals(2, array[1]); @@ -4968,7 +4968,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeObject() { - final String[] array = new String[]{"1", "2", "3", "4", "5"}; + final String[] array = {"1", "2", "3", "4", "5"}; ArrayUtils.shift(array, 1, 3, 1); assertEquals("1", array[0]); assertEquals("3", array[1]); @@ -4985,7 +4985,7 @@ public class ArrayUtilsTest { @Test public void testShiftRangeShort() { - final short[] array = new short[]{1, 2, 3, 4, 5}; + final short[] array = {1, 2, 3, 4, 5}; ArrayUtils.shift(array, 1, 3, 1); assertEquals(1, array[0]); assertEquals(3, array[1]); @@ -5002,7 +5002,7 @@ public class ArrayUtilsTest { @Test public void testShiftShort() { - short[] array = new short[]{1, 2, 3, 4}; + short[] array = {1, 2, 3, 4}; ArrayUtils.shift(array, 1); assertEquals(4, array[0]); assertEquals(1, array[1]); @@ -5034,7 +5034,7 @@ public class ArrayUtilsTest { @Test public void testShuffle() { - final String[] array1 = new String[]{"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"}; + final String[] array1 = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"}; final String[] array2 = ArrayUtils.clone(array1); ArrayUtils.shuffle(array1, new Random(SEED)); @@ -5046,7 +5046,7 @@ public class ArrayUtilsTest { @Test public void testShuffleBoolean() { - final boolean[] array1 = new boolean[]{true, false, true, true, false, false, true, false, false, true}; + final boolean[] array1 = {true, false, true, true, false, false, true, false, false, true}; final boolean[] array2 = ArrayUtils.clone(array1); ArrayUtils.shuffle(array1, new Random(SEED)); @@ -5056,7 +5056,7 @@ public class ArrayUtilsTest { @Test public void testShuffleByte() { - final byte[] array1 = new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + final byte[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; final byte[] array2 = ArrayUtils.clone(array1); ArrayUtils.shuffle(array1, new Random(SEED)); @@ -5068,7 +5068,7 @@ public class ArrayUtilsTest { @Test public void testShuffleChar() { - final char[] array1 = new char[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + final char[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; final char[] array2 = ArrayUtils.clone(array1); ArrayUtils.shuffle(array1, new Random(SEED)); @@ -5080,7 +5080,7 @@ public class ArrayUtilsTest { @Test public void testShuffleDouble() { - final double[] array1 = new double[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + final double[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; final double[] array2 = ArrayUtils.clone(array1); ArrayUtils.shuffle(array1, new Random(SEED)); @@ -5092,7 +5092,7 @@ public class ArrayUtilsTest { @Test public void testShuffleFloat() { - final float[] array1 = new float[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + final float[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; final float[] array2 = ArrayUtils.clone(array1); ArrayUtils.shuffle(array1, new Random(SEED)); @@ -5104,7 +5104,7 @@ public class ArrayUtilsTest { @Test public void testShuffleInt() { - final int[] array1 = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + final int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; final int[] array2 = ArrayUtils.clone(array1); ArrayUtils.shuffle(array1, new Random(SEED)); @@ -5116,7 +5116,7 @@ public class ArrayUtilsTest { @Test public void testShuffleLong() { - final long[] array1 = new long[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + final long[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; final long[] array2 = ArrayUtils.clone(array1); ArrayUtils.shuffle(array1, new Random(SEED)); @@ -5128,7 +5128,7 @@ public class ArrayUtilsTest { @Test public void testShuffleShort() { - final short[] array1 = new short[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + final short[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; final short[] array2 = ArrayUtils.clone(array1); ArrayUtils.shuffle(array1, new Random(SEED)); @@ -5524,7 +5524,7 @@ public class ArrayUtilsTest { @Test public void testSwapBoolean() { - final boolean[] array = new boolean[]{true, false, false}; + final boolean[] array = {true, false, false}; ArrayUtils.swap(array, 0, 2); assertFalse(array[0]); assertFalse(array[1]); @@ -5533,7 +5533,7 @@ public class ArrayUtilsTest { @Test public void testSwapBooleanRange() { - boolean[] array = new boolean[]{false, false, true, true}; + boolean[] array = {false, false, true, true}; ArrayUtils.swap(array, 0, 2, 2); assertTrue(array[0]); assertTrue(array[1]); @@ -5573,7 +5573,7 @@ public class ArrayUtilsTest { @Test public void testSwapByte() { - final byte[] array = new byte[]{1, 2, 3}; + final byte[] array = {1, 2, 3}; ArrayUtils.swap(array, 0, 2); assertEquals(3, array[0]); assertEquals(2, array[1]); @@ -5582,7 +5582,7 @@ public class ArrayUtilsTest { @Test public void testSwapByteRange() { - byte[] array = new byte[]{1, 2, 3, 4}; + byte[] array = {1, 2, 3, 4}; ArrayUtils.swap(array, 0, 2, 2); assertEquals(3, array[0]); assertEquals(4, array[1]); @@ -5622,7 +5622,7 @@ public class ArrayUtilsTest { @Test public void testSwapChar() { - char[] array = new char[]{1, 2, 3}; + char[] array = {1, 2, 3}; ArrayUtils.swap(array, 0, 2); assertArrayEquals(new char[]{3, 2, 1}, array); @@ -5637,7 +5637,7 @@ public class ArrayUtilsTest { @Test public void testSwapCharRange() { - char[] array = new char[]{1, 2, 3, 4}; + char[] array = {1, 2, 3, 4}; ArrayUtils.swap(array, 0, 2, 2); assertEquals(3, array[0]); assertEquals(4, array[1]); @@ -5677,7 +5677,7 @@ public class ArrayUtilsTest { @Test public void testSwapDouble() { - final double[] array = new double[]{1, 2, 3}; + final double[] array = {1, 2, 3}; ArrayUtils.swap(array, 0, 2); assertEquals(3, array[0]); assertEquals(2, array[1]); @@ -5686,7 +5686,7 @@ public class ArrayUtilsTest { @Test public void testSwapDoubleRange() { - double[] array = new double[]{1, 2, 3, 4}; + double[] array = {1, 2, 3, 4}; ArrayUtils.swap(array, 0, 2, 2); assertEquals(3, array[0]); assertEquals(4, array[1]); @@ -5726,70 +5726,70 @@ public class ArrayUtilsTest { @Test public void testSwapEmptyBooleanArray() { - final boolean[] array = new boolean[0]; + final boolean[] array = {}; ArrayUtils.swap(array, 0, 2); assertEquals(0, array.length); } @Test public void testSwapEmptyByteArray() { - final byte[] array = new byte[0]; + final byte[] array = {}; ArrayUtils.swap(array, 0, 2); assertEquals(0, array.length); } @Test public void testSwapEmptyCharArray() { - final char[] array = new char[0]; + final char[] array = {}; ArrayUtils.swap(array, 0, 2); assertEquals(0, array.length); } @Test public void testSwapEmptyDoubleArray() { - final double[] array = new double[0]; + final double[] array = {}; ArrayUtils.swap(array, 0, 2); assertEquals(0, array.length); } @Test public void testSwapEmptyFloatArray() { - final float[] array = new float[0]; + final float[] array = {}; ArrayUtils.swap(array, 0, 2); assertEquals(0, array.length); } @Test public void testSwapEmptyIntArray() { - final int[] array = new int[0]; + final int[] array = {}; ArrayUtils.swap(array, 0, 2); assertEquals(0, array.length); } @Test public void testSwapEmptyLongArray() { - final long[] array = new long[0]; + final long[] array = {}; ArrayUtils.swap(array, 0, 2); assertEquals(0, array.length); } @Test public void testSwapEmptyObjectArray() { - final String[] array = new String[0]; + final String[] array = {}; ArrayUtils.swap(array, 0, 2); assertEquals(0, array.length); } @Test public void testSwapEmptyShortArray() { - final short[] array = new short[0]; + final short[] array = {}; ArrayUtils.swap(array, 0, 2); assertEquals(0, array.length); } @Test public void testSwapFloat() { - final float[] array = new float[]{1, 2, 3}; + final float[] array = {1, 2, 3}; ArrayUtils.swap(array, 0, 2); assertEquals(3, array[0]); assertEquals(2, array[1]); @@ -5798,7 +5798,7 @@ public class ArrayUtilsTest { @Test public void testSwapFloatRange() { - float[] array = new float[]{1, 2, 3, 4}; + float[] array = {1, 2, 3, 4}; ArrayUtils.swap(array, 0, 2, 2); assertEquals(3, array[0]); assertEquals(4, array[1]); @@ -5838,7 +5838,7 @@ public class ArrayUtilsTest { @Test public void testSwapInt() { - final int[] array = new int[]{1, 2, 3}; + final int[] array = {1, 2, 3}; ArrayUtils.swap(array, 0, 2); assertEquals(3, array[0]); assertEquals(2, array[1]); @@ -5859,7 +5859,7 @@ public class ArrayUtilsTest { @Test public void testSwapIntRange() { - int[] array = new int[]{1, 2, 3, 4}; + int[] array = {1, 2, 3, 4}; ArrayUtils.swap(array, 0, 2, 2); assertEquals(3, array[0]); assertEquals(4, array[1]); @@ -5899,7 +5899,7 @@ public class ArrayUtilsTest { @Test public void testSwapLong() { - final long[] array = new long[]{1, 2, 3}; + final long[] array = {1, 2, 3}; ArrayUtils.swap(array, 0, 2); assertEquals(3, array[0]); assertEquals(2, array[1]); @@ -5908,7 +5908,7 @@ public class ArrayUtilsTest { @Test public void testSwapLongRange() { - long[] array = new long[]{1, 2, 3, 4}; + long[] array = {1, 2, 3, 4}; ArrayUtils.swap(array, 0, 2, 2); assertEquals(3, array[0]); assertEquals(4, array[1]); @@ -6011,7 +6011,7 @@ public class ArrayUtilsTest { @Test public void testSwapObject() { - final String[] array = new String[]{"1", "2", "3"}; + final String[] array = {"1", "2", "3"}; ArrayUtils.swap(array, 0, 2); assertEquals("3", array[0]); assertEquals("2", array[1]); @@ -6020,7 +6020,7 @@ public class ArrayUtilsTest { @Test public void testSwapObjectRange() { - String[] array = new String[]{"1", "2", "3", "4"}; + String[] array = {"1", "2", "3", "4"}; ArrayUtils.swap(array, 0, 2, 2); assertEquals("3", array[0]); assertEquals("4", array[1]); @@ -6061,7 +6061,7 @@ public class ArrayUtilsTest { @Test public void testSwapShort() { - final short[] array = new short[]{1, 2, 3}; + final short[] array = {1, 2, 3}; ArrayUtils.swap(array, 0, 2); assertEquals(3, array[0]); assertEquals(2, array[1]); @@ -6070,7 +6070,7 @@ public class ArrayUtilsTest { @Test public void testSwapShortRange() { - short[] array = new short[]{1, 2, 3, 4}; + short[] array = {1, 2, 3, 4}; ArrayUtils.swap(array, 0, 2, 2); assertEquals(3, array[0]); assertEquals(4, array[1]); @@ -6539,7 +6539,7 @@ public class ArrayUtilsTest { assertArrayEquals(new String[0], ArrayUtils.toStringArray(new Object[0])); - final Object[] array = new Object[]{1, 2, 3, "array", "test"}; + final Object[] array = {1, 2, 3, "array", "test"}; assertArrayEquals(new String[]{"1", "2", "3", "array", "test"}, ArrayUtils.toStringArray(array)); assertThrows(NullPointerException.class, () -> ArrayUtils.toStringArray(new Object[]{null})); @@ -6551,7 +6551,7 @@ public class ArrayUtilsTest { assertArrayEquals(new String[0], ArrayUtils.toStringArray(new Object[0], "")); - final Object[] array = new Object[]{1, null, "test"}; + final Object[] array = {1, null, "test"}; assertArrayEquals(new String[]{"1", "valueForNullElements", "test"}, ArrayUtils.toStringArray(array, "valueForNullElements")); } diff --git a/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java b/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java index 0865f945c..58d7ab4c9 100644 --- a/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java @@ -38,7 +38,7 @@ public class BooleanUtilsTest { @Test public void test_booleanValues() { - final Boolean[] expected = new Boolean[] {false, true}; + final Boolean[] expected = {false, true}; assertArrayEquals(sort(expected), BooleanUtils.booleanValues()); } diff --git a/src/test/java/org/apache/commons/lang3/ConversionTest.java b/src/test/java/org/apache/commons/lang3/ConversionTest.java index 7cf32cb13..59b372bd6 100644 --- a/src/test/java/org/apache/commons/lang3/ConversionTest.java +++ b/src/test/java/org/apache/commons/lang3/ConversionTest.java @@ -227,11 +227,11 @@ public class ConversionTest { */ @Test public void testBinaryToHexDigit_2args() { - final boolean[] shortArray = new boolean[]{false, true, true}; + final boolean[] shortArray = {false, true, true}; assertEquals('6', Conversion.binaryToHexDigit(shortArray, 0)); assertEquals('3', Conversion.binaryToHexDigit(shortArray, 1)); assertEquals('1', Conversion.binaryToHexDigit(shortArray, 2)); - final boolean[] longArray = new boolean[]{true, false, true, false, false, true, true}; + final boolean[] longArray = {true, false, true, false, false, true, true}; assertEquals('5', Conversion.binaryToHexDigit(longArray, 0)); assertEquals('2', Conversion.binaryToHexDigit(longArray, 1)); assertEquals('9', Conversion.binaryToHexDigit(longArray, 2)); @@ -295,9 +295,9 @@ public class ConversionTest { // assertEquals('6', Conversion.BinaryToHexDigitMsb0(shortArray, 0)); // assertEquals('3', Conversion.BinaryToHexDigitMsb0(shortArray, 1)); // assertEquals('1', Conversion.BinaryToHexDigitMsb0(shortArray, 2)); - final boolean[] shortArray = new boolean[]{true, true, false, true}; + final boolean[] shortArray = {true, true, false, true}; assertEquals('d', Conversion.binaryToHexDigitMsb0_4bits(shortArray, 0)); - final boolean[] longArray = new boolean[]{true, false, true, false, false, true, true}; + final boolean[] longArray = {true, false, true, false, false, true, true}; assertEquals('a', Conversion.binaryToHexDigitMsb0_4bits(longArray, 0)); assertEquals('4', Conversion.binaryToHexDigitMsb0_4bits(longArray, 1)); assertEquals('9', Conversion.binaryToHexDigitMsb0_4bits(longArray, 2)); @@ -305,7 +305,7 @@ public class ConversionTest { // assertEquals('6', Conversion.BinaryToHexDigitMsb0(longArray, 4)); // assertEquals('3', Conversion.BinaryToHexDigitMsb0(longArray, 5)); // assertEquals('1', Conversion.BinaryToHexDigitMsb0(longArray, 6)); - final boolean[] maxLengthArray = new boolean[]{ + final boolean[] maxLengthArray = { true, false, true, false, false, true, true, true}; assertEquals('a', Conversion.binaryToHexDigitMsb0_4bits(maxLengthArray, 0)); assertEquals('4', Conversion.binaryToHexDigitMsb0_4bits(maxLengthArray, 1)); @@ -315,7 +315,7 @@ public class ConversionTest { // assertEquals('7', Conversion.BinaryToHexDigitMsb0(longArray, 5)); // assertEquals('3', Conversion.BinaryToHexDigitMsb0(longArray, 6)); // assertEquals('1', Conversion.BinaryToHexDigitMsb0(longArray, 7)); - final boolean[] javaDocCheck = new boolean[]{ + final boolean[] javaDocCheck = { true, false, false, true, true, false, true, false}; assertEquals('d', Conversion.binaryToHexDigitMsb0_4bits(javaDocCheck, 3)); @@ -377,11 +377,11 @@ public class ConversionTest { true, false, false, false, false, false, false, false, false, false, false, true, false, true, false, false}, 2)); - final boolean[] shortArray = new boolean[]{true, true, false}; + final boolean[] shortArray = {true, true, false}; assertEquals('6', Conversion.binaryBeMsb0ToHexDigit(shortArray, 0)); assertEquals('3', Conversion.binaryBeMsb0ToHexDigit(shortArray, 1)); assertEquals('1', Conversion.binaryBeMsb0ToHexDigit(shortArray, 2)); - final boolean[] shortArray2 = new boolean[]{true, true, true, false, false, true, false, true}; + final boolean[] shortArray2 = {true, true, true, false, false, true, false, true}; assertEquals('5', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 0)); assertEquals('2', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 1)); assertEquals('9', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 2)); @@ -390,7 +390,7 @@ public class ConversionTest { assertEquals('7', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 5)); assertEquals('3', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 6)); assertEquals('1', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 7)); - final boolean[] multiBytesArray = new boolean[]{ + final boolean[] multiBytesArray = { true, true, false, false, true, false, true, false, true, true, true, false, false, true, false, true}; assertEquals('5', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 0)); @@ -479,7 +479,7 @@ public class ConversionTest { */ @Test public void testIntArrayToLong() { - final int[] src = new int[]{0xCDF1F0C1, 0x0F123456, 0x78000000}; + final int[] src = {0xCDF1F0C1, 0x0F123456, 0x78000000}; assertEquals(0x0000000000000000L, Conversion.intArrayToLong(src, 0, 0L, 0, 0)); assertEquals(0x0000000000000000L, Conversion.intArrayToLong(src, 1, 0L, 0, 0)); assertEquals(0x00000000CDF1F0C1L, Conversion.intArrayToLong(src, 0, 0L, 0, 1)); @@ -497,7 +497,7 @@ public class ConversionTest { */ @Test public void testShortArrayToLong() { - final short[] src = new short[]{ + final short[] src = { (short) 0xCDF1, (short) 0xF0C1, (short) 0x0F12, (short) 0x3456, (short) 0x7800}; assertEquals(0x0000000000000000L, Conversion.shortArrayToLong(src, 0, 0L, 0, 0)); assertEquals(0x000000000000CDF1L, Conversion.shortArrayToLong(src, 0, 0L, 0, 1)); @@ -518,7 +518,7 @@ public class ConversionTest { */ @Test public void testByteArrayToLong() { - final byte[] src = new byte[]{ + final byte[] src = { (byte) 0xCD, (byte) 0xF1, (byte) 0xF0, (byte) 0xC1, (byte) 0x0F, (byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78}; assertEquals(0x0000000000000000L, Conversion.byteArrayToLong(src, 0, 0L, 0, 0)); @@ -538,7 +538,7 @@ public class ConversionTest { */ @Test public void testShortArrayToInt() { - final short[] src = new short[]{ + final short[] src = { (short) 0xCDF1, (short) 0xF0C1, (short) 0x0F12, (short) 0x3456, (short) 0x7800}; assertEquals(0x00000000, Conversion.shortArrayToInt(src, 0, 0, 0, 0)); assertEquals(0x0000CDF1, Conversion.shortArrayToInt(src, 0, 0, 0, 1)); @@ -554,7 +554,7 @@ public class ConversionTest { */ @Test public void testByteArrayToInt() { - final byte[] src = new byte[]{ + final byte[] src = { (byte) 0xCD, (byte) 0xF1, (byte) 0xF0, (byte) 0xC1, (byte) 0x0F, (byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78}; assertEquals(0x00000000, Conversion.byteArrayToInt(src, 0, 0, 0, 0)); @@ -571,7 +571,7 @@ public class ConversionTest { */ @Test public void testByteArrayToShort() { - final byte[] src = new byte[]{ + final byte[] src = { (byte) 0xCD, (byte) 0xF1, (byte) 0xF0, (byte) 0xC1, (byte) 0x0F, (byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78}; assertEquals((short) 0x0000, Conversion.byteArrayToShort(src, 0, (short) 0, 0, 0)); @@ -647,7 +647,7 @@ public class ConversionTest { */ @Test public void testBinaryToLong() { - final boolean[] src = new boolean[]{ + final boolean[] src = { false, false, true, true, true, false, true, true, true, true, true, true, true, false, false, false, true, true, true, true, false, false, false, false, false, false, true, true, true, false, false, false, false, false, false, false, true, @@ -671,7 +671,7 @@ public class ConversionTest { */ @Test public void testBinaryToInt() { - final boolean[] src = new boolean[]{ + final boolean[] src = { false, false, true, true, true, false, true, true, true, true, true, true, true, false, false, false, true, true, true, true, false, false, false, false, false, false, true, true, true, false, false, false, false, false, false, false, true, @@ -692,7 +692,7 @@ public class ConversionTest { */ @Test public void testBinaryToShort() { - final boolean[] src = new boolean[]{ + final boolean[] src = { false, false, true, true, true, false, true, true, true, true, true, true, true, false, false, false, true, true, true, true, false, false, false, false, false, false, true, true, true, false, false, false, false, false, false, false, true, @@ -715,7 +715,7 @@ public class ConversionTest { */ @Test public void testBinaryToByte() { - final boolean[] src = new boolean[]{ + final boolean[] src = { false, false, true, true, true, false, true, true, true, true, true, true, true, false, false, false, true, true, true, true, false, false, false, false, false, false, true, true, true, false, false, false, false, false, false, false, true, diff --git a/src/test/java/org/apache/commons/lang3/ObjectUtilsTest.java b/src/test/java/org/apache/commons/lang3/ObjectUtilsTest.java index 9b2991a37..637ea24ad 100644 --- a/src/test/java/org/apache/commons/lang3/ObjectUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/ObjectUtilsTest.java @@ -121,7 +121,7 @@ public class ObjectUtilsTest { } private static final String FOO = "foo"; private static final String BAR = "bar"; - private static final String[] NON_EMPTY_ARRAY = new String[] { FOO, BAR, }; + private static final String[] NON_EMPTY_ARRAY = { FOO, BAR, }; private static final List<String> NON_EMPTY_LIST = Arrays.asList(NON_EMPTY_ARRAY); @@ -460,7 +460,7 @@ public class ObjectUtilsTest { @Test public void testHashCodeMulti_multiple_emptyArray() { - final Object[] array = new Object[0]; + final Object[] array = {}; assertEquals(1, ObjectUtils.hashCodeMulti(array)); } diff --git a/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java b/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java index 03e4f284e..4a5b36524 100644 --- a/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java @@ -168,7 +168,7 @@ public class RandomStringUtilsTest { @Test public void testExceptions() { - final char[] DUMMY = new char[]{'a'}; // valid char array + final char[] DUMMY = {'a'}; // valid char array assertThrows(IllegalArgumentException.class, () -> RandomStringUtils.random(-1)); assertThrows(IllegalArgumentException.class, () -> RandomStringUtils.random(-1, true, true)); assertThrows(IllegalArgumentException.class, () -> RandomStringUtils.random(-1, DUMMY)); diff --git a/src/test/java/org/apache/commons/lang3/StringEscapeUtilsTest.java b/src/test/java/org/apache/commons/lang3/StringEscapeUtilsTest.java index 29dda0da9..613ed48a6 100644 --- a/src/test/java/org/apache/commons/lang3/StringEscapeUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/StringEscapeUtilsTest.java @@ -476,7 +476,7 @@ public class StringEscapeUtilsTest { // COUNTING ROD UNIT DIGIT THREE // in Unicode // codepoint: U+1D362 - final byte[] data = new byte[] { (byte) 0xF0, (byte) 0x9D, (byte) 0x8D, (byte) 0xA2 }; + final byte[] data = { (byte) 0xF0, (byte) 0x9D, (byte) 0x8D, (byte) 0xA2 }; final String original = new String(data, StandardCharsets.UTF_8); diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java index 6ef2732a1..0f0237532 100644 --- a/src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java +++ b/src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java @@ -314,7 +314,7 @@ public class StringUtilsContainsTest { final char[] chars1= {'b'}; final char[] chars2= {'.'}; final char[] chars3= {'c', 'd'}; - final char[] emptyChars = new char[0]; + final char[] emptyChars = {}; assertTrue(StringUtils.containsNone(null, (char[]) null)); assertTrue(StringUtils.containsNone("", (char[]) null)); assertTrue(StringUtils.containsNone(null, emptyChars)); @@ -429,7 +429,7 @@ public class StringUtilsContainsTest { final char[] chars1= {'b'}; final char[] chars2= {'a'}; final char[] chars3= {'a', 'b'}; - final char[] emptyChars = new char[0]; + final char[] emptyChars = {}; assertFalse(StringUtils.containsOnly(null, (char[]) null)); assertFalse(StringUtils.containsOnly("", (char[]) null)); assertFalse(StringUtils.containsOnly(null, emptyChars)); diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java index a597ef259..daa112636 100644 --- a/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java +++ b/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java @@ -47,7 +47,7 @@ public class StringUtilsEqualsIndexOfTest { private static final String FOOBAR = "foobar"; - private static final String[] FOOBAR_SUB_ARRAY = new String[] {"ob", "ba"}; + private static final String[] FOOBAR_SUB_ARRAY = {"ob", "ba"}; // The purpose of this class is to test StringUtils#equals(CharSequence, CharSequence) // with a CharSequence implementation whose equals(Object) override requires that the diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsTest.java index c86d437cb..609c0b8d5 100644 --- a/src/test/java/org/apache/commons/lang3/StringUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/StringUtilsTest.java @@ -1364,7 +1364,7 @@ public class StringUtilsTest { @Disabled @Test public void testLang1593() { - final int[] arr = new int[] {1, 2, 3, 4, 5, 6, 7}; + final int[] arr = {1, 2, 3, 4, 5, 6, 7}; final String expected = StringUtils.join(arr, '-'); final String actual = StringUtils.join(arr, "-"); assertEquals(expected, actual); @@ -2443,7 +2443,7 @@ public class StringUtilsTest { // test whitespace String input = "ab de fg"; - String[] expected = new String[]{"ab", "", "", "de", "fg"}; + String[] expected = {"ab", "", "", "de", "fg"}; String[] actual = StringUtils.splitByWholeSeparatorPreserveAllTokens(input, null); assertEquals(expected.length, actual.length); @@ -2480,7 +2480,7 @@ public class StringUtilsTest { // test whitespace String input = "ab de fg"; - String[] expected = new String[]{"ab", "", "", "de", "fg"}; + String[] expected = {"ab", "", "", "de", "fg"}; String[] actual = StringUtils.splitByWholeSeparatorPreserveAllTokens(input, null, -1); assertEquals(expected.length, actual.length); @@ -3340,13 +3340,13 @@ public class StringUtilsTest { @Test public void testGeorgianSample() { - final char[] arrayI = new char[]{ + final char[] arrayI = { //Latin Small Letter dotless I (char) 0x0131, //Greek Capital Letter Theta (char) 0x03F4 }; - final char[] arrayJ = new char[]{ + final char[] arrayJ = { //Latin Capital Letter I with dot above (char) 0x0130, //Greek Theta Symbol diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java index 1cd136e4e..ee32f0116 100644 --- a/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java +++ b/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java @@ -199,10 +199,10 @@ public class StringUtilsTrimStripTest { @Test public void testStripAll() { // test stripAll method, merely an array version of the above strip - final String[] empty = new String[0]; - final String[] fooSpace = new String[] { " "+FOO+" ", " "+FOO, FOO+" " }; - final String[] fooDots = new String[] { ".."+FOO+"..", ".."+FOO, FOO+".." }; - final String[] foo = new String[] { FOO, FOO, FOO }; + final String[] empty = {}; + final String[] fooSpace = { " "+FOO+" ", " "+FOO, FOO+" " }; + final String[] fooDots = { ".."+FOO+"..", ".."+FOO, FOO+".." }; + final String[] foo = { FOO, FOO, FOO }; assertNull(StringUtils.stripAll((String[]) null)); // Additional varargs tests diff --git a/src/test/java/org/apache/commons/lang3/ValidateTest.java b/src/test/java/org/apache/commons/lang3/ValidateTest.java index e273ae52b..51ce1f153 100644 --- a/src/test/java/org/apache/commons/lang3/ValidateTest.java +++ b/src/test/java/org/apache/commons/lang3/ValidateTest.java @@ -208,7 +208,7 @@ class ValidateTest { @Test void shouldReturnTheSameInstance() { - final String[] array = new String[]{"hi"}; + final String[] array = {"hi"}; final String[] result = Validate.notEmpty(array); assertSame(array, result); @@ -243,7 +243,7 @@ class ValidateTest { @Test void shouldReturnTheSameInstance() { - final String[] array = new String[]{"hi"}; + final String[] array = {"hi"}; final String[] result = Validate.notEmpty(array, "MSG"); assertSame(array, result); diff --git a/src/test/java/org/apache/commons/lang3/builder/CompareToBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/CompareToBuilderTest.java index c7dee69eb..793940dce 100644 --- a/src/test/java/org/apache/commons/lang3/builder/CompareToBuilderTest.java +++ b/src/test/java/org/apache/commons/lang3/builder/CompareToBuilderTest.java @@ -128,7 +128,7 @@ public class CompareToBuilderTest { @Test public void testReflectionHierarchyCompareExcludeFields() { - final String[] excludeFields = new String[] { "b" }; + final String[] excludeFields = { "b" }; testReflectionHierarchyCompare(true, excludeFields); TestSubObject x; diff --git a/src/test/java/org/apache/commons/lang3/builder/DefaultToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/DefaultToStringStyleTest.java index dc8dede39..13bf2ba72 100644 --- a/src/test/java/org/apache/commons/lang3/builder/DefaultToStringStyleTest.java +++ b/src/test/java/org/apache/commons/lang3/builder/DefaultToStringStyleTest.java @@ -124,7 +124,7 @@ public class DefaultToStringStyleTest { @Test public void testObjectArray() { - Object[] array = new Object[] {null, base, new int[] {3, 6}}; + Object[] array = {null, base, new int[] {3, 6}}; assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -134,7 +134,7 @@ public class DefaultToStringStyleTest { @Test public void testLongArray() { - long[] array = new long[] {1, 2, -3, 4}; + long[] array = {1, 2, -3, 4}; assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -144,7 +144,7 @@ public class DefaultToStringStyleTest { @Test public void testLongArrayArray() { - long[][] array = new long[][] {{1, 2}, null, {5}}; + long[][] array = {{1, 2}, null, {5}}; assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; diff --git a/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java index af64dddcd..d4610edcb 100644 --- a/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java +++ b/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java @@ -916,7 +916,7 @@ public class EqualsBuilderTest { assertFalse(new EqualsBuilder().append(array1, array2).isEquals()); // compare 1 dim to 2. - final boolean[] array3 = new boolean[]{true, true}; + final boolean[] array3 = {true, true}; assertFalse(new EqualsBuilder().append(array1, array3).isEquals()); assertFalse(new EqualsBuilder().append(array3, array1).isEquals()); assertFalse(new EqualsBuilder().append(array2, array3).isEquals()); @@ -1190,8 +1190,8 @@ public class EqualsBuilderTest { */ @Test public void testUnrelatedClasses() { - final Object[] x = new Object[]{new TestACanEqualB(1)}; - final Object[] y = new Object[]{new TestBCanEqualA(1)}; + final Object[] x = {new TestACanEqualB(1)}; + final Object[] y = {new TestBCanEqualA(1)}; // sanity checks: assertArrayEquals(x, x); @@ -1214,8 +1214,8 @@ public class EqualsBuilderTest { */ @Test public void testNpeForNullElement() { - final Object[] x1 = new Object[]{Integer.valueOf(1), null, Integer.valueOf(3)}; - final Object[] x2 = new Object[]{Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3)}; + final Object[] x1 = {Integer.valueOf(1), null, Integer.valueOf(3)}; + final Object[] x2 = {Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3)}; // causes an NPE in 2.0 according to: // https://issues.apache.org/bugzilla/show_bug.cgi?id=33067 @@ -1317,9 +1317,9 @@ public class EqualsBuilderTest { final TestObject one = new TestObject(1); final TestObject two = new TestObject(2); - final Object[] o1 = new Object[]{one}; - final Object[] o2 = new Object[]{two}; - final Object[] o3 = new Object[]{one}; + final Object[] o1 = {one}; + final Object[] o2 = {two}; + final Object[] o3 = {one}; assertFalse(EqualsBuilder.reflectionEquals(o1, o2)); assertTrue(EqualsBuilder.reflectionEquals(o1, o1)); diff --git a/src/test/java/org/apache/commons/lang3/builder/JsonToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/JsonToStringStyleTest.java index 045a3fc03..d11d6431e 100644 --- a/src/test/java/org/apache/commons/lang3/builder/JsonToStringStyleTest.java +++ b/src/test/java/org/apache/commons/lang3/builder/JsonToStringStyleTest.java @@ -305,7 +305,7 @@ public class JsonToStringStyleTest { @Test public void testObjectArray() { - final Object[] array = new Object[]{null, base, new int[]{3, 6}}; + final Object[] array = {null, base, new int[]{3, 6}}; final ToStringBuilder toStringBuilder = new ToStringBuilder(base); assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString()); @@ -325,7 +325,7 @@ public class JsonToStringStyleTest { @Test public void testLongArray() { - final long[] array = new long[]{1, 2, -3, 4}; + final long[] array = {1, 2, -3, 4}; final ToStringBuilder toStringBuilder = new ToStringBuilder(base); assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString()); @@ -345,7 +345,7 @@ public class JsonToStringStyleTest { @Test public void testIntArray() { - final int[] array = new int[]{1, 2, -3, 4}; + final int[] array = {1, 2, -3, 4}; final ToStringBuilder toStringBuilder = new ToStringBuilder(base); assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString()); @@ -365,7 +365,7 @@ public class JsonToStringStyleTest { @Test public void testByteArray() { - final byte[] array = new byte[]{1, 2, -3, 4}; + final byte[] array = {1, 2, -3, 4}; final ToStringBuilder toStringBuilder = new ToStringBuilder(base); assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString()); @@ -385,7 +385,7 @@ public class JsonToStringStyleTest { @Test public void testShortArray() { - final short[] array = new short[]{1, 2, -3, 4}; + final short[] array = {1, 2, -3, 4}; final ToStringBuilder toStringBuilder = new ToStringBuilder(base); assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString()); @@ -405,7 +405,7 @@ public class JsonToStringStyleTest { @Test public void testDoubleArray() { - final double[] array = new double[]{1, 2, -3, 4}; + final double[] array = {1, 2, -3, 4}; final ToStringBuilder toStringBuilder = new ToStringBuilder(base); assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString()); @@ -425,7 +425,7 @@ public class JsonToStringStyleTest { @Test public void testFloatArray() { - final float[] array = new float[]{1, 2, -3, 4}; + final float[] array = {1, 2, -3, 4}; final ToStringBuilder toStringBuilder = new ToStringBuilder(base); assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString()); @@ -445,7 +445,7 @@ public class JsonToStringStyleTest { @Test public void testCharArray() { - final char[] array = new char[]{'1', '2', '3', '4'}; + final char[] array = {'1', '2', '3', '4'}; final ToStringBuilder toStringBuilder = new ToStringBuilder(base); assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString()); @@ -465,7 +465,7 @@ public class JsonToStringStyleTest { @Test public void testBooleanArray() { - final boolean[] array = new boolean[]{true, false}; + final boolean[] array = {true, false}; final ToStringBuilder toStringBuilder = new ToStringBuilder(base); assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString()); @@ -485,7 +485,7 @@ public class JsonToStringStyleTest { @Test public void testLongArrayArray() { - final long[][] array = new long[][]{{1, 2}, null, {5}}; + final long[][] array = {{1, 2}, null, {5}}; final ToStringBuilder toStringBuilder = new ToStringBuilder(base); assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString()); diff --git a/src/test/java/org/apache/commons/lang3/builder/MultiLineToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/MultiLineToStringStyleTest.java index 41f2794fe..54043f398 100644 --- a/src/test/java/org/apache/commons/lang3/builder/MultiLineToStringStyleTest.java +++ b/src/test/java/org/apache/commons/lang3/builder/MultiLineToStringStyleTest.java @@ -124,7 +124,7 @@ public class MultiLineToStringStyleTest { @Test public void testObjectArray() { - Object[] array = new Object[] {null, base, new int[] {3, 6}}; + Object[] array = {null, base, new int[] {3, 6}}; assertEquals(baseStr + "[" + System.lineSeparator() + " {<null>,5,{3,6}}" + System.lineSeparator() + "]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[" + System.lineSeparator() + " {<null>,5,{3,6}}" + System.lineSeparator() + "]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -134,7 +134,7 @@ public class MultiLineToStringStyleTest { @Test public void testLongArray() { - long[] array = new long[] {1, 2, -3, 4}; + long[] array = {1, 2, -3, 4}; assertEquals(baseStr + "[" + System.lineSeparator() + " {1,2,-3,4}" + System.lineSeparator() + "]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[" + System.lineSeparator() + " {1,2,-3,4}" + System.lineSeparator() + "]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -144,7 +144,7 @@ public class MultiLineToStringStyleTest { @Test public void testLongArrayArray() { - long[][] array = new long[][] {{1, 2}, null, {5}}; + long[][] array = {{1, 2}, null, {5}}; assertEquals(baseStr + "[" + System.lineSeparator() + " {{1,2},<null>,{5}}" + System.lineSeparator() + "]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[" + System.lineSeparator() + " {{1,2},<null>,{5}}" + System.lineSeparator() + "]", new ToStringBuilder(base).append((Object) array).toString()); array = null; diff --git a/src/test/java/org/apache/commons/lang3/builder/NoClassNameToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/NoClassNameToStringStyleTest.java index b5c2d9275..25410f085 100644 --- a/src/test/java/org/apache/commons/lang3/builder/NoClassNameToStringStyleTest.java +++ b/src/test/java/org/apache/commons/lang3/builder/NoClassNameToStringStyleTest.java @@ -122,7 +122,7 @@ public class NoClassNameToStringStyleTest { @Test public void testObjectArray() { - Object[] array = new Object[] {null, base, new int[] {3, 6}}; + Object[] array = {null, base, new int[] {3, 6}}; assertEquals("[{<null>,5,{3,6}}]", new ToStringBuilder(base).append(array).toString()); assertEquals("[{<null>,5,{3,6}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -132,7 +132,7 @@ public class NoClassNameToStringStyleTest { @Test public void testLongArray() { - long[] array = new long[] {1, 2, -3, 4}; + long[] array = {1, 2, -3, 4}; assertEquals("[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString()); assertEquals("[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -142,7 +142,7 @@ public class NoClassNameToStringStyleTest { @Test public void testLongArrayArray() { - long[][] array = new long[][] {{1, 2}, null, {5}}; + long[][] array = {{1, 2}, null, {5}}; assertEquals("[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString()); assertEquals("[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; diff --git a/src/test/java/org/apache/commons/lang3/builder/NoFieldNamesToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/NoFieldNamesToStringStyleTest.java index 04ac8e67d..e9058a1b8 100644 --- a/src/test/java/org/apache/commons/lang3/builder/NoFieldNamesToStringStyleTest.java +++ b/src/test/java/org/apache/commons/lang3/builder/NoFieldNamesToStringStyleTest.java @@ -124,7 +124,7 @@ public class NoFieldNamesToStringStyleTest { @Test public void testObjectArray() { - Object[] array = new Object[] {null, base, new int[] {3, 6}}; + Object[] array = {null, base, new int[] {3, 6}}; assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -134,7 +134,7 @@ public class NoFieldNamesToStringStyleTest { @Test public void testLongArray() { - long[] array = new long[] {1, 2, -3, 4}; + long[] array = {1, 2, -3, 4}; assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -144,7 +144,7 @@ public class NoFieldNamesToStringStyleTest { @Test public void testLongArrayArray() { - long[][] array = new long[][] {{1, 2}, null, {5}}; + long[][] array = {{1, 2}, null, {5}}; assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; diff --git a/src/test/java/org/apache/commons/lang3/builder/RecursiveToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/RecursiveToStringStyleTest.java index 5a438ddd3..96cf4f367 100644 --- a/src/test/java/org/apache/commons/lang3/builder/RecursiveToStringStyleTest.java +++ b/src/test/java/org/apache/commons/lang3/builder/RecursiveToStringStyleTest.java @@ -104,7 +104,7 @@ public class RecursiveToStringStyleTest { @Test public void testObjectArray() { - Object[] array = new Object[] {null, base, new int[] {3, 6}}; + Object[] array = {null, base, new int[] {3, 6}}; assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -114,7 +114,7 @@ public class RecursiveToStringStyleTest { @Test public void testLongArray() { - long[] array = new long[] {1, 2, -3, 4}; + long[] array = {1, 2, -3, 4}; assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -124,7 +124,7 @@ public class RecursiveToStringStyleTest { @Test public void testLongArrayArray() { - long[][] array = new long[][] {{1, 2}, null, {5}}; + long[][] array = {{1, 2}, null, {5}}; assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; diff --git a/src/test/java/org/apache/commons/lang3/builder/ShortPrefixToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/ShortPrefixToStringStyleTest.java index 4d60dc4a3..fb7a82dba 100644 --- a/src/test/java/org/apache/commons/lang3/builder/ShortPrefixToStringStyleTest.java +++ b/src/test/java/org/apache/commons/lang3/builder/ShortPrefixToStringStyleTest.java @@ -124,7 +124,7 @@ public class ShortPrefixToStringStyleTest { @Test public void testObjectArray() { - Object[] array = new Object[] {null, base, new int[] {3, 6}}; + Object[] array = {null, base, new int[] {3, 6}}; assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -134,7 +134,7 @@ public class ShortPrefixToStringStyleTest { @Test public void testLongArray() { - long[] array = new long[] {1, 2, -3, 4}; + long[] array = {1, 2, -3, 4}; assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -144,7 +144,7 @@ public class ShortPrefixToStringStyleTest { @Test public void testLongArrayArray() { - long[][] array = new long[][] {{1, 2}, null, {5}}; + long[][] array = {{1, 2}, null, {5}}; assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; diff --git a/src/test/java/org/apache/commons/lang3/builder/SimpleToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/SimpleToStringStyleTest.java index edc8ed9ac..08f912f59 100644 --- a/src/test/java/org/apache/commons/lang3/builder/SimpleToStringStyleTest.java +++ b/src/test/java/org/apache/commons/lang3/builder/SimpleToStringStyleTest.java @@ -122,7 +122,7 @@ public class SimpleToStringStyleTest { @Test public void testObjectArray() { - Object[] array = new Object[] {null, base, new int[] {3, 6}}; + Object[] array = {null, base, new int[] {3, 6}}; assertEquals("{<null>,5,{3,6}}", new ToStringBuilder(base).append(array).toString()); assertEquals("{<null>,5,{3,6}}", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -132,7 +132,7 @@ public class SimpleToStringStyleTest { @Test public void testLongArray() { - long[] array = new long[] {1, 2, -3, 4}; + long[] array = {1, 2, -3, 4}; assertEquals("{1,2,-3,4}", new ToStringBuilder(base).append(array).toString()); assertEquals("{1,2,-3,4}", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -142,7 +142,7 @@ public class SimpleToStringStyleTest { @Test public void testLongArrayArray() { - long[][] array = new long[][] {{1, 2}, null, {5}}; + long[][] array = {{1, 2}, null, {5}}; assertEquals("{{1,2},<null>,{5}}", new ToStringBuilder(base).append(array).toString()); assertEquals("{{1,2},<null>,{5}}", new ToStringBuilder(base).append((Object) array).toString()); array = null; diff --git a/src/test/java/org/apache/commons/lang3/builder/StandardToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/StandardToStringStyleTest.java index cdca05ee6..935fa9bde 100644 --- a/src/test/java/org/apache/commons/lang3/builder/StandardToStringStyleTest.java +++ b/src/test/java/org/apache/commons/lang3/builder/StandardToStringStyleTest.java @@ -141,7 +141,7 @@ public class StandardToStringStyleTest { @Test public void testObjectArray() { - Object[] array = new Object[] {null, base, new int[] {3, 6}}; + Object[] array = {null, base, new int[] {3, 6}}; assertEquals(baseStr + "[[%NULL%, 5, [3, 6]]]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[[%NULL%, 5, [3, 6]]]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -151,7 +151,7 @@ public class StandardToStringStyleTest { @Test public void testLongArray() { - long[] array = new long[] {1, 2, -3, 4}; + long[] array = {1, 2, -3, 4}; assertEquals(baseStr + "[[1, 2, -3, 4]]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[[1, 2, -3, 4]]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -161,7 +161,7 @@ public class StandardToStringStyleTest { @Test public void testLongArrayArray() { - long[][] array = new long[][] {{1, 2}, null, {5}}; + long[][] array = {{1, 2}, null, {5}}; assertEquals(baseStr + "[[[1, 2], %NULL%, [5]]]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[[[1, 2], %NULL%, [5]]]", new ToStringBuilder(base).append((Object) array).toString()); array = null; diff --git a/src/test/java/org/apache/commons/lang3/builder/ToStringBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/ToStringBuilderTest.java index e277f28a8..372c26969 100644 --- a/src/test/java/org/apache/commons/lang3/builder/ToStringBuilderTest.java +++ b/src/test/java/org/apache/commons/lang3/builder/ToStringBuilderTest.java @@ -155,7 +155,7 @@ public class ToStringBuilderTest { @Test public void testReflectionObjectArray() { - Object[] array = new Object[] { null, base, new int[] { 3, 6 } }; + Object[] array = { null, base, new int[] { 3, 6 } }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{<null>,5,{3,6}}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -164,7 +164,7 @@ public class ToStringBuilderTest { @Test public void testReflectionLongArray() { - long[] array = new long[] { 1, 2, -3, 4 }; + long[] array = { 1, 2, -3, 4 }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -173,7 +173,7 @@ public class ToStringBuilderTest { @Test public void testReflectionIntArray() { - int[] array = new int[] { 1, 2, -3, 4 }; + int[] array = { 1, 2, -3, 4 }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -182,7 +182,7 @@ public class ToStringBuilderTest { @Test public void testReflectionShortArray() { - short[] array = new short[] { 1, 2, -3, 4 }; + short[] array = { 1, 2, -3, 4 }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -191,7 +191,7 @@ public class ToStringBuilderTest { @Test public void testReflectionyteArray() { - byte[] array = new byte[] { 1, 2, -3, 4 }; + byte[] array = { 1, 2, -3, 4 }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -200,7 +200,7 @@ public class ToStringBuilderTest { @Test public void testReflectionCharArray() { - char[] array = new char[] { 'A', '2', '_', 'D' }; + char[] array = { 'A', '2', '_', 'D' }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{A,2,_,D}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -209,7 +209,7 @@ public class ToStringBuilderTest { @Test public void testReflectionDoubleArray() { - double[] array = new double[] { 1.0, 2.9876, -3.00001, 4.3 }; + double[] array = { 1.0, 2.9876, -3.00001, 4.3 }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{1.0,2.9876,-3.00001,4.3}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -218,7 +218,7 @@ public class ToStringBuilderTest { @Test public void testReflectionFloatArray() { - float[] array = new float[] { 1.0f, 2.9876f, -3.00001f, 4.3f }; + float[] array = { 1.0f, 2.9876f, -3.00001f, 4.3f }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{1.0,2.9876,-3.00001,4.3}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -227,7 +227,7 @@ public class ToStringBuilderTest { @Test public void testReflectionBooleanArray() { - boolean[] array = new boolean[] { true, false, false }; + boolean[] array = { true, false, false }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{true,false,false}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -238,7 +238,7 @@ public class ToStringBuilderTest { @Test public void testReflectionFloatArrayArray() { - float[][] array = new float[][] { { 1.0f, 2.29686f }, null, { Float.NaN } }; + float[][] array = { { 1.0f, 2.29686f }, null, { Float.NaN } }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{{1.0,2.29686},<null>,{NaN}}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -248,7 +248,7 @@ public class ToStringBuilderTest { @Test public void testReflectionLongArrayArray() { - long[][] array = new long[][] { { 1, 2 }, null, { 5 } }; + long[][] array = { { 1, 2 }, null, { 5 } }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{{1,2},<null>,{5}}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -257,7 +257,7 @@ public class ToStringBuilderTest { @Test public void testReflectionIntArrayArray() { - int[][] array = new int[][] { { 1, 2 }, null, { 5 } }; + int[][] array = { { 1, 2 }, null, { 5 } }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{{1,2},<null>,{5}}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -266,7 +266,7 @@ public class ToStringBuilderTest { @Test public void testReflectionhortArrayArray() { - short[][] array = new short[][] { { 1, 2 }, null, { 5 } }; + short[][] array = { { 1, 2 }, null, { 5 } }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{{1,2},<null>,{5}}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -275,7 +275,7 @@ public class ToStringBuilderTest { @Test public void testReflectionByteArrayArray() { - byte[][] array = new byte[][] { { 1, 2 }, null, { 5 } }; + byte[][] array = { { 1, 2 }, null, { 5 } }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{{1,2},<null>,{5}}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -284,7 +284,7 @@ public class ToStringBuilderTest { @Test public void testReflectionCharArrayArray() { - char[][] array = new char[][] { { 'A', 'B' }, null, { 'p' } }; + char[][] array = { { 'A', 'B' }, null, { 'p' } }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{{A,B},<null>,{p}}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -293,7 +293,7 @@ public class ToStringBuilderTest { @Test public void testReflectionDoubleArrayArray() { - double[][] array = new double[][] { { 1.0, 2.29686 }, null, { Double.NaN } }; + double[][] array = { { 1.0, 2.29686 }, null, { Double.NaN } }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{{1.0,2.29686},<null>,{NaN}}]", ToStringBuilder.reflectionToString(array)); array = null; @@ -302,7 +302,7 @@ public class ToStringBuilderTest { @Test public void testReflectionBooleanArrayArray() { - boolean[][] array = new boolean[][] { { true, false }, null, { false } }; + boolean[][] array = { { true, false }, null, { false } }; final String baseString = this.toBaseString(array); assertEquals(baseString + "[{{true,false},<null>,{false}}]", ToStringBuilder.reflectionToString(array)); assertEquals(baseString + "[{{true,false},<null>,{false}}]", ToStringBuilder.reflectionToString(array)); @@ -629,7 +629,7 @@ public class ToStringBuilderTest { @Test public void testAppendBooleanArrayWithFieldName() { - final boolean[] array = new boolean[] { true, false, false }; + final boolean[] array = { true, false, false }; assertEquals(baseStr + "[flags={true,false,false}]", new ToStringBuilder(base).append("flags", array).toString()); assertEquals(baseStr + "[flags=<null>]", @@ -640,7 +640,7 @@ public class ToStringBuilderTest { @Test public void testAppendBooleanArrayWithFieldNameAndFullDetatil() { - final boolean[] array = new boolean[] { true, false, false }; + final boolean[] array = { true, false, false }; assertEquals(baseStr + "[flags={true,false,false}]", new ToStringBuilder(base).append("flags", array, true).toString()); assertEquals(baseStr + "[length=<size=3>]", @@ -653,7 +653,7 @@ public class ToStringBuilderTest { @Test public void testAppendCharArrayWithFieldName() { - final char[] array = new char[] { 'A', '2', '_', 'D' }; + final char[] array = { 'A', '2', '_', 'D' }; assertEquals(baseStr + "[chars={A,2,_,D}]", new ToStringBuilder(base).append("chars", array).toString()); assertEquals(baseStr + "[letters={A,2,_,D}]", new ToStringBuilder(base).append("letters", array).toString()); assertEquals(baseStr + "[flags=<null>]", @@ -664,7 +664,7 @@ public class ToStringBuilderTest { @Test public void testAppendCharArrayWithFieldNameAndFullDetatil() { - final char[] array = new char[] { 'A', '2', '_', 'D' }; + final char[] array = { 'A', '2', '_', 'D' }; assertEquals(baseStr + "[chars={A,2,_,D}]", new ToStringBuilder(base).append("chars", array, true).toString()); assertEquals(baseStr + "[letters=<size=4>]", new ToStringBuilder(base).append("letters", array, false).toString()); @@ -676,7 +676,7 @@ public class ToStringBuilderTest { @Test public void testAppendDoubleArrayWithFieldName() { - final double[] array = new double[] { 1.0, 2.9876, -3.00001, 4.3 }; + final double[] array = { 1.0, 2.9876, -3.00001, 4.3 }; assertEquals(baseStr + "[values={1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append("values", array).toString()); assertEquals(baseStr + "[values=<null>]", @@ -687,7 +687,7 @@ public class ToStringBuilderTest { @Test public void testAppendDoubleArrayWithFieldNameAndFullDetatil() { - final double[] array = new double[] { 1.0, 2.9876, -3.00001, 4.3 }; + final double[] array = { 1.0, 2.9876, -3.00001, 4.3 }; assertEquals(baseStr + "[values={1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append("values", array, true).toString()); assertEquals(baseStr + "[length=<size=4>]", @@ -700,7 +700,7 @@ public class ToStringBuilderTest { @Test public void testAppendObjectArrayWithFieldName() { - final Object[] array = new Object[] { null, base, new int[] { 3, 6 } }; + final Object[] array = { null, base, new int[] { 3, 6 } }; assertEquals(baseStr + "[values={<null>,5,{3,6}}]", new ToStringBuilder(base).append("values", array).toString()); assertEquals(baseStr + "[values=<null>]", @@ -711,7 +711,7 @@ public class ToStringBuilderTest { @Test public void testAppendObjectArrayWithFieldNameAndFullDetatil() { - final Object[] array = new Object[] { null, base, new int[] { 3, 6 } }; + final Object[] array = { null, base, new int[] { 3, 6 } }; assertEquals(baseStr + "[values={<null>,5,{3,6}}]", new ToStringBuilder(base).append("values", array, true).toString()); assertEquals(baseStr + "[length=<size=3>]", @@ -724,7 +724,7 @@ public class ToStringBuilderTest { @Test public void testAppendLongArrayWithFieldName() { - final long[] array = new long[] { 1, 2, -3, 4 }; + final long[] array = { 1, 2, -3, 4 }; assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array).toString()); assertEquals(baseStr + "[values=<null>]", new ToStringBuilder(base).append("values", (boolean[]) null).toString()); @@ -734,7 +734,7 @@ public class ToStringBuilderTest { @Test public void testAppendLongArrayWithFieldNameAndFullDetatil() { - final long[] array = new long[] { 1, 2, -3, 4 }; + final long[] array = { 1, 2, -3, 4 }; assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array, true).toString()); assertEquals(baseStr + "[length=<size=4>]", @@ -747,7 +747,7 @@ public class ToStringBuilderTest { @Test public void testAppendIntArrayWithFieldName() { - final int[] array = new int[] { 1, 2, -3, 4 }; + final int[] array = { 1, 2, -3, 4 }; assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array).toString()); assertEquals(baseStr + "[values=<null>]", new ToStringBuilder(base).append("values", (boolean[]) null).toString()); @@ -757,7 +757,7 @@ public class ToStringBuilderTest { @Test public void testAppendIntArrayWithFieldNameAndFullDetatil() { - final int[] array = new int[] { 1, 2, -3, 4 }; + final int[] array = { 1, 2, -3, 4 }; assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array, true).toString()); assertEquals(baseStr + "[length=<size=4>]", @@ -770,7 +770,7 @@ public class ToStringBuilderTest { @Test public void testAppendShortArrayWithFieldName() { - final short[] array = new short[] { 1, 2, -3, 4 }; + final short[] array = { 1, 2, -3, 4 }; assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array).toString()); assertEquals(baseStr + "[values=<null>]", new ToStringBuilder(base).append("values", (boolean[]) null).toString()); @@ -780,7 +780,7 @@ public class ToStringBuilderTest { @Test public void testAppendShortArrayWithFieldNameAndFullDetatil() { - final short[] array = new short[] { 1, 2, -3, 4 }; + final short[] array = { 1, 2, -3, 4 }; assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array, true).toString()); assertEquals(baseStr + "[length=<size=4>]", @@ -793,7 +793,7 @@ public class ToStringBuilderTest { @Test public void testAppendByteArrayWithFieldName() { - final byte[] array = new byte[] { 1, 2, -3, 4 }; + final byte[] array = { 1, 2, -3, 4 }; assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array).toString()); assertEquals(baseStr + "[values=<null>]", new ToStringBuilder(base).append("values", (boolean[]) null).toString()); @@ -803,7 +803,7 @@ public class ToStringBuilderTest { @Test public void testAppendByteArrayWithFieldNameAndFullDetatil() { - final byte[] array = new byte[] { 1, 2, -3, 4 }; + final byte[] array = { 1, 2, -3, 4 }; assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array, true).toString()); assertEquals(baseStr + "[length=<size=4>]", @@ -816,7 +816,7 @@ public class ToStringBuilderTest { @Test public void testAppendFloatArrayWithFieldName() { - final float[] array = new float[] { 1.0f, 2.9876f, -3.00001f, 4.3f }; + final float[] array = { 1.0f, 2.9876f, -3.00001f, 4.3f }; assertEquals(baseStr + "[values={1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append("values", array).toString()); assertEquals(baseStr + "[values=<null>]", @@ -827,7 +827,7 @@ public class ToStringBuilderTest { @Test public void testAppendFloatArrayWithFieldNameAndFullDetatil() { - final float[] array = new float[] { 1.0f, 2.9876f, -3.00001f, 4.3f }; + final float[] array = { 1.0f, 2.9876f, -3.00001f, 4.3f }; assertEquals(baseStr + "[values={1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append("values", array, true).toString()); assertEquals(baseStr + "[length=<size=4>]", @@ -946,7 +946,7 @@ public class ToStringBuilderTest { @Test public void testObjectArray() { - Object[] array = new Object[] {null, base, new int[] {3, 6}}; + Object[] array = {null, base, new int[] {3, 6}}; assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -956,7 +956,7 @@ public class ToStringBuilderTest { @Test public void testLongArray() { - long[] array = new long[] {1, 2, -3, 4}; + long[] array = {1, 2, -3, 4}; assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -966,7 +966,7 @@ public class ToStringBuilderTest { @Test public void testIntArray() { - int[] array = new int[] {1, 2, -3, 4}; + int[] array = {1, 2, -3, 4}; assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -976,7 +976,7 @@ public class ToStringBuilderTest { @Test public void testShortArray() { - short[] array = new short[] {1, 2, -3, 4}; + short[] array = {1, 2, -3, 4}; assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -986,7 +986,7 @@ public class ToStringBuilderTest { @Test public void testByteArray() { - byte[] array = new byte[] {1, 2, -3, 4}; + byte[] array = {1, 2, -3, 4}; assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -996,7 +996,7 @@ public class ToStringBuilderTest { @Test public void testCharArray() { - char[] array = new char[] {'A', '2', '_', 'D'}; + char[] array = {'A', '2', '_', 'D'}; assertEquals(baseStr + "[{A,2,_,D}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{A,2,_,D}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -1006,7 +1006,7 @@ public class ToStringBuilderTest { @Test public void testDoubleArray() { - double[] array = new double[] {1.0, 2.9876, -3.00001, 4.3}; + double[] array = {1.0, 2.9876, -3.00001, 4.3}; assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -1016,7 +1016,7 @@ public class ToStringBuilderTest { @Test public void testFloatArray() { - float[] array = new float[] {1.0f, 2.9876f, -3.00001f, 4.3f}; + float[] array = {1.0f, 2.9876f, -3.00001f, 4.3f}; assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -1026,7 +1026,7 @@ public class ToStringBuilderTest { @Test public void testBooleanArray() { - boolean[] array = new boolean[] {true, false, false}; + boolean[] array = {true, false, false}; assertEquals(baseStr + "[{true,false,false}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{true,false,false}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -1036,7 +1036,7 @@ public class ToStringBuilderTest { @Test public void testLongArrayArray() { - long[][] array = new long[][] {{1, 2}, null, {5}}; + long[][] array = {{1, 2}, null, {5}}; assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -1046,7 +1046,7 @@ public class ToStringBuilderTest { @Test public void testIntArrayArray() { - int[][] array = new int[][] {{1, 2}, null, {5}}; + int[][] array = {{1, 2}, null, {5}}; assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -1056,7 +1056,7 @@ public class ToStringBuilderTest { @Test public void testShortArrayArray() { - short[][] array = new short[][] {{1, 2}, null, {5}}; + short[][] array = {{1, 2}, null, {5}}; assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -1066,7 +1066,7 @@ public class ToStringBuilderTest { @Test public void testByteArrayArray() { - byte[][] array = new byte[][] {{1, 2}, null, {5}}; + byte[][] array = {{1, 2}, null, {5}}; assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -1076,7 +1076,7 @@ public class ToStringBuilderTest { @Test public void testCharArrayArray() { - char[][] array = new char[][] {{'A', 'B'}, null, {'p'}}; + char[][] array = {{'A', 'B'}, null, {'p'}}; assertEquals(baseStr + "[{{A,B},<null>,{p}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{{A,B},<null>,{p}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -1086,7 +1086,7 @@ public class ToStringBuilderTest { @Test public void testDoubleArrayArray() { - double[][] array = new double[][] {{1.0, 2.29686}, null, {Double.NaN}}; + double[][] array = {{1.0, 2.29686}, null, {Double.NaN}}; assertEquals(baseStr + "[{{1.0,2.29686},<null>,{NaN}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{{1.0,2.29686},<null>,{NaN}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -1096,7 +1096,7 @@ public class ToStringBuilderTest { @Test public void testFloatArrayArray() { - float[][] array = new float[][] {{1.0f, 2.29686f}, null, {Float.NaN}}; + float[][] array = {{1.0f, 2.29686f}, null, {Float.NaN}}; assertEquals(baseStr + "[{{1.0,2.29686},<null>,{NaN}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{{1.0,2.29686},<null>,{NaN}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; @@ -1106,7 +1106,7 @@ public class ToStringBuilderTest { @Test public void testBooleanArrayArray() { - boolean[][] array = new boolean[][] {{true, false}, null, {false}}; + boolean[][] array = {{true, false}, null, {false}}; assertEquals(baseStr + "[{{true,false},<null>,{false}}]", new ToStringBuilder(base).append(array).toString()); assertEquals(baseStr + "[{{true,false},<null>,{false}}]", new ToStringBuilder(base).append((Object) array).toString()); array = null; diff --git a/src/test/java/org/apache/commons/lang3/math/IEEE754rUtilsTest.java b/src/test/java/org/apache/commons/lang3/math/IEEE754rUtilsTest.java index 2a4374e64..90513dbf9 100644 --- a/src/test/java/org/apache/commons/lang3/math/IEEE754rUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/math/IEEE754rUtilsTest.java @@ -84,19 +84,19 @@ public class IEEE754rUtilsTest { assertEquals(2.5f, IEEE754rUtils.max(1.2f, 2.5f, Float.NaN), 0.01); assertTrue(Float.isNaN(IEEE754rUtils.max(Float.NaN, Float.NaN, Float.NaN))); - final double[] a = new double[] { 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN }; + final double[] a = { 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN }; assertEquals(42.0, IEEE754rUtils.max(a), 0.01); assertEquals(1.2, IEEE754rUtils.min(a), 0.01); - final double[] b = new double[] { Double.NaN, 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN }; + final double[] b = { Double.NaN, 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN }; assertEquals(42.0, IEEE754rUtils.max(b), 0.01); assertEquals(1.2, IEEE754rUtils.min(b), 0.01); - final float[] aF = new float[] { 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN }; + final float[] aF = { 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN }; assertEquals(1.2f, IEEE754rUtils.min(aF), 0.01); assertEquals(42.0f, IEEE754rUtils.max(aF), 0.01); - final float[] bF = new float[] { Float.NaN, 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN }; + final float[] bF = { Float.NaN, 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN }; assertEquals(1.2f, IEEE754rUtils.min(bF), 0.01); assertEquals(42.0f, IEEE754rUtils.max(bF), 0.01); } diff --git a/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java b/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java index d7d49b561..80d1dac82 100644 --- a/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java @@ -967,18 +967,18 @@ public class NumberUtilsTest { assertTrue(Float.isNaN(NumberUtils.min(1.2f, 2.5f, Float.NaN))); assertTrue(Float.isNaN(NumberUtils.max(1.2f, 2.5f, Float.NaN))); - final double[] a = new double[] {1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN}; + final double[] a = {1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN}; assertTrue(Double.isNaN(NumberUtils.max(a))); assertTrue(Double.isNaN(NumberUtils.min(a))); - final double[] b = new double[] {Double.NaN, 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN}; + final double[] b = {Double.NaN, 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN}; assertTrue(Double.isNaN(NumberUtils.max(b))); assertTrue(Double.isNaN(NumberUtils.min(b))); - final float[] aF = new float[] {1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN}; + final float[] aF = {1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN}; assertTrue(Float.isNaN(NumberUtils.max(aF))); - final float[] bF = new float[] {Float.NaN, 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN}; + final float[] bF = {Float.NaN, 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN}; assertTrue(Float.isNaN(NumberUtils.max(bF))); } diff --git a/src/test/java/org/apache/commons/lang3/text/ExtendedMessageFormatTest.java b/src/test/java/org/apache/commons/lang3/text/ExtendedMessageFormatTest.java index 2bb1375e7..27a0bdd25 100644 --- a/src/test/java/org/apache/commons/lang3/text/ExtendedMessageFormatTest.java +++ b/src/test/java/org/apache/commons/lang3/text/ExtendedMessageFormatTest.java @@ -110,7 +110,7 @@ public class ExtendedMessageFormatTest { public void testExtendedAndBuiltInFormats() { final Calendar cal = Calendar.getInstance(); cal.set(2007, Calendar.JANUARY, 23, 18, 33, 5); - final Object[] args = new Object[] {"John Doe", cal.getTime(), Double.valueOf("12345.67")}; + final Object[] args = {"John Doe", cal.getTime(), Double.valueOf("12345.67")}; final String builtinsPattern = "DOB: {1,date,short} Salary: {2,number,currency}"; final String extendedPattern = "Name: {0,upper} "; final String pattern = extendedPattern + builtinsPattern; @@ -228,7 +228,7 @@ public class ExtendedMessageFormatTest { public void testBuiltInDateTimeFormat() { final Calendar cal = Calendar.getInstance(); cal.set(2007, Calendar.JANUARY, 23, 18, 33, 5); - final Object[] args = new Object[] {cal.getTime()}; + final Object[] args = {cal.getTime()}; final Locale[] availableLocales = DateFormat.getAvailableLocales(); checkBuiltInFormat("1: {0,date,short}", args, availableLocales); @@ -249,7 +249,7 @@ public class ExtendedMessageFormatTest { public void testOverriddenBuiltinFormat() { final Calendar cal = Calendar.getInstance(); cal.set(2007, Calendar.JANUARY, 23); - final Object[] args = new Object[] {cal.getTime()}; + final Object[] args = {cal.getTime()}; final Locale[] availableLocales = DateFormat.getAvailableLocales(); final Map<String, ? extends FormatFactory> dateRegistry = Collections.singletonMap("date", new OverrideShortDateFormatFactory()); @@ -276,7 +276,7 @@ public class ExtendedMessageFormatTest { */ @Test public void testBuiltInNumberFormat() { - final Object[] args = new Object[] {Double.valueOf("6543.21")}; + final Object[] args = {Double.valueOf("6543.21")}; final Locale[] availableLocales = NumberFormat.getAvailableLocales(); checkBuiltInFormat("1: {0,number}", args, availableLocales); checkBuiltInFormat("2: {0,number,integer}", args, availableLocales); diff --git a/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java b/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java index 4ca0dac8e..08ffb0125 100644 --- a/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java +++ b/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java @@ -59,7 +59,7 @@ public class StrTokenizerTest { tok.setIgnoreEmptyTokens(false); final String[] tokens = tok.getTokenArray(); - final String[] expected = new String[]{"a", "b", "c", "d;\"e", "f", "", "", ""}; + final String[] expected = {"a", "b", "c", "d;\"e", "f", "", "", ""}; assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens)); for (int i = 0; i < expected.length; i++) { @@ -80,7 +80,7 @@ public class StrTokenizerTest { tok.setIgnoreEmptyTokens(false); final String[] tokens = tok.getTokenArray(); - final String[] expected = new String[]{"a", "b", "c ", "d;\"e", "f", " ", " ", ""}; + final String[] expected = {"a", "b", "c ", "d;\"e", "f", " ", " ", ""}; assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens)); for (int i = 0; i < expected.length; i++) { @@ -101,7 +101,7 @@ public class StrTokenizerTest { tok.setIgnoreEmptyTokens(false); final String[] tokens = tok.getTokenArray(); - final String[] expected = new String[]{"a", "b", " c", "d;\"e", "f", " ", " ", ""}; + final String[] expected = {"a", "b", " c", "d;\"e", "f", " ", " ", ""}; assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens)); for (int i = 0; i < expected.length; i++) { @@ -122,7 +122,7 @@ public class StrTokenizerTest { tok.setIgnoreEmptyTokens(true); final String[] tokens = tok.getTokenArray(); - final String[] expected = new String[]{"a", "b", "c", "d;\"e", "f"}; + final String[] expected = {"a", "b", "c", "d;\"e", "f"}; assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens)); for (int i = 0; i < expected.length; i++) { @@ -144,7 +144,7 @@ public class StrTokenizerTest { tok.setEmptyTokenAsNull(true); final String[] tokens = tok.getTokenArray(); - final String[] expected = new String[]{"a", "b", "c", "d;\"e", "f", null, null, null}; + final String[] expected = {"a", "b", "c", "d;\"e", "f", null, null, null}; assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens)); for (int i = 0; i < expected.length; i++) { @@ -166,7 +166,7 @@ public class StrTokenizerTest { // tok.setTreatingEmptyAsNull(true); final String[] tokens = tok.getTokenArray(); - final String[] expected = new String[]{"a", "b", " c", "d;\"e", "f", null, null, null}; + final String[] expected = {"a", "b", " c", "d;\"e", "f", null, null, null}; int nextCount = 0; while (tok.hasNext()) { @@ -199,7 +199,7 @@ public class StrTokenizerTest { tok.setIgnoreEmptyTokens(false); final String[] tokens = tok.getTokenArray(); - final String[] expected = new String[]{"a", "", "", "b", "c", "d e", "f", ""}; + final String[] expected = {"a", "", "", "b", "c", "d e", "f", ""}; assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens)); for (int i = 0; i < expected.length; i++) { @@ -220,7 +220,7 @@ public class StrTokenizerTest { tok.setIgnoreEmptyTokens(true); final String[] tokens = tok.getTokenArray(); - final String[] expected = new String[]{"a", "b", "c", "d e", "f"}; + final String[] expected = {"a", "b", "c", "d e", "f"}; assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens)); for (int i = 0; i < expected.length; i++) { @@ -605,7 +605,7 @@ public class StrTokenizerTest { @Test public void testCloneReset() { - final char[] input = new char[]{'a'}; + final char[] input = {'a'}; final StrTokenizer tokenizer = new StrTokenizer(input); // Start sanity check assertEquals("a", tokenizer.nextToken()); @@ -749,7 +749,7 @@ public class StrTokenizerTest { public void testReset_charArray() { final StrTokenizer tok = new StrTokenizer("x x x"); - final char[] array = new char[] {'a', 'b', 'c'}; + final char[] array = {'a', 'b', 'c'}; tok.reset(array); assertEquals("abc", tok.next()); assertFalse(tok.hasNext()); diff --git a/src/test/java/org/apache/commons/lang3/text/WordUtilsTest.java b/src/test/java/org/apache/commons/lang3/text/WordUtilsTest.java index ee0c99e9b..6fe861579 100644 --- a/src/test/java/org/apache/commons/lang3/text/WordUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/text/WordUtilsTest.java @@ -203,7 +203,7 @@ public class WordUtilsTest { assertEquals("", WordUtils.capitalize("")); assertEquals(" ", WordUtils.capitalize(" ")); - char[] chars = new char[] { '-', '+', ' ', '@' }; + char[] chars = { '-', '+', ' ', '@' }; assertEquals("I", WordUtils.capitalize("I", chars) ); assertEquals("I", WordUtils.capitalize("i", chars) ); assertEquals("I-Am Here+123", WordUtils.capitalize("i-am here+123", chars) ); @@ -235,7 +235,7 @@ public class WordUtilsTest { assertEquals("", WordUtils.capitalizeFully("")); assertEquals(" ", WordUtils.capitalizeFully(" ")); - char[] chars = new char[] { '-', '+', ' ', '@' }; + char[] chars = { '-', '+', ' ', '@' }; assertEquals("I", WordUtils.capitalizeFully("I", chars) ); assertEquals("I", WordUtils.capitalizeFully("i", chars) ); assertEquals("I-Am Here+123", WordUtils.capitalizeFully("i-am here+123", chars) ); @@ -287,7 +287,7 @@ public class WordUtilsTest { assertEquals("", WordUtils.uncapitalize("")); assertEquals(" ", WordUtils.uncapitalize(" ")); - char[] chars = new char[] { '-', '+', ' ', '@' }; + char[] chars = { '-', '+', ' ', '@' }; assertEquals("i", WordUtils.uncapitalize("I", chars) ); assertEquals("i", WordUtils.uncapitalize("i", chars) ); assertEquals("i am-here+123", WordUtils.uncapitalize("i am-here+123", chars) ); diff --git a/src/test/java/org/apache/commons/lang3/time/DateUtilsTest.java b/src/test/java/org/apache/commons/lang3/time/DateUtilsTest.java index dd6025dce..311956165 100644 --- a/src/test/java/org/apache/commons/lang3/time/DateUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/time/DateUtilsTest.java @@ -872,7 +872,7 @@ public class DateUtilsTest { public void testParseDate() throws Exception { final GregorianCalendar cal = new GregorianCalendar(1972, 11, 3); String dateStr = "1972-12-03"; - final String[] parsers = new String[] {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"}; + final String[] parsers = {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"}; Date date = DateUtils.parseDate(dateStr, parsers); assertEquals(cal.getTime(), date); @@ -887,19 +887,19 @@ public class DateUtilsTest { @Test public void testParseDate_InvalidDateString() { - final String[] parsers = new String[] {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"}; + final String[] parsers = {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"}; assertThrows(ParseException.class, () -> DateUtils.parseDate("197212AB", parsers)); } @Test public void testParseDate_NoDateString() { - final String[] parsers = new String[] {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"}; + final String[] parsers = {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"}; assertThrows(ParseException.class, () -> DateUtils.parseDate("PURPLE", parsers)); } @Test public void testParseDate_Null() { - final String[] parsers = new String[] {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"}; + final String[] parsers = {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"}; assertThrows(IllegalArgumentException.class, () -> DateUtils.parseDate(null, parsers)); } @@ -908,7 +908,7 @@ public class DateUtilsTest { public void testParseDateWithLeniency() throws Exception { final GregorianCalendar cal = new GregorianCalendar(1998, 6, 30); final String dateStr = "02 942, 1996"; - final String[] parsers = new String[] {"MM DDD, yyyy"}; + final String[] parsers = {"MM DDD, yyyy"}; final Date date = DateUtils.parseDate(dateStr, parsers); assertEquals(cal.getTime(), date); diff --git a/src/test/java/org/apache/commons/lang3/time/DurationFormatUtilsTest.java b/src/test/java/org/apache/commons/lang3/time/DurationFormatUtilsTest.java index f29ba6388..4631ffa34 100644 --- a/src/test/java/org/apache/commons/lang3/time/DurationFormatUtilsTest.java +++ b/src/test/java/org/apache/commons/lang3/time/DurationFormatUtilsTest.java @@ -64,8 +64,8 @@ public class DurationFormatUtilsTest { final String msg = year + "-" + month + "-" + day + " to "; final Calendar c = Calendar.getInstance(); c.set(year, month, day, 0, 0, 0); - final int[] array1 = new int[] { year, month, day, 0, 0, 0 }; - final int[] array2 = new int[] { year, month, day, 0, 0, 0 }; + final int[] array1 = { year, month, day, 0, 0, 0 }; + final int[] array2 = { year, month, day, 0, 0, 0 }; for (int i=0; i < FOUR_YEARS; i++) { array2[0] = c.get(Calendar.YEAR); array2[1] = c.get(Calendar.MONTH); |