// as an error to be reported.
func ReadFileWithFileInfo(name string) ([]byte, fs.FileInfo, error) {
	f, err := OsOpenFile(name, readMode, 0o666)
	if err != nil {
		return nil, nil, err
	}
	defer f.Close()

	st, err := f.Stat()
	if err != nil {
		return nil, nil, err
	}

	dst := make([]byte, st.Size())
	_, err = io.ReadFull(f, dst)
	return dst, st, err
}

        this.hashAlgos = hashAlgos;
        this.salt = salt;
    }

    /**
     * Default constructor for deserialization.
     */
    public PreauthIntegrityNegotiateContext() {
    }

    /**
     * Gets the salt value used for preauth integrity.
     *
     * @return the salt
     */
    public byte[] getSalt() {
        return this.salt;
    }

        // SMB_COM_LOGOFF_ANDX = 0x74
        assertEquals((byte) 0x74, msg.command, "Command should be SMB_COM_LOGOFF_ANDX");
    }

    @Test
    @DisplayName("constructor with mock andx properly sets andx field")
    void constructorWithMockAndx() {
        // Create a mock ServerMessageBlock
        ServerMessageBlock mockAndx = mock(ServerMessageBlock.class);

        when(mockWriteResponse.getCount()).thenReturn(10, 5); // Return proper byte counts

        outputStream = new SmbFileOutputStream(mockFile, mockTreeHandle, mockFileHandle,
                SmbConstants.O_CREAT | SmbConstants.O_WRONLY | SmbConstants.O_TRUNC, SmbConstants.FILE_WRITE_DATA,
                SmbConstants.DEFAULT_SHARING);

        byte[] data = new byte[10];

        // When & Then - test boundary conditions

            setField(transport, "negotiated", nego);

            byte[] input = new byte[] { 10, 20, 30, 40 };
            byte[] hash1 = transport.calculatePreauthHash(input, 0, input.length, null);
            assertNotNull(hash1);
            assertEquals(64, hash1.length, "SHA-512 size");

            byte[] hash2 = transport.calculatePreauthHash(new byte[] { 50 }, 0, 1, hash1);
            assertNotNull(hash2);

  /**
   * @deprecated This method is dangerous as it discards the high byte of every character. For
   *     UTF-8, use {@code write(s.getBytes(StandardCharsets.UTF_8))}.
   */
  @Deprecated
  @Override
  void writeBytes(String s);

  /** Returns the contents that have been written to this instance, as a byte array. */
  byte[] toByteArray();

        macAddress = new byte[6];
    }

    @Override
    int writeBodyWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int readBodyWireFormat(final byte[] src, final int srcIndex) {
        return readResourceRecordWireFormat(src, srcIndex);
    }

    @Override
    int writeRDataWireFormat(final byte[] dst, final int dstIndex) {
        return 0;

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    /**
     * {@inheritDoc}
     *
     * @throws SMBProtocolDecodingException

    private int readSize;
    private boolean async;
    private int treeId;
    private long mid, asyncId, sessionId;
    private byte errorContextCount;
    private byte[] errorData;

    private boolean retainPayload;
    private byte[] rawPayload;

    private ServerMessageBlock2 next;

    /**
     * Constructor for SMB2 message block with configuration.
     *
     * @param config the configuration object

    }

    @Override
    int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        writeInt2(searchAttributes, dst, dstIndex);
        return 2;
    }

    @Override
    int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        dst[dstIndex] = (byte) 0x04;
        dstIndex++;
        dstIndex += writeString(path, dst, dstIndex);