From 27aa8c33e28deb9516eac2f702904fbd1dae9e6f Mon Sep 17 00:00:00 2001 From: Artur Signell Date: Tue, 2 Mar 2010 07:15:00 +0000 Subject: [PATCH] #4192 - HierarchicalContainer implements Container.Filterable but does not allow filtering svn changeset:11576/svn branch:6.3 --- .../data/util/HierarchicalContainer.java | 204 ++++++++++++++++-- .../vaadin/data/util/IndexedContainer.java | 8 +- .../container/AbstractContainerTest.java | 57 +++-- .../AbstractHierarchicalContainerTest.java | 144 +++++++++---- .../container/TestHierarchicalContainer.java | 4 + 5 files changed, 333 insertions(+), 84 deletions(-) diff --git a/src/com/vaadin/data/util/HierarchicalContainer.java b/src/com/vaadin/data/util/HierarchicalContainer.java index 988676be8c..a264eafc71 100644 --- a/src/com/vaadin/data/util/HierarchicalContainer.java +++ b/src/com/vaadin/data/util/HierarchicalContainer.java @@ -41,11 +41,21 @@ public class HierarchicalContainer extends IndexedContainer implements */ private final HashMap> children = new HashMap>(); + /** + * Mapping from Item ID to a list of child IDs when filtered + */ + private HashMap> filteredChildren = null; + /** * List that contains all root elements of the container. */ private final LinkedList roots = new LinkedList(); + /** + * List that contains all filtered root elements of the container. + */ + private LinkedList filteredRoots = null; + /* * Can the specified Item have any children? Don't add a JavaDoc comment * here, we use the default documentation from implemented interface. @@ -63,7 +73,14 @@ public class HierarchicalContainer extends IndexedContainer implements * interface. */ public Collection getChildren(Object itemId) { - final Collection c = children.get(itemId); + LinkedList c; + + if (filteredChildren != null) { + c = filteredChildren.get(itemId); + } else { + c = children.get(itemId); + } + if (c == null) { return null; } @@ -85,7 +102,11 @@ public class HierarchicalContainer extends IndexedContainer implements * interface. */ public boolean hasChildren(Object itemId) { - return children.get(itemId) != null; + if (filteredChildren != null) { + return filteredChildren.containsKey(itemId); + } else { + return children.containsKey(itemId); + } } /* @@ -94,6 +115,10 @@ public class HierarchicalContainer extends IndexedContainer implements * interface. */ public boolean isRoot(Object itemId) { + if (filteredRoots != null && !filteredRoots.contains(itemId)) { + return false; + } + if (parent.containsKey(itemId)) { return false; } @@ -107,7 +132,11 @@ public class HierarchicalContainer extends IndexedContainer implements * interface. */ public Collection rootItemIds() { - return Collections.unmodifiableCollection(roots); + if (filteredRoots != null) { + return Collections.unmodifiableCollection(filteredRoots); + } else { + return Collections.unmodifiableCollection(roots); + } } /** @@ -179,20 +208,39 @@ public class HierarchicalContainer extends IndexedContainer implements return true; } - // Making root + // Making root? if (newParentId == null) { - + // The itemId should become a root so we need to + // - Remove it from the old parent's children list (also filtered list) + // - Add it as a root + // - Remove it from the item -> parent list (parent is null for roots) + // Removes from old parents children list - final LinkedList l = children.get(itemId); + final LinkedList l = children.get(itemId); if (l != null) { l.remove(itemId); if (l.isEmpty()) { children.remove(itemId); } + + if (filteredChildren != null) { + LinkedList f = filteredChildren.get(itemId); + if (f != null) { + f.remove(itemId); + if (f.isEmpty()) { + filteredChildren.remove(f); + } + } + } } // Add to be a root roots.add(itemId); + if (filteredRoots != null) { + if (passesFilters(itemId)) { + filteredRoots.add(itemId); + } + } // Updates parent parent.remove(itemId); @@ -200,6 +248,13 @@ public class HierarchicalContainer extends IndexedContainer implements return true; } + // We get here when the item should not become a root and we need to + // - Verify the new parent exists and can have children + // - Check that the new parent is not a child of the selected itemId + // - Updated the item -> parent mapping to point to the new parent + // - Remove the item from the roots list if it was a root + // - Remove the item from the old parent's children list if it was not a root + // Checks that the new parent exists in container and can have // children if (!containsId(newParentId) || noChildrenAllowed.contains(newParentId)) { @@ -217,24 +272,46 @@ public class HierarchicalContainer extends IndexedContainer implements // Updates parent parent.put(itemId, newParentId); - LinkedList pcl = children.get(newParentId); + LinkedList pcl = children.get(newParentId); if (pcl == null) { - pcl = new LinkedList(); + // Create an empty list for holding children if one were not + // previously created + pcl = new LinkedList(); children.put(newParentId, pcl); } pcl.add(itemId); + // Add children list for filtered case also + if (filteredChildren != null) { + LinkedList f = filteredChildren.get(newParentId); + if (f == null) { + // Create an empty list for holding children if one were not + // previously created + f = new LinkedList(); + filteredChildren.put(newParentId, f); + } + } + // Removes from old parent or root if (oldParentId == null) { roots.remove(itemId); } else { - final LinkedList l = children.get(oldParentId); + final LinkedList l = children.get(oldParentId); if (l != null) { l.remove(itemId); if (l.isEmpty()) { children.remove(oldParentId); } } + if (filteredChildren != null) { + LinkedList f = filteredChildren.get(oldParentId); + if (f != null) { + f.remove(itemId); + if (f.isEmpty()) { + filteredChildren.remove(oldParentId); + } + } + } } return true; @@ -247,12 +324,21 @@ public class HierarchicalContainer extends IndexedContainer implements */ @Override public Object addItem() { - final Object id = super.addItem(); - if (id != null && !roots.contains(id)) { - roots.add(id); + final Object itemId = super.addItem(); + if (itemId == null) { + return null; + } + + if (!roots.contains(itemId)) { + roots.add(itemId); + if (filteredRoots != null) { + if (passesFilters(itemId)) { + filteredRoots.add(itemId); + } + } } - return id; + return itemId; } /* @@ -263,9 +349,18 @@ public class HierarchicalContainer extends IndexedContainer implements @Override public Item addItem(Object itemId) { final Item item = super.addItem(itemId); - if (item != null) { - roots.add(itemId); + if (item == null) { + return null; } + + roots.add(itemId); + + if (filteredRoots != null) { + if (passesFilters(itemId)) { + filteredRoots.add(itemId); + } + } + return item; } @@ -283,6 +378,12 @@ public class HierarchicalContainer extends IndexedContainer implements parent.clear(); children.clear(); noChildrenAllowed.clear(); + if (filteredRoots != null) { + filteredRoots = null; + } + if (filteredChildren != null) { + filteredChildren = null; + } } return success; } @@ -297,15 +398,41 @@ public class HierarchicalContainer extends IndexedContainer implements final boolean success = super.removeItem(itemId); if (success) { - if (isRoot(itemId)) { - roots.remove(itemId); + + // Remove from roots if this was a root + if (roots.remove(itemId)) { + + // If filtering is enabled we might need to remove it from the + // filtered list also + if (filteredRoots != null) { + filteredRoots.remove(itemId); + } + } + + // Clear the children list. Old children will now be unattached + // FIXME Should these be made into roots? + if (children.remove(itemId) != null) { + if (filteredChildren != null) { + filteredChildren.remove(itemId); + } } - children.remove(itemId); - final Object p = parent.get(itemId); - if (p != null) { - final LinkedList c = children.get(p); + + // Parent of the item that we are removing will contain the item id + // in its children list + final Object parentItemId = parent.get(itemId); + if (parentItemId != null) { + final LinkedList c = children.get(parentItemId); if (c != null) { c.remove(itemId); + + // Found in the children list so might also be in the + // filteredChildren list + if (filteredChildren != null) { + LinkedList f = filteredChildren.get(parentItemId); + if (f != null) { + f.remove(parentItemId); + } + } } } parent.remove(itemId); @@ -330,4 +457,39 @@ public class HierarchicalContainer extends IndexedContainer implements } } + /* + * Overridden to provide filtering for root & children items. + * + * (non-Javadoc) + * + * @see com.vaadin.data.util.IndexedContainer#updateContainerFiltering() + */ + @Override + protected void updateContainerFiltering() { + super.updateContainerFiltering(); + + filteredRoots = new LinkedList(); + filteredChildren = new HashMap>(); + + // Filter root item ids + for (Object rootId : roots) { + if (passesFilters(rootId)) { + filteredRoots.add(rootId); + } + } + + // Filter children + for (Object parent : children.keySet()) { + if (passesFilters(parent)) { + LinkedList filtered = new LinkedList(); + filteredChildren.put(parent, filtered); + for (Object child : children.get(parent)) { + if (passesFilters(child)) { + filtered.add(child); + } + } + } + } + + } } diff --git a/src/com/vaadin/data/util/IndexedContainer.java b/src/com/vaadin/data/util/IndexedContainer.java index 1d2726cdeb..5131923eac 100644 --- a/src/com/vaadin/data/util/IndexedContainer.java +++ b/src/com/vaadin/data/util/IndexedContainer.java @@ -1561,7 +1561,7 @@ public class IndexedContainer implements Container.Indexed, } } - private void updateContainerFiltering() { + protected void updateContainerFiltering() { // Clearing filters? if (filters == null || filters.isEmpty()) { @@ -1583,7 +1583,7 @@ public class IndexedContainer implements Container.Indexed, // Filter for (final Iterator i = itemIds.iterator(); i.hasNext();) { final Object id = i.next(); - if (passesFilters(new IndexedContainerItem(id))) { + if (passesFilters(id)) { filteredItemIds.add(id); } } @@ -1591,6 +1591,10 @@ public class IndexedContainer implements Container.Indexed, fireContentsChange(-1); } + protected final boolean passesFilters(Object itemId) { + return passesFilters(new IndexedContainerItem(itemId)); + } + private boolean passesFilters(Item item) { if (filters == null) { return true; diff --git a/tests/src/com/vaadin/tests/server/container/AbstractContainerTest.java b/tests/src/com/vaadin/tests/server/container/AbstractContainerTest.java index 09e9fff169..e20f54dc39 100644 --- a/tests/src/com/vaadin/tests/server/container/AbstractContainerTest.java +++ b/tests/src/com/vaadin/tests/server/container/AbstractContainerTest.java @@ -81,9 +81,10 @@ public abstract class AbstractContainerTest extends TestCase { } - protected static final Object PROP1 = "PROP1"; - protected static final Object PROP2 = "PROP2"; - protected static final Object PROP3 = "PROP3"; + protected static final Object FULLY_QUALIFIED_NAME = "PROP1"; + protected static final Object SIMPLE_NAME = "simplename"; + protected static final Object REVERSE_FULLY_QUALIFIED_NAME = "PROP2"; + protected static final Object ID_NUMBER = "PROP3"; protected void testBasicContainerOperations(Container container) { initializeContainer(container); @@ -165,7 +166,7 @@ public abstract class AbstractContainerTest extends TestCase { initializeContainer(container); // Filter by "contains ab" - container.addContainerFilter(PROP1, "ab", false, false); + container.addContainerFilter(FULLY_QUALIFIED_NAME, "ab", false, false); validateContainer(container, "com.vaadin.data.BufferedValidatable", "com.vaadin.ui.TabSheet", @@ -174,7 +175,8 @@ public abstract class AbstractContainerTest extends TestCase { // Filter by "contains da" (reversed as ad here) container.removeAllContainerFilters(); - container.addContainerFilter(PROP2, "ad", false, false); + container.addContainerFilter(REVERSE_FULLY_QUALIFIED_NAME, "ad", false, + false); validateContainer(container, "com.vaadin.data.Buffered", "com.vaadin.terminal.gwt.server.ComponentSizeValidator", @@ -188,12 +190,14 @@ public abstract class AbstractContainerTest extends TestCase { initializeContainer(sortable); // Filter by "contains ab" - filterable.addContainerFilter(PROP1, "ab", false, false); + filterable.addContainerFilter(FULLY_QUALIFIED_NAME, "ab", false, false); // Must be able to sort based on PROP1 for this test - assertTrue(sortable.getSortableContainerPropertyIds().contains(PROP1)); + assertTrue(sortable.getSortableContainerPropertyIds().contains( + FULLY_QUALIFIED_NAME)); - sortable.sort(new Object[] { PROP1 }, new boolean[] { true }); + sortable.sort(new Object[] { FULLY_QUALIFIED_NAME }, + new boolean[] { true }); validateContainer(sortable, "com.vaadin.data.BufferedValidatable", "com.vaadin.ui.TableFieldFactory", @@ -207,17 +211,21 @@ public abstract class AbstractContainerTest extends TestCase { initializeContainer(container); // Must be able to sort based on PROP1 for this test - assertTrue(sortable.getSortableContainerPropertyIds().contains(PROP1)); - assertTrue(sortable.getSortableContainerPropertyIds().contains(PROP2)); + assertTrue(sortable.getSortableContainerPropertyIds().contains( + FULLY_QUALIFIED_NAME)); + assertTrue(sortable.getSortableContainerPropertyIds().contains( + REVERSE_FULLY_QUALIFIED_NAME)); - sortable.sort(new Object[] { PROP1 }, new boolean[] { true }); + sortable.sort(new Object[] { FULLY_QUALIFIED_NAME }, + new boolean[] { true }); validateContainer(container, "com.vaadin.Application", "com.vaadin.util.SerializerHelper", "com.vaadin.terminal.ApplicationResource", "blah", sampleData.length); - sortable.sort(new Object[] { PROP2 }, new boolean[] { true }); + sortable.sort(new Object[] { REVERSE_FULLY_QUALIFIED_NAME }, + new boolean[] { true }); validateContainer(container, "com.vaadin.terminal.gwt.server.ApplicationPortlet2", @@ -233,17 +241,30 @@ public abstract class AbstractContainerTest extends TestCase { container.removeContainerProperty(propertyId); } - container.addContainerProperty(PROP1, String.class, ""); - container.addContainerProperty(PROP2, String.class, null); - container.addContainerProperty(PROP3, Integer.class, null); + container.addContainerProperty(FULLY_QUALIFIED_NAME, String.class, ""); + container.addContainerProperty(SIMPLE_NAME, String.class, ""); + container.addContainerProperty(REVERSE_FULLY_QUALIFIED_NAME, + String.class, null); + container.addContainerProperty(ID_NUMBER, Integer.class, null); for (int i = 0; i < sampleData.length; i++) { String id = sampleData[i]; Item item = container.addItem(id); - item.getItemProperty(PROP1).setValue(sampleData[i]); - item.getItemProperty(PROP2).setValue(reverse(sampleData[i])); - item.getItemProperty(PROP3).setValue(i); + item.getItemProperty(FULLY_QUALIFIED_NAME).setValue(sampleData[i]); + item.getItemProperty(SIMPLE_NAME).setValue( + getSimpleName(sampleData[i])); + item.getItemProperty(REVERSE_FULLY_QUALIFIED_NAME).setValue( + reverse(sampleData[i])); + item.getItemProperty(ID_NUMBER).setValue(i); + } + } + + protected String getSimpleName(String name) { + if (name.contains(".")) { + return name.substring(name.lastIndexOf('.') + 1); + } else { + return name; } } diff --git a/tests/src/com/vaadin/tests/server/container/AbstractHierarchicalContainerTest.java b/tests/src/com/vaadin/tests/server/container/AbstractHierarchicalContainerTest.java index 12037259fd..7aeef3e1b1 100644 --- a/tests/src/com/vaadin/tests/server/container/AbstractHierarchicalContainerTest.java +++ b/tests/src/com/vaadin/tests/server/container/AbstractHierarchicalContainerTest.java @@ -9,10 +9,31 @@ import com.vaadin.data.Container.Sortable; public class AbstractHierarchicalContainerTest extends AbstractContainerTest { + /** + * @param container + * The container to validate + * @param expectedFirstItemId + * Expected first item id + * @param expectedLastItemId + * Expected last item id + * @param itemIdInSet + * An item id that is in the container + * @param itemIdNotInSet + * An item id that is not in the container + * @param expectedSize + * Expected number of items in the container. Not related to + * hierarchy. + * @param expectedTraversalSize + * Expected number of items found when traversing from the roots + * down to all available nodes. + * @param expectedRootSize + * Expected number of root items + */ private void validateHierarchicalContainer(Hierarchical container, Object expectedFirstItemId, Object expectedLastItemId, - Object itemIdInSet, Object itemIdNotInSet, int expectedSize, - int expectedRootSize) { + Object itemIdInSet, Object itemIdNotInSet, + boolean rootsHaveChildren, int expectedSize, + int expectedTraversalSize, int expectedRootSize) { validateContainer(container, expectedFirstItemId, expectedLastItemId, itemIdInSet, itemIdNotInSet, expectedSize); @@ -35,13 +56,18 @@ public class AbstractHierarchicalContainerTest extends AbstractContainerTest { assertTrue(container.areChildrenAllowed(rootId)); // all roots have children in this case - Collection children = container.getChildren(rootId); - assertNotNull(rootId + " should have children", children); - assertTrue(rootId + " should have children", (children.size() > 0)); + if (rootsHaveChildren) { + Collection children = container.getChildren(rootId); + assertNotNull(rootId + " should have children", children); + assertTrue(rootId + " should have children", + (children.size() > 0)); + + // getParent + for (Object childId : children) { + assertEquals(container.getParent(childId), rootId); + } + } else { - // getParent - for (Object childId : children) { - assertEquals(container.getParent(childId), rootId); } } @@ -57,7 +83,7 @@ public class AbstractHierarchicalContainerTest extends AbstractContainerTest { // removeItem of unknown items should return false assertFalse(container.removeItem(itemIdNotInSet)); - assertEquals(expectedSize, countNodes(container)); + assertEquals(expectedTraversalSize, countNodes(container)); validateHierarchy(container); } @@ -114,10 +140,11 @@ public class AbstractHierarchicalContainerTest extends AbstractContainerTest { initializeContainer(container); int packages = 21; + int expectedSize = sampleData.length + packages; validateHierarchicalContainer(container, "com", "com.vaadin.util.SerializerHelper", - "com.vaadin.terminal.ApplicationResource", "blah", - sampleData.length + packages, 1); + "com.vaadin.terminal.ApplicationResource", "blah", true, + expectedSize, expectedSize, 1); } @@ -127,24 +154,29 @@ public class AbstractHierarchicalContainerTest extends AbstractContainerTest { initializeContainer(container); // Must be able to sort based on PROP1 and PROP2 for this test - assertTrue(sortable.getSortableContainerPropertyIds().contains(PROP1)); - assertTrue(sortable.getSortableContainerPropertyIds().contains(PROP2)); + assertTrue(sortable.getSortableContainerPropertyIds().contains( + FULLY_QUALIFIED_NAME)); + assertTrue(sortable.getSortableContainerPropertyIds().contains( + REVERSE_FULLY_QUALIFIED_NAME)); - sortable.sort(new Object[] { PROP1 }, new boolean[] { true }); + sortable.sort(new Object[] { FULLY_QUALIFIED_NAME }, + new boolean[] { true }); int packages = 21; + int expectedSize = sampleData.length + packages; validateHierarchicalContainer(container, "com", "com.vaadin.util.SerializerHelper", - "com.vaadin.terminal.ApplicationResource", "blah", - sampleData.length + packages, 1); + "com.vaadin.terminal.ApplicationResource", "blah", true, + expectedSize, expectedSize, 1); - sortable.sort(new Object[] { PROP2 }, new boolean[] { true }); + sortable.sort(new Object[] { REVERSE_FULLY_QUALIFIED_NAME }, + new boolean[] { true }); validateHierarchicalContainer(container, "com.vaadin.terminal.gwt.server.ApplicationPortlet2", "com.vaadin.data.util.ObjectProperty", - "com.vaadin.terminal.ApplicationResource", "blah", - sampleData.length + packages, 1); + "com.vaadin.terminal.ApplicationResource", "blah", true, + expectedSize, expectedSize, 1); } @@ -154,31 +186,47 @@ public class AbstractHierarchicalContainerTest extends AbstractContainerTest { initializeContainer(container); // Filter by "contains ab" - filterable.addContainerFilter(PROP1, "ab", false, false); + filterable.addContainerFilter(FULLY_QUALIFIED_NAME, "ab", false, false); + + // 20 items should remain in the container but the root should be + // filtered + int expectedSize = 20; + int expectedTraversalSize = 0; + int expectedRoots = 0; validateHierarchicalContainer(container, "com.vaadin.data.BufferedValidatable", "com.vaadin.ui.TabSheet", - "com.vaadin.terminal.gwt.client.Focusable", "blah", 20, 0); + "com.vaadin.terminal.gwt.client.Focusable", "blah", true, + expectedSize, expectedTraversalSize, expectedRoots); // filter out every second item except hierarchy items filterable.removeAllContainerFilters(); - filterable.addContainerFilter(PROP3, "1", false, false); + filterable.addContainerFilter(ID_NUMBER, "1", false, false); int packages = 21; int other = sampleData.length / 2; + + expectedSize = packages + other; + expectedRoots = 1; + expectedTraversalSize = expectedSize; + validateHierarchicalContainer(container, "com", "com.vaadin.util", - "com.vaadin.data.util.IndexedContainer", - "com.vaadin.data.util.ObjectProperty", packages + other, 0); + "com.vaadin.data.util.IndexedContainer", "blah", true, + expectedSize, expectedTraversalSize, expectedRoots); + + // Additionally remove all without 'm' in the simple name. Hierarchy is + // now one root only. + filterable.addContainerFilter(SIMPLE_NAME, "m", false, false); - // Additionally remove all without 'm'. Hierarchy is now one root only. - filterable.addContainerFilter(PROP1, "m", false, false); + expectedSize = 27; + expectedRoots = 1; + expectedTraversalSize = 1; - validateHierarchicalContainer(container, "com.vaadin.data.Buffered", - "com.vaadin.terminal.gwt.server.ComponentSizeValidator", - "com.vaadin.data.util.IndexedContainer", - "com.vaadin.terminal.gwt.client.ui.VUriFragmentUtility", - packages + other, 0); + validateHierarchicalContainer(container, "com", + "com.vaadin.ui.UriFragmentUtility", + "com.vaadin.terminal.gwt.client.ui.TreeImages", "blah", false, + expectedSize, expectedTraversalSize, expectedRoots); } @@ -189,9 +237,11 @@ public class AbstractHierarchicalContainerTest extends AbstractContainerTest { container.removeContainerProperty(propertyId); } - container.addContainerProperty(PROP1, String.class, ""); - container.addContainerProperty(PROP2, String.class, null); - container.addContainerProperty(PROP3, Integer.class, null); + container.addContainerProperty(FULLY_QUALIFIED_NAME, String.class, ""); + container.addContainerProperty(SIMPLE_NAME, String.class, ""); + container.addContainerProperty(REVERSE_FULLY_QUALIFIED_NAME, + String.class, null); + container.addContainerProperty(ID_NUMBER, Integer.class, null); for (int i = 0; i < sampleData.length; i++) { String id = sampleData[i]; @@ -204,9 +254,11 @@ public class AbstractHierarchicalContainerTest extends AbstractContainerTest { if (container.addItem(path) != null) { assertTrue(container.setChildrenAllowed(path, false)); Item item = container.getItem(path); - item.getItemProperty(PROP1).setValue(path); - item.getItemProperty(PROP2).setValue(reverse(path)); - item.getItemProperty(PROP3).setValue(1); + item.getItemProperty(FULLY_QUALIFIED_NAME).setValue(path); + item.getItemProperty(SIMPLE_NAME).setValue(getSimpleName(path)); + item.getItemProperty(REVERSE_FULLY_QUALIFIED_NAME).setValue( + reverse(path)); + item.getItemProperty(ID_NUMBER).setValue(1); } for (int j = 1; j < paths.length; j++) { String parent = path; @@ -218,9 +270,12 @@ public class AbstractHierarchicalContainerTest extends AbstractContainerTest { assertTrue(container.setChildrenAllowed(path, false)); Item item = container.getItem(path); - item.getItemProperty(PROP1).setValue(path); - item.getItemProperty(PROP2).setValue(reverse(path)); - item.getItemProperty(PROP3).setValue(1); + item.getItemProperty(FULLY_QUALIFIED_NAME).setValue(path); + item.getItemProperty(SIMPLE_NAME).setValue( + getSimpleName(path)); + item.getItemProperty(REVERSE_FULLY_QUALIFIED_NAME) + .setValue(reverse(path)); + item.getItemProperty(ID_NUMBER).setValue(1); } assertTrue(container.setChildrenAllowed(parent, true)); @@ -233,9 +288,12 @@ public class AbstractHierarchicalContainerTest extends AbstractContainerTest { assertNotNull(item); String parent = id.substring(0, id.lastIndexOf('.')); assertTrue(container.setParent(id, parent)); - item.getItemProperty(PROP1).setValue(sampleData[i]); - item.getItemProperty(PROP2).setValue(reverse(sampleData[i])); - item.getItemProperty(PROP3).setValue(i % 2); + item.getItemProperty(FULLY_QUALIFIED_NAME).setValue(sampleData[i]); + item.getItemProperty(SIMPLE_NAME).setValue( + getSimpleName(sampleData[i])); + item.getItemProperty(REVERSE_FULLY_QUALIFIED_NAME).setValue( + reverse(sampleData[i])); + item.getItemProperty(ID_NUMBER).setValue(i % 2); } } diff --git a/tests/src/com/vaadin/tests/server/container/TestHierarchicalContainer.java b/tests/src/com/vaadin/tests/server/container/TestHierarchicalContainer.java index 79f1cf6075..0f60e133c1 100644 --- a/tests/src/com/vaadin/tests/server/container/TestHierarchicalContainer.java +++ b/tests/src/com/vaadin/tests/server/container/TestHierarchicalContainer.java @@ -21,6 +21,10 @@ public class TestHierarchicalContainer extends testContainerSorting(new HierarchicalContainer()); } + public void testOrdered() { + testContainerOrdered(new HierarchicalContainer()); + } + public void testHierarchicalSorting() { testHierarchicalSorting(new HierarchicalContainer()); } -- 2.39.5