Class FreshValueGenerator


  • @GwtIncompatible
    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

        private java.lang.Class<?> generateClass()
      • generateObject

        private java.lang.Object generateObject()
      • generateNumber

        private java.lang.Number generateNumber()
      • generateInt

        private int generateInt()
      • generateInteger

        private java.lang.Integer generateInteger()
      • generateLong

        private long generateLong()
      • generateLongObject

        private java.lang.Long generateLongObject()
      • generateFloat

        private float generateFloat()
      • generateFloatObject

        private java.lang.Float generateFloatObject()
      • generateDouble

        private double generateDouble()
      • generateDoubleObject

        private java.lang.Double generateDoubleObject()
      • generateShort

        private short generateShort()
      • generateShortObject

        private java.lang.Short generateShortObject()
      • generateByte

        private byte generateByte()
      • generateByteObject

        private java.lang.Byte generateByteObject()
      • generateChar

        private char generateChar()
      • generateCharacter

        private java.lang.Character generateCharacter()
      • generateBoolean

        private boolean generateBoolean()
      • generateBooleanObject

        private java.lang.Boolean generateBooleanObject()
      • generateUnsignedInteger

        private UnsignedInteger generateUnsignedInteger()
      • generateUnsignedLong

        private UnsignedLong generateUnsignedLong()
      • generateBigInteger

        private java.math.BigInteger generateBigInteger()
      • generateBigDecimal

        private java.math.BigDecimal generateBigDecimal()
      • generateCharSequence

        private java.lang.CharSequence generateCharSequence()
      • generateString

        private java.lang.String generateString()
      • generateComparable

        private java.lang.Comparable<?> generateComparable()
      • generatePattern

        private java.util.regex.Pattern generatePattern()
      • generateCharset

        private java.nio.charset.Charset generateCharset()
      • generateLocale

        private java.util.Locale generateLocale()
      • generateCurrency

        private java.util.Currency generateCurrency()
      • preJava7FreshCurrency

        private java.util.Currency preJava7FreshCurrency()
      • generateJavaOptional

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

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

        private java.util.OptionalInt generateOptionalInt()
      • generateOptionalLong

        private java.util.OptionalLong generateOptionalLong()
      • generateOptionalDouble

        private java.util.OptionalDouble generateOptionalDouble()
      • generateGoogleOptional

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

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

        private Joiner generateJoiner()
      • generateSplitter

        private Splitter generateSplitter()
      • generateEquivalence

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

        private CharMatcher generateCharMatcher()
      • generateTicker

        private Ticker generateTicker()
      • generateComparator

        private <T> java.util.Comparator<T> generateComparator()
      • generateOrdering

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        private static <E extends java.lang.Comparable<? super E>> ImmutableSortedSet<E> generateImmutableSortedSet​(E freshElement)
      • generateMultiset

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

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

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

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

        private static <E extends java.lang.Comparable<E>> SortedMultiset<E> generateSortedMultiset​(E freshElement)
      • generateTreeMultiset

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

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

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

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

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

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

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

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

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

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

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

        private static <K extends java.lang.Comparable<? super K>,​V> ImmutableSortedMap<K,​V> generateImmutableSortedMap​(K key,
                                                                                                                                    V value)
      • generateMultimap

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        private static <R extends java.lang.Comparable,​C extends java.lang.Comparable,​V> RowSortedTable<R,​C,​V> generateRowSortedTable​(R row,
                                                                                                                                                              C column,
                                                                                                                                                              V value)
      • generateTreeBasedTable

        private static <R extends java.lang.Comparable,​C extends java.lang.Comparable,​V> TreeBasedTable<R,​C,​V> generateTreeBasedTable​(R row,
                                                                                                                                                              C column,
                                                                                                                                                              V value)
      • generateImmutableTable

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

        private TypeToken<?> generateTypeToken()
      • generateFile

        private java.io.File generateFile()
      • generateByteArrayInputStream

        private static java.io.ByteArrayInputStream generateByteArrayInputStream()
      • generateInputStream

        private static java.io.InputStream generateInputStream()
      • generateStringReader

        private java.io.StringReader generateStringReader()
      • generateReader

        private java.io.Reader generateReader()
      • generateReadable

        private java.lang.Readable generateReadable()
      • generateBuffer

        private java.nio.Buffer generateBuffer()
      • generateCharBuffer

        private java.nio.CharBuffer generateCharBuffer()
      • generateByteBuffer

        private java.nio.ByteBuffer generateByteBuffer()
      • generateShortBuffer

        private java.nio.ShortBuffer generateShortBuffer()
      • generateIntBuffer

        private java.nio.IntBuffer generateIntBuffer()
      • generateLongBuffer

        private java.nio.LongBuffer generateLongBuffer()
      • generateFloatBuffer

        private java.nio.FloatBuffer generateFloatBuffer()
      • generateDoubleBuffer

        private java.nio.DoubleBuffer generateDoubleBuffer()