Home | History | Annotate | Download | only in testing 
      1 /*
      2  * Copyright (C) 2010 The Guava Authors
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  * http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.google.common.collect.testing;
     18 
     19 import static com.google.common.collect.testing.Helpers.castOrCopyToList;
     20 import static java.util.Collections.reverse;
     21 
     22 import com.google.common.collect.testing.DerivedCollectionGenerators.Bound;
     23 import com.google.common.collect.testing.DerivedCollectionGenerators.SortedMapSubmapTestMapGenerator;
     24 import com.google.common.collect.testing.features.Feature;
     25 import com.google.common.collect.testing.testers.NavigableMapNavigationTester;
     26 
     27 import junit.framework.TestSuite;
     28 
     29 import java.util.ArrayList;
     30 import java.util.List;
     31 import java.util.Map;
     32 import java.util.Map.Entry;
     33 import java.util.NavigableMap;
     34 import java.util.SortedMap;
     35 
     36 /**
     37  * Creates, based on your criteria, a JUnit test suite that exhaustively tests
     38  * a NavigableMap implementation.
     39  */
     40 public class NavigableMapTestSuiteBuilder<K, V> extends SortedMapTestSuiteBuilder<K, V> {
     41   public static <K, V> NavigableMapTestSuiteBuilder<K, V> using(
     42       TestSortedMapGenerator<K, V> generator) {
     43     NavigableMapTestSuiteBuilder<K, V> result = new NavigableMapTestSuiteBuilder<K, V>();
     44     result.usingGenerator(generator);
     45     return result;
     46   }
     47 
     48   @Override protected List<Class<? extends AbstractTester>> getTesters() {
     49     List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
     50     testers.add(NavigableMapNavigationTester.class);
     51     return testers;
     52   }
     53 
     54   @Override
     55   protected List<TestSuite> createDerivedSuites(FeatureSpecificTestSuiteBuilder<?,
     56       ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>> parentBuilder) {
     57     List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
     58 
     59     if (!parentBuilder.getFeatures().contains(NoRecurse.DESCENDING)) {
     60       derivedSuites.add(createDescendingSuite(parentBuilder));
     61     }
     62 
     63     if (!parentBuilder.getFeatures().contains(NoRecurse.SUBMAP)) {
     64       // Other combinations are inherited from SortedMapTestSuiteBuilder.
     65       derivedSuites.add(createSubmapSuite(parentBuilder, Bound.NO_BOUND, Bound.INCLUSIVE));
     66       derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.NO_BOUND));
     67       derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.EXCLUSIVE));
     68       derivedSuites.add(createSubmapSuite(parentBuilder, Bound.EXCLUSIVE, Bound.INCLUSIVE));
     69       derivedSuites.add(createSubmapSuite(parentBuilder, Bound.INCLUSIVE, Bound.INCLUSIVE));
     70     }
     71 
     72     return derivedSuites;
     73   }
     74 
     75   @Override protected NavigableSetTestSuiteBuilder<K> createDerivedKeySetSuite(
     76       TestSetGenerator<K> keySetGenerator) {
     77     return NavigableSetTestSuiteBuilder.using((TestSortedSetGenerator<K>) keySetGenerator);
     78   }
     79 
     80   public static final class NavigableMapSubmapTestMapGenerator<K, V>
     81       extends SortedMapSubmapTestMapGenerator<K, V> {
     82     public NavigableMapSubmapTestMapGenerator(
     83         TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
     84       super(delegate, to, from);
     85     }
     86 
     87     @Override NavigableMap<K, V> createSubMap(SortedMap<K, V> sortedMap, K firstExclusive,
     88         K lastExclusive) {
     89       NavigableMap<K, V> map = (NavigableMap<K, V>) sortedMap;
     90       if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) {
     91         return map.headMap(lastInclusive, true);
     92       } else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) {
     93         return map.tailMap(firstExclusive, false);
     94       } else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) {
     95         return map.subMap(firstExclusive, false, lastExclusive, false);
     96       } else if (from == Bound.EXCLUSIVE && to == Bound.INCLUSIVE) {
     97         return map.subMap(firstExclusive, false, lastInclusive, true);
     98       } else if (from == Bound.INCLUSIVE && to == Bound.INCLUSIVE) {
     99         return map.subMap(firstInclusive, true, lastInclusive, true);
    100       } else {
    101         return (NavigableMap<K, V>) super.createSubMap(map, firstExclusive, lastExclusive);
    102       }
    103     }
    104   }
    105 
    106   @Override
    107   public NavigableMapTestSuiteBuilder<K, V> newBuilderUsing(
    108       TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
    109     return using(new NavigableMapSubmapTestMapGenerator<K, V>(delegate, to, from));
    110   }
    111 
    112   /**
    113    * Create a suite whose maps are descending views of other maps.
    114    */
    115   private TestSuite createDescendingSuite(final FeatureSpecificTestSuiteBuilder<?,
    116           ? extends OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>>> parentBuilder) {
    117     final TestMapGenerator<K, V> delegate
    118         = (TestMapGenerator<K, V>) parentBuilder.getSubjectGenerator().getInnerGenerator();
    119 
    120     List<Feature<?>> features = new ArrayList<Feature<?>>();
    121     features.add(NoRecurse.DESCENDING);
    122     features.addAll(parentBuilder.getFeatures());
    123 
    124     return NavigableMapTestSuiteBuilder
    125         .using(new ForwardingTestMapGenerator<K, V>(delegate) {
    126           @Override public Map<K, V> create(Object... entries) {
    127             NavigableMap<K, V> map = (NavigableMap<K, V>) delegate.create(entries);
    128             return map.descendingMap();
    129           }
    130 
    131           @Override
    132           public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
    133             insertionOrder = castOrCopyToList(delegate.order(insertionOrder));
    134             reverse(insertionOrder);
    135             return insertionOrder;
    136           }
    137         })
    138         .named(parentBuilder.getName() + " descending")
    139         .withFeatures(features)
    140         .suppressing(parentBuilder.getSuppressedTests())
    141         .createTestSuite();
    142   }
    143 
    144   static class ForwardingTestMapGenerator<K, V> implements TestMapGenerator<K, V> {
    145     private TestMapGenerator<K, V> delegate;
    146 
    147     ForwardingTestMapGenerator(TestMapGenerator<K, V> delegate) {
    148       this.delegate = delegate;
    149     }
    150 
    151     @Override
    152     public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
    153       return delegate.order(insertionOrder);
    154     }
    155 
    156     @Override
    157     public K[] createKeyArray(int length) {
    158       return delegate.createKeyArray(length);
    159     }
    160 
    161     @Override
    162     public V[] createValueArray(int length) {
    163       return delegate.createValueArray(length);
    164     }
    165 
    166     @Override
    167     public SampleElements<Entry<K, V>> samples() {
    168       return delegate.samples();
    169     }
    170 
    171     @Override
    172     public Map<K, V> create(Object... elements) {
    173       return delegate.create(elements);
    174     }
    175 
    176     @Override
    177     public Entry<K, V>[] createArray(int length) {
    178       return delegate.createArray(length);
    179     }
    180   }
    181 }
    182