getChildByName(final String named) {
+ return findChildByName(named).orElseThrow(
+ () -> new NodeException("Named child not found"));
+ }
+
+ @Override
+ public String drawTree(final int depth) {
+ final StringBuilder sb = new StringBuilder();
+ final String unnamed = "(unnamed)";
+ if (isNamed()) {
+ sb.append(formatByDepth(name, depth));
+ } else if (!children.isEmpty()) {
+ sb.append(formatByDepth(unnamed, depth));
+ }
+ getChildren().forEach(c -> sb.append(c.drawTree(depth + 1)));
+ return sb.toString();
+ }
+
+ private String formatByDepth(final String value, final int depth) {
+ return String.format("[%1$" + (depth + value.length()) + "s]\n", value);
+ }
+
+ @Override
+ public boolean isNamed() {
+ return name != null && name.length() > 0;
+ }
+}
diff --git a/src/main/java/net/kemitix/node/ImmutableNodeItem.java b/src/main/java/net/kemitix/node/ImmutableNodeItem.java
new file mode 100644
index 0000000..dbc85ec
--- /dev/null
+++ b/src/main/java/net/kemitix/node/ImmutableNodeItem.java
@@ -0,0 +1,95 @@
+package net.kemitix.node;
+
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Represents an immutable tree of nodes.
+ *
+ * Due to the use of generics the data within a node may not be immutable.
+ * (We can't create a defensive copy.) So if a user were to use {@code
+ * getData()} they could then modify the original data within the node. This
+ * wouldn't affect the integrity of the node tree structure, however.
+ *
+ * @author Paul Campbell
+ *
+ * @param the type of data stored in each node
+ */
+final class ImmutableNodeItem extends AbstractNodeItem {
+
+ private static final String IMMUTABLE_OBJECT = "Immutable object";
+
+ private ImmutableNodeItem(
+ final T data, final String name, final Node parent,
+ final Set> children) {
+ super(data, name, parent, children);
+ }
+
+ static ImmutableNodeItem newRoot(
+ final T data, final String name, final Set> children) {
+ return new ImmutableNodeItem<>(data, name, null, children);
+ }
+
+ static ImmutableNodeItem newChild(
+ final T data, final String name, final Node parent,
+ final Set> children) {
+ return new ImmutableNodeItem<>(data, name, parent, children);
+ }
+
+ @Override
+ public void setName(final String name) {
+ throw new UnsupportedOperationException(IMMUTABLE_OBJECT);
+ }
+
+ @Override
+ public void setData(final T data) {
+ throw new UnsupportedOperationException(IMMUTABLE_OBJECT);
+ }
+
+ @Override
+ public void setParent(final Node parent) {
+ throw new UnsupportedOperationException(IMMUTABLE_OBJECT);
+ }
+
+ @Override
+ public void addChild(final Node child) {
+ throw new UnsupportedOperationException(IMMUTABLE_OBJECT);
+ }
+
+ @Override
+ public Node createChild(final T child) {
+ throw new UnsupportedOperationException(IMMUTABLE_OBJECT);
+ }
+
+ @Override
+ public Node createChild(final T child, final String name) {
+ throw new UnsupportedOperationException(IMMUTABLE_OBJECT);
+ }
+
+ @Override
+ public void createDescendantLine(final List descendants) {
+ throw new UnsupportedOperationException(IMMUTABLE_OBJECT);
+ }
+
+ @Override
+ public Node findOrCreateChild(final T child) {
+ return findChild(child).orElseThrow(
+ () -> new UnsupportedOperationException(IMMUTABLE_OBJECT));
+ }
+
+ @Override
+ public void insertInPath(final Node node, final String... path) {
+ throw new UnsupportedOperationException(IMMUTABLE_OBJECT);
+ }
+
+ @Override
+ public void removeChild(final Node node) {
+ throw new UnsupportedOperationException(IMMUTABLE_OBJECT);
+ }
+
+ @Override
+ public void removeParent() {
+ throw new UnsupportedOperationException(IMMUTABLE_OBJECT);
+ }
+
+}
diff --git a/src/main/java/net/kemitix/node/Node.java b/src/main/java/net/kemitix/node/Node.java
index 7cda730..395ebb7 100644
--- a/src/main/java/net/kemitix/node/Node.java
+++ b/src/main/java/net/kemitix/node/Node.java
@@ -7,9 +7,9 @@ import java.util.Set;
/**
* An interface for tree node items.
*
- * @param the type of data held in each node
+ * @author Paul Campbell
*
- * @author pcampbell
+ * @param the type of data held in each node
*/
public interface Node {
@@ -113,6 +113,9 @@ public interface Node {
* @param child the child's data to search or create with
*
* @return the found or created child node
+ *
+ * @deprecated use node.findChild(child).orElseGet(() ->
+ * node.createChild(child));
*/
@Deprecated
Node findOrCreateChild(T child);
diff --git a/src/main/java/net/kemitix/node/NodeItem.java b/src/main/java/net/kemitix/node/NodeItem.java
index ec71f11..12a7cef 100644
--- a/src/main/java/net/kemitix/node/NodeItem.java
+++ b/src/main/java/net/kemitix/node/NodeItem.java
@@ -1,27 +1,27 @@
package net.kemitix.node;
+import lombok.NonNull;
+import lombok.val;
+
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
-import java.util.function.Function;
/**
* Represents a tree of nodes.
*
- * @param the type of data stored in each node
+ * @author Paul Campbell
*
- * @author pcampbell
+ * @param the type of data stored in each node
*/
-public class NodeItem implements Node {
+class NodeItem implements Node {
private T data;
private final Set> children = new HashSet<>();
- private Function, String> nameSupplier;
-
private Node parent;
private String name;
@@ -32,7 +32,7 @@ public class NodeItem implements Node {
* @param data the data or null
* @param name the name
*/
- public NodeItem(final T data, final String name) {
+ NodeItem(final T data, final String name) {
this(data);
this.name = name;
}
@@ -42,21 +42,8 @@ public class NodeItem implements Node {
*
* @param data the data or null
*/
- public NodeItem(final T data) {
+ NodeItem(final T data) {
this.data = data;
- this.nameSupplier = (n) -> null;
- }
-
- /**
- * Creates root node with a name supplier.
- *
- * @param data the data or null
- * @param nameSupplier the name supplier function
- */
- public NodeItem(
- final T data, final Function, String> nameSupplier) {
- this(data);
- this.nameSupplier = nameSupplier;
}
/**
@@ -65,7 +52,7 @@ public class NodeItem implements Node {
* @param data the data or null
* @param parent the parent node
*/
- public NodeItem(final T data, final Node parent) {
+ NodeItem(final T data, final Node parent) {
this.data = data;
setParent(parent);
}
@@ -77,44 +64,14 @@ public class NodeItem implements Node {
* @param name the name
* @param parent the parent node
*/
- public NodeItem(final T data, final String name, final Node parent) {
+ NodeItem(final T data, final String name, final Node parent) {
this.data = data;
this.name = name;
setParent(parent);
}
- /**
- * Creates a node with a name supplier and a parent.
- *
- * @param data the data or null
- * @param nameSupplier the name supplier function
- * @param parent the parent node
- */
- public NodeItem(
- final T data, final Function, String> nameSupplier,
- final Node parent) {
- this(data, nameSupplier);
- setParent(parent);
- }
-
- private String generateName() {
- return getNameSupplier().apply(this);
- }
-
- private Function, String> getNameSupplier() {
- if (nameSupplier != null) {
- return nameSupplier;
- }
- // no test for parent as root nodes will always have a default name
- // supplier
- return ((NodeItem) parent).getNameSupplier();
- }
-
@Override
public String getName() {
- if (name == null) {
- return generateName();
- }
return name;
}
@@ -154,32 +111,35 @@ public class NodeItem implements Node {
* @param child the node to add
*/
@Override
- public void addChild(final Node child) {
- if (child == null) {
- throw new NullPointerException("child");
- }
- if (this.equals(child) || isDescendantOf(child)) {
- throw new NodeException("Child is an ancestor");
- }
- if (child.isNamed()) {
- final Optional> existingChild = findChildByName(
- child.getName());
- if (existingChild.isPresent() && existingChild.get() != child) {
- throw new NodeException(
- "Node with that name already exists here");
- }
- }
+ public void addChild(@NonNull final Node child) {
+ verifyChildIsNotAnAncestor(child);
+ verifyChildWithSameNameDoesNotAlreadyExist(child);
children.add(child);
// update the child's parent if they don't have one or it is not this
- Optional> childParent = child.getParent();
- boolean isOrphan = !childParent.isPresent();
- boolean hasDifferentParent = !isOrphan && !childParent.get()
- .equals(this);
- if (isOrphan || hasDifferentParent) {
+ val childParent = child.getParent();
+ if (!childParent.isPresent() || !childParent.get().equals(this)) {
child.setParent(this);
}
}
+ private void verifyChildWithSameNameDoesNotAlreadyExist(
+ final @NonNull Node child) {
+ if (child.isNamed()) {
+ findChildByName(child.getName())
+ .filter(existingChild -> existingChild != child)
+ .ifPresent(existingChild -> {
+ throw new NodeException(
+ "Node with that name already exists here");
+ });
+ }
+ }
+
+ private void verifyChildIsNotAnAncestor(final @NonNull Node child) {
+ if (this.equals(child) || isDescendantOf(child)) {
+ throw new NodeException("Child is an ancestor");
+ }
+ }
+
/**
* Creates a new node and adds it as a child of the current node.
*
@@ -188,10 +148,7 @@ public class NodeItem implements Node {
* @return the new child node
*/
@Override
- public Node createChild(final T child) {
- if (child == null) {
- throw new NullPointerException("child");
- }
+ public Node createChild(@NonNull final T child) {
return new NodeItem<>(child, this);
}
@@ -210,10 +167,7 @@ public class NodeItem implements Node {
* @param descendants the line of descendants from the current node
*/
@Override
- public void createDescendantLine(final List descendants) {
- if (descendants == null) {
- throw new NullPointerException("descendants");
- }
+ public void createDescendantLine(@NonNull final List descendants) {
if (!descendants.isEmpty()) {
findOrCreateChild(descendants.get(0)).createDescendantLine(
descendants.subList(1, descendants.size()));
@@ -227,12 +181,13 @@ public class NodeItem implements Node {
* @param child the child's data to search or create with
*
* @return the found or created child node
+ *
+ * @deprecated use node.findChild(child).orElseGet(() -> node.createChild
+ * (child));
*/
@Override
- public Node findOrCreateChild(final T child) {
- if (child == null) {
- throw new NullPointerException("child");
- }
+ @Deprecated
+ public Node findOrCreateChild(@NonNull final T child) {
return findChild(child).orElseGet(() -> createChild(child));
}
@@ -244,14 +199,11 @@ public class NodeItem implements Node {
* @return an {@link Optional} containing the child node if found
*/
@Override
- public Optional> findChild(final T child) {
- if (child == null) {
- throw new NullPointerException("child");
- }
- return children.stream()
- .filter(n -> !n.isEmpty())
- .filter(n -> n.getData().get().equals(child))
- .findAny();
+ public Optional> findChild(@NonNull final T child) {
+ return children.stream().filter(node -> {
+ final Optional d = node.getData();
+ return d.isPresent() && d.get().equals(child);
+ }).findAny();
}
@Override
@@ -282,10 +234,7 @@ public class NodeItem implements Node {
* @param parent the new parent node
*/
@Override
- public final void setParent(final Node parent) {
- if (parent == null) {
- throw new NullPointerException("parent");
- }
+ public final void setParent(@NonNull final Node parent) {
if (this.equals(parent) || parent.isDescendantOf(this)) {
throw new NodeException("Parent is a descendant");
}
@@ -304,64 +253,68 @@ public class NodeItem implements Node {
* @return the child or null
*/
@Override
- public Optional> findInPath(final List path) {
- if (path == null) {
- throw new NullPointerException("path");
+ public Optional> findInPath(@NonNull final List path) {
+ if (path.isEmpty()) {
+ return Optional.empty();
}
- if (path.size() > 0) {
- Optional> found = findChild(path.get(0));
- if (found.isPresent()) {
- if (path.size() > 1) {
- return found.get().findInPath(path.subList(1, path.size()));
- }
- return found;
+ Node current = this;
+ for (T item : path) {
+ final Optional> child = current.findChild(item);
+ if (child.isPresent()) {
+ current = child.get();
+ } else {
+ current = null;
+ break;
}
}
- return Optional.empty();
+ return Optional.ofNullable(current);
}
@Override
public void insertInPath(final Node nodeItem, final String... path) {
if (path.length == 0) {
- if (!nodeItem.isNamed()) { // nothing to conflict with
- addChild(nodeItem);
- return;
- }
- String nodeName = nodeItem.getName();
- final Optional> childNamed = findChildByName(nodeName);
- if (!childNamed.isPresent()) { // nothing with the same name exists
- addChild(nodeItem);
- return;
- }
- // we have an existing node with the same name
- final Node existing = childNamed.get();
- if (!existing.isEmpty()) {
- throw new NodeException("A non-empty node named '" + nodeName
- + "' already exists here");
- } else {
- nodeItem.getData().ifPresent(existing::setData);
- }
- return;
- }
- String item = path[0];
- final Optional> childNamed = findChildByName(item);
- Node child;
- if (!childNamed.isPresent()) {
- child = new NodeItem<>(null, item, this);
+ insertChild(nodeItem);
} else {
- child = childNamed.get();
+ val item = path[0];
+ findChildByName(item)
+ .orElseGet(() -> new NodeItem<>(null, item, this))
+ .insertInPath(nodeItem,
+ Arrays.copyOfRange(path, 1, path.length));
+ }
+ }
+
+ private void insertChild(final Node nodeItem) {
+ if (nodeItem.isNamed()) {
+ insertNamedChild(nodeItem);
+ } else {
+ // nothing to conflict with
+ addChild(nodeItem);
+ }
+ }
+
+ private void insertNamedChild(final Node nodeItem) {
+ val childByName = findChildByName(nodeItem.getName());
+ if (childByName.isPresent()) {
+ // we have an existing node with the same name
+ val existing = childByName.get();
+ if (existing.isEmpty()) {
+ // place any data in the new node into the existing empty node
+ nodeItem.getData().ifPresent(existing::setData);
+ } else {
+ throw new NodeException("A non-empty node named '"
+ + nodeItem.getName() + "' already exists here");
+ }
+ } else {
+ // nothing with the same name exists
+ addChild(nodeItem);
}
- child.insertInPath(nodeItem, Arrays.copyOfRange(path, 1, path.length));
}
@Override
- public Optional> findChildByName(final String named) {
- if (named == null) {
- throw new NullPointerException("name");
- }
+ public Optional> findChildByName(@NonNull final String named) {
return children.stream()
- .filter((Node t) -> t.getName().equals(named))
- .findAny();
+ .filter((Node t) -> t.getName().equals(named))
+ .findAny();
}
@Override
@@ -378,17 +331,18 @@ public class NodeItem implements Node {
final StringBuilder sb = new StringBuilder();
final String unnamed = "(unnamed)";
if (isNamed()) {
- sb.append(String.format("[%1$" + (depth + name.length()) + "s]\n",
- name));
+ sb.append(formatByDepth(name, depth));
} else if (!children.isEmpty()) {
- sb.append(
- String.format("[%1$" + (depth + unnamed.length()) + "s]\n",
- unnamed));
+ sb.append(formatByDepth(unnamed, depth));
}
- getChildren().stream().forEach(c -> sb.append(c.drawTree(depth + 1)));
+ getChildren().forEach(c -> sb.append(c.drawTree(depth + 1)));
return sb.toString();
}
+ private String formatByDepth(final String value, final int depth) {
+ return String.format("[%1$" + (depth + value.length()) + "s]\n", value);
+ }
+
@Override
public boolean isNamed() {
String currentName = getName();
@@ -406,14 +360,8 @@ public class NodeItem implements Node {
public void removeParent() {
if (parent != null) {
Node oldParent = parent;
- Function, String> supplier = getNameSupplier();
parent = null;
oldParent.removeChild(this);
- if (this.nameSupplier == null) {
- // this is now a root node, so must provide a default name
- // supplier
- this.nameSupplier = supplier;
- }
}
}
diff --git a/src/main/java/net/kemitix/node/Nodes.java b/src/main/java/net/kemitix/node/Nodes.java
new file mode 100644
index 0000000..ecc5f39
--- /dev/null
+++ b/src/main/java/net/kemitix/node/Nodes.java
@@ -0,0 +1,107 @@
+package net.kemitix.node;
+
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Utility class for {@link Node} items.
+ *
+ * @author pcampbell
+ */
+public final class Nodes {
+
+ private Nodes() {
+ }
+
+ /**
+ * Creates a new unnamed root node.
+ *
+ * @param data the data the node will contain
+ * @param the type of the data
+ *
+ * @return the new node
+ */
+ public static Node unnamedRoot(final T data) {
+ return new NodeItem<>(data);
+ }
+
+ /**
+ * Creates a new named root node.
+ *
+ * @param data the data the node will contain
+ * @param name the name of the node
+ * @param the type of the data
+ *
+ * @return the new node
+ */
+ public static Node namedRoot(final T data, final String name) {
+ return new NodeItem<>(data, name);
+ }
+
+ /**
+ * Creates a new unnamed child node.
+ *
+ * @param data the data the node will contain
+ * @param parent the parent of the node
+ * @param the type of the data
+ *
+ * @return the new node
+ */
+ public static Node unnamedChild(final T data, final Node parent) {
+ return new NodeItem<>(data, parent);
+ }
+
+ /**
+ * Creates a new named child node.
+ *
+ * @param data the data the node will contain
+ * @param name the name of the node
+ * @param parent the parent of the node
+ * @param the type of the data
+ *
+ * @return the new node
+ */
+ public static Node namedChild(
+ final T data, final String name, final Node parent) {
+ return new NodeItem<>(data, name, parent);
+ }
+
+ /**
+ * Creates an immutable copy of an existing node tree.
+ *
+ * @param root the root node of the source tree
+ * @param the type of the data
+ *
+ * @return the immutable copy of the tree
+ */
+ public static Node asImmutable(final Node root) {
+ if (root.getParent().isPresent()) {
+ throw new IllegalArgumentException("source must be the root node");
+ }
+ final Set> children = getImmutableChildren(root);
+ return ImmutableNodeItem.newRoot(root.getData().orElse(null),
+ root.getName(), children);
+ }
+
+ private static Set> getImmutableChildren(final Node source) {
+ return source.getChildren()
+ .stream()
+ .map(Nodes::asImmutableChild)
+ .collect(Collectors.toSet());
+ }
+
+ private static Node asImmutableChild(
+ final Node source) {
+ final Optional> sourceParent = source.getParent();
+ if (sourceParent.isPresent()) {
+ return ImmutableNodeItem.newChild(source.getData().orElse(null),
+ source.getName(), sourceParent.get(),
+ getImmutableChildren(source));
+ } else {
+ throw new IllegalArgumentException(
+ "source must not be the root node");
+ }
+ }
+
+}
diff --git a/src/test/java/net/kemitix/node/ImmutableNodeItemTest.java b/src/test/java/net/kemitix/node/ImmutableNodeItemTest.java
new file mode 100644
index 0000000..91eee8a
--- /dev/null
+++ b/src/test/java/net/kemitix/node/ImmutableNodeItemTest.java
@@ -0,0 +1,454 @@
+package net.kemitix.node;
+
+import lombok.val;
+import org.assertj.core.api.SoftAssertions;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.junit.rules.ExpectedException;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Test for {@link ImmutableNodeItem}.
+ *
+ * @author pcampbell
+ */
+public class ImmutableNodeItemTest {
+
+ private static final String IMMUTABLE_OBJECT = "Immutable object";
+
+ @Rule
+ public ExpectedException exception = ExpectedException.none();
+
+ private Node immutableNode;
+
+ private void expectImmutableException() {
+ exception.expect(UnsupportedOperationException.class);
+ exception.expectMessage(IMMUTABLE_OBJECT);
+ }
+
+ @Test
+ public void getDataReturnsData() {
+ //given
+ val data = "this immutableNode data";
+ //when
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(data));
+ //then
+ assertThat(immutableNode.getData()).as(
+ "can get the data from a immutableNode").
+ contains(data);
+ }
+
+ @Test
+ public void canCreateAnEmptyAndUnnamedNode() {
+ //when
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(null));
+ //then
+ SoftAssertions softly = new SoftAssertions();
+ softly.assertThat(immutableNode.isEmpty())
+ .as("immutableNode is empty")
+ .isTrue();
+ softly.assertThat(immutableNode.isNamed())
+ .as("immutableNode is unnamed")
+ .isFalse();
+ softly.assertAll();
+ }
+
+ @Test
+ public void shouldThrowExceptionOnSetName() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(null));
+ expectImmutableException();
+ //when
+ immutableNode.setName("named");
+ }
+
+ @Test
+ public void rootNodeShouldHaveNoParent() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot("data"));
+ //then
+ assertThat(immutableNode.getParent()).as(
+ "immutableNode created without a parent has no parent")
+ .isEmpty();
+ }
+
+ @Test
+ public void shouldContainImmutableCopyOfChild() {
+ //given
+ val parent = Nodes.unnamedRoot("root");
+ val child = Nodes.namedChild("child", "child", parent);
+ //when
+ immutableNode = Nodes.asImmutable(parent);
+ //then
+ val immutableChild = immutableNode.getChildByName("child");
+ assertThat(immutableChild).isNotSameAs(child);
+ assertThat(immutableChild.getName()).isEqualTo("child");
+ }
+
+ @Test
+ public void childShouldHaveImmutableParent() {
+ //given
+ val parent = Nodes.namedRoot("parent", "root");
+ Nodes.namedChild("subject", "child", parent);
+ //when
+ immutableNode = Nodes.asImmutable(parent);
+ //then
+ // get the immutable node's child's parent
+ val immutableChild = immutableNode.getChildByName("child");
+ final Optional> optionalParent
+ = immutableChild.getParent();
+ if (optionalParent.isPresent()) {
+ val p = optionalParent.get();
+ assertThat(p).hasFieldOrPropertyWithValue("name", "root")
+ .hasFieldOrPropertyWithValue("data",
+ Optional.of("parent"));
+ }
+ }
+
+ @Test
+ public void shouldNotBeAbleToAddChildToImmutableTree() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot("root"));
+ expectImmutableException();
+ //when
+ Nodes.unnamedChild("child", immutableNode);
+ }
+
+ @Test
+ public void shouldThrowExceptionWhenSetParent() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot("subject"));
+ expectImmutableException();
+ //when
+ immutableNode.setParent(null);
+ }
+
+ @Test
+ public void shouldThrowExceptionWhenAddingChild() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot("subject"));
+ expectImmutableException();
+ //when
+ immutableNode.addChild(Nodes.unnamedRoot("child"));
+ }
+
+ /**
+ * Test that we can walk a tree to the target node.
+ */
+ @Test
+ @Category(NodeFindInPathTestsCategory.class)
+ public void shouldWalkTreeToNode() {
+ //given
+ val root = Nodes.unnamedRoot("root");
+ Nodes.namedChild("child", "child", Nodes.unnamedChild("parent", root));
+ immutableNode = Nodes.asImmutable(root);
+ //when
+ val result = immutableNode.findInPath(Arrays.asList("parent", "child"));
+ //then
+ assertThat(result.isPresent()).isTrue();
+ if (result.isPresent()) {
+ assertThat(result.get().getName()).isEqualTo("child");
+ }
+ }
+
+ /**
+ * Test that we get an empty {@link Optional} when walking a path that
+ * doesn't exist.
+ */
+ @Test
+ @Category(NodeFindInPathTestsCategory.class)
+ public void shouldNotFindNonExistentChildNode() {
+ //given
+ val root = Nodes.unnamedRoot("root");
+ Nodes.unnamedChild("child", Nodes.unnamedChild("parent", root));
+ immutableNode = Nodes.asImmutable(root);
+ //when
+ val result = immutableNode.findInPath(
+ Arrays.asList("parent", "no child"));
+ //then
+ assertThat(result.isPresent()).isFalse();
+ }
+
+ /**
+ * Test that when we pass null we get an exception.
+ */
+ @Test
+ @Category(NodeFindInPathTestsCategory.class)
+ public void shouldThrowNEWhenWalkTreeNull() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot("subject"));
+ exception.expect(NullPointerException.class);
+ exception.expectMessage("path");
+ //when
+ immutableNode.findInPath(null);
+ }
+
+ /**
+ * Test that when we pass an empty path we get and empty {@link Optional} as
+ * a result.
+ */
+ @Test
+ @Category(NodeFindInPathTestsCategory.class)
+ public void shouldReturnEmptyForEmptyWalkTreePath() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot("subject"));
+ //when
+ val result = immutableNode.findInPath(Collections.emptyList());
+ //then
+ assertThat(result).isEmpty();
+ }
+
+ /**
+ * Test that we can find a child of a immutableNode.
+ */
+ @Test
+ public void shouldFindExistingChildNode() {
+ //given
+ val root = Nodes.unnamedRoot("root");
+ Nodes.unnamedChild("child", root);
+ immutableNode = Nodes.asImmutable(root);
+ //when
+ val result = immutableNode.findChild("child");
+ //then
+ assertThat(result.isPresent()).isTrue();
+ if (result.isPresent()) {
+ assertThat(result.get().getData()).contains("child");
+ }
+ }
+
+ /**
+ * Test that if we pass null we get an exception.
+ */
+ @Test
+ public void findOrCreateChildShouldThrowNPEFWhenChildIsNull() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot("subject"));
+ exception.expect(NullPointerException.class);
+ exception.expectMessage("child");
+ //when
+ immutableNode.findOrCreateChild(null);
+ }
+
+ /**
+ * Test that we throw an exception when passed null.
+ */
+ @Test
+ public void getChildShouldThrowNPEWhenThereIsNoChild() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot("data"));
+ exception.expect(NullPointerException.class);
+ exception.expectMessage("child");
+ //when
+ immutableNode.findChild(null);
+ }
+
+ @Test
+ public void getChildNamedFindsChild() {
+ //given
+ val root = Nodes.namedRoot("root data", "root");
+ val alpha = Nodes.namedRoot("alpha data", "alpha");
+ val beta = Nodes.namedRoot("beta data", "beta");
+ root.addChild(alpha);
+ root.addChild(beta);
+ immutableNode = Nodes.asImmutable(root);
+ //when
+ val result = immutableNode.getChildByName("alpha");
+ //then
+ assertThat(result.getName()).isEqualTo(alpha.getName());
+ }
+
+ @Test
+ public void getChildNamedFindsNothing() {
+ //given
+ val root = Nodes.namedRoot("root data", "root");
+ val alpha = Nodes.namedRoot("alpha data", "alpha");
+ val beta = Nodes.namedRoot("beta data", "beta");
+ root.addChild(alpha);
+ root.addChild(beta);
+ exception.expect(NodeException.class);
+ exception.expectMessage("Named child not found");
+ immutableNode = Nodes.asImmutable(root);
+ //when
+ immutableNode.getChildByName("gamma");
+ }
+
+ @Test
+ public void removingParentThrowsException() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(null));
+ expectImmutableException();
+ //when
+ immutableNode.removeParent();
+ }
+
+ @Test
+ public void findChildNamedShouldThrowNPEWhenNameIsNull() {
+ //given
+ exception.expect(NullPointerException.class);
+ exception.expectMessage("name");
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(null));
+ //when
+ immutableNode.findChildByName(null);
+ }
+
+ @Test
+ public void isNamedNull() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(null));
+ //then
+ assertThat(immutableNode.isNamed()).isFalse();
+ }
+
+ @Test
+ public void isNamedEmpty() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.namedRoot(null, ""));
+ //then
+ assertThat(immutableNode.isNamed()).isFalse();
+ }
+
+ @Test
+ public void isNamedNamed() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.namedRoot(null, "named"));
+ //then
+ assertThat(immutableNode.isNamed()).isTrue();
+ }
+
+ @Test
+ public void removeChildThrowsExceptions() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(null));
+ expectImmutableException();
+ //then
+ immutableNode.removeChild(null);
+ }
+
+ @Test
+ public void drawTreeIsCorrect() {
+ //given
+ val root = Nodes.namedRoot("root data", "root");
+ val bob = Nodes.namedChild("bob data", "bob", root);
+ val alice = Nodes.namedChild("alice data", "alice", root);
+ Nodes.namedChild("dave data", "dave", alice);
+ Nodes.unnamedChild("bob's child's data",
+ bob); // has no name and no children so no included
+ val kim = Nodes.unnamedChild("kim data", root); // nameless mother
+ Nodes.namedChild("lucy data", "lucy", kim);
+ immutableNode = Nodes.asImmutable(root);
+ //when
+ val tree = immutableNode.drawTree(0);
+ //then
+ String[] lines = tree.split("\n");
+ assertThat(lines).contains("[root]", "[ alice]", "[ dave]",
+ "[ (unnamed)]", "[ lucy]", "[ bob]");
+ assertThat(lines).containsSubsequence("[root]", "[ alice]", "[ dave]");
+ assertThat(lines).containsSubsequence("[root]", "[ (unnamed)]",
+ "[ lucy]");
+ assertThat(lines).containsSubsequence("[root]", "[ bob]");
+ }
+
+ @Test
+ public void setDataShouldThrowException() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot("initial"));
+ expectImmutableException();
+ //when
+ immutableNode.setData("updated");
+ }
+
+ @Test
+ public void createChildThrowsException() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(null));
+ expectImmutableException();
+ //when
+ immutableNode.createChild("child data", "child name");
+ }
+
+ @Test
+ public void canGetChildWhenFound() {
+ //given
+ val root = Nodes.unnamedRoot("data");
+ val child = Nodes.namedChild("child data", "child name", root);
+ immutableNode = Nodes.asImmutable(root);
+ //when
+ val found = immutableNode.getChild("child data");
+ //then
+ assertThat(found.getName()).isEqualTo(child.getName());
+ }
+
+ @Test
+ public void canGetChildWhenNotFound() {
+ //given
+ exception.expect(NodeException.class);
+ exception.expectMessage("Child not found");
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot("data"));
+ //when
+ immutableNode.getChild("child data");
+ }
+
+ @Test
+ public void canSafelyHandleFindChildWhenAChildHasNoData() {
+ //given
+ val root = Nodes.unnamedRoot("");
+ Nodes.unnamedChild(null, root);
+ immutableNode = Nodes.asImmutable(root);
+ //when
+ immutableNode.findChild("data");
+ }
+
+ @Test
+ public void createChildShouldThrowException() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(""));
+ expectImmutableException();
+ //when
+ immutableNode.createChild("child");
+ }
+
+ @Test
+ public void createDescendantLineShouldThrowException() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(""));
+ expectImmutableException();
+ //when
+ immutableNode.createDescendantLine(
+ Arrays.asList("child", "grandchild"));
+ }
+
+ @Test
+ public void insertInPathShouldThrowException() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(""));
+ expectImmutableException();
+ //when
+ immutableNode.insertInPath(null, "");
+ }
+
+ @Test
+ public void findOrCreateChildShouldReturnChildWhenChildIsFound() {
+ //given
+ val root = Nodes.unnamedRoot("");
+ Nodes.namedChild("child", "child", root);
+ immutableNode = Nodes.asImmutable(root);
+ //when
+ val found = immutableNode.findOrCreateChild("child");
+ assertThat(found).extracting(Node::getName).contains("child");
+ }
+
+ @Test
+ public void findOrCreateChildShouldThrowExceptionWhenChildNotFound() {
+ //given
+ immutableNode = Nodes.asImmutable(Nodes.unnamedRoot(""));
+ expectImmutableException();
+ //when
+ immutableNode.findOrCreateChild("child");
+ }
+}
diff --git a/src/test/java/net/kemitix/node/NodeFindInPathTestsCategory.java b/src/test/java/net/kemitix/node/NodeFindInPathTestsCategory.java
new file mode 100644
index 0000000..979190f
--- /dev/null
+++ b/src/test/java/net/kemitix/node/NodeFindInPathTestsCategory.java
@@ -0,0 +1,9 @@
+package net.kemitix.node;
+
+/**
+ * Category marker for tests relating to implementations of Node.findInPath(...).
+ *
+ * @author Paul Campbell
+ */
+public interface NodeFindInPathTestsCategory {
+}
diff --git a/src/test/java/net/kemitix/node/NodeItemTest.java b/src/test/java/net/kemitix/node/NodeItemTest.java
index 700b053..2702ae0 100644
--- a/src/test/java/net/kemitix/node/NodeItemTest.java
+++ b/src/test/java/net/kemitix/node/NodeItemTest.java
@@ -4,17 +4,14 @@ import lombok.val;
import org.assertj.core.api.SoftAssertions;
import org.junit.Rule;
import org.junit.Test;
+import org.junit.experimental.categories.Category;
import org.junit.rules.ExpectedException;
-import static org.assertj.core.api.Assertions.assertThat;
-
-import java.time.LocalDate;
-import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.Collections;
import java.util.Optional;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.Function;
+
+import static org.assertj.core.api.Assertions.assertThat;
/**
* Test for {@link NodeItem}.
@@ -33,7 +30,7 @@ public class NodeItemTest {
//given
val data = "this node data";
//when
- node = new NodeItem<>(data);
+ node = Nodes.unnamedRoot(data);
//then
assertThat(node.getData()).as("can get the data from a node").
contains(data);
@@ -42,7 +39,7 @@ public class NodeItemTest {
@Test
public void canCreateAnEmptyAndUnnamedNode() {
//when
- node = new NodeItem<>(null);
+ node = Nodes.unnamedRoot(null);
//then
SoftAssertions softly = new SoftAssertions();
softly.assertThat(node.isEmpty()).as("node is empty").isTrue();
@@ -50,21 +47,10 @@ public class NodeItemTest {
softly.assertAll();
}
- @Test
- public void canCreateNodeWithParentAndCustomNameSupplier() {
- //given
- node = new NodeItem<>(null, n -> "root name supplier");
- //when
- val child = new NodeItem(null, n -> "overridden", node);
- //then
- assertThat(child.getName()).isEqualTo("overridden");
- assertThat(child.getParent()).contains(node);
- }
-
@Test
public void canSetName() {
//given
- node = new NodeItem<>(null);
+ node = Nodes.unnamedRoot(null);
//when
node.setName("named");
//then
@@ -77,7 +63,7 @@ public class NodeItemTest {
@Test
public void shouldHaveNullForDefaultParent() {
//given
- node = new NodeItem<>("data");
+ node = Nodes.unnamedRoot("data");
//then
assertThat(node.getParent()).as(
"node created without a parent has no parent").isEmpty();
@@ -89,9 +75,9 @@ public class NodeItemTest {
@Test
public void shouldReturnNodeParent() {
//given
- val parent = new NodeItem("parent");
+ val parent = Nodes.unnamedRoot("parent");
//when
- node = new NodeItem<>("subject", parent);
+ node = Nodes.unnamedChild("subject", parent);
//then
assertThat(node.getParent()).as(
"node created with a parent can return the parent")
@@ -105,8 +91,8 @@ public class NodeItemTest {
@Test
public void setParentShouldThrowNodeExceptionWhenParentIsAChild() {
//given
- node = new NodeItem<>("subject");
- val child = new NodeItem("child", node);
+ node = Nodes.unnamedRoot("subject");
+ val child = Nodes.unnamedChild("child", node);
exception.expect(NodeException.class);
exception.expectMessage("Parent is a descendant");
//when
@@ -121,9 +107,9 @@ public class NodeItemTest {
@SuppressWarnings("unchecked")
public void shouldAddNewNodeAsChildToParent() {
//given
- val parent = new NodeItem("parent");
+ val parent = Nodes.unnamedRoot("parent");
//when
- node = new NodeItem<>("subject", parent);
+ node = Nodes.unnamedChild("subject", parent);
//then
assertThat(parent.getChildren()).as(
"when a node is created with a parent, the parent has the new"
@@ -136,8 +122,8 @@ public class NodeItemTest {
@Test
public void shouldReturnSetParent() {
//given
- node = new NodeItem<>("subject");
- val parent = new NodeItem("parent");
+ node = Nodes.unnamedRoot("subject");
+ val parent = Nodes.unnamedRoot("parent");
//when
node.setParent(parent);
//then
@@ -152,7 +138,7 @@ public class NodeItemTest {
@Test
public void shouldThrowNPEWhenSetParentNull() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
exception.expect(NullPointerException.class);
exception.expectMessage("parent");
//when
@@ -166,7 +152,7 @@ public class NodeItemTest {
@Test
public void setParentShouldThrowNodeExceptionWhenParentIsSelf() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
exception.expect(NodeException.class);
exception.expectMessage("Parent is a descendant");
//when
@@ -180,9 +166,9 @@ public class NodeItemTest {
@Test
public void shouldUpdateOldParentWhenNodeSetToNewParent() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
val child = node.createChild("child");
- val newParent = new NodeItem("newParent");
+ val newParent = Nodes.unnamedRoot("newParent");
//when
child.setParent(newParent);
//then
@@ -201,9 +187,9 @@ public class NodeItemTest {
@Test
public void shouldRemoveNodeFromOldParentWhenAddedAsChildToNewParent() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
val child = node.createChild("child");
- val newParent = new NodeItem("newParent");
+ val newParent = Nodes.unnamedRoot("newParent");
//when
newParent.addChild(child);
//then
@@ -223,7 +209,7 @@ public class NodeItemTest {
@Test
public void shouldThrowNPEWhenAddingNullAsChild() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
exception.expect(NullPointerException.class);
exception.expectMessage("child");
//when
@@ -237,8 +223,8 @@ public class NodeItemTest {
@SuppressWarnings("unchecked")
public void shouldReturnAddedChild() {
//given
- node = new NodeItem<>("subject");
- val child = new NodeItem("child");
+ node = Nodes.unnamedRoot("subject");
+ val child = Nodes.unnamedRoot("child");
//when
node.addChild(child);
//then
@@ -253,7 +239,7 @@ public class NodeItemTest {
@Test
public void addChildShouldThrowNodeExceptionWhenAddingANodeAsOwnChild() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
exception.expect(NodeException.class);
exception.expectMessage("Child is an ancestor");
//then
@@ -266,7 +252,7 @@ public class NodeItemTest {
@Test
public void addChildShouldThrowNodeExceptionWhenAddingSelfAsChild() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
exception.expect(NodeException.class);
exception.expectMessage("Child is an ancestor");
//when
@@ -280,8 +266,8 @@ public class NodeItemTest {
@Test
public void addChildShouldThrowNodeExceptionWhenChildIsParent() {
//given
- val parent = new NodeItem("parent");
- node = new NodeItem<>("subject", parent);
+ val parent = Nodes.unnamedRoot("parent");
+ node = Nodes.unnamedChild("subject", parent);
exception.expect(NodeException.class);
exception.expectMessage("Child is an ancestor");
//when
@@ -295,9 +281,9 @@ public class NodeItemTest {
@Test
public void addChildShouldThrowNodeExceptionWhenAddingGrandParentAsChild() {
//given
- val grandParent = new NodeItem("grandparent");
- val parent = new NodeItem("parent", grandParent);
- node = new NodeItem<>("subject", parent);
+ val grandParent = Nodes.unnamedRoot("grandparent");
+ val parent = Nodes.unnamedChild("parent", grandParent);
+ node = Nodes.unnamedChild("subject", parent);
exception.expect(NodeException.class);
exception.expectMessage("Child is an ancestor");
//when
@@ -310,8 +296,8 @@ public class NodeItemTest {
@Test
public void shouldSetParentOnChildWhenAddedAsChild() {
//given
- node = new NodeItem<>("subject");
- val child = new NodeItem("child");
+ node = Nodes.unnamedRoot("subject");
+ val child = Nodes.unnamedRoot("child");
//when
node.addChild(child);
//then
@@ -324,14 +310,15 @@ public class NodeItemTest {
* Test that we can walk a tree to the target node.
*/
@Test
+ @Category(NodeFindInPathTestsCategory.class)
public void shouldWalkTreeToNode() {
//given
val grandparent = "grandparent";
- val grandParentNode = new NodeItem(grandparent);
+ val grandParentNode = Nodes.unnamedRoot(grandparent);
val parent = "parent";
- val parentNode = new NodeItem(parent, grandParentNode);
+ val parentNode = Nodes.unnamedChild(parent, grandParentNode);
val subject = "subject";
- node = new NodeItem<>(subject, parentNode);
+ node = Nodes.unnamedChild(subject, parentNode);
//when
val result = grandParentNode.findInPath(Arrays.asList(parent, subject));
//then
@@ -349,12 +336,13 @@ public class NodeItemTest {
* doesn't exist.
*/
@Test
+ @Category(NodeFindInPathTestsCategory.class)
public void shouldNotFindNonExistentChildNode() {
//given
val parent = "parent";
- val parentNode = new NodeItem(parent);
+ val parentNode = Nodes.unnamedRoot(parent);
val subject = "subject";
- node = new NodeItem<>(subject, parentNode);
+ node = Nodes.unnamedChild(subject, parentNode);
//when
val result = parentNode.findInPath(Arrays.asList(subject, "no child"));
//then
@@ -367,9 +355,10 @@ public class NodeItemTest {
* Test that when we pass null we get an exception.
*/
@Test
+ @Category(NodeFindInPathTestsCategory.class)
public void shouldThrowNEWhenWalkTreeNull() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
exception.expect(NullPointerException.class);
exception.expectMessage("path");
//when
@@ -381,9 +370,10 @@ public class NodeItemTest {
* a result.
*/
@Test
+ @Category(NodeFindInPathTestsCategory.class)
public void shouldReturnEmptyForEmptyWalkTreePath() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
//when
val result = node.findInPath(Collections.emptyList());
//then
@@ -396,7 +386,7 @@ public class NodeItemTest {
@Test
public void shouldCreateDescendantNodes() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
val alphaData = "alpha";
val betaData = "beta";
val gammaData = "gamma";
@@ -445,7 +435,7 @@ public class NodeItemTest {
@Test
public void createDescendantLineShouldThrowNPEWhenDescendantsAreNull() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
exception.expect(NullPointerException.class);
exception.expectMessage("descendants");
//when
@@ -458,7 +448,7 @@ public class NodeItemTest {
@Test
public void shouldChangeNothingWhenCreateDescendantEmpty() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
//when
node.createDescendantLine(Collections.emptyList());
//then
@@ -473,9 +463,9 @@ public class NodeItemTest {
@Test
public void shouldFindExistingChildNode() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
val childData = "child";
- val child = new NodeItem(childData, node);
+ val child = Nodes.unnamedChild(childData, node);
//when
val found = node.findOrCreateChild(childData);
//then
@@ -490,7 +480,7 @@ public class NodeItemTest {
@Test
public void shouldFindCreateNewChildNode() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
val childData = "child";
//when
val found = node.findOrCreateChild(childData);
@@ -506,7 +496,7 @@ public class NodeItemTest {
@Test
public void findOrCreateChildShouldThrowNPEFWhenChildIsNull() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
exception.expect(NullPointerException.class);
exception.expectMessage("child");
//when
@@ -519,9 +509,9 @@ public class NodeItemTest {
@Test
public void shouldGetChild() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
val childData = "child";
- val child = new NodeItem(childData);
+ val child = Nodes.unnamedRoot(childData);
node.addChild(child);
//when
val found = node.findChild(childData);
@@ -541,7 +531,7 @@ public class NodeItemTest {
@Test
public void getChildShouldThrowNPEWhenThereIsNoChild() {
//given
- node = new NodeItem<>("data");
+ node = Nodes.unnamedRoot("data");
exception.expect(NullPointerException.class);
exception.expectMessage("child");
//when
@@ -555,7 +545,7 @@ public class NodeItemTest {
@Test
public void shouldCreateChild() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
val childData = "child";
//when
val child = node.createChild(childData);
@@ -580,82 +570,25 @@ public class NodeItemTest {
@Test
public void createChildShouldThrowNPEWhenChildIsNull() {
//given
- node = new NodeItem<>("subject");
+ node = Nodes.unnamedRoot("subject");
exception.expect(NullPointerException.class);
exception.expectMessage("child");
//when
node.createChild(null);
}
- @Test
- public void getNameShouldBeCorrect() {
- //given
- node = new NodeItem<>("subject", n -> n.getData().get());
- //then
- assertThat(node.getName()).isEqualTo("subject");
- }
-
- @Test
- public void getNameShouldUseParentNameSupplier() {
- //given
- val root = new NodeItem("root", n -> n.getData().get());
- node = new NodeItem<>("child", root);
- //then
- assertThat(node.getName()).isEqualTo("child");
- }
-
- @Test
- public void getNameShouldReturnNameForNonStringData() {
- val root = new NodeItem(LocalDate.parse("2016-05-23"), n -> {
- if (n.isEmpty()) {
- return null;
- }
- return n.getData().get().format(DateTimeFormatter.BASIC_ISO_DATE);
-
- });
- //then
- assertThat(root.getName()).isEqualTo("20160523");
- }
-
- @Test
- public void getNameShouldUseClosestNameSupplier() {
- node = new NodeItem<>("root", n -> n.getData().get());
- val child = new NodeItem("child", Object::toString);
- node.addChild(child);
- val grandChild = new NodeItem<>("grandchild", child);
- //then
- assertThat(node.getName()).isEqualTo("root");
- assertThat(child.getName()).isNotEqualTo("child");
- assertThat(grandChild.getName()).isNotEqualTo("grandchild");
- }
-
- @Test
- public void getNameShouldWorkWithoutNameSupplier() {
- node = new NodeItem<>(null, "root");
- val namedchild = new NodeItem<>("named", "Alice", node);
- //then
- assertThat(node.getName()).isEqualTo("root");
- assertThat(namedchild.getName()).isEqualTo("Alice");
- }
-
@Test
public void canCreateRootNodeWithoutData() {
- node = new NodeItem<>(null, "empty");
- assertThat(node.getData()).isEmpty();
- }
-
- @Test
- public void canCreateRootNodeWithoutDataButWithNameSupplier() {
- node = new NodeItem<>(null);
+ node = Nodes.namedRoot(null, "empty");
assertThat(node.getData()).isEmpty();
}
@Test
public void getChildNamedFindsChild() {
//given
- node = new NodeItem<>(null, "root");
- val alpha = new NodeItem(null, "alpha");
- val beta = new NodeItem(null, "beta");
+ node = Nodes.namedRoot("root data", "root");
+ val alpha = Nodes.namedRoot("alpha data", "alpha");
+ val beta = Nodes.namedRoot("beta data", "beta");
node.addChild(alpha);
node.addChild(beta);
//when
@@ -667,9 +600,9 @@ public class NodeItemTest {
@Test
public void getChildNamedFindsNothing() {
//given
- node = new NodeItem<>(null, "root");
- val alpha = new NodeItem(null, "alpha");
- val beta = new NodeItem(null, "beta");
+ node = Nodes.namedRoot("root data", "root");
+ val alpha = Nodes.namedRoot("alpha data", "alpha");
+ val beta = Nodes.namedRoot("beta data", "beta");
node.addChild(alpha);
node.addChild(beta);
exception.expect(NodeException.class);
@@ -681,10 +614,10 @@ public class NodeItemTest {
@Test
public void nodeNamesAreUniqueWithinAParent() {
//given
- node = new NodeItem<>(null, "root");
- val alpha = new NodeItem(null, "alpha");
+ node = Nodes.namedRoot("root data", "root");
+ val alpha = Nodes.namedRoot("alpha data", "alpha");
node.addChild(alpha);
- val beta = new NodeItem(null, "alpha");
+ val beta = Nodes.namedRoot("beta data", "alpha");
exception.expect(NodeException.class);
exception.expectMessage("Node with that name already exists here");
//when
@@ -694,8 +627,8 @@ public class NodeItemTest {
@Test
public void canPlaceNodeInTreeByPathNames() {
//given
- node = new NodeItem<>(null, "root"); // create a root
- val four = new NodeItem("data", "four");
+ node = Nodes.namedRoot("root data", "root"); // create a root
+ val four = Nodes.namedRoot("data", "four");
//when
node.insertInPath(four, "one", "two", "three");
//then
@@ -717,9 +650,9 @@ public class NodeItemTest {
@SuppressWarnings("unchecked")
public void canPlaceInTreeUnderExistingNode() {
//given
- node = new NodeItem<>(null, "root");
- val child = new NodeItem("child data", "child");
- val grandchild = new NodeItem("grandchild data", "grandchild");
+ node = Nodes.namedRoot(null, "root");
+ val child = Nodes.namedRoot("child data", "child");
+ val grandchild = Nodes.namedRoot("grandchild data", "grandchild");
//when
node.insertInPath(child); // as root/child
node.insertInPath(grandchild, "child"); // as root/child/grandchild
@@ -734,9 +667,9 @@ public class NodeItemTest {
@SuppressWarnings("unchecked")
public void canPlaceInTreeAboveExistingNode() {
//given
- node = new NodeItem<>(null, "root");
- val child = new NodeItem("child data", "child");
- val grandchild = new NodeItem("grandchild data", "grandchild");
+ node = Nodes.namedRoot(null, "root");
+ val child = Nodes.namedRoot("child data", "child");
+ val grandchild = Nodes.namedRoot("grandchild data", "grandchild");
//when
node.insertInPath(grandchild, "child");
node.insertInPath(child);
@@ -752,7 +685,7 @@ public class NodeItemTest {
@Test
public void removingParentFromNodeWithNoParentIsNoop() {
//given
- node = new NodeItem<>(null);
+ node = Nodes.unnamedRoot(null);
//when
node.removeParent();
}
@@ -760,8 +693,8 @@ public class NodeItemTest {
@Test
public void removingParentFromNodeWithParentRemovesParent() {
//given
- node = new NodeItem<>(null);
- val child = new NodeItem(null, node);
+ node = Nodes.unnamedRoot(null);
+ val child = Nodes.unnamedChild("child data", node);
//when
child.removeParent();
//then
@@ -775,22 +708,22 @@ public class NodeItemTest {
exception.expect(NodeException.class);
exception.expectMessage(
"A non-empty node named 'grandchild' already exists here");
- node = new NodeItem<>(null);
- val child = new NodeItem(null, "child", node);
- new NodeItem<>("data", "grandchild", child);
+ node = Nodes.unnamedRoot(null);
+ val child = Nodes.namedChild("child data", "child", node);
+ Nodes.namedChild("data", "grandchild", child);
// root -> child -> grandchild
// only grandchild has data
//when
// attempt to add another node called 'grandchild' to 'child'
- node.insertInPath(new NodeItem<>("cuckoo", "grandchild"), "child");
+ node.insertInPath(Nodes.namedRoot("cuckoo", "grandchild"), "child");
}
@Test
@SuppressWarnings("unchecked")
public void placeNodeInTreeWhenAddedNodeIsUnnamed() {
//given
- node = new NodeItem<>(null);
- final Node newNode = new NodeItem<>(null);
+ node = Nodes.unnamedRoot(null);
+ final Node newNode = Nodes.unnamedRoot(null);
//when
node.insertInPath(newNode);
//then
@@ -801,12 +734,12 @@ public class NodeItemTest {
@SuppressWarnings("unchecked")
public void placeNodeInTreeWhenEmptyChildWithTargetNameExists() {
//given
- node = new NodeItem<>(null);
- final NodeItem child = new NodeItem<>(null, "child");
- final NodeItem target = new NodeItem<>(null, "target");
+ node = Nodes.unnamedRoot(null);
+ final Node child = Nodes.namedRoot(null, "child");
+ final Node target = Nodes.namedRoot(null, "target");
node.addChild(child);
child.addChild(target);
- final NodeItem addMe = new NodeItem<>("I'm new", "target");
+ val addMe = Nodes.namedRoot("I'm new", "target");
assertThat(addMe.getParent()).isEmpty();
assertThat(child.getChildByName("target").isEmpty()).as(
"target starts empty").isTrue();
@@ -823,7 +756,7 @@ public class NodeItemTest {
//given
exception.expect(NullPointerException.class);
exception.expectMessage("name");
- node = new NodeItem<>(null);
+ node = Nodes.unnamedRoot(null);
//when
node.findChildByName(null);
}
@@ -831,7 +764,7 @@ public class NodeItemTest {
@Test
public void isNamedNull() {
//given
- node = new NodeItem<>(null);
+ node = Nodes.unnamedRoot(null);
//then
assertThat(node.isNamed()).isFalse();
}
@@ -839,7 +772,7 @@ public class NodeItemTest {
@Test
public void isNamedEmpty() {
//given
- node = new NodeItem<>(null, "");
+ node = Nodes.namedRoot(null, "");
//then
assertThat(node.isNamed()).isFalse();
}
@@ -847,32 +780,16 @@ public class NodeItemTest {
@Test
public void isNamedNamed() {
//given
- node = new NodeItem<>(null, "named");
+ node = Nodes.namedRoot(null, "named");
//then
assertThat(node.isNamed()).isTrue();
}
- @Test
- public void removeParentNodeProvidesSameNameSupplier() {
- // once a node has it's parent removed it should provide a default name
- // provider
- //given
- node = new NodeItem<>("data", n -> n.getData().get());
- final NodeItem child = new NodeItem<>("other", node);
- assertThat(node.getName()).as("initial root name").isEqualTo("data");
- assertThat(child.getName()).as("initial child name").isEqualTo("other");
- //when
- child.removeParent();
- //then
- assertThat(node.getName()).as("final root name").isEqualTo("data");
- assertThat(child.getName()).as("final child name").isEqualTo("other");
- }
-
@Test
@SuppressWarnings("unchecked")
public void removeChildRemovesTheChild() {
//given
- node = new NodeItem<>(null);
+ node = Nodes.unnamedRoot(null);
Node child = node.createChild("child");
assertThat(node.getChildren()).containsExactly(child);
//then
@@ -885,13 +802,14 @@ public class NodeItemTest {
@Test
public void drawTreeIsCorrect() {
//given
- node = new NodeItem<>(null, "root");
- val bob = new NodeItem(null, "bob", node);
- val alice = new NodeItem(null, "alice", node);
- new NodeItem<>(null, "dave", alice);
- new NodeItem<>(null, bob); // has no name and no children so no included
- val kim = new NodeItem(null, node); // nameless mother
- new NodeItem<>(null, "lucy", kim);
+ node = Nodes.namedRoot(null, "root");
+ val bob = Nodes.namedChild("bob data", "bob", node);
+ val alice = Nodes.namedChild("alice data", "alice", node);
+ Nodes.namedChild("dave data", "dave", alice);
+ Nodes.unnamedChild("bob's child's data",
+ bob); // has no name and no children so no included
+ val kim = Nodes.unnamedChild("kim data", node); // nameless mother
+ Nodes.namedChild("lucy data", "lucy", kim);
//when
val tree = node.drawTree(0);
//then
@@ -907,7 +825,7 @@ public class NodeItemTest {
@Test
public void canChangeNodeData() {
//given
- node = new NodeItem<>("initial");
+ node = Nodes.unnamedRoot("initial");
//when
node.setData("updated");
//then
@@ -918,7 +836,7 @@ public class NodeItemTest {
@SuppressWarnings("unchecked")
public void canCreateNamedChild() {
//given
- node = new NodeItem<>(null);
+ node = Nodes.unnamedRoot(null);
//when
Node child = node.createChild("child data", "child name");
//then
@@ -930,10 +848,10 @@ public class NodeItemTest {
@Test
public void canGetChildWhenFound() {
//given
- node = new NodeItem<>("data");
- Node child = new NodeItem<>("child data", "child name", node);
+ node = Nodes.unnamedRoot("data");
+ val child = Nodes.namedChild("child data", "child name", node);
//when
- Node found = node.getChild("child data");
+ val found = node.getChild("child data");
//then
assertThat(found).isSameAs(child);
}
@@ -943,7 +861,7 @@ public class NodeItemTest {
//given
exception.expect(NodeException.class);
exception.expectMessage("Child not found");
- node = new NodeItem<>("data");
+ node = Nodes.unnamedRoot("data");
//when
node.getChild("child data");
}
@@ -952,99 +870,19 @@ public class NodeItemTest {
@SuppressWarnings("unchecked")
public void constructorWithNameSupplierAndParentBeChildOfParent() {
//given
- node = new NodeItem<>(null);
+ node = Nodes.unnamedRoot(null);
//when
- NodeItem child = new NodeItem<>(null, node);
+ val child = Nodes.unnamedChild("child data", node);
//then
assertThat(child.getParent()).contains(node);
assertThat(node.getChildren()).containsExactly(child);
}
- @Test
- @SuppressWarnings("unchecked")
- public void removeParentCopiesRootNameSupplier() {
- //given
- node = new NodeItem<>("root data", n -> "root supplier");
- val child = new NodeItem<>("child data", node);
- assertThat(child.getName()).isEqualTo("root supplier");
- //when
- child.removeParent();
- //then
- assertThat(child.getName()).isEqualTo("root supplier");
- }
-
- @Test
- @SuppressWarnings("unchecked")
- public void removeParentDoesNotReplaceLocalNameSupplier() {
- //given
- node = new NodeItem<>("root data", n -> "root supplier");
- val child = new NodeItem<>("child data", n -> "local supplier", node);
- assertThat(child.getName()).isEqualTo("local supplier");
- //when
- child.removeParent();
- //then
- assertThat(child.getName()).isEqualTo("local supplier");
- }
-
- @Test
- public void setNameToNullRevertsToParentNameSupplier() {
- //given
- node = new NodeItem<>(null, n -> "root supplier");
- val child = new NodeItem(null, "child name", node);
- assertThat(child.getName()).isEqualTo("child name");
- //when
- child.setName(null);
- //then
- assertThat(child.getName()).isEqualTo("root supplier");
- }
-
- @Test
- public void getNameWithNameSupplierIsRecalculatedEachCall() {
- val counter = new AtomicInteger(0);
- node = new NodeItem<>(null,
- n -> Integer.toString(counter.incrementAndGet()));
- //then
- assertThat(node.getName()).isNotEqualTo(node.getName());
- }
-
- @Test
- public void isNamedWithNameSupplierIsRecalculatedEachCall() {
- val counter = new AtomicInteger(0);
- node = new NodeItem<>(null, n -> {
- // alternate between even numbers and nulls: null, 2, null, 4, null
- final int i = counter.incrementAndGet();
- if (i % 2 == 0) {
- return Integer.toString(i);
- }
- return null;
- });
- //then
- assertThat(node.isNamed()).isFalse();
- assertThat(node.isNamed()).isTrue();
- }
-
- @Test
- public void canUseNameSupplierToBuildFullPath() {
- //given
- final Function, String> pathNameSupplier = node -> {
- Optional> parent = node.getParent();
- if (parent.isPresent()) {
- return parent.get().getName() + "/" + node.getData().get();
- }
- return "";
- };
- node = new NodeItem<>(null, pathNameSupplier);
- val child = new NodeItem("child", node);
- val grandchild = new NodeItem("grandchild", child);
- //then
- assertThat(grandchild.getName()).isEqualTo("/child/grandchild");
- }
-
@Test
public void canSafelyHandleFindChildWhenAChildHasNoData() {
//given
- node = new NodeItem<>(null);
- new NodeItem<>(null, node);
+ node = Nodes.unnamedRoot(null);
+ Nodes.unnamedChild(null, node);
//when
node.findChild("data");
}
diff --git a/src/test/java/net/kemitix/node/NodesTest.java b/src/test/java/net/kemitix/node/NodesTest.java
new file mode 100644
index 0000000..ace4f79
--- /dev/null
+++ b/src/test/java/net/kemitix/node/NodesTest.java
@@ -0,0 +1,62 @@
+package net.kemitix.node;
+
+import lombok.val;
+import org.assertj.core.api.SoftAssertions;
+import org.junit.Test;
+
+import static net.trajano.commons.testing.UtilityClassTestUtil
+ .assertUtilityClassWellDefined;
+
+/**
+ * Tests for {@link Nodes}.
+ *
+ * @author pcampbell
+ */
+public class NodesTest {
+
+ @Test
+ public void shouldBeValidUtilityClass() throws Exception {
+ assertUtilityClassWellDefined(Nodes.class);
+ }
+
+ @Test
+ public void shouldCreateUnnamedRoot() throws Exception {
+ val node = Nodes.unnamedRoot("data");
+ SoftAssertions softly = new SoftAssertions();
+ softly.assertThat(node.getData()).contains("data");
+ softly.assertThat(node.getName()).isNull();
+ softly.assertAll();
+ }
+
+ @Test
+ public void shouldCreateNamedRoot() throws Exception {
+ val node = Nodes.namedRoot("data", "name");
+ SoftAssertions softly = new SoftAssertions();
+ softly.assertThat(node.getData()).contains("data");
+ softly.assertThat(node.getName()).isEqualTo("name");
+ softly.assertAll();
+ }
+
+ @Test
+ public void shouldCreateUnnamedChild() throws Exception {
+ val parent = Nodes.unnamedRoot("root");
+ val node = Nodes.unnamedChild("data", parent);
+ SoftAssertions softly = new SoftAssertions();
+ softly.assertThat(node.getData()).contains("data");
+ softly.assertThat(node.getName()).isNull();
+ softly.assertThat(node.getParent()).contains(parent);
+ softly.assertAll();
+ }
+
+ @Test
+ public void shouldCreateNamedChild() throws Exception {
+ val parent = Nodes.unnamedRoot("root");
+ val node = Nodes.namedChild("data", "child", parent);
+ SoftAssertions softly = new SoftAssertions();
+ softly.assertThat(node.getData()).contains("data");
+ softly.assertThat(node.getName()).isEqualTo("child");
+ softly.assertThat(node.getParent()).contains(parent);
+ softly.assertAll();
+ }
+
+}