更新测试进度

补充单元测试
使用 AssertTools 替代 Preconditions
2024-12-04 01:17:53 +08:00 · 2024-12-04 01:17:42 +08:00 · 2024-12-04 01:17:20 +08:00 · 2024-12-04 01:16:00 +08:00 · 2024-12-04 01:14:20 +08:00
13 changed files with 1156 additions and 190 deletions
--- a/ProgressOfTesting.txt
+++ b/ProgressOfTesting.txt
@@ -1,7 +1,7 @@
-[x] 无需测试
-[ ] 未开始测试
-[-] 测试未完成
-[Y] 测试完成
+[x] 无需测试 - 6
+[ ] 未开始测试 - 38
+[-] 测试未完成 - 15
+[Y] 测试完成 - 11

 xyz.zhouxy.plusone.commons
    ├───annotation
@@ -36,6 +36,7 @@ xyz.zhouxy.plusone.commons
    │       RegexConsts.java                      [ ]
    │
    ├───exception
+    │   │   DataNotExistsException.java           [ ]
    │   │   ParsingFailureException.java          [ ]
    │   │
    │   ├───business
@@ -84,17 +85,17 @@ xyz.zhouxy.plusone.commons
    └───util
            ArrayTools.java                       [-]
            AssertTools.java                      [-]
-            BigDecimals.java                      [-]
+            BigDecimals.java                      [Y]
            ConcurrentHashMapTools.java           [-]
            DateTimeTools.java                    [-]
            Enumeration.java                      [Y]
            EnumTools.java                        [-]
            IdGenerator.java                      [ ]
            IdWorker.java                         [ ]
-            Numbers.java                          [ ]
-            OptionalTools.java                    [ ]
+            Numbers.java                          [Y]
+            OptionalTools.java                    [Y]
            RandomTools.java                      [ ]
            RegexTools.java                       [ ]
            SnowflakeIdGenerator.java             [ ]
-            StringTools.java                      [ ]
+            StringTools.java                      [Y]
            TreeBuilder.java                      [-]
--- a/src/main/java/xyz/zhouxy/plusone/commons/model/dto/UnifiedResponse.java
+++ b/src/main/java/xyz/zhouxy/plusone/commons/model/dto/UnifiedResponse.java
@@ -22,7 +22,7 @@ import java.util.function.Supplier;

 import javax.annotation.Nullable;

