From efa7f5a4d069556061ba4ceef4fb4d76dae84ef4 Mon Sep 17 00:00:00 2001 From: Aleksi Hietanen Date: Tue, 16 May 2017 11:57:02 +0300 Subject: Refactor common methods in in-memory data providers (#9308) * Refactor common methods of InMemoryHierarchicalDataProvider and ListDataProvider to a single interface * Rename HierarchyData and InMemoryHierarchicalDataProvider, introduce HasHierarchicalDataProvider * Additionally adds a helper method for recursive constructing TreeData with a child item provider. --- .../InMemoryHierarchicalDataProviderTest.java | 278 ------------------- .../vaadin/data/provider/TreeDataProviderTest.java | 297 +++++++++++++++++++++ .../java/com/vaadin/tests/components/TreeTest.java | 14 +- .../tests/components/treegrid/TreeGridTest.java | 14 +- .../tests/server/ClassesSerializableTest.java | 1 + .../treegrid/TreeGridDeclarativeTest.java | 8 +- 6 files changed, 316 insertions(+), 296 deletions(-) delete mode 100644 server/src/test/java/com/vaadin/data/provider/InMemoryHierarchicalDataProviderTest.java create mode 100644 server/src/test/java/com/vaadin/data/provider/TreeDataProviderTest.java (limited to 'server/src/test') diff --git a/server/src/test/java/com/vaadin/data/provider/InMemoryHierarchicalDataProviderTest.java b/server/src/test/java/com/vaadin/data/provider/InMemoryHierarchicalDataProviderTest.java deleted file mode 100644 index 99b7a04b19..0000000000 --- a/server/src/test/java/com/vaadin/data/provider/InMemoryHierarchicalDataProviderTest.java +++ /dev/null @@ -1,278 +0,0 @@ -package com.vaadin.data.provider; - -import java.util.ArrayList; -import java.util.Comparator; -import java.util.List; -import java.util.stream.Collectors; - -import org.junit.Assert; -import org.junit.Test; - -import com.vaadin.data.HierarchyData; -import com.vaadin.server.SerializablePredicate; - -public class InMemoryHierarchicalDataProviderTest extends - DataProviderTestBase> { - - private HierarchyData data; - private List flattenedData; - private List rootData; - - @Override - public void setUp() { - List randomBeans = StrBean.generateRandomBeans(20); - flattenedData = new ArrayList<>(); - rootData = new ArrayList<>(); - - data = new HierarchyData<>(); - data.addItems(null, randomBeans.subList(0, 5)); - data.addItems(randomBeans.get(0), randomBeans.subList(5, 10)); - data.addItems(randomBeans.get(5), randomBeans.subList(10, 15)); - data.addItems(null, randomBeans.subList(15, 20)); - - flattenedData.add(randomBeans.get(0)); - flattenedData.add(randomBeans.get(5)); - flattenedData.addAll(randomBeans.subList(10, 15)); - flattenedData.addAll(randomBeans.subList(6, 10)); - flattenedData.addAll(randomBeans.subList(1, 5)); - flattenedData.addAll(randomBeans.subList(15, 20)); - - rootData.addAll(randomBeans.subList(0, 5)); - rootData.addAll(randomBeans.subList(15, 20)); - - super.setUp(); - } - - @Test(expected = IllegalArgumentException.class) - public void hierarchyData_add_item_parent_not_in_hierarchy_throws() { - new HierarchyData<>().addItem(new StrBean("", 0, 0), - new StrBean("", 0, 0)); - } - - @Test(expected = NullPointerException.class) - public void hierarchyData_add_null_item_throws() { - new HierarchyData<>().addItem(null, null); - } - - @Test(expected = IllegalArgumentException.class) - public void hierarchyData_add_item_already_in_hierarchy_throws() { - StrBean bean = new StrBean("", 0, 0); - new HierarchyData<>().addItem(null, bean).addItem(null, bean); - } - - @Test - public void hierarchyData_remove_root_item() { - data.removeItem(null); - Assert.assertTrue(data.getChildren(null).isEmpty()); - } - - @Test - public void hierarchyData_clear() { - data.clear(); - Assert.assertTrue(data.getChildren(null).isEmpty()); - } - - @Test - public void hierarchyData_re_add_removed_item() { - StrBean item = rootData.get(0); - data.removeItem(item).addItem(null, item); - Assert.assertTrue(data.getChildren(null).contains(item)); - } - - @Test - public void setFilter() { - getDataProvider().setFilter(item -> item.getValue().equals("Xyz") - || item.getValue().equals("Baz")); - - Assert.assertEquals(10, sizeWithUnfilteredQuery()); - - getDataProvider().setFilter(item -> !item.getValue().equals("Foo") - && !item.getValue().equals("Xyz")); - - Assert.assertEquals( - "Previous filter should be replaced when setting a new one", 6, - sizeWithUnfilteredQuery()); - - getDataProvider().setFilter(null); - - Assert.assertEquals("Setting filter to null should remove all filters", - 20, sizeWithUnfilteredQuery()); - } - - @Test - public void addFilter() { - getDataProvider().addFilter(item -> item.getId() <= 10); - getDataProvider().addFilter(item -> item.getId() >= 5); - Assert.assertEquals(5, sizeWithUnfilteredQuery()); - } - - @Override - public void filteringListDataProvider_convertFilter() { - DataProvider strFilterDataProvider = getDataProvider() - .withConvertedFilter( - text -> strBean -> strBean.getValue().contains(text)); - Assert.assertEquals("Only one item should match 'Xyz'", 1, - strFilterDataProvider - .size(new HierarchicalQuery<>("Xyz", null))); - Assert.assertEquals("No item should match 'Zyx'", 0, - strFilterDataProvider - .size(new HierarchicalQuery<>("Zyx", null))); - Assert.assertEquals("Unexpected number of matches for 'Foo'", 3, - strFilterDataProvider - .size(new HierarchicalQuery<>("Foo", null))); - Assert.assertEquals("No items should've been filtered out", - rootData.size(), strFilterDataProvider - .size(new HierarchicalQuery<>(null, null))); - } - - @Override - public void filteringListDataProvider_defaultFilterType() { - Assert.assertEquals("Only one item should match 'Xyz'", 1, - getDataProvider().size(new HierarchicalQuery<>( - strBean -> strBean.getValue().contains("Xyz"), null))); - Assert.assertEquals("No item should match 'Zyx'", 0, - dataProvider.size(new HierarchicalQuery<>( - strBean -> strBean.getValue().contains("Zyx"), null))); - Assert.assertEquals("Unexpected number of matches for 'Foo'", 3, - getDataProvider() - .size(new HierarchicalQuery<>(fooFilter, null))); - } - - @Override - public void testDefaultSortWithSpecifiedPostSort() { - Comparator comp = Comparator.comparing(StrBean::getValue) - .thenComparing(Comparator.comparing(StrBean::getId).reversed()); - setSortOrder(QuerySortOrder.asc("value").thenDesc("id").build(), comp); - - List list = getDataProvider() - .fetch(createQuery(QuerySortOrder.asc("randomNumber").build(), - Comparator.comparing(StrBean::getRandomNumber), null, - null)) - .collect(Collectors.toList()); - - Assert.assertEquals("Sorted data and original data sizes don't match", - getDataProvider().fetch(new HierarchicalQuery<>(null, null)) - .count(), - list.size()); - - for (int i = 1; i < list.size(); ++i) { - StrBean prev = list.get(i - 1); - StrBean cur = list.get(i); - // Test specific sort - Assert.assertTrue( - "Failure: " + prev.getRandomNumber() + " > " - + cur.getRandomNumber(), - prev.getRandomNumber() <= cur.getRandomNumber()); - - if (prev.getRandomNumber() == cur.getRandomNumber()) { - // Test default sort - Assert.assertTrue( - prev.getValue().compareTo(cur.getValue()) <= 0); - if (prev.getValue().equals(cur.getValue())) { - Assert.assertTrue(prev.getId() > cur.getId()); - } - } - } - } - - @Override - public void testDefaultSortWithFunction() { - setSortOrder(QuerySortOrder.asc("value").build(), - Comparator.comparing(StrBean::getValue)); - - List list = getDataProvider() - .fetch(new HierarchicalQuery<>(null, null)) - .collect(Collectors.toList()); - - Assert.assertEquals("Sorted data and original data sizes don't match", - rootData.size(), list.size()); - - for (int i = 1; i < list.size(); ++i) { - StrBean prev = list.get(i - 1); - StrBean cur = list.get(i); - - // Test default sort - Assert.assertTrue(prev.getValue().compareTo(cur.getValue()) <= 0); - } - } - - @Override - public void testListContainsAllData() { - assertHierarchyCorrect(); - } - - @Override - public void testSortByComparatorListsDiffer() { - Comparator comp = Comparator.comparing(StrBean::getValue) - .thenComparing(StrBean::getRandomNumber) - .thenComparing(StrBean::getId); - - List list = getDataProvider().fetch( - createQuery(QuerySortOrder.asc("value").thenAsc("randomNumber") - .thenAsc("id").build(), comp, null, null)) - .collect(Collectors.toList()); - - Assert.assertNotEquals("First value should not match", rootData.get(0), - list.get(0)); - - Assert.assertEquals("Sorted data and original data sizes don't match", - rootData.size(), list.size()); - - rootData.sort(comp); - for (int i = 0; i < rootData.size(); ++i) { - Assert.assertEquals("Sorting result differed", rootData.get(i), - list.get(i)); - } - } - - @Override - protected InMemoryHierarchicalDataProvider createDataProvider() { - return new InMemoryHierarchicalDataProvider<>(data); - } - - @Override - protected void setSortOrder(List sortOrder, - Comparator comp) { - getDataProvider().setSortComparator(comp::compare); - } - - @Override - protected long sizeWithUnfilteredQuery() { - return getFlattenedDataFromProvider(new ArrayList<>(), null).size(); - } - - private void assertHierarchyCorrect() { - Assert.assertEquals(flattenedData, - getFlattenedData(new ArrayList<>(), null)); - Assert.assertEquals(flattenedData, - getFlattenedDataFromProvider(new ArrayList<>(), null)); - } - - private List getFlattenedData(List flattened, - StrBean item) { - if (item != null) { - flattened.add(item); - } - data.getChildren(item) - .forEach(child -> getFlattenedData(flattened, child)); - return flattened; - } - - private List getFlattenedDataFromProvider(List flattened, - StrBean item) { - if (item != null) { - flattened.add(item); - } - getDataProvider().fetchChildren(new HierarchicalQuery<>(null, item)) - .forEach(child -> getFlattenedDataFromProvider(flattened, - child)); - return flattened; - } - - private HierarchicalQuery> createQuery( - List sortOrder, Comparator comp, - SerializablePredicate filter, StrBean parent) { - return new HierarchicalQuery<>(0, Integer.MAX_VALUE, sortOrder, comp, - filter, parent); - } -} diff --git a/server/src/test/java/com/vaadin/data/provider/TreeDataProviderTest.java b/server/src/test/java/com/vaadin/data/provider/TreeDataProviderTest.java new file mode 100644 index 0000000000..3f9f1f6e94 --- /dev/null +++ b/server/src/test/java/com/vaadin/data/provider/TreeDataProviderTest.java @@ -0,0 +1,297 @@ +package com.vaadin.data.provider; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; +import java.util.stream.Collectors; + +import org.junit.Assert; +import org.junit.Test; + +import com.vaadin.data.TreeData; +import com.vaadin.server.SerializablePredicate; + +public class TreeDataProviderTest extends + DataProviderTestBase> { + + private TreeData data; + private List flattenedData; + private List rootData; + + @Override + public void setUp() { + List randomBeans = StrBean.generateRandomBeans(20); + flattenedData = new ArrayList<>(); + rootData = new ArrayList<>(); + + data = new TreeData<>(); + data.addItems(null, randomBeans.subList(0, 5)); + data.addItems(randomBeans.get(0), randomBeans.subList(5, 10)); + data.addItems(randomBeans.get(5), randomBeans.subList(10, 15)); + data.addItems(null, randomBeans.subList(15, 20)); + + flattenedData.add(randomBeans.get(0)); + flattenedData.add(randomBeans.get(5)); + flattenedData.addAll(randomBeans.subList(10, 15)); + flattenedData.addAll(randomBeans.subList(6, 10)); + flattenedData.addAll(randomBeans.subList(1, 5)); + flattenedData.addAll(randomBeans.subList(15, 20)); + + rootData.addAll(randomBeans.subList(0, 5)); + rootData.addAll(randomBeans.subList(15, 20)); + + super.setUp(); + } + + @Test(expected = IllegalArgumentException.class) + public void treeData_add_item_parent_not_in_hierarchy_throws() { + new TreeData<>().addItem(new StrBean("", 0, 0), + new StrBean("", 0, 0)); + } + + @Test(expected = NullPointerException.class) + public void treeData_add_null_item_throws() { + new TreeData<>().addItem(null, null); + } + + @Test(expected = IllegalArgumentException.class) + public void treeData_add_item_already_in_hierarchy_throws() { + StrBean bean = new StrBean("", 0, 0); + new TreeData<>().addItem(null, bean).addItem(null, bean); + } + + @Test + public void treeData_remove_root_item() { + data.removeItem(null); + Assert.assertTrue(data.getChildren(null).isEmpty()); + } + + @Test + public void treeData_clear() { + data.clear(); + Assert.assertTrue(data.getChildren(null).isEmpty()); + } + + @Test + public void treeData_re_add_removed_item() { + StrBean item = rootData.get(0); + data.removeItem(item).addItem(null, item); + Assert.assertTrue(data.getChildren(null).contains(item)); + } + + @Test + public void populate_treeData_with_child_item_provider() { + TreeData stringData = new TreeData<>(); + List rootItems = Arrays.asList("a", "b", "c"); + stringData.addItems(rootItems, item -> { + if (item.length() >= 3 || item.startsWith("c")) { + return Arrays.asList(); + } + return Arrays.asList(item + "/a", item + "/b", item + "/c"); + }); + Assert.assertEquals(stringData.getChildren("a"), + Arrays.asList("a/a", "a/b", "a/c")); + Assert.assertEquals(stringData.getChildren("b"), + Arrays.asList("b/a", "b/b", "b/c")); + Assert.assertEquals(stringData.getChildren("c"), Arrays.asList()); + Assert.assertEquals(stringData.getChildren("a/b"), Arrays.asList()); + } + + @Test + public void setFilter() { + getDataProvider().setFilter(item -> item.getValue().equals("Xyz") + || item.getValue().equals("Baz")); + + Assert.assertEquals(10, sizeWithUnfilteredQuery()); + + getDataProvider().setFilter(item -> !item.getValue().equals("Foo") + && !item.getValue().equals("Xyz")); + + Assert.assertEquals( + "Previous filter should be replaced when setting a new one", 6, + sizeWithUnfilteredQuery()); + + getDataProvider().setFilter(null); + + Assert.assertEquals("Setting filter to null should remove all filters", + 20, sizeWithUnfilteredQuery()); + } + + @Test + public void addFilter() { + getDataProvider().addFilter(item -> item.getId() <= 10); + getDataProvider().addFilter(item -> item.getId() >= 5); + Assert.assertEquals(5, sizeWithUnfilteredQuery()); + } + + @Override + public void filteringListDataProvider_convertFilter() { + DataProvider strFilterDataProvider = getDataProvider() + .withConvertedFilter( + text -> strBean -> strBean.getValue().contains(text)); + Assert.assertEquals("Only one item should match 'Xyz'", 1, + strFilterDataProvider + .size(new HierarchicalQuery<>("Xyz", null))); + Assert.assertEquals("No item should match 'Zyx'", 0, + strFilterDataProvider + .size(new HierarchicalQuery<>("Zyx", null))); + Assert.assertEquals("Unexpected number of matches for 'Foo'", 3, + strFilterDataProvider + .size(new HierarchicalQuery<>("Foo", null))); + Assert.assertEquals("No items should've been filtered out", + rootData.size(), strFilterDataProvider + .size(new HierarchicalQuery<>(null, null))); + } + + @Override + public void filteringListDataProvider_defaultFilterType() { + Assert.assertEquals("Only one item should match 'Xyz'", 1, + getDataProvider().size(new HierarchicalQuery<>( + strBean -> strBean.getValue().contains("Xyz"), null))); + Assert.assertEquals("No item should match 'Zyx'", 0, + dataProvider.size(new HierarchicalQuery<>( + strBean -> strBean.getValue().contains("Zyx"), null))); + Assert.assertEquals("Unexpected number of matches for 'Foo'", 3, + getDataProvider() + .size(new HierarchicalQuery<>(fooFilter, null))); + } + + @Override + public void testDefaultSortWithSpecifiedPostSort() { + Comparator comp = Comparator.comparing(StrBean::getValue) + .thenComparing(Comparator.comparing(StrBean::getId).reversed()); + setSortOrder(QuerySortOrder.asc("value").thenDesc("id").build(), comp); + + List list = getDataProvider() + .fetch(createQuery(QuerySortOrder.asc("randomNumber").build(), + Comparator.comparing(StrBean::getRandomNumber), null, + null)) + .collect(Collectors.toList()); + + Assert.assertEquals("Sorted data and original data sizes don't match", + getDataProvider().fetch(new HierarchicalQuery<>(null, null)) + .count(), + list.size()); + + for (int i = 1; i < list.size(); ++i) { + StrBean prev = list.get(i - 1); + StrBean cur = list.get(i); + // Test specific sort + Assert.assertTrue( + "Failure: " + prev.getRandomNumber() + " > " + + cur.getRandomNumber(), + prev.getRandomNumber() <= cur.getRandomNumber()); + + if (prev.getRandomNumber() == cur.getRandomNumber()) { + // Test default sort + Assert.assertTrue( + prev.getValue().compareTo(cur.getValue()) <= 0); + if (prev.getValue().equals(cur.getValue())) { + Assert.assertTrue(prev.getId() > cur.getId()); + } + } + } + } + + @Override + public void testDefaultSortWithFunction() { + setSortOrder(QuerySortOrder.asc("value").build(), + Comparator.comparing(StrBean::getValue)); + + List list = getDataProvider() + .fetch(new HierarchicalQuery<>(null, null)) + .collect(Collectors.toList()); + + Assert.assertEquals("Sorted data and original data sizes don't match", + rootData.size(), list.size()); + + for (int i = 1; i < list.size(); ++i) { + StrBean prev = list.get(i - 1); + StrBean cur = list.get(i); + + // Test default sort + Assert.assertTrue(prev.getValue().compareTo(cur.getValue()) <= 0); + } + } + + @Override + public void testListContainsAllData() { + assertHierarchyCorrect(); + } + + @Override + public void testSortByComparatorListsDiffer() { + Comparator comp = Comparator.comparing(StrBean::getValue) + .thenComparing(StrBean::getRandomNumber) + .thenComparing(StrBean::getId); + + List list = getDataProvider().fetch( + createQuery(QuerySortOrder.asc("value").thenAsc("randomNumber") + .thenAsc("id").build(), comp, null, null)) + .collect(Collectors.toList()); + + Assert.assertNotEquals("First value should not match", rootData.get(0), + list.get(0)); + + Assert.assertEquals("Sorted data and original data sizes don't match", + rootData.size(), list.size()); + + rootData.sort(comp); + for (int i = 0; i < rootData.size(); ++i) { + Assert.assertEquals("Sorting result differed", rootData.get(i), + list.get(i)); + } + } + + @Override + protected TreeDataProvider createDataProvider() { + return new TreeDataProvider<>(data); + } + + @Override + protected void setSortOrder(List sortOrder, + Comparator comp) { + getDataProvider().setSortComparator(comp::compare); + } + + @Override + protected long sizeWithUnfilteredQuery() { + return getFlattenedDataFromProvider(new ArrayList<>(), null).size(); + } + + private void assertHierarchyCorrect() { + Assert.assertEquals(flattenedData, + getFlattenedData(new ArrayList<>(), null)); + Assert.assertEquals(flattenedData, + getFlattenedDataFromProvider(new ArrayList<>(), null)); + } + + private List getFlattenedData(List flattened, + StrBean item) { + if (item != null) { + flattened.add(item); + } + data.getChildren(item) + .forEach(child -> getFlattenedData(flattened, child)); + return flattened; + } + + private List getFlattenedDataFromProvider(List flattened, + StrBean item) { + if (item != null) { + flattened.add(item); + } + getDataProvider().fetchChildren(new HierarchicalQuery<>(null, item)) + .forEach(child -> getFlattenedDataFromProvider(flattened, + child)); + return flattened; + } + + private HierarchicalQuery> createQuery( + List sortOrder, Comparator comp, + SerializablePredicate filter, StrBean parent) { + return new HierarchicalQuery<>(0, Integer.MAX_VALUE, sortOrder, comp, + filter, parent); + } +} diff --git a/server/src/test/java/com/vaadin/tests/components/TreeTest.java b/server/src/test/java/com/vaadin/tests/components/TreeTest.java index 13ef0acc49..9224934a4c 100644 --- a/server/src/test/java/com/vaadin/tests/components/TreeTest.java +++ b/server/src/test/java/com/vaadin/tests/components/TreeTest.java @@ -3,8 +3,8 @@ package com.vaadin.tests.components; import org.junit.Assert; import org.junit.Test; -import com.vaadin.data.HierarchyData; -import com.vaadin.data.provider.InMemoryHierarchicalDataProvider; +import com.vaadin.data.TreeData; +import com.vaadin.data.provider.TreeDataProvider; import com.vaadin.event.CollapseEvent; import com.vaadin.event.CollapseEvent.CollapseListener; import com.vaadin.event.ExpandEvent; @@ -52,12 +52,12 @@ public class TreeTest { @Test public void event_source_is_tree() { Tree tree = new Tree<>(); - HierarchyData hierarchyData = new HierarchyData<>(); - hierarchyData.addItem(null, "Foo"); - hierarchyData.addItem("Foo", "Bar"); - hierarchyData.addItem("Foo", "Baz"); + TreeData treeData = new TreeData<>(); + treeData.addItem(null, "Foo"); + treeData.addItem("Foo", "Bar"); + treeData.addItem("Foo", "Baz"); tree.setDataProvider( - new InMemoryHierarchicalDataProvider<>(hierarchyData)); + new TreeDataProvider<>(treeData)); TreeCollapseExpandListener listener = new TreeCollapseExpandListener( tree); diff --git a/server/src/test/java/com/vaadin/tests/components/treegrid/TreeGridTest.java b/server/src/test/java/com/vaadin/tests/components/treegrid/TreeGridTest.java index 2e335f865e..1544a4f69d 100644 --- a/server/src/test/java/com/vaadin/tests/components/treegrid/TreeGridTest.java +++ b/server/src/test/java/com/vaadin/tests/components/treegrid/TreeGridTest.java @@ -3,8 +3,8 @@ package com.vaadin.tests.components.treegrid; import org.junit.Assert; import org.junit.Test; -import com.vaadin.data.HierarchyData; -import com.vaadin.data.provider.InMemoryHierarchicalDataProvider; +import com.vaadin.data.TreeData; +import com.vaadin.data.provider.TreeDataProvider; import com.vaadin.ui.TreeGrid; import com.vaadin.ui.renderers.TextRenderer; @@ -24,12 +24,12 @@ public class TreeGridTest { @Test public void testExpandAndCollapseEvents() { - HierarchyData hierarchyData = new HierarchyData<>(); - hierarchyData.addItem(null, "Foo"); - hierarchyData.addItem("Foo", "Bar"); - hierarchyData.addItem("Foo", "Baz"); + TreeData treeData = new TreeData<>(); + treeData.addItem(null, "Foo"); + treeData.addItem("Foo", "Bar"); + treeData.addItem("Foo", "Baz"); treeGrid.setDataProvider( - new InMemoryHierarchicalDataProvider<>(hierarchyData)); + new TreeDataProvider<>(treeData)); treeGrid.addExpandListener(e -> expandEventFired = true); treeGrid.addCollapseListener(e -> collapseEventFired = true); diff --git a/server/src/test/java/com/vaadin/tests/server/ClassesSerializableTest.java b/server/src/test/java/com/vaadin/tests/server/ClassesSerializableTest.java index b4f9851867..d2d25b4777 100644 --- a/server/src/test/java/com/vaadin/tests/server/ClassesSerializableTest.java +++ b/server/src/test/java/com/vaadin/tests/server/ClassesSerializableTest.java @@ -76,6 +76,7 @@ public class ClassesSerializableTest { "com\\.vaadin\\.buildhelpers.*", // "com\\.vaadin\\.util\\.EncodeUtil.*", // "com\\.vaadin\\.util\\.ReflectTools.*", // + "com\\.vaadin\\.data\\.provider\\.InMemoryDataProviderHelpers", "com\\.vaadin\\.data\\.provider\\.HierarchyMapper\\$TreeLevelQuery", "com\\.vaadin\\.data\\.util\\.ReflectTools.*", // "com\\.vaadin\\.data\\.util\\.JsonUtil.*", // diff --git a/server/src/test/java/com/vaadin/tests/server/component/treegrid/TreeGridDeclarativeTest.java b/server/src/test/java/com/vaadin/tests/server/component/treegrid/TreeGridDeclarativeTest.java index c8a51a1928..a13ba357ef 100644 --- a/server/src/test/java/com/vaadin/tests/server/component/treegrid/TreeGridDeclarativeTest.java +++ b/server/src/test/java/com/vaadin/tests/server/component/treegrid/TreeGridDeclarativeTest.java @@ -4,9 +4,9 @@ import java.lang.reflect.InvocationTargetException; import org.junit.Assert; -import com.vaadin.data.HierarchyData; +import com.vaadin.data.TreeData; import com.vaadin.data.provider.HierarchicalQuery; -import com.vaadin.data.provider.InMemoryHierarchicalDataProvider; +import com.vaadin.data.provider.TreeDataProvider; import com.vaadin.tests.data.bean.Person; import com.vaadin.tests.server.component.abstractlisting.AbstractListingDeclarativeTest; import com.vaadin.ui.TreeGrid; @@ -28,7 +28,7 @@ public class TreeGridDeclarativeTest Person person6 = createPerson("ca", "last-name"); Person person7 = createPerson("caa", "last-name"); - HierarchyData data = new HierarchyData<>(); + TreeData data = new TreeData<>(); data.addItems(null, person1, person4, person5); data.addItems(person1, person2, person3); data.addItem(person5, person6); @@ -38,7 +38,7 @@ public class TreeGridDeclarativeTest grid.addColumn(Person::getLastName).setId("id").setCaption("Id"); grid.setHierarchyColumn("id"); - grid.setDataProvider(new InMemoryHierarchicalDataProvider<>(data)); + grid.setDataProvider(new TreeDataProvider<>(data)); String design = String.format( "<%s hierarchy-column='id'>" -- cgit v1.2.3