return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                ExpectedFailure expectedFailureAnnotation = method.getAnnotation(ExpectedFailure.class);
                boolean expectedToFail = expectedFailureAnnotation != null;
                Throwable failed = null;
                try {
                    base.evaluate();

import java.util.Optional;

public interface PropertyMetadata {
    String getPropertyName();

    boolean isAnnotationPresent(Class<? extends Annotation> annotationType);

    <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType);

    Optional<Annotation> getAnnotationForCategory(AnnotationCategory category);

    boolean hasAnnotationForCategory(AnnotationCategory category);

    private static TaskClassInfo createTaskClassInfo(Class<? extends Task> type) {
        boolean cacheable = type.isAnnotationPresent(CacheableTask.class);
        Optional<String> reasonNotToTrackState = Optional.ofNullable(type.getAnnotation(UntrackedTask.class))
            .map(UntrackedTask::because);
        Map<String, Class<?>> processedMethods = new HashMap<>();

    void visitValidationFailures(TypeValidationContext validationContext);

    /**
     * Retrieves the annotation of the given type, if present on the type itself.
     */
    <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType);

    WeaklyTypeReferencingMethod<?, R> getMethod();

    String getMethodName();

    boolean isAnnotationPresent(Class<? extends Annotation> annotationType);

    @Nullable
    <A extends Annotation> A getAnnotation(Class<A> annotationType);

    ModelType<R> getReturnType();

    List<ModelReference<?>> getReferences();

    List<List<Annotation>> getParameterAnnotations();

    @Nullable

 */
class ToBeFixedForConfigurationCacheRule implements TestRule {

    @Override
    Statement apply(Statement base, Description description) {
        def annotation = description.getAnnotation(ToBeFixedForConfigurationCache.class)
        if (GradleContextualExecuter.isNotConfigCache() || annotation == null) {
            return base
        }

        return delegate.toString();
    }

    private void registerSoftwareTypes(TypeMetadata typeMetadata) {
        Optional<RegistersSoftwareTypes> registersSoftwareType = typeMetadata.getTypeAnnotationMetadata().getAnnotation(RegistersSoftwareTypes.class);
        registersSoftwareType.ifPresent(registration -> {
            Class<? extends Plugin<Settings>> registeringPlugin = Cast.uncheckedCast(typeMetadata.getType());

            OwnerServiceEncoding(serviceType)
        } else {
            null
        }
    }

    private
    fun serviceType(type: Class<*>): Class<*>? {
        if (type.getAnnotation(ServiceScope::class.java) != null) {
            return type
        }
        for (superInterface in type.interfaces) {
            val serviceType = serviceType(superInterface)
            if (serviceType != null) {

import static org.junit.Assume.assumeTrue

class UnsupportedWithConfigurationCacheRule implements TestRule {

    @Override
    Statement apply(Statement base, Description description) {
        def annotation = description.getAnnotation(UnsupportedWithConfigurationCache.class)
        if (GradleContextualExecuter.isNotConfigCache() || annotation == null) {
            return base
        }

        assert transported.toString() == original.toString()
        assert transported.stackTrace == original.stackTrace
        assert (transported.class.getAnnotation(Contextual) != null) == (original.class.getAnnotation(Contextual) != null)
    }

    private Object transport(Object arg) {
        def outputStream = new ByteArrayOutputStream()