diff --git a/src/main/java/xyz/zhouxy/plusone/commons/util/AssertTools.java b/src/main/java/xyz/zhouxy/plusone/commons/util/AssertTools.java
index f18688a..23b616a 100644
--- a/src/main/java/xyz/zhouxy/plusone/commons/util/AssertTools.java
+++ b/src/main/java/xyz/zhouxy/plusone/commons/util/AssertTools.java
@@ -98,6 +98,68 @@ public class AssertTools {
     // #endregion - Argument
     // ================================
 
+    // ================================
+    // #region - ArgumentNotNull
+    // ================================
+
+    /**
+     * 判断入参不为 {@code null}
+     *
+     * @param <T> 入参类型
+     * @param obj 入参
+     * @throws IllegalArgumentException 当 {@code obj} 为 {@code null} 时抛出
+     */
+    public static <T> T checkArgumentNotNull(@Nullable T obj) {
+        checkCondition(obj != null, IllegalArgumentException::new);
+        return obj;
+    }
+
+    /**
+     * 判断入参不为 {@code null}
+     *
+     * @param <T> 入参类型
+     * @param obj 入参
+     * @param errorMessage 异常信息
+     * @throws IllegalArgumentException 当 {@code obj} 为 {@code null} 时抛出
+     */
+    public static <T> T checkArgumentNotNull(@Nullable T obj, String errorMessage) {
+        checkCondition(obj != null, () -> new IllegalArgumentException(errorMessage));
+        return obj;
+    }
+
+    /**
+     * 判断入参不为 {@code null}
+     *
+     * @param <T> 入参类型
+     * @param obj 入参
+     * @param errorMessageSupplier 异常信息
+     * @throws IllegalArgumentException 当 {@code obj} 为 {@code null} 时抛出
+     */
+    public static <T> T checkArgumentNotNull(@Nullable T obj, Supplier<String> errorMessageSupplier) {
+        checkCondition(obj != null, () -> new IllegalArgumentException(errorMessageSupplier.get()));
+        return obj;
+    }
+
+    /**
+     * 判断入参不为 {@code null}
+     *
+     * @param <T> 入参类型
+     * @param obj 入参
+     * @param errorMessageTemplate 异常信息模板
+     * @param errorMessageArgs 异常信息参数
+     * @throws IllegalArgumentException 当 {@code obj} 为 {@code null} 时抛出
+     */
+    public static <T> T checkArgumentNotNull(@Nullable T obj,
+            String errorMessageTemplate, Object... errorMessageArgs) {
+        checkCondition(obj != null,
+                () -> new IllegalArgumentException(String.format(errorMessageTemplate, errorMessageArgs)));
+        return obj;
+    }
+
+    // ================================
+    // #endregion - ArgumentNotNull
+    // ================================
+
     // ================================
     // #region - State
     // ================================
@@ -149,7 +211,7 @@ public class AssertTools {
     }
 
     // ================================
-    // #endregion
+    // #endregion - State
     // ================================
 
     // ================================
@@ -207,7 +269,7 @@ public class AssertTools {
     }
 
     // ================================
-    // #endregion
+    // #endregion - NotNull
     // ================================
 
     // ================================
diff --git a/src/test/java/xyz/zhouxy/plusone/commons/util/AssertToolsTests.java b/src/test/java/xyz/zhouxy/plusone/commons/util/AssertToolsTests.java
index 5127592..51962f6 100644
--- a/src/test/java/xyz/zhouxy/plusone/commons/util/AssertToolsTests.java
+++ b/src/test/java/xyz/zhouxy/plusone/commons/util/AssertToolsTests.java
@@ -17,6 +17,7 @@
 package xyz.zhouxy.plusone.commons.util;
 
 import static org.junit.jupiter.api.Assertions.*;
+import static xyz.zhouxy.plusone.commons.util.AssertTools.*;
 
 import java.lang.reflect.Constructor;
 import java.time.LocalDate;
@@ -36,47 +37,47 @@ public class AssertToolsTests {
 
     @Test
     void testCheckArgument_true() {
-        AssertTools.checkArgument(true);
+        checkArgument(true);
     }
 
     @Test
     void testCheckArgument_true_withMessage() {
         final String IGNORE_ME = "IGNORE_ME"; // NOSONAR
-        AssertTools.checkArgument(true, IGNORE_ME);
+        checkArgument(true, IGNORE_ME);
     }
 
     @Test
     void testCheckArgument_true_withNullMessage() {
         final String IGNORE_ME = null; // NOSONAR
-        AssertTools.checkArgument(true, IGNORE_ME);
+        checkArgument(true, IGNORE_ME);
     }
 
     @Test
     void testCheckArgument_true_withMessageSupplier() {
-        AssertTools.checkArgument(true, () -> "Error message: " + LocalDate.now());
+        checkArgument(true, () -> "Error message: " + LocalDate.now());
     }
 
     @Test
     void testCheckArgument_true_withNullMessageSupplier() {
         final Supplier<String> IGNORE_ME = null; // NOSONAR
-        AssertTools.checkArgument(true, IGNORE_ME);
+        checkArgument(true, IGNORE_ME);
     }
 
     @Test
     void testCheckArgument_true_withMessageFormat() {
         LocalDate today = LocalDate.now();
-        AssertTools.checkArgument(true, "String format: %s", today);
+        checkArgument(true, "String format: %s", today);
     }
 
     @Test
     void testCheckArgument_true_withNullMessageFormat() {
-        AssertTools.checkArgument(true, null, LocalDate.now());
+        checkArgument(true, null, LocalDate.now());
     }
 
     @Test
     void testCheckArgument_false() {
         final IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
-                () -> AssertTools.checkArgument(false));
+                () -> checkArgument(false));
 
         assertNull(e.getMessage());
         assertNull(e.getCause());
@@ -87,7 +88,7 @@ public class AssertToolsTests {
         final String message = "testCheckArgument_false_withMessage";
 
         final IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
-                () -> AssertTools.checkArgument(false, message));
+                () -> checkArgument(false, message));
 
         assertEquals(message, e.getMessage());
         assertNull(e.getCause());
