2
* Copyright (C) 2012 The Guava Authors
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
8
* http://www.apache.org/licenses/LICENSE-2.0
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.
17
package com.google.common.testing;
19
import static com.google.common.base.Preconditions.checkNotNull;
20
import static com.google.common.base.Throwables.throwIfUnchecked;
21
import static java.util.Objects.requireNonNull;
23
import com.google.common.annotations.GwtIncompatible;
24
import com.google.common.annotations.J2ktIncompatible;
25
import com.google.common.base.CharMatcher;
26
import com.google.common.base.Charsets;
27
import com.google.common.base.Equivalence;
28
import com.google.common.base.Joiner;
29
import com.google.common.base.Splitter;
30
import com.google.common.base.Ticker;
31
import com.google.common.collect.ArrayListMultimap;
32
import com.google.common.collect.BiMap;
33
import com.google.common.collect.HashBasedTable;
34
import com.google.common.collect.HashBiMap;
35
import com.google.common.collect.HashMultimap;
36
import com.google.common.collect.HashMultiset;
37
import com.google.common.collect.ImmutableBiMap;
38
import com.google.common.collect.ImmutableCollection;
39
import com.google.common.collect.ImmutableList;
40
import com.google.common.collect.ImmutableListMultimap;
41
import com.google.common.collect.ImmutableMap;
42
import com.google.common.collect.ImmutableMultimap;
43
import com.google.common.collect.ImmutableMultiset;
44
import com.google.common.collect.ImmutableSet;
45
import com.google.common.collect.ImmutableSetMultimap;
46
import com.google.common.collect.ImmutableSortedMap;
47
import com.google.common.collect.ImmutableSortedMultiset;
48
import com.google.common.collect.ImmutableSortedSet;
49
import com.google.common.collect.ImmutableTable;
50
import com.google.common.collect.Iterables;
51
import com.google.common.collect.LinkedHashMultimap;
52
import com.google.common.collect.LinkedHashMultiset;
53
import com.google.common.collect.ListMultimap;
54
import com.google.common.collect.Lists;
55
import com.google.common.collect.Maps;
56
import com.google.common.collect.Multimap;
57
import com.google.common.collect.Multiset;
58
import com.google.common.collect.Ordering;
59
import com.google.common.collect.Range;
60
import com.google.common.collect.RowSortedTable;
61
import com.google.common.collect.SetMultimap;
62
import com.google.common.collect.Sets;
63
import com.google.common.collect.SortedMultiset;
64
import com.google.common.collect.Table;
65
import com.google.common.collect.TreeBasedTable;
66
import com.google.common.collect.TreeMultiset;
67
import com.google.common.primitives.Primitives;
68
import com.google.common.primitives.UnsignedInteger;
69
import com.google.common.primitives.UnsignedLong;
70
import com.google.common.reflect.AbstractInvocationHandler;
71
import com.google.common.reflect.Invokable;
72
import com.google.common.reflect.Parameter;
73
import com.google.common.reflect.Reflection;
74
import com.google.common.reflect.TypeToken;
75
import java.io.ByteArrayInputStream;
77
import java.io.InputStream;
79
import java.io.StringReader;
80
import java.lang.annotation.ElementType;
81
import java.lang.annotation.Retention;
82
import java.lang.annotation.RetentionPolicy;
83
import java.lang.annotation.Target;
84
import java.lang.reflect.Array;
85
import java.lang.reflect.InvocationTargetException;
86
import java.lang.reflect.Method;
87
import java.lang.reflect.Type;
88
import java.lang.reflect.TypeVariable;
89
import java.math.BigDecimal;
90
import java.math.BigInteger;
91
import java.nio.Buffer;
92
import java.nio.ByteBuffer;
93
import java.nio.CharBuffer;
94
import java.nio.DoubleBuffer;
95
import java.nio.FloatBuffer;
96
import java.nio.IntBuffer;
97
import java.nio.LongBuffer;
98
import java.nio.ShortBuffer;
99
import java.nio.charset.Charset;
100
import java.util.ArrayList;
101
import java.util.Arrays;
102
import java.util.Collection;
103
import java.util.Comparator;
104
import java.util.Currency;
105
import java.util.HashMap;
106
import java.util.HashSet;
107
import java.util.LinkedHashMap;
108
import java.util.LinkedHashSet;
109
import java.util.LinkedList;
110
import java.util.List;
111
import java.util.Locale;
113
import java.util.NavigableMap;
114
import java.util.NavigableSet;
115
import java.util.Optional;
116
import java.util.OptionalDouble;
117
import java.util.OptionalInt;
118
import java.util.OptionalLong;
120
import java.util.SortedMap;
121
import java.util.SortedSet;
122
import java.util.TreeMap;
123
import java.util.TreeSet;
124
import java.util.concurrent.ConcurrentMap;
125
import java.util.concurrent.atomic.AtomicInteger;
126
import java.util.regex.Pattern;
127
import javax.annotation.CheckForNull;
128
import org.checkerframework.checker.nullness.qual.Nullable;
131
* Generates fresh instances of types that are different from each other (if possible).
137
class FreshValueGenerator {
139
private static final ImmutableMap<Class<?>, Method> GENERATORS;
142
ImmutableMap.Builder<Class<?>, Method> builder = ImmutableMap.builder();
143
for (Method method : FreshValueGenerator.class.getDeclaredMethods()) {
144
if (method.isAnnotationPresent(Generates.class)) {
145
builder.put(method.getReturnType(), method);
148
GENERATORS = builder.buildOrThrow();
151
private static final ImmutableMap<Class<?>, Method> EMPTY_GENERATORS;
154
ImmutableMap.Builder<Class<?>, Method> builder = ImmutableMap.builder();
155
for (Method method : FreshValueGenerator.class.getDeclaredMethods()) {
156
if (method.isAnnotationPresent(Empty.class)) {
157
builder.put(method.getReturnType(), method);
160
EMPTY_GENERATORS = builder.buildOrThrow();
163
private final AtomicInteger freshness = new AtomicInteger(1);
164
private final ListMultimap<Class<?>, Object> sampleInstances = ArrayListMultimap.create();
167
* The freshness level at which the {@link Empty @Empty} annotated method was invoked to generate
170
private final Map<Type, Integer> emptyInstanceGenerated = new HashMap<>();
172
final <T> void addSampleInstances(Class<T> type, Iterable<? extends T> instances) {
173
sampleInstances.putAll(checkNotNull(type), checkNotNull(instances));
177
* Returns a fresh instance for {@code type} if possible. The returned instance could be:
180
* <li>exactly of the given type, including generic type parameters, such as {@code
181
* ImmutableList<String>};
182
* <li>of the raw type;
183
* <li>null if no value can be generated.
186
final @Nullable Object generateFresh(TypeToken<?> type) {
187
Object generated = generate(type);
188
if (generated != null) {
189
freshness.incrementAndGet();
194
final <T> @Nullable T generateFresh(Class<T> type) {
195
return Primitives.wrap(type).cast(generateFresh(TypeToken.of(type)));
198
final <T> T newFreshProxy(final Class<T> interfaceType) {
199
T proxy = newProxy(interfaceType);
200
freshness.incrementAndGet();
205
* Generates an instance for {@code type} using the current {@link #freshness}. The generated
206
* instance may or may not be unique across different calls.
208
private @Nullable Object generate(TypeToken<?> type) {
209
Class<?> rawType = type.getRawType();
210
List<Object> samples = sampleInstances.get(rawType);
211
Object sample = pickInstance(samples, null);
212
if (sample != null) {
215
if (rawType.isEnum()) {
216
return pickInstance(rawType.getEnumConstants(), null);
218
if (type.isArray()) {
219
TypeToken<?> componentType = requireNonNull(type.getComponentType());
220
Object array = Array.newInstance(componentType.getRawType(), 1);
221
Array.set(array, 0, generate(componentType));
224
Method emptyGenerate = EMPTY_GENERATORS.get(rawType);
225
if (emptyGenerate != null) {
226
if (emptyInstanceGenerated.containsKey(type.getType())) {
227
// empty instance already generated
228
if (emptyInstanceGenerated.get(type.getType()).intValue() == freshness.get()) {
229
// same freshness, generate again.
230
return invokeGeneratorMethod(emptyGenerate);
232
// Cannot use empty generator. Proceed with other generators.
235
// never generated empty instance for this type before.
236
Object emptyInstance = invokeGeneratorMethod(emptyGenerate);
237
emptyInstanceGenerated.put(type.getType(), freshness.get());
238
return emptyInstance;
241
Method generate = GENERATORS.get(rawType);
242
if (generate != null) {
243
ImmutableList<Parameter> params = Invokable.from(generate).getParameters();
244
List<Object> args = Lists.newArrayListWithCapacity(params.size());
245
TypeVariable<?>[] typeVars = rawType.getTypeParameters();
246
for (int i = 0; i < params.size(); i++) {
247
TypeToken<?> paramType = type.resolveType(typeVars[i]);
248
// We require all @Generates methods to either be parameter-less or accept non-null
249
// values for their generic parameter types.
250
Object argValue = generate(paramType);
251
if (argValue == null) {
252
// When a parameter of a @Generates method cannot be created,
253
// The type most likely is a collection.
254
// Our distinct proxy doesn't work for collections.
255
// So just refuse to generate.
260
return invokeGeneratorMethod(generate, args.toArray());
262
return defaultGenerate(rawType);
265
private <T> @Nullable T defaultGenerate(Class<T> rawType) {
266
if (rawType.isInterface()) {
267
// always create a new proxy
268
return newProxy(rawType);
270
return ArbitraryInstances.get(rawType);
273
private <T> T newProxy(final Class<T> interfaceType) {
274
return Reflection.newProxy(interfaceType, new FreshInvocationHandler(interfaceType));
277
private Object invokeGeneratorMethod(Method generator, Object... args) {
279
return generator.invoke(this, args);
280
} catch (InvocationTargetException e) {
281
throwIfUnchecked(e.getCause());
282
throw new RuntimeException(e.getCause());
283
} catch (Exception e) {
285
throw new RuntimeException(e);
289
private final class FreshInvocationHandler extends AbstractInvocationHandler {
290
private final int identity = generateInt();
291
private final Class<?> interfaceType;
293
FreshInvocationHandler(Class<?> interfaceType) {
294
this.interfaceType = interfaceType;
299
protected Object handleInvocation(Object proxy, Method method, @Nullable Object[] args) {
300
return interfaceMethodCalled(interfaceType, method);
304
public int hashCode() {
309
public boolean equals(@Nullable Object obj) {
310
if (obj instanceof FreshInvocationHandler) {
311
FreshInvocationHandler that = (FreshInvocationHandler) obj;
312
return identity == that.identity;
318
public String toString() {
319
return paramString(interfaceType, identity);
323
/** Subclasses can override to provide different return value for proxied interface methods. */
325
Object interfaceMethodCalled(Class<?> interfaceType, Method method) {
326
throw new UnsupportedOperationException();
329
private <T> T pickInstance(T[] instances, T defaultValue) {
330
return pickInstance(Arrays.asList(instances), defaultValue);
333
private <T> T pickInstance(Collection<T> instances, T defaultValue) {
334
if (instances.isEmpty()) {
337
// generateInt() is 1-based.
338
return Iterables.get(instances, (generateInt() - 1) % instances.size());
341
private static String paramString(Class<?> type, int i) {
342
return type.getSimpleName() + '@' + i;
346
* Annotates a method to be the instance generator of a certain type. The return type is the
347
* generated type. The method parameters correspond to the generated type's type parameters. For
348
* example, if the annotated method returns {@code Map<K, V>}, the method signature should be:
349
* {@code Map<K, V> generateMap(K key, V value)}.
351
@Target(ElementType.METHOD)
352
@Retention(RetentionPolicy.RUNTIME)
353
private @interface Generates {}
356
* Annotates a method to generate the "empty" instance of a collection. This method should accept
357
* no parameter. The value it generates should be unequal to the values generated by methods
358
* annotated with {@link Generates}.
360
@Target(ElementType.METHOD)
361
@Retention(RetentionPolicy.RUNTIME)
362
private @interface Empty {}
365
Class<?> generateClass() {
368
int.class, long.class, void.class, Object.class, Object[].class, Iterable.class),
373
Object generateObject() {
374
return generateString();
378
Number generateNumber() {
379
return generateInt();
384
return freshness.get();
387
@SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
389
Integer generateInteger() {
390
return new Integer(generateInt());
394
long generateLong() {
395
return generateInt();
398
@SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
400
Long generateLongObject() {
401
return new Long(generateLong());
405
float generateFloat() {
406
return generateInt();
409
@SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
411
Float generateFloatObject() {
412
return new Float(generateFloat());
416
double generateDouble() {
417
return generateInt();
420
@SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
422
Double generateDoubleObject() {
423
return new Double(generateDouble());
427
short generateShort() {
428
return (short) generateInt();
431
@SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
433
Short generateShortObject() {
434
return new Short(generateShort());
438
byte generateByte() {
439
return (byte) generateInt();
442
@SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
444
Byte generateByteObject() {
445
return new Byte(generateByte());
449
char generateChar() {
450
return generateString().charAt(0);
453
@SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
455
Character generateCharacter() {
456
return new Character(generateChar());
460
boolean generateBoolean() {
461
return generateInt() % 2 == 0;
464
@SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
466
Boolean generateBooleanObject() {
467
return new Boolean(generateBoolean());
471
UnsignedInteger generateUnsignedInteger() {
472
return UnsignedInteger.fromIntBits(generateInt());
476
UnsignedLong generateUnsignedLong() {
477
return UnsignedLong.fromLongBits(generateLong());
481
BigInteger generateBigInteger() {
482
return BigInteger.valueOf(generateInt());
486
BigDecimal generateBigDecimal() {
487
return BigDecimal.valueOf(generateInt());
491
CharSequence generateCharSequence() {
492
return generateString();
496
String generateString() {
497
return Integer.toString(generateInt());
501
Comparable<?> generateComparable() {
502
return generateString();
506
Pattern generatePattern() {
507
return Pattern.compile(generateString());
511
Charset generateCharset() {
512
return pickInstance(Charset.availableCharsets().values(), Charsets.UTF_8);
516
Locale generateLocale() {
517
return pickInstance(Locale.getAvailableLocales(), Locale.US);
521
Currency generateCurrency() {
522
return pickInstance(Currency.getAvailableCurrencies(), Currency.getInstance(Locale.US));
526
<T> Optional<T> generateJavaOptional() {
527
return Optional.empty();
531
<T> Optional<T> generateJavaOptional(T value) {
532
return Optional.of(value);
536
OptionalInt generateOptionalInt() {
537
return OptionalInt.of(generateInt());
541
OptionalLong generateOptionalLong() {
542
return OptionalLong.of(generateLong());
546
OptionalDouble generateOptionalDouble() {
547
return OptionalDouble.of(generateDouble());
552
<T> com.google.common.base.Optional<T> generateGoogleOptional() {
553
return com.google.common.base.Optional.absent();
557
<T> com.google.common.base.Optional<T> generateGoogleOptional(T value) {
558
return com.google.common.base.Optional.of(value);
562
Joiner generateJoiner() {
563
return Joiner.on(generateString());
567
Splitter generateSplitter() {
568
return Splitter.on(generateString());
572
<T> Equivalence<T> generateEquivalence() {
573
return new Equivalence<T>() {
575
protected boolean doEquivalent(T a, T b) {
580
protected int doHash(T t) {
584
final String string = paramString(Equivalence.class, generateInt());
587
public String toString() {
594
CharMatcher generateCharMatcher() {
595
return new CharMatcher() {
597
public boolean matches(char c) {
601
final String string = paramString(CharMatcher.class, generateInt());
604
public String toString() {
611
Ticker generateTicker() {
612
return new Ticker() {
618
final String string = paramString(Ticker.class, generateInt());
621
public String toString() {
629
<T> Comparator<T> generateComparator() {
630
return generateOrdering();
634
<T extends @Nullable Object> Ordering<T> generateOrdering() {
635
return new Ordering<T>() {
637
public int compare(T left, T right) {
641
final String string = paramString(Ordering.class, generateInt());
644
public String toString() {
651
static <C extends Comparable<?>> Range<C> generateRange() {
656
static <C extends Comparable<?>> Range<C> generateRange(C freshElement) {
657
return Range.singleton(freshElement);
661
static <E> Iterable<E> generateIterable(@Nullable E freshElement) {
662
return generateList(freshElement);
666
static <E> Collection<E> generateCollection(@Nullable E freshElement) {
667
return generateList(freshElement);
671
static <E> List<E> generateList(@Nullable E freshElement) {
672
return generateArrayList(freshElement);
676
static <E> ArrayList<E> generateArrayList(@Nullable E freshElement) {
677
ArrayList<E> list = Lists.newArrayList();
678
list.add(freshElement);
683
static <E> LinkedList<E> generateLinkedList(@Nullable E freshElement) {
684
LinkedList<E> list = Lists.newLinkedList();
685
list.add(freshElement);
690
static <E> ImmutableList<E> generateImmutableList(E freshElement) {
691
return ImmutableList.of(freshElement);
695
static <E> ImmutableCollection<E> generateImmutableCollection(E freshElement) {
696
return generateImmutableList(freshElement);
700
static <E> Set<E> generateSet(@Nullable E freshElement) {
701
return generateHashSet(freshElement);
705
static <E> HashSet<E> generateHashSet(@Nullable E freshElement) {
706
return generateLinkedHashSet(freshElement);
710
static <E> LinkedHashSet<E> generateLinkedHashSet(@Nullable E freshElement) {
711
LinkedHashSet<E> set = Sets.newLinkedHashSet();
712
set.add(freshElement);
717
static <E> ImmutableSet<E> generateImmutableSet(E freshElement) {
718
return ImmutableSet.of(freshElement);
722
static <E extends Comparable<? super E>> SortedSet<E> generateSortedSet(E freshElement) {
723
return generateNavigableSet(freshElement);
727
static <E extends Comparable<? super E>> NavigableSet<E> generateNavigableSet(E freshElement) {
728
return generateTreeSet(freshElement);
732
static <E extends Comparable<? super E>> TreeSet<E> generateTreeSet(E freshElement) {
733
TreeSet<E> set = Sets.newTreeSet();
734
set.add(freshElement);
739
static <E extends Comparable<? super E>> ImmutableSortedSet<E> generateImmutableSortedSet(
741
return ImmutableSortedSet.of(freshElement);
745
static <E> Multiset<E> generateMultiset(@Nullable E freshElement) {
746
return generateHashMultiset(freshElement);
750
static <E> HashMultiset<E> generateHashMultiset(@Nullable E freshElement) {
751
HashMultiset<E> multiset = HashMultiset.create();
752
multiset.add(freshElement);
757
static <E> LinkedHashMultiset<E> generateLinkedHashMultiset(@Nullable E freshElement) {
758
LinkedHashMultiset<E> multiset = LinkedHashMultiset.create();
759
multiset.add(freshElement);
764
static <E> ImmutableMultiset<E> generateImmutableMultiset(E freshElement) {
765
return ImmutableMultiset.of(freshElement);
769
static <E extends Comparable<E>> SortedMultiset<E> generateSortedMultiset(E freshElement) {
770
return generateTreeMultiset(freshElement);
774
static <E extends Comparable<E>> TreeMultiset<E> generateTreeMultiset(E freshElement) {
775
TreeMultiset<E> multiset = TreeMultiset.create();
776
multiset.add(freshElement);
781
static <E extends Comparable<E>> ImmutableSortedMultiset<E> generateImmutableSortedMultiset(
783
return ImmutableSortedMultiset.of(freshElement);
787
static <K, V> Map<K, V> generateMap(@Nullable K key, @Nullable V value) {
788
return generateHashdMap(key, value);
792
static <K, V> HashMap<K, V> generateHashdMap(@Nullable K key, @Nullable V value) {
793
return generateLinkedHashMap(key, value);
797
static <K, V> LinkedHashMap<K, V> generateLinkedHashMap(@Nullable K key, @Nullable V value) {
798
LinkedHashMap<K, V> map = Maps.newLinkedHashMap();
804
static <K, V> ImmutableMap<K, V> generateImmutableMap(K key, V value) {
805
return ImmutableMap.of(key, value);
809
static <K, V> ConcurrentMap<K, V> generateConcurrentMap() {
810
return Maps.newConcurrentMap();
814
static <K, V> ConcurrentMap<K, V> generateConcurrentMap(K key, V value) {
815
ConcurrentMap<K, V> map = Maps.newConcurrentMap();
821
static <K extends Comparable<? super K>, V> SortedMap<K, V> generateSortedMap(
822
K key, @Nullable V value) {
823
return generateNavigableMap(key, value);
827
static <K extends Comparable<? super K>, V> NavigableMap<K, V> generateNavigableMap(
828
K key, @Nullable V value) {
829
return generateTreeMap(key, value);
833
static <K extends Comparable<? super K>, V> TreeMap<K, V> generateTreeMap(
834
K key, @Nullable V value) {
835
TreeMap<K, V> map = Maps.newTreeMap();
841
static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> generateImmutableSortedMap(
843
return ImmutableSortedMap.of(key, value);
847
static <K, V> Multimap<K, V> generateMultimap(@Nullable K key, @Nullable V value) {
848
return generateListMultimap(key, value);
852
static <K, V> ImmutableMultimap<K, V> generateImmutableMultimap(K key, V value) {
853
return ImmutableMultimap.of(key, value);
857
static <K, V> ListMultimap<K, V> generateListMultimap(@Nullable K key, @Nullable V value) {
858
return generateArrayListMultimap(key, value);
862
static <K, V> ArrayListMultimap<K, V> generateArrayListMultimap(
863
@Nullable K key, @Nullable V value) {
864
ArrayListMultimap<K, V> multimap = ArrayListMultimap.create();
865
multimap.put(key, value);
870
static <K, V> ImmutableListMultimap<K, V> generateImmutableListMultimap(K key, V value) {
871
return ImmutableListMultimap.of(key, value);
875
static <K, V> SetMultimap<K, V> generateSetMultimap(@Nullable K key, @Nullable V value) {
876
return generateLinkedHashMultimap(key, value);
880
static <K, V> HashMultimap<K, V> generateHashMultimap(@Nullable K key, @Nullable V value) {
881
HashMultimap<K, V> multimap = HashMultimap.create();
882
multimap.put(key, value);
887
static <K, V> LinkedHashMultimap<K, V> generateLinkedHashMultimap(
888
@Nullable K key, @Nullable V value) {
889
LinkedHashMultimap<K, V> multimap = LinkedHashMultimap.create();
890
multimap.put(key, value);
895
static <K, V> ImmutableSetMultimap<K, V> generateImmutableSetMultimap(K key, V value) {
896
return ImmutableSetMultimap.of(key, value);
900
static <K, V> BiMap<K, V> generateBimap(@Nullable K key, @Nullable V value) {
901
return generateHashBiMap(key, value);
905
static <K, V> HashBiMap<K, V> generateHashBiMap(@Nullable K key, @Nullable V value) {
906
HashBiMap<K, V> bimap = HashBiMap.create();
907
bimap.put(key, value);
912
static <K, V> ImmutableBiMap<K, V> generateImmutableBimap(K key, V value) {
913
return ImmutableBiMap.of(key, value);
917
static <R, C, V> Table<R, C, V> generateTable(R row, C column, V value) {
918
return generateHashBasedTable(row, column, value);
922
static <R, C, V> HashBasedTable<R, C, V> generateHashBasedTable(R row, C column, V value) {
923
HashBasedTable<R, C, V> table = HashBasedTable.create();
924
table.put(row, column, value);
928
@SuppressWarnings("rawtypes") // TreeBasedTable.create() is defined as such
930
static <R extends Comparable, C extends Comparable, V>
931
RowSortedTable<R, C, V> generateRowSortedTable(R row, C column, V value) {
932
return generateTreeBasedTable(row, column, value);
935
@SuppressWarnings("rawtypes") // TreeBasedTable.create() is defined as such
937
static <R extends Comparable, C extends Comparable, V>
938
TreeBasedTable<R, C, V> generateTreeBasedTable(R row, C column, V value) {
939
TreeBasedTable<R, C, V> table = TreeBasedTable.create();
940
table.put(row, column, value);
945
static <R, C, V> ImmutableTable<R, C, V> generateImmutableTable(R row, C column, V value) {
946
return ImmutableTable.of(row, column, value);
951
TypeToken<?> generateTypeToken() {
952
return TypeToken.of(generateClass());
957
File generateFile() {
958
return new File(generateString());
962
static ByteArrayInputStream generateByteArrayInputStream() {
963
return new ByteArrayInputStream(new byte[0]);
967
static InputStream generateInputStream() {
968
return generateByteArrayInputStream();
972
StringReader generateStringReader() {
973
return new StringReader(generateString());
977
Reader generateReader() {
978
return generateStringReader();
982
Readable generateReadable() {
983
return generateReader();
987
Buffer generateBuffer() {
988
return generateCharBuffer();
992
CharBuffer generateCharBuffer() {
993
return CharBuffer.allocate(generateInt());
997
ByteBuffer generateByteBuffer() {
998
return ByteBuffer.allocate(generateInt());
1002
ShortBuffer generateShortBuffer() {
1003
return ShortBuffer.allocate(generateInt());
1007
IntBuffer generateIntBuffer() {
1008
return IntBuffer.allocate(generateInt());
1012
LongBuffer generateLongBuffer() {
1013
return LongBuffer.allocate(generateInt());
1017
FloatBuffer generateFloatBuffer() {
1018
return FloatBuffer.allocate(generateInt());
1022
DoubleBuffer generateDoubleBuffer() {
1023
return DoubleBuffer.allocate(generateInt());