*/
    Plain,
    /**
     * Enable color and rich output when the current process is attached to a console, disable when not attached to a console.
     */
    Auto,
    /**
     * Enable color and rich output, regardless of whether the current process is attached to a console or not.
     * When not attached to a console, the color and rich output is encoded using ANSI control characters.
     */
    Rich,
    /**

public enum ConsoleAttachment {
    NOT_ATTACHED("not attached to a console", null),
    ATTACHED("console attached to both stdout and stderr", TestConsoleMetadata.BOTH),
    ATTACHED_STDOUT_ONLY("console attached to stdout only", TestConsoleMetadata.STDOUT_ONLY),
    ATTACHED_STDERR_ONLY("console attached to stderr only", TestConsoleMetadata.STDERR_ONLY);

    private final String description;

	newAttachment := va.DeepCopy()
	newAttachment.Status.Attached = true
	Strategy.PrepareForUpdate(context.TODO(), newAttachment, va)
	if newAttachment.Status.Attached {
		t.Errorf("expected status to be %v got %v", false, newAttachment.Status.Attached)
	}
}

func TestCreatePreventsStatusWrite(t *testing.T) {
	va := getValidVolumeAttachment("valid-attachment")
	va.Status.Attached = true
	Strategy.PrepareForCreate(context.TODO(), va)

     *
     * @throws EOFException when the end of the byte stream is reached before the long value can be fully read.
     */
    long readLong() throws EOFException, IOException;

    /**
     * Reads a signed 64 bit int value. Can read any value that was written using {@link Encoder#writeSmallLong(long)}.
     *
     * @throws EOFException when the end of the byte stream is reached before the int value can be fully read.
     */

            ProjectConnection connection ->
                connection.model(BuildInvocations).forTasks('assemble').addProgressListener(events).get()
        }

        then: "progress events must be forwarded to the attached listeners"
        events.assertIsABuild()
    }

    def "receive progress events when launching a build"() {
        given:
        goodCode()

        when: "launching a build"

        if (consoleMetaData.isStdOut() && consoleMetaData.isStdErr()) {
            // Redirect stderr to stdout when both stdout and stderr are attached to a console. Assume that they are attached to the same console
            // This avoids interleaving problems when stdout and stderr end up at the same location
            Console console = consoleFor(stdout, consoleMetaData, renderer.getColourMap());

   * Object#toString}.
   *
   * <p>If the target method call finishes before the limit is reached, the return value or
   * exception is propagated to the caller exactly as-is. If, on the other hand, the time limit is
   * reached, the proxy will attempt to abort the call to the target, and will throw an {@link
   * UncheckedTimeoutException} to the caller.
   *

         *
         * @param relativePathSupplier provides the relative path from the visited location to the path with the attached values.
         */
        void visitChildren(PersistentList<T> values, Supplier<String> relativePathSupplier);
    }

    /**
     * Returns a new {@link ValuedVfsHierarchy} with the value attached to the location.
     */
    @CheckReturnValue

    def "returns null when neither stdout or stderr is attached to console"() {
        given:
        terminals.isTerminal(Terminals.Output.Stdout) >> false
        terminals.isTerminal(Terminals.Output.Stderr) >> false

        expect:
        detector.console == null
    }

    @Requires(UnitTestPreconditions.SmartTerminalAvailable)
    def "returns metadata when stdout and stderr are attached to console"() {
        given:

	panic("should not be reached")
}

func (mfc *monitorFakeCmd) SetStdout(out io.Writer) {
	panic("should not be reached")
}

func (mfc *monitorFakeCmd) SetStderr(out io.Writer) {
	panic("should not be reached")
}

func (mfc *monitorFakeCmd) SetEnv(env []string) {
	panic("should not be reached")
}

func (mfc *monitorFakeCmd) StdoutPipe() (io.ReadCloser, error) {
	panic("should not be reached")
}