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 @Override 049 protected List<Class<? extends AbstractTester>> getTesters() { 050 List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters()); 051 testers.add(SortedMapNavigationTester.class); 052 return testers; 053 } 054 055 @Override 056 public TestSuite createTestSuite() { 057 if (!getFeatures().contains(KNOWN_ORDER)) { 058 List<Feature<?>> features = Helpers.copyToList(getFeatures()); 059 features.add(KNOWN_ORDER); 060 withFeatures(features); 061 } 062 return super.createTestSuite(); 063 } 064 065 @Override 066 protected List<TestSuite> createDerivedSuites( 067 FeatureSpecificTestSuiteBuilder< 068 ?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>> 069 parentBuilder) { 070 List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder); 071 072 if (!parentBuilder.getFeatures().contains(NoRecurse.SUBMAP)) { 073 derivedSuites.add(createSubmapSuite(parentBuilder, Bound.NO_BOUND, Bound.EXCLUSIVE)); 074 derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.NO_BOUND)); 075 derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.EXCLUSIVE)); 076 } 077 078 return derivedSuites; 079 } 080 081 @Override 082 protected SetTestSuiteBuilder<K> createDerivedKeySetSuite(TestSetGenerator<K> keySetGenerator) { 083 return keySetGenerator instanceof TestSortedSetGenerator 084 ? SortedSetTestSuiteBuilder.using((TestSortedSetGenerator<K>) keySetGenerator) 085 : SetTestSuiteBuilder.using(keySetGenerator); 086 } 087 088 /** 089 * To avoid infinite recursion, test suites with these marker features won't have derived suites 090 * created for them. 091 */ 092 enum NoRecurse implements Feature<@Nullable Void> { 093 SUBMAP, 094 DESCENDING; 095 096 @Override 097 public Set<Feature<? super @Nullable Void>> getImpliedFeatures() { 098 return Collections.emptySet(); 099 } 100 } 101 102 /** 103 * Creates a suite whose map has some elements filtered out of view. 104 * 105 * <p>Because the map may be ascending or descending, this test must derive the relative order of 106 * these extreme values rather than relying on their regular sort ordering. 107 */ 108 final TestSuite createSubmapSuite( 109 FeatureSpecificTestSuiteBuilder< 110 ?, ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>> 111 parentBuilder, 112 Bound from, 113 Bound to) { 114 TestSortedMapGenerator<K, V> delegate = 115 (TestSortedMapGenerator<K, V>) parentBuilder.getSubjectGenerator().getInnerGenerator(); 116 117 List<Feature<?>> features = new ArrayList<>(); 118 features.add(NoRecurse.SUBMAP); 119 features.addAll(parentBuilder.getFeatures()); 120 121 return newBuilderUsing(delegate, to, from) 122 .named(parentBuilder.getName() + " subMap " + from + "-" + to) 123 .withFeatures(features) 124 .suppressing(parentBuilder.getSuppressedTests()) 125 .withSetUp(parentBuilder.getSetUp()) 126 .withTearDown(parentBuilder.getTearDown()) 127 .createTestSuite(); 128 } 129 130 /** Like using() but overrideable by NavigableMapTestSuiteBuilder. */ 131 SortedMapTestSuiteBuilder<K, V> newBuilderUsing( 132 TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) { 133 return using(new SortedMapSubmapTestMapGenerator<K, V>(delegate, to, from)); 134 } 135}