Add tests and doc to checksum feature

Author: patrickfav

CHANGELOG

@@ -4,6 +4,7 @@
 
 * add bitAt() utility
 * add hash feature
+* add checksum transformer
 
 ## v0.4.0
 

README.md

@@ -201,6 +201,16 @@ Bytes hash = Bytes.wrap(array).sha256();
 Bytes hash = Bytes.wrap(array).hash("MD5");
 ```
 
+**Checksum** can be calculated or automatically appended:
+
+```java
+import static at.favre.lib.bytes.BytesTransformers.*;
+
+Bytes.wrap(array).transform(checksumAppendCrc32());
+Bytes.wrap(array).transform(checksumCrc32());
+Bytes.wrap(array).transform(checksum(new Adler32(), ChecksumTransformer.Mode.TRANSFORM, 4));
+```
+
 Other transformers:
 
 ```java
@@ -289,13 +299,15 @@ The `toString()` methods only shows the length and a preview of maximal 8 bytes:
 A simple validation framework which can be used to check the internal byte array:
 
 ```java
-Bytes.wrap(new byte[]{8, 3, 9}.validate(BytesValidators.startsWith((byte) 8), BytesValidators.atLeast(3)); // true
+import static at.favre.lib.bytes.BytesValidators.*;
+
+Bytes.wrap(new byte[]{8, 3, 9}.validate(startsWith((byte) 8), atLeast(3)); // true
 ```
 
 This is especially convenient when combining validators:
 
 ```java
-Bytes.wrap(new byte[]{0, 1}.validate(BytesValidators.atMost(2), BytesValidators.notOnlyOf((byte)  0)); // true
+Bytes.wrap(new byte[]{0, 1}.validate(atMost(2), notOnlyOf((byte)  0)); // true
 ```
 
 Validators also support nestable logical expressions AND, OR as well as NOT:

src/main/java/at/favre/lib/bytes/BytesTransformers.java

@@ -4,15 +4,49 @@
 import java.util.zip.CRC32;
 import java.util.zip.Checksum;
 
+/**
+ * Collection of additional {@link BytesTransformer} for more specific use cases
+ */
 public final class BytesTransformers {
 
     private BytesTransformers() {
     }
 
-    public static BytesTransformer appendCrc32() {
+    /**
+     * Create a {@link BytesTransformer} which appends 4 byte Crc32 checksum to given bytes
+     *
+     * @return transformer
+     */
+    public static BytesTransformer checksumAppendCrc32() {
         return new ChecksumTransformer(new CRC32(), ChecksumTransformer.Mode.APPEND, 4);
     }
 
+    /**
+     * Create a {@link BytesTransformer} which transforms to 4 byte Crc32 checksum of given bytes
+     *
+     * @return transformer
+     */
+    public static BytesTransformer checksumCrc32() {
+        return new ChecksumTransformer(new CRC32(), ChecksumTransformer.Mode.TRANSFORM, 4);
+    }
+
+    /**
+     * Create a {@link BytesTransformer} which transforms to 4 byte Crc32 checksum of given bytes
+     * @return transformer
+     */
+    /**
+     * Create a {@link BytesTransformer} which transforms to 4 byte Crc32 checksum of given bytes
+     *
+     * @param checksum           used algorithm
+     * @param mode               mode (append or convert)
+     * @param checksumLengthByte the byte length of the checksum; the {@link Checksum} class always returns 8 byte, but some
+     *                           checksum algorithms (e.g. CRC32) only require smaller output. Must  be between 1 and 8 byte.
+     * @return transformer
+     */
+    public static BytesTransformer checksum(Checksum checksum, ChecksumTransformer.Mode mode, int checksumLengthByte) {
+        return new ChecksumTransformer(checksum, mode, checksumLengthByte);
+    }
+
     /**
      * Adds or converts to arbitrary checksum
      */

src/test/java/at/favre/lib/bytes/BytesTransformTest.java

@@ -27,7 +27,11 @@
 import java.nio.ByteBuffer;
 import java.security.SecureRandom;
 import java.util.Comparator;
+import java.util.zip.Adler32;
+import java.util.zip.CRC32;
+import java.util.zip.Checksum;
 
+import static at.favre.lib.bytes.BytesTransformers.*;
 import static org.junit.Assert.*;
 
 public class BytesTransformTest extends ABytesTest {
@@ -272,6 +276,19 @@ public void hash() throws Exception {
         assertEquals(Bytes.parseHex("cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"), Bytes.from("").hashSha512());
     }
 
+    @Test
+    public void checksumTest() throws Exception {
+        Checksum crc32Checksum = new CRC32();
+        crc32Checksum.update(example2_bytes_seven, 0, example2_bytes_seven.length);
+        assertEquals(crc32Checksum.getValue(), Bytes.from(example2_bytes_seven).transform(checksumCrc32()).resize(8).toLong());
+        assertEquals(Bytes.from(example2_bytes_seven, Bytes.from(crc32Checksum.getValue()).resize(4).array()), Bytes.from(example2_bytes_seven).transform(checksumAppendCrc32()));
+
+        Checksum adlerChecksum = new Adler32();
+        adlerChecksum.update(example2_bytes_seven, 0, example2_bytes_seven.length);
+        assertEquals(Bytes.from(adlerChecksum.getValue()).resize(4),
+                Bytes.from(example2_bytes_seven).transform(checksum(new Adler32(), ChecksumTransformer.Mode.TRANSFORM, 4)));
+    }
+
     @Test
     public void transform() throws Exception {
         assertArrayEquals(example_bytes_two, Bytes.from(example_bytes_two).transform(new BytesTransformer() {