}

    @Test
    @DisplayName("readParametersWireFormat with offset should work correctly")
    void testReadParametersWireFormatWithOffset() {
        // Arrange
        byte[] buffer = new byte[20];
        int bufferIndex = 10;

        // Write data at offset
        SMBUtil.writeInt2(500, buffer, bufferIndex);
        SMBUtil.writeInt2(0, buffer, bufferIndex + 2);

        int n = next.writeParametersWireFormat(buf, 0);
        assertEquals(buf.length, n, "Parameter bytes written should match expected length");
        // informationLevel LE at offset 4..5
        assertEquals((byte) 0x04, buf[4]);
        assertEquals((byte) 0x01, buf[5]);
    }

    /**
     * Ensures writeSetupWireFormat writes subcommand and trailing zero, returning 2.
     */
    @Test

	ReadFile(ctx context.Context, volume string, path string, offset int64, buf []byte, verifier *BitrotVerifier) (n int64, err error)
	AppendFile(ctx context.Context, volume string, path string, buf []byte) (err error)
	CreateFile(ctx context.Context, origvolume, olume, path string, size int64, reader io.Reader) error
	ReadFileStream(ctx context.Context, volume, path string, offset, length int64) (io.ReadCloser, error)

     */
    public int size() {
        return 0;
    }

    /**
     * Encode this request (no-op since there's no data)
     *
     * @param dst destination buffer
     * @param dstIndex starting offset
     * @return number of bytes written (always 0)
     */
    public int encode(byte[] dst, int dstIndex) {
        // No data to encode
        return 0;
    }

            byte[] buffer = new byte[100];
            int offset = 40;
            ByteBuffer bb = ByteBuffer.wrap(buffer, offset, 24).order(ByteOrder.LITTLE_ENDIAN);
            bb.putLong(5000L);
            bb.putLong(2500L);
            bb.putInt(16);
            bb.putInt(1024);

            // When
            int bytesConsumed = fileFsSizeInfo.decode(buffer, offset, 24);

            // Then

* `write(data)`: escreve dados (`data`) em `str` ou `bytes` no arquivo.
* `read(size)`: Lê um número de bytes/caracteres de acordo com a quantidade `size` (`int`).
* `seek(offset)`: Navega para o byte na posição `offset` (`int`) do arquivo.
    * E.g., `await myfile.seek(0)` navegaria para o ínicio do arquivo.

    /**
     * Returns the page size.
     *
     * @return The page size.
     */
    public abstract int getPageSize();

    /**
     * Returns the offset.
     *
     * @return The offset.
     */
    public abstract int getOffset();

    /**
     * Returns the extra queries.
     *
     * @return The extra queries.
     */

        return this.file.ensureTreeConnected();
    }

    /**
     * Writes len bytes from the specified byte array starting at
     * offset off to this file output stream.
     *
     * @param b
     *            The array
     * @param off the start offset in the data
     * @param len the number of bytes to write
     * @throws IOException
     *             if a network error occurs
     */

                                        </div>
                                    </div>
                                    <div class="form-group row">
                                        <div class="offset-sm-2 col-sm-10">
                                            <button type="submit" class="btn btn-primary" id="submit"
                                                    name="search"

    val bodySource = response1.body.source()
    assertThat(bodySource.readUtf8()).isEqualTo("ABC.1")

    corruptor()

    return client.newCall(request).execute()
  }

  /**
   * @param delta the offset from the current date to use. Negative values yield dates in the past;
   *     positive values yield dates in the future.
   */
  private fun formatDate(
    delta: Long,
    timeUnit: TimeUnit,