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 {

			fun = call.Fun
			n++
		}
	}
	if n != 1 {
		t.Errorf("%s: got %d CallExprs; want 1", src0, n)
		return
	}

	// check recorded types for fun and descendents (may be parenthesized)
	for {
		// the recorded type for the built-in must match the wanted signature
		typ := types[fun].Type
		if typ == nil {
			t.Errorf("%s: no type recorded for %s", src0, ExprString(fun))

			fun = call.Fun
			n++
		}
	}
	if n != 1 {
		t.Errorf("%s: got %d CallExprs; want 1", src0, n)
		return
	}

	// check recorded types for fun and descendents (may be parenthesized)
	for {
		// the recorded type for the built-in must match the wanted signature
		typ := types[fun].Type
		if typ == nil {
			t.Errorf("%s: no type recorded for %s", src0, ExprString(fun))

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

// Graph summarizes a performance profile into a format that is

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

        final List<MavenProject> bDescendants = graph.markAsFinished(B);
        assertEquals(1, bDescendants.size());
        assertEquals(Y, bDescendants.get(0));

        final List<MavenProject> cDescendants = graph.markAsFinished(C);
        assertEquals(2, cDescendants.size());
        assertEquals(X, cDescendants.get(0));
        assertEquals(Z, cDescendants.get(1));
    }

    @Test

        """
    }

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

public enum RuleApplicationScope {
    /**
     * Rule should be applied to the scope element only.
     */
    SELF,

    /**
     * Rule should be applied to the all matching descendant elements of the scope.
     */
    DESCENDANTS;

    /**
     * Detects if the subject of the rule has been annotated with {@literal @}{@link Each}.
     *
     * @throws IndexOutOfBoundsException If the rule definition has too few parameters.

        return assertHasDescendants(descendants, false);
    }

    public TestFile assertHasDescendants(Iterable<String> descendants, boolean ignoreDirs) {
        Set<String> actual = new TreeSet<>();
        assertIsDir();
        visit(actual, "", this, ignoreDirs);
        Set<String> expected = new TreeSet<>(Lists.newArrayList(descendants));