build(deps-dev): bump mocha from 10.4.0 to 10.5.0

[poolifier.git] / tests / pools / selection-strategies / selection-strategies.test.mjs

diff --git a/tests/pools/selection-strategies/selection-strategies.test.mjs b/tests/pools/selection-strategies/selection-strategies.test.mjs
index 342d2fa6c997c0bfe1f696cfcecfefcce91931c2..e8df7e1a5c35baa931595bb49493f5ba28e4fd5c 100644 (file)
--- a/tests/pools/selection-strategies/selection-strategies.test.mjs
+++ b/tests/pools/selection-strategies/selection-strategies.test.mjs
@@ -1,12 +1,15 @@
+import { randomInt } from 'node:crypto'
+
 import { expect } from 'expect'
+
+import { CircularBuffer } from '../../../lib/circular-buffer.cjs'
 import {
   DynamicClusterPool,
   DynamicThreadPool,
   FixedClusterPool,
   FixedThreadPool,
-  WorkerChoiceStrategies
-} from '../../../lib/index.js'
-import { CircularArray } from '../../../lib/circular-array.js'
+  WorkerChoiceStrategies,
+} from '../../../lib/index.cjs'
 
 describe('Selection strategies test suite', () => {
   const min = 0
@@ -30,11 +33,14 @@ describe('Selection strategies test suite', () => {
     const pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js'
+      './tests/worker-files/thread/testWorker.mjs'
     )
     expect(pool.opts.workerChoiceStrategy).toBe(
       WorkerChoiceStrategies.ROUND_ROBIN
     )
+    expect(pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy).toBe(
+      WorkerChoiceStrategies.ROUND_ROBIN
+    )
     // We need to clean up the resources after our test
     await pool.destroy()
   })
@@ -43,13 +49,13 @@ describe('Selection strategies test suite', () => {
     for (const workerChoiceStrategy of Object.values(WorkerChoiceStrategies)) {
       const pool = new FixedThreadPool(
         max,
-        './tests/worker-files/thread/testWorker.js',
+        './tests/worker-files/thread/testWorker.mjs',
         { workerChoiceStrategy }
       )
       expect(pool.opts.workerChoiceStrategy).toBe(workerChoiceStrategy)
-      expect(pool.workerChoiceStrategyContext.workerChoiceStrategy).toBe(
-        workerChoiceStrategy
-      )
+      expect(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+      ).toBe(workerChoiceStrategy)
       await pool.destroy()
     }
   })
@@ -59,67 +65,44 @@ describe('Selection strategies test suite', () => {
       const pool = new DynamicThreadPool(
         min,
         max,
-        './tests/worker-files/thread/testWorker.js'
+        './tests/worker-files/thread/testWorker.mjs'
       )
       pool.setWorkerChoiceStrategy(workerChoiceStrategy)
       expect(pool.opts.workerChoiceStrategy).toBe(workerChoiceStrategy)
-      expect(pool.workerChoiceStrategyContext.workerChoiceStrategy).toBe(
-        workerChoiceStrategy
-      )
-      expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
-        retries: 6,
-        runTime: { median: false },
-        waitTime: { median: false },
-        elu: { median: false }
-      })
-      expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
-        retries: 6,
-        runTime: { median: false },
-        waitTime: { median: false },
-        elu: { median: false }
-      })
+      expect(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+      ).toBe(workerChoiceStrategy)
       await pool.destroy()
     }
     for (const workerChoiceStrategy of Object.values(WorkerChoiceStrategies)) {
       const pool = new DynamicClusterPool(
         min,
         max,
-        './tests/worker-files/cluster/testWorker.js'
+        './tests/worker-files/cluster/testWorker.cjs'
       )
-      pool.setWorkerChoiceStrategy(workerChoiceStrategy, { retries: 3 })
+      pool.setWorkerChoiceStrategy(workerChoiceStrategy)
       expect(pool.opts.workerChoiceStrategy).toBe(workerChoiceStrategy)
-      expect(pool.workerChoiceStrategyContext.workerChoiceStrategy).toBe(
-        workerChoiceStrategy
-      )
-      expect(pool.opts.workerChoiceStrategyOptions).toStrictEqual({
-        retries: 3,
-        runTime: { median: false },
-        waitTime: { median: false },
-        elu: { median: false }
-      })
-      expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
-        retries: 3,
-        runTime: { median: false },
-        waitTime: { median: false },
-        elu: { median: false }
-      })
+      expect(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+      ).toBe(workerChoiceStrategy)
       await pool.destroy()
     }
   })
 
   it('Verify available strategies default internals at pool creation', async () => {
-    const pool = new FixedThreadPool(
-      max,
-      './tests/worker-files/thread/testWorker.js'
-    )
     for (const workerChoiceStrategy of Object.values(WorkerChoiceStrategies)) {
+      const pool = new FixedThreadPool(
+        max,
+        './tests/worker-files/thread/testWorker.mjs',
+        { workerChoiceStrategy }
+      )
       expect(
-        pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
           workerChoiceStrategy
         ).nextWorkerNodeKey
       ).toBe(0)
       expect(
-        pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
           workerChoiceStrategy
         ).previousWorkerNodeKey
       ).toBe(0)
@@ -127,74 +110,67 @@ describe('Selection strategies test suite', () => {
         workerChoiceStrategy === WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN
       ) {
         expect(
-          pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+          pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
             workerChoiceStrategy
-          ).defaultWorkerWeight
-        ).toBeGreaterThan(0)
-        expect(
-          pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-            workerChoiceStrategy
-          ).workerNodeVirtualTaskRunTime
+          ).workerNodeVirtualTaskExecutionTime
         ).toBe(0)
       } else if (
         workerChoiceStrategy ===
         WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN
       ) {
         expect(
-          pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-            workerChoiceStrategy
-          ).defaultWorkerWeight
-        ).toBeGreaterThan(0)
-        expect(
-          pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+          pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
             workerChoiceStrategy
-          ).workerNodeVirtualTaskRunTime
+          ).workerNodeVirtualTaskExecutionTime
         ).toBe(0)
         expect(
-          pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+          pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
             workerChoiceStrategy
           ).roundId
         ).toBe(0)
         expect(
-          pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+          pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
             workerChoiceStrategy
           ).workerNodeId
         ).toBe(0)
         expect(
-          pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-            workerChoiceStrategy
-          ).roundWeights
-        ).toStrictEqual([
-          pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+          pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
             workerChoiceStrategy
-          ).defaultWorkerWeight
-        ])
+          ).roundWeights.length
+        ).toBe(1)
+        expect(
+          Number.isSafeInteger(
+            pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+              workerChoiceStrategy
+            ).roundWeights[0]
+          )
+        ).toBe(true)
       }
