break
		}

		for {
			numErr := 0

			names, readErr := file.Readdirnames(reqSize)
			// Errors other than EOF should stop us from continuing.
			if readErr != nil && readErr != io.EOF {
				file.Close()
				if IsNotExist(readErr) {
					return nil
				}
				return &PathError{Op: "readdirnames", Path: base, Err: readErr}
			}

			respSize = len(names)
			for _, name := range names {

 */
public class LineIteratorTest {

    /**
     * @throws Exception
     */
    @Test
    public void test() throws Exception {
        final StringReader reader = new StringReader("aaa\nbbb\nccc\n");
        final LineIterator it = new LineIterator(reader);
        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("aaa"));
        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is("bbb"));

import org.apache.maven.api.services.MessageBuilderFactory;
import org.jline.jansi.AnsiConsole;
import org.jline.reader.LineReader;
import org.jline.reader.LineReaderBuilder;
import org.jline.terminal.Terminal;
import org.jline.terminal.TerminalBuilder;

public class MessageUtils {

    static Terminal terminal;
    static LineReader reader;
    static MessageBuilderFactory messageBuilderFactory = new JLineMessageBuilderFactory();

    public Resources resources = new Resources()
    DefaultImportsReader reader = new DefaultImportsReader()

    def "default import packages contain org.gradle.api"() {
        expect:
        reader.importPackages.contains('org.gradle.api')
    }

    def "fq default imports do not contain package private types"() {
        expect:
        null == reader.simpleNameToFullClassNamesMapping
            .collectMany { it.value }

}

// tryLimitedReader tries to assert the io.Reader to io.LimitedReader, it returns the io.LimitedReader,
// the underlying io.Reader and the remaining amount of bytes if the assertion succeeds,
// otherwise it just returns the original io.Reader and the theoretical unlimited remaining amount of bytes.
func tryLimitedReader(r io.Reader) (*io.LimitedReader, io.Reader, int64) {
	var remain int64 = 1<<63 - 1 // by default, copy until EOF

				if err != nil {
					errs[idx] = err
					return
				}

				reader, err = reader.WithEncryption(hr, &objectEncryptionKey)
				if err != nil {
					errs[idx] = err
					return
				}
			}

			objInfo, err := objectAPI.PutObject(ctx, bucket, req.Key, reader, ObjectOptions{
				Versioned:        globalBucketVersioningSys.PrefixEnabled(bucket, req.Key),

        return template;
    }

    private String generateStartScriptContentFromTemplate(final Map<String, String> binding) {
        try (Reader reader = getTemplate().asReader()) {
            SimpleTemplateEngine engine = new SimpleTemplateEngine();
            Template template = engine.createTemplate(reader);
            String output = template.make(binding).toString();
            return TextUtil.convertLineSeparators(output, lineSeparator);

                reader = new ClassReader(ByteStreams.toByteArray(inputStream));
            }

            char[] charBuffer = new char[reader.getMaxStringLength()];
            for (int i = 1; i < reader.getItemCount(); i++) {
                int itemOffset = reader.getItem(i);
                if (itemOffset > 0 && reader.readByte(itemOffset - 1) == 7) {

import org.gradle.api.tasks.options.OptionValues
import spock.lang.Issue
import spock.lang.Specification

class OptionReaderTest extends Specification {

    OptionReader reader
    int builtInOptionCount

    def setup() {
        reader = new OptionReader()
        builtInOptionCount = TaskOptionsGenerator.BUILT_IN_OPTIONS.size();
    }

    def "can read options linked to setter methods of a task"() {
        when:

			t.Errorf("recreating key pair gave different seed on line %d: %x vs %x", lineNo, priv[:32], seed)
		}
	}

	if err := scanner.Err(); err != nil {
		t.Fatalf("error reading test data: %s", err)
	}
}

func TestMalleability(t *testing.T) {
	// https://tools.ietf.org/html/rfc8032#section-5.1.7 adds an additional test