Add static mutable fields check. Handling JaCoCo static mutable fields in classes. (#5)

Author: ajoz

src/main/java/com/github/karczews/utilsverifier/Arrays2.java

@@ -0,0 +1,27 @@
+package com.github.karczews.utilsverifier;
+
+/**
+ * Internal tool that contains convenience methods to work with arrays.
+ */
+final class Arrays2 {
+    private Arrays2() {
+    }
+
+    /**
+     * Performs a check if the specified item is contained in the specified
+     * array.
+     *
+     * @param item will be checked if it's in the array
+     * @param array checked if contains the specified item
+     * @param <T> type of the array elements
+     * @return true if the array contains specified item, false otherwise
+     * @throws NullPointerException if the passed array is null
+     */
+    public static <T> boolean contains(final T item, final T[] array) {
+        for (int index = 0; index < array.length; index++) {
+            if (array[index] == item)
+                return true;
+        }
+        return false;
+    }
+}

src/main/java/com/github/karczews/utilsverifier/UtilsVerifier.java

@@ -27,20 +27,26 @@
  * <li> is final
  * <li> has only one private constructor
  * <li> has no instance fields
+ * <li> has no mutable static fields
  * </ul>
  *
  * @param <T> class under test
  */
-public class UtilsVerifier<T> {
+public final class UtilsVerifier<T> {
 
     private final Class<T> classUnderTest;
 
     private Class<? extends Throwable> expectedConstructorException;
+
     private boolean suppressFinalClassCheck = false;
     private boolean suppressOnlyOneConstructorCheck = false;
     private boolean suppressPrivateConstructorCheck = false;
     private boolean suppressInstanceFieldCheck = false;
     private boolean suppressInstanceMethodCheck = false;
+    private boolean suppressMutableStaticFieldsCheck = false;
+
+    // list of mutable static fields often added by outside tools like JaCoCo
+    private final String[] allowedMutableStaticFields = {"$jacocoData"};
 
     private UtilsVerifier(final Class<T> type) {
         classUnderTest = type;
@@ -65,6 +71,7 @@ public void verify() {
         verifyPrivateConstructor();
         hasNoInstanceFields();
         hasNoInstanceMethods();
+        hasNoMutableStaticFields();
     }
 
     /**
@@ -131,6 +138,17 @@ public UtilsVerifier<T> suppressInstanceMethodCheck(final boolean suppressCheck)
         return this;
     }
 
+    /**
+     * Suppress static mutable fields verification.
+     * Use if util class is allowed to have mutable static fields.
+     *
+     * @param suppressCheck true if check should be suppressed, false otherwise
+     */
+    public UtilsVerifier<T> suppressMutableStaticFieldsCheck(final boolean suppressCheck) {
+        suppressMutableStaticFieldsCheck = suppressCheck;
+        return this;
+    }
+
     private void checkIfClassIsFinal() {
         if (suppressFinalClassCheck) return;
         if (!Modifier.isFinal(classUnderTest.getModifiers())) {
@@ -195,5 +213,22 @@ private void hasNoInstanceMethods() {
             }
         }
     }
-    //TODO: add check for mutable static fields
+
+    private void hasNoMutableStaticFields() {
+        if (suppressMutableStaticFieldsCheck) return;
+        final Field[] fields = classUnderTest.getDeclaredFields();
+
+        fields:
+        for (int index = 0; index < fields.length; index++) {
+            final Field field = fields[index];
+            final int modifiers = field.getModifiers();
+            if (Arrays2.contains(field.getName(), allowedMutableStaticFields)) {
+                continue fields;
+            }
+            if (Modifier.isStatic(modifiers) && !Modifier.isFinal(modifiers)) {
+                throw new AssertionError(classUnderTest.getName()
+                        + " contains static mutable field " + field.getName());
+            }
+        }
+    }
 }

src/test/java/com/github/karczews/utilsverifier/Arrays2Test.java

@@ -0,0 +1,58 @@
+package com.github.karczews.utilsverifier;
+
+import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+public class Arrays2Test {
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Test
+    public void shouldThrowNullPointerExceptionForNullArray() {
+        expectedException.expect(NullPointerException.class);
+
+        final String[] array = null;
+        final String item = "";
+
+        Arrays2.contains(item, array);
+    }
+
+    @Test
+    public void shouldReturnFalseForEmptyArray() {
+        final String[] array = {};
+        final String item = "";
+
+        Assert.assertFalse(Arrays2.contains(item, array));
+    }
+
+    @Test
+    public void shouldReturnFalse() {
+        final String[] array = {"item1", "item2"};
+        final String item = "";
+
+        Assert.assertFalse(Arrays2.contains(item, array));
+    }
+
+    @Test
+    public void shouldReturnFalseForNullItem() {
+        final String[] array = {"item1", "item2"};
+        final String item = null;
+
+        Assert.assertFalse(Arrays2.contains(item, array));
+    }
+
+    @Test
+    public void shouldReturnTrue() {
+        final String[] array = {"item1", "item2"};
+        final String item = "item1";
+
+        Assert.assertTrue(Arrays2.contains(item, array));
+    }
+
+    @Test
+    public void verifyArraysTool() {
+        UtilsVerifier.forClass(Arrays2.class).verify();
+    }
+}

src/test/java/com/github/karczews/utilsverifier/UtilsVerifierTest.java

@@ -15,29 +15,49 @@
 
 import com.github.karczews.utilsverifier.subjects.AbstractClass;
 import com.github.karczews.utilsverifier.subjects.DefaultConstructor;
+import com.github.karczews.utilsverifier.subjects.ImmutableStaticFields;
 import com.github.karczews.utilsverifier.subjects.InstanceFields;
 import com.github.karczews.utilsverifier.subjects.InstanceMethods;
 import com.github.karczews.utilsverifier.subjects.MultipleConstructors;
+import com.github.karczews.utilsverifier.subjects.MutableStaticFields;
 import com.github.karczews.utilsverifier.subjects.NonFinalClass;
 import com.github.karczews.utilsverifier.subjects.NonPrivateConstructor;
 import com.github.karczews.utilsverifier.subjects.ThrowingConstructor;
 import com.github.karczews.utilsverifier.subjects.WellFormed;
-
+import static org.hamcrest.core.AllOf.allOf;
+import static org.hamcrest.core.StringContains.containsString;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
-import org.mockito.Mockito;
-
-import static org.hamcrest.core.AllOf.allOf;
-import static org.hamcrest.core.StringContains.containsString;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
 
 public class UtilsVerifierTest {
 
     @Rule
     public ExpectedException expectedException = ExpectedException.none();
 
+    @Test
+    public void shouldFailOnMutableStaticFields() {
+        expectedException.expect(AssertionError.class);
+        expectedException.expectMessage(containsString("staticInt"));
+
+        suppressedVerifier(MutableStaticFields.class)
+                .suppressMutableStaticFieldsCheck(false)
+                .verify();
+    }
+
+    @Test
+    public void shouldPassOnMutableStaticFields() {
+        suppressedVerifier(ImmutableStaticFields.class)
+                .suppressMutableStaticFieldsCheck(false)
+                .verify();
+
+        // due to complex condition two asserts in one test
+        // to not create confusion with strange test name
+        suppressedVerifier(InstanceFields.class)
+                .suppressMutableStaticFieldsCheck(false)
+                .verify();
+    }
+
     @Test
     public void shouldFailOnNonFinalClassVerification() {
         expectedException.expect(AssertionError.class);
@@ -152,6 +172,7 @@ private static <T> UtilsVerifier<T> suppressedVerifier(final Class<T> type) {
                 .suppressOnlyOneConstructorCheck(true)
                 .suppressPrivateConstructorCheck(true)
                 .suppressInstanceFieldCheck(true)
-                .suppressInstanceMethodCheck(true);
+                .suppressInstanceMethodCheck(true)
+                .suppressMutableStaticFieldsCheck(true);
     }
 }

src/test/java/com/github/karczews/utilsverifier/subjects/ImmutableStaticFields.java

@@ -0,0 +1,8 @@
+package com.github.karczews.utilsverifier.subjects;
+
+public final class ImmutableStaticFields {
+    private static final int staticInt = 0;
+
+    private ImmutableStaticFields(){
+    }
+}

src/test/java/com/github/karczews/utilsverifier/subjects/MutableStaticFields.java

@@ -0,0 +1,8 @@
+package com.github.karczews.utilsverifier.subjects;
+
+public final class MutableStaticFields {
+    private static int staticInt;
+
+    private MutableStaticFields() {
+    }
+}