for (Map.Entry<Class<?>, SerializerFactory<?>> entry : serializerMap.entrySet()) {
            if (baseType.isAssignableFrom(entry.getKey())) {
                matches.put(entry.getKey(), entry.getValue());
            }
        }
        Set<Class<?>> matchingJavaSerialization = new LinkedHashSet<Class<?>>();
        for (Class<?> candidate : javaSerialization.keySet()) {

    }

    @Override
    public void run() {

        try {
            while (!stopped.get()) {
                Cleanup entry = (Cleanup) referenceQueue.remove();
                ClassPath key = entry.getKey();
                removeCacheEntry(key, entry, DONT_CLOSE_CLASSLOADER);
            }
        } catch (InterruptedException ex) {
            Thread.currentThread().interrupt();
        }
    }

    override fun getKey(): SecretKey = secretKey

    override val sourceDescription: String
        get() = "$GRADLE_ENCRYPTION_KEY_ENV_KEY environment variable"

    companion object {
        const val GRADLE_ENCRYPTION_KEY_ENV_KEY = "GRADLE_ENCRYPTION_KEY"
    }
}


private
class NoEncryptionKeySource : SecretKeySource {
    override fun getKey(): SecretKey? {

            return ImmutableMap.of();
        }
        return forkOptions.getEnvironment().entrySet().stream()
            .filter(entry -> INHERITED_UNIX_ENVIRONMENT.matcher(entry.getKey()).matches())
            .collect(ImmutableMap.toImmutableMap(Map.Entry::getKey, Map.Entry::getValue));
    }

    @Override
    public JavaForkOptions getForkOptions() {
        return forkOptions;
    }

    @Override

	id   collectionUID
}

func NewStaticCollection[T any](vals []T) Collection[T] {
	res := map[Key[T]]T{}
	for _, v := range vals {
		res[GetKey(v)] = v
	}
	return &staticList[T]{
		vals: res,
		id:   nextUID(),
	}
}

func (s *staticList[T]) GetKey(k Key[T]) *T {
	if o, f := s.vals[k]; f {
		return &o
	}
	return nil
}

// nolint: unused // (not true, its to implement an interface)

      rowBuilder.put(row.getKey(), ImmutableMap.copyOf(row.getValue()));
    }
    this.rowMap = rowBuilder.buildOrThrow();

    ImmutableMap.Builder<C, ImmutableMap<R, V>> columnBuilder =
        new ImmutableMap.Builder<>(columns.size());
    for (Entry<C, Map<R, V>> col : columns.entrySet()) {
      columnBuilder.put(col.getKey(), ImmutableMap.copyOf(col.getValue()));
    }

    }

    private TestFileCacheEntry getTestFileCacheEntry(String cacheKey) {
        return new TestFileCacheEntry(cacheKey, new TestFile(cacheDir, cacheKey))
    }

    interface TestCacheEntry {
        String getKey()
        String getMd5Hash()
        String getText()
        void setText(String text)
        byte[] getBytes()
        void setBytes(byte[] bytes)
        void copyBytesTo(TestFile file)
    }

        assertThat(entry.getKey().getName(), is("T1"));
        assertThat(entry.getValue(), is(sameClass(Integer.class)));
        entry = it.next();
        assertThat(entry.getKey().getName(), is("T2"));
        assertThat(entry.getValue(), is(sameClass(Long.class)));
        entry = it.next();
        assertThat(entry.getKey().getName(), is("T1"));

                value = resourceName;
            }

            if (value != null) {
                for (final Map.Entry<Pattern, String> entry : passwordMap.entrySet()) {
                    if (entry.getKey().matcher(value).matches()) {
                        return entry.getValue();
                    }
                }
            }
        }

        if (params != null && url != null) {

        }

        for (Map.Entry<String, Integer> entry : added.entrySet()) {
            assertThat(cache.get(entry.getKey()), equalTo(entry.getValue()));
        }

        cache.reset();

        for (Map.Entry<String, Integer> entry : added.entrySet()) {
            assertThat(cache.get(entry.getKey()), equalTo(entry.getValue()));
        }

        return added;
    }