JavadocOptionFileOption<?> localeOption = options.remove("locale");
                if (localeOption != null) {
                    localeOption.write(writerContext);
                }

                for (final String option : options.keySet()) {
                    options.get(option).write(writerContext);
                }

}

// NewWriter returns a new [Writer].
// Writes to the returned writer are compressed and written to w.
//
// It is the caller's responsibility to call Close on the [Writer] when done.
// Writes may be buffered and not flushed until Close.
//
// Callers that wish to set the fields in Writer.Header must do so before
// the first call to Write, Flush, or Close.
func NewWriter(w io.Writer) *Writer {

  private val path = mutableListOf<String>()

  /**
   * False unless we made a recursive call to [write] at the current stack frame. The explicit box
   * adapter can clear this to synthesize non-constructed values that are embedded in octet strings.
   */
  var constructed = false

  fun write(
    name: String,
    tagClass: Int,
    tag: Long,
    block: (BufferedSink) -> Unit,
  ) {

    }

    @Override
    public void write(int b) throws IOException {
        hasher.putByte((byte) b);
        out.write(b);
    }

    @Override
    public void write(byte[] bytes, int off, int len) throws IOException {
        hasher.putBytes(bytes, off, len);
        out.write(bytes, off, len);
    }

    public HashCode hash() {
        return hasher.hash();
    }

 */
public abstract class IoActions {

    /**
     * Gives a writer for the given file/encoding to the given write action, managing the streams.
     *
     * @param output The file to write to
     * @param encoding The character encoding to write with
     * @param action The action to write the actual content
     */

		instructionCount++
		if unsafe {
			unsafeCount++
		}

		// All the instructions inside the write barrier must be unpreemptible.
		if startedWB && !doneWB && !unsafe {
			t.Errorf("instruction %s must be marked unsafe, but isn't", parts[1])
		}

		// Detect whether we're in the write barrier.
		switch runtime.GOARCH {
		case "arm64":
			if parts[3] == "MOVWU" {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Make sure dead write barriers are handled correctly.

package main

func f(p **int) {
	// The trick here is to eliminate the block containing the write barrier,
	// but only after the write barrier branches are inserted.
	// This requires some delicate code.
	i := 0
	var b []bool
	var s string
	for true {

	n, err := w.Write([]byte("asdf"))
	if n != 4 || err != nil {
		t.Errorf("got %d, %v, want 4, nil", n, err)
	}
}

func TestSmallLitWidth(t *testing.T) {
	w := NewWriter(io.Discard, LSB, 2)
	if _, err := w.Write([]byte{0x03}); err != nil {
		t.Fatalf("write a byte < 1<<2: %v", err)
	}
	if _, err := w.Write([]byte{0x04}); err == nil {
		t.Fatal("write a byte >= 1<<2: got nil error, want non-nil")

// applied to the writer interface.
// LimitWriter returns a Writer that writes to w
// but stops with EOF after n bytes.
// The underlying implementation is a *LimitedWriter.
func LimitWriter(w io.Writer, n int64) io.Writer { return &LimitedWriter{w, n} }

// A LimitedWriter writes to W but limits the amount of
// data returned to just N bytes. Each call to Write
// updates N to reflect the new amount remaining.

	var buf strings.Builder
	w := NewWriter(bufio.NewWriter(&buf))
	d := w.DotWriter()
	n, err := d.Write([]byte("abc\n.def\n..ghi\n.jkl\n."))
	if n != 21 || err != nil {
		t.Fatalf("Write: %d, %s", n, err)
	}
	d.Close()
	want := "abc\r\n..def\r\n...ghi\r\n..jkl\r\n..\r\n.\r\n"
	if s := buf.String(); s != want {
		t.Fatalf("wrote %q", s)
	}
}

func TestDotWriterCloseEmptyWrite(t *testing.T) {
	var buf strings.Builder