"""
        settingsFile << """
        """

        when:
        def runner = GradleRunner.create()
        runner.withJvmArguments("-javaagent:${agentJar}")
        if (!GradleContextualExecuter.embedded) {
            runner.withGradleInstallation(buildContext.gradleHomeDir)
        }
        runner.withArguments("--configuration-cache")
        runner.forwardOutput()
        runner.withProjectDir(testDirectory)

// license that can be found in the LICENSE file.

//go:build !goexperiment.staticlockranking

package runtime

const staticLockRanking = false

// // lockRankStruct is embedded in mutex, but is empty when staticklockranking is
// disabled (the default)
type lockRankStruct struct {
}

func lockInit(l *mutex, rank lockRank) {
}

func getLockRank(l *mutex) lockRank {
	return 0
}

//go:build go1.13

package p

import "io"

// A "duplicate method" error should be reported for
// all these interfaces, irrespective of which package
// the embedded Reader is coming from.

type _ interface {
	Reader
	Reader // ERROR "duplicate method Read"
}

type Reader interface {
	Read(p []byte) (n int, err error)
}

type _ interface {
	io.Reader

	// False does not mean to activate pruning.
	XPreserveUnknownFields bool

	// x-kubernetes-embedded-resource defines that the value is an
	// embedded Kubernetes runtime.Object, with TypeMeta and
	// ObjectMeta. The type must be object. It is allowed to further
	// restrict the embedded object. Both ObjectMeta and TypeMeta
	// are validated automatically. x-kubernetes-preserve-unknown-fields
	// must be true.

  quay.io/minio/minio server /data --console-address ":9001"
```

The MinIO deployment starts using default root credentials `minioadmin:minioadmin`. You can test the deployment using the MinIO Console, an embedded
object browser built into MinIO Server. Point a web browser running on the host machine to <http://127.0.0.1:9000> and log in with the

        false              | true                || false
    }

    @Requires(
        value = IntegTestPreconditions.IsEmbeddedExecutor,
        reason = "Tests the embedded distribution"
    )
    def "daemon spawned from embedded runner has agent enabled"() {
        given:
        executer.tap {
            // Force a separate daemon spawned by the InProcessGradleExecuter
            requireDaemon()

        isEnabled = false
    }
}


private
fun IntegrationTest.setUpAgentIfNeeded(testType: TestType, executer: String) {
    if (executer == "embedded") {
        // Apply the instrumentation agent to the test process when running integration tests with embedded Gradle executer.
        jvmArgumentProviders.add(project.objects.newInstance<AgentsClasspathProvider>().apply {

        attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, project.objects.named("gradle-local-repository"))
        attribute(Bundling.BUNDLING_ATTRIBUTE, project.objects.named(Bundling.EMBEDDED))
    }
    extendsFrom(testRepo.get())
}

dependencies {
    testRepo(project(":public-api"))
    integTestDistributionRuntimeOnly(project(":distributions-jvm"))
}

		},
		want: `{"X":6}`,
	}, {
		// Unexported embedded field of non-struct type should not be serialized.
		CaseName: Name("UnexportedEmbeddedInt"),
		makeInput: func() any {
			type (
				myInt int
				S     struct{ myInt }
			)
			return S{5}
		},
		want: `{}`,
	}, {
		// Exported embedded field of non-struct type should be serialized.
		CaseName: Name("ExportedEmbeddedInt"),

		// change the value in-process because runtime.GOROOT uses the value from
		// initial (not current) environment. Spawn a subprocess to determine the
		// real baked-in GOROOT.
		t.Logf("found GOROOT %q from environment; checking embedded GOROOT value", envGoroot)
		testenv.MustHaveExec(t)
		exe, err := os.Executable()
		if err != nil {
			t.Fatal(err)
		}
		cmd := exec.Command(exe)