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.testing;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 
 import java.io.File;
 import java.io.Reader;
import  javax.annotation.Nullable;

Generates fresh instances of types that are different from each other (if possible).

Author(s):
Ben Yu
  private static final ImmutableMap<Class<?>, MethodGENERATORS;
  static {
    ImmutableMap.Builder<Class<?>, Methodbuilder =
        ImmutableMap.builder();
    for (Method method : FreshValueGenerator.class.getDeclaredMethods()) {
      if (method.isAnnotationPresent(Generates.class)) {
        builder.put(method.getReturnType(), method);
      }
    }
     = builder.build();
  }
  private final AtomicInteger differentiator = new AtomicInteger(1);
  private final ListMultimap<Class<?>, ObjectsampleInstances = ArrayListMultimap.create();
  <T> void addSampleInstances(Class<T> typeIterable<? extends T> instances) {
    .putAll(checkNotNull(type), checkNotNull(instances));
  }

  
Returns a fresh instance for type if possible. The returned instance could be:
  • exactly of the given type, including generic type parameters, such as ImmutableList<String>;
  • of the raw type;
  • null if no fresh value can be generated.
  @Nullable final <T> T generate(TypeToken<T> type) {
    // Not completely safe since sample instances are registered by raw types.
    // But we assume the generic type parameters are mostly unimportant for these dummy values,
    // because what really matters are equals/hashCode.
    @SuppressWarnings("unchecked")
    T result = (T) generateIfPossible(type);
    return result;
  }
  @Nullable final <T> T generate(Class<T> type) {
    return generate(TypeToken.of(type));
  }
  @Nullable private Object generateIfPossible(TypeToken<?> type) {
    Class<?> rawType = type.getRawType();
    List<Objectsamples = .get(rawType);
    Object sample = nextInstance(samplesnull);
    if (sample != null) {
      return sample;
    }
    if (rawType.isEnum()) {
      return nextInstance(rawType.getEnumConstants(), null);
    }
    if (type.isArray()) {
      TypeToken<?> componentType = type.getComponentType();
      Object array = Array.newInstance(componentType.getRawType(), 1);
      Array.set(array, 0, generateIfPossible(componentType));
      return array;
    }
    Method generator = .get(rawType);
    if (generator != null) {
      ImmutableList<Parameterparams = Invokable.from(generator).getParameters();
      List<Objectargs = Lists.newArrayListWithCapacity(params.size());
      TypeVariable<?>[] typeVars = rawType.getTypeParameters();
      for (int i = 0; i < params.size(); i++) {
        TypeToken<?> paramType = type.resolveType(typeVars[i]);
        // We require all @Generates methods to either be parameter-less or accept non-null
        // fresh values for their generic parameter types.
        Object argValue = generateIfPossible(paramType);
        if (argValue == null) {
          return defaultGenerate(rawType);
        }
        args.add(argValue);
      }
      try {
        return generator.invoke(thisargs.toArray());
      } catch (InvocationTargetException e) {
        Throwables.propagate(e.getCause());
      } catch (Exception e) {
        throw Throwables.propagate(e);
      }
    }
    return defaultGenerate(rawType);
  }
  private Object defaultGenerate(Class<?> rawType) {
    if (rawType.isInterface()) {
      // always create a new proxy
      return newProxy(rawType);
    }
    return ArbitraryInstances.get(rawType);
  }
  final <T> T newProxy(final Class<T> interfaceType) {
    return Reflection.newProxy(interfaceTypenew FreshInvocationHandler(interfaceType));
  }
  private final class FreshInvocationHandler extends AbstractInvocationHandler {
    private final int identity = freshInt();
    private final Class<?> interfaceType;
    FreshInvocationHandler(Class<?> interfaceType) {
      this. = interfaceType;
    }
    @Override protected Object handleInvocation(Object proxyMethod methodObject[] args) {
      return interfaceMethodCalled(method);
    }
    @Override public int hashCode() {
      return ;
    }
    @Override public boolean equals(@Nullable Object obj) {
      if (obj instanceof FreshInvocationHandler) {
        FreshInvocationHandler that = (FreshInvocationHandlerobj;
        return  == that.identity;
      }
      return false;
    }
    @Override public String toString() {
      return paramString();
    }
  }

  
Subclasses can override to provide different return value for proxied interface methods.
      @SuppressWarnings("unused"Class<?> interfaceType,
      @SuppressWarnings("unused"Method method) {
    throw new UnsupportedOperationException();
  }
  private <T> T nextInstance(T[] instances, T defaultValue) {
    return nextInstance(Arrays.asList(instances), defaultValue);
  }
  private <T> T nextInstance(Collection<T> instances, T defaultValue) {
    if (instances.isEmpty()) {
      return defaultValue;
    }
    // freshInt() is 1-based.
    return Iterables.get(instances, (freshInt() - 1) % instances.size());
  }
  private static String paramString(Class<?> typeint i) {
    return type.getSimpleName() + '@' + i;
  }

  
Annotates a method to be the instance generator of a certain type. The return type is the generated type. The method parameters are non-null fresh values for each method type variable in the same type variable declaration order of the return type.
  private @interface Generates {}
  @Generates private Class<?> freshClass() {
    return nextInstance(
        ImmutableList.of(
            int.classlong.classvoid.class,
            Object.classObject[].classIterable.class),
        Object.class);
  }
  @Generates private Object freshObject() {
    return freshString();
  }
  @Generates private Number freshNumber() {
    return freshInt();
  }
  @Generates private int freshInt() {
  }
  @Generates private Integer freshInteger() {
    return new Integer(freshInt());
  }
  @Generates private long freshLong() {
    return freshInt();
  }
  @Generates private Long freshLongObject() {
    return new Long(freshLong());
  }
  @Generates private float freshFloat() {
    return freshInt();
  }
  @Generates private Float freshFloatObject() {
    return new Float(freshFloat());
  }
  @Generates private double freshDouble() {
    return freshInt();
  }
    return new Double(freshDouble());
  }
  @Generates private short freshShort() {
    return (shortfreshInt();
  }
  @Generates private Short freshShortObject() {
    return new Short(freshShort());
  }
  @Generates private byte freshByte() {
    return (bytefreshInt();
  }
  @Generates private Byte freshByteObject() {
    return new Byte(freshByte());
  }
  @Generates private char freshChar() {
    return freshString().charAt(0);
  }
    return new Character(freshChar());
  }
  @Generates private boolean freshBoolean() {
    return freshInt() % 2 == 0;
  }
    return new Boolean(freshBoolean());
  }
    return UnsignedInteger.fromIntBits(freshInt());
  }
    return UnsignedLong.fromLongBits(freshLong());
  }
    return BigInteger.valueOf(freshInt());
  }
    return BigDecimal.valueOf(freshInt());
  }
    return freshString();
  }
  @Generates private String freshString() {
    return Integer.toString(freshInt());
  }
  @Generates private Comparable<?> freshComparable() {
    return freshString();
  }
  @Generates private Pattern freshPattern() {
    return Pattern.compile(freshString());
  }
  @Generates private Charset freshCharset() {
    return nextInstance(Charset.availableCharsets().values(), .);
  }
  @Generates private Locale freshLocale() {
    return nextInstance(Locale.getAvailableLocales(), .);
  }
  @Generates private Currency freshCurrency() {
    for (Set<LocaleuselessLocales = Sets.newHashSet(); ; ) {
      Locale locale = freshLocale();
      if (uselessLocales.contains(locale)) { // exhausted all locales
        return Currency.getInstance(.);
      }
      try {
        return Currency.getInstance(locale);
      } catch (IllegalArgumentException e) {
        uselessLocales.add(locale);
      }
    }
  }
  // common.base
  @Generates private Joiner freshJoiner() {
    return Joiner.on(freshString());
  }
  @Generates private Splitter freshSplitter() {
    return Splitter.on(freshString());
  }
  @Generates private <T> Equivalence<T> freshEquivalence() {
    return new Equivalence<T>() {
      @Override protected boolean doEquivalent(T a, T b) {
        return false;
      }
      @Override protected int doHash(T t) {
        return 0;
      }
      final String string = paramString(Equivalence.classfreshInt());
      @Override public String toString() {
        return ;
      }
    };
  }
    return new CharMatcher() {
      @Override public boolean matches(char c) {
        return false;
      }
      final String string = paramString(CharMatcher.classfreshInt());
      @Override public String toString() {
        return ;
      }
    };
  }
  @Generates private Ticker freshTicker() {
    return new Ticker() {
      @Override public long read() {
        return 0;
      }
      final String string = paramString(Ticker.classfreshInt());
      @Override public String toString() {
        return ;
      }
    };
  }
  // collect
  @Generates private <T> Comparator<T> freshComparator() {
    return freshOrdering();
  }
  @Generates private <T> Ordering<T> freshOrdering() {
    return new Ordering<T>() {
      @Override public int compare(T left, T right) {
        return 0;
      }
      final String string = paramString(Ordering.classfreshInt());
      @Override public String toString() {
        return ;
      }
    };
  }
  @Generates static private <E> Iterable<E> freshIterable(E freshElement) {
    return freshList(freshElement);
  }
  @Generates static private <E> Collection<E> freshCollection(E freshElement) {
    return freshList(freshElement);
  }
  @Generates static private <E> List<E> freshList(E freshElement) {
    return freshArrayList(freshElement);
  }
  @Generates static private <E> ArrayList<E> freshArrayList(E freshElement) {
    ArrayList<E> list = Lists.newArrayList();
    list.add(freshElement);
    return list;
  }
  @Generates static private <E> LinkedList<E> freshLinkedList(E freshElement) {
    LinkedList<E> list = Lists.newLinkedList();
    list.add(freshElement);
    return list;
  }
  @Generates static private <E> ImmutableList<E> freshImmutableList(E freshElement) {
    return ImmutableList.of(freshElement);
  }
  @Generates static private <E> ImmutableCollection<E> freshImmutableCollection(E freshElement) {
    return freshImmutableList(freshElement);
  }
  @Generates static private <E> Set<E> freshSet(E freshElement) {
    return freshHashSet(freshElement);
  }
  @Generates static private <E> HashSet<E> freshHashSet(E freshElement) {
    return freshLinkedHashSet(freshElement);
  }
  @Generates static private <E> LinkedHashSet<E> freshLinkedHashSet(E freshElement) {
    LinkedHashSet<E> set = Sets.newLinkedHashSet();
    set.add(freshElement);
    return set;
  }
  @Generates static private <E> ImmutableSet<E> freshImmutableSet(E freshElement) {
    return ImmutableSet.of(freshElement);
  }
  @Generates static private <E extends Comparable<? super E>> SortedSet<E>
      freshSortedSet(E freshElement) {
    return freshTreeSet(freshElement);
  }
  @Generates static private <E extends Comparable<? super E>> TreeSet<E> freshTreeSet(
      E freshElement) {
    TreeSet<E> set = Sets.newTreeSet();
    set.add(freshElement);
    return set;
  }
  @Generates static private <E extends Comparable<? super E>> ImmutableSortedSet<E>
      freshImmutableSortedSet(E freshElement) {
    return ImmutableSortedSet.of(freshElement);
  }
  @Generates static private <E> Multiset<E> freshMultiset(E freshElement) {
    return freshHashMultiset(freshElement);
  }
  @Generates static private <E> HashMultiset<E> freshHashMultiset(E freshElement) {
    HashMultiset<E> multiset = HashMultiset.create();
    multiset.add(freshElement);
    return multiset;
  }
  @Generates static private <E> LinkedHashMultiset<E> freshLinkedHashMultiset(E freshElement) {
    LinkedHashMultiset<E> multiset = LinkedHashMultiset.create();
    multiset.add(freshElement);
    return multiset;
  }
  @Generates static private <E> ImmutableMultiset<E> freshImmutableMultiset(E freshElement) {
    return ImmutableMultiset.of(freshElement);
  }
  @Generates static private <E extends Comparable<E>> SortedMultiset<E> freshSortedMultiset(
      E freshElement) {
    return freshTreeMultiset(freshElement);
  }
  @Generates static private <E extends Comparable<E>> TreeMultiset<E> freshTreeMultiset(
      E freshElement) {
    TreeMultiset<E> multiset = TreeMultiset.create();
    multiset.add(freshElement);
    return multiset;
  }
  @Generates static private <E extends Comparable<E>> ImmutableSortedMultiset<E>
      freshImmutableSortedMultiset(E freshElement) {
    return ImmutableSortedMultiset.of(freshElement);
  }
  @Generates static private <K, V> Map<K, V> freshMap(K key, V value) {
    return freshHashdMap(keyvalue);
  }
  @Generates static private <K, V> HashMap<K, V> freshHashdMap(K key, V value) {
    return freshLinkedHashMap(keyvalue);
  }
  @Generates static private <K, V> LinkedHashMap<K, V> freshLinkedHashMap(K key, V value) {
    LinkedHashMap<K, V> map = Maps.newLinkedHashMap();
    map.put(keyvalue);
    return map;
  }
  @Generates static private <K, V> ImmutableMap<K, V> freshImmutableMap(K key, V value) {
    return ImmutableMap.of(keyvalue);
  }
  @Generates static private <K, V> ConcurrentMap<K, V> freshConcurrentMap(K key, V value) {
    ConcurrentMap<K, V> map = Maps.newConcurrentMap();
    map.put(keyvalue);
    return map;
  }
  @Generates static private <K extends Comparable<? super K>, V> SortedMap<K, V>
      freshSortedMap(K key, V value) {
    return freshTreeMap(keyvalue);
  }
  @Generates static private <K extends Comparable<? super K>, V> TreeMap<K, V> freshTreeMap(
      K key, V value) {
    TreeMap<K, V> map = Maps.newTreeMap();
    map.put(keyvalue);
    return map;
  }
  @Generates static private <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V>
      freshImmutableSortedMap(K key, V value) {
    return ImmutableSortedMap.of(keyvalue);
  }
  @Generates static private <K, V> Multimap<K, V> freshMultimap(K key, V value) {
    return freshListMultimap(keyvalue);
  }
  @Generates static private <K, V> ImmutableMultimap<K, V> freshImmutableMultimap(K key, V value) {
    return ImmutableMultimap.of(keyvalue);
  }
  @Generates static private <K, V> ListMultimap<K, V> freshListMultimap(K key, V value) {
    return freshArrayListMultimap(keyvalue);
  }
  @Generates static private <K, V> ArrayListMultimap<K, V> freshArrayListMultimap(K key, V value) {
    ArrayListMultimap<K, V> multimap = ArrayListMultimap.create();
    multimap.put(keyvalue);
    return multimap;
  }
  @Generates static private <K, V> ImmutableListMultimap<K, V> freshImmutableListMultimap(
      K key, V value) {
    return ImmutableListMultimap.of(keyvalue);
  }
  @Generates static private <K, V> SetMultimap<K, V> freshSetMultimap(K key, V value) {
    return freshLinkedHashMultimap(keyvalue);
  }
  @Generates static private <K, V> HashMultimap<K, V> freshHashMultimap(K key, V value) {
    HashMultimap<K, V> multimap = HashMultimap.create();
    multimap.put(keyvalue);
    return multimap;
  }
  @Generates static private <K, V> LinkedHashMultimap<K, V> freshLinkedHashMultimap(
      K key, V value) {
    LinkedHashMultimap<K, V> multimap = LinkedHashMultimap.create();
    multimap.put(keyvalue);
    return multimap;
  }
  @Generates static private <K, V> ImmutableSetMultimap<K, V> freshImmutableSetMultimap(
      K key, V value) {
    return ImmutableSetMultimap.of(keyvalue);
  }
  @Generates static private <K, V> BiMap<K, V> freshBimap(K key, V value) {
    return freshHashBiMap(keyvalue);
  }
  @Generates static private <K, V> HashBiMap<K, V> freshHashBiMap(K key, V value) {
    HashBiMap<K, V> bimap = HashBiMap.create();
    bimap.put(keyvalue);
    return bimap;
  }
  @Generates static private <K, V> ImmutableBiMap<K, V> freshImmutableBimap(
      K key, V value) {
    return ImmutableBiMap.of(keyvalue);
  }
  @Generates static private <R, C, V> Table<R, C, V> freshTable(R row, C column, V value) {
    return freshHashBasedTable(rowcolumnvalue);
  }
  @Generates static private <R, C, V> HashBasedTable<R, C, V> freshHashBasedTable(
      R row, C column, V value) {
    HashBasedTable<R, C, V> table = HashBasedTable.create();
    table.put(rowcolumnvalue);
    return table;
  }
  @SuppressWarnings("rawtypes"// TreeBasedTable.create() is defined as such
  @Generates static private <R extends Comparable, C extends Comparable, V> RowSortedTable<R, C, V>
      freshRowSortedTable(R row, C column, V value) {
    return freshTreeBasedTable(rowcolumnvalue);
  }
  @SuppressWarnings("rawtypes"// TreeBasedTable.create() is defined as such
  @Generates static private <R extends Comparable, C extends Comparable, V> TreeBasedTable<R, C, V>
      freshTreeBasedTable(R row, C column, V value) {
    TreeBasedTable<R, C, V> table = TreeBasedTable.create();
    table.put(rowcolumnvalue);
    return table;
  }
  @Generates static private <R, C, V> ImmutableTable<R, C, V> freshImmutableTable(
      R row, C column, V value) {
    return ImmutableTable.of(rowcolumnvalue);
  }
  // common.reflect
  @Generates private TypeToken<?> freshTypeToken() {
    return TypeToken.of(freshClass());
  }
  // io types
  @Generates private File freshFile() {
    return new File(freshString());
  }
    return new ByteArrayInputStream(new byte[0]);
  }
  @Generates private static InputStream freshInputStream() {
    return freshByteArrayInputStream();
  }
    return new StringReader(freshString());
  }
  @Generates private Reader freshReader() {
    return freshStringReader();
  }
  @Generates private Readable freshReadable() {
    return freshReader();
  }
  @Generates private Buffer freshBuffer() {
    return freshCharBuffer();
  }
    return CharBuffer.allocate(freshInt());
  }
    return ByteBuffer.allocate(freshInt());
  }
    return ShortBuffer.allocate(freshInt());
  }
    return IntBuffer.allocate(freshInt());
  }
    return LongBuffer.allocate(freshInt());
  }
    return FloatBuffer.allocate(freshInt());
  }
    return DoubleBuffer.allocate(freshInt());
  }
New to GrepCode? Check out our FAQ X