+      await pool.destroy()
     }
-    await pool.destroy()
   })
 
   it('Verify ROUND_ROBIN strategy default policy', async () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.ROUND_ROBIN
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
-    expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+    expect(pool.workerChoiceStrategiesContext.getPolicy()).toStrictEqual({
       dynamicWorkerUsage: false,
-      dynamicWorkerReady: true
+      dynamicWorkerReady: true,
     })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
-    expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+    expect(pool.workerChoiceStrategiesContext.getPolicy()).toStrictEqual({
       dynamicWorkerUsage: false,
-      dynamicWorkerReady: true
+      dynamicWorkerReady: true,
     })
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -204,53 +180,53 @@ describe('Selection strategies test suite', () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.ROUND_ROBIN
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+      pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
     ).toStrictEqual({
       runTime: {
         aggregate: false,
         average: false,
-        median: false
+        median: false,
       },
       waitTime: {
         aggregate: false,
         average: false,
-        median: false
+        median: false,
       },
       elu: {
         aggregate: false,
         average: false,
-        median: false
-      }
+        median: false,
+      },
     })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+      pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
     ).toStrictEqual({
       runTime: {
         aggregate: false,
         average: false,
-        median: false
+        median: false,
       },
       waitTime: {
         aggregate: false,
         average: false,
-        median: false
+        median: false,
       },
       elu: {
         aggregate: false,
         average: false,
-        median: false
-      }
+        median: false,
+      },
     })
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -260,7 +236,7 @@ describe('Selection strategies test suite', () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.ROUND_ROBIN
     const pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
@@ -277,33 +253,34 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: {
-          history: new CircularArray()
+          history: expect.any(CircularBuffer),
         },
         waitTime: {
-          history: new CircularArray()
+          history: expect.any(CircularBuffer),
         },
         elu: {
           idle: {
-            history: new CircularArray()
+            history: expect.any(CircularBuffer),
           },
           active: {
-            history: new CircularArray()
-          }
-        }
+            history: expect.any(CircularBuffer),
+          },
+        },
       })
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
     ).toBe(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
     ).toBe(pool.workerNodes.length - 1)
     // We need to clean up the resources after our test
@@ -315,7 +292,7 @@ describe('Selection strategies test suite', () => {
     const pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     // TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
@@ -332,23 +309,24 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: {
-          history: new CircularArray()
+          history: expect.any(CircularBuffer),
         },
         waitTime: {
-          history: new CircularArray()
+          history: expect.any(CircularBuffer),
         },
         elu: {
           idle: {
-            history: new CircularArray()
+            history: expect.any(CircularBuffer),
           },
           active: {
-            history: new CircularArray()
-          }
-        }
+            history: expect.any(CircularBuffer),
+          },
+        },
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
@@ -356,13 +334,13 @@ describe('Selection strategies test suite', () => {
       )
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
     ).toBe(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
     ).toBe(pool.workerNodes.length - 1)
     // We need to clean up the resources after our test
@@ -373,84 +351,76 @@ describe('Selection strategies test suite', () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.ROUND_ROBIN
     let pool = new FixedClusterPool(
       max,
-      './tests/worker-files/cluster/testWorker.js',
+      './tests/worker-files/cluster/testWorker.cjs',
       { workerChoiceStrategy }
     )
     let results = new Set()
     for (let i = 0; i < max; i++) {
-      results.add(pool.workerNodes[pool.chooseWorkerNode()].worker.id)
+      results.add(pool.workerNodes[pool.chooseWorkerNode()].info.id)
     }
     expect(results.size).toBe(max)
     await pool.destroy()
     pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     results = new Set()
     for (let i = 0; i < max; i++) {
-      results.add(pool.workerNodes[pool.chooseWorkerNode()].worker.threadId)
+      results.add(pool.workerNodes[pool.chooseWorkerNode()].info.id)
     }
     expect(results.size).toBe(max)
     await pool.destroy()
   })
 
-  it('Verify ROUND_ROBIN strategy internals are resets after setting it', async () => {
+  it("Verify ROUND_ROBIN strategy internals aren't reset after setting it", async () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.ROUND_ROBIN
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
-      { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
+      './tests/worker-files/thread/testWorker.mjs',
+      { workerChoiceStrategy }
     )
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).nextWorkerNodeKey
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).previousWorkerNodeKey
-    ).toBeDefined()
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+    ).nextWorkerNodeKey = randomInt(1, max - 1)
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+    ).previousWorkerNodeKey = randomInt(1, max - 1)
     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
-    ).toBe(0)
+    ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
-    ).toBe(0)
+    ).toBeGreaterThan(0)
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
-      { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
+      './tests/worker-files/thread/testWorker.mjs',
+      { workerChoiceStrategy }
     )
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).nextWorkerNodeKey
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).previousWorkerNodeKey
-    ).toBeDefined()
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+    ).nextWorkerNodeKey = randomInt(1, max - 1)
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+    ).previousWorkerNodeKey = randomInt(1, max - 1)
     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
-    ).toBe(0)
+    ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
-    ).toBe(0)
+    ).toBeGreaterThan(0)
     // We need to clean up the resources after our test
     await pool.destroy()
   })
