1 /*
2 * Copyright (C) 2012 The Guava Authors
3 *
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
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
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.
15 */
16
17 package com.google.common.testing;
18
19 import static com.google.common.base.Preconditions.checkNotNull;
20 import static com.google.common.base.Throwables.throwIfUnchecked;
21
22 import com.google.common.annotations.GwtIncompatible;
23 import com.google.common.base.CharMatcher;
24 import com.google.common.base.Charsets;
25 import com.google.common.base.Equivalence;
26 import com.google.common.base.Joiner;
27 import com.google.common.base.Splitter;
28 import com.google.common.base.Ticker;
29 import com.google.common.collect.ArrayListMultimap;
30 import com.google.common.collect.BiMap;
31 import com.google.common.collect.HashBasedTable;
32 import com.google.common.collect.HashBiMap;
33 import com.google.common.collect.HashMultimap;
34 import com.google.common.collect.HashMultiset;
35 import com.google.common.collect.ImmutableBiMap;
36 import com.google.common.collect.ImmutableCollection;
37 import com.google.common.collect.ImmutableList;
38 import com.google.common.collect.ImmutableListMultimap;
39 import com.google.common.collect.ImmutableMap;
40 import com.google.common.collect.ImmutableMultimap;
41 import com.google.common.collect.ImmutableMultiset;
42 import com.google.common.collect.ImmutableSet;
43 import com.google.common.collect.ImmutableSetMultimap;
44 import com.google.common.collect.ImmutableSortedMap;
45 import com.google.common.collect.ImmutableSortedMultiset;
46 import com.google.common.collect.ImmutableSortedSet;
47 import com.google.common.collect.ImmutableTable;
48 import com.google.common.collect.Iterables;
49 import com.google.common.collect.LinkedHashMultimap;
50 import com.google.common.collect.LinkedHashMultiset;
51 import com.google.common.collect.ListMultimap;
52 import com.google.common.collect.Lists;
53 import com.google.common.collect.Maps;
54 import com.google.common.collect.Multimap;
55 import com.google.common.collect.Multiset;
56 import com.google.common.collect.Ordering;
57 import com.google.common.collect.Range;
58 import com.google.common.collect.RowSortedTable;
59 import com.google.common.collect.SetMultimap;
60 import com.google.common.collect.Sets;
61 import com.google.common.collect.SortedMultiset;
62 import com.google.common.collect.Table;
63 import com.google.common.collect.TreeBasedTable;
64 import com.google.common.collect.TreeMultiset;
65 import com.google.common.primitives.Primitives;
66 import com.google.common.primitives.UnsignedInteger;
67 import com.google.common.primitives.UnsignedLong;
68 import com.google.common.reflect.AbstractInvocationHandler;
69 import com.google.common.reflect.Invokable;
70 import com.google.common.reflect.Parameter;
71 import com.google.common.reflect.Reflection;
72 import com.google.common.reflect.TypeToken;
73 import java.io.ByteArrayInputStream;
74 import java.io.File;
75 import java.io.InputStream;
76 import java.io.Reader;
77 import java.io.StringReader;
78 import java.lang.annotation.ElementType;
79 import java.lang.annotation.Retention;
80 import java.lang.annotation.RetentionPolicy;
81 import java.lang.annotation.Target;
82 import java.lang.reflect.Array;
83 import java.lang.reflect.InvocationTargetException;
84 import java.lang.reflect.Method;
85 import java.lang.reflect.Type;
86 import java.lang.reflect.TypeVariable;
87 import java.math.BigDecimal;
88 import java.math.BigInteger;
89 import java.nio.Buffer;
90 import java.nio.ByteBuffer;
91 import java.nio.CharBuffer;
92 import java.nio.DoubleBuffer;
93 import java.nio.FloatBuffer;
94 import java.nio.IntBuffer;
95 import java.nio.LongBuffer;
96 import java.nio.ShortBuffer;
97 import java.nio.charset.Charset;
98 import java.util.ArrayList;
99 import java.util.Arrays;
100 import java.util.Collection;
101 import java.util.Comparator;
102 import java.util.Currency;
103 import java.util.HashMap;
104 import java.util.HashSet;
105 import java.util.LinkedHashMap;
106 import java.util.LinkedHashSet;
107 import java.util.LinkedList;
108 import java.util.List;
109 import java.util.Locale;
110 import java.util.Map;
111 import java.util.NavigableMap;
112 import java.util.NavigableSet;
113 import java.util.Optional;
114 import java.util.OptionalDouble;
115 import java.util.OptionalInt;
116 import java.util.OptionalLong;
117 import java.util.Set;
118 import java.util.SortedMap;
119 import java.util.SortedSet;
120 import java.util.TreeMap;
121 import java.util.TreeSet;
122 import java.util.concurrent.ConcurrentMap;
123 import java.util.concurrent.atomic.AtomicInteger;
124 import java.util.regex.Pattern;
125 import org.checkerframework.checker.nullness.qual.Nullable;
126
127 /**
128 * Generates fresh instances of types that are different from each other (if possible).
129 *
130 * @author Ben Yu
131 */
132 @GwtIncompatible
133 class FreshValueGenerator {
134
135 private static final ImmutableMap<Class<?>, Method> GENERATORS;
136
137 static {
138 ImmutableMap.Builder<Class<?>, Method> builder = ImmutableMap.builder();
139 for (Method method : FreshValueGenerator.class.getDeclaredMethods()) {
140 if (method.isAnnotationPresent(Generates.class)) {
141 builder.put(method.getReturnType(), method);
142 }
143 }
144 GENERATORS = builder.build();
145 }
146
147 private static final ImmutableMap<Class<?>, Method> EMPTY_GENERATORS;
148
149 static {
150 ImmutableMap.Builder<Class<?>, Method> builder = ImmutableMap.builder();
151 for (Method method : FreshValueGenerator.class.getDeclaredMethods()) {
152 if (method.isAnnotationPresent(Empty.class)) {
153 builder.put(method.getReturnType(), method);
154 }
155 }
156 EMPTY_GENERATORS = builder.build();
157 }
158
159 private final AtomicInteger freshness = new AtomicInteger(1);
160 private final ListMultimap<Class<?>, Object> sampleInstances = ArrayListMultimap.create();
161
162 /**
163 * The freshness level at which the {@link Empty @Empty} annotated method was invoked to generate
164 * instance.
165 */
166 private final Map<Type, Integer> emptyInstanceGenerated = new HashMap<>();
167
168 final <T> void addSampleInstances(Class<T> type, Iterable<? extends T> instances) {
169 sampleInstances.putAll(checkNotNull(type), checkNotNull(instances));
170 }
171
172 /**
173 * Returns a fresh instance for {@code type} if possible. The returned instance could be:
174 *
175 * <ul>
176 * <li>exactly of the given type, including generic type parameters, such as {@code
177 * ImmutableList<String>};
178 * <li>of the raw type;
179 * <li>null if no value can be generated.
180 * </ul>
181 */
182 final @Nullable Object generateFresh(TypeToken<?> type) {
183 Object generated = generate(type);
184 if (generated != null) {
185 freshness.incrementAndGet();
186 }
187 return generated;
188 }
189
190 final <T> @Nullable T generateFresh(Class<T> type) {
191 return Primitives.wrap(type).cast(generateFresh(TypeToken.of(type)));
192 }
193
194 final <T> T newFreshProxy(final Class<T> interfaceType) {
195 T proxy = newProxy(interfaceType);
196 freshness.incrementAndGet();
197 return proxy;
198 }
199
200 /**
201 * Generates an instance for {@code type} using the current {@link #freshness}. The generated
202 * instance may or may not be unique across different calls.
203 */
204 private Object generate(TypeToken<?> type) {
205 Class<?> rawType = type.getRawType();
206 List<Object> samples = sampleInstances.get(rawType);
207 Object sample = pickInstance(samples, null);
208 if (sample != null) {
209 return sample;
210 }
211 if (rawType.isEnum()) {
212 return pickInstance(rawType.getEnumConstants(), null);
213 }
214 if (type.isArray()) {
215 TypeToken<?> componentType = type.getComponentType();
216 Object array = Array.newInstance(componentType.getRawType(), 1);
217 Array.set(array, 0, generate(componentType));
218 return array;
219 }
220 Method emptyGenerate = EMPTY_GENERATORS.get(rawType);
221 if (emptyGenerate != null) {
222 if (emptyInstanceGenerated.containsKey(type.getType())) {
223 // empty instance already generated
224 if (emptyInstanceGenerated.get(type.getType()).intValue() == freshness.get()) {
225 // same freshness, generate again.
226 return invokeGeneratorMethod(emptyGenerate);
227 } else {
228 // Cannot use empty generator. Proceed with other generators.
229 }
230 } else {
231 // never generated empty instance for this type before.
232 Object emptyInstance = invokeGeneratorMethod(emptyGenerate);
233 emptyInstanceGenerated.put(type.getType(), freshness.get());
234 return emptyInstance;
235 }
236 }
237 Method generate = GENERATORS.get(rawType);
238 if (generate != null) {
239 ImmutableList<Parameter> params = Invokable.from(generate).getParameters();
240 List<Object> args = Lists.newArrayListWithCapacity(params.size());
241 TypeVariable<?>[] typeVars = rawType.getTypeParameters();
242 for (int i = 0; i < params.size(); i++) {
243 TypeToken<?> paramType = type.resolveType(typeVars[i]);
244 // We require all @Generates methods to either be parameter-less or accept non-null
245 // values for their generic parameter types.
246 Object argValue = generate(paramType);
247 if (argValue == null) {
248 // When a parameter of a @Generates method cannot be created,
249 // The type most likely is a collection.
250 // Our distinct proxy doesn't work for collections.
251 // So just refuse to generate.
252 return null;
253 }
254 args.add(argValue);
255 }
256 return invokeGeneratorMethod(generate, args.toArray());
257 }
258 return defaultGenerate(rawType);
259 }
260
261 private <T> T defaultGenerate(Class<T> rawType) {
262 if (rawType.isInterface()) {
263 // always create a new proxy
264 return newProxy(rawType);
265 }
266 return ArbitraryInstances.get(rawType);
267 }
268
269 private <T> T newProxy(final Class<T> interfaceType) {
270 return Reflection.newProxy(interfaceType, new FreshInvocationHandler(interfaceType));
271 }
272
273 private Object invokeGeneratorMethod(Method generator, Object... args) {
274 try {
275 return generator.invoke(this, args);
276 } catch (InvocationTargetException e) {
277 throwIfUnchecked(e.getCause());
278 throw new RuntimeException(e.getCause());
279 } catch (Exception e) {
280 throwIfUnchecked(e);
281 throw new RuntimeException(e);
282 }
283 }
284
285 private final class FreshInvocationHandler extends AbstractInvocationHandler {
286 private final int identity = generateInt();
287 private final Class<?> interfaceType;
288
289 FreshInvocationHandler(Class<?> interfaceType) {
290 this.interfaceType = interfaceType;
291 }
292
293 @Override
294 protected Object handleInvocation(Object proxy, Method method, Object[] args) {
295 return interfaceMethodCalled(interfaceType, method);
296 }
297
298 @Override
299 public int hashCode() {
300 return identity;
301 }
302
303 @Override
304 public boolean equals(@Nullable Object obj) {
305 if (obj instanceof FreshInvocationHandler) {
306 FreshInvocationHandler that = (FreshInvocationHandler) obj;
307 return identity == that.identity;
308 }
309 return false;
310 }
311
312 @Override
313 public String toString() {
314 return paramString(interfaceType, identity);
315 }
316 }
317
318 /** Subclasses can override to provide different return value for proxied interface methods. */
319 Object interfaceMethodCalled(Class<?> interfaceType, Method method) {
320 throw new UnsupportedOperationException();
321 }
322
323 private <T> T pickInstance(T[] instances, T defaultValue) {
324 return pickInstance(Arrays.asList(instances), defaultValue);
325 }
326
327 private <T> T pickInstance(Collection<T> instances, T defaultValue) {
328 if (instances.isEmpty()) {
329 return defaultValue;
330 }
331 // generateInt() is 1-based.
332 return Iterables.get(instances, (generateInt() - 1) % instances.size());
333 }
334
335 private static String paramString(Class<?> type, int i) {
336 return type.getSimpleName() + '@' + i;
337 }
338
339 /**
340 * Annotates a method to be the instance generator of a certain type. The return type is the
341 * generated type. The method parameters correspond to the generated type's type parameters. For
342 * example, if the annotated method returns {@code Map<K, V>}, the method signature should be:
343 * {@code Map<K, V> generateMap(K key, V value)}.
344 */
345 @Target(ElementType.METHOD)
346 @Retention(RetentionPolicy.RUNTIME)
347 private @interface Generates {}
348
349 /**
350 * Annotates a method to generate the "empty" instance of a collection. This method should accept
351 * no parameter. The value it generates should be unequal to the values generated by methods
352 * annotated with {@link Generates}.
353 */
354 @Target(ElementType.METHOD)
355 @Retention(RetentionPolicy.RUNTIME)
356 private @interface Empty {}
357
358 @Generates
359 Class<?> generateClass() {
360 return pickInstance(
361 ImmutableList.of(
362 int.class, long.class, void.class, Object.class, Object[].class, Iterable.class),
363 Object.class);
364 }
365
366 @Generates
367 Object generateObject() {
368 return generateString();
369 }
370
371 @Generates
372 Number generateNumber() {
373 return generateInt();
374 }
375
376 @Generates
377 int generateInt() {
378 return freshness.get();
379 }
380
381 @Generates
382 Integer generateInteger() {
383 return new Integer(generateInt());
384 }
385
386 @Generates
387 long generateLong() {
388 return generateInt();
389 }
390
391 @Generates
392 Long generateLongObject() {
393 return new Long(generateLong());
394 }
395
396 @Generates
397 float generateFloat() {
398 return generateInt();
399 }
400
401 @Generates
402 Float generateFloatObject() {
403 return new Float(generateFloat());
404 }
405
406 @Generates
407 double generateDouble() {
408 return generateInt();
409 }
410
411 @Generates
412 Double generateDoubleObject() {
413 return new Double(generateDouble());
414 }
415
416 @Generates
417 short generateShort() {
418 return (short) generateInt();
419 }
420
421 @Generates
422 Short generateShortObject() {
423 return new Short(generateShort());
424 }
425
426 @Generates
427 byte generateByte() {
428 return (byte) generateInt();
429 }
430
431 @Generates
432 Byte generateByteObject() {
433 return new Byte(generateByte());
434 }
435
436 @Generates
437 char generateChar() {
438 return generateString().charAt(0);
439 }
440
441 @Generates
442 Character generateCharacter() {
443 return new Character(generateChar());
444 }
445
446 @Generates
447 boolean generateBoolean() {
448 return generateInt() % 2 == 0;
449 }
450
451 @Generates
452 Boolean generateBooleanObject() {
453 return new Boolean(generateBoolean());
454 }
455
456 @Generates
457 UnsignedInteger generateUnsignedInteger() {
458 return UnsignedInteger.fromIntBits(generateInt());
459 }
460
461 @Generates
462 UnsignedLong generateUnsignedLong() {
463 return UnsignedLong.fromLongBits(generateLong());
464 }
465
466 @Generates
467 BigInteger generateBigInteger() {
468 return BigInteger.valueOf(generateInt());
469 }
470
471 @Generates
472 BigDecimal generateBigDecimal() {
473 return BigDecimal.valueOf(generateInt());
474 }
475
476 @Generates
477 CharSequence generateCharSequence() {
478 return generateString();
479 }
480
481 @Generates
482 String generateString() {
483 return Integer.toString(generateInt());
484 }
485
486 @Generates
487 Comparable<?> generateComparable() {
488 return generateString();
489 }
490
491 @Generates
492 Pattern generatePattern() {
493 return Pattern.compile(generateString());
494 }
495
496 @Generates
497 Charset generateCharset() {
498 return pickInstance(Charset.availableCharsets().values(), Charsets.UTF_8);
499 }
500
501 @Generates
502 Locale generateLocale() {
503 return pickInstance(Locale.getAvailableLocales(), Locale.US);
504 }
505
506 @Generates
507 Currency generateCurrency() {
508 try {
509 Method method = Currency.class.getMethod("getAvailableCurrencies");
510 @SuppressWarnings("unchecked") // getAvailableCurrencies() returns Set<Currency>.
511 Set<Currency> currencies = (Set<Currency>) method.invoke(null);
512 return pickInstance(currencies, Currency.getInstance(Locale.US));
513 /*
514 * Do not merge the 2 catch blocks below. javac would infer a type of
515 * ReflectiveOperationException, which Animal Sniffer would reject. (Old versions of
516 * Android don't *seem* to mind, but there might be edge cases of which we're unaware.)
517 */
518 } catch (NoSuchMethodException notJava7) {
519 return preJava7FreshCurrency();
520 } catch (InvocationTargetException notJava7) {
521 return preJava7FreshCurrency();
522 } catch (IllegalAccessException impossible) {
523 throw new AssertionError(impossible);
524 }
525 }
526
527 private Currency preJava7FreshCurrency() {
528 for (Set<Locale> uselessLocales = Sets.newHashSet(); ; ) {
529 Locale locale = generateLocale();
530 if (uselessLocales.contains(locale)) { // exhausted all locales
531 return Currency.getInstance(Locale.US);
532 }
533 try {
534 return Currency.getInstance(locale);
535 } catch (IllegalArgumentException e) {
536 uselessLocales.add(locale);
537 }
538 }
539 }
540
541 @Empty
542 <T> Optional<T> generateJavaOptional() {
543 return Optional.empty();
544 }
545
546 @Generates
547 <T> Optional<T> generateJavaOptional(T value) {
548 return Optional.of(value);
549 }
550
551 @Generates
552 OptionalInt generateOptionalInt() {
553 return OptionalInt.of(generateInt());
554 }
555
556 @Generates
557 OptionalLong generateOptionalLong() {
558 return OptionalLong.of(generateLong());
559 }
560
561 @Generates
562 OptionalDouble generateOptionalDouble() {
563 return OptionalDouble.of(generateDouble());
564 }
565
566 // common.base
567 @Empty
568 <T> com.google.common.base.Optional<T> generateGoogleOptional() {
569 return com.google.common.base.Optional.absent();
570 }
571
572 @Generates
573 <T> com.google.common.base.Optional<T> generateGoogleOptional(T value) {
574 return com.google.common.base.Optional.of(value);
575 }
576
577 @Generates
578 Joiner generateJoiner() {
579 return Joiner.on(generateString());
580 }
581
582 @Generates
583 Splitter generateSplitter() {
584 return Splitter.on(generateString());
585 }
586
587 @Generates
588 <T> Equivalence<T> generateEquivalence() {
589 return new Equivalence<T>() {
590 @Override
591 protected boolean doEquivalent(T a, T b) {
592 return false;
593 }
594
595 @Override
596 protected int doHash(T t) {
597 return 0;
598 }
599
600 final String string = paramString(Equivalence.class, generateInt());
601
602 @Override
603 public String toString() {
604 return string;
605 }
606 };
607 }
608
609 @Generates
610 CharMatcher generateCharMatcher() {
611 return new CharMatcher() {
612 @Override
613 public boolean matches(char c) {
614 return false;
615 }
616
617 final String string = paramString(CharMatcher.class, generateInt());
618
619 @Override
620 public String toString() {
621 return string;
622 }
623 };
624 }
625
626 @Generates
627 Ticker generateTicker() {
628 return new Ticker() {
629 @Override
630 public long read() {
631 return 0;
632 }
633
634 final String string = paramString(Ticker.class, generateInt());
635
636 @Override
637 public String toString() {
638 return string;
639 }
640 };
641 }
642
643 // collect
644 @Generates
645 <T> Comparator<T> generateComparator() {
646 return generateOrdering();
647 }
648
649 @Generates
650 <T> Ordering<T> generateOrdering() {
651 return new Ordering<T>() {
652 @Override
653 public int compare(T left, T right) {
654 return 0;
655 }
656
657 final String string = paramString(Ordering.class, generateInt());
658
659 @Override
660 public String toString() {
661 return string;
662 }
663 };
664 }
665
666 @Empty
667 static <C extends Comparable<?>> Range<C> generateRange() {
668 return Range.all();
669 }
670
671 @Generates
672 static <C extends Comparable<?>> Range<C> generateRange(C freshElement) {
673 return Range.singleton(freshElement);
674 }
675
676 @Generates
677 static <E> Iterable<E> generateIterable(@Nullable E freshElement) {
678 return generateList(freshElement);
679 }
680
681 @Generates
682 static <E> Collection<E> generateCollection(@Nullable E freshElement) {
683 return generateList(freshElement);
684 }
685
686 @Generates
687 static <E> List<E> generateList(@Nullable E freshElement) {
688 return generateArrayList(freshElement);
689 }
690
691 @Generates
692 static <E> ArrayList<E> generateArrayList(@Nullable E freshElement) {
693 ArrayList<E> list = Lists.newArrayList();
694 list.add(freshElement);
695 return list;
696 }
697
698 @Generates
699 static <E> LinkedList<E> generateLinkedList(@Nullable E freshElement) {
700 LinkedList<E> list = Lists.newLinkedList();
701 list.add(freshElement);
702 return list;
703 }
704
705 @Generates
706 static <E> ImmutableList<E> generateImmutableList(E freshElement) {
707 return ImmutableList.of(freshElement);
708 }
709
710 @Generates
711 static <E> ImmutableCollection<E> generateImmutableCollection(E freshElement) {
712 return generateImmutableList(freshElement);
713 }
714
715 @Generates
716 static <E> Set<E> generateSet(@Nullable E freshElement) {
717 return generateHashSet(freshElement);
718 }
719
720 @Generates
721 static <E> HashSet<E> generateHashSet(@Nullable E freshElement) {
722 return generateLinkedHashSet(freshElement);
723 }
724
725 @Generates
726 static <E> LinkedHashSet<E> generateLinkedHashSet(@Nullable E freshElement) {
727 LinkedHashSet<E> set = Sets.newLinkedHashSet();
728 set.add(freshElement);
729 return set;
730 }
731
732 @Generates
733 static <E> ImmutableSet<E> generateImmutableSet(E freshElement) {
734 return ImmutableSet.of(freshElement);
735 }
736
737 @Generates
738 static <E extends Comparable<? super E>> SortedSet<E> generateSortedSet(E freshElement) {
739 return generateNavigableSet(freshElement);
740 }
741
742 @Generates
743 static <E extends Comparable<? super E>> NavigableSet<E> generateNavigableSet(E freshElement) {
744 return generateTreeSet(freshElement);
745 }
746
747 @Generates
748 static <E extends Comparable<? super E>> TreeSet<E> generateTreeSet(E freshElement) {
749 TreeSet<E> set = Sets.newTreeSet();
750 set.add(freshElement);
751 return set;
752 }
753
754 @Generates
755 static <E extends Comparable<? super E>> ImmutableSortedSet<E> generateImmutableSortedSet(
756 E freshElement) {
757 return ImmutableSortedSet.of(freshElement);
758 }
759
760 @Generates
761 static <E> Multiset<E> generateMultiset(@Nullable E freshElement) {
762 return generateHashMultiset(freshElement);
763 }
764
765 @Generates
766 static <E> HashMultiset<E> generateHashMultiset(@Nullable E freshElement) {
767 HashMultiset<E> multiset = HashMultiset.create();
768 multiset.add(freshElement);
769 return multiset;
770 }
771
772 @Generates
773 static <E> LinkedHashMultiset<E> generateLinkedHashMultiset(@Nullable E freshElement) {
774 LinkedHashMultiset<E> multiset = LinkedHashMultiset.create();
775 multiset.add(freshElement);
776 return multiset;
777 }
778
779 @Generates
780 static <E> ImmutableMultiset<E> generateImmutableMultiset(E freshElement) {
781 return ImmutableMultiset.of(freshElement);
782 }
783
784 @Generates
785 static <E extends Comparable<E>> SortedMultiset<E> generateSortedMultiset(E freshElement) {
786 return generateTreeMultiset(freshElement);
787 }
788
789 @Generates
790 static <E extends Comparable<E>> TreeMultiset<E> generateTreeMultiset(E freshElement) {
791 TreeMultiset<E> multiset = TreeMultiset.create();
792 multiset.add(freshElement);
793 return multiset;
794 }
795
796 @Generates
797 static <E extends Comparable<E>> ImmutableSortedMultiset<E> generateImmutableSortedMultiset(
798 E freshElement) {
799 return ImmutableSortedMultiset.of(freshElement);
800 }
801
802 @Generates
803 static <K, V> Map<K, V> generateMap(@Nullable K key, @Nullable V value) {
804 return generateHashdMap(key, value);
805 }
806
807 @Generates
808 static <K, V> HashMap<K, V> generateHashdMap(@Nullable K key, @Nullable V value) {
809 return generateLinkedHashMap(key, value);
810 }
811
812 @Generates
813 static <K, V> LinkedHashMap<K, V> generateLinkedHashMap(@Nullable K key, @Nullable V value) {
814 LinkedHashMap<K, V> map = Maps.newLinkedHashMap();
815 map.put(key, value);
816 return map;
817 }
818
819 @Generates
820 static <K, V> ImmutableMap<K, V> generateImmutableMap(K key, V value) {
821 return ImmutableMap.of(key, value);
822 }
823
824 @Empty
825 static <K, V> ConcurrentMap<K, V> generateConcurrentMap() {
826 return Maps.newConcurrentMap();
827 }
828
829 @Generates
830 static <K, V> ConcurrentMap<K, V> generateConcurrentMap(K key, V value) {
831 ConcurrentMap<K, V> map = Maps.newConcurrentMap();
832 map.put(key, value);
833 return map;
834 }
835
836 @Generates
837 static <K extends Comparable<? super K>, V> SortedMap<K, V> generateSortedMap(
838 K key, @Nullable V value) {
839 return generateNavigableMap(key, value);
840 }
841
842 @Generates
843 static <K extends Comparable<? super K>, V> NavigableMap<K, V> generateNavigableMap(
844 K key, @Nullable V value) {
845 return generateTreeMap(key, value);
846 }
847
848 @Generates
849 static <K extends Comparable<? super K>, V> TreeMap<K, V> generateTreeMap(
850 K key, @Nullable V value) {
851 TreeMap<K, V> map = Maps.newTreeMap();
852 map.put(key, value);
853 return map;
854 }
855
856 @Generates
857 static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> generateImmutableSortedMap(
858 K key, V value) {
859 return ImmutableSortedMap.of(key, value);
860 }
861
862 @Generates
863 static <K, V> Multimap<K, V> generateMultimap(@Nullable K key, @Nullable V value) {
864 return generateListMultimap(key, value);
865 }
866
867 @Generates
868 static <K, V> ImmutableMultimap<K, V> generateImmutableMultimap(K key, V value) {
869 return ImmutableMultimap.of(key, value);
870 }
871
872 @Generates
873 static <K, V> ListMultimap<K, V> generateListMultimap(@Nullable K key, @Nullable V value) {
874 return generateArrayListMultimap(key, value);
875 }
876
877 @Generates
878 static <K, V> ArrayListMultimap<K, V> generateArrayListMultimap(
879 @Nullable K key, @Nullable V value) {
880 ArrayListMultimap<K, V> multimap = ArrayListMultimap.create();
881 multimap.put(key, value);
882 return multimap;
883 }
884
885 @Generates
886 static <K, V> ImmutableListMultimap<K, V> generateImmutableListMultimap(K key, V value) {
887 return ImmutableListMultimap.of(key, value);
888 }
889
890 @Generates
891 static <K, V> SetMultimap<K, V> generateSetMultimap(@Nullable K key, @Nullable V value) {
892 return generateLinkedHashMultimap(key, value);
893 }
894
895 @Generates
896 static <K, V> HashMultimap<K, V> generateHashMultimap(@Nullable K key, @Nullable V value) {
897 HashMultimap<K, V> multimap = HashMultimap.create();
898 multimap.put(key, value);
899 return multimap;
900 }
901
902 @Generates
903 static <K, V> LinkedHashMultimap<K, V> generateLinkedHashMultimap(
904 @Nullable K key, @Nullable V value) {
905 LinkedHashMultimap<K, V> multimap = LinkedHashMultimap.create();
906 multimap.put(key, value);
907 return multimap;
908 }
909
910 @Generates
911 static <K, V> ImmutableSetMultimap<K, V> generateImmutableSetMultimap(K key, V value) {
912 return ImmutableSetMultimap.of(key, value);
913 }
914
915 @Generates
916 static <K, V> BiMap<K, V> generateBimap(@Nullable K key, @Nullable V value) {
917 return generateHashBiMap(key, value);
918 }
919
920 @Generates
921 static <K, V> HashBiMap<K, V> generateHashBiMap(@Nullable K key, @Nullable V value) {
922 HashBiMap<K, V> bimap = HashBiMap.create();
923 bimap.put(key, value);
924 return bimap;
925 }
926
927 @Generates
928 static <K, V> ImmutableBiMap<K, V> generateImmutableBimap(K key, V value) {
929 return ImmutableBiMap.of(key, value);
930 }
931
932 @Generates
933 static <R, C, V> Table<R, C, V> generateTable(
934 @Nullable R row, @Nullable C column, @Nullable V value) {
935 return generateHashBasedTable(row, column, value);
936 }
937
938 @Generates
939 static <R, C, V> HashBasedTable<R, C, V> generateHashBasedTable(
940 @Nullable R row, @Nullable C column, @Nullable V value) {
941 HashBasedTable<R, C, V> table = HashBasedTable.create();
942 table.put(row, column, value);
943 return table;
944 }
945
946 @SuppressWarnings("rawtypes") // TreeBasedTable.create() is defined as such
947 @Generates
948 static <R extends Comparable, C extends Comparable, V>
949 RowSortedTable<R, C, V> generateRowSortedTable(R row, C column, V value) {
950 return generateTreeBasedTable(row, column, value);
951 }
952
953 @SuppressWarnings("rawtypes") // TreeBasedTable.create() is defined as such
954 @Generates
955 static <R extends Comparable, C extends Comparable, V>
956 TreeBasedTable<R, C, V> generateTreeBasedTable(R row, C column, V value) {
957 TreeBasedTable<R, C, V> table = TreeBasedTable.create();
958 table.put(row, column, value);
959 return table;
960 }
961
962 @Generates
963 static <R, C, V> ImmutableTable<R, C, V> generateImmutableTable(R row, C column, V value) {
964 return ImmutableTable.of(row, column, value);
965 }
966
967 // common.reflect
968 @Generates
969 TypeToken<?> generateTypeToken() {
970 return TypeToken.of(generateClass());
971 }
972
973 // io types
974 @Generates
975 File generateFile() {
976 return new File(generateString());
977 }
978
979 @Generates
980 static ByteArrayInputStream generateByteArrayInputStream() {
981 return new ByteArrayInputStream(new byte[0]);
982 }
983
984 @Generates
985 static InputStream generateInputStream() {
986 return generateByteArrayInputStream();
987 }
988
989 @Generates
990 StringReader generateStringReader() {
991 return new StringReader(generateString());
992 }
993
994 @Generates
995 Reader generateReader() {
996 return generateStringReader();
997 }
998
999 @Generates
1000 Readable generateReadable() {
1001 return generateReader();
1002 }
1003
1004 @Generates
1005 Buffer generateBuffer() {
1006 return generateCharBuffer();
1007 }
1008
1009 @Generates
1010 CharBuffer generateCharBuffer() {
1011 return CharBuffer.allocate(generateInt());
1012 }
1013
1014 @Generates
1015 ByteBuffer generateByteBuffer() {
1016 return ByteBuffer.allocate(generateInt());
1017 }
1018
1019 @Generates
1020 ShortBuffer generateShortBuffer() {
1021 return ShortBuffer.allocate(generateInt());
1022 }
1023
1024 @Generates
1025 IntBuffer generateIntBuffer() {
1026 return IntBuffer.allocate(generateInt());
1027 }
1028
1029 @Generates
1030 LongBuffer generateLongBuffer() {
1031 return LongBuffer.allocate(generateInt());
1032 }
1033
1034 @Generates
1035 FloatBuffer generateFloatBuffer() {
1036 return FloatBuffer.allocate(generateInt());
1037 }
1038
1039 @Generates
1040 DoubleBuffer generateDoubleBuffer() {
1041 return DoubleBuffer.allocate(generateInt());
1042 }
1043 }