Implemented 'NestedBooleanProperty' including the builder and tests.

Author: Nicolai Parlog

src/org/codefx/libfx/nesting/AbstractNestingNestingBuilder.java

@@ -2,6 +2,7 @@
 
 import java.util.Objects;
 
+import javafx.beans.property.BooleanProperty;
 import javafx.beans.property.DoubleProperty;
 import javafx.beans.property.FloatProperty;
 import javafx.beans.property.IntegerProperty;
@@ -83,6 +84,22 @@ public <N> ObjectPropertyNestingBuilder<N> nestProperty(NestingStep<T, Property<
 		return new ObjectPropertyNestingBuilder<N>(this, nestingStep);
 	}
 
+	/**
+	 * Returns a builder for nestings whose inner observable is a {@link BooleanProperty}. The created nestings depend
+	 * on this builder's outer observable and nesting steps and adds the specified step as the next one.
+	 *
+	 * @param nestingStep
+	 *            the function which performs the nesting step from one observable to the next
+	 * @return a {@link BooleanPropertyNestingBuilder} which builds a nesting from this builder's settings and the
+	 *         specified nesting steps
+	 * @throws NullPointerException
+	 *             if the specified function is null
+	 */
+	public BooleanPropertyNestingBuilder nestBooleanProperty(NestingStep<T, BooleanProperty> nestingStep) {
+		Objects.requireNonNull(nestingStep, "The argument 'nestingStep' must not be null.");
+		return new BooleanPropertyNestingBuilder(this, nestingStep);
+	}
+
 	/**
 	 * Returns a builder for nestings whose inner observable is an {@link IntegerProperty}. The created nestings depend
 	 * on this builder's outer observable and nesting steps and adds the specified step as the next one.

src/org/codefx/libfx/nesting/BooleanPropertyNestingBuilder.java

@@ -0,0 +1,59 @@
+package org.codefx.libfx.nesting;
+
+import javafx.beans.property.BooleanProperty;
+
+import org.codefx.libfx.nesting.property.NestedBooleanProperty;
+import org.codefx.libfx.nesting.property.NestedBooleanPropertyBuilder;
+
+/**
+ * A builder for all kinds of nested functionality whose innermost value is held by a {@link BooleanProperty}.
+ */
+public class BooleanPropertyNestingBuilder extends AbstractNestingBuilder<Boolean, BooleanProperty> {
+
+	// #region CONSTRUCTION
+
+	/**
+	 * Creates a new nesting builder which acts as a nested builder.
+	 *
+	 * @param <P>
+	 *            the type the previous builder wraps
+	 * @param previousNestedBuilder
+	 *            the previous builder
+	 * @param nestingStep
+	 *            the function which performs the nesting step from one observable to the next
+	 */
+	<P> BooleanPropertyNestingBuilder(
+			AbstractNestingBuilder<P, ?> previousNestedBuilder,
+			NestingStep<P, BooleanProperty> nestingStep) {
+
+		super(previousNestedBuilder, nestingStep);
+	}
+
+	//#end CONSTRUCTION
+
+	// #region BUILD
+
+	/**
+	 * Creates a nested property from this builder's settings. This method can be called arbitrarily often and each call
+	 * returns a new instance.
+	 *
+	 * @return a new {@link NestedBooleanProperty} instance with no owning bean and no name
+	 */
+	public NestedBooleanProperty buildProperty() {
+		Nesting<BooleanProperty> nesting = buildNesting();
+		return NestedBooleanPropertyBuilder.forNesting(nesting).build();
+	}
+
+	/**
+	 * Returns a nested object property builder which can be used to define the new property's attributes before
+	 * building it.
+	 *
+	 * @return a new instance of {@link NestedBooleanPropertyBuilder}
+	 */
+	public NestedBooleanPropertyBuilder buildPropertyWithBuilder() {
+		Nesting<BooleanProperty> nesting = buildNesting();
+		return NestedBooleanPropertyBuilder.forNesting(nesting);
+	}
+
+	//#end BUILD
+}

src/org/codefx/libfx/nesting/property/NestedBooleanProperty.java

