Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2008 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.google.common.collect.testing;
 
 import static com.google.common.collect.testing.Helpers.castOrCopyToList;
 import static com.google.common.collect.testing.Helpers.equal;
 import static com.google.common.collect.testing.Helpers.mapEntry;
 import static java.util.Collections.sort;
 
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
Derived suite generators, split out of the suite builders so that they are available to GWT.

Author(s):
George van den Driessche
 
 public final class DerivedCollectionGenerators {
   public static class MapEntrySetGenerator<K, V>
       implements TestSetGenerator<Map.Entry<K, V>>, DerivedGenerator {
     private final OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>>
         mapGenerator;
 
     public MapEntrySetGenerator(
             Map<K, V>, Map.Entry<K, V>> mapGenerator) {
       this. = mapGenerator;
     }
 
     @Override
     public SampleElements<Map.Entry<K, V>> samples() {
       return .samples();
     }
 
     @Override
     public Set<Map.Entry<K, V>> create(Object... elements) {
       return .create(elements).entrySet();
     }
 
     @Override
     public Map.Entry<K, V>[] createArray(int length) {
       return .createArray(length);
     }
 
     @Override
     public Iterable<Map.Entry<K, V>> order(
         List<Map.Entry<K, V>> insertionOrder) {
       return .order(insertionOrder);
     }
 
     @Override
     public OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>> getInnerGenerator() {
       return ;
     }
   }
 
   // TODO: investigate some API changes to SampleElements that would tidy up
   // parts of the following classes.
 
   static <K, V> TestSetGenerator<K> keySetGenerator(
       OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>> mapGenerator) {
     TestContainerGenerator<Map<K, V>, Entry<K, V>> generator = mapGenerator.getInnerGenerator();
     if (generator instanceof TestSortedMapGenerator
         && ((TestSortedMapGenerator<K, V>) generator).create().keySet() instanceof SortedSet) {
       return new MapSortedKeySetGenerator<K, V>(mapGenerator);
     } else {
       return new MapKeySetGenerator<K, V>(mapGenerator);
     }
   }
 
   public static class MapKeySetGenerator<K, V>
       implements TestSetGenerator<K>, DerivedGenerator {
     private final OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>>
        mapGenerator;
    private final SampleElements<K> samples;
    public MapKeySetGenerator(
        OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>>
            mapGenerator) {
      this. = mapGenerator;
      final SampleElements<Map.Entry<K, V>> mapSamples =
          this..samples();
      this. = new SampleElements<K>(
          mapSamples.e0.getKey(),
          mapSamples.e1.getKey(),
          mapSamples.e2.getKey(),
          mapSamples.e3.getKey(),
          mapSamples.e4.getKey());
    }
    @Override
    public SampleElements<K> samples() {
      return ;
    }
    @Override
    public Set<K> create(Object... elements) {
      @SuppressWarnings("unchecked")
      K[] keysArray = (K[]) elements;
      // Start with a suitably shaped collection of entries
      Collection<Map.Entry<K, V>> originalEntries =
          .getSampleElements(elements.length);
      // Create a copy of that, with the desired value for each key
      Collection<Map.Entry<K, V>> entries =
          new ArrayList<Entry<K, V>>(elements.length);
      int i = 0;
      for (Map.Entry<K, V> entry : originalEntries) {
        entries.add(Helpers.mapEntry(keysArray[i++], entry.getValue()));
      }
      return .create(entries.toArray()).keySet();
    }
    @Override
    public K[] createArray(int length) {
      // TODO: with appropriate refactoring of OneSizeGenerator, we can perhaps
      // tidy this up and get rid of the casts here and in
      // MapValueCollectionGenerator.
      return ((TestMapGenerator<K, V>) .getInnerGenerator())
          .createKeyArray(length);
    }
    @Override
    public Iterable<K> order(List<K> insertionOrder) {
      V v = ((TestMapGenerator<K, V>) .getInnerGenerator()).samples()..getValue();
      List<Entry<K, V>> entries = new ArrayList<Entry<K, V>>();
      for (K element : insertionOrder) {
        entries.add(mapEntry(elementv));
      }
      List<K> keys = new ArrayList<K>();
      for (Entry<K, V> entry : .order(entries)) {
        keys.add(entry.getKey());
      }
      return keys;
    }
    @Override
    public OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>> getInnerGenerator() {
      return ;
    }
  }
  
  public static class MapSortedKeySetGenerator<K, V> extends MapKeySetGenerator<K, V>
      implements TestSortedSetGenerator<K>, DerivedGenerator {
    private final TestSortedMapGenerator<K, V> delegate;
    
        OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>> mapGenerator) {
      super(mapGenerator);
      this. = (TestSortedMapGenerator<K, V>) mapGenerator.getInnerGenerator();
    }
    @Override
    public SortedSet<K> create(Object... elements) {
      return (SortedSet<K>) super.create(elements);
    }
    @Override
    public K belowSamplesLesser() {
      return .belowSamplesLesser().getKey();
    }
    @Override
    public K belowSamplesGreater() {
      return .belowSamplesGreater().getKey();
    }
    @Override
    public K aboveSamplesLesser() {
      return .aboveSamplesLesser().getKey();
    }
    @Override
    public K aboveSamplesGreater() {
      return .aboveSamplesGreater().getKey();
    }
    
  }
  public static class MapValueCollectionGenerator<K, V>
      implements TestCollectionGenerator<V>, DerivedGenerator {
    private final OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>>
        mapGenerator;
    private final SampleElements<V> samples;
            Map<K, V>, Map.Entry<K, V>> mapGenerator) {
      this. = mapGenerator;
      final SampleElements<Map.Entry<K, V>> mapSamples =
          this..samples();
      this. = new SampleElements<V>(
          mapSamples.e0.getValue(),
          mapSamples.e1.getValue(),
          mapSamples.e2.getValue(),
          mapSamples.e3.getValue(),
          mapSamples.e4.getValue());
    }
    @Override
    public SampleElements<V> samples() {
      return ;
    }
    @Override
    public Collection<V> create(Object... elements) {
      @SuppressWarnings("unchecked")
      V[] valuesArray = (V[]) elements;
      // Start with a suitably shaped collection of entries
      Collection<Map.Entry<K, V>> originalEntries =
          .getSampleElements(elements.length);
      // Create a copy of that, with the desired value for each value
      Collection<Map.Entry<K, V>> entries =
          new ArrayList<Entry<K, V>>(elements.length);
      int i = 0;
      for (Map.Entry<K, V> entry : originalEntries) {
        entries.add(Helpers.mapEntry(entry.getKey(), valuesArray[i++]));
      }
      return .create(entries.toArray()).values();
    }
    @Override
    public V[] createArray(int length) {
      //noinspection UnnecessaryLocalVariable
      final V[] vs = ((TestMapGenerator<K, V>) .getInnerGenerator())
          .createValueArray(length);
      return vs;
    }
    @Override
    public Iterable<V> order(List<V> insertionOrder) {
      final List<Entry<K, V>> orderedEntries =
              .getSampleElements(5))));
      sort(insertionOrdernew Comparator<V>() {
        @Override public int compare(V left, V right) {
          // The indexes are small enough for the subtraction trick to be safe.
          return indexOfEntryWithValue(left) - indexOfEntryWithValue(right);
        }
        int indexOfEntryWithValue(V value) {
          for (int i = 0; i < orderedEntries.size(); i++) {
            if (equal(orderedEntries.get(i).getValue(), value)) {
              return i;
            }
          }
          throw new IllegalArgumentException("Map.values generator can order only sample values");
        }
      });
      return insertionOrder;
    }
    @Override
    public OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>> getInnerGenerator() {
      return ;
    }
  }
  // TODO(cpovirk): could something like this be used elsewhere, e.g., ReserializedListGenerator?
  static class ForwardingTestMapGenerator<K, V> implements TestMapGenerator<K, V> {
    TestMapGenerator<K, V> delegate;
    ForwardingTestMapGenerator(TestMapGenerator<K, V> delegate) {
      this. = delegate;
    }
    @Override
    public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
      return .order(insertionOrder);
    }
    @Override
    public K[] createKeyArray(int length) {
      return .createKeyArray(length);
    }
    @Override
    public V[] createValueArray(int length) {
      return .createValueArray(length);
    }
    @Override
    public SampleElements<Entry<K, V>> samples() {
      return .samples();
    }
    @Override
    public Map<K, V> create(Object... elements) {
      return .create(elements);
    }
    @Override
    public Entry<K, V>[] createArray(int length) {
      return .createArray(length);
    }
  }

  
