then:
        executed(":producer", ":consumer")

        where:
        disabledTask << ["consumer", "producer"]
    }

    def "takes filters for inputs into account when detecting missing dependencies"() {
        file("src/main/java/MyClass.java").createFile()
        buildFile """
            task producer {
                def outputFile = file("build/output.txt")

// ok: attached to f (duplicated yes, but ok)
//go:noinline

//go:noinline
func f() {
	//go:noinline // ERROR "misplaced compiler directive"
	x := 1

	//go:noinline // ERROR "misplaced compiler directive"
	{
		_ = x //go:noinline // ERROR "misplaced compiler directive"
	}
	var y int //go:noinline // ERROR "misplaced compiler directive"
	//go:noinline // ERROR "misplaced compiler directive"
	_ = y

    protected final Map<Pattern, Directive> directiveMap = new LinkedHashMap<>();

    private final List<String> sitemapList = new ArrayList<>();

    public boolean allows(final String path, final String userAgent) {
        final Directive directive = getMatchedDirective(userAgent);
        if (directive == null) {
            return true;
        }
        return directive.allows(path);
    }

                    if (value != null) {
                        if (!currentDirectiveList.isEmpty() && value.length() > 0) {
                            for (final Directive directive : currentDirectiveList) {
                                directive.addDisallow(value);
                            }
                        }
                    } else if ((value = getValue(ALLOW_RECORD, line)) != null) {

import org.gradle.integtests.fixtures.ToBeFixedForConfigurationCache
import org.gradle.test.fixtures.plugin.PluginBuilder
import spock.lang.Issue

/**
 * Tests various aspects of detecting the existence of plugins by their ID.
 */
class PluginDetectionIntegrationTest extends AbstractIntegrationSpec {

    public static final List<String> JAVA_PLUGIN_IDS = ["java", "org.gradle.java"]

        useDirective(directive)

        then:
        found == ['test1', 'test2', 'test3', 'system1', 'system2', 'system3']

        where:
        directive << ["include", "import"]
    }

    def "ignores comment after directive"() {
        when:
        sourceFile << """
#include "test1"  // A comment here
#include "test2" /* A comment here */
#include "test3" /*
   A comment here
*/

      }

      when {
        "no-cache".equals(directive, ignoreCase = true) -> {
          noCache = true
        }
        "no-store".equals(directive, ignoreCase = true) -> {
          noStore = true
        }
        "max-age".equals(directive, ignoreCase = true) -> {
          maxAgeSeconds = parameter.toNonNegativeInt(-1)
        }
        "s-maxage".equals(directive, ignoreCase = true) -> {

like in Go imports.

	use (
	  ../foo/bar
	  ./baz
	)

The use directive specifies a module to be included in the workspace's
set of main modules. The argument to the use directive is the directory
containing the module's go.mod file.

The go directive specifies the version of Go the file was written at. It
is possible there may be future changes in the semantics of workspaces

        installations[0].source == "testSource"
    }

    def "detecting installations is tracked as build operation"() {
        given:
        def registry = createRegistry([])

        when:
        registry.listInstallations()

        then:
        operations.log.getDescriptors().find { it.displayName == "Toolchain detection" }
    }

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
  - 36961
releaseNotes:
  - |