* Sentinel cache entry indicating a negative cache result
     */
    protected static CacheEntry FALSE_ENTRY = new Dfs.CacheEntry(0L);

    /**
     * Cache of trusted domains for DFS resolution
     */
    protected CacheEntry _domains = null; /* aka trusted domains cache */
    /**
     * Cache of DFS referrals
     */
    protected CacheEntry referrals = null;

    /**
     * Gets the map of trusted domains for DFS resolution

        Dfs.CacheEntry cacheEntry = new Dfs.CacheEntry(ttl);
        long expectedExpiration = System.currentTimeMillis() + ttl * 1000L;
        assertTrue(cacheEntry.expiration >= expectedExpiration - 100 && cacheEntry.expiration <= expectedExpiration + 100);
        assertNotNull(cacheEntry.map);

        // Test with TTL = 0, should use default TTL
        Dfs.CacheEntry cacheEntryDefault = new Dfs.CacheEntry(0);

     * @return
     */
    private static CacheEntry<DfsReferralDataInternal> cacheRootReferral(final CIFSContext tf, final String domain, final String root,
            final Map<String, CacheEntry<DfsReferralDataInternal>> roots, final DfsReferralDataInternal dr,
            CacheEntry<DfsReferralDataInternal> links) {
        if (dr != null) {
            links = new CacheEntry<>(tf.getConfig().getDfsTtl());

        // Step 2: Verify cache entry was created
        DirectoryCacheEntry cacheEntry = directoryLeaseManager.getCacheEntry(directoryPath);
        assertNotNull(cacheEntry);
        assertEquals(directoryPath, cacheEntry.getDirectoryPath());
        assertEquals(DirectoryCacheScope.IMMEDIATE_CHILDREN, cacheEntry.getScope());
        assertFalse(cacheEntry.isComplete());

        // Step 3: Verify can cache directory listing

  @Nullable V getIfCached(@Nullable Object key) {
    Entry<K, V> entry = cacheEntry; // store local reference for thread-safety

    // Check cache. We use == on purpose because it's cheaper and a cache miss is ok.
    if (entry != null && entry.getKey() == key) {
      return entry.getValue();
    }
    return null;
  }

  void clearCache() {
    cacheEntry = null;
  }

  }

  private void addToCache(K key, V value) {
    addToCache(new CacheEntry<K, V>(key, value));
  }

  private void addToCache(CacheEntry<K, V> entry) {
    // Slide new entry into first cache position. Drop previous entry in second cache position.
    cacheEntry2 = cacheEntry1;
    cacheEntry1 = entry;
  }

  private static final class CacheEntry<K, V> {
    final K key;
    final V value;

        // Verify cache entry was created
        DirectoryCacheEntry cacheEntry = directoryLeaseManager.getCacheEntry(directoryPath);
        assertNotNull(cacheEntry);
        assertEquals(directoryPath, cacheEntry.getDirectoryPath());
        assertEquals(expectedKey, cacheEntry.getLeaseKey());
        assertEquals(scope, cacheEntry.getScope());
    }

    @Test
    public void testGetCacheEntry() {

        this.resolveOrder = tc.getConfig().getResolveOrder();

        initCache(tc);
    }

    static final class CacheEntry {

        Name hostName;
        NbtAddress address;
        long expiration;

        CacheEntry(final Name hostName, final NbtAddress address, final long expiration) {
            this.hostName = hostName;
            this.address = address;

        if (CACHE_POLICY == 0) {
            return;
        }
        synchronized (ADDRESS_CACHE) {
            CacheEntry entry = (CacheEntry) ADDRESS_CACHE.get(hostName);
            if (entry == null) {
                entry = new CacheEntry(hostName, addr, expiration);
                ADDRESS_CACHE.put(hostName, entry);
            } else {
                entry.address = addr;

        Smb2LeaseKey leaseKey = baseLeaseManager.requestLease(directoryPath, requestedState);

        // Create directory cache entry
        DirectoryCacheEntry cacheEntry = new DirectoryCacheEntry(directoryPath, leaseKey, scope);
        directoryCache.put(directoryPath, cacheEntry);
        leaseToPath.put(leaseKey, directoryPath);

        // Start change notification if enabled
        Configuration config = context.getConfig();