return nil
}

// Seek implements the [io.Seeker] interface.
func (r *Reader) Seek(offset int64, whence int) (int64, error) {
	r.prevRune = -1
	var abs int64
	switch whence {
	case io.SeekStart:
		abs = offset
	case io.SeekCurrent:
		abs = r.i + offset
	case io.SeekEnd:
		abs = int64(len(r.s)) + offset
	default:
		return 0, errors.New("bytes.Reader.Seek: invalid whence")
	}
	if abs < 0 {

            JAVA15_HOME=$HOME/.java/openjdk15
      - shell: |
          #!/bin/bash
          # Configure a dm-crypt volume backed by a file
          set -e
          dd if=/dev/zero of=dm-crypt.img bs=1 count=0 seek=60GB
          dd if=/dev/urandom of=key.secret bs=2k count=1
          LOOP=$(losetup -f)
          sudo losetup $LOOP dm-crypt.img
          sudo cryptsetup luksFormat -q --key-file key.secret "$LOOP"

        long newPosition = 100L;
        smbRandomAccessFile.seek(newPosition);
        assertEquals(newPosition, smbRandomAccessFile.getFilePointer());
    }

    @Test
    void testSeekNegativePosition() throws SmbException {
        // seek doesn't throw exception for negative position, it just sets it
        smbRandomAccessFile.seek(-1);
        assertEquals(-1, smbRandomAccessFile.getFilePointer());
    }

	}
	f.pos += int64(len(b))
	return len(b), nil
}

func (f *testFile) Seek(pos int64, whence int) (int64, error) {
	if pos == 0 && whence == io.SeekCurrent {
		return f.pos, nil
	}
	if len(f.ops) == 0 {
		return 0, errors.New("unexpected Seek operation")
	}
	s, ok := f.ops[0].(int64)
	if !ok {
		return 0, errors.New("unexpected Seek operation")
	}

	if s != pos || whence != io.SeekCurrent {

		n += w
	}
	if d.idx >= d.length {
		extraBytes := d.idx - d.length
		n -= int(extraBytes)
		if n < 0 {
			n = 0
		}
		err = io.EOF
	}
	return n, err
}

func (d *DummyDataGen) Seek(offset int64, whence int) (int64, error) {
	switch whence {
	case io.SeekStart:
		if offset < 0 {
			return 0, errors.New("Invalid offset")
		}
		d.idx = offset
	case io.SeekCurrent:
		if d.idx+offset < 0 {

        super(config);
    }

    /**
     * Constructs an Open AndX response with a chained response.
     *
     * @param config the configuration
     * @param andxResp the chained seek response
     */
    public SmbComOpenAndXResponse(final Configuration config, final SmbComSeekResponse andxResp) {
        super(config, andxResp);
    }

    /**
     * Gets the file identifier.
     *

* `write(data)`: Writes `data` (`str` or `bytes`) to the file.
* `read(size)`: Reads `size` (`int`) bytes/characters of the file.
* `seek(offset)`: Goes to the byte position `offset` (`int`) in the file.
    * E.g., `await myfile.seek(0)` would go to the start of the file.
    * This is especially useful if you run `await myfile.read()` once and then need to read the contents again.
* `close()`: Closes the file.

	default:
		return n, nil
	}
}

func (sw *sparseFileWriter) ReadFrom(r io.Reader) (n int64, err error) {
	rs, ok := r.(io.ReadSeeker)
	if ok {
		if _, err := rs.Seek(0, io.SeekCurrent); err != nil {
			ok = false // Not all io.Seeker can really seek
		}
	}
	if !ok {
		return io.Copy(struct{ io.Writer }{sw}, r)
	}

	var readLastByte bool
	pos0 := sw.pos

    }

    /**
     * Sets the file pointer to the specified position.
     *
     * @param pos the new file pointer position
     * @throws SmbException if an I/O error occurs
     */
    public void seek(final long pos) throws SmbException {
        fp = pos;
    }

    /**
     * Returns the length of the file.
     *
     * @return the file length in bytes

        assertEquals(0, raf.skipBytes(-3));
    }

    @Test
    @DisplayName("seek() and getFilePointer(): set and get position")
    void seek_and_getFilePointer() throws Exception {
        SmbRandomAccessFile raf = newInstance("r", false, false, false);
        raf.seek(123L);
        assertEquals(123L, raf.getFilePointer());
    }

    @Test