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
	}
	n = copy(p, r.data)
	r.eof = true
	return n, nil
}

        for (int i = 0; i < nameBytes.length; i++) {
            assertEquals(nameBytes[i], dst[12 + i]);
        }
        assertEquals((byte) 0x00, dst[12 + nameBytes.length]);
    }

    /**
     * read*WireFormat methods in request return 0 (not implemented for requests).
     */
    @Test
    void testReadWireFormatStubsReturnZero() {
        // Given

            throws IOException;

    /**
     * Calculates checksums for specified stream. Upon this method returns, the stream will be depleted (fully read)
     * but not closed.
     *
     * @param stream      The stream for which to calculate checksums, must not be {@code null}.
     * @param algorithms  The checksum algorithms to use, must not be {@code null}.

		n := 1
		var base, ext string
		base = *privKeyPath
		if idx := strings.LastIndexByte(base, '.'); idx != -1 {
			ext = base[idx:]
			base = base[:idx]
		}
		for {
			// Automatically read "file.ext", "file-2.ext", "file-3.ext"...
			fn := base + ext
			if n > 1 {
				fn = fmt.Sprintf("%s-%d%s", base, n, ext)
			}

			if b, err := os.ReadFile(fn); err == nil {
				privateKeys = append(privateKeys, b)

		return
	}

	// Check if bucket exists.
	if _, err := objAPI.GetBucketInfo(ctx, bucket, BucketOptions{}); err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	// Read bucket access policy.
	config, err := globalPolicySys.Get(bucket)
	if err != nil {
		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	configData, err := json.Marshal(config)

	Interface   string           // This is a VRF device passed via `--interface` flag
	Trace       func(msg string) // Trace when starting.
	IdleTimeout time.Duration    // Incoming TCP read/write timeout
}

// ForWebsocket returns TCPOptions valid for websocket net.Conn
func (t TCPOptions) ForWebsocket() TCPOptions {
	return TCPOptions{
		UserTimeout: t.UserTimeout,
		Interface:   t.Interface,

	fmt.Println("Buffer contents:", buf.String())
	// Output:
	// Bytes written: 41
	// Buffer contents: Hello, world!
	// This is a ReadFrom example.
}

// The simplest use of a Scanner, to read standard input as a set of lines.
func ExampleScanner_lines() {
	scanner := bufio.NewScanner(os.Stdin)
	for scanner.Scan() {
		fmt.Println(scanner.Text()) // Println will add back the final '\n'
	}

  - [Urgent Upgrade Notes](#urgent-upgrade-notes)
    - [(No, really, you MUST read this before you upgrade)](#no-really-you-must-read-this-before-you-upgrade)
  - [Changes by Kind](#changes-by-kind-13)
    - [Deprecation](#deprecation)
    - [API Change](#api-change-3)
    - [Feature](#feature-11)

    }

    @Test
    public void test_run_withIOException() throws InterruptedException {
        InputStream faultyStream = new InputStream() {
            @Override
            public int read() throws IOException {
                throw new IOException("Test exception");
            }
        };

        InputStreamThread thread = new InputStreamThread(faultyStream, StandardCharsets.UTF_8, 10, null);

//     compress: true # S2/Snappy compressed archive
//     smallerThan: 5MiB # create archive for all objects smaller than 5MiB
//     skipErrs: false # skips any source side read() errors

// BatchJobSnowball describes the snowball feature when replicating objects from a local source to a remote target
type BatchJobSnowball struct {
	line, col   int