Java

FreshValueGenerator.java
1026 строк · 28.7 Кб
Перенос по словам
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
import static java.nio.charset.StandardCharsets.UTF_8;
22
import static java.util.Objects.requireNonNull;
23

24
import com.google.common.annotations.GwtIncompatible;
25
import com.google.common.annotations.J2ktIncompatible;
26
import com.google.common.base.CharMatcher;
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;
76
import java.io.File;
77
import java.io.InputStream;
78
import java.io.Reader;
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;
112
import java.util.Map;
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;
119
import java.util.Set;
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;
129

130
/**
131
 * Generates fresh instances of types that are different from each other (if possible).
132
 *
133
 * @author Ben Yu
134
 */
135
@GwtIncompatible
136
@J2ktIncompatible
137
class FreshValueGenerator {
138

139
  private static final ImmutableMap<Class<?>, Method> GENERATORS;
140

141
  static {
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);
146
      }
147
    }
148
    GENERATORS = builder.buildOrThrow();
149
  }
150

151
  private static final ImmutableMap<Class<?>, Method> EMPTY_GENERATORS;
152

153
  static {
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);
158
      }
159
    }
160
    EMPTY_GENERATORS = builder.buildOrThrow();
161
  }
162

163
  private final AtomicInteger freshness = new AtomicInteger(1);
164
  private final ListMultimap<Class<?>, Object> sampleInstances = ArrayListMultimap.create();
165

166
  /**
167
   * The freshness level at which the {@link Empty @Empty} annotated method was invoked to generate
168
   * instance.
169
   */
170
  private final Map<Type, Integer> emptyInstanceGenerated = new HashMap<>();
171

172
  final <T> void addSampleInstances(Class<T> type, Iterable<? extends T> instances) {
173
    sampleInstances.putAll(checkNotNull(type), checkNotNull(instances));
174
  }
175

176
  /**
177
   * Returns a fresh instance for {@code type} if possible. The returned instance could be:
178
   *
179
   * <ul>
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.
184
   * </ul>
185
   */
186
  final @Nullable Object generateFresh(TypeToken<?> type) {
187
    Object generated = generate(type);
188
    if (generated != null) {
189
      freshness.incrementAndGet();
190
    }
191
    return generated;
192
  }
193

194
  final <T> @Nullable T generateFresh(Class<T> type) {
195
    return Primitives.wrap(type).cast(generateFresh(TypeToken.of(type)));
196
  }
197

198
  final <T> T newFreshProxy(final Class<T> interfaceType) {
199
    T proxy = newProxy(interfaceType);
200
    freshness.incrementAndGet();
201
    return proxy;
202
  }
203

204
  /**
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.
207
   */
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) {
213
      return sample;
214
    }
215
    if (rawType.isEnum()) {
216
      return pickInstance(rawType.getEnumConstants(), null);
217
    }
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));
222
      return array;
223
    }
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);
231
        } else {
232
          // Cannot use empty generator. Proceed with other generators.
233
        }
234
      } else {
235
        // never generated empty instance for this type before.
236
        Object emptyInstance = invokeGeneratorMethod(emptyGenerate);
237
        emptyInstanceGenerated.put(type.getType(), freshness.get());
238
        return emptyInstance;
239
      }
240
    }
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.
256
          return null;
257
        }
258
        args.add(argValue);
259
      }
260
      return invokeGeneratorMethod(generate, args.toArray());
261
    }
262
    return defaultGenerate(rawType);
263
  }
264

265
  private <T> @Nullable T defaultGenerate(Class<T> rawType) {
266
    if (rawType.isInterface()) {
267
      // always create a new proxy
268
      return newProxy(rawType);
269
    }
270
    return ArbitraryInstances.get(rawType);
271
  }
272

273
  private <T> T newProxy(final Class<T> interfaceType) {
274
    return Reflection.newProxy(interfaceType, new FreshInvocationHandler(interfaceType));
275
  }
276

277
  private Object invokeGeneratorMethod(Method generator, Object... args) {
278
    try {
279
      return generator.invoke(this, args);
280
    } catch (InvocationTargetException e) {
281
      throwIfUnchecked(e.getCause());
282
      throw new RuntimeException(e.getCause());
283
    } catch (Exception e) {
284
      throwIfUnchecked(e);
285
      throw new RuntimeException(e);
286
    }
287
  }
288

