Package com.google.common.testing

Class FreshValueGenerator

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

    • Field Detail

      • GENERATORS

        private static final ImmutableMap<java.lang.Class<?>,​java.lang.reflect.Method> GENERATORS

      • EMPTY_GENERATORS

        private static final ImmutableMap<java.lang.Class<?>,​java.lang.reflect.Method> EMPTY_GENERATORS

      • freshness

        private final java.util.concurrent.atomic.AtomicInteger freshness

      • sampleInstances

        private final ListMultimap<java.lang.Class<?>,​java.lang.Object> sampleInstances

      • emptyInstanceGenerated

        private final java.util.Map<java.lang.reflect.Type,​java.lang.Integer> emptyInstanceGenerated
        The freshness level at which the @Empty annotated method was invoked to generate instance.

    • Constructor Detail

      • FreshValueGenerator

        FreshValueGenerator()

    • Method Detail

      • addSampleInstances

        final <T> void addSampleInstances​(java.lang.Class<T> type,
                                  java.lang.Iterable<? extends T> instances)

      • generateFresh

        final java.lang.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​(java.lang.Class<T> type)

      • newFreshProxy

        final <T> T newFreshProxy​(java.lang.Class<T> interfaceType)

      • generate

        private java.lang.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​(java.lang.Class<T> rawType)

      • newProxy

        private <T> T newProxy​(java.lang.Class<T> interfaceType)

      • invokeGeneratorMethod

        private java.lang.Object invokeGeneratorMethod​(java.lang.reflect.Method generator,
                                               java.lang.Object... args)

      • interfaceMethodCalled

        java.lang.Object interfaceMethodCalled​(java.lang.Class<?> interfaceType,
                                       java.lang.reflect.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​(java.util.Collection<T> instances,
                           T defaultValue)

      • paramString

        private static java.lang.String paramString​(java.lang.Class<?> type,
                                            int i)

      • generateClass

        java.lang.Class<?> generateClass()

      • generateObject

        java.lang.Object generateObject()

      • generateNumber

        java.lang.Number generateNumber()

      • generateInt

        int generateInt()

      • generateInteger

        java.lang.Integer generateInteger()

      • generateLong

        long generateLong()

      • generateLongObject

        java.lang.Long generateLongObject()

      • generateFloat

        float generateFloat()

      • generateFloatObject

        java.lang.Float generateFloatObject()

      • generateDouble

        double generateDouble()

      • generateDoubleObject

        java.lang.Double generateDoubleObject()

      • generateShort

        short generateShort()

      • generateShortObject

        java.lang.Short generateShortObject()

      • generateByte

        byte generateByte()

      • generateByteObject

        java.lang.Byte generateByteObject()

      • generateChar

        char generateChar()

      • generateCharacter

        java.lang.Character generateCharacter()

      • generateBoolean

        boolean generateBoolean()

      • generateBooleanObject

        java.lang.Boolean generateBooleanObject()

      • generateBigInteger

        java.math.BigInteger generateBigInteger()

      • generateBigDecimal

        java.math.BigDecimal generateBigDecimal()

      • generateCharSequence

        java.lang.CharSequence generateCharSequence()

      • generateString

        java.lang.String generateString()

      • generateComparable

        java.lang.Comparable<?> generateComparable()

      • generatePattern

        java.util.regex.Pattern generatePattern()

      • generateCharset

        java.nio.charset.Charset generateCharset()

      • generateLocale

        java.util.Locale generateLocale()

      • generateCurrency

        java.util.Currency generateCurrency()

      • preJava7FreshCurrency

        private java.util.Currency preJava7FreshCurrency()

      • generateJavaOptional

        <T> java.util.Optional<T> generateJavaOptional()

      • generateJavaOptional

        <T> java.util.Optional<T> generateJavaOptional​(T value)

      • generateOptionalInt

        java.util.OptionalInt generateOptionalInt()

      • generateOptionalLong

        java.util.OptionalLong generateOptionalLong()

      • generateOptionalDouble

        java.util.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> java.util.Comparator<T> generateComparator()

      • generateOrdering

        <T> Ordering<T> generateOrdering()

      • generateRange

        static <C extends java.lang.Comparable<?>> Range<C> generateRange()

      • generateRange

        static <C extends java.lang.Comparable<?>> Range<C> generateRange​(C freshElement)

      • generateIterable

        static <E> java.lang.Iterable<E> generateIterable​(E freshElement)

      • generateCollection

        static <E> java.util.Collection<E> generateCollection​(E freshElement)

      • generateList

        static <E> java.util.List<E> generateList​(E freshElement)

      • generateArrayList

        static <E> java.util.ArrayList<E> generateArrayList​(E freshElement)

      • generateLinkedList

        static <E> java.util.LinkedList<E> generateLinkedList​(E freshElement)

      • generateImmutableList

        static <E> ImmutableList<E> generateImmutableList​(E freshElement)

      • generateImmutableCollection

        static <E> ImmutableCollection<E> generateImmutableCollection​(E freshElement)

      • generateSet

        static <E> java.util.Set<E> generateSet​(E freshElement)

      • generateHashSet

        static <E> java.util.HashSet<E> generateHashSet​(E freshElement)

      • generateLinkedHashSet

        static <E> java.util.LinkedHashSet<E> generateLinkedHashSet​(E freshElement)

      • generateImmutableSet

        static <E> ImmutableSet<E> generateImmutableSet​(E freshElement)

      • generateSortedSet

        static <E extends java.lang.Comparable<? super E>> java.util.SortedSet<E> generateSortedSet​(E freshElement)

      • generateNavigableSet

        static <E extends java.lang.Comparable<? super E>> java.util.NavigableSet<E> generateNavigableSet​(E freshElement)

      • generateTreeSet

        static <E extends java.lang.Comparable<? super E>> java.util.TreeSet<E> generateTreeSet​(E freshElement)

      • generateImmutableSortedSet

        static <E extends java.lang.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 java.lang.Comparable<E>> SortedMultiset<E> generateSortedMultiset​(E freshElement)

      • generateTreeMultiset

        static <E extends java.lang.Comparable<E>> TreeMultiset<E> generateTreeMultiset​(E freshElement)

      • generateImmutableSortedMultiset

        static <E extends java.lang.Comparable<E>> ImmutableSortedMultiset<E> generateImmutableSortedMultiset​(E freshElement)

      • generateMap

        static <K,​V> java.util.Map<K,​V> generateMap​(K key,
                                                        V value)

      • generateHashdMap

        static <K,​V> java.util.HashMap<K,​V> generateHashdMap​(K key,
                                                                 V value)

      • generateLinkedHashMap

        static <K,​V> java.util.LinkedHashMap<K,​V> generateLinkedHashMap​(K key,
                                                                            V value)

      • generateImmutableMap

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

      • generateConcurrentMap

        static <K,​V> java.util.concurrent.ConcurrentMap<K,​V> generateConcurrentMap()

      • generateConcurrentMap

        static <K,​V> java.util.concurrent.ConcurrentMap<K,​V> generateConcurrentMap​(K key,
                                                                                       V value)

      • generateSortedMap

        static <K extends java.lang.Comparable<? super K>,​V> java.util.SortedMap<K,​V> generateSortedMap​(K key,
                                                                                                            V value)

      • generateNavigableMap

        static <K extends java.lang.Comparable<? super K>,​V> java.util.NavigableMap<K,​V> generateNavigableMap​(K key,
                                                                                                                  V value)

      • generateTreeMap

        static <K extends java.lang.Comparable<? super K>,​V> java.util.TreeMap<K,​V> generateTreeMap​(K key,
                                                                                                        V value)

      • generateImmutableSortedMap

        static <K extends java.lang.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 java.lang.Comparable,​C extends java.lang.Comparable,​V> RowSortedTable<R,​C,​V> generateRowSortedTable​(R row,
                                                                                                                                              C column,
                                                                                                                                              V value)

      • generateTreeBasedTable

        static <R extends java.lang.Comparable,​C extends java.lang.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

        java.io.File generateFile()

      • generateByteArrayInputStream

        static java.io.ByteArrayInputStream generateByteArrayInputStream()

      • generateInputStream

        static java.io.InputStream generateInputStream()

      • generateStringReader

        java.io.StringReader generateStringReader()

      • generateReader

        java.io.Reader generateReader()

      • generateReadable

        java.lang.Readable generateReadable()

      • generateBuffer

        java.nio.Buffer generateBuffer()

      • generateCharBuffer

        java.nio.CharBuffer generateCharBuffer()

      • generateByteBuffer

        java.nio.ByteBuffer generateByteBuffer()

      • generateShortBuffer

        java.nio.ShortBuffer generateShortBuffer()

      • generateIntBuffer

        java.nio.IntBuffer generateIntBuffer()

      • generateLongBuffer

        java.nio.LongBuffer generateLongBuffer()

      • generateFloatBuffer

        java.nio.FloatBuffer generateFloatBuffer()

      • generateDoubleBuffer

        java.nio.DoubleBuffer generateDoubleBuffer()