testImplementation(libs.commonsIo)
    testImplementation(libs.nativePlatform) {
        because("Required for SystemInfo")
    }

    integTestImplementation(projects.messaging)
    // TODO: Make these available for all integration tests? Maybe all tests?
    integTestImplementation(libs.jetbrainsAnnotations)

    testFixturesApi(testFixtures(project(":language-jvm")))

    api(project(":core"))
    api(project(":core-api"))
    api(project(":dependency-management"))
    api(project(":file-temp"))
    api(projects.stdlibJavaExtensions)
    api(project(":logging-api"))
    api(project(":messaging"))
    api(project(":model-core"))
    api(project(":native"))
    api(project(":plugin-use"))
    api(project(":resources"))
    api(projects.serviceProvider)
    api(project(":snapshots"))

    api(libs.groovy)

    implementation(project(":file-collections"))
    implementation(project(":file-temp"))
    implementation(projects.instrumentationAgentServices)
    implementation(projects.io)
    implementation(project(":messaging"))
    implementation(project(":model-core"))
    implementation(project(":platform-jvm"))
    implementation(project(":serialization"))
    implementation(project(":time"))

    public static final String[] RUNTIME_MODULES = new String[]{
        "gradle-core-api",
        "gradle-core",
        "gradle-logging",
        "gradle-logging-api",
        "gradle-messaging",
        "gradle-base-asm",
        "gradle-base-services",
        "gradle-enterprise-logging",
        "gradle-enterprise-workers",
        "gradle-cli",
        "gradle-concurrent",
        "gradle-io",

        cleanup:
        acceptor?.stop()
        connection?.stop()
    }

    def "can receive message from peer after peer has closed connection"() {
        // This is a test to simulate the messaging that the daemon does on build completion, in order to validate some assumptions

        when:
        def acceptor = incomingConnector.accept({ ConnectCompletion event ->
            def conn = event.create(serializer)

        then:
        stdout.stdOut == ""
        stdout.stdErr.contains("--broken")
    }

    def "handles output after worker messaging services are stopped"() {
        when:
        execute(worker(new OutputOnShutdownHookProcess()))

        then:
        noExceptionThrown()
        stdout.stdOut.contains("Goodbye, world!")

  },
  {
    "name": "maven",
    "path": "platforms/software/maven",
    "unitTests": true,
    "functionalTests": true,
    "crossVersionTests": true
  },
  {
    "name": "messaging",
    "path": "platforms/core-runtime/messaging",
    "unitTests": true,
    "functionalTests": true,
    "crossVersionTests": false
  },
  {
    "name": "model-core",
    "path": "platforms/core-configuration/model-core",

        subproject("io")
        subproject("stdlib-java-extensions")
        subproject("launcher")
        subproject("logging")
        subproject("logging-api")
        subproject("messaging")
        subproject("native")
        subproject("process-services")
        subproject("serialization")
        subproject("service-provider")
        subproject("time")
        subproject("tooling-api-provider")

        //if it's really dead we should deregister it if it is not already deregistered.
        //if the daemon is not dead we might continue receiving from it (and try to find the bug in messaging infrastructure)
        LOGGER.error("The message received from the daemon indicates that the daemon has disappeared."
            + "\nBuild request sent: {}"

            moduleRegistry.getModule("gradle-logging-api").getImplementationClasspath().getAsURLs(),
            moduleRegistry.getModule("gradle-messaging").getImplementationClasspath().getAsURLs(),
            moduleRegistry.getModule("gradle-files").getImplementationClasspath().getAsURLs(),