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

)

const (
	percent    rune = '%'
	underscore rune = '_'
	runeZero   rune = 0
)

func evalSQLLike(text, pattern string, escape rune) (match bool, err error) {
	s := []rune{}
	prev := runeZero
	hasLeadingPercent := false
	patLen := len([]rune(pattern))
	for i, r := range pattern {
		if i > 0 && prev == escape {
			switch r {
			case percent, escape, underscore:
				s = append(s, r)

# Execute.
mkdir $WORK/covdata
env GOCOVERDIR=$WORK/covdata
exec $WORK/modex.exe

# Restore previous GOCOVERDIR setting
env GOCOVERDIR=$SAVEGOCOVERDIR

# Examine the result.
go tool covdata percent -i=$WORK/covdata
stdout 'coverage: 100.0% of statements'

# By default we want to see packages resident in the module covered,
# but not dependencies.
go tool covdata textfmt -i=$WORK/covdata -o=$WORK/covdata/out.txt

  /**
   * {@inheritDoc}
   *
   * <p>Implementations may or may not support removal when a call to {@link #peek()} has occurred
   * since the most recent call to {@link #next()}.
   *
   * @throws IllegalStateException if there has been a call to {@link #peek()} since the most recent
   *     call to {@link #next()} and this implementation does not support this sequence of calls
   *     (optional)
   */
  @Override
  void remove();

    /**
     * Returns the next group of elements after removing them from the queue.
     *
     * The group contains the most recently pushed element plus all
     * elements superseded by it ordered from most recent to least recent.
     */
    fun nextGroup(timeoutMillis: Long = pollTimeoutMillis): List<T> {
        lock.withLock {
            if (q.isNotEmpty()) {
                return takeNextGroup()
            }

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

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

    /**