tests/utils/Utils.test.ts

   1 import { describe, it } from 'node:test'
   2
   3 import { hoursToMilliseconds, hoursToSeconds } from 'date-fns'
   4 import { expect } from 'expect'
   5
   6 import { Constants } from '../../src/utils/Constants.js'
   7 import {
   8   clone,
   9   convertToBoolean,
  10   convertToDate,
  11   convertToFloat,
  12   convertToInt,
  13   extractTimeSeriesValues,
  14   formatDurationMilliSeconds,
  15   formatDurationSeconds,
  16   generateUUID,
  17   getRandomFloat,
  18   getRandomInteger,
  19   hasOwnProp,
  20   isArraySorted,
  21   isAsyncFunction,
  22   isEmptyArray,
  23   isEmptyObject,
  24   isEmptyString,
  25   isNotEmptyArray,
  26   isNotEmptyString,
  27   isObject,
  28   isValidDate,
  29   max,
  30   min,
  31   once,
  32   roundTo,
  33   secureRandom,
  34   sleep,
  35   validateUUID
  36 } from '../../src/utils/Utils.js'
  37
  38 await describe('Utils test suite', async () => {
  39   await it('Verify generateUUID()/validateUUID()', () => {
  40     const uuid = generateUUID()
  41     expect(uuid).toBeDefined()
  42     expect(uuid.length).toEqual(36)
  43     expect(validateUUID(uuid)).toBe(true)
  44     expect(validateUUID('abcdef00-0000-4000-0000-000000000000')).toBe(true)
  45     expect(validateUUID('')).toBe(false)
  46     // Shall invalidate Nil UUID
  47     expect(validateUUID('00000000-0000-0000-0000-000000000000')).toBe(false)
  48     expect(validateUUID('987FBC9-4BED-3078-CF07A-9141BA07C9F3')).toBe(false)
  49   })
  50
  51   await it('Verify sleep()', async () => {
  52     const start = performance.now()
  53     await sleep(1000)
  54     const stop = performance.now()
  55     expect(stop - start).toBeGreaterThanOrEqual(1000)
  56   })
  57
  58   await it('Verify formatDurationMilliSeconds()', () => {
  59     expect(formatDurationMilliSeconds(0)).toBe('0 seconds')
  60     expect(formatDurationMilliSeconds(900)).toBe('0 seconds')
  61     expect(formatDurationMilliSeconds(1000)).toBe('1 second')
  62     expect(formatDurationMilliSeconds(hoursToMilliseconds(4380))).toBe('182 days 12 hours')
  63   })
  64
  65   await it('Verify formatDurationSeconds()', () => {
  66     expect(formatDurationSeconds(0)).toBe('0 seconds')
  67     expect(formatDurationSeconds(0.9)).toBe('0 seconds')
  68     expect(formatDurationSeconds(1)).toBe('1 second')
  69     expect(formatDurationSeconds(hoursToSeconds(4380))).toBe('182 days 12 hours')
  70   })
  71
  72   await it('Verify isValidDate()', () => {
  73     expect(isValidDate(undefined)).toBe(false)
  74     expect(isValidDate(-1)).toBe(true)
  75     expect(isValidDate(0)).toBe(true)
  76     expect(isValidDate(1)).toBe(true)
  77     expect(isValidDate(-0.5)).toBe(true)
  78     expect(isValidDate(0.5)).toBe(true)
  79     expect(isValidDate(new Date())).toBe(true)
  80   })
  81
  82   await it('Verify convertToDate()', () => {
  83     expect(convertToDate(undefined)).toBe(undefined)
  84     expect(convertToDate(null)).toBe(undefined)
  85     expect(() => convertToDate('')).toThrow(new Error("Cannot convert to date: ''"))
  86     expect(() => convertToDate('00:70:61')).toThrow(new Error("Cannot convert to date: '00:70:61'"))
  87     expect(convertToDate(0)).toStrictEqual(new Date('1970-01-01T00:00:00.000Z'))
  88     expect(convertToDate(-1)).toStrictEqual(new Date('1969-12-31T23:59:59.999Z'))
  89     const dateStr = '2020-01-01T00:00:00.000Z'
  90     let date = convertToDate(dateStr)
  91     expect(date).toBeInstanceOf(Date)
  92     expect(date).toStrictEqual(new Date(dateStr))
  93     date = convertToDate(new Date(dateStr))
  94     expect(date).toBeInstanceOf(Date)
  95     expect(date).toStrictEqual(new Date(dateStr))
  96   })
  97
  98   await it('Verify convertToInt()', () => {
  99     expect(convertToInt(undefined)).toBe(0)
 100     expect(convertToInt(null)).toBe(0)
 101     expect(convertToInt(0)).toBe(0)
 102     const randomInteger = getRandomInteger()
 103     expect(convertToInt(randomInteger)).toEqual(randomInteger)
 104     expect(convertToInt('-1')).toBe(-1)
 105     expect(convertToInt('1')).toBe(1)
 106     expect(convertToInt('1.1')).toBe(1)
 107     expect(convertToInt('1.9')).toBe(1)
 108     expect(convertToInt('1.999')).toBe(1)
 109     expect(convertToInt(-1)).toBe(-1)
 110     expect(convertToInt(1)).toBe(1)
 111     expect(convertToInt(1.1)).toBe(1)
 112     expect(convertToInt(1.9)).toBe(1)
 113     expect(convertToInt(1.999)).toBe(1)
 114     expect(() => {
 115       convertToInt('NaN')
 116     }).toThrow("Cannot convert to integer: 'NaN'")
 117   })
 118
 119   await it('Verify convertToFloat()', () => {
 120     expect(convertToFloat(undefined)).toBe(0)
 121     expect(convertToFloat(null)).toBe(0)
 122     expect(convertToFloat(0)).toBe(0)
 123     const randomFloat = getRandomFloat()
 124     expect(convertToFloat(randomFloat)).toEqual(randomFloat)
 125     expect(convertToFloat('-1')).toBe(-1)
 126     expect(convertToFloat('1')).toBe(1)
 127     expect(convertToFloat('1.1')).toBe(1.1)
 128     expect(convertToFloat('1.9')).toBe(1.9)
 129     expect(convertToFloat('1.999')).toBe(1.999)
 130     expect(convertToFloat(-1)).toBe(-1)
 131     expect(convertToFloat(1)).toBe(1)
 132     expect(convertToFloat(1.1)).toBe(1.1)
 133     expect(convertToFloat(1.9)).toBe(1.9)
 134     expect(convertToFloat(1.999)).toBe(1.999)
 135     expect(() => {
 136       convertToFloat('NaN')
 137     }).toThrow("Cannot convert to float: 'NaN'")
 138   })
 139
 140   await it('Verify convertToBoolean()', () => {
 141     expect(convertToBoolean(undefined)).toBe(false)
 142     expect(convertToBoolean(null)).toBe(false)
 143     expect(convertToBoolean('true')).toBe(true)
 144     expect(convertToBoolean('false')).toBe(false)
 145     expect(convertToBoolean('TRUE')).toBe(true)
 146     expect(convertToBoolean('FALSE')).toBe(false)
 147     expect(convertToBoolean('1')).toBe(true)
 148     expect(convertToBoolean('0')).toBe(false)
 149     expect(convertToBoolean(1)).toBe(true)
 150     expect(convertToBoolean(0)).toBe(false)
 151     expect(convertToBoolean(true)).toBe(true)
 152     expect(convertToBoolean(false)).toBe(false)
 153     expect(convertToBoolean('')).toBe(false)
 154     expect(convertToBoolean('NoNBoolean')).toBe(false)
 155   })
 156
 157   await it('Verify secureRandom()', () => {
 158     const random = secureRandom()
 159     expect(typeof random === 'number').toBe(true)
 160     expect(random).toBeGreaterThanOrEqual(0)
 161     expect(random).toBeLessThan(1)
 162   })
 163
 164   await it('Verify getRandomInteger()', () => {
 165     let randomInteger = getRandomInteger()
 166     expect(Number.isSafeInteger(randomInteger)).toBe(true)
 167     expect(randomInteger).toBeGreaterThanOrEqual(0)
 168     expect(randomInteger).toBeLessThanOrEqual(Constants.MAX_RANDOM_INTEGER)
 169     expect(randomInteger).not.toEqual(getRandomInteger())
 170     randomInteger = getRandomInteger(0, -Constants.MAX_RANDOM_INTEGER)
 171     expect(randomInteger).toBeGreaterThanOrEqual(-Constants.MAX_RANDOM_INTEGER)
 172     expect(randomInteger).toBeLessThanOrEqual(0)
 173     expect(() => getRandomInteger(0, 1)).toThrow(
 174       'The value of "max" is out of range. It must be greater than the value of "min" (1). Received 1'
 175     )
 176     expect(() => getRandomInteger(-1)).toThrow(
 177       'The value of "max" is out of range. It must be greater than the value of "min" (0). Received 0'
 178     )
 179     expect(() => getRandomInteger(Constants.MAX_RANDOM_INTEGER + 1)).toThrow(
 180       `The value of "max" is out of range. It must be <= ${
 181         Constants.MAX_RANDOM_INTEGER + 1
 182       }. Received 281_474_976_710_656`
 183     )
 184     randomInteger = getRandomInteger(2, 1)
 185     expect(randomInteger).toBeGreaterThanOrEqual(1)
 186     expect(randomInteger).toBeLessThanOrEqual(2)
 187     const maximum = 2.2
 188     const minimum = 1.1
 189     randomInteger = getRandomInteger(maximum, minimum)
 190     expect(randomInteger).toBeLessThanOrEqual(Math.floor(maximum))
 191     expect(randomInteger).toBeGreaterThanOrEqual(Math.ceil(minimum))
 192   })
 193
 194   await it('Verify roundTo()', () => {
 195     expect(roundTo(0, 2)).toBe(0)
 196     expect(roundTo(0.5, 0)).toBe(1)
 197     expect(roundTo(0.5, 2)).toBe(0.5)
 198     expect(roundTo(-0.5, 0)).toBe(-1)
 199     expect(roundTo(-0.5, 2)).toBe(-0.5)
 200     expect(roundTo(1.005, 0)).toBe(1)
 201     expect(roundTo(1.005, 2)).toBe(1.01)
 202     expect(roundTo(2.175, 2)).toBe(2.18)
 203     expect(roundTo(5.015, 2)).toBe(5.02)
 204     expect(roundTo(-1.005, 2)).toBe(-1.01)
 205     expect(roundTo(-2.175, 2)).toBe(-2.18)
 206     expect(roundTo(-5.015, 2)).toBe(-5.02)
 207   })
 208
 209   await it('Verify getRandomFloat()', () => {
 210     let randomFloat = getRandomFloat()
 211     expect(typeof randomFloat === 'number').toBe(true)
 212     expect(randomFloat).toBeGreaterThanOrEqual(0)
 213     expect(randomFloat).toBeLessThanOrEqual(Number.MAX_VALUE)
 214     expect(randomFloat).not.toEqual(getRandomFloat())
 215     expect(() => getRandomFloat(0, 1)).toThrow(new RangeError('Invalid interval'))
 216     expect(() => getRandomFloat(Number.MAX_VALUE, -Number.MAX_VALUE)).toThrow(
 217       new RangeError('Invalid interval')
 218     )
 219     randomFloat = getRandomFloat(0, -Number.MAX_VALUE)
 220     expect(randomFloat).toBeGreaterThanOrEqual(-Number.MAX_VALUE)
 221     expect(randomFloat).toBeLessThanOrEqual(0)
 222   })
 223
 224   await it('Verify extractTimeSeriesValues()', () => {
 225     expect(extractTimeSeriesValues([])).toEqual([])
 226     expect(extractTimeSeriesValues([{ timestamp: Date.now(), value: 1.1 }])).toEqual([1.1])
 227     expect(
 228       extractTimeSeriesValues([
 229         { timestamp: Date.now(), value: 1.1 },
 230         { timestamp: Date.now(), value: 2.2 }
 231       ])
 232     ).toEqual([1.1, 2.2])
 233   })
 234
 235   await it('Verify isObject()', () => {
 236     expect(isObject('test')).toBe(false)
 237     expect(isObject(undefined)).toBe(false)
 238     expect(isObject(null)).toBe(false)
 239     expect(isObject(0)).toBe(false)
 240     expect(isObject([])).toBe(false)
 241     expect(isObject([0, 1])).toBe(false)
 242     expect(isObject(['0', '1'])).toBe(false)
 243     expect(isObject({})).toBe(true)
 244     expect(isObject({ 1: 1 })).toBe(true)
 245     expect(isObject({ 1: '1' })).toBe(true)
 246     expect(isObject(new Map())).toBe(true)
 247     expect(isObject(new Set())).toBe(true)
 248     expect(isObject(new WeakMap())).toBe(true)
 249     expect(isObject(new WeakSet())).toBe(true)
 250   })
 251
 252   await it('Verify isAsyncFunction()', () => {
 253     expect(isAsyncFunction(null)).toBe(false)
 254     expect(isAsyncFunction(undefined)).toBe(false)
 255     expect(isAsyncFunction(true)).toBe(false)
 256     expect(isAsyncFunction(false)).toBe(false)
 257     expect(isAsyncFunction(0)).toBe(false)
 258     expect(isAsyncFunction('')).toBe(false)
 259     expect(isAsyncFunction([])).toBe(false)
 260     expect(isAsyncFunction(new Date())).toBe(false)
 261     // eslint-disable-next-line prefer-regex-literals
 262     expect(isAsyncFunction(new RegExp('[a-z]', 'i'))).toBe(false)
 263     expect(isAsyncFunction(new Error())).toBe(false)
 264     expect(isAsyncFunction(new Map())).toBe(false)
 265     expect(isAsyncFunction(new Set())).toBe(false)
 266     expect(isAsyncFunction(new WeakMap())).toBe(false)
 267     expect(isAsyncFunction(new WeakSet())).toBe(false)
 268     expect(isAsyncFunction(new Int8Array())).toBe(false)
 269     expect(isAsyncFunction(new Uint8Array())).toBe(false)
 270     expect(isAsyncFunction(new Uint8ClampedArray())).toBe(false)
 271     expect(isAsyncFunction(new Int16Array())).toBe(false)
 272     expect(isAsyncFunction(new Uint16Array())).toBe(false)
 273     expect(isAsyncFunction(new Int32Array())).toBe(false)
 274     expect(isAsyncFunction(new Uint32Array())).toBe(false)
 275     expect(isAsyncFunction(new Float32Array())).toBe(false)
 276     expect(isAsyncFunction(new Float64Array())).toBe(false)
 277     expect(isAsyncFunction(new BigInt64Array())).toBe(false)
 278     expect(isAsyncFunction(new BigUint64Array())).toBe(false)
 279     // eslint-disable-next-line @typescript-eslint/no-empty-function
 280     expect(isAsyncFunction(new Promise(() => {}))).toBe(false)
 281     expect(isAsyncFunction(new WeakRef({}))).toBe(false)
 282     // eslint-disable-next-line @typescript-eslint/no-empty-function
 283     expect(isAsyncFunction(new FinalizationRegistry(() => {}))).toBe(false)
 284     expect(isAsyncFunction(new ArrayBuffer(16))).toBe(false)
 285     expect(isAsyncFunction(new SharedArrayBuffer(16))).toBe(false)
 286     expect(isAsyncFunction(new DataView(new ArrayBuffer(16)))).toBe(false)
 287     expect(isAsyncFunction({})).toBe(false)
 288     expect(isAsyncFunction({ a: 1 })).toBe(false)
 289     // eslint-disable-next-line @typescript-eslint/no-empty-function
 290     expect(isAsyncFunction(() => {})).toBe(false)
 291     // eslint-disable-next-line @typescript-eslint/no-empty-function
 292     expect(isAsyncFunction(function () {})).toBe(false)
 293     // eslint-disable-next-line @typescript-eslint/no-empty-function
 294     expect(isAsyncFunction(function named () {})).toBe(false)
 295     // eslint-disable-next-line @typescript-eslint/no-empty-function
 296     expect(isAsyncFunction(async () => {})).toBe(true)
 297     // eslint-disable-next-line @typescript-eslint/no-empty-function
 298     expect(isAsyncFunction(async function () {})).toBe(true)
 299     // eslint-disable-next-line @typescript-eslint/no-empty-function
 300     expect(isAsyncFunction(async function named () {})).toBe(true)
 301     class TestClass {
 302       // eslint-disable-next-line @typescript-eslint/no-empty-function
 303       public testSync (): void {}
 304       // eslint-disable-next-line @typescript-eslint/no-empty-function
 305       public async testAsync (): Promise<void> {}
 306       // eslint-disable-next-line @typescript-eslint/no-empty-function
 307       public testArrowSync = (): void => {}
 308       // eslint-disable-next-line @typescript-eslint/no-empty-function
 309       public testArrowAsync = async (): Promise<void> => {}
 310       // eslint-disable-next-line @typescript-eslint/no-empty-function
 311       public static testStaticSync (): void {}
 312       // eslint-disable-next-line @typescript-eslint/no-empty-function
 313       public static async testStaticAsync (): Promise<void> {}
 314     }
 315     const testClass = new TestClass()
 316     // eslint-disable-next-line @typescript-eslint/unbound-method
 317     expect(isAsyncFunction(testClass.testSync)).toBe(false)
 318     // eslint-disable-next-line @typescript-eslint/unbound-method
 319     expect(isAsyncFunction(testClass.testAsync)).toBe(true)
 320     expect(isAsyncFunction(testClass.testArrowSync)).toBe(false)
 321     expect(isAsyncFunction(testClass.testArrowAsync)).toBe(true)
 322     // eslint-disable-next-line @typescript-eslint/unbound-method
 323     expect(isAsyncFunction(TestClass.testStaticSync)).toBe(false)
 324     // eslint-disable-next-line @typescript-eslint/unbound-method
 325     expect(isAsyncFunction(TestClass.testStaticAsync)).toBe(true)
 326   })
 327
 328   await it('Verify clone()', () => {
 329     const obj = { 1: 1 }
 330     expect(clone(obj)).toStrictEqual(obj)
 331     expect(clone(obj) === obj).toBe(false)
 332     const nestedObj = { 1: obj, 2: obj }
 333     expect(clone(nestedObj)).toStrictEqual(nestedObj)
 334     expect(clone(nestedObj) === nestedObj).toBe(false)
 335     const array = [1, 2]
 336     expect(clone(array)).toStrictEqual(array)
 337     expect(clone(array) === array).toBe(false)
 338     const objArray = [obj, obj]
 339     expect(clone(objArray)).toStrictEqual(objArray)
 340     expect(clone(objArray) === objArray).toBe(false)
 341     const date = new Date()
 342     expect(clone(date)).toStrictEqual(date)
 343     expect(clone(date) === date).toBe(false)
 344     const map = new Map([['1', '2']])
 345     expect(clone(map)).toStrictEqual({})
 346     const set = new Set(['1'])
 347     expect(clone(set)).toStrictEqual({})
 348     const weakMap = new WeakMap([[{ 1: 1 }, { 2: 2 }]])
 349     expect(clone(weakMap)).toStrictEqual({})
 350     const weakSet = new WeakSet([{ 1: 1 }, { 2: 2 }])
 351     expect(clone(weakSet)).toStrictEqual({})
 352   })
 353
 354   await it('Verify hasOwnProp()', () => {
 355     expect(hasOwnProp('test', '')).toBe(false)
 356     expect(hasOwnProp(undefined, '')).toBe(false)
 357     expect(hasOwnProp(null, '')).toBe(false)
 358     expect(hasOwnProp([], '')).toBe(false)
 359     expect(hasOwnProp({}, '')).toBe(false)
 360     expect(hasOwnProp({ 1: 1 }, 1)).toBe(true)
 361     expect(hasOwnProp({ 1: 1 }, '1')).toBe(true)
 362     expect(hasOwnProp({ 1: 1 }, 2)).toBe(false)
 363     expect(hasOwnProp({ 1: 1 }, '2')).toBe(false)
 364     expect(hasOwnProp({ 1: '1' }, '1')).toBe(true)
 365     expect(hasOwnProp({ 1: '1' }, 1)).toBe(true)
 366     expect(hasOwnProp({ 1: '1' }, '2')).toBe(false)
 367     expect(hasOwnProp({ 1: '1' }, 2)).toBe(false)
 368   })
 369
 370   await it('Verify isEmptyString()', () => {
 371     expect(isEmptyString('')).toBe(true)
 372     expect(isEmptyString(' ')).toBe(true)
 373     expect(isEmptyString('     ')).toBe(true)
 374     expect(isEmptyString('test')).toBe(false)
 375     expect(isEmptyString(' test')).toBe(false)
 376     expect(isEmptyString('test ')).toBe(false)
 377     expect(isEmptyString(undefined)).toBe(true)
 378     expect(isEmptyString(null)).toBe(true)
 379     expect(isEmptyString(0)).toBe(false)
 380     expect(isEmptyString({})).toBe(false)
 381     expect(isEmptyString([])).toBe(false)
 382     expect(isEmptyString(new Map())).toBe(false)
 383     expect(isEmptyString(new Set())).toBe(false)
 384     expect(isEmptyString(new WeakMap())).toBe(false)
 385     expect(isEmptyString(new WeakSet())).toBe(false)
 386   })
 387
 388   await it('Verify isNotEmptyString()', () => {
 389     expect(isNotEmptyString('')).toBe(false)
 390     expect(isNotEmptyString(' ')).toBe(false)
 391     expect(isNotEmptyString('     ')).toBe(false)
 392     expect(isNotEmptyString('test')).toBe(true)
 393     expect(isNotEmptyString(' test')).toBe(true)
 394     expect(isNotEmptyString('test ')).toBe(true)
 395     expect(isNotEmptyString(undefined)).toBe(false)
 396     expect(isNotEmptyString(null)).toBe(false)
 397     expect(isNotEmptyString(0)).toBe(false)
 398     expect(isNotEmptyString({})).toBe(false)
 399     expect(isNotEmptyString([])).toBe(false)
 400     expect(isNotEmptyString(new Map())).toBe(false)
 401     expect(isNotEmptyString(new Set())).toBe(false)
 402     expect(isNotEmptyString(new WeakMap())).toBe(false)
 403     expect(isNotEmptyString(new WeakSet())).toBe(false)
 404   })
 405
 406   await it('Verify isEmptyArray()', () => {
 407     expect(isEmptyArray([])).toBe(true)
 408     expect(isEmptyArray([1, 2])).toBe(false)
 409     expect(isEmptyArray(['1', '2'])).toBe(false)
 410     expect(isEmptyArray(undefined)).toBe(false)
 411     expect(isEmptyArray(null)).toBe(false)
 412     expect(isEmptyArray('')).toBe(false)
 413     expect(isEmptyArray('test')).toBe(false)
 414     expect(isEmptyArray(0)).toBe(false)
 415     expect(isEmptyArray({})).toBe(false)
 416     expect(isEmptyArray(new Map())).toBe(false)
 417     expect(isEmptyArray(new Set())).toBe(false)
 418     expect(isEmptyArray(new WeakMap())).toBe(false)
 419     expect(isEmptyArray(new WeakSet())).toBe(false)
 420   })
 421
 422   await it('Verify isNotEmptyArray()', () => {
 423     expect(isNotEmptyArray([])).toBe(false)
 424     expect(isNotEmptyArray([1, 2])).toBe(true)
 425     expect(isNotEmptyArray(['1', '2'])).toBe(true)
 426     expect(isNotEmptyArray(undefined)).toBe(false)
 427     expect(isNotEmptyArray(null)).toBe(false)
 428     expect(isNotEmptyArray('')).toBe(false)
 429     expect(isNotEmptyArray('test')).toBe(false)
 430     expect(isNotEmptyArray(0)).toBe(false)
 431     expect(isNotEmptyArray({})).toBe(false)
 432     expect(isNotEmptyArray(new Map())).toBe(false)
 433     expect(isNotEmptyArray(new Set())).toBe(false)
 434     expect(isNotEmptyArray(new WeakMap())).toBe(false)
 435     expect(isNotEmptyArray(new WeakSet())).toBe(false)
 436   })
 437
 438   await it('Verify isEmptyObject()', () => {
 439     expect(isEmptyObject({})).toBe(true)
 440     expect(isEmptyObject({ 1: 1, 2: 2 })).toBe(false)
 441     expect(isEmptyObject([])).toBe(false)
 442     expect(isEmptyObject([1, 2])).toBe(false)
 443     expect(isEmptyObject(new Map())).toBe(false)
 444     expect(isEmptyObject(new Set())).toBe(false)
 445     expect(isEmptyObject(new WeakMap())).toBe(false)
 446     expect(isEmptyObject(new WeakSet())).toBe(false)
 447   })
 448
 449   await it('Verify isArraySorted()', () => {
 450     expect(
 451       isArraySorted([], (a, b) => {
 452         return a - b
 453       })
 454     ).toBe(true)
 455     expect(
 456       isArraySorted([1], (a, b) => {
 457         return a - b
 458       })
 459     ).toBe(true)
 460     expect(isArraySorted<number>([1, 2, 3, 4, 5], (a, b) => a - b)).toBe(true)
 461     expect(isArraySorted<number>([1, 2, 3, 5, 4], (a, b) => a - b)).toBe(false)
 462     expect(isArraySorted<number>([2, 1, 3, 4, 5], (a, b) => a - b)).toBe(false)
 463   })
 464
 465   await it('Verify once()', () => {
 466     let called = 0
 467     const fn = (): number => ++called
 468     const onceFn = once(fn, this)
 469     const result1 = onceFn()
 470     expect(called).toBe(1)
 471     expect(result1).toBe(1)
 472     const result2 = onceFn()
 473     expect(called).toBe(1)
 474     expect(result2).toBe(1)
 475     const result3 = onceFn()
 476     expect(called).toBe(1)
 477     expect(result3).toBe(1)
 478   })
 479
 480   await it('Verify min()', () => {
 481     expect(min()).toBe(Infinity)
 482     expect(min(0, 1)).toBe(0)
 483     expect(min(1, 0)).toBe(0)
 484     expect(min(0, -1)).toBe(-1)
 485     expect(min(-1, 0)).toBe(-1)
 486   })
 487
 488   await it('Verify max()', () => {
 489     expect(max()).toBe(-Infinity)
 490     expect(max(0, 1)).toBe(1)
 491     expect(max(1, 0)).toBe(1)
 492     expect(max(0, -1)).toBe(0)
 493     expect(max(-1, 0)).toBe(0)
 494   })
 495 })