test: 完善单元测试

plusone-validator/src/main/java/xyz/zhouxy/plusone/validator/StringPropertyValidator.java

@@ -22,8 +22,6 @@ import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.regex.Pattern;
 
-import com.google.common.base.Strings;
-
 import xyz.zhouxy.plusone.commons.constant.PatternConsts;
 import xyz.zhouxy.plusone.commons.util.AssertTools;
 import xyz.zhouxy.plusone.commons.util.RegexTools;
@@ -158,7 +156,7 @@ public class StringPropertyValidator<DTO> extends BaseComparablePropertyValidato
     // ================================
 
     public StringPropertyValidator<DTO> notBlank() {
-        return notBlank("This String argument must have text; it must not be null, empty, or blank");
+        return notBlank("The value must have text; it must not be null, empty, or blank.");
     }
 
     public StringPropertyValidator<DTO> notBlank(String errMsg) {
@@ -209,6 +207,10 @@ public class StringPropertyValidator<DTO> extends BaseComparablePropertyValidato
     // #region - notEmpty
     // ================================
 
+    public StringPropertyValidator<DTO> notEmpty() {
+        return notEmpty("The value must not be empty.");
+    }
+
     public StringPropertyValidator<DTO> notEmpty(String errMsg) {
         return notEmpty(convertExceptionCreator(errMsg));
     }
@@ -227,28 +229,6 @@ public class StringPropertyValidator<DTO> extends BaseComparablePropertyValidato
     // #endregion - notEmpty
     // ================================
 
-    // ================================
-    // #region - isNullOrEmpty
-    // ================================
-
-    public StringPropertyValidator<DTO> isNullOrEmpty(String errMsg) {
-        return isNullOrEmpty(convertExceptionCreator(errMsg));
-    }
-
-    public <E extends RuntimeException> StringPropertyValidator<DTO> isNullOrEmpty(Supplier<E> exceptionCreator) {
-        return isNullOrEmpty(convertExceptionCreator(exceptionCreator));
-    }
-
-    public <E extends RuntimeException> StringPropertyValidator<DTO> isNullOrEmpty(
-            Function<String, E> exceptionCreator) {
-        withRule(Strings::isNullOrEmpty, exceptionCreator);
-        return this;
-    }
-
-    // ================================
-    // #endregion - isNullOrEmpty
-    // ================================
-
     // ================================
     // #region - length
     // ================================

plusone-validator/src/test/java/xyz/zhouxy/plusone/example/validator/ObjectPropertyValidatorTests.java

@@ -13,32 +13,326 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package xyz.zhouxy.plusone.example.validator;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.time.DateTimeException;
 import java.time.LocalDateTime;
+import java.util.Objects;
 
 import org.junit.jupiter.api.Test;
 
 import com.google.common.collect.Lists;
 
+import xyz.zhouxy.plusone.commons.collection.CollectionTools;
+import xyz.zhouxy.plusone.commons.util.DateTimeTools;
+import xyz.zhouxy.plusone.commons.util.StringTools;
 import xyz.zhouxy.plusone.example.ExampleCommand;
 import xyz.zhouxy.plusone.example.Foo;
+import xyz.zhouxy.plusone.validator.BaseValidator;
 
 public class ObjectPropertyValidatorTests {
 
-    // TODO
+    // ================================
+    // #region - withRule
+    // ================================
 
-    static ExampleCommand exampleCommand() {
+    @Test
-        return new ExampleCommand(
+    void withRule() {
+        BaseValidator<ExampleCommand> validator = new BaseValidator<ExampleCommand>() {
+            {
+                ruleFor(ExampleCommand::getBoolProperty)
+                        .notNull("The boolProperty cannot be null.")
+                        .withRule(Boolean.TRUE::equals, "The boolProperty should be true.");
+
+                ruleFor(ExampleCommand::getIntProperty)
+                        .withRule(intProperty -> intProperty > 0, "The intProperty should be greater than 0.");
+
+                ruleFor(ExampleCommand::getLongProperty)
+                        .withRule(longProperty -> longProperty > 0L,
+                                () -> ExampleException.withMessage("The longProperty should be greater than 0."));
+
+                ruleFor(ExampleCommand::getDoubleProperty)
+                        .withRule(doubleProperty -> doubleProperty > 0.00,
+                                doubleProperty -> ExampleException.withMessage("The doubleProperty should be greater than 0, but it was: %s", doubleProperty));
+
+                ruleFor(ExampleCommand::getStringProperty)
+                        .notNull()
+                        .withRule(stringProperty -> stringProperty.length() > 2,
+                                () -> ExampleException.withMessage("The length of stringProperty should be greater than 2."));
+
+                ruleFor(ExampleCommand::getDateTimeProperty)
+                        .withRule(DateTimeTools::isFuture,
+                                () -> new DateTimeException("The dateTimeProperty should be a future time."));
+
+                ruleFor(ExampleCommand::getObjectProperty)
+                        .notNull("The objectProperty cannot be null.");
+
+                ruleFor(ExampleCommand::getStringListProperty)
+                        .withRule(CollectionTools::isNotEmpty, "The stringListProperty cannot be empty.");
+
+                withRule(command -> {
+                    Foo objectProperty = command.getObjectProperty();
+                    if (!Objects.equals(command.getIntProperty(), objectProperty.getIntProperty())) {
+                        throw ExampleException.withMessage("intProperty invalid.");
+                    }
+                });
+            }
+        };
+
+        ExampleCommand command = new ExampleCommand(
                 true,
                 Integer.MAX_VALUE,
                 Long.MAX_VALUE,
-                3.14,
+                Double.MAX_VALUE,
-                "Foo",
+                "StringValue",
-                LocalDateTime.of(2008, 8, 8, 20, 8),
+                LocalDateTime.now().plusDays(1),
-                new Foo(Integer.MIN_VALUE, "Bar"),
+                new Foo(Integer.MAX_VALUE, "StringValue"),
-                Lists.newArrayList("A", "B", "C", "D"));
+                Lists.newArrayList("ABC", "DEF"));
+
+        assertDoesNotThrow(() -> validator.validate(command));
     }
+
+    // ================================
+    // #endregion - withRule
+    // ================================
+
+    // ================================
+    // #region - notNull
+    // ================================
+
+    @Test
+    void notNull_validInput() {
+        BaseValidator<ExampleCommand> validator = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForBool(ExampleCommand::getBoolProperty)
+                        .notNull();
+                ruleForInt(ExampleCommand::getIntProperty)
+                        .notNull("The intProperty cannot be null");
+                ruleForLong(ExampleCommand::getLongProperty)
+                        .notNull(() -> ExampleException.withMessage("The longProperty cannot be null"));
+                ruleForDouble(ExampleCommand::getDoubleProperty)
+                        .notNull(d -> ExampleException.withMessage("The doubleProperty cannot be null, but it was %s", d));
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notNull();
+                ruleForComparable(ExampleCommand::getDateTimeProperty)
+                        .notNull("The dateTimeProperty cannot be null");
+                ruleFor(ExampleCommand::getObjectProperty)
+                        .notNull(() -> ExampleException.withMessage("The objectProperty cannot be null"));
+                ruleForCollection(ExampleCommand::getStringListProperty)
+                        .notNull(d -> ExampleException.withMessage("The stringListProperty cannot be null, but it was %s", d));
+            }
+        };
+        ExampleCommand command = new ExampleCommand(
+                true,
+                Integer.MAX_VALUE,
+                Long.MAX_VALUE,
+                Double.MAX_VALUE,
+                "StringValue",
+                LocalDateTime.now().plusDays(1),
+                new Foo(Integer.MAX_VALUE, "StringValue"),
+                Lists.newArrayList("ABC", "DEF"));
+
+        assertDoesNotThrow(() -> validator.validate(command));
+    }
+
+    @Test
+    void notNull_invalidInput() {
+        ExampleCommand command = new ExampleCommand();
+
+        BaseValidator<ExampleCommand> defaultRule = new BaseValidator<ExampleCommand>() {
+            {
+                ruleFor(ExampleCommand::getObjectProperty)
+                        .notNull();
+            }
+        };
+        IllegalArgumentException eWithDefaultMessage = assertThrows(
+                IllegalArgumentException.class, () -> defaultRule.validate(command));
+        assertEquals("Value could not be null.", eWithDefaultMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithMessage = new BaseValidator<ExampleCommand>() {
+            {
+                ruleFor(ExampleCommand::getObjectProperty)
+                        .notNull("The objectProperty could not be null.");
+            }
+        };
+        IllegalArgumentException eWithSpecifiedMessage = assertThrows(
+                IllegalArgumentException.class, () -> ruleWithMessage.validate(command));
+        assertEquals("The objectProperty could not be null.", eWithSpecifiedMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionSupplier = new BaseValidator<ExampleCommand>() {
+            {
+                ruleFor(ExampleCommand::getObjectProperty)
+                        .notNull(() -> ExampleException.withMessage("The objectProperty could not be null."));
+            }
+        };
+        ExampleException specifiedException = assertThrows(
+                ExampleException.class, () -> ruleWithExceptionSupplier.validate(command));
+        assertEquals("The objectProperty could not be null.", specifiedException.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionFunction = new BaseValidator<ExampleCommand>() {
+            {
+                ruleFor(ExampleCommand::getObjectProperty)
+                        .notNull(str -> ExampleException.withMessage("The objectProperty could not be null, but is was " + str));
+            }
+        };
+        ExampleException specifiedException2 = assertThrows(
+                ExampleException.class, () -> ruleWithExceptionFunction.validate(command));
+        assertEquals("The objectProperty could not be null, but is was null", specifiedException2.getMessage());
+    }
+
+    // ================================
+    // #endregion - notNull
+    // ================================
+
+    // ================================
+    // #region - isNull
+    // ================================
+
+    @Test
+    void isNull_validInput() {
+        BaseValidator<ExampleCommand> validator = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForBool(ExampleCommand::getBoolProperty)
+                        .isNull("The boolProperty should be null");
+                ruleForInt(ExampleCommand::getIntProperty)
+                        .isNull("The intProperty should be null");
+                ruleForLong(ExampleCommand::getLongProperty)
+                        .isNull(() -> ExampleException.withMessage("The longProperty should be null"));
+                ruleForDouble(ExampleCommand::getDoubleProperty)
+                        .isNull(d -> ExampleException.withMessage("The doubleProperty should be null, but it was %s", d));
+                ruleForString(ExampleCommand::getStringProperty)
+                        .isNull("The stringProperty should be null");
+                ruleForComparable(ExampleCommand::getDateTimeProperty)
+                        .isNull("The dateTimeProperty should be null");
+                ruleFor(ExampleCommand::getObjectProperty)
+                        .isNull(() -> ExampleException.withMessage("The objectProperty should be null"));
+                ruleForCollection(ExampleCommand::getStringListProperty)
+                        .isNull(d -> ExampleException.withMessage("The stringListProperty should be null, but it was %s", d));
+            }
+        };
+        ExampleCommand command = new ExampleCommand();
+
+        assertDoesNotThrow(() -> validator.validate(command));
+    }
+
+    @Test
+    void isNull_invalidInput() {
+        ExampleCommand command = new ExampleCommand();
+        command.setObjectProperty(new Foo(Integer.MAX_VALUE, "StringValue"));
+
+        BaseValidator<ExampleCommand> ruleWithMessage = new BaseValidator<ExampleCommand>() {
+            {
+                ruleFor(ExampleCommand::getObjectProperty)
+                        .isNull("The objectProperty should be null.");
+            }
+        };
+        IllegalArgumentException eWithSpecifiedMessage = assertThrows(
+                IllegalArgumentException.class, () -> ruleWithMessage.validate(command));
+        assertEquals("The objectProperty should be null.", eWithSpecifiedMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionSupplier = new BaseValidator<ExampleCommand>() {
+            {
+                ruleFor(ExampleCommand::getObjectProperty)
+                        .isNull(() -> ExampleException.withMessage("The objectProperty should be null."));
+            }
+        };
+        ExampleException specifiedException = assertThrows(
+                ExampleException.class, () -> ruleWithExceptionSupplier.validate(command));
+        assertEquals("The objectProperty should be null.", specifiedException.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionFunction = new BaseValidator<ExampleCommand>() {
+            {
+                ruleFor(ExampleCommand::getObjectProperty)
+                        .isNull(str -> ExampleException.withMessage("The objectProperty should be null, but is was " + str));
+            }
+        };
+        ExampleException specifiedException2 = assertThrows(
+                ExampleException.class, () -> ruleWithExceptionFunction.validate(command));
+        assertEquals("The objectProperty should be null, but is was " + command.getObjectProperty(), specifiedException2.getMessage());
+    }
+
+    // ================================
+    // #endregion - isNull
+    // ================================
+
+    // ================================
+    // #region - equalsThat
+    // ================================
+
+    @Test
+    void equalsThat() {
+
+    }
+
+    @Test
+    void equalsThat2() {
+
+    }
+
+    @Test
+    void equalsThat3() {
+
+    }
+
+    @Test
+    void equalsThat4() {
+
+    }
+
+    // ================================
+    // #endregion - equalsThat
+    // ================================
+
+    // ================================
+    // #region - must
+    // ================================
+
+    @Test
+    void must() {
+
+    }
+
+    @Test
+    void must2() {
+
+    }
+
+    @Test
+    void must3() {
+
+    }
+
+    @Test
+    void must4() {
+
+    }
+
+    @Test
+    void must5() {
+
+    }
+
+    @Test
+    void must6() {
+
+    }
+
+    @Test
+    void must7() {
+
+    }
+
+    @Test
+    void must8() {
+
+    }
+
+    // ================================
+    // #endregion - must
+    // ================================
 }

plusone-validator/src/test/java/xyz/zhouxy/plusone/example/validator/StringPropertyValidatorTests.java

@@ -22,6 +22,8 @@ import java.util.List;
 import java.util.regex.Pattern;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import com.google.common.collect.Lists;
 
@@ -32,6 +34,12 @@ import xyz.zhouxy.plusone.validator.BaseValidator;
 public class StringPropertyValidatorTests {
 
     private static final String MESSAGE_SHOULD_MATCH = "Input should match pattern";
+    private static final String MESSAGE_NOT_BLANK = "Input cannot be blank";
+    private static final String MESSAGE_NOT_EMPTY = "Input cannot be empty";
+    private static final String MESSAGE_NOT_EMAIL = "Input should be an email address";
+
+    private static final int MIN_LENGTH = 6;
+    private static final int MAX_LENGTH = 8;
 
     // ================================
     // #region - matches
@@ -112,10 +120,7 @@ public class StringPropertyValidatorTests {
         };
 
         ExampleCommand command = exampleCommandWithStringProperty(null);
-        IllegalArgumentException e = assertThrows(
+        assertDoesNotThrow(() -> validator.validate(command));
-                IllegalArgumentException.class,
-                () -> validator.validate(command));
-        assertEquals(MESSAGE_SHOULD_MATCH, e.getMessage());
     }
 
     @Test
@@ -128,10 +133,7 @@ public class StringPropertyValidatorTests {
         };
 
         ExampleCommand command = exampleCommandWithStringProperty(null);
-        ExampleException e = assertThrows(
+        assertDoesNotThrow(() -> validator.validate(command));
-                ExampleException.class,
-                () -> validator.validate(command));
-        assertEquals(MESSAGE_SHOULD_MATCH, e.getMessage());
     }
 
     @Test
@@ -145,10 +147,7 @@ public class StringPropertyValidatorTests {
         };
 
         ExampleCommand command = exampleCommandWithStringProperty(null);
-        ExampleException e = assertThrows(
+        assertDoesNotThrow(() -> validator.validate(command));
-                ExampleException.class,
-                () -> validator.validate(command));
-        assertEquals("Input should match pattern, but it is null", e.getMessage());
     }
 
     // ================================
@@ -729,47 +728,460 @@ public class StringPropertyValidatorTests {
     // #region - notBlank
     // ================================
 
-    // TODO
+    @Test
+    void notBlank_all_validInput() {
+        BaseValidator<ExampleCommand> validator = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notBlank()
+                        .notBlank(MESSAGE_NOT_BLANK)
+                        .notBlank(() -> ExampleException.withMessage(MESSAGE_NOT_BLANK))
+                        .notBlank(str -> ExampleException.withMessage("The stringProperty cannot be blank, but is was %s", StringTools.toQuotedString(str)));
+            }
+        };
+
+        ExampleCommand command = exampleCommandWithStringProperty("abcd");
+        assertDoesNotThrow(() -> validator.validate(command));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "", " ", "  ", "\t", "\n" })
+    void notBlank_invalidInput(String value) {
+        ExampleCommand command = exampleCommandWithStringProperty(value);
+
+        BaseValidator<ExampleCommand> defaultRule = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notBlank();
+            }
+        };
+        IllegalArgumentException eWithDefaultMessage = assertThrows(
+                IllegalArgumentException.class,
+                () -> defaultRule.validate(command));
+        assertEquals("The value must have text; it must not be null, empty, or blank.", eWithDefaultMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithMessage = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notBlank(MESSAGE_NOT_BLANK);
+            }
+        };
+        IllegalArgumentException eWithSpecifiedMessage = assertThrows(
+                IllegalArgumentException.class,
+                () -> ruleWithMessage.validate(command));
+        assertEquals(MESSAGE_NOT_BLANK, eWithSpecifiedMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionSupplier = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notBlank(() -> ExampleException.withMessage(MESSAGE_NOT_BLANK));
+            }
+        };
+        ExampleException specifiedException = assertThrows(
+            ExampleException.class,
+                () -> ruleWithExceptionSupplier.validate(command));
+        assertEquals(MESSAGE_NOT_BLANK, specifiedException.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionFunction = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                .notBlank(str -> ExampleException.withMessage("The stringProperty cannot be blank, but is was %s", StringTools.toQuotedString(str)));
+            }
+        };
+        ExampleException specifiedException2 = assertThrows(
+            ExampleException.class,
+                () -> ruleWithExceptionFunction.validate(command));
+        assertEquals("The stringProperty cannot be blank, but is was " + StringTools.toQuotedString(value),
+                specifiedException2.getMessage());
+    }
+
+    @Test
+    void notBlank_nullInput() {
+        ExampleCommand command = exampleCommandWithStringProperty(null);
+
+        BaseValidator<ExampleCommand> defaultRule = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notBlank();
+            }
+        };
+        IllegalArgumentException eWithDefaultMessage = assertThrows(
+                IllegalArgumentException.class,
+                () -> defaultRule.validate(command));
+        assertEquals("The value must have text; it must not be null, empty, or blank.", eWithDefaultMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithMessage = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notBlank(MESSAGE_NOT_BLANK);
+            }
+        };
+        IllegalArgumentException eWithSpecifiedMessage = assertThrows(
+                IllegalArgumentException.class,
+                () -> ruleWithMessage.validate(command));
+        assertEquals(MESSAGE_NOT_BLANK, eWithSpecifiedMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionSupplier = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notBlank(() -> ExampleException.withMessage(MESSAGE_NOT_BLANK));
+            }
+        };
+        ExampleException specifiedException = assertThrows(
+            ExampleException.class,
+                () -> ruleWithExceptionSupplier.validate(command));
+        assertEquals(MESSAGE_NOT_BLANK, specifiedException.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionFunction = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                .notBlank(str -> ExampleException.withMessage("The stringProperty cannot be blank, but is was %s", StringTools.toQuotedString(str)));
+            }
+        };
+        ExampleException specifiedException2 = assertThrows(
+            ExampleException.class,
+                () -> ruleWithExceptionFunction.validate(command));
+        assertEquals("The stringProperty cannot be blank, but is was null",
+                specifiedException2.getMessage());
+    }
 
     // ================================
     // #endregion - notBlank
     // ================================
 
     // ================================
