List<ResolvedArtifactSet> resolvedArtifactSets = new ArrayList<>(artifactsById.size());
        for (ArtifactSet artifactSet : artifactsById) {
            ResolvedArtifactSet resolvedArtifacts = artifactSet.select(variantSelector, spec);
            if (!lenient || !(resolvedArtifacts instanceof UnavailableResolvedArtifactSet)) {

import org.gradle.api.artifacts.dsl.LockMode

class DependencyLockingLenientModeIntegrationTest extends AbstractLockingIntegrationTest {
    @Override
    LockMode lockMode() {
        return LockMode.LENIENT
    }

    def 'does not fail when lock file conflicts with declared strict constraint (initial unique: #unique)'() {
        given:
        mavenRepo.module('org', 'foo', '1.0').publish()

                        e -> e.getKey().toString(), e -> e.getValue().toString()));
        //        lenient().when(session.getSystemProperties()).thenReturn(map);
        //        lenient().when(session.getUserProperties()).thenReturn(Collections.emptyMap());

        Mockito.lenient()
                .when(session.getService(SettingsXmlFactory.class))
                .thenReturn(new DefaultSettingsXmlFactory());
    }

     *
     * @param variantSelector Performs variant selection
     * @param spec Governs how artifacts are selected
     * @param lenient If true, ignore artifacts that are resolved, but unavailable
     */
    SelectedArtifactResults select(ArtifactVariantSelector variantSelector, ArtifactSelectionSpec spec, boolean lenient);

import static org.gradle.kotlin.dsl.resolver.KotlinBuildScriptModelRequestKt.newCorrelationId

class KotlinScriptModelParameters {
    static setModelParameters(modelBuilder, boolean lenient, boolean explicitlyRequestPreparationTasks = true, Iterable<File> scripts = []) {
        if (lenient) {
            modelBuilder.setJvmArguments([KotlinDslModelsParameters.CLASSPATH_MODE_SYSTEM_PROPERTY_DECLARATION])
        } else {

        selected.getArtifacts().sets == [variant1Artifacts, variant2Artifacts]

        selected.getArtifactsWithId(0) == variant1Artifacts
        selected.getArtifactsWithId(1) == variant2Artifacts
    }

    def "lenient selection includes selected variant of each node"() {
        def artifacts1 = Stub(ArtifactSet)
        def artifacts2 = Stub(ArtifactSet)
        def variant1Artifacts = Stub(ResolvedArtifactSet)

    classDirectories.from(classesPath.getIncoming().getFiles())
    sourceDirectories.from(sourcesPath.getIncoming().artifactView { lenient(true) }.getFiles())
    executionData(coverageDataPath.getIncoming().artifactView { lenient(true) }.getFiles().filter { it.exists() })

    reports {
        html.required = true
        xml.required = true
    }
}

val codeCoverageReport by tasks.registering(JacocoReport::class) {
    additionalClassDirs(classesPath.filter { it.isDirectory() })
    additionalSourceDirs(sourcesPath.incoming.artifactView { lenient(true) }.files)
    executionData(coverageDataPath.incoming.artifactView { lenient(true) }.files.filter { it.exists() })

    reports {
        html.required = true
        xml.required = true
    }
}

 * and fail <i>as soon as possible</i>, to avoid as much compromising of
 * the builds as possible.
 *
 * There are, however, two additional modes which can be used: the lenient
 * one will collect all errors but only log them to the CLI. This is useful
 * when updating the file and you want to collect as many errors as possible
 * before failing.
 *

     * Returns successfully resolved files. Ignores dependencies or files that cannot be resolved.
     *
     * @param dependencySpec dependency spec
     * @return resolved dependencies files
     *
     * @deprecated Use a lenient {@link ArtifactView} with a {@code componentFilter} instead.
     */
    @Deprecated
    Set<File> getFiles(Spec<? super Dependency> dependencySpec);

    /**