@@ -0,0 +1,62 @@
+package org.codefx.libfx.nesting.property;
+
+import java.util.Objects;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.Property;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+
+import org.codefx.libfx.nesting.Nesting;
+
+/**
+ * A {@link BooleanProperty} which also implements {@link NestedProperty}.
+ */
+public class NestedBooleanProperty extends SimpleBooleanProperty implements NestedProperty<Boolean> {
+
+	// #region PROPERTIES
+
+	/**
+	 * The property indicating whether the nesting's inner observable is currently null.
+	 */
+	private final BooleanProperty innerObservableNull;
+
+	//#end PROPERTIES
+
+	// #region CONSTUCTION
+
+	/**
+	 * Creates a new property. Except {@code nesting} all arguments can be null.
+	 *
+	 * @param nesting
+	 *            the nesting this property is based on
+	 * @param bean
+	 *            the bean which owns this property; can be null
+	 * @param name
+	 *            this property's name; can be null
+	 */
+	NestedBooleanProperty(Nesting<? extends Property<Boolean>> nesting, Object bean, String name) {
+		super(bean, name);
+		Objects.requireNonNull(nesting, "The argument 'nesting' must not be null.");
+		this.innerObservableNull = new SimpleBooleanProperty(this, "innerObservableNull");
+
+		PropertyToNestingBinding.bind(this, isNull -> innerObservableNull.set(isNull), nesting);
+	}
+
+	//#end CONSTUCTION
+
+	// #region IMPLEMENTATION OF 'NestedProperty'
+
+	@Override
+	public ReadOnlyBooleanProperty innerObservableNull() {
+		return innerObservableNull;
+	}
+
+	@Override
+	public boolean isInnerObservableNull() {
+		return innerObservableNull.get();
+	}
+
+	//#end IMPLEMENTATION OF 'NestedProperty'
+
+}

src/org/codefx/libfx/nesting/property/NestedBooleanPropertyBuilder.java

@@ -0,0 +1,47 @@
+package org.codefx.libfx.nesting.property;
+
+import javafx.beans.property.BooleanProperty;
+
+import org.codefx.libfx.nesting.Nesting;
+
+/**
+ * A builder for a {@link NestedBooleanProperty} which is bound to the {@link Nesting#innerObservable() innerObservable}
+ * of a {@link Nesting}.
+ */
+public class NestedBooleanPropertyBuilder extends AbstractNestedPropertyBuilder<BooleanProperty, NestedBooleanProperty> {
+
+	// #region CONSTRUCTION
+
+	/**
+	 * Creates a new builder which uses the specified nesting.
+	 *
+	 * @param nesting
+	 *            the nesting which will be used for all nested properties
+	 */
+	private NestedBooleanPropertyBuilder(Nesting<BooleanProperty> nesting) {
+		super(nesting);
+	}
+
+	/**
+	 * Creates a new builder which uses the specified nesting.
+	 *
+	 * @param nesting
+	 *            the nesting which will be used for all nested properties
+	 * @return a new instance of {@link NestedBooleanPropertyBuilder}
+	 */
+	public static NestedBooleanPropertyBuilder forNesting(Nesting<BooleanProperty> nesting) {
+		return new NestedBooleanPropertyBuilder(nesting);
+	}
+
+	//#end CONSTRUCTION
+
+	// #region METHODS
+
+	@Override
+	public NestedBooleanProperty build() {
+		return new NestedBooleanProperty(getNesting(), getBean(), getName());
+	}
+
+	//#end METHODS
+
+}

test/org/codefx/libfx/nesting/property/AbstractNestedBooleanPropertyTest.java

