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

class TapiAgentInstrumentationCrossVersionSpec extends ToolingApiSpecification {
    private String buildOutput

    def setup() {
        // TODO(mlopatkin) Figure a way to have agent-based instrumentation in the embedded TAPI mode.
        toolingApi.requireDaemons()
    }

    def "agent is enabled in TAPI by default"() {
        withDumpAgentStatusTask()

        when:
        runDumpTaskWithTapi()

        then:

        try {
            toolingApi.withConnection {
                action.execute(it)
            }
        } finally {
            if (GradleContextualExecuter.embedded) {
                System.getProperties().clear()
                System.getProperties().putAll(systemPropertiesBeforeInvocation)
            }
        }
    }

    @Override

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

// TODO De-duplicate this
/**
 * Tasks that are called by the (currently separate) promotion build running on CI.
 */
tasks.register("promotionBuild") {

                            }
                        }
                    }
                }
            """
            file('build.gradle.kts') << """
                plugins {
                    `embedded-kotlin`
                    `java-gradle-plugin`
                }
                gradlePlugin {
                    plugins {
                        create("gradleDevelocityConventions") {

        }

        private GradleRunner createRunner() {
            def runner = GradleRunner.create()
            if (!GradleContextualExecuter.embedded) {
                runner.withGradleInstallation(buildContext.gradleHomeDir)
            }
            runner.withTestKitDir(testKitDir)
            runner.withProjectDir(workingDir)
            def args = allArgs

  <parent>
    <groupId>org.apache.maven</groupId>
    <artifactId>maven</artifactId>
    <version>4.0.0-beta-4-SNAPSHOT</version>
  </parent>

  <artifactId>maven-embedder</artifactId>

  <name>Maven Embedder</name>
  <description>Maven embeddable component, with CLI and logging support.</description>

  <dependencies>
    <dependency>
      <groupId>org.apache.maven</groupId>

        }
    }
}
val releasedVersions = moduleIdentity.releasedVersions.orNull

fun createQuickFeedbackTasks() {
    val testType = TestType.CROSSVERSION
    val defaultExecuter = "embedded"
    val prefix = testType.prefix
    testType.executers.forEach { executer ->
        val taskName = "$executer${prefix.capitalize()}Test"
        val testTask = createTestTask(taskName, executer, sourceSet, testType) {

 * When running with the daemon, success is dependent on DaemonConnector forking the daemon process with the right classpath.
 *
 * This test is not meaningful when running the embedded integration test mode, so we ignore it in that case.
 */
class SystemClassLoaderTest extends AbstractIntegrationSpec {

    static heading = "systemClassLoader info"
    static noInfoHeading = "no systemClassLoader info"

	c.FuzzNoCustom(obj)

	// Pinning values for fields that get defaults if fuzz value is empty string or nil (thus making the round trip test fail)

	// Avoid round tripping the ClusterConfiguration embedded in the InitConfiguration, since it is
	// only present in the internal version and not in public versions
	obj.ClusterConfiguration = kubeadm.ClusterConfiguration{}