}
            finally {
                f.delete();
            }
        }
    }


    @Test
    public void testCreated () throws CIFSException, MalformedURLException, UnknownHostException {
        try ( SmbResource f = createTestFile() ) {
            try {
                assertCloseTime(f.createTime());
            }
            finally {
                f.delete();

                    while ( chld.hasNext() ) {
                        chld.next();
                    }
                }
                finally {
                    bufSize[ 0 ] = origBufferSize;
                }
            }
            finally {
                f.delete();
            }
        }
    }


    @Test
    // BUG #16

                    ioe2.printStackTrace( log );
                }
                throw ioe;
            } catch( InterruptedException ie ) {
                throw new TransportException( ie );
            } finally {
                response_map.remove( request );
            }
    }
    private void loop() {
        while( thread == Thread.currentThread() ) {
            try {
                Request key = peekKey();

@SuppressWarnings ( "javadoc" )
public class PacMac {

    /**
     * 
     */
    private static final String HMAC_KEY = "HMAC";
    private static final byte[] MD5_CONSTANT = "signaturekey\0".getBytes(StandardCharsets.US_ASCII);
    private static final byte[] ZERO_IV = new byte[] {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };

                f.renameTo(f2);
                try {
                    assertTrue(f2.exists());
                    renamed = true;
                }
                finally {
                    f2.delete();
                }
            }
            finally {
                if ( !renamed && f.exists() ) {
                    f.delete();
                }
            }
        }
    }


    @Test

    private volatile Thread thread;
    private volatile TransportException te;

    protected final Object inLock = new Object();
    protected final Object outLock = new Object();

    protected final Map<Long, Response> response_map = new ConcurrentHashMap<>(10);
    private final AtomicLong usageCount = new AtomicLong(1);


    /**
     * @return session increased usage count
     */

                System.arraycopy("BSRSPYL ".getBytes(), 0, data, index, 8);
            }
        } catch (Exception ex) {
            if( log.level > 0 )
                ex.printStackTrace( log );
        } finally {
            signSequence += 2;
        }
    } 

    /**
     * Performs MAC signature verification.  This calculates the signature
     * of the SMB and compares it to the signature field on the SMB itself.

                        assertTrue("File exists " + u, tf.exists());
                        assertEquals(name, tf.getName());
                    }
                }
            }
            finally {
                d.delete();
            }
        }
    }

                        }
                    }
                    finally {
                        if ( resp2 != null && !trans.isDisconnected() ) {
                            tree.send(new SmbComClose(sess.getConfig(), resp2.getFid(), 0L));
                        }
                    }
                }
                finally {
                    if ( resp != null && !trans.isDisconnected() ) {

    @Test
    public void testStandaloneDFSCache () throws CIFSException {
        CIFSContext context = getContext();
        context = withTestNTLMCredentials(context);

        final String hostname = "foo";
        final String root = "dfs";
        final String path = "\\bla\\";

        DfsImpl dfs = new DfsImpl(context);

        DfsReferralDataImpl dr = new DfsReferralDataImpl() {

            @Override