manager.withPlugin("plugin") { applied << it }

        then:
        applied.empty

        when:
        def dir = testDirectoryProvider.createDir("other")
        groovyLoader.addURL(dir.toURI().toURL())
        addPluginId(dir, "plugin", pluginClass)
        manager.apply(pluginClass)

        then:
        applied.size() == 1

        when:

    }

    def "does not render hint for successful build without applied plugin"() {
        given:
        buildFile << """
            task $DUMMY_TASK_NAME
        """

        when:
        succeeds(DUMMY_TASK_NAME)

        then:
        result.assertNotOutput(SCAN)
    }

    def "renders hint for failing build without applied plugin and #description"() {
        given:

        mavenRepo.module("org", "foo", '1.1').publish()
        mavenRepo.module("org", "bar", '1.0').dependsOn(foo11).publish()
    }

    void "force resolution strategy is applied to dependency constraints"() {
        given:
        buildFile << """
            dependencies {
                conf 'org:bar:1.0'
                constraints {
                    conf 'org:foo:1.1'

// expected-remark@below {{Tac filter (1) specified but not applied to any op}}
// expected-remark@below {{Tac filter (2): filter type: op filter, filter_pattern: "^test_op"}}
// expected-remark@below {{Tac filter (2) specified but not applied to any op}}
module {
  // CHECK-LABEL: testFunctionSkiped
  // expected-remark@+1 {{filtered by tac filter (0)}}

		change.previous = cache.getEndpointsMap(serviceNN, esTracker.applied)

		for name, sliceData := range esTracker.pending {
			if sliceData.remove {
				delete(esTracker.applied, name)
			} else {
				esTracker.applied[name] = sliceData
			}

			delete(esTracker.pending, name)
		}

		change.current = cache.getEndpointsMap(serviceNN, esTracker.applied)
		changes[serviceNN] = change
	}

	return changes

        precompiledGroovyPluginBuiltWith(version(getCurrent()))

        when:
        def result = pluginTaskExecutedWith(version(getPrevious())).run()

        then:
        result.output.contains("$PLUGIN_ID applied")
        result.output.contains("$PLUGIN_TASK executed")
    }

    def "precompiled Groovy plugin built with Gradle 6.4+ can be used with current Gradle version"() {

     * The Kotlin DSL provider handles this in isolation,
     * thus hiding the location of exceptions thrown by groovy scripts applied from kotlin scripts.
     *
     * This test exercises the current behavior.
     */
    @Test
    fun `location of exception thrown by groovy script applied from kotlin script shadowed by the kotlin location`() {

        val kotlinScript = withBuildScript("""apply(from = "other.gradle")""")

    /**
     * Executes or registers an action for a plugin with given id.
     * If the plugin was already applied, the action is executed.
     * If the plugin is applied sometime later the action will be executed after the plugin is applied.
     * If the plugin is never applied, the action is never executed.
     * The behavior is similar to {@link #withType(Class, org.gradle.api.Action)}.
     *

import org.gradle.api.Action;
import org.gradle.internal.HasInternalProtocol;

/**
 * Represents a container for component selection rules.  Rules can be applied as part of the
 * resolutionStrategy of a configuration and individual components can be explicitly accepted
 * or rejected by rule.  Components that are neither accepted or rejected will be subject to
 * the default version matching strategies.
 *
 * <pre class='autoTested'>
 *     configurations {

         * the set of [auto-applied plugins][org.gradle.plugin.management.internal.autoapply.AutoAppliedPluginHandler].
         */
        object ApplyDefaultPluginRequests : StageTransition, Instruction()

        /**
         * Causes the target scope to be closed by applying the plugin requests collected during the execution