Enable creation of nestings on a broken observable hierarchy

As pointed out by #9, creating a 'DeepNesting' on an outer observable which contains null does not work as intended. Its 'innerObservableProperty' will contain null instead of an empty 'Oprional'. The same faulty behavior was found when one of the nested observables contains null.

The problem was that the nesting's initialization could not distinguish between uninitialized values (which were represented as null) and null values contained in those observable. This lead to the initialization following an incorrect (and ultimately incomplete) computational path.

The fix changes the way the value array is created. Instead of containing null for uninitialized values, it contains arbitrary instances which are not null an equal no instances which appears "in the wild".

Author: nicolaiparlog

src/main/java/org/codefx/libfx/nesting/DeepNesting.java

@@ -74,6 +74,9 @@ final class DeepNesting<O extends Observable> implements Nesting<O> {
 
 	/**
 	 * The values currently held by the observables.
+	 * <p>
+	 * Before the initialization these will be non-null "uninitialized" objects. This is done to distinguish them from
+	 * null values which could be held by the observables.
 	 */
 	private final Object[] values;
 
@@ -120,14 +123,25 @@ public DeepNesting(ObservableValue outerObservable, List<NestingStep> nestingSte
 		maxLevel = nestingSteps.size();
 
 		this.observables = createObservables(outerObservable, maxLevel);
-		this.values = new Object[maxLevel];
+		this.values = createUnitializedValues();
 		this.nestingSteps = nestingSteps.toArray(new NestingStep[maxLevel]);
 		this.changeListeners = createChangeListeners(maxLevel);
 		this.inner = new SimpleObjectProperty<>(this, "inner");
 
 		initializeNesting();
 	}
 
+	/**
+	 * @return an array of uninitialized values (i.e. non-null values which do not equal any other instances occurring
+	 *         "in the wild")
+	 */
+	private Object[] createUnitializedValues() {
+		Object[] values = new Object[maxLevel];
+		for (int i = 0; i < maxLevel; i++)
+			values[i] = new Unitialized();
+		return values;
+	}
+
 	/**
 	 * Creates an initialized array of observables. Its first item is the specified outer observable (its other items
 	 * are null).
@@ -234,8 +248,8 @@ public void initialize() {
 	 * identical and nothing more needs to be updated.
 	 * <p>
 	 * Note that the loop will not stop on null observables and null values. Instead it continues and replaces all
-	 * stored observables and values with null. This is the desired behavior as the hierarchy is in now an incomplete
-	 * state and the old observables and values are obsolete and have to be replaced.
+	 * stored observables and values with null. This is the desired behavior as the hierarchy is now in an incomplete
+	 * state where the old observables and values are obsolete and have to be replaced.
 	 */
 	private class NestingUpdater {
 
@@ -394,6 +408,13 @@ private void updateInnerObservable() {
 
 	}
 
+	/**
+	 * Represents an uninitialized entry in the {@link #values} array.
+	 */
+	private static class Unitialized {
+		// no body needed
+	}
+
 	//#end PRIVATE CLASSES
 
 }

src/test/java/org/codefx/libfx/nesting/AbstractDeepNestingTest.java

@@ -1,6 +1,8 @@
 package org.codefx.libfx.nesting;
 
 import static org.codefx.libfx.nesting.testhelper.NestingAccess.getNestingObservable;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import javafx.beans.Observable;
@@ -22,6 +24,37 @@ public abstract class AbstractDeepNestingTest<OO extends Observable, IO extends
 
 	// #region TESTS
 
+	// construction
+
+	/**
+	 * Tests whether creating a {@link DeepNesting} on an outer observable which contains null works correctly.
+	 * <p>
+	 * This ensures that a "broken" hierarchy is correctly initialized.
+	 */
+	@Test
+	public void testCreatingWhenOuterObservableHasValueNull() {
+		outerObservable = createNewNestingHierarchyWhereOuterObservableHasNullValue();
+		nesting = createNewNestingFromOuterObservable(outerObservable);
+
+		assertNotNull(nesting.innerObservableProperty().getValue());
+		assertFalse(nesting.innerObservableProperty().getValue().isPresent());
+	}
+
+	/**
+	 * Tests whether creating a {@link DeepNesting} on a hierarchy where on of the nested observables contains null
+	 * works correctly.
+	 * <p>
+	 * This ensures that a "broken" hierarchy is correctly initialized.
+	 */
+	@Test
+	public void testCreatingWhenNestedObservableHasValueNull() {
+		outerObservable = createNewNestingHierarchyWhereNestedObservableHasNullValue();
+		nesting = createNewNestingFromOuterObservable(outerObservable);
+
+		assertNotNull(nesting.innerObservableProperty().getValue());
+		assertFalse(nesting.innerObservableProperty().getValue().isPresent());
+	}
+
 	// nested value
 
 	/**
@@ -90,6 +123,21 @@ public void testWhenSettingOuterValueToNull() {
 
 	// #region ABSTRACT METHODS
 
+	/**
+	 * Creates a new outer observable with a null value. The returned instances must be new for each call.
+	 *
+	 * @return an {@link ObservableValue} containing null
+	 */
+	protected abstract OO createNewNestingHierarchyWhereOuterObservableHasNullValue();
+
+	/**
+	 * Creates a new nesting hierarchy where one of the nested observables contains null and returns the outer
+	 * observable. All returned instances must be new for each call.
+	 *
+	 * @return an {@link ObservableValue} containing the outer value of a nesting hierarchy
+	 */
+	protected abstract OO createNewNestingHierarchyWhereNestedObservableHasNullValue();
+
 	/**
 	 * Sets a new value of the specified kind on the specified level of the nesting hierarchy contained in the specified
 	 * outer observable.

src/test/java/org/codefx/libfx/nesting/AbstractDeepNestingTestForDefaultNesting.java

@@ -28,6 +28,17 @@ protected Property<OuterValue> createNewNestingHierarchy() {
 		return new SimpleObjectProperty<>(outer);
 	}
 
+	@Override
+	protected Property<OuterValue> createNewNestingHierarchyWhereOuterObservableHasNullValue() {
+		return new SimpleObjectProperty<>(null);
+	}
+
+	@Override
+	protected Property<OuterValue> createNewNestingHierarchyWhereNestedObservableHasNullValue() {
+		OuterValue outer = OuterValue.createWithNull();
+		return new SimpleObjectProperty<>(outer);
+	}
+
 	@Override
 	protected void setNewValue(Property<OuterValue> outerObservable, Level level, Value kindOfNewValue) {
 

src/test/java/org/codefx/libfx/nesting/AbstractNestingTest.java

@@ -44,6 +44,16 @@ public void setUp() {
 
 	// #region TESTS
 
+	// construction
+
+	/**
+	 * Tests whether creating a nesting with on a null outer observable throws an exception.
+	 */
+	@Test(expected = NullPointerException.class)
+	public void testExceptionWhenNullObservable() {
+		nesting = createNewNestingFromOuterObservable(null);
+	}
+
 	/**
 	 * Tests whether the {@link #nesting}'s {@link Nesting#innerObservableProperty() innerObservable} property contains
 	 * the correct observable, which is the {@link #outerObservable}'s inner observable.