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.
 
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.
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.
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 BiMaps 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.
Static utility methods pertaining to boolean primitives, that are not already found in either Boolean or Arrays.
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.
Static utility methods pertaining to byte primitives, that are not already found in either Byte or Arrays, and interpret bytes as neither signed nor unsigned.
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.
Determines a true or false value for any Java char value, just as Predicate does for any Object.
Static utility methods pertaining to char primitives, that are not already found in either Character or Arrays.
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 Closeable that collects Closeable resources and closes them all when it is closed.
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.
Static utility methods pertaining to double primitives, that are not already found in either Double or Arrays.
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.
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.
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.
Static utility methods pertaining to float primitives, that are not already found in either Float or Arrays.
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.
Static utility methods for Graph and Network instances.
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.
Static utility methods pertaining to int primitives, that are not already found in either Integer or Arrays.
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 which joins pieces of text (specified as an array, Iterable, varargs or even a Map) with a separator.
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.
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.
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.
Static utility methods pertaining to long primitives, that are not already found in either Long or Arrays.
A generic JUnit test which tests clear() operations on a map.
Deprecated.
Use
invalid reference
Preconditions
for basic checks.
Deprecated.
Use
invalid reference
Preconditions
for basic checks.
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.
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 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.
Static utility methods pertaining to Map instances (including instances of SortedMap, BiMap, etc.).
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.
Factory and utility methods for Executor, ExecutorService, and ThreadFactory.
Helper functions that operate on any Object, and are not already provided in Objects.
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.entries.
Tester for Multimap.equals.
Optional features of classes derived from Multimap.
 
Tester for Multimap.keySet.
Tester for Multimap.entries.
Tester for Multimap.put(K, V).
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.
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.
Static utility methods pertaining to Queue and Deque instances.
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 set comprising zero or more nonempty, disconnected ranges of type C.
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.
Optional features of classes derived from Set.
 
Generators of different types of sets and derived collections from sets.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
A Multimap that cannot hold duplicate key-value pairs.
Testers for SetMultimap.asMap().
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.
Creates, based on your criteria, a JUnit test suite that exhaustively tests a Set implementation.
Static utility methods pertaining to short primitives, that are not already found in either Short or Arrays.
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.
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.
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
invalid reference
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.
Generates a test suite covering the List implementations in the java.util package.
Generates a test suite covering the Map implementations in the java.util package.
Generates a test suite covering the Queue implementations in the java.util package.
Generates a test suite covering the Set implementations in the java.util package.
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.
An implementation of RangeSet backed by a TreeMap.
Views elements of a type T as nodes in a tree, and provides methods to traverse the trees induced by this traverser.
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().
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.