BaseBuildScanPluginCheckInFixture getTransitivePluginFixture() {
            // Develocity plugin is auto-applied but the Gradle Enterprise plugin is a transitive dependency
            gradleEnterpriseFixture
        }

        @Override
        void assertNotAutoApplied(String output) {
            // Develocity plugin is applied neither as a transitive dependency, nor via auto-application mechanism as Gradle Enterprise plugin is present

        when:
        gradleEnterpriseFixture.publishDummyPlugin(executer)
        settingsFile << gradleEnterpriseFixture.plugins()

        and:
        runBuildWithScanRequest()

        then:
        pluginNotApplied()
    }

    def "does not auto-apply plugin when Gradle Enterprise plugin is applied using plugin class name"() {
        when:

                case ScriptDiscovery.DEFAULT:
                    return new ScriptChangeFixture(rootProjectDir, defaultScriptFile, buildArguments)
                case ScriptDiscovery.APPLIED:
                    String appliedScriptName = "applied${scriptFileExtension}"
                    TestFile appliedScriptFile = new TestFile(defaultScriptFile.parentFile, appliedScriptName)

A script plugin is an ad-hoc plugin, typically written and applied in the same build script.
It is applied using the <<sec:old_plugin_application,legacy application method>>:

[[sec:binary_plugin_example]]
[source, build.gradle.kts]
----
class MyPlugin : Plugin<Project> {
    override fun apply(project: Project) {
        println("Plugin ${this.javaClass.simpleName} applied on ${project.name}")
    }
}

apply<MyPlugin>()

    template: "This EnvoyFilter does not have a priority and has a relative patch operation set which can cause the EnvoyFilter not to be applied. Using the INSERT_FIRST of ADD option or setting the priority may help in ensuring the EnvoyFilter is applied correctly."

The difference between these types of plugins lies in the scope of their application:

Project Plugin :: A project plugin is a plugin that is applied to a specific project in a build.

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.instrumentation.api.types;

public enum BytecodeInterceptorType {

    /**
     * An interceptor that is applied to the bytecode always.
     */
    INSTRUMENTATION(

import javax.annotation.Nullable;

/**
 * Represents the target that a plugin should be applied to, such as a Gradle, Settings or Project object.
 * This is used to apply a plugin to a target in a way that is appropriate for that target, such as adding
 * additional functionality specific to the target or disallowing certain types of plugins to be applied.
 */
public interface PluginTarget {

    private AgentControl() {}

    /**
     * Checks if the instrumentation agent class is applied to the current JVM.
     *
     * @return {@code true} if the agent was applied
     */
    public static boolean isInstrumentationAgentApplied() {
        Method isAppliedMethod = findAgentMethod(INSTRUMENTATION_AGENT_CLASS_NAME, "isApplied");

var configDumpFile string

func checkCmd(ctx cli.Context) *cobra.Command {
	cmd := &cobra.Command{
		Use:   "check [<type>/]<name>[.<namespace>]",
		Short: "Check AuthorizationPolicy applied in the pod.",
		Long: `Check prints the AuthorizationPolicy applied to a pod by directly checking
the Envoy configuration of the pod. The command is especially useful for inspecting