zhouxy108/plusone-commons
1
0
Fork 0
forked from plusone/plusone-commons
Code Pull Requests Activity

ArrayTools：修复 concat 方法的参数 arrays 中存在 null，从而报空指针的问题；补充单元测试

Browse Source
This commit is contained in:
ZhouXY108
2024-12-04 01:14:20 +08:00
parent cca3c8b1ee
commit 65f0bb062c
2 changed files with 485 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

400
src/test/java/xyz/zhouxy/plusone/commons/util/ArrayToolsTests.java
View File

@@ -16,21 +16,403 @@
package xyz.zhouxy.plusone.commons.util;
import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
@SuppressWarnings("all")
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
@SuppressWarnings("null")
public class ArrayToolsTests {
// TODO 【优化】 检查、完善测试用例
//#region null or empty
@Test
void testIsAllNotNull() {
assertTrue(ArrayTools.isAllElementsNotNull(new Object[] { 1L, 2, 3.0, "Java" }));
assertFalse(ArrayTools.isAllElementsNotNull(new Object[] { 1L, 2, 3.0, "Java", null }));
assertFalse(ArrayTools.isAllElementsNotNull(new Object[] { null, 1L, 2, 3.0, "Java" }));
assertTrue(ArrayTools.isAllElementsNotNull(new Object[] {}));
assertThrows(IllegalArgumentException.class,
() -> ArrayTools.isAllElementsNotNull(null));
void isNullOrEmpty_NullArray_ReturnsTrue() {
assertAll(
() -> assertTrue(ArrayTools.isNullOrEmpty((String[]) null)),
() -> assertTrue(ArrayTools.isNullOrEmpty((Integer[]) null)),
() -> assertTrue(ArrayTools.isNullOrEmpty((char[]) null)),
() -> assertTrue(ArrayTools.isNullOrEmpty((byte[]) null)),
() -> assertTrue(ArrayTools.isNullOrEmpty((short[]) null)),
() -> assertTrue(ArrayTools.isNullOrEmpty((int[]) null)),
() -> assertTrue(ArrayTools.isNullOrEmpty((long[]) null)),
() -> assertTrue(ArrayTools.isNullOrEmpty((float[]) null)),
() -> assertTrue(ArrayTools.isNullOrEmpty((double[]) null)));
}
@Test
void isNullOrEmpty_EmptyArray_ReturnsTrue() {
assertAll(
() -> assertTrue(ArrayTools.isNullOrEmpty(new String[] {})),
() -> assertTrue(ArrayTools.isNullOrEmpty(new Integer[] {})),
() -> assertTrue(ArrayTools.isNullOrEmpty(new char[] {})),
() -> assertTrue(ArrayTools.isNullOrEmpty(new byte[] {})),
() -> assertTrue(ArrayTools.isNullOrEmpty(new short[] {})),
() -> assertTrue(ArrayTools.isNullOrEmpty(new int[] {})),
() -> assertTrue(ArrayTools.isNullOrEmpty(new long[] {})),
() -> assertTrue(ArrayTools.isNullOrEmpty(new float[] {})),
() -> assertTrue(ArrayTools.isNullOrEmpty(new double[] {})));
}
@Test
void isNullOrEmpty_NonEmptyArray_ReturnsFalse() {
assertAll(
() -> assertFalse(ArrayTools.isNullOrEmpty(new String[] { "a" })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new Integer[] { 1 })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new char[] { 'a' })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new byte[] { 1 })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new short[] { 1 })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new int[] { 1 })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new long[] { 1 })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new float[] { 1 })),
() -> assertFalse(ArrayTools.isNullOrEmpty(new double[] { 1 })));
}
@Test
void isNotEmpty_NullArray_ReturnsFalse() {
assertAll(
() -> assertFalse(ArrayTools.isNotEmpty((String[]) null)),
() -> assertFalse(ArrayTools.isNotEmpty((Integer[]) null)),
() -> assertFalse(ArrayTools.isNotEmpty((char[]) null)),
() -> assertFalse(ArrayTools.isNotEmpty((byte[]) null)),
() -> assertFalse(ArrayTools.isNotEmpty((short[]) null)),
() -> assertFalse(ArrayTools.isNotEmpty((int[]) null)),
() -> assertFalse(ArrayTools.isNotEmpty((long[]) null)),
() -> assertFalse(ArrayTools.isNotEmpty((float[]) null)),
() -> assertFalse(ArrayTools.isNotEmpty((double[]) null)));
}
@Test
void isNotEmpty_EmptyArray_ReturnsFalse() {
assertAll(
() -> assertFalse(ArrayTools.isNotEmpty(new String[] {})),
() -> assertFalse(ArrayTools.isNotEmpty(new Integer[] {})),
() -> assertFalse(ArrayTools.isNotEmpty(new char[] {})),
() -> assertFalse(ArrayTools.isNotEmpty(new byte[] {})),
() -> assertFalse(ArrayTools.isNotEmpty(new short[] {})),
() -> assertFalse(ArrayTools.isNotEmpty(new int[] {})),
() -> assertFalse(ArrayTools.isNotEmpty(new long[] {})),
() -> assertFalse(ArrayTools.isNotEmpty(new float[] {})),
() -> assertFalse(ArrayTools.isNotEmpty(new double[] {})));
}
@Test
void isNotEmpty_NonEmptyArray_ReturnsTrue() {
assertAll(
() -> assertTrue(ArrayTools.isNotEmpty(new String[] { "a" })),
() -> assertTrue(ArrayTools.isNotEmpty(new Integer[] { 1 })),
() -> assertTrue(ArrayTools.isNotEmpty(new char[] { 'a' })),
() -> assertTrue(ArrayTools.isNotEmpty(new byte[] { 1 })),
() -> assertTrue(ArrayTools.isNotEmpty(new short[] { 1 })),
() -> assertTrue(ArrayTools.isNotEmpty(new int[] { 1 })),
() -> assertTrue(ArrayTools.isNotEmpty(new long[] { 1 })),
() -> assertTrue(ArrayTools.isNotEmpty(new float[] { 1 })),
() -> assertTrue(ArrayTools.isNotEmpty(new double[] { 1 })));
}
@Test
void isAllElementsNotNull_NullArray_ThrowsException() {
assertThrows(IllegalArgumentException.class, () -> ArrayTools.isAllElementsNotNull((String[]) null));
assertThrows(IllegalArgumentException.class, () -> ArrayTools.isAllElementsNotNull((Integer[]) null));
}
@Test
void isAllElementsNotNull_EmptyArray_ReturnsTrue() {
assertTrue(ArrayTools.isAllElementsNotNull(new String[] {}));
assertTrue(ArrayTools.isAllElementsNotNull(new Integer[] {}));
}
@Test
void isAllElementsNotNull_ArrayWithNullElement_ReturnsFalse() {
assertFalse(ArrayTools.isAllElementsNotNull(new String[] { "a", null }));
assertFalse(ArrayTools.isAllElementsNotNull(new Integer[] { 1, null }));
}
@Test
void isAllElementsNotNull_ArrayWithoutNullElements_ReturnsTrue() {
assertTrue(ArrayTools.isAllElementsNotNull(new String[] { "a", "b" }));
assertTrue(ArrayTools.isAllElementsNotNull(new Integer[] { 1, 2 }));
}
// #endregion
// #region - concat
private static List<char[]> charArrays;
private static List<byte[]> byteArrays;
private static List<short[]> shortArrays;
private static List<int[]> intArrays;
private static List<long[]> longArrays;
private static List<float[]> floatArrays;
private static List<double[]> doubleArrays;
@BeforeAll
public static void setUp() {
charArrays = new ArrayList<>();
charArrays.add(new char[] { 'a', 'b' });
charArrays.add(new char[] { 'c', 'd', 'e' });
charArrays.add(null);
byteArrays = new ArrayList<>();
byteArrays.add(new byte[] { 1, 2 });
byteArrays.add(new byte[] { 3, 4, 5 });
byteArrays.add(null);
shortArrays = new ArrayList<>();
shortArrays.add(new short[] { 10, 20 });
shortArrays.add(new short[] { 30, 40, 50 });
shortArrays.add(null);
intArrays = new ArrayList<>();
intArrays.add(new int[] { 100, 200 });
intArrays.add(new int[] { 300, 400, 500 });
intArrays.add(null);
longArrays = new ArrayList<>();
longArrays.add(new long[] { 1000L, 2000L });
longArrays.add(new long[] { 3000L, 4000L, 5000L });
longArrays.add(null);
floatArrays = new ArrayList<>();
floatArrays.add(new float[] { 1000.1f, 2000.2f });
floatArrays.add(new float[] { 3000.3f, 4000.4f, 5000.5f });
floatArrays.add(null);
doubleArrays = new ArrayList<>();
doubleArrays.add(new double[] { 1000.1d, 2000.2d });
doubleArrays.add(new double[] { 3000.3d, 4000.4d, 5000.5d });
doubleArrays.add(null);
}
@Test
public void testConcatCharArray_NullOrEmptyCollection_ReturnsEmptyArray() {
assertArrayEquals(new char[] {}, ArrayTools.concatCharArray(null));
assertEquals(0, ArrayTools.concatCharArray(Collections.emptyList()).length);
}
@Test
public void testConcatCharArray_ValidCollection_ReturnsConcatenatedArray() {
char[] expected = { 'a', 'b', 'c', 'd', 'e' };
char[] result = ArrayTools.concatCharArray(charArrays);
assertArrayEquals(expected, result);
}
@Test
public void testConcatByteArray_NullOrEmptyCollection_ReturnsEmptyArray() {
assertArrayEquals(new byte[0], ArrayTools.concatByteArray(null));
assertEquals(0, ArrayTools.concatByteArray(Collections.emptyList()).length);
}
@Test
public void testConcatByteArray_ValidCollection_ReturnsConcatenatedArray() {
byte[] expected = { 1, 2, 3, 4, 5 };
byte[] result = ArrayTools.concatByteArray(byteArrays);
assertArrayEquals(expected, result);
}
@Test
public void testConcatShortArray_NullOrEmptyCollection_ReturnsEmptyArray() {
assertArrayEquals(new short[0], ArrayTools.concatShortArray(null));
assertEquals(0, ArrayTools.concatShortArray(Collections.emptyList()).length);
}
@Test
public void testConcatShortArray_ValidCollection_ReturnsConcatenatedArray() {
short[] expected = { 10, 20, 30, 40, 50 };
short[] result = ArrayTools.concatShortArray(shortArrays);
assertArrayEquals(expected, result);
}
@Test
public void testConcatIntArray_NullOrEmptyCollection_ReturnsEmptyArray() {
assertArrayEquals(new int[0], ArrayTools.concatIntArray(null));
assertEquals(0, ArrayTools.concatIntArray(Collections.emptyList()).length);
}
@Test
public void testConcatIntArray_ValidCollection_ReturnsConcatenatedArray() {
int[] expected = { 100, 200, 300, 400, 500 };
int[] result = ArrayTools.concatIntArray(intArrays);
assertArrayEquals(expected, result);
}
@Test
public void testConcatLongArray_NullOrEmptyCollection_ReturnsEmptyArray() {
assertArrayEquals(new long[0], ArrayTools.concatLongArray(null));
assertEquals(0, ArrayTools.concatLongArray(Collections.emptyList()).length);
}
@Test
public void testConcatLongArray_ValidCollection_ReturnsConcatenatedArray() {
long[] expected = { 1000L, 2000L, 3000L, 4000L, 5000L };
long[] result = ArrayTools.concatLongArray(longArrays);
assertArrayEquals(expected, result);
}
@Test
public void testConcatFloatArray_NullOrEmptyCollection_ReturnsEmptyArray() {
assertArrayEquals(new float[0], ArrayTools.concatFloatArray(null));
assertEquals(0, ArrayTools.concatFloatArray(Collections.emptyList()).length);
}
@Test
public void testConcatFloatArray_ValidCollection_ReturnsConcatenatedArray() {
float[] expected = { 1000.1f, 2000.2f, 3000.3f, 4000.4f, 5000.5f };
float[] result = ArrayTools.concatFloatArray(floatArrays);
assertArrayEquals(expected, result);
}
@Test
public void testConcatDoubleArray_NullOrEmptyCollection_ReturnsEmptyArray() {
assertArrayEquals(new double[] {}, ArrayTools.concatDoubleArray(null));
assertEquals(0, ArrayTools.concatDoubleArray(Collections.emptyList()).length);
}
@Test
public void testConcatDoubleArray_ValidCollection_ReturnsConcatenatedArray() {
double[] expected = { 1000.1d, 2000.2d, 3000.3d, 4000.4d, 5000.5d };
double[] result = ArrayTools.concatDoubleArray(doubleArrays);
assertArrayEquals(expected, result);
}
@Test
public void testConcatToList_NullOrEmptyCollection_ReturnsEmptyList() {
assertTrue(ArrayTools.concatToList(null).isEmpty());
assertTrue(ArrayTools.concatToList(Collections.emptyList()).isEmpty());
}
@Test
public void testConcatToList_ValidCollection_ReturnsConcatenatedList() {
Character[] charArray1 = { 'a', 'b' };
Character[] charArray2 = { 'c', 'd', 'e' };
List<Character> expected = Arrays.asList('a', 'b', 'c', 'd', 'e');
List<Character> result = ArrayTools.concatToList(Arrays.asList(charArray1, charArray2));
assertEquals(expected, result);
}
// #endregion
// #region - repeat
@Test
void repeat_CharArray_TimesZero_ReturnsEmptyArray() {
char[] input = { 'a', 'b', 'c' };
char[] result = ArrayTools.repeat(input, 0);
assertArrayEquals(ArrayTools.EMPTY_CHAR_ARRAY, result);
}
@Test
void repeat_CharArray_TimesOne_ReturnsSameArray() {
char[] input = { 'a', 'b', 'c' };
char[] result = ArrayTools.repeat(input, 1);
assertArrayEquals(input, result);
}
@Test
void repeat_CharArray_TimesTwo_ReturnsRepeatedArray() {
char[] input = { 'a', 'b', 'c' };
char[] expected = { 'a', 'b', 'c', 'a', 'b', 'c' };
char[] result = ArrayTools.repeat(input, 2);
assertArrayEquals(expected, result);
}
@Test
void repeat_CharArray_WithMaxLength_ReturnsTruncatedArray() {
char[] input = { 'a', 'b', 'c' };
char[] expected = { 'a', 'b', 'c', 'a', 'b' };
char[] result = ArrayTools.repeat(input, 2, 5);
assertArrayEquals(expected, result);
}
@Test
void repeat_ByteArray_TimesZero_ReturnsEmptyArray() {
byte[] input = { 1, 2, 3 };
byte[] result = ArrayTools.repeat(input, 0);
assertArrayEquals(ArrayTools.EMPTY_BYTE_ARRAY, result);
}
@Test
void repeat_ShortArray_TimesZero_ReturnsEmptyArray() {
short[] input = { 1, 2, 3 };
short[] result = ArrayTools.repeat(input, 0);
assertArrayEquals(ArrayTools.EMPTY_SHORT_ARRAY, result);
}
@Test
void repeat_IntArray_TimesZero_ReturnsEmptyArray() {
int[] input = { 1, 2, 3 };
int[] result = ArrayTools.repeat(input, 0);
assertArrayEquals(ArrayTools.EMPTY_INT_ARRAY, result);
}
@Test
void repeat_LongArray_TimesZero_ReturnsEmptyArray() {
long[] input = { 1, 2, 3 };
long[] result = ArrayTools.repeat(input, 0);
assertArrayEquals(ArrayTools.EMPTY_LONG_ARRAY, result);
}
@Test
void repeat_FloatArray_TimesZero_ReturnsEmptyArray() {
float[] input = { 1, 2, 3 };
float[] result = ArrayTools.repeat(input, 0);
assertArrayEquals(ArrayTools.EMPTY_FLOAT_ARRAY, result);
}
@Test
void repeat_DoubleArray_TimesZero_ReturnsEmptyArray() {
double[] input = { 1, 2, 3 };
double[] result = ArrayTools.repeat(input, 0);
assertArrayEquals(ArrayTools.EMPTY_DOUBLE_ARRAY, result);
}
@Test
void repeat_CharArray_ThrowsExceptionForNullArray() {
Executable executable = () -> ArrayTools.repeat((char[]) null, 2);
assertThrows(IllegalArgumentException.class, executable);
}
@Test
void repeat_CharArray_ThrowsExceptionForNegativeTimes() {
char[] input = { 'a', 'b', 'c' };
Executable executable = () -> ArrayTools.repeat(input, -1);
assertThrows(IllegalArgumentException.class, executable);
}
@Test
void repeat_CharArray_ThrowsExceptionForNegativeMaxLength() {
char[] input = { 'a', 'b', 'c' };
Executable executable = () -> ArrayTools.repeat(input, 2, -1);
assertThrows(IllegalArgumentException.class, executable);
}
// #endregion
// TODO 【添加】 补充测试用例
// #region - fill
// #endregion
// #region - indexOf
// #endregion
// #region - lastIndexOf
// #endregion
// #region - contains
// #endregion
}