@Test
        @DisplayName("Should set offset correctly")
        void testSetOffset() {
            assertDoesNotThrow(() -> request.setOffset(0L));
            assertDoesNotThrow(() -> request.setOffset(1024L));
            assertDoesNotThrow(() -> request.setOffset(Long.MAX_VALUE));
        }

        @Test
        @DisplayName("Should set remaining bytes")
        void testSetRemainingBytes() {

        }

        @Test
        @DisplayName("Should set offset correctly")
        void testSetOffset() {
            assertDoesNotThrow(() -> request.setOffset(0L));
            assertDoesNotThrow(() -> request.setOffset(1024L));
            assertDoesNotThrow(() -> request.setOffset(Long.MAX_VALUE));
        }

        @Test
        @DisplayName("Should set minimum count correctly")
        void testSetMinimumCount() {

                clearAttributes();
                termAttr.append(nextToken.word);
                finalOffset = correctOffset(blkStart + nextToken.endOffset);
                offsetAttr.setOffset(correctOffset(blkStart + nextToken.startOffset), finalOffset);
                posIncAttr.setPositionIncrement(nextToken.posInc);
                return true;
            }
        }
    }

                if (th.isSMB2()) {
                    final Smb2ReadRequest request = new Smb2ReadRequest(th.getConfig(), fh.getFileId(), b, off);
                    request.setOffset(this.fp);
                    request.setReadLength(r);
                    request.setRemainingBytes(len - off);
                    try {

	return &Writer{cw: &countWriter{w: bufio.NewWriter(w)}}
}

// SetOffset sets the offset of the beginning of the zip data within the
// underlying writer. It should be used when the zip data is appended to an
// existing file, such as a binary executable.
// It must be called before any data is written.
func (w *Writer) SetOffset(n int64) {
	if w.cw.count != 0 {
		panic("zip: SetOffset called after data was written")
	}
	w.cw.count = n
}

                try {
                    if (th.isSMB2()) {
                        final Smb2ReadRequest request = new Smb2ReadRequest(th.getConfig(), fd.getFileId(), b, off);
                        request.setOffset(type == SmbConstants.TYPE_NAMED_PIPE ? 0 : this.fp);
                        request.setReadLength(r);

                        // Optimization: Set remaining bytes hint for server read-ahead

                w = len > blockSize ? blockSize : len;

                if (this.smb2) {
                    final Smb2WriteRequest wr = new Smb2WriteRequest(th.getConfig(), fh.getFileId());
                    wr.setOffset(this.fp);
                    wr.setData(b, off, w);

                    final Smb2WriteResponse resp = th.send(wr, RequestParam.NO_RETRY);
                    final long cnt = resp.getCount();

		writeTests[1].Data = nil
	}()

	// write a zip file
	buf := new(bytes.Buffer)
	existingData := []byte{1, 2, 3, 1, 2, 3, 1, 2, 3}
	n, _ := buf.Write(existingData)
	w := NewWriter(buf)
	w.SetOffset(int64(n))

	for _, wt := range writeTests {
		testCreate(t, w, &wt)
	}

	if err := w.Close(); err != nil {
		t.Fatal(err)
	}

	// read it back

            try {
                Smb2ReadRequest request = new Smb2ReadRequest();
                request.setFileId(this.fileId);
                request.setOffset(offset + chunkOffset);
                request.setLength(chunkLength);
                
                Smb2ReadResponse response = (Smb2ReadResponse) 
                    channel.getTransport().send(request);

pkg archive/zip, method (*Writer) SetOffset(int64)
pkg bufio, method (*Reader) Discard(int) (int, error)
pkg bufio, method (ReadWriter) Discard(int) (int, error)
pkg bytes, func LastIndexByte([]uint8, uint8) int
pkg bytes, method (*Buffer) Cap() int
pkg bytes, method (*Reader) Size() int64
pkg crypto, const SHA512_224 = 14
pkg crypto, const SHA512_224 Hash
pkg crypto, const SHA512_256 = 15
pkg crypto, const SHA512_256 Hash