@@ -0,0 +1,89 @@
+package org.codefx.libfx.nesting.property;
+
+import static org.codefx.libfx.nesting.testhelper.NestingAccess.getNestingObservable;
+import static org.codefx.libfx.nesting.testhelper.NestingAccess.getNestingValue;
+import static org.codefx.libfx.nesting.testhelper.NestingAccess.setNestingObservable;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertTrue;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+
+import org.codefx.libfx.nesting.Nesting;
+import org.junit.Test;
+
+/**
+ * Abstract superclass to tests for {@link NestedBooleanProperty NestedBooleanProperty} which only leaves the creation
+ * of the tested properties (by {@link #createNestedPropertyFromNesting(Nesting)}) to the subclasses.
+ */
+public abstract class AbstractNestedBooleanPropertyTest extends AbstractNestedPropertyTest<Boolean, BooleanProperty> {
+
+	/*
+	 * Since Boolean has only two values, 'createNewValue' can not fulfill its contract. Instead it always returns
+	 * 'true' whereas 'createNewObservableWithSomeValue' uses false. All tests where this might come into play are
+	 * overridden below (for better readability or just to make them work).
+	 */
+
+	@Override
+	protected boolean allowsNullValues() {
+		return false;
+	}
+
+	@Override
+	protected Boolean createNewValue() {
+		return true;
+	}
+
+	@Override
+	protected BooleanProperty createNewObservableWithValue(Boolean value) {
+		return new SimpleBooleanProperty(value);
+	}
+
+	@Override
+	protected BooleanProperty createNewObservableWithSomeValue() {
+		return createNewObservableWithValue(false);
+	}
+
+	// #region OVERRIDDEN TEST METHODS
+
+	@Override
+	@Test
+	public void testChangingNewObservablesValue() {
+		// set a new observable whose value is 'false'...
+		BooleanProperty newObservable = createNewObservableWithValue(false);
+		setNestingObservable(getNesting(), newObservable);
+		// (assert that setting the observable worked)
+		assertEquals(newObservable, getNestingObservable(getNesting()));
+
+		// ... and change its value to 'true'
+		newObservable.setValue(true);
+
+		// assert that nesting and property hold the new value
+		assertTrue(getNestingValue(getNesting()));
+		assertTrue(getPropertyValue());
+	}
+
+	@Override
+	@Test
+	public void testChangingOldObservablesValue() {
+		// store the old observable which has the value 'false' (see 'createNewObservableWithSomeValue') ...
+		BooleanProperty oldObservable = getNestingObservable(getNesting());
+
+		// ... set a new observable with value 'false' ...
+		BooleanProperty newObservableWithFalse = createNewObservableWithValue(false);
+		setNestingObservable(getNesting(), newObservableWithFalse);
+		// (assert that setting the observable worked)
+		assertNotSame(oldObservable, getNestingObservable(getNesting()));
+
+		// ... and change the old observable's value
+		oldObservable.setValue(true);
+
+		// assert that nesting and property hold the new observable's value (i.e. 'false') instead of the old observable's new value (i.e. 'true')
+		assertFalse(getNestingValue(getNesting()));
+		assertFalse(getPropertyValue());
+	}
+
+	//#end OVERRIDDEN TEST METHODS
+
+}

test/org/codefx/libfx/nesting/property/NestedBooleanPropertyBuilderTest.java

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

test/org/codefx/libfx/nesting/property/NestedBooleanPropertyTest.java

@@ -0,0 +1,17 @@
+package org.codefx.libfx.nesting.property;
+
+import javafx.beans.property.BooleanProperty;
+
+import org.codefx.libfx.nesting.Nesting;
+
+/**
+ * Tests the class {@link NestedBooleanProperty}.
+ */
+public class NestedBooleanPropertyTest extends AbstractNestedBooleanPropertyTest {
+
+	@Override
+	protected NestedProperty<Boolean> createNestedPropertyFromNesting(Nesting<BooleanProperty> nesting) {
+		return new NestedBooleanProperty(nesting, null, null);
+	}
+
+}

test/org/codefx/libfx/nesting/property/_AllNestedPropertyTests.java

@@ -9,6 +9,8 @@
  */
 @RunWith(Suite.class)
 @SuiteClasses({
+		NestedBooleanPropertyBuilderTest.class,
+		NestedBooleanPropertyTest.class,
 		NestedDoublePropertyBuilderTest.class,
 		NestedDoublePropertyTest.class,
 		NestedFloatPropertyBuilderTest.class,