doLast {
                    def filesA = configurations.first.incoming.artifactView { lenient = true }.files.files*.name
                    def filesB = configurations.second.incoming.artifactView { lenient = true }.files.files*.name
                    def filesC = configurations.third.incoming.artifactView { lenient = true }.files.files*.name
                    println "Resolved: \${filesA} \${filesB} \${filesC}"

}
"""

        lockfileFixture.createLockfile('lockedConf',['org:foo:1.0'], unique)

        def constraintVersion = lockMode() == LockMode.LENIENT ? "1.0" : "{strictly 1.0}"
        def extraReason = lockMode() == LockMode.LENIENT ? " (update/lenient mode)" : ""

        when:
        succeeds 'checkDeps'

        then:
        resolve.expectDefaultConfiguration('runtime')
        resolve.expectGraph {

        val sourcesPath by configurations.getting
        val docsPath by configurations.getting

        with(binDistributionSpec())
        from(sourcesPath.incoming.artifactView { lenient(true) }.files) {
            eachFile {
                val subprojectFolder = file.containingSubprojectFolder(listOf("src", "main", "java").size + relativeSourcePath.segments.size)

            .withUpgradeGuideSection(8, "deprecate_filtered_configuration_file_and_filecollection_methods")
            .nagUser();

        rethrowFailure();

        // Disable deprecation, since the lenient configuration method also emits a deprecation warning
        return DeprecationLogger.whileDisabled(() -> configuration.getFirstLevelModuleDependencies(dependencySpec));
    }

    @Override

    @Override
    @Deprecated
    public Set<File> getFiles(Spec<? super Dependency> dependencySpec) {
        DeprecationLogger.deprecateMethod(LenientConfiguration.class, "getFiles(Spec)")
            .withAdvice("Use a lenient ArtifactView with a componentFilter instead.")
            .willBeRemovedInGradle9()
            .withUpgradeGuideSection(8, "deprecate_filtered_configuration_file_and_filecollection_methods")
            .nagUser();

    public void addVariant(String name) {
        additionalVariants.add(new AdditionalVariant(name));
    }

    public void addVariant(String name, String basedOn, boolean lenient) {
        additionalVariants.add(new AdditionalVariant(name, basedOn, lenient));
    }

    public List<AdditionalVariant> getAdditionalVariants() {
        return additionalVariants;
    }

    public static VariantMetadataRules noOp() {

                    }
                }
            }

            task checkLenient {
                doLast {
                    def artifacts = configurations.conf.getIncoming().artifactView { lenient = true }.artifacts.artifacts
                    assert artifacts.size() == 0
                    assert candidates == ${candidates}
                }
            }
"""

        when:

        if (consumableVariants.isEmpty()) {
            return ImmutableList.of();
        }

            }

            val components =
                configurations
                    .compileClasspath.get()
                    .incoming
                    .artifactView { lenient(true) }
                    .artifacts
                    .map { it.id.componentIdentifier }

            val resolvedComponents =
                dependencies
                    .createArtifactResolutionQuery()

        }
    }

    /**
     * This will transform any lock out of date result into an {@link UnresolvedDependency} in order to plug into lenient resolution.
     * This happens only if there are no previous failures as otherwise lock state can't be asserted.
     *
     * @return the existing failures augmented with any locking related one
     */