repositories / poolifier.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
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 bbfeb30df3b651c8981df0975566f04d25c0fef2..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
@@ -35,6 +38,9 @@ describe('Selection strategies test suite', () => {
     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()
   })
@@ -47,9 +53,9 @@ describe('Selection strategies test suite', () => {
         { workerChoiceStrategy }
       )
       expect(pool.opts.workerChoiceStrategy).toBe(workerChoiceStrategy)
-      expect(pool.workerChoiceStrategyContext.workerChoiceStrategy).toBe(
-        workerChoiceStrategy
-      )
+      expect(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+      ).toBe(workerChoiceStrategy)
       await pool.destroy()
     }
   })
@@ -63,65 +69,40 @@ describe('Selection strategies test suite', () => {
       )
       pool.setWorkerChoiceStrategy(workerChoiceStrategy)
       expect(pool.opts.workerChoiceStrategy).toBe(workerChoiceStrategy)
-      expect(pool.workerChoiceStrategyContext.workerChoiceStrategy).toBe(
-        workerChoiceStrategy
-      )
-      expect(pool.opts.workerChoiceStrategyOptions).toBeUndefined()
-      expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
-        retries:
-          pool.info.maxSize +
-          Object.keys(pool.workerChoiceStrategyContext.opts.weights).length,
-        runTime: { median: false },
-        waitTime: { median: false },
-        elu: { median: false },
-        weights: expect.objectContaining({
-          0: expect.any(Number),
-          [pool.info.maxSize - 1]: expect.any(Number)
-        })
-      })
+      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)
       expect(pool.opts.workerChoiceStrategy).toBe(workerChoiceStrategy)
-      expect(pool.workerChoiceStrategyContext.workerChoiceStrategy).toBe(
-        workerChoiceStrategy
-      )
-      expect(pool.opts.workerChoiceStrategyOptions).toBeUndefined()
-      expect(pool.workerChoiceStrategyContext.opts).toStrictEqual({
-        retries:
-          pool.info.maxSize +
-          Object.keys(pool.workerChoiceStrategyContext.opts.weights).length,
-        runTime: { median: false },
-        waitTime: { median: false },
-        elu: { median: false },
-        weights: expect.objectContaining({
-          0: expect.any(Number),
-          [pool.info.maxSize - 1]: expect.any(Number)
-        })
-      })
+      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.mjs'
-    )
     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)
@@ -129,56 +110,44 @@ describe('Selection strategies test suite', () => {
         workerChoiceStrategy === WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN
       ) {
         expect(
-          pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+          pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
             workerChoiceStrategy
-          ).workerNodeVirtualTaskRunTime
+          ).workerNodeVirtualTaskExecutionTime
         ).toBe(0)
       } else if (
         workerChoiceStrategy ===
         WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN
       ) {
         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(
+          pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
             workerChoiceStrategy
           ).roundWeights.length
         ).toBe(1)
+        expect(
+          Number.isSafeInteger(
+            pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+              workerChoiceStrategy
+            ).roundWeights[0]
+          )
+        ).toBe(true)
       }
+      await pool.destroy()
     }
