bufferIndex += 2;
        parameterDisplacement = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        dataCount = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        dataOffset = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        dataDisplacement = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        setupCount = buffer[bufferIndex] & 0xFF;

   *
   * @since 8.0
   */
  public static final byte NUL = 0;

  /**
   * Start of Heading: A communication control character used at the beginning of a sequence of
   * characters which constitute a machine-sensible address or routing information. Such a sequence
   * is referred to as the "heading." An STX character has the effect of terminating a heading.
   *
   * @since 8.0
   */
  public static final byte SOH = 1;

  /**

        final int start = bufferIndex;

        this.pathConsumed = SMBUtil.readInt2(buffer, bufferIndex) / 2;
        bufferIndex += 2;
        this.numReferrals = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.tflags = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 4;

        this.referrals = new Referral[this.numReferrals];

        // Then
        assertEquals(4, bytesWritten);

        // Verify structure size (4) is written at offset
        assertEquals(4, SMBUtil.readInt2(buffer, offset));

        // Verify reserved field (0) is written at offset + 2
        assertEquals(0, SMBUtil.readInt2(buffer, offset + 2));
    }

    @Test
    @DisplayName("Should write exact wire format structure")
    void testWriteBytesWireFormatStructure() {

    }

    @Override
    int readParametersWireFormat(final byte[] buffer, int bufferIndex, final int len) {
        available = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        int head = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        status = readInt2(buffer, bufferIndex);
        return 6;
    }

    @Override

        // Check FID
        int actualFid = SMBUtil.readInt2(buffer, 0);
        assertEquals(TEST_FID, actualFid);

        // Check information level (FILE_BASIC_INFO maps to 0x0101)
        int actualInfoLevel = SMBUtil.readInt2(buffer, 2);
        assertEquals(0x0101, actualInfoLevel);

        // Check reserved bytes (should be 0)
        int reserved = SMBUtil.readInt2(buffer, 4);
        assertEquals(0, reserved);
    }

 * </pre></td><td>
 * Open the Named Pipe foo for reading and writing. The pipe will behave like the <code>CallNamedPipe</code> interface.
 * </td></tr>
 * <tr><td ><pre>
 * new SmbNamedPipe( "smb1://server/IPC$/foo",
 *         SmbNamedPipe.PIPE_TYPE_RDWR |
 *         SmbNamedPipe.PIPE_TYPE_TRANSACT );
 * </pre></td><td>

        byte[] buffer = new byte[512];
        int written = trans2QueryPathInfo.writeParametersWireFormat(buffer, 0);

        // Check information level (first 2 bytes)
        int actualInfoLevel = SMBUtil.readInt2(buffer, 0);
        assertEquals(0x0101, actualInfoLevel); // FILE_BASIC_INFO maps to 0x0101

        // Check reserved bytes (4 bytes of 0x00)
        assertEquals(0x00, buffer[2]);
        assertEquals(0x00, buffer[3]);

   * than would be returned by reading all of the bytes (for example, some special files may return
   * a size of 0 despite actually having content when read).
   *
   * <p>In either case, for mutable sources such as files, a subsequent read may return a different
   * number of bytes if the contents are changed.
   *
   * @throws IOException if an I/O error occurs while reading the size of this source
   */

        bufferIndex += 4;
        this.parameterDisplacement = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        setDataCount(SMBUtil.readInt4(buffer, bufferIndex));
        bufferIndex += 4;
        this.dataOffset = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        this.dataDisplacement = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;