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 java.util.Collections.reverse;
021
022import com.google.common.annotations.GwtIncompatible;
023import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
024import com.google.common.collect.testing.DerivedCollectionGenerators.ForwardingTestMapGenerator;
025import com.google.common.collect.testing.DerivedCollectionGenerators.SortedMapSubmapTestMapGenerator;
026import com.google.common.collect.testing.features.Feature;
027import com.google.common.collect.testing.testers.NavigableMapNavigationTester;
028import java.util.ArrayList;
029import java.util.List;
030import java.util.Map;
031import java.util.Map.Entry;
032import java.util.NavigableMap;
033import java.util.SortedMap;
034import junit.framework.TestSuite;
035
036/**
037 * Creates, based on your criteria, a JUnit test suite that exhaustively tests a NavigableMap
038 * implementation.
039 */
040@GwtIncompatible
041public class NavigableMapTestSuiteBuilder<K, V> extends SortedMapTestSuiteBuilder<K, V> {
042  public static <K, V> NavigableMapTestSuiteBuilder<K, V> using(
043      TestSortedMapGenerator<K, V> generator) {
044    NavigableMapTestSuiteBuilder<K, V> result = new NavigableMapTestSuiteBuilder<>();
045    result.usingGenerator(generator);
046    return result;
047  }
048
049  @SuppressWarnings("rawtypes") // class literals
050  @Override
051  protected List<Class<? extends AbstractTester>> getTesters() {
052    List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
053    testers.add(NavigableMapNavigationTester.class);
054    return testers;
055  }
056
057  @Override
058  protected List<TestSuite> createDerivedSuites(
059      FeatureSpecificTestSuiteBuilder<
060              ?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>>
061          parentBuilder) {
062    List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
063
064    if (!parentBuilder.getFeatures().contains(NoRecurse.DESCENDING)) {
065      derivedSuites.add(createDescendingSuite(parentBuilder));
066    }
067
068    if (!parentBuilder.getFeatures().contains(NoRecurse.SUBMAP)) {
069      // Other combinations are inherited from SortedMapTestSuiteBuilder.
070      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.NO_BOUND, Bound.INCLUSIVE));
071      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.NO_BOUND));
072      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.EXCLUSIVE));
073      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.INCLUSIVE));
074      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.INCLUSIVE));
075    }
076
077    return derivedSuites;
078  }
079
080  @Override
081  protected NavigableSetTestSuiteBuilder<K> createDerivedKeySetSuite(
082      TestSetGenerator<K> keySetGenerator) {
083    return NavigableSetTestSuiteBuilder.using((TestSortedSetGenerator<K>) keySetGenerator);
084  }
085
086  public static final class NavigableMapSubmapTestMapGenerator<K, V>
087      extends SortedMapSubmapTestMapGenerator<K, V> {
088    public NavigableMapSubmapTestMapGenerator(
089        TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
090      super(delegate, to, from);
091    }
092
093    @Override
094    NavigableMap<K, V> createSubMap(SortedMap<K, V> sortedMap, K firstExclusive, K lastExclusive) {
095      NavigableMap<K, V> map = (NavigableMap<K, V>) sortedMap;
096      if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) {
097        return map.headMap(lastInclusive, true);
098      } else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) {
099        return map.tailMap(firstExclusive, false);
100      } else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) {
101        return map.subMap(firstExclusive, false, lastExclusive, false);
102      } else if (from == Bound.EXCLUSIVE && to == Bound.INCLUSIVE) {
103        return map.subMap(firstExclusive, false, lastInclusive, true);
104      } else if (from == Bound.INCLUSIVE && to == Bound.INCLUSIVE) {
105        return map.subMap(firstInclusive, true, lastInclusive, true);
106      } else {
107        return (NavigableMap<K, V>) super.createSubMap(map, firstExclusive, lastExclusive);
108      }
109    }
110  }
111
112  @Override
113  public NavigableMapTestSuiteBuilder<K, V> newBuilderUsing(
114      TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
115    return subSuiteUsing(new NavigableMapSubmapTestMapGenerator<K, V>(delegate, to, from));
116  }
117
118  /** Create a suite whose maps are descending views of other maps. */
119  private TestSuite createDescendingSuite(
120      FeatureSpecificTestSuiteBuilder<
121              ?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>>
122          parentBuilder) {
123    TestSortedMapGenerator<K, V> delegate =
124        (TestSortedMapGenerator<K, V>) parentBuilder.getSubjectGenerator().getInnerGenerator();
125
126    List<Feature<?>> features = new ArrayList<>();
127    features.add(NoRecurse.DESCENDING);
128    features.addAll(parentBuilder.getFeatures());
129
130    return subSuiteUsing(new DescendingTestMapGenerator<K, V>(delegate))
131        .named(parentBuilder.getName() + " descending")
132        .withFeatures(features)
133        .suppressing(parentBuilder.getSuppressedTests())
134        .createTestSuite();
135  }
136
137  NavigableMapTestSuiteBuilder<K, V> subSuiteUsing(TestSortedMapGenerator<K, V> generator) {
138    return using(generator);
139  }
140
141  static class DescendingTestMapGenerator<K, V> extends ForwardingTestMapGenerator<K, V>
142      implements TestSortedMapGenerator<K, V> {
143    DescendingTestMapGenerator(TestSortedMapGenerator<K, V> delegate) {
144      super(delegate);
145    }
146
147    @Override
148    public NavigableMap<K, V> create(Object... entries) {
149      NavigableMap<K, V> map = (NavigableMap<K, V>) delegate.create(entries);
150      return map.descendingMap();
151    }
152
153    @Override
154    public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
155      insertionOrder = castOrCopyToList(delegate.order(insertionOrder));
156      reverse(insertionOrder);
157      return insertionOrder;
158    }
159
160    TestSortedMapGenerator<K, V> delegate() {
161      return (TestSortedMapGenerator<K, V>) delegate;
162    }
163
164    @Override
165    public Entry<K, V> belowSamplesLesser() {
166      return delegate().aboveSamplesGreater();
167    }
168
169    @Override
170    public Entry<K, V> belowSamplesGreater() {
171      return delegate().aboveSamplesLesser();
172    }
173
174    @Override
175    public Entry<K, V> aboveSamplesLesser() {
176      return delegate().belowSamplesGreater();
177    }
178
179    @Override
180    public Entry<K, V> aboveSamplesGreater() {
181      return delegate().belowSamplesLesser();
182    }
183  }
184}