7042c506-6d2b-4b31-8b0d-9e20f06c4e23

Build # 7042c506-6d2b-4b31-8b0d-9e20f06c4e23

Build Type

push

circleci

Committed by Nic30

Commit Message

update CI badge

Run Details

212 of 377 branches covered (56.23%)

Branch coverage included in aggregate %.

612 of 867 relevant lines covered (70.59%)

70.58 hits per line

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

79.75

/src/rowRenderers/numFormat.js

"use strict";

const NUM_FORMATS = {
    'b': 2,
    'o': 8,
    'd': 10,
    'x': 16
};

function genFormatter(newBase) {
    return function (d) {
        if (typeof d === 'number') { return d.toString(newBase); }
                if (d === "X") { return d; }
        let baseChar = d[0];
        d = d.substring(1);
        let base = NUM_FORMATS[baseChar];
        if (base === newBase) { return d; }
                d = d.toUpperCase();
        let containsX = d.indexOf('X') >= 0;
        if (containsX && newBase === 10) { return 'X'; }

        let origD = d;
        if (containsX) {
            d = d.replace(/X/g, '0');
        }

        let num = BigInt('0' + baseChar + d);
        num = num.toString(newBase);

        if (newBase === 2) { newBase = 1; }
        if (base === 2) { base = 1; }

        if (containsX) {
            let _num = [];
            for (let i = 0; i < num.length; i++) {
                _num.push(num[i]);
            }
            // set digits which are not valid to X
            if (base < newBase) {
                // e.g. bin -> hex
                let digitRatio = newBase / base;
                for (let i = 0; i < num.length; i++) {
                    let offset = i * digitRatio;
                    for (var i2 = 0; i2 < digitRatio; i2++) {
                        if (origD[offset + i2] === 'X') {
                            // invalidate corresponding digit if there was a X in original value
                            _num[i] = 'X';
                            break;
                        }
                    }
                }
            } else {
                // e.g. hex -> bin
                let digitRatio = base / newBase;
                for (let i = 0; i < origD.length; i++) {
                    if (origD[i] === 'X') {
                        let end = i * digitRatio;
                        // invalidate all corresponding digits if there was a X in original value
                        for (let i2 = i * digitRatio; i2 < end; i2++) {
                            _num[i2] = 'X';
                        }
                    }
                }
            }
            num = _num.join('');
        }

        return num;
    };
}

function genVectorFormatter(newBase) {
        var itemFormat = genFormatter(newBase);
        return function (d) {
                if (typeof d === 'string')
                   return itemFormat(d);
                // @param d: [[index list], value]
        var buff = [];
        var indexes = d[0];
        indexes.forEach(function (i) {
               buff.push("[");
               buff.push(i);
           buff.push("]"); 
        })
        buff.push("=");
        buff.push(itemFormat(d[1]));
        return buff.join("");
        }
}

export const SCALAR_FORMAT = {
    UINT_BIN: genFormatter(2),
    UINT_OCT: genFormatter(8),
    UINT_DEC: genFormatter(10),
    UINT_HEX: genFormatter(16),
};

export const VECTOR_FORMAT = {
    UINT_BIN: genVectorFormatter(2),
    UINT_OCT: genVectorFormatter(8),
    UINT_DEC: genVectorFormatter(10),
    UINT_HEX: genVectorFormatter(16)
};

1	"use strict";
2
3	const NUM_FORMATS = {	2✔
4	'b': 2,
5	'o': 8,
6	'd': 10,
7	'x': 16
8	};
9
10	function genFormatter(newBase) {
11	return function (d) {	16✔
12	if (typeof d === 'number') { return d.toString(newBase); }	493!
13	if (d === "X") { return d; }	493!
14	let baseChar = d[0];	493✔
15	d = d.substring(1);	493✔
16	let base = NUM_FORMATS[baseChar];	493✔
17	if (base === newBase) { return d; }	493!
18	d = d.toUpperCase();	493✔
19	let containsX = d.indexOf('X') >= 0;	493✔
20	if (containsX && newBase === 10) { return 'X'; }	493!
21
22	let origD = d;	493✔
23	if (containsX) {	493✔
24	d = d.replace(/X/g, '0');	62✔
25	}
26
27	let num = BigInt('0' + baseChar + d);	493✔
28	num = num.toString(newBase);	493✔
29
30	if (newBase === 2) { newBase = 1; }	493!
31	if (base === 2) { base = 1; }	493!
32
33	if (containsX) {	493✔
34	let _num = [];	62✔
35	for (let i = 0; i < num.length; i++) {	62✔
36	_num.push(num[i]);	62✔
37	}
38	// set digits which are not valid to X
39	if (base < newBase) {	62!
40	// e.g. bin -> hex
41	let digitRatio = newBase / base;	62✔
42	for (let i = 0; i < num.length; i++) {	62✔
43	let offset = i * digitRatio;	62✔
44	for (var i2 = 0; i2 < digitRatio; i2++) {	62✔
45	if (origD[offset + i2] === 'X') {	62!
46	// invalidate corresponding digit if there was a X in original value
47	_num[i] = 'X';	62✔
48	break;	62✔
49	}
50	}
51	}
52	} else {
53	// e.g. hex -> bin
54	let digitRatio = base / newBase;	×
55	for (let i = 0; i < origD.length; i++) {	×
56	if (origD[i] === 'X') {	×
57	let end = i * digitRatio;	×
58	// invalidate all corresponding digits if there was a X in original value
59	for (let i2 = i * digitRatio; i2 < end; i2++) {	×
60	_num[i2] = 'X';	×
61	}
62	}
63	}
64	}
65	num = _num.join('');	62✔
66	}
67
68	return num;	493✔
69	};
70	}
71
72	function genVectorFormatter(newBase) {
73	var itemFormat = genFormatter(newBase);	8✔
74	return function (d) {	8✔
75	if (typeof d === 'string')	75✔
76	return itemFormat(d);	15✔
77	// @param d: [[index list], value]
78	var buff = [];	60✔
79	var indexes = d[0];	60✔
80	indexes.forEach(function (i) {	60✔
81	buff.push("[");	60✔
82	buff.push(i);	60✔
83	buff.push("]");	60✔
84	})
85	buff.push("=");	60✔
86	buff.push(itemFormat(d[1]));	60✔
87	return buff.join("");	60✔
88	}
89	}
90
91	export const SCALAR_FORMAT = {	2✔
92	UINT_BIN: genFormatter(2),
93	UINT_OCT: genFormatter(8),
94	UINT_DEC: genFormatter(10),
95	UINT_HEX: genFormatter(16),
96	};
97
98	export const VECTOR_FORMAT = {	2✔
99	UINT_BIN: genVectorFormatter(2),
100	UINT_OCT: genVectorFormatter(8),
101	UINT_DEC: genVectorFormatter(10),
102	UINT_HEX: genVectorFormatter(16)
103	};

Nic30 / d3-wave / 7042c506-6d2b-4b31-8b0d-9e20f06c4e23

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