mirror of
https://gitee.com/chinabugotech/hutool.git
synced 2025-05-09 23:51:34 +08:00
add test
This commit is contained in:
Looly
parent
86cc630bc9
commit
8f62647519
@ -1828,39 +1828,17 @@ public class ArrayUtil extends PrimitiveArrayUtil {
|
||||
// endregion
|
||||
|
||||
// region ----- map
|
||||
|
||||
/**
|
||||
* 按照指定规则，将一种类型的数组转换为另一种类型
|
||||
*
|
||||
* @param array 被转换的数组
|
||||
* @param targetComponentType 目标的元素类型
|
||||
* @param func 转换规则函数
|
||||
* @param <T> 原数组类型
|
||||
* @param <R> 目标数组类型
|
||||
* @return 转换后的数组
|
||||
* @since 5.4.2
|
||||
*/
|
||||
public static <T, R> R[] map(final T[] array, final Class<R> targetComponentType, final Function<? super T, ? extends R> func) {
|
||||
final int length = length(array);
|
||||
final R[] result = newArray(targetComponentType, length);
|
||||
for (int i = 0; i < length; i++) {
|
||||
result[i] = func.apply(array[i]);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* 按照指定规则，将一种类型的数组转换为另一种类型
|
||||
*
|
||||
* @param array 被转换的数组
|
||||
* @param targetComponentType 目标的元素类型
|
||||
* @param func 转换规则函数
|
||||
* @param <T> 原数组类型
|
||||
* @param <R> 目标数组类型
|
||||
* @return 转换后的数组
|
||||
* @since 5.5.8
|
||||
*/
|
||||
public static <T, R> R[] map(final Object array, final Class<R> targetComponentType, final Function<? super T, ? extends R> func) {
|
||||
public static <R> R[] map(final Object array, final Class<R> targetComponentType, final Function<?, ? extends R> func) {
|
||||
final int length = length(array);
|
||||
final R[] result = newArray(targetComponentType, length);
|
||||
for (int i = 0; i < length; i++) {
|
||||
@ -1869,6 +1847,21 @@ public class ArrayUtil extends PrimitiveArrayUtil {
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* 按照指定规则，将一种类型的数组元素转换为另一种类型，并保存为数组
|
||||
*
|
||||
* @param array 被转换的数组
|
||||
* @param func 转换规则函数
|
||||
* @param generator 数组生成器，如返回String[]，则传入String[]::new
|
||||
* @param <T> 原数组类型
|
||||
* @param <R> 目标数组类型
|
||||
* @return 集合
|
||||
*/
|
||||
public static <T, R> R[] mapToArray(final T[] array, final Function<? super T, ? extends R> func,
|
||||
final IntFunction<R[]> generator) {
|
||||
return Arrays.stream(array).map(func).toArray(generator);
|
||||
}
|
||||
|
||||
/**
|
||||
* 按照指定规则，将一种类型的数组元素转换为另一种类型，并保存为 {@link List}
|
||||
*
|
||||
@ -1896,21 +1889,6 @@ public class ArrayUtil extends PrimitiveArrayUtil {
|
||||
public static <T, R> Set<R> mapToSet(final T[] array, final Function<? super T, ? extends R> func) {
|
||||
return Arrays.stream(array).map(func).collect(Collectors.toSet());
|
||||
}
|
||||
|
||||
/**
|
||||
* 按照指定规则，将一种类型的数组元素转换为另一种类型，并保存为数组
|
||||
*
|
||||
* @param array 被转换的数组
|
||||
* @param func 转换规则函数
|
||||
* @param generator 数组生成器，如返回String[]，则传入String[]::new
|
||||
* @param <T> 原数组类型
|
||||
* @param <R> 目标数组类型
|
||||
* @return 集合
|
||||
*/
|
||||
public static <T, R> R[] mapToArray(final T[] array, final Function<? super T, ? extends R> func,
|
||||
final IntFunction<R[]> generator) {
|
||||
return Arrays.stream(array).map(func).toArray(generator);
|
||||
}
|
||||
// endregion
|
||||
|
||||
/**
|
||||
|
||||
@ -13,13 +13,11 @@
|
||||
package org.dromara.hutool.core.date;
|
||||
|
||||
import org.dromara.hutool.core.date.format.FastDateFormat;
|
||||
import org.dromara.hutool.core.date.format.parser.RFC2822DateParser;
|
||||
|
||||
import java.time.ZoneId;
|
||||
import java.time.format.DateTimeFormatter;
|
||||
import java.time.format.DateTimeFormatterBuilder;
|
||||
import java.time.temporal.ChronoField;
|
||||
import java.util.Date;
|
||||
import java.util.Locale;
|
||||
import java.util.TimeZone;
|
||||
|
||||
@ -63,11 +61,6 @@ import java.util.TimeZone;
|
||||
* </p>
|
||||
*
|
||||
* <p>
|
||||
* 其中：CST格式，形如："Mon Aug 15 14:23:15 CST 2022",上面未包含
|
||||
* 参见：{@link RFC2822DateParser#parse(CharSequence)}、{@link DateUtil#parse(String, String...)}、{@link Date#toString()}进行处理
|
||||
* </p>
|
||||
*
|
||||
* <p>
|
||||
* 特殊说明：UTC时间，世界标准时间，0时区的时间，伦敦时间，可以直接加Z表示不加空格，
|
||||
* 如：“09:30 UTC”表示为“09:30Z”或“T0930Z”，其中：Z 是 +00:00 的缩写，意思是 UTC(零时分秒的偏移量).
|
||||
* </p>
|
||||
|
||||
@ -283,7 +283,7 @@ public class FieldUtil {
|
||||
if (null != obj) {
|
||||
final Field[] fields = getFields(obj instanceof Class ? (Class<?>) obj : obj.getClass(), filter);
|
||||
if (null != fields) {
|
||||
return ArrayUtil.map(fields, Object.class, field -> getFieldValue(obj, field));
|
||||
return ArrayUtil.mapToArray(fields, field -> getFieldValue(obj, field), Object[]::new);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
|
||||
@ -13,6 +13,7 @@
|
||||
package org.dromara.hutool.core.array;
|
||||
|
||||
import org.dromara.hutool.core.collection.ListUtil;
|
||||
import org.dromara.hutool.core.collection.set.SetUtil;
|
||||
import org.dromara.hutool.core.util.CharsetUtil;
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
import org.junit.jupiter.api.Test;
|
||||
@ -20,6 +21,9 @@ import org.junit.jupiter.api.Test;
|
||||
import java.math.BigDecimal;
|
||||
import java.util.*;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
|
||||
/**
|
||||
* {@link ArrayUtil} 数组工具单元测试
|
||||
*
|
||||
@ -54,7 +58,7 @@ public class ArrayUtilTest {
|
||||
Assertions.assertFalse(empty);
|
||||
|
||||
// 当这个对象并非数组对象且非`null`时，返回`false`，即当用户传入非数组对象，理解为单个元素的数组。
|
||||
final Object nonArrayObj = "a";
|
||||
final Object nonArrayObj = "a" ;
|
||||
Assertions.assertFalse(ArrayUtil.isEmpty(nonArrayObj));
|
||||
}
|
||||
|
||||
@ -73,67 +77,67 @@ public class ArrayUtilTest {
|
||||
@Test
|
||||
public void newArrayTest() {
|
||||
final String[] newArray = ArrayUtil.newArray(String.class, 3);
|
||||
Assertions.assertEquals(3, newArray.length);
|
||||
assertEquals(3, newArray.length);
|
||||
|
||||
final Object[] newArray2 = ArrayUtil.newArray(3);
|
||||
Assertions.assertEquals(3, newArray2.length);
|
||||
assertEquals(3, newArray2.length);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void cloneTest() {
|
||||
final Integer[] b = {1, 2, 3};
|
||||
final Integer[] cloneB = ArrayUtil.clone(b);
|
||||
Assertions.assertArrayEquals(b, cloneB);
|
||||
assertArrayEquals(b, cloneB);
|
||||
|
||||
final int[] a = {1, 2, 3};
|
||||
final int[] clone = ArrayUtil.clone(a);
|
||||
Assertions.assertArrayEquals(a, clone);
|
||||
assertArrayEquals(a, clone);
|
||||
|
||||
final int[] clone1 = a.clone();
|
||||
Assertions.assertArrayEquals(a, clone1);
|
||||
assertArrayEquals(a, clone1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void filterEditTest() {
|
||||
final Integer[] a = {1, 2, 3, 4, 5, 6};
|
||||
final Integer[] filter = ArrayUtil.edit(a, t -> (t % 2 == 0) ? t : null);
|
||||
Assertions.assertArrayEquals(filter, new Integer[]{2, 4, 6});
|
||||
assertArrayEquals(filter, new Integer[]{2, 4, 6});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void filterTestForFilter() {
|
||||
final Integer[] a = {1, 2, 3, 4, 5, 6};
|
||||
final Integer[] filter = ArrayUtil.filter(a, t -> t % 2 == 0);
|
||||
Assertions.assertArrayEquals(filter, new Integer[]{2, 4, 6});
|
||||
assertArrayEquals(filter, new Integer[]{2, 4, 6});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void editTest() {
|
||||
final Integer[] a = {1, 2, 3, 4, 5, 6};
|
||||
final Integer[] filter = ArrayUtil.edit(a, t -> (t % 2 == 0) ? t * 10 : t);
|
||||
Assertions.assertArrayEquals(filter, new Integer[]{1, 20, 3, 40, 5, 60});
|
||||
assertArrayEquals(filter, new Integer[]{1, 20, 3, 40, 5, 60});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void indexOfTest() {
|
||||
final Integer[] a = {1, 2, 3, 4, 5, 6};
|
||||
final int index = ArrayUtil.indexOf(a, 3);
|
||||
Assertions.assertEquals(2, index);
|
||||
assertEquals(2, index);
|
||||
|
||||
final long[] b = {1, 2, 3, 4, 5, 6};
|
||||
final int index2 = ArrayUtil.indexOf(b, 3);
|
||||
Assertions.assertEquals(2, index2);
|
||||
assertEquals(2, index2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void lastIndexOfTest() {
|
||||
final Integer[] a = {1, 2, 3, 4, 3, 6};
|
||||
final int index = ArrayUtil.lastIndexOf(a, 3);
|
||||
Assertions.assertEquals(4, index);
|
||||
assertEquals(4, index);
|
||||
|
||||
final long[] b = {1, 2, 3, 4, 3, 6};
|
||||
final int index2 = ArrayUtil.lastIndexOf(b, 3);
|
||||
Assertions.assertEquals(4, index2);
|
||||
assertEquals(4, index2);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -178,7 +182,7 @@ public class ArrayUtilTest {
|
||||
@Test
|
||||
public void testContainsIgnoreCaseWithEmptyArray() {
|
||||
final CharSequence[] array = new CharSequence[0];
|
||||
final CharSequence value = "test";
|
||||
final CharSequence value = "test" ;
|
||||
final boolean result = ArrayUtil.containsIgnoreCase(array, value);
|
||||
Assertions.assertFalse(result, "Expected the result to be false for an empty array.");
|
||||
}
|
||||
@ -194,7 +198,7 @@ public class ArrayUtilTest {
|
||||
@Test
|
||||
public void testContainsIgnoreCaseWithExistingValue() {
|
||||
final CharSequence[] array = {"Hello", "World"};
|
||||
final CharSequence value = "world";
|
||||
final CharSequence value = "world" ;
|
||||
final boolean result = ArrayUtil.containsIgnoreCase(array, value);
|
||||
Assertions.assertTrue(result, "Expected the result to be true when the value exists in the array.");
|
||||
}
|
||||
@ -202,7 +206,7 @@ public class ArrayUtilTest {
|
||||
@Test
|
||||
public void testContainsIgnoreCaseWithNonExistingValue() {
|
||||
final CharSequence[] array = {"Hello", "World"};
|
||||
final CharSequence value = "Java";
|
||||
final CharSequence value = "Java" ;
|
||||
final boolean result = ArrayUtil.containsIgnoreCase(array, value);
|
||||
Assertions.assertFalse(result, "Expected the result to be false when the value does not exist in the array.");
|
||||
}
|
||||
@ -210,7 +214,7 @@ public class ArrayUtilTest {
|
||||
@Test
|
||||
public void testContainsIgnoreCaseWithCaseSensitiveValue() {
|
||||
final CharSequence[] array = {"Hello", "World"};
|
||||
final CharSequence value = "HELLO";
|
||||
final CharSequence value = "HELLO" ;
|
||||
final boolean result = ArrayUtil.containsIgnoreCase(array, value);
|
||||
Assertions.assertTrue(result, "Expected the result to be true when the value exists in the array with different case sensitivity.");
|
||||
}
|
||||
@ -220,35 +224,56 @@ public class ArrayUtilTest {
|
||||
final String[] keys = {"a", "b", "c"};
|
||||
final Integer[] values = {1, 2, 3};
|
||||
final Map<String, Integer> map = ArrayUtil.zip(keys, values, true);
|
||||
Assertions.assertEquals(Objects.requireNonNull(map).toString(), "{a=1, b=2, c=3}");
|
||||
assertEquals(Objects.requireNonNull(map).toString(), "{a=1, b=2, c=3}");
|
||||
}
|
||||
|
||||
@Test
|
||||
void mapTest() {
|
||||
final int[] a = {1, 2, 3};
|
||||
final Integer[] map = ArrayUtil.map(a, Integer.class, t -> (int) t * 2);
|
||||
assertEquals("[2, 4, 6]", ArrayUtil.toString(map));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mapToArrayTest() {
|
||||
final String[] keys = {"a", "b", "c"};
|
||||
final Integer[] integers = ArrayUtil.mapToArray(keys, String::length, Integer[]::new);
|
||||
Assertions.assertArrayEquals(integers, new Integer[]{1, 1, 1});
|
||||
assertArrayEquals(new Integer[]{1, 1, 1}, integers);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mapToListTest() {
|
||||
final String[] keys = {"a", "b", "c"};
|
||||
final List<Integer> integers = ArrayUtil.mapToList(keys, String::length);
|
||||
assertEquals(ListUtil.of(1, 1, 1), integers);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mapToSetTest() {
|
||||
final String[] keys = {"a", "b", "c"};
|
||||
final Set<Integer> integers = ArrayUtil.mapToSet(keys, String::length);
|
||||
assertEquals(SetUtil.of(1), integers);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void castTest() {
|
||||
final Object[] values = {"1", "2", "3"};
|
||||
final String[] cast = (String[]) ArrayUtil.cast(String.class, values);
|
||||
Assertions.assertEquals(values[0], cast[0]);
|
||||
Assertions.assertEquals(values[1], cast[1]);
|
||||
Assertions.assertEquals(values[2], cast[2]);
|
||||
assertEquals(values[0], cast[0]);
|
||||
assertEquals(values[1], cast[1]);
|
||||
assertEquals(values[2], cast[2]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void maxTest() {
|
||||
final int max = ArrayUtil.max(1, 2, 13, 4, 5);
|
||||
Assertions.assertEquals(13, max);
|
||||
assertEquals(13, max);
|
||||
|
||||
final long maxLong = ArrayUtil.max(1L, 2L, 13L, 4L, 5L);
|
||||
Assertions.assertEquals(13, maxLong);
|
||||
assertEquals(13, maxLong);
|
||||
|
||||
final double maxDouble = ArrayUtil.max(1D, 2.4D, 13.0D, 4.55D, 5D);
|
||||
Assertions.assertEquals(13.0, maxDouble, 0);
|
||||
assertEquals(13.0, maxDouble, 0);
|
||||
|
||||
final BigDecimal one = new BigDecimal("1.00");
|
||||
final BigDecimal two = new BigDecimal("2.0");
|
||||
@ -256,22 +281,22 @@ public class ArrayUtilTest {
|
||||
final BigDecimal[] bigDecimals = {two, one, three};
|
||||
|
||||
final BigDecimal minAccuracy = ArrayUtil.min(bigDecimals, Comparator.comparingInt(BigDecimal::scale));
|
||||
Assertions.assertEquals(minAccuracy, three);
|
||||
assertEquals(minAccuracy, three);
|
||||
|
||||
final BigDecimal maxAccuracy = ArrayUtil.max(bigDecimals, Comparator.comparingInt(BigDecimal::scale));
|
||||
Assertions.assertEquals(maxAccuracy, one);
|
||||
assertEquals(maxAccuracy, one);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void minTest() {
|
||||
final int min = ArrayUtil.min(1, 2, 13, 4, 5);
|
||||
Assertions.assertEquals(1, min);
|
||||
assertEquals(1, min);
|
||||
|
||||
final long minLong = ArrayUtil.min(1L, 2L, 13L, 4L, 5L);
|
||||
Assertions.assertEquals(1, minLong);
|
||||
assertEquals(1, minLong);
|
||||
|
||||
final double minDouble = ArrayUtil.min(1D, 2.4D, 13.0D, 4.55D, 5D);
|
||||
Assertions.assertEquals(1.0, minDouble, 0);
|
||||
assertEquals(1.0, minDouble, 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -280,7 +305,7 @@ public class ArrayUtilTest {
|
||||
final String[] b = {"a", "b", "c"};
|
||||
|
||||
final String[] result = ArrayUtil.append(a, b);
|
||||
Assertions.assertArrayEquals(new String[]{"1", "2", "3", "4", "a", "b", "c"}, result);
|
||||
assertArrayEquals(new String[]{"1", "2", "3", "4", "a", "b", "c"}, result);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -288,7 +313,7 @@ public class ArrayUtilTest {
|
||||
final String[] a = {"1", "2", "3", "4"};
|
||||
|
||||
final String[] result = ArrayUtil.append(a, "a", "b", "c");
|
||||
Assertions.assertArrayEquals(new String[]{"1", "2", "3", "4", "a", "b", "c"}, result);
|
||||
assertArrayEquals(new String[]{"1", "2", "3", "4", "a", "b", "c"}, result);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -298,69 +323,69 @@ public class ArrayUtilTest {
|
||||
|
||||
// 在-1的位置插入，相当于在3的位置插入
|
||||
String[] result = ArrayUtil.insert(a, -1, b);
|
||||
Assertions.assertArrayEquals(new String[]{"1", "2", "3", "a", "b", "c", "4"}, result);
|
||||
assertArrayEquals(new String[]{"1", "2", "3", "a", "b", "c", "4"}, result);
|
||||
|
||||
// 在第0个位置插入，即在数组前追加
|
||||
result = ArrayUtil.insert(a, 0, b);
|
||||
Assertions.assertArrayEquals(new String[]{"a", "b", "c", "1", "2", "3", "4"}, result);
|
||||
assertArrayEquals(new String[]{"a", "b", "c", "1", "2", "3", "4"}, result);
|
||||
|
||||
// 在第2个位置插入，即"3"之前
|
||||
result = ArrayUtil.insert(a, 2, b);
|
||||
Assertions.assertArrayEquals(new String[]{"1", "2", "a", "b", "c", "3", "4"}, result);
|
||||
assertArrayEquals(new String[]{"1", "2", "a", "b", "c", "3", "4"}, result);
|
||||
|
||||
// 在第4个位置插入，即"4"之后，相当于追加
|
||||
result = ArrayUtil.insert(a, 4, b);
|
||||
Assertions.assertArrayEquals(new String[]{"1", "2", "3", "4", "a", "b", "c"}, result);
|
||||
assertArrayEquals(new String[]{"1", "2", "3", "4", "a", "b", "c"}, result);
|
||||
|
||||
// 在第5个位置插入，由于数组长度为4，因此补充null
|
||||
result = ArrayUtil.insert(a, 5, b);
|
||||
Assertions.assertArrayEquals(new String[]{"1", "2", "3", "4", null, "a", "b", "c"}, result);
|
||||
assertArrayEquals(new String[]{"1", "2", "3", "4", null, "a", "b", "c"}, result);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void joinTest() {
|
||||
final String[] array = {"aa", "bb", "cc", "dd"};
|
||||
final String join = ArrayUtil.join(array, ",", "[", "]");
|
||||
Assertions.assertEquals("[aa],[bb],[cc],[dd]", join);
|
||||
assertEquals("[aa],[bb],[cc],[dd]", join);
|
||||
|
||||
final Object array2 = new String[]{"aa", "bb", "cc", "dd"};
|
||||
final String join2 = ArrayUtil.join(array2, ",");
|
||||
Assertions.assertEquals("aa,bb,cc,dd", join2);
|
||||
assertEquals("aa,bb,cc,dd", join2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinWithNullElement() {
|
||||
final String[] array = { "Java", null, "Python" };
|
||||
final String[] array = {"Java", null, "Python"};
|
||||
final String result = ArrayUtil.join(array, ", ", value -> value == null ? "null" : value);
|
||||
Assertions.assertEquals("Java, null, Python", result);
|
||||
assertEquals("Java, null, Python", result);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinWithEmptyArray() {
|
||||
final String[] array = {};
|
||||
final String result = ArrayUtil.join(array, ", ", String::toUpperCase);
|
||||
Assertions.assertEquals("", result);
|
||||
assertEquals("", result);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinWithoutEditor() {
|
||||
final Integer[] array = { 1, 2, 3 };
|
||||
final Integer[] array = {1, 2, 3};
|
||||
final String result = ArrayUtil.join(array, ", ");
|
||||
Assertions.assertEquals("1, 2, 3", result);
|
||||
assertEquals("1, 2, 3", result);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinWithEditor() {
|
||||
final String[] array = { "java", "scala", "kotlin" };
|
||||
final String[] array = {"java", "scala", "kotlin"};
|
||||
final String result = ArrayUtil.join(array, " -> ", String::toUpperCase);
|
||||
Assertions.assertEquals("JAVA -> SCALA -> KOTLIN", result);
|
||||
assertEquals("JAVA -> SCALA -> KOTLIN", result);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testJoinWithNullConjunction() {
|
||||
final String[] array = { "one", "two", "three" };
|
||||
final String[] array = {"one", "two", "three"};
|
||||
final String result = ArrayUtil.join(array, null, value -> value + "!");
|
||||
Assertions.assertEquals("one!two!three!", result);
|
||||
assertEquals("one!two!three!", result);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -376,7 +401,7 @@ public class ArrayUtilTest {
|
||||
public void distinctTest() {
|
||||
final String[] array = {"aa", "bb", "cc", "dd", "bb", "dd"};
|
||||
final String[] distinct = ArrayUtil.distinct(array);
|
||||
Assertions.assertArrayEquals(new String[]{"aa", "bb", "cc", "dd"}, distinct);
|
||||
assertArrayEquals(new String[]{"aa", "bb", "cc", "dd"}, distinct);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -385,50 +410,50 @@ public class ArrayUtilTest {
|
||||
|
||||
// 覆盖模式下，保留最后加入的两个元素
|
||||
String[] distinct = ArrayUtil.distinct(array, String::toLowerCase, true);
|
||||
Assertions.assertArrayEquals(new String[]{"Aa", "bb"}, distinct);
|
||||
assertArrayEquals(new String[]{"Aa", "bb"}, distinct);
|
||||
|
||||
// 忽略模式下，保留最早加入的两个元素
|
||||
distinct = ArrayUtil.distinct(array, String::toLowerCase, false);
|
||||
Assertions.assertArrayEquals(new String[]{"aa", "BB"}, distinct);
|
||||
assertArrayEquals(new String[]{"aa", "BB"}, distinct);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void toStingTest() {
|
||||
final int[] a = {1, 3, 56, 6, 7};
|
||||
Assertions.assertEquals("[1, 3, 56, 6, 7]", ArrayUtil.toString(a));
|
||||
assertEquals("[1, 3, 56, 6, 7]", ArrayUtil.toString(a));
|
||||
final long[] b = {1, 3, 56, 6, 7};
|
||||
Assertions.assertEquals("[1, 3, 56, 6, 7]", ArrayUtil.toString(b));
|
||||
assertEquals("[1, 3, 56, 6, 7]", ArrayUtil.toString(b));
|
||||
final short[] c = {1, 3, 56, 6, 7};
|
||||
Assertions.assertEquals("[1, 3, 56, 6, 7]", ArrayUtil.toString(c));
|
||||
assertEquals("[1, 3, 56, 6, 7]", ArrayUtil.toString(c));
|
||||
final double[] d = {1, 3, 56, 6, 7};
|
||||
Assertions.assertEquals("[1.0, 3.0, 56.0, 6.0, 7.0]", ArrayUtil.toString(d));
|
||||
assertEquals("[1.0, 3.0, 56.0, 6.0, 7.0]", ArrayUtil.toString(d));
|
||||
final byte[] e = {1, 3, 56, 6, 7};
|
||||
Assertions.assertEquals("[1, 3, 56, 6, 7]", ArrayUtil.toString(e));
|
||||
assertEquals("[1, 3, 56, 6, 7]", ArrayUtil.toString(e));
|
||||
final boolean[] f = {true, false, true, true, true};
|
||||
Assertions.assertEquals("[true, false, true, true, true]", ArrayUtil.toString(f));
|
||||
assertEquals("[true, false, true, true, true]", ArrayUtil.toString(f));
|
||||
final float[] g = {1, 3, 56, 6, 7};
|
||||
Assertions.assertEquals("[1.0, 3.0, 56.0, 6.0, 7.0]", ArrayUtil.toString(g));
|
||||
assertEquals("[1.0, 3.0, 56.0, 6.0, 7.0]", ArrayUtil.toString(g));
|
||||
final char[] h = {'a', 'b', '你', '好', '1'};
|
||||
Assertions.assertEquals("[a, b, 你, 好, 1]", ArrayUtil.toString(h));
|
||||
assertEquals("[a, b, 你, 好, 1]", ArrayUtil.toString(h));
|
||||
|
||||
final String[] array = {"aa", "bb", "cc", "dd", "bb", "dd"};
|
||||
Assertions.assertEquals("[aa, bb, cc, dd, bb, dd]", ArrayUtil.toString(array));
|
||||
assertEquals("[aa, bb, cc, dd, bb, dd]", ArrayUtil.toString(array));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void toArrayTest() {
|
||||
final List<String> list = ListUtil.of("A", "B", "C", "D");
|
||||
final String[] array = ArrayUtil.ofArray(list, String.class);
|
||||
Assertions.assertEquals("A", array[0]);
|
||||
Assertions.assertEquals("B", array[1]);
|
||||
Assertions.assertEquals("C", array[2]);
|
||||
Assertions.assertEquals("D", array[3]);
|
||||
assertEquals("A", array[0]);
|
||||
assertEquals("B", array[1]);
|
||||
assertEquals("C", array[2]);
|
||||
assertEquals("D", array[3]);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void addAllTest() {
|
||||
final int[] ints = ArrayUtil.addAll(new int[]{1, 2, 3}, new int[]{4, 5, 6});
|
||||
Assertions.assertArrayEquals(new int[]{1, 2, 3, 4, 5, 6}, ints);
|
||||
assertArrayEquals(new int[]{1, 2, 3, 4, 5, 6}, ints);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -443,7 +468,7 @@ public class ArrayUtilTest {
|
||||
void firstNonNullTest() {
|
||||
final String[] a = {null, null, "cc", null, "bb", "dd"};
|
||||
final String s = ArrayUtil.firstNonNull(a);
|
||||
Assertions.assertEquals("cc", s);
|
||||
assertEquals("cc", s);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -455,25 +480,25 @@ public class ArrayUtilTest {
|
||||
final Integer[] e = {0x78, 0x9A, 0x10};
|
||||
|
||||
int i = ArrayUtil.indexOfSub(a, b);
|
||||
Assertions.assertEquals(2, i);
|
||||
assertEquals(2, i);
|
||||
|
||||
i = ArrayUtil.indexOfSub(a, c);
|
||||
Assertions.assertEquals(-1, i);
|
||||
assertEquals(-1, i);
|
||||
|
||||
i = ArrayUtil.indexOfSub(a, d);
|
||||
Assertions.assertEquals(3, i);
|
||||
assertEquals(3, i);
|
||||
|
||||
i = ArrayUtil.indexOfSub(a, e);
|
||||
Assertions.assertEquals(-1, i);
|
||||
assertEquals(-1, i);
|
||||
|
||||
i = ArrayUtil.indexOfSub(a, null);
|
||||
Assertions.assertEquals(-1, i);
|
||||
assertEquals(-1, i);
|
||||
|
||||
i = ArrayUtil.indexOfSub(null, null);
|
||||
Assertions.assertEquals(-1, i);
|
||||
assertEquals(-1, i);
|
||||
|
||||
i = ArrayUtil.indexOfSub(null, b);
|
||||
Assertions.assertEquals(-1, i);
|
||||
assertEquals(-1, i);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -481,7 +506,7 @@ public class ArrayUtilTest {
|
||||
final Integer[] a = {0x12, 0x56, 0x34, 0x56, 0x78, 0x9A};
|
||||
final Integer[] b = {0x56, 0x78};
|
||||
final int i = ArrayUtil.indexOfSub(a, b);
|
||||
Assertions.assertEquals(3, i);
|
||||
assertEquals(3, i);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -493,25 +518,25 @@ public class ArrayUtilTest {
|
||||
final Integer[] e = {0x78, 0x9A, 0x10};
|
||||
|
||||
int i = ArrayUtil.lastIndexOfSub(a, b);
|
||||
Assertions.assertEquals(2, i);
|
||||
assertEquals(2, i);
|
||||
|
||||
i = ArrayUtil.lastIndexOfSub(a, c);
|
||||
Assertions.assertEquals(-1, i);
|
||||
assertEquals(-1, i);
|
||||
|
||||
i = ArrayUtil.lastIndexOfSub(a, d);
|
||||
Assertions.assertEquals(3, i);
|
||||
assertEquals(3, i);
|
||||
|
||||
i = ArrayUtil.lastIndexOfSub(a, e);
|
||||
Assertions.assertEquals(-1, i);
|
||||
assertEquals(-1, i);
|
||||
|
||||
i = ArrayUtil.lastIndexOfSub(a, null);
|
||||
Assertions.assertEquals(-1, i);
|
||||
assertEquals(-1, i);
|
||||
|
||||
i = ArrayUtil.lastIndexOfSub(null, null);
|
||||
Assertions.assertEquals(-1, i);
|
||||
assertEquals(-1, i);
|
||||
|
||||
i = ArrayUtil.lastIndexOfSub(null, b);
|
||||
Assertions.assertEquals(-1, i);
|
||||
assertEquals(-1, i);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -519,42 +544,42 @@ public class ArrayUtilTest {
|
||||
final Integer[] a = {0x12, 0x56, 0x78, 0x56, 0x21, 0x9A};
|
||||
final Integer[] b = {0x56, 0x78};
|
||||
final int i = ArrayUtil.indexOfSub(a, b);
|
||||
Assertions.assertEquals(1, i);
|
||||
assertEquals(1, i);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void reverseTest() {
|
||||
final int[] a = {1, 2, 3, 4};
|
||||
final int[] reverse = ArrayUtil.reverse(a);
|
||||
Assertions.assertArrayEquals(new int[]{4, 3, 2, 1}, reverse);
|
||||
assertArrayEquals(new int[]{4, 3, 2, 1}, reverse);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void reverseTest2s() {
|
||||
final Object[] a = {"1", '2', "3", 4};
|
||||
final Object[] reverse = ArrayUtil.reverse(a);
|
||||
Assertions.assertArrayEquals(new Object[]{4, "3", '2', "1"}, reverse);
|
||||
assertArrayEquals(new Object[]{4, "3", '2', "1"}, reverse);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void removeEmptyTest() {
|
||||
final String[] a = {"a", "b", "", null, " ", "c"};
|
||||
final String[] resultA = {"a", "b", " ", "c"};
|
||||
Assertions.assertArrayEquals(ArrayUtil.removeEmpty(a), resultA);
|
||||
assertArrayEquals(ArrayUtil.removeEmpty(a), resultA);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void removeBlankTest() {
|
||||
final String[] a = {"a", "b", "", null, " ", "c"};
|
||||
final String[] resultA = {"a", "b", "c"};
|
||||
Assertions.assertArrayEquals(ArrayUtil.removeBlank(a), resultA);
|
||||
assertArrayEquals(ArrayUtil.removeBlank(a), resultA);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void nullToEmptyTest() {
|
||||
final String[] a = {"a", "b", "", null, " ", "c"};
|
||||
final String[] resultA = {"a", "b", "", "", " ", "c"};
|
||||
Assertions.assertArrayEquals(ArrayUtil.nullToEmpty(a), resultA);
|
||||
assertArrayEquals(ArrayUtil.nullToEmpty(a), resultA);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -580,37 +605,37 @@ public class ArrayUtilTest {
|
||||
final Integer[] a = new Integer[]{1, 2, 3, 4};
|
||||
final int[] wrapA = ArrayUtil.unWrap(a);
|
||||
final Class<?> componentType = wrapA.getClass().getComponentType();
|
||||
Assertions.assertEquals(int.class, componentType);
|
||||
assertEquals(int.class, componentType);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void splitTest() {
|
||||
final byte[] array = new byte[1024];
|
||||
final byte[][] arrayAfterSplit = ArrayUtil.split(array, 500);
|
||||
Assertions.assertEquals(3, arrayAfterSplit.length);
|
||||
Assertions.assertEquals(24, arrayAfterSplit[2].length);
|
||||
assertEquals(3, arrayAfterSplit.length);
|
||||
assertEquals(24, arrayAfterSplit[2].length);
|
||||
|
||||
final byte[] arr = {1, 2, 3, 4, 5, 6, 7};
|
||||
Assertions.assertArrayEquals(new byte[][]{{1, 2, 3, 4, 5, 6, 7}}, ArrayUtil.split(arr, 8));
|
||||
Assertions.assertArrayEquals(new byte[][]{{1, 2, 3, 4, 5, 6, 7}}, ArrayUtil.split(arr, 7));
|
||||
Assertions.assertArrayEquals(new byte[][]{{1, 2, 3, 4}, {5, 6, 7}}, ArrayUtil.split(arr, 4));
|
||||
Assertions.assertArrayEquals(new byte[][]{{1, 2, 3}, {4, 5, 6}, {7}}, ArrayUtil.split(arr, 3));
|
||||
Assertions.assertArrayEquals(new byte[][]{{1, 2}, {3, 4}, {5, 6}, {7}}, ArrayUtil.split(arr, 2));
|
||||
Assertions.assertArrayEquals(new byte[][]{{1}, {2}, {3}, {4}, {5}, {6}, {7}}, ArrayUtil.split(arr, 1));
|
||||
assertArrayEquals(new byte[][]{{1, 2, 3, 4, 5, 6, 7}}, ArrayUtil.split(arr, 8));
|
||||
assertArrayEquals(new byte[][]{{1, 2, 3, 4, 5, 6, 7}}, ArrayUtil.split(arr, 7));
|
||||
assertArrayEquals(new byte[][]{{1, 2, 3, 4}, {5, 6, 7}}, ArrayUtil.split(arr, 4));
|
||||
assertArrayEquals(new byte[][]{{1, 2, 3}, {4, 5, 6}, {7}}, ArrayUtil.split(arr, 3));
|
||||
assertArrayEquals(new byte[][]{{1, 2}, {3, 4}, {5, 6}, {7}}, ArrayUtil.split(arr, 2));
|
||||
assertArrayEquals(new byte[][]{{1}, {2}, {3}, {4}, {5}, {6}, {7}}, ArrayUtil.split(arr, 1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getTest() {
|
||||
final String[] a = {"a", "b", "c"};
|
||||
final Object o = ArrayUtil.get(a, -1);
|
||||
Assertions.assertEquals("c", o);
|
||||
assertEquals("c", o);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getByPredicateTest() {
|
||||
final String[] a = {"a", "b", "c"};
|
||||
final Object o = ArrayUtil.get(a, "b"::equals);
|
||||
Assertions.assertEquals("b", o);
|
||||
assertEquals("b", o);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -620,90 +645,90 @@ public class ArrayUtilTest {
|
||||
|
||||
// 在小于0的位置，-1的位置插入，返回b+a，新数组
|
||||
String[] result = ArrayUtil.replace(a, -1, b);
|
||||
Assertions.assertArrayEquals(new String[]{"a", "b", "c", "1", "2", "3", "4"}, result);
|
||||
assertArrayEquals(new String[]{"a", "b", "c", "1", "2", "3", "4"}, result);
|
||||
|
||||
// 在第0个位置开始替换，返回a
|
||||
result = ArrayUtil.replace(ArrayUtil.clone(a), 0, b);
|
||||
Assertions.assertArrayEquals(new String[]{"a", "b", "c", "4"}, result);
|
||||
assertArrayEquals(new String[]{"a", "b", "c", "4"}, result);
|
||||
|
||||
// 在第1个位置替换，即"2"开始
|
||||
result = ArrayUtil.replace(ArrayUtil.clone(a), 1, b);
|
||||
Assertions.assertArrayEquals(new String[]{"1", "a", "b", "c"}, result);
|
||||
assertArrayEquals(new String[]{"1", "a", "b", "c"}, result);
|
||||
|
||||
// 在第2个位置插入，即"3"之后
|
||||
result = ArrayUtil.replace(ArrayUtil.clone(a), 2, b);
|
||||
Assertions.assertArrayEquals(new String[]{"1", "2", "a", "b", "c"}, result);
|
||||
assertArrayEquals(new String[]{"1", "2", "a", "b", "c"}, result);
|
||||
|
||||
// 在第3个位置插入，即"4"之后
|
||||
result = ArrayUtil.replace(ArrayUtil.clone(a), 3, b);
|
||||
Assertions.assertArrayEquals(new String[]{"1", "2", "3", "a", "b", "c"}, result);
|
||||
assertArrayEquals(new String[]{"1", "2", "3", "a", "b", "c"}, result);
|
||||
|
||||
// 在第4个位置插入，数组长度为4，在索引4出替换即两个数组相加
|
||||
result = ArrayUtil.replace(ArrayUtil.clone(a), 4, b);
|
||||
Assertions.assertArrayEquals(new String[]{"1", "2", "3", "4", "a", "b", "c"}, result);
|
||||
assertArrayEquals(new String[]{"1", "2", "3", "4", "a", "b", "c"}, result);
|
||||
|
||||
// 在大于3个位置插入，数组长度为4，即两个数组相加
|
||||
result = ArrayUtil.replace(ArrayUtil.clone(a), 5, b);
|
||||
Assertions.assertArrayEquals(new String[]{"1", "2", "3", "4", "a", "b", "c"}, result);
|
||||
assertArrayEquals(new String[]{"1", "2", "3", "4", "a", "b", "c"}, result);
|
||||
|
||||
final String[] e = null;
|
||||
final String[] f = {"a", "b", "c"};
|
||||
|
||||
// e为null 返回 f
|
||||
result = ArrayUtil.replace(e, -1, f);
|
||||
Assertions.assertArrayEquals(f, result);
|
||||
assertArrayEquals(f, result);
|
||||
|
||||
final String[] g = {"a", "b", "c"};
|
||||
final String[] h = null;
|
||||
|
||||
// h为null 返回 g
|
||||
result = ArrayUtil.replace(g, 0, h);
|
||||
Assertions.assertArrayEquals(g, result);
|
||||
assertArrayEquals(g, result);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void replaceTest2() {
|
||||
int[] a = new int[0];
|
||||
a = ArrayUtil.replace(a, 0, new int[]{1});
|
||||
Assertions.assertEquals(1, a.length);
|
||||
assertEquals(1, a.length);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setOrAppendTest() {
|
||||
final String[] arr = new String[0];
|
||||
final String[] newArr = ArrayUtil.setOrAppend(arr, 0, "Good");// ClassCastException
|
||||
Assertions.assertArrayEquals(new String[]{"Good"}, newArr);
|
||||
assertArrayEquals(new String[]{"Good"}, newArr);
|
||||
|
||||
// 非空数组替换第一个元素
|
||||
int[] arr2 = new int[]{1};
|
||||
int[] o = ArrayUtil.setOrAppend(arr2, 0, 2);
|
||||
Assertions.assertArrayEquals(new int[]{2}, o);
|
||||
assertArrayEquals(new int[]{2}, o);
|
||||
|
||||
// 空数组追加
|
||||
arr2 = new int[0];
|
||||
o = ArrayUtil.setOrAppend(arr2, 0, 2);
|
||||
Assertions.assertArrayEquals(new int[]{2}, o);
|
||||
assertArrayEquals(new int[]{2}, o);
|
||||
}
|
||||
|
||||
@Test
|
||||
void setOrPaddingTest(){
|
||||
void setOrPaddingTest() {
|
||||
final String[] arr = new String[0];
|
||||
final String[] newArr = ArrayUtil.setOrPadding(arr, 2, "Good");
|
||||
Assertions.assertArrayEquals(new String[]{null, null, "Good"}, newArr);
|
||||
assertArrayEquals(new String[]{null, null, "Good"}, newArr);
|
||||
}
|
||||
|
||||
@Test
|
||||
void setOrPaddingTest2(){
|
||||
void setOrPaddingTest2() {
|
||||
final String[] arr = new String[0];
|
||||
final String[] newArr = ArrayUtil.setOrPadding(arr, 2, "Good");
|
||||
Assertions.assertArrayEquals(new String[]{null, null, "Good"}, newArr);
|
||||
assertArrayEquals(new String[]{null, null, "Good"}, newArr);
|
||||
}
|
||||
|
||||
@Test
|
||||
void setOrPaddingTest3(){
|
||||
void setOrPaddingTest3() {
|
||||
final String[] arr = new String[0];
|
||||
final String[] newArr = ArrayUtil.setOrPadding(arr, 2, "Good", "pad");
|
||||
Assertions.assertArrayEquals(new String[]{"pad", "pad", "Good"}, newArr);
|
||||
assertArrayEquals(new String[]{"pad", "pad", "Good"}, newArr);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -798,20 +823,20 @@ public class ArrayUtilTest {
|
||||
public void subTest() {
|
||||
final int[] arr = {1, 2, 3, 4, 5};
|
||||
final int[] empty = new int[0];
|
||||
Assertions.assertArrayEquals(empty, ArrayUtil.sub(arr, 2, 2));
|
||||
Assertions.assertArrayEquals(empty, ArrayUtil.sub(arr, 5, 5));
|
||||
Assertions.assertArrayEquals(empty, ArrayUtil.sub(arr, 5, 7));
|
||||
Assertions.assertArrayEquals(arr, ArrayUtil.sub(arr, 0, 5));
|
||||
Assertions.assertArrayEquals(arr, ArrayUtil.sub(arr, 5, 0));
|
||||
Assertions.assertArrayEquals(arr, ArrayUtil.sub(arr, 0, 7));
|
||||
Assertions.assertArrayEquals(new int[]{1}, ArrayUtil.sub(arr, 0, 1));
|
||||
Assertions.assertArrayEquals(new int[]{5}, ArrayUtil.sub(arr, 4, 5));
|
||||
Assertions.assertArrayEquals(new int[]{2, 3, 4}, ArrayUtil.sub(arr, 1, 4));
|
||||
Assertions.assertArrayEquals(new int[]{2, 3, 4}, ArrayUtil.sub(arr, 4, 1));
|
||||
Assertions.assertArrayEquals(new int[]{2, 3, 4}, ArrayUtil.sub(arr, 1, -1));
|
||||
Assertions.assertArrayEquals(new int[]{2, 3, 4}, ArrayUtil.sub(arr, -1, 1));
|
||||
Assertions.assertArrayEquals(new int[]{2, 3, 4}, ArrayUtil.sub(arr, -1, 1));
|
||||
Assertions.assertArrayEquals(new int[]{2, 3, 4}, ArrayUtil.sub(arr, -4, -1));
|
||||
assertArrayEquals(empty, ArrayUtil.sub(arr, 2, 2));
|
||||
assertArrayEquals(empty, ArrayUtil.sub(arr, 5, 5));
|
||||
assertArrayEquals(empty, ArrayUtil.sub(arr, 5, 7));
|
||||
assertArrayEquals(arr, ArrayUtil.sub(arr, 0, 5));
|
||||
assertArrayEquals(arr, ArrayUtil.sub(arr, 5, 0));
|
||||
assertArrayEquals(arr, ArrayUtil.sub(arr, 0, 7));
|
||||
assertArrayEquals(new int[]{1}, ArrayUtil.sub(arr, 0, 1));
|
||||
assertArrayEquals(new int[]{5}, ArrayUtil.sub(arr, 4, 5));
|
||||
assertArrayEquals(new int[]{2, 3, 4}, ArrayUtil.sub(arr, 1, 4));
|
||||
assertArrayEquals(new int[]{2, 3, 4}, ArrayUtil.sub(arr, 4, 1));
|
||||
assertArrayEquals(new int[]{2, 3, 4}, ArrayUtil.sub(arr, 1, -1));
|
||||
assertArrayEquals(new int[]{2, 3, 4}, ArrayUtil.sub(arr, -1, 1));
|
||||
assertArrayEquals(new int[]{2, 3, 4}, ArrayUtil.sub(arr, -1, 1));
|
||||
assertArrayEquals(new int[]{2, 3, 4}, ArrayUtil.sub(arr, -4, -1));
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -909,10 +934,10 @@ public class ArrayUtilTest {
|
||||
|
||||
@Test
|
||||
public void copyOfRangeTest() {
|
||||
final String a = "aIDAT";
|
||||
final String a = "aIDAT" ;
|
||||
final byte[] bytes1 = Arrays.copyOfRange(a.getBytes(CharsetUtil.UTF_8), 1, 1 + 4);
|
||||
|
||||
Assertions.assertEquals(new String(bytes1),
|
||||
assertEquals(new String(bytes1),
|
||||
new String(a.getBytes(CharsetUtil.UTF_8), 1, 4));
|
||||
}
|
||||
|
||||
@ -920,14 +945,14 @@ public class ArrayUtilTest {
|
||||
void copyTest() {
|
||||
final String[] dest = new String[3];
|
||||
ArrayUtil.copy(new String[]{"a", "b"}, dest);
|
||||
Assertions.assertArrayEquals(new String[]{"a", "b", null}, dest);
|
||||
assertArrayEquals(new String[]{"a", "b", null}, dest);
|
||||
}
|
||||
|
||||
@Test
|
||||
void copyTest2() {
|
||||
final String[] dest = new String[3];
|
||||
ArrayUtil.copy(new String[]{"a", "b"}, dest, 1);
|
||||
Assertions.assertArrayEquals(new String[]{"a", null, null}, dest);
|
||||
assertArrayEquals(new String[]{"a", null, null}, dest);
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -946,7 +971,7 @@ public class ArrayUtilTest {
|
||||
|
||||
@Test
|
||||
public void hasEmptyVarargsTest() {
|
||||
Assertions.assertFalse(ArrayUtil.hasEmptyVarargs(1,2,3,4,5));
|
||||
Assertions.assertFalse(ArrayUtil.hasEmptyVarargs(1, 2, 3, 4, 5));
|
||||
Assertions.assertTrue(ArrayUtil.hasEmptyVarargs("", " ", " "));
|
||||
Assertions.assertTrue(ArrayUtil.hasEmptyVarargs("", "apple", "pear"));
|
||||
}
|
||||
@ -965,14 +990,14 @@ public class ArrayUtilTest {
|
||||
|
||||
@Test
|
||||
public void isAllEmptyTest() {
|
||||
Assertions.assertFalse(ArrayUtil.isAllEmptyVarargs("apple", "pear", "", "orange"));
|
||||
Assertions.assertFalse(ArrayUtil.isAllEmptyVarargs("apple", "pear", "", "orange"));
|
||||
}
|
||||
|
||||
@Test
|
||||
void emptyCountTest() {
|
||||
final Object[] b = {"a", new ArrayList<>(), new HashMap<>(), new int[0]};
|
||||
final int emptyCount = ArrayUtil.emptyCount(b);
|
||||
Assertions.assertEquals(3, emptyCount);
|
||||
assertEquals(3, emptyCount);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user