common/collect/ForwardingSortedMapTest.java

/*
 * Copyright (C) 2007 The Guava Authors
 *
 * 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.common.collect;

import com.google.common.collect.testing.MapTestSuiteBuilder;
import com.google.common.collect.testing.SafeTreeMap;
import com.google.common.collect.testing.TestStringMapGenerator;
import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.collect.testing.features.CollectionSize;
import com.google.common.collect.testing.features.MapFeature;

import junit.framework.Test;
import junit.framework.TestSuite;

import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.SortedMap;

/**
 * Tests for {@code ForwardingSortedMap}.
 *
 * @author Robert Konigsberg
 */
public class ForwardingSortedMapTest extends ForwardingMapTest {
  static class StandardImplForwardingSortedMap<K, V>
      extends ForwardingSortedMap<K, V> {
    private final SortedMap<K, V> backingMap;

    StandardImplForwardingSortedMap(SortedMap<K, V> backingMap) {
      this.backingMap = backingMap;
    }

    @Override protected SortedMap<K, V> delegate() {
      return backingMap;
    }

    @Override public boolean containsKey(Object key) {
      return standardContainsKey(key);
    }

    @Override public boolean containsValue(Object value) {
      return standardContainsValue(value);
    }

    @Override public void putAll(Map<? extends K, ? extends V> map) {
      standardPutAll(map);
    }

    @Override public V remove(Object object) {
      return standardRemove(object);
    }

    @Override public boolean equals(Object object) {
      return standardEquals(object);
    }

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

    @Override public Set<K> keySet() {
      return new StandardKeySet();
    }

    @Override public Collection<V> values() {
      return new StandardValues();
    }

    @Override public String toString() {
      return standardToString();
    }

    @Override public Set<Entry<K, V>> entrySet() {
      return new StandardEntrySet() {
        @Override
        public Iterator<Entry<K, V>> iterator() {
          return backingMap.entrySet().iterator();
        }
      };
    }

    @Override public void clear() {
      standardClear();
    }

    @Override public boolean isEmpty() {
      return standardIsEmpty();
    }

    @Override public SortedMap<K, V> subMap(K fromKey, K toKey) {
      return standardSubMap(fromKey, toKey);
    }
  }

  public static Test suite() {
    TestSuite suite = new TestSuite();

    suite.addTestSuite(ForwardingSortedMapTest.class);
    suite.addTest(MapTestSuiteBuilder.using(new TestStringMapGenerator() {
      @Override protected Map<String, String> create(
          Entry<String, String>[] entries) {
        SortedMap<String, String> map = new SafeTreeMap<String, String>();
        for (Entry<String, String> entry : entries) {
          map.put(entry.getKey(), entry.getValue());
        }
        return new StandardImplForwardingSortedMap<String, String>(map);
      }

      @Override public Iterable<Entry<String, String>> order(
          List<Entry<String, String>> insertionOrder) {
        return sort(insertionOrder);
      }
    }).named("ForwardingSortedMap[SafeTreeMap] with no comparator and standard "
        + "implementations").withFeatures(CollectionSize.ANY,
        CollectionFeature.KNOWN_ORDER, MapFeature.ALLOWS_NULL_VALUES,
        MapFeature.GENERAL_PURPOSE).createTestSuite());
    suite.addTest(MapTestSuiteBuilder.using(new TestStringMapGenerator() {
      private final Comparator<String> comparator =
          Ordering.natural().nullsFirst();

      @Override protected Map<String, String> create(
          Entry<String, String>[] entries) {
        SortedMap<String, String> map =
            new SafeTreeMap<String, String>(comparator);
        for (Entry<String, String> entry : entries) {
          map.put(entry.getKey(), entry.getValue());
        }
        return new StandardImplForwardingSortedMap<String, String>(map);
      }

      @Override public Iterable<Entry<String, String>> order(
          List<Entry<String, String>> insertionOrder) {
        return sort(insertionOrder);
      }
    }).named("ForwardingSortedMap[SafeTreeMap] with natural comparator and "
        + "standard implementations").withFeatures(CollectionSize.ANY,
        CollectionFeature.KNOWN_ORDER, MapFeature.ALLOWS_NULL_VALUES,
        MapFeature.ALLOWS_NULL_KEYS, MapFeature.GENERAL_PURPOSE)
        .createTestSuite());
    suite.addTest(MapTestSuiteBuilder.using(new TestStringMapGenerator() {
      @Override protected Map<String, String> create(
          Entry<String, String>[] entries) {
        ImmutableSortedMap.Builder<String, String> builder =
            ImmutableSortedMap.naturalOrder();
        for (Entry<String, String> entry : entries) {
          builder.put(entry.getKey(), entry.getValue());
        }
        return new StandardImplForwardingSortedMap<String, String>(
            builder.build());
      }

      @Override public Iterable<Entry<String, String>> order(
          List<Entry<String, String>> insertionOrder) {
        return sort(insertionOrder);
      }
    }).named("ForwardingSortedMap[ImmutableSortedMap] with standard "
        + "implementations").withFeatures(
        CollectionSize.ANY, MapFeature.REJECTS_DUPLICATES_AT_CREATION,
        MapFeature.ALLOWS_NULL_QUERIES)
        .createTestSuite());

    return suite;
  }

  private static Iterable<Entry<String, String>> sort(
      List<Entry<String, String>> entries) {
    SortedMap<String, String> map =
        new SafeTreeMap<String, String>(Ordering.natural().nullsFirst());
    for (Entry<String, String> entry : entries) {
      map.put(entry.getKey(), entry.getValue());
    }
    return map.entrySet();
  }

  @Override public void setUp() throws Exception {
    super.setUp();
    /*
     * Class parameters must be raw, so we can't create a proxy with generic
     * type arguments. The created proxy only records calls and returns null, so
     * the type is irrelevant at runtime.
     */
    @SuppressWarnings("unchecked")
    final SortedMap<String, Boolean> sortedMap =
        createProxyInstance(SortedMap.class);
    forward = new ForwardingSortedMap<String, Boolean>() {
      @Override protected SortedMap<String, Boolean> delegate() {
        return sortedMap;
      }
    };
  }

  public void testComparator() {
    forward().comparator();
    assertEquals("[comparator]", getCalls());
  }

  public void testFirstKey() {
    forward().firstKey();
    assertEquals("[firstKey]", getCalls());
  }

  public void testHeadMap_K() {
    forward().headMap("asdf");
    assertEquals("[headMap(Object)]", getCalls());
  }

  public void testLastKey() {
    forward().lastKey();
    assertEquals("[lastKey]", getCalls());
  }

  public void testSubMap_K_K() {
    forward().subMap("first", "last");
    assertEquals("[subMap(Object,Object)]", getCalls());
  }

  public void testTailMap_K() {
    forward().tailMap("last");
    assertEquals("[tailMap(Object)]", getCalls());
  }

  @Override SortedMap<String, Boolean> forward() {
    return (SortedMap<String, Boolean>) super.forward();
  }
}