#6286 Container filtering improvements: javadoc, more unit tests

svn changeset:17819/svn branch:6.6

src/com/vaadin/data/util/filter/Compare.java

@@ -49,9 +49,10 @@ public abstract class Compare implements Filter {
          * 
          * @param propertyId
          *            the identifier of the property whose value to compare
-         *            against value
+         *            against value, not null
          * @param value
-         *            the value to compare against
+         *            the value to compare against - null values may or may not
+         *            be supported depending on the container
          */
         public Equal(Object propertyId, Object value) {
             super(propertyId, value, Operation.EQUAL);
@@ -81,9 +82,10 @@ public abstract class Compare implements Filter {
          * 
          * @param propertyId
          *            the identifier of the property whose value to compare
-         *            against value
+         *            against value, not null
          * @param value
-         *            the value to compare against
+         *            the value to compare against - null values may or may not
+         *            be supported depending on the container
          */
         public Greater(Object propertyId, Object value) {
             super(propertyId, value, Operation.GREATER);
@@ -113,9 +115,10 @@ public abstract class Compare implements Filter {
          * 
          * @param propertyId
          *            the identifier of the property whose value to compare
-         *            against value
+         *            against value, not null
          * @param value
-         *            the value to compare against
+         *            the value to compare against - null values may or may not
+         *            be supported depending on the container
          */
         public Less(Object propertyId, Object value) {
             super(propertyId, value, Operation.LESS);
@@ -145,9 +148,10 @@ public abstract class Compare implements Filter {
          * 
          * @param propertyId
          *            the identifier of the property whose value to compare
-         *            against value
+         *            against value, not null
          * @param value
-         *            the value to compare against
+         *            the value to compare against - null values may or may not
+         *            be supported depending on the container
          */
         public GreaterOrEqual(Object propertyId, Object value) {
             super(propertyId, value, Operation.GREATER_OR_EQUAL);
@@ -177,9 +181,10 @@ public abstract class Compare implements Filter {
          * 
          * @param propertyId
          *            the identifier of the property whose value to compare
-         *            against value
+         *            against value, not null
          * @param value
-         *            the value to compare against
+         *            the value to compare against - null values may or may not
+         *            be supported depending on the container
          */
         public LessOrEqual(Object propertyId, Object value) {
             super(propertyId, value, Operation.LESS_OR_EQUAL);
@@ -206,9 +211,10 @@ public abstract class Compare implements Filter {
      * 
      * @param propertyId
      *            the identifier of the property whose value to compare against
-     *            value
+     *            value, not null
      * @param value
-     *            the value to compare against
+     *            the value to compare against - null values may or may not be
+     *            supported depending on the container
      * @param operation
      *            the comparison {@link Operation} to use
      */
@@ -290,7 +296,7 @@ public abstract class Compare implements Filter {
      * Returns the property id of the property to compare against the fixed
      * value.
      * 
-     * @return property id
+     * @return property id (not null)
      */
     public Object getPropertyId() {
         return propertyId;

src/com/vaadin/data/util/filter/IsNull.java

@@ -61,6 +61,12 @@ public final class IsNull implements Filter {
         return (null != getPropertyId() ? getPropertyId().hashCode() : 0);
     }
 
+    /**
+     * Returns the property id of the property tested by the filter, not null
+     * for valid filters.
+     * 
+     * @return property id (not null)
+     */
     public Object getPropertyId() {
         return propertyId;
     }

tests/src/com/vaadin/tests/server/container/filter/CompareFilterTest.java

@@ -1,5 +1,7 @@
 package com.vaadin.tests.server.container.filter;
 
+import java.util.Date;
+
 import junit.framework.Assert;
 
 import com.vaadin.data.Container.Filter;
@@ -20,6 +22,19 @@ public class CompareFilterTest extends AbstractFilterTest {
     protected Item itemB;
     protected Item itemC;
 
+    protected final Filter equalB = new Equal(PROPERTY1, "b");
+    protected final Filter greaterB = new Greater(PROPERTY1, "b");
+    protected final Filter lessB = new Less(PROPERTY1, "b");
+    protected final Filter greaterEqualB = new GreaterOrEqual(PROPERTY1, "b");
+    protected final Filter lessEqualB = new LessOrEqual(PROPERTY1, "b");
+
+    protected final Filter equalNull = new Equal(PROPERTY1, null);
+    protected final Filter greaterNull = new Greater(PROPERTY1, null);
+    protected final Filter lessNull = new Less(PROPERTY1, null);
+    protected final Filter greaterEqualNull = new GreaterOrEqual(PROPERTY1,
+            null);
+    protected final Filter lessEqualNull = new LessOrEqual(PROPERTY1, null);
+
     @Override
     protected void setUp() throws Exception {
         super.setUp();
@@ -50,91 +65,196 @@ public class CompareFilterTest extends AbstractFilterTest {
     }
 
     public void testCompareString() {
-        Filter equalB = new Equal(PROPERTY1, "b");
-        Filter greaterB = new Greater(PROPERTY1, "b");
-        Filter lessB = new Less(PROPERTY1, "b");
-        Filter greaterEqualB = new GreaterOrEqual(PROPERTY1, "b");
-        Filter lessEqualB = new LessOrEqual(PROPERTY1, "b");
-
+        Assert.assertFalse(equalB.passesFilter(null, itemEmpty));
         Assert.assertFalse(equalB.passesFilter(null, itemA));
         Assert.assertTrue(equalB.passesFilter(null, itemB));
         Assert.assertFalse(equalB.passesFilter(null, itemC));
 
+        Assert.assertFalse(greaterB.passesFilter(null, itemEmpty));
         Assert.assertFalse(greaterB.passesFilter(null, itemA));
         Assert.assertFalse(greaterB.passesFilter(null, itemB));
         Assert.assertTrue(greaterB.passesFilter(null, itemC));
 
+        Assert.assertTrue(lessB.passesFilter(null, itemEmpty));
         Assert.assertTrue(lessB.passesFilter(null, itemA));
         Assert.assertFalse(lessB.passesFilter(null, itemB));
         Assert.assertFalse(lessB.passesFilter(null, itemC));
 
+        Assert.assertFalse(greaterEqualB.passesFilter(null, itemEmpty));
         Assert.assertFalse(greaterEqualB.passesFilter(null, itemA));
         Assert.assertTrue(greaterEqualB.passesFilter(null, itemB));
         Assert.assertTrue(greaterEqualB.passesFilter(null, itemC));
 
+        Assert.assertTrue(lessEqualB.passesFilter(null, itemEmpty));
         Assert.assertTrue(lessEqualB.passesFilter(null, itemA));
         Assert.assertTrue(lessEqualB.passesFilter(null, itemB));
         Assert.assertFalse(lessEqualB.passesFilter(null, itemC));
     }
 
-    // TODO more tests: null comparisons, different datatypes...
+    public void testCompareWithNull() {
+        // null comparisons: null is less than any other value
+        Assert.assertFalse(equalB.passesFilter(null, itemNull));
+        Assert.assertTrue(greaterB.passesFilter(null, itemNull));
+        Assert.assertFalse(lessB.passesFilter(null, itemNull));
+        Assert.assertTrue(greaterEqualB.passesFilter(null, itemNull));
+        Assert.assertFalse(lessEqualB.passesFilter(null, itemNull));
+
+        Assert.assertTrue(equalNull.passesFilter(null, itemNull));
+        Assert.assertFalse(greaterNull.passesFilter(null, itemNull));
+        Assert.assertFalse(lessNull.passesFilter(null, itemNull));
+        Assert.assertTrue(greaterEqualNull.passesFilter(null, itemNull));
+        Assert.assertTrue(lessEqualNull.passesFilter(null, itemNull));
+
+        Assert.assertFalse(equalNull.passesFilter(null, itemA));
+        Assert.assertFalse(greaterNull.passesFilter(null, itemA));
+        Assert.assertTrue(lessNull.passesFilter(null, itemA));
+        Assert.assertFalse(greaterEqualNull.passesFilter(null, itemA));
+        Assert.assertTrue(lessEqualNull.passesFilter(null, itemA));
+    }
+
+    public void testCompareInteger() {
+        int negative = -1;
+        int zero = 0;
+        int positive = 1;
+
+        Item itemNegative = new PropertysetItem();
+        itemNegative.addItemProperty(PROPERTY1, new ObjectProperty<Integer>(
+                negative, Integer.class));
+        Item itemZero = new PropertysetItem();
+        itemZero.addItemProperty(PROPERTY1, new ObjectProperty<Integer>(zero,
+                Integer.class));
+        Item itemPositive = new PropertysetItem();
+        itemPositive.addItemProperty(PROPERTY1, new ObjectProperty<Integer>(
+                positive, Integer.class));
+
+        Filter equalZero = new Equal(PROPERTY1, zero);
+        Assert.assertFalse(equalZero.passesFilter(null, itemNegative));
+        Assert.assertTrue(equalZero.passesFilter(null, itemZero));
+        Assert.assertFalse(equalZero.passesFilter(null, itemPositive));
+
+        Filter isPositive = new Greater(PROPERTY1, zero);
+        Assert.assertFalse(isPositive.passesFilter(null, itemNegative));
+        Assert.assertFalse(isPositive.passesFilter(null, itemZero));
+        Assert.assertTrue(isPositive.passesFilter(null, itemPositive));
+
+        Filter isNegative = new Less(PROPERTY1, zero);
+        Assert.assertTrue(isNegative.passesFilter(null, itemNegative));
+        Assert.assertFalse(isNegative.passesFilter(null, itemZero));
+        Assert.assertFalse(isNegative.passesFilter(null, itemPositive));
+
+        Filter isNonNegative = new GreaterOrEqual(PROPERTY1, zero);
+        Assert.assertFalse(isNonNegative.passesFilter(null, itemNegative));
+        Assert.assertTrue(isNonNegative.passesFilter(null, itemZero));
+        Assert.assertTrue(isNonNegative.passesFilter(null, itemPositive));
+
+        Filter isNonPositive = new LessOrEqual(PROPERTY1, zero);
+        Assert.assertTrue(isNonPositive.passesFilter(null, itemNegative));
+        Assert.assertTrue(isNonPositive.passesFilter(null, itemZero));
+        Assert.assertFalse(isNonPositive.passesFilter(null, itemPositive));
+    }
+
+    public void testCompareDate() {
+        Date now = new Date();
+        // new Date() is only accurate to the millisecond, so repeating it gives
+        // the same date
+        Date earlier = new Date(now.getTime() - 1);
+        Date later = new Date(now.getTime() + 1);
+
+        Item itemEarlier = new PropertysetItem();
+        itemEarlier.addItemProperty(PROPERTY1, new ObjectProperty<Date>(
+                earlier, Date.class));
+        Item itemNow = new PropertysetItem();
+        itemNow.addItemProperty(PROPERTY1, new ObjectProperty<Date>(now,
+                Date.class));
+        Item itemLater = new PropertysetItem();
+        itemLater.addItemProperty(PROPERTY1, new ObjectProperty<Date>(later,
+                Date.class));
+
+        Filter equalNow = new Equal(PROPERTY1, now);
+        Assert.assertFalse(equalNow.passesFilter(null, itemEarlier));
+        Assert.assertTrue(equalNow.passesFilter(null, itemNow));
+        Assert.assertFalse(equalNow.passesFilter(null, itemLater));
+
+        Filter after = new Greater(PROPERTY1, now);
+        Assert.assertFalse(after.passesFilter(null, itemEarlier));
+        Assert.assertFalse(after.passesFilter(null, itemNow));
+        Assert.assertTrue(after.passesFilter(null, itemLater));
+
+        Filter before = new Less(PROPERTY1, now);
+        Assert.assertTrue(before.passesFilter(null, itemEarlier));
+        Assert.assertFalse(before.passesFilter(null, itemNow));
+        Assert.assertFalse(before.passesFilter(null, itemLater));
+
+        Filter afterOrNow = new GreaterOrEqual(PROPERTY1, now);
+        Assert.assertFalse(afterOrNow.passesFilter(null, itemEarlier));
+        Assert.assertTrue(afterOrNow.passesFilter(null, itemNow));
+        Assert.assertTrue(afterOrNow.passesFilter(null, itemLater));
+
+        Filter beforeOrNow = new LessOrEqual(PROPERTY1, now);
+        Assert.assertTrue(beforeOrNow.passesFilter(null, itemEarlier));
+        Assert.assertTrue(beforeOrNow.passesFilter(null, itemNow));
+        Assert.assertFalse(beforeOrNow.passesFilter(null, itemLater));
+    }
+
+    public void testCompareAppliesToProperty() {
+        Filter filterA = new Equal("a", 1);
+        Filter filterB = new Equal("b", 1);
+
+        Assert.assertTrue(filterA.appliesToProperty("a"));
+        Assert.assertFalse(filterA.appliesToProperty("b"));
+        Assert.assertFalse(filterB.appliesToProperty("a"));
+        Assert.assertTrue(filterB.appliesToProperty("b"));
+    }
 
     public void testCompareEqualsHashCode() {
         // most checks with Equal filter, then only some with others
-        Filter equalNull = new Equal(PROPERTY1, null);
         Filter equalNull2 = new Equal(PROPERTY1, null);
         Filter equalNullProperty2 = new Equal(PROPERTY2, null);
         Filter equalEmpty = new Equal(PROPERTY1, "");
         Filter equalEmpty2 = new Equal(PROPERTY1, "");
         Filter equalEmptyProperty2 = new Equal(PROPERTY2, "");
         Filter equalA = new Equal(PROPERTY1, "a");
-        Filter equalA2 = new Equal(PROPERTY1, "a");
-        Filter equalAProperty2 = new Equal(PROPERTY2, "a");
-        Filter equalB = new Equal(PROPERTY1, "b");
+        Filter equalB2 = new Equal(PROPERTY1, "b");
+        Filter equalBProperty2 = new Equal(PROPERTY2, "b");
 
-        Filter greaterNull = new Greater(PROPERTY1, null);
         Filter greaterEmpty = new Greater(PROPERTY1, "");
 
-        Filter greaterA = new Greater(PROPERTY1, "a");
-        Filter lessA = new Less(PROPERTY1, "a");
-        Filter greaterEqualA = new GreaterOrEqual(PROPERTY1, "a");
-        Filter lessEqualA = new LessOrEqual(PROPERTY1, "a");
-
         // equals()
         Assert.assertEquals(equalNull, equalNull);
         Assert.assertEquals(equalNull, equalNull2);
         Assert.assertFalse(equalNull.equals(equalNullProperty2));
         Assert.assertFalse(equalNull.equals(equalEmpty));
-        Assert.assertFalse(equalNull.equals(equalA));
+        Assert.assertFalse(equalNull.equals(equalB));
 
         Assert.assertEquals(equalEmpty, equalEmpty);
         Assert.assertFalse(equalEmpty.equals(equalNull));
         Assert.assertEquals(equalEmpty, equalEmpty2);
         Assert.assertFalse(equalEmpty.equals(equalEmptyProperty2));
-        Assert.assertFalse(equalEmpty.equals(equalA));
+        Assert.assertFalse(equalEmpty.equals(equalB));
 
-        Assert.assertEquals(equalA, equalA);
-        Assert.assertFalse(equalA.equals(equalNull));
-        Assert.assertFalse(equalA.equals(equalEmpty));
-        Assert.assertEquals(equalA, equalA2);
-        Assert.assertFalse(equalA.equals(equalAProperty2));
-        Assert.assertFalse(equalA.equals(equalB));
+        Assert.assertEquals(equalB, equalB);
+        Assert.assertFalse(equalB.equals(equalNull));
+        Assert.assertFalse(equalB.equals(equalEmpty));
+        Assert.assertEquals(equalB, equalB2);
+        Assert.assertFalse(equalB.equals(equalBProperty2));
+        Assert.assertFalse(equalB.equals(equalA));
 
-        Assert.assertEquals(greaterA, greaterA);
-        Assert.assertFalse(greaterA.equals(lessA));
-        Assert.assertFalse(greaterA.equals(greaterEqualA));
-        Assert.assertFalse(greaterA.equals(lessEqualA));
+        Assert.assertEquals(greaterB, greaterB);
+        Assert.assertFalse(greaterB.equals(lessB));
+        Assert.assertFalse(greaterB.equals(greaterEqualB));
+        Assert.assertFalse(greaterB.equals(lessEqualB));
 
         Assert.assertFalse(greaterNull.equals(greaterEmpty));
-        Assert.assertFalse(greaterNull.equals(greaterA));
+        Assert.assertFalse(greaterNull.equals(greaterB));
         Assert.assertFalse(greaterEmpty.equals(greaterNull));
-        Assert.assertFalse(greaterEmpty.equals(greaterA));
-        Assert.assertFalse(greaterA.equals(greaterNull));
-        Assert.assertFalse(greaterA.equals(greaterEmpty));
+        Assert.assertFalse(greaterEmpty.equals(greaterB));
+        Assert.assertFalse(greaterB.equals(greaterNull));
+        Assert.assertFalse(greaterB.equals(greaterEmpty));
 
         // hashCode()
         Assert.assertEquals(equalNull.hashCode(), equalNull2.hashCode());
         Assert.assertEquals(equalEmpty.hashCode(), equalEmpty2.hashCode());
-        Assert.assertEquals(equalA.hashCode(), equalA2.hashCode());
+        Assert.assertEquals(equalB.hashCode(), equalB2.hashCode());
     }
+
 }

tests/src/com/vaadin/tests/server/container/filter/IsNullFilterTest.java

@@ -32,6 +32,16 @@ public class IsNullFilterTest extends AbstractFilterTest {
         Assert.assertTrue(filter2.passesFilter(null, item2));
     }
 
+    public void testIsNullAppliesToProperty() {
+        Filter filterA = new IsNull("a");
+        Filter filterB = new IsNull("b");
+
+        Assert.assertTrue(filterA.appliesToProperty("a"));
+        Assert.assertFalse(filterA.appliesToProperty("b"));
+        Assert.assertFalse(filterB.appliesToProperty("a"));
+        Assert.assertTrue(filterB.appliesToProperty("b"));
+    }
+
     public void testIsNullEqualsHashCode() {
         Filter filter1 = new IsNull("a");
         Filter filter1b = new IsNull("a");

tests/src/com/vaadin/tests/server/container/filter/NotFilterTest.java

@@ -23,6 +23,16 @@ public class NotFilterTest extends AbstractFilterTest {
         Assert.assertTrue(filter.passesFilter(null, item2));
     }
 
+    public void testANotAppliesToProperty() {
+        Filter filterA = new Not(new SameItemFilter(item1, "a"));
+        Filter filterB = new Not(new SameItemFilter(item1, "b"));
+
+        Assert.assertTrue(filterA.appliesToProperty("a"));
+        Assert.assertFalse(filterA.appliesToProperty("b"));
+        Assert.assertFalse(filterB.appliesToProperty("a"));
+        Assert.assertTrue(filterB.appliesToProperty("b"));
+    }
+
     public void testNotEqualsHashCode() {
         Filter origFilter = new SameItemFilter(item1);
         Filter filter1 = new Not(origFilter);