-    // #region - email
+    // #region - emailAddress
     // ================================
 
-    // TODO
+    @Test
+    void emailAddress_validInput() {
+        BaseValidator<ExampleCommand> validator = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .emailAddress()
+                        .emailAddress(MESSAGE_NOT_EMAIL)
+                        .emailAddress(() -> ExampleException.withMessage(MESSAGE_NOT_EMAIL))
+                        .emailAddress(str -> ExampleException.withMessage("Input should be an email address, but it was \"%s\"", str));
+            }
+        };
+        ExampleCommand validCommand = exampleCommandWithStringProperty("abc@example.com");
+        assertDoesNotThrow(() -> validator.validate(validCommand));
+
+        ExampleCommand commandWithNullStringProperty = exampleCommandWithStringProperty(null);
+        assertDoesNotThrow(() -> validator.validate(commandWithNullStringProperty));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "", "abc", "abc@def@example.com" })
+    void emailAddress_invalidInput(String value) {
+        ExampleCommand command = exampleCommandWithStringProperty(value);
+
+        BaseValidator<ExampleCommand> defaultRule = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .emailAddress();
+            }
+        };
+        IllegalArgumentException eWithDefaultMessage = assertThrows(
+                IllegalArgumentException.class,
+                () -> defaultRule.validate(command));
+        assertEquals("The value is not an email address.", eWithDefaultMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithMessage = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .emailAddress(MESSAGE_NOT_EMAIL);
+            }
+        };
+        IllegalArgumentException eWithSpecifiedMessage = assertThrows(
+                IllegalArgumentException.class,
+                () -> ruleWithMessage.validate(command));
+        assertEquals(MESSAGE_NOT_EMAIL, eWithSpecifiedMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionSupplier = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .emailAddress(() -> ExampleException.withMessage(MESSAGE_NOT_EMAIL));
+            }
+        };
+        ExampleException specifiedException = assertThrows(
+            ExampleException.class,
+                () -> ruleWithExceptionSupplier.validate(command));
+        assertEquals(MESSAGE_NOT_EMAIL, specifiedException.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionFunction = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .emailAddress(str -> ExampleException.withMessage("Input should be an email address, but it was \"%s\"", str));
+            }
+        };
+        ExampleException specifiedException2 = assertThrows(
+            ExampleException.class,
+                () -> ruleWithExceptionFunction.validate(command));
+        assertEquals(String.format("Input should be an email address, but it was \"%s\"", value), specifiedException2.getMessage());
+    }
 
     // ================================