@@ -459,23 +429,23 @@ describe('Selection strategies test suite', () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.LEAST_USED
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
-    expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+    expect(pool.workerChoiceStrategiesContext.getPolicy()).toStrictEqual({
       dynamicWorkerUsage: false,
-      dynamicWorkerReady: true
+      dynamicWorkerReady: true,
     })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
-    expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+    expect(pool.workerChoiceStrategiesContext.getPolicy()).toStrictEqual({
       dynamicWorkerUsage: false,
-      dynamicWorkerReady: true
+      dynamicWorkerReady: true,
     })
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -485,53 +455,53 @@ describe('Selection strategies test suite', () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.LEAST_USED
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+      pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
     ).toStrictEqual({
       runTime: {
         aggregate: false,
         average: false,
-        median: false
+        median: false,
       },
       waitTime: {
         aggregate: false,
         average: false,
-        median: false
+        median: false,
       },
       elu: {
         aggregate: false,
         average: false,
-        median: false
-      }
+        median: false,
+      },
     })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+      pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
     ).toStrictEqual({
       runTime: {
         aggregate: false,
         average: false,
-        median: false
+        median: false,
       },
       waitTime: {
         aggregate: false,
         average: false,
-        median: false
+        median: false,
       },
       elu: {
         aggregate: false,
         average: false,
-        median: false
-      }
+        median: false,
+      },
     })
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -540,7 +510,7 @@ describe('Selection strategies test suite', () => {
   it('Verify LEAST_USED strategy can be run in a fixed pool', async () => {
     const pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy: WorkerChoiceStrategies.LEAST_USED }
     )
     // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
@@ -557,23 +527,24 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: {
-          history: new CircularArray()
+          history: expect.any(CircularBuffer),
         },
         waitTime: {
-          history: new CircularArray()
+          history: expect.any(CircularBuffer),
         },
         elu: {
           idle: {
-            history: new CircularArray()
+            history: expect.any(CircularBuffer),
           },
           active: {
-            history: new CircularArray()
-          }
-        }
+            history: expect.any(CircularBuffer),
+          },
+        },
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
@@ -581,13 +552,13 @@ describe('Selection strategies test suite', () => {
       )
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
     ).toEqual(expect.any(Number))
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
     ).toEqual(expect.any(Number))
     // We need to clean up the resources after our test
@@ -598,7 +569,7 @@ describe('Selection strategies test suite', () => {
     const pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy: WorkerChoiceStrategies.LEAST_USED }
     )
     // TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
@@ -615,23 +586,24 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: {
-          history: new CircularArray()
+          history: expect.any(CircularBuffer),
         },
         waitTime: {
-          history: new CircularArray()
+          history: expect.any(CircularBuffer),
         },
         elu: {
           idle: {
-            history: new CircularArray()
+            history: expect.any(CircularBuffer),
           },
           active: {
-            history: new CircularArray()
-          }
-        }
+            history: expect.any(CircularBuffer),
+          },
+        },
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
@@ -639,13 +611,13 @@ describe('Selection strategies test suite', () => {
       )
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
     ).toEqual(expect.any(Number))
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
     ).toEqual(expect.any(Number))
     // We need to clean up the resources after our test
@@ -656,23 +628,23 @@ describe('Selection strategies test suite', () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.LEAST_BUSY
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
-    expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+    expect(pool.workerChoiceStrategiesContext.getPolicy()).toStrictEqual({
       dynamicWorkerUsage: false,
-      dynamicWorkerReady: true
+      dynamicWorkerReady: true,
     })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
-    expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+    expect(pool.workerChoiceStrategiesContext.getPolicy()).toStrictEqual({
       dynamicWorkerUsage: false,
-      dynamicWorkerReady: true
+      dynamicWorkerReady: true,
     })
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -682,53 +654,53 @@ describe('Selection strategies test suite', () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.LEAST_BUSY
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+      pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
     ).toStrictEqual({
       runTime: {
         aggregate: true,
         average: false,
-        median: false
+        median: false,
       },
       waitTime: {
         aggregate: true,
         average: false,
-        median: false
+        median: false,
       },
       elu: {
         aggregate: false,
         average: false,
-        median: false
-      }
+        median: false,
+      },
     })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+      pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
     ).toStrictEqual({
       runTime: {
         aggregate: true,
         average: false,
-        median: false
+        median: false,
       },
       waitTime: {
         aggregate: true,
         average: false,
-        median: false
+        median: false,
       },
       elu: {
         aggregate: false,
         average: false,
-        median: false
-      }
+        median: false,
+      },
     })
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -737,7 +709,7 @@ describe('Selection strategies test suite', () => {
   it('Verify LEAST_BUSY strategy can be run in a fixed pool', async () => {
     const pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy: WorkerChoiceStrategies.LEAST_BUSY }
     )
     // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
@@ -754,23 +726,24 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: expect.objectContaining({
-          history: expect.any(CircularArray)
+          history: expect.any(CircularBuffer),
         }),
         waitTime: expect.objectContaining({
-          history: expect.any(CircularArray)
+          history: expect.any(CircularBuffer),
         }),
         elu: {
           idle: {
-            history: new CircularArray()
+            history: expect.any(CircularBuffer),
           },
           active: {
-            history: new CircularArray()
-          }
-        }
+            history: expect.any(CircularBuffer),
+          },
+        },
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
@@ -788,13 +761,13 @@ describe('Selection strategies test suite', () => {
       }
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
     ).toEqual(expect.any(Number))
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
     ).toEqual(expect.any(Number))
     // We need to clean up the resources after our test
@@ -805,7 +778,7 @@ describe('Selection strategies test suite', () => {
     const pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy: WorkerChoiceStrategies.LEAST_BUSY }
     )
     // TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
@@ -822,23 +795,24 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: expect.objectContaining({
-          history: expect.any(CircularArray)
+          history: expect.any(CircularBuffer),
         }),
         waitTime: expect.objectContaining({
-          history: expect.any(CircularArray)
+          history: expect.any(CircularBuffer),
         }),
         elu: {
           idle: {
-            history: new CircularArray()
+            history: expect.any(CircularBuffer),
           },
           active: {
-            history: new CircularArray()
-          }
-        }
+            history: expect.any(CircularBuffer),
+          },
+        },
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
@@ -856,13 +830,13 @@ describe('Selection strategies test suite', () => {
       }
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
     ).toEqual(expect.any(Number))
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
     ).toEqual(expect.any(Number))
     // We need to clean up the resources after our test
