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.features.CollectionFeature.KNOWN_ORDER;
020
021import com.google.common.annotations.GwtIncompatible;
022import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
023import com.google.common.collect.testing.DerivedCollectionGenerators.SortedMapSubmapTestMapGenerator;
024import com.google.common.collect.testing.features.Feature;
025import com.google.common.collect.testing.testers.SortedMapNavigationTester;
026import java.util.ArrayList;
027import java.util.Collections;
028import java.util.List;
029import java.util.Map;
030import java.util.Map.Entry;
031import java.util.Set;
032import junit.framework.TestSuite;
033import org.checkerframework.checker.nullness.qual.Nullable;
034
035/**
036 * Creates, based on your criteria, a JUnit test suite that exhaustively tests a SortedMap
037 * implementation.
038 */
039@GwtIncompatible
040public class SortedMapTestSuiteBuilder<K, V> extends MapTestSuiteBuilder<K, V> {
041  public static <K, V> SortedMapTestSuiteBuilder<K, V> using(
042      TestSortedMapGenerator<K, V> generator) {
043    SortedMapTestSuiteBuilder<K, V> result = new SortedMapTestSuiteBuilder<>();
044    result.usingGenerator(generator);
045    return result;
046  }
047
048  @SuppressWarnings("rawtypes") // class literals
049  @Override
050  protected List<Class<? extends AbstractTester>> getTesters() {
051    List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
052    testers.add(SortedMapNavigationTester.class);
053    return testers;
054  }
055
056  @Override
057  public TestSuite createTestSuite() {
058    if (!getFeatures().contains(KNOWN_ORDER)) {
059      List<Feature<?>> features = Helpers.copyToList(getFeatures());
060      features.add(KNOWN_ORDER);
061      withFeatures(features);
062    }
063    return super.createTestSuite();
064  }
065
066  @Override
067  protected List<TestSuite> createDerivedSuites(
068      FeatureSpecificTestSuiteBuilder<
069              ?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>>
070          parentBuilder) {
071    List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
072
073    if (!parentBuilder.getFeatures().contains(NoRecurse.SUBMAP)) {
074      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.NO_BOUND, Bound.EXCLUSIVE));
075      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.NO_BOUND));
076      derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.EXCLUSIVE));
077    }
078
079    return derivedSuites;
080  }
081
082  @Override
083  protected SetTestSuiteBuilder<K> createDerivedKeySetSuite(TestSetGenerator<K> keySetGenerator) {
084    return keySetGenerator instanceof TestSortedSetGenerator
085        ? SortedSetTestSuiteBuilder.using((TestSortedSetGenerator<K>) keySetGenerator)
086        : SetTestSuiteBuilder.using(keySetGenerator);
087  }
088
089  /**
090   * To avoid infinite recursion, test suites with these marker features won't have derived suites
091   * created for them.
092   */
093  enum NoRecurse implements Feature<@Nullable Void> {
094    SUBMAP,
095    DESCENDING;
096
097    @Override
098    public Set<Feature<? super @Nullable Void>> getImpliedFeatures() {
099      return Collections.emptySet();
100    }
101  }
102
103  /**
104   * Creates a suite whose map has some elements filtered out of view.
105   *
106   * <p>Because the map may be ascending or descending, this test must derive the relative order of
107   * these extreme values rather than relying on their regular sort ordering.
108   */
109  final TestSuite createSubmapSuite(
110      FeatureSpecificTestSuiteBuilder<
111              ?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>>
112          parentBuilder,
113      Bound from,
114      Bound to) {
115    TestSortedMapGenerator<K, V> delegate =
116        (TestSortedMapGenerator<K, V>) parentBuilder.getSubjectGenerator().getInnerGenerator();
117
118    List<Feature<?>> features = new ArrayList<>();
119    features.add(NoRecurse.SUBMAP);
120    features.addAll(parentBuilder.getFeatures());
121
122    return newBuilderUsing(delegate, to, from)
123        .named(parentBuilder.getName() + " subMap " + from + "-" + to)
124        .withFeatures(features)
125        .suppressing(parentBuilder.getSuppressedTests())
126        .withSetUp(parentBuilder.getSetUp())
127        .withTearDown(parentBuilder.getTearDown())
128        .createTestSuite();
129  }
130
131  /** Like using() but overrideable by NavigableMapTestSuiteBuilder. */
132  SortedMapTestSuiteBuilder<K, V> newBuilderUsing(
133      TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
134    return using(new SortedMapSubmapTestMapGenerator<K, V>(delegate, to, from));
135  }
136}