All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary Annotation Types Summary
Class |
Description |
Absent<T> |
Implementation of an Optional not containing a reference.
|
AbstractBiMap<K,V> |
A general-purpose bimap implementation using any two backing Map
instances.
|
AbstractBiMap.Inverse<K,V> |
The inverse of any other AbstractBiMap subclass.
|
AbstractBiMapTester<K,V> |
Skeleton for a tester of a BiMap .
|
AbstractByteHasher |
Abstract Hasher that handles converting primitives to bytes using a scratch
ByteBuffer and streams all bytes to a sink to compute the hash.
|
AbstractCache<K,V> |
This class provides a skeletal implementation of the Cache interface to minimize the
effort required to implement this interface.
|
AbstractCache.SimpleStatsCounter |
|
AbstractCache.StatsCounter |
|
AbstractCatchingFuture<V,X extends java.lang.Throwable,F,T> |
Implementations of Futures.catching* .
|
AbstractCatchingFuture.AsyncCatchingFuture<V,X extends java.lang.Throwable> |
|
AbstractCatchingFuture.CatchingFuture<V,X extends java.lang.Throwable> |
|
AbstractCheckedFuture<V,X extends java.lang.Exception> |
|
AbstractCheckedFutureTest |
|
AbstractCollectionTester<E> |
Base class for collection testers.
|
AbstractCollectionTestSuiteBuilder<B extends AbstractCollectionTestSuiteBuilder<B,E>,E> |
Abstract superclass of all test-suite builders for collection interfaces.
|
AbstractCompositeHashFunction |
An abstract composition of multiple hash functions.
|
AbstractContainerTester<C,E> |
Base class for testers of classes (including Collection
and Map ) that contain elements.
|
AbstractContainerTester.ArrayWithDuplicate<E> |
|
AbstractDirectedNetworkConnections<N,E> |
|
AbstractExecutionThreadService |
|
AbstractFuture<V> |
An abstract implementation of ListenableFuture , intended for advanced users only.
|
AbstractFuture.AtomicHelper |
|
AbstractFuture.Cancellation |
A special value to represent cancellation and the 'wasInterrupted' bit.
|
AbstractFuture.Failure |
|
AbstractFuture.Listener |
|
AbstractFuture.SafeAtomicHelper |
|
AbstractFuture.SetFuture<V> |
A special value that encodes the 'setFuture' state.
|
AbstractFuture.SynchronizedHelper |
|
AbstractFuture.TrustedFuture<V> |
A less abstract subclass of AbstractFuture.
|
AbstractFuture.UnsafeAtomicHelper |
|
AbstractFuture.Waiter |
|
AbstractGraph<N> |
This class provides a skeletal implementation of Graph .
|
AbstractGraphBuilder<N> |
A base class for builders that construct graphs with user-defined properties.
|
AbstractHasher |
|
AbstractIdleService |
Base class for services that do not need a thread while "running" but may need one during startup
and shutdown.
|
AbstractIndexedListIterator<E> |
This class provides a skeletal implementation of the ListIterator
interface across a fixed number of elements that may be retrieved by
position.
|
AbstractInvocationHandler |
Abstract implementation of InvocationHandler that handles Object.equals(java.lang.Object) ,
Object.hashCode() and Object.toString() .
|
AbstractIterator<T> |
|
AbstractIterator<T> |
This class provides a skeletal implementation of the Iterator
interface, to make this interface easier to implement for certain types of
data sources.
|
AbstractIterator.State |
|
AbstractIterator.State |
|
AbstractIteratorTester<E,I extends java.util.Iterator<E>> |
|
AbstractIteratorTester.IteratorOperation |
|
AbstractIteratorTester.KnownOrder |
|
AbstractIteratorTester.PermittedMetaException |
|
AbstractIteratorTester.Stimulus<E,T extends java.util.Iterator<E>> |
|
AbstractIteratorTester.UnknownElementException |
|
AbstractListenableFutureTest |
|
AbstractListeningExecutorService |
|
AbstractListIndexOfTester<E> |
|
AbstractListMultimap<K,V> |
|
AbstractListMultimapTester<K,V> |
Superclass for all ListMultimap testers.
|
AbstractListTester<E> |
Base class for list testers.
|
AbstractLoadingCache<K,V> |
This class provides a skeletal implementation of the Cache interface to minimize the
effort required to implement this interface.
|
AbstractMapBasedMultimap<K,V> |
Basic implementation of the Multimap interface.
|
AbstractMapBasedMultiset<E> |
Basic implementation of Multiset<E> backed by an instance of
Map<E, Count> .
|
AbstractMapEntry<K,V> |
Implementation of the equals , hashCode , and toString
methods of Entry .
|
AbstractMapTester<K,V> |
Base class for map testers.
|
AbstractMultimap<K,V> |
A skeleton Multimap implementation, not necessarily in terms of a Map .
|
AbstractMultimapTester<K,V,M extends Multimap<K,V>> |
Superclass for all Multimap testers.
|
AbstractMultiset<E> |
This class provides a skeletal implementation of the Multiset
interface.
|
AbstractMultisetSetCountTester<E> |
|
AbstractMultisetTester<E> |
Base class for multiset collection tests.
|
AbstractNavigableMap<K,V> |
Skeletal implementation of NavigableMap .
|
AbstractNetwork<N,E> |
This class provides a skeletal implementation of Network .
|
AbstractNonStreamingHashFunction |
Skeleton implementation of HashFunction , appropriate for non-streaming algorithms.
|
AbstractNonStreamingHashFunction.ExposedByteArrayOutputStream |
|
AbstractPackageSanityTests |
Automatically runs sanity checks against top level classes in the same package of the test that
extends AbstractPackageSanityTests .
|
AbstractPackageSanityTests.Chopper |
|
AbstractQueueTester<E> |
Base class for queue collection tests.
|
AbstractRangeSet<C extends java.lang.Comparable> |
A skeletal implementation of RangeSet .
|
AbstractScheduledService |
|
AbstractScheduledService.CustomScheduler |
|
AbstractScheduledService.CustomScheduler.Schedule |
A value object that represents an absolute delay until a task should be invoked.
|
AbstractScheduledService.Scheduler |
|
AbstractSequentialIterator<T> |
This class provides a skeletal implementation of the Iterator
interface for sequences whose next element can always be derived from the
previous element.
|
AbstractService |
|
AbstractService.StateSnapshot |
An immutable snapshot of the current state of the service.
|
AbstractSetMultimap<K,V> |
|
AbstractSetTester<E> |
|
AbstractSortedKeySortedSetMultimap<K,V> |
|
AbstractSortedMultiset<E> |
This class provides a skeletal implementation of the SortedMultiset interface.
|
AbstractSortedSetMultimap<K,V> |
|
AbstractStreamingHashFunction |
|
AbstractStreamingHashFunction.AbstractStreamingHasher |
A convenience base class for implementors of Hasher ; handles accumulating data until an
entire "chunk" (of implementation-dependent length) is ready to be hashed.
|
AbstractTable<R,C,V> |
Skeletal, implementation-agnostic implementation of the Table interface.
|
AbstractTester<G> |
This abstract base class for testers allows the framework to inject needed
information after JUnit constructs the instances.
|
AbstractTransformFuture<I,O,F,T> |
Implementations of Futures.transform* .
|
AbstractTransformFuture.AsyncTransformFuture<I,O> |
|
AbstractTransformFuture.TransformFuture<I,O> |
|
AbstractUndirectedNetworkConnections<N,E> |
|
AbstractValueGraph<N,V> |
This class provides a skeletal implementation of ValueGraph .
|
AggregateFuture<InputT,OutputT> |
A future made up of a collection of sub-futures.
|
AggregateFutureState |
A helper which does some thread-safe operations for aggregate futures, which must be implemented
differently in GWT.
|
AggregateFutureState.AtomicHelper |
|
AggregateFutureState.SafeAtomicHelper |
|
AggregateFutureState.SynchronizedAtomicHelper |
|
AllEqualOrdering |
An ordering that treats all references as equals, even nulls.
|
AllowConcurrentEvents |
Marks an event subscriber method as being thread-safe.
|
AnEnum |
A sample enumerated type we use for testing.
|
AppendableWriter |
Writer that places all output on an Appendable target.
|
ArbitraryInstances |
Supplies an arbitrary "default" instance for a wide range of types, often useful in testing
utilities.
|
ArbitraryInstances.AlwaysEqual |
|
ArbitraryInstances.ByToString |
|
ArbitraryInstances.Dummies |
|
ArbitraryInstances.Dummies.DeterministicRandom |
|
ArbitraryInstances.Dummies.DummyCountDownLatch |
|
ArbitraryInstances.Dummies.DummyExecutor |
|
ArbitraryInstances.Dummies.DummyRunnable |
|
ArbitraryInstances.Dummies.DummyScheduledThreadPoolExecutor |
|
ArbitraryInstances.Dummies.DummyThreadFactory |
|
ArbitraryInstances.Dummies.InMemoryPrintStream |
|
ArbitraryInstances.Dummies.InMemoryPrintWriter |
|
ArbitraryInstances.NullByteSink |
|
ArrayBasedCharEscaper |
A CharEscaper that uses an array to quickly look up replacement characters for a given
char value.
|
ArrayBasedEscaperMap |
|
ArrayBasedUnicodeEscaper |
A UnicodeEscaper that uses an array to quickly look up replacement characters for a given
code point.
|
ArrayListMultimap<K,V> |
Implementation of Multimap that uses an ArrayList to store
the values for a given key.
|
ArrayTable<R,C,V> |
Fixed-size Table implementation backed by a two-dimensional array.
|
ArrayTable.ArrayMap<K,V> |
|
Ascii |
Static methods pertaining to ASCII characters (those in the range of values 0x00 through
0x7F ), and to strings containing such characters.
|
AsyncCallable<V> |
Computes a value, possibly asynchronously.
|
AsyncEventBus |
An EventBus that takes the Executor of your choice and uses it to dispatch events,
allowing dispatch to occur asynchronously.
|
AsyncFunction<I,O> |
Transforms a value, possibly asynchronously.
|
AtomicDouble |
A double value that may be updated atomically.
|
AtomicDoubleArray |
A double array in which elements may be updated atomically.
|
AtomicLongMap<K> |
A map containing long values that can be atomically updated.
|
Atomics |
Static utility methods pertaining to classes in the java.util.concurrent.atomic package.
|
BaseComparable |
Simple base class to verify that we handle generics correctly.
|
BaseEncoding |
A binary encoding scheme for reversibly translating between byte sequences and printable ASCII
strings.
|
BaseEncoding.Alphabet |
|
BaseEncoding.Base16Encoding |
|
BaseEncoding.Base64Encoding |
|
BaseEncoding.DecodingException |
Exception indicating invalid base-encoded input encountered while decoding.
|
BaseEncoding.SeparatedBaseEncoding |
|
BaseEncoding.StandardBaseEncoding |
|
Beta |
Signifies that a public API (public class, method or field) is subject to incompatible changes,
or even removal, in a future release.
|
BigIntegerMath |
A class for arithmetic on values of type BigInteger .
|
BiMap<K,V> |
A bimap (or "bidirectional map") is a map that preserves the uniqueness of
its values as well as that of its keys.
|
BiMapClearTester<K,V> |
Tester for BiMap.clear .
|
BiMapGenerators |
Generators of various BiMap s and derived
collections.
|
BiMapGenerators.ImmutableBiMapCopyOfEntriesGenerator |
|
BiMapGenerators.ImmutableBiMapCopyOfGenerator |
|
BiMapGenerators.ImmutableBiMapGenerator |
|
BiMapInverseTester<K,V> |
Tests for the inverse view of a BiMap.
|
BiMapInverseTester.BiMapPair<K,V> |
|
BiMapPutTester<K,V> |
Tester for BiMap.put and BiMap.forcePut .
|
BiMapRemoveTester<K,V> |
Tester for BiMap.remove .
|
BiMapTestSuiteBuilder<K,V> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests a BiMap
implementation.
|
BiMapTestSuiteBuilder.NoRecurse |
|
BinaryTreeTraverser<T> |
A variant of TreeTraverser for binary trees, providing additional traversals specific to
binary trees.
|
BloomFilter<T> |
A Bloom filter for instances of T .
|
BloomFilter.SerialForm<T> |
|
BloomFilter.Strategy |
A strategy to translate T instances, to numHashFunctions bit indexes.
|
BloomFilterStrategies |
Collections of strategies of generating the k * log(M) bits required for an element to be mapped
to a BloomFilter of M bits and k hash functions.
|
BloomFilterStrategies.BitArray |
|
Booleans |
Static utility methods pertaining to boolean primitives, that are not already found in
either Boolean or Arrays .
|
Booleans.BooleanArrayAsList |
|
Booleans.LexicographicalComparator |
|
BoundType |
Indicates whether an endpoint of some range is contained in the range itself ("closed") or not
("open").
|
ByFunctionOrdering<F,T> |
An ordering that orders elements by applying an order to the result of a
function on those elements.
|
ByteArrayDataInput |
An extension of DataInput for reading from in-memory byte arrays; its methods offer
identical functionality but do not throw IOException .
|
ByteArrayDataOutput |
An extension of DataOutput for writing to in-memory byte arrays; its methods offer
identical functionality but do not throw IOException .
|
ByteProcessor<T> |
A callback interface to process bytes from a stream.
|
Bytes |
Static utility methods pertaining to byte primitives, that are not already found in
either Byte or Arrays , and interpret bytes as neither signed nor unsigned.
|
Bytes.ByteArrayAsList |
|
ByteSink |
A destination to which bytes can be written, such as a file.
|
ByteSource |
A readable source of bytes, such as a file.
|
ByteSource.ByteArrayByteSource |
|
ByteSource.ConcatenatedByteSource |
|
ByteSource.EmptyByteSource |
|
ByteStreams |
Provides utility methods for working with byte arrays and I/O streams.
|
ByteStreams.ByteArrayDataInputStream |
|
ByteStreams.ByteArrayDataOutputStream |
|
ByteStreams.FastByteArrayOutputStream |
BAOS that provides limited access to its internal byte array.
|
ByteStreams.LimitedInputStream |
|
Cache<K,V> |
A semi-persistent mapping from keys to values.
|
CacheBuilder<K,V> |
A builder of LoadingCache and Cache instances having any combination of the
following features:
automatic loading of entries into the cache
least-recently-used eviction when a maximum size is exceeded
time-based expiration of entries, measured since last access or last write
keys automatically wrapped in weak references
values automatically wrapped in weak or soft references
notification of evicted (or otherwise removed) entries
accumulation of cache access statistics
|
CacheBuilder.NullListener |
|
CacheBuilder.OneWeigher |
|
CacheBuilderSpec |
|
CacheBuilderSpec.AccessDurationParser |
Parse expireAfterAccess
|
CacheBuilderSpec.ConcurrencyLevelParser |
Parse concurrencyLevel
|
CacheBuilderSpec.DurationParser |
Base class for parsing times with durations
|
CacheBuilderSpec.InitialCapacityParser |
Parse initialCapacity
|
CacheBuilderSpec.IntegerParser |
Base class for parsing integers.
|
CacheBuilderSpec.KeyStrengthParser |
Parse weakKeys
|
CacheBuilderSpec.LongParser |
Base class for parsing integers.
|
CacheBuilderSpec.MaximumSizeParser |
Parse maximumSize
|
CacheBuilderSpec.MaximumWeightParser |
Parse maximumWeight
|
CacheBuilderSpec.RecordStatsParser |
Parse recordStats
|
CacheBuilderSpec.RefreshDurationParser |
Parse refreshAfterWrite
|
CacheBuilderSpec.ValueParser |
Parses a single value.
|
CacheBuilderSpec.ValueStrengthParser |
Parse weakValues and softValues
|
CacheBuilderSpec.WriteDurationParser |
Parse expireAfterWrite
|
CacheLoader<K,V> |
Computes or retrieves values, based on a key, for use in populating a LoadingCache .
|
CacheLoader.FunctionToCacheLoader<K,V> |
|
CacheLoader.InvalidCacheLoadException |
Thrown to indicate that an invalid response was returned from a call to CacheLoader .
|
CacheLoader.SupplierToCacheLoader<V> |
|
CacheLoader.UnsupportedLoadingOperationException |
Exception thrown by loadAll() to indicate that it is not supported.
|
CacheStats |
Statistics about the performance of a Cache .
|
Callables |
Static utility methods pertaining to the Callable interface.
|
CartesianList<E> |
|
CaseFormat |
Utility class for converting between various ASCII case formats.
|
CaseFormat.StringConverter |
|
CharEscaper |
An object that converts literal text into a format safe for inclusion in a particular context
(such as an XML document).
|
CharEscaperBuilder |
Simple helper class to build a "sparse" array of objects based on the indexes that were added to
it.
|
CharEscaperBuilder.CharArrayDecorator |
Simple decorator that turns an array of replacement char[]s into a CharEscaper, this results in
a very fast escape method.
|
CharMatcher |
Determines a true or false value for any Java char value, just as Predicate does
for any Object .
|
CharMatcher.And |
|
CharMatcher.Any |
|
CharMatcher.AnyOf |
|
CharMatcher.Ascii |
|
CharMatcher.BitSetMatcher |
Fast matcher using a BitSet table of matching characters.
|
CharMatcher.BreakingWhitespace |
|
CharMatcher.Digit |
|
CharMatcher.FastMatcher |
A matcher for which precomputation will not yield any significant benefit.
|
CharMatcher.ForPredicate |
|
CharMatcher.InRange |
|
CharMatcher.Invisible |
|
CharMatcher.Is |
|
CharMatcher.IsEither |
|
CharMatcher.IsNot |
|
CharMatcher.JavaDigit |
|
CharMatcher.JavaIsoControl |
|
CharMatcher.JavaLetter |
|
CharMatcher.JavaLetterOrDigit |
|
CharMatcher.JavaLowerCase |
|
CharMatcher.JavaUpperCase |
|
CharMatcher.NamedFastMatcher |
|
CharMatcher.Negated |
|
CharMatcher.NegatedFastMatcher |
|
CharMatcher.None |
|
CharMatcher.Or |
|
CharMatcher.RangesMatcher |
Implementation that matches characters that fall within multiple ranges.
|
CharMatcher.SingleWidth |
|
CharMatcher.Whitespace |
|
Chars |
Static utility methods pertaining to char primitives, that are not already found in
either Character or Arrays .
|
Chars.CharArrayAsList |
|
Chars.LexicographicalComparator |
|
CharSequenceReader |
A Reader that reads the characters in a CharSequence .
|
Charsets |
Contains constant definitions for the six standard Charset instances, which are
guaranteed to be supported by all Java platform implementations.
|
CharSink |
A destination to which characters can be written, such as a text file.
|
CharSource |
A readable source of characters, such as a text file.
|
CharSource.CharSequenceCharSource |
|
CharSource.ConcatenatedCharSource |
|
CharSource.EmptyCharSource |
|
CharStreams |
Provides utility methods for working with character streams.
|
CharStreams.NullWriter |
|
CheckedFuture<V,X extends java.lang.Exception> |
A CheckedFuture is a ListenableFuture that includes versions of the get
methods that can throw a checked exception.
|
ChecksumHashFunction |
|
ClassPath |
Scans the source of a ClassLoader and finds all loadable classes and resources.
|
ClassPath.ClassInfo |
|
ClassPath.DefaultScanner |
|
ClassPath.ResourceInfo |
Represents a class path resource that can be either a class file or any other resource file
loadable from the class path.
|
ClassPath.Scanner |
|
ClassSanityTester |
Tester that runs automated sanity tests for any given class.
|
ClassSanityTester.FactoryMethodReturnsNullException |
Thrown if the test tries to invoke a static factory method to test instance methods but the
factory returned null.
|
ClassSanityTester.ParameterHasNoDistinctValueException |
Thrown if the test fails to generate two distinct non-null values of a constructor or factory
parameter in order to test Object.equals(java.lang.Object) and Object.hashCode() of the declaring
class.
|
ClassSanityTester.ParameterNotInstantiableException |
Thrown if the test tries to invoke a constructor or static factory method but failed because
the dummy value of a constructor or method parameter is unknown.
|
ClassSanityTester.SerializableDummyProxy |
|
ClassToInstanceMap<B> |
A map, each entry of which maps a Java
raw type to an instance of that type.
|
Closeables |
Utility methods for working with Closeable objects.
|
Closer |
A Closeable that collects Closeable resources and closes them all when it is
closed.
|
Closer.LoggingSuppressor |
Suppresses exceptions by logging them.
|
Closer.SuppressingSuppressor |
Suppresses exceptions by adding them to the exception that will be thrown using JDK7's
addSuppressed(Throwable) mechanism.
|
Closer.Suppressor |
Suppression strategy interface.
|
ClusterException |
An ClusterException is a data structure that allows for some code to
"throw multiple exceptions", or something close to it.
|
CollectionAddAllTester<E> |
A generic JUnit test which tests addAll operations on a collection.
|
CollectionAddTester<E> |
A generic JUnit test which tests add operations on a collection.
|
CollectionClearTester<E> |
A generic JUnit test which tests clear() operations on a collection.
|
CollectionContainsAllTester<E> |
A generic JUnit test which tests containsAll() operations on a
collection.
|
CollectionContainsTester<E> |
A generic JUnit test which tests contains() operations on a
collection.
|
CollectionCreationTester<E> |
A generic JUnit test which tests creation (typically through a constructor or
static factory method) of a collection.
|
CollectionEqualsTester<E> |
Tests Collection.equals(java.lang.Object) .
|
CollectionFeature |
Optional features of classes derived from Collection .
|
CollectionFeature.Require |
|
CollectionFuture<V,C> |
Aggregate future that collects (stores) results of each future.
|
CollectionFuture.ListFuture<V> |
|
CollectionIsEmptyTester<E> |
A generic JUnit test which tests isEmpty() operations on a
collection.
|
CollectionIteratorTester<E> |
A generic JUnit test which tests iterator operations on a collection.
|
CollectionRemoveAllTester<E> |
A generic JUnit test which tests removeAll operations on a
collection.
|
CollectionRemoveTester<E> |
A generic JUnit test which tests remove operations on a collection.
|
CollectionRetainAllTester<E> |
A generic JUnit test which tests retainAll operations on a
collection.
|
Collections2 |
Provides static methods for working with Collection instances.
|
Collections2.FilteredCollection<E> |
|
Collections2.OrderedPermutationCollection<E> |
|
Collections2.OrderedPermutationIterator<E> |
|
Collections2.PermutationCollection<E> |
|
Collections2.PermutationIterator<E> |
|
Collections2.TransformedCollection<F,T> |
|
CollectionSerializationEqualTester<E> |
Basic reserialization test for collection types that must preserve equals() behavior
when reserialized.
|
CollectionSerializationTester<E> |
Basic reserialization test for collections.
|
CollectionSize |
When describing the features of the collection produced by a given generator
(i.e.
|
CollectionSize.Require |
|
CollectionSizeTester<E> |
A generic JUnit test which tests size() operations on a collection.
|
CollectionTestSuiteBuilder<E> |
|
CollectionTestSuiteBuilder.ReserializedCollectionGenerator<E> |
|
CollectionToArrayTester<E> |
A generic JUnit test which tests toArray() operations on a
collection.
|
CollectionToStringTester<E> |
A generic JUnit test which tests toString() operations on a
collection.
|
CollectPreconditions |
Precondition checks useful in collection implementations.
|
CombinedFuture<V> |
Aggregate future that computes its value by calling a callable.
|
CommonMatcher |
The subset of the Matcher API which is used by this package, and also
shared with the re2j library.
|
CommonPattern |
The subset of the Pattern API which is used by this package, and also
shared with the re2j library.
|
ComparatorOrdering<T> |
An ordering for a pre-existing comparator.
|
ComparisonChain |
A utility for performing a chained comparison statement.
|
ComparisonChain.InactiveComparisonChain |
|
CompoundOrdering<T> |
An ordering that tries several comparators in order.
|
ComputationException |
Wraps an exception that occurred during a computation.
|
ConcurrentHashMultiset<E> |
A multiset that supports concurrent modifications and that provides atomic versions of most
Multiset operations (exceptions where noted).
|
ConcurrentHashMultiset.FieldSettersHolder |
|
ConcurrentMapPutIfAbsentTester<K,V> |
A generic JUnit test which tests putIfAbsent operations on a concurrent map.
|
ConcurrentMapRemoveTester<K,V> |
Tester for ConcurrentMap.remove(java.lang.Object, java.lang.Object) .
|
ConcurrentMapReplaceEntryTester<K,V> |
A generic JUnit test which tests replace(K, V, V) operations on a concurrent map.
|
ConcurrentMapReplaceTester<K,V> |
A generic JUnit test which tests replace(K, V) operations on a concurrent map.
|
ConcurrentMapTestSuiteBuilder<K,V> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests a ConcurrentMap
implementation.
|
ConcurrentNavigableMapTestSuiteBuilder<K,V> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
a ConcurrentNavigableMap implementation.
|
ConfigurableMutableGraph<N> |
Configurable implementation of MutableGraph that supports both directed and undirected
graphs.
|
ConfigurableMutableNetwork<N,E> |
Configurable implementation of MutableNetwork that supports both directed and undirected
graphs.
|
ConfigurableMutableValueGraph<N,V> |
Configurable implementation of MutableValueGraph that supports both directed and
undirected graphs.
|
ConfigurableNetwork<N,E> |
|
ConfigurableValueGraph<N,V> |
|
ConflictingRequirementsException |
Thrown when requirements on a tester method or class conflict with
each other.
|
Constraint<E> |
A constraint that an element must satisfy in order to be added to a
collection.
|
Constraints |
Factories and utilities pertaining to the Constraint interface.
|
Constraints.ConstrainedCollection<E> |
|
Constraints.ConstrainedList<E> |
|
Constraints.ConstrainedListIterator<E> |
|
Constraints.ConstrainedRandomAccessList<E> |
|
Constraints.ConstrainedSet<E> |
|
Constraints.ConstrainedSortedSet<E> |
|
ConsumingQueueIterator<T> |
An Iterator implementation which draws elements from a queue, removing them from the queue as it
iterates.
|
ContiguousSet<C extends java.lang.Comparable> |
|
Converter<A,B> |
A function from A to B with an associated reverse function from B
to A ; used for converting back and forth between different representations of the same
information.
|
Converter.ConverterComposition<A,B,C> |
|
Converter.FunctionBasedConverter<A,B> |
|
Converter.IdentityConverter<T> |
A converter that always converts or reverses an object to itself.
|
Converter.ReverseConverter<A,B> |
|
Count |
A mutable value of type int , for multisets to use in tracking counts of values.
|
CountingInputStream |
An InputStream that counts the number of bytes read.
|
CountingOutputStream |
An OutputStream that counts the number of bytes written.
|
Crc32cHashFunction |
This class generates a CRC32C checksum, defined by RFC 3720, Section 12.1.
|
Crc32cHashFunction.Crc32cHasher |
|
Cut<C extends java.lang.Comparable> |
Implementation detail for the internal structure of Range instances.
|
Cut.AboveAll |
|
Cut.AboveValue<C extends java.lang.Comparable> |
|
Cut.BelowAll |
|
Cut.BelowValue<C extends java.lang.Comparable> |
|
CycleDetectingLockFactory |
The CycleDetectingLockFactory creates ReentrantLock instances and
ReentrantReadWriteLock instances that detect potential deadlock by checking for cycles in
lock acquisition order.
|
CycleDetectingLockFactory.CycleDetectingLock |
Internal Lock implementations implement the CycleDetectingLock interface, allowing the
detection logic to treat all locks in the same manner.
|
CycleDetectingLockFactory.ExampleStackTrace |
A Throwable used to record a stack trace that illustrates an example of a specific lock
acquisition ordering.
|
CycleDetectingLockFactory.LockGraphNode |
A LockGraphNode associated with each lock instance keeps track of the directed edges in
the lock acquisition graph.
|
CycleDetectingLockFactory.Policies |
|
CycleDetectingLockFactory.Policy |
Encapsulates the action to be taken when a potential deadlock is encountered.
|
CycleDetectingLockFactory.PotentialDeadlockException |
Represents a detected cycle in lock acquisition ordering.
|
CycleDetectingLockFactory.WithExplicitOrdering<E extends java.lang.Enum<E>> |
A CycleDetectingLockFactory.WithExplicitOrdering provides the additional enforcement
of an application-specified ordering of lock acquisitions.
|
DeadEvent |
Wraps an event that was posted, but which had no subscribers and thus could not be delivered.
|
Defaults |
This class provides default values for all Java types, as defined by the JLS.
|
DenseImmutableTable<R,C,V> |
A RegularImmutableTable optimized for dense data.
|
DenseImmutableTable.ImmutableArrayMap<K,V> |
An immutable map implementation backed by an indexed nullable array.
|
DerivedCollectionGenerators |
Derived suite generators, split out of the suite builders so that they are available to GWT.
|
DerivedCollectionGenerators.Bound |
Two bounds (from and to) define how to build a subMap.
|
DerivedCollectionGenerators.ForwardingTestMapGenerator<K,V> |
|
DerivedCollectionGenerators.MapEntrySetGenerator<K,V> |
|
DerivedCollectionGenerators.MapKeySetGenerator<K,V> |
|
DerivedCollectionGenerators.MapSortedKeySetGenerator<K,V> |
|
DerivedCollectionGenerators.MapValueCollectionGenerator<K,V> |
|
DerivedCollectionGenerators.SortedMapSubmapTestMapGenerator<K,V> |
|
DerivedCollectionGenerators.SortedSetSubsetTestSetGenerator<E> |
|
DerivedComparable |
Simple derived class to verify that we handle generics correctly.
|
DerivedGenerator |
A generator that relies on a preexisting generator for most of its work.
|
DerivedGoogleCollectionGenerators |
Derived suite generators for Guava collection interfaces, split out of the suite builders so that
they are available to GWT.
|
DerivedGoogleCollectionGenerators.BiMapValueSetGenerator<K,V> |
|
DerivedGoogleCollectionGenerators.InverseBiMapGenerator<K,V> |
|
DerivedGoogleCollectionGenerators.MapGenerator<K,V> |
|
DerivedIteratorTestSuiteBuilder<E> |
Given a test iterable generator, builds a test suite for the
iterable's iterator, by delegating to a IteratorTestSuiteBuilder .
|
DerivedTestIteratorGenerator<E> |
Adapts a test iterable generator to give a TestIteratorGenerator.
|
DescendingImmutableSortedMultiset<E> |
A descending wrapper around an ImmutableSortedMultiset
|
DescendingImmutableSortedSet<E> |
|
DescendingMultiset<E> |
A skeleton implementation of a descending multiset.
|
DirectedGraphConnections<N,V> |
|
DirectedGraphConnections.PredAndSucc |
A wrapper class to indicate a node is both a predecessor and successor while still providing
the successor value.
|
DirectedMultiNetworkConnections<N,E> |
|
DirectedNetworkConnections<N,E> |
|
DiscreteDomain<C extends java.lang.Comparable> |
A descriptor for a discrete Comparable domain such as all
Integer instances.
|
DiscreteDomain.BigIntegerDomain |
|
DiscreteDomain.IntegerDomain |
|
DiscreteDomain.LongDomain |
|
Dispatcher |
Handler for dispatching events to subscribers, providing different event ordering guarantees that
make sense for different situations.
|
Dispatcher.ImmediateDispatcher |
|
Dispatcher.LegacyAsyncDispatcher |
|
Dispatcher.LegacyAsyncDispatcher.EventWithSubscriber |
|
Dispatcher.PerThreadQueuedDispatcher |
|
Dispatcher.PerThreadQueuedDispatcher.Event |
|
DoubleMath |
A class for arithmetic on doubles that is not covered by Math .
|
Doubles |
Static utility methods pertaining to double primitives, that are not already found in
either Double or Arrays .
|
Doubles.DoubleArrayAsList |
|
Doubles.DoubleConverter |
|
Doubles.LexicographicalComparator |
|
DoubleUtils |
Utilities for double primitives.
|
DummyProxy |
Generates a dummy interface proxy that simply returns a dummy value for each method.
|
EdgesConnecting<E> |
A class to represent the set of edges connecting an (implicit) origin node to a target node.
|
Element |
Represents either a Field , a Method or a Constructor .
|
ElementOrder<T> |
Used to represent the order of elements in a data structure that supports different options for
iteration order guarantees.
|
ElementOrder.Type |
The type of ordering that this object specifies.
|
EmptyContiguousSet<C extends java.lang.Comparable> |
An empty contiguous set.
|
EmptyContiguousSet.SerializedForm<C extends java.lang.Comparable> |
|
EmptyImmutableListMultimap |
|
EmptyImmutableSetMultimap |
|
EndpointPair<N> |
An immutable pair representing the two endpoints of an edge in a graph.
|
EndpointPair.Ordered<N> |
|
EndpointPair.Unordered<N> |
|
EndpointPairIterator<N> |
|
EndpointPairIterator.Directed<N> |
If the graph is directed, each ordered [source, target] pair will be visited once if there is
an edge connecting them.
|
EndpointPairIterator.Undirected<N> |
If the graph is undirected, each unordered [node, otherNode] pair (except self-loops) will be
visited twice if there is an edge connecting them.
|
EnumBiMap<K extends java.lang.Enum<K>,V extends java.lang.Enum<V>> |
A BiMap backed by two EnumMap instances.
|
EnumHashBiMap<K extends java.lang.Enum<K>,V> |
A BiMap backed by an EnumMap instance for keys-to-values, and
a HashMap instance for values-to-keys.
|
EnumMultiset<E extends java.lang.Enum<E>> |
Multiset implementation backed by an EnumMap .
|
Enums |
Utility methods for working with Enum instances.
|
Enums.StringConverter<T extends java.lang.Enum<T>> |
|
EqualsTester |
Tester for equals() and hashCode() methods of a class.
|
EqualsTester.NotAnInstance |
Class used to test whether equals() correctly handles an instance
of an incompatible class.
|
Equivalence<T> |
A strategy for determining whether two instances are considered equivalent.
|
Equivalence.Equals |
|
Equivalence.EquivalentToPredicate<T> |
|
Equivalence.Identity |
|
Equivalence.Wrapper<T> |
|
EquivalenceTester<T> |
Tester for Equivalence relationships between groups of objects.
|
Escaper |
An object that converts literal text into a format safe for inclusion in a particular context
(such as an XML document).
|
EscaperAsserts |
Extra assert methods for testing Escaper implementations.
|
Escapers |
Static utility methods pertaining to Escaper instances.
|
Escapers.Builder |
A builder for simple, fast escapers.
|
EventBus |
Dispatches events to listeners, and provides ways for listeners to register themselves.
|
EventBus.LoggingHandler |
Simple logging handler for subscriber exceptions.
|
EvictingQueue<E> |
A non-blocking queue which automatically evicts elements from the head of the queue when
attempting to add new elements onto the queue and it is full.
|
ExampleIteratorTester<E> |
A non-empty tester for Iterator .
|
ExecutionError |
Error variant of ExecutionException .
|
ExecutionList |
A support class for ListenableFuture implementations to manage their listeners.
|
ExecutionList.RunnableExecutorPair |
|
ExplicitOrdering<T> |
An ordering that compares objects according to a given order.
|
ExtraObjectsMethodsForWeb |
Holder for extra methods of Objects only in web.
|
FakeTicker |
A Ticker whose value can be advanced programmatically in test.
|
FakeTimeLimiter |
A TimeLimiter implementation which actually does not attempt to limit time at all.
|
FarmHashFingerprint64 |
Implementation of FarmHash Fingerprint64, an open-source fingerprinting algorithm for strings.
|
Feature<T> |
Base class for enumerating the features of an interface to be tested.
|
FeatureSpecificTestSuiteBuilder<B extends FeatureSpecificTestSuiteBuilder<B,G>,G> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
the object generated by a G, selecting appropriate tests by matching them
against specified features.
|
FeatureUtil |
Utilities for collecting and validating tester requirements from annotations.
|
FileBackedOutputStream |
An OutputStream that starts buffering to a byte array, but switches to file buffering
once the data reaches a configurable size.
|
FileBackedOutputStream.MemoryOutput |
ByteArrayOutputStream that exposes its internals.
|
Files |
Provides utility methods for working with files.
|
Files.FileByteSink |
|
Files.FileByteSource |
|
Files.FilePredicate |
|
FileWriteMode |
Modes for opening a file for writing.
|
FilteredEntryMultimap<K,V> |
|
FilteredEntrySetMultimap<K,V> |
|
FilteredKeyListMultimap<K,V> |
|
FilteredKeyMultimap<K,V> |
|
FilteredKeyMultimap.AddRejectingList<K,V> |
|
FilteredKeyMultimap.AddRejectingSet<K,V> |
|
FilteredKeySetMultimap<K,V> |
|
FilteredMultimap<K,V> |
An interface for all filtered multimap types.
|
FilteredMultimapValues<K,V> |
|
FilteredSetMultimap<K,V> |
|
FinalizablePhantomReference<T> |
Phantom reference with a finalizeReferent() method which a background thread invokes
after the garbage collector reclaims the referent.
|
FinalizableReference |
Implemented by references that have code to run after garbage collection of their referents.
|
FinalizableReferenceQueue |
|
FinalizableReferenceQueue.DecoupledLoader |
Try to load Finalizer in its own class loader.
|
FinalizableReferenceQueue.DirectLoader |
Loads Finalizer directly using the current class loader.
|
FinalizableReferenceQueue.FinalizerLoader |
Loads Finalizer.class.
|
FinalizableReferenceQueue.SystemLoader |
Tries to load Finalizer from the system class loader.
|
FinalizableSoftReference<T> |
Soft reference with a finalizeReferent() method which a background thread invokes after
the garbage collector reclaims the referent.
|
FinalizableWeakReference<T> |
Weak reference with a finalizeReferent() method which a background thread invokes after
the garbage collector reclaims the referent.
|
Finalizer |
Thread that finalizes referents.
|
Floats |
Static utility methods pertaining to float primitives, that are not already found in
either Float or Arrays .
|
Floats.FloatArrayAsList |
|
Floats.FloatConverter |
|
Floats.LexicographicalComparator |
|
FluentIterable<E> |
An expanded Iterable API, providing functionality similar to Java 8's powerful streams library in a slightly different way.
|
FluentIterable.FromIterableFunction<E> |
Function that transforms Iterable<E> into a fluent iterable.
|
Flushables |
Utility methods for working with Flushable objects.
|
ForwardingBlockingDeque<E> |
A BlockingDeque which forwards all its method calls to another BlockingDeque .
|
ForwardingBlockingQueue<E> |
A BlockingQueue which forwards all its method calls to another BlockingQueue .
|
ForwardingCache<K,V> |
A cache which forwards all its method calls to another cache.
|
ForwardingCache.SimpleForwardingCache<K,V> |
A simplified version of ForwardingCache where subclasses can pass in an already
constructed Cache as the delegate.
|
ForwardingCheckedFuture<V,X extends java.lang.Exception> |
A future which forwards all its method calls to another future.
|
ForwardingCheckedFuture.SimpleForwardingCheckedFuture<V,X extends java.lang.Exception> |
|
ForwardingCollection<E> |
A collection which forwards all its method calls to another collection.
|
ForwardingConcurrentMap<K,V> |
A concurrent map which forwards all its method calls to another concurrent
map.
|
ForwardingDeque<E> |
A deque which forwards all its method calls to another deque.
|
ForwardingExecutorService |
An executor service which forwards all its method calls to another executor service.
|
ForwardingFuture<V> |
A Future which forwards all its method calls to another future.
|
ForwardingFuture.SimpleForwardingFuture<V> |
A simplified version of ForwardingFuture where subclasses can pass in an already
constructed Future as the delegate.
|
ForwardingGraph<N> |
|
ForwardingImmutableCollection |
Dummy class that makes the GWT serialization policy happy.
|
ForwardingImmutableList<E> |
Unused stub class, unreferenced under Java and manually emulated under GWT.
|
ForwardingImmutableMap<K,V> |
Unused stub class, unreferenced under Java and manually emulated under GWT.
|
ForwardingImmutableSet<E> |
Unused stub class, unreferenced under Java and manually emulated under GWT.
|
ForwardingIterator<T> |
An iterator which forwards all its method calls to another iterator.
|
ForwardingList<E> |
A list which forwards all its method calls to another list.
|
ForwardingListenableFuture<V> |
|
ForwardingListenableFuture.SimpleForwardingListenableFuture<V> |
|
ForwardingListeningExecutorService |
A listening executor service which forwards all its method calls to another listening executor
service.
|
ForwardingListIterator<E> |
A list iterator which forwards all its method calls to another list
iterator.
|
ForwardingListMultimap<K,V> |
A list multimap which forwards all its method calls to another list multimap.
|
ForwardingLoadingCache<K,V> |
A cache which forwards all its method calls to another cache.
|
ForwardingLoadingCache.SimpleForwardingLoadingCache<K,V> |
|
ForwardingMap<K,V> |
A map which forwards all its method calls to another map.
|
ForwardingMapEntry<K,V> |
A map entry which forwards all its method calls to another map entry.
|
ForwardingMultimap<K,V> |
A multimap which forwards all its method calls to another multimap.
|
ForwardingMultiset<E> |
A multiset which forwards all its method calls to another multiset.
|
ForwardingNavigableMap<K,V> |
A navigable map which forwards all its method calls to another navigable map.
|
ForwardingNavigableSet<E> |
A navigable set which forwards all its method calls to another navigable set.
|
ForwardingObject |
|
ForwardingQueue<E> |
A queue which forwards all its method calls to another queue.
|
ForwardingSet<E> |
A set which forwards all its method calls to another set.
|
ForwardingSetMultimap<K,V> |
A set multimap which forwards all its method calls to another set multimap.
|
ForwardingSortedMap<K,V> |
A sorted map which forwards all its method calls to another sorted map.
|
ForwardingSortedMultiset<E> |
A sorted multiset which forwards all its method calls to another sorted multiset.
|
ForwardingSortedSet<E> |
A sorted set which forwards all its method calls to another sorted set.
|
ForwardingSortedSetMultimap<K,V> |
A sorted set multimap which forwards all its method calls to another sorted
set multimap.
|
ForwardingTable<R,C,V> |
A table which forwards all its method calls to another table.
|
ForwardingWrapperTester |
Tester to ensure forwarding wrapper works by delegating calls to the corresponding method
with the same parameters forwarded and return value forwarded back or exception propagated as is.
|
ForwardingWrapperTester.InteractionTester<T> |
Tests a single interaction against a method.
|
FreshValueGenerator |
Generates fresh instances of types that are different from each other (if possible).
|
FreshValueGenerator.Empty |
Annotates a method to generate the "empty" instance of a collection.
|
FreshValueGenerator.Generates |
Annotates a method to be the instance generator of a certain type.
|
Function<F,T> |
Determines an output value based on an input value; a pre-Java-8 version of
java.util.function.Function .
|
FunctionalEquivalence<F,T> |
Equivalence applied on functional result.
|
Functions |
Static utility methods pertaining to com.google.common.base.Function instances; see that
class for information about migrating to java.util.function .
|
Functions.ConstantFunction<E> |
|
Functions.ForMapWithDefault<K,V> |
|
Functions.FunctionComposition<A,B,C> |
|
Functions.FunctionForMapNoDefault<K,V> |
|
Functions.IdentityFunction |
|
Functions.PredicateFunction<T> |
|
Functions.SupplierFunction<T> |
|
Functions.ToStringFunction |
|
Funnel<T> |
An object which can send data from an object of type T into a PrimitiveSink .
|
Funnels |
Funnels for common types.
|
Funnels.ByteArrayFunnel |
|
Funnels.IntegerFunnel |
|
Funnels.LongFunnel |
|
Funnels.SequentialFunnel<E> |
|
Funnels.SinkAsStream |
|
Funnels.StringCharsetFunnel |
|
Funnels.StringCharsetFunnel.SerializedForm |
|
Funnels.UnencodedCharsFunnel |
|
FutureCallback<V> |
A callback for accepting the results of a Future computation
asynchronously.
|
Futures |
Static utility methods pertaining to the Future interface.
|
Futures.FutureCombiner<V> |
A helper to create a new ListenableFuture whose result is generated from a combination
of input futures.
|
Futures.MappingCheckedFuture<V,X extends java.lang.Exception> |
A checked future that uses a function to map from exceptions to the appropriate checked type.
|
Futures.NonCancellationPropagatingFuture<V> |
A wrapped future that does not propagate cancellation to its delegate.
|
FuturesGetChecked |
|
FuturesGetChecked.GetCheckedTypeValidator |
|
FuturesGetChecked.GetCheckedTypeValidatorHolder |
|
FuturesGetChecked.GetCheckedTypeValidatorHolder.ClassValueValidator |
|
FuturesGetChecked.GetCheckedTypeValidatorHolder.WeakSetValidator |
|
GcFinalization |
Testing utilities relating to garbage collection finalization.
|
GcFinalization.FinalizationPredicate |
A predicate that is expected to return true subsequent to finalization, that is, one
of the following actions taken by the garbage collector when performing a full collection in
response to System.gc() :
invoking the finalize methods of unreachable objects
clearing weak references to unreachable referents
enqueuing weak references to unreachable referents in their reference queue
|
GeneralRange<T> |
A generalized interval on any ordering, for internal use.
|
GoogleHelpers |
Helper methods/assertions for use with com.google.common.collect types.
|
Graph<N> |
An interface for graph-structured data,
whose edges are anonymous entities with no identity or information of their own.
|
GraphBuilder<N> |
A builder for constructing instances of MutableGraph with user-defined properties.
|
GraphConnections<N,V> |
An interface for representing and manipulating an origin node's adjacent nodes and edge values in
a Graph .
|
GraphConstants |
A utility class to hold various constants used by the Guava Graph library.
|
GraphConstants.Presence |
|
Graphs |
|
Graphs.NodeVisitState |
An enum representing the state of a node during DFS.
|
Graphs.TransposedGraph<N> |
|
Graphs.TransposedNetwork<N,E> |
|
Graphs.TransposedValueGraph<N,V> |
|
GwtCompatible |
The presence of this annotation on a type indicates that the type may be used with the
Google Web Toolkit (GWT).
|
GwtFuturesCatchingSpecialization |
Hidden superclass of Futures that provides us a place to declare special GWT versions of
the Futures.catching family of methods.
|
GwtIncompatible |
The presence of this annotation on an API indicates that the method may not be used with
the Google Web Toolkit (GWT).
|
GwtTransient |
Private replacement for com.google.gwt.user.client.rpc.GwtTransient
to work around build-system quirks.
|
HashBasedTable<R,C,V> |
Implementation of Table using linked hash tables.
|
HashBasedTable.Factory<C,V> |
|
HashBiMap<K,V> |
A BiMap backed by two hash tables.
|
HashBiMap.BiEntry<K,V> |
|
HashBiMap.InverseSerializedForm<K,V> |
|
HashCode |
An immutable hash code of arbitrary bit length.
|
HashCode.BytesHashCode |
|
HashCode.IntHashCode |
|
HashCode.LongHashCode |
|
Hasher |
A PrimitiveSink that can compute a hash code after reading the input.
|
HashFunction |
A hash function is a collision-averse pure function that maps an arbitrary block of data to a
number called a hash code.
|
Hashing |
Static methods for implementing hash-based collections.
|
Hashing |
Static methods to obtain HashFunction instances, and other static hashing-related
utilities.
|
Hashing.Adler32Holder |
|
Hashing.ChecksumType |
|
Hashing.ConcatenatedHashFunction |
|
Hashing.Crc32cHolder |
|
Hashing.Crc32Holder |
|
Hashing.FarmHashFingerprint64Holder |
|
Hashing.LinearCongruentialGenerator |
Linear CongruentialGenerator to use for consistent hashing.
|
Hashing.Md5Holder |
|
Hashing.Murmur3_128Holder |
|
Hashing.Murmur3_32Holder |
|
Hashing.Sha1Holder |
|
Hashing.Sha256Holder |
|
Hashing.Sha384Holder |
|
Hashing.Sha512Holder |
|
Hashing.SipHash24Holder |
|
HashingInputStream |
An InputStream that maintains a hash of the data read from it.
|
HashingOutputStream |
An OutputStream that maintains a hash of the data written to it.
|
HashMultimap<K,V> |
Implementation of Multimap using hash tables.
|
HashMultiset<E> |
Multiset implementation backed by a HashMap .
|
Helpers |
|
Helpers.GwtTransient |
Private replacement for com.google.gwt.user.client.rpc.GwtTransient to work around
build-system quirks.
|
Helpers.NullsBefore |
Compares strings in natural order except that null comes immediately before a given value.
|
Helpers.NullsBeforeB |
|
Helpers.NullsBeforeTwo |
|
HostAndPort |
An immutable representation of a host and port.
|
HostSpecifier |
A syntactically valid host specifier, suitable for use in a URI.
|
HtmlEscapers |
Escaper instances suitable for strings to be included in HTML attribute values and
most elements' text contents.
|
HttpHeaders |
Contains constant definitions for the HTTP header field names.
|
ImmediateFuture<V> |
Implementations of Futures.immediate* .
|
ImmediateFuture.ImmediateCancelledFuture<V> |
|
ImmediateFuture.ImmediateFailedCheckedFuture<V,X extends java.lang.Exception> |
|
ImmediateFuture.ImmediateFailedFuture<V> |
|
ImmediateFuture.ImmediateSuccessfulCheckedFuture<V,X extends java.lang.Exception> |
|
ImmediateFuture.ImmediateSuccessfulFuture<V> |
|
ImmutableAsList<E> |
|
ImmutableAsList.SerializedForm |
Serialized form that leads to the same performance as the original list.
|
ImmutableBiMap<K,V> |
|
ImmutableBiMap.Builder<K,V> |
A builder for creating immutable bimap instances, especially public
static final bimaps ("constant bimaps").
|
ImmutableBiMap.SerializedForm |
Serialized type for all ImmutableBiMap instances.
|
ImmutableClassToInstanceMap<B> |
|
ImmutableClassToInstanceMap.Builder<B> |
A builder for creating immutable class-to-instance maps.
|
ImmutableCollection<E> |
A Collection whose contents will never change, and which offers a few additional
guarantees detailed below.
|
ImmutableCollection.ArrayBasedBuilder<E> |
|
ImmutableCollection.Builder<E> |
|
ImmutableEntry<K,V> |
|
ImmutableEnumMap<K extends java.lang.Enum<K>,V> |
Implementation of ImmutableMap backed by a non-empty EnumMap .
|
ImmutableEnumMap.EnumSerializedForm<K extends java.lang.Enum<K>,V> |
|
ImmutableEnumSet<E extends java.lang.Enum<E>> |
Implementation of ImmutableSet backed by a non-empty EnumSet .
|
ImmutableEnumSet.EnumSerializedForm<E extends java.lang.Enum<E>> |
|
ImmutableGraph<N> |
A Graph whose elements and structural relationships will never change.
|
ImmutableGraph.ValueBackedImpl<N,V> |
|
ImmutableList<E> |
A List whose contents will never change, with many other important properties detailed at
ImmutableCollection .
|
ImmutableList.Builder<E> |
A builder for creating immutable list instances, especially public
static final lists ("constant lists").
|
ImmutableList.ReverseImmutableList<E> |
|
ImmutableList.SerializedForm |
|
ImmutableListMultimap<K,V> |
|
ImmutableListMultimap.Builder<K,V> |
A builder for creating immutable ListMultimap instances, especially
public static final multimaps ("constant multimaps").
|
ImmutableMap<K,V> |
A Map whose contents will never change, with many other important properties detailed at
ImmutableCollection .
|
ImmutableMap.Builder<K,V> |
A builder for creating immutable map instances, especially public
static final maps ("constant maps").
|
ImmutableMap.IteratorBasedImmutableMap<K,V> |
|
ImmutableMap.SerializedForm |
Serialized type for all ImmutableMap instances.
|
ImmutableMapEntry<K,V> |
Implementation of Map.Entry for ImmutableMap that adds extra methods to traverse
hash buckets for the key and the value.
|
ImmutableMapEntry.NonTerminalImmutableBiMapEntry<K,V> |
|
ImmutableMapEntry.NonTerminalImmutableMapEntry<K,V> |
|
ImmutableMapEntrySet<K,V> |
|
ImmutableMapEntrySet.EntrySetSerializedForm<K,V> |
|
ImmutableMapEntrySet.RegularEntrySet<K,V> |
|
ImmutableMapKeySet<K,V> |
|
ImmutableMapKeySet.KeySetSerializedForm<K> |
|
ImmutableMapValues<K,V> |
|
ImmutableMapValues.SerializedForm<V> |
|
ImmutableMultimap<K,V> |
|
ImmutableMultimap.Builder<K,V> |
A builder for creating immutable multimap instances, especially
public static final multimaps ("constant multimaps").
|
ImmutableMultimap.EntryCollection<K,V> |
|
ImmutableMultimap.FieldSettersHolder |
|
ImmutableMultimap.Values<K,V> |
|
ImmutableMultiset<E> |
|
ImmutableMultiset.Builder<E> |
A builder for creating immutable multiset instances, especially
public static final multisets ("constant multisets").
|
ImmutableMultiset.EntrySetSerializedForm<E> |
|
ImmutableMultiset.SerializedForm |
|
ImmutableNetwork<N,E> |
A Network whose elements and structural relationships will never change.
|
ImmutableRangeMap<K extends java.lang.Comparable<?>,V> |
|
ImmutableRangeMap.Builder<K extends java.lang.Comparable<?>,V> |
A builder for immutable range maps.
|
ImmutableRangeMap.SerializedForm<K extends java.lang.Comparable<?>,V> |
This class is used to serialize ImmutableRangeMap instances.
|
ImmutableRangeSet<C extends java.lang.Comparable> |
|
ImmutableRangeSet.AsSetSerializedForm<C extends java.lang.Comparable> |
|
ImmutableRangeSet.Builder<C extends java.lang.Comparable<?>> |
A builder for immutable range sets.
|
ImmutableRangeSet.SerializedForm<C extends java.lang.Comparable> |
|
ImmutableSet<E> |
A Set whose contents will never change, with many other important properties detailed at
ImmutableCollection .
|
ImmutableSet.Builder<E> |
A builder for creating ImmutableSet instances.
|
ImmutableSet.Indexed<E> |
|
ImmutableSet.SerializedForm |
|
ImmutableSetMultimap<K,V> |
|
ImmutableSetMultimap.Builder<K,V> |
A builder for creating immutable SetMultimap instances, especially
public static final multimaps ("constant multimaps").
|
ImmutableSetMultimap.EntrySet<K,V> |
|
ImmutableSortedAsList<E> |
List returned by ImmutableSortedSet.asList() when the set isn't empty.
|
ImmutableSortedMap<K,V> |
A NavigableMap whose contents will never change, with many other important properties
detailed at ImmutableCollection .
|
ImmutableSortedMap.Builder<K,V> |
A builder for creating immutable sorted map instances, especially
public static final maps ("constant maps").
|
ImmutableSortedMap.SerializedForm |
Serialized type for all ImmutableSortedMap instances.
|
ImmutableSortedMapFauxverideShim<K,V> |
|
ImmutableSortedMultiset<E> |
|
ImmutableSortedMultiset.Builder<E> |
A builder for creating immutable multiset instances, especially public static final
multisets ("constant multisets").
|
ImmutableSortedMultiset.SerializedForm<E> |
|
ImmutableSortedMultisetFauxverideShim<E> |
|
ImmutableSortedSet<E> |
A NavigableSet whose contents will never change, with many other important properties
detailed at ImmutableCollection .
|
ImmutableSortedSet.Builder<E> |
A builder for creating immutable sorted set instances, especially
public static final sets ("constant sets"), with a given comparator.
|
ImmutableSortedSet.SerializedForm<E> |
|
ImmutableSortedSetFauxverideShim<E> |
|
ImmutableTable<R,C,V> |
|
ImmutableTable.Builder<R,C,V> |
A builder for creating immutable table instances, especially public
static final tables ("constant tables").
|
ImmutableTable.SerializedForm |
Serialized type for all ImmutableTable instances.
|
ImmutableTypeToInstanceMap<B> |
|
ImmutableTypeToInstanceMap.Builder<B> |
A builder for creating immutable type-to-instance maps.
|
ImmutableValueGraph<N,V> |
A ValueGraph whose elements and structural relationships will never change.
|
InetAddresses |
Static utility methods pertaining to InetAddress instances.
|
InetAddresses.TeredoInfo |
A simple immutable data class to encapsulate the information to be found in a Teredo address.
|
Interner<E> |
Provides equivalent behavior to String.intern() for other immutable
types.
|
Interners |
Contains static methods pertaining to instances of Interner .
|
Interners.InternerFunction<E> |
|
Interners.WeakInterner<E> |
|
Interners.WeakInterner.Dummy |
|
InternetDomainName |
An immutable well-formed internet domain name, such as com or
foo.co.uk .
|
InterruptibleTask |
|
InterruptibleTask.AtomicHelper |
|
InterruptibleTask.SafeAtomicHelper |
|
InterruptibleTask.SynchronizedAtomicHelper |
|
IntMath |
A class for arithmetic on values of type int .
|
Ints |
Static utility methods pertaining to int primitives, that are not already found in either
Integer or Arrays .
|
Ints.IntArrayAsList |
|
Ints.IntConverter |
|
Ints.LexicographicalComparator |
|
Invokable<T,R> |
Wrapper around either a Method or a Constructor .
|
Invokable.ConstructorInvokable<T> |
|
Invokable.MethodInvokable<T> |
|
Iterables |
This class contains static utility methods that operate on or return objects
of type Iterable .
|
Iterables.UnmodifiableIterable<T> |
|
IteratorFeature |
A method supported by implementations of the Iterator or
ListIterator interface.
|
Iterators |
This class contains static utility methods that operate on or return objects
of type Iterator .
|
Iterators.ConcatenatedIterator<T> |
|
Iterators.MergingIterator<T> |
An iterator that performs a lazy N-way merge, calculating the next value
each time the iterator is polled.
|
Iterators.PeekingImpl<E> |
Implementation of PeekingIterator that avoids peeking unless necessary.
|
IteratorTester<E> |
A utility for testing an Iterator implementation by comparing its behavior to
that of a "known good" reference implementation.
|
IteratorTestSuiteBuilder<E> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
an Iterator implementation.
|
JdkFutureAdapters |
Utilities necessary for working with libraries that supply plain Future instances.
|
JdkFutureAdapters.ListenableFutureAdapter<V> |
|
JdkPattern |
A regex pattern implementation which is backed by the Pattern .
|
JdkPattern.JdkMatcher |
|
Joiner |
An object which joins pieces of text (specified as an array, Iterable , varargs or even a
Map ) with a separator.
|
Joiner.MapJoiner |
An object that joins map entries in the same manner as Joiner joins iterables and
arrays.
|
LexicographicalOrdering<T> |
An ordering which sorts iterables by comparing corresponding elements
pairwise.
|
LinearTransformation |
The representation of a linear transformation between real numbers x and y .
|
LinearTransformation.LinearTransformationBuilder |
This is an intermediate stage in the construction process.
|
LinearTransformation.NaNLinearTransformation |
|
LinearTransformation.RegularLinearTransformation |
|
LinearTransformation.VerticalLinearTransformation |
|
LineBuffer |
Package-protected abstract class that implements the line reading algorithm used by
LineReader .
|
LineProcessor<T> |
A callback to be used with the streaming readLines methods.
|
LineReader |
A class for reading lines of text.
|
LinkedHashMultimap<K,V> |
Implementation of Multimap that does not allow duplicate key-value
entries and that returns collections whose iterators follow the ordering in
which the data was added to the multimap.
|
LinkedHashMultimap.ValueEntry<K,V> |
LinkedHashMultimap entries are in no less than three coexisting linked lists:
a bucket in the hash table for a Set associated with a key, the linked list
of insertion-ordered entries in that Set, and the linked list of entries
in the LinkedHashMultimap as a whole.
|
LinkedHashMultimap.ValueSetLink<K,V> |
|
LinkedHashMultiset<E> |
A Multiset implementation with predictable iteration order.
|
LinkedListMultimap<K,V> |
An implementation of ListMultimap that supports deterministic
iteration order for both keys and values.
|
LinkedListMultimap.KeyList<K,V> |
|
LinkedListMultimap.Node<K,V> |
|
ListAddAllAtIndexTester<E> |
A generic JUnit test which tests addAll(int, Collection) operations
on a list.
|
ListAddAllTester<E> |
A generic JUnit test which tests addAll(Collection) operations on a
list.
|
ListAddAtIndexTester<E> |
A generic JUnit test which tests add(int, Object) operations on a
list.
|
ListAddTester<E> |
A generic JUnit test which tests add(Object) operations on a list.
|
ListCreationTester<E> |
A generic JUnit test which tests creation (typically through a constructor or
static factory method) of a list.
|
ListenableFuture<V> |
A Future that accepts completion listeners.
|
ListenableFutureTask<V> |
|
ListenableScheduledFuture<V> |
|
ListenerCallQueue<L> |
A special purpose queue/executor that executes listener callbacks serially on a configured
executor.
|
ListenerCallQueue.Callback<L> |
|
ListeningExecutorService |
|
ListeningScheduledExecutorService |
A ScheduledExecutorService that returns ListenableFuture instances from its
ExecutorService methods.
|
ListEqualsTester<E> |
Tests List.equals(java.lang.Object) .
|
ListFeature |
Optional features of classes derived from List .
|
ListFeature.Require |
|
ListGenerators |
Common generators of different types of lists.
|
ListGenerators.BuilderAddAllListGenerator |
|
ListGenerators.BuilderAddListGenerator |
|
ListGenerators.BuilderReversedListGenerator |
|
ListGenerators.CharactersOfCharSequenceGenerator |
|
ListGenerators.CharactersOfStringGenerator |
|
ListGenerators.ImmutableListHeadSubListGenerator |
|
ListGenerators.ImmutableListMiddleSubListGenerator |
|
ListGenerators.ImmutableListOfGenerator |
|
ListGenerators.ImmutableListTailSubListGenerator |
|
ListGenerators.TestUnhashableListGenerator |
|
ListGenerators.UnhashableElementsImmutableListGenerator |
|
ListGetTester<E> |
A generic JUnit test which tests get() operations on a list.
|
ListHashCodeTester<E> |
Tests List.hashCode() .
|
ListIndexOfTester<E> |
A generic JUnit test which tests indexOf() operations on a list.
|
ListIteratorTester<E> |
A utility similar to IteratorTester for testing a
ListIterator against a known good reference implementation.
|
ListLastIndexOfTester<E> |
A generic JUnit test which tests lastIndexOf() operations on a list.
|
ListListIteratorTester<E> |
A generic JUnit test which tests listIterator operations on a list.
|
ListMultimap<K,V> |
A Multimap that can hold duplicate key-value pairs and that maintains
the insertion ordering of values for a given key.
|
ListMultimapAsMapTester<K,V> |
|
ListMultimapEqualsTester<K,V> |
|
ListMultimapPutAllTester<K,V> |
|
ListMultimapPutTester<K,V> |
|
ListMultimapRemoveTester<K,V> |
|
ListMultimapReplaceValuesTester<K,V> |
|
ListMultimapTestSuiteBuilder<K,V> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
a ListMultimap implementation.
|
ListMultimapTestSuiteBuilder.MultimapAsMapGetGenerator<K,V> |
|
ListMultimapTestSuiteBuilder.MultimapGetGenerator<K,V> |
|
ListRemoveAllTester<E> |
A generic JUnit test which tests removeAll operations on a list.
|
ListRemoveAtIndexTester<E> |
A generic JUnit test which tests remove(int) operations on a list.
|
ListRemoveTester<E> |
A generic JUnit test which tests remove(Object) operations on a list.
|
ListRetainAllTester<E> |
A generic JUnit test which tests retainAll operations on a list.
|
Lists |
Static utility methods pertaining to List instances.
|
Lists.AbstractListWrapper<E> |
|
Lists.CharSequenceAsList |
|
Lists.OnePlusArrayList<E> |
|
Lists.Partition<T> |
|
Lists.RandomAccessListWrapper<E> |
|
Lists.RandomAccessPartition<T> |
|
Lists.RandomAccessReverseList<T> |
|
Lists.ReverseList<T> |
|
Lists.StringAsImmutableList |
|
Lists.TransformingRandomAccessList<F,T> |
Implementation of a transforming random access list.
|
Lists.TransformingSequentialList<F,T> |
Implementation of a sequential transforming list.
|
Lists.TwoPlusArrayList<E> |
|
ListSetTester<E> |
A generic JUnit test which tests set() operations on a list.
|
ListSubListTester<E> |
A generic JUnit test which tests subList() operations on a list.
|
ListTestSuiteBuilder<E> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
a List implementation.
|
ListTestSuiteBuilder.ReserializedListGenerator<E> |
|
ListToArrayTester<E> |
A generic JUnit test which tests toArray() operations on a list.
|
LittleEndianByteArray |
Utility functions for loading and storing values from a byte array.
|
LittleEndianByteArray.JavaLittleEndianBytes |
Fallback implementation for when Unsafe is not available in our current environment.
|
LittleEndianByteArray.LittleEndianBytes |
Common interface for retrieving a 64-bit long from a little-endian byte array.
|
LittleEndianByteArray.UnsafeByteArray |
The only reference to Unsafe is in this nested class.
|
LittleEndianDataInputStream |
An implementation of DataInput that uses little-endian byte ordering for reading
short , int , float , double , and long values.
|
LittleEndianDataOutputStream |
An implementation of DataOutput that uses little-endian byte ordering for writing
char , short , int , float , double , and long values.
|
LoadingCache<K,V> |
A semi-persistent mapping from keys to values.
|
LocalCache<K,V> |
The concurrent hash map implementation built by CacheBuilder .
|
LocalCache.AbstractReferenceEntry<K,V> |
|
LocalCache.AccessQueue<K,V> |
A custom queue for managing access order.
|
LocalCache.EntryFactory |
Creates new entries.
|
LocalCache.LoadingSerializationProxy<K,V> |
Serializes the configuration of a LocalCache, reconsitituting it as an LoadingCache using
CacheBuilder upon deserialization.
|
LocalCache.LoadingValueReference<K,V> |
|
LocalCache.LocalLoadingCache<K,V> |
|
LocalCache.LocalManualCache<K,V> |
|
LocalCache.ManualSerializationProxy<K,V> |
Serializes the configuration of a LocalCache, reconsitituting it as a Cache using CacheBuilder
upon deserialization.
|
LocalCache.NullEntry |
|
LocalCache.ReferenceEntry<K,V> |
An entry in a reference map.
|
LocalCache.Segment<K,V> |
Segments are specialized versions of hash tables.
|
LocalCache.SoftValueReference<K,V> |
References a soft value.
|
LocalCache.Strength |
|
LocalCache.StrongAccessEntry<K,V> |
|
LocalCache.StrongAccessWriteEntry<K,V> |
|
LocalCache.StrongEntry<K,V> |
Used for strongly-referenced keys.
|
LocalCache.StrongValueReference<K,V> |
References a strong value.
|
LocalCache.StrongWriteEntry<K,V> |
|
LocalCache.ValueReference<K,V> |
A reference to a value.
|
LocalCache.WeakAccessEntry<K,V> |
|
LocalCache.WeakAccessWriteEntry<K,V> |
|
LocalCache.WeakEntry<K,V> |
Used for weakly-referenced keys.
|
LocalCache.WeakValueReference<K,V> |
References a weak value.
|
LocalCache.WeakWriteEntry<K,V> |
|
LocalCache.WeightedSoftValueReference<K,V> |
References a soft value.
|
LocalCache.WeightedStrongValueReference<K,V> |
References a strong value.
|
LocalCache.WeightedWeakValueReference<K,V> |
References a weak value.
|
LocalCache.WriteQueue<K,V> |
A custom queue for managing eviction order.
|
LongAddable |
Abstract interface for objects that can concurrently add longs.
|
LongAddables |
Source of LongAddable objects that deals with GWT, Unsafe, and all that.
|
LongAddables.PureJavaLongAddable |
|
LongAdder |
One or more variables that together maintain an initially zero
long sum.
|
LongMath |
A class for arithmetic on values of type long .
|
LongMath.MillerRabinTester |
|
Longs |
Static utility methods pertaining to long primitives, that are not already found in
either Long or Arrays .
|
Longs.LexicographicalComparator |
|
Longs.LongArrayAsList |
|
Longs.LongConverter |
|
MacHashFunction |
|
MacHashFunction.MacHasher |
Hasher that updates a Mac (message authentication code).
|
MapClearTester<K,V> |
A generic JUnit test which tests clear() operations on a map.
|
MapConstraint<K,V> |
Deprecated.
|
MapConstraints |
Deprecated.
|
MapConstraints.ConstrainedAsMapEntries<K,V> |
|
MapConstraints.ConstrainedAsMapValues<K,V> |
|
MapConstraints.ConstrainedEntries<K,V> |
|
MapConstraints.ConstrainedEntrySet<K,V> |
|
MapConstraints.ConstrainedListMultimap<K,V> |
|
MapConstraints.ConstrainedMap<K,V> |
|
MapConstraints.ConstrainedMultimap<K,V> |
|
MapContainsKeyTester<K,V> |
A generic JUnit test which tests containsKey() operations on a map.
|
MapContainsValueTester<K,V> |
A generic JUnit test which tests containsValue() operations on a map.
|
MapCreationTester<K,V> |
A generic JUnit test which tests creation (typically through a constructor or
static factory method) of a map.
|
MapDifference<K,V> |
An object representing the differences between two maps.
|
MapDifference.ValueDifference<V> |
A difference between the mappings from two maps with the same key.
|
MapEntrySetTester<K,V> |
Tests Map.entrySet() .
|
MapEntrySetTester.IncomparableType |
|
MapEqualsTester<K,V> |
Tests Map.equals(java.lang.Object) .
|
MapFeature |
Optional features of classes derived from Map .
|
MapFeature.Require |
|
MapGenerators |
Generators of different types of map and related collections, such as
keys, entries and values.
|
MapGenerators.ImmutableEnumMapGenerator |
|
MapGenerators.ImmutableMapCopyOfEntriesGenerator |
|
MapGenerators.ImmutableMapCopyOfEnumMapGenerator |
|
MapGenerators.ImmutableMapCopyOfGenerator |
|
MapGenerators.ImmutableMapEntryListGenerator |
|
MapGenerators.ImmutableMapGenerator |
|
MapGenerators.ImmutableMapKeyListGenerator |
|
MapGenerators.ImmutableMapUnhashableValuesGenerator |
|
MapGenerators.ImmutableMapValueListGenerator |
|
MapGetTester<K,V> |
A generic JUnit test which tests get operations on a map.
|
MapHashCodeTester<K,V> |
Tests Map.hashCode() .
|
MapInterfaceTest<K,V> |
Tests representing the contract of Map .
|
MapInterfaceTest.IncompatibleKeyType |
A key type that is not assignable to any classes but Object.
|
MapIsEmptyTester<K,V> |
A generic JUnit test which tests isEmpty() operations on a
map.
|
MapIteratorCache<K,V> |
|
MapMaker |
A builder of ConcurrentMap instances that can have keys or values automatically
wrapped in weak references.
|
MapMakerInternalMap<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>,S extends MapMakerInternalMap.Segment<K,V,E,S>> |
The concurrent hash map implementation built by MapMaker .
|
MapMakerInternalMap.AbstractSerializationProxy<K,V> |
The actual object that gets serialized.
|
MapMakerInternalMap.AbstractStrongKeyEntry<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>> |
|
MapMakerInternalMap.AbstractWeakKeyEntry<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>> |
|
MapMakerInternalMap.CleanupMapTask |
|
MapMakerInternalMap.DummyInternalEntry |
|
MapMakerInternalMap.InternalEntry<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>> |
|
MapMakerInternalMap.InternalEntryHelper<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>,S extends MapMakerInternalMap.Segment<K,V,E,S>> |
|
MapMakerInternalMap.SafeToArraySet<E> |
|
MapMakerInternalMap.Segment<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>,S extends MapMakerInternalMap.Segment<K,V,E,S>> |
Segments are specialized versions of hash tables.
|
MapMakerInternalMap.SerializationProxy<K,V> |
The actual object that gets serialized.
|
MapMakerInternalMap.Strength |
|
MapMakerInternalMap.StrongKeyStrongValueEntry<K,V> |
|
MapMakerInternalMap.StrongKeyStrongValueEntry.Helper<K,V> |
|
MapMakerInternalMap.StrongKeyStrongValueSegment<K,V> |
|
MapMakerInternalMap.StrongKeyWeakValueEntry<K,V> |
|
MapMakerInternalMap.StrongKeyWeakValueEntry.Helper<K,V> |
|
MapMakerInternalMap.StrongKeyWeakValueSegment<K,V> |
|
MapMakerInternalMap.StrongValueEntry<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>> |
|
MapMakerInternalMap.WeakKeyStrongValueEntry<K,V> |
|
MapMakerInternalMap.WeakKeyStrongValueEntry.Helper<K,V> |
|
MapMakerInternalMap.WeakKeyStrongValueSegment<K,V> |
|
MapMakerInternalMap.WeakKeyWeakValueEntry<K,V> |
|
MapMakerInternalMap.WeakKeyWeakValueEntry.Helper<K,V> |
|
MapMakerInternalMap.WeakKeyWeakValueSegment<K,V> |
|
MapMakerInternalMap.WeakValueEntry<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>> |
|
MapMakerInternalMap.WeakValueReference<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>> |
A weakly referenced value that also has a reference to its containing entry.
|
MapMakerInternalMap.WeakValueReferenceImpl<K,V,E extends MapMakerInternalMap.InternalEntry<K,V,E>> |
|
MapPutAllTester<K,V> |
A generic JUnit test which tests putAll operations on a map.
|
MapPutTester<K,V> |
A generic JUnit test which tests put operations on a map.
|
MapRemoveTester<K,V> |
A generic JUnit test which tests remove operations on a map.
|
MapRetrievalCache<K,V> |
|
MapRetrievalCache.CacheEntry<K,V> |
|
Maps |
Static utility methods pertaining to Map instances (including instances of
SortedMap , BiMap , etc.).
|
Maps.AbstractFilteredMap<K,V> |
|
Maps.AsMapView<K,V> |
|
Maps.BiMapConverter<A,B> |
|
Maps.DescendingMap<K,V> |
|
Maps.EntryFunction |
|
Maps.EntrySet<K,V> |
|
Maps.EntryTransformer<K,V1,V2> |
A transformation of the value of a key-value pair, using both key and value
as inputs.
|
Maps.FilteredEntryBiMap<K,V> |
|
Maps.FilteredEntryMap<K,V> |
|
Maps.FilteredEntryNavigableMap<K,V> |
|
Maps.FilteredEntrySortedMap<K,V> |
|
Maps.FilteredKeyMap<K,V> |
|
Maps.FilteredMapValues<K,V> |
|
Maps.IteratorBasedAbstractMap<K,V> |
|
Maps.KeySet<K,V> |
|
Maps.MapDifferenceImpl<K,V> |
|
Maps.NavigableAsMapView<K,V> |
|
Maps.NavigableKeySet<K,V> |
|
Maps.SortedAsMapView<K,V> |
|
Maps.SortedKeySet<K,V> |
|
Maps.SortedMapDifferenceImpl<K,V> |
|
Maps.TransformedEntriesMap<K,V1,V2> |
|
Maps.TransformedEntriesNavigableMap<K,V1,V2> |
|
Maps.TransformedEntriesSortedMap<K,V1,V2> |
|
Maps.UnmodifiableBiMap<K,V> |
|
Maps.UnmodifiableEntries<K,V> |
|
Maps.UnmodifiableEntrySet<K,V> |
|
Maps.UnmodifiableNavigableMap<K,V> |
|
Maps.ValueDifferenceImpl<V> |
|
Maps.Values<K,V> |
|
Maps.ViewCachingAbstractMap<K,V> |
AbstractMap extension that makes it easy to cache customized keySet, values,
and entrySet views.
|
MapSerializationTester<K,V> |
Basic serialization test for maps.
|
MapSizeTester<K,V> |
A generic JUnit test which tests size() operations on a map.
|
MapTestSuiteBuilder<K,V> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
a Map implementation.
|
MapTestSuiteBuilder.ReserializedMapGenerator<K,V> |
|
MapToStringTester<K,V> |
A generic JUnit test which tests toString() operations on a map.
|
MathPreconditions |
A collection of preconditions for math functions.
|
MediaType |
|
MediaType.Tokenizer |
|
MessageDigestHashFunction |
|
MessageDigestHashFunction.MessageDigestHasher |
Hasher that updates a message digest.
|
MessageDigestHashFunction.SerializedForm |
|
MinimalCollection<E> |
A simplistic collection which implements only the bare minimum allowed by the
spec, and throws exceptions whenever it can.
|
MinimalIterable<E> |
An implementation of Iterable which throws an exception on all
invocations of the MinimalIterable.iterator() method after the first, and whose
iterator is always unmodifiable.
|
MinimalSet<E> |
A simplistic set which implements the bare minimum so that it can be used in
tests without relying on any specific Set implementations.
|
MinMaxPriorityQueue<E> |
A double-ended priority queue, which provides constant-time access to both
its least element and its greatest element, as determined by the queue's
specified comparator.
|
MinMaxPriorityQueue.Builder<B> |
The builder class used in creation of min-max priority queues.
|
MinMaxPriorityQueue.MoveDesc<E> |
|
MockFutureListener |
A simple mock implementation of Runnable that can be used for
testing ListenableFutures.
|
Monitor |
A synchronization abstraction supporting waiting on arbitrary boolean conditions.
|
Monitor.Guard |
A boolean condition for which a thread may wait.
|
MoreExecutors |
Factory and utility methods for Executor , ExecutorService ,
and ThreadFactory .
|
MoreExecutors.Application |
Represents the current application to register shutdown hooks.
|
MoreExecutors.DirectExecutor |
|
MoreExecutors.DirectExecutorService |
|
MoreExecutors.ListeningDecorator |
|
MoreExecutors.ScheduledListeningDecorator |
|
MoreExecutors.ScheduledListeningDecorator.ListenableScheduledTask<V> |
|
MoreExecutors.ScheduledListeningDecorator.NeverSuccessfulListenableFutureTask |
|
MoreObjects |
Helper functions that operate on any Object , and are not already provided in
Objects .
|
MoreObjects.ToStringHelper |
|
MoreObjects.ToStringHelper.ValueHolder |
|
MultiEdgesConnecting<E> |
A class to represent the set of edges connecting an (implicit) origin node to a target node.
|
MultiInputStream |
An InputStream that concatenates multiple substreams.
|
Multimap<K,V> |
A collection that maps keys to values, similar to Map , but in which
each key may be associated with multiple values.
|
MultimapAsMapGetTester<K,V> |
Tests for Multimap.asMap().get(Object) .
|
MultimapAsMapTester<K,V> |
|
MultimapBuilder<K0,V0> |
A builder for a multimap implementation that allows customization of the backing map and value
collection implementations used in a particular multimap.
|
MultimapBuilder.ArrayListSupplier<V> |
|
MultimapBuilder.EnumSetSupplier<V extends java.lang.Enum<V>> |
|
MultimapBuilder.HashSetSupplier<V> |
|
MultimapBuilder.LinkedHashSetSupplier<V> |
|
MultimapBuilder.LinkedListSupplier |
|
MultimapBuilder.ListMultimapBuilder<K0,V0> |
|
MultimapBuilder.MultimapBuilderWithKeys<K0> |
An intermediate stage in a MultimapBuilder in which the key-value collection map
implementation has been specified, but the value collection implementation has not.
|
MultimapBuilder.SetMultimapBuilder<K0,V0> |
|
MultimapBuilder.SortedSetMultimapBuilder<K0,V0> |
|
MultimapBuilder.TreeSetSupplier<V> |
|
MultimapClearTester<K,V> |
|
MultimapContainsEntryTester<K,V> |
|
MultimapContainsKeyTester<K,V> |
Tester for the containsKey methods of Multimap and its asMap() view.
|
MultimapContainsValueTester<K,V> |
|
MultimapEntriesTester<K,V> |
Tester for Multimap.entries .
|
MultimapEqualsTester<K,V> |
Tester for Multimap.equals .
|
MultimapFeature |
Optional features of classes derived from Multimap .
|
MultimapFeature.Require |
|
MultimapGetTester<K,V> |
|
MultimapKeySetTester<K,V> |
Tester for Multimap.keySet .
|
MultimapKeysTester<K,V> |
Tester for Multimap.entries .
|
MultimapPutAllMultimapTester<K,V> |
|
MultimapPutIterableTester<K,V> |
|
MultimapPutTester<K,V> |
|
MultimapRemoveAllTester<K,V> |
|
MultimapRemoveEntryTester<K,V> |
|
MultimapReplaceValuesTester<K,V> |
|
Multimaps |
Provides static methods acting on or generating a Multimap .
|
Multimaps.AsMap<K,V> |
|
Multimaps.CustomListMultimap<K,V> |
|
Multimaps.CustomMultimap<K,V> |
|
Multimaps.CustomSetMultimap<K,V> |
|
Multimaps.CustomSortedSetMultimap<K,V> |
|
Multimaps.Entries<K,V> |
|
Multimaps.Keys<K,V> |
|
Multimaps.MapMultimap<K,V> |
|
Multimaps.TransformedEntriesListMultimap<K,V1,V2> |
|
Multimaps.TransformedEntriesMultimap<K,V1,V2> |
|
Multimaps.UnmodifiableListMultimap<K,V> |
|
Multimaps.UnmodifiableMultimap<K,V> |
|
Multimaps.UnmodifiableSetMultimap<K,V> |
|
Multimaps.UnmodifiableSortedSetMultimap<K,V> |
|
MultimapSizeTester<K,V> |
Tester for the size methods of Multimap and its views.
|
MultimapTestSuiteBuilder<K,V,M extends Multimap<K,V>> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
a Multimap implementation.
|
MultimapTestSuiteBuilder.AsMapGenerator<K,V,M extends Multimap<K,V>> |
|
MultimapTestSuiteBuilder.EntriesGenerator<K,V,M extends Multimap<K,V>> |
|
MultimapTestSuiteBuilder.KeysGenerator<K,V,M extends Multimap<K,V>> |
|
MultimapTestSuiteBuilder.MultimapAsMapGetGenerator<K,V,M extends Multimap<K,V>> |
|
MultimapTestSuiteBuilder.MultimapGetGenerator<K,V,M extends Multimap<K,V>> |
|
MultimapTestSuiteBuilder.ReserializedMultimapGenerator<K,V,M extends Multimap<K,V>> |
|
MultimapTestSuiteBuilder.ValuesGenerator<K,V,M extends Multimap<K,V>> |
|
MultimapToStringTester<K,V> |
Tester for Multimap.toString() .
|
MultimapValuesTester<K,V> |
Tester for Multimap.values .
|
MultiReader |
A Reader that concatenates multiple readers.
|
Multiset<E> |
A collection that supports order-independent equality, like Set , but
may have duplicate elements.
|
Multiset.Entry<E> |
An unmodifiable element-count pair for a multiset.
|
MultisetAddTester<E> |
Tests for Multiset.add .
|
MultisetContainsTester<E> |
Tests for Multiset.containsAll not already addressed by CollectionContainsTester .
|
MultisetCountTester<E> |
Tests for Multiset#count .
|
MultisetElementSetTester<E> |
Tests for Multiset.elementSet() not covered by the derived SetTestSuiteBuilder .
|
MultisetEntrySetTester<E> |
Tests for Multiset.entrySet .
|
MultisetEqualsTester<E> |
Tests for Multiset.equals and Multiset.hashCode .
|
MultisetFeature |
Optional features of classes derived from Multiset .
|
MultisetFeature.Require |
|
MultisetIteratorTester<E> |
Tester to make sure the iterator().remove() implementation of Multiset works when
there are multiple occurrences of elements.
|
MultisetNavigationTester<E> |
Tester for navigation of SortedMultisets.
|
MultisetNavigationTester.SubMultisetSpec |
|
MultisetReadsTester<E> |
A generic JUnit test which tests multiset-specific read operations.
|
MultisetRemoveTester<E> |
Tests for Multiset#remove , Multiset.removeAll , and Multiset.retainAll
not already covered by the corresponding Collection testers.
|
Multisets |
Provides static utility methods for creating and working with Multiset instances.
|
Multisets.AbstractEntry<E> |
Implementation of the equals , hashCode , and
toString methods of Multiset.Entry .
|
Multisets.ElementSet<E> |
|
Multisets.EntrySet<E> |
|
Multisets.FilteredMultiset<E> |
|
Multisets.ImmutableEntry<E> |
|
Multisets.MultisetIteratorImpl<E> |
|
Multisets.UnmodifiableMultiset<E> |
|
MultisetSerializationTester<E> |
A generic JUnit test which tests multiset-specific serialization.
|
MultisetSetCountConditionallyTester<E> |
A generic JUnit test which tests conditional setCount() operations on
a multiset.
|
MultisetSetCountUnconditionallyTester<E> |
A generic JUnit test which tests unconditional setCount() operations
on a multiset.
|
MultisetTestSuiteBuilder<E> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
a Multiset implementation.
|
MultisetTestSuiteBuilder.ElementSetGenerator<E> |
|
MultisetTestSuiteBuilder.EntrySetGenerator<E> |
|
MultisetTestSuiteBuilder.NoRecurse |
|
MultisetTestSuiteBuilder.ReserializedMultisetGenerator<E> |
|
MultitransformedIterator<F,T> |
|
Murmur3_128HashFunction |
|
Murmur3_128HashFunction.Murmur3_128Hasher |
|
Murmur3_32HashFunction |
|
Murmur3_32HashFunction.Murmur3_32Hasher |
|
MutableClassToInstanceMap<B> |
A mutable class-to-instance map backed by an arbitrary user-provided map.
|
MutableClassToInstanceMap.SerializedForm<B> |
Serialized form of the map, to avoid serializing the constraint.
|
MutableGraph<N> |
A subinterface of Graph which adds mutation methods.
|
MutableNetwork<N,E> |
A subinterface of Network which adds mutation methods.
|
MutableTypeToInstanceMap<B> |
A mutable type-to-instance map.
|
MutableTypeToInstanceMap.UnmodifiableEntry<K,V> |
|
MutableValueGraph<N,V> |
A subinterface of ValueGraph which adds mutation methods.
|
NaturalOrdering |
An ordering that uses the natural order of the values.
|
NavigableMapNavigationTester<K,V> |
A generic JUnit test which tests operations on a NavigableMap.
|
NavigableMapTestSuiteBuilder<K,V> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
a NavigableMap implementation.
|
NavigableMapTestSuiteBuilder.DescendingTestMapGenerator<K,V> |
|
NavigableMapTestSuiteBuilder.NavigableMapSubmapTestMapGenerator<K,V> |
|
NavigableSetNavigationTester<E> |
A generic JUnit test which tests operations on a NavigableSet.
|
NavigableSetTestSuiteBuilder<E> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
a NavigableSet implementation.
|
NavigableSetTestSuiteBuilder.NavigableSetSubsetTestSetGenerator<E> |
|
Network<N,E> |
An interface for graph-structured data,
whose edges are unique objects.
|
NetworkBuilder<N,E> |
A builder for constructing instances of MutableNetwork with user-defined properties.
|
NetworkConnections<N,E> |
An interface for representing and manipulating an origin node's adjacent nodes and incident edges
in a Network .
|
NullPointerTester |
A test utility that verifies that your methods and constructors throw NullPointerException or UnsupportedOperationException whenever null
is passed to a parameter that isn't annotated with Nullable .
|
NullPointerTester.ExceptionTypePolicy |
|
NullPointerTester.Signature |
|
NullPointerTester.Visibility |
Visibility of any method or constructor.
|
NullsFirstOrdering<T> |
An ordering that treats null as less than all other values.
|
NullsLastOrdering<T> |
An ordering that treats null as greater than all other values.
|
ObjectArrays |
Static utility methods pertaining to object arrays.
|
Objects |
Helper functions that can operate on any Object .
|
Objects.ToStringHelper |
Deprecated.
|
Objects.ToStringHelper.ValueHolder |
|
OneSizeGenerator<T,E> |
Generator for collection of a particular size.
|
OneSizeTestContainerGenerator<T,E> |
The subject-generator interface accepted by Collection testers, for testing
a Collection at one particular CollectionSize .
|
Optional<T> |
An immutable object that may contain a non-null reference to another object.
|
Ordering<T> |
A comparator, with additional methods to support common operations.
|
Ordering.ArbitraryOrdering |
|
Ordering.ArbitraryOrderingHolder |
|
Ordering.IncomparableValueException |
|
PairedStats |
An immutable value object capturing some basic statistics about a collection of paired double
values (e.g.
|
PairedStatsAccumulator |
A mutable object which accumulates paired double values (e.g.
|
PairwiseEquivalence<T> |
|
Parameter |
Represents a method or constructor parameter.
|
ParseRequest |
A string to be parsed as a number and the radix to interpret it in.
|
Partially |
Outer class that exists solely to let us write Partially.GwtIncompatible instead of plain
GwtIncompatible .
|
Partially.GwtIncompatible |
The presence of this annotation on an API indicates that the method may be used with the
Google Web Toolkit (GWT) but that it has some
restrictions.
|
PatternCompiler |
Pluggable interface for compiling a regex pattern.
|
PatternFilenameFilter |
File name filter that only accepts files matching a regular expression.
|
PeekingIterator<E> |
An iterator that supports a one-element lookahead while iterating.
|
PercentEscaper |
A UnicodeEscaper that escapes some set of Java characters using a UTF-8 based percent
encoding scheme.
|
PerCollectionSizeTestSuiteBuilder<B extends PerCollectionSizeTestSuiteBuilder<B,G,T,E>,G extends TestContainerGenerator<T,E>,T,E> |
|
PerCollectionSizeTestSuiteBuilder.OneSizeTestSuiteBuilder<T,E> |
|
Platform |
Methods factored out so that they can be emulated differently in GWT.
|
Platform |
Methods factored out so that they can be emulated differently in GWT.
|
Platform |
Methods factored out so that they can be emulated differently in GWT.
|
Platform |
This class is emulated in GWT.
|
Platform |
Methods factored out so that they can be emulated differently in GWT.
|
Platform |
Methods factored out so that they can be emulated differently in GWT.
|
Platform |
Methods factored out so that they can be emulated differently in GWT.
|
Platform.JdkPatternCompiler |
|
Preconditions |
Static convenience methods that help a method or constructor check whether it was invoked
correctly (whether its preconditions have been met).
|
Predicate<T> |
Determines a true or false value for a given input; a pre-Java-8 version of
java.util.function.Predicate .
|
Predicates |
Static utility methods pertaining to Predicate instances.
|
Predicates.AndPredicate<T> |
|
Predicates.CompositionPredicate<A,B> |
|
Predicates.ContainsPatternFromStringPredicate |
|
Predicates.ContainsPatternPredicate |
|
Predicates.InPredicate<T> |
|
Predicates.InstanceOfPredicate |
|
Predicates.IsEqualToPredicate<T> |
|
Predicates.NotPredicate<T> |
|
Predicates.ObjectPredicate |
|
Predicates.OrPredicate<T> |
|
Predicates.SubtypeOfPredicate |
|
Present<T> |
Implementation of an Optional containing a reference.
|
Primitives |
Contains static utility methods pertaining to primitive types and their corresponding wrapper
types.
|
PrimitiveSink |
An object which can receive a stream of primitive values.
|
PublicSuffixPatterns |
Do not use this class directly.
|
PublicSuffixType |
Specifies the type of a top-level domain definition.
|
Quantiles |
Provides a fluent API for calculating
quantiles.
|
Quantiles.Scale |
Describes the point in a fluent API chain where only the scale (i.e.
|
Quantiles.ScaleAndIndex |
Describes the point in a fluent API chain where the scale and a single quantile index (i.e.
|
Quantiles.ScaleAndIndexes |
Describes the point in a fluent API chain where the scale and a multiple quantile indexes (i.e.
|
QueueElementTester<E> |
A generic JUnit test which tests element() operations on a queue.
|
QueueOfferTester<E> |
A generic JUnit test which tests offer operations on a queue.
|
QueuePeekTester<E> |
A generic JUnit test which tests peek() operations on a queue.
|
QueuePollTester<E> |
A generic JUnit test which tests poll() operations on a queue.
|
QueueRemoveTester<E> |
A generic JUnit test which tests remove() operations on a queue.
|
Queues |
Static utility methods pertaining to Queue and Deque instances.
|
QueueTestSuiteBuilder<E> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
a queue implementation.
|
Range<C extends java.lang.Comparable> |
A range (or "interval") defines the boundaries around a contiguous span of values of some
Comparable type; for example, "integers from 1 to 100 inclusive." Note that it is not
possible to iterate over these contained values.
|
Range.RangeLexOrdering |
Needed to serialize sorted collections of Ranges.
|
RangeMap<K extends java.lang.Comparable,V> |
A mapping from disjoint nonempty ranges to non-null values.
|
RangeSet<C extends java.lang.Comparable> |
|
RateLimiter |
A rate limiter.
|
RateLimiter.SleepingStopwatch |
|
ReaderInputStream |
An InputStream that converts characters from a Reader into bytes using an
arbitrary Charset.
|
Reflection |
Static utilities relating to Java reflection.
|
RegularContiguousSet<C extends java.lang.Comparable> |
An implementation of ContiguousSet that contains one or more elements.
|
RegularContiguousSet.SerializedForm<C extends java.lang.Comparable> |
|
RegularImmutableAsList<E> |
An ImmutableAsList implementation specialized for when the delegate collection is
already backed by an ImmutableList or array.
|
RegularImmutableBiMap<K,V> |
Bimap with zero or more mappings.
|
RegularImmutableBiMap.InverseSerializedForm<K,V> |
|
RegularImmutableList<E> |
Implementation of ImmutableList used for 0 or 2+ elements (not 1).
|
RegularImmutableMap<K,V> |
|
RegularImmutableMap.KeySet<K,V> |
|
RegularImmutableMap.KeySet.SerializedForm<K> |
|
RegularImmutableMap.Values<K,V> |
|
RegularImmutableMap.Values.SerializedForm<V> |
|
RegularImmutableMultiset<E> |
|
RegularImmutableMultiset.NonTerminalEntry<E> |
|
RegularImmutableSet<E> |
|
RegularImmutableSortedMultiset<E> |
An immutable sorted multiset with one or more distinct elements.
|
RegularImmutableSortedSet<E> |
An immutable sorted set with one or more elements.
|
RegularImmutableTable<R,C,V> |
An implementation of ImmutableTable holding an arbitrary number of
cells.
|
RelationshipTester<T> |
|
RelationshipTester.Item<T> |
|
RelationshipTester.ItemReporter |
|
RemovalCause |
The reason why a cached entry was removed.
|
RemovalListener<K,V> |
An object that can receive a notification when an entry is removed from a cache.
|
RemovalListeners |
A collection of common removal listeners.
|
RemovalNotification<K,V> |
A notification of the removal of a single entry.
|
ReserializingTestCollectionGenerator<E> |
Reserializes the sets created by another test set generator.
|
ReserializingTestSetGenerator<E> |
Reserializes the sets created by another test set generator.
|
Resources |
Provides utility methods for working with resources in the classpath.
|
Resources.UrlByteSource |
A byte source that reads from a URL using URL.openStream() .
|
ReverseNaturalOrdering |
An ordering that uses the reverse of the natural order of the values.
|
ReverseOrdering<T> |
An ordering that uses the reverse of a given order.
|
RowSortedTable<R,C,V> |
Interface that extends Table and whose rows are sorted.
|
Runnables |
Static utility methods pertaining to the Runnable interface.
|
SafeTreeMap<K,V> |
A wrapper around TreeMap that aggressively checks to see if keys are
mutually comparable.
|
SafeTreeSet<E> |
A wrapper around TreeSet that aggressively checks to see if elements
are mutually comparable.
|
SameThreadScheduledExecutorService |
A ScheduledExecutorService that executes all scheduled actions immediately
in the calling thread.
|
SameThreadScheduledExecutorService.ImmediateScheduledFuture<V> |
|
SampleElements<E> |
A container class for the five sample elements we need for testing.
|
SampleElements.Chars |
|
SampleElements.Collider |
|
SampleElements.Colliders |
|
SampleElements.Enums |
|
SampleElements.Ints |
|
SampleElements.Strings |
|
SampleElements.Unhashables |
|
SerializableTester |
Tests serialization and deserialization of an object, optionally asserting
that the resulting object is equal to the original.
|
Serialization |
Provides static methods for serializing collection classes.
|
Serialization.FieldSetter<T> |
|
SerializingExecutor |
Executor ensuring that all Runnables submitted are executed in order, using the provided
Executor, and serially such that no two will ever be running at the same time.
|
Service |
|
Service.Listener |
A listener for the various state changes that a Service goes through in its lifecycle.
|
Service.State |
The lifecycle states of a service.
|
ServiceManager |
A manager for monitoring and controlling a set of services.
|
ServiceManager.EmptyServiceManagerWarning |
This is never thrown but only used for logging.
|
ServiceManager.Listener |
A listener for the aggregate state changes of the services that are under management.
|
ServiceManager.NoOpService |
A Service instance that does nothing.
|
ServiceManager.ServiceListener |
|
ServiceManager.ServiceManagerState |
|
SetAddAllTester<E> |
A generic JUnit test which tests addAll operations on a set.
|
SetAddTester<E> |
A generic JUnit test which tests add operations on a set.
|
SetCreationTester<E> |
A generic JUnit test which tests creation (typically through a constructor or
static factory method) of a set.
|
SetEqualsTester<E> |
Tests Set.equals(java.lang.Object) .
|
SetFeature |
Optional features of classes derived from Set .
|
SetFeature.Require |
|
SetGenerators |
Generators of different types of sets and derived collections from sets.
|
SetGenerators.AbstractContiguousSetGenerator |
|
SetGenerators.ContiguousSetDescendingGenerator |
|
SetGenerators.ContiguousSetGenerator |
|
SetGenerators.ContiguousSetHeadsetGenerator |
|
SetGenerators.ContiguousSetSubsetGenerator |
|
SetGenerators.ContiguousSetTailsetGenerator |
|
SetGenerators.DegeneratedImmutableSetGenerator |
|
SetGenerators.ImmutableSetAsListGenerator |
|
SetGenerators.ImmutableSetCopyOfGenerator |
|
SetGenerators.ImmutableSetWithBadHashesGenerator |
|
SetGenerators.ImmutableSortedSetAsListGenerator |
|
SetGenerators.ImmutableSortedSetAsListSubListGenerator |
|
SetGenerators.ImmutableSortedSetCopyOfGenerator |
|
SetGenerators.ImmutableSortedSetDescendingAsListGenerator |
|
SetGenerators.ImmutableSortedSetDescendingGenerator |
|
SetGenerators.ImmutableSortedSetExplicitComparator |
|
SetGenerators.ImmutableSortedSetExplicitSuperclassComparatorGenerator |
|
SetGenerators.ImmutableSortedSetHeadsetGenerator |
|
SetGenerators.ImmutableSortedSetReversedOrderGenerator |
|
SetGenerators.ImmutableSortedSetSubsetAsListGenerator |
|
SetGenerators.ImmutableSortedSetSubsetAsListSubListGenerator |
|
SetGenerators.ImmutableSortedSetSubsetGenerator |
|
SetGenerators.ImmutableSortedSetTailsetGenerator |
|
SetGenerators.ImmutableSortedSetUnhashableGenerator |
|
SetGenerators.TestUnhashableSetGenerator |
|
SetHashCodeTester<E> |
Tests Set.hashCode() .
|
SetMultimap<K,V> |
A Multimap that cannot hold duplicate key-value pairs.
|
SetMultimapAsMapTester<K,V> |
|
SetMultimapEqualsTester<K,V> |
|
SetMultimapPutAllTester<K,V> |
|
SetMultimapPutTester<K,V> |
|
SetMultimapReplaceValuesTester<K,V> |
|
SetMultimapTestSuiteBuilder<K,V> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
a SetMultimap implementation.
|
SetMultimapTestSuiteBuilder.EntriesGenerator<K,V> |
|
SetMultimapTestSuiteBuilder.MultimapAsMapGetGenerator<K,V> |
|
SetMultimapTestSuiteBuilder.MultimapGetGenerator<K,V> |
|
SetRemoveTester<E> |
A generic JUnit test which tests remove operations on a set.
|
Sets |
Static utility methods pertaining to Set instances.
|
Sets.CartesianSet<E> |
|
Sets.DescendingSet<E> |
|
Sets.FilteredNavigableSet<E> |
|
Sets.FilteredSet<E> |
|
Sets.FilteredSortedSet<E> |
|
Sets.ImprovedAbstractSet<E> |
AbstractSet substitute without the potentially-quadratic
removeAll implementation.
|
Sets.PowerSet<E> |
|
Sets.SetView<E> |
An unmodifiable view of a set which may be backed by other sets; this view
will change as the backing sets do.
|
Sets.SubSet<E> |
|
Sets.UnmodifiableNavigableSet<E> |
|
SettableFuture<V> |
|
SetTestSuiteBuilder<E> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
a Set implementation.
|
SetTestSuiteBuilder.ReserializedSetGenerator<E> |
|
Shorts |
Static utility methods pertaining to short primitives, that are not already found in
either Short or Arrays .
|
Shorts.LexicographicalComparator |
|
Shorts.ShortArrayAsList |
|
Shorts.ShortConverter |
|
SignedBytes |
Static utility methods pertaining to byte primitives that interpret values as signed.
|
SignedBytes.LexicographicalComparator |
|
SimpleTimeLimiter |
A TimeLimiter that runs method calls in the background using an ExecutorService .
|
SingletonImmutableBiMap<K,V> |
|
SingletonImmutableList<E> |
|
SingletonImmutableSet<E> |
|
SingletonImmutableTable<R,C,V> |
|
SipHashFunction |
|
SipHashFunction.SipHasher |
|
SloppyTearDown |
Simple utility for when you want to create a TearDown that may throw
an exception but should not fail a test when it does.
|
SmallCharMatcher |
An immutable version of CharMatcher for smallish sets of characters that uses a hash table with
linear probing to check for matches.
|
SmoothRateLimiter |
|
SmoothRateLimiter.SmoothBursty |
This implements a "bursty" RateLimiter, where storedPermits are translated to zero throttling.
|
SmoothRateLimiter.SmoothWarmingUp |
This implements the following function where coldInterval = coldFactor * stableInterval.
|
SortedIterable<T> |
An Iterable whose elements are sorted relative to a Comparator , typically
provided at creation time.
|
SortedIterables |
Utilities for dealing with sorted collections of all types.
|
SortedLists |
Static methods pertaining to sorted List instances.
|
SortedLists.KeyAbsentBehavior |
A specification for which index to return if the list contains no elements that compare as
equal to the key.
|
SortedLists.KeyPresentBehavior |
A specification for which index to return if the list contains at least one element that
compares as equal to the key.
|
SortedMapDifference<K,V> |
An object representing the differences between two sorted maps.
|
SortedMapGenerators |
Generators of sorted maps and derived collections.
|
SortedMapGenerators.ImmutableSortedMapCopyOfEntriesGenerator |
|
SortedMapGenerators.ImmutableSortedMapEntryListGenerator |
|
SortedMapGenerators.ImmutableSortedMapGenerator |
|
SortedMapGenerators.ImmutableSortedMapKeyListGenerator |
|
SortedMapGenerators.ImmutableSortedMapValueListGenerator |
|
SortedMapInterfaceTest<K,V> |
Tests representing the contract of SortedMap .
|
SortedMapNavigationTester<K,V> |
A generic JUnit test which tests operations on a SortedMap.
|
SortedMapTestSuiteBuilder<K,V> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
a SortedMap implementation.
|
SortedMapTestSuiteBuilder.NoRecurse |
To avoid infinite recursion, test suites with these marker features won't
have derived suites created for them.
|
SortedMultiset<E> |
A Multiset which maintains the ordering of its elements, according to
either their natural order or an explicit Comparator .
|
SortedMultisetBridge<E> |
Superinterface of SortedMultiset to introduce a bridge method for
elementSet() , to ensure binary compatibility with older Guava versions
that specified elementSet() to return SortedSet .
|
SortedMultisets |
Provides static utility methods for creating and working with
SortedMultiset instances.
|
SortedMultisets.ElementSet<E> |
|
SortedMultisets.NavigableElementSet<E> |
|
SortedMultisetTestSuiteBuilder<E> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests a
SortedMultiset implementation.
|
SortedMultisetTestSuiteBuilder.Bound |
Two bounds (from and to) define how to build a subMultiset.
|
SortedMultisetTestSuiteBuilder.ForwardingTestMultisetGenerator<E> |
|
SortedMultisetTestSuiteBuilder.NoRecurse |
To avoid infinite recursion, test suites with these marker features won't
have derived suites created for them.
|
SortedSetMultimap<K,V> |
A SetMultimap whose set of values for a given key are kept sorted;
that is, they comprise a SortedSet .
|
SortedSetMultimapAsMapTester<K,V> |
|
SortedSetMultimapGetTester<K,V> |
|
SortedSetMultimapTestSuiteBuilder<K,V> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
a SortedSetMultimap implementation.
|
SortedSetNavigationTester<E> |
A generic JUnit test which tests operations on a SortedSet.
|
SortedSetTestSuiteBuilder<E> |
Creates, based on your criteria, a JUnit test suite that exhaustively tests
a SortedSet implementation.
|
SparseImmutableTable<R,C,V> |
A RegularImmutableTable optimized for sparse data.
|
Splitter |
Extracts non-overlapping substrings from an input string, typically by recognizing appearances of
a separator sequence.
|
Splitter.MapSplitter |
An object that splits strings into maps as Splitter splits iterables and lists.
|
Splitter.SplittingIterator |
|
Splitter.Strategy |
|
StandardRowSortedTable<R,C,V> |
Implementation of Table whose iteration ordering across row keys is
sorted by their natural ordering or by a supplied comparator.
|
StandardSystemProperty |
Represents a standard system property.
|
StandardTable<R,C,V> |
Table implementation backed by a map that associates row keys with
column key / value secondary maps.
|
Stats |
A bundle of statistical summary values -- sum, count, mean/average, min and max, and several
forms of variance -- that were computed from a single set of zero or more floating-point values.
|
StatsAccumulator |
A mutable object which accumulates double values and tracks some basic statistics over all the
values added so far.
|
Stopwatch |
An object that measures elapsed time in nanoseconds.
|
Strings |
Static utility methods pertaining to String or CharSequence instances.
|
Striped<L> |
A striped Lock/Semaphore/ReadWriteLock .
|
Striped.CompactStriped<L> |
Implementation of Striped where 2^k stripes are represented as an array of the same length,
eagerly initialized.
|
Striped.LargeLazyStriped<L> |
Implementation of Striped where up to 2^k stripes can be represented, using a ConcurrentMap
where the key domain is [0..2^k).
|
Striped.PaddedLock |
|
Striped.PaddedSemaphore |
|
Striped.PowerOfTwoStriped<L> |
|
Striped.SmallLazyStriped<L> |
Implementation of Striped where up to 2^k stripes can be represented, using an
AtomicReferenceArray of size 2^k.
|
Striped.SmallLazyStriped.ArrayReference<L> |
|
Striped64 |
A package-local class holding common representation and mechanics
for classes supporting dynamic striping on 64bit values.
|
Striped64.Cell |
Padded variant of AtomicLong supporting only raw accesses plus CAS.
|
Subscribe |
Marks a method as an event subscriber.
|
Subscriber |
A subscriber method on a specific object, plus the executor that should be used for dispatching
events to it.
|
Subscriber.SynchronizedSubscriber |
Subscriber that synchronizes invocations of a method to ensure that only one thread may enter
the method at a time.
|
SubscriberExceptionContext |
Context for an exception thrown by a subscriber.
|
SubscriberExceptionHandler |
Handler for exceptions thrown by event subscribers.
|
SubscriberRegistry |
Registry of subscribers to a single event bus.
|
SubscriberRegistry.MethodIdentifier |
|
Supplier<T> |
A class that can supply objects of a single type; a pre-Java-8 version of
java.util.function.Supplier .
|
Suppliers |
Useful suppliers.
|
Suppliers.ExpiringMemoizingSupplier<T> |
|
Suppliers.MemoizingSupplier<T> |
|
Suppliers.SupplierComposition<F,T> |
|
Suppliers.SupplierFunction<T> |
|
Suppliers.SupplierFunctionImpl |
|
Suppliers.SupplierOfInstance<T> |
|
Suppliers.ThreadSafeSupplier<T> |
|
Synchronized |
Synchronized collection views.
|
Synchronized.SynchronizedAsMap<K,V> |
|
Synchronized.SynchronizedAsMapEntries<K,V> |
|
Synchronized.SynchronizedAsMapValues<V> |
|
Synchronized.SynchronizedBiMap<K,V> |
|
Synchronized.SynchronizedCollection<E> |
|
Synchronized.SynchronizedDeque<E> |
|
Synchronized.SynchronizedEntry<K,V> |
|
Synchronized.SynchronizedList<E> |
|
Synchronized.SynchronizedListMultimap<K,V> |
|
Synchronized.SynchronizedMap<K,V> |
|
Synchronized.SynchronizedMultimap<K,V> |
|
Synchronized.SynchronizedMultiset<E> |
|
Synchronized.SynchronizedNavigableMap<K,V> |
|
Synchronized.SynchronizedNavigableSet<E> |
|
Synchronized.SynchronizedObject |
|
Synchronized.SynchronizedQueue<E> |
|
Synchronized.SynchronizedRandomAccessList<E> |
|
Synchronized.SynchronizedSet<E> |
|
Synchronized.SynchronizedSetMultimap<K,V> |
|
Synchronized.SynchronizedSortedMap<K,V> |
|
Synchronized.SynchronizedSortedSet<E> |
|
Synchronized.SynchronizedSortedSetMultimap<K,V> |
|
Table<R,C,V> |
A collection that associates an ordered pair of keys, called a row key and a
column key, with a single value.
|
Table.Cell<R,C,V> |
Row key / column key / value triplet corresponding to a mapping in a table.
|
Tables |
Provides static methods that involve a Table .
|
Tables.AbstractCell<R,C,V> |
|
Tables.ImmutableCell<R,C,V> |
|
Tables.TransformedTable<R,C,V1,V2> |
|
Tables.TransposeTable<C,R,V> |
|
Tables.UnmodifiableRowSortedMap<R,C,V> |
|
Tables.UnmodifiableTable<R,C,V> |
|
TearDown |
|
TearDownAccepter |
Any object which can accept registrations of TearDown instances.
|
TearDownStack |
A TearDownStack contains a stack of TearDown instances.
|
TestBiMapGenerator<K,V> |
Creates bimaps, containing sample entries, to be tested.
|
TestCharacterListGenerator |
Generates List<Character> instances for test suites.
|
TestCollectionGenerator<E> |
Creates collections, containing sample elements, to be tested.
|
TestCollidingSetGenerator |
A generator using sample elements whose hash codes all collide badly.
|
TestContainerGenerator<T,E> |
To be implemented by test generators of things that can contain
elements.
|
TestEnumMapGenerator |
|
TestEnumMultisetGenerator |
An abstract TestMultisetGenerator for generating multisets containing
enum values.
|
TestEnumSetGenerator |
An abstract TestSetGenerator for generating sets containing enum values.
|
TesterAnnotation |
Use this to meta-annotate XxxFeature.Require annotations, so that those annotations can
be used to decide whether to apply a test to a given class-under-test.
|
TesterRequirements |
Encapsulates the constraints that a class under test must satisfy in order
for a tester method to be run against that class.
|
TestingExecutors |
Factory methods for ExecutorService for testing.
|
TestingExecutors.NoOpScheduledExecutorService |
|
TestingExecutors.NoOpScheduledExecutorService.NeverScheduledFuture<V> |
|
TestIntegerSetGenerator |
Create integer sets for collection tests.
|
TestIntegerSortedSetGenerator |
Create integer sets for testing collections that are sorted by natural
ordering.
|
TestIteratorGenerator<E> |
Creates iterators to be tested.
|
TestListGenerator<E> |
Creates sets, containing sample elements, to be tested.
|
TestListMultimapGenerator<K,V> |
A generator for ListMultimap implementations based on test data.
|
TestLogHandler |
Tests may use this to intercept messages that are logged by the code under
test.
|
TestMapEntrySetGenerator<K,V> |
Creates map entries using sample keys and sample values.
|
TestMapGenerator<K,V> |
Creates maps, containing sample elements, to be tested.
|
TestMultimapGenerator<K,V,M extends Multimap<K,V>> |
Creates multimaps, containing sample elements, to be tested.
|
TestMultisetGenerator<E> |
Creates multisets, containing sample elements, to be tested.
|
TestQueueGenerator<E> |
Creates queues, containing sample elements, to be tested.
|
TestSetGenerator<E> |
Creates sets, containing sample elements, to be tested.
|
TestSetMultimapGenerator<K,V> |
A generator for SetMultimap implementations based on test data.
|
TestsForListsInJavaUtil |
Generates a test suite covering the List implementations in the
java.util package.
|
TestsForMapsInJavaUtil |
Generates a test suite covering the Map implementations in the
java.util package.
|
TestsForMapsInJavaUtil.NullFriendlyComparator<T> |
|
TestsForQueuesInJavaUtil |
Generates a test suite covering the Queue implementations in the
java.util package.
|
TestsForSetsInJavaUtil |
Generates a test suite covering the Set implementations in the
java.util package.
|
TestsForSetsInJavaUtil.NullFriendlyComparator<T> |
|
TestSortedMapGenerator<K,V> |
Creates sorted maps, containing sample elements, to be tested.
|
TestSortedSetGenerator<E> |
Creates sorted sets, containing sample elements, to be tested.
|
TestStringBiMapGenerator |
|
TestStringCollectionGenerator |
String creation for testing arbitrary collections.
|
TestStringListGenerator |
TODO: javadoc.
|
TestStringListMultimapGenerator |
A skeleton generator for a ListMultimap implementation.
|
TestStringMapGenerator |
|
TestStringMultisetGenerator |
Create multisets of strings for tests.
|
TestStringQueueGenerator |
Create queue of strings for tests.
|
TestStringSetGenerator |
Create string sets for collection tests.
|
TestStringSetMultimapGenerator |
A skeleton generator for a SetMultimap implementation.
|
TestStringSortedMapGenerator |
|
TestStringSortedSetGenerator |
Create string sets for testing collections that are sorted by natural
ordering.
|
TestSubjectGenerator<T> |
To be implemented by test generators that can produce test subjects without
requiring any parameters.
|
TestUnhashableCollectionGenerator<T extends java.util.Collection<UnhashableObject>> |
Creates collections containing unhashable sample elements, to be tested.
|
ThreadFactoryBuilder |
A ThreadFactory builder, providing any combination of these features:
whether threads should be marked as daemon threads
a naming format
a thread priority
an uncaught exception handler
a backing thread factory
|
Throwables |
Static utility methods pertaining to instances of Throwable .
|
Ticker |
A time source; returns a time value representing the number of nanoseconds elapsed since some
fixed but arbitrary point in time.
|
TimeLimiter |
Produces proxies that impose a time limit on method calls to the proxied object.
|
TimeoutFuture<V> |
Implementation of Futures#withTimeout .
|
TimeoutFuture.Fire<V> |
A runnable that is called when the delegate or the timer completes.
|
TopKSelector<T> |
An accumulator that selects the "top" k elements added to it, relative to a provided
comparator.
|
TransformedIterator<F,T> |
An iterator that transforms a backing iterator; for internal use.
|
TransformedListIterator<F,T> |
An iterator that transforms a backing list iterator; for internal use.
|
TreeBasedTable<R,C,V> |
Implementation of Table whose row keys and column keys are ordered
by their natural ordering or by supplied comparators.
|
TreeBasedTable.Factory<C,V> |
|
TreeMultimap<K,V> |
Implementation of Multimap whose keys and values are ordered by
their natural ordering or by supplied comparators.
|
TreeMultiset<E> |
A multiset which maintains the ordering of its elements, according to either their natural order
or an explicit Comparator .
|
TreeMultiset.Aggregate |
A function which can be summed across a subtree.
|
TreeMultiset.AvlNode<E> |
|
TreeMultiset.Reference<T> |
|
TreeRangeMap<K extends java.lang.Comparable,V> |
An implementation of RangeMap based on a TreeMap , supporting
all optional operations.
|
TreeRangeMap.RangeMapEntry<K extends java.lang.Comparable,V> |
|
TreeRangeSet<C extends java.lang.Comparable<?>> |
An implementation of RangeSet backed by a TreeMap .
|
TreeRangeSet.ComplementRangesByLowerBound<C extends java.lang.Comparable<?>> |
|
TreeRangeSet.RangesByUpperBound<C extends java.lang.Comparable<?>> |
|
TreeRangeSet.SubRangeSetRangesByLowerBound<C extends java.lang.Comparable<?>> |
|
TreeTraverser<T> |
Views elements of a type T as nodes in a tree, and provides methods to traverse the trees
induced by this traverser.
|
TreeTraverser.PostOrderNode<T> |
|
TrieParser |
Parser for a map of reversed domain names stored as a serialized radix tree.
|
TrustedListenableFutureTask<V> |
|
TypeCapture<T> |
Captures the actual type of T .
|
TypeParameter<T> |
|
TypeResolver |
An object of this class encapsulates type mappings from type variables.
|
TypeResolver.TypeMappingIntrospector |
|
TypeResolver.TypeTable |
A TypeTable maintains mapping from TypeVariable to types.
|
TypeResolver.TypeVariableKey |
Wraps around TypeVariable<?> to ensure that any two type variables are equal as long as
they are declared by the same GenericDeclaration and have the same
name, even if their bounds differ.
|
TypeResolver.WildcardCapturer |
|
Types |
Utilities for working with Type .
|
Types.ClassOwnership |
Decides what owner type to use for constructing ParameterizedType from a raw class.
|
Types.GenericArrayTypeImpl |
|
Types.JavaVersion |
|
Types.NativeTypeVariableEquals<X> |
Per https://code.google.com/p/guava-libraries/issues/detail?id=1635, In JDK 1.7.0_51-b13,
TypeVariableImpl.equals() is changed to no longer be equal to custom TypeVariable
implementations.
|
Types.ParameterizedTypeImpl |
|
Types.TypeVariableImpl<D extends java.lang.reflect.GenericDeclaration> |
|
Types.TypeVariableInvocationHandler |
Invocation handler to work around a compatibility problem between Java 7 and Java 8.
|
Types.WildcardTypeImpl |
|
TypeToInstanceMap<B> |
A map, each entry of which maps a TypeToken to an instance of that type.
|
TypeToken<T> |
A Type with generics.
|
TypeToken.Bounds |
|
TypeToken.SimpleTypeToken<T> |
|
TypeToken.TypeCollector<K> |
Collects parent types from a sub type.
|
TypeToken.TypeCollector.ForwardingTypeCollector<K> |
|
TypeToken.TypeFilter |
|
TypeVisitor |
Based on what a Type is, dispatch it to the corresponding visit* method.
|
UncaughtExceptionHandlers |
Factories for Thread.UncaughtExceptionHandler instances.
|
UncaughtExceptionHandlers.Exiter |
|
UncheckedExecutionException |
Unchecked variant of ExecutionException .
|
UncheckedTimeoutException |
Unchecked version of TimeoutException .
|
UndirectedGraphConnections<N,V> |
|
UndirectedMultiNetworkConnections<N,E> |
|
UndirectedNetworkConnections<N,E> |
|
UnhashableObject |
An unhashable object to be used in testing as values in our collections.
|
UnicodeEscaper |
An Escaper that converts literal text into a format safe for inclusion in a particular
context (such as an XML document).
|
Uninterruptibles |
Utilities for treating interruptible operations as uninterruptible.
|
UnmodifiableCollectionTests |
A series of tests that support asserting that collections cannot be
modified, either through direct or indirect means.
|
UnmodifiableIterator<E> |
|
UnmodifiableListIterator<E> |
|
UnmodifiableSortedMultiset<E> |
|
UnsignedBytes |
Static utility methods pertaining to byte primitives that interpret values as
unsigned (that is, any negative value b is treated as the positive value
256 + b ).
|
UnsignedBytes.LexicographicalComparatorHolder |
Provides a lexicographical comparator implementation; either a Java implementation or a faster
implementation based on Unsafe .
|
UnsignedBytes.LexicographicalComparatorHolder.PureJavaComparator |
|
UnsignedBytes.LexicographicalComparatorHolder.UnsafeComparator |
|
UnsignedInteger |
A wrapper class for unsigned int values, supporting arithmetic operations.
|
UnsignedInts |
Static utility methods pertaining to int primitives that interpret values as
unsigned (that is, any negative value x is treated as the positive value
2^32 + x ).
|
UnsignedInts.LexicographicalComparator |
|
UnsignedLong |
A wrapper class for unsigned long values, supporting arithmetic operations.
|
UnsignedLongs |
Static utility methods pertaining to long primitives that interpret values as
unsigned (that is, any negative value x is treated as the positive value
2^64 + x ).
|
UnsignedLongs.LexicographicalComparator |
|
UrlEscapers |
Escaper instances suitable for strings to be included in particular sections of URLs.
|
UsingToStringOrdering |
An ordering that uses the natural order of the string representation of the
values.
|
Utf8 |
Low-level, high-performance utility methods related to the UTF-8
character encoding.
|
ValueGraph<N,V> |
An interface for graph-
structured data, whose edges have associated non-unique values.
|
ValueGraphBuilder<N,V> |
A builder for constructing instances of MutableValueGraph with user-defined properties.
|
Verify |
Static convenience methods that serve the same purpose as Java language
assertions, except that they are always enabled.
|
VerifyException |
Exception thrown upon the failure of a
verification
check, including those performed by the convenience methods of the Verify class.
|
VisibleForTesting |
Annotates a program element that exists, or is more widely visible than otherwise necessary, only
for use in test code.
|
Weigher<K,V> |
Calculates the weights of cache entries.
|
WellBehavedMap<K,V> |
|
WrappingExecutorService |
An abstract ExecutorService that allows subclasses to wrap tasks before they are submitted to the underlying executor.
|
WrappingScheduledExecutorService |
An abstract ScheduledExecutorService that allows subclasses to
wrap tasks before they are submitted to the underlying executor.
|
WrongType |
A type which will never be used as the element type of any collection in our
tests, and so can be used to test how a Collection behaves when given input
of the wrong type.
|
XmlEscapers |
Escaper instances suitable for strings to be included in XML attribute values and
elements' text contents.
|