Fixes various issues found in static code inspection

E.g typos, weaker access, redundant "throws exception"

Author: patrickfav

CONTRIBUTING.md

@@ -2,7 +2,7 @@
 
 We ❤ pull requests from everyone.
 
-If possible proof features and bugfixes with unit tests.
+If possible proof features and bug fixes with unit tests.
 This repo validates against checkstyle (import the xml found in the root to your IDE if possible)
 
 To run the tests (and checkstyle):
@@ -12,4 +12,4 @@ mvn test checkstyle:check
 ```
 
 Tests are automatically run against branches and pull requests
-via TravisCI, so you can also depend on that.
+via TravisCI, so you can also depend on that.

README.md

@@ -54,7 +54,7 @@ Add dependency to your `pom.xml` ([check latest release](https://github.com/patr
         <version>{latest-version}</version>
     </dependency>
 
-_Note:_ There is a byte-code optimized version (powerd by [ProGuard](https://www.guardsquare.com/en/products/proguard)) which can be used with [classifier](https://maven.apache.org/pom.html#Maven_Coordinates) 'optimized'. This may have issues so use at your own risk.
+_Note:_ There is a byte-code optimized version (powered by [ProGuard](https://www.guardsquare.com/en/products/proguard)) which can be used with [classifier](https://maven.apache.org/pom.html#Maven_Coordinates) 'optimized'. This may have issues so use at your own risk.
 
 Some simple examples:
 

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

@@ -1081,7 +1081,7 @@ public Bytes hash(String algorithm) {
      * This transformation might be done in-place (ie. without copying the internal array and overwriting its old state),
      * or on a copy of the internal data, depending on the type (e.g. {@link MutableBytes}) and if the operation can be done
      * in-place. Therefore the caller has to ensure that certain side-effects, which occur due to the changing of the internal
-     * data, do not create bugs in his/her code. Usually immutability is prefered, but when handling many or big byte arrays,
+     * data, do not create bugs in his/her code. Usually immutability is preferred, but when handling many or big byte arrays,
      * mutability enables drastically better performance.
      *
      * @param transformer used to transform this instance

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

@@ -18,6 +18,7 @@
 /**
  * Collection of additional {@link BytesTransformer} for more specific use cases
  */
+@SuppressWarnings("WeakerAccess")
 public final class BytesTransformers {
 
     private BytesTransformers() {
@@ -222,7 +223,7 @@ public boolean supportInPlaceTransformation() {
         }
 
         /**
-         * Converting each byte into unsinged version and comparing it (0...255) vs (-128..127)
+         * Converting each byte into unsigned version and comparing it (0...255) vs (-128..127)
          */
         static final class UnsignedByteComparator implements Comparator<Byte> {
             @Override
@@ -246,7 +247,7 @@ public static final class ChecksumTransformer implements BytesTransformer {
 
         ChecksumTransformer(Checksum checksum, Mode mode, int checksumLengthByte) {
             if (checksumLengthByte <= 0 || checksumLengthByte > 8)
-                throw new IllegalArgumentException("checksumlength must be between 1 and 8 bytes");
+                throw new IllegalArgumentException("checksum length must be between 1 and 8 bytes");
 
             Objects.requireNonNull(checksum, "checksum instance must not be null");
             this.checksum = checksum;

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

@@ -27,6 +27,7 @@
 /**
  * Util and easy access for {@link BytesValidators}
  */
+@SuppressWarnings("WeakerAccess")
 public final class BytesValidators {
 
     private BytesValidators() {

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

@@ -27,7 +27,7 @@
 
 import static org.junit.Assert.*;
 
-public abstract class ABytesTest {
+abstract class ABytesTest {
     byte[] example_bytes_empty;
 
     byte[] example_bytes_one;
@@ -55,7 +55,7 @@ public abstract class ABytesTest {
     String example_hex_twentyfour;
 
     @Before
-    public void setUp() throws Exception {
+    public void setUp() {
         example_bytes_empty = new byte[0];
         example_bytes_one = new byte[]{0x67};
         example_hex_one = "67";

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

@@ -31,7 +31,7 @@
 public class BytesByteOrderTest extends ABytesTest {
 
     @Test
-    public void miscInput() throws Exception {
+    public void miscInput() {
         testOrder(Bytes.from(350));
         testOrder(Bytes.from(172863182736L));
         testOrder(Bytes.from(example_bytes_one));
@@ -52,82 +52,82 @@ private void testOrder(Bytes bytes) {
     }
 
     @Test
-    public void encodeBinary() throws Exception {
+    public void encodeBinary() {
         Bytes b = Bytes.from(example_bytes_four);
         assertNotEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).encodeBinary(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).encodeBinary());
         assertEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).encodeBinary(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).reverse().encodeBinary());
     }
 
     @Test
-    public void encodeOct() throws Exception {
+    public void encodeOct() {
         Bytes b = Bytes.from(example_bytes_four);
         assertNotEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).encodeOctal(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).encodeOctal());
         assertEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).encodeOctal(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).reverse().encodeOctal());
     }
 
     @Test
-    public void encodeDec() throws Exception {
+    public void encodeDec() {
         Bytes b = Bytes.from(example_bytes_four);
         assertNotEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).encodeDec(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).encodeDec());
         assertEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).encodeDec(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).reverse().encodeDec());
     }
 
     @Test
-    public void encodeHex() throws Exception {
+    public void encodeHex() {
         Bytes b = Bytes.from(example_bytes_two);
         assertNotEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).encodeHex(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).encodeHex());
         assertEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).encodeHex(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).reverse().encodeHex());
     }
 
     @Test
-    public void encodeBase36() throws Exception {
+    public void encodeBase36() {
         Bytes b = Bytes.from(example_bytes_four);
         assertNotEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).encodeBase36(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).encodeBase36());
         assertEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).encodeBase36(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).reverse().encodeBase36());
     }
 
     @Test
-    public void encodeBase64() throws Exception {
+    public void encodeBase64() {
         Bytes b = Bytes.from(example_bytes_four);
         assertNotEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).encodeBase64(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).encodeBase64());
         assertEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).encodeBase64(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).reverse().encodeBase64());
     }
 
     @Test
-    public void toByte() throws Exception {
+    public void toByte() {
         Bytes b = Bytes.from(example_bytes_one);
         assertEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).toByte(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).toByte());
     }
 
     @Test
-    public void toChar() throws Exception {
+    public void toChar() {
         Bytes b = Bytes.from(example_bytes_two);
         assertNotEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).toChar(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).toChar());
     }
 
     @Test
-    public void toShort() throws Exception {
+    public void toShort() {
         Bytes b = Bytes.from(example_bytes_two);
         assertNotEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).toShort(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).toShort());
     }
 
     @Test
-    public void toInt() throws Exception {
+    public void toInt() {
         Bytes b = Bytes.from(example_bytes_four);
         assertNotEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).toInt(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).toInt());
     }
 
     @Test
-    public void toLong() throws Exception {
+    public void toLong() {
         Bytes b = Bytes.from(example_bytes_eight);
         assertNotEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).toLong(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).toLong());
     }
 
     @Test
-    public void bigInteger() throws Exception {
+    public void bigInteger() {
         Bytes b = Bytes.from(example_bytes_four);
         assertNotEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).toBigInteger(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).toBigInteger());
         assertEquals(b.byteOrder(ByteOrder.BIG_ENDIAN).toBigInteger(), b.byteOrder(ByteOrder.LITTLE_ENDIAN).reverse().toBigInteger());
     }
 
-}
+}

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

@@ -26,11 +26,7 @@
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 
-import java.io.ByteArrayInputStream;
-import java.io.DataInput;
-import java.io.DataInputStream;
-import java.io.File;
-import java.io.FileOutputStream;
+import java.io.*;
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
@@ -48,7 +44,7 @@
 
 public class BytesConstructorTests extends ABytesTest {
     @Rule
-    public TemporaryFolder testFolder = new TemporaryFolder();
+    public final TemporaryFolder testFolder = new TemporaryFolder();
 
     @Test
     public void wrapTest() {

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

@@ -121,14 +121,14 @@ public void testCompareTo() {
 
         assertTrue(-1 >= Bytes.from(b1).compareTo(Bytes.from(b2)));
         assertTrue(1 <= Bytes.from(b2).compareTo(Bytes.from(b1)));
-        assertTrue(0 == Bytes.from(b1).compareTo(Bytes.from(b1)));
+        assertEquals(0, Bytes.from(b1).compareTo(Bytes.from(b1)));
 
         byte[] bOne = new byte[]{0x01};
         byte[] bTwo = new byte[]{0x02};
 
         assertTrue(-1 >= Bytes.from(bOne).compareTo(Bytes.from(bTwo)));
         assertTrue(1 <= Bytes.from(bTwo).compareTo(Bytes.from(bOne)));
-        assertTrue(0 == Bytes.from(bOne).compareTo(Bytes.from(bOne)));
+        assertEquals(0, Bytes.from(bOne).compareTo(Bytes.from(bOne)));
     }
 
     @Test
@@ -507,7 +507,7 @@ public void readOnly() {
         try {
             Bytes.from(example_bytes_twentyfour).readOnly().array();
             fail();
-        } catch (ReadOnlyBufferException e) {
+        } catch (ReadOnlyBufferException ignored) {
         }
 
         Bytes b = Bytes.from(example_bytes_twentyfour).readOnly();

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

@@ -32,7 +32,7 @@
 public class BytesValidatorTest extends ABytesTest {
 
     @Test
-    public void testOnlyOfValidator() throws Exception {
+    public void testOnlyOfValidator() {
         assertFalse(Bytes.allocate(0).validateNotOnlyZeros());
         assertFalse(Bytes.allocate(2).validateNotOnlyZeros());
         assertTrue(Bytes.wrap(example_bytes_seven).validateNotOnlyZeros());
@@ -50,7 +50,7 @@ public void testOnlyOfValidator() throws Exception {
     }
 
     @Test
-    public void testLengthValidators() throws Exception {
+    public void testLengthValidators() {
         assertFalse(Bytes.allocate(0).validate(atLeast(1)));
         assertTrue(Bytes.allocate(1).validate(atLeast(1)));
         assertTrue(Bytes.allocate(2).validate(atLeast(1)));
@@ -65,7 +65,7 @@ public void testLengthValidators() throws Exception {
     }
 
     @Test
-    public void testOrValidation() throws Exception {
+    public void testOrValidation() {
         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))));
@@ -74,34 +74,34 @@ public void testOrValidation() throws Exception {
     }
 
     @Test
-    public void testAndValidation() throws Exception {
+    public void testAndValidation() {
         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 {
+    public void testNotValidation() {
         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(expected = IllegalArgumentException.class)
-    public void testLogicalNoElements() throws Exception {
+    public void testLogicalNoElements() {
         Bytes.allocate(2).validate(new BytesValidator.Logical(Collections.<BytesValidator>emptyList(), BytesValidator.Logical.Operator.AND));
     }
 
     @Test(expected = IllegalArgumentException.class)
-    public void testLogicalTooManyElements() throws Exception {
+    public void testLogicalTooManyElements() {
         Bytes.allocate(2).validate(new BytesValidator.Logical(
                 Arrays.<BytesValidator>asList(new BytesValidator.Length(2, BytesValidator.Length.Mode.GREATER_OR_EQ_THAN), new BytesValidator.Length(2, BytesValidator.Length.Mode.EXACT))
                 , BytesValidator.Logical.Operator.NOT));
     }
 
     @Test
-    public void testNestedValidation() throws Exception {
+    public void testNestedValidation() {
         assertTrue(Bytes.allocate(16).validate(
                 or(and(atLeast(8), not(onlyOf(((byte) 0)))),
                         or(exactLength(16), exactLength(12)))));
@@ -113,7 +113,7 @@ public void testNestedValidation() throws Exception {
     }
 
     @Test
-    public void testStartWithValidate() throws Exception {
+    public void testStartWithValidate() {
         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)));
@@ -123,12 +123,12 @@ public void testStartWithValidate() throws Exception {
     }
 
     @Test
-    public void testEndsWithValidate() throws Exception {
+    public void testEndsWithValidate() {
         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())));
     }
-}
+}