@@ -98,7 +99,7 @@ public class AssertToolsTests {
         final String message = null;
 
         final IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
-                () -> AssertTools.checkArgument(false, message));
+                () -> checkArgument(false, message));
 
         assertNull(e.getMessage());
         assertNull(e.getCause());
@@ -108,7 +109,7 @@ public class AssertToolsTests {
     void testCheckArgument_false_withMessageSupplier() {
         final LocalDate today = LocalDate.now();
         final IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
-                () -> AssertTools.checkArgument(false, () -> "Error message: " + today));
+                () -> checkArgument(false, () -> "Error message: " + today));
 
         assertEquals("Error message: " + today, e.getMessage());
         assertNull(e.getCause());
@@ -118,14 +119,14 @@ public class AssertToolsTests {
     void testCheckArgument_false_withNullMessageSupplier() {
         Supplier<String> messageSupplier = null;
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkArgument(false, messageSupplier));
+                () -> checkArgument(false, messageSupplier));
     }
 
     @Test
     void testCheckArgument_false_withMessageFormat() {
         LocalDate today = LocalDate.now();
         final IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
-                () -> AssertTools.checkArgument(false, "String format: %s", today));
+                () -> checkArgument(false, "String format: %s", today));
         assertEquals(String.format("String format: %s", today), e.getMessage());
     }
 
@@ -133,56 +134,176 @@ public class AssertToolsTests {
     void testCheckArgument_false_withNullMessageFormat() {
         LocalDate today = LocalDate.now();
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkArgument(false, null, today));
+                () -> checkArgument(false, null, today));
     }
 
     // #endregion - Argument
 
