Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2012 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.google;
 
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

Derived suite generators for Guava collection interfaces, split out of the suite builders so that they are available to GWT.

Author(s):
Louis Wasserman
 
 public final class DerivedGoogleCollectionGenerators {
   public static class MapGenerator<K, V> implements TestMapGenerator<K, V>, DerivedGenerator {
 
     private final OneSizeTestContainerGenerator<BiMap<K, V>, Entry<K, V>> generator;
 
     public MapGenerator(
         OneSizeTestContainerGenerator<BiMap<K, V>, Entry<K, V>> oneSizeTestContainerGenerator) {
       this. = oneSizeTestContainerGenerator;
     }
 
     @Override
     public SampleElements<Map.Entry<K, V>> samples() {
       return .samples();
     }
 
     @Override
     public Map<K, V> create(Object... elements) {
       return .create(elements);
     }
 
     @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);
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public K[] createKeyArray(int length) {
       return (K[]) new Object[length];
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public V[] createValueArray(int length) {
       return (V[]) new Object[length];
     }
 
     public TestSubjectGenerator<?> getInnerGenerator() {
       return ;
     }
   }
 
   public static class InverseBiMapGenerator<K, V>
       implements TestBiMapGenerator<V, K>, DerivedGenerator {
 
     private final OneSizeTestContainerGenerator<BiMap<K, V>, Entry<K, V>> generator;
 
     public InverseBiMapGenerator(
         OneSizeTestContainerGenerator<BiMap<K, V>, Entry<K, V>> oneSizeTestContainerGenerator) {
       this. = oneSizeTestContainerGenerator;
     }
 
    @Override
    public SampleElements<Map.Entry<V, K>> samples() {
      SampleElements<Entry<K, V>> samples = .samples();
      return new SampleElements<Map.Entry<V, K>>(reverse(samples.e0), reverse(samples.e1),
          reverse(samples.e2), reverse(samples.e3), reverse(samples.e4));
    }
    private Map.Entry<V, K> reverse(Map.Entry<K, V> entry) {
      return Helpers.mapEntry(entry.getValue(), entry.getKey());
    }
    @SuppressWarnings("unchecked")
    @Override
    public BiMap<V, K> create(Object... elements) {
      Entry<?, ?>[] entries = new Entry<?, ?>[elements.length];
      for (int i = 0; i < elements.lengthi++) {
        entries[i] = reverse((Entry<K, V>) elements[i]);
      }
      return .create((Object[]) entries).inverse();
    }
    @SuppressWarnings("unchecked")
    @Override
    public Map.Entry<V, K>[] createArray(int length) {
      return new Entry[length];
    }
    @Override
    public Iterable<Entry<V, K>> order(List<Entry<V, K>> insertionOrder) {
      return insertionOrder;
    }
    @SuppressWarnings("unchecked")
    @Override
    public V[] createKeyArray(int length) {
      return (V[]) new Object[length];
    }
    @SuppressWarnings("unchecked")
    @Override
    public K[] createValueArray(int length) {
      return (K[]) new Object[length];
    }
      return ;
    }
  }
  public static class BiMapValueSetGenerator<K, V>
      implements TestSetGenerator<V>, DerivedGenerator {
    private final OneSizeTestContainerGenerator<BiMap<K, V>, Map.Entry<K, V>>
        mapGenerator;
    private final SampleElements<V> samples;
    public BiMapValueSetGenerator(
        OneSizeTestContainerGenerator<BiMap<K, V>, 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 Set<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) {
      final V[] vs = ((TestBiMapGenerator<K, V>) .getInnerGenerator())
          .createValueArray(length);
      return vs;
    }
    @Override
    public Iterable<V> order(List<V> insertionOrder) {
      return insertionOrder;
    }
      return ;
    }
  }
New to GrepCode? Check out our FAQ X