@@ -873,23 +847,23 @@ describe('Selection strategies test suite', () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.LEAST_ELU
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
-    expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+    expect(pool.workerChoiceStrategiesContext.getPolicy()).toStrictEqual({
       dynamicWorkerUsage: false,
-      dynamicWorkerReady: true
+      dynamicWorkerReady: true,
     })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
-    expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+    expect(pool.workerChoiceStrategiesContext.getPolicy()).toStrictEqual({
       dynamicWorkerUsage: false,
-      dynamicWorkerReady: true
+      dynamicWorkerReady: true,
     })
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -899,53 +873,53 @@ describe('Selection strategies test suite', () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.LEAST_ELU
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+      pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
     ).toStrictEqual({
       runTime: {
         aggregate: false,
         average: false,
-        median: false
+        median: false,
       },
       waitTime: {
         aggregate: false,
         average: false,
-        median: false
+        median: false,
       },
       elu: {
         aggregate: true,
         average: false,
-        median: false
-      }
+        median: false,
+      },
     })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+      pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
     ).toStrictEqual({
       runTime: {
         aggregate: false,
         average: false,
-        median: false
+        median: false,
       },
       waitTime: {
         aggregate: false,
         average: false,
-        median: false
+        median: false,
       },
       elu: {
         aggregate: true,
         average: false,
-        median: false
-      }
+        median: false,
+      },
     })
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -954,7 +928,7 @@ describe('Selection strategies test suite', () => {
   it('Verify LEAST_ELU strategy can be run in a fixed pool', async () => {
     const pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy: WorkerChoiceStrategies.LEAST_ELU }
     )
     // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
@@ -971,23 +945,24 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: {
-          history: new CircularArray()
+          history: expect.any(CircularBuffer),
         },
         waitTime: {
-          history: new CircularArray()
+          history: expect.any(CircularBuffer),
         },
         elu: expect.objectContaining({
           idle: expect.objectContaining({
-            history: expect.any(CircularArray)
+            history: expect.any(CircularBuffer),
           }),
           active: expect.objectContaining({
-            history: expect.any(CircularArray)
-          })
-        })
+            history: expect.any(CircularBuffer),
+          }),
+        }),
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
@@ -1011,13 +986,13 @@ describe('Selection strategies test suite', () => {
       }
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
     ).toEqual(expect.any(Number))
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
     ).toEqual(expect.any(Number))
     // We need to clean up the resources after our test
@@ -1028,7 +1003,7 @@ describe('Selection strategies test suite', () => {
     const pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy: WorkerChoiceStrategies.LEAST_ELU }
     )
     // TODO: Create a better test to cover `LeastEluWorkerChoiceStrategy#choose`
@@ -1045,23 +1020,24 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: {
-          history: new CircularArray()
+          history: expect.any(CircularBuffer),
         },
         waitTime: {
-          history: new CircularArray()
+          history: expect.any(CircularBuffer),
         },
         elu: expect.objectContaining({
           idle: expect.objectContaining({
-            history: expect.any(CircularArray)
+            history: expect.any(CircularBuffer),
           }),
           active: expect.objectContaining({
-            history: expect.any(CircularArray)
-          })
-        })
+            history: expect.any(CircularBuffer),
+          }),
+        }),
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
@@ -1085,13 +1061,13 @@ describe('Selection strategies test suite', () => {
       }
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
     ).toEqual(expect.any(Number))
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
     ).toEqual(expect.any(Number))
     // We need to clean up the resources after our test
