common/tests/org.eclipse.jpt.common.utility.tests/src/org/eclipse/jpt/common/utility/tests/internal/model/value/PropertyAspectAdapterTests.java - dali/webtools.dali - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007, 2009 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
  *
  * Contributors:
  *     Oracle - initial API and implementation
  ******************************************************************************/
 package org.eclipse.jpt.common.utility.tests.internal.model.value;

 import junit.framework.TestCase;

 import org.eclipse.jpt.common.utility.internal.model.AbstractModel;
 import org.eclipse.jpt.common.utility.internal.model.value.PropertyAspectAdapter;
 import org.eclipse.jpt.common.utility.internal.model.value.SimplePropertyValueModel;
 import org.eclipse.jpt.common.utility.model.event.PropertyChangeEvent;
 import org.eclipse.jpt.common.utility.model.listener.ChangeAdapter;
 import org.eclipse.jpt.common.utility.model.listener.ChangeListener;
 import org.eclipse.jpt.common.utility.model.listener.PropertyChangeListener;
 import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
 import org.eclipse.jpt.common.utility.model.value.WritablePropertyValueModel;
 import org.eclipse.jpt.common.utility.tests.internal.TestTools;

 @SuppressWarnings("nls")
 public class PropertyAspectAdapterTests extends TestCase {
 	private TestSubject subject1;
 	private WritablePropertyValueModel<TestSubject> subjectHolder1;
 	private PropertyAspectAdapter<TestSubject, String> aa1;
 	private PropertyChangeEvent event1;
 	private PropertyChangeListener listener1;

 	private TestSubject subject2;

 	private PropertyChangeEvent multipleValueEvent;

 	private PropertyChangeEvent customValueEvent;


 	public PropertyAspectAdapterTests(String name) {
 		super(name);
 	}

 	@Override
 	protected void setUp() throws Exception {
 		super.setUp();
 		this.subject1 = new TestSubject("foo", "test subject 1");
 		this.subjectHolder1 = new SimplePropertyValueModel<TestSubject> (this.subject1);
 		this.aa1 = this.buildAspectAdapter(this.subjectHolder1);
 		this.listener1 = this.buildValueChangeListener1();
 		this.aa1.addPropertyChangeListener(PropertyValueModel.VALUE, this.listener1);
 		this.event1 = null;

 		this.subject2 = new TestSubject("bar", "test subject 2");
 	}

 	private PropertyAspectAdapter<TestSubject, String> buildAspectAdapter(PropertyValueModel<TestSubject> subjectHolder) {
 		return new PropertyAspectAdapter<TestSubject, String>(subjectHolder, TestSubject.NAME_PROPERTY) {
 			// this is not a aspect adapter - the value is determined by the aspect name
 			@Override
 			protected String buildValue_() {
 				if (this.propertyNames[0] == TestSubject.NAME_PROPERTY) {
 					return this.subject.getName();
 				} else if (this.propertyNames[0] == TestSubject.DESCRIPTION_PROPERTY) {
 					return this.subject.getDescription();
 				} else {
 					throw new IllegalStateException("invalid aspect name: " + this.propertyNames[0]);
 				}
 			}
 			@Override
 			protected void setValue_(String value) {
 				if (this.propertyNames[0] == TestSubject.NAME_PROPERTY) {
 					this.subject.setName(value);
 				} else if (this.propertyNames[0] == TestSubject.DESCRIPTION_PROPERTY) {
 					this.subject.setDescription(value);
 				} else {
 					throw new IllegalStateException("invalid aspect name: " + this.propertyNames[0]);
 				}
 			}
 		};
 	}

 	private ChangeListener buildValueChangeListener1() {
 		return new ChangeAdapter() {
 			@Override
 			public void propertyChanged(PropertyChangeEvent e) {
 				PropertyAspectAdapterTests.this.value1Changed(e);
 			}
 		};
 	}

 	void value1Changed(PropertyChangeEvent e) {
 		this.event1 = e;
 	}

 	@Override
 	protected void tearDown() throws Exception {
 		TestTools.clear(this);
 		super.tearDown();
 	}

 	public void testSubjectHolder() {
 		assertEquals("foo", this.aa1.getValue());
 		assertNull(this.event1);

 		this.subjectHolder1.setValue(this.subject2);
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
 		assertEquals(PropertyValueModel.VALUE, this.event1.getPropertyName());
 		assertEquals("foo", this.event1.getOldValue());
 		assertEquals("bar", this.event1.getNewValue());
 		assertEquals("bar", this.aa1.getValue());

 		this.event1 = null;
 		this.subjectHolder1.setValue(null);
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
 		assertEquals(PropertyValueModel.VALUE, this.event1.getPropertyName());
 		assertEquals("bar", this.event1.getOldValue());
 		assertNull(this.event1.getNewValue());
 		assertNull(this.aa1.getValue());

 		this.event1 = null;
 		this.subjectHolder1.setValue(this.subject1);
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
 		assertEquals(PropertyValueModel.VALUE, this.event1.getPropertyName());
 		assertEquals(null, this.event1.getOldValue());
 		assertEquals("foo", this.event1.getNewValue());
 		assertEquals("foo", this.aa1.getValue());
 	}

 	public void testPropertyChange() {
 		assertEquals("foo", this.aa1.getValue());
 		assertNull(this.event1);

 		this.subject1.setName("baz");
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
 		assertEquals(PropertyValueModel.VALUE, this.event1.getPropertyName());
 		assertEquals("foo", this.event1.getOldValue());
 		assertEquals("baz", this.event1.getNewValue());
 		assertEquals("baz", this.aa1.getValue());

 		this.event1 = null;
 		this.subject1.setName(null);
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
 		assertEquals(PropertyValueModel.VALUE, this.event1.getPropertyName());
 		assertEquals("baz", this.event1.getOldValue());
 		assertEquals(null, this.event1.getNewValue());
 		assertEquals(null, this.aa1.getValue());

 		this.event1 = null;
 		this.subject1.setName("foo");
 		assertNotNull(this.event1);
 		assertEquals(this.aa1, this.event1.getSource());
 		assertEquals(PropertyValueModel.VALUE, this.event1.getPropertyName());
 		assertEquals(null, this.event1.getOldValue());
 		assertEquals("foo", this.event1.getNewValue());
 		assertEquals("foo", this.aa1.getValue());
 	}

 	public void testValue() {
 		assertEquals("foo", this.subject1.getName());
 		assertEquals("foo", this.aa1.getValue());
 	}

 	public void testStaleValue() {
 		assertEquals("foo", this.subject1.getName());
 		assertEquals("foo", this.aa1.getValue());

 		this.aa1.removePropertyChangeListener(PropertyValueModel.VALUE, this.listener1);
 		assertEquals(null, this.aa1.getValue());

 		this.aa1.addPropertyChangeListener(PropertyValueModel.VALUE, this.listener1);
 		assertEquals("foo", this.aa1.getValue());

 		this.aa1.removePropertyChangeListener(PropertyValueModel.VALUE, this.listener1);
 		this.subjectHolder1.setValue(this.subject2);
 		assertEquals(null, this.aa1.getValue());

 		this.aa1.addPropertyChangeListener(PropertyValueModel.VALUE, this.listener1);
 		assertEquals("bar", this.aa1.getValue());
 	}

 	public void testSetValue() {
 		this.aa1.setValue("baz");
 		assertEquals("baz", this.aa1.getValue());
 		assertEquals("baz", this.subject1.getName());
 	}

 	public void testHasListeners() {
 		assertTrue(this.aa1.hasAnyPropertyChangeListeners(PropertyValueModel.VALUE));
 		assertTrue(this.subject1.hasAnyPropertyChangeListeners(TestSubject.NAME_PROPERTY));
 		this.aa1.removePropertyChangeListener(PropertyValueModel.VALUE, this.listener1);
 		assertFalse(this.subject1.hasAnyPropertyChangeListeners(TestSubject.NAME_PROPERTY));
 		assertFalse(this.aa1.hasAnyPropertyChangeListeners(PropertyValueModel.VALUE));

 		ChangeListener listener2 = this.buildValueChangeListener1();
 		this.aa1.addChangeListener(listener2);
 		assertTrue(this.aa1.hasAnyPropertyChangeListeners(PropertyValueModel.VALUE));
 		assertTrue(this.subject1.hasAnyPropertyChangeListeners(TestSubject.NAME_PROPERTY));
 		this.aa1.removeChangeListener(listener2);
 		assertFalse(this.subject1.hasAnyPropertyChangeListeners(TestSubject.NAME_PROPERTY));
 		assertFalse(this.aa1.hasAnyPropertyChangeListeners(PropertyValueModel.VALUE));
 	}

 	public void testMultipleAspectAdapter() {
 		TestSubject testSubject = new TestSubject("fred", "husband");
 		WritablePropertyValueModel<TestSubject> testSubjectHolder = new SimplePropertyValueModel<TestSubject>(testSubject);
 		WritablePropertyValueModel<String> testAA = this.buildMultipleAspectAdapter(testSubjectHolder);
 		PropertyChangeListener testListener = this.buildMultipleValueChangeListener();
 		testAA.addPropertyChangeListener(PropertyValueModel.VALUE, testListener);
 		assertEquals("fred:husband", testAA.getValue());

 		this.multipleValueEvent = null;
 		testSubject.setName("wilma");
 		assertEquals("wilma:husband", testAA.getValue());
 		assertEquals("fred:husband", this.multipleValueEvent.getOldValue());
 		assertEquals("wilma:husband", this.multipleValueEvent.getNewValue());

 		this.multipleValueEvent = null;
 		testSubject.setDescription("wife");
 		assertEquals("wilma:wife", testAA.getValue());
 		assertEquals("wilma:husband", this.multipleValueEvent.getOldValue());
 		assertEquals("wilma:wife", this.multipleValueEvent.getNewValue());
 	}

 	private WritablePropertyValueModel<String> buildMultipleAspectAdapter(PropertyValueModel<TestSubject> subjectHolder) {
 		return new PropertyAspectAdapter<TestSubject, String>(subjectHolder, TestSubject.NAME_PROPERTY, TestSubject.DESCRIPTION_PROPERTY) {
 			@Override
 			protected String buildValue_() {
 				return this.subject.getName() + ":" + this.subject.getDescription();
 			}
 		};
 	}

 	private PropertyChangeListener buildMultipleValueChangeListener() {
 		return new PropertyChangeListener() {
 			public void propertyChanged(PropertyChangeEvent e) {
 				PropertyAspectAdapterTests.this.multipleValueChanged(e);
 			}
 		};
 	}

 	void multipleValueChanged(PropertyChangeEvent e) {
 		this.multipleValueEvent = e;
 	}

 	/**
 	 * test a bug where we would call #buildValue() in
 	 * #engageNonNullSubject(), when we needed to call
 	 * it in #engageSubject(), so the cached value would
 	 * be rebuilt when the this.subject was set to null
 	 */
 	public void testCustomBuildValueWithNullSubject() {
 		TestSubject customSubject = new TestSubject("fred", "laborer");
 		WritablePropertyValueModel<TestSubject> customSubjectHolder = new SimplePropertyValueModel<TestSubject>(customSubject);
 		WritablePropertyValueModel<String> customAA = this.buildCustomAspectAdapter(customSubjectHolder);
 		PropertyChangeListener customListener = this.buildCustomValueChangeListener();
 		customAA.addPropertyChangeListener(PropertyValueModel.VALUE, customListener);
 		assertEquals("fred", customAA.getValue());

 		this.customValueEvent = null;
 		customSubject.setName("wilma");
 		assertEquals("wilma", customAA.getValue());
 		assertEquals("fred", this.customValueEvent.getOldValue());
 		assertEquals("wilma", this.customValueEvent.getNewValue());

 		this.customValueEvent = null;
 		customSubjectHolder.setValue(null);
 		// this would fail - the value would be null...
 		assertEquals("<unnamed>", customAA.getValue());
 		assertEquals("wilma", this.customValueEvent.getOldValue());
 		assertEquals("<unnamed>", this.customValueEvent.getNewValue());
 	}

 	/**
 	 * Test a bug:
 	 * If two listeners were added to an aspect adapter, one with an
 	 * aspect name and one without, the aspect adapter would add its
 	 * 'subjectChangeListener' to its 'subjectHolder' twice. As a result,
 	 * the following code will trigger an IllegalArgumentException
 	 * if the bug is present; otherwise, it completes silently.
 	 */
 	public void testDuplicateListener() {
 		ChangeListener listener2 = new ChangeAdapter();
 		this.aa1.addChangeListener(listener2);
 	}

 	private WritablePropertyValueModel<String> buildCustomAspectAdapter(PropertyValueModel<TestSubject> subjectHolder) {
 		return new PropertyAspectAdapter<TestSubject, String>(subjectHolder, TestSubject.NAME_PROPERTY) {
 			@Override
 			protected String buildValue() {
 				return (this.subject == null) ? "<unnamed>" : this.subject.getName();
 			}
 		};
 	}

 	private PropertyChangeListener buildCustomValueChangeListener() {
 		return new PropertyChangeListener() {
 			public void propertyChanged(PropertyChangeEvent e) {
 				PropertyAspectAdapterTests.this.customValueChanged(e);
 			}
 		};
 	}

 	void customValueChanged(PropertyChangeEvent e) {
 		this.customValueEvent = e;
 	}


 	// ********** test model **********

 	private static class TestSubject extends AbstractModel {
 		private String name;
 		public static final String NAME_PROPERTY = "name";
 		private String description;
 		public static final String DESCRIPTION_PROPERTY = "description";

 		public TestSubject(String name, String description) {
 			this.name = name;
 			this.description = description;
 		}
 		public String getName() {
 			return this.name;
 		}
 		public void setName(String name) {
 			Object old = this.name;
 			this.name = name;
 			this.firePropertyChanged(NAME_PROPERTY, old, name);
 		}
 		public String getDescription() {
 			return this.description;
 		}
 		public void setDescription(String description) {
 			Object old = this.description;
 			this.description = description;
 			this.firePropertyChanged(DESCRIPTION_PROPERTY, old, description);
 		}
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2007, 2009 Oracle. All rights reserved.
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v1.0, which accompanies this distribution
	* and is available at http://www.eclipse.org/legal/epl-v10.html.
	*
	* Contributors:
	* Oracle - initial API and implementation
	******************************************************************************/
	package org.eclipse.jpt.common.utility.tests.internal.model.value;

	import junit.framework.TestCase;

	import org.eclipse.jpt.common.utility.internal.model.AbstractModel;
	import org.eclipse.jpt.common.utility.internal.model.value.PropertyAspectAdapter;
	import org.eclipse.jpt.common.utility.internal.model.value.SimplePropertyValueModel;
	import org.eclipse.jpt.common.utility.model.event.PropertyChangeEvent;
	import org.eclipse.jpt.common.utility.model.listener.ChangeAdapter;
	import org.eclipse.jpt.common.utility.model.listener.ChangeListener;
	import org.eclipse.jpt.common.utility.model.listener.PropertyChangeListener;
	import org.eclipse.jpt.common.utility.model.value.PropertyValueModel;
	import org.eclipse.jpt.common.utility.model.value.WritablePropertyValueModel;
	import org.eclipse.jpt.common.utility.tests.internal.TestTools;

	@SuppressWarnings("nls")
	public class PropertyAspectAdapterTests extends TestCase {
	private TestSubject subject1;
	private WritablePropertyValueModel<TestSubject> subjectHolder1;
	private PropertyAspectAdapter<TestSubject, String> aa1;
	private PropertyChangeEvent event1;
	private PropertyChangeListener listener1;

	private TestSubject subject2;

	private PropertyChangeEvent multipleValueEvent;

	private PropertyChangeEvent customValueEvent;


	public PropertyAspectAdapterTests(String name) {
	super(name);
	}

	@Override
	protected void setUp() throws Exception {
	super.setUp();
	this.subject1 = new TestSubject("foo", "test subject 1");
	this.subjectHolder1 = new SimplePropertyValueModel<TestSubject> (this.subject1);
	this.aa1 = this.buildAspectAdapter(this.subjectHolder1);
	this.listener1 = this.buildValueChangeListener1();
	this.aa1.addPropertyChangeListener(PropertyValueModel.VALUE, this.listener1);
	this.event1 = null;

	this.subject2 = new TestSubject("bar", "test subject 2");
	}

	private PropertyAspectAdapter<TestSubject, String> buildAspectAdapter(PropertyValueModel<TestSubject> subjectHolder) {
	return new PropertyAspectAdapter<TestSubject, String>(subjectHolder, TestSubject.NAME_PROPERTY) {
	// this is not a aspect adapter - the value is determined by the aspect name
	@Override
	protected String buildValue_() {
	if (this.propertyNames[0] == TestSubject.NAME_PROPERTY) {
	return this.subject.getName();
	} else if (this.propertyNames[0] == TestSubject.DESCRIPTION_PROPERTY) {
	return this.subject.getDescription();
	} else {
	throw new IllegalStateException("invalid aspect name: " + this.propertyNames[0]);
	}
	}
	@Override
	protected void setValue_(String value) {
	if (this.propertyNames[0] == TestSubject.NAME_PROPERTY) {
	this.subject.setName(value);
	} else if (this.propertyNames[0] == TestSubject.DESCRIPTION_PROPERTY) {
	this.subject.setDescription(value);
	} else {
	throw new IllegalStateException("invalid aspect name: " + this.propertyNames[0]);
	}
	}
	};
	}

	private ChangeListener buildValueChangeListener1() {
	return new ChangeAdapter() {
	@Override
	public void propertyChanged(PropertyChangeEvent e) {
	PropertyAspectAdapterTests.this.value1Changed(e);
	}
	};
	}

	void value1Changed(PropertyChangeEvent e) {
	this.event1 = e;
	}

	@Override
	protected void tearDown() throws Exception {
	TestTools.clear(this);
	super.tearDown();
	}

	public void testSubjectHolder() {
	assertEquals("foo", this.aa1.getValue());
	assertNull(this.event1);

	this.subjectHolder1.setValue(this.subject2);
	assertNotNull(this.event1);
	assertEquals(this.aa1, this.event1.getSource());
	assertEquals(PropertyValueModel.VALUE, this.event1.getPropertyName());
	assertEquals("foo", this.event1.getOldValue());
	assertEquals("bar", this.event1.getNewValue());
	assertEquals("bar", this.aa1.getValue());

	this.event1 = null;
	this.subjectHolder1.setValue(null);
	assertNotNull(this.event1);
	assertEquals(this.aa1, this.event1.getSource());
	assertEquals(PropertyValueModel.VALUE, this.event1.getPropertyName());
	assertEquals("bar", this.event1.getOldValue());
	assertNull(this.event1.getNewValue());
	assertNull(this.aa1.getValue());

	this.event1 = null;
	this.subjectHolder1.setValue(this.subject1);
	assertNotNull(this.event1);
	assertEquals(this.aa1, this.event1.getSource());
	assertEquals(PropertyValueModel.VALUE, this.event1.getPropertyName());
	assertEquals(null, this.event1.getOldValue());
	assertEquals("foo", this.event1.getNewValue());
	assertEquals("foo", this.aa1.getValue());
	}

	public void testPropertyChange() {
	assertEquals("foo", this.aa1.getValue());
	assertNull(this.event1);

	this.subject1.setName("baz");
	assertNotNull(this.event1);
	assertEquals(this.aa1, this.event1.getSource());
	assertEquals(PropertyValueModel.VALUE, this.event1.getPropertyName());
	assertEquals("foo", this.event1.getOldValue());
	assertEquals("baz", this.event1.getNewValue());
	assertEquals("baz", this.aa1.getValue());

	this.event1 = null;
	this.subject1.setName(null);
	assertNotNull(this.event1);
	assertEquals(this.aa1, this.event1.getSource());
	assertEquals(PropertyValueModel.VALUE, this.event1.getPropertyName());
	assertEquals("baz", this.event1.getOldValue());
	assertEquals(null, this.event1.getNewValue());
	assertEquals(null, this.aa1.getValue());

	this.event1 = null;
	this.subject1.setName("foo");
	assertNotNull(this.event1);
	assertEquals(this.aa1, this.event1.getSource());
	assertEquals(PropertyValueModel.VALUE, this.event1.getPropertyName());
	assertEquals(null, this.event1.getOldValue());
	assertEquals("foo", this.event1.getNewValue());
	assertEquals("foo", this.aa1.getValue());
	}

	public void testValue() {
	assertEquals("foo", this.subject1.getName());
	assertEquals("foo", this.aa1.getValue());
	}

	public void testStaleValue() {
	assertEquals("foo", this.subject1.getName());
	assertEquals("foo", this.aa1.getValue());

	this.aa1.removePropertyChangeListener(PropertyValueModel.VALUE, this.listener1);
	assertEquals(null, this.aa1.getValue());

	this.aa1.addPropertyChangeListener(PropertyValueModel.VALUE, this.listener1);
	assertEquals("foo", this.aa1.getValue());

	this.aa1.removePropertyChangeListener(PropertyValueModel.VALUE, this.listener1);
	this.subjectHolder1.setValue(this.subject2);
	assertEquals(null, this.aa1.getValue());

	this.aa1.addPropertyChangeListener(PropertyValueModel.VALUE, this.listener1);
	assertEquals("bar", this.aa1.getValue());
	}

	public void testSetValue() {
	this.aa1.setValue("baz");
	assertEquals("baz", this.aa1.getValue());
	assertEquals("baz", this.subject1.getName());
	}

	public void testHasListeners() {
	assertTrue(this.aa1.hasAnyPropertyChangeListeners(PropertyValueModel.VALUE));
	assertTrue(this.subject1.hasAnyPropertyChangeListeners(TestSubject.NAME_PROPERTY));
	this.aa1.removePropertyChangeListener(PropertyValueModel.VALUE, this.listener1);
	assertFalse(this.subject1.hasAnyPropertyChangeListeners(TestSubject.NAME_PROPERTY));
	assertFalse(this.aa1.hasAnyPropertyChangeListeners(PropertyValueModel.VALUE));

	ChangeListener listener2 = this.buildValueChangeListener1();
	this.aa1.addChangeListener(listener2);
	assertTrue(this.aa1.hasAnyPropertyChangeListeners(PropertyValueModel.VALUE));
	assertTrue(this.subject1.hasAnyPropertyChangeListeners(TestSubject.NAME_PROPERTY));
	this.aa1.removeChangeListener(listener2);
	assertFalse(this.subject1.hasAnyPropertyChangeListeners(TestSubject.NAME_PROPERTY));
	assertFalse(this.aa1.hasAnyPropertyChangeListeners(PropertyValueModel.VALUE));
	}

	public void testMultipleAspectAdapter() {
	TestSubject testSubject = new TestSubject("fred", "husband");
	WritablePropertyValueModel<TestSubject> testSubjectHolder = new SimplePropertyValueModel<TestSubject>(testSubject);
	WritablePropertyValueModel<String> testAA = this.buildMultipleAspectAdapter(testSubjectHolder);
	PropertyChangeListener testListener = this.buildMultipleValueChangeListener();
	testAA.addPropertyChangeListener(PropertyValueModel.VALUE, testListener);
	assertEquals("fred:husband", testAA.getValue());

	this.multipleValueEvent = null;
	testSubject.setName("wilma");
	assertEquals("wilma:husband", testAA.getValue());
	assertEquals("fred:husband", this.multipleValueEvent.getOldValue());
	assertEquals("wilma:husband", this.multipleValueEvent.getNewValue());

	this.multipleValueEvent = null;
	testSubject.setDescription("wife");
	assertEquals("wilma:wife", testAA.getValue());
	assertEquals("wilma:husband", this.multipleValueEvent.getOldValue());
	assertEquals("wilma:wife", this.multipleValueEvent.getNewValue());
	}

	private WritablePropertyValueModel<String> buildMultipleAspectAdapter(PropertyValueModel<TestSubject> subjectHolder) {
	return new PropertyAspectAdapter<TestSubject, String>(subjectHolder, TestSubject.NAME_PROPERTY, TestSubject.DESCRIPTION_PROPERTY) {
	@Override
	protected String buildValue_() {
	return this.subject.getName() + ":" + this.subject.getDescription();
	}
	};
	}

	private PropertyChangeListener buildMultipleValueChangeListener() {
	return new PropertyChangeListener() {
	public void propertyChanged(PropertyChangeEvent e) {
	PropertyAspectAdapterTests.this.multipleValueChanged(e);
	}
	};
	}

	void multipleValueChanged(PropertyChangeEvent e) {
	this.multipleValueEvent = e;
	}

	/**
	* test a bug where we would call #buildValue() in
	* #engageNonNullSubject(), when we needed to call
	* it in #engageSubject(), so the cached value would
	* be rebuilt when the this.subject was set to null
	*/
	public void testCustomBuildValueWithNullSubject() {
	TestSubject customSubject = new TestSubject("fred", "laborer");
	WritablePropertyValueModel<TestSubject> customSubjectHolder = new SimplePropertyValueModel<TestSubject>(customSubject);
	WritablePropertyValueModel<String> customAA = this.buildCustomAspectAdapter(customSubjectHolder);
	PropertyChangeListener customListener = this.buildCustomValueChangeListener();
	customAA.addPropertyChangeListener(PropertyValueModel.VALUE, customListener);
	assertEquals("fred", customAA.getValue());

	this.customValueEvent = null;
	customSubject.setName("wilma");
	assertEquals("wilma", customAA.getValue());
	assertEquals("fred", this.customValueEvent.getOldValue());
	assertEquals("wilma", this.customValueEvent.getNewValue());

	this.customValueEvent = null;
	customSubjectHolder.setValue(null);
	// this would fail - the value would be null...
	assertEquals("<unnamed>", customAA.getValue());
	assertEquals("wilma", this.customValueEvent.getOldValue());
	assertEquals("<unnamed>", this.customValueEvent.getNewValue());
	}

	/**
	* Test a bug:
	* If two listeners were added to an aspect adapter, one with an
	* aspect name and one without, the aspect adapter would add its
	* 'subjectChangeListener' to its 'subjectHolder' twice. As a result,
	* the following code will trigger an IllegalArgumentException
	* if the bug is present; otherwise, it completes silently.
	*/
	public void testDuplicateListener() {
	ChangeListener listener2 = new ChangeAdapter();
	this.aa1.addChangeListener(listener2);
	}

	private WritablePropertyValueModel<String> buildCustomAspectAdapter(PropertyValueModel<TestSubject> subjectHolder) {
	return new PropertyAspectAdapter<TestSubject, String>(subjectHolder, TestSubject.NAME_PROPERTY) {
	@Override
	protected String buildValue() {
	return (this.subject == null) ? "<unnamed>" : this.subject.getName();
	}
	};
	}

	private PropertyChangeListener buildCustomValueChangeListener() {
	return new PropertyChangeListener() {
	public void propertyChanged(PropertyChangeEvent e) {
	PropertyAspectAdapterTests.this.customValueChanged(e);
	}
	};
	}

	void customValueChanged(PropertyChangeEvent e) {
	this.customValueEvent = e;
	}


	// ******** test model ********

	private static class TestSubject extends AbstractModel {
	private String name;
	public static final String NAME_PROPERTY = "name";
	private String description;
	public static final String DESCRIPTION_PROPERTY = "description";

	public TestSubject(String name, String description) {
	this.name = name;
	this.description = description;
	}
	public String getName() {
	return this.name;
	}
	public void setName(String name) {
	Object old = this.name;
	this.name = name;
	this.firePropertyChanged(NAME_PROPERTY, old, name);
	}
	public String getDescription() {
	return this.description;
	}
	public void setDescription(String description) {
	Object old = this.description;
	this.description = description;
	this.firePropertyChanged(DESCRIPTION_PROPERTY, old, description);
	}
	}

	}