Added tests for MaterialFX TreeView (Run with IntelliJ not Gradle)

Changed getItemsCount to use 'this'

Signed-off-by: PAlex404 <alessandro.parisi406@gmail.com>

.gitignore

@@ -11,5 +11,4 @@ out/
 
 # Others
 demo/src/main/java/io/github/palexdev/materialfx/demo/TestDemo.java
-demo/src/test
 materialfx/src/test

demo/build.gradle

@@ -9,6 +9,10 @@ repositories {
 }
 
 dependencies {
+    testCompile "org.testfx:testfx-core:4.0.16-alpha"
+    testCompile "junit:junit:4.13-beta-3"
+    testCompile "org.testfx:testfx-junit:4.0.16-alpha"
+
     implementation "fr.brouillard.oss:cssfx:11.4.0"
     implementation 'org.kordamp.ikonli:ikonli-core:11.5.0'
     implementation 'org.kordamp.ikonli:ikonli-javafx:11.5.0'

demo/src/test/java/treeview/TreeViewTests.java

@@ -0,0 +1,268 @@
+package treeview;
+
+import io.github.palexdev.materialfx.controls.TreeItem;
+import io.github.palexdev.materialfx.controls.TreeView;
+import io.github.palexdev.materialfx.controls.base.AbstractTreeItem;
+import io.github.palexdev.materialfx.utils.TreeItemStream;
+import javafx.scene.Scene;
+import javafx.scene.layout.StackPane;
+import javafx.stage.Stage;
+import org.junit.Test;
+import org.testfx.framework.junit.ApplicationTest;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+public class TreeViewTests extends ApplicationTest {
+    private final String desktopPath = System.getProperty("user.home") + "/Desktop";
+    private TreeView<String> treeView;
+    private TreeView<String> complexTreeView;
+
+    @Override
+    public void start(Stage stage) {
+        buildTreeViews();
+        Scene scene = new Scene(new StackPane(treeView, complexTreeView), 100, 100);
+        stage.setScene(scene);
+        stage.show();
+        stage.toBack();
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    @Test
+    public void testItemsCountRoot() {
+        long start = System.nanoTime();
+        AbstractTreeItem<String> root = treeView.getRoot();
+
+        long count = root.getItemsCount();
+        assertEquals(12, count);
+
+        AbstractTreeItem<String> i1 = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I1"))
+                .findFirst().orElse(null);
+        count = i1.getItemsCount();
+        assertEquals(4, count);
+        long end = System.nanoTime();
+        System.out.println("TimeCountRoot:" + ((double) (end - start) / 1000000) + "ms");
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    @Test
+    public void testItemsCountItem() {
+        long start = System.nanoTime();
+        AbstractTreeItem<String> root = treeView.getRoot();
+        AbstractTreeItem<String> i3 = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I3"))
+                .findFirst().orElse(null);
+        long count = i3.getItemsCount();
+        assertEquals(3, count);
+        long end = System.nanoTime();
+        System.out.println("TimeCountItem:" + ((double) (end - start) / 1000000) + "ms");
+    }
+
+    @Test
+    public void testItemCountComplex() throws IOException {
+        long start = System.nanoTime();
+        AbstractTreeItem<String> root = complexTreeView.getRoot();
+        long expectedCount = fileCount();
+        long count = root.getItemsCount();
+        assertEquals(expectedCount, count);
+        long end = System.nanoTime();
+        System.out.println("TimeCountComplex:" + ((double) (end - start) / 1000000) + "ms");
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    @Test
+    public void testItemIndex() {
+        long start = System.nanoTime();
+        AbstractTreeItem<String> root = treeView.getRoot();
+        AbstractTreeItem<String> i1 = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I1"))
+                .findFirst().orElse(null);
+        AbstractTreeItem<String> i1b = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I1B"))
+                .findFirst().orElse(null);
+        AbstractTreeItem<String> i2a = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I2A"))
+                .findFirst().orElse(null);
+        AbstractTreeItem<String> i4a = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I4A"))
+                .findFirst().orElse(null);
+
+        assertEquals(0, root.getIndex());
+        assertEquals(1, i1.getIndex());
+        assertEquals(4, i1b.getIndex());
+        assertEquals(6, i2a.getIndex());
+        assertEquals(11, i4a.getIndex());
+        long end = System.nanoTime();
+        System.out.println("TimeIndex:" + ((double) (end - start) / 1000000) + "ms");
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    @Test
+    public void testItemLevel() {
+        long start = System.nanoTime();
+        AbstractTreeItem<String> root = treeView.getRoot();
+        AbstractTreeItem<String> i1 = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I1"))
+                .findFirst().orElse(null);
+        AbstractTreeItem<String> i1b = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I1B"))
+                .findFirst().orElse(null);
+        AbstractTreeItem<String> i2a = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I2A"))
+                .findFirst().orElse(null);
+        AbstractTreeItem<String> i11a = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I11A"))
+                .findFirst().orElse(null);
+
+        assertEquals(0, root.getLevel());
+        assertEquals(1, i1.getLevel());
+        assertEquals(2, i1b.getLevel());
+        assertEquals(2, i2a.getLevel());
+        assertEquals(3, i11a.getLevel());
+        long end = System.nanoTime();
+        System.out.println("TimeLevel:" + ((double) (end - start) / 1000000) + "ms");
+    }
+
+    @Test
+    public void testTreeViewGet() {
+        long start = System.nanoTime();
+        AbstractTreeItem<String> root = treeView.getRoot();
+        AbstractTreeItem<String> complexRoot = complexTreeView.getRoot();
+
+        TreeItemStream.stream(root).forEach(item -> assertEquals(treeView, item.getTreeView()));
+        TreeItemStream.stream(complexRoot).forEach(item -> assertEquals(complexTreeView, item.getTreeView()));
+        long end = System.nanoTime();
+        System.out.println("TimeTreeViewGet:" + ((double) (end - start) / 1000000) + "ms");
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    @Test
+    public void testNextSiblings() {
+        long start = System.nanoTime();
+        AbstractTreeItem<String> root = treeView.getRoot();
+        AbstractTreeItem<String> i1 = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I1"))
+                .findFirst().orElse(null);
+        AbstractTreeItem<String> i1b = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I1B"))
+                .findFirst().orElse(null);
+        AbstractTreeItem<String> i2a = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I2A"))
+                .findFirst().orElse(null);
+        AbstractTreeItem<String> i3a = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I3A"))
+                .findFirst().orElse(null);
+        AbstractTreeItem<String> i4 = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I4"))
+                .findFirst().orElse(null);
+
+        assertNull(root.getNextSibling());
+        assertEquals("I2", i1.getNextSibling().getData());
+        assertNull(i1b.getNextSibling());
+        assertNull(i2a.getNextSibling());
+        assertEquals("I3B", i3a.getNextSibling().getData());
+        assertNull(i4.getNextSibling());
+        long end = System.nanoTime();
+        System.out.println("TimeNextSiblings:" + ((double) (end - start) / 1000000) + "ms");
+    }
+
+    @SuppressWarnings("ConstantConditions")
+    @Test
+    public void testPreviousSiblings() {
+        long start = System.nanoTime();
+        AbstractTreeItem<String> root = treeView.getRoot();
+        AbstractTreeItem<String> i1 = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I1"))
+                .findFirst().orElse(null);
+        AbstractTreeItem<String> i1b = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I1B"))
+                .findFirst().orElse(null);
+        AbstractTreeItem<String> i2a = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I2A"))
+                .findFirst().orElse(null);
+        AbstractTreeItem<String> i3a = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I3A"))
+                .findFirst().orElse(null);
+        AbstractTreeItem<String> i4 = TreeItemStream.stream(root)
+                .filter(i -> i.getData().equals("I4"))
+                .findFirst().orElse(null);
+
+        assertNull(root.getPreviousSibling());
+        assertNull(i1.getPreviousSibling());
+        assertEquals("I1A", i1b.getPreviousSibling().getData());
+        assertNull(i2a.getPreviousSibling());
+        assertNull(i3a.getPreviousSibling());
+        assertEquals("I3", i4.getPreviousSibling().getData());
+        long end = System.nanoTime();
+        System.out.println("TimePreviousSiblings:" + ((double) (end - start) / 1000000) + "ms");
+    }
+
+    //================================================================================
+    // OTHER METHODS
+    //================================================================================
+    private void createTree(File file, TreeItem<String> parent) {
+        if (file.isDirectory()) {
+            TreeItem<String> treeItem = new TreeItem<>(file.getName());
+            parent.getItems().add(treeItem);
+            File[] fileList = file.listFiles();
+            if (fileList != null) {
+                for (File f : fileList) {
+                    createTree(f, treeItem);
+                }
+            }
+        } else {
+            parent.getItems().add(new TreeItem<>(file.getName()));
+        }
+    }
+
+    private long fileCount() throws IOException {
+        return Files.walk(Paths.get(desktopPath).toAbsolutePath())
+                .parallel()
+                .count();
+    }
+
+    private void buildTreeViews() {
+        TreeItem<String> root = new TreeItem<>("ROOT");
+        TreeItem<String> i1 = new TreeItem<>("I1");
+        TreeItem<String> i1a = new TreeItem<>("I1A");
+        i1a.getItems().add(new TreeItem<>("I11A"));
+
+        TreeItem<String> i1b = new TreeItem<>("I1B");
+        i1.getItems().addAll(List.of(i1a, i1b));
+
+        TreeItem<String> i2 = new TreeItem<>("I2");
+        TreeItem<String> i2a = new TreeItem<>("I2A");
+        i2.getItems().add(i2a);
+
+        TreeItem<String> i3 = new TreeItem<>("I3");
+        TreeItem<String> i3a = new TreeItem<>("I3A");
+        TreeItem<String> i3b = new TreeItem<>("I3B");
+        i3.getItems().addAll(List.of(i3a, i3b));
+
+        TreeItem<String> i4 = new TreeItem<>("I4");
+        TreeItem<String> i4a = new TreeItem<>("I4A");
+        i4.getItems().add(i4a);
+
+        root.getItems().addAll(List.of(i1, i2, i3, i4));
+        treeView = new TreeView<>(root);
+
+
+        Path dir = Paths.get(desktopPath).toAbsolutePath();
+        TreeItem<String> complexRoot = new TreeItem<>(desktopPath);
+        File[] fileList = dir.toFile().listFiles();
+        if (fileList != null) {
+            for (File file : fileList) {
+                createTree(file, complexRoot);
+            }
+        }
+        complexTreeView = new TreeView<>(complexRoot);
+    }
+}

materialfx/src/main/java/io/github/palexdev/materialfx/controls/base/AbstractTreeItem.java

@@ -58,8 +58,8 @@ public abstract class AbstractTreeItem<T> extends Control {
                 .count();
     }
 
-    public long getItemsCount(AbstractTreeItem<T> item) {
-        return TreeItemStream.stream(item).count();
+    public long getItemsCount() {
+        return TreeItemStream.stream(this).count();
     }
 
     public int getLevel() {
@@ -78,6 +78,32 @@ public abstract class AbstractTreeItem<T> extends Control {
         }
     }
 
+    public AbstractTreeItem<T> getNextSibling() {
+        if (isRoot()) {
+            return null;
+        }
+
+        List<AbstractTreeItem<T>> parentItems = getItemParent().getItems();
+        int index = parentItems.indexOf(this);
+        if (index == parentItems.size() - 1) {
+            return null;
+        }
+        return parentItems.get(index + 1);
+    }
+
+    public AbstractTreeItem<T> getPreviousSibling() {
+        if (isRoot()) {
+            return null;
+        }
+
+        List<AbstractTreeItem<T>> parentItems = getItemParent().getItems();
+        int index = parentItems.indexOf(this);
+        if (index == 0) {
+            return null;
+        }
+        return parentItems.get(index - 1);
+    }
+
     public TreeView<T> getTreeView() {
         if (isRoot()) {
             if (treeView != null) return treeView;

materialfx/src/main/java/io/github/palexdev/materialfx/utils/TreeItemIterator.java

@@ -8,8 +8,8 @@ import java.util.Stack;
 public class TreeItemIterator<T> implements Iterator<AbstractTreeItem<T>> {
     private final Stack<AbstractTreeItem<T>> stack = new Stack<>();
 
-    public TreeItemIterator(AbstractTreeItem<T> root) {
-        stack.push(root);
+    public TreeItemIterator(AbstractTreeItem<T> item) {
+        stack.push(item);
     }
 
     @Override

materialfx/src/main/java/io/github/palexdev/materialfx/utils/TreeItemStream.java

@@ -6,8 +6,8 @@ import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
 public class TreeItemStream {
-    public static <T> Stream<AbstractTreeItem<T>> stream(AbstractTreeItem<T> rootItem) {
-        return asStream(new TreeItemIterator<>(rootItem));
+    public static <T> Stream<AbstractTreeItem<T>> stream(AbstractTreeItem<T> item) {
+        return asStream(new TreeItemIterator<>(item));
     }
 
     private static <T> Stream<AbstractTreeItem<T>> asStream(TreeItemIterator<T> iterator) {
@@ -19,10 +19,10 @@ public class TreeItemStream {
         );
     }
 
-    public static <T> Stream<AbstractTreeItem<T>> flattenTree(final AbstractTreeItem<T> root) {
+    public static <T> Stream<AbstractTreeItem<T>> flattenTree(final AbstractTreeItem<T> item) {
         return Stream.concat(
-                Stream.of(root),
-                root.getItems().stream().flatMap(TreeItemStream::flattenTree)
+                Stream.of(item),
+                item.getItems().stream().flatMap(TreeItemStream::flattenTree)
         );
     }
 }