289
  private final class FreshInvocationHandler extends AbstractInvocationHandler {
290
    private final int identity = generateInt();
291
    private final Class<?> interfaceType;
292

293
    FreshInvocationHandler(Class<?> interfaceType) {
294
      this.interfaceType = interfaceType;
295
    }
296

297
    @Override
298
    @CheckForNull
299
    protected Object handleInvocation(Object proxy, Method method, @Nullable Object[] args) {
300
      return interfaceMethodCalled(interfaceType, method);
301
    }
302

303
    @Override
304
    public int hashCode() {
305
      return identity;
306
    }
307

308
    @Override
309
    public boolean equals(@Nullable Object obj) {
310
      if (obj instanceof FreshInvocationHandler) {
311
        FreshInvocationHandler that = (FreshInvocationHandler) obj;
312
        return identity == that.identity;
313
      }
314
      return false;
315
    }
316

317
    @Override
318
    public String toString() {
319
      return paramString(interfaceType, identity);
320
    }
321
  }
322

323
  /** Subclasses can override to provide different return value for proxied interface methods. */
324
  @CheckForNull
325
  Object interfaceMethodCalled(Class<?> interfaceType, Method method) {
326
    throw new UnsupportedOperationException();
327
  }
328

329
  private <T> T pickInstance(T[] instances, T defaultValue) {
330
    return pickInstance(Arrays.asList(instances), defaultValue);
331
  }
332

333
  private <T> T pickInstance(Collection<T> instances, T defaultValue) {
334
    if (instances.isEmpty()) {
335
      return defaultValue;
336
    }
337
    // generateInt() is 1-based.
338
    return Iterables.get(instances, (generateInt() - 1) % instances.size());
339
  }
340

341
  private static String paramString(Class<?> type, int i) {
342
    return type.getSimpleName() + '@' + i;
343
  }
344

345
  /**
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)}.
350
   */
351
  @Target(ElementType.METHOD)
352
  @Retention(RetentionPolicy.RUNTIME)
353
  private @interface Generates {}
354

355
  /**
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}.
359
   */
360
  @Target(ElementType.METHOD)
361
  @Retention(RetentionPolicy.RUNTIME)
362
  private @interface Empty {}
363

364
  @Generates
365
  Class<?> generateClass() {
366
    return pickInstance(
367
        ImmutableList.of(
368
            int.class, long.class, void.class, Object.class, Object[].class, Iterable.class),
369
        Object.class);
370
  }
371

372
  @Generates
373
  Object generateObject() {
374
    return generateString();
375
  }
376

377
  @Generates
378
  Number generateNumber() {
379
    return generateInt();
380
  }
381

382
  @Generates
383
  int generateInt() {
384
    return freshness.get();
385
  }
386

387
  @SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
388
  @Generates
389
  Integer generateInteger() {
390
    return new Integer(generateInt());
391
  }
392

393
  @Generates
394
  long generateLong() {
395
    return generateInt();
396
  }
397

398
  @SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
399
  @Generates
400
  Long generateLongObject() {
401
    return new Long(generateLong());
402
  }
403

404
  @Generates
405
  float generateFloat() {
406
    return generateInt();
407
  }
408

409
  @SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
410
  @Generates
411
  Float generateFloatObject() {
412
    return new Float(generateFloat());
413
  }
414

415
  @Generates
416
  double generateDouble() {
417
    return generateInt();
418
  }
419

420
  @SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
421
  @Generates
422
  Double generateDoubleObject() {
423
    return new Double(generateDouble());
424
  }
425

426
  @Generates
427
  short generateShort() {
428
    return (short) generateInt();
429
  }
430

431
  @SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
432
  @Generates
433
  Short generateShortObject() {
434
    return new Short(generateShort());
435
  }
436

437
  @Generates
438
  byte generateByte() {
439
    return (byte) generateInt();
440
  }
441

442
  @SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
443
  @Generates
444
  Byte generateByteObject() {
445
    return new Byte(generateByte());
446
  }
447

448
  @Generates
449
  char generateChar() {
450
    return generateString().charAt(0);
451
  }
452

453
  @SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
454
  @Generates
455
  Character generateCharacter() {
456
    return new Character(generateChar());
457
  }
458

459
  @Generates
460
  boolean generateBoolean() {
461
    return generateInt() % 2 == 0;
462
  }
463

464
  @SuppressWarnings("removal") // b/321209431 -- maybe just use valueOf here?
465
  @Generates
466
  Boolean generateBooleanObject() {
467
    return new Boolean(generateBoolean());
468
  }
469

470
  @Generates
