/*
 * Copyright (C) 2012 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.SafeTreeSet;
import com.google.common.collect.testing.SetTestSuiteBuilder;
import com.google.common.collect.testing.TestStringSetGenerator;
import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.collect.testing.features.CollectionSize;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.NavigableSet;
import java.util.Set;
import java.util.SortedSet;
import junit.framework.Test;
import junit.framework.TestSuite;

/**
 * Tests for {@code ForwardingNavigableSet}.
 *
 * @author Louis Wasserman
 */
public class ForwardingNavigableSetTest extends ForwardingSortedSetTest {
  static class StandardImplForwardingNavigableSet<T>
      extends ForwardingNavigableSet<T> {
    private final NavigableSet<T> backingSet;

    StandardImplForwardingNavigableSet(NavigableSet<T> backingSet) {
      this.backingSet = backingSet;
    }

    @Override protected NavigableSet<T> delegate() {
      return backingSet;
    }

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

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

    @Override public boolean addAll(Collection<? extends T> collection) {
      return standardAddAll(collection);
    }

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

    @Override public boolean contains(Object object) {
      return standardContains(object);
    }

    @Override public boolean containsAll(Collection<?> collection) {
      return standardContainsAll(collection);
    }

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

    @Override public boolean removeAll(Collection<?> collection) {
      return standardRemoveAll(collection);
    }

    @Override public boolean retainAll(Collection<?> collection) {
      return standardRetainAll(collection);
    }

    @Override public Object[] toArray() {
      return standardToArray();
    }

    @Override public <T> T[] toArray(T[] array) {
      return standardToArray(array);
    }

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

    @Override public SortedSet<T> subSet(T fromElement, T toElement) {
      return standardSubSet(fromElement, toElement);
    }

    @Override
    public T lower(T e) {
      return standardLower(e);
    }

    @Override
    public T floor(T e) {
      return standardFloor(e);
    }

    @Override
    public T ceiling(T e) {
      return standardCeiling(e);
    }

    @Override
    public T higher(T e) {
      return standardHigher(e);
    }

    @Override
    public T pollFirst() {
      return standardPollFirst();
    }

    @Override
    public T pollLast() {
      return standardPollLast();
    }

    @Override
    public SortedSet<T> headSet(T toElement) {
      return standardHeadSet(toElement);
    }

    @Override
    public SortedSet<T> tailSet(T fromElement) {
      return standardTailSet(fromElement);
    }
  }

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

    suite.addTestSuite(ForwardingNavigableSetTest.class);
    suite.addTest(
        SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            return new StandardImplForwardingNavigableSet<String>(
                new SafeTreeSet<String>(Arrays.asList(elements)));
          }

          @Override public List<String> order(List<String> insertionOrder) {
            return Lists.newArrayList(Sets.newTreeSet(insertionOrder));
          }
        }).named(
            "ForwardingNavigableSet[SafeTreeSet] with standard implementations")
            .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER,
                CollectionFeature.GENERAL_PURPOSE).createTestSuite());
    suite.addTest(
        SetTestSuiteBuilder.using(new TestStringSetGenerator() {
          @Override protected Set<String> create(String[] elements) {
            SafeTreeSet<String> set = new SafeTreeSet<String>(Ordering.natural().nullsFirst());
            Collections.addAll(set, elements);
            return new StandardImplForwardingNavigableSet<String>(set);
          }

          @Override public List<String> order(List<String> insertionOrder) {
            return Lists.newArrayList(Sets.newTreeSet(insertionOrder));
          }
        }).named(
            "ForwardingNavigableSet[SafeTreeSet[Ordering.natural.nullsFirst]]"
                + " with standard implementations")
            .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER,
                CollectionFeature.GENERAL_PURPOSE, CollectionFeature.ALLOWS_NULL_VALUES)
                .createTestSuite());

    return suite;
  }

  @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 NavigableSet<String> navigableSet
        = createProxyInstance(NavigableSet.class);
    forward = new ForwardingNavigableSet<String>() {
      @Override protected NavigableSet<String> delegate() {
        return navigableSet;
      }
    };
  }

  public void testLower() {
    forward().lower("a");
    assertEquals("[lower(Object)]", getCalls());
  }

  public void testFloor() {
    forward().floor("a");
    assertEquals("[floor(Object)]", getCalls());
  }

  public void testCeiling() {
    forward().ceiling("a");
    assertEquals("[ceiling(Object)]", getCalls());
  }

  public void testHigher() {
    forward().higher("a");
    assertEquals("[higher(Object)]", getCalls());
  }

  public void testPollFirst() {
    forward().pollFirst();
    assertEquals("[pollFirst]", getCalls());
  }

  public void testPollLast() {
    forward().pollLast();
    assertEquals("[pollLast]", getCalls());
  }

  public void testDescendingIterator() {
    forward().descendingIterator();
    assertEquals("[descendingIterator]", getCalls());
  }

  public void testHeadSet_K_Boolean() {
    forward().headSet("key", false);
    assertEquals("[headSet(Object,boolean)]", getCalls());
  }

  public void testSubSet_K_Boolean_K_Boolean() {
    forward().subSet("a", true, "b", false);
    assertEquals("[subSet(Object,boolean,Object,boolean)]", getCalls());
  }

  public void testTailSet_K_Boolean() {
    forward().tailSet("key", false);
    assertEquals("[tailSet(Object,boolean)]", getCalls());
  }

  @Override NavigableSet<String> forward() {
    return (NavigableSet<String>) super.forward();
  }
}