+    // #region - ArgumentNotNull
+
+    @Test
+    void testCheckArgumentNotNull_notNull() {
+        final Object object = new Object();
+        assertEquals(object, checkArgumentNotNull(object));
+    }
+
+    @Test
+    void testCheckArgumentNotNull_notNull_withMessage() {
+        final Object object = new Object();
+        final String IGNORE_ME = "IGNORE_ME"; // NOSONAR
+        assertEquals(object, checkArgumentNotNull(object, IGNORE_ME));
+    }
+
+    @Test
+    void testCheckArgumentNotNull_notNull_withNullMessage() {
+        final Object object = new Object();
+        final String IGNORE_ME = null; // NOSONAR
+        assertEquals(object, checkArgumentNotNull(object, IGNORE_ME));
+    }
+
+    @Test
+    void testCheckArgumentNotNull_notNull_withMessageSupplier() {
+        final Object object = new Object();
+        assertEquals(object, checkArgumentNotNull(object, () -> "Error message: " + LocalDate.now()));
+    }
+
+    @Test
+    void testCheckArgumentNotNull_notNull_withNullMessageSupplier() {
+        final Object object = new Object();
+        final Supplier<String> IGNORE_ME = null; // NOSONAR
+        assertEquals(object, checkArgumentNotNull(object, IGNORE_ME));
+    }
+
+    @Test
+    void testCheckArgumentNotNull_notNull_withMessageFormat() {
+        final Object object = new Object();
+        LocalDate today = LocalDate.now();
+        assertEquals(object, checkArgumentNotNull(object, "String format: %s", today));
+    }
+
+    @Test
+    void testCheckArgumentNotNull_notNull_withNullMessageFormat() {
+        final Object object = new Object();
+        assertEquals(object, checkArgumentNotNull(object, null, LocalDate.now()));
+    }
+
+    @Test
+    void testCheckArgumentNotNull_null() {
+        final Object object = null;
+        final IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+                () -> checkArgumentNotNull(object));
+
+        assertNull(e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckArgumentNotNull_null_withMessage() {
+        final Object object = null;
+        final String message = "testCheckArgumentNotNull_null_withMessage";
+
+        final IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+                () -> checkArgumentNotNull(object, message));
+
+        assertEquals(message, e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckArgumentNotNull_null_withNullMessage() {
+        final Object object = null;
+        final String message = null;
+
+        final IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+                () -> checkArgumentNotNull(object, message));
+
+        assertNull(e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckArgumentNotNull_null_withMessageSupplier() {
+        final Object object = null;
+        final LocalDate today = LocalDate.now();
+        final IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+                () -> checkArgumentNotNull(object, () -> "Error message: " + today));
+
+        assertEquals("Error message: " + today, e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckArgumentNotNull_null_withNullMessageSupplier() {
+        final Object object = null;
+        Supplier<String> messageSupplier = null;
+        assertThrows(NullPointerException.class,
+                () -> checkArgumentNotNull(object, messageSupplier));
+    }
+
+    @Test
+    void testCheckArgumentNotNull_null_withMessageFormat() {
+        final Object object = null;
+        LocalDate today = LocalDate.now();
+        final IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+                () -> checkArgumentNotNull(object, "String format: %s", today));
+        assertEquals(String.format("String format: %s", today), e.getMessage());
+    }
+
+    @Test
+    void testCheckArgumentNotNull_null_withNullMessageFormat() {
+        final Object object = null;
+        LocalDate today = LocalDate.now();
+        assertThrows(NullPointerException.class,
+                () -> checkArgumentNotNull(object, null, today));
+    }
+
+    // #endregion - ArgumentNotNull
+
     // #region - State
 
     @Test
     void testCheckState_true() {
-        AssertTools.checkState(true);
+        checkState(true);
     }
 
     @Test
     void testCheckState_true_withMessage() {
         final String IGNORE_ME = "IGNORE_ME"; // NOSONAR
-        AssertTools.checkState(true, IGNORE_ME);
+        checkState(true, IGNORE_ME);
     }
 
     @Test
     void testCheckState_true_withNullMessage() {
         final String IGNORE_ME = null; // NOSONAR
-        AssertTools.checkState(true, IGNORE_ME);
+        checkState(true, IGNORE_ME);
     }
 
     @Test
     void testCheckState_true_withMessageSupplier() {
-        AssertTools.checkState(true, () -> "Error message: " + LocalDate.now());
+        checkState(true, () -> "Error message: " + LocalDate.now());
     }
 
     @Test
     void testCheckState_true_withNullMessageSupplier() {
-        final Supplier<String> IGNORE_ME = null; // NOSONAR // NOSONAR
-        AssertTools.checkState(true, IGNORE_ME);
+        final Supplier<String> IGNORE_ME = null; // NOSONAR
+        checkState(true, IGNORE_ME);
     }
 
     @Test
     void testCheckState_true_withMessageFormat() {
         LocalDate today = LocalDate.now();
-        AssertTools.checkState(true, "String format: %s", today);
+        checkState(true, "String format: %s", today);
     }
 
     @Test
     void testCheckState_true_withNullMessageFormat() {
-        AssertTools.checkState(true, null, LocalDate.now());
+        checkState(true, null, LocalDate.now());
     }
 
     @Test
     void testCheckState_false() {
         final IllegalStateException e = assertThrows(IllegalStateException.class,
-                () -> AssertTools.checkState(false));
+                () -> checkState(false));
 
         assertNull(e.getMessage());
         assertNull(e.getCause());
@@ -193,7 +314,7 @@ public class AssertToolsTests {
         final String message = "testCheckState_false_withMessage";
 
         final IllegalStateException e = assertThrows(IllegalStateException.class,
-                () -> AssertTools.checkState(false, message));
+                () -> checkState(false, message));
 
         assertEquals(message, e.getMessage());
         assertNull(e.getCause());
@@ -204,7 +325,7 @@ public class AssertToolsTests {
         final String message = null;
 
         final IllegalStateException e = assertThrows(IllegalStateException.class,
-                () -> AssertTools.checkState(false, message));
+                () -> checkState(false, message));
 
         assertNull(e.getMessage());
         assertNull(e.getCause());
@@ -214,7 +335,7 @@ public class AssertToolsTests {
     void testCheckState_false_withMessageSupplier() {
         final LocalDate today = LocalDate.now();
         final IllegalStateException e = assertThrows(IllegalStateException.class,
-                () -> AssertTools.checkState(false, () -> "Error message: " + today));
+                () -> checkState(false, () -> "Error message: " + today));
 
         assertEquals("Error message: " + today, e.getMessage());
         assertNull(e.getCause());
@@ -224,14 +345,14 @@ public class AssertToolsTests {
     void testCheckState_false_withNullMessageSupplier() {
         Supplier<String> messageSupplier = null;
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkState(false, messageSupplier));
+                () -> checkState(false, messageSupplier));
     }
 
     @Test
     void testCheckState_false_withMessageFormat() {
         LocalDate today = LocalDate.now();
         final IllegalStateException e = assertThrows(IllegalStateException.class,
-                () -> AssertTools.checkState(false, "String format: %s", today));
+                () -> checkState(false, "String format: %s", today));
         assertEquals(String.format("String format: %s", today), e.getMessage());
     }
 
@@ -239,7 +360,7 @@ public class AssertToolsTests {
     void testCheckState_false_withNullMessageFormat() {
         LocalDate today = LocalDate.now();
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkState(false, null, today));
+                () -> checkState(false, null, today));
     }
 
     // #endregion - State
@@ -249,54 +370,54 @@ public class AssertToolsTests {
     @Test
     void testCheckNotNull_notNull() {
         final Object object = new Object();
-        AssertTools.checkNotNull(object);
+        checkNotNull(object);
     }
 
     @Test
     void testCheckNotNull_notNull_withMessage() {
         final Object object = new Object();
         final String IGNORE_ME = "IGNORE_ME"; // NOSONAR
-        AssertTools.checkNotNull(object, IGNORE_ME);
+        checkNotNull(object, IGNORE_ME);
     }
 
     @Test
     void testCheckNotNull_notNull_withNullMessage() {
         final Object object = new Object();
         final String IGNORE_ME = null; // NOSONAR
-        AssertTools.checkNotNull(object, IGNORE_ME);
+        checkNotNull(object, IGNORE_ME);
     }
 
     @Test
     void testCheckNotNull_notNull_withMessageSupplier() {
         final Object object = new Object();
-        AssertTools.checkNotNull(object, () -> "Error message: " + LocalDate.now());
+        checkNotNull(object, () -> "Error message: " + LocalDate.now());
     }
 
     @Test
     void testCheckNotNull_notNull_withNullMessageSupplier() {
         final Object object = new Object();
-        final Supplier<String> IGNORE_ME = null; // NOSONAR // NOSONAR
-        AssertTools.checkNotNull(object, IGNORE_ME);
+        final Supplier<String> IGNORE_ME = null; // NOSONAR
+        checkNotNull(object, IGNORE_ME);
     }
 
     @Test
     void testCheckNotNull_notNull_withMessageFormat() {
         final Object object = new Object();
         LocalDate today = LocalDate.now();
-        AssertTools.checkNotNull(object, "String format: %s", today);
+        checkNotNull(object, "String format: %s", today);
     }
 
     @Test
     void testCheckNotNull_notNull_withNullMessageFormat() {
         final Object object = new Object();
-        AssertTools.checkNotNull(object, null, LocalDate.now());
+        checkNotNull(object, null, LocalDate.now());
     }
 
     @Test
     void testCheckNotNull_null() {
         final Object object = null;
         final NullPointerException e = assertThrows(NullPointerException.class,
-                () -> AssertTools.checkNotNull(object));
+                () -> checkNotNull(object));
 
         assertNull(e.getMessage());
         assertNull(e.getCause());
@@ -308,7 +429,7 @@ public class AssertToolsTests {
         final String message = "testCheckNotNull_null_withMessage";
 
         final NullPointerException e = assertThrows(NullPointerException.class,
-                () -> AssertTools.checkNotNull(object, message));
+                () -> checkNotNull(object, message));
 
         assertEquals(message, e.getMessage());
         assertNull(e.getCause());
@@ -320,7 +441,7 @@ public class AssertToolsTests {
         final String message = null;
 
         final NullPointerException e = assertThrows(NullPointerException.class,
-                () -> AssertTools.checkNotNull(object, message));
+                () -> checkNotNull(object, message));
 
         assertNull(e.getMessage());
         assertNull(e.getCause());
@@ -331,7 +452,7 @@ public class AssertToolsTests {
         final Object object = null;
         final LocalDate today = LocalDate.now();
         final NullPointerException e = assertThrows(NullPointerException.class,
-                () -> AssertTools.checkNotNull(object, () -> "Error message: " + today));
+                () -> checkNotNull(object, () -> "Error message: " + today));
 
         assertEquals("Error message: " + today, e.getMessage());
         assertNull(e.getCause());
@@ -342,7 +463,7 @@ public class AssertToolsTests {
         final Object object = null;
         Supplier<String> messageSupplier = null;
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkNotNull(object, messageSupplier));
+                () -> checkNotNull(object, messageSupplier));
     }
 
     @Test
