// dataUsageCacheV2 contains a cache of data usage entries version 2.
type dataUsageCacheV2 struct {
	Info  dataUsageCacheInfo
	Cache map[string]dataUsageEntryV2
}

// dataUsageCacheV3 contains a cache of data usage entries version 3.
type dataUsageCacheV3 struct {
	Info  dataUsageCacheInfo
	Cache map[string]dataUsageEntryV3
}

// dataUsageCacheV4 contains a cache of data usage entries version 4.

		newCache.buildUserGroupMemberships()
	}

	cache := store.lock()
	defer store.unlock()

	// We should only update the in-memory cache if there were no changes
	// to the in-memory cache since the disk loading began. If there
	// were changes to the in-memory cache we should wait for the next
	// cycle until we can safely update the in-memory cache.
	//
	// An in-memory cache must be replaced only if we know for sure that the

			b.debugf("cache %s not worth keeping", id)
			remove[id] = struct{}{}
			continue
		}
		if cache.id != id {
			logger.Info("cache ID mismatch %s != %s", id, cache.id)
			remove[id] = struct{}{}
			continue
		}
		if cache.bucket != b.bucket {
			logger.Info("cache bucket mismatch %s != %s", b.bucket, cache.bucket)
			remove[id] = struct{}{}
			continue
		}
	}

        }

        // Next get should return the same instance from cache
        byte[] reused = impl.getBuffer();
        assertSame(b, reused, "Buffer should be reused from cache");
        // And it should still be zeroed
        for (byte value : reused) {
            assertEquals(0, value, "Reused buffer must be zeroed");
        }
    }

    // Edge: cache size 0 means nothing is cached; release still zeroes argument
    @Test

                s.acctName = "userX";
            }
            return null;
        }).when(cache).resolveSids0(any(), any(), any());

        cache.resolveSids(ctx, null, arr, 2, 1); // resolve only s3

        // Verify cache behavior - after reset, spying on the same cache won't work
        // Since we're working with internal state, we'll verify the side effects

    }

    /**
     * Gets the cache scope (ALL or IMMEDIATE_CHILDREN)
     * @return the cache scope
     */
    public DirectoryCacheScope getScope() {
        return scope;
    }

    /**
     * Sets the cache scope for this directory cache
     * @param scope the cache scope to set
     */
    public void setScope(DirectoryCacheScope scope) {
        this.scope = scope;
    }

        Arrays.fill(buf, (byte) 0);
        synchronized (this.cache) {
            if (this.freeBuffers < this.cache.length) {
                for (int i = 0; i < this.cache.length; i++) {
                    if (this.cache[i] == null) {
                        this.cache[i] = buf;
                        this.freeBuffers++;
                        return;
                    }

					return
				default:
				}

				// Load cache for bucket
				cacheName := pathJoin(bucket.Name, dataUsageCacheName)
				cache := dataUsageCache{}
				scannerLogIf(ctx, cache.load(ctx, er, cacheName))
				if cache.Info.Name == "" {
					cache.Info.Name = bucket.Name
				}
				cache.Info.SkipHealing = healing
				cache.Info.NextCycle = wantCycle
				if cache.Info.Name != bucket.Name {

        // Cache should be invalidated
        assertFalse(cacheEntry.isComplete());

        // Step 9: Test lease break
        // Re-populate cache
        directoryLeaseManager.updateDirectoryCache(directoryPath, files);
        assertTrue(cacheEntry.isComplete());

        // Simulate lease break with loss of read cache

        when(mockFile2.lastAccess()).thenReturn(900L);

        // Update cache
        List<SmbFile> files = Arrays.asList(mockFile1, mockFile2);
        directoryLeaseManager.updateDirectoryCache(directoryPath, files);

        // Verify cache entry was updated (test the cache content directly)
        DirectoryCacheEntry cacheEntry = directoryLeaseManager.getCacheEntry(directoryPath);