471
  UnsignedInteger generateUnsignedInteger() {
472
    return UnsignedInteger.fromIntBits(generateInt());
473
  }
474

475
  @Generates
476
  UnsignedLong generateUnsignedLong() {
477
    return UnsignedLong.fromLongBits(generateLong());
478
  }
479

480
  @Generates
481
  BigInteger generateBigInteger() {
482
    return BigInteger.valueOf(generateInt());
483
  }
484

485
  @Generates
486
  BigDecimal generateBigDecimal() {
487
    return BigDecimal.valueOf(generateInt());
488
  }
489

490
  @Generates
491
  CharSequence generateCharSequence() {
492
    return generateString();
493
  }
494

495
  @Generates
496
  String generateString() {
497
    return Integer.toString(generateInt());
498
  }
499

500
  @Generates
501
  Comparable<?> generateComparable() {
502
    return generateString();
503
  }
504

505
  @Generates
506
  Pattern generatePattern() {
507
    return Pattern.compile(generateString());
508
  }
509

510
  @Generates
511
  Charset generateCharset() {
512
    return pickInstance(Charset.availableCharsets().values(), UTF_8);
513
  }
514

515
  @Generates
516
  Locale generateLocale() {
517
    return pickInstance(Locale.getAvailableLocales(), Locale.US);
518
  }
519

520
  @Generates
521
  Currency generateCurrency() {
522
    return pickInstance(Currency.getAvailableCurrencies(), Currency.getInstance(Locale.US));
523
  }
524

525
  @Empty
526
  <T> Optional<T> generateJavaOptional() {
527
    return Optional.empty();
528
  }
529

530
  @Generates
531
  <T> Optional<T> generateJavaOptional(T value) {
532
    return Optional.of(value);
533
  }
534

535
  @Generates
536
  OptionalInt generateOptionalInt() {
537
    return OptionalInt.of(generateInt());
538
  }
539

540
  @Generates
541
  OptionalLong generateOptionalLong() {
542
    return OptionalLong.of(generateLong());
543
  }
544

545
  @Generates
546
  OptionalDouble generateOptionalDouble() {
547
    return OptionalDouble.of(generateDouble());
548
  }
549

550
  // common.base
551
  @Empty
552
  <T> com.google.common.base.Optional<T> generateGoogleOptional() {
553
    return com.google.common.base.Optional.absent();
554
  }
555

556
  @Generates
557
  <T> com.google.common.base.Optional<T> generateGoogleOptional(T value) {
558
    return com.google.common.base.Optional.of(value);
559
  }
560

561
  @Generates
562
  Joiner generateJoiner() {
563
    return Joiner.on(generateString());
564
  }
565

566
  @Generates
567
  Splitter generateSplitter() {
568
    return Splitter.on(generateString());
569
  }
570

571
  @Generates
572
  <T> Equivalence<T> generateEquivalence() {
573
    return new Equivalence<T>() {
574
      @Override
575
      protected boolean doEquivalent(T a, T b) {
576
        return false;
577
      }
578

579
      @Override
580
      protected int doHash(T t) {
581
        return 0;
582
      }
583

584
      final String string = paramString(Equivalence.class, generateInt());
585

586
      @Override
587
      public String toString() {
588
        return string;
589
      }
590
    };
591
  }
592

593
  @Generates
594
  CharMatcher generateCharMatcher() {
595
    return new CharMatcher() {
596
      @Override
597
      public boolean matches(char c) {
598
        return false;
599
      }
600

601
      final String string = paramString(CharMatcher.class, generateInt());
602

603
      @Override
604
      public String toString() {
605
        return string;
606
      }
607
    };
608
  }
609

610
  @Generates
611
  Ticker generateTicker() {
612
    return new Ticker() {
613
      @Override
614
      public long read() {
615
        return 0;
616
      }
617

618
      final String string = paramString(Ticker.class, generateInt());
619

620
      @Override
621
      public String toString() {
622
        return string;
623
      }
624
    };
625
  }
626

627
  // collect
628
  @Generates
629
  <T> Comparator<T> generateComparator() {
630
    return generateOrdering();
631
  }
632

633
  @Generates
634
  <T extends @Nullable Object> Ordering<T> generateOrdering() {
635
    return new Ordering<T>() {
636
      @Override
637
      @SuppressWarnings("UnusedVariable") // intentionally weird Comparator
638
      public int compare(T left, T right) {
639
        return 0;
640
      }
641

642
      final String string = paramString(Ordering.class, generateInt());
643

644
      @Override
645
      public String toString() {
646
        return string;
647
      }
648
    };
649
  }