@@ -350,7 +471,7 @@ public class AssertToolsTests {
         final Object object = null;
         LocalDate today = LocalDate.now();
         final NullPointerException e = assertThrows(NullPointerException.class,
-                () -> AssertTools.checkNotNull(object, "String format: %s", today));
+                () -> checkNotNull(object, "String format: %s", today));
         assertEquals(String.format("String format: %s", today), e.getMessage());
     }
 
@@ -359,7 +480,7 @@ public class AssertToolsTests {
         final Object object = null;
         LocalDate today = LocalDate.now();
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkNotNull(object, null, today));
+                () -> checkNotNull(object, null, today));
     }
 
     // #endregion - NotNull
@@ -369,54 +490,54 @@ public class AssertToolsTests {
     @Test
     void testCheckExists_notNull() throws DataNotExistsException {
         final Object object = new Object();
-        AssertTools.checkExists(object);
+        checkExists(object);
     }
 
     @Test
     void testCheckExists_notNull_withMessage() throws DataNotExistsException {
         final Object object = new Object();
         final String IGNORE_ME = "IGNORE_ME"; // NOSONAR
-        AssertTools.checkExists(object, IGNORE_ME);
+        checkExists(object, IGNORE_ME);
     }
 
     @Test
     void testCheckExists_notNull_withNullMessage() throws DataNotExistsException {
         final Object object = new Object();
         final String IGNORE_ME = null; // NOSONAR
-        AssertTools.checkExists(object, IGNORE_ME);
+        checkExists(object, IGNORE_ME);
     }
 
     @Test
     void testCheckExists_notNull_withMessageSupplier() throws DataNotExistsException {
         final Object object = new Object();
-        AssertTools.checkExists(object, () -> "Error message: " + LocalDate.now());
+        checkExists(object, () -> "Error message: " + LocalDate.now());
     }
 
     @Test
     void testCheckExists_notNull_withNullMessageSupplier() throws DataNotExistsException {
         final Object object = new Object();
-        final Supplier<String> IGNORE_ME = null; // NOSONAR // NOSONAR
-        AssertTools.checkExists(object, IGNORE_ME);
+        final Supplier<String> IGNORE_ME = null; // NOSONAR
+        checkExists(object, IGNORE_ME);
     }
 
     @Test
     void testCheckExists_notNull_withMessageFormat() throws DataNotExistsException {
         final Object object = new Object();
         LocalDate today = LocalDate.now();
-        AssertTools.checkExists(object, "String format: %s", today);
+        checkExists(object, "String format: %s", today);
     }
 
     @Test
     void testCheckExists_notNull_withNullMessageFormat() throws DataNotExistsException {
         final Object object = new Object();
-        AssertTools.checkExists(object, null, LocalDate.now());
+        checkExists(object, null, LocalDate.now());
     }
 
     @Test
     void testCheckExists_null() {
         final Object object = null;
         final DataNotExistsException e = assertThrows(DataNotExistsException.class,
-                () -> AssertTools.checkExists(object));
+                () -> checkExists(object));
 
         assertNull(e.getMessage());
         assertNull(e.getCause());
@@ -428,7 +549,7 @@ public class AssertToolsTests {
         final String message = "testCheckExists_null_withMessage";
 
         final DataNotExistsException e = assertThrows(DataNotExistsException.class,
-                () -> AssertTools.checkExists(object, message));
+                () -> checkExists(object, message));
 
         assertEquals(message, e.getMessage());
         assertNull(e.getCause());
@@ -440,7 +561,7 @@ public class AssertToolsTests {
         final String message = null;
 
         final DataNotExistsException e = assertThrows(DataNotExistsException.class,
-                () -> AssertTools.checkExists(object, message));
+                () -> checkExists(object, message));
 
         assertNull(e.getMessage());
         assertNull(e.getCause());
@@ -451,7 +572,7 @@ public class AssertToolsTests {
         final Object object = null;
         final LocalDate today = LocalDate.now();
         final DataNotExistsException e = assertThrows(DataNotExistsException.class,
-                () -> AssertTools.checkExists(object, () -> "Error message: " + today));
+                () -> checkExists(object, () -> "Error message: " + today));
 
         assertEquals("Error message: " + today, e.getMessage());
         assertNull(e.getCause());
@@ -462,7 +583,7 @@ public class AssertToolsTests {
         final Object object = null;
         Supplier<String> messageSupplier = null;
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkExists(object, messageSupplier));
+                () -> checkExists(object, messageSupplier));
     }
 
     @Test