-import com.google.common.base.Preconditions;
+import xyz.zhouxy.plusone.commons.util.AssertTools;

 /**
 * 统一结果，对返回给前端的数据进行封装。
@@ -78,16 +78,16 @@ public abstract class UnifiedResponse {

    public static UnifiedResponse of(final boolean isSuccess,
            final Supplier<SuccessResult> successResult, final Supplier<ErrorResult> errorResult) {
-        Preconditions.checkNotNull(successResult, "Success supplier must not be null.");
-        Preconditions.checkNotNull(errorResult, "Error supplier must not be null.");
+        AssertTools.checkNotNull(successResult, "Success supplier must not be null.");
+        AssertTools.checkNotNull(errorResult, "Error supplier must not be null.");
        return isSuccess ? successResult.get() : errorResult.get();
    }

    public static UnifiedResponse of(final BooleanSupplier isSuccess,
            final Supplier<SuccessResult> successResult, final Supplier<ErrorResult> errorResult) {
-        Preconditions.checkNotNull(isSuccess, "Conditions for success must not be null.");
-        Preconditions.checkNotNull(successResult, "Success supplier must not be null.");
-        Preconditions.checkNotNull(errorResult, "Error supplier must not be null.");
+        AssertTools.checkNotNull(isSuccess, "Conditions for success must not be null.");
+        AssertTools.checkNotNull(successResult, "Success supplier must not be null.");
+        AssertTools.checkNotNull(errorResult, "Error supplier must not be null.");
        return isSuccess.getAsBoolean() ? successResult.get() : errorResult.get();
    }

--- a/src/main/java/xyz/zhouxy/plusone/commons/time/YearQuarter.java
+++ b/src/main/java/xyz/zhouxy/plusone/commons/time/YearQuarter.java
@@ -28,10 +28,10 @@ import java.util.Objects;

 import javax.annotation.Nonnull;

-import com.google.common.base.Preconditions;
 import com.google.errorprone.annotations.Immutable;

 import xyz.zhouxy.plusone.commons.annotation.StaticFactoryMethod;
+import xyz.zhouxy.plusone.commons.util.AssertTools;

 /**
 * 表示年份与季度
@@ -52,7 +52,7 @@ public final class YearQuarter implements Comparable<YearQuarter>, Serializable
    private final LocalDate lastDate;

    private YearQuarter(int year, @Nonnull Quarter quarter) {
-        Preconditions.checkNotNull(quarter, "Quarter can not be null.");
+        AssertTools.checkNotNull(quarter, "Quarter can not be null.");
        this.year = year;
        this.quarter = quarter;
        this.firstDate = quarter.firstMonthDay().atYear(year);
--- a/src/main/java/xyz/zhouxy/plusone/commons/util/ArrayTools.java
+++ b/src/main/java/xyz/zhouxy/plusone/commons/util/ArrayTools.java
@@ -23,10 +23,21 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
 import java.util.function.Predicate;
+import java.util.stream.Collectors;

 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;

+/**
+ * ArrayTools
+ *
+ * <p>
+ * 数组工具类
+ * </p>
+ *
+ * @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a>
+ * @since 0.1.0
+ */
 public class ArrayTools {

    // #region - empty arrays
@@ -267,14 +278,18 @@ public class ArrayTools {
     * @param arrays 数组集合，可以为 {@code null}
     * @return 拼接后的数组
     */
-    public static char[] concatCharArray(@Nullable Collection<char[]> arrays) {
+    public static char[] concatCharArray(@Nullable final Collection<char[]> arrays) {
        if (arrays == null || arrays.isEmpty()) {
            return new char[0];
        }
-        final int length = arrays.stream().mapToInt(a -> a.length).sum();
+        final Collection<char[]> arraysToConcat = arrays
+                .stream()
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+        final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum();
        final char[] result = new char[length];
        int i = 0;
-        for (char[] arr : arrays) {
+        for (char[] arr : arraysToConcat) {
            System.arraycopy(arr, 0, result, i, arr.length);
            i += arr.length;
        }
@@ -287,14 +302,18 @@ public class ArrayTools {
     * @param arrays 数组集合，可以为 {@code null}
     * @return 拼接后的数组
     */
-    public static byte[] concatByteArray(@Nullable Collection<byte[]> arrays) {
+    public static byte[] concatByteArray(@Nullable final Collection<byte[]> arrays) {
        if (arrays == null || arrays.isEmpty()) {
            return new byte[0];
        }
-        final int length = arrays.stream().mapToInt(a -> a.length).sum();
+        final Collection<byte[]> arraysToConcat = arrays
+                .stream()
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+        final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum();
        final byte[] result = new byte[length];
        int i = 0;
-        for (byte[] arr : arrays) {
+        for (byte[] arr : arraysToConcat) {
            System.arraycopy(arr, 0, result, i, arr.length);
            i += arr.length;
        }
@@ -307,14 +326,18 @@ public class ArrayTools {
     * @param arrays 数组集合，可以为 {@code null}
     * @return 拼接后的数组
     */
-    public static short[] concatShortArray(@Nullable Collection<short[]> arrays) {
+    public static short[] concatShortArray(@Nullable final Collection<short[]> arrays) {
        if (arrays == null || arrays.isEmpty()) {
            return new short[0];
        }
-        final int length = arrays.stream().mapToInt(a -> a.length).sum();
+        final Collection<short[]> arraysToConcat = arrays
+                .stream()
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+        final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum();
        final short[] result = new short[length];
        int i = 0;
-        for (short[] arr : arrays) {
+        for (short[] arr : arraysToConcat) {
            System.arraycopy(arr, 0, result, i, arr.length);
            i += arr.length;
        }
@@ -327,14 +350,18 @@ public class ArrayTools {
     * @param arrays 数组集合，可以为 {@code null}
     * @return 拼接后的数组
     */
-    public static int[] concatIntArray(@Nullable Collection<int[]> arrays) {
+    public static int[] concatIntArray(@Nullable final Collection<int[]> arrays) {
        if (arrays == null || arrays.isEmpty()) {
            return new int[0];
        }
-        final int length = arrays.stream().mapToInt(a -> a.length).sum();
+        final Collection<int[]> arraysToConcat = arrays
+                .stream()
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+        final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum();
        final int[] result = new int[length];
        int i = 0;
-        for (int[] arr : arrays) {
+        for (int[] arr : arraysToConcat) {
            System.arraycopy(arr, 0, result, i, arr.length);
            i += arr.length;
        }
@@ -347,14 +374,18 @@ public class ArrayTools {
     * @param arrays 数组集合，可以为 {@code null}
     * @return 拼接后的数组
     */
-    public static long[] concatLongArray(@Nullable Collection<long[]> arrays) {
+    public static long[] concatLongArray(@Nullable final Collection<long[]> arrays) {
        if (arrays == null || arrays.isEmpty()) {
            return new long[0];
        }
-        final int length = arrays.stream().mapToInt(a -> a.length).sum();
+        final Collection<long[]> arraysToConcat = arrays
+                .stream()
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+        final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum();
        final long[] result = new long[length];
        int i = 0;
-        for (long[] arr : arrays) {
+        for (long[] arr : arraysToConcat) {
            System.arraycopy(arr, 0, result, i, arr.length);
            i += arr.length;
        }
@@ -367,14 +398,18 @@ public class ArrayTools {
     * @param arrays 数组集合，可以为 {@code null}
     * @return 拼接后的数组
     */
-    public static float[] concatFloatArray(@Nullable Collection<float[]> arrays) {
+    public static float[] concatFloatArray(@Nullable final Collection<float[]> arrays) {
        if (arrays == null || arrays.isEmpty()) {
            return new float[0];
        }
-        final int length = arrays.stream().mapToInt(a -> a.length).sum();
+        final Collection<float[]> arraysToConcat = arrays
+                .stream()
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+        final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum();
        final float[] result = new float[length];
        int i = 0;
-        for (float[] arr : arrays) {
+        for (float[] arr : arraysToConcat) {
            System.arraycopy(arr, 0, result, i, arr.length);
            i += arr.length;
        }
@@ -387,14 +422,18 @@ public class ArrayTools {
     * @param arrays 数组集合，可以为 {@code null}
     * @return 拼接后的数组
     */
-    public static double[] concatDoubleArray(@Nullable Collection<double[]> arrays) {
+    public static double[] concatDoubleArray(@Nullable final Collection<double[]> arrays) {
        if (arrays == null || arrays.isEmpty()) {
            return new double[0];
        }
-        final int length = arrays.stream().mapToInt(a -> a.length).sum();
+        final Collection<double[]> arraysToConcat = arrays
+                .stream()
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+        final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum();
        final double[] result = new double[length];
        int i = 0;
-        for (double[] arr : arrays) {
+        for (double[] arr : arraysToConcat) {
            System.arraycopy(arr, 0, result, i, arr.length);
            i += arr.length;
        }
@@ -408,17 +447,21 @@ public class ArrayTools {
     * @param <T> 泛型参数，表示数组的元素类型
     * @return 返回连接后的列表，如果输入的集合为空或包含空数组，则返回空列表
     */
-    public static <T> List<T> concatToList(@Nullable Collection<T[]> arrays) {
+    public static <T> List<T> concatToList(@Nullable final Collection<T[]> arrays) {
        // 如果输入的集合是否为空，则直接返回一个空列表
        if (arrays == null || arrays.isEmpty()) {
            return Collections.emptyList();
        }

+        final Collection<T[]> arraysToConcat = arrays
+                .stream()
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
        // 计算所有数组的总长度，用于初始化列表的容量
-        final int length = arrays.stream().mapToInt(a -> a.length).sum();
+        final int length = arraysToConcat.stream().mapToInt(a -> a.length).sum();
        final List<T> result = new ArrayList<>(length);

-        for (T[] arr : arrays) {
+        for (T[] arr : arraysToConcat) {
            Collections.addAll(result, arr);
        }

@@ -825,7 +868,7 @@ public class ArrayTools {

    // #region - indexOf

-    public static <T> int indexOf(T[] arr, Predicate<? super T> predicate) { // TODO 单元测试
+    public static <T> int indexOf(T[] arr, Predicate<? super T> predicate) {
        AssertTools.checkNotNull(predicate);
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
@@ -838,11 +881,11 @@ public class ArrayTools {
        return NOT_FOUND_INDEX;
    }

-    public static <T> int indexOf(T[] arr, T obj) { // TODO 单元测试
+    public static <T> int indexOf(T[] arr, T obj) {
        return indexOf(arr, item -> Objects.equals(item, obj));
    }

-    public static int indexOf(char[] arr, char value) { // TODO 单元测试
+    public static int indexOf(char[] arr, char value) {
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
        }
@@ -854,7 +897,7 @@ public class ArrayTools {
        return NOT_FOUND_INDEX;
    }

-    public static int indexOf(byte[] arr, byte value) { // TODO 单元测试
+    public static int indexOf(byte[] arr, byte value) {
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
        }
@@ -866,7 +909,7 @@ public class ArrayTools {
        return NOT_FOUND_INDEX;
    }

-    public static int indexOf(short[] arr, short value) { // TODO 单元测试
+    public static int indexOf(short[] arr, short value) {
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
        }
@@ -878,7 +921,7 @@ public class ArrayTools {
        return NOT_FOUND_INDEX;
    }

-    public static int indexOf(int[] arr, int value) { // TODO 单元测试
+    public static int indexOf(int[] arr, int value) {
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
        }
@@ -890,7 +933,7 @@ public class ArrayTools {
        return NOT_FOUND_INDEX;
    }

-    public static int indexOf(long[] arr, long value) { // TODO 单元测试
+    public static int indexOf(long[] arr, long value) {
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
        }
@@ -902,7 +945,7 @@ public class ArrayTools {
        return NOT_FOUND_INDEX;
    }

-    public static int indexOf(float[] arr, float value) { // TODO 单元测试
+    public static int indexOf(float[] arr, float value) {
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
        }
@@ -914,7 +957,7 @@ public class ArrayTools {
        return NOT_FOUND_INDEX;
    }

-    public static int indexOf(double[] arr, double value) { // TODO 单元测试
+    public static int indexOf(double[] arr, double value) {
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
        }
@@ -930,7 +973,7 @@ public class ArrayTools {

    // #region - lastIndexOf

-    public static <T> int lastIndexOf(T[] arr, @Nonnull Predicate<? super T> predicate) { // TODO 单元测试
+    public static <T> int lastIndexOf(T[] arr, @Nonnull Predicate<? super T> predicate) {
        AssertTools.checkNotNull(predicate);
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
@@ -943,11 +986,11 @@ public class ArrayTools {
        return NOT_FOUND_INDEX;
    }

-    public static <T> int lastIndexOf(T[] arr, T obj) { // TODO 单元测试
+    public static <T> int lastIndexOf(T[] arr, T obj) {
        return lastIndexOf(arr, item -> Objects.equals(item, obj));
    }

-    public static <T> int lastIndexOf(char[] arr, char value) { // TODO 单元测试
+    public static int lastIndexOf(char[] arr, char value) {
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
        }
@@ -959,7 +1002,7 @@ public class ArrayTools {
        return NOT_FOUND_INDEX;
    }

-    public static <T> int lastIndexOf(byte[] arr, byte value) { // TODO 单元测试
+    public static int lastIndexOf(byte[] arr, byte value) {
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
        }
@@ -971,7 +1014,7 @@ public class ArrayTools {
        return NOT_FOUND_INDEX;
    }

-    public static <T> int lastIndexOf(short[] arr, short value) { // TODO 单元测试
+    public static int lastIndexOf(short[] arr, short value) {
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
        }
@@ -983,7 +1026,7 @@ public class ArrayTools {
        return NOT_FOUND_INDEX;
    }

-    public static <T> int lastIndexOf(int[] arr, int value) { // TODO 单元测试
+    public static int lastIndexOf(int[] arr, int value) {
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
        }
@@ -995,7 +1038,7 @@ public class ArrayTools {
        return NOT_FOUND_INDEX;
    }

-    public static <T> int lastIndexOf(long[] arr, long value) { // TODO 单元测试
+    public static int lastIndexOf(long[] arr, long value) {
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
        }
@@ -1007,7 +1050,7 @@ public class ArrayTools {
        return NOT_FOUND_INDEX;
    }

-    public static <T> int lastIndexOf(float[] arr, float value) { // TODO 单元测试
+    public static int lastIndexOf(float[] arr, float value) {
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
        }
@@ -1019,7 +1062,7 @@ public class ArrayTools {
        return NOT_FOUND_INDEX;
    }

-    public static <T> int lastIndexOf(double[] arr, double value) { // TODO 单元测试
+    public static int lastIndexOf(double[] arr, double value) {
        if (isNullOrEmpty(arr)) {
            return NOT_FOUND_INDEX;
        }
@@ -1035,39 +1078,39 @@ public class ArrayTools {

    // #region - contains

-    public static <T> boolean contains(T[] arr, T obj) { // TODO 单元测试
+    public static <T> boolean contains(T[] arr, T obj) {
        return indexOf(arr, obj) > NOT_FOUND_INDEX;
    }

-    public static boolean contains(char[] arr, char obj) { // TODO 单元测试
+    public static boolean contains(char[] arr, char obj) {
        return indexOf(arr, obj) > NOT_FOUND_INDEX;
    }

-    public static boolean contains(byte[] arr, byte obj) { // TODO 单元测试
+    public static boolean contains(byte[] arr, byte obj) {
        return indexOf(arr, obj) > NOT_FOUND_INDEX;
    }

-    public static boolean contains(short[] arr, short obj) { // TODO 单元测试
+    public static boolean contains(short[] arr, short obj) {
        return indexOf(arr, obj) > NOT_FOUND_INDEX;
    }

-    public static boolean contains(int[] arr, int obj) { // TODO 单元测试
+    public static boolean contains(int[] arr, int obj) {
        return indexOf(arr, obj) > NOT_FOUND_INDEX;
    }

-    public static boolean contains(long[] arr, long obj) { // TODO 单元测试
+    public static boolean contains(long[] arr, long obj) {
        return indexOf(arr, obj) > NOT_FOUND_INDEX;
    }

-    public static boolean contains(float[] arr, float obj) { // TODO 单元测试
+    public static boolean contains(float[] arr, float obj) {
        return indexOf(arr, obj) > NOT_FOUND_INDEX;
    }

-    public static boolean contains(double[] arr, double obj) { // TODO 单元测试
+    public static boolean contains(double[] arr, double obj) {
        return indexOf(arr, obj) > NOT_FOUND_INDEX;
    }

-    public static boolean containsValue(BigDecimal[] arr, BigDecimal obj) { // TODO 单元测试
+    public static boolean containsValue(BigDecimal[] arr, BigDecimal obj) {
        return indexOf(arr, item -> BigDecimals.equalsValue(item, obj)) > NOT_FOUND_INDEX;
    }

--- a/src/main/java/xyz/zhouxy/plusone/commons/util/BigDecimals.java
+++ b/src/main/java/xyz/zhouxy/plusone/commons/util/BigDecimals.java
@@ -21,19 +21,27 @@ import java.math.BigDecimal;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;

-import com.google.common.base.Preconditions;
-
 import xyz.zhouxy.plusone.commons.annotation.StaticFactoryMethod;

+/**
+ * BigDecimals
+ *
+ * <p>
+ * BigDecimal 工具类
+ * </p>
+ *
+ * @author <a href="http://zhouxy.xyz:3000/ZhouXY108">ZhouXY</a>
+ * @since 0.1.0
+ */
 public class BigDecimals {

    public static boolean equalsValue(@Nullable BigDecimal a, @Nullable BigDecimal b) {
-        return (a == b) || (a != null && a.compareTo(b) == 0);
+        return (a == b) || (a != null && b != null && a.compareTo(b) == 0);
    }

    public static boolean gt(BigDecimal a, BigDecimal b) {
-        Preconditions.checkNotNull(a, "Parameter could not be null.");
-        Preconditions.checkNotNull(b, "Parameter could not be null.");
+        AssertTools.checkNotNull(a, "Parameter could not be null.");
+        AssertTools.checkNotNull(b, "Parameter could not be null.");
        return (a != b) && (a.compareTo(b) > 0);
    }

@@ -42,8 +50,8 @@ public class BigDecimals {
    }

    public static boolean lt(BigDecimal a, BigDecimal b) {
-        Preconditions.checkNotNull(a, "Parameter could not be null.");
-        Preconditions.checkNotNull(b, "Parameter could not be null.");
+        AssertTools.checkNotNull(a, "Parameter could not be null.");
+        AssertTools.checkNotNull(b, "Parameter could not be null.");
        return (a != b) && (a.compareTo(b) < 0);
    }

--- a/src/main/java/xyz/zhouxy/plusone/commons/util/RegexTools.java
+++ b/src/main/java/xyz/zhouxy/plusone/commons/util/RegexTools.java
@@ -26,8 +26,6 @@ import java.util.regex.Pattern;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;

-import com.google.common.base.Preconditions;
-
 /**
 * 封装一些常用的正则操作，并可以缓存 {@link Pattern} 实例以复用（最多缓存大概 256 个）。
 *
@@ -49,7 +47,7 @@ public final class RegexTools {
     * @return {@link Pattern} 实例
     */
    public static Pattern getPattern(final String pattern, final boolean cachePattern) {
-        Preconditions.checkNotNull(pattern);
+        AssertTools.checkNotNull(pattern);
        return cachePattern ? cacheAndGetPatternInternal(pattern) : getPatternInternal(pattern);
    }

@@ -60,7 +58,7 @@ public final class RegexTools {
     * @return {@link Pattern} 实例
     */
    public static Pattern getPattern(final String pattern) {
-        Preconditions.checkNotNull(pattern);
+        AssertTools.checkNotNull(pattern);
        return getPatternInternal(pattern);
    }

@@ -72,8 +70,8 @@ public final class RegexTools {
     * @return {@link Pattern} 实例数组
     */
    public static Pattern[] getPatterns(final String[] patterns, final boolean cachePattern) {
-        Preconditions.checkNotNull(patterns);
-        Preconditions.checkArgument(allNotNull(patterns));
+        AssertTools.checkNotNull(patterns);
+        AssertTools.checkArgument(allNotNull(patterns));
        return cachePattern
                ? cacheAndGetPatternsInternal(patterns)
                : getPatternsInternal(patterns);
@@ -86,8 +84,8 @@ public final class RegexTools {
     * @return {@link Pattern} 实例数组
     */
    public static Pattern[] getPatterns(final String[] patterns) {
-        Preconditions.checkNotNull(patterns);
-        Preconditions.checkArgument(allNotNull(patterns));
+        AssertTools.checkNotNull(patterns);
+        AssertTools.checkArgument(allNotNull(patterns));
        return getPatternsInternal(patterns);
    }

@@ -98,7 +96,7 @@ public final class RegexTools {
     * @return 缓存的 Pattern 实例。如果缓存已满，则返回 {@code null}。
     */
    public static Pattern cachePattern(final Pattern pattern) {
-        Preconditions.checkNotNull(pattern, "The pattern can not be null.");
+        AssertTools.checkNotNull(pattern, "The pattern can not be null.");
        if (PATTERN_CACHE.size() >= MAX_CACHE_SIZE) {
            return null;
        }
@@ -115,7 +113,7 @@ public final class RegexTools {
     * @return 判断结果
     */
    public static boolean matches(@Nullable final CharSequence input, final Pattern pattern) {
-        Preconditions.checkNotNull(pattern);
+        AssertTools.checkNotNull(pattern);
        return matchesInternal(input, pattern);
    }

@@ -127,8 +125,8 @@ public final class RegexTools {
     * @return 判断结果
     */
    public static boolean matchesOne(@Nullable final CharSequence input, final Pattern[] patterns) {
-        Preconditions.checkNotNull(patterns);
-        Preconditions.checkArgument(allNotNull(patterns));
+        AssertTools.checkNotNull(patterns);
+        AssertTools.checkArgument(allNotNull(patterns));
        return matchesOneInternal(input, patterns);
    }

@@ -140,8 +138,8 @@ public final class RegexTools {
     * @return 判断结果
     */
    public static boolean matchesAll(@Nullable final CharSequence input, final Pattern[] patterns) {
-        Preconditions.checkNotNull(patterns);
-        Preconditions.checkArgument(allNotNull(patterns));
+        AssertTools.checkNotNull(patterns);
+        AssertTools.checkArgument(allNotNull(patterns));
        return matchesAllInternal(input, patterns);
    }

@@ -155,7 +153,7 @@ public final class RegexTools {
     */
    public static boolean matches(@Nullable final CharSequence input, final String pattern,
            final boolean cachePattern) {
-        Preconditions.checkNotNull(pattern);
+        AssertTools.checkNotNull(pattern);
        Pattern p = cachePattern
                ? cacheAndGetPatternInternal(pattern)
                : getPatternInternal(pattern);
@@ -170,7 +168,7 @@ public final class RegexTools {
     * @return 判断结果
     */
    public static boolean matches(@Nullable final CharSequence input, final String pattern) {
-        Preconditions.checkNotNull(pattern);
+        AssertTools.checkNotNull(pattern);
        return matchesInternal(input, getPatternInternal(pattern));
    }

@@ -184,8 +182,8 @@ public final class RegexTools {
     */
    public static boolean matchesOne(@Nullable final CharSequence input, final String[] patterns,
            final boolean cachePattern) {
-        Preconditions.checkNotNull(patterns);
-        Preconditions.checkArgument(allNotNull(patterns));
+        AssertTools.checkNotNull(patterns);
+        AssertTools.checkArgument(allNotNull(patterns));
        final Pattern[] patternSet = cachePattern
                ? cacheAndGetPatternsInternal(patterns)
                : getPatternsInternal(patterns);
@@ -200,8 +198,8 @@ public final class RegexTools {
     * @return 判断结果
     */
    public static boolean matchesOne(@Nullable final CharSequence input, final String[] patterns) {
-        Preconditions.checkNotNull(patterns);
-        Preconditions.checkArgument(allNotNull(patterns));
+        AssertTools.checkNotNull(patterns);
+        AssertTools.checkArgument(allNotNull(patterns));
        final Pattern[] patternSet = getPatternsInternal(patterns);
        return matchesOneInternal(input, patternSet);
    }
@@ -216,8 +214,8 @@ public final class RegexTools {
     */
    public static boolean matchesAll(@Nullable final CharSequence input, final String[] patterns,
            final boolean cachePattern) {
-        Preconditions.checkNotNull(patterns);
-        Preconditions.checkArgument(allNotNull(patterns));
+        AssertTools.checkNotNull(patterns);
+        AssertTools.checkArgument(allNotNull(patterns));
        final Pattern[] patternSet = cachePattern
                ? cacheAndGetPatternsInternal(patterns)
                : getPatternsInternal(patterns);
@@ -232,8 +230,8 @@ public final class RegexTools {
     * @return 判断结果
     */
    public static boolean matchesAll(@Nullable final CharSequence input, final String[] patterns) {
-        Preconditions.checkNotNull(patterns);
-        Preconditions.checkArgument(allNotNull(patterns));
+        AssertTools.checkNotNull(patterns);
+        AssertTools.checkArgument(allNotNull(patterns));
        final Pattern[] patternSet = getPatternsInternal(patterns);
        return matchesAllInternal(input, patternSet);
    }
@@ -246,8 +244,8 @@ public final class RegexTools {
     * @return 结果
     */
    public static Matcher getMatcher(final CharSequence input, final Pattern pattern) {
-        Preconditions.checkNotNull(input);
-        Preconditions.checkNotNull(pattern);
+        AssertTools.checkNotNull(input);
+        AssertTools.checkNotNull(pattern);
        return pattern.matcher(input);
    }

@@ -260,8 +258,8 @@ public final class RegexTools {
     * @return 结果
     */
    public static Matcher getMatcher(final CharSequence input, final String pattern, boolean cachePattern) {
-        Preconditions.checkNotNull(input);
-        Preconditions.checkNotNull(pattern);
+        AssertTools.checkNotNull(input);
+        AssertTools.checkNotNull(pattern);
        final Pattern p = cachePattern
                ? cacheAndGetPatternInternal(pattern)
                : getPatternInternal(pattern);
@@ -276,8 +274,8 @@ public final class RegexTools {
     * @return 结果
     */
    public static Matcher getMatcher(final CharSequence input, final String pattern) {
-        Preconditions.checkNotNull(input);
-        Preconditions.checkNotNull(pattern);
+        AssertTools.checkNotNull(input);
+        AssertTools.checkNotNull(pattern);
        return getPatternInternal(pattern).matcher(input);
    }

--- a/src/main/java/xyz/zhouxy/plusone/commons/util/SnowflakeIdGenerator.java
+++ b/src/main/java/xyz/zhouxy/plusone/commons/util/SnowflakeIdGenerator.java
@@ -19,7 +19,6 @@ package xyz.zhouxy.plusone.commons.util;
 import java.util.concurrent.TimeUnit;

 import com.google.common.annotations.Beta;
-import com.google.common.base.Preconditions;

 /**
 * Twitter_Snowflake
@@ -80,9 +79,9 @@ public class SnowflakeIdGenerator {
     * @param datacenterId 数据中心ID (0~31)
     */
    public SnowflakeIdGenerator(final long workerId, final long datacenterId) {
-        Preconditions.checkArgument((workerId <= MAX_WORKER_ID && workerId >= 0),
+        AssertTools.checkArgument((workerId <= MAX_WORKER_ID && workerId >= 0),
                "WorkerId can't be greater than %s or less than 0.", MAX_WORKER_ID);
-        Preconditions.checkArgument((datacenterId <= MAX_DATACENTER_ID && datacenterId >= 0),
+        AssertTools.checkArgument((datacenterId <= MAX_DATACENTER_ID && datacenterId >= 0),
                "DatacenterId can't be greater than %s or less than 0.", MAX_DATACENTER_ID);
        this.datacenterIdAndWorkerId
                = (datacenterId << DATACENTER_ID_SHIFT) | (workerId << WORKER_ID_SHIFT);
--- a/src/main/java/xyz/zhouxy/plusone/commons/util/TreeBuilder.java
+++ b/src/main/java/xyz/zhouxy/plusone/commons/util/TreeBuilder.java
@@ -27,8 +27,6 @@ import java.util.stream.Collectors;

 import javax.annotation.Nullable;

-import com.google.common.base.Preconditions;
-
 /**
 * TreeBuilder
 *
@@ -63,7 +61,7 @@ public class TreeBuilder<T, TSubTree extends T, TIdentity> {
     * @param nodes 平铺的节点列表
     */
    public List<T> buildTree(Collection<T> nodes) {
-        Preconditions.checkNotNull(nodes);
+        AssertTools.checkNotNull(nodes);
        return buildTreeInternal(nodes, this.defaultComparator);
    }

@@ -80,7 +78,7 @@ public class TreeBuilder<T, TSubTree extends T, TIdentity> {
     *                   <b>仅影响调用 addChild 的顺序，如果操作对象本身对应的控制了子节点的顺序，无法影响其相关逻辑。</b>
     */
    public List<T> buildTree(Collection<T> nodes, @Nullable Comparator<? super T> comparator) {
-        Preconditions.checkNotNull(nodes);
+        AssertTools.checkNotNull(nodes);
        final Comparator<? super T> c = (comparator != null) ? comparator : this.defaultComparator;
        return buildTreeInternal(nodes, c);
    }
--- a/src/test/java/xyz/zhouxy/plusone/commons/util/ArrayToolsTests.java
+++ b/src/test/java/xyz/zhouxy/plusone/commons/util/ArrayToolsTests.java
@@ -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
+
 }
--- a/src/test/java/xyz/zhouxy/plusone/commons/util/BigDecimalsTests.java
+++ b/src/test/java/xyz/zhouxy/plusone/commons/util/BigDecimalsTests.java
@@ -16,11 +16,9 @@

 package xyz.zhouxy.plusone.commons.util;

-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.*;

 import java.math.BigDecimal;
-import java.math.RoundingMode;
-import java.util.function.Function;

 import org.junit.jupiter.api.Test;

@@ -29,76 +27,178 @@ import lombok.extern.slf4j.Slf4j;
@Slf4j
 public class BigDecimalsTests {

+    // TODO 【优化】 检查测试用例
+
    @Test
-    void testToPlainString() {
-
-        BigDecimalFormatter formatter = BigDecimalFormatter.builder()
-                .setScale(2, RoundingMode.HALF_UP)
-                .stripTrailingZeros()
-                .build();
-
-        assertEquals("8.09", formatter.toPlainString(BigDecimals.of("8.090")));
-        assertEquals("8.09", formatter.toPlainString(BigDecimals.of("8.094")));
-        assertEquals("8.1", formatter.toPlainString(BigDecimals.of("8.095")));
-        assertEquals("8.1", formatter.toPlainString(BigDecimals.of("8.096")));
-        assertEquals("8.1", formatter.toPlainString(BigDecimals.of("8.100")));
+    void equalsValue_NullValues_ReturnsTrue() {
+        assertTrue(BigDecimals.equalsValue(null, null));
    }

    @Test
-    void test() {
-        Object a = 100 % 3.0;
-        log.info("a: {}", a);
-    }
-}
-
-class BigDecimalFormatter {
-    private final Function<BigDecimal, BigDecimal> func;
-
-    private BigDecimalFormatter(Function<BigDecimal, BigDecimal> wholeFunc) {
-        this.func = wholeFunc;
-    }
-
-    public static Builder builder() {
-        return new Builder();
-    }
-
-    public String toPlainString(BigDecimal value) {
-        final BigDecimal finalDecimal = func == null ? value : func.apply(value);
-        return finalDecimal.toPlainString();
-    }
-
-    public String toEngineeringString(BigDecimal value) {
-        final BigDecimal finalDecimal = func == null ? value : func.apply(value);
-        return finalDecimal.toEngineeringString();
-    }
-
-    public static class Builder {
-        private Function<BigDecimal, BigDecimal> wholeFunc;
-
-        private Builder() {
-        }
-
-        public Builder setScale(int newScale, RoundingMode roundingMode) {
-            final Function<BigDecimal, BigDecimal> func = value -> value.setScale(newScale, roundingMode);
-            if (wholeFunc == null) {
-                wholeFunc = func;
-            } else {
-                wholeFunc = func.andThen(func);
-            }
-            return this;
-        }
-
-        public Builder stripTrailingZeros() {
-            if (wholeFunc == null) {
-                wholeFunc = BigDecimal::stripTrailingZeros;
-            } else {
-                wholeFunc = wholeFunc.andThen(BigDecimal::stripTrailingZeros);
-            }
-            return this;
-        }
-
-        public BigDecimalFormatter build() {
-            return new BigDecimalFormatter(wholeFunc);
-        }
+    void equalsValue_SameNonNullableValues_ReturnsTrue() {
+        BigDecimal bd1 = new BigDecimal("10");
+        BigDecimal bd2 = new BigDecimal("10.0");
+        assertTrue(BigDecimals.equalsValue(bd1, bd2));
    }
+
+    @Test
+    void equalsValue_DifferentNonNullableValues_ReturnsFalse() {
+        BigDecimal bd1 = new BigDecimal("10");
+        BigDecimal bd2 = new BigDecimal("20");
+        assertFalse(BigDecimals.equalsValue(bd1, bd2));
+    }
+
+    @Test
+    void equalsValue_OneNullOneNonNullValue_ReturnsFalse() {
+        BigDecimal bd = new BigDecimal("10");
+        assertFalse(BigDecimals.equalsValue(bd, null));
+        assertFalse(BigDecimals.equalsValue(null, bd));
+    }
+
+    @Test
+    void gt_NullFirstValue_ThrowsException() {
+        BigDecimal bd = new BigDecimal("10");
+        assertThrows(NullPointerException.class, () -> BigDecimals.gt(null, bd));
+    }
+
+    @Test
+    void gt_NullSecondValue_ThrowsException() {
+        BigDecimal bd = new BigDecimal("10");
+        assertThrows(NullPointerException.class, () -> BigDecimals.gt(bd, null));
+    }
+
+    @Test
+    void gt_SameValues_ReturnsFalse() {
+        BigDecimal bd = new BigDecimal("10");
+        assertFalse(BigDecimals.gt(bd, bd));
+    }
+
+    @Test
+    void gt_FirstGreaterThanSecond_ReturnsTrue() {
+        BigDecimal bd1 = new BigDecimal("20");
+        BigDecimal bd2 = new BigDecimal("10");
+        assertTrue(BigDecimals.gt(bd1, bd2));
+    }
+
+    @Test
+    void ge_NullFirstValue_ThrowsException() {
+        BigDecimal bd = new BigDecimal("10");
+        assertThrows(NullPointerException.class, () -> BigDecimals.ge(null, bd));
+    }
+
+    @Test
+    void ge_NullSecondValue_ThrowsException() {
+        BigDecimal bd = new BigDecimal("10");
+        assertThrows(NullPointerException.class, () -> BigDecimals.ge(bd, null));
+    }
+
+    @Test
+    void ge_SameValues_ReturnsTrue() {
+        BigDecimal bd = new BigDecimal("10");
+        assertTrue(BigDecimals.ge(bd, bd));
+    }
+
+    @Test
+    void ge_FirstGreaterThanSecond_ReturnsTrue() {
+        BigDecimal bd1 = new BigDecimal("20");
+        BigDecimal bd2 = new BigDecimal("10");
+        assertTrue(BigDecimals.ge(bd1, bd2));
+    }
+
+    @Test
+    void lt_NullFirstValue_ThrowsException() {
+        BigDecimal bd = new BigDecimal("10");
+        assertThrows(NullPointerException.class, () -> BigDecimals.lt(null, bd));
+    }
+
+    @Test
+    void lt_NullSecondValue_ThrowsException() {
+        BigDecimal bd = new BigDecimal("10");
+        assertThrows(NullPointerException.class, () -> BigDecimals.lt(bd, null));
+    }
+
+    @Test
+    void lt_SameValues_ReturnsFalse() {
+        BigDecimal bd = new BigDecimal("10");
+        assertFalse(BigDecimals.lt(bd, bd));
+    }
+
+    @Test
+    void lt_FirstLessThanSecond_ReturnsTrue() {
+        BigDecimal bd1 = new BigDecimal("10");
+        BigDecimal bd2 = new BigDecimal("20");
+        assertTrue(BigDecimals.lt(bd1, bd2));
+    }
+
+    @Test
+    void le_NullFirstValue_ThrowsException() {
+        BigDecimal bd = new BigDecimal("10");
+        assertThrows(NullPointerException.class, () -> BigDecimals.le(null, bd));
+    }
+
+    @Test
+    void le_NullSecondValue_ThrowsException() {
+        BigDecimal bd = new BigDecimal("10");
+        assertThrows(NullPointerException.class, () -> BigDecimals.le(bd, null));
+    }
+
+    @Test
+    void le_SameValues_ReturnsTrue() {
+        BigDecimal bd = new BigDecimal("10");
+        assertTrue(BigDecimals.le(bd, bd));
+    }
+
+    @Test
+    void le_FirstLessThanSecond_ReturnsTrue() {
+        BigDecimal bd1 = new BigDecimal("10");
+        BigDecimal bd2 = new BigDecimal("20");
+        assertTrue(BigDecimals.le(bd1, bd2));
+    }
+
+    @Test
+    void sum_NullArray_ReturnsZero() {
+        assertEquals(BigDecimal.ZERO, BigDecimals.sum());
+    }
+
+    @Test
+    void sum_SingleNonNullValue_ReturnsSameValue() {
+        BigDecimal bd = new BigDecimal("10");
+        assertEquals(bd, BigDecimals.sum(bd));
+    }
+
+    @Test
+    void sum_SingleNullValue_ReturnsZero() {
+        assertEquals(BigDecimal.ZERO, BigDecimals.sum((BigDecimal) null));
+    }
+
+    @Test
+    void sum_MultipleValues_ReturnsCorrectSum() {
+        BigDecimal bd1 = new BigDecimal("10");
+        BigDecimal bd2 = new BigDecimal("20");
+        BigDecimal bd3 = new BigDecimal("30");
+        assertEquals(new BigDecimal("60"), BigDecimals.sum(bd1, bd2, bd3));
+    }
+
+    @Test
+    void nullToZero_NullValue_ReturnsZero() {
+        assertEquals(BigDecimal.ZERO, BigDecimals.nullToZero(null));
+    }
+
+    @Test
+    void nullToZero_NonNullValue_ReturnsSameValue() {
+        BigDecimal bd = new BigDecimal("10");
+        assertEquals(bd, BigDecimals.nullToZero(bd));
+    }
+
+    @Test
+    void of_BlankString_ReturnsZero() {
+        assertEquals(BigDecimal.ZERO, BigDecimals.of(" "));
+    }
+
+    @Test
+    void of_NonBlankString_ReturnsCorrectBigDecimal() {
+        BigDecimal bd = new BigDecimal("10");
+        assertEquals(bd, BigDecimals.of("10"));
+    }
+
 }
--- a/src/test/java/xyz/zhouxy/plusone/commons/util/NumbersTests.java
+++ b/src/test/java/xyz/zhouxy/plusone/commons/util/NumbersTests.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright 2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package xyz.zhouxy.plusone.commons.util;
+
+import org.junit.jupiter.api.Test;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public
+class NumbersTests {
+
+    // TODO 【优化】 检查测试用例
+
+    @Test
+    public void sum_ShortArray_ReturnsCorrectSum() {
+        short[] numbers = {1, 2, 3, 4};
+        int result = Numbers.sum(numbers);
+        assertEquals(10, result);
+    }
+
+    @Test
+    public void sum_IntArray_ReturnsCorrectSum() {
+        int[] numbers = {1, 2, 3, 4};
+        long result = Numbers.sum(numbers);
+        assertEquals(10L, result);
+    }
+
+    @Test
+    public void sum_LongArray_ReturnsCorrectSum() {
+        long[] numbers = {1, 2, 3, 4};
+        long result = Numbers.sum(numbers);
+        assertEquals(10L, result);
+    }
+
+    @Test
+    public void sum_FloatArray_ReturnsCorrectSum() {
+        float[] numbers = {1.5f, 2.5f, 3.5f};
+        double result = Numbers.sum(numbers);
+        assertEquals(7.5, result);
+    }
+
+    @Test
+    public void sum_DoubleArray_ReturnsCorrectSum() {
+        double[] numbers = {1.5, 2.5, 3.5};
+        double result = Numbers.sum(numbers);
+        assertEquals(7.5, result);
+    }
+
+    @Test
+    public void sum_BigIntegerArray_ReturnsCorrectSum() {
+        BigInteger[] numbers = {new BigInteger("1"), new BigInteger("2"), new BigInteger("3")};
+        BigInteger result = Numbers.sum(numbers);
+        assertEquals(new BigInteger("6"), result);
+    }
+
+    @Test
+    public void sum_BigDecimalArray_ReturnsCorrectSum() {
+        BigDecimal[] numbers = {new BigDecimal("1.5"), new BigDecimal("2.5"), new BigDecimal("3.5")};
+        BigDecimal result = Numbers.sum(numbers);
+        assertEquals(new BigDecimal("7.5"), result);
+    }
+
+    @Test
+    public void nullToZero_ByteNotNull_ReturnsSameValue() {
+        Byte value = 5;
+        byte result = Numbers.nullToZero(value);
+        assertEquals(5, result);
+    }
+
+    @Test
+    public void nullToZero_ByteNull_ReturnsZero() {
+        Byte value = null;
+        byte result = Numbers.nullToZero(value);
+        assertEquals(0, result);
+    }
+
+    @Test
+    public void nullToZero_ShortNotNull_ReturnsSameValue() {
+        Short value = 5;
+        short result = Numbers.nullToZero(value);
+        assertEquals(5, result);
+    }
+
+    @Test
+    public void nullToZero_ShortNull_ReturnsZero() {
+        Short value = null;
+        short result = Numbers.nullToZero(value);
+        assertEquals(0, result);
+    }
+
+    @Test
+    public void nullToZero_IntegerNotNull_ReturnsSameValue() {
+        Integer value = 5;
+        int result = Numbers.nullToZero(value);
+        assertEquals(5, result);
+    }
+
+    @Test
+    public void nullToZero_IntegerNull_ReturnsZero() {
+        Integer value = null;
+        int result = Numbers.nullToZero(value);
+        assertEquals(0, result);
+    }
+
+    @Test
+    public void nullToZero_LongNotNull_ReturnsSameValue() {
+        Long value = 5L;
+        long result = Numbers.nullToZero(value);
+        assertEquals(5L, result);
+    }
+
+    @Test
+    public void nullToZero_LongNull_ReturnsZero() {
+        Long value = null;
+        long result = Numbers.nullToZero(value);
+        assertEquals(0L, result);
+    }
+
+    @Test
+    public void nullToZero_FloatNotNull_ReturnsSameValue() {
+        Float value = 5.0F;
+        float result = Numbers.nullToZero(value);
+        assertEquals(5.0F, result);
+    }
+
+    @Test
+    public void nullToZero_FloatNull_ReturnsZero() {
+        Float value = null;
+        float result = Numbers.nullToZero(value);
+        assertEquals(0.0F, result);
+    }
+
+    @Test
+    public void nullToZero_DoubleNotNull_ReturnsSameValue() {
+        Double value = 5.0;
+        double result = Numbers.nullToZero(value);
+        assertEquals(5.0, result);
+    }
+
+    @Test
+    public void nullToZero_DoubleNull_ReturnsZero() {
+        Double value = null;
+        double result = Numbers.nullToZero(value);
+        assertEquals(0.0, result);
+    }
+
+    @Test
+    public void nullToZero_BigIntegerNotNull_ReturnsSameValue() {
+        BigInteger value = new BigInteger("5");
+        BigInteger result = Numbers.nullToZero(value);
+        assertEquals(new BigInteger("5"), result);
+    }
+
+    @Test
+    public void nullToZero_BigIntegerNull_ReturnsZero() {
+        BigInteger value = null;
+        BigInteger result = Numbers.nullToZero(value);
+        assertEquals(BigInteger.ZERO, result);
+    }
+
+    @Test
+    public void nullToZero_BigDecimalNotNull_ReturnsSameValue() {
+        BigDecimal value = new BigDecimal("5.0");
+        BigDecimal result = Numbers.nullToZero(value);
+        assertEquals(new BigDecimal("5.0"), result);
+    }
+
+    @Test
+    public void nullToZero_BigDecimalNull_ReturnsZero() {
+        BigDecimal value = null;
+        BigDecimal result = Numbers.nullToZero(value);
+        assertEquals(BigDecimal.ZERO, result);
+    }
+}
--- a/src/test/java/xyz/zhouxy/plusone/commons/util/OptionalToolsTests.java
+++ b/src/test/java/xyz/zhouxy/plusone/commons/util/OptionalToolsTests.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright 2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package xyz.zhouxy.plusone.commons.util;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+import org.junit.jupiter.api.Test;
+
+public
+class OptionalToolsTests {
+
+    // TODO 【优化】 检查测试用例
+
+    @Test
+    void optionalOf_NullInteger_ReturnsEmptyOptionalInt() {
+        OptionalInt result = OptionalTools.optionalOf((Integer) null);
+        assertFalse(result.isPresent());
+    }
+
+    @Test
+    void optionalOf_ValidInteger_ReturnsOptionalIntWithValue() {
+        OptionalInt result = OptionalTools.optionalOf(10);
+        assertTrue(result.isPresent());
+        assertEquals(10, result.getAsInt());
+    }
+
+    @Test
+    void toOptionalInt_NullOptionalInteger_ReturnsEmptyOptionalInt() {
+        OptionalInt result = OptionalTools.toOptionalInt(Optional.ofNullable(null));
+        assertFalse(result.isPresent());
+    }
+
+    @Test
+    void toOptionalInt_ValidOptionalInteger_ReturnsOptionalIntWithValue() {
+        OptionalInt result = OptionalTools.toOptionalInt(Optional.of(10));
+        assertTrue(result.isPresent());
+        assertEquals(10, result.getAsInt());
+    }
+
+    @Test
+    void optionalOf_NullLong_ReturnsEmptyOptionalLong() {
+        OptionalLong result = OptionalTools.optionalOf((Long) null);
+        assertFalse(result.isPresent());
+    }
+
+    @Test
+    void optionalOf_ValidLong_ReturnsOptionalLongWithValue() {
+        OptionalLong result = OptionalTools.optionalOf(10L);
+        assertTrue(result.isPresent());
+        assertEquals(10L, result.getAsLong());
+    }
+
+    @Test
+    void toOptionalLong_NullOptionalLong_ReturnsEmptyOptionalLong() {
+        OptionalLong result = OptionalTools.toOptionalLong(Optional.ofNullable(null));
+        assertFalse(result.isPresent());
+    }
+
+    @Test
+    void toOptionalLong_ValidOptionalLong_ReturnsOptionalLongWithValue() {
+        OptionalLong result = OptionalTools.toOptionalLong(Optional.of(10L));
+        assertTrue(result.isPresent());
+        assertEquals(10L, result.getAsLong());
+    }
+
+    @Test
+    void optionalOf_NullDouble_ReturnsEmptyOptionalDouble() {
+        OptionalDouble result = OptionalTools.optionalOf((Double) null);
+        assertFalse(result.isPresent());
+    }
+
+    @Test
+    void optionalOf_ValidDouble_ReturnsOptionalDoubleWithValue() {
+        OptionalDouble result = OptionalTools.optionalOf(10.0);
+        assertTrue(result.isPresent());
+        assertEquals(10.0, result.getAsDouble(), 0.0001);
+    }
+
+    @Test
+    void toOptionalDouble_NullOptionalDouble_ReturnsEmptyOptionalDouble() {
+        OptionalDouble result = OptionalTools.toOptionalDouble(Optional.ofNullable(null));
+        assertFalse(result.isPresent());
+    }
+
+    @Test
+    void toOptionalDouble_ValidOptionalDouble_ReturnsOptionalDoubleWithValue() {
+        OptionalDouble result = OptionalTools.toOptionalDouble(Optional.of(10.0));
+        assertTrue(result.isPresent());
+        assertEquals(10.0, result.getAsDouble(), 0.0001);
+    }
+
+    @Test
+    void orElseNull_NullOptional_ReturnsNull() {
+        Object result = OptionalTools.orElseNull(Optional.ofNullable(null));
+        assertNull(result);
+    }
+
+    @Test
+    void orElseNull_PresentOptional_ReturnsValue() {
+        Object result = OptionalTools.orElseNull(Optional.of("test"));
+        assertEquals("test", result);
+    }
+
+    @Test
+    void toInteger_NullOptionalInt_ReturnsNull() {
+        Integer result = OptionalTools.toInteger(OptionalInt.empty());
+        assertNull(result);
+    }
+
+    @Test
+    void toInteger_PresentOptionalInt_ReturnsValue() {
+        Integer result = OptionalTools.toInteger(OptionalInt.of(10));
+        assertEquals(10, result);
+    }
+
+    @Test
+    void toLong_NullOptionalLong_ReturnsNull() {
+        Long result = OptionalTools.toLong(OptionalLong.empty());
+        assertNull(result);
+    }
+
+    @Test
+    void toLong_PresentOptionalLong_ReturnsValue() {
+        Long result = OptionalTools.toLong(OptionalLong.of(10L));
+        assertEquals(10L, result);
+    }
+
+    @Test
+    void toDouble_NullOptionalDouble_ReturnsNull() {
+        Double result = OptionalTools.toDouble(OptionalDouble.empty());
+        assertNull(result);
+    }
+
+    @Test
+    void toDouble_PresentOptionalDouble_ReturnsValue() {
+        Double result = OptionalTools.toDouble(OptionalDouble.of(10.0));
+        assertEquals(10.0, result, 0.0001);
+    }
+}
--- a/src/test/java/xyz/zhouxy/plusone/commons/util/StringToolsTests.java
+++ b/src/test/java/xyz/zhouxy/plusone/commons/util/StringToolsTests.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package xyz.zhouxy.plusone.commons.util;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+public
+class StringToolsTests {
+
+    @Test
+    void isNotBlank_NullString_ReturnsFalse() {
+        assertFalse(StringTools.isNotBlank(null));
+    }
+
+    @Test
+    void isNotBlank_EmptyString_ReturnsFalse() {
+        assertFalse(StringTools.isNotBlank(""));
+    }
+
+    @Test
+    void isNotBlank_WhitespaceString_ReturnsFalse() {
+        assertFalse(StringTools.isNotBlank("   "));
+    }
+
+    @Test
+    void isNotBlank_NonWhitespaceString_ReturnsTrue() {
+        assertTrue(StringTools.isNotBlank("Hello"));
+    }
+
+    @Test
+    void repeat_NullString_ThrowsException() {
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            StringTools.repeat(null, 2);
+        });
+        assertNull(exception.getMessage());
+    }
+
+    @Test
+    void repeat_EmptyString_ReturnsEmptyString() {
+        assertEquals("", StringTools.repeat("", 2));
+    }
+
+    @Test
+    void repeat_RepeatOnce_ReturnsOriginalString() {
+        assertEquals("Hello", StringTools.repeat("Hello", 1));
+    }
+
+    @Test
+    void repeat_RepeatMultipleTimes_ReturnsRepeatedString() {
+        assertEquals("HelloHelloHello", StringTools.repeat("Hello", 3));
+    }
+
+    @Test
+    void repeat_ExceedsMaxLength_ReturnsTruncatedString() {
+        assertEquals("HelloHello", StringTools.repeat("Hello", 2, 14));
+        assertEquals("HelloHel", StringTools.repeat("Hello", 2, 8));
+        assertEquals("He", StringTools.repeat("Hello", 2, 2));
+        assertEquals("", StringTools.repeat("Hello", 0, 2));
+        assertThrows(IllegalArgumentException.class, () -> StringTools.repeat("Hello", -1, 2));
+        assertThrows(IllegalArgumentException.class, () -> StringTools.repeat("Hello", 5, -1));
+    }
+
+    @Test
+    void repeat_ZeroTimes_ReturnsEmptyString() {
+        assertEquals("", StringTools.repeat("Hello", 0));
+    }
+}
Author	SHA1	Message	Date
ZhouXY108	75b39de99f	更新测试进度	2024-12-04 01:17:53 +08:00
ZhouXY108	ab318136a8	补充单元测试	2024-12-04 01:17:42 +08:00
ZhouXY108	b4115aae95	使用 AssertTools 替代 Preconditions	2024-12-04 01:17:20 +08:00
ZhouXY108	10761e92ec	BigDecimals：修复 equalsValue 方法第二个参数为 null 报空指针的问题；补充单元测试	2024-12-04 01:16:00 +08:00
ZhouXY108	65f0bb062c	ArrayTools：修复 concat 方法的参数 arrays 中存在 null，从而报空指针的问题；补充单元测试	2024-12-04 01:14:20 +08:00