6107185957

Committed 07 Sep 2023 08:15AM UTC coverage: 91.555%. Remained the same

Build # 6107185957

Build Type

push

github

Committed by

DrRataplan

Commit Message

3.30.1

Run Details

4938 of 5738 branches covered (0.0%)

Branch coverage included in aggregate %.

10640 of 11277 relevant lines covered (94.35%)

97908.84 hits per line

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

55.32

/src/expressions/operators/arithmetic/Unary.ts

import atomize from '../../dataTypes/atomize';
import castToType from '../../dataTypes/castToType';
import createAtomicValue from '../../dataTypes/createAtomicValue';
import isSubtypeOf from '../../dataTypes/isSubtypeOf';
import sequenceFactory from '../../dataTypes/sequenceFactory';
import { SequenceType, ValueType } from '../../dataTypes/Value';
import DynamicContext from '../../DynamicContext';
import ExecutionParameters from '../../ExecutionParameters';
import Expression from '../../Expression';

const UNARY_LOOKUP: { [key: number]: ValueType } = {
        [ValueType.XSINTEGER]: ValueType.XSINTEGER,
        [ValueType.XSNONPOSITIVEINTEGER]: ValueType.XSINTEGER,
        [ValueType.XSNEGATIVEINTEGER]: ValueType.XSINTEGER,
        [ValueType.XSLONG]: ValueType.XSINTEGER,
        [ValueType.XSINT]: ValueType.XSINTEGER,
        [ValueType.XSSHORT]: ValueType.XSINTEGER,
        [ValueType.XSBYTE]: ValueType.XSINTEGER,
        [ValueType.XSNONNEGATIVEINTEGER]: ValueType.XSINTEGER,
        [ValueType.XSUNSIGNEDLONG]: ValueType.XSINTEGER,
        [ValueType.XSUNSIGNEDINT]: ValueType.XSINTEGER,
        [ValueType.XSUNSIGNEDSHORT]: ValueType.XSINTEGER,
        [ValueType.XSUNSIGNEDBYTE]: ValueType.XSINTEGER,
        [ValueType.XSPOSITIVEINTEGER]: ValueType.XSINTEGER,

        [ValueType.XSDECIMAL]: ValueType.XSDECIMAL,
        [ValueType.XSFLOAT]: ValueType.XSFLOAT,
        [ValueType.XSDOUBLE]: ValueType.XSDOUBLE,
};

class Unary extends Expression {
        private _kind: string;
        private _valueExpr: Expression;

        /**
         * Positivese or negativise a value: +1 = 1, -1 = 0 - 1, -1 + 2 = 1, --1 = 1, etc
         *
         * @param  kind       Either + or -
         * @param  valueExpr  The selector evaluating to the value to process
         */
        constructor(kind: string, valueExpr: Expression, type: SequenceType) {
                super(valueExpr.specificity, [valueExpr], { canBeStaticallyEvaluated: false }, false, type);
                this._valueExpr = valueExpr;
                this._kind = kind;
        }

        public evaluate(dynamicContext: DynamicContext, executionParameters: ExecutionParameters) {
                return atomize(
                        this._valueExpr.evaluateMaybeStatically(dynamicContext, executionParameters),
                        executionParameters
                ).mapAll((atomizedValues) => {
                        if (atomizedValues.length === 0) {
                                // Return the empty sequence when inputted the empty sequence
                                return sequenceFactory.empty();
                        }

                        const value = atomizedValues[0];

                        // We could infer the return type during annotation so we can early return here
                        if (this.type) {
                                let finalValue = this._kind === '+' ? +value.value : -value.value;
                                if (value.type === ValueType.XSBOOLEAN) finalValue = Number.NaN;
                                return sequenceFactory.singleton(createAtomicValue(finalValue, this.type.type));
                        }

                        if (atomizedValues.length > 1) {
                                throw new Error(
                                        'XPTY0004: The operand to a unary operator must be a sequence with a length less than one'
                                );
                        }

                        if (isSubtypeOf(value.type, ValueType.XSUNTYPEDATOMIC)) {
                                const castValue = castToType(value, ValueType.XSDOUBLE).value as number;
                                return sequenceFactory.singleton(
                                        createAtomicValue(
                                                this._kind === '+' ? castValue : -castValue,
                                                ValueType.XSDOUBLE
                                        )
                                );
                        }

                        if (isSubtypeOf(value.type, ValueType.XSNUMERIC)) {
                                if (this._kind === '+') {
                                        return sequenceFactory.singleton(value);
                                }
                                return sequenceFactory.singleton(
                                        createAtomicValue((value.value as number) * -1, UNARY_LOOKUP[value.type])
                                );
                        }
                        return sequenceFactory.singleton(createAtomicValue(Number.NaN, ValueType.XSDOUBLE));
                });
        }
}

export default Unary;

