All Classes and Interfaces
Class
Description
A block without a label at the beginning of a method.
Assertions for use within Spock code.
Utility class for inspecting the abstract syntax tree (AST) produced by
the Groovy compiler.
Unchecked exception thrown by AstInspector when:
an IOException occurs when loading a file
a declaration with the specified name cannot be found
an internal error occurs
Provides access to frequently used AST nodes.
Utility methods for AST processing.
Alternative to class BlockingVariable(s) that allows to evaluate conditions
in a thread other than the spec runner's thread(s).
Automatically cleans up the object stored in the annotated field or property
at the end of its life time.
Executes a single Spec.
Indicates that the annotated element, a member of Spock's public API, is in a
trial phase.
AST node representing a block in a feature method.
Runtime information about a block in a method of a Spock specification.
A statically typed variable whose get() method will block until some other
thread has set a value with the set() method, or a timeout expires.
The different kind of blocks that a BlockInfo instance can represent.
Internal block metadata generated by the compiler for consumption by the runtime.
A response strategy that delegates method calls to the real object underlying the mock (if any).
Thrown to indicate a problem when creating a mock object.
Thrown to indicate that an attempt was made to delegate a method call to
a real object underlying a mock, although no such underlying object exists.
CaptureType represents a wildcard that has gone through capture conversion.
AST node representing a cleanup-block in a feature method.
Runtime representation of an evaluated condition.
Indicates that the closure argument(s) of the annotated method are code blocks
containing conditions, allowing to leave off the assert keyword.
Rewrites explicit ("assert x > 3") and implicit ("x > 3") condition
statements.
Thrown to indicate that there is a problem with Spock's configuration (file).
Confines any changes made to the meta classes of the specified classes to the
annotated scope.
Internal metadata about a data provider from which the runtime model is built.
Walks the statement and expression tree to:
- rewrite explicit conditions,
- rewrite interactions,
- rewrite core language primitives (members of class Specification)
- Forbid
Also records whether conditions and interactions were found.
Calculates Levenshtein distance and corresponding edit path between two character sequences.
A response strategy that returns zero, an "empty" object, or a "dummy" object,
depending on the method's declared return type.
Reporting facility for problems found during compilation.
Creates a string representation of an assertion and its recorded values.
Groovy AST visitor that allows to replace both statements and expressions.
Scans class path for extension descriptors and loads the extension classes specified therein.
Collects all Spock extensions found on the class path (via their descriptor).
Runs global and local extensions for a spec.
Indicates that a feature method is expected to fail with the given exception.
Internal metadata about a feature from which the runtime model is built.
AST node representing a feature method.
AST node representing a user-defined instance field.
Runtime information about a field in a Spock specification.
An assignment of the form "x = expr", where x is a field and expr is a field
initializer expression.
Internal metadata about a field, from which the runtime model is built.
AST node representing a fixture method.
Utility class for doing reflection on types.
Provides convenient access to Groovy language and runtime features.
Creates a Guice injector, and injects Guice-provided objects into specifications.
Facade around Hamcrest API that works both with Hamcrest 1.1 and 1.2,
providing better failure descriptions if the latter is available.
HashMap based implementation of IMultiset.
A constraint on an invocation argument.
Generates return values for invocations on mock objects.
A strategy for responding to unexpected method calls.
Identifiers used throughout the core.
A function from domain D to co-domain C.
Indicates that a specification or feature method should not be run.
Ignores the annotated spec/feature if the given condition holds.
Indicates that all feature methods except the ones carrying this annotation
should be ignored.
An interaction scope holds a group of interactions that will be verified,
and thereafter removed, at the same time.
Maps method names in bytecode to their logical names.
Configuration options for mock objects.
An anticipated interaction between the SUT and one or more mock objects.
A method invocation on a mock object.
Represents a method that can be mocked.
Set-like data structure where each element has a cardinality.
Configuration indicating which specs and methods should be
included/excluded from a spec run.
Marks a declaration in Groovy code so that it can be easily accessed using
AstInspector.
Base class for exceptions thrown to indicate that one or more interactions
were not satisfied.
Creates the AST representation of an InteractionBuilder build sequence.
A scope for interactions defined outside a then-block
Internal identifiers in generated byte code.
Indicates that a spec was found to contain a (syntactic or semantic)
error during compilation.
Indicates that a Spec has done something it is not supposed to do.
Generates responses to mock invocations.
Listens to a spec run.
Marker-like interface implemented by all mock objects that allows
MockDetector to detect mock objects.Indicates that a feature method or specification relates to one or more
issues in an external issue tracking system.
Generates result values from an iterable object.
Runtime information about an iteration of a feature method.
A function from domain D to co-domain C that may throw a checked exception.
Generates and attaches JUnit Description's to a SpecInfo's nodes.
Adapts an org.junit.runner.manipulation.Filter to an IMethodInfoFilter.
Adapts the JUnit
Before, After, BeforeClass and AfterClass fixture mechanism to Spock.Adapts an org.junit.runner.manipulation.Sorter to a IMethodInfoSorter.
LinkedHashMap based implementation of IMultiset.
AST node representing a Spec method (one of fixture method, feature method, helper method).
Runtime information about a method in a Spock specification.
The different kinds of methods that a MethodInfo instance can represent.
Detects mock objects and provides information about them.
Determines how method calls are processed and matched against interactions.
Spock's mocking API primarily consists of the following factory methods:
Mock()
Creates a general-purpose test double that supports both stubbing and mocking.
Stub()
Creates a test double that supports stubbing but not mocking.
Spy()
Creates a test double that, by default, delegates all calls to a real object.
An anticipated interaction between the SUT and one or more mock objects.
A named set of defaults for a mock's configuration options.
Base class for all SpecL AST nodes.
Base class for runtime information about an element in a Spock specification.
Indicates that the annotated field, parameter, or return value of the
annotated method is allowed to be null.
Utility methods applicable to (almost) any object.
Used to represent the argument to Specification.old() once it has been processed
by IRewriteResources.captureOldValue().
Inspired from JUnit's MaxCore.
An immmutable pair of elements.
Adds the ability to run parameterized features.
Repeatedly evaluates one or more conditions until they are satisfied or a timeout has elapsed.
Some implementation details of this class are inspired from Spring, EasyMock
Class Extensions, JMock, Mockito, and this thread:
http://www.nabble.com/Callbacks%2C-classes-and-instances-to4092596.html
Configuration settings for the spec runner.
Forms a gestalt from its blueprint.
One or more references to external information related to a specification or feature.
AST node representing a setup-block in a feature method.
Indicates that a field is shared among all feature methods in a
specification.
AST node representing a Spock specification.
Puts all spec information required at runtime into annotations
attached to class members.
Finds all class files below a base directory that contain a runnable spec.
Ant selector that selects class files containing Spock specifications.
Base class for Spock specifications.
Runtime information about a Spock specification.
Builds a SpecInfo from a Class instance.
Internal specification metadata generated by the compiler for consumption
by the runtime.
Given the abstract syntax tree of a Groovy class representing a Spock
specification, builds an object model of the specification.
A Spec visitor responsible for most of the rewriting of a Spec's AST.
Utility methods related to specifications.
Thrown when a condition of the form 'expr1 == expr2' fails.
Indicates that a problem occurred during Spec execution.
Indicates that an operation timed out.
AST transformation for rewriting Spock specifications.
A JUnit runner for Spock specifications.
Filters an exception's stack trace.
Adds the ability to replace statements.
Indicates that a spec's feature methods should be run sequentially
in their declared order (even in the presence of a parallel spec runner),
always starting from the first method.
Indicates which objects/classes are the subjects of a specification.
A position in a text, given as a line/column pair.
A region of text spanning all characters between a start position (inclusive)
and an end position (exclusive).
Utility methods for text processing.
AST node representing a then-block in a feature method.
Indicates that the execution of a method should time out
after the given duration has elapsed.
Times out a method invocation if it takes too long.
Thrown to indicate that one or more mandatory interactions matched too few invocations.
Thrown to indicate that a mandatory interaction matched too many invocations.
Wrapper around
Type.Indicates that iterations of a data-driven feature should be made visible
as separate features to the outside world (IDEs, reports, etc.).
Activates one or more Groovy categories while the annotated spec method
or class executes.
Activates Guice integration for a specification.
Records the values in a condition.
A version number with format major.minor.micro-qualifier.
AST node representing a when-block in a feature method.
Returns the default value for the invoked method's return type.
Wraps a checked exception s.t.
Thrown if an invocation on a mock object occurs too late.
A response strategy that returns zero, false, or null, depending on the method's return type.