println "configuring \$project.path"
            classes.doLast { t ->
                println "classes of \$t.path"
            }
        """

        when:
        execute(buildA, ":assemble")

        then:
        outputContains("> Configure project :buildB:buildSrc")
        result.groupedOutput.task(":buildB:buildSrc:classes").output.contains("classes of :classes")

        where:

    TestFile sourceFile(String path);

    TestFile resourceFile(String path);

    void manifestAttributes(Map<String, String> attributes);

    void preserveTimestamps(boolean preserveTimestamps);

    void buildJar(File jarFile);

}

var passAnalyzersToVet = map[string]bool{
	"appends":          true,
	"asmdecl":          true,
	"assign":           true,
	"atomic":           true,
	"bool":             true,
	"bools":            true,
	"buildtag":         true,
	"buildtags":        true,
	"cgocall":          true,
	"composites":       true,
	"copylocks":        true,
	"defers":           true,
	"directive":        true,
	"errorsas":         true,

		option := fuzz.Struct[Option](fg)
		b := New(bundle, push, policies, option)
		if b == nil {
			fg.T().Skip()
			return // To help linter
		}
		b.BuildTCP()
	})
}

func validatePush(in *model.PushContext) bool {
	if in == nil {
		return false
	}
	if in.AuthzPolicies == nil {
		return false
	}
	return true

    @Override
    public void jar(File jarFile, Action action) {
        try {
            buildJar(jarFile, action);
        } catch (Exception e) {
            throw new GradleException(String.format("Failed to create Jar file %s.", jarFile), e);
        }
    }

    private static void buildJar(File jarFile, Action action) throws IOException {
        Files.createDirectories(jarFile.getParentFile().toPath());

echo "istio.io/istio/pkg/version.buildGitRevision=${BUILD_GIT_REVISION}"
echo "istio.io/istio/pkg/version.buildStatus=${tree_status}"
echo "istio.io/istio/pkg/version.buildTag=${GIT_DESCRIBE_TAG}"
echo "istio.io/istio/pkg/version.buildHub=${HUB}"
echo "istio.io/istio/pkg/version.buildOS=${BUILD_GOOS}"

                    return null;
                }
            }
        """
        def jar = temporaryFolder.file("work folder", "action-impl.jar")
        builder.buildJar(jar)

        when:
        def classloader = new URLClassLoader([jar.toURL()] as URL[], getClass().classLoader)
        def action = classloader.loadClass("ActionImpl").getConstructor().newInstance()

package comment, and only in package main or *_test.go files.

Support for other known directives may be added in the future.

This analyzer does not check //go:build, which is handled by the
buildtag analyzer.
`

var Analyzer = &analysis.Analyzer{
	Name: "directive",
	Doc:  Doc,
	URL:  "https://pkg.go.dev/golang.org/x/tools/go/analysis/passes/directive",
	Run:  runDirective,
}

		if err != nil {
			t.Fatal(err)
		}
		ln, err := ListenUnix("unix", ta)
		if err != nil {
			t.Fatal(err)
		}
		ls := (&streamListener{Listener: ln}).newLocalServer()
		defer ls.teardown()
		if err := ls.buildup(handler); err != nil {
			t.Fatal(err)
		}

		la, err := ResolveUnixAddr("unix", laddr)
		if err != nil {
			t.Fatal(err)
		}
		c, err := DialUnix("unix", la, ta)
		if err != nil {
			t.Fatal(err)
		}

			}

			ls := newLocalServer(t, network)
			defer ls.teardown()
			ch := make(chan error, 1)
			handler := func(ls *localServer, ln Listener) { ls.transponder(ln, ch) }
			if err := ls.buildup(handler); err != nil {
				t.Fatal(err)
			}
			if ls.Listener.Addr().Network() != network {
				t.Fatalf("got %s; want %s", ls.Listener.Addr().Network(), network)
			}