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
 */

    /**
     * Adds an action to be called immediately before a project is evaluated.
     * <p>
     * The action will be applied to all projects configured in the current build. Due to `Isolated Projects`, a particular build might only configure a subset of all projects.
     *
     * @param action The action to execute.
     */
    void beforeProject(Action<? super Project> action);

        @ClosureParams(value = SimpleType, options = "InterceptorTestReceiver") Closure<?> call
    ) {
        def receiver = new InterceptorTestReceiver()
        def closure = instrumentedClasses.instrumentedClosure(call)
        if (shouldDelegate) {
            closure.delegate = receiver
            closure.call()
        } else {
            closure.call(receiver)
        }
        receiver.intercepted
    }

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();

 * * the source representations of the literal values (thus taking into account only the values),
 * * the error causes, thus considering all error nodes equal to each other but not to any other node.
 */
fun DeclarativeDocument.structurallyEqualsAsData(other: DeclarativeDocument): Boolean {
    fun ValueNode.structurallyEquals(other: ValueNode): Boolean = when (this) {

plugins {
    id 'groovy'
    id 'maven-publish'
}

version = '1.0.2'
group = 'org.gradle.sample'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.codehaus.groovy:groovy-all:3.0.21'
}

publishing {
    publications {
        library(MavenPublication) {
            from components.java
        }
    }
    repositories {
        maven {

        // System.nanoTime() can go backwards under some circumstances.
        // http://bugs.java.com/bugdatabase/view_bug.do?bug_id=6458294
        // This max() call ensures that we don't return negative durations.
        return Math.max(elapsedMillis, 0);
    }

    @Override
    public void reset() {
        startTime = timeSource.nanoTime();
    }