001: /*
002: * Copyright 2001-2004 The Apache Software Foundation
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */
016: package org.apache.commons.collections.keyvalue;
017:
018: import java.util.HashMap;
019: import java.util.Map;
020:
021: import junit.framework.TestCase;
022:
023: /**
024: * Abstract tests that can be extended to test any Map.Entry implementation.
025: * Subclasses must implement {@link #makeMapEntry(Object, Object)} to return
026: * a new Map.Entry of the type being tested. Subclasses must also implement
027: * {@link #testConstructors()} to test the constructors of the Map.Entry
028: * type being tested.
029: *
030: * @since Commons Collections 3.0
031: * @version $Revision: 155406 $ $Date: 2005-02-26 12:55:26 +0000 (Sat, 26 Feb 2005) $
032: *
033: * @author Neil O'Toole
034: */
035: public abstract class AbstractTestMapEntry extends TestCase {
036:
037: protected final String key = "name";
038: protected final String value = "duke";
039:
040: /**
041: * JUnit constructor.
042: *
043: * @param testName the test name
044: */
045: public AbstractTestMapEntry(String testName) {
046: super (testName);
047: }
048:
049: //-----------------------------------------------------------------------
050: /**
051: * Make an instance of Map.Entry with the default (null) key and value.
052: * This implementation simply calls {@link #makeMapEntry(Object, Object)}
053: * with null for key and value. Subclasses can override this method if desired.
054: */
055: public Map.Entry makeMapEntry() {
056: return makeMapEntry(null, null);
057: }
058:
059: /**
060: * Make an instance of Map.Entry with the specified key and value.
061: * Subclasses should override this method to return a Map.Entry
062: * of the type being tested.
063: */
064: public abstract Map.Entry makeMapEntry(Object key, Object value);
065:
066: /**
067: * Makes a Map.Entry of a type that's known to work correctly.
068: */
069: public Map.Entry makeKnownMapEntry() {
070: return makeKnownMapEntry(null, null);
071: }
072:
073: /**
074: * Makes a Map.Entry of a type that's known to work correctly.
075: */
076: public Map.Entry makeKnownMapEntry(Object key, Object value) {
077: Map map = new HashMap(1);
078: map.put(key, value);
079: Map.Entry entry = (Map.Entry) map.entrySet().iterator().next();
080: return entry;
081: }
082:
083: //-----------------------------------------------------------------------
084: public void testAccessorsAndMutators() {
085: Map.Entry entry = makeMapEntry(key, value);
086:
087: assertTrue(entry.getKey() == key);
088:
089: entry.setValue(value);
090: assertTrue(entry.getValue() == value);
091:
092: // check that null doesn't do anything funny
093: entry = makeMapEntry(null, null);
094: assertTrue(entry.getKey() == null);
095:
096: entry.setValue(null);
097: assertTrue(entry.getValue() == null);
098: }
099:
100: /**
101: * Subclasses should override this method to test the
102: * desired behaviour of the class with respect to
103: * handling of self-references.
104: *
105: */
106:
107: public void testSelfReferenceHandling() {
108: // test that #setValue does not permit
109: // the MapEntry to contain itself (and thus cause infinite recursion
110: // in #hashCode and #toString)
111:
112: Map.Entry entry = makeMapEntry();
113:
114: try {
115: entry.setValue(entry);
116: fail("Should throw an IllegalArgumentException");
117: } catch (IllegalArgumentException iae) {
118: // expected to happen...
119:
120: // check that the KVP's state has not changed
121: assertTrue(entry.getKey() == null
122: && entry.getValue() == null);
123: }
124: }
125:
126: /**
127: * Subclasses should provide tests for their constructors.
128: *
129: */
130: public abstract void testConstructors();
131:
132: public void testEqualsAndHashCode() {
133: // 1. test with object data
134: Map.Entry e1 = makeMapEntry(key, value);
135: Map.Entry e2 = makeKnownMapEntry(key, value);
136:
137: assertTrue(e1.equals(e1));
138: assertTrue(e2.equals(e1));
139: assertTrue(e1.equals(e2));
140: assertTrue(e1.hashCode() == e2.hashCode());
141:
142: // 2. test with nulls
143: e1 = makeMapEntry();
144: e2 = makeKnownMapEntry();
145:
146: assertTrue(e1.equals(e1));
147: assertTrue(e2.equals(e1));
148: assertTrue(e1.equals(e2));
149: assertTrue(e1.hashCode() == e2.hashCode());
150: }
151:
152: public void testToString() {
153: Map.Entry entry = makeMapEntry(key, value);
154: assertTrue(entry.toString().equals(
155: entry.getKey() + "=" + entry.getValue()));
156:
157: // test with nulls
158: entry = makeMapEntry();
159: assertTrue(entry.toString().equals(
160: entry.getKey() + "=" + entry.getValue()));
161: }
162:
163: }
|