@@ -470,7 +591,7 @@ public class AssertToolsTests {
         final Object object = null;
         LocalDate today = LocalDate.now();
         final DataNotExistsException e = assertThrows(DataNotExistsException.class,
-                () -> AssertTools.checkExists(object, "String format: %s", today));
+                () -> checkExists(object, "String format: %s", today));
         assertEquals(String.format("String format: %s", today), e.getMessage());
     }
 
@@ -479,60 +600,60 @@ public class AssertToolsTests {
         final Object object = null;
         LocalDate today = LocalDate.now();
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkExists(object, null, today));
+                () -> checkExists(object, null, today));
     }
 
     @Test
     void testCheckExists_optional() throws DataNotExistsException {
         final Optional<Object> object = Optional.of(new Object());
-        AssertTools.checkExists(object);
+        checkExists(object);
     }
 
     @Test
     void testCheckExists_optional_withMessage() throws DataNotExistsException {
         final Optional<Object> object = Optional.of(new Object());
         final String IGNORE_ME = "IGNORE_ME"; // NOSONAR
-        AssertTools.checkExists(object, IGNORE_ME);
+        checkExists(object, IGNORE_ME);
     }
 
     @Test
     void testCheckExists_optional_withNullMessage() throws DataNotExistsException {
         final Optional<Object> object = Optional.of(new Object());
         final String IGNORE_ME = null; // NOSONAR
-        AssertTools.checkExists(object, IGNORE_ME);
+        checkExists(object, IGNORE_ME);
     }
 
     @Test
     void testCheckExists_optional_withMessageSupplier() throws DataNotExistsException {
         final Optional<Object> object = Optional.of(new Object());
-        AssertTools.checkExists(object, () -> "Error message: " + LocalDate.now());
+        checkExists(object, () -> "Error message: " + LocalDate.now());
     }
 
     @Test
     void testCheckExists_optional_withNullMessageSupplier() throws DataNotExistsException {
         final Optional<Object> object = Optional.of(new Object());
         final Supplier<String> IGNORE_ME = null; // NOSONAR
-        AssertTools.checkExists(object, IGNORE_ME);
+        checkExists(object, IGNORE_ME);
     }
 
     @Test
     void testCheckExists_optional_withMessageFormat() throws DataNotExistsException {
         final Optional<Object> object = Optional.of(new Object());
         LocalDate today = LocalDate.now();
-        AssertTools.checkExists(object, "String format: %s", today);
+        checkExists(object, "String format: %s", today);
     }
 
     @Test
     void testCheckExists_optional_withNullMessageFormat() throws DataNotExistsException {
         final Optional<Object> object = Optional.of(new Object());
-        AssertTools.checkExists(object, null, LocalDate.now());
+        checkExists(object, null, LocalDate.now());
     }
 
     @Test
     void testCheckExists_emptyOptional() {
         final Optional<Object> object = Optional.empty();
         final DataNotExistsException e = assertThrows(DataNotExistsException.class,
-                () -> AssertTools.checkExists(object));
+                () -> checkExists(object));
 
         assertNull(e.getMessage());
         assertNull(e.getCause());
@@ -544,7 +665,7 @@ public class AssertToolsTests {
         final String message = "testCheckExists_emptyOptional_withMessage";
 
         final DataNotExistsException e = assertThrows(DataNotExistsException.class,
-                () -> AssertTools.checkExists(object, message));
+                () -> checkExists(object, message));
 
         assertEquals(message, e.getMessage());
         assertNull(e.getCause());
@@ -556,7 +677,7 @@ public class AssertToolsTests {
         final String message = null;
 
         final DataNotExistsException e = assertThrows(DataNotExistsException.class,
-                () -> AssertTools.checkExists(object, message));
+                () -> checkExists(object, message));
 
         assertNull(e.getMessage());
         assertNull(e.getCause());
