Implemented 'NestedLongProperty' including the builder and tests.

Author: Nicolai Parlog

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

@@ -5,6 +5,7 @@
 import javafx.beans.property.DoubleProperty;
 import javafx.beans.property.FloatProperty;
 import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.LongProperty;
 import javafx.beans.property.Property;
 import javafx.beans.value.ObservableValue;
 
@@ -97,6 +98,22 @@ public IntegerPropertyNestingBuilder nestIntegerProperty(NestingStep<T, IntegerP
 		return new IntegerPropertyNestingBuilder(this, nestingStep);
 	}
 
+	/**
+	 * Returns a builder for nestings whose inner observable is a {@link LongProperty}. 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 LongPropertyNestingBuilder} which builds a nesting from this builder's settings and the
+	 *         specified nesting steps
+	 * @throws NullPointerException
+	 *             if the specified function is null
+	 */
+	public LongPropertyNestingBuilder nestLongProperty(NestingStep<T, LongProperty> nestingStep) {
+		Objects.requireNonNull(nestingStep, "The argument 'nestingStep' must not be null.");
+		return new LongPropertyNestingBuilder(this, nestingStep);
+	}
+
 	/**
 	 * Returns a builder for nestings whose inner observable is a {@link FloatProperty}. 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/LongPropertyNestingBuilder.java

@@ -0,0 +1,59 @@
+package org.codefx.libfx.nesting;
+
+import javafx.beans.property.LongProperty;
+
+import org.codefx.libfx.nesting.property.NestedLongProperty;
+import org.codefx.libfx.nesting.property.NestedLongPropertyBuilder;
+
+/**
+ * A builder for all kinds of nested functionality whose innermost value is held by a {@link LongProperty}.
+ */
+public class LongPropertyNestingBuilder extends AbstractNestingBuilder<Number, LongProperty> {
+
+	// #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> LongPropertyNestingBuilder(
+			AbstractNestingBuilder<P, ?> previousNestedBuilder,
+			NestingStep<P, LongProperty> 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 NestedLongProperty} instance with no owning bean and no name
+	 */
+	public NestedLongProperty buildProperty() {
+		Nesting<LongProperty> nesting = buildNesting();
+		return NestedLongPropertyBuilder.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 NestedLongPropertyBuilder}
+	 */
+	public NestedLongPropertyBuilder buildPropertyWithBuilder() {
+		Nesting<LongProperty> nesting = buildNesting();
+		return NestedLongPropertyBuilder.forNesting(nesting);
+	}
+
+	//#end BUILD
+}

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

@@ -0,0 +1,64 @@
+package org.codefx.libfx.nesting.property;
+
+import java.util.Objects;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.LongProperty;
+import javafx.beans.property.Property;
+import javafx.beans.property.ReadOnlyBooleanProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleLongProperty;
+
+import org.codefx.libfx.nesting.Nesting;
+
+/**
+ * A {@link LongProperty} which also implements {@link NestedProperty}.
+ */
+public class NestedLongProperty extends SimpleLongProperty implements NestedProperty<Number> {
+
+	// #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
+	 */
+	NestedLongProperty(Nesting<? extends Property<Number>> 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/NestedLongPropertyBuilder.java

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

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

@@ -0,0 +1,40 @@
+package org.codefx.libfx.nesting.property;
+
+import javafx.beans.property.LongProperty;
+import javafx.beans.property.SimpleLongProperty;
+
+import org.codefx.libfx.nesting.Nesting;
+
+/**
+ * Abstract superclass to tests for {@link NestedLongProperty NestedLongProperty} which only leaves the creation of the
+ * tested properties (by {@link #createNestedPropertyFromNesting(Nesting)}) to the subclasses.
+ */
+public abstract class AbstractNestedLongPropertyTest extends AbstractNestedPropertyTest<Number, LongProperty> {
+
+	/**
+	 * The last value returned by {@link #createNewValue()}.
+	 */
+	private long lastValue = 0;
+
+	@Override
+	protected boolean allowsNullValues() {
+		return false;
+	}
+
+	@Override
+	protected Number createNewValue() {
+		lastValue += 1;
+		return lastValue;
+	}
+
+	@Override
+	protected LongProperty createNewObservableWithValue(Number value) {
+		return new SimpleLongProperty(value.longValue());
+	}
+
+	@Override
+	protected LongProperty createNewObservableWithSomeValue() {
+		return createNewObservableWithValue(0);
+	}
+
+}

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

@@ -0,0 +1,51 @@
+package org.codefx.libfx.nesting.property;
+
+import javafx.beans.property.LongProperty;
+import javafx.beans.property.SimpleLongProperty;
+
+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 NestedLongPropertyBuilder}.
+ */
+@RunWith(Suite.class)
+@SuiteClasses({
+		NestedLongPropertyBuilderTest.AbstractBuilderContract.class,
+		NestedLongPropertyBuilderTest.CreatedProperties.class,
+})
+public class NestedLongPropertyBuilderTest {
+
+	/**
+	 * Tests whether the builder fulfills the contract defined by {@link AbstractNestedPropertyBuilder}.
+	 */
+	public static class AbstractBuilderContract
+			extends AbstractNestedPropertyBuilderTest<LongProperty, NestedLongProperty> {
+
+		@Override
+		protected AbstractNestedPropertyBuilder<LongProperty, NestedLongProperty> createBuilder() {
+			LongProperty innerObservable = new SimpleLongProperty(0);
+			EditableNesting<LongProperty> nesting = EditableNesting.createWithInnerObservable(innerObservable);
+			return NestedLongPropertyBuilder.forNesting(nesting);
+		}
+
+	}
+
+	/**
+	 * Uses the builder to create properties which are then tested.
+	 */
+	public static class CreatedProperties extends AbstractNestedLongPropertyTest {
+
+		@Override
+		protected NestedProperty<Number> createNestedPropertyFromNesting(Nesting<LongProperty> nesting) {
+			// use the builder to create the property
+			NestedLongPropertyBuilder builder = NestedLongPropertyBuilder.forNesting(nesting);
+			return builder.build();
+		}
+
+	}
+
+}

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

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

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

@@ -9,14 +9,16 @@
  */
 @RunWith(Suite.class)
 @SuiteClasses({
-		NestedFloatPropertyTest.class,
-		NestedFloatPropertyBuilderTest.class,
-		NestedDoublePropertyTest.class,
-		NestedDoublePropertyBuilderTest.class,
-		NestedIntegerPropertyTest.class,
-		NestedIntegerPropertyBuilderTest.class,
-		NestedObjectPropertyTest.class,
-		NestedObjectPropertyBuilderTest.class,
+	NestedDoublePropertyBuilderTest.class,
+	NestedDoublePropertyTest.class,
+	NestedFloatPropertyBuilderTest.class,
+	NestedFloatPropertyTest.class,
+	NestedIntegerPropertyBuilderTest.class,
+	NestedIntegerPropertyTest.class,
+	NestedLongPropertyBuilderTest.class,
+	NestedLongPropertyTest.class,
+	NestedObjectPropertyBuilderTest.class,
+	NestedObjectPropertyTest.class,
 })
 public class _AllNestedPropertyTests {
 	// no body needed