@Override
        protected int writeSetupWireFormat(byte[] dst, int dstIndex) {
            return setupWireFormatReturn;
        }

        @Override
        protected int writeParametersWireFormat(byte[] dst, int dstIndex) {
            return parametersWireFormatReturn;
        }

        @Override
        protected int writeDataWireFormat(byte[] dst, int dstIndex) {
            return dataWireFormatReturn;

package jcifs.smb1.smb1;

class SmbComReadAndXResponse extends AndXServerMessageBlock {

    byte[] b;
    int off, dataCompactionMode, dataLength, dataOffset;

    SmbComReadAndXResponse() {
    }

    SmbComReadAndXResponse(final byte[] b, final int off) {
        this.b = b;
        this.off = off;
    }

    void setParam(final byte[] b, final int off) {
        this.b = b;
        this.off = off;
    }

		if offsetBeginString[0] == '+' {
			return nil, fmt.Errorf("Byte position ('%s') must not have a sign", offsetBeginString)
		} else if offsetBegin, err = strconv.ParseInt(offsetBeginString, 10, 64); err != nil {
			return nil, fmt.Errorf("'%s' does not have a valid first byte position value", rangeString)
		} else if offsetBegin < 0 {
			return nil, fmt.Errorf("First byte position is negative ('%d')", offsetBegin)
		}
	}

        // save number of bits, casting the long to an array of 8 bytes
        // save low-order byte first.
        for (int i = 0; i < 8; i++) {
            tail[padLen + i] = (byte) (count * 8 >>> 8 * i);
        }

        engineUpdate(tail, 0, tail.length);

        final byte[] result = new byte[16];
        // cast this MD4's context (array of 4 ints) into an array of 16 bytes.

        dst[dstIndex] = (byte) 0x00;
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00;
        dst[dstIndex++] = (byte) 0x00;
        dst[dstIndex++] = (byte) 0x00;
        SMBUtil.writeInt4(this.capabilities, dst, dstIndex);
        dstIndex += 4;

        return dstIndex - start;
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {

    }

    @Override
    public byte[] calculateMIC(final byte[] data) throws CIFSException {
        if (!this.completed) {
            throw new CIFSException("Context is not established");
        }
        return this.mechContext.calculateMIC(data);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.SSPContext#verifyMIC(byte[], byte[])
     */
    @Override

        @Test
        @DisplayName("findTermination should find null termination in single-byte encoding")
        void testFindTermination() {
            // Given
            String testString = "Hello";
            byte[] stringBytes = testString.getBytes(StandardCharsets.UTF_8);
            byte[] bufferWithTermination = new byte[stringBytes.length + 1]; // +1 for null termination

     */
    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#readBytesWireFormat(byte[], int)
     */
    @Override

  }

  public void testReset() throws Exception {
    byte[] data = newPreFilledByteArray(100);
    FileBackedOutputStream out = new FileBackedOutputStream(Integer.MAX_VALUE);
    ByteSource source = out.asByteSource();

    out.write(data);
    assertTrue(Arrays.equals(data, source.read()));

    out.reset();
    assertTrue(Arrays.equals(new byte[0], source.read()));

    out.write(data);

        super(config);
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

        buffer[bufferIndex] = (byte) 0x00; // Reserved
        bufferIndex++;
        buffer[bufferIndex++] = (byte) 0x00; // Reserved
        buffer[bufferIndex++] = (byte) 0x00; // Reserved

        this.totalParameterCount = SMBUtil.readInt4(buffer, bufferIndex);