generator
    }

    private static class Holder {
        static final KeyRing VALID_KEYRING = new KeyRing("gradle")
        static final KeyRing INVALID_KEYRING = new KeyRing("invalid-key-ring")
    }

    private static class KeyRing {
        private final PgpSignatory signatory
        private final PGPPublicKey publicKey
        private final PGPSecretKey secretKey

	for _, key := range stringKeys {
		provider := providers[key]
		if provider.Enabled() {
			klog.V(4).Infof("Registering credential provider: %v", key)
			keyring.Providers = append(keyring.Providers, provider)
		}
	}

	return keyring

        private FirstMatchBuilder(PublicKeyResultBuilder delegate) {
            this.delegate = delegate;
        }

        @Override
        public void keyRing(PGPPublicKeyRing keyring) {
            delegate.keyRing(keyring);
            hasResult = true;
        }

        @Override
        public void publicKey(PGPPublicKey publicKey) {
            delegate.publicKey(publicKey);

            } else {
                PgpKeyId expectedKeyId = new PgpKeyId(keyId);
                for (PGPSecretKeyRing keyring : new JcaPGPSecretKeyRingCollection(in)) {
                    for (PGPSecretKey key : keyring) {
                        if (expectedKeyId.equals(new PgpKeyId(key.getKeyID()))) {
                            return factory.createSignatory(name, key, password);

[source,bash]
----
$ gpg --no-default-keyring --keyring gradle/verification-keyring.gpg --recv-keys 8756c4f765c9ac3cb6b85d62379ce192d401ab61

gpg: keybox 'gradle/verification-keyring.gpg' created
gpg: key 379CE192D401AB61: public key "Bintray (by JFrog) <****>" imported
gpg: Total number processed: 1
gpg:               imported: 1

import javax.annotation.Nullable;
import java.io.File;

public class BuildTreeDefinedKeys {
    private static final String VERIFICATION_KEYRING_GPG = "verification-keyring.gpg";
    private static final String VERIFICATION_KEYRING_ASCII = "verification-keyring.keys";

    private final KeyringFilePublicKeyService keyService;
    private final File keyringsRoot;

    private final File effectiveKeyringsFile;

    }

    /**
     * Returns the number of keys in the given keyring.
     * There is no public API to do this, so we use reflection to access the private field.
     * Public keys iterator is not used because it would require O(n) time to count the keys.
     */
    @SuppressWarnings("unchecked")
    public static int getSize(PGPPublicKeyRing keyring) {
        try {

            throw new RuntimeException(e);
        }
    }

    public static PGPPublicKeyRing strip(PGPPublicKeyRing keyring, KeyFingerPrintCalculator fingerprintCalculator) {
        List<PGPPublicKey> strippedKeys = StreamSupport
            .stream(keyring.spliterator(), false)
            .map(key -> stripKey(key, fingerprintCalculator))
            .collect(Collectors.toList());

        "<keyring-format>armored</keyring-format>" | DependencyVerificationConfiguration.KeyringFormat.ARMORED
        "<keyring-format>binary</keyring-format>"  | DependencyVerificationConfiguration.KeyringFormat.BINARY
        ""                                         | null
    }

    def "reasonable error message when invalid invalid keyring format given"() {
        when:

 */
package org.gradle.security.internal;

import org.bouncycastle.openpgp.PGPPublicKey;
import org.bouncycastle.openpgp.PGPPublicKeyRing;

public interface PublicKeyResultBuilder {
    void keyRing(PGPPublicKeyRing keyring);
    void publicKey(PGPPublicKey publicKey);