}
    }

    private def findLaunchables(Collection<GradleProject> gradleProjects, String taskName) {
        collectGradleProjects(gradleProjects).collect { it.tasks }.flatten().findAll { GradleTask task -> task.path.contains(taskName) }
    }

    private def collectGradleProjects(Collection<GradleProject> projects, Collection<GradleProject> acc = []) {
        acc.addAll(projects)

    private static List<Boolean> parametersNullabilityOf(CtBehavior behavior) {
        def annotations = behavior.parameterAnnotations as List<Object[]>
        annotations.collect { Object[] pAnn ->
            pAnn.flatten().any { isNullableCtAnnotation(it) }
        }
    }

    private static boolean hasNullableAnnotation(CtField field) {
        return NULLABLE_ANNOTATIONS.any { field.hasAnnotation(it) }
    }

        }
        this.contentCharset = contentCharset;
    }

    @Override
    public ManifestMergeSpec from(Object... mergePaths) {
        GUtil.flatten(mergePaths, this.mergePaths);
        return this;
    }

    @Override
    public ManifestMergeSpec eachEntry(Action<? super ManifestMergeDetails> mergeAction) {
        actions.add(mergeAction);
        return this;

        out.toString().contains("> Task $taskPath")
    }

    Collection<EclipseProject> collectProjects(EclipseProject parent) {
        return parent.children.collect { collectProjects(it) }.flatten() + [parent]
    }

    EclipseWorkspace eclipseWorkspace(List<EclipseWorkspaceProject> projects) {
        new DefaultEclipseWorkspace(temporaryFolder.file("workspace"), projects)
    }

func Dereference[E any](s []*E) []E {
	res := make([]E, 0, len(s))
	for _, v := range s {
		if v != nil {
			res = append(res, *v)
		}
	}
	return res
}

// Flatten merges a slice of slices into a single slice.
func Flatten[E any](s [][]E) []E {
	if s == nil {
		return nil
	}
	res := make([]E, 0)
	for _, v := range s {
		res = append(res, v...)
	}
	return res
}

        1 * spec.isSatisfiedBy(firstLevelDependenciesEntries[1].key) >> false
        1 * spec.isSatisfiedBy(firstLevelDependenciesEntries[2].key) >> true
        0 * _
    }

    def "should flatten all resolved dependencies in dependency tree"() {
        given:
        def lenientConfiguration = newConfiguration()

        def (expected, root) = generateDependenciesWithChildren(treeStructure)

        when:

            elementIfNoFailures {
                fun PropertyAccess.flatten(): List<String> =
                    buildList {
                        if (receiver is PropertyAccess) {
                            addAll(receiver.flatten())
                        }
                        add(name)
                    }

                val nameParts = checked(content!!).flatten()

        hash1 == hash2

        where:
        [context, fooPattern] << [SnapshotContext.values(), ['**/foo.properties', '**/f*.properties', 'some/**/f*.properties', 'some/path/to/foo.properties']].combinations()*.flatten()
    }

    def "can filter multiple files selectively based on pattern (pattern: #fPattern, context: #context)"() {
        given:
        filters = [

            // TODO: This doesn't allow adoc files to be generated?
            task.from(extension.getUserManual().getRoot(), sub -> {
                sub.include("**/*.adoc");
                // Flatten adocs into a single directory
                sub.eachFile(fcd -> fcd.setRelativePath(RelativePath.parse(true, fcd.getName())));
            });

        this.textUriFileResourceLoaderFactory = textUriFileResourceLoaderFactory;
        this.defaultTarget = defaultTarget;
    }

    @Override
    public ObjectConfigurationAction to(Object... targets) {
        GUtil.flatten(targets, this.targets);
        return this;
    }

    @Override
    public ObjectConfigurationAction from(final Object script) {
        actions.add(new Runnable() {
            @Override