@@ -1102,23 +1078,23 @@ describe('Selection strategies test suite', () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.FAIR_SHARE
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
-    expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+    expect(pool.workerChoiceStrategiesContext.getPolicy()).toStrictEqual({
       dynamicWorkerUsage: false,
-      dynamicWorkerReady: true
+      dynamicWorkerReady: true,
     })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
-    expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+    expect(pool.workerChoiceStrategiesContext.getPolicy()).toStrictEqual({
       dynamicWorkerUsage: false,
-      dynamicWorkerReady: true
+      dynamicWorkerReady: true,
     })
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -1128,53 +1104,53 @@ describe('Selection strategies test suite', () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.FAIR_SHARE
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+      pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
     ).toStrictEqual({
       runTime: {
         aggregate: true,
         average: true,
-        median: false
+        median: false,
       },
       waitTime: {
-        aggregate: false,
-        average: false,
-        median: false
+        aggregate: true,
+        average: true,
+        median: false,
       },
       elu: {
         aggregate: true,
         average: true,
-        median: false
-      }
+        median: false,
+      },
     })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+      pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
     ).toStrictEqual({
       runTime: {
         aggregate: true,
         average: true,
-        median: false
+        median: false,
       },
       waitTime: {
-        aggregate: false,
-        average: false,
-        median: false
+        aggregate: true,
+        average: true,
+        median: false,
       },
       elu: {
         aggregate: true,
         average: true,
-        median: false
-      }
+        median: false,
+      },
     })
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -1183,7 +1159,7 @@ describe('Selection strategies test suite', () => {
   it('Verify FAIR_SHARE strategy can be run in a fixed pool', async () => {
     const pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
     )
     // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
@@ -1200,23 +1176,24 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: expect.objectContaining({
-          history: expect.any(CircularArray)
+          history: expect.any(CircularBuffer),
+        }),
+        waitTime: expect.objectContaining({
+          history: expect.any(CircularBuffer),
         }),
-        waitTime: {
-          history: new CircularArray()
-        },
         elu: expect.objectContaining({
           idle: expect.objectContaining({
-            history: expect.any(CircularArray)
+            history: expect.any(CircularBuffer),
           }),
           active: expect.objectContaining({
-            history: expect.any(CircularArray)
-          })
-        })
+            history: expect.any(CircularBuffer),
+          }),
+        }),
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
@@ -1232,6 +1209,16 @@ describe('Selection strategies test suite', () => {
       } else {
         expect(workerNode.usage.runTime.average).toBeGreaterThan(0)
       }
+      if (workerNode.usage.waitTime.aggregate == null) {
+        expect(workerNode.usage.waitTime.aggregate).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.aggregate).toBeGreaterThan(0)
+      }
+      if (workerNode.usage.waitTime.average == null) {
+        expect(workerNode.usage.waitTime.average).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.average).toBeGreaterThan(0)
+      }
       if (workerNode.usage.elu.active.aggregate == null) {
         expect(workerNode.usage.elu.active.aggregate).toBeUndefined()
       } else {
@@ -1251,13 +1238,13 @@ describe('Selection strategies test suite', () => {
       expect(workerNode.strategyData.virtualTaskEndTimestamp).toBeGreaterThan(0)
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
     ).toEqual(expect.any(Number))
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
     ).toEqual(expect.any(Number))
     // We need to clean up the resources after our test
@@ -1268,7 +1255,7 @@ describe('Selection strategies test suite', () => {
     const pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
     )
     // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
@@ -1285,23 +1272,24 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: expect.objectContaining({
-          history: expect.any(CircularArray)
+          history: expect.any(CircularBuffer),
+        }),
+        waitTime: expect.objectContaining({
+          history: expect.any(CircularBuffer),
         }),
-        waitTime: {
-          history: new CircularArray()
-        },
         elu: expect.objectContaining({
           idle: expect.objectContaining({
-            history: expect.any(CircularArray)
+            history: expect.any(CircularBuffer),
           }),
           active: expect.objectContaining({
-            history: expect.any(CircularArray)
-          })
-        })
+            history: expect.any(CircularBuffer),
+          }),
+        }),
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
@@ -1317,6 +1305,16 @@ describe('Selection strategies test suite', () => {
       } else {
         expect(workerNode.usage.runTime.average).toBeGreaterThan(0)
       }
+      if (workerNode.usage.waitTime.aggregate == null) {
+        expect(workerNode.usage.waitTime.aggregate).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.aggregate).toBeGreaterThan(0)
+      }
+      if (workerNode.usage.waitTime.average == null) {
+        expect(workerNode.usage.waitTime.average).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.average).toBeGreaterThan(0)
+      }
       if (workerNode.usage.elu.active.aggregate == null) {
         expect(workerNode.usage.elu.active.aggregate).toBeUndefined()
       } else {
@@ -1336,13 +1334,13 @@ describe('Selection strategies test suite', () => {
       expect(workerNode.strategyData.virtualTaskEndTimestamp).toBeGreaterThan(0)
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
     ).toEqual(expect.any(Number))
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
     ).toEqual(expect.any(Number))
     // We need to clean up the resources after our test
@@ -1353,12 +1351,12 @@ describe('Selection strategies test suite', () => {
     const pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       {
         workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE,
         workerChoiceStrategyOptions: {
-          runTime: { median: true }
-        }
+          runTime: { median: true },
+        },
       }
     )
     // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
@@ -1375,23 +1373,24 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: expect.objectContaining({
-          history: expect.any(CircularArray)
+          history: expect.any(CircularBuffer),
+        }),
+        waitTime: expect.objectContaining({
+          history: expect.any(CircularBuffer),
         }),
-        waitTime: {
-          history: new CircularArray()
-        },
         elu: expect.objectContaining({
           idle: expect.objectContaining({
-            history: expect.any(CircularArray)
+            history: expect.any(CircularBuffer),
           }),
           active: expect.objectContaining({
-            history: expect.any(CircularArray)
-          })
-        })
+            history: expect.any(CircularBuffer),
+          }),
+        }),
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
@@ -1407,6 +1406,16 @@ describe('Selection strategies test suite', () => {
       } else {
         expect(workerNode.usage.runTime.median).toBeGreaterThan(0)
       }
+      if (workerNode.usage.waitTime.aggregate == null) {
+        expect(workerNode.usage.waitTime.aggregate).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.aggregate).toBeGreaterThan(0)
+      }
+      if (workerNode.usage.waitTime.median == null) {
+        expect(workerNode.usage.waitTime.median).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.median).toBeGreaterThan(0)
+      }
       if (workerNode.usage.elu.active.aggregate == null) {
         expect(workerNode.usage.elu.active.aggregate).toBeUndefined()
       } else {
@@ -1426,48 +1435,48 @@ describe('Selection strategies test suite', () => {
       expect(workerNode.strategyData.virtualTaskEndTimestamp).toBeGreaterThan(0)
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
     ).toEqual(expect.any(Number))
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
     ).toEqual(expect.any(Number))
     // We need to clean up the resources after our test
     await pool.destroy()
   })
 
