elemental/tests/elemental/js/util/MapFromStringTests.java - gwt - Git at Google

 /*
  * 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);
   }
 }
	/*
	* 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);
	}
	}