output.done()

        then:
        file.length() == 5
        file.seek(0)
        file.readInt() == 123
        file.readByte() == 12

        when:
        stream = output.start(5)
        stream.writeInt(321)
        output.done()

        then:
        file.length() == 9
        file.seek(0)
        file.readInt() == 123
        file.readByte() == 12
        file.readInt() == 321

	if len(toread) < amt {
		amt = len(toread)
	}
	copy(b, toread)
	r.off += int64(amt)
	return amt, nil
}

func (r *Reader) Seek(offset int64, whence int) (ret int64, err error) {
	switch whence {
	case io.SeekStart:
		if offset < 0 || offset > int64(len(r.b)) {
			return 0, fmt.Errorf("invalid seek: new offset %d (out of range [0 %d]", offset, len(r.b))
		}
		r.off = offset
		return offset, nil
	case io.SeekCurrent:

		fmt.Fprintf(os.Stderr, "=-= after readHeader: %+v\n", d.hdr)
	}
	return nil
}

func (d *CoverageMetaDataDecoder) readStringTable() error {
	// Seek to the correct location to read the string table.
	stringTableLocation := int64(coverage.CovMetaHeaderSize + 4*d.hdr.NumFuncs)
	if _, err := d.r.Seek(stringTableLocation, io.SeekStart); err != nil {
		return err
	}

	// Read the table itself.
	d.strtab = stringtab.NewReader(d.r)

				}
			}
		}
		// Do not call eofError; caller does not expect to see io.EOF.
		return n, err
	}
}

// Seek wraps syscall.Seek.
func (fd *FD) Seek(offset int64, whence int) (int64, error) {
	if err := fd.incref(); err != nil {
		return 0, err
	}
	defer fd.decref()
	return syscall.Seek(fd.Sysfd, offset, whence)

		},
		func() error {
			return syscall.Mount(-1, 0, "", 0, "")
		})
	// originally failed only on plan9_arm
	testalias(t,
		"seek",
		func() error {
			_, err := syscall.Seek(0, 0, -1)
			return err
		},
		func() error {
			_, err := syscall.Seek(-1, 0, 0)
			return err
		})

	if whence == 1 {
		offset -= int64(r.Buffered())
	}
	off, err := r.f.Seek(offset, whence)
	if err != nil {
		log.Fatalf("seeking in output: %v", err)
	}
	r.Reset(r.f)
	return off
}

func (w *Writer) MustSeek(offset int64, whence int) int64 {
	if err := w.Flush(); err != nil {
		log.Fatalf("writing output: %v", err)
	}
	off, err := w.f.Seek(offset, whence)
	if err != nil {
		log.Fatalf("seeking in output: %v", err)

	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("strings.Reader.Seek: invalid whence")
	}
	if abs < 0 {

	// a bit brittle but cannot be addressed without a large change of the
	// algorithm in the os.(*File).readdir method.
	return n - len(b), nil
}

// Seek wraps syscall.Seek.
func (fd *FD) Seek(offset int64, whence int) (int64, error) {
	if err := fd.incref(); err != nil {
		return 0, err
	}
	defer fd.decref()
	// syscall.Filetype is a uint8 but we store it as a uint32 in SysFile in

func (r errorReader) ReadAt(p []byte, off int64) (n int, err error) {
	return 0, r.error
}

func (r errorReader) Seek(offset int64, whence int) (int64, error) {
	return 0, r.error
}

func (r errorReader) Close() error {
	return r.error
}

// readSeekerFromReader converts an io.Reader into an io.ReadSeeker.
// In general Seek may not be efficient, but it is optimized for
// common cases such as seeking to the end to find the length of the

    /**
     * Current position in file
     * 
     * @return current position
     */
    long getFilePointer ();


    /**
     * Seek to new position
     * 
     * @param pos
     */
    void seek ( long pos );


    /**
     * Get the current file length
     * 
     * @return file length
     * @throws SmbException
     */