when:
        def scaled = heapProportionalCacheSizer.scaleCacheSize(100, 100)
        then:
        scaled >= 100
    }

    def "cache cap sizer adjusts caps based on maximum heap size"() {
        given:
        def heapProportionalCacheSizer = new HeapProportionalCacheSizer(maxHeapMB)

        when:
        def caps = heapProportionalCacheSizer.scaleCacheSize(2000)

        then:
        caps == expectedCaps

        return Math.max(ratioToDefaultAvailableHeap, MIN_RATIO);
    }

    public int scaleCacheSize(int referenceValue) {
        return scaleCacheSize(referenceValue, 100);
    }

    private int scaleCacheSize(int referenceValue, int granularity) {
        if (referenceValue < granularity) {

    public CachingPatternSpecFactory() {
        cacheSizer = new HeapProportionalCacheSizer();
        specInstanceCache = CacheBuilder.newBuilder().maximumSize(cacheSizer.scaleCacheSize(INSTANCES_MAX_SIZE)).build();
    }

    @Override
    protected Spec<FileTreeElement> createSpec(final Collection<String> patterns, final boolean include, final boolean caseSensitive) {

        this.maximumLockingTimeMillis = 5000;
        HeapProportionalCacheSizer heapProportionalCacheSizer = new HeapProportionalCacheSizer();
        int queueCapacity = Math.min(4000, heapProportionalCacheSizer.scaleCacheSize(40000));
        workQueue = new ArrayBlockingQueue<Runnable>(queueCapacity, true);
    }

    @Override
    public void enqueue(Runnable task) {
        addToQueue(task);
    }

            // Short-lived process, don't cache in memory
            LOG.debug("Creating cache {} without in-memory store.", cacheId);
            return backingCache;
        }
        int targetSize = cacheSizer.scaleCacheSize(maxEntriesToKeepInMemory);
        CacheDetails cacheDetails = getCache(cacheId, targetSize);
        return new InMemoryDecoratedCache<>(backingCache, cacheDetails.entries, cacheId, cacheDetails.lockState);
    }