boolean verifyMetadata,
        boolean verifySignatures,
        List<TrustedArtifact> trustedArtifacts,
        boolean useKeyServers,
        List<URI> keyServers,
        Set<IgnoredKey> ignoredKeys,
        List<TrustedKey> trustedKeys,
        @Nullable KeyringFormat keyringFormat
    ) {
        this.verifyMetadata = verifyMetadata;
        this.verifySignatures = verifySignatures;

"""
        then:
        verifier.configuration.verifyMetadata == verifyMetadata
        verifier.configuration.verifySignatures == verifySignatures
        verifier.configuration.keyServers == []

        where:
        verifyMetadata | verifySignatures
        false          | false
        false          | true
        true           | false
        true           | true

    }

    def "parses key servers"() {

    def "can write an empty file"() {
        when:
        builder.verifyMetadata = verifyMetadata
        builder.verifySignatures = verifySignatures
        serialize()

        then:
        contents == """<?xml version="1.0" encoding="UTF-8"?>
<verification-metadata>
   <configuration>
      <verify-metadata>$verifyMetadata</verify-metadata>
      <verify-signatures>$verifySignatures</verify-signatures>

        byComponent.computeIfAbsent(componentIdentifier, ComponentVerificationsBuilder::new)
            .addIgnoredKey(artifact, key);
    }

    public void setVerifyMetadata(boolean verifyMetadata) {
        isVerifyMetadata = verifyMetadata;
    }

    public boolean isVerifyMetadata() {
        return isVerifyMetadata;
    }

    public boolean isVerifySignatures() {
        return isVerifySignatures;
    }

            TomlParseResult result = Toml.parse(inputStream);
            assertNoParseErrors(result);
            TomlTable metadataTable = result.getTable(METADATA_KEY);
            verifyMetadata(metadataTable);
            TomlTable librariesTable = result.getTable(LIBRARIES_KEY);
            TomlTable bundlesTable = result.getTable(BUNDLES_KEY);
            TomlTable versionsTable = result.getTable(VERSIONS_KEY);

        void disableKeyServers() {
            builder.useKeyServers = false
        }

        void noMetadataVerification() {
            builder.verifyMetadata = false
        }

        void verifySignatures() {
            builder.verifySignatures = true
        }

        void keyServer(String uri) {
            builder.addKeyServer(new URI(uri))

                    assertValidComponent();
                    currentArtifact = createArtifactId(attributes);
                    break;
                case VERIFY_METADATA:
                    assertInConfiguration(VERIFY_METADATA);
                    inVerifyMetadata = true;
                    break;
                case VERIFY_SIGNATURES:
                    assertInConfiguration(VERIFY_SIGNATURES);

    static final String TRUSTING = "trusting";
    static final String URI = "uri";
    static final String VALUE = "value";
    static final String VERIFICATION_METADATA = "verification-metadata";
    static final String VERIFY_METADATA = "verify-metadata";
    static final String VERIFY_SIGNATURES = "verify-signatures";
    static final String VERSION = "version";
    static final String KEYRING_FORMAT = "keyring-format";

import static org.gradle.api.internal.artifacts.verification.serializer.DependencyVerificationXmlTags.VERIFICATION_METADATA;
import static org.gradle.api.internal.artifacts.verification.serializer.DependencyVerificationXmlTags.VERIFY_METADATA;
import static org.gradle.api.internal.artifacts.verification.serializer.DependencyVerificationXmlTags.VERIFY_SIGNATURES;
import static org.gradle.api.internal.artifacts.verification.serializer.DependencyVerificationXmlTags.VERSION;