All Classes and Interfaces
Class
Description
Defines the JVM and ASM-specific access flags for classes, fields, methods, and method parameters.
The Interface AnAnnotation.
The Enum AnEnum.
The Interface AnInterface.
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 all entity types, containing the id property, which is automatically generated.
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.The Class BooleanExpressions.
Coverage data gathered for a branch inside a line of source code.
The Class BusinessService.
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.The Class ClassInDefaultPackage.
The Enum NestedEnum.
Holds additional information about a classfile:
ClassInfo.signature, ClassInfo.superName, ClassInfo.interfaces,
ClassInfo.hostClassName.The Class ClassInRegularPackage.
The Enum NestedEnum.
The Class ClassLoadedByCustomLoaderOnly.
The Class ClassNotExercised.
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.The Class ClassWithNestedClasses.
The Class NestedClass.
The Class ClassWithReferenceToNestedClass.
A
ClassVisitor that generates classes in bytecode form, that is, a byte array conforming to the
Java class file format.The Class Collaborator.
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 access to the application database, allowing transient instances of entity classes to be persisted, and
persistent instances to be recovered or removed from the database.
This class is a static facade for persistence operations.
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.The Class IfElseStatements.
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.
The Interface InterfaceWithExecutableCode.
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).
The Class MultiThreadedCode.
This class makes use of several idioms which would prevent unit testing with more "conventional" mocking tools.
Matches a decimal argument against another within a given margin of error.
Defines the JVM opcodes.
A pet owner.
A domain service class for
Owner-related business operations.An application service class that handles
Owner-related operations from the owner screen.A person having a first and a last name.
A pet.
A domain service class for
Pet-related business operations.An application service class that handles
Pet-related operations from the pet screen.The type of a
Pet (for example, "Dog").A Vet's specialty (for example, "Dentistry").
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.
The Class UnreachableStatements.
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.A veterinarian.
A domain service class for
Vet-related business operations.An application service class that handles
Vet-related operations from the vet screen.A visit from a pet and its owner to the clinic.
A domain service class for
Visit-related business operations.An application service class that handles
Visit-related operations from the visit screen.Same as
ClassVisitor, except it always wraps a ClassWriter.Same as
MethodVisitor, except it always wraps a MethodWriter.