001/*
002 * Copyright (C) 2010 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017package com.google.common.collect.testing;
018
019import static com.google.common.collect.testing.Helpers.castOrCopyToList;
020import static com.google.common.collect.testing.Helpers.copyToList;
021import static java.util.Collections.reverse;
022
023import com.google.common.annotations.GwtIncompatible;
024import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
025import com.google.common.collect.testing.DerivedCollectionGenerators.ForwardingTestMapGenerator;
026import com.google.common.collect.testing.DerivedCollectionGenerators.SortedMapSubmapTestMapGenerator;
027import com.google.common.collect.testing.features.Feature;
028import com.google.common.collect.testing.testers.NavigableMapNavigationTester;
029import java.util.ArrayList;
030import java.util.List;
031import java.util.Map;
032import java.util.Map.Entry;
033import java.util.NavigableMap;
034import java.util.SortedMap;
035import junit.framework.TestSuite;
036
037/**
038 * Creates, based on your criteria, a JUnit test suite that exhaustively tests a NavigableMap
039 * implementation.
040 */
041@GwtIncompatible
042public class NavigableMapTestSuiteBuilder<K, V> extends SortedMapTestSuiteBuilder<K, V> {
043  public static <K, V> NavigableMapTestSuiteBuilder<K, V> using(
044      TestSortedMapGenerator<K, V> generator) {
045    NavigableMapTestSuiteBuilder<K, V> result = new NavigableMapTestSuiteBuilder<>();
046    result.usingGenerator(generator);
047    return result;
048  }
049
050  @SuppressWarnings("rawtypes") // class literals
051  @Override
052  protected List<Class<? extends AbstractTester>> getTesters() {
053    List<Class<? extends AbstractTester>> testers = copyToList(super.getTesters());
054    testers.add(NavigableMapNavigationTester.class);
055    return testers;
056  }
057
058  @Override
059  protected List<TestSuite> createDerivedSuites(
060      FeatureSpecificTestSuiteBuilder<
061              ?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>>
062          parentBuilder) {
063    List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
064
065    if (!parentBuilder.getFeatures().contains(NoRecurse.DESCENDING)) {
066      derivedSuites.add(createDescendingSuite(parentBuilder));
067    }
068
069    if (!parentBuilder.getFeatures().contains(NoRecurse.SUBMAP)) {
070      // Other combinations are inherited from SortedMapTestSuiteBuilder.
071      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.NO_BOUND, Bound.INCLUSIVE));
072      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.NO_BOUND));
073      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.EXCLUSIVE));
074      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.INCLUSIVE));
075      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.INCLUSIVE));
076    }
077
078    return derivedSuites;
079  }
080
081  @Override
082  protected NavigableSetTestSuiteBuilder<K> createDerivedKeySetSuite(
083      TestSetGenerator<K> keySetGenerator) {
084    return NavigableSetTestSuiteBuilder.using((TestSortedSetGenerator<K>) keySetGenerator);
085  }
086
087  public static final class NavigableMapSubmapTestMapGenerator<K, V>
088      extends SortedMapSubmapTestMapGenerator<K, V> {
089    public NavigableMapSubmapTestMapGenerator(
090        TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
091      super(delegate, to, from);
092    }
093
094    @Override
095    NavigableMap<K, V> createSubMap(SortedMap<K, V> sortedMap, K firstExclusive, K lastExclusive) {
096      NavigableMap<K, V> map = (NavigableMap<K, V>) sortedMap;
097      if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) {
098        return map.headMap(lastInclusive, true);
099      } else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) {
100        return map.tailMap(firstExclusive, false);
101      } else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) {
102        return map.subMap(firstExclusive, false, lastExclusive, false);
103      } else if (from == Bound.EXCLUSIVE && to == Bound.INCLUSIVE) {
104        return map.subMap(firstExclusive, false, lastInclusive, true);
105      } else if (from == Bound.INCLUSIVE && to == Bound.INCLUSIVE) {
106        return map.subMap(firstInclusive, true, lastInclusive, true);
107      } else {
108        return (NavigableMap<K, V>) super.createSubMap(map, firstExclusive, lastExclusive);
109      }
110    }
111  }
112
113  @Override
114  public NavigableMapTestSuiteBuilder<K, V> newBuilderUsing(
115      TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
116    return subSuiteUsing(new NavigableMapSubmapTestMapGenerator<K, V>(delegate, to, from));
117  }
118
119  /** Create a suite whose maps are descending views of other maps. */
120  private TestSuite createDescendingSuite(
121      FeatureSpecificTestSuiteBuilder<
122              ?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>>
123          parentBuilder) {
124    TestSortedMapGenerator<K, V> delegate =
125        (TestSortedMapGenerator<K, V>) parentBuilder.getSubjectGenerator().getInnerGenerator();
126
127    List<Feature<?>> features = new ArrayList<>();
128    features.add(NoRecurse.DESCENDING);
129    features.addAll(parentBuilder.getFeatures());
130
131    return subSuiteUsing(new DescendingTestMapGenerator<K, V>(delegate))
132        .named(parentBuilder.getName() + " descending")
133        .withFeatures(features)
134        .suppressing(parentBuilder.getSuppressedTests())
135        .createTestSuite();
136  }
137
138  NavigableMapTestSuiteBuilder<K, V> subSuiteUsing(TestSortedMapGenerator<K, V> generator) {
139    return using(generator);
140  }
141
142  static class DescendingTestMapGenerator<K, V> extends ForwardingTestMapGenerator<K, V>
143      implements TestSortedMapGenerator<K, V> {
144    DescendingTestMapGenerator(TestSortedMapGenerator<K, V> delegate) {
145      super(delegate);
146    }
147
148    @Override
149    public NavigableMap<K, V> create(Object... entries) {
150      NavigableMap<K, V> map = (NavigableMap<K, V>) delegate.create(entries);
151      return map.descendingMap();
152    }
153
154    @Override
155    public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
156      insertionOrder = castOrCopyToList(delegate.order(insertionOrder));
157      reverse(insertionOrder);
158      return insertionOrder;
159    }
160
161    TestSortedMapGenerator<K, V> delegate() {
162      return (TestSortedMapGenerator<K, V>) delegate;
163    }
164
165    @Override
166    public Entry<K, V> belowSamplesLesser() {
167      return delegate().aboveSamplesGreater();
168    }
169
170    @Override
171    public Entry<K, V> belowSamplesGreater() {
172      return delegate().aboveSamplesLesser();
173    }
174
175    @Override
176    public Entry<K, V> aboveSamplesLesser() {
177      return delegate().belowSamplesGreater();
178    }
179
180    @Override
181    public Entry<K, V> aboveSamplesGreater() {
182      return delegate().belowSamplesLesser();
183    }
184  }
185}