| /* |
| * Copyright 2010 Google Inc. |
| * |
| * 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 elemental.js.util; |
| |
| import static elemental.js.util.TestUtils.assertSamelitude; |
| |
| import com.google.gwt.junit.client.GWTTestCase; |
| |
| import elemental.util.ArrayOf; |
| import elemental.util.ArrayOfBoolean; |
| import elemental.util.ArrayOfInt; |
| import elemental.util.ArrayOfNumber; |
| import elemental.util.ArrayOfString; |
| import elemental.util.CanCompare; |
| import elemental.util.Collections; |
| import elemental.util.MapFromStringTo; |
| import elemental.util.MapFromStringToBoolean; |
| import elemental.util.MapFromStringToInt; |
| import elemental.util.MapFromStringToNumber; |
| import elemental.util.MapFromStringToString; |
| |
| import java.util.Arrays; |
| |
| /** |
| * Tests {@link MapFromStringTo}, {@link MapFromStringToBoolean}, |
| * {@link MapFromStringToInt}, {@link MapFromStringToNumber} and |
| * {@link MapFromStringToString}. |
| */ |
| public class MapFromStringTests extends GWTTestCase { |
| |
| @Override |
| public String getModuleName() { |
| return "elemental.Elemental"; |
| } |
| |
| /** |
| * Tests {@link MapFromStringTo}. |
| */ |
| public void testMapsFromString() { |
| // This is our test subject. |
| final MapFromStringTo<TestItem> map = Collections.mapFromStringTo(); |
| |
| // These are his keys. |
| final String[] keys = new String[] {"key-1", "key-2", "key-3"}; |
| |
| // These are the values for those keys. |
| final TestItem[] vals = new TestItem[] {new TestItem(0), new TestItem(1), new TestItem(2)}; |
| |
| // Let's put those values in. |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| map.put(keys[i], vals[i]); |
| } |
| |
| // Are they all in the right place? |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| assertTrue(map.hasKey(keys[i])); |
| assertEquals(vals[i], map.get(keys[i])); |
| } |
| |
| // These are some new values. |
| final TestItem[] newVals = new TestItem[] {new TestItem(3), new TestItem(4), new TestItem(5)}; |
| |
| // Let's update those keys, ok. |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| map.put(keys[i], newVals[i]); |
| } |
| |
| // Are they all in the right place? |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| assertTrue(map.hasKey(keys[i])); |
| assertEquals(newVals[i], map.get(keys[i])); |
| } |
| |
| checkMapContents(map, keys, newVals); |
| |
| // Let's remove a key, did it go away? |
| map.remove(keys[0]); |
| assertNull(map.get(keys[0])); |
| assertFalse(map.hasKey(keys[0])); |
| } |
| |
| /** |
| * Tests {@link MapFromStringToInt}. |
| */ |
| public void testMapsFromStringsToInts() { |
| // This is our test subject. |
| final MapFromStringToInt map = Collections.mapFromStringToInt(); |
| |
| // These are his keys. |
| final String[] keys = new String[] {"key-1", "key-2", "key-3"}; |
| |
| // These are the values for those keys. |
| final int[] vals = new int[] {0, 1, 2}; |
| |
| // Let's put those values in. |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| map.put(keys[i], vals[i]); |
| } |
| |
| // Are they all in the right place? |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| assertTrue(map.hasKey(keys[i])); |
| assertEquals(vals[i], map.get(keys[i])); |
| } |
| |
| // These are some new values. |
| final int[] newVals = new int[] {3, 4, 5}; |
| |
| // Let's update those keys, ok. |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| map.put(keys[i], newVals[i]); |
| } |
| |
| // Are they all in the right place? |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| assertTrue(map.hasKey(keys[i])); |
| assertEquals(newVals[i], map.get(keys[i])); |
| } |
| |
| checkMapContents(map, keys, newVals); |
| |
| // Let's remove a key, did it go away? |
| map.remove(keys[0]); |
| assertFalse(map.hasKey(keys[0])); |
| } |
| |
| /** |
| * Tests {@link MapFromStringToNumber}. |
| */ |
| public void testMapsFromStringsToNumbers() { |
| // This is our test subject. |
| final MapFromStringToNumber map = Collections.mapFromStringToNumber(); |
| |
| // These are his keys. |
| final String[] keys = new String[] {"key-1", "key-2", "key-3"}; |
| |
| // These are the values for those keys. |
| final double[] vals = new double[] {0.0, 1.0, 2.0}; |
| |
| // Let's put those values in. |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| map.put(keys[i], vals[i]); |
| } |
| |
| // Are they all in the right place? |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| assertTrue(map.hasKey(keys[i])); |
| assertEquals(vals[i], map.get(keys[i])); |
| } |
| |
| // These are some new values. |
| final double[] newVals = new double[] {3.0, 4.0, 5.0}; |
| |
| // Let's update those keys, ok. |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| map.put(keys[i], newVals[i]); |
| } |
| |
| // Are they all in the right place? |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| assertTrue(map.hasKey(keys[i])); |
| assertEquals(newVals[i], map.get(keys[i])); |
| } |
| |
| checkMapContents(map, keys, newVals); |
| |
| // Let's remove a key, did it go away? |
| map.remove(keys[0]); |
| assertFalse(map.hasKey(keys[0])); |
| } |
| |
| /** |
| * Tests {@link MapFromStringToString}. |
| */ |
| public void testMapsFromStringsToStrings() { |
| // This is our test subject. |
| final MapFromStringToString map = Collections.mapFromStringToString(); |
| |
| // These are his keys. |
| final String[] keys = new String[] {"key-1", "key-2", "key-3"}; |
| |
| // These are the values for those keys. |
| final String[] vals = new String[] {"val-0", "val-1", "val-2"}; |
| |
| // Let's put those values in. |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| map.put(keys[i], vals[i]); |
| } |
| |
| // Are they all in the right place? |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| assertTrue(map.hasKey(keys[i])); |
| assertEquals(vals[i], map.get(keys[i])); |
| } |
| |
| // These are some new values. |
| final String[] newVals = new String[] {"val-3", "val-4", "val-5"}; |
| |
| // Let's update those keys, ok. |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| map.put(keys[i], newVals[i]); |
| } |
| |
| // Are they all in the right place? |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| assertTrue(map.hasKey(keys[i])); |
| assertEquals(newVals[i], map.get(keys[i])); |
| } |
| |
| checkMapContents(map, keys, newVals); |
| |
| // Let's remove a key, did it go away? |
| map.remove(keys[0]); |
| assertNull(map.get(keys[0])); |
| assertFalse(map.hasKey(keys[0])); |
| } |
| |
| /** |
| * Tests {@link MapFromStringToBoolean}. |
| */ |
| public void testsMapFromStringsToBooleans() { |
| // This is our test subject. |
| final MapFromStringToBoolean map = Collections.mapFromStringToBoolean(); |
| |
| // These are his keys. |
| final String[] keys = new String[] {"key-1", "key-2", "key-3"}; |
| |
| // These are the values for those keys. |
| final boolean[] vals = new boolean[] {true, false, true}; |
| |
| // Let's put those values in. |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| map.put(keys[i], vals[i]); |
| } |
| |
| // Are they all in the right place? |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| assertTrue(map.hasKey(keys[i])); |
| assertEquals(vals[i], map.get(keys[i])); |
| } |
| |
| // These are some new values. |
| final boolean[] newVals = new boolean[] {false, true, false}; |
| |
| // Let's update those keys, ok. |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| map.put(keys[i], newVals[i]); |
| } |
| |
| // Are they all in the right place? |
| for (int i = 0, n = keys.length; i < n; ++i) { |
| assertTrue(map.hasKey(keys[i])); |
| assertEquals(newVals[i], map.get(keys[i])); |
| } |
| |
| checkMapContents(map, keys, newVals); |
| |
| // Let's remove a key, did it go away? |
| map.remove(keys[0]); |
| assertFalse(map.hasKey(keys[0])); |
| } |
| |
| private void checkMapContents(MapFromStringToBoolean map, String[] keys, boolean[] values) { |
| keys = Arrays.copyOf(keys, keys.length); |
| Arrays.sort(keys); |
| ArrayOfString mapKeys = map.keys(); |
| mapKeys.sort(); |
| assertSamelitude(keys, mapKeys); |
| |
| // We can't sort boolean array so we just compare true values count. |
| ArrayOfBoolean mapValues = map.values(); |
| assertEquals(values.length, mapValues.length()); |
| int expectedTrueCount = 0; |
| int actualTrueCount = 0; |
| for (int i = 0; i < values.length; i++) { |
| if (values[i]) { |
| expectedTrueCount++; |
| } |
| if (mapValues.get(i)) { |
| actualTrueCount++; |
| } |
| } |
| assertEquals(expectedTrueCount, actualTrueCount); |
| } |
| |
| private void checkMapContents(MapFromStringToNumber map, String[] keys, double[] values) { |
| keys = Arrays.copyOf(keys, keys.length); |
| Arrays.sort(keys); |
| ArrayOfString mapKeys = map.keys(); |
| mapKeys.sort(); |
| assertSamelitude(keys, mapKeys); |
| |
| values = Arrays.copyOf(values, values.length); |
| Arrays.sort(values); |
| ArrayOfNumber mapValues = map.values(); |
| mapValues.sort(); |
| assertSamelitude(values, mapValues); |
| } |
| |
| private void checkMapContents(MapFromStringToInt map, String[] keys, int[] values) { |
| keys = Arrays.copyOf(keys, keys.length); |
| Arrays.sort(keys); |
| ArrayOfString mapKeys = map.keys(); |
| mapKeys.sort(); |
| assertSamelitude(keys, mapKeys); |
| |
| values = Arrays.copyOf(values, values.length); |
| Arrays.sort(values); |
| ArrayOfInt mapValues = map.values(); |
| mapValues.sort(); |
| assertSamelitude(values, mapValues); |
| } |
| |
| private void checkMapContents(MapFromStringTo<TestItem> map, String[] keys, TestItem[] values) { |
| keys = Arrays.copyOf(keys, keys.length); |
| Arrays.sort(keys); |
| ArrayOfString mapKeys = map.keys(); |
| mapKeys.sort(); |
| assertSamelitude(keys, mapKeys); |
| |
| values = Arrays.copyOf(values, values.length); |
| Arrays.sort(values); |
| ArrayOf<TestItem> mapValues = map.values(); |
| mapValues.sort(new CanCompare<TestItem>() { |
| @Override |
| public int compare(TestItem a, TestItem b) { |
| return a.compareTo(b); |
| } |
| }); |
| assertSamelitude(values, mapValues); |
| } |
| |
| private void checkMapContents(MapFromStringToString map, String[] keys, String[] values) { |
| keys = Arrays.copyOf(keys, keys.length); |
| Arrays.sort(keys); |
| ArrayOfString mapKeys = map.keys(); |
| mapKeys.sort(); |
| assertSamelitude(keys, mapKeys); |
| |
| values = Arrays.copyOf(values, values.length); |
| Arrays.sort(values); |
| ArrayOfString mapValues = map.values(); |
| mapValues.sort(); |
| assertSamelitude(values, mapValues); |
| } |
| } |