* The implementation may throw, and the exception will be propagated to the caller.
     * The implementation may choose to delegate to the original Groovy implementation by returning the value of {@code invocation.callOriginal()}.
     *
     * @param invocation the arguments supplied by the caller
     * @param consumer the class that invokes the intercepted call

/**
 * Service instances can implement this interface to apply some lifecycle to all services annotation with a given annotation.
 */
public interface AnnotatedServiceLifecycleHandler {
    List<Class<? extends Annotation>> getAnnotations();

    /**
     * When not null, all services are considered to have the implicit annotation
     * and the handler should be notified about all registrations.
     */
    @Nullable

    /**
     * Returns a copy of this configuration metadata, except with all artifacts transformed by the given transformer.
     *
     * @param artifactTransformer A transformer applied to all artifacts and sub-variant artifacts.
     *
     * @return A copy of this metadata, with the given transformer applied to all artifacts.
     */

public interface ManagedExecutor extends AsyncStoppable, ExecutorService {
    /**
     * Stops accepting new jobs and blocks until all currently executing jobs have been completed.
     */
    @Override
    void stop();

    /**
     * Stops accepting new jobs and blocks until all currently executing jobs have been completed. Once the given
     * timeout has been reached, forcefully stops remaining jobs and throws an exception.

        try {
            oos.writeObject(message);
        } finally {
            oos.flush();
        }
    }

    /**
     * Read back an object from the provided stream that has been serialized by a call to {@link #send(Object, java.io.OutputStream)}. Any {@link Throwable} that cannot be de-serialized (for whatever
     * reason) will be replaced by a {@link PlaceholderException}.
     *

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Marks a type or a whole package as providing a non-null API by default.
 *
 * All parameter and return types are assumed to be {@link Nonnull} unless specifically marked as {@link Nullable}.
 *
 * All types of an annotated package inherit the package rule.
 * Subpackages do not inherit nullability rules and must be annotated.
 *
 * @since 4.2
 */

import java.util.regex.Pattern;

import static org.gradle.util.internal.GroovyDependencyUtil.groovyModuleDependency;

public class GroovyJarFile {
    private static final Pattern FILE_NAME_PATTERN = Pattern.compile("(groovy(?:-all)?)-(\\d.*?)(-indy)?.jar");

    private final File file;
    private final Matcher matcher;

    private GroovyJarFile(File file, Matcher matcher) {
        this.file = file;
        this.matcher = matcher;
    }

import com.google.common.collect.ImmutableList;
import org.gradle.api.artifacts.ResolveException;

import java.util.List;

/**
 * An internal specialization of the public {@link ResolveException}. All resolve exceptions thrown
 * by Gradle are assumed to be an instance of this class.
 */
public class TypedResolveException extends ResolveException {
    private final String type;

        then:
        0 * _._
    }

    def "runs cleanup action when it is due"() {
        when:
        store.open()
        store.close()

        then:
        0 * _  // Does not call initialization or cleanup action.
        gcFile.assertIsFile()

        when:
        markCacheForCleanup(gcFile)
        def modificationTimeBefore = gcFile.lastModified()
        store.open()

    /**
     * Returns a display name for this worker process.
     */
    String getDisplayName();

    /**
     * Returns the connection which can be used to send/receive messages to/from the server process. Call {@link ObjectConnection#connect()} to complete the connection.
     */
    ObjectConnection getServerConnection();

    ClassLoader getApplicationClassLoader();

    ServiceRegistry getServiceRegistry();