void testShareAccessConstants() {
        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);
    }

        if (this.desiredAccess == 0x3) {
            this.desiredAccess = 0x2; /* Mmm, I thought 0x03 was RDWR */
        }

        // map shareAccess as far as we can
        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) {

        SmbFileHandleImpl sfd = mock(SmbFileHandleImpl.class);
        when(sfd.getInitialSize()).thenReturn(0L);
        when(src.openUnshared(eq(0), eq(SmbConstants.O_RDONLY), eq(SmbConstants.FILE_SHARE_READ), eq(SmbConstants.ATTR_NORMAL), eq(0)))
                .thenReturn(sfd);

        // openCopyTargetFile should be called by serverSideCopy, so dest.openUnshared must succeed

                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)) {

     */
    public static final int SMB2_IMPERSONATION_LEVEL_DELEGATE = 0x3;

    /**
     * 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
     */

    }

    @Test
    @DisplayName("Test share access setter")
    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);

     * other SMB clients will be permitted to read from 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_READ = 0x01;
    /**
     * When specified as the {@code shareAccess} constructor parameter,
     * other SMB clients will be permitted to write to the target file while

                throw SmbException.wrap(e);
            }
        }

        try (SmbFileHandleImpl sfd = src.openUnshared(0, SmbConstants.O_RDONLY, SmbConstants.FILE_SHARE_READ, SmbConstants.ATTR_NORMAL, 0);
                SmbFileInputStream fis = new SmbFileInputStream(src, sh, sfd)) {
            final int attrs = src.getAttributes();

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

            assertNotNull(inputStream);
            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 {