Two bounds (from and to) define how to build a subMap.
  public enum Bound {
    INCLUSIVE,
    EXCLUSIVE,
    NO_BOUND;
  }
  
  public static class SortedSetSubsetTestSetGenerator<E>
      implements TestSortedSetGenerator<E> {
    final Bound to;
    final Bound from;
    final E firstInclusive;
    final E lastInclusive;
    private final Comparator<? super E> comparator;
    private final TestSortedSetGenerator<E> delegate;
    
        TestSortedSetGenerator<E> delegateBound toBound from) {
      this. = to;
      this. = from;
      this. = delegate;
      
      SortedSet<E> emptySet = delegate.create();
      this. = emptySet.comparator();
      
      SampleElements<E> samples = delegate.samples();
      List<E> samplesList = new ArrayList<E>(samples.asList());
      Collections.sort(samplesList);
      this. = samplesList.get(0);
      this. = samplesList.get(samplesList.size() - 1);
    }
    public final TestSortedSetGenerator<E> getInnerGenerator() {
      return ;
    }
    public final Bound getTo() {
      return ;
    }
    public final Bound getFrom() {
      return ;
    }
    @Override
    public SampleElements<E> samples() {
      return .samples();
    }
    @Override
    public E[] createArray(int length) {
      return .createArray(length);
    }
    @Override
    public Iterable<E> order(List<E> insertionOrder) {
      return .order(insertionOrder);
    }
    @Override
    public SortedSet<E> create(Object... elements) {
      @SuppressWarnings("unchecked"// set generators must pass SampleElements values
      List<E> normalValues = (List) Arrays.asList(elements);
      List<E> extremeValues = new ArrayList<E>();
      
      // nulls are usually out of bounds for a subset, so ban them altogether
      for (Object o : elements) {
        if (o == null) {
          throw new NullPointerException();
        }
      }
      // prepare extreme values to be filtered out of view
      E firstExclusive = .belowSamplesGreater();
      E lastExclusive = .aboveSamplesLesser();
      if ( != .) {
        extremeValues.add(.belowSamplesLesser());
        extremeValues.add(.belowSamplesGreater());
      }
      if ( != .) {
        extremeValues.add(.aboveSamplesLesser());
        extremeValues.add(.aboveSamplesGreater());
      }
      // the regular values should be visible after filtering
      List<E> allEntries = new ArrayList<E>();
      allEntries.addAll(extremeValues);
      allEntries.addAll(normalValues);
      SortedSet<E> map = .create(allEntries.toArray());
      return createSubSet(mapfirstExclusivelastExclusive);
    }

    
Calls the smallest subSet overload that filters out the extreme values.
    SortedSet<E> createSubSet(SortedSet<E> set, E firstExclusive, E lastExclusive) {
      if ( == . &&  == .) {
        return set.headSet(lastExclusive);
      } else if ( == . &&  == .) {
        return set.tailSet();
      } else if ( == . &&  == .) {
        return set.subSet(lastExclusive);
      } else {
        throw new IllegalArgumentException();
      }
    }
    @Override
    public E belowSamplesLesser() {
      throw new UnsupportedOperationException();
    }
    @Override
    public E belowSamplesGreater() {
      throw new UnsupportedOperationException();
    }
    @Override
    public E aboveSamplesLesser() {
      throw new UnsupportedOperationException();
    }
    @Override
    public E aboveSamplesGreater() {
      throw new UnsupportedOperationException();
    }
  }
  /*
   * TODO(cpovirk): surely we can find a less ugly solution than a class that accepts 3 parameters,
   * exposes as many getters, does work in the constructor, and has both a superclass and a subclass
   */
  public static class SortedMapSubmapTestMapGenerator<K, V>
      extends ForwardingTestMapGenerator<K, V> implements TestSortedMapGenerator<K, V> {
    final Bound to;
    final Bound from;
    final K firstInclusive;
    final K lastInclusive;
    private final Comparator<Entry<K, V>> entryComparator;
        TestSortedMapGenerator<K, V> delegateBound toBound from) {
      super(delegate);
      this. = to;
      this. = from;
      SortedMap<K, V> emptyMap = delegate.create();
      this. = Helpers.entryComparator(emptyMap.comparator());
      // derive values for inclusive filtering from the input samples
      SampleElements<Entry<K, V>> samples = delegate.samples();
      @SuppressWarnings("unchecked"// no elements are inserted into the array
      List<Entry<K, V>> samplesList = Arrays.asList(
          samples.e0samples.e1samples.e2samples.e3samples.e4);
      Collections.sort(samplesList);
      this. = samplesList.get(0).getKey();
      this. = samplesList.get(samplesList.size() - 1).getKey();
    }
    @Override public SortedMap<K, V> create(Object... entries) {
      @SuppressWarnings("unchecked"// map generators must past entry objects
      List<Entry<K, V>> normalValues = (List) Arrays.asList(entries);
      List<Entry<K, V>> extremeValues = new ArrayList<Entry<K, V>>();
      // prepare extreme values to be filtered out of view
      K firstExclusive = getInnerGenerator().belowSamplesGreater().getKey();
      K lastExclusive = getInnerGenerator().aboveSamplesLesser().getKey();
      if ( != .) {
        extremeValues.add(getInnerGenerator().belowSamplesLesser());
        extremeValues.add(getInnerGenerator().belowSamplesGreater());
      }
      if ( != .) {
        extremeValues.add(getInnerGenerator().aboveSamplesLesser());
        extremeValues.add(getInnerGenerator().aboveSamplesGreater());
      }
      // the regular values should be visible after filtering
      List<Entry<K, V>> allEntries = new ArrayList<Entry<K, V>>();
      allEntries.addAll(extremeValues);
      allEntries.addAll(normalValues);
      SortedMap<K, V> map = (SortedMap<K, V>)
          .create((Object[])
              allEntries.toArray(new Entry<?, ?>[allEntries.size()]));
      return createSubMap(mapfirstExclusivelastExclusive);
    }

    
Calls the smallest subMap overload that filters out the extreme values. This method is overridden in NavigableMapTestSuiteBuilder.
    SortedMap<K, V> createSubMap(SortedMap<K, V> map, K firstExclusive, K lastExclusive) {
      if ( == . &&  == .) {
        return map.headMap(lastExclusive);
      } else if ( == . &&  == .) {
        return map.tailMap();
      } else if ( == . &&  == .) {
        return map.subMap(lastExclusive);
      } else {
        throw new IllegalArgumentException();
      }
    }
    public final Bound getTo() {
      return ;
    }
    public final Bound getFrom() {
      return ;
    }
    public final TestSortedMapGenerator<K, V> getInnerGenerator() {
      return (TestSortedMapGenerator<K, V>) ;
    }
    @Override
    public Entry<K, V> belowSamplesLesser() {
      // should never reach here!
      throw new UnsupportedOperationException();
    }
    @Override
    public Entry<K, V> belowSamplesGreater() {
      // should never reach here!
      throw new UnsupportedOperationException();
    }
    @Override
    public Entry<K, V> aboveSamplesLesser() {
      // should never reach here!
      throw new UnsupportedOperationException();
    }
    @Override
    public Entry<K, V> aboveSamplesGreater() {
      // should never reach here!
      throw new UnsupportedOperationException();
    }
  }
New to GrepCode? Check out our FAQ X