Improved tests for nested properties and wrote tests for property builders.

Author: Nicolai Parlog

test/org/codefx/AllTests.java

@@ -1,6 +1,6 @@
 package org.codefx;
 
-import org.codefx.nesting.AllNestingTests;
+import org.codefx.nesting._AllNestingTests;
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
 import org.junit.runners.Suite.SuiteClasses;
@@ -10,7 +10,7 @@
  */
 @RunWith(Suite.class)
 @SuiteClasses({
-	AllNestingTests.class,
+	_AllNestingTests.class,
 })
 public class AllTests {
 	// no body needed

test/org/codefx/nesting/AllNestingTests.java renamed to test/org/codefx/nesting/_AllNestingTests.java

@@ -1,6 +1,6 @@
 package org.codefx.nesting;
 
-import org.codefx.nesting.property.AllNestedPropertyTests;
+import org.codefx.nesting.property._AllNestedPropertyTests;
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
 import org.junit.runners.Suite.SuiteClasses;
@@ -10,10 +10,10 @@
  */
 @RunWith(Suite.class)
 @SuiteClasses({
-		AllNestedPropertyTests.class,
+		_AllNestedPropertyTests.class,
 		DeepNestingTest.class,
 		ShallowNestingTest.class,
 })
-public class AllNestingTests {
+public class _AllNestingTests {
 	// no body needed
 }

test/org/codefx/nesting/property/AbstractNestedIntegerPropertyTest.java

@@ -0,0 +1,39 @@
+package org.codefx.nesting.property;
+
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+
+import org.codefx.nesting.Nesting;
+
+/**
+ * Abstract superclass to tests for {@link NestedObjectProperty NestedObjectProperties} which only leaves the creation
+ * of the tested properties (by {@link #createNestedPropertyFromNesting(Nesting)}) to the subclasses.
+ */
+public abstract class AbstractNestedIntegerPropertyTest extends AbstractNestedPropertyTest<Number, IntegerProperty> {
+
+	/**
+	 * The next value returned by {@link #createNewValue()}.
+	 */
+	private int nextValue = 1;
+
+	@Override
+	protected boolean allowsNullValues() {
+		return false;
+	}
+
+	@Override
+	protected Number createNewValue() {
+		return ++nextValue;
+	}
+
+	@Override
+	protected IntegerProperty createNewObservableWithValue(Number value) {
+		return new SimpleIntegerProperty(value.intValue());
+	}
+
+	@Override
+	protected IntegerProperty createNewObservableWithSomeValue() {
+		return createNewObservableWithValue(0);
+	}
+
+}

test/org/codefx/nesting/property/AbstractNestedObjectPropertyTest.java

@@ -0,0 +1,37 @@
+package org.codefx.nesting.property;
+
+import javafx.beans.property.Property;
+import javafx.beans.property.SimpleObjectProperty;
+
+import org.codefx.nesting.Nesting;
+import org.codefx.nesting.testhelper.SomeValue;
+
+/**
+ * Abstract superclass to tests for {@link NestedObjectProperty NestedObjectProperties} which only leaves the creation
+ * of the tested properties (by {@link #createNestedPropertyFromNesting(Nesting)}) to the subclasses.
+ */
+public abstract class AbstractNestedObjectPropertyTest
+		extends AbstractNestedPropertyTest<SomeValue, Property<SomeValue>> {
+
+	@Override
+	protected final boolean allowsNullValues() {
+		return true;
+	}
+
+	@Override
+	protected final SomeValue createNewValue() {
+		return new SomeValue();
+	}
+
+	@Override
+	protected final Property<SomeValue> createNewObservableWithValue(SomeValue value) {
+		return new SimpleObjectProperty<>(value);
+	}
+
+	@Override
+	protected final Property<SomeValue> createNewObservableWithSomeValue() {
+		SomeValue someValue = new SomeValue();
+		return createNewObservableWithValue(someValue);
+	}
+
+}

test/org/codefx/nesting/property/AbstractNestedPropertyBuilderTest.java

@@ -0,0 +1,110 @@
+package org.codefx.nesting.property;
+
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+import javafx.beans.property.Property;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Abstract superclass to tests for nested property builders.
+ *
+ * @param <N>
+ *            the nesting hierarchy's innermost type of {@link Property}
+ * @param <P>
+ *            the type of {@link Property} which will be built
+ */
+public abstract class AbstractNestedPropertyBuilderTest<N extends Property<?>, P extends NestedProperty<?>> {
+
+	// #region TESTED INSTANCES
+
+	/**
+	 * The tested builder.
+	 */
+	private AbstractNestedPropertyBuilder<N, P> builder;
+
+	//#end TESTED INSTANCES
+
+	/**
+	 * Creates a new builder before each test.
+	 */
+	@Before
+	public void setUp() {
+		builder = createBuilder();
+	}
+
+	// #region TESTS
+
+	/**
+	 * Tests whether calling {@link AbstractNestedPropertyBuilder#setBean(Object)} sets the bean for the created nested
+	 * property.
+	 */
+	@Test
+	public void testSetBean() {
+		// set a bean on the builder and let it build the property
+		Object bean = "Mr. Bean";
+		builder.setBean(bean);
+		P nestedProperty = builder.build();
+
+		assertSame(bean, nestedProperty.getBean());
+	}
+
+	/**
+	 * Tests whether calling {@link AbstractNestedPropertyBuilder#setBean(Object)} with null causes a
+	 * {@link NullPointerException}.
+	 */
+	@Test(expected = NullPointerException.class)
+	public void testSetBeanToNull() {
+		builder.setBean(null);
+	}
+
+	/**
+	 * Tests whether calling {@link AbstractNestedPropertyBuilder#setName(String)} sets the name for the created nested
+	 * property.
+	 */
+	@Test
+	public void testSetName() {
+		// set a name on the builder and let it build the property
+		String name = "The Name";
+		builder.setName(name);
+		P nestedProperty = builder.build();
+
+		assertSame(name, nestedProperty.getName());
+	}
+
+	/**
+	 * Tests whether calling {@link AbstractNestedPropertyBuilder#setName(String)} with null causes a
+	 * {@link NullPointerException}.
+	 */
+	@Test(expected = NullPointerException.class)
+	public void testSetNameToNull() {
+		builder.setName(null);
+	}
+
+	/**
+	 * Tests whether repeatedly calling {@link AbstractNestedPropertyBuilder#build()} returns different instances of
+	 * nested properties.
+	 */
+	@Test
+	public void testBuildCreatesNewInstances() {
+		P firstNestedProperty = builder.build();
+		P secondNestedProperty = builder.build();
+
+		assertNotSame(firstNestedProperty, secondNestedProperty);
+	}
+
+	//#end TESTS
+
+	// #region ABSTRACT METHODS
+
+	/**
+	 * Creates the tested builder. Each call must return a new instance
+	 *
+	 * @return an {@link AbstractNestedPropertyBuilder}
+	 */
+	protected abstract AbstractNestedPropertyBuilder<N, P> createBuilder();
+
+	//#end ABSTRACT METHODS
+
+}

test/org/codefx/nesting/property/AbstractNestedPropertyTest.java

@@ -22,15 +22,17 @@
  *
  * @param <T>
  *            the type wrapped by the nested property
+ * @param <P>
+ *            the type of property wrapped by the nesting
  */
-public abstract class AbstractNestedPropertyTest<T> {
+public abstract class AbstractNestedPropertyTest<T, P extends Property<T>> {
 
 	// #region INSTANCES USED FOR TESTING
 
 	/**
 	 * The nesting on which the tested property is based.
 	 */
-	private NestingAccess.EditableNesting<Property<T>> nesting;
+	private NestingAccess.EditableNesting<P> nesting;
 
 	/**
 	 * The tested property.
@@ -44,7 +46,7 @@ public abstract class AbstractNestedPropertyTest<T> {
 	 */
 	@Before
 	public void setUp() {
-		Property<T> innerObservable = createNewObservableWithSomeValue();
+		P innerObservable = createNewObservableWithSomeValue();
 		nesting = NestingAccess.EditableNesting.createWithInnerObservable(innerObservable);
 		property = createNestedPropertyFromNesting(nesting);
 	}
@@ -98,7 +100,7 @@ public void testChangingValueToNull() {
 	@Test
 	public void testChangingObservable() {
 		T newValue = createNewValue();
-		Property<T> newObservable = createNewObservableWithValue(newValue);
+		P newObservable = createNewObservableWithValue(newValue);
 		setNestingObservable(nesting, newObservable);
 		// assert that setting the observable worked
 		assertSame(newObservable, getNestingObservable(nesting));
@@ -132,7 +134,7 @@ public void testChangingObservableToNull() {
 	@Test
 	public void testChangingNewObservablesValue() {
 		// set a new observable ...
-		Property<T> newObservable = createNewObservableWithSomeValue();
+		P newObservable = createNewObservableWithSomeValue();
 		setNestingObservable(nesting, newObservable);
 		// (assert that setting the observable worked)
 		assertSame(newObservable, getNestingObservable(nesting));
@@ -156,7 +158,7 @@ public void testChangingOldObservablesValue() {
 
 		// ... set a new observable ...
 		T newValueInNewObservable = createNewValue();
-		Property<T> newObservable = createNewObservableWithValue(newValueInNewObservable);
+		P newObservable = createNewObservableWithValue(newValueInNewObservable);
 		setNestingObservable(nesting, newObservable);
 		// (assert that setting the observable worked)
 		assertNotSame(oldObservable, getNestingObservable(nesting));
@@ -190,7 +192,7 @@ public void testChangingOldObservablesValue() {
 	 *            the nesting from which the nested property is created
 	 * @return a new {@link NestedProperty} instance
 	 */
-	protected abstract NestedProperty<T> createNestedPropertyFromNesting(Nesting<Property<T>> nesting);
+	protected abstract NestedProperty<T> createNestedPropertyFromNesting(Nesting<P> nesting);
 
 	/**
 	 * Creates a new value. Each call must return a new instance.
@@ -206,15 +208,15 @@ public void testChangingOldObservablesValue() {
 	 *            the new observable's value
 	 * @return a new {@link Property} instance with the specified value
 	 */
-	protected abstract Property<T> createNewObservableWithValue(T value);
+	protected abstract P createNewObservableWithValue(T value);
 
 	/**
 	 * Creates a new observable which holds some arbitrary value (there are no constraints for this value). Each call
 	 * must return a new instance.
 	 *
 	 * @return a new {@link Property} instance with the specified value
 	 */
-	protected abstract Property<T> createNewObservableWithSomeValue();
+	protected abstract P createNewObservableWithSomeValue();
 
 	//#end ABSTRACT METHODS
 

test/org/codefx/nesting/property/NestedIntegerPropertyBuilderTest.java

@@ -0,0 +1,51 @@
+package org.codefx.nesting.property;
+
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+
+import org.codefx.nesting.Nesting;
+import org.codefx.nesting.testhelper.NestingAccess.EditableNesting;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+/**
+ * Tests the class {@link NestedIntegerPropertyBuilder}.
+ */
+@RunWith(Suite.class)
+@SuiteClasses({
+		NestedIntegerPropertyBuilderTest.AbstractBuilderContract.class,
+		NestedIntegerPropertyBuilderTest.CreatedProperties.class,
+})
+public class NestedIntegerPropertyBuilderTest {
+
+	/**
+	 * Tests whether the builder fulfills the contract defined by {@link AbstractNestedPropertyBuilder}.
+	 */
+	public static class AbstractBuilderContract
+	extends AbstractNestedPropertyBuilderTest<IntegerProperty, NestedIntegerProperty> {
+
+		@Override
+		protected AbstractNestedPropertyBuilder<IntegerProperty, NestedIntegerProperty> createBuilder() {
+			IntegerProperty innerObservable = new SimpleIntegerProperty(0);
+			EditableNesting<IntegerProperty> nesting = EditableNesting.createWithInnerObservable(innerObservable);
+			return NestedIntegerPropertyBuilder.forNesting(nesting);
+		}
+
+	}
+
+	/**
+	 * Uses the builder to create properties which are then tested.
+	 */
+	public static class CreatedProperties extends AbstractNestedIntegerPropertyTest {
+
+		@Override
+		protected NestedProperty<Number> createNestedPropertyFromNesting(Nesting<IntegerProperty> nesting) {
+			// use the builder to create the property
+			NestedIntegerPropertyBuilder builder = NestedIntegerPropertyBuilder.forNesting(nesting);
+			return builder.build();
+		}
+
+	}
+
+}