assertEquals(0x00, SmbConstants.FILE_NO_SHARE);
        assertEquals(0x01, SmbConstants.FILE_SHARE_READ);
        assertEquals(0x02, SmbConstants.FILE_SHARE_WRITE);
        assertEquals(0x04, SmbConstants.FILE_SHARE_DELETE);
        assertEquals(SmbConstants.FILE_SHARE_READ | SmbConstants.FILE_SHARE_WRITE | SmbConstants.FILE_SHARE_DELETE,
                SmbConstants.DEFAULT_SHARING);
    }

    @Test

        if ((shareAccess & SmbConstants.FILE_SHARE_READ) != 0 && (shareAccess & SmbConstants.FILE_SHARE_WRITE) != 0) {
            this.desiredAccess |= SHARING_DENY_NONE;
        } else if (shareAccess == SmbConstants.FILE_NO_SHARE) {
            this.desiredAccess |= SHARING_DENY_READ_WRITE_EXECUTE;
        } else if ((shareAccess & SmbConstants.FILE_SHARE_WRITE) == 0) {
            this.desiredAccess |= SHARING_DENY_WRITE;

    void testSetShareAccess() {
        request = new Smb2CreateRequest(mockConfig, "test.txt");

        int shareAccess = Smb2CreateRequest.FILE_SHARE_READ | Smb2CreateRequest.FILE_SHARE_WRITE | Smb2CreateRequest.FILE_SHARE_DELETE;
        request.setShareAccess(shareAccess);

        byte[] buffer = new byte[1024];
        request.writeBytesWireFormat(buffer, 0);

    /**
     * Enable other opens for read access
     */
    public static final int FILE_SHARE_READ = 0x1;

    /**
     * Enable other opens for write access
     */
    public static final int FILE_SHARE_WRITE = 0x2;

    /**
     * Enable other opens for delete access
     */
    public static final int FILE_SHARE_DELETE = 0x4;

    /**
     * If file exists, supersede it. Otherwise create the file
     */

                withOpen(th, Smb2CreateRequest.FILE_OPEN, FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE, req);
            } else if (th.hasCapability(SmbConstants.CAP_NT_SMBS)) {

                try (SmbFileHandleImpl f = openUnshared(O_RDONLY, FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE, dir,
                        dir != 0 ? 0x0001 : 0x0040)) {

     * other SMB clients will be permitted to write to the target file while
     * this file is open. This constant may be logically OR'd with other share
     * access flags.
     */
    public static final int FILE_SHARE_WRITE = 0x02;
    /**
     * When specified as the {@code shareAccess} constructor parameter,
     * other SMB clients will be permitted to delete the target file while

     * other SMB clients will be permitted to write to the target file while
     * this file is open. This constant may be logically OR'd with other share
     * access flags.
     */
    int FILE_SHARE_WRITE = 0x02;
    /**
     * When specified as the <code>shareAccess</code> constructor parameter,
     * other SMB clients will be permitted to delete the target file while

    have exclusive access to the file. An additional open command
    from jCIFS or another application will fail with the "file is being
    accessed by another process" error. The <code>FILE_SHARE_READ</code>,
    <code>FILE_SHARE_WRITE</code>, and <code>FILE_SHARE_DELETE</code> may be
    combined with the bitwise OR '|' to specify that other peocesses may read,
    write, and/or delete the file while the jCIFS user has the file open.
     *

            verify(smbFile).openUnshared(0, // SmbConstants.O_RDONLY = 0x01, but SmbFileInputStream uses 0
                    SmbFile.O_RDONLY, SmbConstants.DEFAULT_SHARING, // 7 = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE
                    SmbConstants.ATTR_NORMAL, // 128
                    0);
        }

        @Test
        void testGetOutputStream() throws IOException {
            // Act