2051049265

Build # 2051049265

Build Type

github

Committed by GitHub

Commit Message

Merge cc41c8de7 into 2543c8a1a

Pull Request Pull Request #482: Make the child:: axis lazy

Run Details

4747 of 5550 branches covered (85.53%)

Branch coverage included in aggregate %.

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

11 existing lines in 4 files now uncovered.

10190 of 10842 relevant lines covered (93.99%)

132400.33 hits per line

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

91.43

/src/expressions/dataTypes/Sequences/SingletonSequence.ts

import { DONE_TOKEN, IIterator, ready } from '../../util/iterators';
import ISequence, { SwitchCasesCases } from '../ISequence';
import sequenceFactory from '../sequenceFactory';
import Value from '../Value';
import getEffectiveBooleanValue from './getEffectiveBooleanValue';

export default class SingletonSequence implements ISequence {
        public value: IIterator<Value>;

        private _effectiveBooleanValue: boolean;

        constructor(
                private readonly _sequenceFactory: typeof sequenceFactory,
                private readonly _onlyValue: Value
        ) {
                let hasPassed = false;
                this.value = {
                        next: () => {
                                if (hasPassed) {
                                        return DONE_TOKEN;
                                }
                                hasPassed = true;
                                return ready(_onlyValue);
                        },
                };
                this._effectiveBooleanValue = null;
        }

        public expandSequence(): ISequence {
                return this;
        }

        public filter(callback: (value: Value, i: number, sequence: ISequence) => boolean): ISequence {
                return callback(this._onlyValue, 0, this) ? this : this._sequenceFactory.create();
        }

        public first(): Value | null {
                return this._onlyValue;
        }

        public getAllValues(): Value[] {
                return [this._onlyValue];
        }

        public getEffectiveBooleanValue(): boolean {
                if (this._effectiveBooleanValue === null) {
                        this._effectiveBooleanValue = getEffectiveBooleanValue(this._onlyValue);
                }
                return this._effectiveBooleanValue;
        }

        public getLength(): number {
                return 1;
        }

        public isEmpty(): boolean {
                return false;
        }

        public isSingleton(): boolean {
                return true;
        }

        public map(callback: (value: Value, i: number, sequence: ISequence) => Value): ISequence {
                return this._sequenceFactory.create(callback(this._onlyValue, 0, this));
        }

        public mapAll(callback: (allValues: Value[]) => ISequence): ISequence {
                return callback([this._onlyValue]);
        }

        public switchCases(cases: SwitchCasesCases): ISequence {
                if (cases.singleton) {
                        return cases.singleton(this);
                }
                return cases.default(this);
        }
}

1	import { DONE_TOKEN, IIterator, ready } from '../../util/iterators';	12✔
2	import ISequence, { SwitchCasesCases } from '../ISequence';
3	import sequenceFactory from '../sequenceFactory';
4	import Value from '../Value';
5	import getEffectiveBooleanValue from './getEffectiveBooleanValue';	12✔
6
7	export default class SingletonSequence implements ISequence {	12✔
8	public value: IIterator<Value>;
9
10	private _effectiveBooleanValue: boolean;
11
12	constructor(
13	private readonly _sequenceFactory: typeof sequenceFactory,	1,687,240✔
14	private readonly _onlyValue: Value	1,687,240✔
15	) {
16	let hasPassed = false;	1,687,240✔
17	this.value = {	1,687,240✔
18	next: () => {
19	if (hasPassed) {	2,100,004✔
20	return DONE_TOKEN;	1,040,980✔
21	}
22	hasPassed = true;	1,059,024✔
23	return ready(_onlyValue);	1,059,024✔
24	},
25	};
26	this._effectiveBooleanValue = null;	1,687,240✔
27	}
28
29	public expandSequence(): ISequence {
30	return this;	18,728✔
31	}
32
33	public filter(callback: (value: Value, i: number, sequence: ISequence) => boolean): ISequence {
UNCOV 34	return callback(this._onlyValue, 0, this) ? this : this._sequenceFactory.create();	×
35	}
36
37	public first(): Value \| null {
38	return this._onlyValue;	530,480✔
39	}
40
41	public getAllValues(): Value[] {
42	return [this._onlyValue];	4,352✔
43	}
44
45	public getEffectiveBooleanValue(): boolean {
46	if (this._effectiveBooleanValue === null) {	2,180✔
47	this._effectiveBooleanValue = getEffectiveBooleanValue(this._onlyValue);	2,148✔
48	}
49	return this._effectiveBooleanValue;	2,180✔
50	}
51
52	public getLength(): number {
53	return 1;	20,120✔
54	}
55
56	public isEmpty(): boolean {
57	return false;	4,444✔
58	}
59
60	public isSingleton(): boolean {
61	return true;	9,716✔
62	}
63
64	public map(callback: (value: Value, i: number, sequence: ISequence) => Value): ISequence {
65	return this._sequenceFactory.create(callback(this._onlyValue, 0, this));	87,320✔
66	}
67
68	public mapAll(callback: (allValues: Value[]) => ISequence): ISequence {
69	return callback([this._onlyValue]);	920✔
70	}
71
72	public switchCases(cases: SwitchCasesCases): ISequence {
73	if (cases.singleton) {	85,372✔
74	return cases.singleton(this);	40,196✔
75	}
76	return cases.default(this);	45,176✔
77	}
78	}

FontoXML / fontoxpath / 2051049265

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