650

651
  @Empty
652
  static <C extends Comparable<?>> Range<C> generateRange() {
653
    return Range.all();
654
  }
655

656
  @Generates
657
  static <C extends Comparable<?>> Range<C> generateRange(C freshElement) {
658
    return Range.singleton(freshElement);
659
  }
660

661
  @Generates
662
  static <E> Iterable<E> generateIterable(@Nullable E freshElement) {
663
    return generateList(freshElement);
664
  }
665

666
  @Generates
667
  static <E> Collection<E> generateCollection(@Nullable E freshElement) {
668
    return generateList(freshElement);
669
  }
670

671
  @Generates
672
  static <E> List<E> generateList(@Nullable E freshElement) {
673
    return generateArrayList(freshElement);
674
  }
675

676
  @Generates
677
  static <E> ArrayList<E> generateArrayList(@Nullable E freshElement) {
678
    ArrayList<E> list = Lists.newArrayList();
679
    list.add(freshElement);
680
    return list;
681
  }
682

683
  @Generates
684
  static <E> LinkedList<E> generateLinkedList(@Nullable E freshElement) {
685
    LinkedList<E> list = Lists.newLinkedList();
686
    list.add(freshElement);
687
    return list;
688
  }
689

690
  @Generates
691
  static <E> ImmutableList<E> generateImmutableList(E freshElement) {
692
    return ImmutableList.of(freshElement);
693
  }
694

695
  @Generates
696
  static <E> ImmutableCollection<E> generateImmutableCollection(E freshElement) {
697
    return generateImmutableList(freshElement);
698
  }
699

700
  @Generates
701
  static <E> Set<E> generateSet(@Nullable E freshElement) {
702
    return generateHashSet(freshElement);
703
  }
704

705
  @Generates
706
  static <E> HashSet<E> generateHashSet(@Nullable E freshElement) {
707
    return generateLinkedHashSet(freshElement);
708
  }
709

710
  @Generates
711
  static <E> LinkedHashSet<E> generateLinkedHashSet(@Nullable E freshElement) {
712
    LinkedHashSet<E> set = Sets.newLinkedHashSet();
713
    set.add(freshElement);
714
    return set;
715
  }
716

717
  @Generates
718
  static <E> ImmutableSet<E> generateImmutableSet(E freshElement) {
719
    return ImmutableSet.of(freshElement);
720
  }
721

722
  @Generates
723
  static <E extends Comparable<? super E>> SortedSet<E> generateSortedSet(E freshElement) {
724
    return generateNavigableSet(freshElement);
725
  }
726

727
  @Generates
728
  static <E extends Comparable<? super E>> NavigableSet<E> generateNavigableSet(E freshElement) {
729
    return generateTreeSet(freshElement);
730
  }
731

732
  @Generates
733
  static <E extends Comparable<? super E>> TreeSet<E> generateTreeSet(E freshElement) {
734
    TreeSet<E> set = Sets.newTreeSet();
735
    set.add(freshElement);
736
    return set;
737
  }
738

739
  @Generates
740
  static <E extends Comparable<? super E>> ImmutableSortedSet<E> generateImmutableSortedSet(
741
      E freshElement) {
742
    return ImmutableSortedSet.of(freshElement);
743
  }
744

745
  @Generates
746
  static <E> Multiset<E> generateMultiset(@Nullable E freshElement) {
747
    return generateHashMultiset(freshElement);
748
  }
749

750
  @Generates
751
  static <E> HashMultiset<E> generateHashMultiset(@Nullable E freshElement) {
752
    HashMultiset<E> multiset = HashMultiset.create();
753
    multiset.add(freshElement);
754
    return multiset;
755
  }
756

757
  @Generates
758
  static <E> LinkedHashMultiset<E> generateLinkedHashMultiset(@Nullable E freshElement) {
759
    LinkedHashMultiset<E> multiset = LinkedHashMultiset.create();
760
    multiset.add(freshElement);
761
    return multiset;
762
  }
763

764
  @Generates
765
  static <E> ImmutableMultiset<E> generateImmutableMultiset(E freshElement) {
766
    return ImmutableMultiset.of(freshElement);
767
  }
768

769
  @Generates
770
  static <E extends Comparable<E>> SortedMultiset<E> generateSortedMultiset(E freshElement) {
771
    return generateTreeMultiset(freshElement);
772
  }
773

774
  @Generates
