From: Matti Tahvonen <matti.tahvonen@itmill.com>
Date: Mon, 3 Jan 2011 12:33:05 +0000 (+0000)
Subject: extended test case to cover #6002
X-Git-Tag: 6.7.0.beta1~554
X-Git-Url: https://source.dussan.org/?a=commitdiff_plain;h=c8486f33e116a91202f9cdc61a92b94ed01acf83;p=vaadin-framework.git

extended test case to cover #6002

svn changeset:16758/svn branch:6.5
---

diff --git a/tests/src/com/vaadin/tests/server/components/AbstractTestFieldValueChange.java b/tests/src/com/vaadin/tests/server/components/AbstractTestFieldValueChange.java
index 45b5c0b0b2..3aebd5bf9d 100644
--- a/tests/src/com/vaadin/tests/server/components/AbstractTestFieldValueChange.java
+++ b/tests/src/com/vaadin/tests/server/components/AbstractTestFieldValueChange.java
@@ -33,6 +33,10 @@ public abstract class AbstractTestFieldValueChange extends TestCase {
 
     }
 
+    protected ValueChangeListener getListener() {
+        return listener;
+    }
+
     /**
      * Test that listeners are not called when they have been unregistered.
      */
diff --git a/tests/src/com/vaadin/tests/server/components/TestTextFieldValueChange.java b/tests/src/com/vaadin/tests/server/components/TestTextFieldValueChange.java
index 9e50d983dc..1144caf805 100644
--- a/tests/src/com/vaadin/tests/server/components/TestTextFieldValueChange.java
+++ b/tests/src/com/vaadin/tests/server/components/TestTextFieldValueChange.java
@@ -3,6 +3,12 @@ package com.vaadin.tests.server.components;
 import java.util.HashMap;
 import java.util.Map;
 
+import junit.framework.Assert;
+
+import org.easymock.EasyMock;
+
+import com.vaadin.data.Property.ValueChangeEvent;
+import com.vaadin.data.util.ObjectProperty;
 import com.vaadin.ui.AbstractField;
 import com.vaadin.ui.TextField;
 
@@ -36,4 +42,139 @@ public class TestTextFieldValueChange extends AbstractTestFieldValueChange {
         field.changeVariables(field, variables);
     }
 
+    /**
+     * Test that field propagates value change events originating from property,
+     * but don't fire value change events twice if value has only changed once.
+     * 
+     * 
+     * TODO make test field type agnostic (eg. combobox)
+     */
+    public void testValueChangeEventPropagationWithReadThrough() {
+        ObjectProperty<String> property = new ObjectProperty<String>("");
+        getField().setPropertyDataSource(property);
+
+        // defaults, buffering off
+        getField().setWriteThrough(true);
+        getField().setReadThrough(true);
+
+        // Expectations and start test
+        getListener().valueChange(EasyMock.isA(ValueChangeEvent.class));
+        EasyMock.replay(getListener());
+
+        // Add listener and set the value -> should end up in listener once
+        getField().addListener(getListener());
+
+        property.setValue("Foo");
+
+        // Ensure listener was called once
+        EasyMock.verify(getListener());
+
+        // get value should not fire value change again
+        Object value = getField().getValue();
+        Assert.assertEquals("Foo", value);
+
+        // Ensure listener still has been called only once
+        EasyMock.verify(getListener());
+    }
+
+    /**
+     * If read through is on and value has been modified, but not committed, the
+     * value should not propagate similar to
+     * {@link #testValueChangeEventPropagationWithReadThrough()}
+     * 
+     * TODO make test field type agnostic (eg. combobox)
+     */
+    public void testValueChangePropagationWithReadThroughWithModifiedValue() {
+        final String initialValue = "initial";
+        ObjectProperty<String> property = new ObjectProperty<String>(
+                initialValue);
+        getField().setPropertyDataSource(property);
+
+        // write buffering on, read buffering off
+        getField().setWriteThrough(false);
+        getField().setReadThrough(true);
+
+        // Expect no value changes calls to listener
+        EasyMock.replay(getListener());
+
+        // first set the value (note, write through false -> not forwarded to
+        // property)
+        setValue(getField());
+
+        Assert.assertTrue(getField().isModified());
+
+        // Add listener and set the value -> should end up in listener once
+        getField().addListener(getListener());
+
+        // modify property value, should not fire value change in field as the
+        // field has uncommitted value (aka isModified() == true)
+        property.setValue("Foo");
+
+        // Ensure listener was called once
+        EasyMock.verify(getListener());
+
+        // get value should not fire value change again
+        Object value = getField().getValue();
+        // Ensure listener still has been called only once
+        EasyMock.verify(getListener());
+
+        // field value should be different from the original value and current
+        // proeprty value
+        boolean isValueEqualToInitial = value.equals(initialValue);
+        Assert.assertFalse(isValueEqualToInitial);
+        boolean isValueEqualToPropertyValue = value.equals(property.getValue());
+        Assert.assertFalse(isValueEqualToPropertyValue);
+
+        // Ensure listener has not been called
+        EasyMock.verify(getListener());
+
+    }
+
+    /**
+     * Value change events from property should not propagate if read through is
+     * false. Execpt when the property is being set.
+     * 
+     * TODO make test field type agnostic (eg. combobox)
+     */
+    public void testValueChangePropagationWithReadThroughOff() {
+        final String initialValue = "initial";
+        ObjectProperty<String> property = new ObjectProperty<String>(
+                initialValue);
+
+        // set buffering
+        getField().setWriteThrough(false);
+        getField().setReadThrough(false);
+
+        // Value change should only happen once, when setting the property,
+        // further changes via property should not cause value change listener
+        // in field to be notified
+        getListener().valueChange(EasyMock.isA(ValueChangeEvent.class));
+        EasyMock.replay(getListener());
+
+        getField().addListener(getListener());
+        getField().setPropertyDataSource(property);
+
+        // Ensure listener was called once
+        EasyMock.verify(getListener());
+
+        // modify property value, should not fire value change in field as the
+        // read buffering is on (read through == false)
+        property.setValue("Foo");
+
+        // Ensure listener still has been called only once
+        EasyMock.verify(getListener());
+
+        // get value should not fire value change again
+        Object value = getField().getValue();
+
+        // field value should be different from the original value and current
+        // proeprty value
+        boolean isValueEqualToInitial = value.equals(initialValue);
+        Assert.assertTrue(isValueEqualToInitial);
+
+        // Ensure listener still has been called only once
+        EasyMock.verify(getListener());
+
+    }
+
 }