convertToDate,
convertToFloat,
convertToInt,
+ extractTimeSeriesValues,
formatDurationMilliSeconds,
formatDurationSeconds,
generateUUID,
isNullOrUndefined,
isObject,
isUndefined,
- isValidDate,
+ isValidTime,
+ max,
+ min,
+ once,
roundTo,
secureRandom,
sleep,
it('Verify sleep()', async () => {
const start = performance.now();
await sleep(1000);
- const end = performance.now();
- expect(end - start).toBeGreaterThanOrEqual(1000);
+ const stop = performance.now();
+ expect(stop - start).toBeGreaterThanOrEqual(1000);
});
it('Verify formatDurationMilliSeconds()', () => {
expect(formatDurationSeconds(hoursToSeconds(4380))).toBe('182 days 12 hours');
});
- it('Verify isValidDate()', () => {
- expect(isValidDate(undefined)).toBe(false);
- expect(isValidDate(null)).toBe(false);
- expect(isValidDate('')).toBe(false);
- expect(isValidDate({})).toBe(false);
- expect(isValidDate([])).toBe(false);
- expect(isValidDate(new Map())).toBe(false);
- expect(isValidDate(new Set())).toBe(false);
- expect(isValidDate(new WeakMap())).toBe(false);
- expect(isValidDate(new WeakSet())).toBe(false);
- expect(isValidDate(-1)).toBe(true);
- expect(isValidDate(0)).toBe(true);
- expect(isValidDate(1)).toBe(true);
- expect(isValidDate(-0.5)).toBe(true);
- expect(isValidDate(0.5)).toBe(true);
- expect(isValidDate(new Date())).toBe(true);
+ it('Verify isValidTime()', () => {
+ expect(isValidTime(undefined)).toBe(false);
+ expect(isValidTime(null)).toBe(false);
+ expect(isValidTime('')).toBe(false);
+ expect(isValidTime({})).toBe(false);
+ expect(isValidTime([])).toBe(false);
+ expect(isValidTime(new Map())).toBe(false);
+ expect(isValidTime(new Set())).toBe(false);
+ expect(isValidTime(new WeakMap())).toBe(false);
+ expect(isValidTime(new WeakSet())).toBe(false);
+ expect(isValidTime(-1)).toBe(true);
+ expect(isValidTime(0)).toBe(true);
+ expect(isValidTime(1)).toBe(true);
+ expect(isValidTime(-0.5)).toBe(true);
+ expect(isValidTime(0.5)).toBe(true);
+ expect(isValidTime(new Date())).toBe(true);
});
it('Verify convertToDate()', () => {
expect(convertToDate(undefined)).toBe(undefined);
- expect(convertToDate(null)).toBe(null);
- const invalidDate = convertToDate('');
- expect(invalidDate instanceof Date && !isNaN(invalidDate.getTime())).toBe(false);
+ expect(() => convertToDate('')).toThrowError(new Error("Cannot convert to date: ''"));
+ expect(() => convertToDate('00:70:61')).toThrowError(
+ new Error("Cannot convert to date: '00:70:61'"),
+ );
expect(convertToDate(0)).toStrictEqual(new Date('1970-01-01T00:00:00.000Z'));
+ expect(convertToDate(-1)).toStrictEqual(new Date('1969-12-31T23:59:59.999Z'));
const dateStr = '2020-01-01T00:00:00.000Z';
let date = convertToDate(dateStr);
expect(date).toBeInstanceOf(Date);
expect(convertToInt(1.999)).toBe(1);
expect(() => {
convertToInt('NaN');
- }).toThrow('Cannot convert to integer: NaN');
+ }).toThrow("Cannot convert to integer: 'NaN'");
});
it('Verify convertToFloat()', () => {
expect(convertToFloat(1.999)).toBe(1.999);
expect(() => {
convertToFloat('NaN');
- }).toThrow('Cannot convert to float: NaN');
+ }).toThrow("Cannot convert to float: 'NaN'");
});
it('Verify convertToBoolean()', () => {
randomInteger = getRandomInteger(2, 1);
expect(randomInteger).toBeGreaterThanOrEqual(1);
expect(randomInteger).toBeLessThanOrEqual(2);
- const max = 2.2,
- min = 1.1;
- randomInteger = getRandomInteger(max, min);
- expect(randomInteger).toBeGreaterThanOrEqual(Math.ceil(min));
- expect(randomInteger).toBeLessThanOrEqual(Math.floor(max));
+ const maximum = 2.2,
+ minimum = 1.1;
+ randomInteger = getRandomInteger(maximum, minimum);
+ expect(randomInteger).toBeLessThanOrEqual(Math.floor(maximum));
+ expect(randomInteger).toBeGreaterThanOrEqual(Math.ceil(minimum));
});
it('Verify roundTo()', () => {
expect(randomFloat).toBeLessThanOrEqual(0);
});
+ it('Verify extractTimeSeriesValues()', () => {
+ expect(extractTimeSeriesValues([])).toEqual([]);
+ expect(extractTimeSeriesValues([{ timestamp: Date.now(), value: 1.1 }])).toEqual([1.1]);
+ expect(
+ extractTimeSeriesValues([
+ { timestamp: Date.now(), value: 1.1 },
+ { timestamp: Date.now(), value: 2.2 },
+ ]),
+ ).toEqual([1.1, 2.2]);
+ });
+
it('Verify isObject()', () => {
expect(isObject('test')).toBe(false);
expect(isObject(undefined)).toBe(false);
const obj = { 1: 1 };
expect(cloneObject(obj)).toStrictEqual(obj);
expect(cloneObject(obj) === obj).toBe(false);
+ const nestedObj = { 1: obj, 2: obj };
+ expect(cloneObject(nestedObj)).toStrictEqual(nestedObj);
+ expect(cloneObject(nestedObj) === nestedObj).toBe(false);
const array = [1, 2];
expect(cloneObject(array)).toStrictEqual(array);
expect(cloneObject(array) === array).toBe(false);
+ const objArray = [obj, obj];
+ expect(cloneObject(objArray)).toStrictEqual(objArray);
+ expect(cloneObject(objArray) === objArray).toBe(false);
const date = new Date();
expect(cloneObject(date)).toStrictEqual(date);
expect(cloneObject(date) === date).toBe(false);
const map = new Map([['1', '2']]);
- expect(cloneObject(map)).toStrictEqual(map);
- expect(cloneObject(map) === map).toBe(false);
+ expect(cloneObject(map)).toStrictEqual({});
const set = new Set(['1']);
- expect(cloneObject(set)).toStrictEqual(set);
- expect(cloneObject(set) === set).toBe(false);
+ expect(cloneObject(set)).toStrictEqual({});
// The URL object seems to have not enumerable properties
const url = new URL('https://domain.tld');
- expect(cloneObject(url)).toStrictEqual(url);
- expect(cloneObject(url) === url).toBe(true);
+ expect(cloneObject(url)).toStrictEqual({});
const weakMap = new WeakMap([[{ 1: 1 }, { 2: 2 }]]);
- expect(cloneObject(weakMap)).toStrictEqual(weakMap);
- expect(cloneObject(weakMap) === weakMap).toBe(true);
+ expect(cloneObject(weakMap)).toStrictEqual({});
const weakSet = new WeakSet([{ 1: 1 }, { 2: 2 }]);
- expect(cloneObject(weakSet)).toStrictEqual(weakSet);
- expect(cloneObject(weakSet) === weakSet).toBe(true);
+ expect(cloneObject(weakSet)).toStrictEqual({});
});
it('Verify hasOwnProp()', () => {
).toBe(true);
expect(isArraySorted<number>([1, 2, 3, 4, 5], (a, b) => a - b)).toBe(true);
expect(isArraySorted<number>([1, 2, 3, 5, 4], (a, b) => a - b)).toBe(false);
+ expect(isArraySorted<number>([2, 1, 3, 4, 5], (a, b) => a - b)).toBe(false);
+ });
+
+ it('Verify once()', () => {
+ let called = 0;
+ const fn = () => ++called;
+ const onceFn = once(fn, this);
+ const result1 = onceFn();
+ expect(called).toBe(1);
+ expect(result1).toBe(1);
+ const result2 = onceFn();
+ expect(called).toBe(1);
+ expect(result2).toBe(1);
+ const result3 = onceFn();
+ expect(called).toBe(1);
+ expect(result3).toBe(1);
+ });
+
+ it('Verify min()', () => {
+ expect(min()).toBe(Infinity);
+ expect(min(0, 1)).toBe(0);
+ expect(min(1, 0)).toBe(0);
+ expect(min(0, -1)).toBe(-1);
+ expect(min(-1, 0)).toBe(-1);
+ });
+
+ it('Verify max()', () => {
+ expect(max()).toBe(-Infinity);
+ expect(max(0, 1)).toBe(1);
+ expect(max(1, 0)).toBe(1);
+ expect(max(0, -1)).toBe(0);
+ expect(max(-1, 0)).toBe(0);
});
});