t.Errorf("replaceFunc: want %+v but got %+v", c.applied, applied)
			}

			// insertBeforeFunc
			got, applied = insertBeforeFunc(slices.Clone(c.input), f)
			if !slices.Equal(c.insertBefore, got) {
				t.Errorf("insertBeforeFunc: want %+v but got %+v", c.insertBefore, got)
			}
			if c.applied != applied {
				t.Errorf("insertBeforeFunc: want %+v but got %+v", c.applied, applied)
			}

			// insertAfterFunc

	for name, pmap := range envoyFilterStatusMap {
		for pt, applied := range pmap {
			if applied {
				envoyFilterStatus.With(nameType.Value(name)).With(patchType.Value(pt)).
					With(resultType.Value(string(Applied))).Record(1)
			} else {
				envoyFilterStatus.With(nameType.Value(name)).With(patchType.Value(pt)).
					With(resultType.Value(string(Applied))).Record(0)
			}
		}
	}

    def "detects that the build scan plugin has been [applied=#applied]"() {
        given:
        if (applied) {
            applyPlugin()
        }

        settingsFile << """
            println "present: " + services.get($GradleEnterprisePluginManager.name).present
        """

        when:
        succeeds "t"

        then:
        output.contains("present: ${applied}")

        where:

		t.Errorf("error applying object: %v", err)
	}

	lastApplied, err := getLastApplied(f.Live())
	if err != nil {
		t.Errorf("failed to get last applied: %v", err)
	}

	if lastApplied != originalLastApplied {
		t.Errorf("expected last applied annotation to be %q and NOT be updated, but got: %q", originalLastApplied, lastApplied)
	}

	if err := f.Apply(appliedObj, "kubectl", false); err != nil {

        agentStatusWas(true)
    }

    private void agentWasNotApplied() {
        agentStatusWas(false)
    }

    private void agentStatusWas(boolean applied) {
        assert buildOutput.contains("agent applied = $applied")
    }

    private void withAgentEnabledInProperties() {
        withAgentStatusInProperties(true)
    }

    private void withAgentDisabledInProperties() {

        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]

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

        }

        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'"