APIs(context.Context) ([]madmin.KMSAPI, error)

	// Stat returns the current KMS status.
	Status(context.Context) (map[string]madmin.ItemState, error)

	// CreateKey creates a new key at the KMS with the given key ID.
	CreateKey(context.Context, *CreateKeyRequest) error

	ListKeys(context.Context, *ListRequest) ([]madmin.KMSKeyInfo, string, error)

	// GenerateKey generates a new data encryption key using the

		return []madmin.KMSKeyInfo{{Name: s.keyID}}, "", nil
	}
	return []madmin.KMSKeyInfo{}, "", 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
}

@RunWith(JUnit4.class)
@NullUnmarked
public final class InvalidatableSetTest {
  Set<Integer> wrappedSet;
  Set<Integer> copyOfWrappedSet;
  InvalidatableSet<Integer> setToTest;

  @Before
  public void createSets() {
    wrappedSet = new HashSet<>();
    wrappedSet.add(1);
    wrappedSet.add(2);
    wrappedSet.add(3);

    copyOfWrappedSet = ImmutableSet.copyOf(wrappedSet);
    setToTest =

        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 Set<Artifact> getArtifacts() {
            return artifacts;
        }

        public LifecycleExecutionException getException() {
            return exception;
        }
    }

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

            } else {
                return false;
            }
        }
    }

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

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

    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);

        }

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

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

        // 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,

        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);
    }

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

    @Override