@@ -567,7 +688,7 @@ public class AssertToolsTests {
         final Optional<Object> object = Optional.empty();
         final LocalDate today = LocalDate.now();
         final DataNotExistsException e = assertThrows(DataNotExistsException.class,
-                () -> AssertTools.checkExists(object, () -> "Error message: " + today));
+                () -> checkExists(object, () -> "Error message: " + today));
 
         assertEquals("Error message: " + today, e.getMessage());
         assertNull(e.getCause());
@@ -578,7 +699,7 @@ public class AssertToolsTests {
         final Optional<Object> object = Optional.empty();
         Supplier<String> messageSupplier = null;
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkExists(object, messageSupplier));
+                () -> checkExists(object, messageSupplier));
     }
 
     @Test
@@ -586,7 +707,7 @@ public class AssertToolsTests {
         final Optional<Object> object = Optional.empty();
         LocalDate today = LocalDate.now();
         final DataNotExistsException e = assertThrows(DataNotExistsException.class,
-                () -> AssertTools.checkExists(object, "String format: %s", today));
+                () -> checkExists(object, "String format: %s", today));
         assertEquals(String.format("String format: %s", today), e.getMessage());
     }
 
@@ -595,14 +716,14 @@ public class AssertToolsTests {
         final Optional<Object> object = Optional.empty();
         LocalDate today = LocalDate.now();
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkExists(object, null, today));
+                () -> checkExists(object, null, today));
     }
 
     @Test
     void testCheckExists_nullOptional() {
         final Optional<Object> object = null;
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkExists(object));
+                () -> checkExists(object));
     }
 
     @Test
@@ -611,7 +732,7 @@ public class AssertToolsTests {
         final String message = "testCheckExists_nullOptional_withMessage";
 
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkExists(object, message));
+                () -> checkExists(object, message));
     }
 
     @Test
@@ -620,7 +741,7 @@ public class AssertToolsTests {
         final String message = null;
 
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkExists(object, message));
+                () -> checkExists(object, message));
     }
 
     @Test
@@ -628,7 +749,7 @@ public class AssertToolsTests {
         final Optional<Object> object = null;
         final LocalDate today = LocalDate.now();
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkExists(object, () -> "Error message: " + today));
+                () -> checkExists(object, () -> "Error message: " + today));
     }
 
     @Test
@@ -636,7 +757,7 @@ public class AssertToolsTests {
         final Optional<Object> object = null;
         Supplier<String> messageSupplier = null;
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkExists(object, messageSupplier));
+                () -> checkExists(object, messageSupplier));
     }
 
     @Test
@@ -644,7 +765,7 @@ public class AssertToolsTests {
         final Optional<Object> object = null;
         LocalDate today = LocalDate.now();
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkExists(object, "String format: %s", today));
+                () -> checkExists(object, "String format: %s", today));
     }
 
     @Test
@@ -652,7 +773,7 @@ public class AssertToolsTests {
         final Optional<Object> object = null;
         LocalDate today = LocalDate.now();
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkExists(object, null, today));
+                () -> checkExists(object, null, today));
     }
 
     // #endregion - Exists
@@ -663,10 +784,10 @@ public class AssertToolsTests {
     void testCheckAffectedRows_int() {
         final int expectedValue = 25;
 
-        AssertTools.checkAffectedRows(expectedValue, 25);
+        checkAffectedRows(expectedValue, 25);
 
         DataOperationResultException e0 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedRows(expectedValue, 108));
+                () -> checkAffectedRows(expectedValue, 108));
         assertEquals(String.format("The number of rows affected is expected to be %d, but is: %d", expectedValue, 108),
                 e0.getMessage());
 
@@ -678,18 +799,18 @@ public class AssertToolsTests {
 
         final String message = "Static message";
 
-        AssertTools.checkAffectedRows(expectedValue, 25, message);
+        checkAffectedRows(expectedValue, 25, message);
 
         DataOperationResultException e1 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedRows(expectedValue, 108, message));
+                () -> checkAffectedRows(expectedValue, 108, message));
         assertEquals(message, e1.getMessage());
 
         final String nullMessage = null;
 
-        AssertTools.checkAffectedRows(expectedValue, 25, nullMessage);
+        checkAffectedRows(expectedValue, 25, nullMessage);
 
         e1 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedRows(expectedValue, 108, nullMessage));
+                () -> checkAffectedRows(expectedValue, 108, nullMessage));
         assertNull(e1.getMessage());
     }
 
@@ -699,44 +820,44 @@ public class AssertToolsTests {
 
         final Supplier<String> messageSupplier = () -> "Supplier message";
 
-        AssertTools.checkAffectedRows(expectedValue, 25, messageSupplier);
+        checkAffectedRows(expectedValue, 25, messageSupplier);
 
         DataOperationResultException e2 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedRows(expectedValue, 108, messageSupplier));
+                () -> checkAffectedRows(expectedValue, 108, messageSupplier));
         assertEquals(messageSupplier.get(), e2.getMessage());
 
         final Supplier<String> nullSupplier = null;
 
