tests/pools/abstract-pool.test.mjs

   1 import { EventEmitterAsyncResource } from 'node:events'
   2 import { dirname, join } from 'node:path'
   3 import { readFileSync } from 'node:fs'
   4 import { fileURLToPath } from 'node:url'
   5 import { createHook, executionAsyncId } from 'node:async_hooks'
   6 import { expect } from 'expect'
   7 import { restore, stub } from 'sinon'
   8 import {
   9   DynamicClusterPool,
  10   DynamicThreadPool,
  11   FixedClusterPool,
  12   FixedThreadPool,
  13   PoolEvents,
  14   PoolTypes,
  15   WorkerChoiceStrategies,
  16   WorkerTypes
  17 } from '../../lib/index.js'
  18 import { CircularArray } from '../../lib/circular-array.js'
  19 import { Deque } from '../../lib/deque.js'
  20 import { DEFAULT_TASK_NAME } from '../../lib/utils.js'
  21 import { waitPoolEvents } from '../test-utils.js'
  22 import { WorkerNode } from '../../lib/pools/worker-node.js'
  23
  24 describe('Abstract pool test suite', () => {
  25   const version = JSON.parse(
  26     readFileSync(
  27       join(dirname(fileURLToPath(import.meta.url)), '../..', 'package.json'),
  28       'utf8'
  29     )
  30   ).version
  31   const numberOfWorkers = 2
  32   class StubPoolWithIsMain extends FixedThreadPool {
  33     isMain () {
  34       return false
  35     }
  36   }
  37
  38   afterEach(() => {
  39     restore()
  40   })
  41
  42   it('Verify that pool can be created and destroyed', async () => {
  43     const pool = new FixedThreadPool(
  44       numberOfWorkers,
  45       './tests/worker-files/thread/testWorker.mjs'
  46     )
  47     expect(pool).toBeInstanceOf(FixedThreadPool)
  48     await pool.destroy()
  49   })
  50
  51   it('Verify that pool cannot be created from a non main thread/process', () => {
  52     expect(
  53       () =>
  54         new StubPoolWithIsMain(
  55           numberOfWorkers,
  56           './tests/worker-files/thread/testWorker.mjs',
  57           {
  58             errorHandler: e => console.error(e)
  59           }
  60         )
  61     ).toThrow(
  62       new Error(
  63         'Cannot start a pool from a worker with the same type as the pool'
  64       )
  65     )
  66   })
  67
  68   it('Verify that pool statuses properties are set', async () => {
  69     const pool = new FixedThreadPool(
  70       numberOfWorkers,
  71       './tests/worker-files/thread/testWorker.mjs'
  72     )
  73     expect(pool.started).toBe(true)
  74     expect(pool.starting).toBe(false)
  75     expect(pool.destroying).toBe(false)
  76     await pool.destroy()
  77   })
  78
  79   it('Verify that filePath is checked', () => {
  80     expect(() => new FixedThreadPool(numberOfWorkers)).toThrow(
  81       new TypeError('The worker file path must be specified')
  82     )
  83     expect(() => new FixedThreadPool(numberOfWorkers, 0)).toThrow(
  84       new TypeError('The worker file path must be a string')
  85     )
  86     expect(
  87       () => new FixedThreadPool(numberOfWorkers, './dummyWorker.ts')
  88     ).toThrow(new Error("Cannot find the worker file './dummyWorker.ts'"))
  89   })
  90
  91   it('Verify that numberOfWorkers is checked', () => {
  92     expect(
  93       () =>
  94         new FixedThreadPool(
  95           undefined,
  96           './tests/worker-files/thread/testWorker.mjs'
  97         )
  98     ).toThrow(
  99       new Error(
 100         'Cannot instantiate a pool without specifying the number of workers'
 101       )
 102     )
 103   })
 104
 105   it('Verify that a negative number of workers is checked', () => {
 106     expect(
 107       () =>
 108         new FixedClusterPool(-1, './tests/worker-files/cluster/testWorker.js')
 109     ).toThrow(
 110       new RangeError(
 111         'Cannot instantiate a pool with a negative number of workers'
 112       )
 113     )
 114   })
 115
 116   it('Verify that a non integer number of workers is checked', () => {
 117     expect(
 118       () =>
 119         new FixedThreadPool(0.25, './tests/worker-files/thread/testWorker.mjs')
 120     ).toThrow(
 121       new TypeError(
 122         'Cannot instantiate a pool with a non safe integer number of workers'
 123       )
 124     )
 125   })
 126
 127   it('Verify that pool arguments number and pool type are checked', () => {
 128     expect(
 129       () =>
 130         new FixedThreadPool(
 131           numberOfWorkers,
 132           './tests/worker-files/thread/testWorker.mjs',
 133           undefined,
 134           numberOfWorkers * 2
 135         )
 136     ).toThrow(
 137       new Error(
 138         'Cannot instantiate a fixed pool with a maximum number of workers specified at initialization'
 139       )
 140     )
 141   })
 142
 143   it('Verify that dynamic pool sizing is checked', () => {
 144     expect(
 145       () =>
 146         new DynamicClusterPool(
 147           1,
 148           undefined,
 149           './tests/worker-files/cluster/testWorker.js'
 150         )
 151     ).toThrow(
 152       new TypeError(
 153         'Cannot instantiate a dynamic pool without specifying the maximum pool size'
 154       )
 155     )
 156     expect(
 157       () =>
 158         new DynamicThreadPool(
 159           0.5,
 160           1,
 161           './tests/worker-files/thread/testWorker.mjs'
 162         )
 163     ).toThrow(
 164       new TypeError(
 165         'Cannot instantiate a pool with a non safe integer number of workers'
 166       )
 167     )
 168     expect(
 169       () =>
 170         new DynamicClusterPool(
 171           0,
 172           0.5,
 173           './tests/worker-files/cluster/testWorker.js'
 174         )
 175     ).toThrow(
 176       new TypeError(
 177         'Cannot instantiate a dynamic pool with a non safe integer maximum pool size'
 178       )
 179     )
 180     expect(
 181       () =>
 182         new DynamicThreadPool(
 183           2,
 184           1,
 185           './tests/worker-files/thread/testWorker.mjs'
 186         )
 187     ).toThrow(
 188       new RangeError(
 189         'Cannot instantiate a dynamic pool with a maximum pool size inferior to the minimum pool size'
 190       )
 191     )
 192     expect(
 193       () =>
 194         new DynamicThreadPool(
 195           0,
 196           0,
 197           './tests/worker-files/thread/testWorker.mjs'
 198         )
 199     ).toThrow(
 200       new RangeError(
 201         'Cannot instantiate a dynamic pool with a maximum pool size equal to zero'
 202       )
 203     )
 204     expect(
 205       () =>
 206         new DynamicClusterPool(
 207           1,
 208           1,
 209           './tests/worker-files/cluster/testWorker.js'
 210         )
 211     ).toThrow(
 212       new RangeError(
 213         'Cannot instantiate a dynamic pool with a minimum pool size equal to the maximum pool size. Use a fixed pool instead'
 214       )
 215     )
 216   })
 217
 218   it('Verify that pool options are checked', async () => {
 219     let pool = new FixedThreadPool(
 220       numberOfWorkers,
 221       './tests/worker-files/thread/testWorker.mjs'
 222     )
 223     expect(pool.emitter).toBeInstanceOf(EventEmitterAsyncResource)
 224     expect(pool.opts).toStrictEqual({
 225       startWorkers: true,
 226       enableEvents: true,
 227       restartWorkerOnError: true,
 228       enableTasksQueue: false,
 229       workerChoiceStrategy: WorkerChoiceStrategies.ROUND_ROBIN
 230     })
 231     expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
 232       retries: pool.info.maxSize,
 233       runTime: { median: false },
 234       waitTime: { median: false },
 235       elu: { median: false }
 236     })
 237     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
 238       .workerChoiceStrategies) {
 239       expect(workerChoiceStrategy.opts).toStrictEqual({
 240         retries: pool.info.maxSize,
 241         runTime: { median: false },
 242         waitTime: { median: false },
 243         elu: { median: false }
 244       })
 245     }
 246     await pool.destroy()
 247     const testHandler = () => console.info('test handler executed')
 248     pool = new FixedThreadPool(
 249       numberOfWorkers,
 250       './tests/worker-files/thread/testWorker.mjs',
 251       {
 252         workerChoiceStrategy: WorkerChoiceStrategies.LEAST_USED,
 253         workerChoiceStrategyOptions: {
 254           runTime: { median: true },
 255           weights: { 0: 300, 1: 200 }
 256         },
 257         enableEvents: false,
 258         restartWorkerOnError: false,
 259         enableTasksQueue: true,
 260         tasksQueueOptions: { concurrency: 2 },
 261         messageHandler: testHandler,
 262         errorHandler: testHandler,
 263         onlineHandler: testHandler,
 264         exitHandler: testHandler
 265       }
 266     )
 267     expect(pool.emitter).toBeUndefined()
 268     expect(pool.opts).toStrictEqual({
 269       startWorkers: true,
 270       enableEvents: false,
 271       restartWorkerOnError: false,
 272       enableTasksQueue: true,
 273       tasksQueueOptions: {
 274         concurrency: 2,
 275         size: Math.pow(numberOfWorkers, 2),
 276         taskStealing: true,
 277         tasksStealingOnBackPressure: true,
 278         tasksFinishedTimeout: 2000
 279       },
 280       workerChoiceStrategy: WorkerChoiceStrategies.LEAST_USED,
 281       workerChoiceStrategyOptions: {
 282         runTime: { median: true },
 283         weights: { 0: 300, 1: 200 }
 284       },
 285       onlineHandler: testHandler,
 286       messageHandler: testHandler,
 287       errorHandler: testHandler,
 288       exitHandler: testHandler
 289     })
 290     expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
 291       retries: pool.info.maxSize,
 292       runTime: { median: true },
 293       waitTime: { median: false },
 294       elu: { median: false },
 295       weights: { 0: 300, 1: 200 }
 296     })
 297     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
 298       .workerChoiceStrategies) {
 299       expect(workerChoiceStrategy.opts).toStrictEqual({
 300         retries: pool.info.maxSize,
 301         runTime: { median: true },
 302         waitTime: { median: false },
 303         elu: { median: false },
 304         weights: { 0: 300, 1: 200 }
 305       })
 306     }
 307     await pool.destroy()
 308   })
 309
 310   it('Verify that pool options are validated', () => {
 311     expect(
 312       () =>
 313         new FixedThreadPool(
 314           numberOfWorkers,
 315           './tests/worker-files/thread/testWorker.mjs',
 316           {
 317             workerChoiceStrategy: 'invalidStrategy'
 318           }
 319         )
 320     ).toThrow(new Error("Invalid worker choice strategy 'invalidStrategy'"))
 321     expect(
 322       () =>
 323         new FixedThreadPool(
 324           numberOfWorkers,
 325           './tests/worker-files/thread/testWorker.mjs',
 326           {
 327             workerChoiceStrategyOptions: { weights: {} }
 328           }
 329         )
 330     ).toThrow(
 331       new Error(
 332         'Invalid worker choice strategy options: must have a weight for each worker node'
 333       )
 334     )
 335     expect(
 336       () =>
 337         new FixedThreadPool(
 338           numberOfWorkers,
 339           './tests/worker-files/thread/testWorker.mjs',
 340           {
 341             workerChoiceStrategyOptions: { measurement: 'invalidMeasurement' }
 342           }
 343         )
 344     ).toThrow(
 345       new Error(
 346         "Invalid worker choice strategy options: invalid measurement 'invalidMeasurement'"
 347       )
 348     )
 349     expect(
 350       () =>
 351         new FixedThreadPool(
 352           numberOfWorkers,
 353           './tests/worker-files/thread/testWorker.mjs',
 354           {
 355             enableTasksQueue: true,
 356             tasksQueueOptions: 'invalidTasksQueueOptions'
 357           }
 358         )
 359     ).toThrow(
 360       new TypeError('Invalid tasks queue options: must be a plain object')
 361     )
 362     expect(
 363       () =>
 364         new FixedThreadPool(
 365           numberOfWorkers,
 366           './tests/worker-files/thread/testWorker.mjs',
 367           {
 368             enableTasksQueue: true,
 369             tasksQueueOptions: { concurrency: 0 }
 370           }
 371         )
 372     ).toThrow(
 373       new RangeError(
 374         'Invalid worker node tasks concurrency: 0 is a negative integer or zero'
 375       )
 376     )
 377     expect(
 378       () =>
 379         new FixedThreadPool(
 380           numberOfWorkers,
 381           './tests/worker-files/thread/testWorker.mjs',
 382           {
 383             enableTasksQueue: true,
 384             tasksQueueOptions: { concurrency: -1 }
 385           }
 386         )
 387     ).toThrow(
 388       new RangeError(
 389         'Invalid worker node tasks concurrency: -1 is a negative integer or zero'
 390       )
 391     )
 392     expect(
 393       () =>
 394         new FixedThreadPool(
 395           numberOfWorkers,
 396           './tests/worker-files/thread/testWorker.mjs',
 397           {
 398             enableTasksQueue: true,
 399             tasksQueueOptions: { concurrency: 0.2 }
 400           }
 401         )
 402     ).toThrow(
 403       new TypeError('Invalid worker node tasks concurrency: must be an integer')
 404     )
 405     expect(
 406       () =>
 407         new FixedThreadPool(
 408           numberOfWorkers,
 409           './tests/worker-files/thread/testWorker.mjs',
 410           {
 411             enableTasksQueue: true,
 412             tasksQueueOptions: { size: 0 }
 413           }
 414         )
 415     ).toThrow(
 416       new RangeError(
 417         'Invalid worker node tasks queue size: 0 is a negative integer or zero'
 418       )
 419     )
 420     expect(
 421       () =>
 422         new FixedThreadPool(
 423           numberOfWorkers,
 424           './tests/worker-files/thread/testWorker.mjs',
 425           {
 426             enableTasksQueue: true,
 427             tasksQueueOptions: { size: -1 }
 428           }
 429         )
 430     ).toThrow(
 431       new RangeError(
 432         'Invalid worker node tasks queue size: -1 is a negative integer or zero'
 433       )
 434     )
 435     expect(
 436       () =>
 437         new FixedThreadPool(
 438           numberOfWorkers,
 439           './tests/worker-files/thread/testWorker.mjs',
 440           {
 441             enableTasksQueue: true,
 442             tasksQueueOptions: { size: 0.2 }
 443           }
 444         )
 445     ).toThrow(
 446       new TypeError('Invalid worker node tasks queue size: must be an integer')
 447     )
 448   })
 449
 450   it('Verify that pool worker choice strategy options can be set', async () => {
 451     const pool = new FixedThreadPool(
 452       numberOfWorkers,
 453       './tests/worker-files/thread/testWorker.mjs',
 454       { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
 455     )
 456     expect(pool.opts.workerChoiceStrategyOptions).toBeUndefined()
 457     expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
 458       retries: pool.info.maxSize,
 459       runTime: { median: false },
 460       waitTime: { median: false },
 461       elu: { median: false }
 462     })
 463     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
 464       .workerChoiceStrategies) {
 465       expect(workerChoiceStrategy.opts).toStrictEqual({
 466         retries: pool.info.maxSize,
 467         runTime: { median: false },
 468         waitTime: { median: false },
 469         elu: { median: false }
 470       })
 471     }
 472     expect(
 473       pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
 474     ).toStrictEqual({
 475       runTime: {
 476         aggregate: true,
 477         average: true,
 478         median: false
 479       },
 480       waitTime: {
 481         aggregate: false,
 482         average: false,
 483         median: false
 484       },
 485       elu: {
 486         aggregate: true,
 487         average: true,
 488         median: false
 489       }
 490     })
 491     pool.setWorkerChoiceStrategyOptions({
 492       runTime: { median: true },
 493       elu: { median: true }
 494     })
 495     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
 496       runTime: { median: true },
 497       elu: { median: true }
 498     })
 499     expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
 500       retries: pool.info.maxSize,
 501       runTime: { median: true },
 502       waitTime: { median: false },
 503       elu: { median: true }
 504     })
 505     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
 506       .workerChoiceStrategies) {
 507       expect(workerChoiceStrategy.opts).toStrictEqual({
 508         retries: pool.info.maxSize,
 509         runTime: { median: true },
 510         waitTime: { median: false },
 511         elu: { median: true }
 512       })
 513     }
 514     expect(
 515       pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
 516     ).toStrictEqual({
 517       runTime: {
 518         aggregate: true,
 519         average: false,
 520         median: true
 521       },
 522       waitTime: {
 523         aggregate: false,
 524         average: false,
 525         median: false
 526       },
 527       elu: {
 528         aggregate: true,
 529         average: false,
 530         median: true
 531       }
 532     })
 533     pool.setWorkerChoiceStrategyOptions({
 534       runTime: { median: false },
 535       elu: { median: false }
 536     })
 537     expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
 538       runTime: { median: false },
 539       elu: { median: false }
 540     })
 541     expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
 542       retries: pool.info.maxSize,
 543       runTime: { median: false },
 544       waitTime: { median: false },
 545       elu: { median: false }
 546     })
 547     for (const [, workerChoiceStrategy] of pool.workerChoiceStrategyContext
 548       .workerChoiceStrategies) {
 549       expect(workerChoiceStrategy.opts).toStrictEqual({
 550         retries: pool.info.maxSize,
 551         runTime: { median: false },
 552         waitTime: { median: false },
 553         elu: { median: false }
 554       })
 555     }
 556     expect(
 557       pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
 558     ).toStrictEqual({
 559       runTime: {
 560         aggregate: true,
 561         average: true,
 562         median: false
 563       },
 564       waitTime: {
 565         aggregate: false,
 566         average: false,
 567         median: false
 568       },
 569       elu: {
 570         aggregate: true,
 571         average: true,
 572         median: false
 573       }
 574     })
 575     expect(() =>
 576       pool.setWorkerChoiceStrategyOptions('invalidWorkerChoiceStrategyOptions')
 577     ).toThrow(
 578       new TypeError(
 579         'Invalid worker choice strategy options: must be a plain object'
 580       )
 581     )
 582     expect(() => pool.setWorkerChoiceStrategyOptions({ weights: {} })).toThrow(
 583       new Error(
 584         'Invalid worker choice strategy options: must have a weight for each worker node'
 585       )
 586     )
 587     expect(() =>
 588       pool.setWorkerChoiceStrategyOptions({ measurement: 'invalidMeasurement' })
 589     ).toThrow(
 590       new Error(
 591         "Invalid worker choice strategy options: invalid measurement 'invalidMeasurement'"
 592       )
 593     )
 594     await pool.destroy()
 595   })
 596
 597   it('Verify that pool tasks queue can be enabled/disabled', async () => {
 598     const pool = new FixedThreadPool(
 599       numberOfWorkers,
 600       './tests/worker-files/thread/testWorker.mjs'
 601     )
 602     expect(pool.opts.enableTasksQueue).toBe(false)
 603     expect(pool.opts.tasksQueueOptions).toBeUndefined()
 604     pool.enableTasksQueue(true)
 605     expect(pool.opts.enableTasksQueue).toBe(true)
 606     expect(pool.opts.tasksQueueOptions).toStrictEqual({
 607       concurrency: 1,
 608       size: Math.pow(numberOfWorkers, 2),
 609       taskStealing: true,
 610       tasksStealingOnBackPressure: true,
 611       tasksFinishedTimeout: 2000
 612     })
 613     pool.enableTasksQueue(true, { concurrency: 2 })
 614     expect(pool.opts.enableTasksQueue).toBe(true)
 615     expect(pool.opts.tasksQueueOptions).toStrictEqual({
 616       concurrency: 2,
 617       size: Math.pow(numberOfWorkers, 2),
 618       taskStealing: true,
 619       tasksStealingOnBackPressure: true,
 620       tasksFinishedTimeout: 2000
 621     })
 622     pool.enableTasksQueue(false)
 623     expect(pool.opts.enableTasksQueue).toBe(false)
 624     expect(pool.opts.tasksQueueOptions).toBeUndefined()
 625     await pool.destroy()
 626   })
 627
 628   it('Verify that pool tasks queue options can be set', async () => {
 629     const pool = new FixedThreadPool(
 630       numberOfWorkers,
 631       './tests/worker-files/thread/testWorker.mjs',
 632       { enableTasksQueue: true }
 633     )
 634     expect(pool.opts.tasksQueueOptions).toStrictEqual({
 635       concurrency: 1,
 636       size: Math.pow(numberOfWorkers, 2),
 637       taskStealing: true,
 638       tasksStealingOnBackPressure: true,
 639       tasksFinishedTimeout: 2000
 640     })
 641     for (const workerNode of pool.workerNodes) {
 642       expect(workerNode.tasksQueueBackPressureSize).toBe(
 643         pool.opts.tasksQueueOptions.size
 644       )
 645     }
 646     pool.setTasksQueueOptions({
 647       concurrency: 2,
 648       size: 2,
 649       taskStealing: false,
 650       tasksStealingOnBackPressure: false,
 651       tasksFinishedTimeout: 3000
 652     })
 653     expect(pool.opts.tasksQueueOptions).toStrictEqual({
 654       concurrency: 2,
 655       size: 2,
 656       taskStealing: false,
 657       tasksStealingOnBackPressure: false,
 658       tasksFinishedTimeout: 3000
 659     })
 660     for (const workerNode of pool.workerNodes) {
 661       expect(workerNode.tasksQueueBackPressureSize).toBe(
 662         pool.opts.tasksQueueOptions.size
 663       )
 664     }
 665     pool.setTasksQueueOptions({
 666       concurrency: 1,
 667       taskStealing: true,
 668       tasksStealingOnBackPressure: true
 669     })
 670     expect(pool.opts.tasksQueueOptions).toStrictEqual({
 671       concurrency: 1,
 672       size: Math.pow(numberOfWorkers, 2),
 673       taskStealing: true,
 674       tasksStealingOnBackPressure: true,
 675       tasksFinishedTimeout: 2000
 676     })
 677     for (const workerNode of pool.workerNodes) {
 678       expect(workerNode.tasksQueueBackPressureSize).toBe(
 679         pool.opts.tasksQueueOptions.size
 680       )
 681     }
 682     expect(() => pool.setTasksQueueOptions('invalidTasksQueueOptions')).toThrow(
 683       new TypeError('Invalid tasks queue options: must be a plain object')
 684     )
 685     expect(() => pool.setTasksQueueOptions({ concurrency: 0 })).toThrow(
 686       new RangeError(
 687         'Invalid worker node tasks concurrency: 0 is a negative integer or zero'
 688       )
 689     )
 690     expect(() => pool.setTasksQueueOptions({ concurrency: -1 })).toThrow(
 691       new RangeError(
 692         'Invalid worker node tasks concurrency: -1 is a negative integer or zero'
 693       )
 694     )
 695     expect(() => pool.setTasksQueueOptions({ concurrency: 0.2 })).toThrow(
 696       new TypeError('Invalid worker node tasks concurrency: must be an integer')
 697     )
 698     expect(() => pool.setTasksQueueOptions({ size: 0 })).toThrow(
 699       new RangeError(
 700         'Invalid worker node tasks queue size: 0 is a negative integer or zero'
 701       )
 702     )
 703     expect(() => pool.setTasksQueueOptions({ size: -1 })).toThrow(
 704       new RangeError(
 705         'Invalid worker node tasks queue size: -1 is a negative integer or zero'
 706       )
 707     )
 708     expect(() => pool.setTasksQueueOptions({ size: 0.2 })).toThrow(
 709       new TypeError('Invalid worker node tasks queue size: must be an integer')
 710     )
 711     await pool.destroy()
 712   })
 713
 714   it('Verify that pool info is set', async () => {
 715     let pool = new FixedThreadPool(
 716       numberOfWorkers,
 717       './tests/worker-files/thread/testWorker.mjs'
 718     )
 719     expect(pool.info).toStrictEqual({
 720       version,
 721       type: PoolTypes.fixed,
 722       worker: WorkerTypes.thread,
 723       started: true,
 724       ready: true,
 725       strategy: WorkerChoiceStrategies.ROUND_ROBIN,
 726       minSize: numberOfWorkers,
 727       maxSize: numberOfWorkers,
 728       workerNodes: numberOfWorkers,
 729       idleWorkerNodes: numberOfWorkers,
 730       busyWorkerNodes: 0,
 731       executedTasks: 0,
 732       executingTasks: 0,
 733       failedTasks: 0
 734     })
 735     await pool.destroy()
 736     pool = new DynamicClusterPool(
 737       Math.floor(numberOfWorkers / 2),
 738       numberOfWorkers,
 739       './tests/worker-files/cluster/testWorker.js'
 740     )
 741     expect(pool.info).toStrictEqual({
 742       version,
 743       type: PoolTypes.dynamic,
 744       worker: WorkerTypes.cluster,
 745       started: true,
 746       ready: true,
 747       strategy: WorkerChoiceStrategies.ROUND_ROBIN,
 748       minSize: Math.floor(numberOfWorkers / 2),
 749       maxSize: numberOfWorkers,
 750       workerNodes: Math.floor(numberOfWorkers / 2),
 751       idleWorkerNodes: Math.floor(numberOfWorkers / 2),
 752       busyWorkerNodes: 0,
 753       executedTasks: 0,
 754       executingTasks: 0,
 755       failedTasks: 0
 756     })
 757     await pool.destroy()
 758   })
 759
 760   it('Verify that pool worker tasks usage are initialized', async () => {
 761     const pool = new FixedClusterPool(
 762       numberOfWorkers,
 763       './tests/worker-files/cluster/testWorker.js'
 764     )
 765     for (const workerNode of pool.workerNodes) {
 766       expect(workerNode).toBeInstanceOf(WorkerNode)
 767       expect(workerNode.usage).toStrictEqual({
 768         tasks: {
 769           executed: 0,
 770           executing: 0,
 771           queued: 0,
 772           maxQueued: 0,
 773           sequentiallyStolen: 0,
 774           stolen: 0,
 775           failed: 0
 776         },
 777         runTime: {
 778           history: new CircularArray()
 779         },
 780         waitTime: {
 781           history: new CircularArray()
 782         },
 783         elu: {
 784           idle: {
 785             history: new CircularArray()
 786           },
 787           active: {
 788             history: new CircularArray()
 789           }
 790         }
 791       })
 792     }
 793     await pool.destroy()
 794   })
 795
 796   it('Verify that pool worker tasks queue are initialized', async () => {
 797     let pool = new FixedClusterPool(
 798       numberOfWorkers,
 799       './tests/worker-files/cluster/testWorker.js'
 800     )
 801     for (const workerNode of pool.workerNodes) {
 802       expect(workerNode).toBeInstanceOf(WorkerNode)
 803       expect(workerNode.tasksQueue).toBeInstanceOf(Deque)
 804       expect(workerNode.tasksQueue.size).toBe(0)
 805       expect(workerNode.tasksQueue.maxSize).toBe(0)
 806     }
 807     await pool.destroy()
 808     pool = new DynamicThreadPool(
 809       Math.floor(numberOfWorkers / 2),
 810       numberOfWorkers,
 811       './tests/worker-files/thread/testWorker.mjs'
 812     )
 813     for (const workerNode of pool.workerNodes) {
 814       expect(workerNode).toBeInstanceOf(WorkerNode)
 815       expect(workerNode.tasksQueue).toBeInstanceOf(Deque)
 816       expect(workerNode.tasksQueue.size).toBe(0)
 817       expect(workerNode.tasksQueue.maxSize).toBe(0)
 818     }
 819     await pool.destroy()
 820   })
 821
 822   it('Verify that pool worker info are initialized', async () => {
 823     let pool = new FixedClusterPool(
 824       numberOfWorkers,
 825       './tests/worker-files/cluster/testWorker.js'
 826     )
 827     for (const workerNode of pool.workerNodes) {
 828       expect(workerNode).toBeInstanceOf(WorkerNode)
 829       expect(workerNode.info).toStrictEqual({
 830         id: expect.any(Number),
 831         type: WorkerTypes.cluster,
 832         dynamic: false,
 833         ready: true
 834       })
 835     }
 836     await pool.destroy()
 837     pool = new DynamicThreadPool(
 838       Math.floor(numberOfWorkers / 2),
 839       numberOfWorkers,
 840       './tests/worker-files/thread/testWorker.mjs'
 841     )
 842     for (const workerNode of pool.workerNodes) {
 843       expect(workerNode).toBeInstanceOf(WorkerNode)
 844       expect(workerNode.info).toStrictEqual({
 845         id: expect.any(Number),
 846         type: WorkerTypes.thread,
 847         dynamic: false,
 848         ready: true
 849       })
 850     }
 851     await pool.destroy()
 852   })
 853
 854   it('Verify that pool statuses are checked at start or destroy', async () => {
 855     const pool = new FixedThreadPool(
 856       numberOfWorkers,
 857       './tests/worker-files/thread/testWorker.mjs'
 858     )
 859     expect(pool.info.started).toBe(true)
 860     expect(pool.info.ready).toBe(true)
 861     expect(() => pool.start()).toThrow(
 862       new Error('Cannot start an already started pool')
 863     )
 864     await pool.destroy()
 865     expect(pool.info.started).toBe(false)
 866     expect(pool.info.ready).toBe(false)
 867     await expect(pool.destroy()).rejects.toThrow(
 868       new Error('Cannot destroy an already destroyed pool')
 869     )
 870   })
 871
 872   it('Verify that pool can be started after initialization', async () => {
 873     const pool = new FixedClusterPool(
 874       numberOfWorkers,
 875       './tests/worker-files/cluster/testWorker.js',
 876       {
 877         startWorkers: false
 878       }
 879     )
 880     expect(pool.info.started).toBe(false)
 881     expect(pool.info.ready).toBe(false)
 882     expect(pool.readyEventEmitted).toBe(false)
 883     expect(pool.workerNodes).toStrictEqual([])
 884     await expect(pool.execute()).rejects.toThrow(
 885       new Error('Cannot execute a task on not started pool')
 886     )
 887     pool.start()
 888     expect(pool.info.started).toBe(true)
 889     expect(pool.info.ready).toBe(true)
 890     await waitPoolEvents(pool, PoolEvents.ready, 1)
 891     expect(pool.readyEventEmitted).toBe(true)
 892     expect(pool.workerNodes.length).toBe(numberOfWorkers)
 893     for (const workerNode of pool.workerNodes) {
 894       expect(workerNode).toBeInstanceOf(WorkerNode)
 895     }
 896     await pool.destroy()
 897   })
 898
 899   it('Verify that pool execute() arguments are checked', async () => {
 900     const pool = new FixedClusterPool(
 901       numberOfWorkers,
 902       './tests/worker-files/cluster/testWorker.js'
 903     )
 904     await expect(pool.execute(undefined, 0)).rejects.toThrow(
 905       new TypeError('name argument must be a string')
 906     )
 907     await expect(pool.execute(undefined, '')).rejects.toThrow(
 908       new TypeError('name argument must not be an empty string')
 909     )
 910     await expect(pool.execute(undefined, undefined, {})).rejects.toThrow(
 911       new TypeError('transferList argument must be an array')
 912     )
 913     await expect(pool.execute(undefined, 'unknown')).rejects.toBe(
 914       "Task function 'unknown' not found"
 915     )
 916     await pool.destroy()
 917     await expect(pool.execute()).rejects.toThrow(
 918       new Error('Cannot execute a task on not started pool')
 919     )
 920   })
 921
 922   it('Verify that pool worker tasks usage are computed', async () => {
 923     const pool = new FixedClusterPool(
 924       numberOfWorkers,
 925       './tests/worker-files/cluster/testWorker.js'
 926     )
 927     const promises = new Set()
 928     const maxMultiplier = 2
 929     for (let i = 0; i < numberOfWorkers * maxMultiplier; i++) {
 930       promises.add(pool.execute())
 931     }
 932     for (const workerNode of pool.workerNodes) {
 933       expect(workerNode.usage).toStrictEqual({
 934         tasks: {
 935           executed: 0,
 936           executing: maxMultiplier,
 937           queued: 0,
 938           maxQueued: 0,
 939           sequentiallyStolen: 0,
 940           stolen: 0,
 941           failed: 0
 942         },
 943         runTime: {
 944           history: expect.any(CircularArray)
 945         },
 946         waitTime: {
 947           history: expect.any(CircularArray)
 948         },
 949         elu: {
 950           idle: {
 951             history: expect.any(CircularArray)
 952           },
 953           active: {
 954             history: expect.any(CircularArray)
 955           }
 956         }
 957       })
 958     }
 959     await Promise.all(promises)
 960     for (const workerNode of pool.workerNodes) {
 961       expect(workerNode.usage).toStrictEqual({
 962         tasks: {
 963           executed: maxMultiplier,
 964           executing: 0,
 965           queued: 0,
 966           maxQueued: 0,
 967           sequentiallyStolen: 0,
 968           stolen: 0,
 969           failed: 0
 970         },
 971         runTime: {
 972           history: expect.any(CircularArray)
 973         },
 974         waitTime: {
 975           history: expect.any(CircularArray)
 976         },
 977         elu: {
 978           idle: {
 979             history: expect.any(CircularArray)
 980           },
 981           active: {
 982             history: expect.any(CircularArray)
 983           }
 984         }
 985       })
 986     }
 987     await pool.destroy()
 988   })
 989
 990   it('Verify that pool worker tasks usage are reset at worker choice strategy change', async () => {
 991     const pool = new DynamicThreadPool(
 992       Math.floor(numberOfWorkers / 2),
 993       numberOfWorkers,
 994       './tests/worker-files/thread/testWorker.mjs'
 995     )
 996     const promises = new Set()
 997     const maxMultiplier = 2
 998     for (let i = 0; i < numberOfWorkers * maxMultiplier; i++) {
 999       promises.add(pool.execute())
1000     }
1001     await Promise.all(promises)
1002     for (const workerNode of pool.workerNodes) {
1003       expect(workerNode.usage).toStrictEqual({
1004         tasks: {
1005           executed: expect.any(Number),
1006           executing: 0,
1007           queued: 0,
1008           maxQueued: 0,
1009           sequentiallyStolen: 0,
1010           stolen: 0,
1011           failed: 0
1012         },
1013         runTime: {
1014           history: expect.any(CircularArray)
1015         },
1016         waitTime: {
1017           history: expect.any(CircularArray)
1018         },
1019         elu: {
1020           idle: {
1021             history: expect.any(CircularArray)
1022           },
1023           active: {
1024             history: expect.any(CircularArray)
1025           }
1026         }
1027       })
1028       expect(workerNode.usage.tasks.executed).toBeGreaterThan(0)
1029       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
1030         numberOfWorkers * maxMultiplier
1031       )
1032       expect(workerNode.usage.runTime.history.length).toBe(0)
1033       expect(workerNode.usage.waitTime.history.length).toBe(0)
1034       expect(workerNode.usage.elu.idle.history.length).toBe(0)
1035       expect(workerNode.usage.elu.active.history.length).toBe(0)
1036     }
1037     pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
1038     for (const workerNode of pool.workerNodes) {
1039       expect(workerNode.usage).toStrictEqual({
1040         tasks: {
1041           executed: 0,
1042           executing: 0,
1043           queued: 0,
1044           maxQueued: 0,
1045           sequentiallyStolen: 0,
1046           stolen: 0,
1047           failed: 0
1048         },
1049         runTime: {
1050           history: expect.any(CircularArray)
1051         },
1052         waitTime: {
1053           history: expect.any(CircularArray)
1054         },
1055         elu: {
1056           idle: {
1057             history: expect.any(CircularArray)
1058           },
1059           active: {
1060             history: expect.any(CircularArray)
1061           }
1062         }
1063       })
1064       expect(workerNode.usage.runTime.history.length).toBe(0)
1065       expect(workerNode.usage.waitTime.history.length).toBe(0)
1066       expect(workerNode.usage.elu.idle.history.length).toBe(0)
1067       expect(workerNode.usage.elu.active.history.length).toBe(0)
1068     }
1069     await pool.destroy()
1070   })
1071
1072   it("Verify that pool event emitter 'ready' event can register a callback", async () => {
1073     const pool = new DynamicClusterPool(
1074       Math.floor(numberOfWorkers / 2),
1075       numberOfWorkers,
1076       './tests/worker-files/cluster/testWorker.js'
1077     )
1078     expect(pool.emitter.eventNames()).toStrictEqual([])
1079     let poolInfo
1080     let poolReady = 0
1081     pool.emitter.on(PoolEvents.ready, info => {
1082       ++poolReady
1083       poolInfo = info
1084     })
1085     await waitPoolEvents(pool, PoolEvents.ready, 1)
1086     expect(pool.emitter.eventNames()).toStrictEqual([PoolEvents.ready])
1087     expect(poolReady).toBe(1)
1088     expect(poolInfo).toStrictEqual({
1089       version,
1090       type: PoolTypes.dynamic,
1091       worker: WorkerTypes.cluster,
1092       started: true,
1093       ready: true,
1094       strategy: WorkerChoiceStrategies.ROUND_ROBIN,
1095       minSize: expect.any(Number),
1096       maxSize: expect.any(Number),
1097       workerNodes: expect.any(Number),
1098       idleWorkerNodes: expect.any(Number),
1099       busyWorkerNodes: expect.any(Number),
1100       executedTasks: expect.any(Number),
1101       executingTasks: expect.any(Number),
1102       failedTasks: expect.any(Number)
1103     })
1104     await pool.destroy()
1105   })
1106
1107   it("Verify that pool event emitter 'busy' event can register a callback", async () => {
1108     const pool = new FixedThreadPool(
1109       numberOfWorkers,
1110       './tests/worker-files/thread/testWorker.mjs'
1111     )
1112     expect(pool.emitter.eventNames()).toStrictEqual([])
1113     const promises = new Set()
1114     let poolBusy = 0
1115     let poolInfo
1116     pool.emitter.on(PoolEvents.busy, info => {
1117       ++poolBusy
1118       poolInfo = info
1119     })
1120     expect(pool.emitter.eventNames()).toStrictEqual([PoolEvents.busy])
1121     for (let i = 0; i < numberOfWorkers * 2; i++) {
1122       promises.add(pool.execute())
1123     }
1124     await Promise.all(promises)
1125     // The `busy` event is triggered when the number of submitted tasks at once reach the number of fixed pool workers.
1126     // So in total numberOfWorkers + 1 times for a loop submitting up to numberOfWorkers * 2 tasks to the fixed pool.
1127     expect(poolBusy).toBe(numberOfWorkers + 1)
1128     expect(poolInfo).toStrictEqual({
1129       version,
1130       type: PoolTypes.fixed,
1131       worker: WorkerTypes.thread,
1132       started: true,
1133       ready: true,
1134       strategy: WorkerChoiceStrategies.ROUND_ROBIN,
1135       minSize: expect.any(Number),
1136       maxSize: expect.any(Number),
1137       workerNodes: expect.any(Number),
1138       idleWorkerNodes: expect.any(Number),
1139       busyWorkerNodes: expect.any(Number),
1140       executedTasks: expect.any(Number),
1141       executingTasks: expect.any(Number),
1142       failedTasks: expect.any(Number)
1143     })
1144     await pool.destroy()
1145   })
1146
1147   it("Verify that pool event emitter 'full' event can register a callback", async () => {
1148     const pool = new DynamicThreadPool(
1149       Math.floor(numberOfWorkers / 2),
1150       numberOfWorkers,
1151       './tests/worker-files/thread/testWorker.mjs'
1152     )
1153     expect(pool.emitter.eventNames()).toStrictEqual([])
1154     const promises = new Set()
1155     let poolFull = 0
1156     let poolInfo
1157     pool.emitter.on(PoolEvents.full, info => {
1158       ++poolFull
1159       poolInfo = info
1160     })
1161     expect(pool.emitter.eventNames()).toStrictEqual([PoolEvents.full])
1162     for (let i = 0; i < numberOfWorkers * 2; i++) {
1163       promises.add(pool.execute())
1164     }
1165     await Promise.all(promises)
1166     expect(poolFull).toBe(1)
1167     expect(poolInfo).toStrictEqual({
1168       version,
1169       type: PoolTypes.dynamic,
1170       worker: WorkerTypes.thread,
1171       started: true,
1172       ready: true,
1173       strategy: WorkerChoiceStrategies.ROUND_ROBIN,
1174       minSize: expect.any(Number),
1175       maxSize: expect.any(Number),
1176       workerNodes: expect.any(Number),
1177       idleWorkerNodes: expect.any(Number),
1178       busyWorkerNodes: expect.any(Number),
1179       executedTasks: expect.any(Number),
1180       executingTasks: expect.any(Number),
1181       failedTasks: expect.any(Number)
1182     })
1183     await pool.destroy()
1184   })
1185
1186   it("Verify that pool event emitter 'backPressure' event can register a callback", async () => {
1187     const pool = new FixedThreadPool(
1188       numberOfWorkers,
1189       './tests/worker-files/thread/testWorker.mjs',
1190       {
1191         enableTasksQueue: true
1192       }
1193     )
1194     stub(pool, 'hasBackPressure').returns(true)
1195     expect(pool.emitter.eventNames()).toStrictEqual([])
1196     const promises = new Set()
1197     let poolBackPressure = 0
1198     let poolInfo
1199     pool.emitter.on(PoolEvents.backPressure, info => {
1200       ++poolBackPressure
1201       poolInfo = info
1202     })
1203     expect(pool.emitter.eventNames()).toStrictEqual([PoolEvents.backPressure])
1204     for (let i = 0; i < numberOfWorkers + 1; i++) {
1205       promises.add(pool.execute())
1206     }
1207     await Promise.all(promises)
1208     expect(poolBackPressure).toBe(1)
1209     expect(poolInfo).toStrictEqual({
1210       version,
1211       type: PoolTypes.fixed,
1212       worker: WorkerTypes.thread,
1213       started: true,
1214       ready: true,
1215       strategy: WorkerChoiceStrategies.ROUND_ROBIN,
1216       minSize: expect.any(Number),
1217       maxSize: expect.any(Number),
1218       workerNodes: expect.any(Number),
1219       idleWorkerNodes: expect.any(Number),
1220       busyWorkerNodes: expect.any(Number),
1221       executedTasks: expect.any(Number),
1222       executingTasks: expect.any(Number),
1223       maxQueuedTasks: expect.any(Number),
1224       queuedTasks: expect.any(Number),
1225       backPressure: true,
1226       stolenTasks: expect.any(Number),
1227       failedTasks: expect.any(Number)
1228     })
1229     expect(pool.hasBackPressure.callCount).toBe(5)
1230     await pool.destroy()
1231   })
1232
1233   it('Verify that destroy() waits for queued tasks to finish', async () => {
1234     const tasksFinishedTimeout = 2500
1235     const pool = new FixedThreadPool(
1236       numberOfWorkers,
1237       './tests/worker-files/thread/asyncWorker.mjs',
1238       {
1239         enableTasksQueue: true,
1240         tasksQueueOptions: { tasksFinishedTimeout }
1241       }
1242     )
1243     const maxMultiplier = 4
1244     let tasksFinished = 0
1245     for (const workerNode of pool.workerNodes) {
1246       workerNode.on('taskFinished', () => {
1247         ++tasksFinished
1248       })
1249     }
1250     for (let i = 0; i < numberOfWorkers * maxMultiplier; i++) {
1251       pool.execute()
1252     }
1253     expect(pool.info.queuedTasks).toBeGreaterThan(0)
1254     const startTime = performance.now()
1255     await pool.destroy()
1256     const elapsedTime = performance.now() - startTime
1257     expect(tasksFinished).toBe(numberOfWorkers * maxMultiplier)
1258     expect(elapsedTime).toBeGreaterThanOrEqual(2000)
1259     expect(elapsedTime).toBeLessThanOrEqual(tasksFinishedTimeout + 100)
1260   })
1261
1262   it('Verify that destroy() waits until the tasks finished timeout is reached', async () => {
1263     const tasksFinishedTimeout = 1000
1264     const pool = new FixedThreadPool(
1265       numberOfWorkers,
1266       './tests/worker-files/thread/asyncWorker.mjs',
1267       {
1268         enableTasksQueue: true,
1269         tasksQueueOptions: { tasksFinishedTimeout }
1270       }
1271     )
1272     const maxMultiplier = 4
1273     let tasksFinished = 0
1274     for (const workerNode of pool.workerNodes) {
1275       workerNode.on('taskFinished', () => {
1276         ++tasksFinished
1277       })
1278     }
1279     for (let i = 0; i < numberOfWorkers * maxMultiplier; i++) {
1280       pool.execute()
1281     }
1282     expect(pool.info.queuedTasks).toBeGreaterThan(0)
1283     const startTime = performance.now()
1284     await pool.destroy()
1285     const elapsedTime = performance.now() - startTime
1286     expect(tasksFinished).toBe(0)
1287     expect(elapsedTime).toBeLessThanOrEqual(tasksFinishedTimeout + 600)
1288   })
1289
1290   it('Verify that pool asynchronous resource track tasks execution', async () => {
1291     let taskAsyncId
1292     let initCalls = 0
1293     let beforeCalls = 0
1294     let afterCalls = 0
1295     let resolveCalls = 0
1296     const hook = createHook({
1297       init (asyncId, type) {
1298         if (type === 'poolifier:task') {
1299           initCalls++
1300           taskAsyncId = asyncId
1301         }
1302       },
1303       before (asyncId) {
1304         if (asyncId === taskAsyncId) beforeCalls++
1305       },
1306       after (asyncId) {
1307         if (asyncId === taskAsyncId) afterCalls++
1308       },
1309       promiseResolve () {
1310         if (executionAsyncId() === taskAsyncId) resolveCalls++
1311       }
1312     })
1313     const pool = new FixedThreadPool(
1314       numberOfWorkers,
1315       './tests/worker-files/thread/testWorker.mjs'
1316     )
1317     hook.enable()
1318     await pool.execute()
1319     hook.disable()
1320     expect(initCalls).toBe(1)
1321     expect(beforeCalls).toBe(1)
1322     expect(afterCalls).toBe(1)
1323     expect(resolveCalls).toBe(1)
1324     await pool.destroy()
1325   })
1326
1327   it('Verify that hasTaskFunction() is working', async () => {
1328     const dynamicThreadPool = new DynamicThreadPool(
1329       Math.floor(numberOfWorkers / 2),
1330       numberOfWorkers,
1331       './tests/worker-files/thread/testMultipleTaskFunctionsWorker.mjs'
1332     )
1333     await waitPoolEvents(dynamicThreadPool, PoolEvents.ready, 1)
1334     expect(dynamicThreadPool.hasTaskFunction(DEFAULT_TASK_NAME)).toBe(true)
1335     expect(dynamicThreadPool.hasTaskFunction('jsonIntegerSerialization')).toBe(
1336       true
1337     )
1338     expect(dynamicThreadPool.hasTaskFunction('factorial')).toBe(true)
1339     expect(dynamicThreadPool.hasTaskFunction('fibonacci')).toBe(true)
1340     expect(dynamicThreadPool.hasTaskFunction('unknown')).toBe(false)
1341     await dynamicThreadPool.destroy()
1342     const fixedClusterPool = new FixedClusterPool(
1343       numberOfWorkers,
1344       './tests/worker-files/cluster/testMultipleTaskFunctionsWorker.js'
1345     )
1346     await waitPoolEvents(fixedClusterPool, PoolEvents.ready, 1)
1347     expect(fixedClusterPool.hasTaskFunction(DEFAULT_TASK_NAME)).toBe(true)
1348     expect(fixedClusterPool.hasTaskFunction('jsonIntegerSerialization')).toBe(
1349       true
1350     )
1351     expect(fixedClusterPool.hasTaskFunction('factorial')).toBe(true)
1352     expect(fixedClusterPool.hasTaskFunction('fibonacci')).toBe(true)
1353     expect(fixedClusterPool.hasTaskFunction('unknown')).toBe(false)
1354     await fixedClusterPool.destroy()
1355   })
1356
1357   it('Verify that addTaskFunction() is working', async () => {
1358     const dynamicThreadPool = new DynamicThreadPool(
1359       Math.floor(numberOfWorkers / 2),
1360       numberOfWorkers,
1361       './tests/worker-files/thread/testWorker.mjs'
1362     )
1363     await waitPoolEvents(dynamicThreadPool, PoolEvents.ready, 1)
1364     await expect(
1365       dynamicThreadPool.addTaskFunction(0, () => {})
1366     ).rejects.toThrow(new TypeError('name argument must be a string'))
1367     await expect(
1368       dynamicThreadPool.addTaskFunction('', () => {})
1369     ).rejects.toThrow(
1370       new TypeError('name argument must not be an empty string')
1371     )
1372     await expect(dynamicThreadPool.addTaskFunction('test', 0)).rejects.toThrow(
1373       new TypeError('fn argument must be a function')
1374     )
1375     await expect(dynamicThreadPool.addTaskFunction('test', '')).rejects.toThrow(
1376       new TypeError('fn argument must be a function')
1377     )
1378     expect(dynamicThreadPool.listTaskFunctionNames()).toStrictEqual([
1379       DEFAULT_TASK_NAME,
1380       'test'
1381     ])
1382     const echoTaskFunction = data => {
1383       return data
1384     }
1385     await expect(
1386       dynamicThreadPool.addTaskFunction('echo', echoTaskFunction)
1387     ).resolves.toBe(true)
1388     expect(dynamicThreadPool.taskFunctions.size).toBe(1)
1389     expect(dynamicThreadPool.taskFunctions.get('echo')).toStrictEqual(
1390       echoTaskFunction
1391     )
1392     expect(dynamicThreadPool.listTaskFunctionNames()).toStrictEqual([
1393       DEFAULT_TASK_NAME,
1394       'test',
1395       'echo'
1396     ])
1397     const taskFunctionData = { test: 'test' }
1398     const echoResult = await dynamicThreadPool.execute(taskFunctionData, 'echo')
1399     expect(echoResult).toStrictEqual(taskFunctionData)
1400     for (const workerNode of dynamicThreadPool.workerNodes) {
1401       expect(workerNode.getTaskFunctionWorkerUsage('echo')).toStrictEqual({
1402         tasks: {
1403           executed: expect.any(Number),
1404           executing: 0,
1405           queued: 0,
1406           sequentiallyStolen: 0,
1407           stolen: 0,
1408           failed: 0
1409         },
1410         runTime: {
1411           history: new CircularArray()
1412         },
1413         waitTime: {
1414           history: new CircularArray()
1415         },
1416         elu: {
1417           idle: {
1418             history: new CircularArray()
1419           },
1420           active: {
1421             history: new CircularArray()
1422           }
1423         }
1424       })
1425     }
1426     await dynamicThreadPool.destroy()
1427   })
1428
1429   it('Verify that removeTaskFunction() is working', async () => {
1430     const dynamicThreadPool = new DynamicThreadPool(
1431       Math.floor(numberOfWorkers / 2),
1432       numberOfWorkers,
1433       './tests/worker-files/thread/testWorker.mjs'
1434     )
1435     await waitPoolEvents(dynamicThreadPool, PoolEvents.ready, 1)
1436     expect(dynamicThreadPool.listTaskFunctionNames()).toStrictEqual([
1437       DEFAULT_TASK_NAME,
1438       'test'
1439     ])
1440     await expect(dynamicThreadPool.removeTaskFunction('test')).rejects.toThrow(
1441       new Error('Cannot remove a task function not handled on the pool side')
1442     )
1443     const echoTaskFunction = data => {
1444       return data
1445     }
1446     await dynamicThreadPool.addTaskFunction('echo', echoTaskFunction)
1447     expect(dynamicThreadPool.taskFunctions.size).toBe(1)
1448     expect(dynamicThreadPool.taskFunctions.get('echo')).toStrictEqual(
1449       echoTaskFunction
1450     )
1451     expect(dynamicThreadPool.listTaskFunctionNames()).toStrictEqual([
1452       DEFAULT_TASK_NAME,
1453       'test',
1454       'echo'
1455     ])
1456     await expect(dynamicThreadPool.removeTaskFunction('echo')).resolves.toBe(
1457       true
1458     )
1459     expect(dynamicThreadPool.taskFunctions.size).toBe(0)
1460     expect(dynamicThreadPool.taskFunctions.get('echo')).toBeUndefined()
1461     expect(dynamicThreadPool.listTaskFunctionNames()).toStrictEqual([
1462       DEFAULT_TASK_NAME,
1463       'test'
1464     ])
1465     await dynamicThreadPool.destroy()
1466   })
1467
1468   it('Verify that listTaskFunctionNames() is working', async () => {
1469     const dynamicThreadPool = new DynamicThreadPool(
1470       Math.floor(numberOfWorkers / 2),
1471       numberOfWorkers,
1472       './tests/worker-files/thread/testMultipleTaskFunctionsWorker.mjs'
1473     )
1474     await waitPoolEvents(dynamicThreadPool, PoolEvents.ready, 1)
1475     expect(dynamicThreadPool.listTaskFunctionNames()).toStrictEqual([
1476       DEFAULT_TASK_NAME,
1477       'jsonIntegerSerialization',
1478       'factorial',
1479       'fibonacci'
1480     ])
1481     await dynamicThreadPool.destroy()
1482     const fixedClusterPool = new FixedClusterPool(
1483       numberOfWorkers,
1484       './tests/worker-files/cluster/testMultipleTaskFunctionsWorker.js'
1485     )
1486     await waitPoolEvents(fixedClusterPool, PoolEvents.ready, 1)
1487     expect(fixedClusterPool.listTaskFunctionNames()).toStrictEqual([
1488       DEFAULT_TASK_NAME,
1489       'jsonIntegerSerialization',
1490       'factorial',
1491       'fibonacci'
1492     ])
1493     await fixedClusterPool.destroy()
1494   })
1495
1496   it('Verify that setDefaultTaskFunction() is working', async () => {
1497     const dynamicThreadPool = new DynamicThreadPool(
1498       Math.floor(numberOfWorkers / 2),
1499       numberOfWorkers,
1500       './tests/worker-files/thread/testMultipleTaskFunctionsWorker.mjs'
1501     )
1502     await waitPoolEvents(dynamicThreadPool, PoolEvents.ready, 1)
1503     const workerId = dynamicThreadPool.workerNodes[0].info.id
1504     await expect(dynamicThreadPool.setDefaultTaskFunction(0)).rejects.toThrow(
1505       new Error(
1506         `Task function operation 'default' failed on worker ${workerId} with error: 'TypeError: name parameter is not a string'`
1507       )
1508     )
1509     await expect(
1510       dynamicThreadPool.setDefaultTaskFunction(DEFAULT_TASK_NAME)
1511     ).rejects.toThrow(
1512       new Error(
1513         `Task function operation 'default' failed on worker ${workerId} with error: 'Error: Cannot set the default task function reserved name as the default task function'`
1514       )
1515     )
1516     await expect(
1517       dynamicThreadPool.setDefaultTaskFunction('unknown')
1518     ).rejects.toThrow(
1519       new Error(
1520         `Task function operation 'default' failed on worker ${workerId} with error: 'Error: Cannot set the default task function to a non-existing task function'`
1521       )
1522     )
1523     expect(dynamicThreadPool.listTaskFunctionNames()).toStrictEqual([
1524       DEFAULT_TASK_NAME,
1525       'jsonIntegerSerialization',
1526       'factorial',
1527       'fibonacci'
1528     ])
1529     await expect(
1530       dynamicThreadPool.setDefaultTaskFunction('factorial')
1531     ).resolves.toBe(true)
1532     expect(dynamicThreadPool.listTaskFunctionNames()).toStrictEqual([
1533       DEFAULT_TASK_NAME,
1534       'factorial',
1535       'jsonIntegerSerialization',
1536       'fibonacci'
1537     ])
1538     await expect(
1539       dynamicThreadPool.setDefaultTaskFunction('fibonacci')
1540     ).resolves.toBe(true)
1541     expect(dynamicThreadPool.listTaskFunctionNames()).toStrictEqual([
1542       DEFAULT_TASK_NAME,
1543       'fibonacci',
1544       'jsonIntegerSerialization',
1545       'factorial'
1546     ])
1547     await dynamicThreadPool.destroy()
1548   })
1549
1550   it('Verify that multiple task functions worker is working', async () => {
1551     const pool = new DynamicClusterPool(
1552       Math.floor(numberOfWorkers / 2),
1553       numberOfWorkers,
1554       './tests/worker-files/cluster/testMultipleTaskFunctionsWorker.js'
1555     )
1556     const data = { n: 10 }
1557     const result0 = await pool.execute(data)
1558     expect(result0).toStrictEqual({ ok: 1 })
1559     const result1 = await pool.execute(data, 'jsonIntegerSerialization')
1560     expect(result1).toStrictEqual({ ok: 1 })
1561     const result2 = await pool.execute(data, 'factorial')
1562     expect(result2).toBe(3628800)
1563     const result3 = await pool.execute(data, 'fibonacci')
1564     expect(result3).toBe(55)
1565     expect(pool.info.executingTasks).toBe(0)
1566     expect(pool.info.executedTasks).toBe(4)
1567     for (const workerNode of pool.workerNodes) {
1568       expect(workerNode.info.taskFunctionNames).toStrictEqual([
1569         DEFAULT_TASK_NAME,
1570         'jsonIntegerSerialization',
1571         'factorial',
1572         'fibonacci'
1573       ])
1574       expect(workerNode.taskFunctionsUsage.size).toBe(3)
1575       for (const name of pool.listTaskFunctionNames()) {
1576         expect(workerNode.getTaskFunctionWorkerUsage(name)).toStrictEqual({
1577           tasks: {
1578             executed: expect.any(Number),
1579             executing: 0,
1580             failed: 0,
1581             queued: 0,
1582             sequentiallyStolen: 0,
1583             stolen: 0
1584           },
1585           runTime: {
1586             history: expect.any(CircularArray)
1587           },
1588           waitTime: {
1589             history: expect.any(CircularArray)
1590           },
1591           elu: {
1592             idle: {
1593               history: expect.any(CircularArray)
1594             },
1595             active: {
1596               history: expect.any(CircularArray)
1597             }
1598           }
1599         })
1600         expect(
1601           workerNode.getTaskFunctionWorkerUsage(name).tasks.executed
1602         ).toBeGreaterThan(0)
1603       }
1604       expect(
1605         workerNode.getTaskFunctionWorkerUsage(DEFAULT_TASK_NAME)
1606       ).toStrictEqual(
1607         workerNode.getTaskFunctionWorkerUsage(
1608           workerNode.info.taskFunctionNames[1]
1609         )
1610       )
1611     }
1612     await pool.destroy()
1613   })
1614
1615   it('Verify sendKillMessageToWorker()', async () => {
1616     const pool = new DynamicClusterPool(
1617       Math.floor(numberOfWorkers / 2),
1618       numberOfWorkers,
1619       './tests/worker-files/cluster/testWorker.js'
1620     )
1621     const workerNodeKey = 0
1622     await expect(
1623       pool.sendKillMessageToWorker(workerNodeKey)
1624     ).resolves.toBeUndefined()
1625     await expect(
1626       pool.sendKillMessageToWorker(numberOfWorkers)
1627     ).rejects.toStrictEqual(
1628       new Error(`Invalid worker node key '${numberOfWorkers}'`)
1629     )
1630     await pool.destroy()
1631   })
1632
1633   it('Verify sendTaskFunctionOperationToWorker()', async () => {
1634     const pool = new DynamicClusterPool(
1635       Math.floor(numberOfWorkers / 2),
1636       numberOfWorkers,
1637       './tests/worker-files/cluster/testWorker.js'
1638     )
1639     const workerNodeKey = 0
1640     await expect(
1641       pool.sendTaskFunctionOperationToWorker(workerNodeKey, {
1642         taskFunctionOperation: 'add',
1643         taskFunctionName: 'empty',
1644         taskFunction: (() => {}).toString()
1645       })
1646     ).resolves.toBe(true)
1647     expect(
1648       pool.workerNodes[workerNodeKey].info.taskFunctionNames
1649     ).toStrictEqual([DEFAULT_TASK_NAME, 'test', 'empty'])
1650     await pool.destroy()
1651   })
1652
1653   it('Verify sendTaskFunctionOperationToWorkers()', async () => {
1654     const pool = new DynamicClusterPool(
1655       Math.floor(numberOfWorkers / 2),
1656       numberOfWorkers,
1657       './tests/worker-files/cluster/testWorker.js'
1658     )
1659     await expect(
1660       pool.sendTaskFunctionOperationToWorkers({
1661         taskFunctionOperation: 'add',
1662         taskFunctionName: 'empty',
1663         taskFunction: (() => {}).toString()
1664       })
1665     ).resolves.toBe(true)
1666     for (const workerNode of pool.workerNodes) {
1667       expect(workerNode.info.taskFunctionNames).toStrictEqual([
1668         DEFAULT_TASK_NAME,
1669         'test',
1670         'empty'
1671       ])
1672     }
1673     await pool.destroy()
1674   })
1675 })