}
    }

    private ClaimStatistic toXmlReportFile(ReportConfiguration config, Writer writer) throws RatException, IOException {
        ClaimStatistic stats = new ClaimStatistic();
        RatReport standardReport = XmlReportFactory.createStandardReport(new XmlWriter(writer), stats, config);

        standardReport.startReport();
        for (FileCollection dirSet : getSourceFolders().get()) {

        protected boolean isCommit = false;

        /** The temporary file to write changes to. */
        protected File newFile;

        /** The writer for the temporary file. */
        protected Writer writer;

        /** The stemmer override item being added or updated. */
        protected StemmerOverrideItem item;

        /**

    /**
     * Implementation method for writing an XML node to a writer.
     *
     * @param node the XML node to write
     * @param writer the writer to write to
     * @throws IOException if there is an error writing the XML
     */
    protected abstract void doWrite(XmlNode node, Writer writer) throws IOException;

    /**
     * Implementation method for merging two XML nodes.
     *

  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);
  }

            versionToIncubating.toSortedMap().forEach { (version, incubatingDescriptions) ->
                writer.println("<a name=\"sec_$version\"></a>")
                writer.println(
                    "<h2>Incubating since $version (${versions[version]?.run { "released on $this" } ?: "unreleased"})</h2>"
                )
                writer.println("<ul>")
                incubatingDescriptions.sortedBy { it.name }.forEach { incubating ->

     * .
     *
     * @throws IOException
     */
    @Test
    public void testStorePropertiesWriterString() throws IOException {
        final Properties outProperties = new Properties();
        outProperties.setProperty("a", "A");
        final File file = tempFolder.newFile("hoge.properties");
        final Writer writer = WriterUtil.create(file);

		}

		if v.Alias != "" {
			writer.WriteString(" AS ")
			write(v.Raw, v.Alias)
		}
	case []clause.Column:
		writer.WriteByte('(')
		for idx, d := range v {
			if idx > 0 {
				writer.WriteByte(',')
			}
			stmt.QuoteTo(writer, d)
		}
		writer.WriteByte(')')
	case clause.Expr:
		v.Build(stmt)
	case string:
		stmt.DB.Dialector.QuoteTo(writer, v)
	case []string:
		writer.WriteByte('(')

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.

        startLatch.countDown();

        // Wait for writer thread to complete
        writerThread.join(1000);

        // Wait for all reader threads to complete
        for (Thread thread : readerThreads) {
            thread.join(testDurationMs + 1000);
        }

        // Verify that alive was changed to false
        assertFalse("alive should be false after writer thread", dataStore.alive);

// LimitedWriter takes an io.Writer and returns an ioutil.LimitWriter.
func LimitedWriter(w io.Writer, skipBytes int64, limit int64) *LimitWriter {
	return &LimitWriter{w, skipBytes, limit}
}

type nopCloser struct {
	io.Writer
}

func (nopCloser) Close() error { return nil }

// NopCloser returns a WriteCloser with a no-op Close method wrapping
// the provided Writer w.
func NopCloser(w io.Writer) io.WriteCloser {