interface PluginDescriptorSupplier {
        PluginDescriptor load()
                throws PluginResolutionException, PluginDescriptorParsingException, InvalidPluginDescriptorException;
    }

    Key createKey(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session);

    void put(Key key, PluginDescriptor pluginDescriptor);

    PluginDescriptor get(Key key);

	defer k.Close()

	testKName := randKeyName("TestCreateOpenDeleteKey_")

	testK, exist, err := registry.CreateKey(k, testKName, registry.CREATE_SUB_KEY)
	if err != nil {
		t.Fatal(err)
	}
	defer testK.Close()

	if exist {
		t.Fatalf("key %q already exists", testKName)
	}

	testKAgain, exist, err := registry.CreateKey(k, testKName, registry.CREATE_SUB_KEY)
	if err != nil {
		t.Fatal(err)
	}
	defer testKAgain.Close()

        // marker interface for cache keys
    }

    @FunctionalInterface
    interface PluginRealmSupplier {
        CacheRecord load() throws PluginResolutionException, PluginContainerException;
    }

    Key createKey(
            Plugin plugin,
            ClassLoader parentRealm,
            Map<String, ClassLoader> foreignImports,
            DependencyFilter dependencyFilter,
            List<RemoteRepository> repositories,

		return []string{s.keyID}, "", nil
	}
	return []string{}, "", nil
}

// CreateKey returns ErrKeyExists unless req.Name is equal to the secretKey name.
// The builtin KMS does not support creating multiple keys.
func (s secretKey) CreateKey(_ context.Context, req *CreateKeyRequest) error {
	if req.Name != s.keyID {
		return ErrNotSupported
	}
	return ErrKeyExists
}

        CacheRecord(ClassRealm realm, DependencyFilter extensionArtifactFilter) {
            this.realm = realm;
            this.extensionArtifactFilter = extensionArtifactFilter;
        }
    }

    Key createKey(List<? extends ClassRealm> extensionRealms);

    CacheRecord get(Key key);

    CacheRecord put(Key key, ClassRealm projectRealm, DependencyFilter extensionArtifactFilter);

    void flush();

    /**

        public Set<Artifact> getArtifacts() {
            return artifacts;
        }

        public LifecycleExecutionException getException() {
            return exception;
        }
    }

    Key createKey(
            MavenProject project,
            Collection<String> scopesToCollect,
            Collection<String> scopesToResolve,
            boolean aggregating,
            RepositorySystemSession session);

        public ExtensionDescriptor getDescriptor() {
            return descriptor;
        }

        public List<Artifact> getArtifacts() {
            return artifacts;
        }
    }

    Key createKey(List<Artifact> extensionArtifacts);

    CacheRecord get(Key key);

    CacheRecord put(
            Key key, ClassRealm extensionRealm, ExtensionDescriptor extensionDescriptor, List<Artifact> artifacts);

        }

        public CacheRecord(PluginResolutionException exception) {
            this.artifacts = null;
            this.exception = exception;
        }
    }

    Key createKey(
            Plugin plugin,
            DependencyFilter extensionFilter,
            List<RemoteRepository> repositories,
            RepositorySystemSession session);

        public String toString() {
            return extensionRealms.toString();
        }
    }

    protected final Map<Key, CacheRecord> cache = new ConcurrentHashMap<>();

    @Override
    public Key createKey(List<? extends ClassRealm> extensionRealms) {
        return new CacheKey(extensionRealms);
    }

    public CacheRecord get(Key key) {
        return cache.get(key);
    }

                    && Objects.equals(filter, that.filter);
        }
    }

    protected final Map<Key, CacheRecord> cache = new ConcurrentHashMap<>();

    public Key createKey(
            Plugin plugin,
            DependencyFilter extensionFilter,
            List<RemoteRepository> repositories,
            RepositorySystemSession session) {