<phase>generate-sources</phase>
            <configuration>
              <templates>
                <template>merger.vm</template>
                <template>transformer.vm</template>
                <template>reader-stax.vm</template>
                <template>writer-stax.vm</template>
              </templates>
              <params combine.children="append">
                <param>locationTracking=true</param>

      <excludes>
        <exclude>org.codehaus.plexus:plexus-classworlds</exclude>
      </excludes>
    </dependencySet>
  </dependencySets>
  <fileSets>
    <fileSet>
      <includes>
        <include>README*</include>
      </includes>
    </fileSet>
    <fileSet>
      <directory>target/maven-shared-archive-resources/META-INF</directory>
      <outputDirectory>./</outputDirectory>
      <includes>

     * @param in      The input stream to read the dictionary from.
     * @throws DictionaryException if the input stream cannot be parsed.
     */
    protected void reload(final StopwordsUpdater updater, final InputStream in) {
        final List<StopwordsItem> itemList = new ArrayList<>();
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(in, Constants.UTF_8))) {

// Return pointer to testOneByteReadNoEOF{}
func newTestReaderNoEOF(data []byte) io.Reader {
	return &testOneByteReadNoEOF{false, data}
}

// testOneByteReadNoEOF - implements io.Reader which returns 1 byte and nil error, but
// returns io.EOF on the next Read().
type testOneByteReadNoEOF struct {
	eof  bool
	data []byte
}

func (r *testOneByteReadNoEOF) Read(p []byte) (n int, err error) {
	if r.eof {
		return 0, io.EOF
	}

        // Test user boost
        item.setUserBoost(2.0f);
        assertEquals(2.0f, item.getUserBoost(), 0.001f);

        // Test readings
        String[][] newReadings = { { "read1", "read2" }, { "read3" } };
        item.setReadings(newReadings);
        assertArrayEquals(newReadings, item.getReadings());

        // Test fields
        String[] fields = { "field1", "field2" };

        readStory(story00)
        result.add(path.name)
      } catch (ignored: IOException) {
        // Skip this path.
      }
    }
    return result.toTypedArray<String>()
  }

  /**
   * Reads stories named "story_xx.json" from the folder provided.
   */
  fun readStories(testFolderName: String): List<Story> {
    val result = mutableListOf<Story>()
    var i = 0
    while (true) { // break after last test.

// Code generated by github.com/tinylib/msgp DO NOT EDIT.

package cmd

import (
	"github.com/tinylib/msgp/msgp"
)

// DecodeMsg implements msgp.Decodable
func (z *BitrotAlgorithm) DecodeMsg(dc *msgp.Reader) (err error) {
	{
		var zb0001 uint
		zb0001, err = dc.ReadUint()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = BitrotAlgorithm(zb0001)
	}
	return
}

	failAfter int
}

func newMockReader(failAfter int, data byte) *mockReader {
	return &mockReader{0, data, failAfter}
}

func (r *mockReader) Read(p []byte) (n int, err error) {
	if r.pos >= r.failAfter {
		return 0, fmt.Errorf("intentionally unexpected reader error")
	}
	r.pos++
	p[0] = r.mockData
	return 1, nil
}

func TestScannerFailure(t *testing.T) {
	var (
		i         int
		failAfter = 900

            timeZone = TimeZone.getTimeZone("UTC")
        }

        fun readBuildReceiptFromString(buildReceipt: String) =
            Properties().apply { load(buildReceipt.reader()) }

        const val buildReceiptFileName = "build-receipt.properties"
        const val buildReceiptLocation = "org/gradle/$buildReceiptFileName"
    }

    @get:Input
    abstract val version: Property<String>

import java.util.Random;
import org.jspecify.annotations.NullUnmarked;

/**
 * Benchmarks for {@link CharStreams#copy}.
 *
 * <p>{@link CharStreams#copy} has type specific optimizations for various common Appendable and
 * Reader implementations, this compares the performance of the different options.
 */
// These benchmarks allocate a lot of data so use a large heap
@VmOptions({"-Xms12g", "-Xmx12g", "-d64"})
@NullUnmarked