More JUnit tests for BeanItemContainer and IndexedContainer

svn changeset:16129/svn branch:6.5

diff --git a/tests/src/com/vaadin/tests/server/container/AbstractContainerTest.java b/tests/src/com/vaadin/tests/server/container/AbstractContainerTest.java
index 80cdfc1b6d3c4ece5db7fd7386d95b2020d8a13e..2b8dd1eecfa927c42c8ab70120e73f30c843ec61 100644 (file)
--- a/tests/src/com/vaadin/tests/server/container/AbstractContainerTest.java
+++ b/tests/src/com/vaadin/tests/server/container/AbstractContainerTest.java
@@ -3,6 +3,7 @@ package com.vaadin.tests.server.container;
 import java.util.ArrayList;\r
 import java.util.List;\r
 \r
+import junit.framework.Assert;\r
 import junit.framework.TestCase;\r
 \r
 import com.vaadin.data.Container;\r
@@ -172,6 +173,83 @@ public abstract class AbstractContainerTest extends TestCase {
 \r
     }\r
 \r
+    protected void testContainerIndexed(Container.Indexed container,\r
+            Object itemId, int itemPosition, boolean testAddEmptyItemAt,\r
+            Object newItemId, boolean testAddItemAtWithId) {\r
+        initializeContainer(container);\r
+\r
+        // indexOfId\r
+        Assert.assertEquals(itemPosition, container.indexOfId(itemId));\r
+\r
+        // getIdByIndex\r
+        Assert.assertEquals(itemId, container.getIdByIndex(itemPosition));\r
+\r
+        // addItemAt\r
+        if (testAddEmptyItemAt) {\r
+            Object addedId = container.addItemAt(itemPosition);\r
+            Assert.assertEquals(itemPosition, container.indexOfId(addedId));\r
+            Assert.assertEquals(itemPosition + 1, container.indexOfId(itemId));\r
+            Assert.assertEquals(addedId, container.getIdByIndex(itemPosition));\r
+            Assert.assertEquals(itemId,\r
+                    container.getIdByIndex(itemPosition + 1));\r
+\r
+            Object newFirstId = container.addItemAt(0);\r
+            Assert.assertEquals(0, container.indexOfId(newFirstId));\r
+            Assert.assertEquals(itemPosition + 2, container.indexOfId(itemId));\r
+            Assert.assertEquals(newFirstId, container.firstItemId());\r
+            Assert.assertEquals(newFirstId, container.getIdByIndex(0));\r
+            Assert.assertEquals(itemId,\r
+                    container.getIdByIndex(itemPosition + 2));\r
+\r
+            Object newLastId = container.addItemAt(container.size());\r
+            Assert.assertEquals(container.size() - 1,\r
+                    container.indexOfId(newLastId));\r
+            Assert.assertEquals(itemPosition + 2, container.indexOfId(itemId));\r
+            Assert.assertEquals(newLastId, container.lastItemId());\r
+            Assert.assertEquals(newLastId,\r
+                    container.getIdByIndex(container.size() - 1));\r
+            Assert.assertEquals(itemId,\r
+                    container.getIdByIndex(itemPosition + 2));\r
+\r
+            container.removeItem(addedId);\r
+            container.removeItem(newFirstId);\r
+            container.removeItem(newLastId);\r
+        }\r
+\r
+        // addItemAt\r
+        if (testAddItemAtWithId) {\r
+            container.addItemAt(itemPosition, newItemId);\r
+            Assert.assertEquals(itemPosition, container.indexOfId(newItemId));\r
+            Assert.assertEquals(itemPosition + 1, container.indexOfId(itemId));\r
+            Assert.assertEquals(newItemId, container.getIdByIndex(itemPosition));\r
+            Assert.assertEquals(itemId,\r
+                    container.getIdByIndex(itemPosition + 1));\r
+            container.removeItem(newItemId);\r
+            Assert.assertFalse(container.containsId(newItemId));\r
+\r
+            container.addItemAt(0, newItemId);\r
+            Assert.assertEquals(0, container.indexOfId(newItemId));\r
+            Assert.assertEquals(itemPosition + 1, container.indexOfId(itemId));\r
+            Assert.assertEquals(newItemId, container.firstItemId());\r
+            Assert.assertEquals(newItemId, container.getIdByIndex(0));\r
+            Assert.assertEquals(itemId,\r
+                    container.getIdByIndex(itemPosition + 1));\r
+            container.removeItem(newItemId);\r
+            Assert.assertFalse(container.containsId(newItemId));\r
+\r
+            container.addItemAt(container.size(), newItemId);\r
+            Assert.assertEquals(container.size() - 1,\r
+                    container.indexOfId(newItemId));\r
+            Assert.assertEquals(itemPosition, container.indexOfId(itemId));\r
+            Assert.assertEquals(newItemId, container.lastItemId());\r
+            Assert.assertEquals(newItemId,\r
+                    container.getIdByIndex(container.size() - 1));\r
+            Assert.assertEquals(itemId, container.getIdByIndex(itemPosition));\r
+            container.removeItem(newItemId);\r
+            Assert.assertFalse(container.containsId(newItemId));\r
+        }\r
+    }\r
+\r
     protected void testContainerFiltering(Container.Filterable container) {\r
         initializeContainer(container);\r
 \r
@@ -528,5 +606,4 @@ public abstract class AbstractContainerTest extends TestCase {
             "com.vaadin.ui.VerticalLayout", "com.vaadin.ui.Window",\r
             "com.vaadin.util.SerializerHelper", "org.vaadin.test.LastClass" };\r
 \r
-    // TODO testContainerIndexing(Container.Indexed) & use in subclasses\r
 }\r

