| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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.support; |
| |
| import java.lang.reflect.Array; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Set; |
| import junit.framework.TestCase; |
| |
| public class Support_MapTest extends TestCase { |
| |
| // must be a map containing the string keys "0"-"99" paired with the Integer |
| // values Integer(0) to Integer(99) |
| private final Map<String, Integer> modifiableMap; |
| private final Map<String, Integer> unmodifiableMap; |
| |
| public Support_MapTest(String p1, Map<String, Integer> modifiableMap) { |
| super(p1); |
| this.modifiableMap = modifiableMap; |
| unmodifiableMap = Collections.unmodifiableMap(modifiableMap); |
| } |
| |
| @Override |
| public void runTest() { |
| testContents(modifiableMap); |
| testContents(unmodifiableMap); |
| |
| // values() |
| new Support_UnmodifiableCollectionTest("values() from map test", modifiableMap.values()) |
| .runTest(); |
| new Support_UnmodifiableCollectionTest("values() from unmodifiable map test", |
| unmodifiableMap.values()).runTest(); |
| |
| // entrySet() |
| testEntrySet(modifiableMap.entrySet(), unmodifiableMap.entrySet()); |
| |
| // keySet() |
| testKeySet(modifiableMap.keySet(), unmodifiableMap.keySet()); |
| } |
| |
| private void testContents(Map<String, Integer> map) { |
| // size |
| assertTrue("Size should return 100, returned: " + map.size(), map.size() == 100); |
| |
| // containsKey |
| assertTrue("Should contain the key \"0\"", map.containsKey("0")); |
| assertTrue("Should contain the key \"50\"", map.containsKey("50")); |
| assertTrue("Should not contain the key \"100\"", !map.containsKey("100")); |
| |
| // containsValue |
| assertTrue("Should contain the value 0", map.containsValue(0)); |
| assertTrue("Should contain the value 50", map.containsValue(50)); |
| assertTrue("Should not contain value 100", !map.containsValue(100)); |
| |
| // get |
| assertTrue("getting \"0\" didn't return 0", map.get("0") == 0); |
| assertTrue("getting \"50\" didn't return 50", map.get("50") == 50); |
| assertNull("getting \"100\" didn't return null", map.get("100")); |
| |
| // isEmpty |
| assertTrue("should have returned false to isEmpty", !map.isEmpty()); |
| } |
| |
| private static void testEntrySet( |
| Set<Map.Entry<String, Integer>> referenceEntrySet, |
| Set<Map.Entry<String, Integer>> entrySet) { |
| // entrySet should be a set of mappings {"0", 0}, {"1",1}... {"99", 99} |
| assertEquals(100, referenceEntrySet.size()); |
| assertEquals(100, entrySet.size()); |
| |
| // The ordering may be undefined for a map implementation but the ordering must be the |
| // same across iterator(), toArray() and toArray(T[]) for a given map *and* the same for the |
| // modifiable and unmodifiable map. |
| crossCheckOrdering(referenceEntrySet, entrySet, Map.Entry.class); |
| } |
| |
| private static void testKeySet(Set<String> referenceKeySet, Set<String> keySet) { |
| // keySet should be a set of the strings "0" to "99" |
| testKeySetContents(referenceKeySet); |
| testKeySetContents(keySet); |
| |
| // The ordering may be undefined for a map implementation but the ordering must be the |
| // same across iterator(), toArray() and toArray(T[]) for a given map *and* the same for the |
| // modifiable and unmodifiable map. |
| crossCheckOrdering(referenceKeySet, keySet, String.class); |
| } |
| |
| private static void testKeySetContents(Set<String> keySet) { |
| // contains |
| assertTrue("should contain \"0\"", keySet.contains("0")); |
| assertTrue("should contain \"50\"", keySet.contains("50")); |
| assertTrue("should not contain \"100\"", !keySet.contains("100")); |
| |
| // containsAll |
| HashSet<String> hs = new HashSet<String>(); |
| hs.add("0"); |
| hs.add("25"); |
| hs.add("99"); |
| assertTrue("Should contain set of \"0\", \"25\", and \"99\"", keySet.containsAll(hs)); |
| hs.add("100"); |
| assertTrue("Should not contain set of \"0\", \"25\", \"99\" and \"100\"", |
| !keySet.containsAll(hs)); |
| |
| // isEmpty |
| assertTrue("Should not be empty", !keySet.isEmpty()); |
| |
| // size |
| assertEquals("Returned wrong size.", 100, keySet.size()); |
| } |
| |
| private static <T> void crossCheckOrdering(Set<T> set1, Set<T> set2, Class<?> elementType) { |
| Iterator<T> set1Iterator = set1.iterator(); |
| Iterator<T> set2Iterator = set2.iterator(); |
| |
| T[] zeroLengthArray = createArray(elementType, 0); |
| T[] set1TypedArray1 = set1.toArray(zeroLengthArray); |
| assertEquals(set1.size(), set1TypedArray1.length); |
| |
| // Compare set1.iterator(), set2.iterator() and set1.toArray(new T[0]) |
| int entryCount = 0; |
| while (set1Iterator.hasNext()) { |
| T set1Entry = set1Iterator.next(); |
| T set2Entry = set2Iterator.next(); |
| |
| // Compare set1 with set2 |
| assertEquals(set1Entry, set2Entry); |
| |
| // Compare the iterator with the array. The arrays will be checked against each other. |
| assertEquals(set1Entry, set1TypedArray1[entryCount]); |
| |
| entryCount++; |
| } |
| assertFalse(set2Iterator.hasNext()); |
| assertEquals(set1.size(), entryCount); |
| |
| // Compare the various arrays with each other. |
| |
| // set1.toArray(new T[size]) |
| T[] parameterArray1 = createArray(elementType, set1.size()); |
| T[] set1TypedArray2 = set1.toArray(parameterArray1); |
| assertSame(set1TypedArray2, parameterArray1); |
| assertArrayEquals(set1TypedArray1, set1TypedArray2); |
| |
| // set1.toArray() |
| Object[] set1UntypedArray = set1.toArray(); |
| assertEquals(set1.size(), set1UntypedArray.length); |
| assertArrayEquals(set1TypedArray1, set1UntypedArray); |
| |
| // set2.toArray(new T[0]) |
| T[] set2TypedArray1 = set2.toArray(zeroLengthArray); |
| assertEquals(set1.size(), set2TypedArray1.length); |
| assertArrayEquals(set1TypedArray1, set2TypedArray1); |
| |
| // set2.toArray(new T[size]) |
| T[] parameterArray2 = createArray(elementType, set2.size()); |
| T[] set2TypedArray2 = set1.toArray(parameterArray2); |
| assertSame(set2TypedArray2, parameterArray2); |
| assertArrayEquals(set1TypedArray1, set1TypedArray2); |
| |
| // set2.toArray() |
| Object[] set2UntypedArray = set2.toArray(); |
| assertArrayEquals(set1TypedArray1, set2UntypedArray); |
| } |
| |
| private static <T> void assertArrayEquals(T[] array1, T[] array2) { |
| assertTrue(Arrays.equals(array1, array2)); |
| } |
| |
| private static <T> T[] createArray(Class<?> elementType, int size) { |
| return (T[]) Array.newInstance(elementType, size); |
| } |
| } |