// Execute the method
        int bytesWritten = transaction.writeParameterWordsWireFormat(dst, 0);

        // Verify the bytes written
        assertTrue(bytesWritten > 0);

        // Verify max setup count is written at position 0
        assertEquals(2, dst[0]);

        // Verify reserved bytes
        assertEquals(0, dst[1]);
        assertEquals(0, dst[2]);

        // Check that the path is written after the referral level
        // The path should be written starting at index 2
        // writeString adds null terminator
        assertTrue(len > 2, "Length should include path");
        String writtenPath = extractStringFromBuffer(buffer, 2, len - 2);
        assertTrue(writtenPath.contains("abc"), "Path should be written to buffer");
    }

    @Test

  }

  @Override
  public void write(int b) throws IOException {
    hasher.putByte((byte) b);
    out.write(b);
  }

  @Override
  public void write(byte[] bytes, int off, int len) throws IOException {
    hasher.putBytes(bytes, off, len);
    out.write(bytes, off, len);
  }

  /**
   * Returns the {@link HashCode} based on the data written to this stream. The result is

		// from subsequent blocks.
		offset = 0

		// We have written all the blocks, write the last remaining block.
		if write < int64(len(block)) {
			n, err := dst.Write(block[:write])
			if err != nil {
				return 0, err
			}
			totalWritten += int64(n)
			break
		}

		// Copy the block.
		n, err := dst.Write(block)
		if err != nil {
			return 0, err
		}

		// Decrement output size.

        assertEquals(4, written, "Should report 4 bytes written");
        // StructureSize (2 bytes, LE) == 4
        assertEquals(4, SMBUtil.readInt2(buf, offset));
        // Reserved (2 bytes, LE) == 0
        assertEquals(0, SMBUtil.readInt2(buf, offset + 2));
    }

    @Test
    @DisplayName("writeBytesWireFormat throws when buffer too small")
    void writeBytesWireFormat_throwsIfInsufficientSpace() {
        // Arrange

     * @return number of bytes written
     */
    protected abstract int writeParametersWireFormat(byte[] dst, int dstIndex);

    /**
     * Writes data in wire format
     * @param dst destination buffer
     * @param dstIndex starting index in destination buffer
     * @return number of bytes written
     */
    protected abstract int writeDataWireFormat(byte[] dst, int dstIndex);

    super(checkNotNull(out));
  }

  /** Returns the number of bytes written. */
  public long getCount() {
    return count;
  }

  @Override
  public void write(byte[] b, int off, int len) throws IOException {
    out.write(b, off, len);
    count += len;
  }

  @Override
  public void write(int b) throws IOException {
    out.write(b);
    count++;
  }

        request.setNotifyFlags(0x0001);
        request.setCompletionFilter(0x00000FFF);

        // When
        byte[] buffer = new byte[512];
        int written = request.writeBytesWireFormat(buffer, 0);

        // Then
        assertEquals(32, written);

        // Verify complete structure
        assertEquals(32, SMBUtil.readInt2(buffer, 0)); // StructureSize

 */
public class SmbComWriteResponse extends ServerMessageBlock {

    private long count;

    /**
     * Constructs a write response for SMB1 protocol.
     *
     * @param config the configuration for this SMB session
     */
    public SmbComWriteResponse(final Configuration config) {
        super(config);
    }

    /**
     * Gets the number of bytes written.
     *

	// and don't process the If-Modified-Since header.
	if objInfo.ModTime.IsZero() || objInfo.ModTime.Equal(time.Unix(0, 0)) {
		return false
	}

	// Headers to be set of object content is not going to be written to the client.
	writeHeaders := func() {
		// set common headers
		setCommonHeaders(w)

		// set object-related metadata headers
		w.Header().Set(xhttp.LastModified, objInfo.ModTime.UTC().Format(http.TimeFormat))