add

Author: Bascy6

app/src/main/java/hexlet/code/BaseSchema.java

@@ -0,0 +1,17 @@
+package hexlet.code;
+
+public abstract class BaseSchema<T> {
+    protected boolean isRequired = false;
+
+    public T required() {
+        this.isRequired = true;
+        return (T) this;
+    }
+
+    public boolean isValid(Object value) {
+        if (isRequired && value == null) {
+            return false;
+        }
+        return true;
+    }
+}

app/src/main/java/hexlet/code/NumberSchema.java

@@ -0,0 +1,39 @@
+package hexlet.code;
+
+public class NumberSchema extends BaseSchema<NumberSchema> {
+    private boolean isPositive = false;
+    private int minRange = Integer.MIN_VALUE;
+    private int maxRange = Integer.MAX_VALUE;
+
+    public NumberSchema positive() {
+        this.isPositive = true;
+        return this;
+    }
+
+    public NumberSchema range(int min, int max) {
+        this.minRange = min;
+        this.maxRange = max;
+        return this;
+    }
+
+    @Override
+    public boolean isValid(Object value) {
+        if (!super.isValid(value)) {
+            return false;
+        }
+        if (value == null) {
+            return true;
+        }
+        if (!(value instanceof Integer)) {
+            return false;
+        }
+        int number = (int) value;
+        if (isPositive && number <= 0) {
+            return false;
+        }
+        if (number < minRange || number > maxRange) {
+            return false;
+        }
+        return true;
+    }
+}

app/src/main/java/hexlet/code/StringSchema.java

@@ -1,15 +1,9 @@
 package hexlet.code;
 
-public class StringSchema {
-    private boolean isRequired = false;
+public class StringSchema extends BaseSchema<StringSchema> {
     private int minLength = 0;
     private String containsSubstring = null;
 
-    public StringSchema required() {
-        this.isRequired = true;
-        return this;
-    }
-
     public StringSchema minLength(int length) {
         this.minLength = length;
         return this;
@@ -20,17 +14,25 @@ public StringSchema contains(String substring) {
         return this;
     }
 
-    public boolean isValid(String value) {
+    @Override
+    public boolean isValid(Object value) {
+        if (!super.isValid(value)) {
+            return false;
+        }
         if (value == null) {
-            return !isRequired;
+            return !isRequired; // Если значение null, оно валидно только если isRequired == false
         }
-        if (isRequired && value.isEmpty()) {
+        if (!(value instanceof String)) {
             return false;
         }
-        if (value.length() < minLength) {
+        String str = (String) value;
+        if (isRequired && str.isEmpty()) {
+            return false; // Пустая строка не валидна, если isRequired == true
+        }
+        if (str.length() < minLength) {
             return false;
         }
-        if (containsSubstring != null && !value.contains(containsSubstring)) {
+        if (containsSubstring != null && !str.contains(containsSubstring)) {
             return false;
         }
         return true;

app/src/main/java/hexlet/code/Validator.java

@@ -4,4 +4,8 @@ public class Validator {
     public StringSchema string() {
         return new StringSchema();
     }
+
+    public NumberSchema number() {
+        return new NumberSchema();
+    }
 }

app/src/test/java/hexlet/code/NumberSchemaTest.java

@@ -0,0 +1,65 @@
+package hexlet.code;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+public class NumberSchemaTest {
+
+    @Test
+    public void testDefaultSchema() {
+        Validator v = new Validator();
+        NumberSchema schema = v.number();
+
+        assertTrue(schema.isValid(null));
+        assertTrue(schema.isValid(5));
+    }
+
+    @Test
+    public void testRequired() {
+        Validator v = new Validator();
+        StringSchema schema = v.string().required();
+
+        assertFalse(schema.isValid(null));
+        assertFalse(schema.isValid(""));
+        assertTrue(schema.isValid("hexlet"));
+    }
+
+    @Test
+    public void testPositive() {
+        Validator v = new Validator();
+        NumberSchema schema = v.number().positive();
+
+        assertTrue(schema.isValid(10));
+        assertFalse(schema.isValid(-10));
+        assertFalse(schema.isValid(0));
+    }
+
+    @Test
+    public void testRange() {
+        Validator v = new Validator();
+        NumberSchema schema = v.number().range(5, 10);
+
+        assertTrue(schema.isValid(5));
+        assertTrue(schema.isValid(10));
+        assertFalse(schema.isValid(4));
+        assertFalse(schema.isValid(11));
+    }
+
+    @Test
+    public void testCombinedRules() {
+        Validator v = new Validator();
+        NumberSchema schema = v.number()
+                .required()
+                .positive()
+                .range(5, 10);
+
+        assertFalse(schema.isValid(null)); // required
+        assertFalse(schema.isValid(-5));   // positive
+        assertFalse(schema.isValid(0));    // positive
+        assertFalse(schema.isValid(4));    // range
+        assertFalse(schema.isValid(11));   // range
+        assertTrue(schema.isValid(5));     // valid
+        assertTrue(schema.isValid(10));    // valid
+    }
+}