}

    override suspend fun ReadContext.decode(): ArtifactCollectionInternal {
        val displayName = readString()
        val lenient = readBoolean()
        val elements = readList().uncheckedCast<List<Any>>()

        val files = artifactSetConverter.asFileCollection(displayName, lenient,
            elements.map { element ->
                when (element) {

        "incoming.artifactView({componentFilter { true }}).artifacts" | _
        "incoming.artifactView({lenient(false)}).artifacts"           | _
    }

    @ToBeFixedForConfigurationCache(because = "task uses Configuration API")
    def "lenient artifact view reports failure to resolve graph and artifacts"() {
        settingsFile << "include 'a', 'b'"

        buildFile << """

			lenientErr     error
		)
		_, gvk, lenientErr = lenientDecoder.Decode(policyDef, nil, policy)
		if lenientErr != nil {
			return nil, fmt.Errorf("failed lenient decoding: %w", lenientErr)
		}
		klog.Warningf("Audit policy contains errors, falling back to lenient decoding: %v", err)
	}

	// Ensure the policy file contained an apiVersion and kind.
	gv := schema.GroupVersion{Group: gvk.Group, Version: gvk.Version}

        attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named("incubation-report-$reportType"))
    }
    extendsFrom(reports)

     */
    public ResolutionBackedFileCollection asFileCollection(String displayName, boolean lenient, List<?> elements) {
        return new ResolutionBackedFileCollection(new PartialSelectedArtifactProvider(elements), lenient, new NameBackedResolutionHost(displayName), taskDependencyFactory);
    }

    public ResolvedArtifactSet asResolvedArtifactSet(Throwable failure) {

        extension.getClasspath().from(runtimeClasspath);
        extension.getSourceRoots().from(sourcesPath.getIncoming().artifactView(v -> v.lenient(true)).getFiles());
        extension.getDocumentedSource().from(sourcesPath.getIncoming().artifactView(v -> v.lenient(true)).getFiles().getAsFileTree().matching(f -> {
            f.include(PublicApi.INSTANCE.getIncludes());
            // Filter out any non-public APIs

                    }
                }
            }
        """
    }

    void setupBuildWithColorTransformImplementation(boolean lenient) {
        setupBuildWithColorTransformImplementation(getBuildFile(), lenient)
    }

    /**
     * Each project produces a 'blue' variant, and has a `resolve` task that resolves the 'green' variant and a transform that converts 'blue' to 'green'.

        def artifacts = configurations.compileClasspath.incoming.artifactView {
            attributes { it.attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.class, 'size')) }
            if (project.hasProperty("lenient")) {
                lenient(true)
            }
        }.artifacts
        from artifacts.artifactFiles
        into "\${buildDir}/libs"
        doLast {
            println "files: " + artifacts.collect { it.file.name }

        def smokeTestRunner = runner('assembleBootDist', 'check')

            name = "Resolve all dependencies"
            tasks = "resolveAllDependencies"
            gradleParams = (
                buildToolGradleParameters(isContinue = false) + listOf("--dependency-verification", "lenient")
                ).joinToString(separator = " ")
        }
    }