value or className specify the original class either as a class literal or by
name, while classNameProvider is the most flexible approach where the class name is
computed by user code. Optionally, inner classes can be specified using the innerClass
property.
Based on additional annotations, the original class is modified in different ways:
Delete or Substitute: the annotated class is an alias for the
original class. This is the most frequently used case. All methods and fields of the annotated
class must be annotated too:
Alias: The annotated method or field is an alias for the original element, i.e., the
annotated element does not exist at run time. All usages of the annotated element reference the
original element. For fields, the original field can be further modified using the
RecomputeFieldValue and InjectAccessors annotations (see the documentation of the
annotations for details).Delete: The annotated method or field, as well as the original element, do not exist.
Any usage of them will be reported as an error.Substitute: The annotated method replaces the original method.AnnotateOriginal: The original method remains mostly unchanged, but with one
exception: all annotations on the annotated method are also present on the original method.Delete: The annotated class, as well as the original class, do not exist. Any usage
of them will be reported as an error.Substitute: The annotated class replaces the original class. All fields and methods
of the original class are per default treated as deleted, i.e., any usage of them will be
reported as an error, with the following exception: A method annotated with Substitute
replaces the original method, i.e., calls to the original method now call the annotated method; a
method annotated with KeepOriginal keeps the original method, i.e., calls to the original
method still call the original method.| Modifier and Type | Class and Description |
|---|---|
| public static class | TargetClass.
The default value for the |
| public static interface | TargetClass.
Marker value for |
| Modifier and Type | Method and Description |
|---|---|
| public String | |
| public Class | |
| public String[] | |
| public Class | onlyWith()
Substitute only if all provided predicates are true (default: unconditional substitution that is always included). |
| public Class |
| className | back to summary |
|---|---|
| public String className() Specifies the substitutee class using a class-name string. This method is provided for cases
where the substitutee class is not accessible (according to Java language access control
rules).
Either
| |
| classNameProvider | back to summary |
|---|---|
| public Class Specifies the substitutee class. This is the most flexible version to provide the class name
to specify which class should be substituted. The
| |
| innerClass | back to summary |
|---|---|
| public String[] innerClass() Specifies the suffix of the substitutee class name when it is an inner class.
| |
| onlyWith | back to summary |
|---|---|
| public Class Substitute only if all provided predicates are true (default: unconditional substitution that
is always included).
The classes must either implement
| |
| value | back to summary |
|---|---|
| public Class Specifies the substitutee class using a class literal.
Either
| |
TargetClass#onlyWith() attribute.
| Access | Constructor and Description |
|---|---|
| pack-priv |
| Modifier and Type | Method and Description |
|---|---|
| public boolean |
| AlwaysIncluded | back to summary |
|---|---|
| pack-priv AlwaysIncluded() | |
| getAsBoolean | back to summary |
|---|---|
| public boolean getAsBoolean() Implements java. Doc from java. Gets a result.
| |
classNameProvider that no class name provider should be used.