harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mloe...@apache.org
Subject svn commit: r394923 [2/16] - in /incubator/harmony/enhanced/classlib/trunk/modules/beans: make/common/ src/test/java.injected/ src/test/java.injected/java/ src/test/java.injected/java/beans/ src/test/java/tests/ src/test/java/tests/api/ src/test/java/t...
Date Tue, 18 Apr 2006 12:11:45 GMT
Added: incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/CustomizerTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/CustomizerTest.java?rev=394923&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/CustomizerTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/CustomizerTest.java Tue Apr 18 05:11:09 2006
@@ -0,0 +1,46 @@
+/* Copyright 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package tests.api.java.beans;
+
+import java.beans.Customizer;
+import java.beans.PropertyChangeListener;
+
+import tests.api.java.beans.BeanInfoTest.DummyBeanInfo;
+
+import junit.framework.TestCase;
+
+/**
+ * Test the signature of the interface Customizer.
+ */
+public class CustomizerTest extends TestCase {
+
+	public void testSignature() {
+		DummyCustomizer o = new DummyCustomizer();
+		assertTrue(o instanceof Customizer);
+	}
+
+	static class DummyCustomizer implements Customizer {
+
+		public void addPropertyChangeListener(PropertyChangeListener listener) {
+		}
+
+		public void removePropertyChangeListener(PropertyChangeListener listener) {
+		}
+
+		public void setObject(Object bean) {
+		}
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/DefaultPersistenceDelegateTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/DefaultPersistenceDelegateTest.java?rev=394923&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/DefaultPersistenceDelegateTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/DefaultPersistenceDelegateTest.java Tue Apr 18 05:11:09 2006
@@ -0,0 +1,999 @@
+/* Copyright 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package tests.api.java.beans;
+
+import java.beans.DefaultPersistenceDelegate;
+import java.beans.Encoder;
+import java.beans.ExceptionListener;
+import java.beans.Expression;
+import java.beans.Introspector;
+import java.beans.PersistenceDelegate;
+import java.beans.PropertyDescriptor;
+import java.beans.SimpleBeanInfo;
+import java.beans.Statement;
+
+import junit.framework.TestCase;
+import tests.api.java.beans.mock.MockFoo;
+import tests.api.java.beans.mock.MockFoo2;
+import tests.api.java.beans.mock.MockFooStop;
+import tests.util.CallVerificationStack;
+
+/**
+ * Tests the class java.beans.DefaultPersistenceDelegate
+ */
+public class DefaultPersistenceDelegateTest extends TestCase {
+
+	/*
+	 * @see TestCase#setUp()
+	 */
+	protected void setUp() throws Exception {
+		super.setUp();
+		Introspector.flushCaches();
+		CallVerificationStack.getInstance().clear();
+	}
+
+	/*
+	 * Test the default constructor.
+	 */
+	public void testConstructor_Default() {
+		new DefaultPersistenceDelegate();
+	}
+
+	/*
+	 * Test the constructor with normal property names.
+	 */
+	public void testConstructor_StringArray_Normal() {
+		new DefaultPersistenceDelegate(new String[] { "prop1", "", null });
+	}
+
+	/*
+	 * Test the constructor with an empty string array.
+	 */
+	public void testConstructor_StringArray_Empty() {
+		new DefaultPersistenceDelegate(new String[0]);
+	}
+
+	/*
+	 * Test the constructor with null.
+	 */
+	public void testConstructor_StringArray_Null() {
+		new DefaultPersistenceDelegate(null);
+	}
+
+	/*
+	 * Test instantiate() under normal conditions: two properties, valid getter
+	 * method but no setter method and no such a constructor requiring the two
+	 * properties.
+	 */
+	public void testInstantiate_Normal() throws Exception {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(new String[] {
+				"prop1", "prop2" });
+		MockBean b = new MockBean();
+		Encoder enc = new Encoder();
+		b.setAll("bean1", 2);
+		Expression e = pd.instantiate(b, enc);
+		assertSame(b, e.getValue());
+		assertSame(MockBean.class, e.getTarget());
+		assertEquals("new", e.getMethodName());
+		assertSame("bean1", e.getArguments()[0]);
+		assertEquals(new Integer(2), e.getArguments()[1]);
+	}
+
+	/*
+	 * Test instantiate() with null instance.
+	 */
+	public void testInstantiate_NullInstance() throws Exception {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(new String[] {
+				"prop1", "prop2" });
+		Encoder enc = new Encoder();
+		try {
+			pd.instantiate(null, enc);
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException ex) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test instantiate() with null encoder.
+	 */
+	public void testInstantiate_NullEncoder() throws Exception {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(new String[] {
+				"prop1", "prop2" });
+		MockBean b = new MockBean();
+		b.setAll("bean1", 2);
+		Expression e = pd.instantiate(b, null);
+		assertSame(b, e.getValue());
+		assertSame(MockBean.class, e.getTarget());
+		assertEquals("new", e.getMethodName());
+		assertSame("bean1", e.getArguments()[0]);
+		assertEquals(new Integer(2), e.getArguments()[1]);
+		assertEquals(2, e.getArguments().length);
+	}
+
+	/*
+	 * Test instantiate() with null property name.
+	 */
+	public void testInstantiate_NullProperty() throws Exception {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(new String[] {
+				"prop1", null });
+		MockBean b = new MockBean();
+		b.setAll("bean1", 2);
+		try {
+			pd.instantiate(b, new Encoder());
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException ex) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test instantiate() with empty property name.
+	 */
+	public void testInstantiate_EmptyProperty() throws Exception {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(new String[] {
+				"prop1", "" });
+		MockBean b = new MockBean();
+		b.setAll("bean1", 2);
+		try {
+			pd.instantiate(b, null);
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException ex) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test instantiate() with no property.
+	 */
+	public void testInstantiate_NoProperty() throws Exception {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate();
+		MockBean b = new MockBean();
+		b.setAll("bean1", 2);
+		Expression e = pd.instantiate(b, new Encoder());
+		assertSame(b, e.getValue());
+		assertSame(MockBean.class, e.getTarget());
+		assertEquals("new", e.getMethodName());
+		assertEquals(0, e.getArguments().length);
+	}
+
+	/*
+	 * Test instantiate() with one normal property name, but non-existing getter
+	 * method.
+	 */
+	public void testInstantiate_NonExistingGetter() throws Exception {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(new String[] {
+				"prop1", "non_existing" });
+		MockBean b = new MockBean();
+		b.setAll("bean1", 2);
+		Encoder enc = new Encoder();
+		ExceptionListener el = new ExceptionListener() {
+			public void exceptionThrown(Exception e) {
+				CallVerificationStack.getInstance().push(e);
+			}
+		};
+		enc.setExceptionListener(el);
+		Expression e = pd.instantiate(b, enc);
+		assertSame(b, e.getValue());
+		assertSame(MockBean.class, e.getTarget());
+		assertEquals("new", e.getMethodName());
+		assertEquals(2, e.getArguments().length);
+		assertSame(b.getProp1(), e.getArguments()[0]);
+		assertSame(null, e.getArguments()[1]);
+		assertTrue(CallVerificationStack.getInstance().pop() instanceof Exception);
+
+		enc.setExceptionListener(null);
+		assertNotNull(enc.getExceptionListener());
+		e = pd.instantiate(b, enc);
+		assertSame(b, e.getValue());
+		assertSame(MockBean.class, e.getTarget());
+		assertEquals("new", e.getMethodName());
+		assertEquals(2, e.getArguments().length);
+		assertSame(b.getProp1(), e.getArguments()[0]);
+		assertSame(null, e.getArguments()[1]);
+	}
+
+	/*
+	 * Test instantiate() with one normal property name, but non-existing getter
+	 * method, and null encoder.
+	 */
+	public void testInstantiate_NonExistingGetterNulEncoder() throws Exception {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(new String[] {
+				"prop1", "non_existing" });
+		MockBean b = new MockBean();
+		b.setAll("bean1", 2);
+		try {
+			pd.instantiate(b, null);
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException ex) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test instantiate() with one normal property name, but an invalid getter
+	 * method (requiring an argument, for instance).
+	 */
+	public void testInstantiate_InvalidGetter() throws Exception {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(new String[] {
+				"prop1", "prop4" });
+		MockBean b = new MockBean();
+		b.setAll("bean1", 2);
+		Expression e = pd.instantiate(b, new Encoder());
+		assertSame(b, e.getValue());
+		assertSame(MockBean.class, e.getTarget());
+		assertEquals("new", e.getMethodName());
+		assertEquals(2, e.getArguments().length);
+		assertSame(b.getProp1(), e.getArguments()[0]);
+		assertSame(null, e.getArguments()[1]);
+	}
+
+	/*
+	 * Test instantiate() with one normal property name, but a getter method
+	 * that will throw an exception.
+	 */
+	public void testInstantiate_ExceptionalGetter() throws Exception {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(new String[] {
+				"prop1", "prop5" });
+		MockBean b = new MockBean();
+		b.setAll("bean1", 2);
+		Expression e = pd.instantiate(b, new Encoder());
+		assertSame(b, e.getValue());
+		assertSame(MockBean.class, e.getTarget());
+		assertEquals("new", e.getMethodName());
+		assertEquals(2, e.getArguments().length);
+		assertSame(b.getProp1(), e.getArguments()[0]);
+		assertSame(null, e.getArguments()[1]);
+	}
+
+	/*
+	 * Test instantiate() with one normal property name, but a getter method
+	 * that will throw an error.
+	 */
+	public void testInstantiate_ErrorGetter() throws Exception {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(new String[] {
+				"prop1", "prop7" });
+		MockBean b = new MockBean();
+		b.setAll("bean1", 2);
+		Expression e = pd.instantiate(b, new Encoder());
+		assertSame(b, e.getValue());
+		assertSame(MockBean.class, e.getTarget());
+		assertEquals("new", e.getMethodName());
+		assertEquals(2, e.getArguments().length);
+		assertSame(b.getProp1(), e.getArguments()[0]);
+		assertSame(null, e.getArguments()[1]);
+	}
+
+	/*
+	 * Test instantiate() with one normal property name, but a private getter
+	 * method.
+	 */
+	public void testInstantiate_PrivateGetter() throws Exception {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(new String[] {
+				"prop1", "prop6" });
+		MockBean b = new MockBean();
+		b.setAll("bean1", 2);
+		Expression e = pd.instantiate(b, new Encoder());
+		assertSame(b, e.getValue());
+		assertSame(MockBean.class, e.getTarget());
+		assertEquals("new", e.getMethodName());
+		assertEquals(2, e.getArguments().length);
+		assertSame(b.getProp1(), e.getArguments()[0]);
+		assertSame(null, e.getArguments()[1]);
+	}
+
+	/*
+	 * Test instantiate() with a property name starting with initial upper case
+	 * letter, and a valid getter method.
+	 */
+	public void testInstantiate_InitialUpperCasePropName() throws Exception {
+		String[] props = new String[] { "Prop1", "prop2" };
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(props);
+		MockBean b = new MockBean();
+		b.setAll("bean1", 2);
+		Expression e = pd.instantiate(b, new Encoder());
+		assertSame(b, e.getValue());
+		assertSame(MockBean.class, e.getTarget());
+		assertEquals("new", e.getMethodName());
+		assertEquals(2, e.getArguments().length);
+		assertSame(b.getProp1(), e.getArguments()[0]);
+		assertEquals(new Integer(2), e.getArguments()[1]);
+	}
+
+	/*
+	 * Test instantiate() with a bean with no getter.
+	 */
+	public void testInstantiate_NoGetter() throws Exception {
+		MockEncoder enc = new MockEncoder();
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(
+				new String[] { "i" });
+		MockNoGetterBean2 b = new MockNoGetterBean2(3);
+		enc.setExceptionListener(new ExceptionListener() {
+			public void exceptionThrown(Exception e) {
+				CallVerificationStack.getInstance().push(e);
+			}
+		});
+		Expression e = pd.instantiate(b, enc);
+		assertSame(b, e.getValue());
+		assertSame(MockNoGetterBean2.class, e.getTarget());
+		assertEquals("new", e.getMethodName());
+		assertEquals(1, e.getArguments().length);
+		assertSame(null, e.getArguments()[0]);
+		assertFalse(CallVerificationStack.getInstance().empty());
+	}
+
+	/*
+	 * Test instantiate() with a property name that has an unregular getter
+	 * method, defined by its beaninfo.
+	 */
+	public void testInstantiate_NotRegularGetter() throws Exception {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(new String[] {
+				"prop1", "i" });
+		MockFoo2 b = new MockFoo2(2);
+		Expression e = pd.instantiate(b, new Encoder());
+		assertSame(b, e.getValue());
+		assertSame(MockFoo2.class, e.getTarget());
+		assertEquals("new", e.getMethodName());
+		assertEquals(2, e.getArguments().length);
+		assertEquals(new Integer(2), e.getArguments()[0]);
+		assertEquals(null, e.getArguments()[1]);
+	}
+
+	/*
+	 * Tests mutatesTo() under normal conditions without any properties.
+	 */
+	public void testMutatesTo_NormalNoProperty() {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate();
+		assertTrue(pd.mutatesTo("test1", "test2"));
+		assertFalse(pd.mutatesTo(new Object(), new Object() {
+			public int hashCode() {
+				return super.hashCode();
+			}
+		}));
+		assertFalse(pd.mutatesTo(new MockFoo(), new MockFooStop()));
+	}
+
+	/*
+	 * Tests mutatesTo() under normal conditions with properties but no equal
+	 * method defined.
+	 */
+	public void testMutatesTo_NormalWithPropertyNoEqualMethod() {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(
+				new String[] { "name" });
+		assertFalse(pd.mutatesTo(new Object(), new Object() {
+			public int hashCode() {
+				return super.hashCode();
+			}
+		}));
+	}
+
+	/*
+	 * Tests mutatesTo() under normal conditions with null properties and equal
+	 * method defined.
+	 */
+	public void testMutatesTo_NormalWithNullPropertyPublicEqualMethod() {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(
+				new String[] { null });
+		assertFalse(pd.mutatesTo("test1", "test2"));
+	}
+
+	/*
+	 * Tests mutatesTo() under normal conditions with empty properties and equal
+	 * method defined.
+	 */
+	public void testMutatesTo_NormalWithEmptyPropertyPublicEqualMethod() {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(new String[0]);
+		assertTrue(pd.mutatesTo("test1", "test2"));
+	}
+
+	/*
+	 * Tests mutatesTo() under normal conditions with properties and equal
+	 * method defined.
+	 */
+	public void testMutatesTo_NormalWithPropertyPublicEqualMethod() {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(
+				new String[] { "name" });
+		assertFalse(pd.mutatesTo("test1", "test2"));
+		assertTrue(pd.mutatesTo("test1", "test1"));
+	}
+
+	/*
+	 * Tests mutatesTo() under normal conditions with properties and protected
+	 * equal method defined.
+	 */
+	public void testMutatesTo_NormalWithPropertyProtectedEqualMethod() {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate(
+				new String[] { "name" });
+		assertFalse(pd.mutatesTo(new MockPersistenceDelegate(), "test"));
+	}
+
+	/*
+	 * Tests mutatesTo() with null parameters.
+	 */
+	public void testMutatesTo_Null() {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate();
+		assertFalse(pd.mutatesTo("test", null));
+		assertFalse(pd.mutatesTo(null, null));
+		try {
+			pd.mutatesTo(null, "test");
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException ex) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test initialize() under normal conditions with a bean that does not have
+	 * bean info class.
+	 */
+	public void testInitialize_Normal() throws Exception {
+		MockEncoder enc = new MockEncoder();
+		MockPersistenceDelegate pd = new MockPersistenceDelegate();
+		MockFoo b = new MockFoo();
+		b.setName("myName");
+		// b.setLabel("myLabel");
+
+		enc.writeObject(b);
+		CallVerificationStack.getInstance().clear();
+		MockFoo b2 = (MockFoo) enc.get(b);
+		b2.setName("YourName");
+
+		pd.initialize(MockFoo.class, b, b2, enc);
+
+		// should have called writeStatement()
+		Statement stm = (Statement) CallVerificationStack.getInstance().pop();
+		assertSame(b, stm.getTarget());
+		assertEquals("setName", stm.getMethodName());
+		assertEquals(1, stm.getArguments().length);
+		assertEquals("myName", stm.getArguments()[0]);
+
+		// should have called get()
+		assertEquals("myName", CallVerificationStack.getInstance().pop());
+
+		// should have called writeExpression()
+		Expression exp = (Expression) CallVerificationStack.getInstance().pop();
+		assertSame(b.getName(), exp.getValue());
+		assertSame(b, exp.getTarget());
+		assertEquals("getName", exp.getMethodName());
+		assertEquals(0, exp.getArguments().length);
+
+		// should have called get()
+		assertEquals(null, CallVerificationStack.getInstance().pop());
+
+		// should have called writeExpression()
+		exp = (Expression) CallVerificationStack.getInstance().pop();
+		assertSame(b.getLabel(), exp.getValue());
+		assertSame(b, exp.getTarget());
+		assertEquals("getLabel", exp.getMethodName());
+		assertEquals(0, exp.getArguments().length);
+
+		assertTrue(CallVerificationStack.getInstance().empty());
+	}
+
+	/*
+	 * Test initialize() under normal conditions with a bean that does have bean
+	 * info class.
+	 */
+	public void testInitialize_NormalBeanInfo() throws Exception {
+		MockEncoder enc = new MockEncoder();
+		MockPersistenceDelegate pd = new MockPersistenceDelegate();
+		MockFoo2 b = new MockFoo2(2);
+
+		enc.writeObject(b);
+		CallVerificationStack.getInstance().clear();
+		MockFoo2 b2 = (MockFoo2) enc.get(b);
+		b2.myset(3);
+
+		pd.initialize(MockFoo2.class, b, b2, enc);
+
+		// should have called writeStatement()
+		Statement stm = (Statement) CallVerificationStack.getInstance().pop();
+		assertSame(b, stm.getTarget());
+		assertEquals("myset", stm.getMethodName());
+		assertEquals(1, stm.getArguments().length);
+		assertEquals(new Integer(2), stm.getArguments()[0]);
+
+		// should have called get()
+		assertEquals(new Integer(2), CallVerificationStack.getInstance().pop());
+
+		// should have called writeExpression()
+		Expression exp = (Expression) CallVerificationStack.getInstance().pop();
+		assertEquals(new Integer(2), exp.getValue());
+		assertSame(b, exp.getTarget());
+		assertEquals("myget", exp.getMethodName());
+		assertEquals(0, exp.getArguments().length);
+
+		assertTrue(CallVerificationStack.getInstance().empty());
+	}
+
+	/*
+	 * Test initialize() when oldInstance == newInstance.
+	 */
+	public void testInitialize_SameInstance() throws Exception {
+		MockEncoder enc = new MockEncoder();
+		MockPersistenceDelegate pd = new MockPersistenceDelegate();
+		MockFoo b = new MockFoo();
+		b.setName("mymyName");
+		// b.setLabel("myLabel");
+
+		pd.initialize(MockFoo.class, b, b, enc);
+
+		// should have called get()
+		assertEquals("mymyName", CallVerificationStack.getInstance().pop());
+
+		// should have called writeExpression()
+		Expression exp = (Expression) CallVerificationStack.getInstance().pop();
+		assertSame(b.getName(), exp.getValue());
+		assertSame(b, exp.getTarget());
+		assertEquals("getName", exp.getMethodName());
+		assertEquals(0, exp.getArguments().length);
+
+		// should have called get()
+		assertEquals(null, CallVerificationStack.getInstance().pop());
+
+		// should have called writeExpression()
+		exp = (Expression) CallVerificationStack.getInstance().pop();
+		assertSame(b.getLabel(), exp.getValue());
+		assertSame(b, exp.getTarget());
+		assertEquals("getLabel", exp.getMethodName());
+		assertEquals(0, exp.getArguments().length);
+
+		assertTrue(CallVerificationStack.getInstance().empty());
+	}
+
+	/*
+	 * Test initialize() with a bean with a transient property.
+	 */
+	public void testInitialize_TransientProperty() throws Exception {
+		MockEncoder enc = new MockEncoder();
+		MockPersistenceDelegate pd = new MockPersistenceDelegate();
+		MockTransientBean b = new MockTransientBean();
+		b.setName("myName");
+		pd.initialize(MockTransientBean.class, b, new MockTransientBean(), enc);
+		assertTrue(CallVerificationStack.getInstance().empty());
+		// set transient to false
+		Introspector.flushCaches();
+		MockTransientBeanBeanInfo.setTransient(false);
+		pd.initialize(MockTransientBean.class, new MockTransientBean(),
+				new MockTransientBean(), enc);
+		assertFalse(CallVerificationStack.getInstance().empty());
+	}
+
+	/*
+	 * Test initialize() with a bean with no setter.
+	 */
+	public void testInitialize_NoSetter() throws Exception {
+		MockEncoder enc = new MockEncoder();
+		MockPersistenceDelegate pd = new MockPersistenceDelegate();
+		MockNoSetterBean b = new MockNoSetterBean();
+		enc.setExceptionListener(new ExceptionListener() {
+			public void exceptionThrown(Exception e) {
+				CallVerificationStack.getInstance().push(e);
+			}
+		});
+		b.setName("myName");
+		pd.initialize(MockNoSetterBean.class, b, new MockNoSetterBean(), enc);
+		assertTrue(CallVerificationStack.getInstance().empty());
+
+		pd = new MockPersistenceDelegate(new String[] { "name" });
+		enc.setExceptionListener(new ExceptionListener() {
+			public void exceptionThrown(Exception e) {
+				CallVerificationStack.getInstance().push(e);
+			}
+		});
+		b.setName("myName");
+		pd.initialize(MockNoSetterBean.class, b, new MockNoSetterBean(), enc);
+		assertTrue(CallVerificationStack.getInstance().empty());
+	}
+
+	/*
+	 * Test initialize() with a bean with no getter.
+	 */
+	public void testInitialize_NoGetter() throws Exception {
+		MockEncoder enc = new MockEncoder();
+		MockPersistenceDelegate pd = new MockPersistenceDelegate();
+		MockNoGetterBean b = new MockNoGetterBean();
+
+		b.setName("myName");
+		enc.setExceptionListener(new ExceptionListener() {
+			public void exceptionThrown(Exception e) {
+				CallVerificationStack.getInstance().push(e);
+			}
+		});
+		enc.writeObject(b);
+		CallVerificationStack.getInstance().clear();
+		MockNoGetterBean b2 = (MockNoGetterBean) enc.get(b);
+		b2.setName("yourName");
+		b2.setLabel("hehe");
+		pd.initialize(MockNoGetterBean.class, b, b2, enc);
+		assertTrue(CallVerificationStack.getInstance().empty());
+	}
+
+	/*
+	 * Tests initialize() with null class.
+	 */
+	public void testInitialize_NullClass() {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate();
+		Encoder enc = new Encoder();
+		Object o1 = new Object();
+		Object o2 = new Object();
+		// enc.setPersistenceDelegate(MockFooStop.class,
+		// new MockPersistenceDelegate());
+		try {
+			enc.setExceptionListener(new ExceptionListener() {
+				public void exceptionThrown(Exception e) {
+					CallVerificationStack.getInstance().push(e);
+				}
+			});
+			pd.initialize(null, o1, o2, enc);
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException ex) {
+			// expected
+		}
+		assertTrue(CallVerificationStack.getInstance().empty());
+	}
+
+	/*
+	 * Tests initialize() with null old and new instances.
+	 */
+	public void testInitialize_NullInstances() {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate();
+		Encoder enc = new Encoder();
+		MockFoo b = new MockFoo();
+		b.setName("myName");
+		// enc.setPersistenceDelegate(MockFooStop.class,
+		// new MockPersistenceDelegate());
+		enc.setExceptionListener(new ExceptionListener() {
+			public void exceptionThrown(Exception e) {
+				CallVerificationStack.getInstance().push(e);
+			}
+		});
+		try {
+			pd.initialize(MockFoo.class, null, b, enc);
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException ex) {
+			// expected
+		}
+		assertTrue(CallVerificationStack.getInstance().empty());
+		pd.initialize(MockFoo.class, b, null, enc);
+		assertFalse(CallVerificationStack.getInstance().empty());
+	}
+
+	/*
+	 * Tests initialize() with null encoder.
+	 */
+	public void testInitialize_NullEncoder() {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate();
+		Object o1 = new Object();
+		Object o2 = new Object();
+		try {
+			pd.initialize(MockFoo.class, o1, o2, null);
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException ex) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test initialize() with a property name that has an unregular getter
+	 * method, defined by its beaninfo.
+	 */
+	public void testInitialize_NotRegularGetter() throws Exception {
+		MockPersistenceDelegate pd = new MockPersistenceDelegate();
+		// new String[] { "prop1" });
+		MockEncoder enc = new MockEncoder();
+
+		MockFoo2 b = new MockFoo2(2);
+		MockFoo2 b2 = new MockFoo2(1);
+		pd.initialize(MockFoo2.class, b, b2, enc);
+
+		// should have called writeStatement()
+		Statement stm = (Statement) CallVerificationStack.getInstance().pop();
+		assertSame(b, stm.getTarget());
+		assertEquals("myset", stm.getMethodName());
+		assertEquals(1, stm.getArguments().length);
+		assertEquals(new Integer(2), stm.getArguments()[0]);
+
+		// should have called get()
+		assertEquals(new Integer(2), CallVerificationStack.getInstance().pop());
+
+		// should have called writeExpression()
+		Expression exp = (Expression) CallVerificationStack.getInstance().pop();
+		assertEquals(new Integer(2), exp.getValue());
+		assertSame(b, exp.getTarget());
+		assertEquals("myget", exp.getMethodName());
+		assertEquals(0, exp.getArguments().length);
+	}
+
+	/*
+	 * Tests array persistence delegate
+	 */
+	public void testArrayPD_Normal() {
+		Encoder enc = new MockEncoder();
+		int[] ia = new int[] { 1 };
+		PersistenceDelegate pd = enc.getPersistenceDelegate(ia.getClass());
+		pd.writeObject(ia, enc);
+	}
+
+	/*
+	 * BeanInfo for the MockBean below.
+	 */
+	public static class MockNoGetterBeanBeanInfo extends SimpleBeanInfo {
+
+		public PropertyDescriptor[] getPropertyDescriptors() {
+			try {
+				PropertyDescriptor pd = new PropertyDescriptor("name", null,
+						MockNoGetterBean.class.getMethod("setName",
+								new Class[] { String.class }));
+				PropertyDescriptor pd2 = new PropertyDescriptor("ii", null,
+						MockNoGetterBean.class.getMethod("setII",
+								new Class[] { Integer.class }));
+				return new PropertyDescriptor[] { pd, pd2 };
+			} catch (Exception e) {
+				throw new Error(e);
+			}
+		}
+	}
+
+	/*
+	 * Mock bean with no getter.
+	 */
+	public static class MockNoGetterBean extends MockFoo {
+		private Integer ii = new Integer(2);
+
+		public void setII(Integer i) {
+			this.ii = i;
+		}
+	}
+
+	/*
+	 * Mock bean with no getter.
+	 */
+	public static class MockNoGetterBean2 {
+		private int ii;
+
+		public MockNoGetterBean2(int i) {
+			this.ii = i;
+		}
+
+		public void setI(int i) {
+			this.ii = i;
+		}
+	}
+
+	/*
+	 * BeanInfo for the MockBean below.
+	 */
+	public static class MockNoSetterBeanBeanInfo extends SimpleBeanInfo {
+
+		public PropertyDescriptor[] getPropertyDescriptors() {
+			try {
+				PropertyDescriptor pd = new PropertyDescriptor("name",
+						MockNoSetterBean.class.getMethod("getName", null), null);
+				return new PropertyDescriptor[] { pd };
+			} catch (Exception e) {
+				throw new Error(e);
+			}
+		}
+	}
+
+	/*
+	 * Mock bean with no setter.
+	 */
+	public static class MockNoSetterBean {
+		private String name;
+
+		public String getName() {
+			return name;
+		}
+
+		public void setName(String name) {
+			this.name = name;
+		}
+	}
+
+	/*
+	 * BeanInfo for the MockBean below.
+	 */
+	public static class MockTransientBeanBeanInfo extends SimpleBeanInfo {
+
+		private static boolean trans = true;
+
+		public static void setTransient(boolean b) {
+			trans = b;
+		}
+
+		public PropertyDescriptor[] getPropertyDescriptors() {
+			try {
+				PropertyDescriptor pd = new PropertyDescriptor("name",
+						MockTransientBean.class);
+				pd.setValue("transient", new Boolean(trans));
+				return new PropertyDescriptor[] { pd };
+			} catch (Exception e) {
+				throw new Error(e);
+			}
+		}
+	}
+
+	/*
+	 * Mock bean with a transient property.
+	 */
+	public static class MockTransientBean extends MockFoo {
+	}
+
+	/*
+	 * Mock bean.
+	 */
+	public static class MockBean {
+		private transient String prop1;
+
+		private transient int prop2;
+
+		public String getProp1() {
+			return this.prop1;
+		}
+
+		public int getProp2() {
+			return this.prop2;
+		}
+
+		public int getProp3() {
+			return this.prop2;
+		}
+
+		public void setProp3() {
+			// empty
+		}
+
+		public int getProp4(int i) {
+			return this.prop2;
+		}
+
+		public int getProp5() throws Exception {
+			throw new Exception();
+		}
+
+		private int getProp6() {
+			return 1;
+		}
+
+		public int getProp7() {
+			throw new Error();
+		}
+
+		public void setAll(String prop1, int prop2) {
+			this.prop1 = prop1;
+			this.prop2 = prop2;
+		}
+
+		public int get() {
+			return this.prop2;
+		}
+
+	}
+
+	/*
+	 * Mock DefaultPersistenceDelegate subclass.
+	 */
+	static class MockPersistenceDelegate extends DefaultPersistenceDelegate {
+
+		public MockPersistenceDelegate() {
+			super();
+		}
+
+		public MockPersistenceDelegate(String[] props) {
+			super(props);
+		}
+
+		public Expression instantiate(Object oldInstance, Encoder out) {
+			return super.instantiate(oldInstance, out);
+		}
+
+		public void initialize(Class type, Object oldInstance,
+				Object newInstance, Encoder enc) {
+			super.initialize(type, oldInstance, newInstance, enc);
+		}
+
+		public boolean mutatesTo(Object oldInstance, Object newInstance) {
+			return super.mutatesTo(oldInstance, newInstance);
+		}
+
+		protected boolean equals(String o) {
+			return true;
+		}
+
+	}
+
+	/*
+	 * Mock Encoder.
+	 */
+	static class MockEncoder extends Encoder {
+
+		public ExceptionListener getExceptionListener() {
+			StackTraceElement[] eles = (new Throwable()).getStackTrace();
+			int i = 1;
+			// while (eles[i++].getClassName().equals(
+			// DefaultPersistenceDelegate.class.getName())) {
+			// // skip calls from DefaultPersistenceDelegate
+			// }
+			return super.getExceptionListener();
+		}
+
+		public PersistenceDelegate getPersistenceDelegate(Class type) {
+			return super.getPersistenceDelegate(type);
+		}
+
+		public void setExceptionListener(ExceptionListener exceptionListener) {
+			super.setExceptionListener(exceptionListener);
+		}
+
+		public void setPersistenceDelegate(Class type,
+				PersistenceDelegate persistenceDelegate) {
+			super.setPersistenceDelegate(type, persistenceDelegate);
+		}
+
+		private void recordCall(Object param) {
+			StackTraceElement[] eles = (new Throwable()).getStackTrace();
+			int i = 0;
+			// skip Throwable.init()
+			while (eles[i].getClassName().equals("java.lang.Throwable")) {
+				i++;
+			}
+			// skip calls from MockEncoder
+			while (eles[i].getClassName().equals(MockEncoder.class.getName())) {
+				i++;
+			}
+			// skip calls from DefaultPersistenceDelegate & PersistenceDelegate
+			while (eles[i].getClassName().equals(
+					DefaultPersistenceDelegate.class.getName())
+					|| eles[i].getClassName().equals(
+							PersistenceDelegate.class.getName())) {
+				i++;
+			}
+			if (i > 2
+					&& eles[++i].getClassName().equals(
+							DefaultPersistenceDelegateTest.class.getName())) {
+				CallVerificationStack.getInstance().push(param);
+			}
+		}
+
+		public Object get(Object oldInstance) {
+			recordCall(oldInstance);
+			return super.get(oldInstance);
+		}
+
+		public Object remove(Object oldInstance) {
+			recordCall(oldInstance);
+			return super.remove(oldInstance);
+		}
+
+		public void writeExpression(Expression oldExp) {
+			recordCall(oldExp);
+			super.writeExpression(oldExp);
+		}
+
+		public void writeStatement(Statement oldStm) {
+			recordCall(oldStm);
+			super.writeStatement(oldStm);
+		}
+
+		public void writeObject(Object o) {
+			recordCall(o);
+			super.writeObject(o);
+		}
+	}
+
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/DependencyBean.xml
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/DependencyBean.xml?rev=394923&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/DependencyBean.xml (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/DependencyBean.xml Tue Apr 18 05:11:09 2006
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+
+<!-- Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+     
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+     
+         http://www.apache.org/licenses/LICENSE-2.0
+     
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License. -->
+
+<java version="1.4.2_07" class="java.beans.XMLDecoder"> 
+ <object class="tests.api.java.beans.XMLEncoderTest$DependencyBean"> 
+  <void id="intArray0" property="ints"> 
+   <void index="0"> 
+    <int>888</int> 
+   </void> 
+  </void> 
+  <void property="ref"> 
+   <object idref="intArray0"/> 
+  </void> 
+ </object> 
+</java> 

Added: incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/DesignModeTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/DesignModeTest.java?rev=394923&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/DesignModeTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/DesignModeTest.java Tue Apr 18 05:11:09 2006
@@ -0,0 +1,41 @@
+/* Copyright 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package tests.api.java.beans;
+
+import java.beans.DesignMode;
+
+import junit.framework.TestCase;
+
+/**
+ * Test the signature of the interface DesignMode.
+ */
+public class DesignModeTest extends TestCase {
+
+    public void testSignature() {
+        DummyDesignMode o = new DummyDesignMode();
+        assertTrue(o instanceof DesignMode);
+    }
+
+    static class DummyDesignMode implements DesignMode {
+
+        public boolean isDesignTime() {
+            return false;
+        }
+
+        public void setDesignTime(boolean value) {
+        }
+    }
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/EncoderTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/EncoderTest.java?rev=394923&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/EncoderTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/EncoderTest.java Tue Apr 18 05:11:09 2006
@@ -0,0 +1,491 @@
+/* Copyright 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package tests.api.java.beans;
+
+import java.beans.DefaultPersistenceDelegate;
+import java.beans.Encoder;
+import java.beans.ExceptionListener;
+import java.beans.Expression;
+import java.beans.PersistenceDelegate;
+import java.beans.Statement;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.lang.reflect.Proxy;
+import java.util.List;
+
+import junit.framework.TestCase;
+import tests.api.java.beans.mock.MockBean4Codec;
+import tests.api.java.beans.mock.MockBean4CodecBadGetter;
+import tests.api.java.beans.mock.MockExceptionListener;
+import tests.api.java.beans.mock.MockFooLiYang;
+
+public class EncoderTest extends TestCase {
+
+	public static void main(String[] args) throws Exception {
+		// VerboseEncoder enc = new VerboseEncoder();
+		// SampleBean b = new SampleBean();
+		// b.setI(3);
+		// b.setMyid("new name");
+		// enc.writeObject(b);
+		// enc.remove(b);
+		// enc.writeObject(null);
+
+		junit.textui.TestRunner.run(EncoderTest.class);
+	}
+
+	public static class VerboseEncoder extends Encoder {
+
+		private PrintWriter out;
+
+		private boolean ident;
+
+		public VerboseEncoder() {
+			this(new PrintWriter(System.out, true), true);
+		}
+
+		public VerboseEncoder(PrintWriter out, boolean ident) {
+			this.out = out;
+			this.ident = ident;
+		}
+
+		public Object get(Object arg0) {
+			String identStr = ident ? ident() : "";
+			out.println(identStr + "get()> " + arg0);
+			Object result = super.get(arg0);
+			out.println(identStr + "get()< " + result);
+			return result;
+		}
+
+		public PersistenceDelegate getPersistenceDelegate(Class type) {
+			PersistenceDelegate result = super.getPersistenceDelegate(type);
+			return result;
+		}
+
+		public Object remove(Object arg0) {
+			String identStr = ident ? ident() : "";
+			out.println(identStr + "remove()> " + arg0);
+			Object result = super.remove(arg0);
+			out.println(identStr + "remove()< " + result);
+			return result;
+		}
+
+		public void writeExpression(Expression arg0) {
+			String identStr = ident ? ident() : "";
+			out.println(identStr + "writeExpression()> " + string(arg0));
+			super.writeExpression(arg0);
+			out.println(identStr + "writeExpression()< ");
+		}
+
+		public void writeStatement(Statement arg0) {
+			String identStr = ident ? ident() : "";
+			out.println(identStr
+					+ new Exception().getStackTrace()[1].getClassName()
+					+ ".writeStatement()> " + string(arg0));
+			super.writeStatement(arg0);
+			out.println(identStr + "writeStatement()< ");
+		}
+
+		public void writeObject(Object arg0) {
+			String identStr = ident ? ident() : "";
+			out.println(identStr + "writeObject()> " + arg0);
+			super.writeObject(arg0);
+			out.println(identStr + "writeObject()< ");
+		}
+	}
+
+	public static class VerbosePD extends DefaultPersistenceDelegate {
+
+		protected void initialize(Class arg0, Object arg1, Object arg2,
+				Encoder arg3) {
+			System.out.println(ident() + "PDinitialize()> " + arg0 + ", "
+					+ arg1 + ", " + arg2);
+			super.initialize(arg0, arg1, arg2, arg3);
+			System.out.println(ident() + "PDinitialize()< ");
+		}
+
+		protected Expression instantiate(Object arg0, Encoder arg1) {
+			System.out.println(ident() + "PDinstantiate()> " + arg0);
+			Expression result = super.instantiate(arg0, arg1);
+			System.out.println(ident() + "PDinstantiate()< " + result);
+			return result;
+		}
+
+		protected boolean mutatesTo(Object arg0, Object arg1) {
+			System.out
+					.println(ident() + "PDmutatesTo()> " + arg0 + ", " + arg1);
+			boolean result = super.mutatesTo(arg0, arg1);
+			System.out.println(ident() + "PDmutatesTo()< " + result);
+			return result;
+		}
+
+		public void writeObject(Object arg0, Encoder arg1) {
+			System.out.println(ident() + "PDwriteObject()> " + arg0);
+			super.writeObject(arg0, arg1);
+			System.out.println(ident() + "PDwriteObject()< ");
+		}
+	}
+
+	public static class SampleBean {
+		String myid = "default ID";
+
+		int i = 1;
+
+		SampleBean ref;
+
+		public String getMyid() {
+			return myid;
+		}
+
+		public void setMyid(String myid) {
+			this.myid = myid;
+		}
+
+		public int getI() {
+			return i;
+		}
+
+		public void setI(int i) {
+			this.i = i;
+		}
+
+		public SampleBean getRef() {
+			return ref;
+		}
+
+		public void setRef(SampleBean ref) {
+			this.ref = ref;
+		}
+
+		public String toString() {
+			String superResult = super.toString();
+			String addr = superResult.substring(superResult.indexOf("@"));
+			return "myid=" + myid;
+		}
+	}
+
+	public static String ident() {
+		Exception ex = new Exception();
+		int level = ex.getStackTrace().length;
+		StringBuffer buf = new StringBuffer();
+		for (int i = 0; i < level; i++) {
+			buf.append("  ");
+		}
+		return buf.toString();
+	}
+
+	public static String string(Statement stat) {
+		String str = "(" + stat.getTarget() + ")." + stat.getMethodName() + "(";
+		Object args[] = stat.getArguments();
+		for (int i = 0; i < args.length; i++) {
+			if (i > 0) {
+				str += ", ";
+			}
+			str += args[i];
+		}
+		str = str + ")";
+		return str;
+	}
+
+	public static String string(Expression exp) {
+		String str = "";
+		try {
+			str += str + exp.getValue();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		str += "=" + string((Statement) exp);
+		return str;
+	}
+
+	public static class MockEncoder extends Encoder {
+
+		public void writeObject(Object o) {
+			super.writeObject(o);
+		}
+	}
+
+	public void testGetExceptionListener() {
+		MockEncoder enc = new MockEncoder();
+		assertNotNull(enc.getExceptionListener());
+
+		MockExceptionListener l = new MockExceptionListener();
+		enc.setExceptionListener(l);
+		assertSame(l, enc.getExceptionListener());
+
+		enc.writeObject(new MockBean4CodecBadGetter());
+		assertTrue(l.size() > 0);
+	}
+
+	public void testSetExceptionListener_Null() {
+		MockEncoder enc = new MockEncoder();
+		ExceptionListener l = enc.getExceptionListener();
+		enc.setExceptionListener(null);
+		assertSame(l, enc.getExceptionListener());
+
+		ExceptionListener l2 = new MockExceptionListener();
+		enc.setExceptionListener(l2);
+		enc.setExceptionListener(null);
+		assertSame(l.getClass(), enc.getExceptionListener().getClass());
+	}
+
+	public void testSetExceptionListener() {
+		MockEncoder enc = new MockEncoder();
+		assertNotNull(enc.getExceptionListener());
+
+		MockExceptionListener l = new MockExceptionListener();
+		enc.setExceptionListener(l);
+		assertSame(l, enc.getExceptionListener());
+
+		enc.writeObject(new MockBean4CodecBadGetter());
+		assertTrue(l.size() > 0);
+	}
+
+	public void testWriteExpression() {
+		// covered by testWriteObject()
+	}
+
+	public void testWriteExpression_Null() {
+		MockEncoder enc = new MockEncoder();
+		try {
+			enc.writeExpression(null);
+			fail();
+		} catch (NullPointerException e) {
+			// expected
+		}
+	}
+
+	public void testWriteStatement() {
+		// covered by testWriteObject()
+	}
+
+	public void testWriteStatement_Null() {
+		MockEncoder enc = new MockEncoder();
+		try {
+			enc.writeStatement(null);
+			fail();
+		} catch (NullPointerException e) {
+			// expected
+		}
+	}
+
+	public void testWriteObject_Null() {
+		StringWriter sbwriter = new StringWriter();
+		VerboseEncoder enc = new VerboseEncoder(
+				new PrintWriter(sbwriter, true), false);
+		enc.writeObject(null);
+		String trace = sbwriter.toString();
+
+		final String LS = System.getProperty("line.separator");
+		assertEquals("writeObject()> null" + LS + "writeObject()< " + LS, trace);
+	}
+
+	public void testWriteObject() {
+		StringWriter sbwriter = new StringWriter();
+		VerboseEncoder enc = new VerboseEncoder(
+				new PrintWriter(sbwriter, true), false);
+		SampleBean b = new SampleBean();
+		b.setI(3);
+		b.setMyid("new name");
+		enc.writeObject(b);
+		String trace = sbwriter.toString();
+
+		final String LS = System.getProperty("line.separator");
+		int lastIndex = 0, index = 0;
+
+		index = trace
+				.indexOf(
+						"writeObject()> myid=new name"
+								+ LS
+								+ "get()> myid=new name"
+								+ LS
+								+ "get()< null"
+								+ LS
+								+ "remove()> myid=new name"
+								+ LS
+								+ "remove()< null"
+								+ LS
+								+ "writeExpression()> myid=new name=(class tests.api.java.beans.EncoderTest$SampleBean).new()"
+								+ LS, lastIndex);
+		assertTrue(lastIndex <= index);
+		lastIndex = index;
+
+		index = trace
+				.indexOf("writeObject()> myid=new name" + LS
+						+ "get()> myid=new name" + LS
+						+ "get()< myid=default ID" + LS
+						+ "writeExpression()> 3=(myid=new name).getI()" + LS,
+						lastIndex);
+		assertTrue(lastIndex <= index);
+		lastIndex = index;
+
+		index = trace.indexOf("get()> 3" + LS + "get()< 1" + LS, lastIndex);
+		assertTrue(lastIndex <= index);
+		lastIndex = index;
+
+		index = trace.indexOf(
+				"writeExpression()> new name=(myid=new name).getMyid()" + LS
+						+ "get()> new name" + LS + "get()< new name" + LS
+						+ "writeExpression()< " + LS, lastIndex);
+		assertTrue(lastIndex <= index);
+		lastIndex = index;
+
+		index = trace.indexOf(
+				"writeStatement()> (myid=new name).setMyid(new name)" + LS
+						+ "get()> myid=new name" + LS
+						+ "get()< myid=default ID" + LS + "get()> new name"
+						+ LS + "get()< new name" + LS + "writeStatement()< "
+						+ LS, lastIndex);
+		assertTrue(lastIndex <= index);
+		lastIndex = index;
+	}
+
+	public void testGetPersistenceDelegate_Null() {
+		// TODO different behavior
+		// MockEncoder enc = new MockEncoder();
+		// PersistenceDelegate pd = enc.getPersistenceDelegate(null);
+		// assertNotNull(pd);
+	}
+
+	public void testGetPersistenceDelegate_ArrayClass() {
+		MockEncoder enc = new MockEncoder();
+		PersistenceDelegate pd = enc.getPersistenceDelegate(int[].class);
+		assertFalse(pd instanceof DefaultPersistenceDelegate);
+	}
+
+	public void testGetPersistenceDelegate_ProxyClass() {
+		MockEncoder enc = new MockEncoder();
+		PersistenceDelegate pd = enc.getPersistenceDelegate(Proxy
+				.getProxyClass(ClassLoader.getSystemClassLoader(),
+						new Class[] { List.class }));
+	}
+
+	public void testGetPersistenceDelegate_BeanInfo() {
+		MockEncoder enc = new MockEncoder();
+		PersistenceDelegate pd = enc
+				.getPersistenceDelegate(MockFooLiYang.class);
+		assertTrue(pd instanceof VerbosePD);
+	}
+
+	public void testGetPersistenceDelegate_Default() {
+		MockEncoder enc = new MockEncoder();
+		MockEncoder enc2 = new MockEncoder();
+
+		PersistenceDelegate pd1 = enc.getPersistenceDelegate(SampleBean.class);
+		assertTrue(pd1 instanceof DefaultPersistenceDelegate);
+
+		PersistenceDelegate pd2 = enc.getPersistenceDelegate(SampleBean.class);
+		assertTrue(pd2 instanceof DefaultPersistenceDelegate);
+
+		PersistenceDelegate pd3 = enc2
+				.getPersistenceDelegate(MockBean4Codec.class);
+		assertTrue(pd3 instanceof DefaultPersistenceDelegate);
+
+		assertSame(pd1, pd2);
+		assertSame(pd1, pd3);
+	}
+
+	public void testSetPersistenceDelegate_Null() {
+		MockEncoder enc = new MockEncoder();
+		PersistenceDelegate pd = enc.getPersistenceDelegate(EncoderTest.class);
+
+		try {
+			enc.setPersistenceDelegate(null, pd);
+			fail();
+		} catch (NullPointerException e) {
+			// expected
+		}
+
+		try {
+			enc.setPersistenceDelegate(EncoderTest.class, null);
+			fail();
+		} catch (NullPointerException e) {
+			// expected
+		}
+	}
+
+	public void testSetPersistenceDelegate() {
+		MockEncoder enc = new MockEncoder();
+		PersistenceDelegate pd = enc.getPersistenceDelegate(EncoderTest.class);
+		assertTrue(pd instanceof DefaultPersistenceDelegate);
+
+		enc.setPersistenceDelegate(EncoderTest.class, new VerbosePD());
+		assertTrue(enc.getPersistenceDelegate(EncoderTest.class) instanceof VerbosePD);
+
+		MockEncoder enc2 = new MockEncoder();
+		assertTrue(enc.getPersistenceDelegate(EncoderTest.class) instanceof VerbosePD);
+	}
+
+	public void testGet_NullParam() {
+		MockEncoder enc = new MockEncoder();
+
+		assertNull(enc.get(null));
+	}
+
+	public void testGet_String() {
+		MockEncoder enc = new MockEncoder();
+
+		String str = "string";
+		assertSame(str, enc.get(str));
+	}
+
+	public void testGet_Integer() {
+		MockEncoder enc = new MockEncoder();
+
+		Integer integer = new Integer(8);
+		assertNull(enc.get(integer));
+		enc.writeObject(integer);
+		assertEquals(integer, enc.get(integer));
+		assertNull(enc.get(new Integer(integer.intValue())));
+
+		Double d = new Double(8);
+		assertNull(enc.get(d));
+		enc.writeObject(d);
+		assertEquals(d, enc.get(d));
+	}
+
+	public void testRemove_Null() {
+		MockEncoder enc = new MockEncoder();
+
+		assertNull(enc.remove(null));
+	}
+
+	public void testRemove_String() {
+		MockEncoder enc = new MockEncoder();
+
+		String str = "string";
+		assertSame(str, enc.get(str));
+		assertNull(enc.remove(str));
+
+		enc.writeObject(str);
+		assertSame(str, enc.get(str));
+		assertNull(enc.remove(str));
+	}
+
+	public void testRemove_Integer() {
+		MockEncoder enc = new MockEncoder();
+
+		Integer integer = new Integer(8);
+		assertNull(enc.remove(integer));
+
+		enc.writeObject(integer);
+		assertEquals(integer, enc.get(integer));
+		assertEquals(integer, enc.remove(integer));
+
+		assertNull(enc.get(integer));
+		assertNull(enc.remove(integer));
+	}
+
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/EventHandlerTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/EventHandlerTest.java?rev=394923&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/EventHandlerTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/EventHandlerTest.java Tue Apr 18 05:11:09 2006
@@ -0,0 +1,971 @@
+/* Copyright 2005 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package tests.api.java.beans;
+
+import java.beans.EventHandler;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyChangeSupport;
+import java.io.Serializable;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.EventListener;
+import java.util.EventObject;
+
+import junit.framework.TestCase;
+import tests.api.java.beans.mock.MockButton;
+
+/**
+ * Unit test for EventHandler.
+ */
+public class EventHandlerTest extends TestCase {
+
+	/*
+	 * @see TestCase#setUp()
+	 */
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	/*
+	 * @see TestCase#tearDown()
+	 */
+	protected void tearDown() throws Exception {
+		super.tearDown();
+	}
+
+	/*
+	 * Class under test for Object create(Class, Object, String)
+	 */
+	public void testCreateClassObjectString() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "setCalled");
+		button.addPropertyChangeListener(proxy);
+		button.setLabel("new label value");
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+		assertTrue(target.isCalled());
+	}
+
+	/*
+	 * listenerInterface class is null
+	 */
+	public void testCreateClassObjectString_ClassNull() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		try {
+			PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+					.create(null, target, "setCalled");
+			fail("Should throw NullPointerException.");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	/*
+	 * listenerInterface is not a interface
+	 */
+	public void testCreateClassObjectString_ClassInvalid() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		try {
+			PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+					.create(MockButton.class, target, "setCalled");
+			fail("Should throw IllegalArgumentException.");
+		} catch (IllegalArgumentException e) {
+		}
+	}
+
+	/*
+	 * the target object is null
+	 */
+	public void testCreateClassObjectString_ObjectNull() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		try {
+			PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+					.create(PropertyChangeListener.class, null, "setCalled");
+			fail("Should throw NullPointerException.");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	/*
+	 * the target's method is null
+	 */
+	public void testCreateClassObjectString_MethodNull() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, null);
+		button.addPropertyChangeListener(proxy);
+		try {
+			button.setLabel("new label value");
+			fail("Should throw NullPointerException.");
+		} catch (NullPointerException e) {
+		}
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+	}
+
+	/*
+	 * the target's method is invalid
+	 */
+	public void testCreateClassObjectString_MethodEmpty() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "");
+		button.addPropertyChangeListener(proxy);
+		try {
+			button.setLabel("new label value");
+			fail("Should throw IndexOutOfBoundsException.");
+		} catch (IndexOutOfBoundsException e) {
+		}
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+	}
+
+	/*
+	 * Class under test for Object create(Class, Object, String, String)
+	 */
+	public void testCreateClassObjectStringString() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "text",
+						"source.label");
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+
+		button.addPropertyChangeListener(proxy);
+		String newLabel = "New Value: set text.";
+		button.setLabel(newLabel);
+		assertEquals(MockButton.defaultName, target.getText());
+		button.setLabel("New Value: set text2.");
+		assertEquals(newLabel, target.getText());
+	}
+
+	/*
+	 * listenerInterface is null
+	 */
+	public void testCreateClassObjectStringString_ClassNull() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		try {
+			PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+					.create(null, target, "text", "source.label");
+			fail("Should throw NullPointerException");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	/*
+	 * listenerInterface is not a interface
+	 */
+	public void testCreateClassObjectStringString_ClassInvalid() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		try {
+			PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+					.create(String.class, target, "text", "source.label");
+			fail("Should throw IllegalArgumentException");
+		} catch (IllegalArgumentException e) {
+		}
+	}
+
+	/*
+	 * the target object is null
+	 */
+	public void testCreateClassObjectStringString_TargetNull() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		try {
+			PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+					.create(PropertyChangeListener.class, null, "text",
+							"source.label");
+			fail("Should throw NullPointerException");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	/*
+	 * the action is null
+	 */
+	public void testCreateClassObjectStringString_ActionNull() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, null,
+						"source.label");
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+
+		button.addPropertyChangeListener(proxy);
+		String newLabel = "New Value: set text.";
+		try {
+			button.setLabel(newLabel);
+			fail("Should throw NullPointerException.");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	/*
+	 * action is invalid
+	 */
+	public void testCreateClassObjectStringString_ActionInvalid() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "action_invalid",
+						"source.label");
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+
+		button.addPropertyChangeListener(proxy);
+		String newLabel = "New Value: set text.";
+		try {
+			button.setLabel(newLabel);
+			fail("Should throw NullPointerException.");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	/*
+	 * propertyname is null
+	 */
+	public void testCreateClassObjectStringString_PropertyNameNull() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "text", null);
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+
+		button.addPropertyChangeListener(proxy);
+		String newLabel = "New Value: set text.";
+		try {
+			button.setLabel(newLabel);
+			fail("Should throw NullPointerException.");
+		} catch (Exception e) {
+		}
+	}
+
+	/*
+	 * property name is invalid
+	 */
+	public void testCreateClassObjectStringString_PropertyNameInvalid() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "text",
+						"source.label_invalid");
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+
+		button.addPropertyChangeListener(proxy);
+		String newLabel = "New Value: set text.";
+		try {
+			button.setLabel(newLabel);
+			fail("Should throw NullPointerException.");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	/*
+	 * Class under test for Object create(Class, Object, String, String, String)
+	 */
+	public void testCreateClassObjectStringStringString() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "text",
+						"source.label", "propertyChange");
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+
+		button.addPropertyChangeListener(proxy);
+		String newLabel = "New Value: set text.";
+		button.setLabel(newLabel);
+		assertEquals(MockButton.defaultName, target.getText());
+		button.setLabel("New Value: set text2.");
+		assertEquals(newLabel, target.getText());
+	}
+
+	/*
+	 * listenerInterface is null
+	 */
+	public void testCreateClassObjectStringStringString_ClassNull() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		try {
+			PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+					.create(null, target, "text", "source.label",
+							"propertyChange");
+			fail("Should throw NullPointerException.");
+		} catch (NullPointerException e) {
+
+		}
+	}
+
+	/*
+	 * listenerInterface is invalid
+	 */
+	public void testCreateClassObjectStringStringString_ClassInvalid() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		try {
+			PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+					.create(Serializable.class, target, "text", "source.label",
+							"propertyChange");
+			fail("Should throw ClassCastException.");
+		} catch (ClassCastException e) {
+		}
+	}
+
+	/*
+	 * the target object is null
+	 */
+	public void testCreateClassObjectStringStringString_TargetNull() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		try {
+			PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+					.create(PropertyChangeListener.class, null, "text",
+							"source.label", "propertyChange");
+			fail("Should throw NullPointerException.");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	/*
+	 * action is null
+	 */
+	public void testCreateClassObjectStringStringString_ActionNull() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, null,
+						"source.label", "propertyChange");
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+
+		button.addPropertyChangeListener(proxy);
+		String newLabel = "New Value: set text.";
+		try {
+			button.setLabel(newLabel);
+			fail("Should throw NullPointerException.");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	/*
+	 * action is invalid
+	 */
+	public void testCreateClassObjectStringStringString_ActionInvalid() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "text_invalid",
+						"source.label", "propertyChange");
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+
+		button.addPropertyChangeListener(proxy);
+		String newLabel = "New Value: set text.";
+		try {
+			button.setLabel(newLabel);
+			fail("Should throw NullPointerException.");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	/*
+	 * property name is null
+	 */
+	public void testCreateClassObjectStringStringString_PropertyNull() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "text", null,
+						"propertyChange");
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+
+		button.addPropertyChangeListener(proxy);
+		String newLabel = "New Value: set text.";
+		try {
+			button.setLabel(newLabel);
+			fail("Should throw NullPointerException.");
+		} catch (Exception e) {
+		}
+	}
+
+	/*
+	 * property name is invalid
+	 */
+	public void testCreateClassObjectStringStringString_PropertyInvalid() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "text",
+						"source.label.invalid", "propertyChange");
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+
+		button.addPropertyChangeListener(proxy);
+		String newLabel = "New Value: set text.";
+		try {
+			button.setLabel(newLabel);
+			fail("Should throw NullPointerException.");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	/*
+	 * listenerMethodName is null
+	 */
+	public void testCreateClassObjectStringStringString_MethodNull() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "text",
+						"source.label", null);
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+
+		button.addPropertyChangeListener(proxy);
+		String newLabel = "New Value: set text.";
+		button.setLabel(newLabel);
+		assertEquals(MockButton.defaultName, target.getText());
+		button.setLabel("New Value: set text2.");
+		assertEquals(newLabel, target.getText());
+	}
+
+	/*
+	 * listenerMethodName is invalid
+	 */
+	public void testCreateClassObjectStringStringString_MethodInvalid() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "text",
+						"source.label", "propertyChange_invalid");
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+
+		button.addPropertyChangeListener(proxy);
+		String newLabel = "New Value: set text.";
+		button.setLabel(newLabel);
+		assertNull(target.getText());
+	}
+
+	/*
+	 * public EventHandler(Object target, String action, String
+	 * eventPropertyName, String listenerMethodName)
+	 */
+	public void testEventHandler() {
+		MockTarget target = new MockTarget();
+		String action = "text";
+		String eventPropertyName = "source.label";
+		String listenerMethodName = "propertyChange";
+		EventHandler handler = new EventHandler(target, action,
+				eventPropertyName, listenerMethodName);
+		assertSame(target, handler.getTarget());
+		assertSame(action, handler.getAction());
+		assertSame(eventPropertyName, handler.getEventPropertyName());
+		assertSame(listenerMethodName, handler.getListenerMethodName());
+	}
+
+	/*
+	 * target is null
+	 */
+	public void testEventHandler_TargetNull() {
+		String action = "text";
+		String eventPropertyName = "source.label";
+		String listenerMethodName = "propertyChange";
+		EventHandler handler = new EventHandler(null, action,
+				eventPropertyName, listenerMethodName);
+		assertNull(handler.getTarget());
+		assertSame(action, handler.getAction());
+		assertSame(eventPropertyName, handler.getEventPropertyName());
+		assertSame(listenerMethodName, handler.getListenerMethodName());
+	}
+
+	/*
+	 * action is null
+	 */
+	public void testEventHandler_ActionNull() {
+		MockTarget target = new MockTarget();
+		String eventPropertyName = "source.label";
+		String listenerMethodName = "propertyChange";
+		EventHandler handler = new EventHandler(target, null,
+				eventPropertyName, listenerMethodName);
+		assertSame(target, handler.getTarget());
+		assertNull(handler.getAction());
+		assertSame(eventPropertyName, handler.getEventPropertyName());
+		assertSame(listenerMethodName, handler.getListenerMethodName());
+	}
+
+	/*
+	 * EventProperty is null
+	 */
+	public void testEventHandler_EventPropertyNull() {
+		MockTarget target = new MockTarget();
+		String action = "text";
+		String listenerMethodName = "propertyChange";
+		EventHandler handler = new EventHandler(target, action, null,
+				listenerMethodName);
+		assertSame(target, handler.getTarget());
+		assertSame(action, handler.getAction());
+		assertNull(handler.getEventPropertyName());
+		assertSame(listenerMethodName, handler.getListenerMethodName());
+	}
+
+	/*
+	 * Method is null
+	 */
+	public void testEventHandler_MethodNull() {
+		MockTarget target = new MockTarget();
+		String action = "text";
+		String eventPropertyName = "source.label";
+		EventHandler handler = new EventHandler(target, action,
+				eventPropertyName, null);
+		assertSame(target, handler.getTarget());
+		assertSame(action, handler.getAction());
+		assertSame(eventPropertyName, handler.getEventPropertyName());
+		assertNull(handler.getListenerMethodName());
+	}
+
+	public void testInvoke_1() throws SecurityException, NoSuchMethodException {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "setCalled");
+
+		PropertyChangeListener proxy2 = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "setCalled");
+
+		String action = "text";
+		String eventPropertyName = "source.label";
+		EventHandler handler = new EventHandler(target, action,
+				eventPropertyName, null);
+		Method listenerMethod = PropertyChangeListener.class.getMethod(
+				"propertyChange", new Class[] { PropertyChangeEvent.class });
+		PropertyChangeEvent event = new PropertyChangeEvent(button, "label",
+				"1", "5");
+		handler.invoke(proxy, listenerMethod, new Object[] { event });
+		assertEquals(button.getLabel(), target.getText());
+		Method equalsMethod = Object.class.getMethod("equals",
+				new Class[] { Object.class });
+		assertEquals(Boolean.FALSE, handler.invoke(proxy, equalsMethod,
+				new String[] { "mock" }));
+	}
+
+	public void testIncompatibleMethod() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "Text", "source");
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+
+		button.addPropertyChangeListener(proxy);
+		String newLabel = "New Value: set text.";
+		try {
+			button.setLabel(newLabel);
+			fail("Should throw NullPointerException.");
+		} catch (NullPointerException e) {
+
+		}
+	}
+
+	public void testCoverage_1() {
+		MockTarget target = new MockTarget();
+		MockButton button = new MockButton();
+		PropertyChangeListener proxy = (PropertyChangeListener) EventHandler
+				.create(PropertyChangeListener.class, target, "Text", "");
+		assertTrue(Proxy.isProxyClass(proxy.getClass()));
+
+		button.addPropertyChangeListener(proxy);
+		String newLabel = "New Value: set text.";
+		try {
+			button.setLabel(newLabel);
+			fail("Should throw NullPointerException.");
+		} catch (NullPointerException e) {
+
+		}
+
+	}
+
+	public void testInvoke_extend1() {
+		MockFish fish = new MockFish();
+		MockFishTarget target = new MockFishTarget();
+		PropertyChangeSupport support = new PropertyChangeSupport(fish);
+		Object proxy = EventHandler.create(PropertyChangeListener.class,
+				target, "action1");
+		support.addPropertyChangeListener((PropertyChangeListener) proxy);
+		PropertyChangeEvent event = new PropertyChangeEvent(fish, "name", "1",
+				"5");
+		support.firePropertyChange(event);
+		assertEquals("action1", target.getActionRecord());
+	}
+
+	public void testInvoke_extend1_1() {
+		MockFish fish = new MockFish();
+		MockFishTarget target = new MockFishTarget();
+		PropertyChangeSupport support = new PropertyChangeSupport(fish);
+		Object proxy = EventHandler.create(PropertyChangeListener.class,
+				target, "action4");
+		support.addPropertyChangeListener((PropertyChangeListener) proxy);
+		PropertyChangeEvent event = new PropertyChangeEvent(fish, "name", "1",
+				"5");
+		try {
+			support.firePropertyChange(event);
+		} catch (Exception e) {
+
+		}
+		assertEquals("action4", target.getActionRecord());
+	}
+
+	public void testInvoke_extend2() {
+		MockFish fish = new MockFish();
+		MockFishTarget target = new MockFishTarget();
+		PropertyChangeSupport support = new PropertyChangeSupport(fish);
+		Object proxy = EventHandler.create(PropertyChangeListener.class,
+				target, "action2");
+		support.addPropertyChangeListener((PropertyChangeListener) proxy);
+		PropertyChangeEvent event = new PropertyChangeEvent(fish, "name", "1",
+				"5");
+		try {
+			support.firePropertyChange(event);
+			fail("Should throw exception");
+		} catch (Exception e) {
+			// e.printStackTrace();
+		}
+
+	}
+
+	public void testInvoke_extend2_2() {
+		MockFish fish = new MockFish();
+		MockFishTarget target = new MockFishTarget();
+		PropertyChangeSupport support = new PropertyChangeSupport(fish);
+		Object proxy = EventHandler.create(PropertyChangeListener.class,
+				target, "action3");
+		support.addPropertyChangeListener((PropertyChangeListener) proxy);
+		PropertyChangeEvent event = new PropertyChangeEvent(fish, "name", "1",
+				"5");
+		support.firePropertyChange(event);
+
+		assertEquals("action3", target.getActionRecord());
+	}
+
+	public void testInvoke_extend3() {
+		MockFish fish = new MockFish();
+		MockFishTarget target = new MockFishTarget();
+		PropertyChangeSupport support = new PropertyChangeSupport(fish);
+		Object proxy = EventHandler.create(PropertyChangeListener.class,
+				target, "a", "source.a");
+		support.addPropertyChangeListener((PropertyChangeListener) proxy);
+		PropertyChangeEvent event = new PropertyChangeEvent(fish, "name", "1",
+				"5");
+		support.firePropertyChange(event);
+		assertEquals("boolean:true", target.getActionRecord());
+	}
+
+	public void testInvoke_extend4() {
+		MockFish fish = new MockFish();
+		MockFishTarget target = new MockFishTarget();
+		PropertyChangeSupport support = new PropertyChangeSupport(fish);
+		Object proxy = EventHandler.create(PropertyChangeListener.class,
+				target, "b", "source.a");
+		support.addPropertyChangeListener((PropertyChangeListener) proxy);
+		PropertyChangeEvent event = new PropertyChangeEvent(fish, "name", "1",
+				"5");
+		support.firePropertyChange(event);
+		assertEquals("Boolean:true", target.getActionRecord());
+	}
+
+	public void testInvoke_extend4_BooleanObject() {
+		MockFish fish = new MockFish();
+		MockFishTarget target = new MockFishTarget();
+		PropertyChangeSupport support = new PropertyChangeSupport(fish);
+		Object proxy = EventHandler.create(PropertyChangeListener.class,
+				target, "a", "source.booleanObject");
+		support.addPropertyChangeListener((PropertyChangeListener) proxy);
+		PropertyChangeEvent event = new PropertyChangeEvent(fish, "name", "1",
+				"5");
+		support.firePropertyChange(event);
+		assertEquals("boolean:true", target.getActionRecord());
+	}
+
+	public void testInvoke_extend5() {
+		MockFish fish = new MockFish();
+		MockFishTarget target = new MockFishTarget();
+		PropertyChangeSupport support = new PropertyChangeSupport(fish);
+		Object proxy = EventHandler.create(PropertyChangeListener.class,
+				target, "int", "source.int");
+		support.addPropertyChangeListener((PropertyChangeListener) proxy);
+		PropertyChangeEvent event = new PropertyChangeEvent(fish, "name", "1",
+				"5");
+		support.firePropertyChange(event);
+		assertEquals("int:1", target.getActionRecord());
+	}
+
+	public void testInvoke_extend6() {
+		MockFish fish = new MockFish();
+		MockFishTarget target = new MockFishTarget();
+		PropertyChangeSupport support = new PropertyChangeSupport(fish);
+		Object proxy = EventHandler.create(PropertyChangeListener.class,
+				target, "char", "source.char");
+		support.addPropertyChangeListener((PropertyChangeListener) proxy);
+		PropertyChangeEvent event = new PropertyChangeEvent(fish, "name", "1",
+				"5");
+		support.firePropertyChange(event);
+		assertEquals("char:a", target.getActionRecord());
+	}
+
+	public void testInvoke_extend7() {
+		MockFish fish = new MockFish();
+		MockFishTarget target = new MockFishTarget();
+		PropertyChangeSupport support = new PropertyChangeSupport(fish);
+		Object proxy = EventHandler.create(PropertyChangeListener.class,
+				target, "byte", "source.byte");
+		support.addPropertyChangeListener((PropertyChangeListener) proxy);
+		PropertyChangeEvent event = new PropertyChangeEvent(fish, "name", "1",
+				"5");
+		support.firePropertyChange(event);
+		assertEquals("byte:10", target.getActionRecord());
+	}
+
+	public void testInvoke_extend8() {
+		MockFish fish = new MockFish();
+		MockFishTarget target = new MockFishTarget();
+		PropertyChangeSupport support = new PropertyChangeSupport(fish);
+		Object proxy = EventHandler.create(PropertyChangeListener.class,
+				target, "short", "source.short");
+		support.addPropertyChangeListener((PropertyChangeListener) proxy);
+		PropertyChangeEvent event = new PropertyChangeEvent(fish, "name", "1",
+				"5");
+		support.firePropertyChange(event);
+		assertEquals("short:100", target.getActionRecord());
+	}
+
+	public void testInvoke_extend9() {
+		MockFish fish = new MockFish();
+		MockFishTarget target = new MockFishTarget();
+		PropertyChangeSupport support = new PropertyChangeSupport(fish);
+		Object proxy = EventHandler.create(PropertyChangeListener.class,
+				target, "long", "source.long");
+		support.addPropertyChangeListener((PropertyChangeListener) proxy);
+		PropertyChangeEvent event = new PropertyChangeEvent(fish, "name", "1",
+				"5");
+		support.firePropertyChange(event);
+		assertEquals("long:1000", target.getActionRecord());
+	}
+
+	public void testInvoke_extend10() {
+		MockFish fish = new MockFish();
+		MockFishTarget target = new MockFishTarget();
+		PropertyChangeSupport support = new PropertyChangeSupport(fish);
+		Object proxy = EventHandler.create(PropertyChangeListener.class,
+				target, "float", "source.float");
+		support.addPropertyChangeListener((PropertyChangeListener) proxy);
+		PropertyChangeEvent event = new PropertyChangeEvent(fish, "name", "1",
+				"5");
+		support.firePropertyChange(event);
+		assertEquals("float:2.2", target.getActionRecord());
+	}
+
+	public void testInvoke_extend11() {
+		MockFish fish = new MockFish();
+		MockFishTarget target = new MockFishTarget();
+		PropertyChangeSupport support = new PropertyChangeSupport(fish);
+		Object proxy = EventHandler.create(PropertyChangeListener.class,
+				target, "double", "source.double");
+		support.addPropertyChangeListener((PropertyChangeListener) proxy);
+		PropertyChangeEvent event = new PropertyChangeEvent(fish, "name", "1",
+				"5");
+		support.firePropertyChange(event);
+		assertEquals("double:3.3", target.getActionRecord());
+	}
+
+	public void testEventHandlerCreate() {
+		((FredListener) EventHandler.create(FredListener.class,
+				new Untitled1(), "i", "i"))
+				.fireFredEvent(new FredEvent("bean2"));
+	}
+
+	public interface FredListener extends EventListener {
+		public void fireFredEvent(FredEvent event);
+	}
+
+	public static class FredEvent extends EventObject {
+
+		private static final long serialVersionUID = 1L;
+
+		private static int i;
+
+		public FredEvent(Object source) {
+			super(source);
+		}
+
+		public static int getI() {
+			return i;
+		}
+
+		public static void setI(int j) {
+			i = j;
+		}
+	}
+
+	public static class Untitled1 {
+		private int i;
+
+		public int getI() {
+			return i;
+		}
+
+		public void setI(int i) {
+			// System.out.println("Untitled1 : setI()");
+			this.i = i;
+		}
+	}
+
+	public static class MockFish {
+		String name;
+
+		public String getName() {
+			return name;
+		}
+
+		public void setName(String name) {
+			this.name = name;
+		}
+
+		public boolean isA() {
+			return true;
+		}
+
+		public Boolean isBooleanObject() {
+			return new Boolean(true);
+		}
+
+		public int getInt() {
+			return 1;
+		}
+
+		public char getChar() {
+			return 'a';
+		}
+
+		public byte getByte() {
+			return 10;
+		}
+
+		public short getShort() {
+			return 100;
+		}
+
+		public long getLong() {
+			return 1000;
+		}
+
+		public float getFloat() {
+			return 2.2f;
+		}
+
+		public double getDouble() {
+			return 3.3;
+		}
+	}
+
+	public static class MockFishTarget {
+		String actionRecord;
+
+		public void action1() {
+			this.actionRecord = "action1";
+		}
+
+		public void setAction2(String value) {
+			this.actionRecord = "action2";
+		}
+
+		public void setAction3() {
+			this.actionRecord = "action3";
+		}
+
+		public void action4() {
+			this.actionRecord = "action4";
+		}
+
+		public void action4(EventObject event) {
+			this.actionRecord = "action4";
+		}
+
+		public String getActionRecord() {
+			return actionRecord;
+		}
+
+		public void setA(boolean value) {
+			this.actionRecord = "boolean:" + Boolean.valueOf(value).toString();
+		}
+
+		public void setB(Boolean value) {
+			this.actionRecord = "Boolean:" + value.toString();
+		}
+
+		public void setInt(int value) {
+			this.actionRecord = "int:" + value;
+		}
+
+		public void setChar(char value) {
+			this.actionRecord = "char:" + value;
+		}
+
+		public void setShort(short value) {
+			this.actionRecord = "short:" + value;
+		}
+
+		public void setByte(byte value) {
+			this.actionRecord = "byte:" + value;
+		}
+
+		public void setLong(long value) {
+			this.actionRecord = "long:" + value;
+		}
+
+		public void setFloat(float value) {
+			this.actionRecord = "float:" + value;
+		}
+
+		public void setDouble(double value) {
+			this.actionRecord = "double:" + value;
+		}
+
+	}
+
+	public static class MockTarget {
+		private boolean called;
+
+		private String text;
+
+		public MockTarget() {
+			this.called = false;
+		}
+
+		public void setCalled() {
+			this.called = true;
+		}
+
+		public boolean isCalled() {
+			return this.called;
+		}
+
+		public void setText(String text) {
+			this.text = text;
+		}
+
+		public String getText() {
+			return this.text;
+		}
+	}
+}



Mime
View raw message