tests/utils.test.js

   1 const { expect } = require('expect')
   2 const { CircularArray } = require('../lib/circular-array')
   3 const {
   4   availableParallelism,
   5   isAsyncFunction,
   6   isKillBehavior,
   7   isPlainObject,
   8   median,
   9   round,
  10   updateMeasurementStatistics
  11 } = require('../lib/utils')
  12 const { KillBehaviors } = require('../lib/worker/worker-options')
  13
  14 describe('Utils test suite', () => {
  15   it('Verify availableParallelism() behavior', () => {
  16     expect(typeof availableParallelism() === 'number').toBe(true)
  17   })
  18
  19   it('Verify median() computation', () => {
  20     expect(median([])).toBe(0)
  21     expect(median([0.08])).toBe(0.08)
  22     expect(median([0.25, 4.75, 3.05, 6.04, 1.01, 2.02, 5.03])).toBe(3.05)
  23     expect(median([0.25, 4.75, 3.05, 6.04, 1.01, 2.02])).toBe(2.535)
  24   })
  25
  26   it('Verify round() behavior', () => {
  27     expect(round(0)).toBe(0)
  28     expect(round(0.5, 0)).toBe(1)
  29     expect(round(0.5)).toBe(0.5)
  30     expect(round(-0.5, 0)).toBe(-1)
  31     expect(round(-0.5)).toBe(-0.5)
  32     expect(round(1.005)).toBe(1.01)
  33     expect(round(2.175)).toBe(2.18)
  34     expect(round(5.015)).toBe(5.02)
  35     expect(round(-1.005)).toBe(-1.01)
  36     expect(round(-2.175)).toBe(-2.18)
  37     expect(round(-5.015)).toBe(-5.02)
  38   })
  39
  40   it('Verify isPlainObject() behavior', () => {
  41     expect(isPlainObject(null)).toBe(false)
  42     expect(isPlainObject(undefined)).toBe(false)
  43     expect(isPlainObject(true)).toBe(false)
  44     expect(isPlainObject(false)).toBe(false)
  45     expect(isPlainObject(0)).toBe(false)
  46     expect(isPlainObject('')).toBe(false)
  47     expect(isPlainObject([])).toBe(false)
  48     expect(isPlainObject(() => {})).toBe(false)
  49     expect(isPlainObject(new Date())).toBe(false)
  50     expect(isPlainObject(new RegExp())).toBe(false)
  51     expect(isPlainObject(new Error())).toBe(false)
  52     expect(isPlainObject(new Map())).toBe(false)
  53     expect(isPlainObject(new Set())).toBe(false)
  54     expect(isPlainObject(new WeakMap())).toBe(false)
  55     expect(isPlainObject(new WeakSet())).toBe(false)
  56     expect(isPlainObject(new Int8Array())).toBe(false)
  57     expect(isPlainObject(new Uint8Array())).toBe(false)
  58     expect(isPlainObject(new Uint8ClampedArray())).toBe(false)
  59     expect(isPlainObject(new Int16Array())).toBe(false)
  60     expect(isPlainObject(new Uint16Array())).toBe(false)
  61     expect(isPlainObject(new Int32Array())).toBe(false)
  62     expect(isPlainObject(new Uint32Array())).toBe(false)
  63     expect(isPlainObject(new Float32Array())).toBe(false)
  64     expect(isPlainObject(new Float64Array())).toBe(false)
  65     expect(isPlainObject(new BigInt64Array())).toBe(false)
  66     expect(isPlainObject(new BigUint64Array())).toBe(false)
  67     expect(isPlainObject(new Promise(() => {}))).toBe(false)
  68     expect(isPlainObject(new WeakRef({}))).toBe(false)
  69     expect(isPlainObject(new FinalizationRegistry(() => {}))).toBe(false)
  70     expect(isPlainObject(new ArrayBuffer())).toBe(false)
  71     expect(isPlainObject(new SharedArrayBuffer())).toBe(false)
  72     expect(isPlainObject(new DataView(new ArrayBuffer()))).toBe(false)
  73     expect(isPlainObject({})).toBe(true)
  74     expect(isPlainObject({ a: 1 })).toBe(true)
  75   })
  76
  77   it('Verify isKillBehavior() behavior', () => {
  78     expect(isKillBehavior(KillBehaviors.SOFT, KillBehaviors.SOFT)).toBe(true)
  79     expect(isKillBehavior(KillBehaviors.SOFT, KillBehaviors.HARD)).toBe(false)
  80     expect(isKillBehavior(KillBehaviors.HARD, KillBehaviors.HARD)).toBe(true)
  81     expect(isKillBehavior(KillBehaviors.HARD, KillBehaviors.SOFT)).toBe(false)
  82     expect(isKillBehavior(KillBehaviors.SOFT)).toBe(false)
  83     expect(isKillBehavior(KillBehaviors.HARD)).toBe(false)
  84     expect(isKillBehavior(KillBehaviors.HARD, null)).toBe(false)
  85     expect(isKillBehavior(KillBehaviors.HARD, undefined)).toBe(false)
  86     expect(isKillBehavior(KillBehaviors.SOFT, 'unknown')).toBe(false)
  87   })
  88
  89   it('Verify isAsyncFunction() behavior', () => {
  90     expect(isAsyncFunction(null)).toBe(false)
  91     expect(isAsyncFunction(undefined)).toBe(false)
  92     expect(isAsyncFunction(true)).toBe(false)
  93     expect(isAsyncFunction(false)).toBe(false)
  94     expect(isAsyncFunction(0)).toBe(false)
  95     expect(isAsyncFunction('')).toBe(false)
  96     expect(isAsyncFunction([])).toBe(false)
  97     expect(isAsyncFunction(new Date())).toBe(false)
  98     expect(isAsyncFunction(new RegExp())).toBe(false)
  99     expect(isAsyncFunction(new Error())).toBe(false)
 100     expect(isAsyncFunction(new Map())).toBe(false)
 101     expect(isAsyncFunction(new Set())).toBe(false)
 102     expect(isAsyncFunction(new WeakMap())).toBe(false)
 103     expect(isAsyncFunction(new WeakSet())).toBe(false)
 104     expect(isAsyncFunction(new Int8Array())).toBe(false)
 105     expect(isAsyncFunction(new Uint8Array())).toBe(false)
 106     expect(isAsyncFunction(new Uint8ClampedArray())).toBe(false)
 107     expect(isAsyncFunction(new Int16Array())).toBe(false)
 108     expect(isAsyncFunction(new Uint16Array())).toBe(false)
 109     expect(isAsyncFunction(new Int32Array())).toBe(false)
 110     expect(isAsyncFunction(new Uint32Array())).toBe(false)
 111     expect(isAsyncFunction(new Float32Array())).toBe(false)
 112     expect(isAsyncFunction(new Float64Array())).toBe(false)
 113     expect(isAsyncFunction(new BigInt64Array())).toBe(false)
 114     expect(isAsyncFunction(new BigUint64Array())).toBe(false)
 115     expect(isAsyncFunction(new Promise(() => {}))).toBe(false)
 116     expect(isAsyncFunction(new WeakRef({}))).toBe(false)
 117     expect(isAsyncFunction(new FinalizationRegistry(() => {}))).toBe(false)
 118     expect(isAsyncFunction(new ArrayBuffer())).toBe(false)
 119     expect(isAsyncFunction(new SharedArrayBuffer())).toBe(false)
 120     expect(isAsyncFunction(new DataView(new ArrayBuffer()))).toBe(false)
 121     expect(isAsyncFunction({})).toBe(false)
 122     expect(isAsyncFunction({ a: 1 })).toBe(false)
 123     expect(isAsyncFunction(() => {})).toBe(false)
 124     expect(isAsyncFunction(function () {})).toBe(false)
 125     expect(isAsyncFunction(function named () {})).toBe(false)
 126     expect(isAsyncFunction(async () => {})).toBe(true)
 127     expect(isAsyncFunction(async function () {})).toBe(true)
 128     expect(isAsyncFunction(async function named () {})).toBe(true)
 129   })
 130
 131   it('Verify updateMeasurementStatistics() behavior', () => {
 132     const measurementStatistics = {
 133       history: new CircularArray()
 134     }
 135     updateMeasurementStatistics(
 136       measurementStatistics,
 137       { aggregate: true, average: false, median: false },
 138       0.01,
 139       1
 140     )
 141     expect(measurementStatistics).toStrictEqual({
 142       aggregate: 0.01,
 143       maximum: 0.01,
 144       minimum: 0.01,
 145       history: expect.any(CircularArray)
 146     })
 147     updateMeasurementStatistics(
 148       measurementStatistics,
 149       { aggregate: true, average: false, median: false },
 150       0.02,
 151       2
 152     )
 153     expect(measurementStatistics).toStrictEqual({
 154       aggregate: 0.03,
 155       maximum: 0.02,
 156       minimum: 0.01,
 157       history: expect.any(CircularArray)
 158     })
 159     updateMeasurementStatistics(
 160       measurementStatistics,
 161       { aggregate: true, average: true, median: false },
 162       0.001,
 163       3
 164     )
 165     expect(measurementStatistics).toStrictEqual({
 166       aggregate: 0.031,
 167       maximum: 0.02,
 168       minimum: 0.001,
 169       average: 0.010333333333333333,
 170       history: expect.any(CircularArray)
 171     })
 172   })
 173 })