All Classes

Class	Description
AbstractBooleanExpression	Abstract class representing boolean expressions that occur in SpecificationClause objects.
AbstractGenerator	Algorithm template for implementing a test generator.
AccessibilityPredicate	Interface for predicates that check whether a class or class member is considered accessible.
AccessibilityPredicate.AnyAccessibilityPredicate	AnyAccessibilityPredicate is a AccessibilityPredicate that always returns true.
AccessibilityPredicate.NotPrivateAccessibilityPredicate	NotPrivateAccessibilityPredicate is a AccessibilityPredicate that returns true in the case that the class/method/constructor/field is not declared to be private.
AccessibilityPredicate.PackageAccessibilityPredicate	A predicate that tests for accessibility of a class, method, constructor, or field relative to a particular package.
AccessibilityPredicate.PublicAccessibilityPredicate	PublicAccessibilityPredicate is a AccessibilityPredicate that returns true in the case that the class/method/constructor/field is public.
AccessibleField	AccessibleField represents an accessible field of a class object, which can be an instance field, a static field, or a static final field.
AlwaysFalse<T>	A predicate that always return false.
AlwaysTrue<T>	A predicate that always returns true.
ArrayCreation	ArrayCreation is a Operation representing the construction of a one-dimensional array of a given type.
ArrayElementSet	Created by bjkeller on 8/19/16.
ArrayType	Represents an array type as defined in JLS, Section 4.3.
Bloodhound	Implements the Bloodhound component, as described by the paper "GRT: Program-Analysis-Guided Random Testing" by Ma et.
BoundsCheck	Predicate to check the type of a substitution for a list of type variables.
CallableOperation	CallableOperation is an abstract implementation of the Operation interface to provide default implementations of Operation predicates that are false except for a few kinds of operations.
CaptureTypeVariable	Represents a type variable introduced by capture conversion over a wildcard type argument.
Check	A Check represents the expected runtime behavior of a Sequence, at a particular offset.
CheckpointingMultiMap<K extends @Signed Object,V extends @Signed Object>	A MultiMap that supports checkpointing and restoring to a checkpoint (that is, undoing all operations up to a checkpoint, also called a "mark").
CheckpointingMultiMap.Ops	The operations on the map.
CheckpointingSet<E extends @Signed Object>	A Set that supports settingcheckpoints (also called "marks") and restoring the data structure's state to them.
CheckRep	Write this annotation on a method to specify that that the method checks a representation invariant.
CheckRepContract	Represents the contract that an object must conform to its representation invariant, as expressed in a user-supplied representation check method.
CheckRepExtractor	CheckRepExtractor is a ClassVisitor that inspects the methods passed to it to see if they are annotated with CheckRep, are non-static, and have either a boolean or void return type.
ClassFileConstants	Reads literals from a class file, including from the constant pool and from bytecodes that take immediate arguments.
ClassFileConstants.ConstantSet	Stores constant values from a class file.
ClassLiteralExtractor	ClassLiteralExtractor is a ClassVisitor that extracts literals from the bytecode of each class visited, adding a sequence for each to a map associating a sequence with a type.
ClassLiterals	For a given class C, ClassLiterals maps C (if present) to a collection of literals (represented as single-element sequences) that are defined in C.
ClassNameErrorHandler	A ClassNameErrorHandler determines the error behavior when a class name error occurs.
ClassOrInterfaceType	Represents a class or interface type as defined in JLS Section 4.3.
ClassRenamingVisitor	JavaParser visitor to rename classes.
ClassTypeNameSimplifyVisitor	JavaParser Visitor to simplify type names.
ClassTypeVisitor	Visitor for Class types in JavaParser AST.
ClassVisitor	ClassVisitor defines the interface for a visitor class that uses reflection to collect information about a class and its members.
ClosingStream
CodeWriter	Interface for a method writeClassCode that writes a class to a file.
CollectionsExt
CommandHandler	A command is the first argument given to Randoop.
CompareToAntiSymmetric	The contract: Checks that an object is antisymmetric over compareTo.
CompareToEquals	The contract: Checks that compareTo is consistent with equals.
CompareToReflexive	The contract: Checks that an object is reflexive over compareTo.
CompareToReturnsNormally	Checks that calling compareTo() on an object does not throw an exception.
CompareToSubs	The contract: Checks the substitutability property of compareTo for equals.
CompareToTransitive	The contract: Checks the transitivity of the compare to method.
CompilableTestPredicate	TestPredicate that returns true if the given ExecutableSequence is compilable.
CompileUtil	Utilities for compiler classes.
ComponentManager	Stores the component sequences generated during a run of Randoop.
ConstructorCall	ConstructorCall is an Operation that represents a call to a constructor, and holds a reference to a reflective Constructor object.
ConstructorReflectionCode	Wraps a constructor together with its arguments, ready for execution.
ContractCheckingGenerator	An execution visitor that generates checks for error-revealing tests.
ContractSet	Manages the set of ObjectContract objects.
CountDownTimer
CoverageTracker	Tracks the branch coverage of each method under test.
CoverageTracker.DummySessionInfoVisitor	An ISessionInfoVisitor that does nothing.
CoveredClassVisitor	A ExecutionVisitor that polls a set of coverage instrumented classes and adds each covered class to an ExecutableSequence after it is executed.
CreatedJUnitFile	A message indicating that Randoop created a specific JUnit file containing generated tests.
DeclarationExtractor	A ClassVisitor that simply collects ClassOrInterfaceType objects for visited Class objects.
DefaultClassVisitor	Default implementation of the ClassVisitor class.
DefaultOperationHistoryLogger	The default implementation of the OperationHistoryLogInterface.
DefaultReflectionPredicate	Default implementations of methods that indicate what is "under test": whether a class, method, constructor, or field should be used in Randoop's exploration.
DummyCheckGenerator	Returns an empty TestChecks.
DummyVariable	A dummy variable, to ensure that parameter lists are the expected length.
DummyVisitor	A visitor that does nothing and adds no checks.
EagerReferenceBound	Represents a bound on a type variable where the bound is a ReferenceType that can be used directly.
EmptyExceptionCheck	An ExceptionCheck that doesn't enforce the expectation of an exception by the statement at the statement index.
EnumConstant	EnumConstant is an Operation representing a constant value from an enum.
EnumValue	A check for a particular value of an Enum.
EqualsHashcode	The contract: o1.equals(o2) ==> o1.hashCode() == o2.hashCode().
EqualsMethodMatcher
EqualsReflexive	The contract: x0.equals(x0)==true.
EqualsReturnsNormally	Checks that calling equals() on an object does not throw an exception.
EqualsSymmetric	The contract: o1.equals(o2) ==> o2.equals(o1).
EqualsToNullRetFalse	The contract: x0.equals(null)==false.
EqualsTransitive	The contract: Checks the transitivity of equals for an object (x0.equals(x1) && x1.equals(x2)) ==> x0.equals(x2).
ErrorRevealed	A message indicating that an error was revealed.
ErrorRevealingChecks	ErrorRevealingChecks represent failing checks for a particular test sequence.
ErrorTestPredicate	Returns true if the sequence is an error test (has a failure).
EverythingAllowedPredicate
EverythingIsDifferentMatcher
ExceptionalExecution	Means that the execution of a statement threw an exception.
ExceptionBehaviorClassifier	Static method ExceptionBehaviorClassifier.classify(randoop.ExceptionalExecution, randoop.sequence.ExecutableSequence) classifies exceptions thrown by a test sequence based on the GenInputsAbstract.BehaviorType command-line arguments.
ExceptionCheck	An ExceptionCheck indicates that an exception is expected at a particular statement in a sequence.
ExcludeTestPredicate	Forbids certain sequences.
ExecutableBooleanExpression	A ExecutableBooleanExpression represents a boolean Java expression, and allows evaluation on argument values.
ExecutableSequence	An ExecutableSequence wraps a Sequence with functionality for executing the sequence, via methods ExecutableSequence.execute(ExecutionVisitor, TestCheckGenerator) and ExecutableSequence.execute(ExecutionVisitor, TestCheckGenerator, boolean).
ExecutableSpecification	The executable version of an OperationSpecification.
Execution	Represents the unfolding execution of a sequence.
ExecutionOutcome	Represents the outcome of executing one statement in a sequence, including: the value returned by the statement, or the exception thrown.
ExecutionVisitor	A visitor that is invoked as the execution of a sequence unfolds.
ExpectedExceptionCheck	An ExceptionCheck that enforces the expectation of an exception being thrown.
ExpectedExceptionCheckGen	A check generator that when given an exception, generates either an ExpectedExceptionCheck object or an EmptyExceptionCheck.
ExpectedExceptionGenerator	A TestCheckGenerator that generates checks for exceptions that are expected at the final statement of a sequence.
ExpectedOutcomeTable	An ExpectedOutcomeTable collects all the permitted outcomes for a set of methods (where the methods are all in an overriding relationship) and a set of prestate values.
ExplicitTypeVariable	Represents a type variable that is a type parameter.
ExtendGenerator	This TestCheckGenerator combines two generators, using the invalid and failure checks from the first, and, if none of those, then returning the output of the second.
FailedPredicateException	Represents when a user provides a signature that is excluded by a predicate.
FailingAssertionCommentWriter	A CodeWriter that comments out failing assertions when outputting JUnit tests.
FailingAssertionCommentWriter.Match	The line and first group from the match of a Pattern.
FailingAssertionCommentWriter.NotMatchedException	An exception that indicates that an expected pattern was not found.
FieldAccessTypeNameSimplifyVisitor	JavaParser visitor to simplify field access in a test method.
FieldGet	FieldGetter is an adapter that creates a Operation from a AccessibleField and behaves like a getter for the field.
FieldParser	Recognizes a string representation of a field as part of parsing an Operation that is a FieldGet or FieldSet operation.
FieldSet	FieldSetter is an adapter for a AccessibleField as a Operation that acts like a setter for the field.
FileCompiler	Compiler for Java source code files.
FileCompiler.FileCompilerException	Exception for errors during compilation using FileCompiler.
ForwardGenerator	Randoop's forward, component-based generator.
ForwardGenerator.VarAndSeq
GenericClassType	Represents the type of a generic class.
GenInputsAbstract	Container for Randoop options.
GenInputsAbstract.BehaviorType	The possible values for exception behavior types.
GenInputsAbstract.BloodhoundCoverageUpdateMode	The possible modes for updating the coverage information that is used by Bloodhound.
GenInputsAbstract.ClassLiteralsMode	The possible values of the literals_level command-line argument.
GenInputsAbstract.FlakyTestAction	Possible behaviors if Randoop generates a flaky test.
GenInputsAbstract.InputSelectionMode	How to select inputs: the random choice strategy.
GenInputsAbstract.Limits	Wraps the three ways of limiting Randoop test generation.
GenInputsAbstract.MethodSelectionMode	The possible values of the method_selection command-line argument.
GenTests	Test generation.
Globals	Various general global variables used throughout Randoop.
Globals.NullOutputStream	Discards anything written to it.
Guard	The representation of a boolean expression over the values of parameters and receiver object of an operation (i.e., a method or constructor).
GuardPropertyPair	Represents a pair of an executable guard and an executable property.
GuardThrowsPair	Represents a pair of a an executable guard expression and an executable throws clause.
HashCodeReturnsNormally	Checks that calling hashCode() on an object does not throw an exception.
Help	The "help" command.
HelperSequenceCreator	Contains static methods that create Sequences.
HelperSequenceCreator.SequenceExtender
Identifiers	Contains the identifiers used in the guards and properties of the specifications in a OperationSpecification.
IdentityMultiMap<K,V>	A multi-map using key identity rather than equality.
IEventListener	Defines various event during Randoop's generation at which an implementing class can be notified and perform some action.
IMessage	IMessages are messages created by Randoop during generation, to inform clients of any relevant information; example messages are whether the generation has started or stopped, percentage done, the names of any files created, or whether an error in the classes under test has been discovered.
IMultiMap<K,V>	A multimap, which maps each key to a set of values.
IncludeIfCoversPredicate	Requires a test to cover certain classes.
IncludeTestPredicate	Returns true if the test uses a variable (or method) defined in a class that matches the given regular expression.
InitializedArrayCreation	InitializedArrayCreation is an Operation representing the construction of a one-dimensional array with a given element type and length.
InputsAndSuccessFlag	Represents a set of inputs, plus a boolean that is true if this is a good set of inputs.
InputSequenceSelector	Interface for selecting sequences as input for creating new sequences.
InstantiatedType	Represents a parameterized type as a generic class instantiated with type arguments.
IntersectionTypeBound	Represents an intersection type bound on a type parameter in a class, interface, method or constructor (see JLS section 4.4).
InvalidCheckGenerator	Generates invalid checks.
InvalidChecks	An empty or singleton set.
InvalidExceptionCheck	An InvalidExceptionCheck represents the occurrence of an exception tagged as an invalid behavior during Check generation.
InvalidValueCheck	Represents the occurrence of an invalid value for a ExecutableBooleanExpression of the TypedOperation in a Statement.
IsNotNull	The contract: x != null.
IsNull	The contract: x == null.
IStopper	Used by Randoop to determine whether generation should stop.
JarReader
JavaFileWriter	A CodeWriter that writes JUnit4 test class source text to a .java file with annotations so that tests are executed in ascending alphabetical order by test method name.
JavaTypes	Constants for non-JDK Java types.
JDKTypes	Defines type constants for classes in the JDK Collections.
JUnitCreator	Creates Java source as String for a suite of JUnit4 tests.
KeyToMultiSet<K extends @Signed Object,V extends @Signed Object>	A map from a key to a multi-set.
LazyParameterBound	A lazy representation of a type bound in which a type variable occurs.
LazyParameterBound.LazyBoundException	There was an attempt to perform an operation, such as capture conversion, on a lazy bound.
LazyReferenceBound	A lazy representation of a type bound in which a type variable occurs.
ListOfLists<E>	Given a list of lists, defines methods that can access all the elements as if they were part of a single list, without actually merging the lists.
LiteralFileReader	Method LiteralFileReader.parse(java.lang.String) reads a file specifying literal values to use during generation.
Log	Static methods that log to GenInputsAbstract.log, if that is non-null.
Main	Main entry point for Randoop.
MappedSequences<K>	A multimap from keys of type K to sequences.
MethodCall	MethodCall is a Operation that represents a call to a method.
MethodReflectionCode	Wraps a method together with its arguments, ready for execution.
MethodTypeNameSimplifyVisitor	JavaParser visitor to simplify type names in method calls.
Minimize	This program minimizes a failing JUnit test suite.
Minimize.ClassOrInterfaceTypeComparator	Sorts a type by its simple name.
Minimize.ImportDeclarationComparator	Sorts ImportDeclaration objects by their name.
Minimize.Outputs	Contains the command line, exit status, standard output, and standard error from running a process.
MinimizerWriter	A CodeWriter that, for an error-revealing test class, writes both the original and minimized class.
MissingExceptionCheck	Represents the fact that a statement should throw an exception, but did not.
MultiMap<K extends @Signed Object,V extends @Signed Object>	Implements an IMultiMap with a java.util.LinkedHashMap.
MultiMap.EmptyMultiMap<K extends @Signed Object,V extends @Signed Object>	An immutable, empty multimap.
MultiSet<E extends @Signed Object>	A multiset: each value may appear multiple times.
MultiVisitor	An execution visitor that chains a list of visitors in sequence.
NameGenerator	A NameGenerator generates a sequence of names as strings in the form "prefix"+i for integer i.
NoExceptionCheck	This check represents the fact that a statement should not throw any exception.
NonParameterizedType	NonParameterizedType represents a non-parameterized class, interface, enum, or the rawtype of a generic class.
NonreceiverTerm	Represents a value that either cannot (primitive or null values), or we don't care to have (String, Class) be a receiver for a method call as an Operation.
NormalExecution	Means that the statement that this result represents completed normally.
NotExecuted	Means that the statement that this outcome represents was not executed.
NullReferenceType	The null type is the type of the value null.
ObjectCache
ObjectCheck	A check that checks for expected properties of one or more objects generated during the execution of a Sequence, for example: Checking that the objects created during execution of a sequence respect reflexivity, transitivity and symmetry of equality.
ObjectContract	An object contract represents a property that must hold of any object of a given class.
ObjectContractReflectionCode
ObjectContractUtils	Utility methods for safely executing and printing ObjectContract code.
ObserverEqArray	A check recording the current state of an array during execution.
ObserverEqValue	A check recording the value that an observer method returned during execution, e.g.
OmitMethodsPredicate	Tests whether the RawSignature of an operation is matched by an omit.
OneMoreElementList<E>
Operation	Operation represents the constructs that can occur in a statement as part of a test sequence.
OperationExtractor	OperationExtractor is a ClassVisitor that creates a collection of TypedOperation objects for a particular ClassOrInterfaceType through its visit methods as called by ReflectionManager.apply(Class).
OperationHistoryLogger	The working implementation of a OperationHistoryLogInterface that will collect and print the operation history log to the PrintWriter given when constructed.
OperationHistoryLogInterface	Interface for classes that log the usage of operations in the generated sequences.
OperationModel	OperationModel represents the information context from which tests are generated.
OperationOutcome	Representations for outcomes after an operation is selected during generation.
OperationParseException
OperationParser	Parser for text serialization (string representation) of Operations.
OperationSignature	Represents the signature of a method or constructor for an OperationSpecification so that the java.lang.reflect.AccessibleObject can be loaded, which is done by SpecificationCollection.getAccessibleObject.
OperationSpecification	A specification of a constructor or method, aka, an operation.
OptionsCache	Manages the static state of Randoop classes with Options annotations.
OrienteeringSelection	Implements the Orienteering component, as described by the paper "GRT: Program-Analysis-Guided Random Testing" by Ma et.
OrienteeringSelection.SequenceDetails	Information used by Orienteering to compute a weight for a sequence.
PackageLiterals	For a given package P, PackageLiterals maps P (if present) to a collection of literals (represented as single-element sequences) that can be used as inputs to classes in the given package.
ParameterBound	Represents a type bound on a type variable or wildcard occurring as a type parameter of a generic class, interface, method or constructor.
ParameterizedType	Represents a parameterized type.
ParameterType	An abstract class representing kinds of type parameters, which are either type variables or wildcard types.
Postcondition	A Postcondition is a specification clause of a contract on the outcome of the invocation of an operation.
PostConditionCheck	Represents the observed failure of a post-condition.
PostConditionCheckGenerator	Checks the given post-conditions after the last statement of a sequence.
Precondition	A SpecificationClause for pre-conditions on the parameters and receiver of an operation.
PrimitiveAndWrappedTypeVarNameCollector	Visit every variable declaration.
PrimitiveType	Represents a Java primitive type.
PrimitiveTypes	Utilities for working with Class<?> objects that Java reflection treats as primitive, which includes primitive types and void.
PrimValue	A check recording the value of a primitive value (or String) obtained during execution (e.g., var3 == 1 where var3 is an integer-valued variable in a Randoop test).
PrimValue.EqualityMode	Specifies what type of equality the contract uses.
ProgressDisplay	Modified from Daikon.FileIOProgress.
ProgressDisplay.Mode
Property	The representation of a boolean expression over the values of parameters, receiver object, and return value of a method.
Randomness	A simple-to-use wrapper around Random.
RandoopBug	Thrown to indicate exceptional behavior that definitely indicates a bug in Randoop.
RandoopClassNameError	Exception for classname errors.
RandoopCommandError	Indicates a user error in a command supplied to Randoop.
RandoopFinished	A message indicating that Randoop is finished generating tests.
RandoopGenerationError	Error class to signal generation errors that should stop Randoop execution.
RandoopInstantiationError
RandoopLoggingError	Exception for tracking errors in logging that should result in Randoop termination.
RandoopOutputException	An exception (usually an IOException) occurred while writing tests to a file.
RandoopSpecificationError	Indicates a problem creating ExecutableBooleanExpression (usually a syntax error in the condition text) or an exception thrown when evaluating it.
RandoopStarted	A message indicating that Randoop has just started generating tests.
RandoopTypeException	Exception used to indicate when a type problem has occurred in Randoop.
RandoopUncaughtRunnerThreadExceptionHandler
RandoopUsageError	Indicates a user error in invoking Randoop.
RawSignature	Represents the raw type signature for an java.lang.reflect.AccessibleObject.
RecordListReader	Reads a list of records from a text file, where a record is partially specified by the client of this class.
RecordProcessor	Processes a single record given by RecordListReader.
ReferenceArgument	Represents a reference type as a type argument to a parameterized type.
ReferenceBound	Represents a bound on a type variable where the bound is a ReferenceType.
ReferenceType	Represents a reference type defined in JLS Section 4.3
ReferenceValue	Represents a ReferenceType value created by the execution of a Statement.
ReflectionArrayCreation	Represents an array creation using reflection, and corresponds to the code (List<String>[])(Array.newInstance(componentType, length));
ReflectionCode	Wraps a method or constructor together with its arguments.
ReflectionCode.ReflectionCodeException	Indicates a bug in the ReflectionCode class.
ReflectionExecutor	Static methods that executes the code of a ReflectionCode object.
ReflectionManager	ReflectionManager contains a set of visitors and an accessibility predicate.
ReflectionPredicate	Methods that indicate whether a class, method, constructor, or field should be used in Randoop's exploration.
RegressionCaptureGenerator	A TestCheckGenerator that records regression checks on the values created by the sequence.
RegressionChecks	A set of checks, including at most one ExceptionCheck.
RegressionTestPredicate	RegressionTestPredicate determines whether to keep an ExecutableSequence as a regression test.
ReplayFailureException	Thrown by a ContractFailureReplayVisitor or a RegressionReplayVisitor when a regression decoration fails to replay.
RunCommand	Class providing the RunCommand.run(List, Path, long) method to run a command in a separate process with a timeout.
RunCommand.CommandException	Exception representing an error that occured while running a process with RunCommand.run(List, Path, long).
RunCommand.Status	Represents the status of a process that has been executed.
RunnerThread
RunnerThread.NextCallMustBe
SeedSequences	Provides functionality for creating a set of sequences that create a set of primitive values.
Sequence	An immutable sequence of Statements.
Sequence.RelativeNegativeIndex	Used internally (i.e.
SequenceCollection	A collection of sequences that makes it efficient to ask for all the sequences that create a value of a given type.
SequenceCompiler	Compiles a Java class given as a String.
SequenceCompilerException	Exception for compilation of Java classes given as String.
SequenceExceptionError	Exception representing occurrence of a "flaky" test sequence where an exception was thrown by a statement other than the last of the sequence.
SequenceExecutionException	Represents an error that occurs during execution of a sequence.
SequenceJavaFileObject	A JavaFileObject for source code in memory.
SequenceParseException
SideEffectFree	A side-effect-free method does not change the state of receiver or parameters.
SignatureParseException	Represents exception when parsing signature strings using SignatureParser.
SignatureParser	Parses type signature strings used to identify methods and constructors in input.
SimpleArrayList<E>
SimpleList<E>	Stores a sequence of items, much like a regular List.
SizeToArrayLength	The contract: c.toArray().length == c.size() for all Collections c.
SmallTestsSequenceSelection	Select input sequences, favoring shorter sequences.
SourceBuilder	Common behavior for source builder classes.
SpecificationClause	Abstract class for representations of conditions that can be attached to methods and constructors.
SpecificationCollection	A collection of OperationSpecification objects, indexed by AccessibleObject reflection objects.
SpecificationTranslator	Method SpecificationTranslator.createExecutableSpecification(java.lang.reflect.Executable, randoop.condition.specification.OperationSpecification, randoop.compile.SequenceCompiler) translates an OperationSpecification object (which has preconditions, postconditions, and throws conditions) to its executable version, ExecutableSpecification.
StateMatcher
Statement	Statement represents a Java statement, such as a method call Foo f = m(i1...iN) or a declaration int x = 0.
StaticCache	Stores the mutable state of a class, allowing it to be saved, printed and restored.
StringTooLongException	An exception indicating a string is too long.
Substitution	A substitution maps type parameters/variables (including wildcards) to concrete types.
SubTypeSet	A set of classes.
TestCheckGenerator	Generates a set of test checks from a test sequence that has been executed.
TestChecks<T extends TestChecks<T>>	A TestChecks reprents a set of Checks, and possibly a single ExceptionCheck.
TestCoverageInfo
TestCoverageInfo.BranchCov
TestEnvironment	Provides the environment for running JUnit tests.
TestUtils	Utility methods for setting up selection and operation-history logging in integration tests that use a generator.
TestValue	Signals to Randoop that the value of a primitive (or primitive array) field in a class under test should be used as an input value to methods under test.
TestValueExtractor	TestValueExtractor is a ClassVisitor that inspects the fields passed to it to see if they are annotated with TestValue, are static, and have type that is primitive, String, or an array of primitive or String.
ThrowClassNameError	ThrowClassNameError is used to handle a class name error by throwing an Error with the message.
ThrowsClause	Represents an expected exception in a throws-condition.
ThrowsCondition	A specification clause that an exception should be thrown.
ToStringReturnsNormally	Checks that calling toString() on an object does not throw an exception.
TupleSequence	A Sequence that produces a tuple or collection of values, all of the same type.
TupleSet<E>	Represents a non-empty set of tuples.
Type	The superclass of a class hierarchy representing Java types defined in JLS Section 4.1.
TypeArgument	Represents a type argument of a parameterized type as described in JLS Section 4.5.1.
TypeArguments	TypeArguments provides static methods for creating and recognizing strings representing the type arguments of a method or constructor.
TypedClassOperation	Represents a TypedOperation and its declaring class.
TypedClassOperationWithCast	Represents a method with a return type that is a type variable that must be instantiated, and for which execution performs a cast to the instantiating type to emulate handling of casts that are not done in reflection.
TypedOperation	Type decorator of Operation objects.
TypedOperation.RankedTypeOperation	RankedTypedOperation is a wrapper around a TypedOperation and a number.
TypedOperationSelector	An interface for selecting an operation for the ForwardGenerator to use in constructing a new test sequence.
TypedTermOperation	Represents operations that have no declaring class, such as literal value, cast, or array creation/access/assignment.
TypeExtractor	TypeExtractor is a ClassVisitor that extracts both the class type, and concrete types that are used in a class as either a parameter, a return type, or a field type.
TypeInstantiator	Instantiates type parameters from a set of input types.
TypeNames	TypeNames provides a pair of static methods to: get string names for classes and primitive types, and get the Class object for a string representing a class or primitive type.
TypeTuple	TypeTuple represents an immutable ordered tuple of Type objects.
TypeTuple.TypeIterator
TypeTupleSet	Represents a set of lists of candidate type arguments for a ParameterizedType, and uses this set to construct substitutions for a list of TypeArgument objects.
TypeVariable	An abstract class representing type variables.
UncheckedCast	An Operation to perform an explicit cast.
UniformRandomMethodSelection	This class selects a method, from the list of methods under test, with uniform probability.
UniformRandomSequenceSelection	Select sequences uniformly at random.
Util	Helpers for assertions, and stuff...
ValidityCheckingGenerator	A ValidityCheckingGenerator checks for occurrences of exceptions that have been tagged as invalid behaviors.
Value	Utility methods to work with values in test sequences.
ValueSizePredicate	Returns true if the sequence returns a value that is NOT too large value.
Variable	Represents the result of a statement call in a sequence.
VariableRenamer
VoidType	Represents void.
WarnOnBadClassName	WarnOnBadClassName is used to handle a bad class name error by printing a warning to standard out, and is used to suppress an exception.
WildcardArgument	Represents a wildcard type argument to a parameterized type.
WildcardType	Represents a wildcard type, which occurs as a type argument to a parameterized type.