// Copyright 2014 The Bazel Authors. All rights reserved.
//
// 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.devtools.build.lib.collect;

import static com.google.common.truth.Truth.assertThat;
import static com.google.devtools.build.lib.testutil.MoreAsserts.assertThrows;

import com.google.common.collect.Maps;
import com.google.common.testing.NullPointerTester;
import java.io.Serializable;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/**
 * A test for {@link ImmutableSortedKeyListMultimap}. Started out as a blatant copy of
 * ImmutableListMapTest.
 */
@RunWith(JUnit4.class)
public class ImmutableSortedKeyMapTest {

  @Test
  public void emptyBuilder() {
    ImmutableSortedKeyMap<String, Integer> map
        = ImmutableSortedKeyMap.<String, Integer>builder().build();
    assertThat(map).isEmpty();
  }

  @Test
  public void singletonBuilder() {
    ImmutableSortedKeyMap<String, Integer> map = ImmutableSortedKeyMap.<String, Integer>builder()
        .put("one", 1)
        .build();
    assertMapEquals(map, "one", 1);
  }

  @Test
  public void builder() {
    ImmutableSortedKeyMap<String, Integer> map = ImmutableSortedKeyMap.<String, Integer>builder()
        .put("one", 1)
        .put("two", 2)
        .put("three", 3)
        .put("four", 4)
        .put("five", 5)
        .build();
    assertMapEquals(map,
        "five", 5, "four", 4, "one", 1, "three", 3, "two", 2);
  }

  @Test
  public void builderPutAllWithEmptyMap() {
    ImmutableSortedKeyMap<String, Integer> map = ImmutableSortedKeyMap.<String, Integer>builder()
        .putAll(Collections.<String, Integer>emptyMap())
        .build();
    assertThat(map).isEmpty();
  }

  @Test
  public void builderPutAll() {
    Map<String, Integer> toPut = new LinkedHashMap<>();
    toPut.put("one", 1);
    toPut.put("two", 2);
    toPut.put("three", 3);
    Map<String, Integer> moreToPut = new LinkedHashMap<>();
    moreToPut.put("four", 4);
    moreToPut.put("five", 5);

    ImmutableSortedKeyMap<String, Integer> map = ImmutableSortedKeyMap.<String, Integer>builder()
        .putAll(toPut)
        .putAll(moreToPut)
        .build();
    assertMapEquals(map,
        "five", 5, "four", 4, "one", 1, "three", 3, "two", 2);
  }

  @Test
  public void builderReuse() {
    ImmutableSortedKeyMap.Builder<String, Integer> builder =
        ImmutableSortedKeyMap.<String, Integer>builder();
    ImmutableSortedKeyMap<String, Integer> mapOne = builder
        .put("one", 1)
        .put("two", 2)
        .build();
    ImmutableSortedKeyMap<String, Integer> mapTwo = builder
        .put("three", 3)
        .put("four", 4)
        .build();

    assertMapEquals(mapOne, "one", 1, "two", 2);
    assertMapEquals(mapTwo, "four", 4, "one", 1, "three", 3, "two", 2);
  }

  @Test
  public void builderPutNullKey() {
    ImmutableSortedKeyMap.Builder<String, Integer> builder = new ImmutableSortedKeyMap.Builder<>();
    assertThrows(NullPointerException.class, () -> builder.put(null, 1));
  }

  @Test
  public void builderPutNullValue() {
    ImmutableSortedKeyMap.Builder<String, Integer> builder = new ImmutableSortedKeyMap.Builder<>();
    assertThrows(NullPointerException.class, () -> builder.put("one", null));
  }

  @Test
  public void builderPutNullKeyViaPutAll() {
    ImmutableSortedKeyMap.Builder<String, Integer> builder = new ImmutableSortedKeyMap.Builder<>();
    assertThrows(
        NullPointerException.class,
        () -> builder.putAll(Collections.<String, Integer>singletonMap(null, 1)));
  }

  @Test
  public void builderPutNullValueViaPutAll() {
    ImmutableSortedKeyMap.Builder<String, Integer> builder = new ImmutableSortedKeyMap.Builder<>();
    assertThrows(
        NullPointerException.class,
        () -> builder.putAll(Collections.<String, Integer>singletonMap("one", null)));
  }

  @Test
  public void of() {
    assertMapEquals(
        ImmutableSortedKeyMap.of("one", 1),
        "one", 1);
    assertMapEquals(
        ImmutableSortedKeyMap.of("one", 1, "two", 2),
        "one", 1, "two", 2);
  }

  @Test
  public void ofNullKey() {
    assertThrows(NullPointerException.class, () -> ImmutableSortedKeyMap.of((String) null, 1));

    assertThrows(NullPointerException.class, () -> ImmutableSortedKeyMap.of("one", 1, null, 2));
  }

  @Test
  public void ofNullValue() {
    assertThrows(NullPointerException.class, () -> ImmutableSortedKeyMap.of("one", null));

    assertThrows(NullPointerException.class, () -> ImmutableSortedKeyMap.of("one", 1, "two", null));
  }