775
  static <E extends Comparable<E>> TreeMultiset<E> generateTreeMultiset(E freshElement) {
776
    TreeMultiset<E> multiset = TreeMultiset.create();
777
    multiset.add(freshElement);
778
    return multiset;
779
  }
780

781
  @Generates
782
  static <E extends Comparable<E>> ImmutableSortedMultiset<E> generateImmutableSortedMultiset(
783
      E freshElement) {
784
    return ImmutableSortedMultiset.of(freshElement);
785
  }
786

787
  @Generates
788
  static <K, V> Map<K, V> generateMap(@Nullable K key, @Nullable V value) {
789
    return generateHashdMap(key, value);
790
  }
791

792
  @Generates
793
  static <K, V> HashMap<K, V> generateHashdMap(@Nullable K key, @Nullable V value) {
794
    return generateLinkedHashMap(key, value);
795
  }
796

797
  @Generates
798
  static <K, V> LinkedHashMap<K, V> generateLinkedHashMap(@Nullable K key, @Nullable V value) {
799
    LinkedHashMap<K, V> map = Maps.newLinkedHashMap();
800
    map.put(key, value);
801
    return map;
802
  }
803

804
  @Generates
805
  static <K, V> ImmutableMap<K, V> generateImmutableMap(K key, V value) {
806
    return ImmutableMap.of(key, value);
807
  }
808

809
  @Empty
810
  static <K, V> ConcurrentMap<K, V> generateConcurrentMap() {
811
    return Maps.newConcurrentMap();
812
  }
813

814
  @Generates
815
  static <K, V> ConcurrentMap<K, V> generateConcurrentMap(K key, V value) {
816
    ConcurrentMap<K, V> map = Maps.newConcurrentMap();
817
    map.put(key, value);
818
    return map;
819
  }
820

821
  @Generates
822
  static <K extends Comparable<? super K>, V> SortedMap<K, V> generateSortedMap(
823
      K key, @Nullable V value) {
824
    return generateNavigableMap(key, value);
825
  }
826

827
  @Generates
828
  static <K extends Comparable<? super K>, V> NavigableMap<K, V> generateNavigableMap(
829
      K key, @Nullable V value) {
830
    return generateTreeMap(key, value);
831
  }
832

833
  @Generates
834
  static <K extends Comparable<? super K>, V> TreeMap<K, V> generateTreeMap(
835
      K key, @Nullable V value) {
836
    TreeMap<K, V> map = Maps.newTreeMap();
837
    map.put(key, value);
838
    return map;
839
  }
840

841
  @Generates
842
  static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> generateImmutableSortedMap(
843
      K key, V value) {
844
    return ImmutableSortedMap.of(key, value);
845
  }
846

847
  @Generates
848
  static <K, V> Multimap<K, V> generateMultimap(@Nullable K key, @Nullable V value) {
849
    return generateListMultimap(key, value);
850
  }
851

852
  @Generates
853
  static <K, V> ImmutableMultimap<K, V> generateImmutableMultimap(K key, V value) {
854
    return ImmutableMultimap.of(key, value);
855
  }
856

857
  @Generates
858
  static <K, V> ListMultimap<K, V> generateListMultimap(@Nullable K key, @Nullable V value) {
859
    return generateArrayListMultimap(key, value);
860
  }
861

862
  @Generates
863
  static <K, V> ArrayListMultimap<K, V> generateArrayListMultimap(
864
      @Nullable K key, @Nullable V value) {
865
    ArrayListMultimap<K, V> multimap = ArrayListMultimap.create();
866
    multimap.put(key, value);
867
    return multimap;
868
  }
869

870
  @Generates
871
  static <K, V> ImmutableListMultimap<K, V> generateImmutableListMultimap(K key, V value) {
872
    return ImmutableListMultimap.of(key, value);
873
  }
874

875
  @Generates
876
  static <K, V> SetMultimap<K, V> generateSetMultimap(@Nullable K key, @Nullable V value) {
877
    return generateLinkedHashMultimap(key, value);
878
  }
879

880
  @Generates
881
  static <K, V> HashMultimap<K, V> generateHashMultimap(@Nullable K key, @Nullable V value) {
882
    HashMultimap<K, V> multimap = HashMultimap.create();
883
    multimap.put(key, value);
884
    return multimap;
885
  }
886

887
  @Generates
888
  static <K, V> LinkedHashMultimap<K, V> generateLinkedHashMultimap(
889
      @Nullable K key, @Nullable V value) {
890
    LinkedHashMultimap<K, V> multimap = LinkedHashMultimap.create();
891
    multimap.put(key, value);
892
    return multimap;
893
  }
