private final AtomicInteger evictionCounter = new AtomicInteger(0);
    private final String cacheId;
    private final int maxSize;
    private final int logInterval;
    private final Logger logger;
    private Cache<Object, Object> cache;

    LoggingEvictionListener(String cacheId, int maxSize, Logger logger) {
        this.cacheId = cacheId;
        this.maxSize = maxSize;
        this.logInterval = maxSize / 10;

		</attributes>
	</classpathentry>
	<classpathentry sourcepath="@CACHE_DIR@/joda-time/joda-time/2.5/@SHA1@/joda-time-2.5-sources.jar" kind="lib" path="@CACHE_DIR@/joda-time/joda-time/2.5/@SHA1@/joda-time-2.5.jar">
		<attributes>
			<attribute name="javadoc_location" value="jar:file:@CACHE_DIR@/joda-time/joda-time/2.5/@SHA1@/joda-time-2.5-javadoc.jar!/"/>
			<attribute name="gradle_used_by_scope" value="main,test"/>

		<attributes>
			<attribute name="javadoc_location" value="jar:file:@CACHE_DIR@/joda-time/joda-time/2.5/@SHA1@/joda-time-2.5-javadoc.jar!/"/>
			<attribute name="gradle_used_by_scope" value="main,test"/>
			<attribute name="org.eclipse.jst.component.nondependency" value=""/>
		</attributes>

			t.Fatalf("Unexpected error: %v", err)
		}
	}

	cacher, _, err := newTestCacher(etcdStorage)
	if err != nil {
		t.Fatalf("Couldn't create cacher: %v", err)
	}
	defer cacher.Stop()

	// Given that cacher is always initialized from the "current" version of etcd,
	// we now have a cacher with an empty cache of watch events and a resourceVersion of rv.

    private final Cache<Object, Object> inMemoryCache;
    private final String cacheId;
    private final AtomicReference<FileLock.State> fileLockStateReference;

    public InMemoryDecoratedCache(MultiProcessSafeAsyncPersistentIndexedCache<K, V> delegate, Cache<Object, Object> inMemoryCache, String cacheId, AtomicReference<FileLock.State> fileLockStateReference) {
        this.delegate = delegate;

	<classpathentry sourcepath="@CACHE_DIR@/commons-collections/commons-collections/3.2.2/@SHA1@/commons-collections-3.2.2-sources.jar" kind="lib" path="@CACHE_DIR@/commons-collections/commons-collections/3.2.2/@SHA1@/commons-collections-3.2.2.jar">
		<attributes>
			<attribute name="javadoc_location" value="jar:file:@CACHE_DIR@/commons-collections/commons-collections/3.2.2/@SHA1@/commons-collections-3.2.2-javadoc.jar!/"/>

    private static final String CACHE_ID = "md-rule";

    public static boolean isMetadataRuleExecutorCache(InMemoryCacheController controller) {
        return CACHE_ID.equals(controller.getCacheId());
    }

    private static Transformer<Object, ModuleComponentResolveMetadata> getKeyToSnapshotableTransformer() {

            task first {
                outputs.file file("first.txt")
                outputs.cacheIf { true }
                doFirst {
                    file("first.txt").text = "Hello from the first task"
                }
            }

            task second {
                outputs.file file("second.txt")
                outputs.cacheIf { true }
                doFirst {

			Indexers:       indexers,
			Codec:          storageConfig.Codec,
		}
		cacher, err := cacherstorage.NewCacherFromConfig(cacherConfig)
		if err != nil {
			return nil, func() {}, err
		}
		var once sync.Once
		destroyFunc := func() {
			once.Do(func() {
				cacher.Stop()
				d()
			})
		}

		return cacher, destroyFunc, nil
	}
}

func objectTypeToArgs(obj runtime.Object) []interface{} {

        //    using a 2-level map (by group, then by name)
        //    using an interned string for the cachedId (interning turned out to cost as much as what we gain from faster checks in maps)
        //
        // And none of them reached the performance of just using a good old string
        this.cachedId = group + ":" + name;
    }

    private int computeHashcode(String group, String name, @Nullable String version) {