11973412300

Committed 22 Nov 2024 01:21PM UTC coverage: 91.545% (-0.03%) from 91.575%

Build # 11973412300

Build Type

Pull #660

github

Committed by

DrRataplan

Commit Message

Improve test coverage

Pull Request Pull Request #660: Implement otherwise and combinating tests from XQ4

Run Details

5059 of 5878 branches covered (86.07%)

Branch coverage included in aggregate %.

112 of 118 new or added lines in 11 files covered. (94.92%)

5 existing lines in 1 file now uncovered.

10868 of 11520 relevant lines covered (94.34%)

35628.9 hits per line

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

93.1

/src/expressions/tests/UnionNodeTest.ts

import Value from '../dataTypes/Value';
import DynamicContext from '../DynamicContext';
import ExecutionParameters from '../ExecutionParameters';
import Specificity from '../Specificity';
import StaticContext from '../StaticContext';
import { Bucket, unionBucket } from '../util/Bucket';
import TestAbstractExpression from './TestAbstractExpression';

/**
 * Union node test, used to process `descendant::(a|b|c)` selectors
 */
class UnionNodeTest extends TestAbstractExpression {
        private _subTests: TestAbstractExpression[];
        private _bucket: Bucket;
        constructor(subTests: TestAbstractExpression[]) {
                const maxSpecificity = subTests.reduce<Specificity>((currentMaxSpecificity, selector) => {
                        if (currentMaxSpecificity.compareTo(selector.specificity) > 0) {
                                return currentMaxSpecificity;
                        }
                        return selector.specificity;
                }, new Specificity({}));

                super(maxSpecificity);

                // If all subExpressions define the same bucket: use that one, else, use no bucket.
                let bucket: Bucket | null;
                for (let i = 0; i < subTests.length; ++i) {
                        const subTestBucket = subTests[i].getBucket();
                        if (bucket === undefined) {
                                bucket = subTestBucket;
                        }
                        if (bucket === null) {
                                // Not applicable buckets
                                break;
                        }

                        bucket = unionBucket(bucket, subTestBucket);
                }

                this._bucket = bucket;
                this._subTests = subTests;
        }

        public evaluateToBoolean(
                dynamicContext: DynamicContext,
                value: Value,
                executionParameters: ExecutionParameters,
        ) {
                return this._subTests.some((test) => {
                        const result = test.evaluateToBoolean(dynamicContext, value, executionParameters);
                        return result;
                });
        }

        public override getBucket(): Bucket {
                return this._bucket;
        }

        public performStaticEvaluation(staticContext: StaticContext) {
                this._subTests.forEach((test) => test.performStaticEvaluation(staticContext));
        }
}

export default UnionNodeTest;

1	import Value from '../dataTypes/Value';
2	import DynamicContext from '../DynamicContext';
3	import ExecutionParameters from '../ExecutionParameters';
4	import Specificity from '../Specificity';	6✔
5	import StaticContext from '../StaticContext';
6	import { Bucket, unionBucket } from '../util/Bucket';	6✔
7	import TestAbstractExpression from './TestAbstractExpression';	6✔
8
9	/**
10	* Union node test, used to process `descendant::(a\|b\|c)` selectors
11	*/
12	class UnionNodeTest extends TestAbstractExpression {
13	private _subTests: TestAbstractExpression[];
14	private _bucket: Bucket;
15	constructor(subTests: TestAbstractExpression[]) {
16	const maxSpecificity = subTests.reduce<Specificity>((currentMaxSpecificity, selector) => {	12✔
17	if (currentMaxSpecificity.compareTo(selector.specificity) > 0) {	24✔
18	return currentMaxSpecificity;	6✔
19	}
20	return selector.specificity;	18✔
21	}, new Specificity({}));
22
23	super(maxSpecificity);	12✔
24
25	// If all subExpressions define the same bucket: use that one, else, use no bucket.
26	let bucket: Bucket \| null;
27	for (let i = 0; i < subTests.length; ++i) {	12✔
28	const subTestBucket = subTests[i].getBucket();	24✔
29	if (bucket === undefined) {	24✔
30	bucket = subTestBucket;	12✔
31	}
32	if (bucket === null) {	24!
33	// Not applicable buckets
NEW 34	break;	×
35	}
36
37	bucket = unionBucket(bucket, subTestBucket);	24✔
38	}
39
40	this._bucket = bucket;	12✔
41	this._subTests = subTests;	12✔
42	}
43
44	public evaluateToBoolean(
45	dynamicContext: DynamicContext,
46	value: Value,
47	executionParameters: ExecutionParameters,
48	) {
49	return this._subTests.some((test) => {	18✔
50	const result = test.evaluateToBoolean(dynamicContext, value, executionParameters);	30✔
51	return result;	30✔
52	});
53	}
54
55	public override getBucket(): Bucket {
56	return this._bucket;	12✔
57	}
58
59	public performStaticEvaluation(staticContext: StaticContext) {
60	this._subTests.forEach((test) => test.performStaticEvaluation(staticContext));	18✔
61	}
62	}
63
64	export default UnionNodeTest;	6✔

FontoXML / fontoxpath / 11973412300

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