*/
    @Override
    public synchronized void close(final long lastWriteTime) throws CIFSException {
        closeInternal(lastWriteTime, true);
    }

    /**
     * @param lastWriteTime
     * @throws SmbException
     */
    void closeInternal(final long lastWriteTime, final boolean explicit) throws CIFSException {
        final SmbTreeHandleImpl t = this.tree;
        try {

 */
package jcifs.smb;

import java.util.Arrays;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.CIFSException;
import jcifs.internal.smb2.lease.DirectoryCacheScope;
import jcifs.internal.smb2.lease.DirectoryLeaseManager;
import jcifs.internal.smb2.lease.Smb2LeaseKey;
import jcifs.internal.smb2.lease.Smb2LeaseState;

/**

 */
package jcifs.smb;

import java.io.IOException;
import java.net.MalformedURLException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.CIFSException;
import jcifs.CloseableIterator;
import jcifs.SmbConstants;
import jcifs.SmbResource;
import jcifs.internal.fscc.FileBasicInfo;
import jcifs.internal.smb1.com.SmbComSetInformation;

            }

            this.fp = 0L;
        } catch (final CIFSException e) {
            throw SmbException.wrap(e);
        }
    }

    /**
     * @return
     * @throws SmbException
     */
    synchronized SmbFileHandleImpl ensureOpen() throws CIFSException {
        // ensure file is open
        if (this.handle == null || !this.handle.isValid()) {

     *
     * @param resource the SMB resource to test
     * @return whether the given resource should be included
     * @throws CIFSException if an error occurs while accessing the resource
     */
    boolean accept(SmbResource resource) throws CIFSException;

        }

        @Test
        @DisplayName("Should propagate CIFSException when getting session key")
        void testGetSessionKey_ThrowsCIFSException() throws Exception {
            DcerpcPipeHandle handle = createMockedDcerpcPipeHandle();
            CIFSException exception = new CIFSException("Test exception");
            when(mockSmbPipeHandleInternal.getSessionKey()).thenThrow(exception);

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.dcerpc.ndr;

import jcifs.CIFSException;

/**
 * Exception thrown when an error occurs during NDR encoding or decoding operations.
 */
public class NdrException extends CIFSException {

    /**
     *
     */
    private static final long serialVersionUID = 7621650016319792189L;
    /**

    }

    @Test
    @DisplayName("calculateMIC wraps GSSException into CIFSException")
    void calculateMIC_failure_wraps() throws Exception {
        byte[] data = new byte[] { 0 };
        when(gssContext.getMIC(any(), anyInt(), anyInt(), any())).thenThrow(new GSSException(GSSException.FAILURE));

        CIFSException ex = assertThrows(CIFSException.class, () -> ctx.calculateMIC(data));

     * {@inheritDoc}
     *
     * @throws CIFSException
     *
     * @see jcifs.smb.SSPContext#calculateMIC(byte[])
     */
    @Override
    public byte[] calculateMIC(byte[] data) throws CIFSException {
        try {
            return this.gssContext.getMIC(data, 0, data.length, new MessageProp(false));
        } catch (GSSException e) {
            throw new CIFSException("Failed to calculate MIC", e);
        }
    }

     * @param rn the referral number
     * @return dfs referral
     * @throws SmbException if an SMB error occurs
     * @throws CIFSException if a CIFS error occurs
     */
    DfsReferralData getDfsReferrals(CIFSContext ctx, String name, String targetHost, String targetDomain, int rn) throws CIFSException;

    /**
     * Checks if message signing is supported but not mandatory.
     *