2514017809

Build Type

push

github

Committed by Martin Middel

Commit Message

Make random-number-generator#permute permute properly

Run Details

4753 of 5556 branches covered (85.55%)

Branch coverage included in aggregate %.

9 of 9 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

10199 of 10853 relevant lines covered (93.97%)

33096.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.86

/src/expressions/postfix/Lookup.ts

import EmptySequence from '../dataTypes/Sequences/EmptySequence';
import DynamicContext from '../DynamicContext';
import ExecutionParameters from '../ExecutionParameters';
import Expression from '../Expression';
import { Bucket } from '../util/Bucket';
import evaluateLookup from './evaluateLookup';

class Lookup extends Expression {
        private readonly _keySpecifier: '*' | Expression;
        private readonly _selector: Expression;

        constructor(selector: Expression, keySpecifier: '*' | Expression) {
                super(selector.specificity, [selector].concat(keySpecifier === '*' ? [] : [keySpecifier]), {
                        canBeStaticallyEvaluated: selector.canBeStaticallyEvaluated,
                        resultOrder: selector.expectedResultOrder,
                        subtree: selector.subtree,
                });

                this._selector = selector;
                this._keySpecifier = keySpecifier;
        }

        public evaluate(dynamicContext: DynamicContext, executionParameters: ExecutionParameters) {
                const sequence = this._selector.evaluateMaybeStatically(
                        dynamicContext,
                        executionParameters
                );
                return sequence.mapAll((items) => {
                        return items.reduce((toReturn, item) => {
                                return evaluateLookup(
                                        item,
                                        this._keySpecifier,
                                        toReturn,
                                        dynamicContext,
                                        executionParameters
                                );
                        }, new EmptySequence());
                });
        }

        public override getBucket(): Bucket | null {
                return this._selector.getBucket();
        }
}

export default Lookup;

1	import EmptySequence from '../dataTypes/Sequences/EmptySequence';	3✔
2	import DynamicContext from '../DynamicContext';
3	import ExecutionParameters from '../ExecutionParameters';
4	import Expression from '../Expression';	3✔
5	import { Bucket } from '../util/Bucket';
6	import evaluateLookup from './evaluateLookup';	3✔
7
8	class Lookup extends Expression {
9	private readonly _keySpecifier: '*' \| Expression;
10	private readonly _selector: Expression;
11
12	constructor(selector: Expression, keySpecifier: '*' \| Expression) {
13	super(selector.specificity, [selector].concat(keySpecifier === '*' ? [] : [keySpecifier]), {	24✔
14	canBeStaticallyEvaluated: selector.canBeStaticallyEvaluated,
15	resultOrder: selector.expectedResultOrder,
16	subtree: selector.subtree,
17	});
18
19	this._selector = selector;	24✔
20	this._keySpecifier = keySpecifier;	24✔
21	}
22
23	public evaluate(dynamicContext: DynamicContext, executionParameters: ExecutionParameters) {
24	const sequence = this._selector.evaluateMaybeStatically(	420✔
25	dynamicContext,
26	executionParameters
27	);
28	return sequence.mapAll((items) => {	420✔
29	return items.reduce((toReturn, item) => {	420✔
30	return evaluateLookup(	429✔
31	item,
32	this._keySpecifier,
33	toReturn,
34	dynamicContext,
35	executionParameters
36	);
37	}, new EmptySequence());
38	});
39	}
40
41	public override getBucket(): Bucket \| null {
UNCOV 42	return this._selector.getBucket();	×
43	}
44	}
45
46	export default Lookup;	3✔

FontoXML / fontoxpath / 2514017809

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous