return s.Start != nil && s.End != nil
}

// Descendents returns a slice consisting of itself (always the first task returned),
// and the transitive closure of all of its children.
func (s *UserTaskSummary) Descendents() []*UserTaskSummary {
	descendents := []*UserTaskSummary{s}
	for _, child := range s.Children {
		descendents = append(descendents, child.Descendents()...)
	}
	return descendents
}

	}
	if task.End != nil {
		opts.endTime = task.End.Time().Sub(parsed.startTime())
	} else { // The task didn't end.
		opts.endTime = parsed.endTime().Sub(parsed.startTime())
	}
	opts.tasks = task.Descendents()
	slices.SortStableFunc(opts.tasks, func(a, b *trace.UserTaskSummary) int {
		aStart, bStart := parsed.startTime(), parsed.startTime()
		if a.Start != nil {
			aStart = a.Start.Time()
		}
		if b.Start != nil {

	// represents the whole function, it points back to itself.
	Function *Node

	// Values associated to this node. Flat is exclusive to this node,
	// Cum includes all descendents.
	Flat, FlatDiv, Cum, CumDiv int64

	// In and out Contains the nodes immediately reaching or reached by
	// this node.
	In, Out EdgeMap

	// LabelTags provide additional information about subsets of a sample.

        """
    }

    def "reports typed work item progress events as descendants of tasks"() {
        when:
        def events = runBuild("runInWorker", EnumSet.allOf(OperationType))

        then:
        def taskOperation = events.operation("Task :runInWorker")
        taskOperation.assertIsTask()
        with(taskOperation.descendant("org.gradle.test.TestWork")) {
            successful
            assertIsWorkItem()

}

// isDescendantOf returns true if it is a descendant of (or the same as)
// `ancestor`.
//
// For example:
//
//	 	/a, /a/b, /a/b/c are all descendants of /a.
//		/abc or /abd/a are not descendants of /ab.
func (cp collectorPath) isDescendantOf(arg string) bool {
	descendant := string(cp)
	if descendant == arg {
		return true
	}
	if len(arg) >= len(descendant) {
		return false
	}

  current_layer_descendants.push_back(op);
  // BFS downstream ops for current user.
  // If any one of the descendants meet one of the three conditions, we return
  // false for the current value:
  // 1: The descendant is not in the ops_to_add.
  // 2: The descendant is not a stablehlo op.
  // 3: The depth of the descendant is larger than 5, we don't want to search
  // too deep, max depth is arbitrarily chosen.

     */
    @CheckReturnValue
    public abstract FileHierarchySet plus(File path);

    /**
     * Returns a set that contains the union of this set and the given absolute path. The set contains the path itself, plus all its descendants.
     */
    @CheckReturnValue
    public abstract FileHierarchySet plus(String absolutePath);

            data.dependents.forEach(dependents::put);
            if (fullRebuildCause == null) {
                fullRebuildCause = data.fullRebuildCause;
            }
        }
        ImmutableMap.Builder<String, DependentsSet> mergedDependents = ImmutableMap.builderWithExpectedSize(dependents.size());
        for (Map.Entry<String, Collection<DependentsSet>> entry : dependents.asMap().entrySet()) {

        def pullTaskOperation = pullFromCacheResults.operation("Task :cacheable")
        def pullOperations = pullTaskOperation.descendants {
            it.descriptor.displayName ==~ /Load entry .+ from (local|remote) build cache/
        }
        def unpackOperations = pullTaskOperation.descendants {
            it.descriptor.displayName ==~ /Unpack build cache entry .+/
        }
        if (hasLocalBuildCacheOperations()) {

        def a2 = first(c.dependencies).selected

        a2.is(a)

        first(b.dependents).is(first(a.dependencies))
        first(c.dependents).is(first(b.dependencies))
        first(a.dependents).is(first(c.dependencies))

        first(b.dependents).from.is(a)
        first(c.dependents).from.is(b)
        first(a.dependents).from.is(c)
    }

    def "accumulates and avoids duplicate dependencies"() {