Add missing tests

Author: SQiShER

src/main/java/de/danielbechler/diff/access/Instances.java

@@ -26,9 +26,6 @@
 
 import static de.danielbechler.util.Objects.isEqual;
 
-/**
- * @author Daniel Bechler
- */
 public class Instances
 {
 	private final Accessor sourceAccessor;
@@ -118,6 +115,7 @@ else if (isPrimitiveBooleanType())
 		return fresh;
 	}
 
+	@SuppressWarnings("UnusedDeclaration")
 	public <T> T getFresh(final Class<T> type)
 	{
 		final Object o = getFresh();

src/test/java/de/danielbechler/diff/access/InstancesSpec.groovy

@@ -19,11 +19,9 @@ package de.danielbechler.diff.access
 import spock.lang.Specification
 import spock.lang.Unroll
 
-/**
- * @author Daniel Bechler
- */
 class InstancesSpec extends Specification {
-	def "getType() throws IllegalArgumentException if base and working have incompatible types"() {
+
+	def "getType: throws IllegalArgumentException if base and working have incompatible types"() {
 		setup:
 		  def instances = new Instances(RootAccessor.instance, working, base, null)
 
@@ -41,7 +39,7 @@ class InstancesSpec extends Specification {
 	}
 
 	@Unroll
-	def "getType() returns '#resultTypeName' for base of type '#baseClassName' and working of type '#workingClassName'"() {
+	def "getType: returns '#resultTypeName' for base of type '#baseClassName' and working of type '#workingClassName'"() {
 		setup:
 		  def instances = Instances.of(working, base)
 
@@ -50,6 +48,7 @@ class InstancesSpec extends Specification {
 
 		where:
 		  base            | working             || resultType
+		  new ArrayList() | new ArrayList()     || ArrayList.class
 		  new ArrayList() | new LinkedHashSet() || Collection.class
 		  new HashMap()   | new TreeMap()       || Map.class
 
@@ -59,7 +58,7 @@ class InstancesSpec extends Specification {
 	}
 
 	@Unroll
-	def "getType() returns type of TypeAwareAccessor when it is primitive '#type'"() {
+	def "getType: returns type of TypeAwareAccessor when it is primitive '#type'"() {
 		given:
 		  def typeAwareAccessor = Mock(TypeAwareAccessor);
 		  def instances = Instances.of(typeAwareAccessor, 0, 0L);
@@ -74,21 +73,21 @@ class InstancesSpec extends Specification {
 		  type << [long, int, float, boolean, char, byte, short]
 	}
 
-	def "getType() returns most specific shared type for non-primitive objects (except for Map and Collection)"() {
+	def "getType: returns most specific shared type for non-primitive objects (except for Map and Collection)"() {
 		given:
 		  def instances = Instances.of(propertyAccessor, working, base);
 
 		expect:
 		  instances.getType() == resultType
 
 		where:
-		  propertyAccessor  | working                                    | base                                     | resultType
+		  propertyAccessor      | working                                    | base                                     | resultType
 		  RootAccessor.instance | BigInteger.ONE                             | BigDecimal.ONE                           | Number
 		  RootAccessor.instance | new LineNumberReader(new StringReader("")) | new BufferedReader(new StringReader("")) | BufferedReader
 		  RootAccessor.instance | new StringReader("")                       | new BufferedReader(new StringReader("")) | Reader
 	}
 
-	def "getType() uses type of TypeAwareAccessor if no shared type for non-primitive objects could be determined"() {
+	def "getType: uses type of TypeAwareAccessor if no shared type for non-primitive objects could be determined"() {
 		given:
 		  def accessor = Mock(TypeAwareAccessor)
 		  def instances = Instances.of(accessor, new StringBuilder(), "");
@@ -99,4 +98,166 @@ class InstancesSpec extends Specification {
 		expect:
 		  instances.getType() == CharSequence
 	}
+
+	def 'areNull: returns true when base and working are null'() {
+		given:
+		  Instances instances = new Instances(RootAccessor.instance, null, null, null);
+		expect:
+		  instances.areNull()
+	}
+
+	def 'areNull: returns false when base is not null'() {
+		given:
+		  Instances instances = new Instances(RootAccessor.instance, null, '', null);
+		expect:
+		  !instances.areNull()
+	}
+
+	def 'areNull: returns false when working is not null'() {
+		given:
+		  Instances instances = new Instances(RootAccessor.instance, '', null, null);
+		expect:
+		  !instances.areNull()
+	}
+
+	@Unroll
+	def 'isPrimitiveType: returns true for primitive type (#type)'() {
+		given:
+		  def typeAwareAccessor = Stub TypeAwareAccessor
+		  typeAwareAccessor.type >> type
+		and:
+		  def instances = new Instances(typeAwareAccessor, null, null, null)
+		expect:
+		  instances.isPrimitiveType()
+		where:
+		  type << [boolean, short, int, char, long, double, float, byte]
+	}
+
+	@Unroll
+	def 'isPrimitiveType: returns returns false for primitive wrapper type (#type)'() {
+		given:
+		  def typeAwareAccessor = Stub TypeAwareAccessor
+		  typeAwareAccessor.type >> type
+		and:
+		  def instances = new Instances(typeAwareAccessor, null, null, null)
+		expect:
+		  !instances.isPrimitiveType()
+		where:
+		  type << [Boolean, Short, Integer, Character, Long, Double, Float, Byte]
+	}
+
+	@Unroll
+	def 'isPrimitiveType: returns returns false for complex type'() {
+		given:
+		  def typeAwareAccessor = Stub TypeAwareAccessor
+		  typeAwareAccessor.type >> type
+		and:
+		  def instances = new Instances(typeAwareAccessor, null, null, null)
+		expect:
+		  !instances.isPrimitiveType()
+		where:
+		  type << [String, Object, Date]
+	}
+
+	def 'getFresh: returns zero for numeric types without custom initialization'() {
+		given:
+		  def typeAwareAccessor = Stub TypeAwareAccessor
+		  typeAwareAccessor.type >> type
+		and:
+		  def instances = new Instances(typeAwareAccessor, null, null, null)
+		expect:
+		  instances.getFresh() == 0
+		where:
+		  type << [short, int, char, long, double, float, byte]
+	}
+
+	def 'getFresh: returns false for primitive boolean type without custom initialization'() {
+		given:
+		  def typeAwareAccessor = Stub TypeAwareAccessor
+		  typeAwareAccessor.type >> boolean
+		and:
+		  def instances = new Instances(typeAwareAccessor, null, null, null)
+		expect:
+		  instances.getFresh() == false
+	}
+
+	def 'getFresh: returns fresh value from constructor for non-primitive types'() {
+		given:
+		  def typeAwareAccessor = Stub TypeAwareAccessor
+		  typeAwareAccessor.type >> Object
+		and:
+		  def instances = new Instances(typeAwareAccessor, null, null, 'foo')
+		expect:
+		  instances.getFresh() == 'foo'
+	}
+
+	@Unroll
+	def 'getFresh: returns null for primitive wrapper types (#type)'() {
+		given:
+		  def typeAwareAccessor = Stub TypeAwareAccessor
+		  typeAwareAccessor.type >> type
+		and:
+		  def instances = Instances.of(typeAwareAccessor, null, null)
+		expect:
+		  instances.getFresh() == null
+		where:
+		  type << [Boolean, Short, Integer, Character, Long, Double, Float, Byte]
+	}
+
+	def 'areSame: should return true when working and base are the same object'() {
+		given:
+		  def object = new Object()
+		  def instances = new Instances(RootAccessor.instance, object, object, null)
+		expect:
+		  instances.areSame()
+	}
+
+	def 'areSame: should return false when working and base are not the same object'() {
+		given:
+		  def instances = new Instances(RootAccessor.instance, new Object(), new Object(), null)
+		expect:
+		  !instances.areSame()
+	}
+
+	@Unroll('hasBeenAdded: should return #result when [working: #working, base: #base, fresh: #fresh]')
+	def 'hasBeenAdded'() {
+		given:
+		  def typeAwareAccessor = Stub TypeAwareAccessor
+		  typeAwareAccessor.type >> typeFromAccessor
+		and:
+		  def instances = new Instances(typeAwareAccessor, working, base, fresh)
+		expect:
+		  instances.hasBeenAdded() == result
+		where:
+		  working | base  | fresh | typeFromAccessor || result
+		  null    | null  | null  | null             || false
+		  'foo'   | null  | null  | null             || true
+		  'foo'   | 'foo' | null  | null             || false
+		  null    | 'foo' | null  | null             || false
+		  2       | 0     | 0     | int              || true
+		  2       | 1     | 1     | int              || true
+		  1       | 1     | 1     | int              || false
+		  2       | 0     | 1     | int              || false
+	}
+
+	@Unroll('hasBeenRemoved: should return #result when [working: #working, base: #base, fresh: #fresh]')
+	def 'hasBeenRemoved'() {
+		given:
+		  def typeAwareAccessor = Stub TypeAwareAccessor
+		  typeAwareAccessor.type >> typeFromAccessor
+		and:
+		  def instances = Instances.of(typeAwareAccessor, working, base, fresh)
+		expect:
+		  instances.hasBeenRemoved() == result
+		where:
+		  working | base  | fresh | typeFromAccessor || result
+		  null    | null  | null  | null             || false
+		  'foo'   | null  | null  | null             || false
+		  'foo'   | 'foo' | null  | null             || false
+		  null    | 'foo' | null  | null             || true
+		  0       | 0     | 0     | int              || false
+		  1       | 1     | 1     | int              || false
+		  0       | 1     | 1     | int              || false
+		  1       | 2     | 1     | int              || true
+	}
 }

src/test/java/de/danielbechler/diff/access/InstancesTest.java

@@ -24,7 +24,7 @@ import spock.lang.Specification
 /**
  * @author Daniel Bechler
  */
-class MapEntryAccessorTest extends Specification {
+class MapEntryAccessorSpec extends Specification {
 
 	@Shared
 	def key1 = new ObjectWithIdentityAndValue("key", "1")