user/test/com/google/gwt/emultest/java8/util/AbstractJava8MapTest.java

/*
 * Copyright 2016 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 com.google.gwt.emultest.java8.util;

import com.google.gwt.emultest.java.util.EmulTestBase;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

/**
 * Tests for java.util.Map implementing classes Java 8 API emulation.
 */
abstract class AbstractJava8MapTest extends EmulTestBase {

  private Map<String, String> testSample;

  @Override
  protected void gwtSetUp() throws Exception {
    super.gwtSetUp();
    testSample = createTestSample();
  }

  public void testCompute() {
    Map<String, String> map = createTestMap();

    String value = map.compute("a", (k, v) -> k + " - " + v);
    assertEquals("a - A", value);
    assertTrue(map.containsKey("a"));
    assertEquals("a - A", map.get("a"));

    value = map.compute("a", (k, v) -> null);
    assertNull(value);
    assertFalse(map.containsKey("a"));

    value = map.compute("a", (k, v) -> {
      assertNull(v);
      return k.toUpperCase();
    });
    assertEquals("A", value);
    assertTrue(map.containsKey("a"));
    assertEquals("A", map.get("a"));
  }

  public void testComputeIfAbsent() {
    Map<String, String> map = createTestMap();

    String value = map.computeIfAbsent("a", k -> {
      fail();
      return null;
    });
    assertEquals("A", value);
    assertTrue(map.containsKey("a"));
    assertEquals("A", map.get("a"));

    map.remove("a");
    value = map.computeIfAbsent("a", String::toUpperCase);
    assertEquals("A", value);
    assertTrue(map.containsKey("a"));
    assertEquals("A", map.get("a"));

    map.remove("a");
    value = map.computeIfAbsent("a", k -> null);
    assertNull(value);
    assertFalse(map.containsKey("a"));
  }

  public void testComputeIfPresent() {
    Map<String, String> map = createTestMap();

    String value = map.computeIfPresent("a", (k, v) -> k + " - " + v);
    assertEquals("a - A", value);
    assertTrue(map.containsKey("a"));
    assertEquals("a - A", map.get("a"));

    value = map.computeIfPresent("a", (k, v) -> null);
    assertNull(value);
    assertFalse(map.containsKey("a"));

    value = map.computeIfPresent("a", (k, v) -> {
      fail();
      return null;
    });
    assertNull(value);
    assertFalse(map.containsKey("a"));
  }

  public void testForeach() {
    Map<String, String> map = createTestMap();
    Map<String, String> expected = new HashMap<>(testSample);

    assertEquals(expected.size(), map.size());
    map.forEach((k, v) -> {
      assertTrue(expected.containsKey(k));
      assertEquals(expected.get(k), v);
      expected.remove(k);
    });
    assertTrue(expected.isEmpty());
  }

  public void testGetOrDefault() {
    Map<String, String> map = createTestMap();

    String value = map.getOrDefault("a", null);
    assertEquals("A", value);
    assertTrue(map.containsKey("a"));
    assertEquals("A", map.get("a"));

    map.remove("a");
    value = map.getOrDefault("a", "A");
    assertEquals("A", value);
    assertFalse(map.containsKey("a"));
    assertNull(map.get("a"));

    map.put("a", null);
    value = map.getOrDefault("a", "A");
    assertNull(value);
    assertTrue(map.containsKey("a"));
    assertNull(map.get("a"));
  }

  public void testMerge() {
    Map<String, String> map = createTestMap();

    String newValue = map.merge("a", "a", (currentValue, value) -> {
      assertEquals("A", currentValue);
      assertEquals("a", value);
      return value;
    });
    assertEquals(newValue, "a");
    assertTrue(map.containsKey("a"));
    assertEquals("a", map.get("a"));

    try {
      map.merge("a", null, (currentValue, value) -> "");
      fail();
    } catch (NullPointerException expected) {
    }

    newValue = map.merge("a", "", (currentValue, value) -> null);
    assertNull(newValue);
    assertFalse(map.containsKey("a"));
    assertNull(map.get("a"));

    newValue = map.merge("a", "A", (currentValue, value) -> value);
    assertEquals("A", newValue);
    assertTrue(map.containsKey("a"));
    assertEquals("A", map.get("a"));
  }

  public void testPutIfAbsent() {
    Map<String, String> map = createTestMap();

    String oldValue = map.putIfAbsent("a", "a");
    assertEquals("A", oldValue);
    assertTrue(map.containsKey("a"));
    assertEquals("A", map.get("a"));

    map.remove("a");
    oldValue = map.putIfAbsent("a", "a");
    assertNull(oldValue);
    assertTrue(map.containsKey("a"));
    assertEquals("a", map.get("a"));
  }

  public void testRemove() {
    Map<String, String> map = createTestMap();

    assertFalse(map.remove("a", "a"));
    assertTrue(map.containsKey("a"));
    assertEquals("A", map.get("a"));

    assertTrue(map.remove("a", "A"));
    assertFalse(map.containsKey("a"));

    assertFalse(map.remove("a", null));

    map.put("a", null);
    assertTrue(map.remove("a", null));
    assertFalse(map.containsKey("a"));
  }

  public void testReplace() {
    Map<String, String> map = createTestMap();

    String oldValue = map.replace("a", "a");
    assertEquals("A", oldValue);
    assertTrue(map.containsKey("a"));
    assertEquals("a", map.get("a"));

    map.remove("a");
    oldValue = map.replace("a", "A");
    assertNull(oldValue);
    assertFalse(map.containsKey("a"));
    assertNull(map.get("a"));
  }

  public void testReplace_Key_OldValue_NewValue() {
    Map<String, String> map = createTestMap();

    assertTrue(map.replace("a", "A", "a"));
    assertTrue(map.containsKey("a"));
    assertEquals("a", map.get("a"));

    assertFalse(map.replace("a", "A", "a"));

    assertTrue(map.replace("a", "a", null));
    assertTrue(map.containsKey("a"));
    assertNull(map.get("a"));

    map.remove("a");
    assertFalse(map.replace("a", "a", "A"));
    assertFalse(map.containsKey("a"));
    assertNull(map.get("a"));
  }

  public void testReplaceAll() {
    Map<String, String> map = createTestMap();
    map.replaceAll((k, v) -> v.toLowerCase());

    assertEquals(testSample.size(), map.size());
    for (Entry<String, String> entry : testSample.entrySet()) {
      assertTrue(map.containsKey(entry.getKey()));
      assertEquals(map.get(entry.getKey()), entry.getValue().toLowerCase());
    }
  }

  private Map<String, String> createTestMap() {
    Map<String, String> map = createMap();
    map.putAll(testSample);
    return map;
  }

  private static Map<String, String> createTestSample() {
    Map<String, String> map = new HashMap<>();
    map.put("a", "A");
    map.put("b", "B");
    map.put("c", "C");
    return Collections.unmodifiableMap(map);
  }

  protected abstract Map<String, String> createMap();

}