diff --git a/tests/src/com/vaadin/tests/server/container/AbstractHierarchicalContainerTest.java b/tests/src/com/vaadin/tests/server/container/AbstractHierarchicalContainerTest.java
index 7d0aa6f5e5cf5d12b9688ed0efec9a73faa83416..5c4dfc658feded921be2cc75cdb6b6dc2e170496 100644 (file)
--- a/tests/src/com/vaadin/tests/server/container/AbstractHierarchicalContainerTest.java
+++ b/tests/src/com/vaadin/tests/server/container/AbstractHierarchicalContainerTest.java
@@ -7,7 +7,8 @@ import com.vaadin.data.Container.Hierarchical;
 import com.vaadin.data.Container.Sortable;\r
 import com.vaadin.data.Item;\r
 \r
-public class AbstractHierarchicalContainerTest extends AbstractContainerTest {\r
+public abstract class AbstractHierarchicalContainerTest extends\r
+        AbstractContainerTest {\r
 \r
     /**\r
      * @param container\r

diff --git a/tests/src/com/vaadin/tests/server/container/BeanItemContainerTest.java b/tests/src/com/vaadin/tests/server/container/BeanItemContainerTest.java
index 3fc03c97eaf25f0ce2cde550436c9892bffa9584..fa764998607e9a658d1d226e372392a975af5724 100644 (file)
--- a/tests/src/com/vaadin/tests/server/container/BeanItemContainerTest.java
+++ b/tests/src/com/vaadin/tests/server/container/BeanItemContainerTest.java
@@ -1,9 +1,19 @@
 package com.vaadin.tests.server.container;
 
-import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 
+import junit.framework.Assert;
+
+import org.easymock.EasyMock;
+
 import com.vaadin.data.Container;
+import com.vaadin.data.Container.ItemSetChangeEvent;
+import com.vaadin.data.Container.ItemSetChangeListener;
 import com.vaadin.data.Item;
 import com.vaadin.data.util.BeanItemContainer;
 
@@ -65,24 +75,32 @@ public class BeanItemContainerTest extends AbstractContainerTest {
         }
     }
 
-    private Map<String, ClassName> nameToBean = new HashMap<String, ClassName>();
+    private Map<String, ClassName> nameToBean = new LinkedHashMap<String, ClassName>();
 
     private BeanItemContainer<ClassName> getContainer() {
         return new BeanItemContainer<ClassName>(ClassName.class);
     }
 
+    @Override
+    public void setUp() {
+        nameToBean.clear();
+
+        for (int i = 0; i < sampleData.length; i++) {
+            ClassName className = new ClassName(sampleData[i], i);
+            nameToBean.put(sampleData[i], className);
+        }
+    }
+
     @Override
     @SuppressWarnings("unchecked")
     protected void initializeContainer(Container container) {
         BeanItemContainer<ClassName> beanItemContainer = (BeanItemContainer<ClassName>) container;
 
         beanItemContainer.removeAllItems();
-        nameToBean.clear();
 
-        for (int i = 0; i < sampleData.length; i++) {
-            ClassName className = new ClassName(sampleData[i], i);
-            nameToBean.put(sampleData[i], className);
-            beanItemContainer.addBean(className);
+        Iterator<ClassName> it = nameToBean.values().iterator();
+        while (it.hasNext()) {
+            beanItemContainer.addBean(it.next());
         }
     }
 
@@ -196,4 +214,169 @@ public class BeanItemContainerTest extends AbstractContainerTest {
 
     }
 
+    public void testContainerIndexed() {
+        testContainerIndexed(getContainer(), nameToBean.get(sampleData[2]), 2,
+                false, new ClassName("org.vaadin.test.Test", 8888), true);
+    }
+
+    // note that the constructor tested here is problematic, and should also
+    // take the bean class as a parameter
+    public void testCollectionConstructor() {
+        List<ClassName> classNames = new ArrayList<ClassName>();
+        classNames.add(new ClassName("a.b.c.Def", 1));
+        classNames.add(new ClassName("a.b.c.Fed", 2));
+        classNames.add(new ClassName("b.c.d.Def", 3));
+
+        BeanItemContainer<ClassName> container = new BeanItemContainer<ClassName>(
+                classNames);
+
+        Assert.assertEquals(3, container.size());
+        Assert.assertEquals(classNames.get(0), container.firstItemId());
+        Assert.assertEquals(classNames.get(1), container.getIdByIndex(1));
+        Assert.assertEquals(classNames.get(2), container.lastItemId());
+    }
+
+    // this only applies to the collection constructor with no type parameter
+    public void testEmptyCollectionConstructor() {
+        try {
+            BeanItemContainer<ClassName> container = new BeanItemContainer<ClassName>(
+                    (Collection<ClassName>) null);
+            Assert.fail("Initializing BeanItemContainer from a null collection should not work!");
+        } catch (IllegalArgumentException e) {
+            // success
+        }
+        try {
+            BeanItemContainer<ClassName> container = new BeanItemContainer<ClassName>(
+                    new ArrayList<ClassName>());
+            Assert.fail("Initializing BeanItemContainer from an empty collection should not work!");
+        } catch (IllegalArgumentException e) {
+            // success
+        }
+    }
+
+    protected abstract class ItemSetChangeListenerTester {
+        public void listenerTest() {
+            listenerTest(true);
+        }
+
+        public void listenerTest(boolean expectChangeEvent) {
+            BeanItemContainer<ClassName> container = prepareContainer();
+
+            ItemSetChangeListener listener = EasyMock
+                    .createStrictMock(ItemSetChangeListener.class);
+
+            // Expectations and start test
+            if (expectChangeEvent) {
+                listener.containerItemSetChange(EasyMock
+                        .isA(ItemSetChangeEvent.class));
+            }
+            EasyMock.replay(listener);
+
+            // Add listener and add a property -> should end up in listener
+            // once
+            container.addListener(listener);
+            performModification(container);
+
+            // Ensure listener was called once
+            EasyMock.verify(listener);
+
+            // Remove the listener
+            container.removeListener(listener);
+            performModification(container);
+
+            // Ensure listener has not been called again
+            EasyMock.verify(listener);
+        }
+
+        protected BeanItemContainer<ClassName> prepareContainer() {
+            BeanItemContainer<ClassName> container = getContainer();
+            initializeContainer(container);
+            return container;
+        }
+
+        protected abstract void performModification(
+                BeanItemContainer<ClassName> container);
+    }
+
+    public void testItemSetChangeListeners() {
+        new ItemSetChangeListenerTester() {
+            @Override
+            protected void performModification(
+                    BeanItemContainer<ClassName> container) {
+                container.addBean(new ClassName("com.example.Test", 1111));
+            }
+        }.listenerTest();
+
+        new ItemSetChangeListenerTester() {
+            @Override
+            protected void performModification(
+                    BeanItemContainer<ClassName> container) {
+                container.removeItem(nameToBean.get(sampleData[0]));
+            }
+        }.listenerTest();
+
+        new ItemSetChangeListenerTester() {
+            @Override
+            protected void performModification(
+                    BeanItemContainer<ClassName> container) {
+                container.removeItem(new ClassName("com.example.Test", 1111));
+            }
+        }.listenerTest(false);
+
+        new ItemSetChangeListenerTester() {
+            @Override
+            protected void performModification(
+                    BeanItemContainer<ClassName> container) {
+                // this test does not check that there would be no second
+                // notification because the collection is already empty
+                container.removeAllItems();
+            }
+        }.listenerTest();
+
+        new ItemSetChangeListenerTester() {
+            private int propertyIndex = 0;
+
+            @Override
+            protected void performModification(
+                    BeanItemContainer<ClassName> container) {
+                Collection<String> containerPropertyIds = container
+                        .getContainerPropertyIds();
+                container.addContainerFilter(new ArrayList<String>(
+                        containerPropertyIds).get(propertyIndex++), "a", true,
+                        false);
+            }
+        }.listenerTest();
+
+        new ItemSetChangeListenerTester() {
+            @Override
+            protected void performModification(
+                    BeanItemContainer<ClassName> container) {
+                container.removeContainerFilters(SIMPLE_NAME);
+            }
+
+            @Override
+            protected BeanItemContainer<ClassName> prepareContainer() {
+                BeanItemContainer<ClassName> container = super
+                        .prepareContainer();
+                container.addContainerFilter(SIMPLE_NAME, "a", true, false);
+                return container;
+            };
+        }.listenerTest();
+
+        new ItemSetChangeListenerTester() {
+            @Override
+            protected void performModification(
+                    BeanItemContainer<ClassName> container) {
+                container.removeAllContainerFilters();
+            }
+
+            @Override
+            protected BeanItemContainer<ClassName> prepareContainer() {
+                BeanItemContainer<ClassName> container = super
+                        .prepareContainer();
+                container.addContainerFilter(SIMPLE_NAME, "a", true, false);
+                return container;
+            };
+        }.listenerTest();
+    }
 }

diff --git a/tests/src/com/vaadin/tests/server/container/TestIndexedContainer.java b/tests/src/com/vaadin/tests/server/container/TestIndexedContainer.java
index 13e8e17c484155813f9f7317e5c98fc9b98d04f5..1bb80b25b31c66d1628be0b36c4f9ed44cb2fbaf 100644 (file)
--- a/tests/src/com/vaadin/tests/server/container/TestIndexedContainer.java
+++ b/tests/src/com/vaadin/tests/server/container/TestIndexedContainer.java
@@ -24,4 +24,9 @@ public class TestIndexedContainer extends AbstractContainerTest {
         testContainerOrdered(new IndexedContainer());\r
     }\r
 \r
+    public void testContainerIndexed() {\r
+        testContainerIndexed(new IndexedContainer(), sampleData[2], 2, true,\r
+                "newItemId", true);\r
+    }\r
+\r
 }\r