6234074041

Committed 19 Sep 2023 10:08AM CUT coverage: 91.578%. First build

Build # 6234074041

Build Type

push

github

Committed by

DrRataplan

Commit Message

Update testcases csv

Run Details

4961 of 5761 branches covered (0.0%)

Branch coverage included in aggregate %.

10665 of 11302 relevant lines covered (94.36%)

97712.03 hits per line

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

70.0

/src/expressions/functions/builtInFunctions_duration.ts

import createAtomicValue from '../dataTypes/createAtomicValue';
import sequenceFactory from '../dataTypes/sequenceFactory';
import { SequenceMultiplicity, ValueType } from '../dataTypes/Value';
import { BUILT_IN_NAMESPACE_URIS } from '../staticallyKnownNamespaces';
import { BuiltinDeclarationType } from './builtInFunctions';
import FunctionDefinitionType from './FunctionDefinitionType';

const fnYearsFromDuration: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        if (sequence.isEmpty()) {
                return sequence;
        }
        return sequenceFactory.singleton(
                createAtomicValue(sequence.first().value.getYears(), ValueType.XSINTEGER)
        );
};

const fnMonthsFromDuration: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        if (sequence.isEmpty()) {
                return sequence;
        }
        return sequenceFactory.singleton(
                createAtomicValue(sequence.first().value.getMonths(), ValueType.XSINTEGER)
        );
};

const fnDaysFromDuration: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        if (sequence.isEmpty()) {
                return sequence;
        }
        return sequenceFactory.singleton(
                createAtomicValue(sequence.first().value.getDays(), ValueType.XSINTEGER)
        );
};

const fnHoursFromDuration: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        if (sequence.isEmpty()) {
                return sequence;
        }
        return sequenceFactory.singleton(
                createAtomicValue(sequence.first().value.getHours(), ValueType.XSINTEGER)
        );
};

const fnMinutesFromDuration: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        if (sequence.isEmpty()) {
                return sequence;
        }
        return sequenceFactory.singleton(
                createAtomicValue(sequence.first().value.getMinutes(), ValueType.XSINTEGER)
        );
};

const fnSecondsFromDuration: FunctionDefinitionType = (
        _dynamicContext,
        _executionParameters,
        _staticContext,
        sequence
) => {
        if (sequence.isEmpty()) {
                return sequence;
        }
        return sequenceFactory.singleton(
                createAtomicValue(sequence.first().value.getSeconds(), ValueType.XSDECIMAL)
        );
};

