diff --git a/src/main/java/am/ik/yavi/constraint/BigDecimalConstraint.java b/src/main/java/am/ik/yavi/constraint/BigDecimalConstraint.java
index c7b0f8a9..57503ddd 100644
--- a/src/main/java/am/ik/yavi/constraint/BigDecimalConstraint.java
+++ b/src/main/java/am/ik/yavi/constraint/BigDecimalConstraint.java
@@ -51,4 +51,9 @@ protected Predicate<BigDecimal> isLessThanOrEqual(BigDecimal max) {
 	protected BigDecimal zeroValue() {
 		return BigDecimal.ZERO;
 	}
+
+	@Override
+	protected BigDecimal oneValue() {
+		return BigDecimal.ONE;
+	}
 }
diff --git a/src/main/java/am/ik/yavi/constraint/BigIntegerConstraint.java b/src/main/java/am/ik/yavi/constraint/BigIntegerConstraint.java
index 29c9cc80..d9a5b0e3 100644
--- a/src/main/java/am/ik/yavi/constraint/BigIntegerConstraint.java
+++ b/src/main/java/am/ik/yavi/constraint/BigIntegerConstraint.java
@@ -51,4 +51,9 @@ protected Predicate<BigInteger> isLessThanOrEqual(BigInteger max) {
 	protected BigInteger zeroValue() {
 		return BigInteger.ZERO;
 	}
+
+	@Override
+	protected BigInteger oneValue() {
+		return BigInteger.ONE;
+	}
 }
diff --git a/src/main/java/am/ik/yavi/constraint/ByteConstraint.java b/src/main/java/am/ik/yavi/constraint/ByteConstraint.java
index 3e694367..0db3bc10 100644
--- a/src/main/java/am/ik/yavi/constraint/ByteConstraint.java
+++ b/src/main/java/am/ik/yavi/constraint/ByteConstraint.java
@@ -49,4 +49,9 @@ protected Predicate<Byte> isLessThanOrEqual(Byte max) {
 	protected Byte zeroValue() {
 		return 0;
 	}
+
+	@Override
+	protected Byte oneValue() {
+		return 1;
+	}
 }
diff --git a/src/main/java/am/ik/yavi/constraint/CharacterConstraint.java b/src/main/java/am/ik/yavi/constraint/CharacterConstraint.java
index 501f757e..d75c02d3 100644
--- a/src/main/java/am/ik/yavi/constraint/CharacterConstraint.java
+++ b/src/main/java/am/ik/yavi/constraint/CharacterConstraint.java
@@ -50,4 +50,9 @@ protected Predicate<Character> isLessThanOrEqual(Character max) {
 	protected Character zeroValue() {
 		return Character.MIN_VALUE;
 	}
+
+	@Override
+	protected Character oneValue() {
+		return '1';
+	}
 }
diff --git a/src/main/java/am/ik/yavi/constraint/DoubleConstraint.java b/src/main/java/am/ik/yavi/constraint/DoubleConstraint.java
index a848ac23..3cc16644 100644
--- a/src/main/java/am/ik/yavi/constraint/DoubleConstraint.java
+++ b/src/main/java/am/ik/yavi/constraint/DoubleConstraint.java
@@ -50,4 +50,9 @@ protected Predicate<Double> isLessThanOrEqual(Double max) {
 	protected Double zeroValue() {
 		return 0.0;
 	}
+
+	@Override
+	protected Double oneValue() {
+		return 1.0;
+	}
 }
diff --git a/src/main/java/am/ik/yavi/constraint/FloatConstraint.java b/src/main/java/am/ik/yavi/constraint/FloatConstraint.java
index 4d5ee6af..68d974db 100644
--- a/src/main/java/am/ik/yavi/constraint/FloatConstraint.java
+++ b/src/main/java/am/ik/yavi/constraint/FloatConstraint.java
@@ -50,4 +50,9 @@ protected Predicate<Float> isLessThanOrEqual(Float max) {
 	protected Float zeroValue() {
 		return 0f;
 	}
+
+	@Override
+	protected Float oneValue() {
+		return 1f;
+	}
 }
