| /* |
| * 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 com.google.common.base.CharMatcher; |
| import com.google.common.base.Charsets; |
| import com.google.common.base.Equivalence; |
| import com.google.common.base.Joiner; |
| import com.google.common.base.Optional; |
| import com.google.common.base.Splitter; |
| import com.google.common.base.Throwables; |
| import com.google.common.base.Ticker; |
| import com.google.common.collect.ArrayListMultimap; |
| import com.google.common.collect.BiMap; |
| import com.google.common.collect.HashBasedTable; |
| import com.google.common.collect.HashBiMap; |
| import com.google.common.collect.HashMultimap; |
| import com.google.common.collect.HashMultiset; |
| import com.google.common.collect.ImmutableBiMap; |
| import com.google.common.collect.ImmutableCollection; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableListMultimap; |
| import com.google.common.collect.ImmutableMap; |
| import com.google.common.collect.ImmutableMultimap; |
| import com.google.common.collect.ImmutableMultiset; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.ImmutableSetMultimap; |
| import com.google.common.collect.ImmutableSortedMap; |
| import com.google.common.collect.ImmutableSortedMultiset; |
| import com.google.common.collect.ImmutableSortedSet; |
| import com.google.common.collect.ImmutableTable; |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.LinkedHashMultimap; |
| import com.google.common.collect.LinkedHashMultiset; |
| import com.google.common.collect.ListMultimap; |
| import com.google.common.collect.Lists; |
| import com.google.common.collect.Maps; |
| import com.google.common.collect.Multimap; |
| import com.google.common.collect.Multiset; |
| import com.google.common.collect.Ordering; |
| import com.google.common.collect.Range; |
| import com.google.common.collect.RowSortedTable; |
| import com.google.common.collect.SetMultimap; |
| import com.google.common.collect.Sets; |
| import com.google.common.collect.SortedMultiset; |
| import com.google.common.collect.Table; |
| import com.google.common.collect.TreeBasedTable; |
| import com.google.common.collect.TreeMultiset; |
| import com.google.common.primitives.Primitives; |
| import com.google.common.primitives.UnsignedInteger; |
| import com.google.common.primitives.UnsignedLong; |
| import com.google.common.reflect.AbstractInvocationHandler; |
| import com.google.common.reflect.Invokable; |
| import com.google.common.reflect.Parameter; |
| import com.google.common.reflect.Reflection; |
| import com.google.common.reflect.TypeToken; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.File; |
| import java.io.InputStream; |
| import java.io.Reader; |
| import java.io.StringReader; |
| import java.lang.annotation.ElementType; |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.lang.annotation.Target; |
| import java.lang.reflect.Array; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Type; |
| import java.lang.reflect.TypeVariable; |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| import java.nio.Buffer; |
| import java.nio.ByteBuffer; |
| import java.nio.CharBuffer; |
| import java.nio.DoubleBuffer; |
| import java.nio.FloatBuffer; |
| import java.nio.IntBuffer; |
| import java.nio.LongBuffer; |
| import java.nio.ShortBuffer; |
| import java.nio.charset.Charset; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Comparator; |
| import java.util.Currency; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.LinkedHashMap; |
| import java.util.LinkedHashSet; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| import java.util.NavigableMap; |
| import java.util.NavigableSet; |
| import java.util.Set; |
| import java.util.SortedMap; |
| import java.util.SortedSet; |
| import java.util.TreeMap; |
| import java.util.TreeSet; |
| import java.util.concurrent.ConcurrentMap; |
| import java.util.concurrent.atomic.AtomicInteger; |
| import java.util.regex.Pattern; |
| |
| import javax.annotation.Nullable; |
| |
| /** |
| * Generates fresh instances of types that are different from each other (if possible). |
| * |
| * @author Ben Yu |
| */ |
| class FreshValueGenerator { |
| |
| private static final ImmutableMap<Class<?>, Method> GENERATORS; |
| static { |
| ImmutableMap.Builder<Class<?>, Method> builder = |
| ImmutableMap.builder(); |
| for (Method method : FreshValueGenerator.class.getDeclaredMethods()) { |
| if (method.isAnnotationPresent(Generates.class)) { |
| builder.put(method.getReturnType(), method); |
| } |
| } |
| GENERATORS = builder.build(); |
| } |
| |
| private final AtomicInteger differentiator = new AtomicInteger(1); |
| private final ListMultimap<Class<?>, Object> sampleInstances = ArrayListMultimap.create(); |
| private final Set<Type> generatedOptionalTypes = Sets.newHashSet(); |
| |
| <T> void addSampleInstances(Class<T> type, Iterable<? extends T> instances) { |
| sampleInstances.putAll(checkNotNull(type), checkNotNull(instances)); |
| } |
| |
| /** |
| * Returns a fresh instance for {@code type} if possible. The returned instance could be: |
| * <ul> |
| * <li>exactly of the given type, including generic type parameters, such as |
| * {@code ImmutableList<String>}; |
| * <li>of the raw type; |
| * <li>null if no fresh value can be generated. |
| * </ul> |
| */ |
| @Nullable Object generate(TypeToken<?> type) { |
| Class<?> rawType = type.getRawType(); |
| List<Object> samples = sampleInstances.get(rawType); |
| Object sample = nextInstance(samples, null); |
| 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, generate(componentType)); |
| return array; |
| } |
| if (rawType == Optional.class && generatedOptionalTypes.add(type.getType())) { |
| // For any Optional<T>, we'll first generate absent(). The next call generates a distinct |
| // value of T to be wrapped in Optional.of(). |
| return Optional.absent(); |
| } |
| Method generator = GENERATORS.get(rawType); |
| if (generator != null) { |
| ImmutableList<Parameter> params = Invokable.from(generator).getParameters(); |
| List<Object> args = 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 = generate(paramType); |
| if (argValue == null) { |
| // When a parameter of a @Generates method cannot be created, |
| // The type most likely is a collection. |
| // Our distinct proxy doesn't work for collections. |
| // So just refuse to generate. |
| return null; |
| } |
| args.add(argValue); |
| } |
| try { |
| return generator.invoke(this, args.toArray()); |
| } catch (InvocationTargetException e) { |
| Throwables.propagate(e.getCause()); |
| } catch (Exception e) { |
| throw Throwables.propagate(e); |
| } |
| } |
| return defaultGenerate(rawType); |
| } |
| |
| @Nullable final <T> T generate(Class<T> type) { |
| return Primitives.wrap(type).cast(generate(TypeToken.of(type))); |
| } |
| |
| private <T> T defaultGenerate(Class<T> 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(interfaceType, new FreshInvocationHandler(interfaceType)); |
| } |
| |
| private final class FreshInvocationHandler extends AbstractInvocationHandler { |
| private final int identity = freshInt(); |
| private final Class<?> interfaceType; |
| |
| FreshInvocationHandler(Class<?> interfaceType) { |
| this.interfaceType = interfaceType; |
| } |
| |
| @Override protected Object handleInvocation(Object proxy, Method method, Object[] args) { |
| return interfaceMethodCalled(interfaceType, method); |
| } |
| |
| @Override public int hashCode() { |
| return identity; |
| } |
| |
| @Override public boolean equals(@Nullable Object obj) { |
| if (obj instanceof FreshInvocationHandler) { |
| FreshInvocationHandler that = (FreshInvocationHandler) obj; |
| return identity == that.identity; |
| } |
| return false; |
| } |
| |
| @Override public String toString() { |
| return paramString(interfaceType, identity); |
| } |
| } |
| |
| /** Subclasses can override to provide different return value for proxied interface methods. */ |
| Object interfaceMethodCalled( |
| @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<?> type, int 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. |
| */ |
| @Target(ElementType.METHOD) |
| @Retention(RetentionPolicy.RUNTIME) |
| private @interface Generates {} |
| |
| @Generates private Class<?> freshClass() { |
| return nextInstance( |
| ImmutableList.of( |
| int.class, long.class, void.class, |
| Object.class, Object[].class, Iterable.class), |
| Object.class); |
| } |
| |
| @Generates private Object freshObject() { |
| return freshString(); |
| } |
| |
| @Generates private Number freshNumber() { |
| return freshInt(); |
| } |
| |
| @Generates private int freshInt() { |
| return differentiator.getAndIncrement(); |
| } |
| |
| @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(); |
| } |
| |
| @Generates private Double freshDoubleObject() { |
| return new Double(freshDouble()); |
| } |
| |
| @Generates private short freshShort() { |
| return (short) freshInt(); |
| } |
| |
| @Generates private Short freshShortObject() { |
| return new Short(freshShort()); |
| } |
| |
| @Generates private byte freshByte() { |
| return (byte) freshInt(); |
| } |
| |
| @Generates private Byte freshByteObject() { |
| return new Byte(freshByte()); |
| } |
| |
| @Generates private char freshChar() { |
| return freshString().charAt(0); |
| } |
| |
| @Generates private Character freshCharacter() { |
| return new Character(freshChar()); |
| } |
| |
| @Generates private boolean freshBoolean() { |
| return freshInt() % 2 == 0; |
| } |
| |
| @Generates private Boolean freshBooleanObject() { |
| return new Boolean(freshBoolean()); |
| } |
| |
| @Generates private UnsignedInteger freshUnsignedInteger() { |
| return UnsignedInteger.fromIntBits(freshInt()); |
| } |
| |
| @Generates private UnsignedLong freshUnsignedLong() { |
| return UnsignedLong.fromLongBits(freshLong()); |
| } |
| |
| @Generates private BigInteger freshBigInteger() { |
| return BigInteger.valueOf(freshInt()); |
| } |
| |
| @Generates private BigDecimal freshBigDecimal() { |
| return BigDecimal.valueOf(freshInt()); |
| } |
| |
| @Generates private CharSequence freshCharSequence() { |
| 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(), Charsets.UTF_8); |
| } |
| |
| @Generates private Locale freshLocale() { |
| return nextInstance(Locale.getAvailableLocales(), Locale.US); |
| } |
| |
| @Generates private Currency freshCurrency() { |
| for (Set<Locale> uselessLocales = Sets.newHashSet(); ; ) { |
| Locale locale = freshLocale(); |
| if (uselessLocales.contains(locale)) { // exhausted all locales |
| return Currency.getInstance(Locale.US); |
| } |
| try { |
| return Currency.getInstance(locale); |
| } catch (IllegalArgumentException e) { |
| uselessLocales.add(locale); |
| } |
| } |
| } |
| |
| // common.base |
| @Generates private <T> Optional<T> freshOptional(T value) { |
| return Optional.of(value); |
| } |
| |
| @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.class, freshInt()); |
| @Override public String toString() { |
| return string; |
| } |
| }; |
| } |
| |
| @Generates private CharMatcher freshCharMatcher() { |
| return new CharMatcher() { |
| @Override public boolean matches(char c) { |
| return false; |
| } |
| final String string = paramString(CharMatcher.class, freshInt()); |
| @Override public String toString() { |
| return string; |
| } |
| }; |
| } |
| |
| @Generates private Ticker freshTicker() { |
| return new Ticker() { |
| @Override public long read() { |
| return 0; |
| } |
| final String string = paramString(Ticker.class, freshInt()); |
| @Override public String toString() { |
| return string; |
| } |
| }; |
| } |
| |
| // 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.class, freshInt()); |
| @Override public String toString() { |
| return string; |
| } |
| }; |
| } |
| |
| @Generates private static <C extends Comparable> Range<C> freshRange(C freshElement) { |
| return Range.singleton(freshElement); |
| } |
| |
| @Generates private static <E> Iterable<E> freshIterable(E freshElement) { |
| return freshList(freshElement); |
| } |
| |
| @Generates private static <E> Collection<E> freshCollection(E freshElement) { |
| return freshList(freshElement); |
| } |
| |
| @Generates private static <E> List<E> freshList(E freshElement) { |
| return freshArrayList(freshElement); |
| } |
| |
| @Generates private static <E> ArrayList<E> freshArrayList(E freshElement) { |
| ArrayList<E> list = Lists.newArrayList(); |
| list.add(freshElement); |
| return list; |
| } |
| |
| @Generates private static <E> LinkedList<E> freshLinkedList(E freshElement) { |
| LinkedList<E> list = Lists.newLinkedList(); |
| list.add(freshElement); |
| return list; |
| } |
| |
| @Generates private static <E> ImmutableList<E> freshImmutableList(E freshElement) { |
| return ImmutableList.of(freshElement); |
| } |
| |
| @Generates private static <E> ImmutableCollection<E> freshImmutableCollection(E freshElement) { |
| return freshImmutableList(freshElement); |
| } |
| |
| @Generates private static <E> Set<E> freshSet(E freshElement) { |
| return freshHashSet(freshElement); |
| } |
| |
| @Generates private static <E> HashSet<E> freshHashSet(E freshElement) { |
| return freshLinkedHashSet(freshElement); |
| } |
| |
| @Generates private static <E> LinkedHashSet<E> freshLinkedHashSet(E freshElement) { |
| LinkedHashSet<E> set = Sets.newLinkedHashSet(); |
| set.add(freshElement); |
| return set; |
| } |
| |
| @Generates private static <E> ImmutableSet<E> freshImmutableSet(E freshElement) { |
| return ImmutableSet.of(freshElement); |
| } |
| |
| @Generates private static <E extends Comparable<? super E>> SortedSet<E> |
| freshSortedSet(E freshElement) { |
| return freshNavigableSet(freshElement); |
| } |
| |
| @Generates private static <E extends Comparable<? super E>> NavigableSet<E> |
| freshNavigableSet(E freshElement) { |
| return freshTreeSet(freshElement); |
| } |
| |
| @Generates private static <E extends Comparable<? super E>> TreeSet<E> freshTreeSet( |
| E freshElement) { |
| TreeSet<E> set = Sets.newTreeSet(); |
| set.add(freshElement); |
| return set; |
| } |
| |
| @Generates private static <E extends Comparable<? super E>> ImmutableSortedSet<E> |
| freshImmutableSortedSet(E freshElement) { |
| return ImmutableSortedSet.of(freshElement); |
| } |
| |
| @Generates private static <E> Multiset<E> freshMultiset(E freshElement) { |
| return freshHashMultiset(freshElement); |
| } |
| |
| @Generates private static <E> HashMultiset<E> freshHashMultiset(E freshElement) { |
| HashMultiset<E> multiset = HashMultiset.create(); |
| multiset.add(freshElement); |
| return multiset; |
| } |
| |
| @Generates private static <E> LinkedHashMultiset<E> freshLinkedHashMultiset(E freshElement) { |
| LinkedHashMultiset<E> multiset = LinkedHashMultiset.create(); |
| multiset.add(freshElement); |
| return multiset; |
| } |
| |
| @Generates private static <E> ImmutableMultiset<E> freshImmutableMultiset(E freshElement) { |
| return ImmutableMultiset.of(freshElement); |
| } |
| |
| @Generates private static <E extends Comparable<E>> SortedMultiset<E> freshSortedMultiset( |
| E freshElement) { |
| return freshTreeMultiset(freshElement); |
| } |
| |
| @Generates private static <E extends Comparable<E>> TreeMultiset<E> freshTreeMultiset( |
| E freshElement) { |
| TreeMultiset<E> multiset = TreeMultiset.create(); |
| multiset.add(freshElement); |
| return multiset; |
| } |
| |
| @Generates private static <E extends Comparable<E>> ImmutableSortedMultiset<E> |
| freshImmutableSortedMultiset(E freshElement) { |
| return ImmutableSortedMultiset.of(freshElement); |
| } |
| |
| @Generates private static <K, V> Map<K, V> freshMap(K key, V value) { |
| return freshHashdMap(key, value); |
| } |
| |
| @Generates private static <K, V> HashMap<K, V> freshHashdMap(K key, V value) { |
| return freshLinkedHashMap(key, value); |
| } |
| |
| @Generates private static <K, V> LinkedHashMap<K, V> freshLinkedHashMap(K key, V value) { |
| LinkedHashMap<K, V> map = Maps.newLinkedHashMap(); |
| map.put(key, value); |
| return map; |
| } |
| |
| @Generates private static <K, V> ImmutableMap<K, V> freshImmutableMap(K key, V value) { |
| return ImmutableMap.of(key, value); |
| } |
| |
| @Generates private static <K, V> ConcurrentMap<K, V> freshConcurrentMap(K key, V value) { |
| ConcurrentMap<K, V> map = Maps.newConcurrentMap(); |
| map.put(key, value); |
| return map; |
| } |
| |
| @Generates private static <K extends Comparable<? super K>, V> SortedMap<K, V> |
| freshSortedMap(K key, V value) { |
| return freshNavigableMap(key, value); |
| } |
| |
| @Generates private static <K extends Comparable<? super K>, V> NavigableMap<K, V> |
| freshNavigableMap(K key, V value) { |
| return freshTreeMap(key, value); |
| } |
| |
| @Generates private static <K extends Comparable<? super K>, V> TreeMap<K, V> freshTreeMap( |
| K key, V value) { |
| TreeMap<K, V> map = Maps.newTreeMap(); |
| map.put(key, value); |
| return map; |
| } |
| |
| @Generates private static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> |
| freshImmutableSortedMap(K key, V value) { |
| return ImmutableSortedMap.of(key, value); |
| } |
| |
| @Generates private static <K, V> Multimap<K, V> freshMultimap(K key, V value) { |
| return freshListMultimap(key, value); |
| } |
| |
| @Generates private static <K, V> ImmutableMultimap<K, V> freshImmutableMultimap(K key, V value) { |
| return ImmutableMultimap.of(key, value); |
| } |
| |
| @Generates private static <K, V> ListMultimap<K, V> freshListMultimap(K key, V value) { |
| return freshArrayListMultimap(key, value); |
| } |
| |
| @Generates private static <K, V> ArrayListMultimap<K, V> freshArrayListMultimap(K key, V value) { |
| ArrayListMultimap<K, V> multimap = ArrayListMultimap.create(); |
| multimap.put(key, value); |
| return multimap; |
| } |
| |
| @Generates private static <K, V> ImmutableListMultimap<K, V> freshImmutableListMultimap( |
| K key, V value) { |
| return ImmutableListMultimap.of(key, value); |
| } |
| |
| @Generates private static <K, V> SetMultimap<K, V> freshSetMultimap(K key, V value) { |
| return freshLinkedHashMultimap(key, value); |
| } |
| |
| @Generates private static <K, V> HashMultimap<K, V> freshHashMultimap(K key, V value) { |
| HashMultimap<K, V> multimap = HashMultimap.create(); |
| multimap.put(key, value); |
| return multimap; |
| } |
| |
| @Generates private static <K, V> LinkedHashMultimap<K, V> freshLinkedHashMultimap( |
| K key, V value) { |
| LinkedHashMultimap<K, V> multimap = LinkedHashMultimap.create(); |
| multimap.put(key, value); |
| return multimap; |
| } |
| |
| @Generates private static <K, V> ImmutableSetMultimap<K, V> freshImmutableSetMultimap( |
| K key, V value) { |
| return ImmutableSetMultimap.of(key, value); |
| } |
| |
| @Generates private static <K, V> BiMap<K, V> freshBimap(K key, V value) { |
| return freshHashBiMap(key, value); |
| } |
| |
| @Generates private static <K, V> HashBiMap<K, V> freshHashBiMap(K key, V value) { |
| HashBiMap<K, V> bimap = HashBiMap.create(); |
| bimap.put(key, value); |
| return bimap; |
| } |
| |
| @Generates private static <K, V> ImmutableBiMap<K, V> freshImmutableBimap( |
| K key, V value) { |
| return ImmutableBiMap.of(key, value); |
| } |
| |
| @Generates private static <R, C, V> Table<R, C, V> freshTable(R row, C column, V value) { |
| return freshHashBasedTable(row, column, value); |
| } |
| |
| @Generates private static <R, C, V> HashBasedTable<R, C, V> freshHashBasedTable( |
| R row, C column, V value) { |
| HashBasedTable<R, C, V> table = HashBasedTable.create(); |
| table.put(row, column, value); |
| return table; |
| } |
| |
| @SuppressWarnings("rawtypes") // TreeBasedTable.create() is defined as such |
| @Generates private static <R extends Comparable, C extends Comparable, V> RowSortedTable<R, C, V> |
| freshRowSortedTable(R row, C column, V value) { |
| return freshTreeBasedTable(row, column, value); |
| } |
| |
| @SuppressWarnings("rawtypes") // TreeBasedTable.create() is defined as such |
| @Generates private static <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(row, column, value); |
| return table; |
| } |
| |
| @Generates private static <R, C, V> ImmutableTable<R, C, V> freshImmutableTable( |
| R row, C column, V value) { |
| return ImmutableTable.of(row, column, value); |
| } |
| |
| // common.reflect |
| @Generates private TypeToken<?> freshTypeToken() { |
| return TypeToken.of(freshClass()); |
| } |
| |
| // io types |
| @Generates private File freshFile() { |
| return new File(freshString()); |
| } |
| |
| @Generates private static ByteArrayInputStream freshByteArrayInputStream() { |
| return new ByteArrayInputStream(new byte[0]); |
| } |
| |
| @Generates private static InputStream freshInputStream() { |
| return freshByteArrayInputStream(); |
| } |
| |
| @Generates private StringReader freshStringReader() { |
| return new StringReader(freshString()); |
| } |
| |
| @Generates private Reader freshReader() { |
| return freshStringReader(); |
| } |
| |
| @Generates private Readable freshReadable() { |
| return freshReader(); |
| } |
| |
| @Generates private Buffer freshBuffer() { |
| return freshCharBuffer(); |
| } |
| |
| @Generates private CharBuffer freshCharBuffer() { |
| return CharBuffer.allocate(freshInt()); |
| } |
| |
| @Generates private ByteBuffer freshByteBuffer() { |
| return ByteBuffer.allocate(freshInt()); |
| } |
| |
| @Generates private ShortBuffer freshShortBuffer() { |
| return ShortBuffer.allocate(freshInt()); |
| } |
| |
| @Generates private IntBuffer freshIntBuffer() { |
| return IntBuffer.allocate(freshInt()); |
| } |
| |
| @Generates private LongBuffer freshLongBuffer() { |
| return LongBuffer.allocate(freshInt()); |
| } |
| |
| @Generates private FloatBuffer freshFloatBuffer() { |
| return FloatBuffer.allocate(freshInt()); |
| } |
| |
| @Generates private DoubleBuffer freshDoubleBuffer() { |
| return DoubleBuffer.allocate(freshInt()); |
| } |
| } |