  @Test
  public void copyOfEmptyMap() {
    ImmutableSortedKeyMap<String, Integer> copy
        = ImmutableSortedKeyMap.copyOf(Collections.<String, Integer>emptyMap());
    assertThat(copy).isEmpty();
    assertThat(ImmutableSortedKeyMap.copyOf(copy)).isSameInstanceAs(copy);
  }

  @Test
  public void copyOfSingletonMap() {
    ImmutableSortedKeyMap<String, Integer> copy
        = ImmutableSortedKeyMap.copyOf(Collections.singletonMap("one", 1));
    assertMapEquals(copy, "one", 1);
    assertThat(ImmutableSortedKeyMap.copyOf(copy)).isSameInstanceAs(copy);
  }

  @Test
  public void copyOf() {
    Map<String, Integer> original = new LinkedHashMap<>();
    original.put("one", 1);
    original.put("two", 2);
    original.put("three", 3);

    ImmutableSortedKeyMap<String, Integer> copy = ImmutableSortedKeyMap.copyOf(original);
    assertMapEquals(copy, "one", 1, "three", 3, "two", 2);
    assertThat(ImmutableSortedKeyMap.copyOf(copy)).isSameInstanceAs(copy);
  }

  @Test
  public void nullGet() {
    ImmutableSortedKeyMap<String, Integer> map = ImmutableSortedKeyMap.of("one", 1);
    assertThat(map).doesNotContainKey(null);
  }

  @Test
  public void nullPointers() {
    NullPointerTester tester = new NullPointerTester();
    tester.testAllPublicStaticMethods(ImmutableSortedKeyMap.class);
    tester.testAllPublicInstanceMethods(
        new ImmutableSortedKeyMap.Builder<String, Object>());
    tester.testAllPublicInstanceMethods(ImmutableSortedKeyMap.<String, Integer>of());
    tester.testAllPublicInstanceMethods(ImmutableSortedKeyMap.of("one", 1));
    tester.testAllPublicInstanceMethods(
        ImmutableSortedKeyMap.of("one", 1, "two", 2));
  }

  private static <K, V> void assertMapEquals(Map<K, V> map,
      Object... alternatingKeysAndValues) {
    assertThat(alternatingKeysAndValues.length / 2).isEqualTo(map.size());
    int i = 0;
    for (Map.Entry<K, V> entry : map.entrySet()) {
      assertThat(entry.getKey()).isEqualTo(alternatingKeysAndValues[i++]);
      assertThat(entry.getValue()).isEqualTo(alternatingKeysAndValues[i++]);
    }
  }

  private static class IntHolder implements Serializable {
    public int value;

    public IntHolder(int value) {
      this.value = value;
    }

    @Override public boolean equals(Object o) {
      return (o instanceof IntHolder) && ((IntHolder) o).value == value;
    }

    @Override public int hashCode() {
      return value;
    }

    private static final long serialVersionUID = 5;
  }

  @Test
  public void mutableValues() {
    IntHolder holderA = new IntHolder(1);
    IntHolder holderB = new IntHolder(2);
    Map<String, IntHolder> map = ImmutableSortedKeyMap.of("a", holderA, "b", holderB);
    holderA.value = 3;
    assertThat(map.entrySet()).contains(Maps.immutableEntry("a", new IntHolder(3)));
    Map<String, Integer> intMap = ImmutableSortedKeyMap.of("a", 3, "b", 2);
    assertThat(map.entrySet().hashCode()).isEqualTo(intMap.hashCode());
    assertThat(map.hashCode()).isEqualTo(intMap.hashCode());
  }

  @Test
  public void toStringTest() {
    Map<String, Integer> map = ImmutableSortedKeyMap.of("a", 1, "b", 2);
    assertThat(map.toString()).isEqualTo("{a=1, b=2}");
    map = ImmutableSortedKeyMap.of();
    assertThat(map.toString()).isEqualTo("{}");
  }

  @Test
  public void emptyValuesCollectionTest() {
    Map<String, Integer> map = ImmutableSortedKeyMap.of();
    assertThat(map.values().size()).isEqualTo(0);
    assertThat(map.values()).containsExactly();
    Iterator<Integer> it = map.values().iterator();
    assertThat(it.hasNext()).isFalse();
  }

  @Test
  public void valuesCollectionTest() {
    Map<String, Integer> map = ImmutableSortedKeyMap.of("a", 1, "b", 2);
    assertThat(map.values().size()).isEqualTo(2);
    assertThat(map.values()).containsExactly(1, 2);
    Iterator<Integer> it = map.values().iterator();
    assertThat(it.hasNext()).isTrue();
    assertThat(it.next()).isEqualTo(1);
    assertThat(it.hasNext()).isTrue();
    assertThat(it.next()).isEqualTo(2);
    assertThat(it.hasNext()).isFalse();
  }
}