-    await pool.destroy()
-  })
-
-  it('Verify strategies wait for worker node readiness in dynamic pool', async () => {
-    const pool = new DynamicThreadPool(
-      min,
-      max,
-      './tests/worker-files/thread/testWorker.mjs'
-    )
-    expect(pool.starting).toBe(false)
-    expect(pool.workerNodes.length).toBe(min)
-    const maxMultiplier = 10000
-    const promises = new Set()
-    for (let i = 0; i < max * maxMultiplier; i++) {
-      promises.add(pool.execute())
-    }
-    await Promise.all(promises)
-    expect(pool.workerNodes.length).toBe(max)
-    // We need to clean up the resources after our test
-    await pool.destroy()
   })
 
   it('Verify ROUND_ROBIN strategy default policy', async () => {
@@ -188,9 +157,9 @@ describe('Selection strategies test suite', () => {
       './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(
@@ -199,9 +168,9 @@ describe('Selection strategies test suite', () => {
       './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()
@@ -215,23 +184,23 @@ describe('Selection strategies test suite', () => {
       { 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(
@@ -241,23 +210,23 @@ describe('Selection strategies test suite', () => {
       { 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()
@@ -286,32 +255,32 @@ describe('Selection strategies test suite', () => {
           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
@@ -342,22 +311,22 @@ describe('Selection strategies test suite', () => {
           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(
@@ -365,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
@@ -382,7 +351,7 @@ 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()
@@ -404,62 +373,54 @@ describe('Selection strategies test suite', () => {
     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.mjs',
-      { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
+      { 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.mjs',
-      { workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
+      { 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()
   })
@@ -471,9 +432,9 @@ describe('Selection strategies test suite', () => {
       './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(
@@ -482,9 +443,9 @@ describe('Selection strategies test suite', () => {
       './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()
@@ -498,23 +459,23 @@ describe('Selection strategies test suite', () => {
       { 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(
@@ -524,23 +485,23 @@ describe('Selection strategies test suite', () => {
       { 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()
@@ -568,22 +529,22 @@ describe('Selection strategies test suite', () => {
           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(
@@ -591,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
@@ -627,22 +588,22 @@ describe('Selection strategies test suite', () => {
           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(
@@ -650,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
@@ -670,9 +631,9 @@ describe('Selection strategies test suite', () => {
       './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(
@@ -681,9 +642,9 @@ describe('Selection strategies test suite', () => {
       './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()
@@ -697,23 +658,23 @@ describe('Selection strategies test suite', () => {
       { 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(
@@ -723,23 +684,23 @@ describe('Selection strategies test suite', () => {
       { 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()
@@ -767,22 +728,22 @@ describe('Selection strategies test suite', () => {
           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(
@@ -800,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
@@ -836,22 +797,22 @@ describe('Selection strategies test suite', () => {
           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(
@@ -869,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
@@ -889,9 +850,9 @@ describe('Selection strategies test suite', () => {
       './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(
@@ -900,9 +861,9 @@ describe('Selection strategies test suite', () => {
       './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()
@@ -916,23 +877,23 @@ describe('Selection strategies test suite', () => {
       { 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(
@@ -942,23 +903,23 @@ describe('Selection strategies test suite', () => {
       { 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()
@@ -986,22 +947,22 @@ describe('Selection strategies test suite', () => {
           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(
@@ -1025,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
@@ -1061,22 +1022,22 @@ describe('Selection strategies test suite', () => {
           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(
@@ -1100,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
@@ -1120,9 +1081,9 @@ describe('Selection strategies test suite', () => {
       './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(
@@ -1131,9 +1092,9 @@ describe('Selection strategies test suite', () => {
       './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()
@@ -1147,23 +1108,23 @@ describe('Selection strategies test suite', () => {
       { 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(
@@ -1173,23 +1134,23 @@ describe('Selection strategies test suite', () => {
       { 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()
@@ -1217,22 +1178,22 @@ describe('Selection strategies test suite', () => {
           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(
@@ -1248,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 {
@@ -1267,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
@@ -1303,22 +1274,22 @@ describe('Selection strategies test suite', () => {
           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(
@@ -1334,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 {
@@ -1353,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
@@ -1374,8 +1355,8 @@ describe('Selection strategies test suite', () => {
       {
         workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE,
         workerChoiceStrategyOptions: {
-          runTime: { median: true }
-        }
+          runTime: { median: true },
+        },
       }
     )
     // TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
@@ -1394,22 +1375,22 @@ describe('Selection strategies test suite', () => {
           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(
@@ -1425,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 {
@@ -1444,20 +1435,20 @@ 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,
@@ -1465,12 +1456,12 @@ describe('Selection strategies test suite', () => {
     )
     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(
@@ -1480,12 +1471,12 @@ describe('Selection strategies test suite', () => {
     )
     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()
@@ -1498,9 +1489,9 @@ describe('Selection strategies test suite', () => {
       './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(
@@ -1509,9 +1500,9 @@ describe('Selection strategies test suite', () => {
       './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()
@@ -1525,23 +1516,23 @@ describe('Selection strategies test suite', () => {
       { 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(
@@ -1551,23 +1542,23 @@ describe('Selection strategies test suite', () => {
       { 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()
@@ -1595,22 +1586,22 @@ describe('Selection strategies test suite', () => {
           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(
@@ -1626,21 +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
-    ).toEqual(expect.any(Number))
+    ).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()
@@ -1669,22 +1670,22 @@ describe('Selection strategies test suite', () => {
           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(
@@ -1700,21 +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
-    ).toEqual(expect.any(Number))
+    ).toEqual(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
-      ).workerNodeVirtualTaskRunTime
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
+      ).workerNodeVirtualTaskExecutionTime
     ).toBeGreaterThanOrEqual(0)
     // We need to clean up the resources after our test
     await pool.destroy()
@@ -1728,8 +1739,8 @@ describe('Selection strategies test suite', () => {
       {
         workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN,
         workerChoiceStrategyOptions: {
-          runTime: { median: true }
-        }
+          runTime: { median: true },
+        },
       }
     )
     // TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
@@ -1748,22 +1759,22 @@ describe('Selection strategies test suite', () => {
           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(
@@ -1779,100 +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
-    ).toEqual(expect.any(Number))
+    ).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
-      ).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.mjs'
+      './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
-      ).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)
+    ).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.mjs'
+      './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
-      ).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)
+    ).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()
   })
@@ -1885,9 +1896,9 @@ describe('Selection strategies test suite', () => {
       './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(
@@ -1896,9 +1907,9 @@ describe('Selection strategies test suite', () => {
       './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()
@@ -1913,23 +1924,23 @@ describe('Selection strategies test suite', () => {
       { 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(
@@ -1939,23 +1950,23 @@ describe('Selection strategies test suite', () => {
       { 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()
@@ -1967,7 +1978,7 @@ describe('Selection strategies test suite', () => {
       './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`
@@ -1986,53 +1997,80 @@ describe('Selection strategies test suite', () => {
           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
+      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
+      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()
   })
@@ -2044,7 +2082,7 @@ describe('Selection strategies test suite', () => {
       './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`
@@ -2063,172 +2101,195 @@ describe('Selection strategies test suite', () => {
           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
+      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
+      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.mjs'
+      './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
-      ).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)
+    ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).roundWeights.length
-    ).toBe(1)
+    ).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.mjs'
+      './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
-      ).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)
+    ).toBeGreaterThan(0)
     expect(
-      pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
-        pool.workerChoiceStrategyContext.workerChoiceStrategy
+      pool.workerChoiceStrategiesContext.workerChoiceStrategies.get(
+        pool.workerChoiceStrategiesContext.defaultWorkerChoiceStrategy
       ).roundWeights.length
-    ).toBe(1)
+    ).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()
   })
Fast and small Node.js thread pool implementation mirror - https://github.com/poolifier/poolifier