-  it('Verify FAIR_SHARE strategy internals are resets after setting it', async () => {
+  it("Verify FAIR_SHARE strategy internals aren't reset after setting it", async () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.FAIR_SHARE
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js'
+      './tests/worker-files/thread/testWorker.mjs'
     )
     for (const workerNode of pool.workerNodes) {
       workerNode.strategyData = {
-        virtualTaskEndTimestamp: performance.now()
+        virtualTaskEndTimestamp: performance.now(),
       }
     }
     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
     for (const workerNode of pool.workerNodes) {
-      expect(workerNode.strategyData.virtualTaskEndTimestamp).toBeUndefined()
+      expect(workerNode.strategyData.virtualTaskEndTimestamp).toBeGreaterThan(0)
     }
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js'
+      './tests/worker-files/thread/testWorker.mjs'
     )
     for (const workerNode of pool.workerNodes) {
       workerNode.strategyData = {
-        virtualTaskEndTimestamp: performance.now()
+        virtualTaskEndTimestamp: performance.now(),
       }
     }
     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
     for (const workerNode of pool.workerNodes) {
-      expect(workerNode.strategyData.virtualTaskEndTimestamp).toBeUndefined()
+      expect(workerNode.strategyData.virtualTaskEndTimestamp).toBeGreaterThan(0)
     }
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -1477,23 +1486,23 @@ describe('Selection strategies test suite', () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
-    expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+    expect(pool.workerChoiceStrategiesContext.getPolicy()).toStrictEqual({
       dynamicWorkerUsage: false,
-      dynamicWorkerReady: true
+      dynamicWorkerReady: true,
     })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
-    expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+    expect(pool.workerChoiceStrategiesContext.getPolicy()).toStrictEqual({
       dynamicWorkerUsage: false,
-      dynamicWorkerReady: true
+      dynamicWorkerReady: true,
     })
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -1503,53 +1512,53 @@ describe('Selection strategies test suite', () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+      pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
     ).toStrictEqual({
       runTime: {
         aggregate: true,
         average: true,
-        median: false
+        median: false,
       },
       waitTime: {
-        aggregate: false,
-        average: false,
-        median: false
+        aggregate: true,
+        average: true,
+        median: false,
       },
       elu: {
         aggregate: false,
         average: false,
-        median: false
-      }
+        median: false,
+      },
     })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+      pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
     ).toStrictEqual({
       runTime: {
         aggregate: true,
         average: true,
-        median: false
+        median: false,
       },
       waitTime: {
-        aggregate: false,
-        average: false,
-        median: false
+        aggregate: true,
+        average: true,
+        median: false,
       },
       elu: {
         aggregate: false,
         average: false,
-        median: false
-      }
+        median: false,
+      },
     })
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -1558,7 +1567,7 @@ describe('Selection strategies test suite', () => {
   it('Verify WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
     const pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
     )
     // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
@@ -1575,23 +1584,24 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: expect.objectContaining({
-          history: expect.any(CircularArray)
+          history: expect.any(CircularBuffer),
+        }),
+        waitTime: expect.objectContaining({
+          history: expect.any(CircularBuffer),
         }),
-        waitTime: {
-          history: new CircularArray()
-        },
         elu: {
           idle: {
-            history: new CircularArray()
+            history: expect.any(CircularBuffer),
           },
           active: {
-            history: new CircularArray()
-          }
-        }
+            history: expect.any(CircularBuffer),
+          },
+        },
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
@@ -1607,26 +1617,31 @@ describe('Selection strategies test suite', () => {
       } else {
         expect(workerNode.usage.runTime.average).toBeGreaterThan(0)
       }
+      if (workerNode.usage.waitTime.aggregate == null) {
+        expect(workerNode.usage.waitTime.aggregate).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.aggregate).toBeGreaterThan(0)
+      }
+      if (workerNode.usage.waitTime.average == null) {
+        expect(workerNode.usage.waitTime.average).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.average).toBeGreaterThan(0)
+      }
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
     ).toBe(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
-    ).toBe(0)
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).defaultWorkerWeight
-    ).toBeGreaterThan(0)
+    ).toEqual(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).workerNodeVirtualTaskRunTime
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+      ).workerNodeVirtualTaskExecutionTime
     ).toBeGreaterThanOrEqual(0)
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -1636,7 +1651,7 @@ describe('Selection strategies test suite', () => {
     const pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
     )
     // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
@@ -1653,23 +1668,24 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: expect.objectContaining({
-          history: expect.any(CircularArray)
+          history: expect.any(CircularBuffer),
+        }),
+        waitTime: expect.objectContaining({
+          history: expect.any(CircularBuffer),
         }),
-        waitTime: {
-          history: new CircularArray()
-        },
         elu: {
           idle: {
-            history: new CircularArray()
+            history: expect.any(CircularBuffer),
           },
           active: {
-            history: new CircularArray()
-          }
-        }
+            history: expect.any(CircularBuffer),
+          },
+        },
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
@@ -1685,26 +1701,31 @@ describe('Selection strategies test suite', () => {
       } else {
         expect(workerNode.usage.runTime.average).toBeGreaterThan(0)
       }
+      if (workerNode.usage.waitTime.aggregate == null) {
+        expect(workerNode.usage.waitTime.aggregate).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.aggregate).toBeGreaterThan(0)
+      }
+      if (workerNode.usage.waitTime.average == null) {
+        expect(workerNode.usage.waitTime.average).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.average).toBeGreaterThan(0)
+      }
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
-    ).toBe(0)
+    ).toEqual(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
-    ).toBe(0)
+    ).toEqual(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).defaultWorkerWeight
-    ).toBeGreaterThan(0)
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).workerNodeVirtualTaskRunTime
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+      ).workerNodeVirtualTaskExecutionTime
     ).toBeGreaterThanOrEqual(0)
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -1714,12 +1735,12 @@ describe('Selection strategies test suite', () => {
     const pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       {
         workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN,
         workerChoiceStrategyOptions: {
-          runTime: { median: true }
-        }
+          runTime: { median: true },
+        },
       }
     )
     // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
@@ -1736,23 +1757,24 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: expect.objectContaining({
-          history: expect.any(CircularArray)
+          history: expect.any(CircularBuffer),
+        }),
+        waitTime: expect.objectContaining({
+          history: expect.any(CircularBuffer),
         }),
-        waitTime: {
-          history: new CircularArray()
-        },
         elu: {
           idle: {
-            history: new CircularArray()
+            history: expect.any(CircularBuffer),
           },
           active: {
-            history: new CircularArray()
-          }
-        }
+            history: expect.any(CircularBuffer),
+          },
+        },
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
@@ -1768,125 +1790,100 @@ describe('Selection strategies test suite', () => {
       } else {
         expect(workerNode.usage.runTime.median).toBeGreaterThan(0)
       }
+      if (workerNode.usage.waitTime.aggregate == null) {
+        expect(workerNode.usage.waitTime.aggregate).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.aggregate).toBeGreaterThan(0)
+      }
+      if (workerNode.usage.waitTime.median == null) {
+        expect(workerNode.usage.waitTime.median).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.median).toBeGreaterThan(0)
+      }
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
-    ).toBe(0)
+    ).toEqual(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
-    ).toBe(0)
+    ).toEqual(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).defaultWorkerWeight
-    ).toBeGreaterThan(0)
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).workerNodeVirtualTaskRunTime
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+      ).workerNodeVirtualTaskExecutionTime
     ).toBeGreaterThanOrEqual(0)
     // We need to clean up the resources after our test
     await pool.destroy()
   })
 
