}

    def "can group standard output streams with task if configured"() {
        given:
        buildFile << testLoggingStandardStream()

        file(JAVA_TEST_FILE_PATH) << javaTestClass {
            """
                System.out.println("standard output");
                System.err.println("standard error");
            """
        }

        when:

[short] skip

# Listing GOROOT should only find standard packages.
cd $GOROOT/src
go list -f '{{if not .Standard}}{{.ImportPath}}{{end}}' ./...
! stdout .

# Standard packages should include cmd, but not cmd/vendor.
go list ./...
stdout cmd/compile
! stdout vendor/golang.org
! stdout cmd/vendor

# In GOPATH mode, packages vendored into GOROOT should be reported as standard.
go list -f '{{if .Standard}}{{.ImportPath}}{{end}}' std cmd

		}

		if errno != EBADF {
			print("runtime: unexpected error while checking standard file descriptor ", i, ", errno=", errno, "\n")
			throw("cannot open standard fds")
		}

		if ret := open(&devNull[0], O_RDWR, 0); ret < 0 {
			print("runtime: standard file descriptor ", i, " closed, unable to open /dev/null, errno=", errno, "\n")
			throw("cannot open standard fds")
		} else if ret != int32(i) {

          listOf(TLS_1_3, TLS_1_2).flatMap { tlsVersion ->
            listOf(Channel, Standard).flatMap { socketMode ->
              listOf(DISABLED, STANDARD).map { tlsExtensionMode ->
                TlsInstance(provider, protocol, tlsVersion, socketMode, tlsExtensionMode)
              }
            }
          }
        }
      } + Channel + Standard
  }
}

sealed class SocketMode

object Channel : SocketMode() {

    | org.gradle.usage               | java-runtime | java-runtime |
    | org.gradle.dependency.bundling |              | external     |
    | org.gradle.jvm.environment     |              | standard-jvm |
    | org.gradle.jvm.version         |              | 11           |

io.vertx:vertx-lang-groovy:3.9.4
\--- runtimeClasspath

io.vertx:vertx-lang-groovy-gen:3.9.4
  Variant runtime:

@HasInternalProtocol
public interface LoggingOutput {
    /**
     * Adds a listener which receives output written to standard output by the Gradle logging system.
     *
     * @param listener The listener to add.
     */
    void addStandardOutputListener(StandardOutputListener listener);

    /**
     * Removes a listener from standard output.
     *
     * @param listener The listener to remove.
     */

    | org.gradle.usage               | java-runtime | java-runtime |
    | org.gradle.dependency.bundling |              | external     |
    | org.gradle.jvm.environment     |              | standard-jvm |
    | org.gradle.jvm.version         |              | 11           |

io.vertx:vertx-lang-groovy:3.9.4
\--- runtimeClasspath

io.vertx:vertx-lang-groovy-gen:3.9.4
  Variant runtime:

    @Override
    public BaseExecSpec setStandardInput(InputStream inputStream) {
        throw new UnsupportedOperationException("Standard streams cannot be configured for exec output provider");
    }

    @Override
    public InputStream getStandardInput() {
        throw new UnsupportedOperationException("Standard streams cannot be configured for exec output provider");
    }

    @Override

        then:
        expectAndroid()
    }

    def "prefers standard JVM variant by default"() {
        given:
        prepareResolve('legacy', 'jre')

        when:
        run ':checkDeps'

        then:
        expectStandardJVM()
    }

    def "can enforce standard JVM variant on Android by constraint"() {
        given:

    /**
     * Creates a {@code StyledTextOutput} with the given category and the standard output log level.
     *
     * @param logCategory The log category.
     * @return the output
     */
    StyledTextOutput create(String logCategory);

    /**
     * Creates a {@code StyledTextOutput} with the given category and the standard output log level.
     *
     * @param logCategory The log category.
     * @return the output