* @since 4.5
 */
public enum WarningMode {
    /**
     * Show all warnings.
     */
    All(true),

    /**
     * Display a summary at the end of the build instead of rendering all warnings into the console output.
     */
    Summary(false),

    /**
     * No deprecation warnings at all.
     */
    None(false),

    /**
     * Show all warnings and fail the build if any warning present
     *

     */
    private final static Set<String> ALL = [PmdPlugin.DEFAULT_PMD_VERSION, '5.0.5', '5.1.1', '5.3.3', '6.0.0', '6.13.0', '7.0.0'].asImmutable()

    static Set<String> getSupportedVersionsByJdk() {
        if (JavaVersion.current() <= JavaVersion.VERSION_21) {
            ALL
        } else {
            VersionCoverage.versionsAtLeast(ALL, '7.0.0')
        }
    }

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

        repository.put('class1', value1)
        repository.put('class2', value2)
        Closure cl = Mock()

        when:
        repository.each(cl)

        then:
        1 * cl.call(['class1', value1] as Object[])
        1 * cl.call(['class2', value2] as Object[])
        0 * cl._
    }

    def canIterateOverClassesUsingAction() {
        TestDomainObject value1 = new TestDomainObject('a')

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.

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

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;
    }