-        AssertTools.checkAffectedRows(expectedValue, 25, nullSupplier);
+        checkAffectedRows(expectedValue, 25, nullSupplier);
 
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkAffectedRows(expectedValue, 108, nullSupplier));
+                () -> checkAffectedRows(expectedValue, 108, nullSupplier));
     }
 
     @Test
     void testCheckAffectedRows_int_messageFormat() {
         final int expectedValue = 25;
 
-        AssertTools.checkAffectedRows(expectedValue, 25, "预计是 %d，结果是 %d。", expectedValue, 25);
+        checkAffectedRows(expectedValue, 25, "预计是 %d，结果是 %d。", expectedValue, 25);
 
         DataOperationResultException e3 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedRows(expectedValue, 108, "预计是 %d，结果是 %d。", expectedValue, 108));
+                () -> checkAffectedRows(expectedValue, 108, "预计是 %d，结果是 %d。", expectedValue, 108));
         assertEquals("预计是 25，结果是 108。", e3.getMessage());
 
-        AssertTools.checkAffectedRows(expectedValue, 25, null, expectedValue, 25);
+        checkAffectedRows(expectedValue, 25, null, expectedValue, 25);
 
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkAffectedRows(expectedValue, 108, null, expectedValue, 108));
+                () -> checkAffectedRows(expectedValue, 108, null, expectedValue, 108));
     }
 
     @Test
     void testCheckAffectedRows_long() {
         final long expectedValue = 25L;
 
-        AssertTools.checkAffectedRows(expectedValue, 25L);
+        checkAffectedRows(expectedValue, 25L);
 
         DataOperationResultException e0 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedRows(expectedValue, 108L));
+                () -> checkAffectedRows(expectedValue, 108L));
         assertEquals(String.format("The number of rows affected is expected to be %d, but is: %d", expectedValue, 108L),
                 e0.getMessage());
 
@@ -748,18 +869,18 @@ public class AssertToolsTests {
 
         final String message = "Static message";
 
-        AssertTools.checkAffectedRows(expectedValue, 25L, message);
+        checkAffectedRows(expectedValue, 25L, message);
 
         DataOperationResultException e1 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedRows(expectedValue, 108L, message));
+                () -> checkAffectedRows(expectedValue, 108L, message));
         assertEquals(message, e1.getMessage());
 
         final String nullMessage = null;
 
-        AssertTools.checkAffectedRows(expectedValue, 25L, nullMessage);
+        checkAffectedRows(expectedValue, 25L, nullMessage);
 
         e1 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedRows(expectedValue, 108L, nullMessage));
+                () -> checkAffectedRows(expectedValue, 108L, nullMessage));
         assertNull(e1.getMessage());
     }
 
@@ -769,42 +890,42 @@ public class AssertToolsTests {
 
         final Supplier<String> messageSupplier = () -> "Supplier message";
 
-        AssertTools.checkAffectedRows(expectedValue, 25L, messageSupplier);
+        checkAffectedRows(expectedValue, 25L, messageSupplier);
 
         DataOperationResultException e2 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedRows(expectedValue, 108L, messageSupplier));
+                () -> checkAffectedRows(expectedValue, 108L, messageSupplier));
         assertEquals(messageSupplier.get(), e2.getMessage());
 
         final Supplier<String> nullSupplier = null;
 
-        AssertTools.checkAffectedRows(expectedValue, 25L, nullSupplier);
+        checkAffectedRows(expectedValue, 25L, nullSupplier);
 
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkAffectedRows(expectedValue, 108L, nullSupplier));
+                () -> checkAffectedRows(expectedValue, 108L, nullSupplier));
     }
 
     @Test
     void testCheckAffectedRows_long_messageFormat() {
         final long expectedValue = 25L;
 
-        AssertTools.checkAffectedRows(expectedValue, 25L, "预计是 %d，结果是 %d。", expectedValue, 25L);
+        checkAffectedRows(expectedValue, 25L, "预计是 %d，结果是 %d。", expectedValue, 25L);
 
         DataOperationResultException e3 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedRows(expectedValue, 108L, "预计是 %d，结果是 %d。", expectedValue, 108L));
+                () -> checkAffectedRows(expectedValue, 108L, "预计是 %d，结果是 %d。", expectedValue, 108L));
         assertEquals("预计是 25，结果是 108。", e3.getMessage());
 
-        AssertTools.checkAffectedRows(expectedValue, 25L, null, expectedValue, 25L);
+        checkAffectedRows(expectedValue, 25L, null, expectedValue, 25L);
 
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkAffectedRows(expectedValue, 108L, null, expectedValue, 108L));
+                () -> checkAffectedRows(expectedValue, 108L, null, expectedValue, 108L));
     }
 
     @Test
     void testCheckAffectedOneRow_int() {
-        AssertTools.checkAffectedOneRow(1);
+        checkAffectedOneRow(1);
 
         DataOperationResultException e0 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedOneRow(108));
+                () -> checkAffectedOneRow(108));
         assertEquals(String.format("The number of rows affected is expected to be 1, but is: %d", 108),
                 e0.getMessage());
 
@@ -814,18 +935,18 @@ public class AssertToolsTests {
     void testCheckAffectedOneRow_int_message() {
         final String message = "Static message";
 
-        AssertTools.checkAffectedOneRow(1, message);
+        checkAffectedOneRow(1, message);
 
         DataOperationResultException e1 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedOneRow(108, message));
+                () -> checkAffectedOneRow(108, message));
         assertEquals(message, e1.getMessage());
 
         final String nullMessage = null;
 
-        AssertTools.checkAffectedOneRow(1, nullMessage);
+        checkAffectedOneRow(1, nullMessage);
 
         e1 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedOneRow(108, nullMessage));
