All Classes and Interfaces
Class
Description
Skeleton for a tester of a
BiMap
.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()
.A delegating wrapper around a
ListenableFuture
that adds support for the AbstractCheckedFuture.checkedGet()
and AbstractCheckedFuture.checkedGet(long, TimeUnit)
methods.Test case to make sure the
CheckedFuture.checkedGet()
and
CheckedFuture.checkedGet(long, TimeUnit)
methods work correctly.Base class for collection testers.
Abstract superclass of all test-suite builders for collection interfaces.
Base class for testers of classes (including
Collection
and Map
) that contain elements.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.This class provides a skeletal implementation of
Graph
.Base class for services that do not need a thread while "running" but may need one during startup
and shutdown.
Abstract implementation of
InvocationHandler
that handles Object.equals(java.lang.Object)
,
Object.hashCode()
and Object.toString()
.This class provides a skeletal implementation of the
Iterator
interface, to make this interface easier to implement for certain types of
data sources.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
.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.Base class for map testers.
Superclass for all
Multimap
testers.Common superclass for
MultisetSetCountUnconditionallyTester
and
MultisetSetCountConditionallyTester
.Base class for multiset collection tests.
This class provides a skeletal implementation of
Network
.Automatically runs sanity checks against top level classes in the same package of the test that
extends
AbstractPackageSanityTests
.Base class for queue collection tests.
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.
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.This abstract base class for testers allows the framework to inject needed
information after JUnit constructs the instances.
This class provides a skeletal implementation of
ValueGraph
.Marks an event subscriber method as being thread-safe.
A sample enumerated type we use for testing.
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.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.
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 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
.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 variant of
TreeTraverser
for binary trees, providing additional traversals specific to
binary trees.A Bloom filter for instances of
T
.Indicates whether an endpoint of some range is contained in the range itself ("closed") or not
("open").
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 having any combination of the
following features:
automatic loading of entries into the cache
least-recently-used eviction when a maximum size is exceeded
time-based expiration of entries, measured since last access or last write
keys automatically wrapped in weak references
values automatically wrapped in weak or soft references
notification of evicted (or otherwise removed) entries
accumulation of cache access statistics
A specification of a
CacheBuilder
configuration.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.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.
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.
Provides utility methods for working with character streams.
A
CheckedFuture
is a ListenableFuture
that includes versions of the get
methods that can throw a checked exception.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 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.
A map, each entry of which maps a Java
raw type to an instance of that type.
Utility methods for working with
Closeable
objects.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
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
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.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.A utility for performing a chained comparison statement.
Wraps an exception that occurred during a computation.
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.
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.An
InputStream
that counts the number of bytes read.An OutputStream that counts the number of bytes written.
The
CycleDetectingLockFactory
creates ReentrantLock
instances and
ReentrantReadWriteLock
instances that detect potential deadlock by checking for cycles in
lock acquisition order.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.
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.
Given a test iterable generator, builds a test suite for the
iterable's iterator, by delegating to a
IteratorTestSuiteBuilder
.Adapts a test iterable generator to give a TestIteratorGenerator.
A descriptor for a discrete
Comparable
domain such as all
Integer
instances.A class for arithmetic on doubles that is not covered by
Math
.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.
An immutable pair representing the two endpoints of an edge in a graph.
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 backed by an
EnumMap
.Utility methods for working with
Enum
instances.Tester for equals() and hashCode() methods of a class.
A strategy for determining whether two instances are considered equivalent.
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.
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.
A non-empty tester for
Iterator
.Error
variant of ExecutionException
.A support class for
ListenableFuture
implementations to manage their listeners.A Ticker whose value can be advanced programmatically in test.
A TimeLimiter implementation which actually does not attempt to limit time at all.
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.Provides utility methods for working with files.
Modes for opening a file for writing.
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.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.
An expanded
Iterable
API, providing functionality similar to Java 8's powerful streams library in a slightly different way.Utility methods for working with
Flushable
objects.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 future which forwards all its method calls to another future.
A simplified version of
ForwardingCheckedFuture
where subclasses can pass in an already
constructed CheckedFuture
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.
A deque which forwards all its method calls to another deque.
An executor service which forwards all its method calls to another executor service.
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.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.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.
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.
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.
Determines an output value based on an input value; a pre-Java-8 version of
java.util.function.Function
.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.A helper to create a new
ListenableFuture
whose result is generated from a combination
of input futures.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
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
with user-defined properties.The presence of this annotation on a type indicates that the type may be used with the
Google Web Toolkit (GWT).
The presence of this annotation on an API indicates that the method may not be used with
the Google Web Toolkit (GWT).
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 to obtain
HashFunction
instances, and other static hashing-related
utilities.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.Multiset implementation backed by a
HashMap
.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.
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").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.A
Graph
whose elements and structural relationships will never change.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").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").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
Network
whose elements and structural relationships will never change.A
RangeMap
whose contents will never change, with many other important properties
detailed at ImmutableCollection
.A builder for immutable range maps.
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.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").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").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.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").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.Static utility methods pertaining to
InetAddress
instances.A simple immutable data class to encapsulate the information to be found in a Teredo address.
Provides equivalent behavior to
String.intern()
for other immutable
types.Contains static methods pertaining to instances of
Interner
.An immutable well-formed internet domain name, such as
com
or
foo.co.uk
.A class for arithmetic on values of type
int
.Wrapper around either a
Method
or a Constructor
.This class contains 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
.A utility for testing an Iterator implementation by comparing its behavior to
that of a "known good" reference implementation.
Creates, based on your criteria, a JUnit test suite that exhaustively tests
an Iterator implementation.
Utilities necessary for working with libraries that supply plain
Future
instances.An object that joins map entries in the same manner as
Joiner
joins iterables and
arrays.The representation of a linear transformation between real numbers
x
and y
.This is an intermediate stage in the construction process.
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.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
.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
retainAll
operations on a list.Static utility methods pertaining to
List
instances.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.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.
A class for arithmetic on values of type
long
.A generic JUnit test which tests
clear()
operations on a map.Deprecated.
Deprecated.
Use
for basic checks.
invalid reference
Preconditions
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
.Generators of different types of map and related collections, such as
keys, entries and values.
A generic JUnit test which tests
get
operations on a map.Tests
Map.hashCode()
.Tests representing the contract of
Map
.A generic JUnit test which tests
isEmpty()
operations on a
map.A builder of
ConcurrentMap
instances that can have keys or values automatically
wrapped in weak references.A generic JUnit test which tests
putAll
operations on a map.A generic JUnit test which tests
put
operations on a map.A generic JUnit test which tests
remove
operations on a map.A transformation of the value of a key-value pair, using both key and value
as inputs.
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.Represents an Internet Media Type
(also known as a MIME Type or Content Type).
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.
Helper functions that operate on any
Object
, and are not already provided in
Objects
.Support class for
MoreObjects.toStringHelper(java.lang.Object)
.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()
.A builder for a multimap implementation that allows customization of the backing map and value
collection implementations used in a particular multimap.
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
.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 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
.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.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.A mutable class-to-instance map backed by an arbitrary user-provided map.
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.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
with user-defined properties.A test utility that verifies that your methods and constructors throw
NullPointerException
or UnsupportedOperationException
whenever null
is passed to a parameter that isn't annotated with Nullable
.Visibility of any method or constructor.
Static utility methods pertaining to object arrays.
Helper functions that can operate on any
Object
.Deprecated.
Use
MoreObjects.ToStringHelper
instead.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.
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.
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...)
.Static convenience methods that help a method or constructor check whether it was invoked
correctly (whether its preconditions have been met).
Determines a true or false value for a given input; a pre-Java-8 version of
java.util.function.Predicate
.Static utility methods pertaining to
Predicate
instances.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.
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.A mapping from disjoint nonempty ranges to non-null values.
A rate limiter.
Static utilities relating to Java reflection.
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.
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 container class for the five sample elements we need for testing.
Tests serialization and deserialization of an object, optionally asserting
that the resulting object is equal to the original.
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.
A listener for the aggregate state changes of the services that are under management.
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.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.
Static utility methods pertaining to
byte
primitives that interpret values as signed.A TimeLimiter that runs method calls in the background using an
ExecutorService
.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 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.
A
Multiset
which maintains the ordering of its elements, according to
either their natural order or an explicit Comparator
.Creates, based on your criteria, a JUnit test suite that exhaustively tests a
SortedMultiset
implementation.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.
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.Represents a standard system property.
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 measures elapsed time in nanoseconds.
Static utility methods pertaining to
String
or CharSequence
instances.A striped
Lock/Semaphore/ReadWriteLock
.Marks a method as an event subscriber.
Context for an exception thrown by a subscriber.
Handler for exceptions thrown by event subscribers.
A class that can supply objects of a single type; a pre-Java-8 version of
java.util.function.Supplier
.Useful suppliers.
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.
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 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
for testing.
invalid reference
ExecutorService
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.
Produces proxies that impose a time limit on method calls to the proxied object.
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
.An implementation of
RangeMap
based on a TreeMap
, supporting
all optional operations.Views elements of a type
T
as nodes in a tree, and provides methods to traverse the trees
induced by this traverser.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 map, each entry of which maps a
TypeToken
to an instance of that type.A
Type
with generics.Factories for
Thread.UncaughtExceptionHandler
instances.Unchecked variant of
ExecutionException
.Unchecked version of
TimeoutException
.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)
.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
).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.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
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.
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.
invalid reference