1 files changed, 516 insertions, 0 deletions
diff --git a/compatibility-server/src/test/java/com/vaadin/data/util/BeanContainerTest.java b/compatibility-server/src/test/java/com/vaadin/data/util/BeanContainerTest.java
new file mode 100644
index 0000000000..bdf6ba1958
--- /dev/null
+++ b/compatibility-server/src/test/java/com/vaadin/data/util/BeanContainerTest.java
@@ -0,0 +1,516 @@
+package com.vaadin.data.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.vaadin.data.Container;
+import com.vaadin.data.Item;
+import com.vaadin.data.util.AbstractBeanContainer.BeanIdResolver;
+
+public class BeanContainerTest extends AbstractBeanContainerTestBase {
+
+    protected static class PersonNameResolver
+            implements BeanIdResolver<String, Person> {
+
+        @Override
+        public String getIdForBean(Person bean) {
+            return bean != null ? bean.getName() : null;
+        }
+
+    }
+
+    protected static class NullResolver
+            implements BeanIdResolver<String, Person> {
+
+        @Override
+        public String getIdForBean(Person bean) {
+            return null;
+        }
+
+    }
+
+    private Map<String, ClassName> nameToBean = new LinkedHashMap<String, ClassName>();
+
+    private BeanContainer<String, ClassName> getContainer() {
+        return new BeanContainer<String, ClassName>(ClassName.class);
+    }
+
+    @Before
+    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) {
+        BeanContainer<String, ClassName> beanItemContainer = (BeanContainer<String, ClassName>) container;
+
+        beanItemContainer.removeAllItems();
+
+        for (Entry<String, ClassName> entry : nameToBean.entrySet()) {
+            beanItemContainer.addItem(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    protected boolean isFilteredOutItemNull() {
+        return false;
+    }
+
+    @Test
+    public void testGetType_existingProperty_typeReturned() {
+        BeanContainer<String, ClassName> container = getContainer();
+        Assert.assertEquals(
+                "Unexpected type is returned for property 'simpleName'",
+                String.class, container.getType("simpleName"));
+    }
+
+    @Test
+    public void testGetType_notExistingProperty_nullReturned() {
+        BeanContainer<String, ClassName> container = getContainer();
+        Assert.assertNull("Not null type is returned for property ''",
+                container.getType(""));
+    }
+
+    @Test
+    public void testBasicOperations() {
+        testBasicContainerOperations(getContainer());
+    }
+
+    @Test
+    public void testFiltering() {
+        testContainerFiltering(getContainer());
+    }
+
+    @Test
+    public void testSorting() {
+        testContainerSorting(getContainer());
+    }
+
+    @Test
+    public void testSortingAndFiltering() {
+        testContainerSortingAndFiltering(getContainer());
+    }
+
+    // duplicated from parent class and modified - adding items to
+    // BeanContainer differs from other containers
+    @Test
+    public void testContainerOrdered() {
+        BeanContainer<String, String> container = new BeanContainer<String, String>(
+                String.class);
+
+        String id = "test1";
+
+        Item item = container.addItem(id, "value");
+        assertNotNull(item);
+
+        assertEquals(id, container.firstItemId());
+        assertEquals(id, container.lastItemId());
+
+        // isFirstId
+        assertTrue(container.isFirstId(id));
+        assertTrue(container.isFirstId(container.firstItemId()));
+        // isLastId
+        assertTrue(container.isLastId(id));
+        assertTrue(container.isLastId(container.lastItemId()));
+
+        // Add a new item before the first
+        // addItemAfter
+        String newFirstId = "newFirst";
+        item = container.addItemAfter(null, newFirstId, "newFirstValue");
+        assertNotNull(item);
+        assertNotNull(container.getItem(newFirstId));
+
+        // isFirstId
+        assertTrue(container.isFirstId(newFirstId));
+        assertTrue(container.isFirstId(container.firstItemId()));
+        // isLastId
+        assertTrue(container.isLastId(id));
+        assertTrue(container.isLastId(container.lastItemId()));
+
+        // nextItemId
+        assertEquals(id, container.nextItemId(newFirstId));
+        assertNull(container.nextItemId(id));
+        assertNull(container.nextItemId("not-in-container"));
+
+        // prevItemId
+        assertEquals(newFirstId, container.prevItemId(id));
+        assertNull(container.prevItemId(newFirstId));
+        assertNull(container.prevItemId("not-in-container"));
+
+        // addItemAfter(IDTYPE, IDTYPE, BT)
+        String newSecondItemId = "newSecond";
+        item = container.addItemAfter(newFirstId, newSecondItemId,
+                "newSecondValue");
+        // order is now: newFirstId, newSecondItemId, id
+        assertNotNull(item);
+        assertNotNull(container.getItem(newSecondItemId));
+        assertEquals(id, container.nextItemId(newSecondItemId));
+        assertEquals(newFirstId, container.prevItemId(newSecondItemId));
+
+        // addItemAfter(IDTYPE, IDTYPE, BT)
+        String fourthId = "id of the fourth item";
+        Item fourth = container.addItemAfter(newFirstId, fourthId,
+                "fourthValue");
+        // order is now: newFirstId, fourthId, newSecondItemId, id
+        assertNotNull(fourth);
+        assertEquals(fourth, container.getItem(fourthId));
+        assertEquals(newSecondItemId, container.nextItemId(fourthId));
+        assertEquals(newFirstId, container.prevItemId(fourthId));
+
+        // addItemAfter(IDTYPE, IDTYPE, BT)
+        String fifthId = "fifth";
+        Item fifth = container.addItemAfter(null, fifthId, "fifthValue");
+        // order is now: fifthId, newFirstId, fourthId, newSecondItemId, id
+        assertNotNull(fifth);
+        assertEquals(fifth, container.getItem(fifthId));
+        assertEquals(newFirstId, container.nextItemId(fifthId));
+        assertNull(container.prevItemId(fifthId));
+
+    }
+
+    // TODO test Container.Indexed interface operation - testContainerIndexed()?
+
+    @Test
+    public void testAddItemAt() {
+        BeanContainer<String, String> container = new BeanContainer<String, String>(
+                String.class);
+
+        container.addItem("id1", "value1");
+        // id1
+        container.addItemAt(0, "id2", "value2");
+        // id2, id1
+        container.addItemAt(1, "id3", "value3");
+        // id2, id3, id1
+        container.addItemAt(container.size(), "id4", "value4");
+        // id2, id3, id1, id4
+
+        assertNull(container.addItemAt(-1, "id5", "value5"));
+        assertNull(container.addItemAt(container.size() + 1, "id6", "value6"));
+
+        assertEquals(4, container.size());
+        assertEquals("id2", container.getIdByIndex(0));
+        assertEquals("id3", container.getIdByIndex(1));
+        assertEquals("id1", container.getIdByIndex(2));
+        assertEquals("id4", container.getIdByIndex(3));
+    }
+
+    @Test
+    public void testUnsupportedMethods() {
+        BeanContainer<String, Person> container = new BeanContainer<String, Person>(
+                Person.class);
+        container.addItem("John", new Person("John"));
+
+        try {
+            container.addItem();
+            Assert.fail();
+        } catch (UnsupportedOperationException e) {
+            // should get exception
+        }
+
+        try {
+            container.addItem(null);
+            Assert.fail();
+        } catch (UnsupportedOperationException e) {
+            // should get exception
+        }
+
+        try {
+            container.addItemAfter(null, null);
+            Assert.fail();
+        } catch (UnsupportedOperationException e) {
+            // should get exception
+        }
+
+        try {
+            container.addItemAfter(new Person("Jane"));
+            Assert.fail();
+        } catch (UnsupportedOperationException e) {
+            // should get exception
+        }
+
+        try {
+            container.addItemAt(0);
+            Assert.fail();
+        } catch (UnsupportedOperationException e) {
+            // should get exception
+        }
+
+        try {
+            container.addItemAt(0, new Person("Jane"));
+            Assert.fail();
+        } catch (UnsupportedOperationException e) {
+            // should get exception
+        }
+
+        try {
+            container.addContainerProperty("lastName", String.class, "");
+            Assert.fail();
+        } catch (UnsupportedOperationException e) {
+            // should get exception
+        }
+
+        assertEquals(1, container.size());
+    }
+
+    @Test
+    public void testRemoveContainerProperty() {
+        BeanContainer<String, Person> container = new BeanContainer<String, Person>(
+                Person.class);
+        container.setBeanIdResolver(new PersonNameResolver());
+        container.addBean(new Person("John"));
+
+        Assert.assertEquals("John",
+                container.getContainerProperty("John", "name").getValue());
+        Assert.assertTrue(container.removeContainerProperty("name"));
+        Assert.assertNull(container.getContainerProperty("John", "name"));
+
+        Assert.assertNotNull(container.getItem("John"));
+        // property removed also from item
+        Assert.assertNull(container.getItem("John").getItemProperty("name"));
+    }
+
+    @Test
+    public void testAddNullBeans() {
+        BeanContainer<String, Person> container = new BeanContainer<String, Person>(
+                Person.class);
+
+        assertNull(container.addItem("id1", null));
+        assertNull(container.addItemAfter(null, "id2", null));
+        assertNull(container.addItemAt(0, "id3", null));
+
+        assertEquals(0, container.size());
+    }
+
+    @Test
+    public void testAddNullId() {
+        BeanContainer<String, Person> container = new BeanContainer<String, Person>(
+                Person.class);
+
+        Person john = new Person("John");
+
+        assertNull(container.addItem(null, john));
+        assertNull(container.addItemAfter(null, null, john));
+        assertNull(container.addItemAt(0, null, john));
+
+        assertEquals(0, container.size());
+    }
+
+    @Test
+    public void testEmptyContainer() {
+        BeanContainer<String, Person> container = new BeanContainer<String, Person>(
+                Person.class);
+
+        assertNull(container.firstItemId());
+        assertNull(container.lastItemId());
+
+        assertEquals(0, container.size());
+
+        // could test more about empty container
+    }
+
+    @Test
+    public void testAddBeanWithoutResolver() {
+        BeanContainer<String, Person> container = new BeanContainer<String, Person>(
+                Person.class);
+
+        try {
+            container.addBean(new Person("John"));
+            Assert.fail();
+        } catch (IllegalStateException e) {
+            // should get exception
+        }
+        try {
+            container.addBeanAfter(null, new Person("Jane"));
+            Assert.fail();
+        } catch (IllegalStateException e) {
+            // should get exception
+        }
+        try {
+            container.addBeanAt(0, new Person("Jack"));
+            Assert.fail();
+        } catch (IllegalStateException e) {
+            // should get exception
+        }
+        try {
+            container
+                    .addAll(Arrays.asList(new Person[] { new Person("Jack") }));
+            Assert.fail();
+        } catch (IllegalStateException e) {
+            // should get exception
+        }
+
+        assertEquals(0, container.size());
+    }
+
+    @Test
+    public void testAddAllWithNullItemId() {
+        BeanContainer<String, Person> container = new BeanContainer<String, Person>(
+                Person.class);
+        // resolver that returns null as item id
+        container.setBeanIdResolver(
+                new BeanIdResolver<String, AbstractBeanContainerTestBase.Person>() {
+
+                    @Override
+                    public String getIdForBean(Person bean) {
+                        return bean.getName();
+                    }
+                });
+
+        List<Person> persons = new ArrayList<Person>();
+        persons.add(new Person("John"));
+        persons.add(new Person("Marc"));
+        persons.add(new Person(null));
+        persons.add(new Person("foo"));
+
+        try {
+            container.addAll(persons);
+            fail();
+        } catch (IllegalArgumentException e) {
+            // should get exception
+        }
+
+        container.removeAllItems();
+        persons.remove(2);
+        container.addAll(persons);
+        assertEquals(3, container.size());
+    }
+
+    @Test
+    public void testAddBeanWithNullResolver() {
+        BeanContainer<String, Person> container = new BeanContainer<String, Person>(
+                Person.class);
+        // resolver that returns null as item id
+        container.setBeanIdResolver(new NullResolver());
+
+        try {
+            container.addBean(new Person("John"));
+            Assert.fail();
+        } catch (IllegalArgumentException e) {
+            // should get exception
+        }
+        try {
+            container.addBeanAfter(null, new Person("Jane"));
+            Assert.fail();
+        } catch (IllegalArgumentException e) {
+            // should get exception
+        }
+        try {
+            container.addBeanAt(0, new Person("Jack"));
+            Assert.fail();
+        } catch (IllegalArgumentException e) {
+            // should get exception
+        }
+
+        assertEquals(0, container.size());
+    }
+
+    @Test
+    public void testAddBeanWithResolver() {
+        BeanContainer<String, Person> container = new BeanContainer<String, Person>(
+                Person.class);
+        container.setBeanIdResolver(new PersonNameResolver());
+
+        assertNotNull(container.addBean(new Person("John")));
+        assertNotNull(container.addBeanAfter(null, new Person("Jane")));
+        assertNotNull(container.addBeanAt(0, new Person("Jack")));
+
+        container.addAll(Arrays.asList(
+                new Person[] { new Person("Jill"), new Person("Joe") }));
+
+        assertTrue(container.containsId("John"));
+        assertTrue(container.containsId("Jane"));
+        assertTrue(container.containsId("Jack"));
+        assertTrue(container.containsId("Jill"));
+        assertTrue(container.containsId("Joe"));
+        assertEquals(3, container.indexOfId("Jill"));
+        assertEquals(4, container.indexOfId("Joe"));
+        assertEquals(5, container.size());
+    }
+
+    @Test
+    public void testAddNullBeansWithResolver() {
+        BeanContainer<String, Person> container = new BeanContainer<String, Person>(
+                Person.class);
+        container.setBeanIdResolver(new PersonNameResolver());
+
+        assertNull(container.addBean(null));
+        assertNull(container.addBeanAfter(null, null));
+        assertNull(container.addBeanAt(0, null));
+
+        assertEquals(0, container.size());
+    }
+
+    @Test
+    public void testAddBeanWithPropertyResolver() {
+        BeanContainer<String, Person> container = new BeanContainer<String, Person>(
+                Person.class);
+        container.setBeanIdProperty("name");
+
+        assertNotNull(container.addBean(new Person("John")));
+        assertNotNull(container.addBeanAfter(null, new Person("Jane")));
+        assertNotNull(container.addBeanAt(0, new Person("Jack")));
+
+        container.addAll(Arrays.asList(
+                new Person[] { new Person("Jill"), new Person("Joe") }));
+
+        assertTrue(container.containsId("John"));
+        assertTrue(container.containsId("Jane"));
+        assertTrue(container.containsId("Jack"));
+        assertTrue(container.containsId("Jill"));
+        assertTrue(container.containsId("Joe"));
+        assertEquals(3, container.indexOfId("Jill"));
+        assertEquals(4, container.indexOfId("Joe"));
+        assertEquals(5, container.size());
+    }
+
+    @Test
+    public void testAddNestedContainerProperty() {
+        BeanContainer<String, NestedMethodPropertyTest.Person> container = new BeanContainer<String, NestedMethodPropertyTest.Person>(
+                NestedMethodPropertyTest.Person.class);
+        container.setBeanIdProperty("name");
+
+        container.addBean(new NestedMethodPropertyTest.Person("John",
+                new NestedMethodPropertyTest.Address("Ruukinkatu 2-4", 20540)));
+
+        assertTrue(container.addNestedContainerProperty("address.street"));
+        assertEquals("Ruukinkatu 2-4", container
+                .getContainerProperty("John", "address.street").getValue());
+    }
+
+    @Test
+    public void testNestedContainerPropertyWithNullBean() {
+        BeanContainer<String, NestedMethodPropertyTest.Person> container = new BeanContainer<String, NestedMethodPropertyTest.Person>(
+                NestedMethodPropertyTest.Person.class);
+        container.setBeanIdProperty("name");
+
+        container.addBean(new NestedMethodPropertyTest.Person("John", null));
+        assertTrue(container
+                .addNestedContainerProperty("address.postalCodeObject"));
+        assertTrue(container.addNestedContainerProperty("address.street"));
+        // the nested properties added with allowNullBean setting should return
+        // null
+        assertNull(container.getContainerProperty("John", "address.street")
+                .getValue());
+    }
+
+}