Class FreshValueGenerator

java.lang.Object
com.google.common.testing.FreshValueGenerator

class FreshValueGenerator extends Object
Generates fresh instances of types that are different from each other (if possible).
  • Field Details

  • Constructor Details

    • FreshValueGenerator

      FreshValueGenerator()
  • Method Details

    • addSampleInstances

      final <T> void addSampleInstances(Class<T> type, Iterable<? extends T> instances)
    • generateFresh

      final Object generateFresh(TypeToken<?> type)
      Returns a fresh instance for type if possible. The returned instance could be:
      • exactly of the given type, including generic type parameters, such as ImmutableList<String>;
      • of the raw type;
      • null if no value can be generated.
    • generateFresh

      final <T> T generateFresh(Class<T> type)
    • newFreshProxy

      final <T> T newFreshProxy(Class<T> interfaceType)
    • generate

      private Object generate(TypeToken<?> type)
      Generates an instance for type using the current freshness. The generated instance may or may not be unique across different calls.
    • defaultGenerate

      private <T> T defaultGenerate(Class<T> rawType)
    • newProxy

      private <T> T newProxy(Class<T> interfaceType)
    • invokeGeneratorMethod

      private Object invokeGeneratorMethod(Method generator, Object... args)
    • interfaceMethodCalled

      @CheckForNull Object interfaceMethodCalled(Class<?> interfaceType, Method method)
      Subclasses can override to provide different return value for proxied interface methods.
    • pickInstance

      private <T> T pickInstance(T[] instances, T defaultValue)
    • pickInstance

      private <T> T pickInstance(Collection<T> instances, T defaultValue)
    • paramString

      private static String paramString(Class<?> type, int i)
    • generateClass

      Class<?> generateClass()
    • generateObject

      Object generateObject()
    • generateNumber

      Number generateNumber()
    • generateInt

      int generateInt()
    • generateInteger

      Integer generateInteger()
    • generateLong

      long generateLong()
    • generateLongObject

      Long generateLongObject()
    • generateFloat

      float generateFloat()
    • generateFloatObject

      Float generateFloatObject()
    • generateDouble

      double generateDouble()
    • generateDoubleObject

      Double generateDoubleObject()
    • generateShort

      short generateShort()
    • generateShortObject

      Short generateShortObject()
    • generateByte

      byte generateByte()
    • generateByteObject

      Byte generateByteObject()
    • generateChar

      char generateChar()
    • generateCharacter

      Character generateCharacter()
    • generateBoolean

      boolean generateBoolean()
    • generateBooleanObject

      Boolean generateBooleanObject()
    • generateUnsignedInteger

      UnsignedInteger generateUnsignedInteger()
    • generateUnsignedLong

      UnsignedLong generateUnsignedLong()
    • generateBigInteger

      BigInteger generateBigInteger()
    • generateBigDecimal

      BigDecimal generateBigDecimal()
    • generateCharSequence

      CharSequence generateCharSequence()
    • generateString

      String generateString()
    • generateComparable

      Comparable<?> generateComparable()
    • generatePattern

      Pattern generatePattern()
    • generateCharset

      Charset generateCharset()
    • generateLocale

      Locale generateLocale()
    • generateCurrency

      Currency generateCurrency()
    • generateJavaOptional

      <T> Optional<T> generateJavaOptional()
    • generateJavaOptional

      <T> Optional<T> generateJavaOptional(T value)
    • generateOptionalInt

      OptionalInt generateOptionalInt()
    • generateOptionalLong

      OptionalLong generateOptionalLong()
    • generateOptionalDouble

      OptionalDouble generateOptionalDouble()
    • generateGoogleOptional

      <T> Optional<T> generateGoogleOptional()
    • generateGoogleOptional

      <T> Optional<T> generateGoogleOptional(T value)
    • generateJoiner

      Joiner generateJoiner()
    • generateSplitter

      Splitter generateSplitter()
    • generateEquivalence

      <T> Equivalence<T> generateEquivalence()
    • generateCharMatcher

      CharMatcher generateCharMatcher()
    • generateTicker

      Ticker generateTicker()
    • generateComparator

      <T> Comparator<T> generateComparator()
    • generateOrdering

      <T> Ordering<T> generateOrdering()
    • generateRange

      static <C extends Comparable<?>> Range<C> generateRange()
    • generateRange

      static <C extends Comparable<?>> Range<C> generateRange(C freshElement)
    • generateIterable

      static <E> Iterable<E> generateIterable(E freshElement)
    • generateCollection

      static <E> Collection<E> generateCollection(E freshElement)
    • generateList

      static <E> List<E> generateList(E freshElement)
    • generateArrayList

      static <E> ArrayList<E> generateArrayList(E freshElement)
    • generateLinkedList

      static <E> LinkedList<E> generateLinkedList(E freshElement)
    • generateImmutableList

      static <E> ImmutableList<E> generateImmutableList(E freshElement)
    • generateImmutableCollection

      static <E> ImmutableCollection<E> generateImmutableCollection(E freshElement)
    • generateSet

      static <E> Set<E> generateSet(E freshElement)
    • generateHashSet

      static <E> HashSet<E> generateHashSet(E freshElement)
    • generateLinkedHashSet

      static <E> LinkedHashSet<E> generateLinkedHashSet(E freshElement)
    • generateImmutableSet

      static <E> ImmutableSet<E> generateImmutableSet(E freshElement)
    • generateSortedSet

      static <E extends Comparable<? super E>> SortedSet<E> generateSortedSet(E freshElement)
    • generateNavigableSet

      static <E extends Comparable<? super E>> NavigableSet<E> generateNavigableSet(E freshElement)
    • generateTreeSet

      static <E extends Comparable<? super E>> TreeSet<E> generateTreeSet(E freshElement)
    • generateImmutableSortedSet

      static <E extends Comparable<? super E>> ImmutableSortedSet<E> generateImmutableSortedSet(E freshElement)
    • generateMultiset

      static <E> Multiset<E> generateMultiset(E freshElement)
    • generateHashMultiset

      static <E> HashMultiset<E> generateHashMultiset(E freshElement)
    • generateLinkedHashMultiset

      static <E> LinkedHashMultiset<E> generateLinkedHashMultiset(E freshElement)
    • generateImmutableMultiset

      static <E> ImmutableMultiset<E> generateImmutableMultiset(E freshElement)
    • generateSortedMultiset

      static <E extends Comparable<E>> SortedMultiset<E> generateSortedMultiset(E freshElement)
    • generateTreeMultiset

      static <E extends Comparable<E>> TreeMultiset<E> generateTreeMultiset(E freshElement)
    • generateImmutableSortedMultiset

      static <E extends Comparable<E>> ImmutableSortedMultiset<E> generateImmutableSortedMultiset(E freshElement)
    • generateMap

      static <K, V> Map<K,V> generateMap(K key, V value)
    • generateHashdMap

      static <K, V> HashMap<K,V> generateHashdMap(K key, V value)
    • generateLinkedHashMap

      static <K, V> LinkedHashMap<K,V> generateLinkedHashMap(K key, V value)
    • generateImmutableMap

      static <K, V> ImmutableMap<K,V> generateImmutableMap(K key, V value)
    • generateConcurrentMap

      static <K, V> ConcurrentMap<K,V> generateConcurrentMap()
    • generateConcurrentMap

      static <K, V> ConcurrentMap<K,V> generateConcurrentMap(K key, V value)
    • generateSortedMap

      static <K extends Comparable<? super K>, V> SortedMap<K,V> generateSortedMap(K key, V value)
    • generateNavigableMap

      static <K extends Comparable<? super K>, V> NavigableMap<K,V> generateNavigableMap(K key, V value)
    • generateTreeMap

      static <K extends Comparable<? super K>, V> TreeMap<K,V> generateTreeMap(K key, V value)
    • generateImmutableSortedMap

      static <K extends Comparable<? super K>, V> ImmutableSortedMap<K,V> generateImmutableSortedMap(K key, V value)
    • generateMultimap

      static <K, V> Multimap<K,V> generateMultimap(K key, V value)
    • generateImmutableMultimap

      static <K, V> ImmutableMultimap<K,V> generateImmutableMultimap(K key, V value)
    • generateListMultimap

      static <K, V> ListMultimap<K,V> generateListMultimap(K key, V value)
    • generateArrayListMultimap

      static <K, V> ArrayListMultimap<K,V> generateArrayListMultimap(K key, V value)
    • generateImmutableListMultimap

      static <K, V> ImmutableListMultimap<K,V> generateImmutableListMultimap(K key, V value)
    • generateSetMultimap

      static <K, V> SetMultimap<K,V> generateSetMultimap(K key, V value)
    • generateHashMultimap

      static <K, V> HashMultimap<K,V> generateHashMultimap(K key, V value)
    • generateLinkedHashMultimap

      static <K, V> LinkedHashMultimap<K,V> generateLinkedHashMultimap(K key, V value)
    • generateImmutableSetMultimap

      static <K, V> ImmutableSetMultimap<K,V> generateImmutableSetMultimap(K key, V value)
    • generateBimap

      static <K, V> BiMap<K,V> generateBimap(K key, V value)
    • generateHashBiMap

      static <K, V> HashBiMap<K,V> generateHashBiMap(K key, V value)
    • generateImmutableBimap

      static <K, V> ImmutableBiMap<K,V> generateImmutableBimap(K key, V value)
    • generateTable

      static <R, C, V> Table<R,C,V> generateTable(R row, C column, V value)
    • generateHashBasedTable

      static <R, C, V> HashBasedTable<R,C,V> generateHashBasedTable(R row, C column, V value)
    • generateRowSortedTable

      static <R extends Comparable, C extends Comparable, V> RowSortedTable<R,C,V> generateRowSortedTable(R row, C column, V value)
    • generateTreeBasedTable

      static <R extends Comparable, C extends Comparable, V> TreeBasedTable<R,C,V> generateTreeBasedTable(R row, C column, V value)
    • generateImmutableTable

      static <R, C, V> ImmutableTable<R,C,V> generateImmutableTable(R row, C column, V value)
    • generateTypeToken

      TypeToken<?> generateTypeToken()
    • generateFile

      File generateFile()
    • generateByteArrayInputStream

      static ByteArrayInputStream generateByteArrayInputStream()
    • generateInputStream

      static InputStream generateInputStream()
    • generateStringReader

      StringReader generateStringReader()
    • generateReader

      Reader generateReader()
    • generateReadable

      Readable generateReadable()
    • generateBuffer

      Buffer generateBuffer()
    • generateCharBuffer

      CharBuffer generateCharBuffer()
    • generateByteBuffer

      ByteBuffer generateByteBuffer()
    • generateShortBuffer

      ShortBuffer generateShortBuffer()
    • generateIntBuffer

      IntBuffer generateIntBuffer()
    • generateLongBuffer

      LongBuffer generateLongBuffer()
    • generateFloatBuffer

      FloatBuffer generateFloatBuffer()
    • generateDoubleBuffer

      DoubleBuffer generateDoubleBuffer()