You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2021/05/25 17:51:30 UTC
[commons-lang] branch master updated (d72c88a -> 1682277)
This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git.
from d72c88a Remove unused imports and reorg others.
new 24957f9 Use final.
new e8fe1a9 Create array with curly.
new 2d86ac6 Lambdas.
new b4a4338 Use valueOf().
new d02b2c5 Use valueOf().
new 8668397 Simpler boolean tests.
new 1682277 Revert.
The 7 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../java/org/apache/commons/lang3/ArrayUtils.java | 44 +-
.../java/org/apache/commons/lang3/CharRange.java | 2 +-
.../java/org/apache/commons/lang3/Streams.java | 4 +-
.../org/apache/commons/lang3/math/NumberUtils.java | 2 +-
.../org/apache/commons/lang3/stream/Streams.java | 4 +-
.../org/apache/commons/lang3/text/StrBuilder.java | 2 +-
.../apache/commons/lang3/text/StrSubstitutor.java | 10 +-
.../commons/lang3/time/DurationFormatUtils.java | 2 +-
.../apache/commons/lang3/time/FastDatePrinter.java | 2 +-
.../apache/commons/lang3/ArrayUtilsAddTest.java | 50 +-
.../lang3/ArrayUtilsRemoveMultipleTest.java | 18 +-
.../org/apache/commons/lang3/ArrayUtilsTest.java | 578 ++++++++++-----------
.../org/apache/commons/lang3/BooleanUtilsTest.java | 2 +-
.../org/apache/commons/lang3/ConversionTest.java | 38 +-
.../org/apache/commons/lang3/ObjectUtilsTest.java | 4 +-
.../commons/lang3/RandomStringUtilsTest.java | 2 +-
.../commons/lang3/StringEscapeUtilsTest.java | 2 +-
.../commons/lang3/StringUtilsContainsTest.java | 4 +-
.../lang3/StringUtilsEqualsIndexOfTest.java | 2 +-
.../org/apache/commons/lang3/StringUtilsTest.java | 10 +-
.../commons/lang3/StringUtilsTrimStripTest.java | 8 +-
.../org/apache/commons/lang3/SystemUtilsTest.java | 2 +-
.../org/apache/commons/lang3/ValidateTest.java | 4 +-
.../lang3/builder/CompareToBuilderTest.java | 2 +-
.../lang3/builder/DefaultToStringStyleTest.java | 6 +-
.../commons/lang3/builder/EqualsBuilderTest.java | 16 +-
.../lang3/builder/JsonToStringStyleTest.java | 20 +-
.../lang3/builder/MultiLineToStringStyleTest.java | 6 +-
.../builder/NoClassNameToStringStyleTest.java | 6 +-
.../builder/NoFieldNamesToStringStyleTest.java | 6 +-
.../lang3/builder/RecursiveToStringStyleTest.java | 6 +-
.../builder/ShortPrefixToStringStyleTest.java | 6 +-
.../lang3/builder/SimpleToStringStyleTest.java | 6 +-
.../lang3/builder/StandardToStringStyleTest.java | 6 +-
.../commons/lang3/builder/ToStringBuilderTest.java | 104 ++--
.../commons/lang3/math/IEEE754rUtilsTest.java | 8 +-
.../apache/commons/lang3/math/NumberUtilsTest.java | 10 +-
.../lang3/text/ExtendedMessageFormatTest.java | 8 +-
.../commons/lang3/text/StrTokenizerTest.java | 20 +-
.../apache/commons/lang3/text/WordUtilsTest.java | 6 +-
.../apache/commons/lang3/time/DateUtilsTest.java | 10 +-
.../lang3/time/DurationFormatUtilsTest.java | 4 +-
.../commons/lang3/tuple/ImmutableTripleTest.java | 4 +-
.../org/apache/commons/lang3/tuple/TripleTest.java | 2 +-
44 files changed, 527 insertions(+), 531 deletions(-)
[commons-lang] 04/07: Use valueOf().
Posted by gg...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
commit b4a43380f15abe6eff2a37d7d0de09cbcea1e106
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Tue May 25 13:38:02 2021 -0400
Use valueOf().
---
src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java | 4 ++--
src/test/java/org/apache/commons/lang3/tuple/ImmutableTripleTest.java | 4 ++--
src/test/java/org/apache/commons/lang3/tuple/TripleTest.java | 2 +-
3 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
index a9e62de..5366a07 100644
--- a/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
+++ b/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
@@ -356,9 +356,9 @@ public class DiffBuilderTest {
@Test
public void testObjectsNotSameButEqual() {
final TypeTestClass left = new TypeTestClass();
- left.objectField = new Integer(1);
+ left.objectField = Integer.valueOf(1);
final TypeTestClass right = new TypeTestClass();
- right.objectField = new Integer(1);
+ right.objectField = Integer.valueOf(1);
assertNotSame(left.objectField, right.objectField);
assertEquals(left.objectField, right.objectField);
diff --git a/src/test/java/org/apache/commons/lang3/tuple/ImmutableTripleTest.java b/src/test/java/org/apache/commons/lang3/tuple/ImmutableTripleTest.java
index cd18bce..dc01ac5 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/ImmutableTripleTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/ImmutableTripleTest.java
@@ -50,8 +50,8 @@ public class ImmutableTripleTest {
assertNull(triple2.getLeft());
assertEquals("bar", triple2.middle);
assertEquals("bar", triple2.getMiddle());
- assertEquals(new Integer(42), triple2.right);
- assertEquals(new Integer(42), triple2.getRight());
+ assertEquals(Integer.valueOf(42), triple2.right);
+ assertEquals(Integer.valueOf(42), triple2.getRight());
}
@Test
diff --git a/src/test/java/org/apache/commons/lang3/tuple/TripleTest.java b/src/test/java/org/apache/commons/lang3/tuple/TripleTest.java
index dbf06f3..b9ae9de 100644
--- a/src/test/java/org/apache/commons/lang3/tuple/TripleTest.java
+++ b/src/test/java/org/apache/commons/lang3/tuple/TripleTest.java
@@ -131,7 +131,7 @@ public class TripleTest {
assertTrue(triple2 instanceof ImmutableTriple<?, ?, ?>);
assertNull(((ImmutableTriple<Object, String, Long>) triple2).left);
assertEquals("bar", ((ImmutableTriple<Object, String, Long>) triple2).middle);
- assertEquals(new Long(200L), ((ImmutableTriple<Object, String, Long>) triple2).right);
+ assertEquals(Long.valueOf(200L), ((ImmutableTriple<Object, String, Long>) triple2).right);
}
}
[commons-lang] 02/07: Create array with curly.
Posted by gg...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
commit e8fe1a941ccd469750a509d6d7e91d727cca83a1
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Tue May 25 13:34:53 2021 -0400
Create array with curly.
---
.../java/org/apache/commons/lang3/ArrayUtils.java | 44 +-
.../java/org/apache/commons/lang3/CharRange.java | 2 +-
.../commons/lang3/time/DurationFormatUtils.java | 2 +-
.../apache/commons/lang3/time/FastDatePrinter.java | 2 +-
.../apache/commons/lang3/ArrayUtilsAddTest.java | 50 +-
.../lang3/ArrayUtilsRemoveMultipleTest.java | 18 +-
.../org/apache/commons/lang3/ArrayUtilsTest.java | 578 ++++++++++-----------
.../org/apache/commons/lang3/BooleanUtilsTest.java | 2 +-
.../org/apache/commons/lang3/ConversionTest.java | 38 +-
.../org/apache/commons/lang3/ObjectUtilsTest.java | 4 +-
.../commons/lang3/RandomStringUtilsTest.java | 2 +-
.../commons/lang3/StringEscapeUtilsTest.java | 2 +-
.../commons/lang3/StringUtilsContainsTest.java | 4 +-
.../lang3/StringUtilsEqualsIndexOfTest.java | 2 +-
.../org/apache/commons/lang3/StringUtilsTest.java | 10 +-
.../commons/lang3/StringUtilsTrimStripTest.java | 8 +-
.../org/apache/commons/lang3/ValidateTest.java | 4 +-
.../lang3/builder/CompareToBuilderTest.java | 2 +-
.../lang3/builder/DefaultToStringStyleTest.java | 6 +-
.../commons/lang3/builder/EqualsBuilderTest.java | 16 +-
.../lang3/builder/JsonToStringStyleTest.java | 20 +-
.../lang3/builder/MultiLineToStringStyleTest.java | 6 +-
.../builder/NoClassNameToStringStyleTest.java | 6 +-
.../builder/NoFieldNamesToStringStyleTest.java | 6 +-
.../lang3/builder/RecursiveToStringStyleTest.java | 6 +-
.../builder/ShortPrefixToStringStyleTest.java | 6 +-
.../lang3/builder/SimpleToStringStyleTest.java | 6 +-
.../lang3/builder/StandardToStringStyleTest.java | 6 +-
.../commons/lang3/builder/ToStringBuilderTest.java | 104 ++--
.../commons/lang3/math/IEEE754rUtilsTest.java | 8 +-
.../apache/commons/lang3/math/NumberUtilsTest.java | 8 +-
.../lang3/text/ExtendedMessageFormatTest.java | 8 +-
.../commons/lang3/text/StrTokenizerTest.java | 20 +-
.../apache/commons/lang3/text/WordUtilsTest.java | 6 +-
.../apache/commons/lang3/time/DateUtilsTest.java | 10 +-
.../lang3/time/DurationFormatUtilsTest.java | 4 +-
36 files changed, 513 insertions(+), 513 deletions(-)
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 @@ public class ArrayUtils {
/**
* 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 @@ public class ArrayUtils {
/**
* 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 @@ final class CharRange implements Iterable<Character>, Serializable {
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 @@ public class DurationFormatUtils {
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 @@ public class FastDatePrinter implements DatePrinter, Serializable {
// 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 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.addFirst(null, true);
assertArrayEquals(new boolean[]{true}, newArray);
assertEquals(Boolean.TYPE, newArray.getClass().getComponentType());
- final boolean[] array1 = new boolean[]{true, false, true};
+ final boolean[] array1 = {true, false, true};
newArray = ArrayUtils.addFirst(array1, false);
assertArrayEquals(new boolean[]{false, true, false, true}, newArray);
assertEquals(Boolean.TYPE, newArray.getClass().getComponentType());
@@ -55,7 +55,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.addFirst((byte[]) null, (byte) 1);
assertArrayEquals(new byte[]{1}, newArray);
assertEquals(Byte.TYPE, newArray.getClass().getComponentType());
- final byte[] array1 = new byte[]{1, 2, 3};
+ final byte[] array1 = {1, 2, 3};
newArray = ArrayUtils.addFirst(array1, (byte) 0);
assertArrayEquals(new byte[]{0, 1, 2, 3}, newArray);
assertEquals(Byte.TYPE, newArray.getClass().getComponentType());
@@ -73,7 +73,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.addFirst((char[]) null, (char) 1);
assertArrayEquals(new char[]{1}, newArray);
assertEquals(Character.TYPE, newArray.getClass().getComponentType());
- final char[] array1 = new char[]{1, 2, 3};
+ final char[] array1 = {1, 2, 3};
newArray = ArrayUtils.addFirst(array1, (char) 0);
assertArrayEquals(new char[]{0, 1, 2, 3}, newArray);
assertEquals(Character.TYPE, newArray.getClass().getComponentType());
@@ -91,7 +91,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.addFirst((double[]) null, 1);
assertArrayEquals(new double[]{1}, newArray);
assertEquals(Double.TYPE, newArray.getClass().getComponentType());
- final double[] array1 = new double[]{1, 2, 3};
+ final double[] array1 = {1, 2, 3};
newArray = ArrayUtils.addFirst(array1, 0);
assertArrayEquals(new double[]{0, 1, 2, 3}, newArray);
assertEquals(Double.TYPE, newArray.getClass().getComponentType());
@@ -109,7 +109,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.addFirst((float[]) null, 1);
assertArrayEquals(new float[]{1}, newArray);
assertEquals(Float.TYPE, newArray.getClass().getComponentType());
- final float[] array1 = new float[]{1, 2, 3};
+ final float[] array1 = {1, 2, 3};
newArray = ArrayUtils.addFirst(array1, 0);
assertArrayEquals(new float[]{0, 1, 2, 3}, newArray);
assertEquals(Float.TYPE, newArray.getClass().getComponentType());
@@ -127,7 +127,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.addFirst((int[]) null, 1);
assertArrayEquals(new int[]{1}, newArray);
assertEquals(Integer.TYPE, newArray.getClass().getComponentType());
- final int[] array1 = new int[]{1, 2, 3};
+ final int[] array1 = {1, 2, 3};
newArray = ArrayUtils.addFirst(array1, 0);
assertArrayEquals(new int[]{0, 1, 2, 3}, newArray);
assertEquals(Integer.TYPE, newArray.getClass().getComponentType());
@@ -145,7 +145,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.addFirst((long[]) null, 1);
assertArrayEquals(new long[]{1}, newArray);
assertEquals(Long.TYPE, newArray.getClass().getComponentType());
- final long[] array1 = new long[]{1, 2, 3};
+ final long[] array1 = {1, 2, 3};
newArray = ArrayUtils.addFirst(array1, 0);
assertArrayEquals(new long[]{0, 1, 2, 3}, newArray);
assertEquals(Long.TYPE, newArray.getClass().getComponentType());
@@ -170,7 +170,7 @@ public class ArrayUtilsAddTest {
assertArrayEquals(new Object[]{"a"}, newStringArray);
assertEquals(String.class, newStringArray.getClass().getComponentType());
- final String[] stringArray1 = new String[] { "a", "b", "c" };
+ final String[] stringArray1 = { "a", "b", "c" };
newArray = ArrayUtils.addFirst(stringArray1, null);
assertArrayEquals(new String[] { null, "a", "b", "c" }, newArray);
assertEquals(String.class, newArray.getClass().getComponentType());
@@ -179,7 +179,7 @@ public class ArrayUtilsAddTest {
assertArrayEquals(new String[] { "d", "a", "b", "c" }, newArray);
assertEquals(String.class, newArray.getClass().getComponentType());
- Number[] numberArray1 = new Number[] { Integer.valueOf(1), Double.valueOf(2) };
+ Number[] numberArray1 = { Integer.valueOf(1), Double.valueOf(2) };
newArray = ArrayUtils.addFirst(numberArray1, Float.valueOf(3));
assertArrayEquals(new Number[] { Float.valueOf(3), Integer.valueOf(1), Double.valueOf(2) }, newArray);
assertEquals(Number.class, newArray.getClass().getComponentType());
@@ -199,7 +199,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.addFirst((short[]) null, (short) 1);
assertArrayEquals(new short[]{1}, newArray);
assertEquals(Short.TYPE, newArray.getClass().getComponentType());
- final short[] array1 = new short[]{1, 2, 3};
+ final short[] array1 = {1, 2, 3};
newArray = ArrayUtils.addFirst(array1, (short) 0);
assertArrayEquals(new short[]{0, 1, 2, 3}, newArray);
assertEquals(Short.TYPE, newArray.getClass().getComponentType());
@@ -217,7 +217,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.add(null, true);
assertArrayEquals(new boolean[]{true}, newArray);
assertEquals(Boolean.TYPE, newArray.getClass().getComponentType());
- final boolean[] array1 = new boolean[]{true, false, true};
+ final boolean[] array1 = {true, false, true};
newArray = ArrayUtils.add(array1, false);
assertArrayEquals(new boolean[]{true, false, true, false}, newArray);
assertEquals(Boolean.TYPE, newArray.getClass().getComponentType());
@@ -232,7 +232,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.add((byte[]) null, (byte) 1);
assertArrayEquals(new byte[]{1}, newArray);
assertEquals(Byte.TYPE, newArray.getClass().getComponentType());
- final byte[] array1 = new byte[]{1, 2, 3};
+ final byte[] array1 = {1, 2, 3};
newArray = ArrayUtils.add(array1, (byte) 0);
assertArrayEquals(new byte[]{1, 2, 3, 0}, newArray);
assertEquals(Byte.TYPE, newArray.getClass().getComponentType());
@@ -250,7 +250,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.add((char[]) null, (char) 1);
assertArrayEquals(new char[]{1}, newArray);
assertEquals(Character.TYPE, newArray.getClass().getComponentType());
- final char[] array1 = new char[]{1, 2, 3};
+ final char[] array1 = {1, 2, 3};
newArray = ArrayUtils.add(array1, (char) 0);
assertArrayEquals(new char[]{1, 2, 3, 0}, newArray);
assertEquals(Character.TYPE, newArray.getClass().getComponentType());
@@ -268,7 +268,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.add((double[]) null, 1);
assertArrayEquals(new double[]{1}, newArray);
assertEquals(Double.TYPE, newArray.getClass().getComponentType());
- final double[] array1 = new double[]{1, 2, 3};
+ final double[] array1 = {1, 2, 3};
newArray = ArrayUtils.add(array1, 0);
assertArrayEquals(new double[]{1, 2, 3, 0}, newArray);
assertEquals(Double.TYPE, newArray.getClass().getComponentType());
@@ -286,7 +286,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.add((float[]) null, 1);
assertArrayEquals(new float[]{1}, newArray);
assertEquals(Float.TYPE, newArray.getClass().getComponentType());
- final float[] array1 = new float[]{1, 2, 3};
+ final float[] array1 = {1, 2, 3};
newArray = ArrayUtils.add(array1, 0);
assertArrayEquals(new float[]{1, 2, 3, 0}, newArray);
assertEquals(Float.TYPE, newArray.getClass().getComponentType());
@@ -304,7 +304,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.add((int[]) null, 1);
assertArrayEquals(new int[]{1}, newArray);
assertEquals(Integer.TYPE, newArray.getClass().getComponentType());
- final int[] array1 = new int[]{1, 2, 3};
+ final int[] array1 = {1, 2, 3};
newArray = ArrayUtils.add(array1, 0);
assertArrayEquals(new int[]{1, 2, 3, 0}, newArray);
assertEquals(Integer.TYPE, newArray.getClass().getComponentType());
@@ -322,7 +322,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.add((long[]) null, 1);
assertArrayEquals(new long[]{1}, newArray);
assertEquals(Long.TYPE, newArray.getClass().getComponentType());
- final long[] array1 = new long[]{1, 2, 3};
+ final long[] array1 = {1, 2, 3};
newArray = ArrayUtils.add(array1, 0);
assertArrayEquals(new long[]{1, 2, 3, 0}, newArray);
assertEquals(Long.TYPE, newArray.getClass().getComponentType());
@@ -347,7 +347,7 @@ public class ArrayUtilsAddTest {
assertArrayEquals(new Object[]{"a"}, newStringArray);
assertEquals(String.class, newStringArray.getClass().getComponentType());
- final String[] stringArray1 = new String[]{"a", "b", "c"};
+ final String[] stringArray1 = {"a", "b", "c"};
newArray = ArrayUtils.add(stringArray1, null);
assertArrayEquals(new String[]{"a", "b", "c", null}, newArray);
assertEquals(String.class, newArray.getClass().getComponentType());
@@ -356,7 +356,7 @@ public class ArrayUtilsAddTest {
assertArrayEquals(new String[]{"a", "b", "c", "d"}, newArray);
assertEquals(String.class, newArray.getClass().getComponentType());
- Number[] numberArray1 = new Number[]{Integer.valueOf(1), Double.valueOf(2)};
+ Number[] numberArray1 = {Integer.valueOf(1), Double.valueOf(2)};
newArray = ArrayUtils.add(numberArray1, Float.valueOf(3));
assertArrayEquals(new Number[]{Integer.valueOf(1), Double.valueOf(2), Float.valueOf(3)}, newArray);
assertEquals(Number.class, newArray.getClass().getComponentType());
@@ -376,7 +376,7 @@ public class ArrayUtilsAddTest {
newArray = ArrayUtils.add((short[]) null, (short) 1);
assertArrayEquals(new short[]{1}, newArray);
assertEquals(Short.TYPE, newArray.getClass().getComponentType());
- final short[] array1 = new short[]{1, 2, 3};
+ final short[] array1 = {1, 2, 3};
newArray = ArrayUtils.add(array1, (short) 0);
assertArrayEquals(new short[]{1, 2, 3, 0}, newArray);
assertEquals(Short.TYPE, newArray.getClass().getComponentType());
@@ -389,8 +389,8 @@ public class ArrayUtilsAddTest {
public void testAddObjectArrayToObjectArray() {
assertNull(ArrayUtils.addAll(null, (Object[]) null));
Object[] newArray;
- final String[] stringArray1 = new String[]{"a", "b", "c"};
- final String[] stringArray2 = new String[]{"1", "2", "3"};
+ final String[] stringArray1 = {"a", "b", "c"};
+ final String[] stringArray2 = {"1", "2", "3"};
newArray = ArrayUtils.addAll(stringArray1, (String[]) null);
assertNotSame(stringArray1, newArray);
assertArrayEquals(stringArray1, newArray);
@@ -416,7 +416,7 @@ public class ArrayUtilsAddTest {
assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, newArray);
assertArrayEquals(new String[]{}, newArray);
assertEquals(String.class, newArray.getClass().getComponentType());
- final String[] stringArrayNull = new String []{null};
+ final String[] stringArrayNull = {null};
newArray = ArrayUtils.addAll(stringArrayNull, stringArrayNull);
assertArrayEquals(new String[]{null, null}, newArray);
assertEquals(String.class, newArray.getClass().getComponentType());
@@ -487,7 +487,7 @@ public class ArrayUtilsAddTest {
assertArrayEquals(new String[]{"a"}, newArray);
assertArrayEquals(new Object[]{"a"}, newArray);
assertEquals(String.class, newArray.getClass().getComponentType());
- final String[] stringArray1 = new String[]{"a", "b", "c"};
+ final String[] stringArray1 = {"a", "b", "c"};
newArray = ArrayUtils.add(stringArray1, 0, null);
assertArrayEquals(new String[]{null, "a", "b", "c"}, newArray);
assertEquals(String.class, newArray.getClass().getComponentType());
@@ -502,7 +502,7 @@ public class ArrayUtilsAddTest {
assertEquals(String.class, newArray.getClass().getComponentType());
assertEquals(String.class, newArray.getClass().getComponentType());
- final Object[] o = new Object[] {"1", "2", "4"};
+ final Object[] o = {"1", "2", "4"};
final Object[] result = ArrayUtils.add(o, 2, "3");
final Object[] result2 = ArrayUtils.add(o, 3, "5");
diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsRemoveMultipleTest.java
index 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 @@ public class ArrayUtilsRemoveMultipleTest {
@Test
public void testRemoveAllBooleanArrayRemoveNone() {
- final boolean[] array1 = new boolean[] { true, false };
+ final boolean[] array1 = { true, false };
final boolean[] array2 = ArrayUtils.removeAll(array1);
assertNotSame(array1, array2);
assertArrayEquals(array1, array2);
@@ -175,7 +175,7 @@ public class ArrayUtilsRemoveMultipleTest {
@Test
public void testRemoveAllByteArrayRemoveNone() {
- final byte[] array1 = new byte[] { 1, 2 };
+ final byte[] array1 = { 1, 2 };
final byte[] array2 = ArrayUtils.removeAll(array1);
assertNotSame(array1, array2);
assertArrayEquals(array1, array2);
@@ -247,7 +247,7 @@ public class ArrayUtilsRemoveMultipleTest {
@Test
public void testRemoveAllCharArrayRemoveNone() {
- final char[] array1 = new char[] { 'a', 'b' };
+ final char[] array1 = { 'a', 'b' };
final char[] array2 = ArrayUtils.removeAll(array1);
assertNotSame(array1, array2);
assertArrayEquals(array1, array2);
@@ -319,7 +319,7 @@ public class ArrayUtilsRemoveMultipleTest {
@Test
public void testRemoveAllDoubleArrayRemoveNone() {
- final double[] array1 = new double[] { 1, 2 };
+ final double[] array1 = { 1, 2 };
final double[] array2 = ArrayUtils.removeAll(array1);
assertNotSame(array1, array2);
assertArrayEquals(array1, array2);
@@ -391,7 +391,7 @@ public class ArrayUtilsRemoveMultipleTest {
@Test
public void testRemoveAllFloatArrayRemoveNone() {
- final float[] array1 = new float[] { 1, 2 };
+ final float[] array1 = { 1, 2 };
final float[] array2 = ArrayUtils.removeAll(array1);
assertNotSame(array1, array2);
assertArrayEquals(array1, array2);
@@ -469,7 +469,7 @@ public class ArrayUtilsRemoveMultipleTest {
@Test
public void testRemoveAllIntArrayRemoveNone() {
- final int[] array1 = new int[] { 1, 2 };
+ final int[] array1 = { 1, 2 };
final int[] array2 = ArrayUtils.removeAll(array1);
assertNotSame(array1, array2);
assertArrayEquals(array1, array2);
@@ -541,7 +541,7 @@ public class ArrayUtilsRemoveMultipleTest {
@Test
public void testRemoveAllLongArrayRemoveNone() {
- final long[] array1 = new long[] { 1, 2 };
+ final long[] array1 = { 1, 2 };
final long[] array2 = ArrayUtils.removeAll(array1);
assertNotSame(array1, array2);
assertArrayEquals(array1, array2);
@@ -685,7 +685,7 @@ public class ArrayUtilsRemoveMultipleTest {
@Test
public void testRemoveAllObjectArrayRemoveNone() {
- final Object[] array1 = new Object[] { "foo", "bar", "baz" };
+ final Object[] array1 = { "foo", "bar", "baz" };
final Object[] array2 = ArrayUtils.removeAll(array1);
assertNotSame(array1, array2);
assertArrayEquals(array1, array2);
@@ -757,7 +757,7 @@ public class ArrayUtilsRemoveMultipleTest {
@Test
public void testRemoveAllShortArrayRemoveNone() {
- final short[] array1 = new short[] { 1, 2 };
+ final short[] array1 = { 1, 2 };
final short[] array2 = ArrayUtils.removeAll(array1);
assertNotSame(array1, array2);
assertArrayEquals(array1, array2);
diff --git a/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java b/src/test/java/org/apache/commons/lang3/ArrayUtilsTest.java
index 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 @@ public class ArrayUtilsTest {
@Test
public void testClone() {
assertArrayEquals(null, ArrayUtils.clone((Object[]) null));
- Object[] original1 = new Object[0];
+ Object[] original1 = {};
Object[] cloned1 = ArrayUtils.clone(original1);
assertArrayEquals(original1, cloned1);
assertNotSame(original1, cloned1);
@@ -120,7 +120,7 @@ public class ArrayUtilsTest {
@Test
public void testCloneBoolean() {
assertNull(ArrayUtils.clone((boolean[]) null));
- final boolean[] original = new boolean[]{true, false};
+ final boolean[] original = {true, false};
final boolean[] cloned = ArrayUtils.clone(original);
assertArrayEquals(original, cloned);
assertNotSame(original, cloned);
@@ -129,7 +129,7 @@ public class ArrayUtilsTest {
@Test
public void testCloneByte() {
assertNull(ArrayUtils.clone((byte[]) null));
- final byte[] original = new byte[]{1, 6};
+ final byte[] original = {1, 6};
final byte[] cloned = ArrayUtils.clone(original);
assertArrayEquals(original, cloned);
assertNotSame(original, cloned);
@@ -138,7 +138,7 @@ public class ArrayUtilsTest {
@Test
public void testCloneChar() {
assertNull(ArrayUtils.clone((char[]) null));
- final char[] original = new char[]{'a', '4'};
+ final char[] original = {'a', '4'};
final char[] cloned = ArrayUtils.clone(original);
assertArrayEquals(original, cloned);
assertNotSame(original, cloned);
@@ -147,7 +147,7 @@ public class ArrayUtilsTest {
@Test
public void testCloneDouble() {
assertNull(ArrayUtils.clone((double[]) null));
- final double[] original = new double[]{2.4d, 5.7d};
+ final double[] original = {2.4d, 5.7d};
final double[] cloned = ArrayUtils.clone(original);
assertArrayEquals(original, cloned);
assertNotSame(original, cloned);
@@ -156,7 +156,7 @@ public class ArrayUtilsTest {
@Test
public void testCloneFloat() {
assertNull(ArrayUtils.clone((float[]) null));
- final float[] original = new float[]{2.6f, 6.4f};
+ final float[] original = {2.6f, 6.4f};
final float[] cloned = ArrayUtils.clone(original);
assertArrayEquals(original, cloned);
assertNotSame(original, cloned);
@@ -165,7 +165,7 @@ public class ArrayUtilsTest {
@Test
public void testCloneInt() {
assertNull(ArrayUtils.clone((int[]) null));
- final int[] original = new int[]{5, 8};
+ final int[] original = {5, 8};
final int[] cloned = ArrayUtils.clone(original);
assertArrayEquals(original, cloned);
assertNotSame(original, cloned);
@@ -174,7 +174,7 @@ public class ArrayUtilsTest {
@Test
public void testCloneLong() {
assertNull(ArrayUtils.clone((long[]) null));
- final long[] original = new long[]{0L, 1L};
+ final long[] original = {0L, 1L};
final long[] cloned = ArrayUtils.clone(original);
assertArrayEquals(original, cloned);
assertNotSame(original, cloned);
@@ -183,7 +183,7 @@ public class ArrayUtilsTest {
@Test
public void testCloneShort() {
assertNull(ArrayUtils.clone((short[]) null));
- final short[] original = new short[]{1, 4};
+ final short[] original = {1, 4};
final short[] cloned = ArrayUtils.clone(original);
assertArrayEquals(original, cloned);
assertNotSame(original, cloned);
@@ -201,7 +201,7 @@ public class ArrayUtilsTest {
@Test
public void testContains() {
- final Object[] array = new Object[]{"0", "1", "2", "3", null, "0"};
+ final Object[] array = {"0", "1", "2", "3", null, "0"};
assertFalse(ArrayUtils.contains(null, null));
assertFalse(ArrayUtils.contains(null, "1"));
assertTrue(ArrayUtils.contains(array, "0"));
@@ -282,7 +282,7 @@ public class ArrayUtilsTest {
@Test
public void testContainsDoubleNaN() {
- final double[] a = new double[] { Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY };
+ final double[] a = { Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY };
assertTrue(ArrayUtils.contains(a, Double.POSITIVE_INFINITY));
assertTrue(ArrayUtils.contains(a, Double.NEGATIVE_INFINITY));
assertTrue(ArrayUtils.contains(a, Double.NaN));
@@ -315,7 +315,7 @@ public class ArrayUtilsTest {
@Test
public void testContainsFloatNaN() {
- final float[] array = new float[] { Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY };
+ final float[] array = { Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY };
assertTrue(ArrayUtils.contains(array, Float.POSITIVE_INFINITY));
assertTrue(ArrayUtils.contains(array, Float.NEGATIVE_INFINITY));
assertTrue(ArrayUtils.contains(array, Float.NaN));
@@ -446,50 +446,50 @@ public class ArrayUtilsTest {
public void testGetLength() {
assertEquals(0, ArrayUtils.getLength(null));
- final Object[] emptyObjectArray = new Object[0];
- final Object[] notEmptyObjectArray = new Object[]{"aValue"};
+ final Object[] emptyObjectArray = {};
+ final Object[] notEmptyObjectArray = {"aValue"};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyObjectArray));
assertEquals(1, ArrayUtils.getLength(notEmptyObjectArray));
- final int[] emptyIntArray = new int[]{};
- final int[] notEmptyIntArray = new int[]{1};
+ final int[] emptyIntArray = {};
+ final int[] notEmptyIntArray = {1};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyIntArray));
assertEquals(1, ArrayUtils.getLength(notEmptyIntArray));
- final short[] emptyShortArray = new short[]{};
- final short[] notEmptyShortArray = new short[]{1};
+ final short[] emptyShortArray = {};
+ final short[] notEmptyShortArray = {1};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyShortArray));
assertEquals(1, ArrayUtils.getLength(notEmptyShortArray));
- final char[] emptyCharArray = new char[]{};
- final char[] notEmptyCharArray = new char[]{1};
+ final char[] emptyCharArray = {};
+ final char[] notEmptyCharArray = {1};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyCharArray));
assertEquals(1, ArrayUtils.getLength(notEmptyCharArray));
- final byte[] emptyByteArray = new byte[]{};
- final byte[] notEmptyByteArray = new byte[]{1};
+ final byte[] emptyByteArray = {};
+ final byte[] notEmptyByteArray = {1};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyByteArray));
assertEquals(1, ArrayUtils.getLength(notEmptyByteArray));
- final double[] emptyDoubleArray = new double[]{};
- final double[] notEmptyDoubleArray = new double[]{1.0};
+ final double[] emptyDoubleArray = {};
+ final double[] notEmptyDoubleArray = {1.0};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyDoubleArray));
assertEquals(1, ArrayUtils.getLength(notEmptyDoubleArray));
- final float[] emptyFloatArray = new float[]{};
- final float[] notEmptyFloatArray = new float[]{1.0F};
+ final float[] emptyFloatArray = {};
+ final float[] notEmptyFloatArray = {1.0F};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyFloatArray));
assertEquals(1, ArrayUtils.getLength(notEmptyFloatArray));
- final boolean[] emptyBooleanArray = new boolean[]{};
- final boolean[] notEmptyBooleanArray = new boolean[]{true};
+ final boolean[] emptyBooleanArray = {};
+ final boolean[] notEmptyBooleanArray = {true};
assertEquals(0, ArrayUtils.getLength(null));
assertEquals(0, ArrayUtils.getLength(emptyBooleanArray));
assertEquals(1, ArrayUtils.getLength(notEmptyBooleanArray));
@@ -499,24 +499,24 @@ public class ArrayUtilsTest {
@Test
public void testHashCode() {
- final long[][] array1 = new long[][]{{2, 5}, {4, 5}};
- final long[][] array2 = new long[][]{{2, 5}, {4, 6}};
+ final long[][] array1 = {{2, 5}, {4, 5}};
+ final long[][] array2 = {{2, 5}, {4, 6}};
assertEquals(ArrayUtils.hashCode(array1), ArrayUtils.hashCode(array1));
assertNotEquals(ArrayUtils.hashCode(array1), ArrayUtils.hashCode(array2));
- final Object[] array3 = new Object[]{new String(new char[]{'A', 'B'})};
- final Object[] array4 = new Object[]{"AB"};
+ final Object[] array3 = {new String(new char[]{'A', 'B'})};
+ final Object[] array4 = {"AB"};
assertEquals(ArrayUtils.hashCode(array3), ArrayUtils.hashCode(array3));
assertEquals(ArrayUtils.hashCode(array3), ArrayUtils.hashCode(array4));
- final Object[] arrayA = new Object[]{new boolean[]{true, false}, new int[]{6, 7}};
- final Object[] arrayB = new Object[]{new boolean[]{true, false}, new int[]{6, 7}};
+ final Object[] arrayA = {new boolean[]{true, false}, new int[]{6, 7}};
+ final Object[] arrayB = {new boolean[]{true, false}, new int[]{6, 7}};
assertEquals(ArrayUtils.hashCode(arrayB), ArrayUtils.hashCode(arrayA));
}
@Test
public void testIndexesOf() {
- final Object[] array = new Object[]{"0", "1", "2", "3", null, "0"};
+ final Object[] array = {"0", "1", "2", "3", null, "0"};
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf((Object[]) null, null));
@@ -836,7 +836,7 @@ public class ArrayUtilsTest {
@Test
public void testIndexesOfLong() {
- final long[] array = new long[]{0, 1, 2, 3};
+ final long[] array = {0, 1, 2, 3};
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf((long[]) null, 0));
@@ -856,7 +856,7 @@ public class ArrayUtilsTest {
@Test
public void testIndexesOfLongWithStartIndex() {
- final long[] array = new long[]{0, 1, 2, 3, 2, 1, 0, 1};
+ final long[] array = {0, 1, 2, 3, 2, 1, 0, 1};
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf((long[]) null, 0, 0));
@@ -928,7 +928,7 @@ public class ArrayUtilsTest {
@Test
public void testIndexesOfWithStartIndex() {
- final Object[] array = new Object[]{"0", "1", "2", "3", "2", "3", "1", null, "0"};
+ final Object[] array = {"0", "1", "2", "3", "2", "3", "1", null, "0"};
final BitSet emptySet = new BitSet();
final BitSet testSet = new BitSet();
assertEquals(emptySet, ArrayUtils.indexesOf(null, null, 2));
@@ -960,7 +960,7 @@ public class ArrayUtilsTest {
@Test
public void testIndexOf() {
- final Object[] array = new Object[]{"0", "1", "2", "3", null, "0"};
+ final Object[] array = {"0", "1", "2", "3", null, "0"};
assertEquals(-1, ArrayUtils.indexOf(null, null));
assertEquals(-1, ArrayUtils.indexOf(null, "0"));
assertEquals(-1, ArrayUtils.indexOf(new Object[0], "0"));
@@ -1071,7 +1071,7 @@ public class ArrayUtilsTest {
@Test
public void testIndexOfDoubleNaN() {
- final double[] array = new double[] { Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY, Double.NaN };
+ final double[] array = { Double.NEGATIVE_INFINITY, Double.NaN, Double.POSITIVE_INFINITY, Double.NaN };
assertEquals(0, ArrayUtils.indexOf(array, Double.NEGATIVE_INFINITY));
assertEquals(1, ArrayUtils.indexOf(array, Double.NaN));
assertEquals(2, ArrayUtils.indexOf(array, Double.POSITIVE_INFINITY));
@@ -1143,7 +1143,7 @@ public class ArrayUtilsTest {
@Test
public void testIndexOfFloatNaN() {
- final float[] array = new float[] { Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY, Float.NaN };
+ final float[] array = { Float.NEGATIVE_INFINITY, Float.NaN, Float.POSITIVE_INFINITY, Float.NaN };
assertEquals(0, ArrayUtils.indexOf(array, Float.NEGATIVE_INFINITY));
assertEquals(1, ArrayUtils.indexOf(array, Float.NaN));
assertEquals(2, ArrayUtils.indexOf(array, Float.POSITIVE_INFINITY));
@@ -1246,7 +1246,7 @@ public class ArrayUtilsTest {
@Test
public void testIndexOfWithStartIndex() {
- final Object[] array = new Object[]{"0", "1", "2", "3", null, "0"};
+ final Object[] array = {"0", "1", "2", "3", null, "0"};
assertEquals(-1, ArrayUtils.indexOf(null, null, 2));
assertEquals(-1, ArrayUtils.indexOf(new Object[0], "0", 0));
assertEquals(-1, ArrayUtils.indexOf(null, "0", 2));
@@ -1302,8 +1302,8 @@ public class ArrayUtilsTest {
*/
@Test
public void testIsEmptyObject() {
- final Object[] emptyArray = new Object[]{};
- final Object[] notEmptyArray = new Object[]{"Value"};
+ final Object[] emptyArray = {};
+ final Object[] notEmptyArray = {"Value"};
assertTrue(ArrayUtils.isEmpty((Object[]) null));
assertTrue(ArrayUtils.isEmpty(emptyArray));
assertFalse(ArrayUtils.isEmpty(notEmptyArray));
@@ -1321,50 +1321,50 @@ public class ArrayUtilsTest {
*/
@Test
public void testIsEmptyPrimitives() {
- final long[] emptyLongArray = new long[]{};
- final long[] notEmptyLongArray = new long[]{1L};
+ final long[] emptyLongArray = {};
+ final long[] notEmptyLongArray = {1L};
assertTrue(ArrayUtils.isEmpty((long[]) null));
assertTrue(ArrayUtils.isEmpty(emptyLongArray));
assertFalse(ArrayUtils.isEmpty(notEmptyLongArray));
- final int[] emptyIntArray = new int[]{};
- final int[] notEmptyIntArray = new int[]{1};
+ final int[] emptyIntArray = {};
+ final int[] notEmptyIntArray = {1};
assertTrue(ArrayUtils.isEmpty((int[]) null));
assertTrue(ArrayUtils.isEmpty(emptyIntArray));
assertFalse(ArrayUtils.isEmpty(notEmptyIntArray));
- final short[] emptyShortArray = new short[]{};
- final short[] notEmptyShortArray = new short[]{1};
+ final short[] emptyShortArray = {};
+ final short[] notEmptyShortArray = {1};
assertTrue(ArrayUtils.isEmpty((short[]) null));
assertTrue(ArrayUtils.isEmpty(emptyShortArray));
assertFalse(ArrayUtils.isEmpty(notEmptyShortArray));
- final char[] emptyCharArray = new char[]{};
- final char[] notEmptyCharArray = new char[]{1};
+ final char[] emptyCharArray = {};
+ final char[] notEmptyCharArray = {1};
assertTrue(ArrayUtils.isEmpty((char[]) null));
assertTrue(ArrayUtils.isEmpty(emptyCharArray));
assertFalse(ArrayUtils.isEmpty(notEmptyCharArray));
- final byte[] emptyByteArray = new byte[]{};
- final byte[] notEmptyByteArray = new byte[]{1};
+ final byte[] emptyByteArray = {};
+ final byte[] notEmptyByteArray = {1};
assertTrue(ArrayUtils.isEmpty((byte[]) null));
assertTrue(ArrayUtils.isEmpty(emptyByteArray));
assertFalse(ArrayUtils.isEmpty(notEmptyByteArray));
- final double[] emptyDoubleArray = new double[]{};
- final double[] notEmptyDoubleArray = new double[]{1.0};
+ final double[] emptyDoubleArray = {};
+ final double[] notEmptyDoubleArray = {1.0};
assertTrue(ArrayUtils.isEmpty((double[]) null));
assertTrue(ArrayUtils.isEmpty(emptyDoubleArray));
assertFalse(ArrayUtils.isEmpty(notEmptyDoubleArray));
- final float[] emptyFloatArray = new float[]{};
- final float[] notEmptyFloatArray = new float[]{1.0F};
+ final float[] emptyFloatArray = {};
+ final float[] notEmptyFloatArray = {1.0F};
assertTrue(ArrayUtils.isEmpty((float[]) null));
assertTrue(ArrayUtils.isEmpty(emptyFloatArray));
assertFalse(ArrayUtils.isEmpty(notEmptyFloatArray));
- final boolean[] emptyBooleanArray = new boolean[]{};
- final boolean[] notEmptyBooleanArray = new boolean[]{true};
+ final boolean[] emptyBooleanArray = {};
+ final boolean[] notEmptyBooleanArray = {true};
assertTrue(ArrayUtils.isEmpty((boolean[]) null));
assertTrue(ArrayUtils.isEmpty(emptyBooleanArray));
assertFalse(ArrayUtils.isEmpty(notEmptyBooleanArray));
@@ -1372,48 +1372,48 @@ public class ArrayUtilsTest {
@Test
public void testIsEquals() {
- final long[][] larray1 = new long[][]{{2, 5}, {4, 5}};
- final long[][] larray2 = new long[][]{{2, 5}, {4, 6}};
- final long[] larray3 = new long[]{2, 5};
+ final long[][] larray1 = {{2, 5}, {4, 5}};
+ final long[][] larray2 = {{2, 5}, {4, 6}};
+ final long[] larray3 = {2, 5};
this.assertIsEquals(larray1, larray2, larray3);
- final int[][] iarray1 = new int[][]{{2, 5}, {4, 5}};
- final int[][] iarray2 = new int[][]{{2, 5}, {4, 6}};
- final int[] iarray3 = new int[]{2, 5};
+ final int[][] iarray1 = {{2, 5}, {4, 5}};
+ final int[][] iarray2 = {{2, 5}, {4, 6}};
+ final int[] iarray3 = {2, 5};
this.assertIsEquals(iarray1, iarray2, iarray3);
- final short[][] sarray1 = new short[][]{{2, 5}, {4, 5}};
- final short[][] sarray2 = new short[][]{{2, 5}, {4, 6}};
- final short[] sarray3 = new short[]{2, 5};
+ final short[][] sarray1 = {{2, 5}, {4, 5}};
+ final short[][] sarray2 = {{2, 5}, {4, 6}};
+ final short[] sarray3 = {2, 5};
this.assertIsEquals(sarray1, sarray2, sarray3);
- final float[][] farray1 = new float[][]{{2, 5}, {4, 5}};
- final float[][] farray2 = new float[][]{{2, 5}, {4, 6}};
- final float[] farray3 = new float[]{2, 5};
+ final float[][] farray1 = {{2, 5}, {4, 5}};
+ final float[][] farray2 = {{2, 5}, {4, 6}};
+ final float[] farray3 = {2, 5};
this.assertIsEquals(farray1, farray2, farray3);
- final double[][] darray1 = new double[][]{{2, 5}, {4, 5}};
- final double[][] darray2 = new double[][]{{2, 5}, {4, 6}};
- final double[] darray3 = new double[]{2, 5};
+ final double[][] darray1 = {{2, 5}, {4, 5}};
+ final double[][] darray2 = {{2, 5}, {4, 6}};
+ final double[] darray3 = {2, 5};
this.assertIsEquals(darray1, darray2, darray3);
- final byte[][] byteArray1 = new byte[][]{{2, 5}, {4, 5}};
- final byte[][] byteArray2 = new byte[][]{{2, 5}, {4, 6}};
- final byte[] byteArray3 = new byte[]{2, 5};
+ final byte[][] byteArray1 = {{2, 5}, {4, 5}};
+ final byte[][] byteArray2 = {{2, 5}, {4, 6}};
+ final byte[] byteArray3 = {2, 5};
this.assertIsEquals(byteArray1, byteArray2, byteArray3);
- final char[][] charArray1 = new char[][]{{2, 5}, {4, 5}};
- final char[][] charArray2 = new char[][]{{2, 5}, {4, 6}};
- final char[] charArray3 = new char[]{2, 5};
+ final char[][] charArray1 = {{2, 5}, {4, 5}};
+ final char[][] charArray2 = {{2, 5}, {4, 6}};
+ final char[] charArray3 = {2, 5};
this.assertIsEquals(charArray1, charArray2, charArray3);
- final boolean[][] barray1 = new boolean[][]{{true, false}, {true, true}};
- final boolean[][] barray2 = new boolean[][]{{true, false}, {true, false}};
- final boolean[] barray3 = new boolean[]{false, true};
+ final boolean[][] barray1 = {{true, false}, {true, true}};
+ final boolean[][] barray2 = {{true, false}, {true, false}};
+ final boolean[] barray3 = {false, true};
this.assertIsEquals(barray1, barray2, barray3);
- final Object[] array3 = new Object[]{new String(new char[]{'A', 'B'})};
- final Object[] array4 = new Object[]{"AB"};
+ final Object[] array3 = {new String(new char[]{'A', 'B'})};
+ final Object[] array4 = {"AB"};
assertTrue(ArrayUtils.isEquals(array3, array3));
assertTrue(ArrayUtils.isEquals(array3, array4));
@@ -1426,8 +1426,8 @@ public class ArrayUtilsTest {
*/
@Test
public void testIsNotEmptyObject() {
- final Object[] emptyArray = new Object[]{};
- final Object[] notEmptyArray = new Object[]{"Value"};
+ final Object[] emptyArray = {};
+ final Object[] notEmptyArray = {"Value"};
assertFalse(ArrayUtils.isNotEmpty((Object[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyArray));
@@ -1445,50 +1445,50 @@ public class ArrayUtilsTest {
*/
@Test
public void testIsNotEmptyPrimitives() {
- final long[] emptyLongArray = new long[]{};
- final long[] notEmptyLongArray = new long[]{1L};
+ final long[] emptyLongArray = {};
+ final long[] notEmptyLongArray = {1L};
assertFalse(ArrayUtils.isNotEmpty((long[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyLongArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyLongArray));
- final int[] emptyIntArray = new int[]{};
- final int[] notEmptyIntArray = new int[]{1};
+ final int[] emptyIntArray = {};
+ final int[] notEmptyIntArray = {1};
assertFalse(ArrayUtils.isNotEmpty((int[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyIntArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyIntArray));
- final short[] emptyShortArray = new short[]{};
- final short[] notEmptyShortArray = new short[]{1};
+ final short[] emptyShortArray = {};
+ final short[] notEmptyShortArray = {1};
assertFalse(ArrayUtils.isNotEmpty((short[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyShortArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyShortArray));
- final char[] emptyCharArray = new char[]{};
- final char[] notEmptyCharArray = new char[]{1};
+ final char[] emptyCharArray = {};
+ final char[] notEmptyCharArray = {1};
assertFalse(ArrayUtils.isNotEmpty((char[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyCharArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyCharArray));
- final byte[] emptyByteArray = new byte[]{};
- final byte[] notEmptyByteArray = new byte[]{1};
+ final byte[] emptyByteArray = {};
+ final byte[] notEmptyByteArray = {1};
assertFalse(ArrayUtils.isNotEmpty((byte[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyByteArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyByteArray));
- final double[] emptyDoubleArray = new double[]{};
- final double[] notEmptyDoubleArray = new double[]{1.0};
+ final double[] emptyDoubleArray = {};
+ final double[] notEmptyDoubleArray = {1.0};
assertFalse(ArrayUtils.isNotEmpty((double[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyDoubleArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyDoubleArray));
- final float[] emptyFloatArray = new float[]{};
- final float[] notEmptyFloatArray = new float[]{1.0F};
+ final float[] emptyFloatArray = {};
+ final float[] notEmptyFloatArray = {1.0F};
assertFalse(ArrayUtils.isNotEmpty((float[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyFloatArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyFloatArray));
- final boolean[] emptyBooleanArray = new boolean[]{};
- final boolean[] notEmptyBooleanArray = new boolean[]{true};
+ final boolean[] emptyBooleanArray = {};
+ final boolean[] notEmptyBooleanArray = {true};
assertFalse(ArrayUtils.isNotEmpty((boolean[]) null));
assertFalse(ArrayUtils.isNotEmpty(emptyBooleanArray));
assertTrue(ArrayUtils.isNotEmpty(notEmptyBooleanArray));
@@ -1653,7 +1653,7 @@ public class ArrayUtilsTest {
@Test
public void testLastIndexOf() {
- final Object[] array = new Object[]{"0", "1", "2", "3", null, "0"};
+ final Object[] array = {"0", "1", "2", "3", null, "0"};
assertEquals(-1, ArrayUtils.lastIndexOf(null, null));
assertEquals(-1, ArrayUtils.lastIndexOf(null, "0"));
assertEquals(5, ArrayUtils.lastIndexOf(array, "0"));
@@ -1921,7 +1921,7 @@ public class ArrayUtilsTest {
@Test
public void testLastIndexOfWithStartIndex() {
- final Object[] array = new Object[]{"0", "1", "2", "3", null, "0"};
+ final Object[] array = {"0", "1", "2", "3", null, "0"};
assertEquals(-1, ArrayUtils.lastIndexOf(null, null, 2));
assertEquals(-1, ArrayUtils.lastIndexOf(null, "0", 2));
assertEquals(0, ArrayUtils.lastIndexOf(array, "0", 2));
@@ -1939,13 +1939,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyBoolean() {
- final boolean[] original = new boolean[]{true, false};
+ final boolean[] original = {true, false};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyBooleanEmptyArray() {
- final boolean[] empty = new boolean[]{};
+ final boolean[] empty = {};
final boolean[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_BOOLEAN_ARRAY, result);
assertNotSame(empty, result);
@@ -1958,13 +1958,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyBooleanObject() {
- final Boolean[] original = new Boolean[]{Boolean.TRUE, Boolean.FALSE};
+ final Boolean[] original = {Boolean.TRUE, Boolean.FALSE};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyBooleanObjectEmptyArray() {
- final Boolean[] empty = new Boolean[]{};
+ final Boolean[] empty = {};
final Boolean[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_BOOLEAN_OBJECT_ARRAY, result);
assertNotSame(empty, result);
@@ -1977,13 +1977,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyByte() {
- final byte[] original = new byte[]{0x0F, 0x0E};
+ final byte[] original = {0x0F, 0x0E};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyByteEmptyArray() {
- final byte[] empty = new byte[]{};
+ final byte[] empty = {};
final byte[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_BYTE_ARRAY, result);
assertNotSame(empty, result);
@@ -1996,13 +1996,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyByteObject() {
- final Byte[] original = new Byte[]{0x0F, 0x0E};
+ final Byte[] original = {0x0F, 0x0E};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyByteObjectEmptyArray() {
- final Byte[] empty = new Byte[]{};
+ final Byte[] empty = {};
final Byte[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_BYTE_OBJECT_ARRAY, result);
assertNotSame(empty, result);
@@ -2015,13 +2015,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyChar() {
- final char[] original = new char[]{'a', 'b'};
+ final char[] original = {'a', 'b'};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyCharEmptyArray() {
- final char[] empty = new char[]{};
+ final char[] empty = {};
final char[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, result);
assertNotSame(empty, result);
@@ -2034,13 +2034,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyCharObject() {
- final Character[] original = new Character[]{'a', 'b'};
+ final Character[] original = {'a', 'b'};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyCharObjectEmptyArray() {
- final Character[] empty = new Character[]{};
+ final Character[] empty = {};
final Character[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_CHARACTER_OBJECT_ARRAY, result);
assertNotSame(empty, result);
@@ -2072,13 +2072,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyDouble() {
- final double[] original = new double[]{1L, 2L};
+ final double[] original = {1L, 2L};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyDoubleEmptyArray() {
- final double[] empty = new double[]{};
+ final double[] empty = {};
final double[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_DOUBLE_ARRAY, result);
assertNotSame(empty, result);
@@ -2091,13 +2091,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyDoubleObject() {
- final Double[] original = new Double[]{1D, 2D};
+ final Double[] original = {1D, 2D};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyDoubleObjectEmptyArray() {
- final Double[] empty = new Double[]{};
+ final Double[] empty = {};
final Double[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_DOUBLE_OBJECT_ARRAY, result);
assertNotSame(empty, result);
@@ -2110,13 +2110,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyFloat() {
- final float[] original = new float[]{2.6f, 3.8f};
+ final float[] original = {2.6f, 3.8f};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyFloatEmptyArray() {
- final float[] empty = new float[]{};
+ final float[] empty = {};
final float[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_FLOAT_ARRAY, result);
assertNotSame(empty, result);
@@ -2129,13 +2129,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyFloatObject() {
- final Float[] original = new Float[]{2.6f, 3.8f};
+ final Float[] original = {2.6f, 3.8f};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyFloatObjectEmptyArray() {
- final Float[] empty = new Float[]{};
+ final Float[] empty = {};
final Float[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_FLOAT_OBJECT_ARRAY, result);
assertNotSame(empty, result);
@@ -2148,7 +2148,7 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyGeneric() {
- final TestClass[] input = new TestClass[]{new TestClass(), new TestClass()};
+ final TestClass[] input = {new TestClass(), new TestClass()};
final TestClass[] output = ArrayUtils.nullToEmpty(input, TestClass[].class);
assertSame(input, output);
@@ -2156,7 +2156,7 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyGenericEmpty() {
- final TestClass[] input = new TestClass[]{};
+ final TestClass[] input = {};
final TestClass[] output = ArrayUtils.nullToEmpty(input, TestClass[].class);
assertSame(input, output);
@@ -2172,19 +2172,19 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyGenericNullType() {
- final TestClass[] input = new TestClass[]{};
+ final TestClass[] input = {};
assertThrows(IllegalArgumentException.class, () -> ArrayUtils.nullToEmpty(input, null));
}
@Test
public void testNullToEmptyInt() {
- final int[] original = new int[]{1, 2};
+ final int[] original = {1, 2};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyIntEmptyArray() {
- final int[] empty = new int[]{};
+ final int[] empty = {};
final int[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_INT_ARRAY, result);
assertNotSame(empty, result);
@@ -2197,13 +2197,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyIntObject() {
- final Integer[] original = new Integer[]{1, 2};
+ final Integer[] original = {1, 2};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyIntObjectEmptyArray() {
- final Integer[] empty = new Integer[]{};
+ final Integer[] empty = {};
final Integer[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_INTEGER_OBJECT_ARRAY, result);
assertNotSame(empty, result);
@@ -2216,13 +2216,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyLong() {
- final long[] original = new long[]{1L, 2L};
+ final long[] original = {1L, 2L};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyLongEmptyArray() {
- final long[] empty = new long[]{};
+ final long[] empty = {};
final long[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_LONG_ARRAY, result);
assertNotSame(empty, result);
@@ -2235,13 +2235,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyLongObject() {
- @SuppressWarnings("boxing") final Long[] original = new Long[]{1L, 2L};
+ @SuppressWarnings("boxing") final Long[] original = {1L, 2L};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyLongObjectEmptyArray() {
- final Long[] empty = new Long[]{};
+ final Long[] empty = {};
final Long[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_LONG_OBJECT_ARRAY, result);
assertNotSame(empty, result);
@@ -2254,13 +2254,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyObject() {
- final Object[] original = new Object[]{Boolean.TRUE, Boolean.FALSE};
+ final Object[] original = {Boolean.TRUE, Boolean.FALSE};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyObjectEmptyArray() {
- final Object[] empty = new Object[]{};
+ final Object[] empty = {};
final Object[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_OBJECT_ARRAY, result);
assertNotSame(empty, result);
@@ -2273,13 +2273,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyShort() {
- final short[] original = new short[]{1, 2};
+ final short[] original = {1, 2};
assertEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyShortEmptyArray() {
- final short[] empty = new short[]{};
+ final short[] empty = {};
final short[] result = ArrayUtils.nullToEmpty(empty);
assertEquals(ArrayUtils.EMPTY_SHORT_ARRAY, result);
assertNotSame(empty, result);
@@ -2292,13 +2292,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyShortObject() {
- @SuppressWarnings("boxing") final Short[] original = new Short[]{1, 2};
+ @SuppressWarnings("boxing") final Short[] original = {1, 2};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyShortObjectEmptyArray() {
- final Short[] empty = new Short[]{};
+ final Short[] empty = {};
final Short[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_SHORT_OBJECT_ARRAY, result);
assertNotSame(empty, result);
@@ -2311,13 +2311,13 @@ public class ArrayUtilsTest {
@Test
public void testNullToEmptyString() {
- final String[] original = new String[]{"abc", "def"};
+ final String[] original = {"abc", "def"};
assertArrayEquals(original, ArrayUtils.nullToEmpty(original));
}
@Test
public void testNullToEmptyStringEmptyArray() {
- final String[] empty = new String[]{};
+ final String[] empty = {};
final String[] result = ArrayUtils.nullToEmpty(empty);
assertArrayEquals(ArrayUtils.EMPTY_STRING_ARRAY, result);
assertNotSame(empty, result);
@@ -2332,10 +2332,10 @@ public class ArrayUtilsTest {
public void testReverse() {
final StringBuffer str1 = new StringBuffer("pick");
final String str2 = "a";
- final String[] str3 = new String[]{"stick"};
+ final String[] str3 = {"stick"};
final String str4 = "up";
- Object[] array = new Object[]{str1, str2, str3};
+ Object[] array = {str1, str2, str3};
ArrayUtils.reverse(array);
assertEquals(array[0], str3);
assertEquals(array[1], str2);
@@ -2355,7 +2355,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseBoolean() {
- boolean[] array = new boolean[]{false, false, true};
+ boolean[] array = {false, false, true};
ArrayUtils.reverse(array);
assertTrue(array[0]);
assertFalse(array[1]);
@@ -2368,7 +2368,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseBooleanRange() {
- boolean[] array = new boolean[]{false, false, true};
+ boolean[] array = {false, false, true};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertTrue(array[0]);
@@ -2400,7 +2400,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseByte() {
- byte[] array = new byte[]{2, 3, 4};
+ byte[] array = {2, 3, 4};
ArrayUtils.reverse(array);
assertEquals(array[0], 4);
assertEquals(array[1], 3);
@@ -2413,7 +2413,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseByteRange() {
- byte[] array = new byte[]{1, 2, 3};
+ byte[] array = {1, 2, 3};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals(3, array[0]);
@@ -2445,7 +2445,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseChar() {
- char[] array = new char[]{'a', 'f', 'C'};
+ char[] array = {'a', 'f', 'C'};
ArrayUtils.reverse(array);
assertEquals(array[0], 'C');
assertEquals(array[1], 'f');
@@ -2458,7 +2458,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseCharRange() {
- char[] array = new char[]{1, 2, 3};
+ char[] array = {1, 2, 3};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals(3, array[0]);
@@ -2490,7 +2490,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseDouble() {
- double[] array = new double[]{0.3d, 0.4d, 0.5d};
+ double[] array = {0.3d, 0.4d, 0.5d};
ArrayUtils.reverse(array);
assertEquals(0.5d, array[0]);
assertEquals(0.4d, array[1]);
@@ -2503,7 +2503,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseDoubleRange() {
- double[] array = new double[]{1, 2, 3};
+ double[] array = {1, 2, 3};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals(3, array[0]);
@@ -2535,7 +2535,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseFloat() {
- float[] array = new float[]{0.3f, 0.4f, 0.5f};
+ float[] array = {0.3f, 0.4f, 0.5f};
ArrayUtils.reverse(array);
assertEquals(0.5f, array[0]);
assertEquals(0.4f, array[1]);
@@ -2548,7 +2548,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseFloatRange() {
- float[] array = new float[]{1, 2, 3};
+ float[] array = {1, 2, 3};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals(3, array[0]);
@@ -2580,7 +2580,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseInt() {
- int[] array = new int[]{1, 2, 3};
+ int[] array = {1, 2, 3};
ArrayUtils.reverse(array);
assertEquals(array[0], 3);
assertEquals(array[1], 2);
@@ -2593,7 +2593,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseIntRange() {
- int[] array = new int[]{1, 2, 3};
+ int[] array = {1, 2, 3};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals(3, array[0]);
@@ -2625,7 +2625,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseLong() {
- long[] array = new long[]{1L, 2L, 3L};
+ long[] array = {1L, 2L, 3L};
ArrayUtils.reverse(array);
assertEquals(array[0], 3L);
assertEquals(array[1], 2L);
@@ -2638,7 +2638,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseLongRange() {
- long[] array = new long[]{1, 2, 3};
+ long[] array = {1, 2, 3};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals(3, array[0]);
@@ -2670,7 +2670,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseObjectRange() {
- String[] array = new String[]{"1", "2", "3"};
+ String[] array = {"1", "2", "3"};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals("3", array[0]);
@@ -2702,7 +2702,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseShort() {
- short[] array = new short[]{1, 2, 3};
+ short[] array = {1, 2, 3};
ArrayUtils.reverse(array);
assertEquals(array[0], 3);
assertEquals(array[1], 2);
@@ -2715,7 +2715,7 @@ public class ArrayUtilsTest {
@Test
public void testReverseShortRange() {
- short[] array = new short[]{1, 2, 3};
+ short[] array = {1, 2, 3};
// The whole array
ArrayUtils.reverse(array, 0, 3);
assertEquals(3, array[0]);
@@ -2748,9 +2748,9 @@ public class ArrayUtilsTest {
@Test
public void testSameLength() {
final Object[] nullArray = null;
- final Object[] emptyArray = new Object[0];
- final Object[] oneArray = new Object[]{"pick"};
- final Object[] twoArray = new Object[]{"pick", "stick"};
+ final Object[] emptyArray = {};
+ final Object[] oneArray = {"pick"};
+ final Object[] twoArray = {"pick", "stick"};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
@@ -2776,41 +2776,41 @@ public class ArrayUtilsTest {
@Test
public void testSameLengthAll() {
final Object[] nullArrayObject = null;
- final Object[] emptyArrayObject = new Object[0];
- final Object[] oneArrayObject = new Object[]{"pick"};
- final Object[] twoArrayObject = new Object[]{"pick", "stick"};
+ final Object[] emptyArrayObject = {};
+ final Object[] oneArrayObject = {"pick"};
+ final Object[] twoArrayObject = {"pick", "stick"};
final boolean[] nullArrayBoolean = null;
- final boolean[] emptyArrayBoolean = new boolean[0];
- final boolean[] oneArrayBoolean = new boolean[]{true};
- final boolean[] twoArrayBoolean = new boolean[]{true, false};
+ final boolean[] emptyArrayBoolean = {};
+ final boolean[] oneArrayBoolean = {true};
+ final boolean[] twoArrayBoolean = {true, false};
final long[] nullArrayLong = null;
- final long[] emptyArrayLong = new long[0];
- final long[] oneArrayLong = new long[]{0L};
- final long[] twoArrayLong = new long[]{0L, 76L};
+ final long[] emptyArrayLong = {};
+ final long[] oneArrayLong = {0L};
+ final long[] twoArrayLong = {0L, 76L};
final int[] nullArrayInt = null;
- final int[] emptyArrayInt = new int[0];
- final int[] oneArrayInt = new int[]{4};
- final int[] twoArrayInt = new int[]{5, 7};
+ final int[] emptyArrayInt = {};
+ final int[] oneArrayInt = {4};
+ final int[] twoArrayInt = {5, 7};
final short[] nullArrayShort = null;
- final short[] emptyArrayShort = new short[0];
- final short[] oneArrayShort = new short[]{4};
- final short[] twoArrayShort = new short[]{6, 8};
+ final short[] emptyArrayShort = {};
+ final short[] oneArrayShort = {4};
+ final short[] twoArrayShort = {6, 8};
final char[] nullArrayChar = null;
- final char[] emptyArrayChar = new char[0];
- final char[] oneArrayChar = new char[]{'f'};
- final char[] twoArrayChar = new char[]{'d', 't'};
+ final char[] emptyArrayChar = {};
+ final char[] oneArrayChar = {'f'};
+ final char[] twoArrayChar = {'d', 't'};
final byte[] nullArrayByte = null;
- final byte[] emptyArrayByte = new byte[0];
- final byte[] oneArrayByte = new byte[]{3};
- final byte[] twoArrayByte = new byte[]{4, 6};
+ final byte[] emptyArrayByte = {};
+ final byte[] oneArrayByte = {3};
+ final byte[] twoArrayByte = {4, 6};
final double[] nullArrayDouble = null;
- final double[] emptyArrayDouble = new double[0];
- final double[] oneArrayDouble = new double[]{1.3d};
- final double[] twoArrayDouble = new double[]{4.5d, 6.3d};
+ final double[] emptyArrayDouble = {};
+ final double[] oneArrayDouble = {1.3d};
+ final double[] twoArrayDouble = {4.5d, 6.3d};
final float[] nullArrayFloat = null;
- final float[] emptyArrayFloat = new float[0];
- final float[] oneArrayFloat = new float[]{2.5f};
- final float[] twoArrayFloat = new float[]{6.4f, 5.8f};
+ final float[] emptyArrayFloat = {};
+ final float[] oneArrayFloat = {2.5f};
+ final float[] twoArrayFloat = {6.4f, 5.8f};
assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayObject));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayBoolean));
assertTrue(ArrayUtils.isSameLength(nullArrayObject, nullArrayLong));
@@ -4112,9 +4112,9 @@ public class ArrayUtilsTest {
@Test
public void testSameLengthBoolean() {
final boolean[] nullArray = null;
- final boolean[] emptyArray = new boolean[0];
- final boolean[] oneArray = new boolean[]{true};
- final boolean[] twoArray = new boolean[]{true, false};
+ final boolean[] emptyArray = {};
+ final boolean[] oneArray = {true};
+ final boolean[] twoArray = {true, false};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
@@ -4140,9 +4140,9 @@ public class ArrayUtilsTest {
@Test
public void testSameLengthByte() {
final byte[] nullArray = null;
- final byte[] emptyArray = new byte[0];
- final byte[] oneArray = new byte[]{3};
- final byte[] twoArray = new byte[]{4, 6};
+ final byte[] emptyArray = {};
+ final byte[] oneArray = {3};
+ final byte[] twoArray = {4, 6};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
@@ -4168,9 +4168,9 @@ public class ArrayUtilsTest {
@Test
public void testSameLengthChar() {
final char[] nullArray = null;
- final char[] emptyArray = new char[0];
- final char[] oneArray = new char[]{'f'};
- final char[] twoArray = new char[]{'d', 't'};
+ final char[] emptyArray = {};
+ final char[] oneArray = {'f'};
+ final char[] twoArray = {'d', 't'};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
@@ -4196,9 +4196,9 @@ public class ArrayUtilsTest {
@Test
public void testSameLengthDouble() {
final double[] nullArray = null;
- final double[] emptyArray = new double[0];
- final double[] oneArray = new double[]{1.3d};
- final double[] twoArray = new double[]{4.5d, 6.3d};
+ final double[] emptyArray = {};
+ final double[] oneArray = {1.3d};
+ final double[] twoArray = {4.5d, 6.3d};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
@@ -4224,9 +4224,9 @@ public class ArrayUtilsTest {
@Test
public void testSameLengthFloat() {
final float[] nullArray = null;
- final float[] emptyArray = new float[0];
- final float[] oneArray = new float[]{2.5f};
- final float[] twoArray = new float[]{6.4f, 5.8f};
+ final float[] emptyArray = {};
+ final float[] oneArray = {2.5f};
+ final float[] twoArray = {6.4f, 5.8f};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
@@ -4252,9 +4252,9 @@ public class ArrayUtilsTest {
@Test
public void testSameLengthInt() {
final int[] nullArray = null;
- final int[] emptyArray = new int[0];
- final int[] oneArray = new int[]{4};
- final int[] twoArray = new int[]{5, 7};
+ final int[] emptyArray = {};
+ final int[] oneArray = {4};
+ final int[] twoArray = {5, 7};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
@@ -4280,9 +4280,9 @@ public class ArrayUtilsTest {
@Test
public void testSameLengthLong() {
final long[] nullArray = null;
- final long[] emptyArray = new long[0];
- final long[] oneArray = new long[]{0L};
- final long[] twoArray = new long[]{0L, 76L};
+ final long[] emptyArray = {};
+ final long[] oneArray = {0L};
+ final long[] twoArray = {0L, 76L};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
@@ -4308,9 +4308,9 @@ public class ArrayUtilsTest {
@Test
public void testSameLengthShort() {
final short[] nullArray = null;
- final short[] emptyArray = new short[0];
- final short[] oneArray = new short[]{4};
- final short[] twoArray = new short[]{6, 8};
+ final short[] emptyArray = {};
+ final short[] oneArray = {4};
+ final short[] twoArray = {6, 8};
assertTrue(ArrayUtils.isSameLength(nullArray, nullArray));
assertTrue(ArrayUtils.isSameLength(nullArray, emptyArray));
@@ -4348,7 +4348,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftAllByte() {
- final byte[] array = new byte[]{1, 2, 3, 4};
+ final byte[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
@@ -4363,7 +4363,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftAllChar() {
- final char[] array = new char[]{1, 2, 3, 4};
+ final char[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
@@ -4378,7 +4378,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftAllDouble() {
- final double[] array = new double[]{1, 2, 3, 4};
+ final double[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
@@ -4393,7 +4393,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftAllFloat() {
- final float[] array = new float[]{1, 2, 3, 4};
+ final float[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
@@ -4408,7 +4408,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftAllInt() {
- final int[] array = new int[]{1, 2, 3, 4};
+ final int[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
@@ -4423,7 +4423,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftAllLong() {
- final long[] array = new long[]{1, 2, 3, 4};
+ final long[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
@@ -4438,7 +4438,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftAllObject() {
- final String[] array = new String[]{"1", "2", "3", "4"};
+ final String[] array = {"1", "2", "3", "4"};
ArrayUtils.shift(array, 4);
assertEquals("1", array[0]);
assertEquals("2", array[1]);
@@ -4453,7 +4453,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftAllShort() {
- final short[] array = new short[]{1, 2, 3, 4};
+ final short[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 4);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
@@ -4468,7 +4468,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftBoolean() {
- final boolean[] array = new boolean[]{true, true, false, false};
+ final boolean[] array = {true, true, false, false};
ArrayUtils.shift(array, 1);
assertFalse(array[0]);
@@ -4497,7 +4497,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftByte() {
- final byte[] array = new byte[]{1, 2, 3, 4};
+ final byte[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
@@ -4522,7 +4522,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftChar() {
- final char[] array = new char[]{1, 2, 3, 4};
+ final char[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
@@ -4547,7 +4547,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftDouble() {
- final double[] array = new double[]{1, 2, 3, 4};
+ final double[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
@@ -4572,7 +4572,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftFloat() {
- final float[] array = new float[]{1, 2, 3, 4};
+ final float[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
@@ -4598,7 +4598,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftInt() {
- final int[] array = new int[]{1, 2, 3, 4};
+ final int[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
@@ -4623,7 +4623,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftLong() {
- final long[] array = new long[]{1, 2, 3, 4};
+ final long[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
@@ -4704,7 +4704,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftObject() {
- final String[] array = new String[]{"1", "2", "3", "4"};
+ final String[] array = {"1", "2", "3", "4"};
ArrayUtils.shift(array, 1);
assertEquals("4", array[0]);
assertEquals("1", array[1]);
@@ -4729,7 +4729,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeByte() {
- final byte[] array = new byte[]{1, 2, 3, 4, 5};
+ final byte[] array = {1, 2, 3, 4, 5};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(1, array[0]);
assertEquals(3, array[1]);
@@ -4746,7 +4746,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeChar() {
- final char[] array = new char[]{1, 2, 3, 4, 5};
+ final char[] array = {1, 2, 3, 4, 5};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(1, array[0]);
assertEquals(3, array[1]);
@@ -4763,7 +4763,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeDouble() {
- final double[] array = new double[]{1, 2, 3, 4, 5};
+ final double[] array = {1, 2, 3, 4, 5};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(1, array[0]);
assertEquals(3, array[1]);
@@ -4780,7 +4780,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeFloat() {
- final float[] array = new float[]{1, 2, 3, 4, 5};
+ final float[] array = {1, 2, 3, 4, 5};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(1, array[0]);
assertEquals(3, array[1]);
@@ -4797,7 +4797,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeInt() {
- final int[] array = new int[]{1, 2, 3, 4, 5};
+ final int[] array = {1, 2, 3, 4, 5};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(1, array[0]);
assertEquals(3, array[1]);
@@ -4814,7 +4814,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeLong() {
- final long[] array = new long[]{1, 2, 3, 4, 5};
+ final long[] array = {1, 2, 3, 4, 5};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(1, array[0]);
assertEquals(3, array[1]);
@@ -4831,7 +4831,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeNoElemByte() {
- final byte[] array = new byte[]{1, 2, 3, 4};
+ final byte[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
@@ -4841,7 +4841,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeNoElemChar() {
- final char[] array = new char[]{1, 2, 3, 4};
+ final char[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
@@ -4851,7 +4851,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeNoElemDouble() {
- final double[] array = new double[]{1, 2, 3, 4};
+ final double[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
@@ -4861,7 +4861,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeNoElemFloat() {
- final float[] array = new float[]{1, 2, 3, 4};
+ final float[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
@@ -4871,7 +4871,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeNoElemInt() {
- final int[] array = new int[]{1, 2, 3, 4};
+ final int[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
@@ -4881,7 +4881,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeNoElemLong() {
- final long[] array = new long[]{1, 2, 3, 4};
+ final long[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
@@ -4891,7 +4891,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeNoElemObject() {
- final String[] array = new String[]{"1", "2", "3", "4"};
+ final String[] array = {"1", "2", "3", "4"};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals("1", array[0]);
assertEquals("2", array[1]);
@@ -4901,7 +4901,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeNoElemShort() {
- final short[] array = new short[]{1, 2, 3, 4};
+ final short[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1, 1, 1);
assertEquals(1, array[0]);
assertEquals(2, array[1]);
@@ -4968,7 +4968,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeObject() {
- final String[] array = new String[]{"1", "2", "3", "4", "5"};
+ final String[] array = {"1", "2", "3", "4", "5"};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals("1", array[0]);
assertEquals("3", array[1]);
@@ -4985,7 +4985,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftRangeShort() {
- final short[] array = new short[]{1, 2, 3, 4, 5};
+ final short[] array = {1, 2, 3, 4, 5};
ArrayUtils.shift(array, 1, 3, 1);
assertEquals(1, array[0]);
assertEquals(3, array[1]);
@@ -5002,7 +5002,7 @@ public class ArrayUtilsTest {
@Test
public void testShiftShort() {
- short[] array = new short[]{1, 2, 3, 4};
+ short[] array = {1, 2, 3, 4};
ArrayUtils.shift(array, 1);
assertEquals(4, array[0]);
assertEquals(1, array[1]);
@@ -5034,7 +5034,7 @@ public class ArrayUtilsTest {
@Test
public void testShuffle() {
- final String[] array1 = new String[]{"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};
+ final String[] array1 = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"};
final String[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, new Random(SEED));
@@ -5046,7 +5046,7 @@ public class ArrayUtilsTest {
@Test
public void testShuffleBoolean() {
- final boolean[] array1 = new boolean[]{true, false, true, true, false, false, true, false, false, true};
+ final boolean[] array1 = {true, false, true, true, false, false, true, false, false, true};
final boolean[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, new Random(SEED));
@@ -5056,7 +5056,7 @@ public class ArrayUtilsTest {
@Test
public void testShuffleByte() {
- final byte[] array1 = new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ final byte[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
final byte[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, new Random(SEED));
@@ -5068,7 +5068,7 @@ public class ArrayUtilsTest {
@Test
public void testShuffleChar() {
- final char[] array1 = new char[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ final char[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
final char[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, new Random(SEED));
@@ -5080,7 +5080,7 @@ public class ArrayUtilsTest {
@Test
public void testShuffleDouble() {
- final double[] array1 = new double[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ final double[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
final double[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, new Random(SEED));
@@ -5092,7 +5092,7 @@ public class ArrayUtilsTest {
@Test
public void testShuffleFloat() {
- final float[] array1 = new float[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ final float[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
final float[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, new Random(SEED));
@@ -5104,7 +5104,7 @@ public class ArrayUtilsTest {
@Test
public void testShuffleInt() {
- final int[] array1 = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ final int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
final int[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, new Random(SEED));
@@ -5116,7 +5116,7 @@ public class ArrayUtilsTest {
@Test
public void testShuffleLong() {
- final long[] array1 = new long[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ final long[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
final long[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, new Random(SEED));
@@ -5128,7 +5128,7 @@ public class ArrayUtilsTest {
@Test
public void testShuffleShort() {
- final short[] array1 = new short[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+ final short[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
final short[] array2 = ArrayUtils.clone(array1);
ArrayUtils.shuffle(array1, new Random(SEED));
@@ -5524,7 +5524,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapBoolean() {
- final boolean[] array = new boolean[]{true, false, false};
+ final boolean[] array = {true, false, false};
ArrayUtils.swap(array, 0, 2);
assertFalse(array[0]);
assertFalse(array[1]);
@@ -5533,7 +5533,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapBooleanRange() {
- boolean[] array = new boolean[]{false, false, true, true};
+ boolean[] array = {false, false, true, true};
ArrayUtils.swap(array, 0, 2, 2);
assertTrue(array[0]);
assertTrue(array[1]);
@@ -5573,7 +5573,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapByte() {
- final byte[] array = new byte[]{1, 2, 3};
+ final byte[] array = {1, 2, 3};
ArrayUtils.swap(array, 0, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
@@ -5582,7 +5582,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapByteRange() {
- byte[] array = new byte[]{1, 2, 3, 4};
+ byte[] array = {1, 2, 3, 4};
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
@@ -5622,7 +5622,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapChar() {
- char[] array = new char[]{1, 2, 3};
+ char[] array = {1, 2, 3};
ArrayUtils.swap(array, 0, 2);
assertArrayEquals(new char[]{3, 2, 1}, array);
@@ -5637,7 +5637,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapCharRange() {
- char[] array = new char[]{1, 2, 3, 4};
+ char[] array = {1, 2, 3, 4};
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
@@ -5677,7 +5677,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapDouble() {
- final double[] array = new double[]{1, 2, 3};
+ final double[] array = {1, 2, 3};
ArrayUtils.swap(array, 0, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
@@ -5686,7 +5686,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapDoubleRange() {
- double[] array = new double[]{1, 2, 3, 4};
+ double[] array = {1, 2, 3, 4};
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
@@ -5726,70 +5726,70 @@ public class ArrayUtilsTest {
@Test
public void testSwapEmptyBooleanArray() {
- final boolean[] array = new boolean[0];
+ final boolean[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
public void testSwapEmptyByteArray() {
- final byte[] array = new byte[0];
+ final byte[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
public void testSwapEmptyCharArray() {
- final char[] array = new char[0];
+ final char[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
public void testSwapEmptyDoubleArray() {
- final double[] array = new double[0];
+ final double[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
public void testSwapEmptyFloatArray() {
- final float[] array = new float[0];
+ final float[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
public void testSwapEmptyIntArray() {
- final int[] array = new int[0];
+ final int[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
public void testSwapEmptyLongArray() {
- final long[] array = new long[0];
+ final long[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
public void testSwapEmptyObjectArray() {
- final String[] array = new String[0];
+ final String[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
public void testSwapEmptyShortArray() {
- final short[] array = new short[0];
+ final short[] array = {};
ArrayUtils.swap(array, 0, 2);
assertEquals(0, array.length);
}
@Test
public void testSwapFloat() {
- final float[] array = new float[]{1, 2, 3};
+ final float[] array = {1, 2, 3};
ArrayUtils.swap(array, 0, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
@@ -5798,7 +5798,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapFloatRange() {
- float[] array = new float[]{1, 2, 3, 4};
+ float[] array = {1, 2, 3, 4};
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
@@ -5838,7 +5838,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapInt() {
- final int[] array = new int[]{1, 2, 3};
+ final int[] array = {1, 2, 3};
ArrayUtils.swap(array, 0, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
@@ -5859,7 +5859,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapIntRange() {
- int[] array = new int[]{1, 2, 3, 4};
+ int[] array = {1, 2, 3, 4};
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
@@ -5899,7 +5899,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapLong() {
- final long[] array = new long[]{1, 2, 3};
+ final long[] array = {1, 2, 3};
ArrayUtils.swap(array, 0, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
@@ -5908,7 +5908,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapLongRange() {
- long[] array = new long[]{1, 2, 3, 4};
+ long[] array = {1, 2, 3, 4};
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
@@ -6011,7 +6011,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapObject() {
- final String[] array = new String[]{"1", "2", "3"};
+ final String[] array = {"1", "2", "3"};
ArrayUtils.swap(array, 0, 2);
assertEquals("3", array[0]);
assertEquals("2", array[1]);
@@ -6020,7 +6020,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapObjectRange() {
- String[] array = new String[]{"1", "2", "3", "4"};
+ String[] array = {"1", "2", "3", "4"};
ArrayUtils.swap(array, 0, 2, 2);
assertEquals("3", array[0]);
assertEquals("4", array[1]);
@@ -6061,7 +6061,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapShort() {
- final short[] array = new short[]{1, 2, 3};
+ final short[] array = {1, 2, 3};
ArrayUtils.swap(array, 0, 2);
assertEquals(3, array[0]);
assertEquals(2, array[1]);
@@ -6070,7 +6070,7 @@ public class ArrayUtilsTest {
@Test
public void testSwapShortRange() {
- short[] array = new short[]{1, 2, 3, 4};
+ short[] array = {1, 2, 3, 4};
ArrayUtils.swap(array, 0, 2, 2);
assertEquals(3, array[0]);
assertEquals(4, array[1]);
@@ -6539,7 +6539,7 @@ public class ArrayUtilsTest {
assertArrayEquals(new String[0], ArrayUtils.toStringArray(new Object[0]));
- final Object[] array = new Object[]{1, 2, 3, "array", "test"};
+ final Object[] array = {1, 2, 3, "array", "test"};
assertArrayEquals(new String[]{"1", "2", "3", "array", "test"}, ArrayUtils.toStringArray(array));
assertThrows(NullPointerException.class, () -> ArrayUtils.toStringArray(new Object[]{null}));
@@ -6551,7 +6551,7 @@ public class ArrayUtilsTest {
assertArrayEquals(new String[0], ArrayUtils.toStringArray(new Object[0], ""));
- final Object[] array = new Object[]{1, null, "test"};
+ final Object[] array = {1, null, "test"};
assertArrayEquals(new String[]{"1", "valueForNullElements", "test"},
ArrayUtils.toStringArray(array, "valueForNullElements"));
}
diff --git a/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java b/src/test/java/org/apache/commons/lang3/BooleanUtilsTest.java
index 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 @@ public class BooleanUtilsTest {
@Test
public void test_booleanValues() {
- final Boolean[] expected = new Boolean[] {false, true};
+ final Boolean[] expected = {false, true};
assertArrayEquals(sort(expected), BooleanUtils.booleanValues());
}
diff --git a/src/test/java/org/apache/commons/lang3/ConversionTest.java b/src/test/java/org/apache/commons/lang3/ConversionTest.java
index 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 @@ public class ConversionTest {
*/
@Test
public void testBinaryToHexDigit_2args() {
- final boolean[] shortArray = new boolean[]{false, true, true};
+ final boolean[] shortArray = {false, true, true};
assertEquals('6', Conversion.binaryToHexDigit(shortArray, 0));
assertEquals('3', Conversion.binaryToHexDigit(shortArray, 1));
assertEquals('1', Conversion.binaryToHexDigit(shortArray, 2));
- final boolean[] longArray = new boolean[]{true, false, true, false, false, true, true};
+ final boolean[] longArray = {true, false, true, false, false, true, true};
assertEquals('5', Conversion.binaryToHexDigit(longArray, 0));
assertEquals('2', Conversion.binaryToHexDigit(longArray, 1));
assertEquals('9', Conversion.binaryToHexDigit(longArray, 2));
@@ -295,9 +295,9 @@ public class ConversionTest {
// assertEquals('6', Conversion.BinaryToHexDigitMsb0(shortArray, 0));
// assertEquals('3', Conversion.BinaryToHexDigitMsb0(shortArray, 1));
// assertEquals('1', Conversion.BinaryToHexDigitMsb0(shortArray, 2));
- final boolean[] shortArray = new boolean[]{true, true, false, true};
+ final boolean[] shortArray = {true, true, false, true};
assertEquals('d', Conversion.binaryToHexDigitMsb0_4bits(shortArray, 0));
- final boolean[] longArray = new boolean[]{true, false, true, false, false, true, true};
+ final boolean[] longArray = {true, false, true, false, false, true, true};
assertEquals('a', Conversion.binaryToHexDigitMsb0_4bits(longArray, 0));
assertEquals('4', Conversion.binaryToHexDigitMsb0_4bits(longArray, 1));
assertEquals('9', Conversion.binaryToHexDigitMsb0_4bits(longArray, 2));
@@ -305,7 +305,7 @@ public class ConversionTest {
// assertEquals('6', Conversion.BinaryToHexDigitMsb0(longArray, 4));
// assertEquals('3', Conversion.BinaryToHexDigitMsb0(longArray, 5));
// assertEquals('1', Conversion.BinaryToHexDigitMsb0(longArray, 6));
- final boolean[] maxLengthArray = new boolean[]{
+ final boolean[] maxLengthArray = {
true, false, true, false, false, true, true, true};
assertEquals('a', Conversion.binaryToHexDigitMsb0_4bits(maxLengthArray, 0));
assertEquals('4', Conversion.binaryToHexDigitMsb0_4bits(maxLengthArray, 1));
@@ -315,7 +315,7 @@ public class ConversionTest {
// assertEquals('7', Conversion.BinaryToHexDigitMsb0(longArray, 5));
// assertEquals('3', Conversion.BinaryToHexDigitMsb0(longArray, 6));
// assertEquals('1', Conversion.BinaryToHexDigitMsb0(longArray, 7));
- final boolean[] javaDocCheck = new boolean[]{
+ final boolean[] javaDocCheck = {
true, false, false, true, true, false, true, false};
assertEquals('d', Conversion.binaryToHexDigitMsb0_4bits(javaDocCheck, 3));
@@ -377,11 +377,11 @@ public class ConversionTest {
true, false, false, false, false, false, false, false, false, false, false,
true, false, true, false, false}, 2));
- final boolean[] shortArray = new boolean[]{true, true, false};
+ final boolean[] shortArray = {true, true, false};
assertEquals('6', Conversion.binaryBeMsb0ToHexDigit(shortArray, 0));
assertEquals('3', Conversion.binaryBeMsb0ToHexDigit(shortArray, 1));
assertEquals('1', Conversion.binaryBeMsb0ToHexDigit(shortArray, 2));
- final boolean[] shortArray2 = new boolean[]{true, true, true, false, false, true, false, true};
+ final boolean[] shortArray2 = {true, true, true, false, false, true, false, true};
assertEquals('5', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 0));
assertEquals('2', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 1));
assertEquals('9', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 2));
@@ -390,7 +390,7 @@ public class ConversionTest {
assertEquals('7', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 5));
assertEquals('3', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 6));
assertEquals('1', Conversion.binaryBeMsb0ToHexDigit(shortArray2, 7));
- final boolean[] multiBytesArray = new boolean[]{
+ final boolean[] multiBytesArray = {
true, true, false, false, true, false, true, false, true, true, true, false, false,
true, false, true};
assertEquals('5', Conversion.binaryBeMsb0ToHexDigit(multiBytesArray, 0));
@@ -479,7 +479,7 @@ public class ConversionTest {
*/
@Test
public void testIntArrayToLong() {
- final int[] src = new int[]{0xCDF1F0C1, 0x0F123456, 0x78000000};
+ final int[] src = {0xCDF1F0C1, 0x0F123456, 0x78000000};
assertEquals(0x0000000000000000L, Conversion.intArrayToLong(src, 0, 0L, 0, 0));
assertEquals(0x0000000000000000L, Conversion.intArrayToLong(src, 1, 0L, 0, 0));
assertEquals(0x00000000CDF1F0C1L, Conversion.intArrayToLong(src, 0, 0L, 0, 1));
@@ -497,7 +497,7 @@ public class ConversionTest {
*/
@Test
public void testShortArrayToLong() {
- final short[] src = new short[]{
+ final short[] src = {
(short) 0xCDF1, (short) 0xF0C1, (short) 0x0F12, (short) 0x3456, (short) 0x7800};
assertEquals(0x0000000000000000L, Conversion.shortArrayToLong(src, 0, 0L, 0, 0));
assertEquals(0x000000000000CDF1L, Conversion.shortArrayToLong(src, 0, 0L, 0, 1));
@@ -518,7 +518,7 @@ public class ConversionTest {
*/
@Test
public void testByteArrayToLong() {
- final byte[] src = new byte[]{
+ final byte[] src = {
(byte) 0xCD, (byte) 0xF1, (byte) 0xF0, (byte) 0xC1, (byte) 0x0F, (byte) 0x12, (byte) 0x34,
(byte) 0x56, (byte) 0x78};
assertEquals(0x0000000000000000L, Conversion.byteArrayToLong(src, 0, 0L, 0, 0));
@@ -538,7 +538,7 @@ public class ConversionTest {
*/
@Test
public void testShortArrayToInt() {
- final short[] src = new short[]{
+ final short[] src = {
(short) 0xCDF1, (short) 0xF0C1, (short) 0x0F12, (short) 0x3456, (short) 0x7800};
assertEquals(0x00000000, Conversion.shortArrayToInt(src, 0, 0, 0, 0));
assertEquals(0x0000CDF1, Conversion.shortArrayToInt(src, 0, 0, 0, 1));
@@ -554,7 +554,7 @@ public class ConversionTest {
*/
@Test
public void testByteArrayToInt() {
- final byte[] src = new byte[]{
+ final byte[] src = {
(byte) 0xCD, (byte) 0xF1, (byte) 0xF0, (byte) 0xC1, (byte) 0x0F, (byte) 0x12, (byte) 0x34,
(byte) 0x56, (byte) 0x78};
assertEquals(0x00000000, Conversion.byteArrayToInt(src, 0, 0, 0, 0));
@@ -571,7 +571,7 @@ public class ConversionTest {
*/
@Test
public void testByteArrayToShort() {
- final byte[] src = new byte[]{
+ final byte[] src = {
(byte) 0xCD, (byte) 0xF1, (byte) 0xF0, (byte) 0xC1, (byte) 0x0F, (byte) 0x12, (byte) 0x34,
(byte) 0x56, (byte) 0x78};
assertEquals((short) 0x0000, Conversion.byteArrayToShort(src, 0, (short) 0, 0, 0));
@@ -647,7 +647,7 @@ public class ConversionTest {
*/
@Test
public void testBinaryToLong() {
- final boolean[] src = new boolean[]{
+ final boolean[] src = {
false, false, true, true, true, false, true, true, true, true, true, true, true,
false, false, false, true, true, true, true, false, false, false, false, false,
false, true, true, true, false, false, false, false, false, false, false, true,
@@ -671,7 +671,7 @@ public class ConversionTest {
*/
@Test
public void testBinaryToInt() {
- final boolean[] src = new boolean[]{
+ final boolean[] src = {
false, false, true, true, true, false, true, true, true, true, true, true, true,
false, false, false, true, true, true, true, false, false, false, false, false,
false, true, true, true, false, false, false, false, false, false, false, true,
@@ -692,7 +692,7 @@ public class ConversionTest {
*/
@Test
public void testBinaryToShort() {
- final boolean[] src = new boolean[]{
+ final boolean[] src = {
false, false, true, true, true, false, true, true, true, true, true, true, true,
false, false, false, true, true, true, true, false, false, false, false, false,
false, true, true, true, false, false, false, false, false, false, false, true,
@@ -715,7 +715,7 @@ public class ConversionTest {
*/
@Test
public void testBinaryToByte() {
- final boolean[] src = new boolean[]{
+ final boolean[] src = {
false, false, true, true, true, false, true, true, true, true, true, true, true,
false, false, false, true, true, true, true, false, false, false, false, false,
false, true, true, true, false, false, false, false, false, false, false, true,
diff --git a/src/test/java/org/apache/commons/lang3/ObjectUtilsTest.java b/src/test/java/org/apache/commons/lang3/ObjectUtilsTest.java
index 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 @@ public class ObjectUtilsTest {
}
private static final String FOO = "foo";
private static final String BAR = "bar";
- private static final String[] NON_EMPTY_ARRAY = new String[] { FOO, BAR, };
+ private static final String[] NON_EMPTY_ARRAY = { FOO, BAR, };
private static final List<String> NON_EMPTY_LIST = Arrays.asList(NON_EMPTY_ARRAY);
@@ -460,7 +460,7 @@ public class ObjectUtilsTest {
@Test
public void testHashCodeMulti_multiple_emptyArray() {
- final Object[] array = new Object[0];
+ final Object[] array = {};
assertEquals(1, ObjectUtils.hashCodeMulti(array));
}
diff --git a/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java b/src/test/java/org/apache/commons/lang3/RandomStringUtilsTest.java
index 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 @@ public class RandomStringUtilsTest {
@Test
public void testExceptions() {
- final char[] DUMMY = new char[]{'a'}; // valid char array
+ final char[] DUMMY = {'a'}; // valid char array
assertThrows(IllegalArgumentException.class, () -> RandomStringUtils.random(-1));
assertThrows(IllegalArgumentException.class, () -> RandomStringUtils.random(-1, true, true));
assertThrows(IllegalArgumentException.class, () -> RandomStringUtils.random(-1, DUMMY));
diff --git a/src/test/java/org/apache/commons/lang3/StringEscapeUtilsTest.java b/src/test/java/org/apache/commons/lang3/StringEscapeUtilsTest.java
index 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 @@ public class StringEscapeUtilsTest {
// COUNTING ROD UNIT DIGIT THREE
// in Unicode
// codepoint: U+1D362
- final byte[] data = new byte[] { (byte) 0xF0, (byte) 0x9D, (byte) 0x8D, (byte) 0xA2 };
+ final byte[] data = { (byte) 0xF0, (byte) 0x9D, (byte) 0x8D, (byte) 0xA2 };
final String original = new String(data, StandardCharsets.UTF_8);
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java
index 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 @@ public class StringUtilsContainsTest {
final char[] chars1= {'b'};
final char[] chars2= {'.'};
final char[] chars3= {'c', 'd'};
- final char[] emptyChars = new char[0];
+ final char[] emptyChars = {};
assertTrue(StringUtils.containsNone(null, (char[]) null));
assertTrue(StringUtils.containsNone("", (char[]) null));
assertTrue(StringUtils.containsNone(null, emptyChars));
@@ -429,7 +429,7 @@ public class StringUtilsContainsTest {
final char[] chars1= {'b'};
final char[] chars2= {'a'};
final char[] chars3= {'a', 'b'};
- final char[] emptyChars = new char[0];
+ final char[] emptyChars = {};
assertFalse(StringUtils.containsOnly(null, (char[]) null));
assertFalse(StringUtils.containsOnly("", (char[]) null));
assertFalse(StringUtils.containsOnly(null, emptyChars));
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java
index 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 @@ public class StringUtilsEqualsIndexOfTest {
private static final String FOOBAR = "foobar";
- private static final String[] FOOBAR_SUB_ARRAY = new String[] {"ob", "ba"};
+ private static final String[] FOOBAR_SUB_ARRAY = {"ob", "ba"};
// The purpose of this class is to test StringUtils#equals(CharSequence, CharSequence)
// with a CharSequence implementation whose equals(Object) override requires that the
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsTest.java
index 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 @@ public class StringUtilsTest {
@Disabled
@Test
public void testLang1593() {
- final int[] arr = new int[] {1, 2, 3, 4, 5, 6, 7};
+ final int[] arr = {1, 2, 3, 4, 5, 6, 7};
final String expected = StringUtils.join(arr, '-');
final String actual = StringUtils.join(arr, "-");
assertEquals(expected, actual);
@@ -2443,7 +2443,7 @@ public class StringUtilsTest {
// test whitespace
String input = "ab de fg";
- String[] expected = new String[]{"ab", "", "", "de", "fg"};
+ String[] expected = {"ab", "", "", "de", "fg"};
String[] actual = StringUtils.splitByWholeSeparatorPreserveAllTokens(input, null);
assertEquals(expected.length, actual.length);
@@ -2480,7 +2480,7 @@ public class StringUtilsTest {
// test whitespace
String input = "ab de fg";
- String[] expected = new String[]{"ab", "", "", "de", "fg"};
+ String[] expected = {"ab", "", "", "de", "fg"};
String[] actual = StringUtils.splitByWholeSeparatorPreserveAllTokens(input, null, -1);
assertEquals(expected.length, actual.length);
@@ -3340,13 +3340,13 @@ public class StringUtilsTest {
@Test
public void testGeorgianSample() {
- final char[] arrayI = new char[]{
+ final char[] arrayI = {
//Latin Small Letter dotless I
(char) 0x0131,
//Greek Capital Letter Theta
(char) 0x03F4
};
- final char[] arrayJ = new char[]{
+ final char[] arrayJ = {
//Latin Capital Letter I with dot above
(char) 0x0130,
//Greek Theta Symbol
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java
index 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 @@ public class StringUtilsTrimStripTest {
@Test
public void testStripAll() {
// test stripAll method, merely an array version of the above strip
- final String[] empty = new String[0];
- final String[] fooSpace = new String[] { " "+FOO+" ", " "+FOO, FOO+" " };
- final String[] fooDots = new String[] { ".."+FOO+"..", ".."+FOO, FOO+".." };
- final String[] foo = new String[] { FOO, FOO, FOO };
+ final String[] empty = {};
+ final String[] fooSpace = { " "+FOO+" ", " "+FOO, FOO+" " };
+ final String[] fooDots = { ".."+FOO+"..", ".."+FOO, FOO+".." };
+ final String[] foo = { FOO, FOO, FOO };
assertNull(StringUtils.stripAll((String[]) null));
// Additional varargs tests
diff --git a/src/test/java/org/apache/commons/lang3/ValidateTest.java b/src/test/java/org/apache/commons/lang3/ValidateTest.java
index 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 @@ class ValidateTest {
@Test
void shouldReturnTheSameInstance() {
- final String[] array = new String[]{"hi"};
+ final String[] array = {"hi"};
final String[] result = Validate.notEmpty(array);
assertSame(array, result);
@@ -243,7 +243,7 @@ class ValidateTest {
@Test
void shouldReturnTheSameInstance() {
- final String[] array = new String[]{"hi"};
+ final String[] array = {"hi"};
final String[] result = Validate.notEmpty(array, "MSG");
assertSame(array, result);
diff --git a/src/test/java/org/apache/commons/lang3/builder/CompareToBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/CompareToBuilderTest.java
index 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 @@ public class CompareToBuilderTest {
@Test
public void testReflectionHierarchyCompareExcludeFields() {
- final String[] excludeFields = new String[] { "b" };
+ final String[] excludeFields = { "b" };
testReflectionHierarchyCompare(true, excludeFields);
TestSubObject x;
diff --git a/src/test/java/org/apache/commons/lang3/builder/DefaultToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/DefaultToStringStyleTest.java
index 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 @@ public class DefaultToStringStyleTest {
@Test
public void testObjectArray() {
- Object[] array = new Object[] {null, base, new int[] {3, 6}};
+ Object[] array = {null, base, new int[] {3, 6}};
assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -134,7 +134,7 @@ public class DefaultToStringStyleTest {
@Test
public void testLongArray() {
- long[] array = new long[] {1, 2, -3, 4};
+ long[] array = {1, 2, -3, 4};
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -144,7 +144,7 @@ public class DefaultToStringStyleTest {
@Test
public void testLongArrayArray() {
- long[][] array = new long[][] {{1, 2}, null, {5}};
+ long[][] array = {{1, 2}, null, {5}};
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
diff --git a/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/EqualsBuilderTest.java
index 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 @@ public class EqualsBuilderTest {
assertFalse(new EqualsBuilder().append(array1, array2).isEquals());
// compare 1 dim to 2.
- final boolean[] array3 = new boolean[]{true, true};
+ final boolean[] array3 = {true, true};
assertFalse(new EqualsBuilder().append(array1, array3).isEquals());
assertFalse(new EqualsBuilder().append(array3, array1).isEquals());
assertFalse(new EqualsBuilder().append(array2, array3).isEquals());
@@ -1190,8 +1190,8 @@ public class EqualsBuilderTest {
*/
@Test
public void testUnrelatedClasses() {
- final Object[] x = new Object[]{new TestACanEqualB(1)};
- final Object[] y = new Object[]{new TestBCanEqualA(1)};
+ final Object[] x = {new TestACanEqualB(1)};
+ final Object[] y = {new TestBCanEqualA(1)};
// sanity checks:
assertArrayEquals(x, x);
@@ -1214,8 +1214,8 @@ public class EqualsBuilderTest {
*/
@Test
public void testNpeForNullElement() {
- final Object[] x1 = new Object[]{Integer.valueOf(1), null, Integer.valueOf(3)};
- final Object[] x2 = new Object[]{Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3)};
+ final Object[] x1 = {Integer.valueOf(1), null, Integer.valueOf(3)};
+ final Object[] x2 = {Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3)};
// causes an NPE in 2.0 according to:
// https://issues.apache.org/bugzilla/show_bug.cgi?id=33067
@@ -1317,9 +1317,9 @@ public class EqualsBuilderTest {
final TestObject one = new TestObject(1);
final TestObject two = new TestObject(2);
- final Object[] o1 = new Object[]{one};
- final Object[] o2 = new Object[]{two};
- final Object[] o3 = new Object[]{one};
+ final Object[] o1 = {one};
+ final Object[] o2 = {two};
+ final Object[] o3 = {one};
assertFalse(EqualsBuilder.reflectionEquals(o1, o2));
assertTrue(EqualsBuilder.reflectionEquals(o1, o1));
diff --git a/src/test/java/org/apache/commons/lang3/builder/JsonToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/JsonToStringStyleTest.java
index 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 @@ public class JsonToStringStyleTest {
@Test
public void testObjectArray() {
- final Object[] array = new Object[]{null, base, new int[]{3, 6}};
+ final Object[] array = {null, base, new int[]{3, 6}};
final ToStringBuilder toStringBuilder = new ToStringBuilder(base);
assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString());
@@ -325,7 +325,7 @@ public class JsonToStringStyleTest {
@Test
public void testLongArray() {
- final long[] array = new long[]{1, 2, -3, 4};
+ final long[] array = {1, 2, -3, 4};
final ToStringBuilder toStringBuilder = new ToStringBuilder(base);
assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString());
@@ -345,7 +345,7 @@ public class JsonToStringStyleTest {
@Test
public void testIntArray() {
- final int[] array = new int[]{1, 2, -3, 4};
+ final int[] array = {1, 2, -3, 4};
final ToStringBuilder toStringBuilder = new ToStringBuilder(base);
assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString());
@@ -365,7 +365,7 @@ public class JsonToStringStyleTest {
@Test
public void testByteArray() {
- final byte[] array = new byte[]{1, 2, -3, 4};
+ final byte[] array = {1, 2, -3, 4};
final ToStringBuilder toStringBuilder = new ToStringBuilder(base);
assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString());
@@ -385,7 +385,7 @@ public class JsonToStringStyleTest {
@Test
public void testShortArray() {
- final short[] array = new short[]{1, 2, -3, 4};
+ final short[] array = {1, 2, -3, 4};
final ToStringBuilder toStringBuilder = new ToStringBuilder(base);
assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString());
@@ -405,7 +405,7 @@ public class JsonToStringStyleTest {
@Test
public void testDoubleArray() {
- final double[] array = new double[]{1, 2, -3, 4};
+ final double[] array = {1, 2, -3, 4};
final ToStringBuilder toStringBuilder = new ToStringBuilder(base);
assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString());
@@ -425,7 +425,7 @@ public class JsonToStringStyleTest {
@Test
public void testFloatArray() {
- final float[] array = new float[]{1, 2, -3, 4};
+ final float[] array = {1, 2, -3, 4};
final ToStringBuilder toStringBuilder = new ToStringBuilder(base);
assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString());
@@ -445,7 +445,7 @@ public class JsonToStringStyleTest {
@Test
public void testCharArray() {
- final char[] array = new char[]{'1', '2', '3', '4'};
+ final char[] array = {'1', '2', '3', '4'};
final ToStringBuilder toStringBuilder = new ToStringBuilder(base);
assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString());
@@ -465,7 +465,7 @@ public class JsonToStringStyleTest {
@Test
public void testBooleanArray() {
- final boolean[] array = new boolean[]{true, false};
+ final boolean[] array = {true, false};
final ToStringBuilder toStringBuilder = new ToStringBuilder(base);
assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString());
@@ -485,7 +485,7 @@ public class JsonToStringStyleTest {
@Test
public void testLongArrayArray() {
- final long[][] array = new long[][]{{1, 2}, null, {5}};
+ final long[][] array = {{1, 2}, null, {5}};
final ToStringBuilder toStringBuilder = new ToStringBuilder(base);
assertThrows(UnsupportedOperationException.class, () -> toStringBuilder.append(array).toString());
diff --git a/src/test/java/org/apache/commons/lang3/builder/MultiLineToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/MultiLineToStringStyleTest.java
index 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 @@ public class MultiLineToStringStyleTest {
@Test
public void testObjectArray() {
- Object[] array = new Object[] {null, base, new int[] {3, 6}};
+ Object[] array = {null, base, new int[] {3, 6}};
assertEquals(baseStr + "[" + System.lineSeparator() + " {<null>,5,{3,6}}" + System.lineSeparator() + "]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[" + System.lineSeparator() + " {<null>,5,{3,6}}" + System.lineSeparator() + "]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -134,7 +134,7 @@ public class MultiLineToStringStyleTest {
@Test
public void testLongArray() {
- long[] array = new long[] {1, 2, -3, 4};
+ long[] array = {1, 2, -3, 4};
assertEquals(baseStr + "[" + System.lineSeparator() + " {1,2,-3,4}" + System.lineSeparator() + "]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[" + System.lineSeparator() + " {1,2,-3,4}" + System.lineSeparator() + "]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -144,7 +144,7 @@ public class MultiLineToStringStyleTest {
@Test
public void testLongArrayArray() {
- long[][] array = new long[][] {{1, 2}, null, {5}};
+ long[][] array = {{1, 2}, null, {5}};
assertEquals(baseStr + "[" + System.lineSeparator() + " {{1,2},<null>,{5}}" + System.lineSeparator() + "]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[" + System.lineSeparator() + " {{1,2},<null>,{5}}" + System.lineSeparator() + "]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
diff --git a/src/test/java/org/apache/commons/lang3/builder/NoClassNameToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/NoClassNameToStringStyleTest.java
index 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 @@ public class NoClassNameToStringStyleTest {
@Test
public void testObjectArray() {
- Object[] array = new Object[] {null, base, new int[] {3, 6}};
+ Object[] array = {null, base, new int[] {3, 6}};
assertEquals("[{<null>,5,{3,6}}]", new ToStringBuilder(base).append(array).toString());
assertEquals("[{<null>,5,{3,6}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -132,7 +132,7 @@ public class NoClassNameToStringStyleTest {
@Test
public void testLongArray() {
- long[] array = new long[] {1, 2, -3, 4};
+ long[] array = {1, 2, -3, 4};
assertEquals("[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
assertEquals("[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -142,7 +142,7 @@ public class NoClassNameToStringStyleTest {
@Test
public void testLongArrayArray() {
- long[][] array = new long[][] {{1, 2}, null, {5}};
+ long[][] array = {{1, 2}, null, {5}};
assertEquals("[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString());
assertEquals("[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
diff --git a/src/test/java/org/apache/commons/lang3/builder/NoFieldNamesToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/NoFieldNamesToStringStyleTest.java
index 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 @@ public class NoFieldNamesToStringStyleTest {
@Test
public void testObjectArray() {
- Object[] array = new Object[] {null, base, new int[] {3, 6}};
+ Object[] array = {null, base, new int[] {3, 6}};
assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -134,7 +134,7 @@ public class NoFieldNamesToStringStyleTest {
@Test
public void testLongArray() {
- long[] array = new long[] {1, 2, -3, 4};
+ long[] array = {1, 2, -3, 4};
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -144,7 +144,7 @@ public class NoFieldNamesToStringStyleTest {
@Test
public void testLongArrayArray() {
- long[][] array = new long[][] {{1, 2}, null, {5}};
+ long[][] array = {{1, 2}, null, {5}};
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
diff --git a/src/test/java/org/apache/commons/lang3/builder/RecursiveToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/RecursiveToStringStyleTest.java
index 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 @@ public class RecursiveToStringStyleTest {
@Test
public void testObjectArray() {
- Object[] array = new Object[] {null, base, new int[] {3, 6}};
+ Object[] array = {null, base, new int[] {3, 6}};
assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -114,7 +114,7 @@ public class RecursiveToStringStyleTest {
@Test
public void testLongArray() {
- long[] array = new long[] {1, 2, -3, 4};
+ long[] array = {1, 2, -3, 4};
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -124,7 +124,7 @@ public class RecursiveToStringStyleTest {
@Test
public void testLongArrayArray() {
- long[][] array = new long[][] {{1, 2}, null, {5}};
+ long[][] array = {{1, 2}, null, {5}};
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
diff --git a/src/test/java/org/apache/commons/lang3/builder/ShortPrefixToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/ShortPrefixToStringStyleTest.java
index 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 @@ public class ShortPrefixToStringStyleTest {
@Test
public void testObjectArray() {
- Object[] array = new Object[] {null, base, new int[] {3, 6}};
+ Object[] array = {null, base, new int[] {3, 6}};
assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -134,7 +134,7 @@ public class ShortPrefixToStringStyleTest {
@Test
public void testLongArray() {
- long[] array = new long[] {1, 2, -3, 4};
+ long[] array = {1, 2, -3, 4};
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -144,7 +144,7 @@ public class ShortPrefixToStringStyleTest {
@Test
public void testLongArrayArray() {
- long[][] array = new long[][] {{1, 2}, null, {5}};
+ long[][] array = {{1, 2}, null, {5}};
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
diff --git a/src/test/java/org/apache/commons/lang3/builder/SimpleToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/SimpleToStringStyleTest.java
index 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 @@ public class SimpleToStringStyleTest {
@Test
public void testObjectArray() {
- Object[] array = new Object[] {null, base, new int[] {3, 6}};
+ Object[] array = {null, base, new int[] {3, 6}};
assertEquals("{<null>,5,{3,6}}", new ToStringBuilder(base).append(array).toString());
assertEquals("{<null>,5,{3,6}}", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -132,7 +132,7 @@ public class SimpleToStringStyleTest {
@Test
public void testLongArray() {
- long[] array = new long[] {1, 2, -3, 4};
+ long[] array = {1, 2, -3, 4};
assertEquals("{1,2,-3,4}", new ToStringBuilder(base).append(array).toString());
assertEquals("{1,2,-3,4}", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -142,7 +142,7 @@ public class SimpleToStringStyleTest {
@Test
public void testLongArrayArray() {
- long[][] array = new long[][] {{1, 2}, null, {5}};
+ long[][] array = {{1, 2}, null, {5}};
assertEquals("{{1,2},<null>,{5}}", new ToStringBuilder(base).append(array).toString());
assertEquals("{{1,2},<null>,{5}}", new ToStringBuilder(base).append((Object) array).toString());
array = null;
diff --git a/src/test/java/org/apache/commons/lang3/builder/StandardToStringStyleTest.java b/src/test/java/org/apache/commons/lang3/builder/StandardToStringStyleTest.java
index 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 @@ public class StandardToStringStyleTest {
@Test
public void testObjectArray() {
- Object[] array = new Object[] {null, base, new int[] {3, 6}};
+ Object[] array = {null, base, new int[] {3, 6}};
assertEquals(baseStr + "[[%NULL%, 5, [3, 6]]]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[[%NULL%, 5, [3, 6]]]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -151,7 +151,7 @@ public class StandardToStringStyleTest {
@Test
public void testLongArray() {
- long[] array = new long[] {1, 2, -3, 4};
+ long[] array = {1, 2, -3, 4};
assertEquals(baseStr + "[[1, 2, -3, 4]]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[[1, 2, -3, 4]]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -161,7 +161,7 @@ public class StandardToStringStyleTest {
@Test
public void testLongArrayArray() {
- long[][] array = new long[][] {{1, 2}, null, {5}};
+ long[][] array = {{1, 2}, null, {5}};
assertEquals(baseStr + "[[[1, 2], %NULL%, [5]]]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[[[1, 2], %NULL%, [5]]]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
diff --git a/src/test/java/org/apache/commons/lang3/builder/ToStringBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/ToStringBuilderTest.java
index 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 @@ public class ToStringBuilderTest {
@Test
public void testReflectionObjectArray() {
- Object[] array = new Object[] { null, base, new int[] { 3, 6 } };
+ Object[] array = { null, base, new int[] { 3, 6 } };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{<null>,5,{3,6}}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -164,7 +164,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionLongArray() {
- long[] array = new long[] { 1, 2, -3, 4 };
+ long[] array = { 1, 2, -3, 4 };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -173,7 +173,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionIntArray() {
- int[] array = new int[] { 1, 2, -3, 4 };
+ int[] array = { 1, 2, -3, 4 };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -182,7 +182,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionShortArray() {
- short[] array = new short[] { 1, 2, -3, 4 };
+ short[] array = { 1, 2, -3, 4 };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -191,7 +191,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionyteArray() {
- byte[] array = new byte[] { 1, 2, -3, 4 };
+ byte[] array = { 1, 2, -3, 4 };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{1,2,-3,4}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -200,7 +200,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionCharArray() {
- char[] array = new char[] { 'A', '2', '_', 'D' };
+ char[] array = { 'A', '2', '_', 'D' };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{A,2,_,D}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -209,7 +209,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionDoubleArray() {
- double[] array = new double[] { 1.0, 2.9876, -3.00001, 4.3 };
+ double[] array = { 1.0, 2.9876, -3.00001, 4.3 };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{1.0,2.9876,-3.00001,4.3}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -218,7 +218,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionFloatArray() {
- float[] array = new float[] { 1.0f, 2.9876f, -3.00001f, 4.3f };
+ float[] array = { 1.0f, 2.9876f, -3.00001f, 4.3f };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{1.0,2.9876,-3.00001,4.3}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -227,7 +227,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionBooleanArray() {
- boolean[] array = new boolean[] { true, false, false };
+ boolean[] array = { true, false, false };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{true,false,false}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -238,7 +238,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionFloatArrayArray() {
- float[][] array = new float[][] { { 1.0f, 2.29686f }, null, { Float.NaN } };
+ float[][] array = { { 1.0f, 2.29686f }, null, { Float.NaN } };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{{1.0,2.29686},<null>,{NaN}}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -248,7 +248,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionLongArrayArray() {
- long[][] array = new long[][] { { 1, 2 }, null, { 5 } };
+ long[][] array = { { 1, 2 }, null, { 5 } };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{{1,2},<null>,{5}}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -257,7 +257,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionIntArrayArray() {
- int[][] array = new int[][] { { 1, 2 }, null, { 5 } };
+ int[][] array = { { 1, 2 }, null, { 5 } };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{{1,2},<null>,{5}}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -266,7 +266,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionhortArrayArray() {
- short[][] array = new short[][] { { 1, 2 }, null, { 5 } };
+ short[][] array = { { 1, 2 }, null, { 5 } };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{{1,2},<null>,{5}}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -275,7 +275,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionByteArrayArray() {
- byte[][] array = new byte[][] { { 1, 2 }, null, { 5 } };
+ byte[][] array = { { 1, 2 }, null, { 5 } };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{{1,2},<null>,{5}}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -284,7 +284,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionCharArrayArray() {
- char[][] array = new char[][] { { 'A', 'B' }, null, { 'p' } };
+ char[][] array = { { 'A', 'B' }, null, { 'p' } };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{{A,B},<null>,{p}}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -293,7 +293,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionDoubleArrayArray() {
- double[][] array = new double[][] { { 1.0, 2.29686 }, null, { Double.NaN } };
+ double[][] array = { { 1.0, 2.29686 }, null, { Double.NaN } };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{{1.0,2.29686},<null>,{NaN}}]", ToStringBuilder.reflectionToString(array));
array = null;
@@ -302,7 +302,7 @@ public class ToStringBuilderTest {
@Test
public void testReflectionBooleanArrayArray() {
- boolean[][] array = new boolean[][] { { true, false }, null, { false } };
+ boolean[][] array = { { true, false }, null, { false } };
final String baseString = this.toBaseString(array);
assertEquals(baseString + "[{{true,false},<null>,{false}}]", ToStringBuilder.reflectionToString(array));
assertEquals(baseString + "[{{true,false},<null>,{false}}]", ToStringBuilder.reflectionToString(array));
@@ -629,7 +629,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendBooleanArrayWithFieldName() {
- final boolean[] array = new boolean[] { true, false, false };
+ final boolean[] array = { true, false, false };
assertEquals(baseStr + "[flags={true,false,false}]",
new ToStringBuilder(base).append("flags", array).toString());
assertEquals(baseStr + "[flags=<null>]",
@@ -640,7 +640,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendBooleanArrayWithFieldNameAndFullDetatil() {
- final boolean[] array = new boolean[] { true, false, false };
+ final boolean[] array = { true, false, false };
assertEquals(baseStr + "[flags={true,false,false}]",
new ToStringBuilder(base).append("flags", array, true).toString());
assertEquals(baseStr + "[length=<size=3>]",
@@ -653,7 +653,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendCharArrayWithFieldName() {
- final char[] array = new char[] { 'A', '2', '_', 'D' };
+ final char[] array = { 'A', '2', '_', 'D' };
assertEquals(baseStr + "[chars={A,2,_,D}]", new ToStringBuilder(base).append("chars", array).toString());
assertEquals(baseStr + "[letters={A,2,_,D}]", new ToStringBuilder(base).append("letters", array).toString());
assertEquals(baseStr + "[flags=<null>]",
@@ -664,7 +664,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendCharArrayWithFieldNameAndFullDetatil() {
- final char[] array = new char[] { 'A', '2', '_', 'D' };
+ final char[] array = { 'A', '2', '_', 'D' };
assertEquals(baseStr + "[chars={A,2,_,D}]", new ToStringBuilder(base).append("chars", array, true).toString());
assertEquals(baseStr + "[letters=<size=4>]",
new ToStringBuilder(base).append("letters", array, false).toString());
@@ -676,7 +676,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendDoubleArrayWithFieldName() {
- final double[] array = new double[] { 1.0, 2.9876, -3.00001, 4.3 };
+ final double[] array = { 1.0, 2.9876, -3.00001, 4.3 };
assertEquals(baseStr + "[values={1.0,2.9876,-3.00001,4.3}]",
new ToStringBuilder(base).append("values", array).toString());
assertEquals(baseStr + "[values=<null>]",
@@ -687,7 +687,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendDoubleArrayWithFieldNameAndFullDetatil() {
- final double[] array = new double[] { 1.0, 2.9876, -3.00001, 4.3 };
+ final double[] array = { 1.0, 2.9876, -3.00001, 4.3 };
assertEquals(baseStr + "[values={1.0,2.9876,-3.00001,4.3}]",
new ToStringBuilder(base).append("values", array, true).toString());
assertEquals(baseStr + "[length=<size=4>]",
@@ -700,7 +700,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendObjectArrayWithFieldName() {
- final Object[] array = new Object[] { null, base, new int[] { 3, 6 } };
+ final Object[] array = { null, base, new int[] { 3, 6 } };
assertEquals(baseStr + "[values={<null>,5,{3,6}}]",
new ToStringBuilder(base).append("values", array).toString());
assertEquals(baseStr + "[values=<null>]",
@@ -711,7 +711,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendObjectArrayWithFieldNameAndFullDetatil() {
- final Object[] array = new Object[] { null, base, new int[] { 3, 6 } };
+ final Object[] array = { null, base, new int[] { 3, 6 } };
assertEquals(baseStr + "[values={<null>,5,{3,6}}]",
new ToStringBuilder(base).append("values", array, true).toString());
assertEquals(baseStr + "[length=<size=3>]",
@@ -724,7 +724,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendLongArrayWithFieldName() {
- final long[] array = new long[] { 1, 2, -3, 4 };
+ final long[] array = { 1, 2, -3, 4 };
assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array).toString());
assertEquals(baseStr + "[values=<null>]",
new ToStringBuilder(base).append("values", (boolean[]) null).toString());
@@ -734,7 +734,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendLongArrayWithFieldNameAndFullDetatil() {
- final long[] array = new long[] { 1, 2, -3, 4 };
+ final long[] array = { 1, 2, -3, 4 };
assertEquals(baseStr + "[values={1,2,-3,4}]",
new ToStringBuilder(base).append("values", array, true).toString());
assertEquals(baseStr + "[length=<size=4>]",
@@ -747,7 +747,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendIntArrayWithFieldName() {
- final int[] array = new int[] { 1, 2, -3, 4 };
+ final int[] array = { 1, 2, -3, 4 };
assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array).toString());
assertEquals(baseStr + "[values=<null>]",
new ToStringBuilder(base).append("values", (boolean[]) null).toString());
@@ -757,7 +757,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendIntArrayWithFieldNameAndFullDetatil() {
- final int[] array = new int[] { 1, 2, -3, 4 };
+ final int[] array = { 1, 2, -3, 4 };
assertEquals(baseStr + "[values={1,2,-3,4}]",
new ToStringBuilder(base).append("values", array, true).toString());
assertEquals(baseStr + "[length=<size=4>]",
@@ -770,7 +770,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendShortArrayWithFieldName() {
- final short[] array = new short[] { 1, 2, -3, 4 };
+ final short[] array = { 1, 2, -3, 4 };
assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array).toString());
assertEquals(baseStr + "[values=<null>]",
new ToStringBuilder(base).append("values", (boolean[]) null).toString());
@@ -780,7 +780,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendShortArrayWithFieldNameAndFullDetatil() {
- final short[] array = new short[] { 1, 2, -3, 4 };
+ final short[] array = { 1, 2, -3, 4 };
assertEquals(baseStr + "[values={1,2,-3,4}]",
new ToStringBuilder(base).append("values", array, true).toString());
assertEquals(baseStr + "[length=<size=4>]",
@@ -793,7 +793,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendByteArrayWithFieldName() {
- final byte[] array = new byte[] { 1, 2, -3, 4 };
+ final byte[] array = { 1, 2, -3, 4 };
assertEquals(baseStr + "[values={1,2,-3,4}]", new ToStringBuilder(base).append("values", array).toString());
assertEquals(baseStr + "[values=<null>]",
new ToStringBuilder(base).append("values", (boolean[]) null).toString());
@@ -803,7 +803,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendByteArrayWithFieldNameAndFullDetatil() {
- final byte[] array = new byte[] { 1, 2, -3, 4 };
+ final byte[] array = { 1, 2, -3, 4 };
assertEquals(baseStr + "[values={1,2,-3,4}]",
new ToStringBuilder(base).append("values", array, true).toString());
assertEquals(baseStr + "[length=<size=4>]",
@@ -816,7 +816,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendFloatArrayWithFieldName() {
- final float[] array = new float[] { 1.0f, 2.9876f, -3.00001f, 4.3f };
+ final float[] array = { 1.0f, 2.9876f, -3.00001f, 4.3f };
assertEquals(baseStr + "[values={1.0,2.9876,-3.00001,4.3}]",
new ToStringBuilder(base).append("values", array).toString());
assertEquals(baseStr + "[values=<null>]",
@@ -827,7 +827,7 @@ public class ToStringBuilderTest {
@Test
public void testAppendFloatArrayWithFieldNameAndFullDetatil() {
- final float[] array = new float[] { 1.0f, 2.9876f, -3.00001f, 4.3f };
+ final float[] array = { 1.0f, 2.9876f, -3.00001f, 4.3f };
assertEquals(baseStr + "[values={1.0,2.9876,-3.00001,4.3}]",
new ToStringBuilder(base).append("values", array, true).toString());
assertEquals(baseStr + "[length=<size=4>]",
@@ -946,7 +946,7 @@ public class ToStringBuilderTest {
@Test
public void testObjectArray() {
- Object[] array = new Object[] {null, base, new int[] {3, 6}};
+ Object[] array = {null, base, new int[] {3, 6}};
assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{<null>,5,{3,6}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -956,7 +956,7 @@ public class ToStringBuilderTest {
@Test
public void testLongArray() {
- long[] array = new long[] {1, 2, -3, 4};
+ long[] array = {1, 2, -3, 4};
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -966,7 +966,7 @@ public class ToStringBuilderTest {
@Test
public void testIntArray() {
- int[] array = new int[] {1, 2, -3, 4};
+ int[] array = {1, 2, -3, 4};
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -976,7 +976,7 @@ public class ToStringBuilderTest {
@Test
public void testShortArray() {
- short[] array = new short[] {1, 2, -3, 4};
+ short[] array = {1, 2, -3, 4};
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -986,7 +986,7 @@ public class ToStringBuilderTest {
@Test
public void testByteArray() {
- byte[] array = new byte[] {1, 2, -3, 4};
+ byte[] array = {1, 2, -3, 4};
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{1,2,-3,4}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -996,7 +996,7 @@ public class ToStringBuilderTest {
@Test
public void testCharArray() {
- char[] array = new char[] {'A', '2', '_', 'D'};
+ char[] array = {'A', '2', '_', 'D'};
assertEquals(baseStr + "[{A,2,_,D}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{A,2,_,D}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -1006,7 +1006,7 @@ public class ToStringBuilderTest {
@Test
public void testDoubleArray() {
- double[] array = new double[] {1.0, 2.9876, -3.00001, 4.3};
+ double[] array = {1.0, 2.9876, -3.00001, 4.3};
assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -1016,7 +1016,7 @@ public class ToStringBuilderTest {
@Test
public void testFloatArray() {
- float[] array = new float[] {1.0f, 2.9876f, -3.00001f, 4.3f};
+ float[] array = {1.0f, 2.9876f, -3.00001f, 4.3f};
assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{1.0,2.9876,-3.00001,4.3}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -1026,7 +1026,7 @@ public class ToStringBuilderTest {
@Test
public void testBooleanArray() {
- boolean[] array = new boolean[] {true, false, false};
+ boolean[] array = {true, false, false};
assertEquals(baseStr + "[{true,false,false}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{true,false,false}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -1036,7 +1036,7 @@ public class ToStringBuilderTest {
@Test
public void testLongArrayArray() {
- long[][] array = new long[][] {{1, 2}, null, {5}};
+ long[][] array = {{1, 2}, null, {5}};
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -1046,7 +1046,7 @@ public class ToStringBuilderTest {
@Test
public void testIntArrayArray() {
- int[][] array = new int[][] {{1, 2}, null, {5}};
+ int[][] array = {{1, 2}, null, {5}};
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -1056,7 +1056,7 @@ public class ToStringBuilderTest {
@Test
public void testShortArrayArray() {
- short[][] array = new short[][] {{1, 2}, null, {5}};
+ short[][] array = {{1, 2}, null, {5}};
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -1066,7 +1066,7 @@ public class ToStringBuilderTest {
@Test
public void testByteArrayArray() {
- byte[][] array = new byte[][] {{1, 2}, null, {5}};
+ byte[][] array = {{1, 2}, null, {5}};
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{{1,2},<null>,{5}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -1076,7 +1076,7 @@ public class ToStringBuilderTest {
@Test
public void testCharArrayArray() {
- char[][] array = new char[][] {{'A', 'B'}, null, {'p'}};
+ char[][] array = {{'A', 'B'}, null, {'p'}};
assertEquals(baseStr + "[{{A,B},<null>,{p}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{{A,B},<null>,{p}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -1086,7 +1086,7 @@ public class ToStringBuilderTest {
@Test
public void testDoubleArrayArray() {
- double[][] array = new double[][] {{1.0, 2.29686}, null, {Double.NaN}};
+ double[][] array = {{1.0, 2.29686}, null, {Double.NaN}};
assertEquals(baseStr + "[{{1.0,2.29686},<null>,{NaN}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{{1.0,2.29686},<null>,{NaN}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -1096,7 +1096,7 @@ public class ToStringBuilderTest {
@Test
public void testFloatArrayArray() {
- float[][] array = new float[][] {{1.0f, 2.29686f}, null, {Float.NaN}};
+ float[][] array = {{1.0f, 2.29686f}, null, {Float.NaN}};
assertEquals(baseStr + "[{{1.0,2.29686},<null>,{NaN}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{{1.0,2.29686},<null>,{NaN}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
@@ -1106,7 +1106,7 @@ public class ToStringBuilderTest {
@Test
public void testBooleanArrayArray() {
- boolean[][] array = new boolean[][] {{true, false}, null, {false}};
+ boolean[][] array = {{true, false}, null, {false}};
assertEquals(baseStr + "[{{true,false},<null>,{false}}]", new ToStringBuilder(base).append(array).toString());
assertEquals(baseStr + "[{{true,false},<null>,{false}}]", new ToStringBuilder(base).append((Object) array).toString());
array = null;
diff --git a/src/test/java/org/apache/commons/lang3/math/IEEE754rUtilsTest.java b/src/test/java/org/apache/commons/lang3/math/IEEE754rUtilsTest.java
index 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 @@ public class IEEE754rUtilsTest {
assertEquals(2.5f, IEEE754rUtils.max(1.2f, 2.5f, Float.NaN), 0.01);
assertTrue(Float.isNaN(IEEE754rUtils.max(Float.NaN, Float.NaN, Float.NaN)));
- final double[] a = new double[] { 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN };
+ final double[] a = { 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN };
assertEquals(42.0, IEEE754rUtils.max(a), 0.01);
assertEquals(1.2, IEEE754rUtils.min(a), 0.01);
- final double[] b = new double[] { Double.NaN, 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN };
+ final double[] b = { Double.NaN, 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN };
assertEquals(42.0, IEEE754rUtils.max(b), 0.01);
assertEquals(1.2, IEEE754rUtils.min(b), 0.01);
- final float[] aF = new float[] { 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN };
+ final float[] aF = { 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN };
assertEquals(1.2f, IEEE754rUtils.min(aF), 0.01);
assertEquals(42.0f, IEEE754rUtils.max(aF), 0.01);
- final float[] bF = new float[] { Float.NaN, 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN };
+ final float[] bF = { Float.NaN, 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN };
assertEquals(1.2f, IEEE754rUtils.min(bF), 0.01);
assertEquals(42.0f, IEEE754rUtils.max(bF), 0.01);
}
diff --git a/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java b/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java
index 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 @@ public class NumberUtilsTest {
assertTrue(Float.isNaN(NumberUtils.min(1.2f, 2.5f, Float.NaN)));
assertTrue(Float.isNaN(NumberUtils.max(1.2f, 2.5f, Float.NaN)));
- final double[] a = new double[] {1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN};
+ final double[] a = {1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN};
assertTrue(Double.isNaN(NumberUtils.max(a)));
assertTrue(Double.isNaN(NumberUtils.min(a)));
- final double[] b = new double[] {Double.NaN, 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN};
+ final double[] b = {Double.NaN, 1.2, Double.NaN, 3.7, 27.0, 42.0, Double.NaN};
assertTrue(Double.isNaN(NumberUtils.max(b)));
assertTrue(Double.isNaN(NumberUtils.min(b)));
- final float[] aF = new float[] {1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN};
+ final float[] aF = {1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN};
assertTrue(Float.isNaN(NumberUtils.max(aF)));
- final float[] bF = new float[] {Float.NaN, 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN};
+ final float[] bF = {Float.NaN, 1.2f, Float.NaN, 3.7f, 27.0f, 42.0f, Float.NaN};
assertTrue(Float.isNaN(NumberUtils.max(bF)));
}
diff --git a/src/test/java/org/apache/commons/lang3/text/ExtendedMessageFormatTest.java b/src/test/java/org/apache/commons/lang3/text/ExtendedMessageFormatTest.java
index 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 class ExtendedMessageFormatTest {
public void testExtendedAndBuiltInFormats() {
final Calendar cal = Calendar.getInstance();
cal.set(2007, Calendar.JANUARY, 23, 18, 33, 5);
- final Object[] args = new Object[] {"John Doe", cal.getTime(), Double.valueOf("12345.67")};
+ final Object[] args = {"John Doe", cal.getTime(), Double.valueOf("12345.67")};
final String builtinsPattern = "DOB: {1,date,short} Salary: {2,number,currency}";
final String extendedPattern = "Name: {0,upper} ";
final String pattern = extendedPattern + builtinsPattern;
@@ -228,7 +228,7 @@ public class ExtendedMessageFormatTest {
public void testBuiltInDateTimeFormat() {
final Calendar cal = Calendar.getInstance();
cal.set(2007, Calendar.JANUARY, 23, 18, 33, 5);
- final Object[] args = new Object[] {cal.getTime()};
+ final Object[] args = {cal.getTime()};
final Locale[] availableLocales = DateFormat.getAvailableLocales();
checkBuiltInFormat("1: {0,date,short}", args, availableLocales);
@@ -249,7 +249,7 @@ public class ExtendedMessageFormatTest {
public void testOverriddenBuiltinFormat() {
final Calendar cal = Calendar.getInstance();
cal.set(2007, Calendar.JANUARY, 23);
- final Object[] args = new Object[] {cal.getTime()};
+ final Object[] args = {cal.getTime()};
final Locale[] availableLocales = DateFormat.getAvailableLocales();
final Map<String, ? extends FormatFactory> dateRegistry = Collections.singletonMap("date", new OverrideShortDateFormatFactory());
@@ -276,7 +276,7 @@ public class ExtendedMessageFormatTest {
*/
@Test
public void testBuiltInNumberFormat() {
- final Object[] args = new Object[] {Double.valueOf("6543.21")};
+ final Object[] args = {Double.valueOf("6543.21")};
final Locale[] availableLocales = NumberFormat.getAvailableLocales();
checkBuiltInFormat("1: {0,number}", args, availableLocales);
checkBuiltInFormat("2: {0,number,integer}", args, availableLocales);
diff --git a/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java b/src/test/java/org/apache/commons/lang3/text/StrTokenizerTest.java
index 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 @@ public class StrTokenizerTest {
tok.setIgnoreEmptyTokens(false);
final String[] tokens = tok.getTokenArray();
- final String[] expected = new String[]{"a", "b", "c", "d;\"e", "f", "", "", ""};
+ final String[] expected = {"a", "b", "c", "d;\"e", "f", "", "", ""};
assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens));
for (int i = 0; i < expected.length; i++) {
@@ -80,7 +80,7 @@ public class StrTokenizerTest {
tok.setIgnoreEmptyTokens(false);
final String[] tokens = tok.getTokenArray();
- final String[] expected = new String[]{"a", "b", "c ", "d;\"e", "f", " ", " ", ""};
+ final String[] expected = {"a", "b", "c ", "d;\"e", "f", " ", " ", ""};
assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens));
for (int i = 0; i < expected.length; i++) {
@@ -101,7 +101,7 @@ public class StrTokenizerTest {
tok.setIgnoreEmptyTokens(false);
final String[] tokens = tok.getTokenArray();
- final String[] expected = new String[]{"a", "b", " c", "d;\"e", "f", " ", " ", ""};
+ final String[] expected = {"a", "b", " c", "d;\"e", "f", " ", " ", ""};
assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens));
for (int i = 0; i < expected.length; i++) {
@@ -122,7 +122,7 @@ public class StrTokenizerTest {
tok.setIgnoreEmptyTokens(true);
final String[] tokens = tok.getTokenArray();
- final String[] expected = new String[]{"a", "b", "c", "d;\"e", "f"};
+ final String[] expected = {"a", "b", "c", "d;\"e", "f"};
assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens));
for (int i = 0; i < expected.length; i++) {
@@ -144,7 +144,7 @@ public class StrTokenizerTest {
tok.setEmptyTokenAsNull(true);
final String[] tokens = tok.getTokenArray();
- final String[] expected = new String[]{"a", "b", "c", "d;\"e", "f", null, null, null};
+ final String[] expected = {"a", "b", "c", "d;\"e", "f", null, null, null};
assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens));
for (int i = 0; i < expected.length; i++) {
@@ -166,7 +166,7 @@ public class StrTokenizerTest {
// tok.setTreatingEmptyAsNull(true);
final String[] tokens = tok.getTokenArray();
- final String[] expected = new String[]{"a", "b", " c", "d;\"e", "f", null, null, null};
+ final String[] expected = {"a", "b", " c", "d;\"e", "f", null, null, null};
int nextCount = 0;
while (tok.hasNext()) {
@@ -199,7 +199,7 @@ public class StrTokenizerTest {
tok.setIgnoreEmptyTokens(false);
final String[] tokens = tok.getTokenArray();
- final String[] expected = new String[]{"a", "", "", "b", "c", "d e", "f", ""};
+ final String[] expected = {"a", "", "", "b", "c", "d e", "f", ""};
assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens));
for (int i = 0; i < expected.length; i++) {
@@ -220,7 +220,7 @@ public class StrTokenizerTest {
tok.setIgnoreEmptyTokens(true);
final String[] tokens = tok.getTokenArray();
- final String[] expected = new String[]{"a", "b", "c", "d e", "f"};
+ final String[] expected = {"a", "b", "c", "d e", "f"};
assertEquals(expected.length, tokens.length, ArrayUtils.toString(tokens));
for (int i = 0; i < expected.length; i++) {
@@ -605,7 +605,7 @@ public class StrTokenizerTest {
@Test
public void testCloneReset() {
- final char[] input = new char[]{'a'};
+ final char[] input = {'a'};
final StrTokenizer tokenizer = new StrTokenizer(input);
// Start sanity check
assertEquals("a", tokenizer.nextToken());
@@ -749,7 +749,7 @@ public class StrTokenizerTest {
public void testReset_charArray() {
final StrTokenizer tok = new StrTokenizer("x x x");
- final char[] array = new char[] {'a', 'b', 'c'};
+ final char[] array = {'a', 'b', 'c'};
tok.reset(array);
assertEquals("abc", tok.next());
assertFalse(tok.hasNext());
diff --git a/src/test/java/org/apache/commons/lang3/text/WordUtilsTest.java b/src/test/java/org/apache/commons/lang3/text/WordUtilsTest.java
index 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 @@ public class WordUtilsTest {
assertEquals("", WordUtils.capitalize(""));
assertEquals(" ", WordUtils.capitalize(" "));
- char[] chars = new char[] { '-', '+', ' ', '@' };
+ char[] chars = { '-', '+', ' ', '@' };
assertEquals("I", WordUtils.capitalize("I", chars) );
assertEquals("I", WordUtils.capitalize("i", chars) );
assertEquals("I-Am Here+123", WordUtils.capitalize("i-am here+123", chars) );
@@ -235,7 +235,7 @@ public class WordUtilsTest {
assertEquals("", WordUtils.capitalizeFully(""));
assertEquals(" ", WordUtils.capitalizeFully(" "));
- char[] chars = new char[] { '-', '+', ' ', '@' };
+ char[] chars = { '-', '+', ' ', '@' };
assertEquals("I", WordUtils.capitalizeFully("I", chars) );
assertEquals("I", WordUtils.capitalizeFully("i", chars) );
assertEquals("I-Am Here+123", WordUtils.capitalizeFully("i-am here+123", chars) );
@@ -287,7 +287,7 @@ public class WordUtilsTest {
assertEquals("", WordUtils.uncapitalize(""));
assertEquals(" ", WordUtils.uncapitalize(" "));
- char[] chars = new char[] { '-', '+', ' ', '@' };
+ char[] chars = { '-', '+', ' ', '@' };
assertEquals("i", WordUtils.uncapitalize("I", chars) );
assertEquals("i", WordUtils.uncapitalize("i", chars) );
assertEquals("i am-here+123", WordUtils.uncapitalize("i am-here+123", chars) );
diff --git a/src/test/java/org/apache/commons/lang3/time/DateUtilsTest.java b/src/test/java/org/apache/commons/lang3/time/DateUtilsTest.java
index 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 class DateUtilsTest {
public void testParseDate() throws Exception {
final GregorianCalendar cal = new GregorianCalendar(1972, 11, 3);
String dateStr = "1972-12-03";
- final String[] parsers = new String[] {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"};
+ final String[] parsers = {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"};
Date date = DateUtils.parseDate(dateStr, parsers);
assertEquals(cal.getTime(), date);
@@ -887,19 +887,19 @@ public class DateUtilsTest {
@Test
public void testParseDate_InvalidDateString() {
- final String[] parsers = new String[] {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"};
+ final String[] parsers = {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"};
assertThrows(ParseException.class, () -> DateUtils.parseDate("197212AB", parsers));
}
@Test
public void testParseDate_NoDateString() {
- final String[] parsers = new String[] {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"};
+ final String[] parsers = {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"};
assertThrows(ParseException.class, () -> DateUtils.parseDate("PURPLE", parsers));
}
@Test
public void testParseDate_Null() {
- final String[] parsers = new String[] {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"};
+ final String[] parsers = {"yyyy'-'DDD", "yyyy'-'MM'-'dd", "yyyyMMdd"};
assertThrows(IllegalArgumentException.class, () -> DateUtils.parseDate(null, parsers));
}
@@ -908,7 +908,7 @@ public class DateUtilsTest {
public void testParseDateWithLeniency() throws Exception {
final GregorianCalendar cal = new GregorianCalendar(1998, 6, 30);
final String dateStr = "02 942, 1996";
- final String[] parsers = new String[] {"MM DDD, yyyy"};
+ final String[] parsers = {"MM DDD, yyyy"};
final Date date = DateUtils.parseDate(dateStr, parsers);
assertEquals(cal.getTime(), date);
diff --git a/src/test/java/org/apache/commons/lang3/time/DurationFormatUtilsTest.java b/src/test/java/org/apache/commons/lang3/time/DurationFormatUtilsTest.java
index 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 @@ public class DurationFormatUtilsTest {
final String msg = year + "-" + month + "-" + day + " to ";
final Calendar c = Calendar.getInstance();
c.set(year, month, day, 0, 0, 0);
- final int[] array1 = new int[] { year, month, day, 0, 0, 0 };
- final int[] array2 = new int[] { year, month, day, 0, 0, 0 };
+ final int[] array1 = { year, month, day, 0, 0, 0 };
+ final int[] array2 = { year, month, day, 0, 0, 0 };
for (int i=0; i < FOUR_YEARS; i++) {
array2[0] = c.get(Calendar.YEAR);
array2[1] = c.get(Calendar.MONTH);
[commons-lang] 07/07: Revert.
Posted by gg...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
commit 1682277ebcc37d24a1bfd87ebedd60510a7da4c1
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Tue May 25 13:48:57 2021 -0400
Revert.
---
src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java b/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
index 5366a07..a9e62de 100644
--- a/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
+++ b/src/test/java/org/apache/commons/lang3/builder/DiffBuilderTest.java
@@ -356,9 +356,9 @@ public class DiffBuilderTest {
@Test
public void testObjectsNotSameButEqual() {
final TypeTestClass left = new TypeTestClass();
- left.objectField = Integer.valueOf(1);
+ left.objectField = new Integer(1);
final TypeTestClass right = new TypeTestClass();
- right.objectField = Integer.valueOf(1);
+ right.objectField = new Integer(1);
assertNotSame(left.objectField, right.objectField);
assertEquals(left.objectField, right.objectField);
[commons-lang] 05/07: Use valueOf().
Posted by gg...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
commit d02b2c53a076cdd484cd741e9b5f2248d963fb35
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Tue May 25 13:39:51 2021 -0400
Use valueOf().
---
src/test/java/org/apache/commons/lang3/SystemUtilsTest.java | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/test/java/org/apache/commons/lang3/SystemUtilsTest.java b/src/test/java/org/apache/commons/lang3/SystemUtilsTest.java
index 38f917b..eea7ae0 100644
--- a/src/test/java/org/apache/commons/lang3/SystemUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/SystemUtilsTest.java
@@ -539,7 +539,7 @@ public class SystemUtilsTest {
final String expectedStringValue = System.getProperty("java.awt.headless");
final String expectedStringValueWithDefault = System.getProperty("java.awt.headless", "false");
assertNotNull(expectedStringValueWithDefault);
- final boolean expectedValue = Boolean.valueOf(expectedStringValue).booleanValue();
+ final boolean expectedValue = Boolean.parseBoolean(expectedStringValue);
if (expectedStringValue != null) {
assertEquals(expectedStringValue, SystemUtils.JAVA_AWT_HEADLESS);
}
[commons-lang] 01/07: Use final.
Posted by gg...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
commit 24957f9934cee310debd2005bdbd78e21e857e7e
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Tue May 25 13:34:08 2021 -0400
Use final.
---
src/main/java/org/apache/commons/lang3/math/NumberUtils.java | 2 +-
src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/main/java/org/apache/commons/lang3/math/NumberUtils.java b/src/main/java/org/apache/commons/lang3/math/NumberUtils.java
index 92dcd4f..7a90fef 100644
--- a/src/main/java/org/apache/commons/lang3/math/NumberUtils.java
+++ b/src/main/java/org/apache/commons/lang3/math/NumberUtils.java
@@ -874,7 +874,7 @@ public class NumberUtils {
* can be null)
* @return true if the magnitude is zero
*/
- private static boolean isZero(final String mant, String dec) {
+ private static boolean isZero(final String mant, final String dec) {
return isAllZeros(mant) && isAllZeros(dec);
}
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 971bd5c..d7d49b5 100644
--- a/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/math/NumberUtilsTest.java
@@ -717,7 +717,7 @@ public class NumberUtilsTest {
}
}
- private static void assertCreateNumberZero(String number, Object zero, Object negativeZero) {
+ private static void assertCreateNumberZero(final String number, final Object zero, final Object negativeZero) {
assertEquals(zero, NumberUtils.createNumber(number), () -> "Input: " + number);
assertEquals(zero, NumberUtils.createNumber("+" + number), () -> "Input: +" + number);
assertEquals(negativeZero, NumberUtils.createNumber("-" + number), () -> "Input: -" + number);
[commons-lang] 03/07: Lambdas.
Posted by gg...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
commit 2d86ac6ecf24939e665a08be2f07fa144120990f
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Tue May 25 13:36:29 2021 -0400
Lambdas.
---
src/main/java/org/apache/commons/lang3/Streams.java | 4 +---
src/main/java/org/apache/commons/lang3/stream/Streams.java | 4 +---
2 files changed, 2 insertions(+), 6 deletions(-)
diff --git a/src/main/java/org/apache/commons/lang3/Streams.java b/src/main/java/org/apache/commons/lang3/Streams.java
index 58ab429..c284944 100644
--- a/src/main/java/org/apache/commons/lang3/Streams.java
+++ b/src/main/java/org/apache/commons/lang3/Streams.java
@@ -478,9 +478,7 @@ public class Streams {
@Override
public Function<List<O>, O[]> finisher() {
- return list -> {
- return list.toArray(ArrayUtils.newInstance(elementType, list.size()));
- };
+ return list -> list.toArray(ArrayUtils.newInstance(elementType, list.size()));
}
@Override
diff --git a/src/main/java/org/apache/commons/lang3/stream/Streams.java b/src/main/java/org/apache/commons/lang3/stream/Streams.java
index cfad60c..7022210 100644
--- a/src/main/java/org/apache/commons/lang3/stream/Streams.java
+++ b/src/main/java/org/apache/commons/lang3/stream/Streams.java
@@ -104,9 +104,7 @@ public class Streams {
@Override
public Function<List<O>, O[]> finisher() {
- return list -> {
- return list.toArray(ArrayUtils.newInstance(elementType, list.size()));
- };
+ return list -> list.toArray(ArrayUtils.newInstance(elementType, list.size()));
}
@Override
[commons-lang] 06/07: Simpler boolean tests.
Posted by gg...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-lang.git
commit 86683978bdfc3730af44fdb06d240ec69e4de82c
Author: Gary Gregory <ga...@gmail.com>
AuthorDate: Tue May 25 13:41:55 2021 -0400
Simpler boolean tests.
---
src/main/java/org/apache/commons/lang3/text/StrBuilder.java | 2 +-
.../java/org/apache/commons/lang3/text/StrSubstitutor.java | 10 +++++-----
2 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/src/main/java/org/apache/commons/lang3/text/StrBuilder.java b/src/main/java/org/apache/commons/lang3/text/StrBuilder.java
index 2c4807c..8c23960 100644
--- a/src/main/java/org/apache/commons/lang3/text/StrBuilder.java
+++ b/src/main/java/org/apache/commons/lang3/text/StrBuilder.java
@@ -2988,7 +2988,7 @@ public class StrBuilder implements CharSequence, Appendable, Serializable, Build
/** {@inheritDoc} */
@Override
public int read() {
- if (ready() == false) {
+ if (!ready()) {
return -1;
}
return StrBuilder.this.charAt(pos++);
diff --git a/src/main/java/org/apache/commons/lang3/text/StrSubstitutor.java b/src/main/java/org/apache/commons/lang3/text/StrSubstitutor.java
index bc52884..b676855 100644
--- a/src/main/java/org/apache/commons/lang3/text/StrSubstitutor.java
+++ b/src/main/java/org/apache/commons/lang3/text/StrSubstitutor.java
@@ -400,7 +400,7 @@ public class StrSubstitutor {
return null;
}
final StrBuilder buf = new StrBuilder(source);
- if (substitute(buf, 0, source.length()) == false) {
+ if (!substitute(buf, 0, source.length())) {
return source;
}
return buf.toString();
@@ -423,7 +423,7 @@ public class StrSubstitutor {
return null;
}
final StrBuilder buf = new StrBuilder(length).append(source, offset, length);
- if (substitute(buf, 0, length) == false) {
+ if (!substitute(buf, 0, length)) {
return source.substring(offset, offset + length);
}
return buf.toString();
@@ -640,7 +640,7 @@ public class StrSubstitutor {
return false;
}
final StrBuilder buf = new StrBuilder(length).append(source, offset, length);
- if (substitute(buf, 0, length) == false) {
+ if (!substitute(buf, 0, length)) {
return false;
}
source.replace(offset, offset + length, buf.toString());
@@ -683,7 +683,7 @@ public class StrSubstitutor {
return false;
}
final StrBuilder buf = new StrBuilder(length).append(source, offset, length);
- if (substitute(buf, 0, length) == false) {
+ if (!substitute(buf, 0, length)) {
return false;
}
source.replace(offset, offset + length, buf.toString());
@@ -896,7 +896,7 @@ public class StrSubstitutor {
* @param priorVariables the list of prior variables
*/
private void checkCyclicSubstitution(final String varName, final List<String> priorVariables) {
- if (priorVariables.contains(varName) == false) {
+ if (!priorVariables.contains(varName)) {
return;
}
final StrBuilder buf = new StrBuilder(256);