-  it('Verify WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
+  it("Verify WEIGHTED_ROUND_ROBIN strategy internals aren't reset after setting it", async () => {
     const workerChoiceStrategy = WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js'
+      './tests/worker-files/thread/testWorker.mjs',
+      { workerChoiceStrategy }
     )
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).nextWorkerNodeKey
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).previousWorkerNodeKey
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).defaultWorkerWeight
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).workerNodeVirtualTaskRunTime
-    ).toBeDefined()
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).nextWorkerNodeKey = randomInt(1, max - 1)
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).previousWorkerNodeKey = randomInt(1, max - 1)
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).workerNodeVirtualTaskRunTime = randomInt(100, 1000)
     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
-    ).toBe(0)
+    ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
-    ).toBe(0)
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).defaultWorkerWeight
     ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).workerNodeVirtualTaskRunTime
-    ).toBe(0)
+    ).toBeGreaterThan(99)
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js'
+      './tests/worker-files/thread/testWorker.mjs',
+      { workerChoiceStrategy }
     )
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).nextWorkerNodeKey
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).previousWorkerNodeKey
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).defaultWorkerWeight
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).workerNodeVirtualTaskRunTime
-    ).toBeDefined()
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).nextWorkerNodeKey = randomInt(1, max - 1)
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).previousWorkerNodeKey = randomInt(1, max - 1)
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).workerNodeVirtualTaskRunTime = randomInt(100, 1000)
     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
-    ).toBe(0)
+    ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
-    ).toBe(0)
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).defaultWorkerWeight
     ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).workerNodeVirtualTaskRunTime
-    ).toBe(0)
+    ).toBeGreaterThan(99)
     // We need to clean up the resources after our test
     await pool.destroy()
   })
@@ -1896,23 +1893,23 @@ describe('Selection strategies test suite', () => {
       WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
-    expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+    expect(pool.workerChoiceStrategiesContext.getPolicy()).toStrictEqual({
       dynamicWorkerUsage: false,
-      dynamicWorkerReady: true
+      dynamicWorkerReady: true,
     })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
-    expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+    expect(pool.workerChoiceStrategiesContext.getPolicy()).toStrictEqual({
       dynamicWorkerUsage: false,
-      dynamicWorkerReady: true
+      dynamicWorkerReady: true,
     })
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -1923,53 +1920,53 @@ describe('Selection strategies test suite', () => {
       WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+      pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
     ).toStrictEqual({
       runTime: {
         aggregate: true,
         average: true,
-        median: false
+        median: false,
       },
       waitTime: {
-        aggregate: false,
-        average: false,
-        median: false
+        aggregate: true,
+        average: true,
+        median: false,
       },
       elu: {
         aggregate: false,
         average: false,
-        median: false
-      }
+        median: false,
+      },
     })
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       { workerChoiceStrategy }
     )
     expect(
-      pool.workerChoiceStrategyContext.getTaskStatisticsRequirements()
+      pool.workerChoiceStrategiesContext.getTaskStatisticsRequirements()
     ).toStrictEqual({
       runTime: {
         aggregate: true,
         average: true,
-        median: false
+        median: false,
       },
       waitTime: {
-        aggregate: false,
-        average: false,
-        median: false
+        aggregate: true,
+        average: true,
+        median: false,
       },
       elu: {
         aggregate: false,
         average: false,
-        median: false
-      }
+        median: false,
+      },
     })
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -1978,10 +1975,10 @@ describe('Selection strategies test suite', () => {
   it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy can be run in a fixed pool', async () => {
     const pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       {
         workerChoiceStrategy:
-          WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN
+          WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN,
       }
     )
     // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
@@ -1998,63 +1995,82 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: expect.objectContaining({
-          history: expect.any(CircularArray)
+          history: expect.any(CircularBuffer),
+        }),
+        waitTime: expect.objectContaining({
+          history: expect.any(CircularBuffer),
         }),
-        waitTime: {
-          history: new CircularArray()
-        },
         elu: {
           idle: {
-            history: new CircularArray()
+            history: expect.any(CircularBuffer),
           },
           active: {
-            history: new CircularArray()
-          }
-        }
+            history: expect.any(CircularBuffer),
+          },
+        },
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
         max * maxMultiplier
       )
+      if (workerNode.usage.runTime.aggregate == null) {
+        expect(workerNode.usage.runTime.aggregate).toBeUndefined()
+      } else {
+        expect(workerNode.usage.runTime.aggregate).toBeGreaterThan(0)
+      }
+      if (workerNode.usage.runTime.average == null) {
+        expect(workerNode.usage.runTime.average).toBeUndefined()
+      } else {
+        expect(workerNode.usage.runTime.average).toBeGreaterThan(0)
+      }
+      if (workerNode.usage.waitTime.aggregate == null) {
+        expect(workerNode.usage.waitTime.aggregate).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.aggregate).toBeGreaterThan(0)
+      }
+      if (workerNode.usage.waitTime.average == null) {
+        expect(workerNode.usage.waitTime.average).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.average).toBeGreaterThan(0)
+      }
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).defaultWorkerWeight
-    ).toBeGreaterThan(0)
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).roundId
     ).toBe(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).workerNodeId
     ).toBe(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
     ).toBe(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
-    ).toEqual(expect.any(Number))
+    ).toEqual(0)
+    expect(
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+      ).roundWeights.length
+    ).toBe(1)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).roundWeights
-    ).toStrictEqual([
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).defaultWorkerWeight
-    ])
+      Number.isSafeInteger(
+        pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+          pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+        ).roundWeights[0]
+      )
+    ).toBe(true)
     // We need to clean up the resources after our test
     await pool.destroy()
   })
