Create array with curly.
diff --git a/src/main/java/org/apache/commons/lang3/ArrayUtils.java b/src/main/java/org/apache/commons/lang3/ArrayUtils.java
index 9404cff..6d22f8c 100644
--- a/src/main/java/org/apache/commons/lang3/ArrayUtils.java
+++ b/src/main/java/org/apache/commons/lang3/ArrayUtils.java
@@ -52,32 +52,32 @@
/**
* An empty immutable {@code boolean} array.
*/
- public static final boolean[] EMPTY_BOOLEAN_ARRAY = new boolean[0];
+ public static final boolean[] EMPTY_BOOLEAN_ARRAY = {};
/**
* An empty immutable {@code Boolean} array.
*/
- public static final Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY = new Boolean[0];
+ public static final Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY = {};
/**
* An empty immutable {@code byte} array.
*/
- public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
+ public static final byte[] EMPTY_BYTE_ARRAY = {};
/**
* An empty immutable {@code Byte} array.
*/
- public static final Byte[] EMPTY_BYTE_OBJECT_ARRAY = new Byte[0];
+ public static final Byte[] EMPTY_BYTE_OBJECT_ARRAY = {};
/**
* An empty immutable {@code char} array.
*/
- public static final char[] EMPTY_CHAR_ARRAY = new char[0];
+ public static final char[] EMPTY_CHAR_ARRAY = {};
/**
* An empty immutable {@code Character} array.
*/
- public static final Character[] EMPTY_CHARACTER_OBJECT_ARRAY = new Character[0];
+ public static final Character[] EMPTY_CHARACTER_OBJECT_ARRAY = {};
/**
* An empty immutable {@code Class} array.
@@ -87,90 +87,90 @@
/**
* An empty immutable {@code double} array.
*/
- public static final double[] EMPTY_DOUBLE_ARRAY = new double[0];
+ public static final double[] EMPTY_DOUBLE_ARRAY = {};
/**
* An empty immutable {@code Double} array.
*/
- public static final Double[] EMPTY_DOUBLE_OBJECT_ARRAY = new Double[0];
+ public static final Double[] EMPTY_DOUBLE_OBJECT_ARRAY = {};
/**
* An empty immutable {@code Field} array.
*
* @since 3.10
*/
- public static final Field[] EMPTY_FIELD_ARRAY = new Field[0];
+ public static final Field[] EMPTY_FIELD_ARRAY = {};
/**
* An empty immutable {@code float} array.
*/
- public static final float[] EMPTY_FLOAT_ARRAY = new float[0];
+ public static final float[] EMPTY_FLOAT_ARRAY = {};
/**
* An empty immutable {@code Float} array.
*/
- public static final Float[] EMPTY_FLOAT_OBJECT_ARRAY = new Float[0];
+ public static final Float[] EMPTY_FLOAT_OBJECT_ARRAY = {};
/**
* An empty immutable {@code int} array.
*/
- public static final int[] EMPTY_INT_ARRAY = new int[0];
+ public static final int[] EMPTY_INT_ARRAY = {};
/**
* An empty immutable {@code Integer} array.
*/
- public static final Integer[] EMPTY_INTEGER_OBJECT_ARRAY = new Integer[0];
+ public static final Integer[] EMPTY_INTEGER_OBJECT_ARRAY = {};
/**
* An empty immutable {@code long} array.
*/
- public static final long[] EMPTY_LONG_ARRAY = new long[0];
+ public static final long[] EMPTY_LONG_ARRAY = {};
/**
* An empty immutable {@code Long} array.
*/
- public static final Long[] EMPTY_LONG_OBJECT_ARRAY = new Long[0];
+ public static final Long[] EMPTY_LONG_OBJECT_ARRAY = {};
/**
* An empty immutable {@code Method} array.
*
* @since 3.10
*/
- public static final Method[] EMPTY_METHOD_ARRAY = new Method[0];
+ public static final Method[] EMPTY_METHOD_ARRAY = {};
/**
* An empty immutable {@code Object} array.
*/
- public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
+ public static final Object[] EMPTY_OBJECT_ARRAY = {};
/**
* An empty immutable {@code short} array.
*/
- public static final short[] EMPTY_SHORT_ARRAY = new short[0];
+ public static final short[] EMPTY_SHORT_ARRAY = {};
/**
* An empty immutable {@code Short} array.
*/
- public static final Short[] EMPTY_SHORT_OBJECT_ARRAY = new Short[0];
+ public static final Short[] EMPTY_SHORT_OBJECT_ARRAY = {};
/**
* An empty immutable {@code String} array.
*/
- public static final String[] EMPTY_STRING_ARRAY = new String[0];
+ public static final String[] EMPTY_STRING_ARRAY = {};
/**
* An empty immutable {@code Throwable} array.
*
* @since 3.10
*/
- public static final Throwable[] EMPTY_THROWABLE_ARRAY = new Throwable[0];
+ public static final Throwable[] EMPTY_THROWABLE_ARRAY = {};
/**
* An empty immutable {@code Type} array.
*
* @since 3.10
*/
- public static final Type[] EMPTY_TYPE_ARRAY = new Type[0];
+ public static final Type[] EMPTY_TYPE_ARRAY = {};
/**
* The index value when an element is not found in a list or array: {@code -1}.
diff --git a/src/main/java/org/apache/commons/lang3/CharRange.java b/src/main/java/org/apache/commons/lang3/CharRange.java
index 36d8595..94e5a0a 100644
--- a/src/main/java/org/apache/commons/lang3/CharRange.java
+++ b/src/main/java/org/apache/commons/lang3/CharRange.java
@@ -50,7 +50,7 @@
private transient String iToString;
/** Empty array. */
- static final CharRange[] EMPTY_ARRAY = new CharRange[0];
+ static final CharRange[] EMPTY_ARRAY = {};
/**
* <p>Constructs a {@code CharRange} over a set of characters,
diff --git a/src/main/java/org/apache/commons/lang3/time/DurationFormatUtils.java b/src/main/java/org/apache/commons/lang3/time/DurationFormatUtils.java
index 481eccb..91d1f19 100644
--- a/src/main/java/org/apache/commons/lang3/time/DurationFormatUtils.java
+++ b/src/main/java/org/apache/commons/lang3/time/DurationFormatUtils.java
@@ -570,7 +570,7 @@
static class Token {
/** Empty array. */
- private static final Token[] EMPTY_ARRAY = new Token[0];
+ private static final Token[] EMPTY_ARRAY = {};
/**
* Helper method to determine if a set of tokens contain a value
diff --git a/src/main/java/org/apache/commons/lang3/time/FastDatePrinter.java b/src/main/java/org/apache/commons/lang3/time/FastDatePrinter.java
index cc1b48f..66f49eb 100644
--- a/src/main/java/org/apache/commons/lang3/time/FastDatePrinter.java
+++ b/src/main/java/org/apache/commons/lang3/time/FastDatePrinter.java
@@ -92,7 +92,7 @@
// So, don't change this code! It works and is very fast.
/** Empty array. */
- private static final Rule[] EMPTY_RULE_ARRAY = new Rule[0];
+ private static final Rule[] EMPTY_RULE_ARRAY = {};
/**
* Required for serialization support.
diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsAddTest.java
index 3030308..60dc090 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 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 @@
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 @@
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 @@
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 b5d30aa..8ae503b 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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 c69cd39..405845d 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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
*/
@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 @@
*/
@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 @@
@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 @@
*/
@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 @@
*/
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
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 @@
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 0865f94..58d7ab4 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 @@
@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 7cf32cb..59b372b 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 @@
*/
@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 @@
// 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 @@
// 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 @@
// 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 @@
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 @@
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 @@
*/
@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 @@
*/
@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 @@
*/
@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 @@
*/
@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 @@
*/
@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 @@
*/
@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 @@
*/
@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 @@
*/
@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 @@
*/
@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 @@
*/
@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 9b2991a..637ea24 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 @@
}
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 @@
@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 03e4f28..4a5b365 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 @@
@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 29dda0d..613ed48 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 @@
// 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 6ef2732..0f02375 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 @@
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 @@
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 a597ef2..daa1126 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 @@
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 c86d437..609c0b8 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 @@
@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 @@
// 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 @@
// 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 @@
@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 1cd136e..ee32f01 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 @@
@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 e273ae5..51ce1f1 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 @@
@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 @@
@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 c7dee69..793940d 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 @@
@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 dc8dede..13bf2ba 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 @@
@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 @@
@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 @@
@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 af64ddd..d4610ed 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 @@
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 @@
*/
@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 @@
*/
@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 @@
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 045a3fc..d11d643 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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 41f2794..54043f3 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 @@
@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 @@
@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 @@
@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 b5c2d92..25410f0 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 @@
@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 @@
@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 @@
@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 04ac8e6..e9058a1 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 @@
@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 @@
@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 @@
@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 5a438dd..96cf4f3 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 @@
@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 @@
@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 @@
@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 4d60dc4..fb7a82d 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 @@
@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 @@
@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 @@
@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 edc8ed9..08f912f 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 @@
@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 @@
@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 @@
@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 cdca05e..935fa9b 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 @@
@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 @@
@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 @@
@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 e277f28..372c269 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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 @@
@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 2a4374e..90513db 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 @@
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 d7d49b5..80d1dac 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 @@
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 2bb1375..27a0bdd 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 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 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 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 @@
*/
@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 4ca0dac..08ffb01 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
@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 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 ee0c99e..6fe8615 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 @@
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 @@
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 @@
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 dd6025d..3119561 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 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 @@
@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 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 f29ba63..4631ffa 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 @@
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);
