apply plugin: '$appliedBy'
            operations << "applied"

            assert plugins["$detectedBy"]
            assert plugins.getPlugin("$detectedBy")
            assert pluginManager.hasPlugin("$detectedBy")
            assert pluginManager.findPlugin("$detectedBy").id == "$detectedBy"

            task verify {
                doLast {
                    assert operations[0] == 'applying'

go test -fuzz=xxx -race -v
! stderr 'race detected during execution of test'

# Test with just race instrumentation enabled
go test -race -v
! stderr 'race detected during execution of test'

# Test with coverage and race instrumentation enabled, and a matching fuzz
# pattern
go test -fuzz=FuzzRace -race -v -fuzztime=200x
! stderr 'race detected during execution of test'

-- go.mod --
module test

[compiler:gccgo] skip # gccgo has no cover tool

! go test -n importmain/test
stderr 'not an importable package' # check that import main was detected
! go test -n -cover importmain/test
stderr 'not an importable package' # check that import main was detected

-- go.mod --
module importmain

go 1.16
-- ismain/main.go --
package main

import _ "importmain/test"

func main() {}
-- test/test.go --
package test

        failure.assertHasCause("""A cycle has been detected in model rule dependencies. References forming the cycle:
first
\\- Rules#first(String)
   \\- second
      \\- second { ... } @ build.gradle line 26, column 17
         \\- third
            \\- Rules#third(String)
               \\- first""")
    }

    def "cycles involving multiple rules of same phase are detected"() {
        when:
        buildScript '''

     | Detected by:        {description}TestSource{normal}

{identifier} + AdoptOpenJDK JRE 14+2{normal}
     | Location:           {description}path{normal}
     | Language Version:   {description}14{normal}
     | Vendor:             {description}AdoptOpenJDK{normal}
     | Architecture:       {description}archName{normal}
     | Is JDK:             {description}false{normal}

func (*testAEAD) Open(a, b, c, d []byte) ([]byte, error) { return []byte{}, nil }
func (*testAEAD) InAESPackage() bool                     { return true }

// Test the gcmAble interface is detected correctly by the cipher package.
func TestGCMAble(t *testing.T) {
	b := cipher.Block(&testBlock{})
	if _, ok := b.(gcmAble); !ok {
		t.Fatalf("testBlock does not implement the gcmAble interface")
	}

			mandatory[feature] = true
		}
		if flag, ok := mapping[feature]; ok {
			if !*flag {
				t.Errorf("feature '%v' not detected", feature)
			}
		} else {
			t.Logf("no entry for '%v'", feature)
		}
	}
	for k, v := range mandatory {
		if !v {
			t.Errorf("mandatory feature '%v' not detected", k)
		}
	}

# Basic switch should work.
env TESTGO_VERSION_SWITCH=switch
go version
stdout go1.21.99

# Toolchain target mismatch should be detected.
env TESTGO_VERSION_SWITCH=mismatch
! go version
stderr '^go: toolchain go1.21.1 invoked to provide go1.21.99$'

# Toolchain loop should be detected.
env TESTGO_VERSION_SWITCH=loop
! go version
stderr -count=10 '^go: switching from go1.21.1 to go1.21.99 \[depth 9[0-9]\]$'

     */
    public ImmutableList<String> getRebuildReasons() {
        return rebuildReasons;
    }

    /**
     * Returns changes detected between the execution state after the last execution and before the current execution.
     * Empty if changes couldn't be detected (e.g. because history was unavailable).
     */
    public Optional<ExecutionStateChanges> getChanges() {
        return Optional.ofNullable(executionStateChanges);

			Name:           "port_errors_total",
			Help:           "Number of errors detected on ports by the repair loop broken down by type of error: leak, repair, full, outOfRange, duplicate, unknown",
			StabilityLevel: metrics.ALPHA,
		},
		[]string{"type"},
	)
	// nodePortRepairReconcileErrors indicates the number of times the repair loop has failed to repair
	// the errors it detected.
	nodePortRepairReconcileErrors = metrics.NewCounter(