diff --git a/src/main/java/am/ik/yavi/constraint/IntegerConstraint.java b/src/main/java/am/ik/yavi/constraint/IntegerConstraint.java
index b3d5bd40..ef3b0761 100644
--- a/src/main/java/am/ik/yavi/constraint/IntegerConstraint.java
+++ b/src/main/java/am/ik/yavi/constraint/IntegerConstraint.java
@@ -50,4 +50,9 @@ protected Predicate<Integer> isLessThanOrEqual(Integer max) {
 	protected Integer zeroValue() {
 		return 0;
 	}
+
+	@Override
+	protected Integer oneValue() {
+		return 1;
+	}
 }
diff --git a/src/main/java/am/ik/yavi/constraint/LongConstraint.java b/src/main/java/am/ik/yavi/constraint/LongConstraint.java
index 31fdf760..f95bb8f6 100644
--- a/src/main/java/am/ik/yavi/constraint/LongConstraint.java
+++ b/src/main/java/am/ik/yavi/constraint/LongConstraint.java
@@ -49,4 +49,9 @@ protected Predicate<Long> isLessThanOrEqual(Long max) {
 	protected Long zeroValue() {
 		return 0L;
 	}
+
+	@Override
+	protected Long oneValue() {
+		return 1L;
+	}
 }
diff --git a/src/main/java/am/ik/yavi/constraint/ShortConstraint.java b/src/main/java/am/ik/yavi/constraint/ShortConstraint.java
index 6c64e094..dc822d43 100644
--- a/src/main/java/am/ik/yavi/constraint/ShortConstraint.java
+++ b/src/main/java/am/ik/yavi/constraint/ShortConstraint.java
@@ -50,4 +50,9 @@ protected Predicate<Short> isLessThanOrEqual(Short max) {
 	protected Short zeroValue() {
 		return 0;
 	}
+
+	@Override
+	protected Short oneValue() {
+		return 1;
+	}
 }
