Add test for Annotation.equals()

1 files changed, 40 insertions, 11 deletions

diff --git a/src/test/java/org/zwobble/couscous/tests/AnnotationNodeTests.java b/src/test/java/org/zwobble/couscous/tests/AnnotationNodeTests.java
index 2eb8d9c..5eba8cb 100644
--- a/src/test/java/org/zwobble/couscous/tests/AnnotationNodeTests.java
+++ b/src/test/java/org/zwobble/couscous/tests/AnnotationNodeTests.java
@@ -2,6 +2,7 @@ package org.zwobble.couscous.tests;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
+import java.util.function.Function;
 import java.util.stream.IntStream;
 
 import org.junit.Test;
@@ -12,6 +13,7 @@ import com.google.common.base.Joiner;
 
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
 import static org.zwobble.couscous.util.ExtraArrays.stream;
 
 public class AnnotationNodeTests {
@@ -21,7 +23,12 @@ public class AnnotationNodeTests {
     }
 
     private <T> void assertIsValueObject(Class<T> clazz) throws Exception {
-        GeneratedValue value = generateValue(clazz);
+        assertToStringIncludesAllFields(clazz);
+        assertEqualityIncludesAllFields(clazz);
+    }
+
+    private <T> void assertToStringIncludesAllFields(Class<T> clazz) {
+        GeneratedValue value = generateValue(clazz, this::generateInstance);
         Field[] fields = clazz.getDeclaredFields();
         Object[] fieldStrings = IntStream.range(0, fields.length)
             .mapToObj(index -> String.format("%s=%s", fields[index].getName(), value.arguments[index]))
@@ -32,14 +39,44 @@ public class AnnotationNodeTests {
                 Joiner.on(", ").join(fieldStrings)),
             value.instance.toString());
     }
+
+    private void assertEqualityIncludesAllFields(Class<?> clazz) {
+        assertNotEquals(
+            generateFirstInstance(clazz),
+            generateSecondInstance(clazz));
+    }
+    
+    private Object generateFirstInstance(Class<?> type) {
+        if (type.equals(String.class)) {
+            return "[string 1]";
+        } else {
+            return generateValue(type, this::generateFirstInstance).instance;         
+        }
+    }
+    
+    private Object generateSecondInstance(Class<?> type) {
+        if (type.equals(String.class)) {
+            return "[string ]";
+        } else {
+            return generateValue(type, this::generateSecondInstance).instance;           
+        }
+    }
     
-    private GeneratedValue generateValue(Class<?> type) {
+    private Object generateInstance(Class<?> type) {
+        if (type.equals(String.class)) {
+            return "[string]";
+        } else {
+            return generateValue(type, this::generateInstance).instance;
+        }
+    }
+    
+    private GeneratedValue generateValue(Class<?> type, Function<Class<?>, Object> generate) {
         try {
             Field[] fields = type.getDeclaredFields();
             Class<?>[] fieldTypes = ExtraArrays.map(fields, field -> field.getType())
                 .toArray(Class<?>[]::new);
             Method constructor = findStaticConstructor(type, fieldTypes);
-            Object[] arguments = ExtraArrays.map(fieldTypes, fieldType -> generateInstance(fieldType))
+            Object[] arguments = ExtraArrays.map(fieldTypes, fieldType -> generate.apply(fieldType))
                 .toArray(Object[]::new);
             Object instance = constructor.invoke(null, arguments);
             return new GeneratedValue(instance, arguments);
@@ -48,14 +85,6 @@ public class AnnotationNodeTests {
         }
     }
     
-    private Object generateInstance(Class<?> type) {
-        if (type.equals(String.class)) {
-            return "[string]";
-        } else {
-            return generateValue(type).instance;            
-        }
-    }
-    
     private Method findStaticConstructor(Class<?> type, Class<?>[] fieldTypes) {
         return stream(type.getDeclaredMethods())
             .filter(method -> isStaticConstructor(type, fieldTypes, method))