-    // #endregion - email
+    // #endregion - emailAddress
     // ================================
 
     // ================================
     // #region - notEmpty
     // ================================
 
-    // TODO
+    @ParameterizedTest
+    @ValueSource(strings = { "abcd", " ", "  ", "\t", "\n" })
+    void notEmpty_all_validInput() {
+        BaseValidator<ExampleCommand> validator = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notEmpty()
+                        .notEmpty(MESSAGE_NOT_EMPTY)
+                        .notEmpty(() -> ExampleException.withMessage(MESSAGE_NOT_EMPTY))
+                        .notEmpty(str -> ExampleException.withMessage("The stringProperty cannot be empty, but is was %s", StringTools.toQuotedString(str)));
+            }
+        };
+
+        ExampleCommand command = exampleCommandWithStringProperty("abcd");
+        assertDoesNotThrow(() -> validator.validate(command));
+    }
+
+    @Test
+    void notEmpty_invalidInput() {
+        final String value = "";
+        ExampleCommand command = exampleCommandWithStringProperty(value);
+
+        BaseValidator<ExampleCommand> defaultRule = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notEmpty();
+            }
+        };
+        IllegalArgumentException eWithDefaultMessage = assertThrows(
+                IllegalArgumentException.class,
+                () -> defaultRule.validate(command));
+        assertEquals("The value must not be empty.", eWithDefaultMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithMessage = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notEmpty(MESSAGE_NOT_EMPTY);
+            }
+        };
+        IllegalArgumentException eWithSpecifiedMessage = assertThrows(
+                IllegalArgumentException.class,
+                () -> ruleWithMessage.validate(command));
+        assertEquals(MESSAGE_NOT_EMPTY, eWithSpecifiedMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionSupplier = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notEmpty(() -> ExampleException.withMessage(MESSAGE_NOT_EMPTY));
+            }
+        };
+        ExampleException specifiedException = assertThrows(
+            ExampleException.class,
+                () -> ruleWithExceptionSupplier.validate(command));
+        assertEquals(MESSAGE_NOT_EMPTY, specifiedException.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionFunction = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                .notEmpty(str -> ExampleException.withMessage("The stringProperty cannot be empty, but is was %s", StringTools.toQuotedString(str)));
+            }
+        };
+        ExampleException specifiedException2 = assertThrows(
+            ExampleException.class,
+                () -> ruleWithExceptionFunction.validate(command));
+        assertEquals("The stringProperty cannot be empty, but is was " + StringTools.toQuotedString(value),
+                specifiedException2.getMessage());
+    }
+
+    @Test
+    void notEmpty_nullInput() {
+        ExampleCommand command = exampleCommandWithStringProperty(null);
+
+        BaseValidator<ExampleCommand> defaultRule = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notEmpty();
+            }
+        };
+        IllegalArgumentException eWithDefaultMessage = assertThrows(
+                IllegalArgumentException.class,
+                () -> defaultRule.validate(command));
+        assertEquals("The value must not be empty.", eWithDefaultMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithMessage = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notEmpty(MESSAGE_NOT_EMPTY);
+            }
+        };
+        IllegalArgumentException eWithSpecifiedMessage = assertThrows(
+                IllegalArgumentException.class,
+                () -> ruleWithMessage.validate(command));
+        assertEquals(MESSAGE_NOT_EMPTY, eWithSpecifiedMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionSupplier = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notEmpty(() -> ExampleException.withMessage(MESSAGE_NOT_EMPTY));
+            }
+        };
+        ExampleException specifiedException = assertThrows(
+            ExampleException.class,
+                () -> ruleWithExceptionSupplier.validate(command));
+        assertEquals(MESSAGE_NOT_EMPTY, specifiedException.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionFunction = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .notEmpty(str -> ExampleException.withMessage("The stringProperty cannot be empty, but is was %s", StringTools.toQuotedString(str)));
+            }
+        };
+        ExampleException specifiedException2 = assertThrows(
+            ExampleException.class,
+                () -> ruleWithExceptionFunction.validate(command));
+        assertEquals("The stringProperty cannot be empty, but is was null",
+                specifiedException2.getMessage());
+    }
 
     // ================================
     // #endregion - notEmpty
     // ================================
 
