errEINVAL error = syscall.EINVAL
	errENOENT error = syscall.ENOENT
)

// errnoErr returns common boxed Errno values, to prevent
// allocations at runtime.
func errnoErr(e syscall.Errno) error {
	switch e {
	case 0:
		return nil
	case syscall.EAGAIN:
		return errEAGAIN
	case syscall.EINVAL:
		return errEINVAL
	case syscall.ENOENT:
		return errENOENT
	}
	return e

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

     * 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);

    /**

 *
 *  * Characters in `encodeSet` are percent-encoded.
 *
 *  * Control characters and non-ASCII characters are percent-encoded.
 *
 *  * All other characters are copied without transformation.
 *
 * @param alreadyEncoded true to leave '%' as-is; false to convert it to '%25'.
 * @param strict true to encode '%' if it is not the prefix of a valid percent encoding.

```

### 3.2 Automatic removal of noncurrent versions keeping only most recent ones after noncurrent days

It is possible to configure automatic removal of older noncurrent versions keeping only the most recent `N` using `NewerNoncurrentVersions`.

e.g, To remove noncurrent versions of all objects keeping the most recent 5 noncurrent versions under the prefix `user-uploads/` 30 days after they become noncurrent ,

```
{

 * 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.
 *

    @Rule
    BlockingHttpServer server = new BlockingHttpServer()
    GradleHandle gradle

    def setup() {
        server.start()
    }

    def "shows progress bar and percent phase completion"() {
        createDirs("a", "b", "c", "d")
        settingsFile << """
            ${server.callFromBuild('settings')}
            include "a", "b", "c", "d"
        """
        buildFile << """

        "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 << """

    }

    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) {

spec:
  hosts:
    - b
  http:
    - route:
        - destination:
            host: b
      mirror:
        host: {{.MirrorHost}}
{{- if not .Absent }}
      mirrorPercentage:
        value: {{.Percent}}