894

895
  @Generates
896
  static <K, V> ImmutableSetMultimap<K, V> generateImmutableSetMultimap(K key, V value) {
897
    return ImmutableSetMultimap.of(key, value);
898
  }
899

900
  @Generates
901
  static <K, V> BiMap<K, V> generateBimap(@Nullable K key, @Nullable V value) {
902
    return generateHashBiMap(key, value);
903
  }
904

905
  @Generates
906
  static <K, V> HashBiMap<K, V> generateHashBiMap(@Nullable K key, @Nullable V value) {
907
    HashBiMap<K, V> bimap = HashBiMap.create();
908
    bimap.put(key, value);
909
    return bimap;
910
  }
911

912
  @Generates
913
  static <K, V> ImmutableBiMap<K, V> generateImmutableBimap(K key, V value) {
914
    return ImmutableBiMap.of(key, value);
915
  }
916

917
  @Generates
918
  static <R, C, V> Table<R, C, V> generateTable(R row, C column, V value) {
919
    return generateHashBasedTable(row, column, value);
920
  }
921

922
  @Generates
923
  static <R, C, V> HashBasedTable<R, C, V> generateHashBasedTable(R row, C column, V value) {
924
    HashBasedTable<R, C, V> table = HashBasedTable.create();
925
    table.put(row, column, value);
926
    return table;
927
  }
928

929
  @SuppressWarnings("rawtypes") // TreeBasedTable.create() is defined as such
930
  @Generates
931
  static <R extends Comparable, C extends Comparable, V>
932
      RowSortedTable<R, C, V> generateRowSortedTable(R row, C column, V value) {
933
    return generateTreeBasedTable(row, column, value);
934
  }
935

936
  @SuppressWarnings("rawtypes") // TreeBasedTable.create() is defined as such
937
  @Generates
938
  static <R extends Comparable, C extends Comparable, V>
939
      TreeBasedTable<R, C, V> generateTreeBasedTable(R row, C column, V value) {
940
    TreeBasedTable<R, C, V> table = TreeBasedTable.create();
941
    table.put(row, column, value);
942
    return table;
943
  }
944

945
  @Generates
946
  static <R, C, V> ImmutableTable<R, C, V> generateImmutableTable(R row, C column, V value) {
947
    return ImmutableTable.of(row, column, value);
948
  }
949

950
  // common.reflect
951
  @Generates
952
  TypeToken<?> generateTypeToken() {
953
    return TypeToken.of(generateClass());
954
  }
955

956
  // io types
957
  @Generates
958
  File generateFile() {
959
    return new File(generateString());
960
  }
961

962
  @Generates
963
  static ByteArrayInputStream generateByteArrayInputStream() {
964
    return new ByteArrayInputStream(new byte[0]);
965
  }
966

967
  @Generates
968
  static InputStream generateInputStream() {
969
    return generateByteArrayInputStream();
970
  }
971

972
  @Generates
973
  StringReader generateStringReader() {
974
    return new StringReader(generateString());
975
  }
976

977
  @Generates
978
  Reader generateReader() {
979
    return generateStringReader();
980
  }
981

982
  @Generates
983
  Readable generateReadable() {
984
    return generateReader();
985
  }
986

987
  @Generates
988
  Buffer generateBuffer() {
989
    return generateCharBuffer();
990
  }
991

992
  @Generates
993
  CharBuffer generateCharBuffer() {
994
    return CharBuffer.allocate(generateInt());
995
  }
996

997
  @Generates
998
  ByteBuffer generateByteBuffer() {
999
    return ByteBuffer.allocate(generateInt());
1000
  }
1001

1002
  @Generates
1003
  ShortBuffer generateShortBuffer() {
1004
    return ShortBuffer.allocate(generateInt());
1005
  }
1006

1007
  @Generates
1008
  IntBuffer generateIntBuffer() {
1009
    return IntBuffer.allocate(generateInt());
1010
  }
1011

1012
  @Generates
1013
  LongBuffer generateLongBuffer() {
1014
    return LongBuffer.allocate(generateInt());
1015
  }
1016

1017
  @Generates
1018
  FloatBuffer generateFloatBuffer() {
1019
    return FloatBuffer.allocate(generateInt());
1020
  }
1021

1022
  @Generates
1023
  DoubleBuffer generateDoubleBuffer() {
1024
    return DoubleBuffer.allocate(generateInt());
1025
  }
1026
}
1027
Java

Использование cookies
