6967729624

Committed 23 Nov 2023 09:18AM UTC coverage: 91.59% (+0.01%) from 91.58%

Build # 6967729624

Build Type

Pull #620

github

Committed by

web-flow

Commit Message

Merge 4db324b0c into dd07d62fd

Pull Request Pull Request #620: Implement switch expression

Run Details

4971 of 5774 branches covered (0.0%)

Branch coverage included in aggregate %.

55 of 59 new or added lines in 4 files covered. (93.22%)

23 existing lines in 1 file now uncovered.

10723 of 11361 relevant lines covered (94.38%)

97148.78 hits per line

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

90.57

/src/expressions/xquery/SwitchExpression.ts

import ISequence from '../dataTypes/ISequence';
import sequenceFactory from '../dataTypes/sequenceFactory';
import { SequenceType } from '../dataTypes/Value';
import DynamicContext from '../DynamicContext';
import ExecutionParameters from '../ExecutionParameters';
import Expression, { RESULT_ORDERINGS } from '../Expression';
import sequenceDeepEqual, {
        itemDeepEqual,
} from '../functions/builtInFunctions_sequences_deepEqual';
import PossiblyUpdatingExpression, { SequenceCallbacks } from '../PossiblyUpdatingExpression';
import Specificity from '../Specificity';
import StaticContext from '../StaticContext';
import atomizeSequence from '../util/atomizeSequence';
import { IterationHint } from '../util/iterators';
import { errXUST0001 } from '../xquery-update/XQueryUpdateFacilityErrors';
import { errXPTY0004 } from './XQueryErrors';

export type SwitchExpressionClause = {
        caseClauseExpression: PossiblyUpdatingExpression;
        tests: Expression[];
};

class SwitchExpression extends PossiblyUpdatingExpression {
        private _amountOfCases: number;
        private _argExpression: Expression;
        private _testsByCase: Expression[][];

        constructor(
                argExpression: Expression,
                caseClauses: SwitchExpressionClause[],
                defaultExpression: PossiblyUpdatingExpression,
                type: SequenceType,
        ) {
                const specificity = new Specificity({});
                super(
                        specificity,
                        [
                                argExpression,
                                ...caseClauses.map((clause) => clause.caseClauseExpression),
                                defaultExpression,
                        ].concat(...caseClauses.map((clause) => clause.tests.map((test) => test))),
                        {
                                canBeStaticallyEvaluated: false,
                                peer: false,
                                resultOrder: RESULT_ORDERINGS.UNSORTED,
                                subtree: false,
                        },
                        type,
                );
                this._argExpression = argExpression;
                this._amountOfCases = caseClauses.length;
                this._testsByCase = caseClauses.map((clause) => clause.tests);
        }

        public performFunctionalEvaluation(
                dynamicContext: DynamicContext,
                executionParameters: ExecutionParameters,
                sequenceCallbacks: ((dynamicContext: DynamicContext) => ISequence)[],
        ) {
                // Pick the argumentExpression.
                const evaluatedExpression = atomizeSequence(
                        sequenceCallbacks[0](dynamicContext),
                        executionParameters,
                );

                // Map over all values the type test, and return the result.
                return evaluatedExpression.switchCases({
                        multiple: () => {
                                throw errXPTY0004(
                                        'The operand for a switch expression should result in zero or one item',
                                );
                        },
                        default: () => {
                                const singleValue = evaluatedExpression.first();
                                const isEmpty = !singleValue;

                                for (let i = 0; i < this._amountOfCases; i++) {
                                        const results = this._testsByCase[i].map((x) =>
                                                x.evaluateMaybeStatically(dynamicContext, executionParameters),
                                        );

                                        for (const result of results) {
                                                const atomizedResult = atomizeSequence(result, executionParameters);
                                                if (atomizedResult.isEmpty()) {
                                                        if (isEmpty) {
                                                                return sequenceCallbacks[i + 1](dynamicContext);
                                                        }
                                                        continue;
                                                }

                                                if (!atomizedResult.isSingleton()) {
                                                        throw errXPTY0004(
                                                                'The operand for a switch case should result in zero or one item',
                                                        );
                                                }

                                                if (isEmpty) {
                                                        continue;
                                                }

                                                const first = atomizedResult.first();

                                                if (
                                                        itemDeepEqual(
                                                                dynamicContext,
                                                                executionParameters,
                                                                null,
                                                                singleValue,
                                                                first,
                                                        ).next(IterationHint.NONE).value
                                                ) {
                                                        return sequenceCallbacks[i + 1](dynamicContext);
                                                }
                                        }
                                }

                                return sequenceCallbacks[this._amountOfCases + 1](dynamicContext);
                        },
                });
        }

        public performStaticEvaluation(staticContext: StaticContext) {
                super.performStaticEvaluation(staticContext);

                if (this._argExpression.isUpdating) {
                        throw errXUST0001();
                }
        }
}

