All Classes and Interfaces
Class
Description
Defines the JVM and ASM-specific access flags for classes, fields, methods, and method parameters.
A bytecode reader for reading common elements (signature, annotations) of a class, field, or method.
A visitor to visit a Java annotation, in the following order: (
visit | visitEnum |
visitAnnotation | visitArray)* visitEnd.An argument matcher for the recording/verification of expectations.
Types for the argument of a NEWARRAY instruction.
Base class for encapsulating state and logic needed by both the Mocking and Faking APIs, but which should not go into
Invocation in order to keep the published API clean.Coverage data gathered for a branch inside a line of source code.
A dynamically extensible vector of bytes.
Holds a map of internal class names to the corresponding class files (bytecode arrays), for the classes that have
already been loaded during the test run.
Indicates a mock field or a mock parameter for which all classes extending/implementing the mocked type will also get mocked.
The control flow graph analysis algorithm, used to compute the maximum stack size for a method or constructor.
Finds and loads all classes that should also be measured, but were not loaded until now.
Identifies a class by its loader and name rather than by the
Class object, which isn't available during
initial class transformation.Holds additional information about a classfile:
ClassInfo.signature, ClassInfo.superName, ClassInfo.interfaces,
ClassInfo.hostClassName.A Java class parser to make a
ClassVisitor visit an existing class.Constants for JVM classfile versions corresponding to major versions of Java.
A visitor to visit a Java class, in the following order:
visit (visitAnnotation)* (visitInnerClass | visitField |
visitMethod)* visitEnd.A
ClassVisitor that generates classes in bytecode form, that is, a byte array conforming to the
Java class file format.Generates a concrete subclass for an
abstract base class.Allows the constant pool for a classfile to be created from scratch, when that classfile itself is being generated or
modified from an existing class file.
Constants for types of
items in the constant pool of a class.
Coverage data captured for all source files exercised during a test run.
Provides utility methods that enable access to ("de-encapsulate") otherwise non-accessible fields.
Provides default values for each type, typically used for returning default values according to method return types.
An empty interface to be used with the
Expectations.result field or the
Invocations#with(Delegate) method, allowing test code to define
varying invocation results or argument matching rules, respectively.An edge in the control flow graph of a method body.
This marker interface exists only to guarantee that JMockit can get the bytecode definition of each Proxy class it
creates through
java.lang.reflect.Proxy.Used to record expectations on mocked types and their instances.
If applied, this fake will take over calls to
AbstractBeanFactory.getBean(String) and
AbstractBeanFactory.getBean(String, Class) in any implementation class, returning instead a
@Tested or @Injectable object with the given field name, or a dependency object
injected at any level into a @Tested object.Startup fake that modifies the JUnit 4.5+ test runner so that it calls back to JMockit immediately after every test
executes.
An invocation to a fake method.
Startup fake which works in conjunction with
JUnit4TestRunnerDecorator to provide JUnit 4.5+ integration.Holds state associated with fake class containing annotated fakes.
A visitor to visit a Java field, in the following order: (
BaseWriter.visitAnnotation(java.lang.String))* BaseWriter.visitEnd().Coverage data gathered for the lines, branching points, and fields of a single source file.
Generates an HTML page containing line-by-line coverage information for a single source file.
Information about the input and output stack map frames of a basic block.
Responsible for recursive injection of dependencies into a
@Tested(fullyInitialized = true) object.Same as
Verifications, but checking that all invocations from code under test are explicitly
verified, except for those already verified through other means.Adapts the
org.hamcrest.Matcher interface to ArgumentMatcher.Allows the creation of new implementation classes for interfaces and abstract classes.
Indicates that the value of a mock field or mock parameter will be an isolated mocked instance,
intended to be passed or injected into the code under test.
Provides type, name, and value(s) for an injection point, which is either a field to be injected or a parameter in
the chosen constructor of a tested class.
Holds state used throughout the injection process while it's in progress for a given set of tested objects.
Factory for the creation of new mocked instances, and for obtaining/clearing the last instance created.
A context object representing the current invocation to a mocked or faked method/constructor, to be passed as the
first parameter of the corresponding delegate/fake method implementation.
A constant pool item of a given type.
A Java field or method type.
Constants that subdivide the 220 instruction opcodes in 18 types of instructions.
A label represents a position in the bytecode of a method.
Coverage data gathered for a single executable line of code in a source file.
Parses a source line into one or more consecutive segments, identifying which ones contain Java code and which ones
contain only comments.
A reference to a method.
A visitor to visit a Java method, in the following order:
(
(
BaseWriter.visitAnnotation(java.lang.String))* (MethodVisitor.visitParameterAnnotation(int, java.lang.String))* [(visitXInsn |
MethodVisitor.visitLabel(mockit.asm.controlFlow.Label) | MethodVisitor.visitTryCatchBlock(mockit.asm.controlFlow.Label, mockit.asm.controlFlow.Label, mockit.asm.controlFlow.Label, java.lang.String) | MethodVisitor.visitLocalVariable(java.lang.String, java.lang.String, java.lang.String, mockit.asm.controlFlow.Label, mockit.asm.controlFlow.Label, int) | MethodVisitor.visitLineNumber(int, mockit.asm.controlFlow.Label))*
MethodVisitor.visitMaxStack(int)] BaseWriter.visitEnd().A
MethodVisitor that generates methods in bytecode form.Thrown to indicate that one or more expected invocations still had not occurred by the end of the test.
Used inside a fake class to indicate a fake method whose implementation will temporarily
replace the implementation of one or more matching "real" methods or constructors (these are the "faked"
methods/constructors).
Indicates an instance field of a test class as being a mock field, or a parameter of a test method as a
mock parameter; in either case, the declared type of the field/parameter is a mocked type, whose
instances are mocked instances.
Holds data about redefined/transformed classes, with methods to add/remove and query such data.
Handles invocations to all kinds of mock implementations created for interfaces and annotation types through any of
the mocking APIs.
A base class used in the creation of a fake for an external type, which is usually a class from
some library or component used from the internal codebase of the system under test (SUT).
Matches a decimal argument against another within a given margin of error.
Defines the JVM opcodes.
Writes the "StackMapTable" method attribute (or "StackMap" for classfiles older than Java 6).
Provides utility methods to extract and filter stack trace information.
This is the "agent class" that initializes the JMockit "Java agent", provided the JVM is initialized with
Indicates a class to be tested, with optional automatic instantiation and/or automatic injection of dependencies.
Provides callbacks to be called by the TestNG 6.2+ test runner for each test execution.
A singleton which stores several data structures which in turn hold global state for individual test methods, test
classes, and for the test run as a whole.
Base class for "test runner decorators", which provide integration between JMockit and specific test runners from
JUnit and TestNG.
A
WebApplicationContext implementation which exposes the
@Tested objects and their injected dependencies declared in the current test class.Thrown to indicate that one or more unexpected invocations occurred during the test.
Miscellaneous utility constants and methods.
Used to verify a set of expectations on available mocked types and/or instances, against
the invocations which actually occurred during the test.
Same as
Verifications, but checking that invocations from code under test occur in the same order as the
verified expectations.Same as
ClassVisitor, except it always wraps a ClassWriter.Same as
MethodVisitor, except it always wraps a MethodWriter.