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()