Function TreeProcessor

ui/plugins/ui/jasmine/jasmine.js:9571–9810

(attrs)

getJasmineRequireObj().TreeProcessor = function() {
    function TreeProcessor(attrs) {
        const tree = attrs.tree
        const runnableIds = attrs.runnableIds
        const queueRunnerFactory = attrs.queueRunnerFactory
        const nodeStart = attrs.nodeStart || function() {}
        const nodeComplete = attrs.nodeComplete || function() {}
        const failSpecWithNoExpectations = !!attrs.failSpecWithNoExpectations
        const orderChildren =
            attrs.orderChildren ||
            function(node) {
                return node.children
            }
        const excludeNode =
            attrs.excludeNode ||
            function(node) {
                return false
            }
        let stats = { valid: true }
        let processed = false
        const defaultMin = Infinity
        const defaultMax = 1 - Infinity

        this.processTree = function() {
            processNode(tree, true)
            processed = true
            return stats
        }

        this.execute = async function() {
            if (!processed) {
                this.processTree()
            }

            if (!stats.valid) {
                throw "invalid order"
            }

            const childFns = wrapChildren(tree, 0)

            await new Promise(function(resolve) {
                queueRunnerFactory({
                    queueableFns: childFns,
                    userContext: tree.sharedUserContext(),
                    onException: function() {
                        tree.handleException.apply(tree, arguments)
                    },
                    onComplete: resolve,
                    onMultipleDone: tree.onMultipleDone ? tree.onMultipleDone.bind(tree) : null,
                })
            })
        }

        function runnableIndex(id) {
            for (let i = 0; i < runnableIds.length; i++) {
                if (runnableIds[i] === id) {
                    return i
                }
            }