export default SwitchExpression;

1	import ISequence from '../dataTypes/ISequence';
2	import sequenceFactory from '../dataTypes/sequenceFactory';
3	import { SequenceType } from '../dataTypes/Value';
4	import DynamicContext from '../DynamicContext';
5	import ExecutionParameters from '../ExecutionParameters';
6	import Expression, { RESULT_ORDERINGS } from '../Expression';	15✔
7	import sequenceDeepEqual, {	15✔
8	itemDeepEqual,
9	} from '../functions/builtInFunctions_sequences_deepEqual';
10	import PossiblyUpdatingExpression, { SequenceCallbacks } from '../PossiblyUpdatingExpression';	15✔
11	import Specificity from '../Specificity';	15✔
12	import StaticContext from '../StaticContext';
13	import atomizeSequence from '../util/atomizeSequence';	15✔
14	import { IterationHint } from '../util/iterators';	15✔
15	import { errXUST0001 } from '../xquery-update/XQueryUpdateFacilityErrors';	15✔
16	import { errXPTY0004 } from './XQueryErrors';	15✔
17
18	export type SwitchExpressionClause = {
19	caseClauseExpression: PossiblyUpdatingExpression;
20	tests: Expression[];
21	};
22
23	class SwitchExpression extends PossiblyUpdatingExpression {
24	private _amountOfCases: number;
25	private _argExpression: Expression;
26	private _testsByCase: Expression[][];
27
28	constructor(
29	argExpression: Expression,
30	caseClauses: SwitchExpressionClause[],
31	defaultExpression: PossiblyUpdatingExpression,
32	type: SequenceType,
33	) {
34	const specificity = new Specificity({});	15✔
35	super(	15✔
36	specificity,
37	[
38	argExpression,
39	...caseClauses.map((clause) => clause.caseClauseExpression),	15✔
40	defaultExpression,
41	].concat(...caseClauses.map((clause) => clause.tests.map((test) => test))),	18✔
42	{
43	canBeStaticallyEvaluated: false,
44	peer: false,
45	resultOrder: RESULT_ORDERINGS.UNSORTED,
46	subtree: false,
47	},
48	type,
49	);
50	this._argExpression = argExpression;	15✔
51	this._amountOfCases = caseClauses.length;	15✔
52	this._testsByCase = caseClauses.map((clause) => clause.tests);	15✔
53	}
54
55	public performFunctionalEvaluation(
56	dynamicContext: DynamicContext,
57	executionParameters: ExecutionParameters,
58	sequenceCallbacks: ((dynamicContext: DynamicContext) => ISequence)[],
59	) {
60	// Pick the argumentExpression.
61	const evaluatedExpression = atomizeSequence(	15✔
62	sequenceCallbacks[0](dynamicContext),
63	executionParameters,
64	);
65
66	// Map over all values the type test, and return the result.
67	return evaluatedExpression.switchCases({	15✔
68	multiple: () => {
NEW 69	throw errXPTY0004(	×
70	'The operand for a switch expression should result in zero or one item',
71	);
72	},
73	default: () => {
74	const singleValue = evaluatedExpression.first();	15✔
75	const isEmpty = !singleValue;	15✔
76
77	for (let i = 0; i < this._amountOfCases; i++) {	15✔
78	const results = this._testsByCase[i].map((x) =>	15✔
79	x.evaluateMaybeStatically(dynamicContext, executionParameters),	18✔
80	);
81
82	for (const result of results) {	15✔
83	const atomizedResult = atomizeSequence(result, executionParameters);	18✔
84	if (atomizedResult.isEmpty()) {	18✔
85	if (isEmpty) {	6✔
86	return sequenceCallbacks[i + 1](dynamicContext);	3✔
87	}
88	continue;	3✔
89	}
90
91	if (!atomizedResult.isSingleton()) {	12!
NEW 92	throw errXPTY0004(	×
93	'The operand for a switch case should result in zero or one item',
94	);
95	}
96
97	if (isEmpty) {	12✔
98	continue;	3✔
99	}
100
101	const first = atomizedResult.first();	9✔
102
103	if (	9✔
104	itemDeepEqual(
105	dynamicContext,
106	executionParameters,
107	null,
108	singleValue,
109	first,
110	).next(IterationHint.NONE).value
111	) {
112	return sequenceCallbacks[i + 1](dynamicContext);	6✔
113	}
114	}
115	}
116
117	return sequenceCallbacks[this._amountOfCases + 1](dynamicContext);	6✔
118	},
119	});
120	}
121
122	public performStaticEvaluation(staticContext: StaticContext) {
123	super.performStaticEvaluation(staticContext);	15✔
124
125	if (this._argExpression.isUpdating) {	15!
NEW 126	throw errXUST0001();	×
127	}
128	}
129	}
130
131	export default SwitchExpression;	15✔

FontoXML / fontoxpath / 6967729624

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