All Classes and Interfaces
Class
Description
Implementation of an
Optional
not containing a reference.This class provides a skeletal implementation of
BaseGraph
.A general-purpose bimap implementation using any two backing
Map
instances.The inverse of any other
AbstractBiMap
subclass.Skeleton for a tester of a
BiMap
.Abstract
Hasher
that handles converting primitives to bytes using a scratch
ByteBuffer
and streams all bytes to a sink to compute the hash.This class provides a skeletal implementation of the
Cache
interface to minimize the
effort required to implement this interface.A thread-safe
AbstractCache.StatsCounter
implementation for use by Cache
implementors.Accumulates statistics during the operation of a
Cache
for presentation by Cache.stats()
.Implementations of
Futures.catching*
.An
AbstractCatchingFuture
that delegates to an AsyncFunction
and AbstractFuture.setFuture(ListenableFuture)
.Base class for collection testers.
Abstract superclass of all test-suite builders for collection interfaces.
An abstract composition of multiple hash functions.
Base class for testers of classes (including
Collection
and Map
)
that contain elements.A base implementation of
NetworkConnections
for directed networks.Base class for services that can implement
AbstractExecutionThreadService.startUp()
, AbstractExecutionThreadService.run()
and AbstractExecutionThreadService.shutDown()
methods.An abstract implementation of
ListenableFuture
, intended for advanced users only.A special value to represent cancellation and the 'wasInterrupted' bit.
A special value to represent failure, when
AbstractFuture.setException(java.lang.Throwable)
is called successfully.Listeners also form a stack through the
AbstractFuture.listeners
field.A special value that encodes the 'setFuture' state.
AbstractFuture.AtomicHelper
based on synchronized
and volatile writes.Tag interface marking trusted subclasses.
A less abstract subclass of AbstractFuture.
AbstractFuture.AtomicHelper
based on Unsafe
.Waiter links form a Treiber stack, in the
AbstractFuture.waiters
field.This class provides a skeletal implementation of
Graph
.A base class for builders that construct graphs with user-defined properties.
An abstract implementation of
Hasher
, which only requires subtypes to implement Hasher.putByte(byte)
.Skeleton implementation of
HashFunction
in terms of HashFunction.newHasher()
.Base class for services that do not need a thread while "running" but may need one during startup
and shutdown.
This class provides a skeletal implementation of the
ListIterator
interface across a
fixed number of elements that may be retrieved by position.Abstract implementation of
InvocationHandler
that handles Object.equals(java.lang.Object)
, Object.hashCode()
and Object.toString()
.Note this class is a copy of
AbstractIterator
(for dependency
reasons).This class provides a skeletal implementation of the
Iterator
interface, to make this
interface easier to implement for certain types of data sources.Most of the logic for
IteratorTester
and ListIteratorTester
.Meta-exception thrown by
AbstractIteratorTester.MultiExceptionListIterator
instead of
throwing any particular exception type.Abstract test case parent for anything implementing
ListenableFuture
.Abstract
ListeningExecutorService
implementation that creates ListenableFuture
instances for each Runnable
and Callable
submitted to it.Common parent class for
ListIndexOfTester
and ListLastIndexOfTester
.Basic implementation of the
ListMultimap
interface.Superclass for all
ListMultimap
testers.Base class for list testers.
This class provides a skeletal implementation of the
Cache
interface to minimize the
effort required to implement this interface.Basic implementation of the
Multimap
interface.Basic implementation of
Multiset<E>
backed by an instance of Map<E, Count>
.Implementation of the
equals
, hashCode
, and toString
methods of
Entry
.Base class for map testers.
A skeleton
Multimap
implementation, not necessarily in terms of a Map
.Superclass for all
Multimap
testers.This class provides a skeletal implementation of the
Multiset
interface.Common superclass for
MultisetSetCountUnconditionallyTester
and MultisetSetCountConditionallyTester
.Base class for multiset collection tests.
Skeletal implementation of
NavigableMap
.This class provides a skeletal implementation of
Network
.Skeleton implementation of
HashFunction
, appropriate for non-streaming algorithms.Automatically runs sanity checks against top level classes in the same package of the test that
extends
AbstractPackageSanityTests
.Base class for queue collection tests.
A skeletal implementation of
RangeSet
.Base class for services that can implement
AbstractScheduledService.startUp()
and AbstractScheduledService.shutDown()
but while in
the "running" state need to perform a periodic task.A
AbstractScheduledService.Scheduler
that provides a convenient way for the AbstractScheduledService
to
use a dynamically changing schedule.A value object that represents an absolute delay until a task should be invoked.
Contains the most recently submitted
Future
, which may be cancelled or updated,
always under a lock.A scheduler defines the policy for how the
AbstractScheduledService
should run its
task.This class provides a skeletal implementation of the
Iterator
interface for sequences
whose next element can always be derived from the previous element.Base class for implementing services that can handle
AbstractService.doStart()
and AbstractService.doStop()
requests, responding to them with AbstractService.notifyStarted()
and AbstractService.notifyStopped()
callbacks.An immutable snapshot of the current state of the service.
Basic implementation of the
SetMultimap
interface.Basic implementation of a
SortedSetMultimap
with a sorted key set.This class provides a skeletal implementation of the
SortedMultiset
interface.Basic implementation of the
SortedSetMultimap
interface.A convenience base class for implementors of
Hasher
; handles accumulating data until an
entire "chunk" (of implementation-dependent length) is ready to be hashed.Skeletal, implementation-agnostic implementation of the
Table
interface.This abstract base class for testers allows the framework to inject needed information after
JUnit constructs the instances.
Implementations of
Futures.transform*
.An
AbstractTransformFuture
that delegates to an AsyncFunction
and AbstractFuture.setFuture(ListenableFuture)
.A base implementation of
NetworkConnections
for undirected networks.This class provides a skeletal implementation of
ValueGraph
.A future whose value is derived from a collection of input futures.
A helper which does some thread-safe operations for aggregate futures, which must be implemented
differently in GWT.
An ordering that treats all references as equals, even nulls.
Marks an event subscriber method as being thread-safe.
A sample enumerated type we use for testing.
Writer that places all output on an
Appendable
target.Supplies an arbitrary "default" instance for a wide range of types, often useful in testing
utilities.
A
CharEscaper
that uses an array to quickly look up replacement characters for a given
char
value.An implementation-specific parameter class suitable for initializing
ArrayBasedCharEscaper
or ArrayBasedUnicodeEscaper
instances.A
UnicodeEscaper
that uses an array to quickly look up replacement characters for a given
code point.Implementation of
Multimap
that uses an ArrayList
to store the values for a given
key.A dummy superclass to support GWT serialization of the element types of an
ArrayListMultimap
.Fixed-size
Table
implementation backed by a two-dimensional array.Static methods pertaining to ASCII characters (those in the range of values
0x00
through
0x7F
), and to strings containing such characters.Computes a value, possibly asynchronously.
An
EventBus
that takes the Executor of your choice and uses it to dispatch events,
allowing dispatch to occur asynchronously.Transforms a value, possibly asynchronously.
A
double
value that may be updated atomically.A
double
array in which elements may be updated atomically.A map containing
long
values that can be atomically updated.Static utility methods pertaining to classes in the
java.util.concurrent.atomic
package.Simple base class to verify that we handle generics correctly.
A binary encoding scheme for reversibly translating between byte sequences and printable ASCII
strings.
Exception indicating invalid base-encoded input encountered while decoding.
A non-public interface for the methods shared between
Graph
and ValueGraph
.A dummy superclass of
ImmutableMultimap
that can be instanceof'd without ProGuard
retaining additional implementation details of ImmutableMultimap
.Signifies that a public API (public class, method or field) is subject to incompatible changes,
or even removal, in a future release.
A class for arithmetic on
BigDecimal
that is not covered by its built-in methods.A class for arithmetic on values of type
BigInteger
.A bimap (or "bidirectional map") is a map that preserves the uniqueness of its values as well as
that of its keys.
Tester for
BiMap.clear
.Tester for
BiMap.entrySet
and methods on the entries in the set.Generators of various
BiMap
s and derived collections.Tests for the
inverse
view of a BiMap.Tester for
BiMap.put
and BiMap.forcePut
.Tester for
BiMap.remove
.Creates, based on your criteria, a JUnit test suite that exhaustively tests a
BiMap
implementation.A Bloom filter for instances of
T
.A strategy to translate T instances, to
numHashFunctions
bit indexes.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.
Models a lock-free array of bits.
Comparators for
Boolean
values.Indicates whether an endpoint of some range is contained in the range itself ("closed") or not
("open").
An ordering that orders elements by applying an order to the result of a function on those
elements.
An extension of
DataInput
for reading from in-memory byte arrays; its methods offer
identical functionality but do not throw IOException
.An extension of
DataOutput
for writing to in-memory byte arrays; its methods offer
identical functionality but do not throw IOException
.A callback interface to process bytes from a stream.
A destination to which bytes can be written, such as a file.
A readable source of bytes, such as a file.
Provides utility methods for working with byte arrays and I/O streams.
A semi-persistent mapping from keys to values.
A builder of
LoadingCache
and Cache
instances.A specification of a
CacheBuilder
configuration.Parse expireAfterAccess
Parse concurrencyLevel
Base class for parsing times with durations
Parse initialCapacity
Base class for parsing integers.
Parse weakKeys
Base class for parsing integers.
Parse maximumSize
Parse maximumWeight
Parse recordStats
Parse refreshAfterWrite
Parses a single value.
Parse weakValues and softValues
Parse expireAfterWrite
Computes or retrieves values, based on a key, for use in populating a
LoadingCache
.Thrown to indicate that an invalid response was returned from a call to
CacheLoader
.Exception thrown by
loadAll()
to indicate that it is not supported.Statistics about the performance of a
Cache
.Static utility methods pertaining to the
Callable
interface.Implementation of
Lists.cartesianProduct(List)
.Utility class for converting between various ASCII case formats.
An object that converts literal text into a format safe for inclusion in a particular context
(such as an XML document).
Simple helper class to build a "sparse" array of objects based on the indexes that were added to
it.
Simple decorator that turns an array of replacement char[]s into a CharEscaper, this results in
a very fast escape method.
Implementation of
CharMatcher.and(CharMatcher)
.Implementation of
CharMatcher.any()
.Implementation of
CharMatcher.anyOf(CharSequence)
for three or more characters.Implementation of
CharMatcher.ascii()
.Fast matcher using a
BitSet
table of matching characters.Implementation of
CharMatcher.breakingWhitespace()
.Implementation of
CharMatcher.digit()
.A matcher for which precomputation will not yield any significant benefit.
Implementation of
CharMatcher.forPredicate(Predicate)
.Implementation of
CharMatcher.inRange(char, char)
.Implementation of
CharMatcher.invisible()
.Implementation of
CharMatcher.is(char)
.Implementation of
CharMatcher.anyOf(CharSequence)
for exactly two characters.Implementation of
CharMatcher.isNot(char)
.Implementation of
CharMatcher.javaDigit()
.Implementation of
CharMatcher.javaIsoControl()
.Implementation of
CharMatcher.javaLetter()
.Implementation of
CharMatcher.javaLetterOrDigit()
.Implementation of
CharMatcher.javaLowerCase()
.Implementation of
CharMatcher.javaUpperCase()
.CharMatcher.FastMatcher
which overrides toString()
with a custom name.Implementation of
CharMatcher.Negated.negate()
.Negation of a
CharMatcher.FastMatcher
.Implementation of
CharMatcher.none()
.Implementation of
CharMatcher.or(CharMatcher)
.Implementation that matches characters that fall within multiple ranges.
Implementation of
CharMatcher.singleWidth()
.Implementation of
CharMatcher.whitespace()
.A
Reader
that reads the characters in a CharSequence
.Contains constant definitions for the six standard
Charset
instances, which are
guaranteed to be supported by all Java platform implementations.A destination to which characters can be written, such as a text file.
A readable source of characters, such as a text file.
Subclass specialized for string instances.
Provides utility methods for working with character streams.
HashFunction
adapter for Checksum
instances.Scans the source of a
ClassLoader
and finds all loadable classes and resources.Represents a class that can be loaded through
ClassPath.ClassInfo.load()
.Represents a single location (a directory or a jar file) in the class path and is responsible
for scanning resources from this location.
Represents a class path resource that can be either a class file or any other resource file
loadable from the class path.
Tester that runs automated sanity tests for any given class.
Thrown if the test tries to invoke a static factory method to test instance methods but the
factory returned null.
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.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.
A map, each entry of which maps a Java raw type to an
instance of that type.
Utility methods for working with
Closeable
objects.Suppression strategy interface.
A step in a pipeline of an asynchronous computation.
An operation that computes a
ClosingFuture
of a result.A function from an input to a
ClosingFuture
of a result.An operation that computes a result.
A function from an input to a result.
A builder of a
ClosingFuture
step that is derived from more than one input step.An operation that returns a
ClosingFuture
result and may throw an exception.An operation that returns a result and may throw an exception.
A generic
ClosingFuture.Combiner
that lets you use a lambda or method reference to combine two ClosingFuture
s.A function that returns a
ClosingFuture
when applied to the values of the two futures
passed to ClosingFuture.whenAllSucceed(ClosingFuture, ClosingFuture)
.A function that returns a value when applied to the values of the two futures passed to
ClosingFuture.whenAllSucceed(ClosingFuture, ClosingFuture)
.A generic
ClosingFuture.Combiner
that lets you use a lambda or method reference to combine three
ClosingFuture
s.A function that returns a
ClosingFuture
when applied to the values of the three
futures passed to ClosingFuture.whenAllSucceed(ClosingFuture, ClosingFuture, ClosingFuture)
.A function that returns a value when applied to the values of the three futures passed to
ClosingFuture.whenAllSucceed(ClosingFuture, ClosingFuture, ClosingFuture)
.A generic
ClosingFuture.Combiner
that lets you use a lambda or method reference to combine four
ClosingFuture
s.A function that returns a
ClosingFuture
when applied to the values of the four
futures passed to ClosingFuture.whenAllSucceed(ClosingFuture, ClosingFuture, ClosingFuture, ClosingFuture)
.A function that returns a value when applied to the values of the four futures passed to
ClosingFuture.whenAllSucceed(ClosingFuture, ClosingFuture, ClosingFuture, ClosingFuture)
.A generic
ClosingFuture.Combiner
that lets you use a lambda or method reference to combine five
ClosingFuture
s.A function that returns a
ClosingFuture
when applied to the values of the five
futures passed to ClosingFuture.whenAllSucceed(ClosingFuture, ClosingFuture, ClosingFuture, ClosingFuture, ClosingFuture)
.A function that returns a value when applied to the values of the five futures passed to
ClosingFuture.whenAllSucceed(ClosingFuture, ClosingFuture, ClosingFuture, ClosingFuture, ClosingFuture)
.An object that can capture objects to be closed later, when a
ClosingFuture
pipeline is
done.An object that can return the value of the
ClosingFuture
s that are passed to ClosingFuture.whenAllComplete(Iterable)
or ClosingFuture.whenAllSucceed(Iterable)
.The state of a
ClosingFuture.CloseableList
.An object that holds the final result of an asynchronous
ClosingFuture
operation and
allows the user to close all the closeable objects that were captured during it for later
closing.Represents an operation that accepts a
ClosingFuture.ValueAndCloser
for the last step in a ClosingFuture
pipeline.An
ClusterException
is a data structure that allows for some code to "throw multiple
exceptions", or something close to it.Collectors utilities for
common.collect
internals.A generic JUnit test which tests addAll operations on a collection.
A generic JUnit test which tests
add
operations on a collection.A generic JUnit test which tests
clear()
operations on a collection.A generic JUnit test which tests
containsAll()
operations on a collection.A generic JUnit test which tests
contains()
operations on a collection.A generic JUnit test which tests creation (typically through a constructor or static factory
method) of a collection.
Optional features of classes derived from
Collection
.A generic JUnit test which tests
forEach
operations on a collection.Aggregate future that collects (stores) results of each future.
The result of a successful
Future
.A generic JUnit test which tests
isEmpty()
operations on a collection.A generic JUnit test which tests
iterator
operations on a collection.A generic JUnit test which tests
removeAll
operations on a collection.A generic JUnit test which tests
Collection.removeIf(java.util.function.Predicate<? super E>)
.A generic JUnit test which tests
remove
operations on a collection.A generic JUnit test which tests
retainAll
operations on a collection.Provides static methods for working with
Collection
instances.Basic reserialization test for collection types that must preserve
equals()
behavior when
reserialized.Basic reserialization test for collections.
When describing the features of the collection produced by a given generator (i.e.
A generic JUnit test which tests
size()
operations on a collection.A generic JUnit test which tests
spliterator
operations on a collection.A generic JUnit test which tests
stream
operations on a collection.Concrete instantiation of
AbstractCollectionTestSuiteBuilder
for testing collections that
do not have a more specific tester like ListTestSuiteBuilder
or SetTestSuiteBuilder
.A generic JUnit test which tests
toArray()
operations on a collection.A generic JUnit test which tests
toString()
operations on a collection.Tester for
Collector
implementations.Different orderings for combining the elements of an input array, which must all produce the
same result.
Precondition checks useful in collection implementations.
Spliterator utilities for
common.collect
internals.Implements the
operation on spliterators.
invalid reference
Stream#flatMap
Factory for constructing
CollectSpliterators.FlatMapSpliterator
instances.Implementation of
with an object spliterator output type.
invalid reference
Stream#flatMap
Implementation of
with a primitive spliterator output type.
invalid reference
Stream#flatMap
Aggregate future that computes its value by calling a callable.
The subset of the
Matcher
API which is used by this package, and also
shared with the re2j
library.The subset of the
Pattern
API which is used by this package, and also
shared with the re2j
library.Helper classes and static methods for implementing compact hash-based collections.
CompactHashMap is an implementation of a Map.
CompactHashSet is an implementation of a Set.
CompactLinkedHashMap is an implementation of a Map with insertion or LRU iteration order,
maintained with a doubly linked list through the entries.
CompactLinkedHashSet is an implementation of a Set, which a predictable iteration order that
matches the insertion order.
An ordering for a pre-existing comparator.
Provides static methods for working with
Comparator
instances.A utility for performing a chained comparison statement.
An ordering that tries several comparators in order.
Deprecated.
A multiset that supports concurrent modifications and that provides atomic versions of most
Multiset
operations (exceptions where noted).A generic JUnit test which tests
putIfAbsent
operations on a concurrent map.A generic JUnit test which tests
replace(K, V, V)
operations on a concurrent map.A generic JUnit test which tests
replace(K, V)
operations on a concurrent map.Creates, based on your criteria, a JUnit test suite that exhaustively tests a ConcurrentMap
implementation.
Creates, based on your criteria, a JUnit test suite that exhaustively tests a
ConcurrentNavigableMap implementation.
Thrown when requirements on a tester method or class conflict with each other.
An Iterator implementation which draws elements from a queue, removing them from the queue as it
iterates.
A sorted set of contiguous values in a given
DiscreteDomain
.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.A converter that always converts or reverses an object to itself.
A mutable value of type
int
, for multisets to use in tracking counts of values.An
InputStream
that counts the number of bytes read.An OutputStream that counts the number of bytes written.
This class generates a CRC32C checksum, defined by RFC 3720, Section 12.1.
Implementation detail for the internal structure of
Range
instances.The
CycleDetectingLockFactory
creates ReentrantLock
instances and ReentrantReadWriteLock
instances that detect potential deadlock by checking for cycles in lock
acquisition order.Internal Lock implementations implement the
CycleDetectingLock
interface, allowing the
detection logic to treat all locks in the same manner.A Throwable used to record a stack trace that illustrates an example of a specific lock
acquisition ordering.
A
LockGraphNode
associated with each lock instance keeps track of the directed edges in
the lock acquisition graph.Pre-defined
CycleDetectingLockFactory.Policy
implementations.Encapsulates the action to be taken when a potential deadlock is encountered.
Represents a detected cycle in lock acquisition ordering.
A
CycleDetectingLockFactory.WithExplicitOrdering
provides the additional enforcement of
an application-specified ordering of lock acquisitions.Wraps an event that was posted, but which had no subscribers and thus could not be delivered.
This class provides default values for all Java types, as defined by the JLS.
A
RegularImmutableTable
optimized for dense data.An immutable map implementation backed by an indexed nullable array.
Derived suite generators, split out of the suite builders so that they are available to GWT.
Two bounds (from and to) define how to build a subMap.
Simple derived class to verify that we handle generics correctly.
A generator that relies on a preexisting generator for most of its work.
Derived suite generators for Guava collection interfaces, split out of the suite builders so that
they are available to GWT.
Adapts a test iterable generator to give a TestIteratorGenerator.
A descending wrapper around an
ImmutableSortedMultiset
Skeletal implementation of
ImmutableSortedSet.descendingSet()
.A skeleton implementation of a descending multiset.
An implementation of
GraphConnections
for directed graphs.A value class representing single connection between the origin node and another node.
A wrapper class to indicate a node is both a predecessor and successor while still providing
the successor value.
An implementation of
NetworkConnections
for directed networks with parallel edges.An implementation of
NetworkConnections
for directed networks.See newDirectExecutorService javadoc for behavioral notes.
A descriptor for a discrete
Comparable
domain such as all Integer
instances.Handler for dispatching events to subscribers, providing different event ordering guarantees that
make sense for different situations.
Implementation of
Dispatcher.immediate()
.Implementation of a
Dispatcher.legacyAsync()
dispatcher.Implementation of a
Dispatcher.perThreadDispatchQueue()
dispatcher.A class for arithmetic on doubles that is not covered by
Math
.Holder for web specializations of methods of
Doubles
.Utilities for
double
primitives.Generates a dummy interface proxy that simply returns a dummy value for each method.
A class to represent the set of edges connecting an (implicit) origin node to a target node.
Used to represent the order of elements in a data structure that supports different options for
iteration order guarantees.
The type of ordering that this object specifies.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
Marks all "top-level" types as non-null in a way that is recognized by Kotlin.
An empty contiguous set.
Implementation of
ImmutableListMultimap
with no entries.Implementation of
ImmutableListMultimap
with no entries.An immutable pair representing the two endpoints of an edge in a graph.
A class to facilitate the set returned by
Graph.edges()
.If the graph is directed, each ordered [source, target] pair will be visited once if there is
an edge connecting them.
If the graph is undirected, each unordered [node, otherNode] pair (except self-loops) will be
visited twice if there is an edge connecting them.
A
BiMap
backed by two EnumMap
instances.A
BiMap
backed by an EnumMap
instance for keys-to-values, and a HashMap
instance for values-to-keys.Multiset implementation specialized for enum elements, supporting all single-element operations
in O(1).
Utility methods for working with
Enum
instances.Tester for equals() and hashCode() methods of a class.
Class used to test whether equals() correctly handles an instance of an incompatible class.
A strategy for determining whether two instances are considered equivalent, and for computing
hash codes in a manner consistent with that equivalence.
Wraps an object so that
Equivalence.Wrapper.equals(Object)
and Equivalence.Wrapper.hashCode()
delegate to an Equivalence
.Tester for
Equivalence
relationships between groups of objects.An object that converts literal text into a format safe for inclusion in a particular context
(such as an XML document).
Extra assert methods for testing Escaper implementations.
Static utility methods pertaining to
Escaper
instances.A builder for simple, fast escapers.
Dispatches events to listeners, and provides ways for listeners to register themselves.
Simple logging handler for subscriber exceptions.
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.
Error
variant of ExecutionException
.A support class for
ListenableFuture
implementations to manage their listeners.Serializes execution of tasks, somewhat like an "asynchronous
(successful, failed, or
cancelled).
synchronized
block." Each
enqueued callable will not be submitted to its associated executor until the
previous callable has returned -- and, if the previous callable was an AsyncCallable
, not
until the Future
it returned is
invalid reference
done
This class helps avoid a StackOverflowError when large numbers of tasks are submitted with
MoreExecutors.directExecutor()
.This object is unsafely published, but avoids problematic races by relying exclusively on the
identity equality of its Thread field so that the task field is only accessed by a single
thread.
An ordering that compares objects according to a given order.
Holder for extra methods of
Objects
only in web.A Ticker whose value can be advanced programmatically in test.
A TimeLimiter implementation which actually does not attempt to limit time at all.
Implementation of FarmHash Fingerprint64, an open-source fingerprinting algorithm for strings.
Base class for enumerating the features of an interface to be tested.
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.
Utilities for collecting and validating tester requirements from annotations.
An
OutputStream
that starts buffering to a byte array, but switches to file buffering
once the data reaches a configurable size.ByteArrayOutputStream that exposes its internals.
Provides utility methods for working with files.
Modes for opening a file for writing.
Implementation of
Multimaps.filterEntries(Multimap, Predicate)
.Implementation of
Multimaps.filterEntries(SetMultimap, Predicate)
.Implementation of
Multimaps.filterKeys(ListMultimap, Predicate)
.Implementation of
Multimaps.filterKeys(Multimap, Predicate)
.Implementation of
Multimaps.filterKeys(SetMultimap, Predicate)
.An interface for all filtered multimap types.
Implementation for
Multimap.values()
.A supertype for filtered
SetMultimap
implementations.Phantom reference with a
finalizeReferent()
method which a background thread invokes
after the garbage collector reclaims the referent.Implemented by references that have code to run after garbage collection of their referents.
A reference queue with an associated background thread that dequeues references and invokes
FinalizableReference.finalizeReferent()
on them.Try to load Finalizer in its own class loader.
Loads Finalizer directly using the current class loader.
Loads Finalizer.class.
Tries to load Finalizer from the system class loader.
Soft reference with a
finalizeReferent()
method which a background thread invokes after
the garbage collector reclaims the referent.Weak reference with a
finalizeReferent()
method which a background thread invokes after
the garbage collector reclaims the referent.Thread that finalizes referents.
Implementation of Geoff Pike's fingerprint2011 hash function.
Holder for web specializations of methods of
Floats
.A
ListenableFuture
that supports fluent chains of operations.A less abstract subclass of AbstractFuture.
A discouraged (but not deprecated) precursor to Java's superior
Stream
library.Function that transforms
Iterable<E>
into a fluent iterable.Utility methods for working with
Flushable
objects.Deprecated.
This class has moved to
com.google.common.util.concurrent
.A
BlockingDeque
which forwards all its method calls to another BlockingDeque
.A
BlockingQueue
which forwards all its method calls to another BlockingQueue
.A cache which forwards all its method calls to another cache.
A simplified version of
ForwardingCache
where subclasses can pass in an already
constructed Cache
as the delegate.A collection which forwards all its method calls to another collection.
A concurrent map which forwards all its method calls to another concurrent map.
Forwarding wrapper around a
Condition
.A deque which forwards all its method calls to another deque.
An executor service which forwards all its method calls to another executor service.
FluentFuture
that forwards all calls to a delegate.A
Future
which forwards all its method calls to another future.A simplified version of
ForwardingFuture
where subclasses can pass in an already
constructed Future
as the delegate.Dummy class that makes the GWT serialization policy happy.
Unused stub class, unreferenced under Java and manually emulated under GWT.
Unused stub class, unreferenced under Java and manually emulated under GWT.
Unused stub class, unreferenced under Java and manually emulated under GWT.
An iterator which forwards all its method calls to another iterator.
A list which forwards all its method calls to another list.
A
ListenableFuture
which forwards all its method calls to another future.A simplified version of
ForwardingListenableFuture
where subclasses can pass in an
already constructed ListenableFuture
as the delegate.A listening executor service which forwards all its method calls to another listening executor
service.
A list iterator which forwards all its method calls to another list iterator.
A list multimap which forwards all its method calls to another list multimap.
A cache which forwards all its method calls to another cache.
A simplified version of
ForwardingLoadingCache
where subclasses can pass in an already
constructed LoadingCache
as the delegate.Forwarding wrapper around a
Lock
.A map which forwards all its method calls to another map.
A map entry which forwards all its method calls to another map entry.
A multimap which forwards all its method calls to another multimap.
A multiset which forwards all its method calls to another multiset.
A navigable map which forwards all its method calls to another navigable map.
A navigable set which forwards all its method calls to another navigable set.
A class to allow
Network
implementations to be backed by a provided delegate.An abstract base class for implementing the decorator pattern.
A queue which forwards all its method calls to another queue.
A set which forwards all its method calls to another set.
A set multimap which forwards all its method calls to another set multimap.
A sorted map which forwards all its method calls to another sorted map.
A sorted multiset which forwards all its method calls to another sorted multiset.
A sorted set which forwards all its method calls to another sorted set.
A sorted set multimap which forwards all its method calls to another sorted set multimap.
A table which forwards all its method calls to another table.
A class to allow
ValueGraph
implementations to be backed by a provided delegate.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.
Tests a single interaction against a method.
Generates fresh instances of types that are different from each other (if possible).
Annotates a method to generate the "empty" instance of a collection.
Annotates a method to be the instance generator of a certain type.
Legacy version of
java.util.function.Function
.Equivalence applied on functional result.
Static utility methods pertaining to
com.google.common.base.Function
instances; see that
class for information about migrating to java.util.function
.An object which can send data from an object of type
T
into a PrimitiveSink
.Funnels for common types.
A callback for accepting the results of a
Future
computation
asynchronously.Static utility methods pertaining to the
Future
interface.See
Futures.addCallback(ListenableFuture, FutureCallback, Executor)
for behavioral notes.A helper to create a new
ListenableFuture
whose result is generated from a combination
of input futures.A wrapped future that does not propagate cancellation to its delegate.
Static methods used to implement
Futures.getChecked(Future, Class)
.Provides a check of whether an exception type is valid for use with
FuturesGetChecked.getChecked(Future, Class)
, possibly using caching.Testing utilities relating to garbage collection finalization.
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
A generalized interval on any ordering, for internal use.
Helper methods/assertions for use with
com.google.common.collect
types.An interface for graph-structured data,
whose edges are anonymous entities with no identity or information of their own.
A builder for constructing instances of
MutableGraph
or ImmutableGraph
with
user-defined properties.An interface for representing and manipulating an origin node's adjacent nodes and edge values in
a
Graph
.A utility class to hold various constants used by the Guava Graph library.
Singleton edge value for
Graph
implementations backed by ValueGraph
s.An enum representing the state of a node during DFS.
Supertype for
Graphs
, containing the old signatures of methods whose signatures we've
changed.The presence of this annotation on a type indicates that the type may be used with the Google Web Toolkit (GWT).
Hidden superclass of
family of methods.
FluentFuture
that provides us a place to declare special GWT
versions of the
invalid reference
FluentFuture.catching
Hidden superclass of
Futures
that provides us a place to declare special GWT versions of
the Futures.catching
family of methods.The presence of this annotation on an API indicates that the method may not be used with
the Google Web Toolkit (GWT).
Private replacement for
to work around
build-system quirks.
invalid reference
com.google.gwt.user.client.rpc.GwtTransient
Implementation of
Table
using linked hash tables.A
BiMap
backed by two hash tables.An immutable hash code of arbitrary bit length.
A
PrimitiveSink
that can compute a hash code after reading the input.A hash function is a collision-averse pure function that maps an arbitrary block of data to a
number called a hash code.
Static methods for implementing hash-based collections.
Static methods to obtain
HashFunction
instances, and other static hashing-related
utilities.Linear CongruentialGenerator to use for consistent hashing.
An
InputStream
that maintains a hash of the data read from it.An
OutputStream
that maintains a hash of the data written to it.Implementation of
Multimap
using hash tables.A dummy superclass to support GWT serialization of the element types of a
HashMultimap
.Multiset implementation backed by a
HashMap
.Private replacement for
to work around
build-system quirks.
invalid reference
com.google.gwt.user.client.rpc.GwtTransient
Compares strings in natural order except that null comes immediately before a given value.
An immutable representation of a host and port.
A syntactically valid host specifier, suitable for use in a URI.
Escaper
instances suitable for strings to be included in HTML attribute values and
most elements' text contents.Contains constant definitions for the HTTP header field names.
Values for the
Referrer-Policy
header.Disables Animal Sniffer's checking of compatibility with older versions of Java/Android.
Disables Animal Sniffer's checking of compatibility with older versions of Java/Android.
Disables Animal Sniffer's checking of compatibility with older versions of Java/Android.
Disables Animal Sniffer's checking of compatibility with older versions of Java/Android.
Disables Animal Sniffer's checking of compatibility with older versions of Java/Android.
Disables Animal Sniffer's checking of compatibility with older versions of Java/Android.
Disables Animal Sniffer's checking of compatibility with older versions of Java/Android.
Implementation of
Futures.immediateFuture(V)
.List returned by
ImmutableCollection.asList()
that delegates contains
checks to the
backing collection.Serialized form that leads to the same performance as the original list.
A
BiMap
whose contents will never change, with many other important properties detailed
at ImmutableCollection
.A builder for creating immutable bimap instances, especially
public static final
bimaps
("constant bimaps").Serialized type for all ImmutableBiMap instances.
A
ClassToInstanceMap
whose contents will never change, with many other important
properties detailed at ImmutableCollection
.A builder for creating immutable class-to-instance maps.
A
Collection
whose contents will never change, and which offers a few additional
guarantees detailed below.Abstract base class for builders of
ImmutableCollection
types.An immutable array of
double
values, with an API resembling List
.A builder for
ImmutableDoubleArray
instances; obtained using ImmutableDoubleArray.builder(int)
.An immutable
Map.Entry
, used both by Maps.immutableEntry(Object, Object)
and by other parts of
common.collect
as a superclass.Implementation of
ImmutableMap
backed by a non-empty EnumMap
.Implementation of
ImmutableSet
backed by a non-empty EnumSet
.A
Graph
whose elements and structural relationships will never change.A builder for creating
ImmutableGraph
instances, especially static final
graphs.An immutable array of
int
values, with an API resembling List
.A builder for
ImmutableIntArray
instances; obtained using ImmutableIntArray.builder(int)
.A
List
whose contents will never change, with many other important properties detailed at
ImmutableCollection
.A builder for creating immutable list instances, especially
public static final
lists
("constant lists").A
ListMultimap
whose contents will never change, with many other important properties
detailed at ImmutableCollection
.A builder for creating immutable
ListMultimap
instances, especially public
static final
multimaps ("constant multimaps").An immutable array of
long
values, with an API resembling List
.A builder for
ImmutableLongArray
instances; obtained using ImmutableLongArray.builder(int)
.A
Map
whose contents will never change, with many other important properties detailed at
ImmutableCollection
.A builder for creating immutable map instances, especially
public static final
maps
("constant maps").Serialized type for all ImmutableMap instances.
Implementation of
Entry
for ImmutableMap
that adds extra methods to traverse hash
buckets for the key and the value.entrySet()
implementation for ImmutableMap
.keySet()
implementation for ImmutableMap
.values()
implementation for ImmutableMap
.A
Multimap
whose contents will never change, with many other important properties
detailed at ImmutableCollection
.A builder for creating immutable multimap instances, especially
public static final
multimaps ("constant multimaps").A
Multiset
whose contents will never change, with many other important properties
detailed at ImmutableCollection
.A builder for creating immutable multiset instances, especially
public static final
multisets ("constant multisets").A dummy superclass to support GWT serialization of the element type of an
ImmutableMultiset
.A
Network
whose elements and structural relationships will never change.A builder for creating
ImmutableNetwork
instances, especially static final
networks.A
RangeMap
whose contents will never change, with many other important properties
detailed at ImmutableCollection
.A builder for immutable range maps.
This class is used to serialize ImmutableRangeMap instances.
A
RangeSet
whose contents will never change, with many other important properties
detailed at ImmutableCollection
.A builder for immutable range sets.
A
Set
whose contents will never change, with many other important properties detailed at
ImmutableCollection
.A builder for creating
ImmutableSet
instances.SetBuilderImpl version that uses a JDK HashSet, which has built in hash flooding protection.
Default implementation of the guts of ImmutableSet.Builder, creating an open-addressed hash
table and deduplicating elements as they come, so it only allocates O(max(distinct,
expectedCapacity)) rather than O(calls to add).
Swappable internal implementation of an ImmutableSet.Builder.
A
SetMultimap
whose contents will never change, with many other important properties
detailed at ImmutableCollection
.A builder for creating immutable
SetMultimap
instances, especially public static
final
multimaps ("constant multimaps").List returned by
ImmutableSortedSet.asList()
when the set isn't empty.A
NavigableMap
whose contents will never change, with many other important properties
detailed at ImmutableCollection
.A builder for creating immutable sorted map instances, especially
public static final
maps ("constant maps").Serialized type for all ImmutableSortedMap instances.
A
SortedMultiset
whose contents will never change, with many other important properties
detailed at ImmutableCollection
.A builder for creating immutable multiset instances, especially
public static final
multisets ("constant multisets").A
NavigableSet
whose contents will never change, with many other important properties
detailed at ImmutableCollection
.A builder for creating immutable sorted set instances, especially
public static final
sets ("constant sets"), with a given comparator.Explicitly named subinterface of
.
Supplier
that can be marked @
invalid reference
Immutable
A
Table
whose contents will never change, with many other important properties detailed
at ImmutableCollection
.A builder for creating immutable table instances, especially
public static final
tables
("constant tables").Serialized type for all ImmutableTable instances.
A type-to-instance map backed by an
ImmutableMap
.A builder for creating immutable type-to-instance maps.
A
ValueGraph
whose elements and structural relationships will never change.A builder for creating
ImmutableValueGraph
instances, especially static final
graphs.Abstract base class for an incident edges set that allows different implementations of
AbstractCollection.iterator()
.Static utility methods pertaining to
InetAddress
instances.A simple immutable data class to encapsulate the information to be found in a Teredo address.
Exception indicating that a recursive delete can't be performed because the file system does not
have the support necessary to guarantee that it is not vulnerable to race conditions that would
allow it to delete files and directories outside of the directory being deleted (i.e.,
SecureDirectoryStream
is not supported).This class is for
com.google.common.base
use only!This class is for
com.google.common.util.concurrent
use only!A future that, if it fails, may optionally provide access to the cause of the failure.
Static utilities for
InternalFutureFailureAccess
.Provides similar behavior to
String.intern()
for any immutable type.Contains static methods pertaining to instances of
Interner
.Builder for
Interner
instances.An immutable well-formed internet domain name, such as
com
or foo.co.uk
.Using this as the blocker object allows introspection and debugging tools to see that the
currentRunner thread is blocked on the progress of the interruptor thread, which can help
identify deadlocks.
A class for arithmetic on values of type
int
.Holder for web specializations of methods of
Ints
.A subclass of `ForwardingSet` that throws `IllegalStateException` on invocation of any method
(except `hashCode` and `equals`) if the provided `Supplier` returns false.
Wrapper around either a
Method
or a Constructor
.An assortment of mainly legacy static utility methods that operate on or return objects of type
Iterable
.A method supported by implementations of the
Iterator
or ListIterator
interface.This class contains static utility methods that operate on or return objects of type
Iterator
.This is an enum singleton rather than an anonymous class so ProGuard can figure out it's only
referenced by emptyModifiableIterator().
An iterator that performs a lazy N-way merge, calculating the next value each time the iterator
is polled.
Implementation of PeekingIterator that avoids peeking unless necessary.
A utility for testing an Iterator implementation by comparing its behavior to that of a "known
good" reference implementation.
The presence of this annotation on an API indicates that the method may not be used with
J2kt.
Wrappers around
Buffer
methods that are covariantly overridden in Java 9+.Wrappers around
Buffer
methods that are covariantly overridden in Java 9+.Wrappers around
Buffer
methods that are covariantly overridden in Java 9+.Implementation of ImmutableBiMap backed by a pair of JDK HashMaps, which have smartness
protecting against hash flooding.
Implementation of ImmutableMap backed by a JDK HashMap, which has smartness protecting against
hash flooding.
An implementation of ImmutableMultiset backed by a JDK Map and a list of entries.
ImmutableSet implementation backed by a JDK HashSet, used to defend against apparent hash
flooding.
Utilities necessary for working with libraries that supply plain
Future
instances.An adapter to turn a
Future
into a ListenableFuture
.A regex pattern implementation which is backed by the
Pattern
.An object that joins map entries in the same manner as
Joiner
joins iterables and
arrays.A holder for a
Logger
that is initialized only when requested.An ordering which sorts iterables by comparing corresponding elements pairwise.
The representation of a linear transformation between real numbers
x
and y
.This is an intermediate stage in the construction process.
Package-protected abstract class that implements the line reading algorithm used by
LineReader
.A callback to be used with the streaming
readLines
methods.A class for reading lines of text.
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 entries are in no less than three coexisting linked lists: a bucket in the
hash table for a
Set<V>
associated with a key, the linked list of insertion-ordered
entries in that Set<V>
, and the linked list of entries in the LinkedHashMultimap as a
whole.A dummy superclass to support GWT serialization of the element types of a
LinkedHashMultimap
.A
Multiset
implementation with predictable iteration order.An implementation of
ListMultimap
that supports deterministic iteration order for both
keys and values.A generic JUnit test which tests
addAll(int, Collection)
operations on a list.A generic JUnit test which tests
addAll(Collection)
operations on a list.A generic JUnit test which tests
add(int, Object)
operations on a list.A generic JUnit test which tests
add(Object)
operations on a list.A generic JUnit test which tests creation (typically through a constructor or static factory
method) of a list.
A
Future
that accepts completion listeners.A
FutureTask
that also implements the ListenableFuture
interface.Helper interface to implement both
ListenableFuture
and ScheduledFuture
.A list of listeners for implementing a concurrency friendly observable object.
Method reference-compatible listener event.
A special purpose queue/executor that dispatches listener events serially on a configured
executor.
An
ExecutorService
that returns ListenableFuture
instances.A
ScheduledExecutorService
that returns ListenableFuture
instances from its
ExecutorService
methods.Optional features of classes derived from
List
.Common generators of different types of lists.
A generic JUnit test which tests
get()
operations on a list.Tests
List.hashCode()
.A generic JUnit test which tests
indexOf()
operations on a list.A utility similar to
IteratorTester
for testing a ListIterator
against a known
good reference implementation.A generic JUnit test which tests
lastIndexOf()
operations on a list.A generic JUnit test which tests
listIterator
operations on a list.A
Multimap
that can hold duplicate key-value pairs and that maintains the insertion
ordering of values for a given key.Testers for
ListMultimap.asMap()
.Testers for
ListMultimap.equals(Object)
.Testers for
Multimap.putAll(Object, Iterable)
.Testers for
Multimap.put(Object, Object)
.Testers for
Multimap.remove(Object, Object)
.Testers for
ListMultimap.replaceValues(Object, Iterable)
.Creates, based on your criteria, a JUnit test suite that exhaustively tests a
ListMultimap
implementation.A generic JUnit test which tests removeAll operations on a list.
A generic JUnit test which tests
remove(int)
operations on a list.A generic JUnit test which tests
remove(Object)
operations on a list.A generic JUnit test which tests
List.replaceAll(java.util.function.UnaryOperator<E>)
.A generic JUnit test which tests
retainAll
operations on a list.Static utility methods pertaining to
List
instances.Implementation of a transforming random access list.
Implementation of a sequential transforming list.
A generic JUnit test which tests
set()
operations on a list.A generic JUnit test which tests
subList()
operations on a list.Creates, based on your criteria, a JUnit test suite that exhaustively tests a List
implementation.
A generic JUnit test which tests
toArray()
operations on a list.Utility functions for loading and storing values from a byte array.
Fallback implementation for when Unsafe is not available in our current environment.
Common interface for retrieving a 64-bit long from a little-endian byte array.
The only reference to Unsafe is in this nested class.
An implementation of
DataInput
that uses little-endian byte ordering for reading
short
, int
, float
, double
, and long
values.An implementation of
DataOutput
that uses little-endian byte ordering for writing
char
, short
, int
, float
, double
, and long
values.A semi-persistent mapping from keys to values.
The concurrent hash map implementation built by
CacheBuilder
.A custom queue for managing access order.
Creates new entries.
Serializes the configuration of a LocalCache, reconstituting it as an LoadingCache using
CacheBuilder upon deserialization.
Serializes the configuration of a LocalCache, reconstituting it as a Cache using CacheBuilder
upon deserialization.
Segments are specialized versions of hash tables.
References a soft value.
Used for strongly-referenced keys.
References a strong value.
A reference to a value.
Used for weakly-referenced keys.
References a weak value.
References a soft value.
References a strong value.
References a weak value.
A custom queue for managing eviction order.
Abstract interface for objects that can concurrently add longs.
Abstract interface for objects that can concurrently add longs.
Source of
LongAddable
objects that deals with GWT, Unsafe, and all that.Source of
LongAddable
objects that deals with GWT, Unsafe, and all that.One or more variables that together maintain an initially zero
long
sum.One or more variables that together maintain an initially zero
long
sum.A class for arithmetic on values of type
long
.HashFunction
adapter for Mac
instances.Hasher that updates a
Mac
(message authentication code).A generic JUnit test which tests
clear()
operations on a map.A generic JUnit test which tests
Map.computeIfAbsent(K, java.util.function.Function<? super K, ? extends V>)
.A generic JUnit test which tests
Map.computeIfPresent(K, java.util.function.BiFunction<? super K, ? super V, ? extends V>)
.A generic JUnit test which tests
Map.compute(K, java.util.function.BiFunction<? super K, ? super V, ? extends V>)
.A generic JUnit test which tests
containsKey()
operations on a map.A generic JUnit test which tests
containsValue()
operations on a map.A generic JUnit test which tests creation (typically through a constructor or static factory
method) of a map.
An object representing the differences between two maps.
A difference between the mappings from two maps with the same key.
Tests
Map.entrySet()
.Tests
Map.equals(java.lang.Object)
.Optional features of classes derived from
Map
.A generic JUnit test which tests
Map.forEach(java.util.function.BiConsumer<? super K, ? super V>)
.Generators of different types of map and related collections, such as keys, entries and values.
A generic JUnit test which tests
Map.getOrDefault(java.lang.Object, V)
.A generic JUnit test which tests
get
operations on a map.Tests
Map.hashCode()
.Tests representing the contract of
Map
.A key type that is not assignable to any classes but Object.
A generic JUnit test which tests
isEmpty()
operations on a map.A map-like data structure that wraps a backing map and caches values while iterating through
MapIteratorCache.unmodifiableKeySet()
.A builder of
ConcurrentMap
instances that can have keys or values automatically wrapped
in weak references.A dummy singleton value type used by
Interners
.The concurrent hash map implementation built by
MapMaker
.The actual object that gets serialized.
Base class for
MapMakerInternalMap.InternalEntry
implementations for strong keys.Base class for
MapMakerInternalMap.InternalEntry
implementations for weak keys.A dummy implementation of
MapMakerInternalMap.InternalEntry
, solely for use in the type signature of MapMakerInternalMap.UNSET_WEAK_VALUE_REFERENCE
below.An entry in a hash table of a
MapMakerInternalMap.Segment
.A helper object for operating on
MapMakerInternalMap.InternalEntry
instances in a type-safe and efficient
manner.Segments are specialized versions of hash tables.
The actual object that gets serialized.
Concrete implementation of
MapMakerInternalMap.InternalEntry
for strong keys and MapMaker.Dummy
values.Concrete implementation of
MapMakerInternalMap.InternalEntryHelper
for strong keys and MapMaker.Dummy
values.Concrete implementation of
MapMakerInternalMap.Segment
for strong keys and MapMaker.Dummy
values.Concrete implementation of
MapMakerInternalMap.InternalEntry
for strong keys and strong values.Concrete implementation of
MapMakerInternalMap.InternalEntryHelper
for strong keys and strong values.Concrete implementation of
MapMakerInternalMap.Segment
for strong keys and strong values.Concrete implementation of
MapMakerInternalMap.InternalEntry
for strong keys and weak values.Concrete implementation of
MapMakerInternalMap.InternalEntryHelper
for strong keys and weak values.Concrete implementation of
MapMakerInternalMap.Segment
for strong keys and weak values.Marker interface for
MapMakerInternalMap.InternalEntry
implementations for strong values.Concrete implementation of
MapMakerInternalMap.InternalEntry
for weak keys and MapMaker.Dummy
values.Concrete implementation of
MapMakerInternalMap.InternalEntryHelper
for weak keys and MapMaker.Dummy
values.Concrete implementation of
MapMakerInternalMap.Segment
for weak keys and MapMaker.Dummy
values.Concrete implementation of
MapMakerInternalMap.InternalEntry
for weak keys and strong values.Concrete implementation of
MapMakerInternalMap.InternalEntryHelper
for weak keys and strong values.Concrete implementation of
MapMakerInternalMap.Segment
for weak keys and strong values.Concrete implementation of
MapMakerInternalMap.InternalEntry
for weak keys and weak values.Concrete implementation of
MapMakerInternalMap.InternalEntryHelper
for weak keys and weak values.Concrete implementation of
MapMakerInternalMap.Segment
for weak keys and weak values.Marker interface for
MapMakerInternalMap.InternalEntry
implementations for weak values.A weakly referenced value that also has a reference to its containing entry.
Concrete implementation of
MapMakerInternalMap.WeakValueReference
.A generic JUnit test which tests
Map.merge(K, V, java.util.function.BiFunction<? super V, ? super V, ? extends V>)
.A generic JUnit test which tests
putAll
operations on a map.A generic JUnit test which tests
Map.putIfAbsent(K, V)
.A generic JUnit test which tests
put
operations on a map.Tester for
Map.remove(Object, Object)
.A generic JUnit test which tests
remove
operations on a map.A generic JUnit test which tests
replaceAll()
operations on a map.A generic JUnit test which tests
Map.replace(Object, Object, Object)
.A generic JUnit test which tests
Map.replace(Object, Object)
.A
MapIteratorCache
that adds additional caching.A transformation of the value of a key-value pair, using both key and value as inputs.
The implementation of
Multimaps.unmodifiableEntries(java.util.Collection<java.util.Map.Entry<K, V>>)
.The implementation of
Maps.unmodifiableEntrySet(Set)
.AbstractMap
extension that makes it easy to cache customized keySet, values, and
entrySet views.Basic serialization test for maps.
A generic JUnit test which tests
size()
operations on a map.Creates, based on your criteria, a JUnit test suite that exhaustively tests a Map implementation.
A generic JUnit test which tests
toString()
operations on a map.A collection of preconditions for math functions.
Represents an Internet Media Type
(also known as a MIME Type or Content Type).
HashFunction
adapter for MessageDigest
instances.Hasher that updates a message digest.
A simplistic collection which implements only the bare minimum allowed by the spec, and throws
exceptions whenever it can.
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.A simplistic set which implements the bare minimum so that it can be used in tests without
relying on any specific Set implementations.
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.
The builder class used in creation of min-max priority queues.
A simple mock implementation of
Runnable
that can be used for testing ListenableFutures.A synchronization abstraction supporting waiting on arbitrary boolean conditions.
A boolean condition for which a thread may wait.
Collectors not present in
java.util.stream.Collectors
that are not otherwise associated
with a com.google.common
type.This atrocity is here to let us report several of the elements in the stream if there were more
than one, not just two.
Represents the current application to register shutdown hooks.
Helper functions that operate on any
Object
, and are not already provided in Objects
.Support class for
MoreObjects.toStringHelper(java.lang.Object)
.Holder object for values that cannot be null or empty (will be printed unconditionally).
A class to represent the set of edges connecting an (implicit) origin node to a target node.
An
InputStream
that concatenates multiple substreams.A collection that maps keys to values, similar to
Map
, but in which each key may be
associated with multiple values.Tests for
Multimap.asMap().get(Object)
.Tests for
Multimap.asMap()
.An immutable builder for
Multimap
instances, letting you independently select the desired
behaviors (for example, ordering) of the backing map and value-collections.A specialization of
MultimapBuilder
that generates ListMultimap
instances.An intermediate stage in a
MultimapBuilder
in which the key-value collection map
implementation has been specified, but the value collection implementation has not.A specialization of
MultimapBuilder
that generates SetMultimap
instances.A specialization of
MultimapBuilder
that generates SortedSetMultimap
instances.Tests for
Multimap.clear()
.Tester for the
containsKey
methods of Multimap
and its asMap()
view.Tester for
Multimap.containsValue(java.lang.Object)
.Tester for
Multimap.entries
.Tester for
Multimap.equals
.Optional features of classes derived from
Multimap
.Tests for
Multimap.get(Object)
.Tester for
Multimap.keySet
.Tester for
Multimap.entries
.Tester for
Multimap.putAll(Multimap)
.Tests for
Multimap.putAll(Object, Iterable)
.Tester for
Multimap.put(K, V)
.Tests for
Multimap.removeAll(Object)
.Tests for
Multimap.remove(Object, Object)
.Tests for
Multimap.replaceValues(Object, Iterable)
.Provides static methods acting on or generating a
Multimap
.A skeleton implementation of
Multimap.asMap()
.A skeleton implementation of
Multimap.entries()
.Tester for the
size
methods of Multimap
and its views.Creates, based on your criteria, a JUnit test suite that exhaustively tests a
Multimap
implementation.Tester for
Multimap.toString()
.Tester for
Multimap.values
.A
Reader
that concatenates multiple readers.A collection that supports order-independent equality, like
Set
, but may have duplicate
elements.An unmodifiable element-count pair for a multiset.
Tests for
Multiset.add
.Tests for
Multiset.containsAll
not already addressed by CollectionContainsTester
.Tests for
Multiset#count
.Tests for
Multiset.elementSet()
not covered by the derived SetTestSuiteBuilder
.Tests for
Multiset.entrySet
.Tests for
Multiset.equals
and Multiset.hashCode
.Optional features of classes derived from
Multiset
.Tests for
Multiset#forEachEntry
.Tester to make sure the
iterator().remove()
implementation of Multiset
works when
there are multiple occurrences of elements.Tester for navigation of SortedMultisets.
A generic JUnit test which tests multiset-specific read operations.
Tests for
Multiset#remove
, Multiset.removeAll
, and Multiset.retainAll
not
already covered by the corresponding Collection testers.Provides static utility methods for creating and working with
Multiset
instances.An
AbstractMultiset
with additional default implementations, some of them linear-time
implementations in terms of elementSet
and entrySet
.A generic JUnit test which tests multiset-specific serialization.
A generic JUnit test which tests conditional
setCount()
operations on a multiset.A generic JUnit test which tests unconditional
setCount()
operations on a multiset.Creates, based on your criteria, a JUnit test suite that exhaustively tests a
Multiset
implementation.See MurmurHash3_x64_128 in the
C++ implementation.
See MurmurHash3_x86_32 in the C++
implementation.
A mutable class-to-instance map backed by an arbitrary user-provided map.
Serialized form of the map, to avoid serializing the constraint.
A subinterface of
Graph
which adds mutation methods.A subinterface of
Network
which adds mutation methods.A mutable type-to-instance map.
A subinterface of
ValueGraph
which adds mutation methods.An ordering that uses the natural order of the values.
A generic JUnit test which tests operations on a NavigableMap.
Creates, based on your criteria, a JUnit test suite that exhaustively tests a NavigableMap
implementation.
A generic JUnit test which tests operations on a NavigableSet.
Creates, based on your criteria, a JUnit test suite that exhaustively tests a NavigableSet
implementation.
An interface for graph-structured data,
whose edges are unique objects.
A builder for constructing instances of
MutableNetwork
or ImmutableNetwork
with
user-defined properties.An interface for representing and manipulating an origin node's adjacent nodes and incident edges
in a
Network
.A utility method to perform unchecked casts to suppress errors produced by nullness analyses.
A utility method to perform unchecked casts to suppress errors produced by nullness analyses.
A utility method to perform unchecked casts to suppress errors produced by nullness analyses.
A test utility that verifies that your methods and constructors throw
NullPointerException
or UnsupportedOperationException
whenever null is passed to a
parameter whose declaration or type isn't annotated with an annotation with the simple name
Nullable
, CheckForNull
, NullableType
, or NullableDecl
.Strategy for exception type matching used by
NullPointerTester
.Looks for declaration nullness annotations and, if supported, type-use nullness annotations.
Visibility of any method or constructor.
An ordering that treats
null
as less than all other values.An ordering that treats
null
as greater than all other values.Static utility methods pertaining to object arrays.
Helper functions that can operate on any
Object
.Generator for collection of a particular size.
The subject-generator interface accepted by Collection testers, for testing a Collection at one
particular
CollectionSize
.An immutable object that may contain a non-null reference to another object.
A comparator, with additional methods to support common operations.
Exception thrown by a
Ordering.explicit(List)
or Ordering.explicit(Object, Object[])
comparator when comparing a value outside the set of values it can compare.Works around an android bug, where parking for more than INT_MAX seconds can produce an abort
signal on 32 bit devices running Android Q.
An immutable value object capturing some basic statistics about a collection of paired double
values (e.g.
A mutable object which accumulates paired double values (e.g.
Represents a method or constructor parameter.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
Annotates a "top-level" type-variable usage that takes its nullness from the type argument
supplied by the user of the class.
A string to be parsed as a number and the radix to interpret it in.
Outer class that exists solely to let us write
Partially.GwtIncompatible
instead of plain
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.
Pluggable interface for compiling a regex pattern.
File name filter that only accepts files matching a regular expression.
An iterator that supports a one-element lookahead while iterating.
A
UnicodeEscaper
that escapes some set of Java characters using a UTF-8 based percent
encoding scheme.This builder creates a composite test suite, containing a separate test suite for each
CollectionSize
present in the features specified by FeatureSpecificTestSuiteBuilder.withFeatures(Feature...)
.Builds a test suite for one particular
CollectionSize
.Methods factored out so that they can be emulated differently in GWT.
Methods factored out so that they can be emulated differently in GWT.
Methods factored out so that they can be emulated differently in GWT.
This class is emulated in GWT.
Methods factored out so that they can be emulated differently in GWT.
Methods factored out so that they can be emulated differently in GWT.
Methods factored out so that they can be emulated differently in GWT.
Static convenience methods that help a method or constructor check whether it was invoked
correctly (that is, whether its preconditions were met).
A functional interface for graph-structured data.
Legacy version of
java.util.function.Predicate
.Static utility methods pertaining to
Predicate
instances.Implementation of an
Optional
containing a reference.Contains static utility methods pertaining to primitive types and their corresponding wrapper
types.
An object which can receive a stream of primitive values.
Do not use this class directly.
Do not use this class directly.
Provides a fluent API for calculating quantiles.
Describes the point in a fluent API chain where only the scale (i.e.
Describes the point in a fluent API chain where the scale and a single quantile index (i.e.
Describes the point in a fluent API chain where the scale and a multiple quantile indexes (i.e.
A generic JUnit test which tests
element()
operations on a queue.A generic JUnit test which tests offer operations on a queue.
A generic JUnit test which tests
peek()
operations on a queue.A generic JUnit test which tests
poll()
operations on a queue.A generic JUnit test which tests
remove()
operations on a queue.Creates, based on your criteria, a JUnit test suite that exhaustively tests a queue
implementation.
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.Needed to serialize sorted collections of Ranges.
A dummy superclass to support GWT serialization of the element type of a
Range
.A mapping from disjoint nonempty ranges to non-null values.
A rate limiter.
An
InputStream
that converts characters from a Reader
into bytes using an
arbitrary Charset.Options for use with recursive delete methods (
MoreFiles.deleteRecursively(java.nio.file.Path, com.google.common.io.RecursiveDeleteOption...)
and MoreFiles.deleteDirectoryContents(java.nio.file.Path, com.google.common.io.RecursiveDeleteOption...)
).An entry in a reference map.
Static utilities relating to Java reflection.
An implementation of
ContiguousSet
that contains one or more elements.An
ImmutableAsList
implementation specialized for when the delegate collection is already
backed by an ImmutableList
or array.Bimap with zero or more mappings.
Implementation of
ImmutableList
backed by a simple array.Implementation of
ImmutableMap
used for 0 entries and for 2+ entries.Implementation of
ImmutableMultiset
with zero or more elements.Implementation of
ImmutableSet
with two or more elements.An immutable sorted multiset with one or more distinct elements.
An immutable sorted set with one or more elements.
An implementation of
ImmutableTable
holding an arbitrary number of cells.Implementation helper for
EqualsTester
and EquivalenceTester
that tests for
equivalence classes.The reason why a cached entry was removed.
An object that can receive a notification when an entry is removed from a cache.
A collection of common removal listeners.
A notification of the removal of a single entry.
Reserializes the sets created by another test set generator.
Reserializes the sets created by another test set generator.
Provides utility methods for working with resources in the classpath.
A byte source that reads from a URL using
URL.openStream()
.An ordering that uses the reverse of the natural order of the values.
An ordering that uses the reverse of a given order.
Interface that extends
Table
and whose rows are sorted.Static utility methods pertaining to the
Runnable
interface.A wrapper around
TreeMap
that aggressively checks to see if keys are mutually comparable.A wrapper around
TreeSet
that aggressively checks to see if elements are mutually
comparable.A ScheduledExecutorService that executes all scheduled actions immediately in the calling thread.
A container class for the five sample elements we need for testing.
Executor ensuring that all Runnables submitted are executed in order, using the provided
Executor, and sequentially such that no two will ever be running at the same time.
Tests serialization and deserialization of an object, optionally asserting that the resulting
object is equal to the original.
Provides static methods for serializing collection classes.
An object with an operational state, plus asynchronous
Service.startAsync()
and Service.stopAsync()
lifecycle methods to transition between states.A listener for the various state changes that a
Service
goes through in its lifecycle.The lifecycle states of a service.
A manager for monitoring and controlling a set of services.
This is never thrown but only used for logging.
A listener for the aggregate state changes of the services that are under management.
A
Service
instance that does nothing.A
Service
that wraps another service and times how long it takes for it to start and
also calls the ServiceManager.ServiceManagerState.transitionService(Service, State, State)
, to record
the state transitions.An encapsulation of all the mutable state of the
ServiceManager
that needs to be
accessed by instances of ServiceManager.ServiceListener
.Superinterface of
ServiceManager
to introduce a bridge method for
servicesByState()
, to ensure binary compatibility with older Guava versions that specified
servicesByState()
to return ImmutableMultimap
.A generic JUnit test which tests addAll operations on a set.
A generic JUnit test which tests add operations on a set.
A generic JUnit test which tests creation (typically through a constructor or static factory
method) of a set.
Tests
Set.equals(java.lang.Object)
.Optional features of classes derived from
Set
.Generators of different types of sets and derived collections from sets.
Tests
Set.hashCode()
.A
Multimap
that cannot hold duplicate key-value pairs.Testers for
SetMultimap.asMap()
.Testers for
SetMultimap.equals(Object)
.Creates, based on your criteria, a JUnit test suite that exhaustively tests a
SetMultimap
implementation.A generic JUnit test which tests remove operations on a set.
Static utility methods pertaining to
Set
instances.AbstractSet
substitute without the potentially-quadratic removeAll
implementation.An unmodifiable view of a set which may be backed by other sets; this view will change as the
backing sets do.
A
ListenableFuture
whose result can be set by a SettableFuture.set(Object)
, SettableFuture.setException(Throwable)
or SettableFuture.setFuture(ListenableFuture)
call.Creates, based on your criteria, a JUnit test suite that exhaustively tests a Set implementation.
Holder for web specializations of methods of
Shorts
.Static utility methods pertaining to
byte
primitives that interpret values as signed.A TimeLimiter that runs method calls in the background using an
ExecutorService
.Implementation of
ImmutableMap
with exactly one entry.Implementation of
ImmutableList
with exactly one element.Implementation of
ImmutableSet
with exactly one element.An implementation of
ImmutableTable
that holds a single cell.HashFunction
implementation of SipHash-c-d.Simple utility for when you want to create a
TearDown
that may throw an exception but
should not fail a test when it does.An immutable version of CharMatcher for smallish sets of characters that uses a hash table with
linear probing to check for matches.
This implements a "bursty" RateLimiter, where storedPermits are translated to zero throttling.
This implements the following function where coldInterval = coldFactor * stableInterval.
An
Iterable
whose elements are sorted relative to a Comparator
, typically
provided at creation time.Utilities for dealing with sorted collections of all types.
Static methods pertaining to sorted
List
instances.A specification for which index to return if the list contains no elements that compare as
equal to the key.
A specification for which index to return if the list contains at least one element that
compares as equal to the key.
An object representing the differences between two sorted maps.
Generators of sorted maps and derived collections.
Tests representing the contract of
SortedMap
.A generic JUnit test which tests operations on a SortedMap.
Creates, based on your criteria, a JUnit test suite that exhaustively tests a SortedMap
implementation.
To avoid infinite recursion, test suites with these marker features won't have derived suites
created for them.
A
Multiset
which maintains the ordering of its elements, according to either their
natural order or an explicit Comparator
.Superinterface of
SortedMultiset
to introduce a bridge method for elementSet()
,
to ensure binary compatibility with older Guava versions that specified elementSet()
to
return SortedSet
.Provides static utility methods for creating and working with
SortedMultiset
instances.A skeleton implementation for
SortedMultiset.elementSet()
.A skeleton navigable implementation for
SortedMultiset.elementSet()
.Creates, based on your criteria, a JUnit test suite that exhaustively tests a
SortedMultiset
implementation.Two bounds (from and to) define how to build a subMultiset.
To avoid infinite recursion, test suites with these marker features won't have derived suites
created for them.
A
SetMultimap
whose set of values for a given key are kept sorted; that is, they comprise
a SortedSet
.Testers for
SortedSetMultimap.asMap()
.Tester for
SortedSetMultimap.get(Object)
.Creates, based on your criteria, a JUnit test suite that exhaustively tests a
SortedSetMultimap
implementation.A generic JUnit test which tests operations on a SortedSet.
Creates, based on your criteria, a JUnit test suite that exhaustively tests a SortedSet
implementation.
A
RegularImmutableTable
optimized for sparse data.Tester for
Spliterator
implementations.Return type from "contains the following elements" assertions.
Different ways of decomposing a Spliterator, all of which must produce the same elements (up to
ordering, if Spliterator.ORDERED is not present).
Extracts non-overlapping substrings from an input string, typically by recognizing appearances of
a separator sequence.
An object that splits strings into maps as
Splitter
splits iterables and lists.Standard implementation of
MutableGraph
that supports both directed and undirected
graphs.Standard implementation of
MutableNetwork
that supports both directed and undirected
graphs.Standard implementation of
MutableValueGraph
that supports both directed and undirected
graphs.Standard implementation of
Network
that supports the options supplied by NetworkBuilder
.Implementation of
Table
whose iteration ordering across row keys is sorted by their
natural ordering or by a supplied comparator.Represents a standard system property.
Table
implementation backed by a map that associates row keys with column key / value
secondary maps.Standard implementation of
ValueGraph
that supports the options supplied by AbstractGraphBuilder
.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.
A mutable object which accumulates double values and tracks some basic statistics over all the
values added so far.
An object that accurately measures elapsed time: the measured duration between two
successive readings of "now" in the same process.
Static utility methods related to
Stream
instances.An analogue of
DoubleFunction
also accepting an index.An analogue of
Function
also accepting an index.An analogue of
IntFunction
also accepting an index.An analogue of
LongFunction
also accepting an index.Static utility methods pertaining to
String
or CharSequence
instances.A striped
Lock/Semaphore/ReadWriteLock
.Implementation of Striped where 2^k stripes are represented as an array of the same length,
eagerly initialized.
Implementation of Striped where up to 2^k stripes can be represented, using a ConcurrentMap
where the key domain is [0..2^k).
Implementation of Striped where up to 2^k stripes can be represented, using an
AtomicReferenceArray of size 2^k.
Condition object that ensures a strong reference is retained to a specified object.
Lock object that ensures a strong reference is retained to a specified object.
ReadWriteLock implementation whose read and write locks retain a reference back to this lock.
A package-local class holding common representation and mechanics for classes supporting dynamic
striping on 64bit values.
A package-local class holding common representation and mechanics for classes supporting dynamic
striping on 64bit values.
Padded variant of AtomicLong supporting only raw accesses plus CAS.
Padded variant of AtomicLong supporting only raw accesses plus CAS.
Marks a method as an event subscriber.
A subscriber method on a specific object, plus the executor that should be used for dispatching
events to it.
Subscriber that synchronizes invocations of a method to ensure that only one thread may enter
the method at a time.
Context for an exception thrown by a subscriber.
Handler for exceptions thrown by event subscribers.
Registry of subscribers to a single event bus.
A functional interface for graph-structured data.
Legacy version of
java.util.function.Supplier
.Useful suppliers.
Synchronized collection views.
A collection that associates an ordered pair of keys, called a row key and a column key, with a
single value.
Row key / column key / value triplet corresponding to a mapping in a table.
Collectors utilities for
common.collect.Table
internals.Provides static methods that involve a
Table
.An object that can perform a
TearDown.tearDown()
operation.Any object which can accept registrations of
TearDown
instances.A
TearDownStack
contains a stack of TearDown
instances.Creates temporary files and directories whose permissions are restricted to the current user or,
in the case of Android, the current app.
Creates bimaps, containing sample entries, to be tested.
Generates
List<Character>
instances for test suites.Creates collections, containing sample elements, to be tested.
A generator using sample elements whose hash codes all collide badly.
To be implemented by test generators of things that can contain elements.
Implementation helper for
TestMapGenerator
for use with enum maps.An abstract
TestMultisetGenerator
for generating multisets containing enum values.An abstract TestSetGenerator for generating sets containing enum values.
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.Encapsulates the constraints that a class under test must satisfy in order for a tester method to
be run against that class.
Factory methods for
ExecutorService
for testing.Create integer sets for collection tests.
Create integer sets for testing collections that are sorted by natural ordering.
Creates iterators to be tested.
Creates sets, containing sample elements, to be tested.
A generator for
ListMultimap
implementations based on test data.Tests may use this to intercept messages that are logged by the code under test.
Creates map entries using sample keys and sample values.
Creates maps, containing sample elements, to be tested.
Creates multimaps, containing sample elements, to be tested.
Creates multisets, containing sample elements, to be tested.
Creates queues, containing sample elements, to be tested.
Creates sets, containing sample elements, to be tested.
A generator for
SetMultimap
implementations based on test data.Creates sorted maps, containing sample elements, to be tested.
Creates sorted sets, containing sample elements, to be tested.
Implementation helper for
TestBiMapGenerator
for use with bimaps of strings.String creation for testing arbitrary collections.
TODO: javadoc.
A skeleton generator for a
ListMultimap
implementation.Implementation helper for
TestMapGenerator
for use with maps of strings.Create multisets of strings for tests.
Create queue of strings for tests.
Create string sets for collection tests.
A skeleton generator for a
SetMultimap
implementation.Implementation helper for
TestMapGenerator
for use with sorted maps of strings.Create string sets for testing collections that are sorted by natural ordering.
To be implemented by test generators that can produce test subjects without requiring any
parameters.
Creates collections containing unhashable sample elements, to be tested.
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
Static utility methods pertaining to instances of
Throwable
.A time source; returns a time value representing the number of nanoseconds elapsed since some
fixed but arbitrary point in time.
Imposes a time limit on method calls.
Implementation of
Futures#withTimeout
.A runnable that is called when the delegate or the timer completes.
An accumulator that selects the "top"
k
elements added to it, relative to a provided
comparator.An iterator that transforms a backing iterator; for internal use.
An iterator that transforms a backing list iterator; for internal use.
An object that can traverse the nodes that are reachable from a specified (set of) start node(s)
using a specified
SuccessorsFunction
.Poor man's method reference for
Deque::addFirst
and Deque::addLast
.Abstracts away the difference between traversing a graph vs.
Implementation of
Table
whose row keys and column keys are ordered by their natural
ordering or by supplied comparators.Implementation of
Multimap
whose keys and values are ordered by their natural ordering or
by supplied comparators.A multiset which maintains the ordering of its elements, according to either their natural order
or an explicit
Comparator
.A function which can be summed across a subtree.
An implementation of
RangeMap
based on a TreeMap
, supporting all optional
operations.Deprecated.
Use
Traverser
instead.Parser for a map of reversed domain names stored as a serialized radix tree.
A
RunnableFuture
that also implements the ListenableFuture
interface.Captures the actual type of
T
.Captures a free type variable that can be used in
TypeToken.where(com.google.common.reflect.TypeParameter<X>, com.google.common.reflect.TypeToken<X>)
.An object of this class encapsulates type mappings from type variables.
A TypeTable maintains mapping from
TypeVariable
to types.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.Utilities for working with
Type
.Decides what owner type to use for constructing
ParameterizedType
from a raw class.Per issue 1635,
In JDK 1.7.0_51-b13,
Types.TypeVariableImpl.equals(Object)
is changed to no longer be equal
to custom TypeVariable implementations.Invocation handler to work around a compatibility problem between Java 7 and Java 8.
A map, each entry of which maps a
TypeToken
to an instance of that type.A
Type
with generics.Collects parent types from a subtype.
Based on what a
Type
is, dispatch it to the corresponding visit*
method.Factories for
Thread.UncaughtExceptionHandler
instances.Unchecked variant of
ExecutionException
.Unchecked version of
TimeoutException
.An implementation of
GraphConnections
for undirected graphs.An implementation of
NetworkConnections
for undirected networks with parallel edges.An implementation of
NetworkConnections
for undirected networks.An unhashable object to be used in testing as values in our collections.
An
Escaper
that converts literal text into a format safe for inclusion in a particular
context (such as an XML document).Utilities for treating interruptible operations as uninterruptible.
A series of tests that support asserting that collections cannot be modified, either through
direct or indirect means.
An iterator that does not support
UnmodifiableIterator.remove()
.A list iterator that does not support
UnmodifiableIterator.remove()
, UnmodifiableListIterator.add(E)
, or UnmodifiableListIterator.set(E)
.Implementation of
Multisets.unmodifiableSortedMultiset(SortedMultiset)
, split out into
its own file so it can be GWT emulated (to deal with the differing elementSet() types in GWT and
non-GWT).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
).Provides a lexicographical comparator implementation; either a Java implementation or a faster
implementation based on
Unsafe
.A wrapper class for unsigned
int
values, supporting arithmetic operations.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
).A wrapper class for unsigned
long
values, supporting arithmetic operations.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
).Escaper
instances suitable for strings to be included in particular sections of URLs.An ordering that uses the natural order of the string representation of the values.
Low-level, high-performance utility methods related to the UTF-8
character encoding.
An interface for graph-structured data,
whose edges have associated non-unique values.
A builder for constructing instances of
MutableValueGraph
or ImmutableValueGraph
with user-defined properties.Static convenience methods that serve the same purpose as Java language assertions,
except that they are always enabled.
Exception thrown upon the failure of a verification check,
including those performed by the convenience methods of the
Verify
class.Annotates a program element that exists, or is more widely visible than otherwise necessary, only
for use in test code.
Calculates the weights of cache entries.
An abstract
ExecutorService
that allows subclasses to wrap tasks before they are submitted to the underlying executor.An abstract
ScheduledExecutorService
that allows subclasses to wrap tasks before they are submitted to the underlying executor.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.
Escaper
instances suitable for strings to be included in XML attribute values and
elements' text contents.
com.google.common
.