diff --git a/src/main/java/am/ik/yavi/constraint/base/NumericConstraintBase.java b/src/main/java/am/ik/yavi/constraint/base/NumericConstraintBase.java
index 2a5671dd..65be03a3 100644
--- a/src/main/java/am/ik/yavi/constraint/base/NumericConstraintBase.java
+++ b/src/main/java/am/ik/yavi/constraint/base/NumericConstraintBase.java
@@ -51,6 +51,15 @@ public C lessThanOrEqual(V max) {
 	}
 
 	/**
+	 * Is the given value positve. Positive means it is greater than 0.
+	 *
+	 * <pre>
+	 *     0 -> false
+	 *     1 -> true
+	 *     n where n > 0 -> true
+	 *     n where n < 0 -> false
+	 * </pre>
+	 *
 	 * @since 0.10.0
 	 */
 	public C positive() {
@@ -59,9 +68,7 @@ public C positive() {
 		return cast();
 	}
 
-	/**
-	 * @since 0.10.0
-	 */
+	/** @since 0.10.0 */
 	public C positiveOrZero() {
 		this.predicates()
 				.add(ConstraintPredicate.of(this.isGreaterThanOrEqual(zeroValue()),
@@ -70,6 +77,16 @@ public C positiveOrZero() {
 	}
 
 	/**
+	 * Is the given value negative. Negative means it is less than 0.
+	 *
+	 * <pre>
+	 *     0 -> false
+	 *     1 -> false
+	 *     -1 -> true
+	 *     n where n > 0 -> false
+	 *     n where n < 0 -> true
+	 * </pre>
+	 *
 	 * @since 0.10.0
 	 */
 	public C negative() {
@@ -78,15 +95,29 @@ public C negative() {
 		return cast();
 	}
 
-	/**
-	 * @since 0.10.0
-	 */
+	/** @since 0.10.0 */
 	public C negaitveOrZero() {
 		this.predicates().add(ConstraintPredicate.of(this.isLessThanOrEqual(zeroValue()),
 				NUMERIC_NEGATIVE_OR_ZERO, () -> new Object[] {}, VALID));
 		return cast();
 	}
 
+	/**
+	 * Is the given value equal to the zero representation of its type. The exact
+	 * representation of <i>zero</i> can be found in {@link #zeroValue()}.
+	 */
+	public C isZero() {
+		return this.equalTo(zeroValue());
+	}
+
+	/**
+	 * Is the given value equal to the <i>one</i> representation of its type The exact
+	 * representation of <i>one</i> can be found in {@link #oneValue()}.
+	 */
+	public C isOne() {
+		return this.equalTo(oneValue());
+	}
+
 	protected abstract Predicate<V> isGreaterThan(V min);
 
 	protected abstract Predicate<V> isGreaterThanOrEqual(V min);
@@ -95,5 +126,17 @@ public C negaitveOrZero() {
 
 	protected abstract Predicate<V> isLessThanOrEqual(V max);
 
+	/**
+	 * The value that represents zero
+	 *
+	 * @return the numeric value zero
+	 */
 	protected abstract V zeroValue();
+
+	/**
+	 * The value that represents one
+	 *
+	 * @return the numeric value one
+	 */
+	protected abstract V oneValue();
 }
diff --git a/src/test/java/am/ik/yavi/constraint/BigDecimalConstraintTest.java b/src/test/java/am/ik/yavi/constraint/BigDecimalConstraintTest.java
index 34b1bd49..80c60260 100644
--- a/src/test/java/am/ik/yavi/constraint/BigDecimalConstraintTest.java
+++ b/src/test/java/am/ik/yavi/constraint/BigDecimalConstraintTest.java
@@ -16,6 +16,7 @@
 package am.ik.yavi.constraint;
 
 import am.ik.yavi.constraint.base.NumericConstraintBase;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
@@ -155,6 +156,34 @@ void validNegativeOrZero(BigDecimal value) {
 		assertThat(predicate.test(value)).isTrue();
 	}
 
+	@ParameterizedTest
+	@ValueSource(strings = { "-101", "-120" })
+	void invalidZero(BigDecimal value) {
+		Predicate<BigDecimal> predicate = retrievePredicate(
+				NumericConstraintBase::isZero);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validZero() {
+		Predicate<BigDecimal> predicate = retrievePredicate(
+				NumericConstraintBase::isZero);
+		assertThat(predicate.test(BigDecimal.ZERO)).isTrue();
+	}
+
+	@ParameterizedTest
+	@ValueSource(strings = { "-101", "-120" })
+	void invalidOne(BigDecimal value) {
+		Predicate<BigDecimal> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validOne() {
+		Predicate<BigDecimal> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(BigDecimal.ONE)).isTrue();
+	}
+
 	private static Predicate<BigDecimal> retrievePredicate(
 			Function<BigDecimalConstraint<BigDecimal>, BigDecimalConstraint<BigDecimal>> constraint) {
 		return constraint.apply(new BigDecimalConstraint<>()).predicates().peekFirst()
diff --git a/src/test/java/am/ik/yavi/constraint/BigIntegerConstraintTest.java b/src/test/java/am/ik/yavi/constraint/BigIntegerConstraintTest.java
index a218c9c4..4f7c13a8 100644
--- a/src/test/java/am/ik/yavi/constraint/BigIntegerConstraintTest.java
+++ b/src/test/java/am/ik/yavi/constraint/BigIntegerConstraintTest.java
@@ -16,10 +16,10 @@
 package am.ik.yavi.constraint;
 
 import am.ik.yavi.constraint.base.NumericConstraintBase;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
-import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.function.Function;
 import java.util.function.Predicate;
@@ -156,6 +156,34 @@ void validNegativeOrZero(BigInteger value) {
 		assertThat(predicate.test(value)).isTrue();
 	}
 
+	@ParameterizedTest
+	@ValueSource(strings = { "-101", "-120" })
+	void invalidZero(BigInteger value) {
+		Predicate<BigInteger> predicate = retrievePredicate(
+				NumericConstraintBase::isZero);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validZero() {
+		Predicate<BigInteger> predicate = retrievePredicate(
+				NumericConstraintBase::isZero);
+		assertThat(predicate.test(BigInteger.ZERO)).isTrue();
+	}
+
+	@ParameterizedTest
+	@ValueSource(strings = { "-101", "-120" })
+	void invalidOne(BigInteger value) {
+		Predicate<BigInteger> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validOne() {
+		Predicate<BigInteger> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(BigInteger.ONE)).isTrue();
+	}
+
 	private static Predicate<BigInteger> retrievePredicate(
 			Function<BigIntegerConstraint<BigInteger>, BigIntegerConstraint<BigInteger>> constraint) {
 		return constraint.apply(new BigIntegerConstraint<>()).predicates().peekFirst()
diff --git a/src/test/java/am/ik/yavi/constraint/ByteConstraintTest.java b/src/test/java/am/ik/yavi/constraint/ByteConstraintTest.java
index 0532c311..3541ad17 100644
--- a/src/test/java/am/ik/yavi/constraint/ByteConstraintTest.java
+++ b/src/test/java/am/ik/yavi/constraint/ByteConstraintTest.java
@@ -16,10 +16,10 @@
 package am.ik.yavi.constraint;
 
 import am.ik.yavi.constraint.base.NumericConstraintBase;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
-import java.math.BigInteger;
 import java.util.function.Function;
 import java.util.function.Predicate;
 
@@ -145,6 +145,32 @@ void validNegativeOrZero(byte value) {
 		assertThat(predicate.test(value)).isTrue();
 	}
 
+	@ParameterizedTest
+	@ValueSource(bytes = { -101, -120 })
+	void invalidZero(byte value) {
+		Predicate<Byte> predicate = retrievePredicate(NumericConstraintBase::isZero);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validZero() {
+		Predicate<Byte> predicate = retrievePredicate(NumericConstraintBase::isZero);
+		assertThat(predicate.test(Byte.valueOf("0"))).isTrue();
+	}
+
+	@ParameterizedTest
+	@ValueSource(bytes = { -101, -120 })
+	void invalidOne(byte value) {
+		Predicate<Byte> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validOne() {
+		Predicate<Byte> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(Byte.valueOf("1"))).isTrue();
+	}
+
 	private static Predicate<Byte> retrievePredicate(
 			Function<ByteConstraint<Byte>, ByteConstraint<Byte>> constraint) {
 		return constraint.apply(new ByteConstraint<>()).predicates().peekFirst()
diff --git a/src/test/java/am/ik/yavi/constraint/CharacterConstraintTest.java b/src/test/java/am/ik/yavi/constraint/CharacterConstraintTest.java
index bacc4d7c..ad3b5593 100644
--- a/src/test/java/am/ik/yavi/constraint/CharacterConstraintTest.java
+++ b/src/test/java/am/ik/yavi/constraint/CharacterConstraintTest.java
@@ -16,6 +16,7 @@
 package am.ik.yavi.constraint;
 
 import am.ik.yavi.constraint.base.NumericConstraintBase;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
@@ -112,6 +113,32 @@ void validNegative(char value) {
 		assertThat(predicate.test(value)).isFalse();
 	}
 
+	@ParameterizedTest
+	@ValueSource(chars = { 101, 120 })
+	void invalidZero(char value) {
+		Predicate<Character> predicate = retrievePredicate(NumericConstraintBase::isZero);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validZero() {
+		Predicate<Character> predicate = retrievePredicate(NumericConstraintBase::isZero);
+		assertThat(predicate.test(Character.MIN_VALUE)).isTrue();
+	}
+
+	@ParameterizedTest
+	@ValueSource(chars = { 101, 120 })
+	void invalidOne(char value) {
+		Predicate<Character> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validOne() {
+		Predicate<Character> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test('1')).isTrue();
+	}
+
 	private static Predicate<Character> retrievePredicate(
 			Function<CharacterConstraint<Character>, CharacterConstraint<Character>> constraint) {
 		return constraint.apply(new CharacterConstraint<>()).predicates().peekFirst()
diff --git a/src/test/java/am/ik/yavi/constraint/DoubleConstraintTest.java b/src/test/java/am/ik/yavi/constraint/DoubleConstraintTest.java
index 4d99933b..6e5f371a 100644
--- a/src/test/java/am/ik/yavi/constraint/DoubleConstraintTest.java
+++ b/src/test/java/am/ik/yavi/constraint/DoubleConstraintTest.java
@@ -16,6 +16,7 @@
 package am.ik.yavi.constraint;
 
 import am.ik.yavi.constraint.base.NumericConstraintBase;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
@@ -142,6 +143,32 @@ void validNegativeOrZero(double value) {
 		assertThat(predicate.test(value)).isTrue();
 	}
 
+	@ParameterizedTest
+	@ValueSource(doubles = { -101.5, -120.1 })
+	void invalidZero(double value) {
+		Predicate<Double> predicate = retrievePredicate(NumericConstraintBase::isZero);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validZero() {
+		Predicate<Double> predicate = retrievePredicate(NumericConstraintBase::isZero);
+		assertThat(predicate.test(0.0)).isTrue();
+	}
+
+	@ParameterizedTest
+	@ValueSource(doubles = { -101.5, -120.1 })
+	void invalidOne(double value) {
+		Predicate<Double> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validOne() {
+		Predicate<Double> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(1.0)).isTrue();
+	}
+
 	private static Predicate<Double> retrievePredicate(
 			Function<DoubleConstraint<Double>, DoubleConstraint<Double>> constraint) {
 		return constraint.apply(new DoubleConstraint<>()).predicates().peekFirst()
diff --git a/src/test/java/am/ik/yavi/constraint/FloatConstraintTest.java b/src/test/java/am/ik/yavi/constraint/FloatConstraintTest.java
index 8d9d14bc..63c95c8a 100644
--- a/src/test/java/am/ik/yavi/constraint/FloatConstraintTest.java
+++ b/src/test/java/am/ik/yavi/constraint/FloatConstraintTest.java
@@ -16,6 +16,7 @@
 package am.ik.yavi.constraint;
 
 import am.ik.yavi.constraint.base.NumericConstraintBase;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
@@ -142,6 +143,32 @@ void validNegativeOrZero(float value) {
 		assertThat(predicate.test(value)).isTrue();
 	}
 
+	@ParameterizedTest
+	@ValueSource(floats = { -101f, -120f })
+	void invalidZero(float value) {
+		Predicate<Float> predicate = retrievePredicate(NumericConstraintBase::isZero);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validZero() {
+		Predicate<Float> predicate = retrievePredicate(NumericConstraintBase::isZero);
+		assertThat(predicate.test(0f)).isTrue();
+	}
+
+	@ParameterizedTest
+	@ValueSource(floats = { -101f, -120f })
+	void invalidOne(float value) {
+		Predicate<Float> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validOne() {
+		Predicate<Float> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(1f)).isTrue();
+	}
+
 	private static Predicate<Float> retrievePredicate(
 			Function<FloatConstraint<Float>, FloatConstraint<Float>> constraint) {
 		return constraint.apply(new FloatConstraint<>()).predicates().peekFirst()
diff --git a/src/test/java/am/ik/yavi/constraint/IntegerConstraintTest.java b/src/test/java/am/ik/yavi/constraint/IntegerConstraintTest.java
index 8cab6f49..cb9a12b9 100644
--- a/src/test/java/am/ik/yavi/constraint/IntegerConstraintTest.java
+++ b/src/test/java/am/ik/yavi/constraint/IntegerConstraintTest.java
@@ -16,6 +16,7 @@
 package am.ik.yavi.constraint;
 
 import am.ik.yavi.constraint.base.NumericConstraintBase;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
@@ -142,6 +143,32 @@ void validNegativeOrZero(int value) {
 		assertThat(predicate.test(value)).isTrue();
 	}
 
+	@ParameterizedTest
+	@ValueSource(ints = { -101, -120 })
+	void invalidZero(int value) {
+		Predicate<Integer> predicate = retrievePredicate(NumericConstraintBase::isZero);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validZero() {
+		Predicate<Integer> predicate = retrievePredicate(NumericConstraintBase::isZero);
+		assertThat(predicate.test(0)).isTrue();
+	}
+
+	@ParameterizedTest
+	@ValueSource(ints = { -101, -120 })
+	void invalidOne(int value) {
+		Predicate<Integer> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validOne() {
+		Predicate<Integer> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(1)).isTrue();
+	}
+
 	private static Predicate<Integer> retrievePredicate(
 			Function<IntegerConstraint<Integer>, IntegerConstraint<Integer>> constraint) {
 		return constraint.apply(new IntegerConstraint<>()).predicates().peekFirst()
diff --git a/src/test/java/am/ik/yavi/constraint/LongConstraintTest.java b/src/test/java/am/ik/yavi/constraint/LongConstraintTest.java
index 802d5f2a..c8b5b572 100644
--- a/src/test/java/am/ik/yavi/constraint/LongConstraintTest.java
+++ b/src/test/java/am/ik/yavi/constraint/LongConstraintTest.java
@@ -16,6 +16,7 @@
 package am.ik.yavi.constraint;
 
 import am.ik.yavi.constraint.base.NumericConstraintBase;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
@@ -142,6 +143,32 @@ void validNegativeOrZero(long value) {
 		assertThat(predicate.test(value)).isTrue();
 	}
 
+	@ParameterizedTest
+	@ValueSource(longs = { -101L, -120L })
+	void invalidZero(long value) {
+		Predicate<Long> predicate = retrievePredicate(NumericConstraintBase::isZero);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validZero() {
+		Predicate<Long> predicate = retrievePredicate(NumericConstraintBase::isZero);
+		assertThat(predicate.test(0L)).isTrue();
+	}
+
+	@ParameterizedTest
+	@ValueSource(longs = { -101L, -120L })
+	void invalidOne(long value) {
+		Predicate<Long> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validOne() {
+		Predicate<Long> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(1L)).isTrue();
+	}
+
 	private static Predicate<Long> retrievePredicate(
 			Function<LongConstraint<Long>, LongConstraint<Long>> constraint) {
 		return constraint.apply(new LongConstraint<>()).predicates().peekFirst()
diff --git a/src/test/java/am/ik/yavi/constraint/ShortConstraintTest.java b/src/test/java/am/ik/yavi/constraint/ShortConstraintTest.java
index e655e5af..b719d0d5 100644
--- a/src/test/java/am/ik/yavi/constraint/ShortConstraintTest.java
+++ b/src/test/java/am/ik/yavi/constraint/ShortConstraintTest.java
@@ -16,6 +16,7 @@
 package am.ik.yavi.constraint;
 
 import am.ik.yavi.constraint.base.NumericConstraintBase;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
@@ -146,6 +147,32 @@ void validNegativeOrZero(short value) {
 		assertThat(predicate.test(value)).isTrue();
 	}
 
+	@ParameterizedTest
+	@ValueSource(shorts = { -101, -120 })
+	void invalidZero(short value) {
+		Predicate<Short> predicate = retrievePredicate(NumericConstraintBase::isZero);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validZero() {
+		Predicate<Short> predicate = retrievePredicate(NumericConstraintBase::isZero);
+		assertThat(predicate.test(Short.parseShort("0"))).isTrue();
+	}
+
+	@ParameterizedTest
+	@ValueSource(shorts = { -101, -120 })
+	void invalidOne(short value) {
+		Predicate<Short> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(value)).isFalse();
+	}
+
+	@Test
+	void validOne() {
+		Predicate<Short> predicate = retrievePredicate(NumericConstraintBase::isOne);
+		assertThat(predicate.test(Short.parseShort("1"))).isTrue();
+	}
+
 	private static Predicate<Short> retrievePredicate(
 			Function<ShortConstraint<Short>, ShortConstraint<Short>> constraint) {
 		return constraint.apply(new ShortConstraint<>()).predicates().peekFirst()
diff --git a/src/test/java/am/ik/yavi/core/ValidatorTest.java b/src/test/java/am/ik/yavi/core/ValidatorTest.java
index 6494a9e5..404d5039 100644
--- a/src/test/java/am/ik/yavi/core/ValidatorTest.java
+++ b/src/test/java/am/ik/yavi/core/ValidatorTest.java
@@ -36,6 +36,7 @@
 import static org.assertj.core.api.Assertions.fail;
 
 class ValidatorTest {
+
 	@Test
 	void allInvalid() throws Exception {
 		User user = new User("", "example.com", 300);
@@ -61,8 +62,8 @@ void allInvalid() throws Exception {
 	@Test
 	void codePointsAllIncludedRange() throws Exception {
 		CodePointsRanges<String> whiteList = () -> Arrays.asList(
-				CodePoints.Range.of(0x0041/* A */, 0x005A /* Z */),
-				CodePoints.Range.of(0x0061/* a */, 0x007A /* z */));
+				CodePoints.Range.of(0x0041 /* A */, 0x005A /* Z */),
+				CodePoints.Range.of(0x0061 /* a */, 0x007A /* z */));
 
 		User user = new User("abc@b.c", null, null);
 		Validator<User> validator = ValidatorBuilder.of(User.class)
@@ -82,7 +83,7 @@ void codePointsAllIncludedRangeBeginToEnd() throws Exception {
 		User user = new User("abc@b.c", null, null);
 		Validator<User> validator = ValidatorBuilder.of(User.class)
 				.constraint(User::getName, "name",
-						c -> c.codePoints(0x0041/* A */, 0x007A /* z */).asWhiteList())
+						c -> c.codePoints(0x0041 /* A */, 0x007A /* z */).asWhiteList())
 				.build();
 		ConstraintViolations violations = validator.validate(user);
 		assertThat(violations.isValid()).isFalse();
@@ -95,10 +96,11 @@ void codePointsAllIncludedRangeBeginToEnd() throws Exception {
 	@Test
 	void codePointsAllIncludedRangeRange() throws Exception {
 		User user = new User("abc@b.c", null, null);
-		Validator<User> validator = ValidatorBuilder.of(User.class).constraint(
-				User::getName, "name",
-				c -> c.codePoints(CodePoints.Range.of(0x0041/* A */, 0x005A /* Z */),
-						CodePoints.Range.of(0x0061/* a */, 0x007A /* z */)).asWhiteList())
+		Validator<User> validator = ValidatorBuilder.of(User.class)
+				.constraint(User::getName, "name", c -> c
+						.codePoints(CodePoints.Range.of(0x0041 /* A */, 0x005A /* Z */),
+								CodePoints.Range.of(0x0061 /* a */, 0x007A /* z */))
+						.asWhiteList())
 				.build();
 		ConstraintViolations violations = validator.validate(user);
 		assertThat(violations.isValid()).isFalse();
@@ -173,8 +175,8 @@ void codePointsAllIncludedSetSet() throws Exception {
 	@Test
 	void codePointsNotIncludedRange() throws Exception {
 		CodePointsRanges<String> blackList = () -> Arrays.asList(
-				CodePoints.Range.of(0x0041/* A */, 0x0042 /* B */),
-				CodePoints.Range.of(0x0061/* a */, 0x0062 /* b */));
+				CodePoints.Range.of(0x0041 /* A */, 0x0042 /* B */),
+				CodePoints.Range.of(0x0061 /* a */, 0x0062 /* b */));
 
 		User user = new User("abcA@Bb.c", null, null);
 		Validator<User> validator = ValidatorBuilder.of(User.class)
@@ -741,6 +743,36 @@ void ageNegativeValidatorUserInValid() {
 		assertThat(violations.get(0).message()).isEqualTo("\"age\" must be negative");
 	}
 
+	@Test
+	void ageIsZeroAndNameDiegoValidTest() {
+		String validName = "Diego";
+		User user = new User(validName, "foo@bar.com", 0);
+
+		Validator<User> validator = ValidatorBuilder.<User> of()
+				.constraint(User::getAge, "age", NumericConstraintBase::isZero)
+				.constraint(User::getName, "name", c -> c.equalTo(validName)).build();
+
+		ConstraintViolations violations = validator.validate(user);
+		assertThat(violations.isValid()).isTrue();
+	}
+
+	@Test
+	void ageIsZeroAndNameDiegoInValidTest() {
+		String validName = "Diego";
+		User user = new User(validName + "Invalid", "foo@bar.com", 10);
+
+		Validator<User> validator = ValidatorBuilder.<User> of()
+				.constraint(User::getAge, "age", NumericConstraintBase::isZero)
+				.constraint(User::getName, "name", c -> c.equalTo(validName)).build();
+
+		ConstraintViolations violations = validator.validate(user);
+		assertThat(violations.isValid()).isFalse();
+		assertThat(violations.size()).isEqualTo(2);
+		assertThat(violations.get(0).message()).isEqualTo("\"age\" must be equal to 0");
+		assertThat(violations.get(1).message())
+				.isEqualTo("\"name\" must be equal to Diego");
+	}
+
 	Validator<User> validator() {
 		return ValidatorBuilder.<User> of() //
 				.constraint(User::getName, "name", c -> c.notNull() //
@@ -756,5 +788,4 @@ Validator<User> validator() {
 				.constraint(User::isEnabled, "enabled", c -> c.isTrue()) //
 				.build();
 	}
-
 }