this.keyServers = keyServers;
        this.ignoredKeys = ignoredKeys;
        this.trustedKeys = trustedKeys;
        this.keyringFormat = keyringFormat;
    }

    @Nullable
    public KeyringFormat getKeyringFormat() {
        return keyringFormat;
    }

    public boolean isVerifySignatures() {
        return verifySignatures;
    }

    public boolean isVerifyMetadata() {

    private DependencyVerificationConfiguration.KeyringFormat keyringFormat = null;

    public void setKeyringFormat(String newKeyringFormat) {
        this.keyringFormat = parseKeyringFormat(newKeyringFormat);
    }

    private DependencyVerificationConfiguration.KeyringFormat parseKeyringFormat(String keyringFormat) {
        if (keyringFormat == null) {
            return null;
        }
        try {

        @Nullable DependencyVerificationConfiguration.KeyringFormat effectiveFormat
    ) {
        this.keyringsRoot = keyringsRoot;

        File effectiveFile;
        if (effectiveFormat == DependencyVerificationConfiguration.KeyringFormat.ARMORED) {
            effectiveFile = getAsciiKeyringsFile();
        } else if (effectiveFormat == DependencyVerificationConfiguration.KeyringFormat.BINARY) {

        if (keyringFormat == null) {
            writeAsciiArmoredKeyRingFile(asciiArmoredFile, allKeyRings);
            writeBinaryKeyringFile(keyringFile, allKeyRings);
            LOGGER.lifecycle("Exported {} keys to {} and {}", allKeyRings.size(), keyringFile, asciiArmoredFile);
        } else if (keyringFormat.equals(DependencyVerificationConfiguration.KeyringFormat.ARMORED)) {

        DependencyVerificationConfiguration.KeyringFormat keyRingFormat = configuration.getKeyringFormat();
        if (keyRingFormat == null) {
            return;
        }
        writer.startElement(KEYRING_FORMAT);
        writer.write(String.valueOf(keyRingFormat).toLowerCase());
        writer.endElement();
    }

            builder.addKeyServer(new URI(uri))
        }

        void keyServer(URI uri) {
            builder.addKeyServer(uri)
        }

        void keyRingFormat(String keyRingFormat) {
            builder.setKeyringFormat(keyRingFormat);
        }

        void trust(String group, String name = null, String version = null, String fileName = null, boolean regex = false, String reason = null) {

"""
        then:
        verifier.configuration.keyringFormat == expectedResult

        where:
        formatLine                                 | expectedResult
        "<keyring-format>armored</keyring-format>" | DependencyVerificationConfiguration.KeyringFormat.ARMORED
        "<keyring-format>binary</keyring-format>"  | DependencyVerificationConfiguration.KeyringFormat.BINARY
        ""                                         | null

        null                  | true                        | false       | 'only ascii armored exists'
    }

    def "other formats should be ignored keyringFormat=#keyringFormat is specified when #hint"() {
        // key will not be published on the server fixture but available locally
        def keyring = newKeyRing()
        def pkId = toHexString(keyring.publicKey.fingerprint)

        def keyring = newKeyRing()
        def pkId = Fingerprint.of(keyring.publicKey)
        createMetadataFile {
            keyServer(keyServerFixture.uri)
            keyRingFormat("binary")
        }

        given:
        javaLibrary()
        uncheckedModule("org", "foo", "1.0") {
            withSignature {