e := d.Cache[id]
		if len(e.Children) > 0 {
			e = d.flatten(e)
		}
		m[id] = e
	}
	return m
}

// flatten all children of the root into the root element and return it.
func (d *dataUsageCache) flatten(root dataUsageEntry) dataUsageEntry {
	for id := range root.Children {
		e := d.Cache[id]
		if len(e.Children) > 0 {
			e = d.flatten(e)
		}
		root.merge(e)
	}
	root.Children = nil

 * If the type is {@link org.apache.maven.api.Node Node} or
 * {@code List<}{@link org.apache.maven.api.Node Node}{@code >},
 * and {@code pathScope != ""}, the dependencies will be <i>flattened</i>.
 * Else the dependencies will be <i>resolved</i> and {@code pathScope} must be non empty,
 * and the field type can be {@link org.apache.maven.api.Node Node},
 * {@code List<}{@link org.apache.maven.api.Node Node}{@code >},

    /**
     * Shortcut for {@code getService(DependencyResolver.class).flatten(...)}.
     *
     * @param node node for which to get a flattened list
     * @param scope build path scope (main compile, test compile, etc.) of desired nodes
     * @return flattened list of node with the given build path scope

		path       string
		isNil      bool
		size, objs int
		flatten    bool
		oSizes     sizeHistogram
	}{
		{
			path:    "/",
			size:    363515,
			flatten: true,
			objs:    14,
			oSizes:  sizeHistogram{0: 7, 1: 5, 2: 2},
		},
		{
			path:    "/dir1",
			size:    342210,
			objs:    7,
			flatten: false,
			oSizes:  sizeHistogram{0: 2, 1: 3, 2: 2},
		},
		{

 * followed by <dfn>flattening</dfn> and <dfn>resolution</dfn>.
 * The version selection is done for each dependency during the collection phase.
 * The flatten phase keeps only a single version per ({@code groupId}, {@code artifactId}) pair.
 * The resolution phase actually downloads the dependencies (or artifacts) that have been computed.
 *
 * @since 4.0.0
 */
@Experimental

            .plus(subprojectsFolder.asFile)
            .plus(testingFolder.asFile)
            .plus(packingFolder.asFile)

        return subprojectRoots.map { it.listFiles(File::isDirectory).asList() }.flatten()
    }

    private
    fun generateSubprojects(): List<GradleSubproject> {
        return generateSubprojectsDirectories()
            .filter {
                File(it, "build.gradle.kts").exists() ||

            // 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())));
            });

 * <ul>
 *   <li><strong>maven-exec-plugin</strong>: Upgrades to version 3.2.0 or higher</li>
 *   <li><strong>maven-enforcer-plugin</strong>: Upgrades to version 3.0.0 or higher</li>
 *   <li><strong>flatten-maven-plugin</strong>: Upgrades to version 1.2.7 or higher</li>
 *   <li><strong>maven-shade-plugin</strong>: Upgrades to version 3.5.0 or higher</li>

          <type>String</type>
          <description>pathScope used to flatten dependencies</description>
        </field>
        <field>
          <name>requestType</name>
          <required>false</required>
          <version>2.0.0+</version>
          <type>String</type>
          <description>either {@code collect}, {@code flatten}, or {@code resolve}</description>
        </field>
      </fields>
    </class>

            throw IllegalArgumentException("More than one scenario split for test project $key: $projectDurations")
        }
    }
    return durationsPerTestProject
        .mapValues { (_, durations) -> durations.flatten().map { it.scenario } }
}

class EmptyTestProjectBucket(
    private val index: Int,
) : PerformanceTestBucket {
    override fun createPerformanceTestsFor(
        model: CIBuildModel,