Add logical expressions in validator and starts/endswith

patrickfav · patrickfav · commit d89bfd875ab5 · 2017-11-04T14:33:00.000+01:00
diff --git a/README.md b/README.md
@@ -190,7 +190,7 @@ Bytes.from(array).encodeBase36(); //5qpdvuwjvu5
 A simple validation framework which can be used to check the internal byte array:
 
 ```java
-Bytes.wrap(new byte[]{8, 3, 9}.validate(BytesValidators.atLeast(3)); // true
+Bytes.wrap(new byte[]{8, 3, 9}.validate(BytesValidators.startsWith((byte) 8), BytesValidators.atLeast(3)); // true
 ```
 
 This is especially convenient when combining validators:
@@ -199,6 +199,23 @@ This is especially convenient when combining validators:
 Bytes.wrap(new byte[]{0, 1}.validate(BytesValidators.atMost(2), BytesValidators.notOnlyOf((byte)  0)); // true
 ```
 
+Validators also support nestable logical expressions AND, OR as well as NOT:
+
+```java
+Bytes.allocate(0).validate(or(exactLength(1), exactLength(0))) //true
+Bytes.allocate(21).validate(and(atLeast(3), atMost(20))) //true
+Bytes.allocate(2).validate(not(onlyOf((byte) 0))); //false
+```
+
+Nesting is also possible:
+
+```java
+assertTrue(Bytes.allocate(16).validate(
+                or(
+                   and(atLeast(8),not(onlyOf(((byte) 0)))),
+                   or(exactLength(16), exactLength(12)))));
+```
+
 ### Converting
 
 ### Mutable and Read-Only
diff --git a/src/main/java/at/favre/lib/bytes/Bytes.java b/src/main/java/at/favre/lib/bytes/Bytes.java
@@ -810,18 +810,14 @@ public boolean validateNotOnlyZeros() {
     }
 
     /**
-     * Applies all given validators and returns true if all of them return true
+     * Applies all given validators and returns true if all of them return true (default AND concatenation).
      *
      * @param bytesValidators array of validators to check against the byte array
      * @return true if all validators return true
      */
     public boolean validate(BytesValidator... bytesValidators) {
         Objects.requireNonNull(bytesValidators);
-        boolean valid = true;
-        for (BytesValidator bytesValidator : bytesValidators) {
-            valid &= bytesValidator.validate(internalArray());
-        }
-        return valid;
+        return BytesValidators.and(bytesValidators).validate(internalArray());
     }
 
     /* ATTRIBUTES ************************************************************************************************/
diff --git a/src/main/java/at/favre/lib/bytes/BytesValidator.java b/src/main/java/at/favre/lib/bytes/BytesValidator.java
@@ -21,6 +21,11 @@
 
 package at.favre.lib.bytes;
 
+import java.util.List;
+
+import static at.favre.lib.bytes.BytesValidator.Logical.Operator.NOT;
+import static at.favre.lib.bytes.BytesValidator.Logical.Operator.OR;
+
 /**
  * Interface for validating byte arrays
  */
@@ -64,7 +69,6 @@ public boolean validate(byte[] byteArrayToValidate) {
         }
     }
 
-
     /**
      * Checks if a byte array contains only the same value
      */
@@ -98,4 +102,79 @@ public boolean validate(byte[] byteArrayToValidate) {
             return mode == Mode.NONE_OF || mode == Mode.ONLY_OF;
         }
     }
+
+    /**
+     * Checks if arrays end or start with given array
+     */
+    final class PrePostFix implements BytesValidator {
+
+        private final byte[] pfix;
+        private final boolean startsWith;
+
+        public PrePostFix(boolean startsWith, byte... pfix) {
+            this.pfix = pfix;
+            this.startsWith = startsWith;
+        }
+
+        @Override
+        public boolean validate(byte[] byteArrayToValidate) {
+            if (pfix.length > byteArrayToValidate.length) {
+                return false;
+            }
+
+            for (int i = 0; i < pfix.length; i++) {
+                if (startsWith && pfix[i] != byteArrayToValidate[i]) {
+                    return false;
+                }
+                if (!startsWith && pfix[i] != byteArrayToValidate[byteArrayToValidate.length - pfix.length + i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    /**
+     * Logical operations over multiple validators
+     */
+    final class Logical implements BytesValidator {
+        enum Operator {
+            OR, AND, NOT
+        }
+
+        private final List<BytesValidator> validatorList;
+
+        private final Operator operator;
+
+        public Logical(List<BytesValidator> validatorList, Operator operator) {
+            if (validatorList.isEmpty()) throw new IllegalArgumentException("must contain at least 1 element");
+            if (operator == NOT && validatorList.size() != 1)
+                throw new IllegalArgumentException("not operator can only be applied to single element");
+            this.validatorList = validatorList;
+            this.operator = operator;
+
+        }
+
+        @Override
+        public boolean validate(byte[] byteArrayToValidate) {
+            if (operator == NOT) {
+                return !validatorList.get(0).validate(byteArrayToValidate);
+            }
+
+            boolean bool = operator != OR;
+            for (BytesValidator bytesValidator : validatorList) {
+                switch (operator) {
+                    default:
+                    case OR:
+                        bool |= bytesValidator.validate(byteArrayToValidate);
+                        break;
+                    case AND:
+                        bool &= bytesValidator.validate(byteArrayToValidate);
+                        break;
+                }
+            }
+            return bool;
+        }
+
+    }
 }
diff --git a/src/main/java/at/favre/lib/bytes/BytesValidators.java b/src/main/java/at/favre/lib/bytes/BytesValidators.java
@@ -21,6 +21,9 @@
 
 package at.favre.lib.bytes;
 
+import java.util.Arrays;
+import java.util.Collections;
+
 /**
  * Util and easy access for {@link BytesValidators}
  */
@@ -79,6 +82,26 @@ public static BytesValidator notOnlyOf(byte refByte) {
         return new BytesValidator.IdenticalContent(refByte, BytesValidator.IdenticalContent.Mode.NOT_ONLY_OF);
     }
 
+    /**
+     * Checks if the internal byte array starts with given bytes
+     *
+     * @param startsWithBytes the supposed prefix
+     * @return true all startsWithBytes match the first bytes in the internal array
+     */
+    public static BytesValidator startsWith(byte... startsWithBytes) {
+        return new BytesValidator.PrePostFix(true, startsWithBytes);
+    }
+
+    /**
+     * Checks if the internal byte array ends with given bytes
+     *
+     * @param endsWithBytes the supposed postfix
+     * @return true all startsWithBytes match the first bytes in the internal array
+     */
+    public static BytesValidator endsWith(byte... endsWithBytes) {
+        return new BytesValidator.PrePostFix(false, endsWithBytes);
+    }
+
     /**
      * Checks individual byte content
      *
@@ -88,4 +111,35 @@ public static BytesValidator notOnlyOf(byte refByte) {
     public static BytesValidator noneOf(byte refByte) {
         return new BytesValidator.IdenticalContent(refByte, BytesValidator.IdenticalContent.Mode.NONE_OF);
     }
+
+
+    /**
+     * This will execute all passed validators and returns true if at least one returns true (i.e. OR concatenation)
+     *
+     * @param validators at least one validator must be passed
+     * @return true if at least one validator returns true
+     */
+    public static BytesValidator or(BytesValidator... validators) {
+        return new BytesValidator.Logical(Arrays.asList(validators), BytesValidator.Logical.Operator.OR);
+    }
+
+    /**
+     * This will execute all passed validators and returns true if all return true (i.e. AND concatenation)
+     *
+     * @param validators at least one validator must be passed
+     * @return true if all return true
+     */
+    public static BytesValidator and(BytesValidator... validators) {
+        return new BytesValidator.Logical(Arrays.asList(validators), BytesValidator.Logical.Operator.AND);
+    }
+
+    /**
+     * This will negate the result of the passed validator
+     *
+     * @param validator to negate
+     * @return negated result
+     */
+    public static BytesValidator not(BytesValidator validator) {
+        return new BytesValidator.Logical(Collections.singletonList(validator), BytesValidator.Logical.Operator.NOT);
+    }
 }
diff --git a/src/test/java/at/favre/lib/bytes/BytesConstructorTests.java b/src/test/java/at/favre/lib/bytes/BytesConstructorTests.java
@@ -21,6 +21,7 @@
 
 package at.favre.lib.bytes;
 
+import org.junit.Ignore;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
@@ -290,6 +291,28 @@ public void fromFile() throws Exception {
         assertArrayEquals(randomBytes.array(), Bytes.from(tempFile).array());
     }
 
+    @Test(expected = IllegalArgumentException.class)
+    public void fromFileNotExisting() throws Exception {
+        Bytes.from(new File("doesnotexist"));
+    }
+
+    @Test
+    @Ignore("setting file NOT readable does not seem to work")
+    public void fromFileCannotRead() throws Exception {
+        File tempFile = testFolder.newFile("out-test2.txt");
+        Bytes randomBytes = Bytes.random(500);
+
+        try (FileOutputStream stream = new FileOutputStream(tempFile)) {
+            stream.write(randomBytes.array());
+        }
+        assertTrue(tempFile.setReadable(false));
+        try {
+            Bytes.from(tempFile);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+    }
+
     @Test
     public void fromObjectArray() throws Exception {
         Byte[] objectArray = new Byte[]{0x01, 0x02, 0x03, 0x04};
diff --git a/src/test/java/at/favre/lib/bytes/BytesValidatorTest.java b/src/test/java/at/favre/lib/bytes/BytesValidatorTest.java
@@ -23,8 +23,8 @@
 
 import org.junit.Test;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static at.favre.lib.bytes.BytesValidators.*;
+import static org.junit.Assert.*;
 
 public class BytesValidatorTest extends ABytesTest {
 
@@ -36,28 +36,84 @@ public void testOnlyOfValidator() throws Exception {
         assertTrue(Bytes.wrap(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 1}).validateNotOnlyZeros());
         assertTrue(Bytes.random(128).validateNotOnlyZeros());
 
-        assertTrue(Bytes.allocate(1).validate(BytesValidators.onlyOf((byte) 0)));
-        assertFalse(Bytes.allocate(1).validate(BytesValidators.noneOf((byte) 0)));
-        assertFalse(Bytes.allocate(1).validate(BytesValidators.onlyOf((byte) 1)));
-        assertTrue(Bytes.allocate(1).validate(BytesValidators.noneOf((byte) 1)));
-        assertTrue(Bytes.allocate(1).validate(BytesValidators.noneOf((byte) 1)));
-        assertTrue(Bytes.wrap(new byte[]{1, 1, 1, 1, 0, 1}).validate(BytesValidators.notOnlyOf((byte) 1)));
-        assertFalse(Bytes.wrap(new byte[]{1, 1, 1, 1, 1}).validate(BytesValidators.notOnlyOf((byte) 1)));
-        assertTrue(Bytes.wrap(new byte[]{1, 1, 1, 1, 1, 1}).validate(BytesValidators.onlyOf((byte) 1)));
+        assertTrue(Bytes.allocate(1).validate(onlyOf((byte) 0)));
+        assertFalse(Bytes.allocate(1).validate(noneOf((byte) 0)));
+        assertFalse(Bytes.allocate(1).validate(onlyOf((byte) 1)));
+        assertTrue(Bytes.allocate(1).validate(noneOf((byte) 1)));
+        assertTrue(Bytes.allocate(1).validate(noneOf((byte) 1)));
+        assertTrue(Bytes.wrap(new byte[]{1, 1, 1, 1, 0, 1}).validate(notOnlyOf((byte) 1)));
+        assertFalse(Bytes.wrap(new byte[]{1, 1, 1, 1, 1}).validate(notOnlyOf((byte) 1)));
+        assertTrue(Bytes.wrap(new byte[]{1, 1, 1, 1, 1, 1}).validate(onlyOf((byte) 1)));
     }
 
     @Test
     public void testLengthValidators() throws Exception {
-        assertFalse(Bytes.allocate(0).validate(BytesValidators.atLeast(1)));
-        assertTrue(Bytes.allocate(1).validate(BytesValidators.atLeast(1)));
-        assertTrue(Bytes.allocate(2).validate(BytesValidators.atLeast(1)));
+        assertFalse(Bytes.allocate(0).validate(atLeast(1)));
+        assertTrue(Bytes.allocate(1).validate(atLeast(1)));
+        assertTrue(Bytes.allocate(2).validate(atLeast(1)));
 
-        assertFalse(Bytes.allocate(2).validate(BytesValidators.atMost(1)));
-        assertTrue(Bytes.allocate(1).validate(BytesValidators.atMost(1)));
-        assertTrue(Bytes.allocate(0).validate(BytesValidators.atMost(1)));
+        assertFalse(Bytes.allocate(2).validate(atMost(1)));
+        assertTrue(Bytes.allocate(1).validate(atMost(1)));
+        assertTrue(Bytes.allocate(0).validate(atMost(1)));
 
-        assertFalse(Bytes.allocate(0).validate(BytesValidators.exactLength(1)));
-        assertTrue(Bytes.allocate(1).validate(BytesValidators.exactLength(1)));
-        assertFalse(Bytes.allocate(2).validate(BytesValidators.exactLength(1)));
+        assertFalse(Bytes.allocate(0).validate(exactLength(1)));
+        assertTrue(Bytes.allocate(1).validate(exactLength(1)));
+        assertFalse(Bytes.allocate(2).validate(exactLength(1)));
+    }
+
+    @Test
+    public void testOrValidation() throws Exception {
+        assertTrue(Bytes.allocate(0).validate(or(exactLength(1), exactLength(0))));
+        assertTrue(Bytes.allocate(2).validate(or(atLeast(3), onlyOf((byte) 0))));
+        assertTrue(Bytes.allocate(3).validate(or(onlyOf((byte) 1), onlyOf((byte) 0))));
+        assertTrue(Bytes.wrap(new byte[]{0, 0}).validate(or(onlyOf((byte) 1), onlyOf((byte) 0))));
+        assertFalse(Bytes.wrap(new byte[]{1, 0}).validate(or(onlyOf((byte) 2), onlyOf((byte) 1), onlyOf((byte) 0))));
+    }
+
+    @Test
+    public void testAndValidation() throws Exception {
+        assertFalse(Bytes.allocate(5).validate(and(atLeast(3), notOnlyOf((byte) 0))));
+        assertFalse(Bytes.wrap(new byte[]{1, 0}).validate(and(atLeast(3), notOnlyOf((byte) 0))));
+        assertTrue(Bytes.wrap(new byte[]{1, 0, 0}).validate(and(atLeast(3), notOnlyOf((byte) 0))));
+        assertFalse(Bytes.allocate(21).validate(and(atLeast(3), atMost(20))));
+    }
+
+    @Test
+    public void testNotValidation() throws Exception {
+        assertEquals(Bytes.allocate(2).validate(not(onlyOf((byte) 0))), Bytes.allocate(2).validate(notOnlyOf((byte) 0)));
+        assertTrue(Bytes.allocate(2).validate(not(atLeast(16))));
+        assertFalse(Bytes.allocate(2).validate(not(atMost(16))));
+    }
+
+    @Test
+    public void testNestedValidation() throws Exception {
+        assertTrue(Bytes.allocate(16).validate(
+                or(and(atLeast(8), not(onlyOf(((byte) 0)))),
+                        or(exactLength(16), exactLength(12)))));
+
+        assertTrue(Bytes.allocate(16).validate(or(exactLength(16), exactLength(12))));
+        assertFalse(Bytes.allocate(16).validate(and(atLeast(8), not(onlyOf(((byte) 0))))));
+        assertTrue(Bytes.allocate(16).validate(and(atLeast(8), onlyOf(((byte) 0)))));
+        assertTrue(Bytes.allocate(16).validate(or(not(onlyOf(((byte) 0))), exactLength(16))));
+    }
+
+    @Test
+    public void testStartWithValidate() throws Exception {
+        assertTrue(Bytes.wrap(new byte[]{0, 3, 0}).validate(startsWith((byte) 0, (byte) 3)));
+        assertFalse(Bytes.wrap(new byte[]{0, 2, 0}).validate(startsWith((byte) 0, (byte) 3)));
+        assertTrue(Bytes.wrap(new byte[]{0, 2, 0}).validate(startsWith((byte) 0)));
+        assertFalse(Bytes.wrap(new byte[]{0, 2, 0}).validate(startsWith((byte) 2)));
+        assertTrue(Bytes.allocate(16).validate(startsWith((byte) 0)));
+        assertFalse(Bytes.allocate(16).validate(startsWith(Bytes.allocate(17).array())));
+    }
+
+    @Test
+    public void testEndsWithValidate() throws Exception {
+        assertTrue(Bytes.wrap(new byte[]{1, 2, 3}).validate(endsWith((byte) 2, (byte) 3)));
+        assertFalse(Bytes.wrap(new byte[]{0, 2, 0}).validate(endsWith((byte) 3, (byte) 0)));
+        assertTrue(Bytes.wrap(new byte[]{0, 2, 0}).validate(endsWith((byte) 0)));
+        assertFalse(Bytes.wrap(new byte[]{0, 2, 0}).validate(endsWith((byte) 2)));
+        assertTrue(Bytes.allocate(16).validate(endsWith((byte) 0)));
+        assertFalse(Bytes.allocate(16).validate(endsWith(Bytes.allocate(17).array())));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -810,18 +810,14 @@ public boolean validateNotOnlyZeros() {`
`810`	`810`	`}`
`811`	`811`
`812`	`812`	`/**`
`813`		`- * Applies all given validators and returns true if all of them return true`
	`813`	`+ * Applies all given validators and returns true if all of them return true (default AND concatenation).`
`814`	`814`	`*`
`815`	`815`	`* @param bytesValidators array of validators to check against the byte array`
`816`	`816`	`* @return true if all validators return true`
`817`	`817`	`*/`
`818`	`818`	`public boolean validate(BytesValidator... bytesValidators) {`
`819`	`819`	`Objects.requireNonNull(bytesValidators);`
`820`		`- boolean valid = true;`
`821`		`- for (BytesValidator bytesValidator : bytesValidators) {`
`822`		`- valid &= bytesValidator.validate(internalArray());`
`823`		`- }`
`824`		`- return valid;`
	`820`	`+ return BytesValidators.and(bytesValidators).validate(internalArray());`
`825`	`821`	`}`
`826`	`822`
`827`	`823`	`/* ATTRIBUTES ************************************************************************************************/`