private final String name;
    private final String base;
    private final boolean lenient;

    public AdditionalVariant(String name) {
        this(name, null, false);
    }

    public AdditionalVariant(String name, @Nullable String base, boolean lenient) {
        this.name = name;
        this.base = base;
        this.lenient = lenient;
    }

    public String getName() {
        return name;
    }

    private final boolean lenient;
    private final CalculatedValue<ArtifactSetResult> result;

    public DefaultArtifactCollection(ResolutionBackedFileCollection files, boolean lenient, ResolutionHost resolutionHost, CalculatedValueFactory calculatedValueFactory) {
        this.fileCollection = files;
        this.lenient = lenient;

     */
    InstantiationScheme decorateScheme();

    /**
     * Creates an {@link Instantiator} that decorates the instances created.
     * The returned {@link Instantiator} is lenient when there is a missing {@link javax.inject.Inject} annotation or null constructor parameters,
     * for backwards compatibility.

 *     <li>{@code LENIENT} will load the lock state, to anchor dynamic versions, but otherwise be lenient about modifications of the dependency resolution,
 *     allowing versions to change and module to be added or removed</li>
 * </ul>
 *
 * @since 6.1
 */
public enum LockMode {
    STRICT,
    DEFAULT,
    LENIENT

     */
    STRICT,

    /**
     * Error types are equal to and subtypes of all types.
     *
     * [LENIENT] should be chosen if type errors are expected and should be treated as type holes that can be satisfied by any other type.
     * However, caution should be applied when using [LENIENT], as the policy can swallow type errors which should have been dealt with

        capability.name == 'bar'
        capability.version == '1.0'

        where:
        parser << [strictParser, lenientParser]
    }

    def "can parse string notation without version using lenient parser"() {
        when:
        def capability = lenientParser.parseNotation("foo:bar")

        then:
        capability.group == 'foo'
        capability.name == 'bar'
        capability.version == null
    }

            actualFiles = findLines(configDetails, 'lenient-artifact-view-file')
            compare("artifactView.files (lenient)", actualFiles, expectedFiles)

            actualArtifacts = findLines(configDetails, 'lenient-artifact-view-artifact')
            compare("artifactView.artifacts (lenient)", actualArtifacts, expectedArtifacts)

            actualFiles = findLines(configDetails, 'lenient-artifact-view-file-file')

            }

            is ResolutionBackedFileCollection -> {
                val displayName = fileCollection.resolutionHost.displayName
                val lenient = fileCollection.isLenient
                val nestedVisitor = ResolutionContentsCollectingVisitor(displayName, lenient)
                fileCollection.visitStructure(nestedVisitor)
                nestedVisitor.addElements(elements)
                false
            }

                lenientArtifactViewFiles.each {
                    writeFile("lenient-artifact-view-file", writer, it)
                }
                lenientArtifactViewArtifacts.each {
                    writeArtifact("lenient-artifact-view-artifact", writer, it)
                }
                lenientArtifactViewFiles.files.each {
                    writeFile("lenient-artifact-view-file-file", writer, it)
                }

        given:
        mainProjectDir.file("app/build.gradle") << """
            tasks.register("resolve", Resolve) {
                artifactFiles.from(configurations.getByName("compileClasspath").incoming.artifactView {
                    lenient = true
                }.getFiles())
            }
        """