1	import atomize from '../../dataTypes/atomize';	9✔
2	import castToType from '../../dataTypes/castToType';	9✔
3	import createAtomicValue from '../../dataTypes/createAtomicValue';	9✔
4	import isSubtypeOf from '../../dataTypes/isSubtypeOf';	9✔
5	import sequenceFactory from '../../dataTypes/sequenceFactory';	9✔
6	import { SequenceType, ValueType } from '../../dataTypes/Value';
7	import DynamicContext from '../../DynamicContext';
8	import ExecutionParameters from '../../ExecutionParameters';
9	import Expression from '../../Expression';	9✔
10
11	const UNARY_LOOKUP: { [key: number]: ValueType } = {	9✔
12	[ValueType.XSINTEGER]: ValueType.XSINTEGER,
13	[ValueType.XSNONPOSITIVEINTEGER]: ValueType.XSINTEGER,
14	[ValueType.XSNEGATIVEINTEGER]: ValueType.XSINTEGER,
15	[ValueType.XSLONG]: ValueType.XSINTEGER,
16	[ValueType.XSINT]: ValueType.XSINTEGER,
17	[ValueType.XSSHORT]: ValueType.XSINTEGER,
18	[ValueType.XSBYTE]: ValueType.XSINTEGER,
19	[ValueType.XSNONNEGATIVEINTEGER]: ValueType.XSINTEGER,
20	[ValueType.XSUNSIGNEDLONG]: ValueType.XSINTEGER,
21	[ValueType.XSUNSIGNEDINT]: ValueType.XSINTEGER,
22	[ValueType.XSUNSIGNEDSHORT]: ValueType.XSINTEGER,
23	[ValueType.XSUNSIGNEDBYTE]: ValueType.XSINTEGER,
24	[ValueType.XSPOSITIVEINTEGER]: ValueType.XSINTEGER,
25
26	[ValueType.XSDECIMAL]: ValueType.XSDECIMAL,
27	[ValueType.XSFLOAT]: ValueType.XSFLOAT,
28	[ValueType.XSDOUBLE]: ValueType.XSDOUBLE,
29	};
30
31	class Unary extends Expression {
32	private _kind: string;
33	private _valueExpr: Expression;
34
35	/**
36	* Positivese or negativise a value: +1 = 1, -1 = 0 - 1, -1 + 2 = 1, --1 = 1, etc
37	*
38	* @param kind Either + or -
39	* @param valueExpr The selector evaluating to the value to process
40	*/
41	constructor(kind: string, valueExpr: Expression, type: SequenceType) {
42	super(valueExpr.specificity, [valueExpr], { canBeStaticallyEvaluated: false }, false, type);	165✔
43	this._valueExpr = valueExpr;	165✔
44	this._kind = kind;	165✔
45	}
46
47	public evaluate(dynamicContext: DynamicContext, executionParameters: ExecutionParameters) {
48	return atomize(	168✔
49	this._valueExpr.evaluateMaybeStatically(dynamicContext, executionParameters),
50	executionParameters
51	).mapAll((atomizedValues) => {
52	if (atomizedValues.length === 0) {	168✔
53	// Return the empty sequence when inputted the empty sequence
54	return sequenceFactory.empty();	3✔
55	}
56
57	const value = atomizedValues[0];	165✔
58
59	// We could infer the return type during annotation so we can early return here
60	if (this.type) {	165!
61	let finalValue = this._kind === '+' ? +value.value : -value.value;	165✔
62	if (value.type === ValueType.XSBOOLEAN) finalValue = Number.NaN;	165✔
63	return sequenceFactory.singleton(createAtomicValue(finalValue, this.type.type));	165✔
64	}
65
66	if (atomizedValues.length > 1) {	×
67	throw new Error(	×
68	'XPTY0004: The operand to a unary operator must be a sequence with a length less than one'
69	);
70	}
71
72	if (isSubtypeOf(value.type, ValueType.XSUNTYPEDATOMIC)) {	×
73	const castValue = castToType(value, ValueType.XSDOUBLE).value as number;	×
74	return sequenceFactory.singleton(	×
75	createAtomicValue(
76	this._kind === '+' ? castValue : -castValue,	×
77	ValueType.XSDOUBLE
78	)
79	);
80	}
81
82	if (isSubtypeOf(value.type, ValueType.XSNUMERIC)) {	×
83	if (this._kind === '+') {	×
84	return sequenceFactory.singleton(value);	×
85	}
86	return sequenceFactory.singleton(	×
87	createAtomicValue((value.value as number) * -1, UNARY_LOOKUP[value.type])
88	);
89	}
90	return sequenceFactory.singleton(createAtomicValue(Number.NaN, ValueType.XSDOUBLE));	×
91	});
92	}
93	}
94
95	export default Unary;	9✔

FontoXML / fontoxpath / 6107185957

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