完成 AssertTools 单元测试，修复错误

ProgressOfTesting.txt

@@ -1,6 +1,6 @@
 [ ] 未开始测试 - 25 (35.71%)
-[-] 测试未完成 - 14 (20.00%)
+[-] 测试未完成 - 13 (18.57%)
-[Y] 测试完成 - 19 (27.14%)
+[Y] 测试完成 - 20 (28.57%)
 [x] 无需测试 - 12 (17.14%)
 
 xyz.zhouxy.plusone.commons
@@ -84,7 +84,7 @@ xyz.zhouxy.plusone.commons
     │
     └───util
             ArrayTools.java                       [-]
-            AssertTools.java                      [-]
+            AssertTools.java                      [Y]
             BigDecimals.java                      [Y]
             ConcurrentHashMapTools.java           [-]
             DateTimeTools.java                    [-]

src/main/java/xyz/zhouxy/plusone/commons/util/AssertTools.java

@@ -217,21 +217,22 @@ public class AssertTools {
                 () -> new DataOperationResultException(String.format(format, args)));
     }
 
-    public static void checkAffectedRows(long result, long expectedValue) {
+    public static void checkAffectedRows(long expectedValue, long result) {
-        checkCondition(expectedValue == result, DataOperationResultException::new);
+        checkAffectedRows(expectedValue, result,
+                "The number of rows affected is expected to be %d, but is: %d", expectedValue, result);
     }
 
-    public static void checkAffectedRows(long result, long expectedValue, String message) {
+    public static void checkAffectedRows(long expectedValue, long result, String message) {
         checkCondition(expectedValue == result, () -> new DataOperationResultException(message));
     }
 
-    public static void checkAffectedRows(long result, long expectedValue,
+    public static void checkAffectedRows(long expectedValue, long result,
             @Nonnull Supplier<String> messageSupplier) {
         checkCondition(expectedValue == result,
                 () -> new DataOperationResultException(messageSupplier.get()));
     }
 
-    public static void checkAffectedRows(long result, long expectedValue, String format, Object... args) {
+    public static void checkAffectedRows(long expectedValue, long result, String format, Object... args) {
         checkCondition(expectedValue == result,
                 () -> new DataOperationResultException(String.format(format, args)));
     }
@@ -253,6 +254,23 @@ public class AssertTools {
         checkAffectedRows(1, result, format, args);
     }
 
+    public static void checkAffectedOneRow(long result) {
+        checkAffectedRows(1L, result,
+                () -> "The number of rows affected is expected to be 1, but is: " + result);
+    }
+
+    public static void checkAffectedOneRow(long result, String message) {
+        checkAffectedRows(1L, result, message);
+    }
+
+    public static void checkAffectedOneRow(long result, @Nonnull Supplier<String> messageSupplier) {
+        checkAffectedRows(1L, result, messageSupplier);
+    }
+
+    public static void checkAffectedOneRow(long result, String format, Object... args) {
+        checkAffectedRows(1L, result, format, args);
+    }
+
     // ================================
     // #endregion - AffectedRows
     // ================================

src/test/java/xyz/zhouxy/plusone/commons/util/AssertToolsTests.java

@@ -0,0 +1,941 @@
+/*
+ * 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.*;
+
+import java.time.LocalDate;
+import java.util.Optional;
+import java.util.function.Supplier;
+
+import org.junit.jupiter.api.Test;
+
+import xyz.zhouxy.plusone.commons.exception.DataNotExistsException;
+import xyz.zhouxy.plusone.commons.exception.system.DataOperationResultException;
+
+@SuppressWarnings("null")
+public class AssertToolsTests {
+
+    // #region - Argument
+
+    @Test
+    void testCheckArgument_true() {
+        AssertTools.checkArgument(true);
+    }
+
+    @Test
+    void testCheckArgument_true_withMessage() {
+        final String IGNORE_ME = "IGNORE_ME"; // NOSONAR
+        AssertTools.checkArgument(true, IGNORE_ME);
+    }
+
+    @Test
+    void testCheckArgument_true_withNullMessage() {
+        final String IGNORE_ME = null; // NOSONAR
+        AssertTools.checkArgument(true, IGNORE_ME);
+    }
+
+    @Test
+    void testCheckArgument_true_withMessageSupplier() {
+        AssertTools.checkArgument(true, () -> "Error message: " + LocalDate.now());
+    }
+
+    @Test
+    void testCheckArgument_true_withNullMessageSupplier() {
+        final Supplier<String> IGNORE_ME = null; // NOSONAR
+        AssertTools.checkArgument(true, IGNORE_ME);
+    }
+
+    @Test
+    void testCheckArgument_true_withMessageFormat() {
+        LocalDate today = LocalDate.now();
+        AssertTools.checkArgument(true, "String format: %s", today);
+    }
+
+    @Test
+    void testCheckArgument_true_withNullMessageFormat() {
+        AssertTools.checkArgument(true, null, LocalDate.now());
+    }
+
+    @Test
+    void testCheckArgument_false() {
+        final IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+                () -> AssertTools.checkArgument(false));
+
+        assertNull(e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckArgument_false_withMessage() {
+        final String message = "testCheckArgument_false_withMessage";
+
+        final IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+                () -> AssertTools.checkArgument(false, message));
+
+        assertEquals(message, e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckArgument_false_withNullMessage() {
+        final String message = null;
+
+        final IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+                () -> AssertTools.checkArgument(false, message));
+
+        assertNull(e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckArgument_false_withMessageSupplier() {
+        final LocalDate today = LocalDate.now();
+        final IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+                () -> AssertTools.checkArgument(false, () -> "Error message: " + today));
+
+        assertEquals("Error message: " + today, e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckArgument_false_withNullMessageSupplier() {
+        Supplier<String> messageSupplier = null;
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.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));
+        assertEquals(String.format("String format: %s", today), e.getMessage());
+    }
+
+    @Test
+    void testCheckArgument_false_withNullMessageFormat() {
+        LocalDate today = LocalDate.now();
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkArgument(false, null, today));
+    }
+
+    // #endregion - Argument
+
+    // #region - State
+
+    @Test
+    void testCheckState_true() {
+        AssertTools.checkState(true);
+    }
+
+    @Test
+    void testCheckState_true_withMessage() {
+        final String IGNORE_ME = "IGNORE_ME"; // NOSONAR
+        AssertTools.checkState(true, IGNORE_ME);
+    }
+
+    @Test
+    void testCheckState_true_withNullMessage() {
+        final String IGNORE_ME = null; // NOSONAR
+        AssertTools.checkState(true, IGNORE_ME);
+    }
+
+    @Test
+    void testCheckState_true_withMessageSupplier() {
+        AssertTools.checkState(true, () -> "Error message: " + LocalDate.now());
+    }
+
+    @Test
+    void testCheckState_true_withNullMessageSupplier() {
+        final Supplier<String> IGNORE_ME = null; // NOSONAR // NOSONAR
+        AssertTools.checkState(true, IGNORE_ME);
+    }
+
+    @Test
+    void testCheckState_true_withMessageFormat() {
+        LocalDate today = LocalDate.now();
+        AssertTools.checkState(true, "String format: %s", today);
+    }
+
+    @Test
+    void testCheckState_true_withNullMessageFormat() {
+        AssertTools.checkState(true, null, LocalDate.now());
+    }
+
+    @Test
+    void testCheckState_false() {
+        final IllegalStateException e = assertThrows(IllegalStateException.class,
+                () -> AssertTools.checkState(false));
+
+        assertNull(e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckState_false_withMessage() {
+        final String message = "testCheckState_false_withMessage";
+
+        final IllegalStateException e = assertThrows(IllegalStateException.class,
+                () -> AssertTools.checkState(false, message));
+
+        assertEquals(message, e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckState_false_withNullMessage() {
+        final String message = null;
+
+        final IllegalStateException e = assertThrows(IllegalStateException.class,
+                () -> AssertTools.checkState(false, message));
+
+        assertNull(e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckState_false_withMessageSupplier() {
+        final LocalDate today = LocalDate.now();
+        final IllegalStateException e = assertThrows(IllegalStateException.class,
+                () -> AssertTools.checkState(false, () -> "Error message: " + today));
+
+        assertEquals("Error message: " + today, e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckState_false_withNullMessageSupplier() {
+        Supplier<String> messageSupplier = null;
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.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));
+        assertEquals(String.format("String format: %s", today), e.getMessage());
+    }
+
+    @Test
+    void testCheckState_false_withNullMessageFormat() {
+        LocalDate today = LocalDate.now();
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkState(false, null, today));
+    }
+
+    // #endregion - State
+
+    // #region - NotNull
+
+    @Test
+    void testCheckNotNull_notNull() {
+        final Object object = new Object();
+        AssertTools.checkNotNull(object);
+    }
+
+    @Test
+    void testCheckNotNull_notNull_withMessage() {
+        final Object object = new Object();
+        final String IGNORE_ME = "IGNORE_ME"; // NOSONAR
+        AssertTools.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);
+    }
+
+    @Test
+    void testCheckNotNull_notNull_withMessageSupplier() {
+        final Object object = new Object();
+        AssertTools.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);
+    }
+
+    @Test
+    void testCheckNotNull_notNull_withMessageFormat() {
+        final Object object = new Object();
+        LocalDate today = LocalDate.now();
+        AssertTools.checkNotNull(object, "String format: %s", today);
+    }
+
+    @Test
+    void testCheckNotNull_notNull_withNullMessageFormat() {
+        final Object object = new Object();
+        AssertTools.checkNotNull(object, null, LocalDate.now());
+    }
+
+    @Test
+    void testCheckNotNull_null() {
+        final Object object = null;
+        final NullPointerException e = assertThrows(NullPointerException.class,
+                () -> AssertTools.checkNotNull(object));
+
+        assertNull(e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckNotNull_null_withMessage() {
+        final Object object = null;
+        final String message = "testCheckNotNull_null_withMessage";
+
+        final NullPointerException e = assertThrows(NullPointerException.class,
+                () -> AssertTools.checkNotNull(object, message));
+
+        assertEquals(message, e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckNotNull_null_withNullMessage() {
+        final Object object = null;
+        final String message = null;
+
+        final NullPointerException e = assertThrows(NullPointerException.class,
+                () -> AssertTools.checkNotNull(object, message));
+
+        assertNull(e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckNotNull_null_withMessageSupplier() {
+        final Object object = null;
+        final LocalDate today = LocalDate.now();
+        final NullPointerException e = assertThrows(NullPointerException.class,
+                () -> AssertTools.checkNotNull(object, () -> "Error message: " + today));
+
+        assertEquals("Error message: " + today, e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckNotNull_null_withNullMessageSupplier() {
+        final Object object = null;
+        Supplier<String> messageSupplier = null;
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkNotNull(object, messageSupplier));
+    }
+
+    @Test
+    void testCheckNotNull_null_withMessageFormat() {
+        final Object object = null;
+        LocalDate today = LocalDate.now();
+        final NullPointerException e = assertThrows(NullPointerException.class,
+                () -> AssertTools.checkNotNull(object, "String format: %s", today));
+        assertEquals(String.format("String format: %s", today), e.getMessage());
+    }
+
+    @Test
+    void testCheckNotNull_null_withNullMessageFormat() {
+        final Object object = null;
+        LocalDate today = LocalDate.now();
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkNotNull(object, null, today));
+    }
+
+    // #endregion - NotNull
+
+    // #region - Exists
+
+    @Test
+    void testCheckExists_notNull() throws DataNotExistsException {
+        final Object object = new Object();
+        AssertTools.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);
+    }
+
+    @Test
+    void testCheckExists_notNull_withNullMessage() throws DataNotExistsException {
+        final Object object = new Object();
+        final String IGNORE_ME = null; // NOSONAR
+        AssertTools.checkExists(object, IGNORE_ME);
+    }
+
+    @Test
+    void testCheckExists_notNull_withMessageSupplier() throws DataNotExistsException {
+        final Object object = new Object();
+        AssertTools.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);
+    }
+
+    @Test
+    void testCheckExists_notNull_withMessageFormat() throws DataNotExistsException {
+        final Object object = new Object();
+        LocalDate today = LocalDate.now();
+        AssertTools.checkExists(object, "String format: %s", today);
+    }
+
+    @Test
+    void testCheckExists_notNull_withNullMessageFormat() throws DataNotExistsException {
+        final Object object = new Object();
+        AssertTools.checkExists(object, null, LocalDate.now());
+    }
+
+    @Test
+    void testCheckExists_null() {
+        final Object object = null;
+        final DataNotExistsException e = assertThrows(DataNotExistsException.class,
+                () -> AssertTools.checkExists(object));
+
+        assertNull(e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckExists_null_withMessage() {
+        final Object object = null;
+        final String message = "testCheckExists_null_withMessage";
+
+        final DataNotExistsException e = assertThrows(DataNotExistsException.class,
+                () -> AssertTools.checkExists(object, message));
+
+        assertEquals(message, e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckExists_null_withNullMessage() {
+        final Object object = null;
+        final String message = null;
+
+        final DataNotExistsException e = assertThrows(DataNotExistsException.class,
+                () -> AssertTools.checkExists(object, message));
+
+        assertNull(e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckExists_null_withMessageSupplier() {
+        final Object object = null;
+        final LocalDate today = LocalDate.now();
+        final DataNotExistsException e = assertThrows(DataNotExistsException.class,
+                () -> AssertTools.checkExists(object, () -> "Error message: " + today));
+
+        assertEquals("Error message: " + today, e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckExists_null_withNullMessageSupplier() {
+        final Object object = null;
+        Supplier<String> messageSupplier = null;
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkExists(object, messageSupplier));
+    }
+
+    @Test
+    void testCheckExists_null_withMessageFormat() {
+        final Object object = null;
+        LocalDate today = LocalDate.now();
+        final DataNotExistsException e = assertThrows(DataNotExistsException.class,
+                () -> AssertTools.checkExists(object, "String format: %s", today));
+        assertEquals(String.format("String format: %s", today), e.getMessage());
+    }
+
+    @Test
+    void testCheckExists_null_withNullMessageFormat() {
+        final Object object = null;
+        LocalDate today = LocalDate.now();
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkExists(object, null, today));
+    }
+
+    @Test
+    void testCheckExists_optional() throws DataNotExistsException {
+        final Optional<Object> object = Optional.of(new Object());
+        AssertTools.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);
+    }
+
+    @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);
+    }
+
+    @Test
+    void testCheckExists_optional_withMessageSupplier() throws DataNotExistsException {
+        final Optional<Object> object = Optional.of(new Object());
+        AssertTools.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);
+    }
+
+    @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);
+    }
+
+    @Test
+    void testCheckExists_optional_withNullMessageFormat() throws DataNotExistsException {
+        final Optional<Object> object = Optional.of(new Object());
+        AssertTools.checkExists(object, null, LocalDate.now());
+    }
+
+    @Test
+    void testCheckExists_emptyOptional() {
+        final Optional<Object> object = Optional.empty();
+        final DataNotExistsException e = assertThrows(DataNotExistsException.class,
+                () -> AssertTools.checkExists(object));
+
+        assertNull(e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckExists_emptyOptional_withMessage() {
+        final Optional<Object> object = Optional.empty();
+        final String message = "testCheckExists_emptyOptional_withMessage";
+
+        final DataNotExistsException e = assertThrows(DataNotExistsException.class,
+                () -> AssertTools.checkExists(object, message));
+
+        assertEquals(message, e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckExists_emptyOptional_withNullMessage() {
+        final Optional<Object> object = Optional.empty();
+        final String message = null;
+
+        final DataNotExistsException e = assertThrows(DataNotExistsException.class,
+                () -> AssertTools.checkExists(object, message));
+
+        assertNull(e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckExists_emptyOptional_withMessageSupplier() {
+        final Optional<Object> object = Optional.empty();
+        final LocalDate today = LocalDate.now();
+        final DataNotExistsException e = assertThrows(DataNotExistsException.class,
+                () -> AssertTools.checkExists(object, () -> "Error message: " + today));
+
+        assertEquals("Error message: " + today, e.getMessage());
+        assertNull(e.getCause());
+    }
+
+    @Test
+    void testCheckExists_emptyOptional_withNullMessageSupplier() {
+        final Optional<Object> object = Optional.empty();
+        Supplier<String> messageSupplier = null;
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkExists(object, messageSupplier));
+    }
+
+    @Test
+    void testCheckExists_emptyOptional_withMessageFormat() {
+        final Optional<Object> object = Optional.empty();
+        LocalDate today = LocalDate.now();
+        final DataNotExistsException e = assertThrows(DataNotExistsException.class,
+                () -> AssertTools.checkExists(object, "String format: %s", today));
+        assertEquals(String.format("String format: %s", today), e.getMessage());
+    }
+
+    @Test
+    void testCheckExists_emptyOptional_withNullMessageFormat() {
+        final Optional<Object> object = Optional.empty();
+        LocalDate today = LocalDate.now();
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkExists(object, null, today));
+    }
+
+    @Test
+    void testCheckExists_nullOptional() {
+        final Optional<Object> object = null;
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkExists(object));
+    }
+
+    @Test
+    void testCheckExists_nullOptional_withMessage() {
+        final Optional<Object> object = null;
+        final String message = "testCheckExists_nullOptional_withMessage";
+
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkExists(object, message));
+    }
+
+    @Test
+    void testCheckExists_nullOptional_withNullMessage() {
+        final Optional<Object> object = null;
+        final String message = null;
+
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkExists(object, message));
+    }
+
+    @Test
+    void testCheckExists_nullOptional_withMessageSupplier() {
+        final Optional<Object> object = null;
+        final LocalDate today = LocalDate.now();
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkExists(object, () -> "Error message: " + today));
+    }
+
+    @Test
+    void testCheckExists_nullOptional_withNullMessageSupplier() {
+        final Optional<Object> object = null;
+        Supplier<String> messageSupplier = null;
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkExists(object, messageSupplier));
+    }
+
+    @Test
+    void testCheckExists_nullOptional_withMessageFormat() {
+        final Optional<Object> object = null;
+        LocalDate today = LocalDate.now();
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkExists(object, "String format: %s", today));
+    }
+
+    @Test
+    void testCheckExists_nullOptional_withNullMessageFormat() {
+        final Optional<Object> object = null;
+        LocalDate today = LocalDate.now();
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkExists(object, null, today));
+    }
+
+    // #endregion - Exists
+
+    // #region - AffectedRows
+
+    @Test
+    void testCheckAffectedRows_int() {
+        final int expectedValue = 25;
+
+        AssertTools.checkAffectedRows(expectedValue, 25);
+
+        DataOperationResultException e0 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedRows(expectedValue, 108));
+        assertEquals(String.format("The number of rows affected is expected to be %d, but is: %d", expectedValue, 108),
+                e0.getMessage());
+
+    }
+
+    @Test
+    void testCheckAffectedRows_int_message() {
+        final int expectedValue = 25;
+
+        final String message = "Static message";
+
+        AssertTools.checkAffectedRows(expectedValue, 25, message);
+
+        DataOperationResultException e1 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedRows(expectedValue, 108, message));
+        assertEquals(message, e1.getMessage());
+
+        final String nullMessage = null;
+
+        AssertTools.checkAffectedRows(expectedValue, 25, nullMessage);
+
+        e1 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedRows(expectedValue, 108, nullMessage));
+        assertNull(e1.getMessage());
+    }
+
+    @Test
+    void testCheckAffectedRows_int_messageSupplier() {
+        final int expectedValue = 25;
+
+        final Supplier<String> messageSupplier = () -> "Supplier message";
+
+        AssertTools.checkAffectedRows(expectedValue, 25, messageSupplier);
+
+        DataOperationResultException e2 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedRows(expectedValue, 108, messageSupplier));
+        assertEquals(messageSupplier.get(), e2.getMessage());
+
+        final Supplier<String> nullSupplier = null;
+
+        AssertTools.checkAffectedRows(expectedValue, 25, nullSupplier);
+
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkAffectedRows(expectedValue, 108, nullSupplier));
+    }
+
+    @Test
+    void testCheckAffectedRows_int_messageFormat() {
+        final int expectedValue = 25;
+
+        AssertTools.checkAffectedRows(expectedValue, 25, "预计是 %d，结果是 %d。", expectedValue, 25);
+
+        DataOperationResultException e3 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedRows(expectedValue, 108, "预计是 %d，结果是 %d。", expectedValue, 108));
+        assertEquals("预计是 25，结果是 108。", e3.getMessage());
+
+        AssertTools.checkAffectedRows(expectedValue, 25, null, expectedValue, 25);
+
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkAffectedRows(expectedValue, 108, null, expectedValue, 108));
+    }
+
+    @Test
+    void testCheckAffectedRows_long() {
+        final long expectedValue = 25L;
+
+        AssertTools.checkAffectedRows(expectedValue, 25L);
+
+        DataOperationResultException e0 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedRows(expectedValue, 108L));
+        assertEquals(String.format("The number of rows affected is expected to be %d, but is: %d", expectedValue, 108L),
+                e0.getMessage());
+
+    }
+
+    @Test
+    void testCheckAffectedRows_long_message() {
+        final long expectedValue = 25L;
+
+        final String message = "Static message";
+
+        AssertTools.checkAffectedRows(expectedValue, 25L, message);
+
+        DataOperationResultException e1 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedRows(expectedValue, 108L, message));
+        assertEquals(message, e1.getMessage());
+
+        final String nullMessage = null;
+
+        AssertTools.checkAffectedRows(expectedValue, 25L, nullMessage);
+
+        e1 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedRows(expectedValue, 108L, nullMessage));
+        assertNull(e1.getMessage());
+    }
+
+    @Test
+    void testCheckAffectedRows_long_messageSupplier() {
+        final long expectedValue = 25L;
+
+        final Supplier<String> messageSupplier = () -> "Supplier message";
+
+        AssertTools.checkAffectedRows(expectedValue, 25L, messageSupplier);
+
+        DataOperationResultException e2 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedRows(expectedValue, 108L, messageSupplier));
+        assertEquals(messageSupplier.get(), e2.getMessage());
+
+        final Supplier<String> nullSupplier = null;
+
+        AssertTools.checkAffectedRows(expectedValue, 25L, nullSupplier);
+
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkAffectedRows(expectedValue, 108L, nullSupplier));
+    }
+
+    @Test
+    void testCheckAffectedRows_long_messageFormat() {
+        final long expectedValue = 25L;
+
+        AssertTools.checkAffectedRows(expectedValue, 25L, "预计是 %d，结果是 %d。", expectedValue, 25L);
+
+        DataOperationResultException e3 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedRows(expectedValue, 108L, "预计是 %d，结果是 %d。", expectedValue, 108L));
+        assertEquals("预计是 25，结果是 108。", e3.getMessage());
+
+        AssertTools.checkAffectedRows(expectedValue, 25L, null, expectedValue, 25L);
+
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkAffectedRows(expectedValue, 108L, null, expectedValue, 108L));
+    }
+
+    @Test
+    void testCheckAffectedOneRow_int() {
+        AssertTools.checkAffectedOneRow(1);
+
+        DataOperationResultException e0 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedOneRow(108));
+        assertEquals(String.format("The number of rows affected is expected to be 1, but is: %d", 108),
+                e0.getMessage());
+
+    }
+
+    @Test
+    void testCheckAffectedOneRow_int_message() {
+        final String message = "Static message";
+
+        AssertTools.checkAffectedOneRow(1, message);
+
+        DataOperationResultException e1 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedOneRow(108, message));
+        assertEquals(message, e1.getMessage());
+
+        final String nullMessage = null;
+
+        AssertTools.checkAffectedOneRow(1, nullMessage);
+
+        e1 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedOneRow(108, nullMessage));
+        assertNull(e1.getMessage());
+    }
+
+    @Test
+    void testCheckAffectedOneRow_int_messageSupplier() {
+        final Supplier<String> messageSupplier = () -> "Supplier message";
+
+        AssertTools.checkAffectedOneRow(1, messageSupplier);
+
+        DataOperationResultException e2 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedOneRow(108, messageSupplier));
+        assertEquals(messageSupplier.get(), e2.getMessage());
+
+        final Supplier<String> nullSupplier = null;
+
+        AssertTools.checkAffectedOneRow(1, nullSupplier);
+
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkAffectedOneRow(108, nullSupplier));
+    }
+
+    @Test
+    void testCheckAffectedOneRow_int_messageFormat() {
+        AssertTools.checkAffectedOneRow(1, "预计是 %d，结果是 %d。", 1, 108);
+
+        DataOperationResultException e3 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedOneRow(108, "预计是 %d，结果是 %d。", 1, 108));
+        assertEquals("预计是 1，结果是 108。", e3.getMessage());
+
+        AssertTools.checkAffectedOneRow(1, null, 1);
+
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkAffectedOneRow(108, null, 108));
+    }
+
+    @Test
+    void testCheckAffectedOneRow_long() {
+        AssertTools.checkAffectedOneRow(1L);
+
+        DataOperationResultException e0 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedOneRow(108L));
+        assertEquals(String.format("The number of rows affected is expected to be 1, but is: %d", 108L),
+                e0.getMessage());
+
+    }
+
+    @Test
+    void testCheckAffectedOneRow_long_message() {
+        final String message = "Static message";
+
+        AssertTools.checkAffectedOneRow(1L, message);
+
+        DataOperationResultException e1 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedOneRow(108L, message));
+        assertEquals(message, e1.getMessage());
+
+        final String nullMessage = null;
+
+        AssertTools.checkAffectedOneRow(1L, nullMessage);
+
+        e1 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedOneRow(108L, nullMessage));
+        assertNull(e1.getMessage());
+    }
+
+    @Test
+    void testCheckAffectedOneRow_long_messageSupplier() {
+        final Supplier<String> messageSupplier = () -> "Supplier message";
+
+        AssertTools.checkAffectedOneRow(1L, messageSupplier);
+
+        DataOperationResultException e2 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedOneRow(108L, messageSupplier));
+        assertEquals(messageSupplier.get(), e2.getMessage());
+
+        final Supplier<String> nullSupplier = null;
+
+        AssertTools.checkAffectedOneRow(1L, nullSupplier);
+
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkAffectedOneRow(108L, nullSupplier));
+    }
+
+    @Test
+    void testCheckAffectedOneRow_long_messageFormat() {
+        AssertTools.checkAffectedOneRow(1L, "预计是 %d，结果是 %d。", 1L, 108L);
+
+        DataOperationResultException e3 = assertThrows(DataOperationResultException.class,
+                () -> AssertTools.checkAffectedOneRow(108L, "预计是 %d，结果是 %d。", 1L, 108L));
+        assertEquals("预计是 1，结果是 108。", e3.getMessage());
+
+        AssertTools.checkAffectedOneRow(1L, null, 1L);
+
+        assertThrows(NullPointerException.class,
+                () -> AssertTools.checkAffectedOneRow(108L, null, 108L));
+    }
+
+    // #endregion - AffectedRows
+
+    // #region - Condition
+
+    @Test
+    void testCheckCondition() {
+        class MyException extends RuntimeException {}
+
+        AssertTools.checkCondition(true, MyException::new);
+
+        final MyException me = new MyException();
+        MyException e = assertThrows(MyException.class, () -> AssertTools.checkCondition(false, () -> me));
+        assertEquals(me, e);
+    }
+
+    // #endregion - Condition
+
+}