then:
        result.assertOutputContains("My gradle plugin applied!")
        result.assertOutputContains("My settings plugin applied!")
        result.assertOutputContains("settings pluginManagement {}")
        if (supportsSettingsPluginsBlock) {
            result.assertOutputContains("settings plugins {}")
        }
        result.assertOutputContains("My project plugin applied!")
        result.assertOutputContains("My task executed!")
    }

        given:
        scanPlugin.collectConfig = applied

        when:
        succeeds "t"

        then:
        output.contains("buildScan plugin applied: ${applied}")
        if (applied) {
            with(scanPlugin.attributes(output)) {
                isTaskExecutingBuild()
            }
        }

        where:
        applied << [true, false]

        when:
        succeeds("help")
        then:
        outputContains("test-plugin applied to :buildSrc")
        outputContains("test-plugin applied to :")
    }

    private void writePluginTo(TestFile projectDir) {
        def pluginBuilder = new PluginBuilder(projectDir)
        pluginBuilder.addPlugin("println 'test-plugin applied to ' + project.gradle.publicBuildPath.buildPath")
        pluginBuilder.prepareToExecute()
    }

		return nil, fmt.Errorf("failed to convert last applied to typed: %v", err)
	}

	lastAppliedObjFieldSet, err := lastAppliedObjTyped.ToFieldSet()
	if err != nil {
		return nil, fmt.Errorf("failed to create fieldset for last applied object: %v", err)
	}

	comparison, err := lastAppliedObjTyped.Compare(liveObjTyped)
	if err != nil {
		return nil, fmt.Errorf("failed to compare last applied object and live object: %v", err)
	}

                    """
                )
                withFile(
                    "src/main/kotlin/my-plugin.settings.gradle.kts",
                    """
                        plugins {
                            id("base-plugin")
                        }
                        println("my-plugin settings plugin applied")
                    """
                )

        }

        void assertSettingsPluginApplied() {
            outputContains("$settingsPluginId applied")
        }

        void assertSettingsPluginNotApplied() {
            outputDoesNotContain("$settingsPluginId applied")
        }

        void assertProjectPluginApplied() {
            outputContains("$projectPluginId applied")
        }

        void assertProjectPluginNotApplied() {

        then:
        wrapper.generated()
    }

    def "can use camel-case for dynamically applied wrapper plugin "() {
        when:
        run taskName
        then:
        wrapper.generated()
        where:
        taskName << ["wrapp"]//, "wrap", "w"]
    }

    def "wrapper plugin not applied on subprojects"() {
        setup:
        settingsFile << "include 'moduleA'"

        then:
        plugin.assertAutoApplied(output, true)
        outputContains("${plugin.id} is already applied")
    }

    @ToBeImplemented("https://github.com/gradle/gradle/issues/24884")
    def "is not auto-applied when --scan is used and applied via init script in beforeSettings"() {
        given:
        def pluginArtifactId = "com.gradle:develocity-gradle-plugin:${plugin.runtimeVersion}"

            throw new GradleException("The Java plugin must be applied to access the java component.");
        }

        return (JvmSoftwareComponentInternal) component;
    }

    /**
     * Gets the default test suite. This method assumes the Java plugin is applied.
     *
     * @throws GradleException If the default test suite does not exist.
     */

			applied = true
		} else if lp.Operation == networking.EnvoyFilter_Patch_INSERT_AFTER {
			// Insert after without a filter match is same as ADD in the end
			if !hasListenerFilterMatch(lp) {
				lis.ListenerFilters = append(lis.ListenerFilters, proto.Clone(lp.Value).(*listener.ListenerFilter))
				applied = true
				continue
			}
			lis.ListenerFilters, applied = insertAfterFunc(