harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mloe...@apache.org
Subject svn commit: r394923 [4/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/ExpressionTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/ExpressionTest.java?rev=394923&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/ExpressionTest.java
(added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/ExpressionTest.java
Tue Apr 18 05:11:09 2006
@@ -0,0 +1,1072 @@
+/* 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.Expression;
+import java.util.Arrays;
+import java.util.Vector;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import junit.framework.TestCase;
+
+/**
+ * Test the class java.beans.Expression.
+ */
+public class ExpressionTest extends TestCase {
+
+	/*
+	 * Test the constructor under normal conditions.
+	 */
+	public void testConstructor_Normal() {
+		Object arg1 = new Object();
+		Object arg2 = "string";
+		Object[] oa = new Object[] { arg1, arg2 };
+		Expression t = new Expression(arg1, "method", oa);
+		assertSame(arg1, t.getTarget());
+		assertSame("method", t.getMethodName());
+		assertSame(oa, t.getArguments());
+		assertSame(arg1, t.getArguments()[0]);
+		assertSame(arg2, t.getArguments()[1]);
+		Pattern p = Pattern
+				.compile(".*=Object[0-9]+\\.method\\(Object[0-9]+, \"string\"\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor with null target.
+	 */
+	public void testConstructor_NullTarget() {
+		Object arg = new Object();
+		Object[] oa = new Object[] { arg };
+		Expression t = new Expression(null, "method", oa);
+		assertSame(null, t.getTarget());
+		assertSame("method", t.getMethodName());
+		assertSame(oa, t.getArguments());
+		assertSame(arg, t.getArguments()[0]);
+
+		Pattern p = Pattern.compile(".*=null\\.method\\(Object[0-9]+\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor with an array target.
+	 */
+	public void testConstructor_ArrayTarget() {
+		Object arg = new Object();
+		Object[] oa = new Object[] { arg };
+		Expression t = new Expression(oa, "method", oa);
+		assertSame(oa, t.getTarget());
+		assertSame("method", t.getMethodName());
+		assertSame(oa, t.getArguments());
+		assertSame(arg, t.getArguments()[0]);
+
+		Pattern p = Pattern
+				.compile(".*=ObjectArray[0-9]+\\.method\\(Object[0-9]+\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor with null method name.
+	 */
+	public void testConstructor_NullMethodName() {
+		Object target = new Object();
+		Object[] oa = new Object[] { new Object() };
+		Expression t = new Expression(target, null, oa);
+		assertSame(target, t.getTarget());
+		assertSame(null, t.getMethodName());
+		assertSame(oa, t.getArguments());
+
+		Pattern p = Pattern
+				.compile(".*=Object[0-9]+\\.null\\(Object[0-9]+\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor with the method name "new".
+	 */
+	public void testConstructor_NewMethodName() {
+		Object target = new Object();
+		Object[] oa = new Object[] { new Object() };
+		Expression t = new Expression(target, "new", oa);
+		assertSame(target, t.getTarget());
+		assertSame("new", t.getMethodName());
+		assertSame(oa, t.getArguments());
+
+		Pattern p = Pattern.compile(".*=Object[0-9]+\\.new\\(Object[0-9]+\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor with empty method name.
+	 */
+	public void testConstructor_EmptyMethodName() {
+		Object target = new Object();
+		Object[] oa = new Object[] { new Object() };
+		Expression t = new Expression(target, "", oa);
+		assertSame(target, t.getTarget());
+		assertSame("", t.getMethodName());
+		assertSame(oa, t.getArguments());
+
+		Pattern p = Pattern.compile(".*=Object[0-9]+\\.\\(Object[0-9]+\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor with null arguments.
+	 */
+	public void testConstructor_NullArguments() {
+		Object target = new Object();
+		Expression t = new Expression(target, "method", null);
+		assertSame(target, t.getTarget());
+		assertSame("method", t.getMethodName());
+		assertEquals(0, t.getArguments().length);
+
+		Pattern p = Pattern.compile(".*=Object[0-9]+\\.method\\(\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor with a null argument.
+	 */
+	public void testConstructor_NullArgument() {
+		Object target = new Object();
+		Object[] oa = new Object[] { null };
+		Expression t = new Expression(target, "method", oa);
+		assertSame(target, t.getTarget());
+		assertSame("method", t.getMethodName());
+		assertSame(oa, t.getArguments());
+		assertNull(t.getArguments()[0]);
+
+		Pattern p = Pattern.compile(".*=Object[0-9]+\\.method\\(null\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor(value, ...) under normal conditions.
+	 */
+	public void testConstructor_Value_Normal() throws Exception {
+		Object val = new Object();
+		Object arg1 = new Object();
+		Object arg2 = new Object();
+		Object[] oa = new Object[] { arg1, arg2 };
+		Expression t = new Expression(val, arg1, "method", oa);
+		assertSame(val, t.getValue());
+		assertSame(arg1, t.getTarget());
+		assertSame("method", t.getMethodName());
+		assertSame(oa, t.getArguments());
+		assertSame(arg1, t.getArguments()[0]);
+		assertSame(arg2, t.getArguments()[1]);
+		Pattern p = Pattern
+				.compile("Object[0-9]+=Object[0-9]+\\.method\\(Object[0-9]+, Object[0-9]+\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor(value, ...) with null target.
+	 */
+	public void testConstructor_Value_NullTarget() throws Exception {
+		Object val = new Object();
+		Object arg = new Object();
+		Object[] oa = new Object[] { arg };
+		Expression t = new Expression(val, null, "method", oa);
+		assertSame(val, t.getValue());
+		assertSame(null, t.getTarget());
+		assertSame("method", t.getMethodName());
+		assertSame(oa, t.getArguments());
+		assertSame(arg, t.getArguments()[0]);
+
+		Pattern p = Pattern
+				.compile("Object[0-9]+=null\\.method\\(Object[0-9]+\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor(value, ...) with an array target.
+	 */
+	public void testConstructor_Value_ArrayTarget() throws Exception {
+		Object val = new Object();
+		Object arg = new Object();
+		Object[] oa = new Object[] { arg };
+		Expression t = new Expression(val, oa, "method", oa);
+		assertSame(val, t.getValue());
+		assertSame(oa, t.getTarget());
+		assertSame("method", t.getMethodName());
+		assertSame(oa, t.getArguments());
+		assertSame(arg, t.getArguments()[0]);
+
+		Pattern p = Pattern
+				.compile("Object[0-9]+=ObjectArray[0-9]+\\.method\\(Object[0-9]+\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor(value, ...) with null method name.
+	 */
+	public void testConstructor_Value_NullMethodName() throws Exception {
+		Object val = new Object();
+		Object target = new Object();
+		Object[] oa = new Object[] { new Object() };
+		Expression t = new Expression(val, target, null, oa);
+		assertSame(val, t.getValue());
+		assertSame(target, t.getTarget());
+		assertSame(null, t.getMethodName());
+		assertSame(oa, t.getArguments());
+
+		Pattern p = Pattern
+				.compile("Object[0-9]+=Object[0-9]+\\.null\\(Object[0-9]+\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor(value, ...) with the method name "new".
+	 */
+	public void testConstructor_Value_NewMethodName() throws Exception {
+		Object val = new Object();
+		Object target = new Object();
+		Object[] oa = new Object[] { new Object() };
+		Expression t = new Expression(val, target, "new", oa);
+		assertSame(val, t.getValue());
+		assertSame(target, t.getTarget());
+		assertSame("new", t.getMethodName());
+		assertSame(oa, t.getArguments());
+
+		Pattern p = Pattern
+				.compile("Object[0-9]+=Object[0-9]+\\.new\\(Object[0-9]+\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor(value, ...) with empty method name.
+	 */
+	public void testConstructor_Value_EmptyMethodName() throws Exception {
+		Object val = new Object();
+		Object target = new Object();
+		Object[] oa = new Object[] { new Object() };
+		Expression t = new Expression(val, target, "", oa);
+		assertSame(val, t.getValue());
+		assertSame(target, t.getTarget());
+		assertSame("", t.getMethodName());
+		assertSame(oa, t.getArguments());
+
+		Pattern p = Pattern
+				.compile("Object[0-9]+=Object[0-9]+\\.\\(Object[0-9]+\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor(value, ...) with null arguments.
+	 */
+	public void testConstructor_Value_NullArguments() throws Exception {
+		Object val = new Object();
+		Object target = new Object();
+		Expression t = new Expression(val, target, "method", null);
+		assertSame(val, t.getValue());
+		assertSame(target, t.getTarget());
+		assertSame("method", t.getMethodName());
+		assertEquals(0, t.getArguments().length);
+
+		Pattern p = Pattern
+				.compile("Object[0-9]+=Object[0-9]+\\.method\\(\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor(value, ...) with a null argument.
+	 */
+	public void testConstructor_Value_NullArgument() throws Exception {
+		Object val = new Object();
+		Object target = new Object();
+		Object[] oa = new Object[] { null };
+		Expression t = new Expression(val, target, "method", oa);
+		assertSame(val, t.getValue());
+		assertSame(target, t.getTarget());
+		assertSame("method", t.getMethodName());
+		assertSame(oa, t.getArguments());
+		assertNull(t.getArguments()[0]);
+
+		Pattern p = Pattern
+				.compile("Object[0-9]+=Object[0-9]+\\.method\\(null\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the constructor(value, ...) with a null value.
+	 */
+	public void testConstructor_Value_NullValue() throws Exception {
+		Object target = new Object();
+		Object[] oa = new Object[] { null };
+		Expression t = new Expression(null, target, "method", oa);
+		assertSame(null, t.getValue());
+		assertSame(target, t.getTarget());
+		assertSame("method", t.getMethodName());
+		assertSame(oa, t.getArguments());
+		assertNull(t.getArguments()[0]);
+
+		Pattern p = Pattern.compile("null=Object[0-9]+\\.method\\(null\\);");
+		Matcher m = p.matcher(t.toString());
+		assertTrue(m.matches());
+	}
+
+	/*
+	 * Test the setValue() method with a non-null value when the value of the
+	 * expression is still unbounded.
+	 */
+	public void testSetValue_UnboundNormal() throws Exception {
+		MockObject mo = new MockObject(false);
+		Expression t = new Expression(mo, "method", new Object[0]);
+		t.setValue(mo);
+		assertSame(mo, t.getValue());
+		MockObject.assertNotCalled();
+	}
+
+	/*
+	 * Test the setValue() method with a null value when the value of the
+	 * expression is still unbounded.
+	 */
+	public void testSetValue_UnboundNull() throws Exception {
+		MockObject mo = new MockObject(false);
+		Expression t = new Expression(mo, "method", new Object[0]);
+		t.setValue(null);
+		assertSame(null, t.getValue());
+		MockObject.assertNotCalled();
+	}
+
+	/*
+	 * Test the setValue() method when the value of the expression is set by the
+	 * constructor.
+	 */
+	public void testSetValue_Constructor() throws Exception {
+		MockObject mo = new MockObject(false);
+		Expression t = new Expression(mo, mo, "method", new Object[0]);
+		assertSame(mo, t.getValue());
+		MockObject.assertNotCalled();
+		t.setValue(null);
+		assertSame(null, t.getValue());
+		MockObject.assertNotCalled();
+	}
+
+	/*
+	 * Test the setValue() method when the value of the expression is set by a
+	 * previous call to setValue().
+	 */
+	public void testSetValue_Set() throws Exception {
+		MockObject mo = new MockObject(false);
+		Expression t = new Expression(mo, "method", new Object[0]);
+		t.setValue(mo);
+		assertSame(mo, t.getValue());
+		MockObject.assertNotCalled();
+		t.setValue(null);
+		assertSame(null, t.getValue());
+		MockObject.assertNotCalled();
+	}
+
+	/*
+	 * Test the setValue() method when the value of the expression is set by a
+	 * previous call to getValue().
+	 */
+	public void testSetValue_Evaluated() throws Exception {
+		MockObject mo = new MockObject(false);
+		Expression t = new Expression(mo, "method", new Object[0]);
+		assertEquals("method1", t.getValue());
+		MockObject.assertCalled("method1", new Object[0]);
+		t.setValue(mo);
+		assertSame(mo, t.getValue());
+		MockObject.assertNotCalled();
+	}
+
+	/*
+	 * Test the getValue() method when the value of the expression is evaluated
+	 * by a previous call to getValue().
+	 */
+	public void testGetValue_Evaluated() throws Exception {
+		MockObject mo = new MockObject(false);
+		Expression t = new Expression(mo, "method", new Object[0]);
+		assertEquals("method1", t.getValue());
+		MockObject.assertCalled("method1", new Object[0]);
+		assertEquals("method1", t.getValue());
+		MockObject.assertNotCalled();
+	}
+
+	/*
+	 * Test the getValue() method when the value of expression is set by the
+	 * constructor.
+	 */
+	public void testGetValue_Constructor() throws Exception {
+		MockObject mo = new MockObject(false);
+		Expression t = new Expression(mo, mo, "method", new Object[0]);
+		assertSame(mo, t.getValue());
+		MockObject.assertNotCalled();
+	}
+
+	/*
+	 * Test the getValue() method when the value of expression is set by a
+	 * previous call to setValue().
+	 */
+	public void testGetValue_Set() throws Exception {
+		MockObject mo = new MockObject(false);
+		Expression t = new Expression(mo, "method", new Object[0]);
+		t.setValue(mo);
+		assertSame(mo, t.getValue());
+		MockObject.assertNotCalled();
+	}
+
+	/*
+	 * Test the method getValue() with a normal object, a valid method name and
+	 * valid arguments.
+	 */
+	public void testGetValue_UnboundedNormalInstanceMethod() throws Exception {
+		MockObject mo = new MockObject(false);
+		Expression t = new Expression(mo, "method", new Object[0]);
+		assertEquals("method1", t.getValue());
+		MockObject.assertCalled("method1", new Object[0]);
+		t = new Expression(mo, "method", null);
+		assertEquals("method1", t.getValue());
+		MockObject.assertCalled("method1", new Object[0]);
+	}
+
+	/*
+	 * Test the method getValue() with a normal object, a valid method that
+	 * throws an exception and valid arguments.
+	 */
+	public void testGetValue_UnboundedExceptionalMethod() throws Exception {
+		MockObject mo = new MockObject(false);
+		Expression t = new Expression(mo, "method", new Object[] { null, null });
+		try {
+			t.getValue();
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException ex) {
+			// expected
+		}
+		MockObject.assertCalled("method4", new Object[] { null, null });
+	}
+
+	/*
+	 * Test the method getValue() with a normal object and a non-existing method
+	 * name.
+	 */
+	public void testGetValue_UnboundedNonExistingMethod() throws Exception {
+		MockObject mo = new MockObject(false);
+		Expression t = new Expression(mo, "method_not_existing", new Object[] {
+				null, null });
+		try {
+			t.getValue();
+			fail("Should throw NoSuchMethodException!");
+		} catch (NoSuchMethodException ex) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test the method getValue() with a null object.
+	 */
+	public void testGetValue_UnboundedNullTarget() throws Exception {
+		Expression t = new Expression(null, "method_not_existing",
+				new Object[] { null, null });
+		try {
+			t.getValue();
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException ex) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test the method getValue() with a null method name.
+	 */
+	public void testGetValue_UnboundedNullMethodName() throws Exception {
+		MockObject mo = new MockObject(false);
+		Expression t = new Expression(mo, null, new Object[] { null, null });
+		try {
+			t.getValue();
+			fail("Should throw NoSuchMethodException!");
+		} catch (NoSuchMethodException ex) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test the method getValue() with a normal object, a valid method and
+	 * invalid arguments (in terms of type, numbers, etc.).
+	 */
+	public void testGetValue_UnboundedInvalidArguments() throws Exception {
+		MockObject mo = new MockObject(false);
+		Expression t = new Expression(mo, "method", new Object[] {
+				new Object(), new Object(), new Object() });
+		try {
+			t.getValue();
+			fail("Should throw NoSuchMethodException!");
+		} catch (NoSuchMethodException ex) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test the method getValue() with a normal object, an overloaded method and
+	 * valid arguments. 
+	 */
+	public void testGetValue_UnboundedOverloadedMethods() throws Exception {
+		MockObject mo = new MockObject(false);
+		Object[] arguments = new Object[] { new Object() };
+		Expression t = new Expression(mo, "method", arguments);
+		assertEquals("method2", t.getValue());
+		MockObject.assertCalled("method2", arguments);
+
+		arguments = new Object[] { "test" };
+		t = new Expression(mo, "method", arguments);
+		assertEquals("method3", t.getValue());
+		MockObject.assertCalled("method3", arguments);
+	}
+
+	/*
+	 * Test the method getValue() with a normal object, an overloaded method and
+	 * null arguments. 
+	 * 
+	 * Note: decided by definition position.
+	 */
+	public void testGetValue_UnboundedOverloadedMethodsNull() throws Exception {
+		MockObject mo = new MockObject(false);
+		Object[] arguments = new Object[] { null };
+		Expression t = new Expression(mo, "method", arguments);
+		assertEquals("method1-2", t.getValue());
+		MockObject.assertCalled("method1-2", arguments);
+	}
+
+	/*
+	 * Test the method getValue() with a normal object, the method name "new"
+	 * and valid arguments.
+	 */
+	public void testGetValue_UnboundedNormalConstructor() throws Exception {
+		Expression t = new Expression(MockObject.class, "new", new Object[0]);
+		t.getValue();
+		MockObject.assertCalled("new0", new Object[0]);
+		t = new Expression(MockObject.class, "new", null);
+		assertTrue(t.getValue() instanceof MockObject);
+		MockObject.assertCalled("new0", new Object[0]);
+	}
+
+	/*
+	 * Test the method getValue() with a normal object, the method name "new"
+	 * that throws an exception and valid arguments.
+	 */
+	public void testGetValue_UnboundedExceptionalConstructor() throws Exception {
+		Expression t = new Expression(MockObject.class, "new", new Object[] {
+				null, null });
+		try {
+			t.getValue();
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException ex) {
+			// expected
+		}
+		MockObject.assertCalled("new4", new Object[] { null, null });
+	}
+
+	/*
+	 * Test the method getValue() with a normal object, the method name "new"
+	 * and invalid arguments (in terms of type, numbers, etc.).
+	 */
+	public void testGetValue_UnboundedNonExistingConstructor() throws Exception {
+		Expression t = new Expression(MockObject.class, "new", new Object[] {
+				null, null, null });
+		try {
+			t.getValue();
+			fail("Should throw NoSuchMethodException!");
+		} catch (NoSuchMethodException ex) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test the method getValue() with a normal object with overloaded
+	 * constructors, the method name "new" and valid arguments. See Java
+	 * Language Specification (15.11) for reference.
+	 * 
+	 * Note: decided by definition position.
+	 */
+	public void testGetValue_UnboundedOverloadedConstructors() throws Exception {
+		Object[] arguments = new Object[] { new Object() };
+		Expression t = new Expression(MockObject.class, "new", arguments);
+		t.getValue();
+		MockObject.assertCalled("new2", arguments);
+
+		arguments = new Object[] { "test" };
+		t = new Expression(MockObject.class, "new", arguments);
+		assertTrue(t.getValue() instanceof MockObject);
+		// MockObject.assertCalled("new2", arguments);
+
+		arguments = new Object[] { new Integer(1) };
+		t = new Expression(MockObject.class, "new", arguments);
+		assertTrue(t.getValue() instanceof MockObject);
+		MockObject.assertCalled("new1-2", arguments);
+	}
+
+	/*
+	 * Test the method getValue() with a normal object with overloaded
+	 * constructors, the method name "new" and null arguments. See Java Language
+	 * Specification (15.11) for reference.
+	 */
+	public void testGetValue_UnboundedOverloadedConstructorsNull()
+			throws Exception {
+		Object[] arguments = new Object[] { null };
+		Expression t = new Expression(MockObject.class, "new", arguments);
+		try {
+			t.getValue(); 
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException ex) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test the method getValue() with the Class object, a static method name
+	 * and valid arguments.
+	 */
+	public void testGetValue_UnboundedNormalStaticMethodViaClass()
+			throws Exception {
+		Object[] arguments = new Object[] { new Object() };
+		Expression t = new Expression(MockObject.class, "staticMethod",
+				arguments);
+		assertEquals("staticMethod", t.getValue());
+		MockObject.assertCalled("staticMethod", arguments);
+	}
+
+	/*
+	 * Test the method getValue() with an object, a static method name and valid
+	 * arguments.
+	 */
+	public void testGetValue_UnboundedNormalStaticMethodViaObject()
+			throws Exception {
+		MockObject mo = new MockObject(false);
+		Object[] arguments = new Object[] { new Object() };
+		Expression t = new Expression(mo, "staticMethod", arguments);
+		assertEquals("staticMethod", t.getValue());
+		MockObject.assertCalled("staticMethod", arguments);
+	}
+
+	/*
+	 * Test the method getValue() with a Class object of a normal class that has
+	 * a method of the same signature as Class.forName(String), a static method
+	 * name "forName" and valid argument "string".
+	 */
+	public void testGetValue_UnboundedAmbitiousStaticMethod() throws Exception {
+		Object[] arguments = new Object[] { "test" };
+		Expression t = new Expression(MockObject.class, "forName", arguments);
+		assertEquals(null, t.getValue());
+		MockObject.assertCalled("forName", arguments);
+
+		t = new Expression(String.class, "forName",
+				new Object[] { "java.lang.String" });
+		assertSame(String.class, t.getValue());
+	}
+
+	/*
+	 * Test the method getValue() with the special method Class.forName().
+	 */
+	public void testGetValue_UnboundedClassForName() throws Exception {
+		Object[] arguments = new String[] { this.getClass().getName() };
+		Expression t = new Expression(Class.class, "forName", arguments);
+		assertSame(this.getClass(), t.getValue());
+
+		// t = new Expression(String.class, "forName", arguments);
+		// assertSame(this.getClass(), t.getValue());
+	}
+
+	/*
+	 * Test the method getValue() with a normal array object, the method name
+	 * "get" and valid arguments.
+	 */
+	public void testGetValue_UnboundedArrayGet() throws Exception {
+		Object[] array = new Object[] { "test" };
+		Expression t = new Expression(array, "get", new Object[] { new Integer(
+				0) });
+		assertEquals("test", t.getValue());
+	}
+
+	/*
+	 * Test the method getValue() with a normal array object, the method name
+	 * "getInt" and invalid arguments.
+	 */
+	public void testGetValue_UnboundedArrayInvalidSetInt() throws Exception {
+		int[] array = new int[] { 1 };
+		Expression t = new Expression(array, "getInt",
+				new Object[] { new Integer(0) });
+		try {
+			t.getValue();
+			fail("Should throw NoSuchMethodException!");
+		} catch (NoSuchMethodException ex) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test the method getValue() with a normal array object, the method name
+	 * "gets".
+	 */
+	public void testGetValue_UnboundedArrayInvalidName() throws Exception {
+		Object[] array = new Object[] { "test" };
+		Expression t = new Expression(array, "gets", new Object[] {
+				new Integer(0), new Object() });
+		try {
+			t.getValue();
+			fail("Should throw NoSuchMethodException!");
+		} catch (NoSuchMethodException ex) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test the method getValue() with a normal object with overloaded methods
+	 * (primitive type VS wrapper class), a valid method name and valid
+	 * arguments.
+	 * 
+	 * Note: decided by definition position!
+	 */
+	public void testGetValue_UnboundedPrimitiveVSWrapper() throws Exception {
+		MockObject mo = new MockObject(false);
+		Object[] arguments = new Object[] { new Integer(1) };
+		Expression t = new Expression(mo, "methodB", arguments);
+		assertEquals("methodB1", t.getValue());
+		MockObject.assertCalled("methodB1", arguments);
+
+		arguments = new Object[] { Boolean.FALSE };
+		t = new Expression(mo, "methodB", arguments);
+		assertEquals("methodB3", t.getValue());
+		MockObject.assertCalled("methodB3", arguments);
+	}
+
+	/*
+	 * Test the method getValue() with a normal object with void method name and
+	 * valid arguments.
+	 */
+	public void testGetValue_UnboundedVoidMethod() throws Exception {
+		MockObject mo = new MockObject(false);
+		Object[] arguments = new Object[] { new Integer(1) };
+		Expression t = new Expression(mo, "voidMethod", arguments);
+		assertNull(t.getValue());
+		MockObject.assertCalled("voidMethod2", arguments);
+	}
+
+	/*
+	 * Test the method getValue() with a protected method but within java.beans
+	 * package.
+	 */
+	public void testGetValue_ProtectedMethodWithPackage() throws Exception {
+		DefaultPersistenceDelegate dpd = new DefaultPersistenceDelegate();
+		Object[] arguments = new Object[] { "test", "test" };
+		Expression t = new Expression(dpd, "mutatesTo", arguments);
+		try {
+			t.getValue();
+			fail("Should throw NoSuchMethodException!");
+		} catch (NoSuchMethodException e) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test the method getValue() with a method that is applicable via type
+	 * conversion.
+	 */
+	public void testGetValue_ApplicableViaTypeConversion() throws Exception {
+		MockObject mo = new MockObject(false);
+		// mo.methodB('c');
+		Object[] arguments = new Object[] { new Character((char) 1) };
+		Expression t = new Expression(mo, "methodB", arguments);
+		try {
+			t.getValue();
+			fail("Should throw NoSuchMethodException!");
+		} catch (NoSuchMethodException e) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test that setValue() is called in the constructor.
+	 */
+	public void testConstructor_Value_SetValueCalledIn() {
+		Object o = new Object();
+		MockExpression exp = new MockExpression(o);
+		exp.assertCalled(o);
+	}
+
+	/*
+	 * Test the method getValue() with two equal specific methods.
+	 * 
+	 * Note: decided by definition position! should be ambiguous.
+	 */
+	public void testGetValue_EqualSpecificMethods() throws Exception {
+		MockObject mo = new MockObject(false);
+		Object[] arguments = new Object[] { new MockObject(false),
+				new MockObject(false) };
+		Expression t = new Expression(mo, "equalSpecificMethod", arguments);
+		assertEquals("equalSpecificMethod1", t.getValue());
+		MockObject.assertCalled("equalSpecificMethod1", arguments);
+	}
+
+	/*
+	 * Test the method getValue() with two equal specific methods but one
+	 * declaring thrown exception.
+	 * 
+	 * Note: decided by definition position! should call the one with
+	 * exception.
+	 */
+	public void testGetValue_EqualSpecificMethodsException() throws Exception {
+		MockObject mo = new MockObject(false);
+		Object[] arguments = new Object[] { new MockObject(false),
+				new MockObject(false), new Object() };
+		Expression t = new Expression(mo, "equalSpecificMethod", arguments);
+		assertEquals("equalSpecificMethod3", t.getValue());
+		MockObject.assertCalled("equalSpecificMethod3", arguments);
+	}
+
+	/*
+	 * Super class of MockObject.
+	 */
+	public static class MockParent {
+
+		protected static String calledMethod = null;
+
+		protected static Vector receivedArguments = new Vector();
+
+		public Object method() {
+			reset();
+			calledMethod = "method1";
+			return calledMethod;
+		}
+
+		protected Object method(Boolean o) {
+			reset();
+			calledMethod = "method1-1";
+			receivedArguments.add(o);
+			return calledMethod;
+		}
+
+		public Object method(Integer o) {
+			reset();
+			calledMethod = "method1-2";
+			receivedArguments.add(o);
+			return calledMethod;
+		}
+
+		public Object method(Object o) {
+			reset();
+			calledMethod = "method2";
+			receivedArguments.add(o);
+			return calledMethod;
+		}
+
+		public Object method(String o) {
+			reset();
+			calledMethod = "method3";
+			receivedArguments.add(o);
+			return calledMethod;
+		}
+
+		public Object method(Object o, Object o2) {
+			reset();
+			calledMethod = "method4";
+			receivedArguments.add(o);
+			receivedArguments.add(o2);
+			throw new NullPointerException();
+		}
+
+		public static void reset() {
+			receivedArguments.clear();
+			calledMethod = null;
+		}
+	}
+
+	/*
+	 * Mock object.
+	 */
+	public static class MockObject extends MockParent {
+
+		public MockObject() {
+			reset();
+			calledMethod = "new0";
+		}
+
+		public MockObject(boolean testingConstructor) {
+			reset();
+			if (testingConstructor) {
+				calledMethod = "new1";
+			}
+		}
+
+		public MockObject(Integer o) {
+			reset();
+			calledMethod = "new1-2";
+			receivedArguments.add(o);
+		}
+
+		public MockObject(Object o) {
+			reset();
+			calledMethod = "new2";
+			receivedArguments.add(o);
+		}
+
+		public MockObject(String o) {
+			reset();
+			calledMethod = "new3";
+			receivedArguments.add(o);
+		}
+
+		public MockObject(Object o, Object o2) {
+			reset();
+			calledMethod = "new4";
+			receivedArguments.add(o);
+			receivedArguments.add(o2);
+			throw new NullPointerException();
+		}
+
+		public Object methodB(Integer i) {
+			reset();
+			calledMethod = "methodB1";
+			receivedArguments.add(i);
+			return calledMethod;
+		}
+
+		public Object methodB(int i) {
+			reset();
+			calledMethod = "methodB2";
+			receivedArguments.add(new Integer(i));
+			return calledMethod;
+		}
+
+		public Object methodB(boolean b) {
+			reset();
+			calledMethod = "methodB3";
+			receivedArguments.add(new Boolean(b));
+			return calledMethod;
+		}
+
+		// public Object methodB(Boolean b) {
+		// reset();
+		// calledMethod = "methodB4";
+		// receivedArguments.add(b);
+		// return calledMethod;
+		// }
+
+		public Object voidMethod(Object o) {
+			reset();
+			calledMethod = "voidMethod";
+			receivedArguments.add(o);
+			return "voidMethod";
+		}
+
+		public void voidMethod(Integer o) {
+			reset();
+			calledMethod = "voidMethod2";
+			receivedArguments.add(o);
+		}
+
+		public static Object staticMethod(Object o) {
+			reset();
+			calledMethod = "staticMethod";
+			receivedArguments.add(o);
+			return calledMethod;
+		}
+
+		public Object equalSpecificMethod(MockObject o, MockParent p) {
+			reset();
+			calledMethod = "equalSpecificMethod1";
+			receivedArguments.add(o);
+			receivedArguments.add(p);
+			return calledMethod;
+		}
+
+		public Object equalSpecificMethod(MockParent p, MockObject o) {
+			reset();
+			calledMethod = "equalSpecificMethod2";
+			receivedArguments.add(p);
+			receivedArguments.add(o);
+			return calledMethod;
+		}
+
+		public Object equalSpecificMethod(MockObject o, MockParent p, Object o2) {
+			reset();
+			calledMethod = "equalSpecificMethod3";
+			receivedArguments.add(o);
+			receivedArguments.add(p);
+			receivedArguments.add(o2);
+			return calledMethod;
+		}
+
+		public Object equalSpecificMethod(MockParent p, MockObject o, Object o2)
+				throws Exception {
+			reset();
+			calledMethod = "equalSpecificMethod4";
+			receivedArguments.add(p);
+			receivedArguments.add(o);
+			receivedArguments.add(o2);
+			return calledMethod;
+		}
+
+		public static Class forName(String o) {
+			reset();
+			calledMethod = "forName";
+			receivedArguments.add(o);
+			return null;
+		}
+
+		public static void assertCalled(String methodName, Object[] arguments) {
+			assertEquals(methodName, calledMethod);
+			assertTrue(Arrays.equals(arguments, receivedArguments.toArray()));
+			reset();
+		}
+
+		public static void assertNotCalled() {
+			assertEquals(null, calledMethod);
+			assertTrue(receivedArguments.isEmpty());
+		}
+	}
+
+	/*
+	 * Mock expression to test that setValue() is called in the constructor.
+	 */
+	public static class MockExpression extends Expression {
+
+		private Object acceptedValue;
+
+		public MockExpression(Object o) {
+			super(o, null, null, null);
+		}
+
+		public void setValue(Object o) {
+			acceptedValue = o;
+		}
+
+		public void assertCalled(Object o) {
+			assertSame(o, acceptedValue);
+		}
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/FeatureDescriptorTest.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/FeatureDescriptorTest.java?rev=394923&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/FeatureDescriptorTest.java
(added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/FeatureDescriptorTest.java
Tue Apr 18 05:11:09 2006
@@ -0,0 +1,279 @@
+/* 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.FeatureDescriptor;
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+import junit.framework.TestCase;
+
+/**
+ * Unit test for FeatureDescriptor.
+ */
+public class FeatureDescriptorTest extends TestCase {
+
+	private FeatureDescriptor fd;
+
+	protected void setUp() throws Exception {
+		super.setUp();
+		fd = new FeatureDescriptor();
+	}
+
+	public void testFeatureDescriptor() {
+		assertNull(fd.getDisplayName());
+		assertNull(fd.getName());
+		assertNull(fd.getShortDescription());
+
+		assertNotNull(fd.attributeNames());
+
+		assertFalse(fd.isExpert());
+		assertFalse(fd.isHidden());
+		assertFalse(fd.isPreferred());
+	}
+
+	public void testSetDisplayName() {
+		String displayName = "FeatureDescriptor.displayName";
+		fd.setDisplayName(displayName);
+		assertSame(displayName, fd.getDisplayName());
+		assertNull(fd.getName());
+		assertSame(displayName, fd.getShortDescription());
+
+		assertNotNull(fd.attributeNames());
+
+		assertFalse(fd.isExpert());
+		assertFalse(fd.isHidden());
+		assertFalse(fd.isPreferred());
+	}
+
+	public void testSetDisplayName_DisplayNameNull() {
+		String displayName = null;
+		fd.setDisplayName(displayName);
+		assertNull(fd.getDisplayName());
+		assertNull(fd.getName());
+		assertNull(fd.getShortDescription());
+
+		assertNotNull(fd.attributeNames());
+
+		assertFalse(fd.isExpert());
+		assertFalse(fd.isHidden());
+		assertFalse(fd.isPreferred());
+	}
+
+	public void testSetExpert_False() {
+		fd.setExpert(false);
+		assertFalse(fd.isExpert());
+
+		assertNull(fd.getDisplayName());
+		assertNull(fd.getName());
+		assertNull(fd.getShortDescription());
+
+		assertNotNull(fd.attributeNames());
+
+		assertFalse(fd.isHidden());
+		assertFalse(fd.isPreferred());
+	}
+
+	public void testSetExpert_True() {
+		fd.setExpert(true);
+		assertTrue(fd.isExpert());
+
+		assertNull(fd.getDisplayName());
+		assertNull(fd.getName());
+		assertNull(fd.getShortDescription());
+
+		assertNotNull(fd.attributeNames());
+
+		assertFalse(fd.isHidden());
+		assertFalse(fd.isPreferred());
+	}
+
+	public void testSetHidden_False() {
+		fd.setHidden(false);
+		assertFalse(fd.isHidden());
+
+		assertNull(fd.getDisplayName());
+		assertNull(fd.getName());
+		assertNull(fd.getShortDescription());
+
+		assertNotNull(fd.attributeNames());
+
+		assertFalse(fd.isExpert());
+		assertFalse(fd.isPreferred());
+	}
+
+	public void testSetHidden_True() {
+		fd.setHidden(true);
+		assertTrue(fd.isHidden());
+
+		assertNull(fd.getDisplayName());
+		assertNull(fd.getName());
+		assertNull(fd.getShortDescription());
+
+		assertNotNull(fd.attributeNames());
+
+		assertFalse(fd.isExpert());
+		assertFalse(fd.isPreferred());
+	}
+
+	public void testSetName() {
+		String name = "FeatureDescriptor.name";
+		fd.setName(name);
+		assertSame(name, fd.getName());
+
+		assertSame(name, fd.getDisplayName());
+		assertSame(name, fd.getShortDescription());
+
+		assertNotNull(fd.attributeNames());
+
+		assertFalse(fd.isExpert());
+		assertFalse(fd.isHidden());
+		assertFalse(fd.isPreferred());
+	}
+
+	public void testSetName_null() {
+		fd.setName("FeatureDescriptor.name");
+		fd.setName(null);
+		assertNull(fd.getName());
+
+		assertNull(fd.getDisplayName());
+		assertNull(fd.getShortDescription());
+
+		assertNotNull(fd.attributeNames());
+
+		assertFalse(fd.isExpert());
+		assertFalse(fd.isHidden());
+		assertFalse(fd.isPreferred());
+	}
+
+	public void testSetPreferred_False() {
+		fd.setPreferred(false);
+		assertFalse(fd.isPreferred());
+
+		assertNull(fd.getDisplayName());
+		assertNull(fd.getName());
+		assertNull(fd.getShortDescription());
+
+		assertNotNull(fd.attributeNames());
+
+		assertFalse(fd.isExpert());
+		assertFalse(fd.isHidden());
+	}
+
+	public void testSetPreferred_True() {
+		fd.setPreferred(true);
+		assertTrue(fd.isPreferred());
+
+		assertNull(fd.getDisplayName());
+		assertNull(fd.getName());
+		assertNull(fd.getShortDescription());
+
+		assertNotNull(fd.attributeNames());
+
+		assertFalse(fd.isExpert());
+		assertFalse(fd.isHidden());
+	}
+
+	public void testSetShortDescription() {
+		String shortDesc = "FeatureDescriptor.ShortDescription";
+		fd.setShortDescription(shortDesc);
+		assertSame(shortDesc, fd.getShortDescription());
+
+		assertNull(fd.getDisplayName());
+		assertNull(fd.getName());
+
+		assertNotNull(fd.attributeNames());
+
+		assertFalse(fd.isExpert());
+		assertFalse(fd.isHidden());
+		assertFalse(fd.isPreferred());
+	}
+
+	public void testSetShortDescription_ShortDescNull() {
+		String shortDesc = "FeatureDescriptor.ShortDescription";
+		fd.setShortDescription(shortDesc);
+		assertSame(shortDesc, fd.getShortDescription());
+		fd.setShortDescription(null);
+		assertNull(fd.getShortDescription());
+
+		assertNull(fd.getDisplayName());
+		assertNull(fd.getName());
+
+		assertNotNull(fd.attributeNames());
+
+		assertFalse(fd.isExpert());
+		assertFalse(fd.isHidden());
+		assertFalse(fd.isPreferred());
+	}
+
+	public void testSetValue() {
+		String[] attributeNames = { "Blue", "Yellow", "Red", };
+		Object[] values = { "Blue.value", "Yellow.value", "Red.value", };
+		for (int i = 0; i < attributeNames.length; i++) {
+			fd.setValue(attributeNames[i], values[i]);
+		}
+
+		for (int i = 0; i < attributeNames.length; i++) {
+			assertSame(values[i], fd.getValue(attributeNames[i]));
+		}
+	}
+
+	public void testSetValue_ExistAttribute() {
+		String attributeName = "blue";
+		Object value = "Anyone";
+		fd.setValue(attributeName, value);
+		assertSame(value, fd.getValue(attributeName));
+
+		Object newValue = "Another";
+		fd.setValue(attributeName, newValue);
+		assertSame(newValue, fd.getValue(attributeName));
+	}
+
+	public void testSetValue_ValueNull() {
+		String attributeName = "blue";
+		Object value = "Anyone";
+		fd.setValue(attributeName, value);
+		assertSame(value, fd.getValue(attributeName));
+
+		Object newValue = null;
+		try {
+			fd.setValue(attributeName, newValue);
+			fail("Should throw NullPointerException.");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	public void testattributeNames() {
+		assertFalse(fd.attributeNames().hasMoreElements());
+
+		String[] attributeNames = { "Blue", "Yellow", "Red", };
+		Object[] values = { "Blue.value", "Yellow.value", "Red.value", };
+		for (int i = 0; i < attributeNames.length; i++) {
+			fd.setValue(attributeNames[i], values[i]);
+		}
+		Enumeration names = fd.attributeNames();
+		Hashtable table = new Hashtable();
+		while (names.hasMoreElements()) {
+			String name = (String) names.nextElement();
+			table.put(name, fd.getValue(name));
+		}
+
+		assertEquals(attributeNames.length, table.size());
+		for (int i = 0; i < attributeNames.length; i++) {
+			assertTrue(table.containsKey(attributeNames[i]));
+		}
+	}
+}

Added: incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/FozzzEditor.java
URL: http://svn.apache.org/viewcvs/incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/FozzzEditor.java?rev=394923&view=auto
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/FozzzEditor.java
(added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/beans/src/test/java/tests/api/java/beans/FozzzEditor.java
Tue Apr 18 05:11:09 2006
@@ -0,0 +1,127 @@
+/* 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.awt.Component;
+import java.awt.Graphics;
+import java.awt.Rectangle;
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyEditor;
+
+/**
+ * Test PropertyEditorManager
+ */
+public class FozzzEditor implements PropertyEditor {
+
+    /* (non-Javadoc)
+     * @see java.beans.PropertyEditor#addPropertyChangeListener(java.beans.PropertyChangeListener)
+     */
+    public void addPropertyChangeListener(PropertyChangeListener listener) {
+        // TO DO Auto-generated method stub
+
+    }
+
+    /* (non-Javadoc)
+     * @see java.beans.PropertyEditor#getAsText()
+     */
+    public String getAsText() {
+        // TO DO Auto-generated method stub
+        return null;
+    }
+
+    /* (non-Javadoc)
+     * @see java.beans.PropertyEditor#getCustomEditor()
+     */
+    public Component getCustomEditor() {
+        // TO DO Auto-generated method stub
+        return null;
+    }
+
+    /* (non-Javadoc)
+     * @see java.beans.PropertyEditor#getJavaInitializationString()
+     */
+    public String getJavaInitializationString() {
+        // TO DO Auto-generated method stub
+        return null;
+    }
+
+    /* (non-Javadoc)
+     * @see java.beans.PropertyEditor#getTags()
+     */
+    public String[] getTags() {
+        // TO DO Auto-generated method stub
+        return null;
+    }
+
+    /* (non-Javadoc)
+     * @see java.beans.PropertyEditor#getValue()
+     */
+    public Object getValue() {
+        // TO DO Auto-generated method stub
+        return null;
+    }
+
+    /* (non-Javadoc)
+     * @see java.beans.PropertyEditor#isPaintable()
+     */
+    public boolean isPaintable() {
+        // TO DO Auto-generated method stub
+        return false;
+    }
+
+    /* (non-Javadoc)
+     * @see java.beans.PropertyEditor#paintValue(java.awt.Graphics, java.awt.Rectangle)
+     */
+    public void paintValue(Graphics graphics, Rectangle box) {
+        // TO DO Auto-generated method stub
+
+    }
+
+    /* (non-Javadoc)
+     * @see java.beans.PropertyEditor#removePropertyChangeListener(java.beans.PropertyChangeListener)
+     */
+    public void removePropertyChangeListener(PropertyChangeListener listener) {
+        // TO DO Auto-generated method stub
+
+    }
+
+    /* (non-Javadoc)
+     * @see java.beans.PropertyEditor#setAsText(java.lang.String)
+     */
+    public void setAsText(String text) throws IllegalArgumentException {
+        // TO DO Auto-generated method stub
+
+    }
+
+    /* (non-Javadoc)
+     * @see java.beans.PropertyEditor#setValue(java.lang.Object)
+     */
+    public void setValue(Object value) {
+        // TO DO Auto-generated method stub
+
+    }
+
+    /* (non-Javadoc)
+     * @see java.beans.PropertyEditor#supportsCustomEditor()
+     */
+    public boolean supportsCustomEditor() {
+        // TO DO Auto-generated method stub
+        return false;
+    }
+
+}
+
+ 



Mime
View raw message