+                () -> checkAffectedOneRow(108, nullMessage));
         assertNull(e1.getMessage());
     }
 
@@ -833,40 +954,40 @@ public class AssertToolsTests {
     void testCheckAffectedOneRow_int_messageSupplier() {
         final Supplier<String> messageSupplier = () -> "Supplier message";
 
-        AssertTools.checkAffectedOneRow(1, messageSupplier);
+        checkAffectedOneRow(1, messageSupplier);
 
         DataOperationResultException e2 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedOneRow(108, messageSupplier));
+                () -> checkAffectedOneRow(108, messageSupplier));
         assertEquals(messageSupplier.get(), e2.getMessage());
 
         final Supplier<String> nullSupplier = null;
 
-        AssertTools.checkAffectedOneRow(1, nullSupplier);
+        checkAffectedOneRow(1, nullSupplier);
 
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkAffectedOneRow(108, nullSupplier));
+                () -> checkAffectedOneRow(108, nullSupplier));
     }
 
     @Test
     void testCheckAffectedOneRow_int_messageFormat() {
-        AssertTools.checkAffectedOneRow(1, "预计是 %d，结果是 %d。", 1, 108);
+        checkAffectedOneRow(1, "预计是 %d，结果是 %d。", 1, 108);
 
         DataOperationResultException e3 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedOneRow(108, "预计是 %d，结果是 %d。", 1, 108));
+                () -> checkAffectedOneRow(108, "预计是 %d，结果是 %d。", 1, 108));
         assertEquals("预计是 1，结果是 108。", e3.getMessage());
 
-        AssertTools.checkAffectedOneRow(1, null, 1);
+        checkAffectedOneRow(1, null, 1);
 
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkAffectedOneRow(108, null, 108));
+                () -> checkAffectedOneRow(108, null, 108));
     }
 
     @Test
     void testCheckAffectedOneRow_long() {
-        AssertTools.checkAffectedOneRow(1L);
+        checkAffectedOneRow(1L);
 
         DataOperationResultException e0 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedOneRow(108L));
+                () -> checkAffectedOneRow(108L));
         assertEquals(String.format("The number of rows affected is expected to be 1, but is: %d", 108L),
                 e0.getMessage());
 
@@ -876,18 +997,18 @@ public class AssertToolsTests {
     void testCheckAffectedOneRow_long_message() {
         final String message = "Static message";
 
-        AssertTools.checkAffectedOneRow(1L, message);
+        checkAffectedOneRow(1L, message);
 
         DataOperationResultException e1 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedOneRow(108L, message));
+                () -> checkAffectedOneRow(108L, message));
         assertEquals(message, e1.getMessage());
 
         final String nullMessage = null;
 
-        AssertTools.checkAffectedOneRow(1L, nullMessage);
+        checkAffectedOneRow(1L, nullMessage);
 
         e1 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedOneRow(108L, nullMessage));
+                () -> checkAffectedOneRow(108L, nullMessage));
         assertNull(e1.getMessage());
     }
 
@@ -895,32 +1016,32 @@ public class AssertToolsTests {
     void testCheckAffectedOneRow_long_messageSupplier() {
         final Supplier<String> messageSupplier = () -> "Supplier message";
 
-        AssertTools.checkAffectedOneRow(1L, messageSupplier);
+        checkAffectedOneRow(1L, messageSupplier);
 
         DataOperationResultException e2 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedOneRow(108L, messageSupplier));
+                () -> checkAffectedOneRow(108L, messageSupplier));
         assertEquals(messageSupplier.get(), e2.getMessage());
 
         final Supplier<String> nullSupplier = null;
 
-        AssertTools.checkAffectedOneRow(1L, nullSupplier);
+        checkAffectedOneRow(1L, nullSupplier);
 
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkAffectedOneRow(108L, nullSupplier));
+                () -> checkAffectedOneRow(108L, nullSupplier));
     }
 
     @Test
     void testCheckAffectedOneRow_long_messageFormat() {
-        AssertTools.checkAffectedOneRow(1L, "预计是 %d，结果是 %d。", 1L, 108L);
+        checkAffectedOneRow(1L, "预计是 %d，结果是 %d。", 1L, 108L);
 
         DataOperationResultException e3 = assertThrows(DataOperationResultException.class,
-                () -> AssertTools.checkAffectedOneRow(108L, "预计是 %d，结果是 %d。", 1L, 108L));
+                () -> checkAffectedOneRow(108L, "预计是 %d，结果是 %d。", 1L, 108L));
         assertEquals("预计是 1，结果是 108。", e3.getMessage());
 
-        AssertTools.checkAffectedOneRow(1L, null, 1L);
+        checkAffectedOneRow(1L, null, 1L);
 
         assertThrows(NullPointerException.class,
-                () -> AssertTools.checkAffectedOneRow(108L, null, 108L));
+                () -> checkAffectedOneRow(108L, null, 108L));
     }
 
     // #endregion - AffectedRows
@@ -932,10 +1053,10 @@ public class AssertToolsTests {
     @Test
     void testCheckCondition() {
 
-        AssertTools.checkCondition(true, MyException::new);
+        checkCondition(true, MyException::new);
 
         final MyException me = new MyException();
-        MyException e = assertThrows(MyException.class, () -> AssertTools.checkCondition(false, () -> me));
+        MyException e = assertThrows(MyException.class, () -> checkCondition(false, () -> me));
         assertEquals(me, e);
     }