@@ -2063,10 +2079,10 @@ describe('Selection strategies test suite', () => {
     const pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js',
+      './tests/worker-files/thread/testWorker.mjs',
       {
         workerChoiceStrategy:
-          WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN
+          WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN,
       }
     )
     // TODO: Create a better test to cover `InterleavedWeightedRoundRobinWorkerChoiceStrategy#choose`
@@ -2083,210 +2099,197 @@ describe('Selection strategies test suite', () => {
           executing: 0,
           queued: 0,
           maxQueued: 0,
+          sequentiallyStolen: 0,
           stolen: 0,
-          failed: 0
+          failed: 0,
         },
         runTime: expect.objectContaining({
-          history: expect.any(CircularArray)
+          history: expect.any(CircularBuffer),
+        }),
+        waitTime: expect.objectContaining({
+          history: expect.any(CircularBuffer),
         }),
-        waitTime: {
-          history: new CircularArray()
-        },
         elu: {
           idle: {
-            history: new CircularArray()
+            history: expect.any(CircularBuffer),
           },
           active: {
-            history: new CircularArray()
-          }
-        }
+            history: expect.any(CircularBuffer),
+          },
+        },
       })
       expect(workerNode.usage.tasks.executed).toBeGreaterThanOrEqual(0)
       expect(workerNode.usage.tasks.executed).toBeLessThanOrEqual(
         max * maxMultiplier
       )
+      if (workerNode.usage.runTime.aggregate == null) {
+        expect(workerNode.usage.runTime.aggregate).toBeUndefined()
+      } else {
+        expect(workerNode.usage.runTime.aggregate).toBeGreaterThan(0)
+      }
+      if (workerNode.usage.runTime.average == null) {
+        expect(workerNode.usage.runTime.average).toBeUndefined()
+      } else {
+        expect(workerNode.usage.runTime.average).toBeGreaterThan(0)
+      }
+      if (workerNode.usage.waitTime.aggregate == null) {
+        expect(workerNode.usage.waitTime.aggregate).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.aggregate).toBeGreaterThan(0)
+      }
+      if (workerNode.usage.waitTime.average == null) {
+        expect(workerNode.usage.waitTime.average).toBeUndefined()
+      } else {
+        expect(workerNode.usage.waitTime.average).toBeGreaterThan(0)
+      }
     }
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).defaultWorkerWeight
-    ).toBeGreaterThan(0)
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).roundId
     ).toBe(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).workerNodeId
     ).toBe(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
     ).toBe(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
-    ).toEqual(expect.any(Number))
+    ).toEqual(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).roundWeights
-    ).toStrictEqual([
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).defaultWorkerWeight
-    ])
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+      ).roundWeights.length
+    ).toBe(1)
+    expect(
+      Number.isSafeInteger(
+        pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+          pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+        ).roundWeights[0]
+      )
+    ).toBe(true)
     // We need to clean up the resources after our test
     await pool.destroy()
   })
 
-  it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
+  it("Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy internals aren't reset after setting it", async () => {
     const workerChoiceStrategy =
       WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN
     let pool = new FixedThreadPool(
       max,
-      './tests/worker-files/thread/testWorker.js'
+      './tests/worker-files/thread/testWorker.mjs',
+      { workerChoiceStrategy }
     )
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).roundId
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).workerNodeId
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).nextWorkerNodeKey
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).previousWorkerNodeKey
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).defaultWorkerWeight
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).roundWeights
-    ).toBeDefined()
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).roundId = randomInt(1, max - 1)
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).workerNodeId = randomInt(1, max - 1)
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).nextWorkerNodeKey = randomInt(1, max - 1)
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).previousWorkerNodeKey = randomInt(1, max - 1)
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).roundWeights = [randomInt(1, max - 1), randomInt(1, max - 1)]
     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).roundId
-    ).toBe(0)
+    ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).workerNodeId
-    ).toBe(0)
+    ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
-    ).toBe(0)
+    ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
-    ).toBe(0)
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).defaultWorkerWeight
     ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).roundWeights
-    ).toStrictEqual([
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).defaultWorkerWeight
-    ])
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+      ).roundWeights.length
+    ).toBeGreaterThan(1)
+    expect(
+      Number.isSafeInteger(
+        pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+          pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+        ).roundWeights[0]
+      )
+    ).toBe(true)
     await pool.destroy()
     pool = new DynamicThreadPool(
       min,
       max,
-      './tests/worker-files/thread/testWorker.js'
+      './tests/worker-files/thread/testWorker.mjs',
+      { workerChoiceStrategy }
     )
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).roundId
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).workerNodeId
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).nextWorkerNodeKey
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).previousWorkerNodeKey
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).defaultWorkerWeight
-    ).toBeDefined()
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        workerChoiceStrategy
-      ).roundWeights
-    ).toBeDefined()
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).roundId = randomInt(1, max - 1)
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).workerNodeId = randomInt(1, max - 1)
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).nextWorkerNodeKey = randomInt(1, max - 1)
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).previousWorkerNodeKey = randomInt(1, max - 1)
+    pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+      workerChoiceStrategy
+    ).roundWeights = [randomInt(1, max - 1), randomInt(1, max - 1)]
     pool.setWorkerChoiceStrategy(workerChoiceStrategy)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).roundId
-    ).toBe(0)
+    ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).workerNodeId
-    ).toBe(0)
+    ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).nextWorkerNodeKey
-    ).toBe(0)
+    ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).previousWorkerNodeKey
-    ).toBe(0)
-    expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).defaultWorkerWeight
     ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).roundWeights
-    ).toStrictEqual([
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
-      ).defaultWorkerWeight
-    ])
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+      ).roundWeights.length
+    ).toBeGreaterThan(1)
+    expect(
+      Number.isSafeInteger(
+        pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+          pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+        ).roundWeights[0]
+      )
+    ).toBe(true)
     // We need to clean up the resources after our test
     await pool.destroy()
   })
@@ -2297,9 +2300,9 @@ describe('Selection strategies test suite', () => {
         new DynamicThreadPool(
           min,
           max,
-          './tests/worker-files/thread/testWorker.js',
+          './tests/worker-files/thread/testWorker.mjs',
           { workerChoiceStrategy: 'UNKNOWN_STRATEGY' }
         )
-    ).toThrowError("Invalid worker choice strategy 'UNKNOWN_STRATEGY'")
+    ).toThrow("Invalid worker choice strategy 'UNKNOWN_STRATEGY'")
   })
 })