📄 abstracttestmap.java
字号:
}
verify();
resetFull();
for (int i = 0; i < keys.length; i++) {
assertEquals("Full map.get() should return value from mapping.",
values[i], map.get(keys[i]));
}
}
/**
* Tests Map.hashCode()
*/
public void testMapHashCode() {
resetEmpty();
assertTrue("Empty maps have different hashCodes.",
map.hashCode() == confirmed.hashCode());
resetFull();
assertTrue("Equal maps have different hashCodes.",
map.hashCode() == confirmed.hashCode());
}
/**
* Tests Map.toString(). Since the format of the string returned by the
* toString() method is not defined in the Map interface, there is no
* common way to test the results of the toString() method. Thereforce,
* it is encouraged that Map implementations override this test with one
* that checks the format matches any format defined in its API. This
* default implementation just verifies that the toString() method does
* not return null.
*/
public void testMapToString() {
resetEmpty();
assertTrue("Empty map toString() should not return null",
map.toString() != null);
verify();
resetFull();
assertTrue("Empty map toString() should not return null",
map.toString() != null);
verify();
}
/**
* Compare the current serialized form of the Map
* against the canonical version in CVS.
*/
public void testEmptyMapCompatibility() throws Exception {
/**
* Create canonical objects with this code
Map map = makeEmptyMap();
if (!(map instanceof Serializable)) return;
writeExternalFormToDisk((Serializable) map, getCanonicalEmptyCollectionName(map));
*/
// test to make sure the canonical form has been preserved
Map map = makeEmptyMap();
if (map instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
Map map2 = (Map) readExternalFormFromDisk(getCanonicalEmptyCollectionName(map));
assertEquals("Map is empty", 0, map2.size());
}
}
/**
* Compare the current serialized form of the Map
* against the canonical version in CVS.
*/
public void testFullMapCompatibility() throws Exception {
/**
* Create canonical objects with this code
Map map = makeFullMap();
if (!(map instanceof Serializable)) return;
writeExternalFormToDisk((Serializable) map, getCanonicalFullCollectionName(map));
*/
// test to make sure the canonical form has been preserved
Map map = makeFullMap();
if (map instanceof Serializable && !skipSerializedCanonicalTests() && isTestSerialization()) {
Map map2 = (Map) readExternalFormFromDisk(getCanonicalFullCollectionName(map));
assertEquals("Map is the right size", getSampleKeys().length, map2.size());
}
}
/**
* Tests Map.put(Object, Object)
*/
public void testMapPut() {
resetEmpty();
Object[] keys = getSampleKeys();
Object[] values = getSampleValues();
Object[] newValues = getNewSampleValues();
if (isPutAddSupported()) {
for (int i = 0; i < keys.length; i++) {
Object o = map.put(keys[i], values[i]);
confirmed.put(keys[i], values[i]);
verify();
assertTrue("First map.put should return null", o == null);
assertTrue("Map should contain key after put",
map.containsKey(keys[i]));
assertTrue("Map should contain value after put",
map.containsValue(values[i]));
}
if (isPutChangeSupported()) {
for (int i = 0; i < keys.length; i++) {
Object o = map.put(keys[i], newValues[i]);
confirmed.put(keys[i], newValues[i]);
verify();
assertEquals("Map.put should return previous value when changed",
values[i], o);
assertTrue("Map should still contain key after put when changed",
map.containsKey(keys[i]));
assertTrue("Map should contain new value after put when changed",
map.containsValue(newValues[i]));
// if duplicates are allowed, we're not guaranteed that the value
// no longer exists, so don't try checking that.
if (!isAllowDuplicateValues()) {
assertTrue("Map should not contain old value after put when changed",
!map.containsValue(values[i]));
}
}
} else {
try {
// two possible exception here, either valid
map.put(keys[0], newValues[0]);
fail("Expected IllegalArgumentException or UnsupportedOperationException on put (change)");
} catch (IllegalArgumentException ex) {
} catch (UnsupportedOperationException ex) {}
}
} else if (isPutChangeSupported()) {
resetEmpty();
try {
map.put(keys[0], values[0]);
fail("Expected UnsupportedOperationException or IllegalArgumentException on put (add) when fixed size");
} catch (IllegalArgumentException ex) {
} catch (UnsupportedOperationException ex) {
}
resetFull();
int i = 0;
for (Iterator it = map.keySet().iterator(); it.hasNext() && i < newValues.length; i++) {
Object key = it.next();
Object o = map.put(key, newValues[i]);
Object value = confirmed.put(key, newValues[i]);
verify();
assertEquals("Map.put should return previous value when changed",
value, o);
assertTrue("Map should still contain key after put when changed",
map.containsKey(key));
assertTrue("Map should contain new value after put when changed",
map.containsValue(newValues[i]));
// if duplicates are allowed, we're not guaranteed that the value
// no longer exists, so don't try checking that.
if (!isAllowDuplicateValues()) {
assertTrue("Map should not contain old value after put when changed",
!map.containsValue(values[i]));
}
}
} else {
try {
map.put(keys[0], values[0]);
fail("Expected UnsupportedOperationException on put (add)");
} catch (UnsupportedOperationException ex) {}
}
}
/**
* Tests Map.put(null, value)
*/
public void testMapPutNullKey() {
resetFull();
Object[] values = getSampleValues();
if (isPutAddSupported()) {
if (isAllowNullKey()) {
map.put(null, values[0]);
} else {
try {
map.put(null, values[0]);
fail("put(null, value) should throw NPE/IAE");
} catch (NullPointerException ex) {
} catch (IllegalArgumentException ex) {}
}
}
}
/**
* Tests Map.put(null, value)
*/
public void testMapPutNullValue() {
resetFull();
Object[] keys = getSampleKeys();
if (isPutAddSupported()) {
if (isAllowNullValue()) {
map.put(keys[0], null);
} else {
try {
map.put(keys[0], null);
fail("put(key, null) should throw NPE/IAE");
} catch (NullPointerException ex) {
} catch (IllegalArgumentException ex) {}
}
}
}
/**
* Tests Map.putAll(map)
*/
public void testMapPutAll() {
if (!isPutAddSupported()) {
if (!isPutChangeSupported()) {
Map temp = makeFullMap();
resetEmpty();
try {
map.putAll(temp);
fail("Expected UnsupportedOperationException on putAll");
} catch (UnsupportedOperationException ex) {}
}
return;
}
// check putAll OK adding empty map to empty map
resetEmpty();
assertEquals(0, map.size());
map.putAll(new HashMap());
assertEquals(0, map.size());
// check putAll OK adding empty map to non-empty map
resetFull();
int size = map.size();
map.putAll(new HashMap());
assertEquals(size, map.size());
// check putAll OK adding non-empty map to empty map
resetEmpty();
Map m2 = makeFullMap();
map.putAll(m2);
confirmed.putAll(m2);
verify();
// check putAll OK adding non-empty JDK map to empty map
resetEmpty();
m2 = makeConfirmedMap();
Object[] keys = getSampleKeys();
Object[] values = getSampleValues();
for(int i = 0; i < keys.length; i++) {
m2.put(keys[i], values[i]);
}
map.putAll(m2);
confirmed.putAll(m2);
verify();
// check putAll OK adding non-empty JDK map to non-empty map
resetEmpty();
m2 = makeConfirmedMap();
map.put(keys[0], values[0]);
confirmed.put(keys[0], values[0]);
verify();
for(int i = 1; i < keys.length; i++) {
m2.put(keys[i], values[i]);
}
map.putAll(m2);
confirmed.putAll(m2);
verify();
}
/**
* Tests Map.remove(Object)
*/
public void testMapRemove() {
if (!isRemoveSupported()) {
try {
resetFull();
map.remove(map.keySet().iterator().next());
fail("Expected UnsupportedOperationException on remove");
} catch (UnsupportedOperationException ex) {}
return;
}
resetEmpty();
Object[] keys = getSampleKeys();
Object[] values = getSampleValues();
for(int i = 0; i < keys.length; i++) {
Object o = map.remove(keys[i]);
assertTrue("First map.remove should return null", o == null);
}
verify();
resetFull();
for(int i = 0; i < keys.length; i++) {
Object o = map.remove(keys[i]);
confirmed.remove(keys[i]);
verify();
assertEquals("map.remove with valid key should return value",
values[i], o);
}
Object[] other = getOtherKeys();
resetFull();
int size = map.size();
for (int i = 0; i < other.length; i++) {
Object o = map.remove(other[i]);
assertEquals("map.remove for nonexistent key should return null",
o, null);
assertEquals("map.remove for nonexistent key should not " +
"shrink map", size, map.size());
}
verify();
}
//-----------------------------------------------------------------------
/**
* Tests that the {@link Map#values} collection is backed by
* the underlying map for clear().
*/
public void testValuesClearChangesMap() {
if (!isRemoveSupported()) return;
// clear values, reflected in map
resetFull();
Collection values = map.values();
assertTrue(map.size() > 0);
assertTrue(values.size() > 0);
values.clear();
assertTrue(map.size() == 0);
assertTrue(values.size() == 0);
// clear map, reflected in values
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -