Path path;
        OutputStream outputStream;
        Writer writer;
        T content;
        Function<Object, String> inputLocationFormatter;

        public XmlWriterRequestBuilder<T> path(Path path) {
            this.path = path;
            return this;
        }

        public XmlWriterRequestBuilder<T> outputStream(OutputStream outputStream) {
            this.outputStream = outputStream;

    public SystemLogger(@Nullable OutputStream out) {
        this(out, null);
    }

    public SystemLogger(@Nullable OutputStream out, @Nullable Level threshold) {
        this.out = new PrintWriter(toPsOrDef(out, System.err), true);
        this.threshold = Objects.requireNonNullElse(threshold, Level.INFO);
    }

    private PrintStream toPsOrDef(OutputStream outputStream, PrintStream def) {

import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.nio.charset.Charset;

/**
 * A destination to which bytes can be written, such as a file. Unlike an {@link OutputStream}, a
 * {@code ByteSink} is not an open, stateful stream that can be written to and closed. Instead, it
 * is an immutable <i>supplier</i> of {@code OutputStream} instances.
 *

            builder.field("test", "value");
            builder.endObject();
            return builder;
        };

        OutputStream outputStream = SearchEngineUtil.getXContentBuilderOutputStream(callback, XContentType.JSON);
        assertNotNull(outputStream);
        assertTrue(outputStream instanceof ByteArrayOutputStream);
    }

    @Test
    public void test_getXContentBuilderOutputStream_ioException() {

    }

    /**
     * Creates an OutputStream from an XContentBuilder using the provided callback function.
     *
     * @param func the callback function to build XContent
     * @param mediaType the media type for the content builder
     * @return an OutputStream containing the built content, or an empty ByteArrayOutputStream if an error occurs
     */

        assertDoesNotThrow(() -> outputStream.write(data, 0, -1)); // negative length, returns early
        assertDoesNotThrow(() -> outputStream.write(data, 0, 0)); // zero length, returns early

        // These should pass through to the underlying implementation
        assertDoesNotThrow(() -> outputStream.write(data, 0, 10)); // valid - will consume first mock (10)

     * @return the output stream, or null if not set
     */
    @Nullable
    OutputStream stdOut();

    /**
     * Returns the error stream to be used for the Maven execution.
     * If not set, {@link System#err} will be used by default.
     *
     * @return the error stream, or null if not set
     */
    @Nullable
    OutputStream stdErr();

    /**

        write(XmlWriterRequest.<T>builder().content(content).path(path).build());
    }

    default void write(@Nonnull T content, @Nonnull OutputStream outputStream) throws XmlWriterException {
        write(XmlWriterRequest.<T>builder()
                .content(content)
                .outputStream(outputStream)
                .build());
    }

    default void write(@Nonnull T content, @Nonnull Writer writer) throws XmlWriterException {

    }
  }

  /**
   * Wraps a {@code PrimitiveSink} as an {@link OutputStream}, so it is easy to {@link Funnel#funnel
   * funnel} an object to a {@code PrimitiveSink} if there is already a way to write the contents of
   * the object to an {@code OutputStream}.
   *
   * <p>The {@code close} and {@code flush} methods of the returned {@code OutputStream} do nothing,
   * and no method throws {@code IOException}.
   *

   * data written to it to the underlying {@link OutputStream}.
   *
   * <p>The {@link OutputStream} should not be written to before or after the hand-off.
   */
  // TODO(user): Evaluate whether it makes sense to always piggyback the computation of a
  // HashCode on an existing OutputStream, compared to creating a separate OutputStream that could
  // be (optionally) be combined with another if needed (with something like