import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class DependencyVerifierBuilder {
    private static final Comparator<ModuleComponentIdentifier> MODULE_COMPONENT_IDENTIFIER_COMPARATOR = Comparator.comparing(ModuleComponentIdentifier::getGroup)
        .thenComparing(ModuleComponentIdentifier::getModule)

        )
        def componentArtifactIdentified = new DefaultModuleComponentArtifactIdentifier(
            moduleComponentIdentifier, "artifact", "jar", ".jar"
        )

        def dependencyVerifier = new DependencyVerifierBuilder.ComponentVerificationsBuilder(moduleComponentIdentifier);
        keyIds.forEach {
            dependencyVerifier.addTrustedKey(componentArtifactIdentified, it)
        }

        when:

    private static final Joiner GROUP_JOINER = Joiner.on("[.]");

    private final DependencyVerifierBuilder verificationsBuilder;
    private final Set<VerificationEntry> entriesToBeWritten;

    PgpKeyGrouper(DependencyVerifierBuilder dependencyVerifierBuilder, Set<VerificationEntry> entriesToBeWritten) {
        this.verificationsBuilder = dependencyVerifierBuilder;
        this.entriesToBeWritten = entriesToBeWritten;
    }

                throw UncheckedException.throwAsUncheckedException(e);
            }
        }
    }

    public static DependencyVerifier readFromXml(InputStream in) {
        DependencyVerifierBuilder builder = new DependencyVerifierBuilder();
        readFromXml(in, builder);
        return builder.build();
    }

    private static SAXParser createSecureParser() throws ParserConfigurationException, SAXException {

import org.gradle.api.internal.artifacts.verification.verifier.DependencyVerifierBuilder
import org.gradle.internal.component.external.model.DefaultModuleComponentIdentifier
import org.gradle.internal.component.external.model.ModuleComponentFileArtifactIdentifier
import spock.lang.Specification

class PgpKeyGrouperTest extends Specification {
    private DependencyVerifierBuilder builder = new DependencyVerifierBuilder()
    private DependencyVerifier verifier

                assert expectedChecksums == actualChecksums
            }
        }
    }

    static class Builder {
        private final DependencyVerifierBuilder builder = new DependencyVerifierBuilder()

        void disableKeyServers() {
            builder.useKeyServers = false
        }

        void noMetadataVerification() {
            builder.verifyMetadata = false

import javax.xml.validation.Schema
import javax.xml.validation.SchemaFactory

class DependencyVerificationsXmlWriterTest extends Specification {
    private final DependencyVerifierBuilder builder = new DependencyVerifierBuilder()
    private String rawContents
    private String contents

    private Map<String, Schema> schemas = loadSchemas()

    def "can write an empty file"() {
        when:

    private static final String KEY_NOT_DOWNLOADED = "Key couldn't be downloaded from any key server";

    private final DependencyVerifierBuilder verificationsBuilder = new DependencyVerifierBuilder();
    private final BuildOperationExecutor buildOperationExecutor;
    private final List<String> checksums;

Class <org.gradle.api.internal.artifacts.verification.verifier.DependencyVerifierBuilder$ChecksumBuilder> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (DependencyVerifierBuilder.java:0)