Skip to content

Commit

Permalink
Added tests for MaterialFX TreeView (Run with IntelliJ not Gradle)
Browse files Browse the repository at this point in the history 
Changed getItemsCount to use 'this'

Signed-off-by: PAlex404 <[email protected]>
  • Loading branch information
@palexdev
palexdev committed Jan 25, 2021
1 parent 5f71369 commit 0ec4517
Show file tree
Hide file tree
Showing 6 changed files with 307 additions and 10 deletions.
1 change: 0 additions & 1 deletion .gitignore
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,5 +11,4 @@ out/

# Others
demo/src/main/java/io/github/palexdev/materialfx/demo/TestDemo.java
demo/src/test
materialfx/src/test
4 changes: 4 additions & 0 deletions demo/build.gradle
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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'
Expand Down
268 changes: 268 additions & 0 deletions demo/src/test/java/treeview/TreeViewTests.java
View file
Original file line number Diff line number Diff line change
@@ -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);
}
}
30 changes: 28 additions & 2 deletions materialfx/src/main/java/io/github/palexdev/materialfx/controls/base/AbstractTreeItem.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -58,8 +58,8 @@ public long getIndex() {
.count();
}

public long getItemsCount(AbstractTreeItem<T> item) {
return TreeItemStream.stream(item).count();
public long getItemsCount() {
return TreeItemStream.stream(this).count();
}

public int getLevel() {
Expand All @@ -78,6 +78,32 @@ public int getLevel() {
}
}

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;
Expand Down
4 changes: 2 additions & 2 deletions materialfx/src/main/java/io/github/palexdev/materialfx/utils/TreeItemIterator.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,8 +8,8 @@
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
Expand Down
10 changes: 5 additions & 5 deletions materialfx/src/main/java/io/github/palexdev/materialfx/utils/TreeItemStream.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,8 +6,8 @@
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) {
Expand All @@ -19,10 +19,10 @@ private static <T> Stream<AbstractTreeItem<T>> asStream(TreeItemIterator<T> iter
);
}

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)
);
}
}

0 comments on commit 0ec4517

Please sign in to comment.