-    // ================================
-    // #region - isNullOrEmpty
-    // ================================
-
-    // TODO
-
-    // ================================
-    // #endregion - isNullOrEmpty
-    // ================================
-
     // ================================
     // #region - length
     // ================================
 
-    // TODO
+    @Test
+    void length_specifiedLength_validLength() {
+        BaseValidator<ExampleCommand> validator = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .length(MIN_LENGTH, "The length of the string must be 6")
+                        .length(MIN_LENGTH, () -> ExampleException.withMessage("The length of the string must be 6"))
+                        .length(MIN_LENGTH, str -> ExampleException.withMessage("The length of the string must be 6, but it was %d", str.length()));
+            }
+        };
+        ExampleCommand validCommand = exampleCommandWithStringProperty("123456");
+        assertDoesNotThrow(() -> validator.validate(validCommand));
+
+        ExampleCommand commandWithNullStringProperty = exampleCommandWithStringProperty(null);
+        assertDoesNotThrow(() -> validator.validate(commandWithNullStringProperty));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "", "12345", "1234567" })
+    void length_specifiedLength_invalidLength(String value) {
+        ExampleCommand command = exampleCommandWithStringProperty(value);
+
+        BaseValidator<ExampleCommand> ruleWithMessage = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .length(MIN_LENGTH, "The length of the string must be 6");
+            }
+        };
+        IllegalArgumentException eWithSpecifiedMessage = assertThrows(
+                IllegalArgumentException.class,
+                () -> ruleWithMessage.validate(command));
+        assertEquals("The length of the string must be 6", eWithSpecifiedMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionSupplier = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .length(MIN_LENGTH, () -> ExampleException.withMessage("The length of the string must be 6"));
+            }
+        };
+        ExampleException specifiedException = assertThrows(
+                ExampleException.class,
+                () -> ruleWithExceptionSupplier.validate(command));
+        assertEquals("The length of the string must be 6", specifiedException.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionFunction = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .length(MIN_LENGTH, str -> ExampleException.withMessage("The length of the string must be 6, but it was %d", str.length()));
+            }
+        };
+        ExampleException specifiedException2 = assertThrows(
+                ExampleException.class,
+                () -> ruleWithExceptionFunction.validate(command));
+        assertEquals(
+                String.format("The length of the string must be 6, but it was %d", value.length()),
+                specifiedException2.getMessage());
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "123456", "1234567", "12345678" })
+    void length_specifiedMinLengthAndMaxLength_validLength(String value) {
+        ExampleCommand command = exampleCommandWithStringProperty(value);
+        BaseValidator<ExampleCommand> validator = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .length(MIN_LENGTH, MAX_LENGTH, String.format("Min length is %d, max length is %d", MIN_LENGTH, MAX_LENGTH))
+                        .length(MIN_LENGTH, MAX_LENGTH, () -> ExampleException.withMessage("Min length is %d, max length is %d", MIN_LENGTH, MAX_LENGTH))
+                        .length(MIN_LENGTH, MAX_LENGTH, str -> ExampleException.withMessage("Length of StringProperty is %d, min length is %d, max length is %d", str.length(), MIN_LENGTH, MAX_LENGTH));
+            }
+        };
+        assertDoesNotThrow(() -> validator.validate(command));
+    }
+
+    @Test
+    void length_specifiedMinLengthAndMaxLength_null() {
+        ExampleCommand command = exampleCommandWithStringProperty(null);
+        BaseValidator<ExampleCommand> validator = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .length(MIN_LENGTH, MAX_LENGTH, String.format("Min length is %d, max length is %d", MIN_LENGTH, MAX_LENGTH))
+                        .length(MIN_LENGTH, MAX_LENGTH, () -> ExampleException.withMessage("Min length is %d, max length is %d", MIN_LENGTH, MAX_LENGTH))
+                        .length(MIN_LENGTH, MAX_LENGTH, str -> ExampleException.withMessage("Length of StringProperty is %d, min length is %d, max length is %d", str.length(), MIN_LENGTH, MAX_LENGTH));
+            }
+        };
+        assertDoesNotThrow(() -> validator.validate(command));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = { "", "12345", "123456789" })
+    void length_specifiedMinLengthAndMaxLength_invalidLength(String value) {
+        ExampleCommand command = exampleCommandWithStringProperty(value);
+
+        BaseValidator<ExampleCommand> ruleWithMessage = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .length(MIN_LENGTH, MAX_LENGTH, String.format("Min length is %d, max length is %d", MIN_LENGTH, MAX_LENGTH));
+            }
+        };
+        IllegalArgumentException eWithSpecifiedMessage = assertThrows(
+                IllegalArgumentException.class,
+                () -> ruleWithMessage.validate(command));
+        assertEquals("Min length is 6, max length is 8", eWithSpecifiedMessage.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionSupplier = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .length(MIN_LENGTH, MAX_LENGTH, () -> ExampleException.withMessage("Min length is %d, max length is %d", MIN_LENGTH, MAX_LENGTH));
+            }
+        };
+        ExampleException specifiedException = assertThrows(
+            ExampleException.class,
+                () -> ruleWithExceptionSupplier.validate(command));
+        assertEquals("Min length is 6, max length is 8", specifiedException.getMessage());
+
+        BaseValidator<ExampleCommand> ruleWithExceptionFunction = new BaseValidator<ExampleCommand>() {
+            {
+                ruleForString(ExampleCommand::getStringProperty)
+                        .length(MIN_LENGTH, MAX_LENGTH, str -> ExampleException.withMessage("Length of StringProperty is %d, min length is %d, max length is %d", str.length(), MIN_LENGTH, MAX_LENGTH));
+            }
+        };
+        ExampleException specifiedException2 = assertThrows(
+            ExampleException.class,
+                () -> ruleWithExceptionFunction.validate(command));
+        assertEquals(
+                String.format("Length of StringProperty is %d, min length is %d, max length is %d", value.length(), MIN_LENGTH, MAX_LENGTH),
+                specifiedException2.getMessage());
+    }
 
     // ================================
     // #endregion - length