const declarations: BuiltinDeclarationType[] = [
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'years-from-duration',
                argumentTypes: [{ type: ValueType.XSDURATION, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnYearsFromDuration,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'months-from-duration',
                argumentTypes: [{ type: ValueType.XSDURATION, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnMonthsFromDuration,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'days-from-duration',
                argumentTypes: [{ type: ValueType.XSDURATION, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnDaysFromDuration,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'hours-from-duration',
                argumentTypes: [{ type: ValueType.XSDURATION, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnHoursFromDuration,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'minutes-from-duration',
                argumentTypes: [{ type: ValueType.XSDURATION, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnMinutesFromDuration,
        },
        {
                namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
                localName: 'seconds-from-duration',
                argumentTypes: [{ type: ValueType.XSDURATION, mult: SequenceMultiplicity.ZERO_OR_ONE }],
                returnType: { type: ValueType.XSDECIMAL, mult: SequenceMultiplicity.ZERO_OR_ONE },
                callFunction: fnSecondsFromDuration,
        },
];

export default {
        declarations,
};

1	import createAtomicValue from '../dataTypes/createAtomicValue';	9✔
2	import sequenceFactory from '../dataTypes/sequenceFactory';	9✔
3	import { SequenceMultiplicity, ValueType } from '../dataTypes/Value';
4	import { BUILT_IN_NAMESPACE_URIS } from '../staticallyKnownNamespaces';
5	import { BuiltinDeclarationType } from './builtInFunctions';
6	import FunctionDefinitionType from './FunctionDefinitionType';
7
8	const fnYearsFromDuration: FunctionDefinitionType = (	9✔
9	_dynamicContext,
10	_executionParameters,
11	_staticContext,
12	sequence
13	) => {
14	if (sequence.isEmpty()) {	18!
15	return sequence;	×
16	}
17	return sequenceFactory.singleton(	18✔
18	createAtomicValue(sequence.first().value.getYears(), ValueType.XSINTEGER)
19	);
20	};
21
22	const fnMonthsFromDuration: FunctionDefinitionType = (	9✔
23	_dynamicContext,
24	_executionParameters,
25	_staticContext,
26	sequence
27	) => {
28	if (sequence.isEmpty()) {	18!
29	return sequence;	×
30	}
31	return sequenceFactory.singleton(	18✔
32	createAtomicValue(sequence.first().value.getMonths(), ValueType.XSINTEGER)
33	);
34	};
35
36	const fnDaysFromDuration: FunctionDefinitionType = (	9✔
37	_dynamicContext,
38	_executionParameters,
39	_staticContext,
40	sequence
41	) => {
42	if (sequence.isEmpty()) {	18!
43	return sequence;	×
44	}
45	return sequenceFactory.singleton(	18✔
46	createAtomicValue(sequence.first().value.getDays(), ValueType.XSINTEGER)
47	);
48	};
49
50	const fnHoursFromDuration: FunctionDefinitionType = (	9✔
51	_dynamicContext,
52	_executionParameters,
53	_staticContext,
54	sequence
55	) => {
56	if (sequence.isEmpty()) {	18!
57	return sequence;	×
58	}
59	return sequenceFactory.singleton(	18✔
60	createAtomicValue(sequence.first().value.getHours(), ValueType.XSINTEGER)
61	);
62	};
63
64	const fnMinutesFromDuration: FunctionDefinitionType = (	9✔
65	_dynamicContext,
66	_executionParameters,
67	_staticContext,
68	sequence
69	) => {
70	if (sequence.isEmpty()) {	18!
71	return sequence;	×
72	}
73	return sequenceFactory.singleton(	18✔
74	createAtomicValue(sequence.first().value.getMinutes(), ValueType.XSINTEGER)
75	);
76	};
77
78	const fnSecondsFromDuration: FunctionDefinitionType = (	9✔
79	_dynamicContext,
80	_executionParameters,
81	_staticContext,
82	sequence
83	) => {
84	if (sequence.isEmpty()) {	18!
85	return sequence;	×
86	}
87	return sequenceFactory.singleton(	18✔
88	createAtomicValue(sequence.first().value.getSeconds(), ValueType.XSDECIMAL)
89	);
90	};
91
92	const declarations: BuiltinDeclarationType[] = [	9✔
93	{
94	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
95	localName: 'years-from-duration',
96	argumentTypes: [{ type: ValueType.XSDURATION, mult: SequenceMultiplicity.ZERO_OR_ONE }],
97	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
98	callFunction: fnYearsFromDuration,
99	},
100	{
101	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
102	localName: 'months-from-duration',
103	argumentTypes: [{ type: ValueType.XSDURATION, mult: SequenceMultiplicity.ZERO_OR_ONE }],
104	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
105	callFunction: fnMonthsFromDuration,
106	},
107	{
108	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
109	localName: 'days-from-duration',
110	argumentTypes: [{ type: ValueType.XSDURATION, mult: SequenceMultiplicity.ZERO_OR_ONE }],
111	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
112	callFunction: fnDaysFromDuration,
113	},
114	{
115	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
116	localName: 'hours-from-duration',
117	argumentTypes: [{ type: ValueType.XSDURATION, mult: SequenceMultiplicity.ZERO_OR_ONE }],
118	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
119	callFunction: fnHoursFromDuration,
120	},
121	{
122	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
123	localName: 'minutes-from-duration',
124	argumentTypes: [{ type: ValueType.XSDURATION, mult: SequenceMultiplicity.ZERO_OR_ONE }],
125	returnType: { type: ValueType.XSINTEGER, mult: SequenceMultiplicity.ZERO_OR_ONE },
126	callFunction: fnMinutesFromDuration,
127	},
128	{
129	namespaceURI: BUILT_IN_NAMESPACE_URIS.FUNCTIONS_NAMESPACE_URI,
130	localName: 'seconds-from-duration',
131	argumentTypes: [{ type: ValueType.XSDURATION, mult: SequenceMultiplicity.ZERO_OR_ONE }],
132	returnType: { type: ValueType.XSDECIMAL, mult: SequenceMultiplicity.ZERO_OR_ONE },
133	callFunction: fnSecondsFromDuration,
134	},
135	];
136
137	export default {	9✔
138	declarations,
139	};

FontoXML / fontoxpath / 6234074041

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