import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;

import org.codelibs.core.exception.IORuntimeException;

/**
 * {@link Writer}用のユーティリティクラスです。
 *
 * @author koichik
 */
public abstract class WriterUtil {

    /**
     * 指定のエンコーディングでストリームへ出力する{@link Writer}を作成します。
     *
     * @param os
     *            ストリーム。{@literal null}であってはいけません

	if len(mappedResp) > 0 {
		mresp, err := json.MarshalIndent(mappedResp, "", "  ")
		if err != nil {
			return nil, nil, err
		}
		_, _ = s.Writer.Write(mresp)
		_, _ = s.Writer.Write([]byte("\n"))
	}

	return w, fullStatus, nil
}

func xdsStatusPrintln(w io.Writer, status *xdsWriterStatus) error {
	_, err := fmt.Fprintf(w, "%v\t%v\t%v\t%v\t%v\t%v\t%v\t%v\t%v\n",
		status.proxyID, status.clusterID,

                throw new DictionaryException("Failed to write: " + oldItem + " -> " + item, e);
            }
        }

        public void write(final String line) {
            try {
                writer.write(line);
                writer.write(Constants.LINE_SEPARATOR);
            } catch (final IOException e) {
                throw new DictionaryException("Failed to write: " + line, e);
            }
        }

                throw new DictionaryException("Failed to write: " + oldItem + " -> " + item, e);
            }
        }

        public void write(final String line) {
            try {
                writer.write(line);
                writer.write(Constants.LINE_SEPARATOR);
            } catch (final IOException e) {
                throw new DictionaryException("Failed to write: " + line, e);
            }
        }

        }
        try {
            if (writer != null) {
                new PluginDescriptorStaxWriter().write(writer, content);
            } else if (outputStream != null) {
                new PluginDescriptorStaxWriter().write(outputStream, content);
            } else {
                try (OutputStream os = Files.newOutputStream(path)) {

  fun setClient(client: Boolean) {
    if (this.client == client) return
    this.client = client
    writer = Http2Writer(bytesOut, client)
  }

  fun acceptFrame() {
    frameCount++
  }

  /** Maximum length of an outbound data frame.  */
  fun maxOutboundDataLength(): Int = writer.maxDataLength()

  /** Count of frames sent or received.  */
  fun frameCount(): Int = frameCount

        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
                PrintWriter writer = new PrintWriter(baos, false, Constants.CHARSET_UTF_8)) {
            exception.printStackTrace(writer);
            writer.flush();
            append(buf, "exception", () -> StringEscapeUtils.escapeJson(new String(baos.toByteArray(), Constants.CHARSET_UTF_8)));

        final int result = copy(url, "UTF-8", writer);
        assertThat(result, is(urlString.length()));
        assertThat(writer.toString(), is(urlString));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testFileToWriter() throws Exception {
        final int result = copy(inputFile, "UTF-8", writer);
        assertThat(result, is(urlString.length()));

	}
}

func TestCloseOnWriter(t *testing.T) {
	writer := WriteOnClose(io.Discard)
	if writer.HasWritten() {
		t.Error("WriteOnCloser must not be marked as HasWritten")
	}
	writer.Write(nil)
	if !writer.HasWritten() {
		t.Error("WriteOnCloser must be marked as HasWritten")
	}

	writer = WriteOnClose(io.Discard)
	writer.Close()
	if !writer.HasWritten() {
		t.Error("WriteOnCloser must be marked as HasWritten")

				mappedResp[id] = string(resource.Value) + "\n"
			} else {
				_, _ = s.Writer.Write(resource.Value)
				_, _ = s.Writer.Write([]byte("\n"))
			}
		}
	}
	if len(mappedResp) > 0 {
		mresp, err := json.MarshalIndent(mappedResp, "", "  ")
		if err != nil {
			return err
		}
		_, _ = s.Writer.Write(mresp)
		_, _ = s.Writer.Write([]byte("\n"))
	}

	return nil