assertNotNull(leaseManager.getLease(key1));
        assertNotNull(leaseManager.getLease(key2));

        leaseManager.releaseAll();

        assertNull(leaseManager.getLease(key1));
        assertNull(leaseManager.getLease(key2));
        assertTrue(leaseManager.getAllLeases().isEmpty());
    }

    @Test

public boolean canCacheRead() {
    if (leaseKey != null) {
        LeaseEntry entry = leaseManager.getLease(leaseKey);
        return entry != null && entry.hasReadCache();
    }
    return false;  // Fall back to oplock logic
}

public boolean canCacheWrite() {
    if (leaseKey != null) {
        LeaseEntry entry = leaseManager.getLease(leaseKey);
        return entry != null && entry.hasWriteCache();
    }
    return false;

        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            // Ignore
        }

        // When lease is lost, cache entry should be removed
        when(baseLeaseManager.getLease(leaseKey)).thenReturn(null);

        assertNull(directoryLeaseManager.getCacheEntry(directoryPath));
    }

    @Test
    public void testCanCacheDirectoryListing() {

        builder.setSnapshotPolicy(toRepositoryPolicy(repository.getSnapshots()));
        builder.setReleasePolicy(toRepositoryPolicy(repository.getReleases()));
        return builder.build();
    }

    public static RepositoryPolicy toRepositoryPolicy(org.apache.maven.model.RepositoryPolicy policy) {
        boolean enabled = true;

    }

    @Override
    public void setArtifactHandler(ArtifactHandler artifactHandler) {
        this.artifactHandler = artifactHandler;
    }

    @Override
    public void setRelease(boolean release) {
        this.release = release;
    }

    @Override
    public boolean isRelease() {
        return release;
    }

    @Override

        // Check if cache entry is valid
        if (entry != null && entry.needsRefresh()) {
            // Check if lease is still valid
            LeaseManager.LeaseEntry leaseEntry = baseLeaseManager.getLease(entry.getLeaseKey());
            if (leaseEntry == null || !leaseEntry.hasReadCache()) {
                // Lease lost, remove cache entry
                directoryCache.remove(directoryPath);
                return null;

        
        // Check if cache entry is valid
        if (entry != null && entry.needsRefresh()) {
            // Check if lease is still valid
            LeaseEntry leaseEntry = baseLeaseManager.getLease(entry.getLeaseKey());
            if (leaseEntry == null || !leaseEntry.hasReadCache()) {
                // Lease lost, remove cache entry
                directoryCache.remove(directoryPath);
                return null;

        File file = artifact.getFile();

        ArtifactRepositoryPolicy policy = artifact.isSnapshot() ? repository.getSnapshots() : repository.getReleases();

        if (!policy.isEnabled()) {
            if (getLogger().isDebugEnabled()) {
                getLogger()

      }
    }

    @Override
    void putThread(Waiter waiter, Thread newValue) {
      waiterThreadUpdater.setRelease(waiter, newValue);
    }

    @Override
    void putNext(Waiter waiter, @Nullable Waiter newValue) {
      waiterNextUpdater.setRelease(waiter, newValue);
    }

    @Override
    boolean casWaiters(

                    new RemoteRepository.Builder(repo.getId(), getLayout(repo), repo.getUrl());
            builder.setSnapshotPolicy(toPolicy(repo.getSnapshots()));
            builder.setReleasePolicy(toPolicy(repo.getReleases()));
            builder.setAuthentication(toAuthentication(repo.getAuthentication()));
            builder.setProxy(toProxy(repo.getProxy()));