Function processNode

ui/plugins/ui/jasmine/jasmine.js:9631–9683

(node, parentExcluded)

        }

        function processNode(node, parentExcluded) {
            const executableIndex = runnableIndex(node.id)

            if (executableIndex !== undefined) {
                parentExcluded = false
            }

            if (!node.children) {
                const excluded = parentExcluded || excludeNode(node)
                stats[node.id] = {
                    excluded: excluded,
                    willExecute: !excluded && !node.markedPending,
                    segments: [
                        {
                            index: 0,
                            owner: node,
                            nodes: [node],
                            min: startingMin(executableIndex),
                            max: startingMax(executableIndex),
                        },
                    ],
                }
            } else {
                let hasExecutableChild = false

                const orderedChildren = orderChildren(node)

                for (let i = 0; i < orderedChildren.length; i++) {
                    const child = orderedChildren[i]

                    processNode(child, parentExcluded)

                    if (!stats.valid) {
                        return
                    }

                    const childStats = stats[child.id]

                    hasExecutableChild = hasExecutableChild || childStats.willExecute
                }

                stats[node.id] = {
                    excluded: parentExcluded,
                    willExecute: hasExecutableChild,
                }

                segmentChildren(node, orderedChildren, stats[node.id], executableIndex)

                if (!node.canBeReentered() && stats[node.id].segments.length > 1) {
                    stats = { valid: false }
                }
            }
        }

        function startingMin(executableIndex) {
            return executableIndex === undefined ? defaultMin : executableIndex