DirectoryCacheEntry entry1 = directoryLeaseManager.getCacheEntry(dir1);
        DirectoryCacheEntry entry2 = directoryLeaseManager.getCacheEntry(dir2);

        assertNotNull(entry1);
        assertNotNull(entry2);
        assertEquals(DirectoryCacheScope.IMMEDIATE_CHILDREN, entry1.getScope());
        assertEquals(DirectoryCacheScope.RECURSIVE_TREE, entry2.getScope());

        // Update first directory cache

        assertNotNull(key);
        LeaseEntry entry = leaseManager.getLease(key);
        assertNotNull(entry);
        assertEquals(requestedState, entry.getLeaseState());
        assertEquals(path, entry.getPath());
        assertEquals(1, entry.getEpoch());
        assertFalse(entry.isBreaking());
    }

    @Test
    @DisplayName("Should reuse existing lease for same path")

    }

    /**
     * Get cache entry for a directory
     *
     * @param directoryPath directory path
     * @return cache entry or null
     */
    public DirectoryCacheEntry getCacheEntry(String directoryPath) {
        DirectoryCacheEntry entry = directoryCache.get(directoryPath);

        // Check if cache entry is valid
        if (entry != null && entry.needsRefresh()) {

func (o *listPathOptions) shouldSkip(ctx context.Context, entry metaCacheEntry) (yes bool) {
	if !o.IncludeDirectories && (entry.isDir() || (!o.Versioned && entry.isObjectDir() && entry.isLatestDeletemarker())) {
		return true
	}
	if o.Marker != "" && entry.name < o.Marker {
		return true
	}
	if !strings.HasPrefix(entry.name, o.Prefix) {
		return true
	}

        LeaseEntry entry = leases.get(key);
        if (entry != null) {
            log.info("Handling lease break for {} from state 0x{} to 0x{}", key, Integer.toHexString(entry.getLeaseState()),
                    Integer.toHexString(newState));

            entry.setBreaking(true);
            int oldState = entry.getLeaseState();
            entry.updateState(newState);

        // Add some children
        entry.updateChild("file1.txt", 1024L, 1000L, false, 0x20, 500L, 800L);
        entry.updateChild("file2.txt", 2048L, 2000L, false, 0x20, 600L, 900L);
        entry.markComplete();

        // Invalidate the cache
        entry.invalidate();

        assertFalse(entry.isComplete());
        assertTrue(entry.hasChanges());
        assertTrue(entry.getChildren().isEmpty());
    }

		return
	}

	// Check for abandoned entries.
	found := make(map[string]struct{}, len(d.Cache))

	// Mark all children recursively
	var mark func(entry dataUsageEntry)
	mark = func(entry dataUsageEntry) {
		for k := range entry.Children {
			found[k] = struct{}{}
			if ch, ok := d.Cache[k]; ok {
				mark(ch)
			}
		}
	}
	found[top] = struct{}{}
	mark(*topE)

	// Initialize sync waitgroup.
	g := errgroup.WithNErrs(len(localDrives))

	// Disk states slices
	beforeState := make([]string, len(localDrives))
	afterState := make([]string, len(localDrives))

	// Make a volume entry on all underlying storage disks.
	for index := range localDrives {
		g.Go(func() (serr error) {
			if localDrives[index] == nil {
				beforeState[index] = madmin.DriveStateOffline

    private AuditEntry getAuditEntry() {
        AuditEntry entry = auditEntryPool.poll();
        if (entry == null) {
            entry = new AuditEntry();
        } else {
            // Reset the entry
            entry.context = null;
            entry.message = null;
            entry.eventType = null;
            entry.severity = null;
            entry.timestamp = null;
        }
        return entry;
    }

                DirectoryCacheScope.IMMEDIATE_CHILDREN);

        // Now cache entry should exist
        DirectoryCacheEntry entry = directoryLeaseManager.getCacheEntry(directoryPath);
        assertNotNull(entry);
        assertEquals(directoryPath, entry.getDirectoryPath());
    }

    @Test
    public void testGetCacheEntryWithExpiredLease() {
        String directoryPath = "/test/dir";