public void setUp() {
    sink = new TestCharSink();
  }

  public void testOpenBufferedStream() throws IOException {
    Writer writer = sink.openBufferedStream();
    assertTrue(sink.wasStreamOpened());
    assertFalse(sink.wasStreamClosed());

    writer.write(STRING);
    writer.close();

    assertTrue(sink.wasStreamClosed());
    assertThat(sink.getString()).isEqualTo(STRING);
  }

                    writer.println("<h3>In $project</h3>")
                    writer.println("<ul>")
                    problems.forEach {
                        writer.println("   <li>${it.name.escape()}</li>")
                    }
                    writer.println("</ul>")
                }
            }
            writer.println("</body></html>")
        }
    }

    private

    }

    return result
  }

  override fun toDer(
    writer: DerWriter,
    value: T,
  ) {
    if (typeHint) {
      writer.typeHint = value
    }

    if (isOptional && value == defaultValue) {
      // Nothing to write!
      return
    }

    writer.write(name, tagClass, tag) {
      codec.encode(writer, value)
    }
  }

  /**

        try {
            Files.createDirectories(resumeProperties.getParent());
            try (Writer writer = Files.newBufferedWriter(resumeProperties)) {
                properties.store(writer, null);
            }
        } catch (IOException e) {
            String message = "Could not create " + RESUME_PROPERTIES_FILENAME + " file.";

        String encrypted = context.reader.readLine("Enter the password to decrypt: ");
        if (secDispatcher.isAnyEncryptedString(encrypted)) {
            context.terminal.writer().println(secDispatcher.decrypt(encrypted));
            return OK;
        } else {
            context.terminal.writer().println(messageBuilderFactory.builder().error("Malformed encrypted string"));

// implementation which is buggy on NUMA systems, we have to use a simpler
// io.Writer implementation alone avoids also unnecessary buffer copies,
// and as such incurred latencies.
var Discard io.Writer = discard{}

// discard is /dev/null for Golang.
type discard struct{}

func (discard) Write(p []byte) (int, error) {
	return len(p), nil
}

// DiscardReader discarded reader

import org.codelibs.fess.suggest.exception.SuggestIndexException;
import org.codelibs.fess.suggest.index.SuggestIndexResponse;
import org.codelibs.fess.suggest.index.writer.SuggestWriter;
import org.codelibs.fess.suggest.index.writer.SuggestWriterResult;
import org.codelibs.fess.suggest.settings.SuggestSettings;
import org.opensearch.transport.client.Client;

/**
 * Internal operations class for core indexing functionality.

        if (!context.interactive) {
            context.terminal.writer().println("This tool works only in interactive mode!");
            context.terminal
                    .writer()
                    .println("Tool purpose is to configure password management on developer workstations.");
            context.terminal
                    .writer()
                    .println(

    Reader reader = source.openStream();

    StringWriter writer = new StringWriter();
    char[] buf = new char[64];
    int read;
    while ((read = reader.read(buf)) != -1) {
      writer.write(buf, 0, read);
    }
    reader.close();
    writer.close();

    assertExpectedString(writer.toString());
  }

  public void testOpenBufferedStream() throws IOException {

    @Override
    public void write(Writer output, Map<String, Object> options, PersistedToolchains toolchains) throws IOException {
        Objects.requireNonNull(output, "output cannot be null");
        Objects.requireNonNull(toolchains, "toolchains cannot be null");

        try (Writer out = output) {
            new MavenToolchainsStaxWriter().write(out, toolchains.getDelegate());