@daiso-tech/core 0.49.1 → 0.50.0

package/dist/semaphore/implementations/test-utilities/{semaphore-provider.test-suite.js → semaphore-factory.test-suite.js}

@@ -5,11 +5,12 @@ import { vi, } from "vitest";
 import { LimitReachedSemaphoreError, SEMAPHORE_EVENTS, FailedReleaseSemaphoreError, FailedRefreshSemaphoreError, SEMAPHORE_STATE, } from "../../../semaphore/contracts/_module.js";
 import {} from "../../../serde/contracts/_module.js";
 import { Task } from "../../../task/implementations/_module.js";
-import { TO_MILLISECONDS } from "../../../time-span/contracts/_module.js";
+import { createIsTimeSpanEqualityTester } from "../../../test-utilities/_module.js";
+import { TO_MILLISECONDS, } from "../../../time-span/contracts/_module.js";
 import { TimeSpan } from "../../../time-span/implementations/_module.js";
 import {} from "../../../utilities/_module.js";
 /**
- * The `semaphoreProviderTestSuite` function simplifies the process of testing your custom implementation of {@link ISemaphore | `ISemaphore`} with `vitest`.
+ * The `semaphoreFactoryTestSuite` function simplifies the process of testing your custom implementation of {@link ISemaphore | `ISemaphore`} with `vitest`.
  *
  * IMPORT_PATH: `"@daiso-tech/core/semaphore/test-utilities"`
  * @group Utilities
@@ -17,23 +18,23 @@ import {} from "../../../utilities/_module.js";
  * ```ts
  * import { describe, expect, test, beforeEach } from "vitest";
  * import { MemorySemaphoreAdapter } from "@daiso-tech/core/semaphore/memory-semaphore-adapter";
- * import { SemaphoreProvider } from "@daiso-tech/core/semaphore";
+ * import { SemaphoreFactory } from "@daiso-tech/core/semaphore";
  * import { EventBus } from "@daiso-tech/core/event-bus";
  * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/memory-event-bus-adapter";
- * import { semaphoreProviderTestSuite } from "@daiso-tech/core/semaphore/test-utilities";
+ * import { semaphoreFactoryTestSuite } from "@daiso-tech/core/semaphore/test-utilities";
  * import { Serde } from "@daiso-tech/core/serde";
  * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/super-json-serde-adapter";
  * import type { ISemaphoreData } from "@daiso-tech/core/semaphore/contracts";
  *
- * describe("class: SemaphoreProvider", () => {
- *     semaphoreProviderTestSuite({
- *         createSemaphoreProvider: () => {
+ * describe("class: SemaphoreFactory", () => {
+ *     semaphoreFactoryTestSuite({
+ *         createSemaphoreFactory: () => {
  *             const serde = new Serde(new SuperJsonSerdeAdapter());
- *             const semaphoreProvider = new SemaphoreProvider({
+ *             const semaphoreFactory = new SemaphoreFactory({
  *                 serde,
  *                 adapter: new MemorySemaphoreAdapter(),
  *             });
- *             return { semaphoreProvider, serde };
+ *             return { semaphoreFactory, serde };
  *         },
  *         beforeEach,
  *         describe,
@@ -44,18 +45,18 @@ import {} from "../../../utilities/_module.js";
  * });
  * ```
  */
-export function semaphoreProviderTestSuite(settings) {
-    const { expect, test, createSemaphoreProvider, describe, beforeEach, includeEventTests = true, includeSerdeTests = true, } = settings;
-    let semaphoreProvider;
+export function semaphoreFactoryTestSuite(settings) {
+    const { expect, test, createSemaphoreFactory, describe, beforeEach, includeEventTests = true, includeSerdeTests = true, retry = 0, delayBuffer = TimeSpan.fromMilliseconds(10), timeSpanEqualityBuffer = TimeSpan.fromMilliseconds(10), } = settings;
+    let semaphoreFactory;
     let serde;
     async function delay(time) {
-        await Task.delay(time.addMilliseconds(10));
+        await Task.delay(TimeSpan.fromTimeSpan(time).addTimeSpan(delayBuffer));
     }
     const RETURN_VALUE = "RETURN_VALUE";
-    describe("ISemaphoreProvider tests:", () => {
+    describe("ISemaphoreFactory tests:", () => {
         beforeEach(async () => {
-            const { semaphoreProvider: semaphoreProvider_, serde: serde_ } = await createSemaphoreProvider();
-            semaphoreProvider = semaphoreProvider_;
+            const { semaphoreFactory: semaphoreFactory_, serde: serde_ } = await createSemaphoreFactory();
+            semaphoreFactory = semaphoreFactory_;
             serde = serde_;
         });
         describe("Api tests:", () => {
@@ -64,7 +65,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -78,7 +79,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -93,7 +94,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -107,7 +108,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -122,7 +123,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -141,7 +142,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -159,7 +160,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -171,7 +172,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -181,7 +182,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -193,7 +194,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -213,7 +214,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -233,7 +234,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -243,7 +244,7 @@ export function semaphoreProviderTestSuite(settings) {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     try {
-                        await semaphoreProvider
+                        await semaphoreFactory
                             .create(key, {
                             ttl,
                             limit,
@@ -259,7 +260,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -269,7 +270,7 @@ export function semaphoreProviderTestSuite(settings) {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     try {
-                        await semaphoreProvider
+                        await semaphoreFactory
                             .create(key, {
                             ttl,
                             limit,
@@ -285,7 +286,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const result = await semaphoreProvider
+                    const result = await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -299,14 +300,14 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
                     })
                         .acquire();
                     await delay(ttl);
-                    const result = await semaphoreProvider
+                    const result = await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -320,12 +321,12 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const lock = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
-                    await lock.acquire();
-                    const result = lock.runOrFail(() => {
+                    await semaphore.acquire();
+                    const result = semaphore.runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     await expect(result).rejects.toBeInstanceOf(LimitReachedSemaphoreError);
@@ -334,12 +335,12 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    const lock = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
-                    await lock.acquire();
-                    const result = lock.runOrFail(() => {
+                    await semaphore.acquire();
+                    const result = semaphore.runOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     await expect(result).rejects.toBeInstanceOf(LimitReachedSemaphoreError);
@@ -348,13 +349,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
                     })
                         .acquire();
-                    const result = semaphoreProvider
+                    const result = semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -368,13 +369,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
                     })
                         .acquire();
-                    const result = semaphoreProvider
+                    const result = semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -390,7 +391,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -407,7 +408,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -425,7 +426,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -442,7 +443,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -460,7 +461,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -482,7 +483,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -503,7 +504,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -518,7 +519,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -528,7 +529,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const handlerFn = vi.fn(() => {
                         return Promise.resolve(RETURN_VALUE);
                     });
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -543,7 +544,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -566,7 +567,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -589,7 +590,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -599,7 +600,7 @@ export function semaphoreProviderTestSuite(settings) {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     try {
-                        await semaphoreProvider
+                        await semaphoreFactory
                             .create(key, {
                             ttl,
                             limit,
@@ -618,7 +619,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -628,7 +629,7 @@ export function semaphoreProviderTestSuite(settings) {
                         return Promise.resolve(RETURN_VALUE);
                     });
                     try {
-                        await semaphoreProvider
+                        await semaphoreFactory
                             .create(key, {
                             ttl,
                             limit,
@@ -647,7 +648,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const result = await semaphoreProvider
+                    const result = await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -664,14 +665,14 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
                     })
                         .acquire();
                     await delay(ttl);
-                    const result = await semaphoreProvider
+                    const result = await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -688,12 +689,12 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    const lock = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
-                    await lock.acquire();
-                    const result = lock.runBlockingOrFail(() => {
+                    await semaphore.acquire();
+                    const result = semaphore.runBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     }, {
                         time: TimeSpan.fromMilliseconds(5),
@@ -705,12 +706,12 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    const lock = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
-                    await lock.acquire();
-                    const result = lock.runBlockingOrFail(() => {
+                    await semaphore.acquire();
+                    const result = semaphore.runBlockingOrFail(() => {
                         return Promise.resolve(RETURN_VALUE);
                     }, {
                         time: TimeSpan.fromMilliseconds(5),
@@ -722,13 +723,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 1;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
                     })
                         .acquire();
-                    const result = semaphoreProvider
+                    const result = semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -745,13 +746,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
                     })
                         .acquire();
-                    const result = semaphoreProvider
+                    const result = semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -764,25 +765,25 @@ export function semaphoreProviderTestSuite(settings) {
                     });
                     await expect(result).rejects.toBeInstanceOf(LimitReachedSemaphoreError);
                 });
-                test("Should retry acquire the lock", async () => {
+                test("Should retry acquire the semaphore", { retry }, async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    const lock1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
-                    await lock1.acquire();
+                    await semaphore1.acquire();
                     let index = 0;
-                    await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, (_event) => {
+                    await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, (_event) => {
                         index++;
                     });
-                    const lock2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
                     try {
-                        await lock2.runBlockingOrFail(() => {
+                        await semaphore2.runBlockingOrFail(() => {
                             return Promise.resolve(RETURN_VALUE);
                         }, {
                             time: TimeSpan.fromMilliseconds(55),
@@ -800,7 +801,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const result = await semaphoreProvider
+                    const result = await semaphoreFactory
                         .create(key, {
                         limit,
                         ttl,
@@ -812,7 +813,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -825,12 +826,12 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -841,17 +842,17 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore2.acquire();
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -862,20 +863,20 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl: ttl1,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl: ttl2,
                     });
                     await semaphore2.acquire();
                     await delay(ttl2);
                     const ttl3 = null;
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         ttl: ttl3,
                         limit,
                     });
@@ -886,7 +887,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -898,7 +899,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -910,13 +911,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -927,13 +928,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -944,24 +945,24 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     const newLimit = 3;
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit: newLimit,
                         ttl,
                     });
                     await semaphore2.acquire();
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         limit: newLimit,
                         ttl,
                     });
                     const result1 = await semaphore3.acquire();
                     expect(result1).toBe(false);
-                    const state = await semaphore3.getState();
+                    const state = (await semaphore3.getState());
                     expect(state.limit).toBe(limit);
                 });
             });
@@ -970,7 +971,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const result = semaphoreProvider
+                    const result = semaphoreFactory
                         .create(key, {
                         limit,
                         ttl,
@@ -982,7 +983,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -995,12 +996,12 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1011,17 +1012,17 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore2.acquire();
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1032,20 +1033,20 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl: ttl1,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl: ttl2,
                     });
                     await semaphore2.acquire();
                     await delay(ttl2);
                     const ttl3 = null;
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         ttl: ttl3,
                         limit,
                     });
@@ -1056,7 +1057,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1068,7 +1069,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1080,13 +1081,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1097,13 +1098,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1114,24 +1115,24 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     const newLimit = 3;
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit: newLimit,
                         ttl,
                     });
                     await semaphore2.acquire();
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         limit: newLimit,
                         ttl,
                     });
                     const result1 = semaphore3.acquireOrFail();
                     await expect(result1).rejects.toBeInstanceOf(LimitReachedSemaphoreError);
-                    const state = await semaphore3.getState();
+                    const state = (await semaphore3.getState());
                     expect(state.limit).toBe(limit);
                 });
             });
@@ -1140,7 +1141,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const result = await semaphoreProvider
+                    const result = await semaphoreFactory
                         .create(key, {
                         limit,
                         ttl,
@@ -1155,7 +1156,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1171,12 +1172,12 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1190,17 +1191,17 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore2.acquire();
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1214,20 +1215,20 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl: ttl1,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl: ttl2,
                     });
                     await semaphore2.acquire();
                     await delay(ttl2);
                     const ttl3 = null;
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         ttl: ttl3,
                         limit,
                     });
@@ -1241,7 +1242,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1256,7 +1257,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1271,13 +1272,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1291,13 +1292,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1311,18 +1312,18 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     const newLimit = 3;
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit: newLimit,
                         ttl,
                     });
                     await semaphore2.acquire();
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         limit: newLimit,
                         ttl,
                     });
@@ -1331,23 +1332,23 @@ export function semaphoreProviderTestSuite(settings) {
                         interval: TimeSpan.fromMilliseconds(5),
                     });
                     expect(result1).toBe(false);
-                    const state = await semaphore3.getState();
+                    const state = (await semaphore3.getState());
                     expect(state.limit).toBe(limit);
                 });
-                test("Should retry acquire the semaphore", async () => {
+                test("Should retry acquire the semaphore", { retry }, async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
                     await semaphore1.acquire();
                     let index = 0;
-                    await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, (_event) => {
+                    await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, (_event) => {
                         index++;
                     });
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1363,7 +1364,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const result = semaphoreProvider
+                    const result = semaphoreFactory
                         .create(key, {
                         limit,
                         ttl,
@@ -1378,7 +1379,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1394,12 +1395,12 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1413,17 +1414,17 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore2.acquire();
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1437,20 +1438,20 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl: ttl1,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl: ttl2,
                     });
                     await semaphore2.acquire();
                     await delay(ttl2);
                     const ttl3 = null;
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         ttl: ttl3,
                         limit,
                     });
@@ -1464,7 +1465,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1479,7 +1480,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1494,13 +1495,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1514,13 +1515,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1534,18 +1535,18 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     const newLimit = 3;
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit: newLimit,
                         ttl,
                     });
                     await semaphore2.acquire();
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         limit: newLimit,
                         ttl,
                     });
@@ -1554,23 +1555,23 @@ export function semaphoreProviderTestSuite(settings) {
                         interval: TimeSpan.fromMilliseconds(5),
                     });
                     await expect(result1).rejects.toBeInstanceOf(LimitReachedSemaphoreError);
-                    const state = await semaphore3.getState();
+                    const state = (await semaphore3.getState());
                     expect(state.limit).toBe(limit);
                 });
-                test("Should retry acquire the semaphore", async () => {
+                test("Should retry acquire the semaphore", { retry }, async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 1;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
                     await semaphore1.acquire();
                     let index = 0;
-                    await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, (_event) => {
+                    await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, (_event) => {
                         index++;
                     });
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1591,14 +1592,14 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         limit,
                         ttl,
                     })
                         .acquire();
                     const noneExistingKey = "c";
-                    const result = await semaphoreProvider
+                    const result = await semaphoreFactory
                         .create(noneExistingKey, {
                         limit,
                         ttl,
@@ -1610,14 +1611,14 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         limit,
                         ttl,
                     })
                         .acquire();
                     const noneExistingSlotId = "1";
-                    const result = await semaphoreProvider
+                    const result = await semaphoreFactory
                         .create(key, {
                         limit,
                         ttl,
@@ -1630,25 +1631,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 2;
-                    const semaphore1 = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await semaphore1.acquire();
-                    await delay(ttl);
-                    const result = await semaphoreProvider
-                        .create(key, {
-                        ttl,
-                        limit,
-                    })
-                        .release();
-                    expect(result).toBe(false);
-                });
-                test("Should return false when slot exists, is expired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1657,11 +1640,11 @@ export function semaphoreProviderTestSuite(settings) {
                     const result = await semaphore.release();
                     expect(result).toBe(false);
                 });
-                test("Should return true when slot exists, is unexpired", async () => {
+                test("Should return true when slot exists and is unexpired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1669,11 +1652,11 @@ export function semaphoreProviderTestSuite(settings) {
                     const result = await semaphore.release();
                     expect(result).toBe(true);
                 });
-                test("Should return true when slot exists, is unexpireable", async () => {
+                test("Should return true when slot exists and is unexpireable", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1685,12 +1668,12 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1698,25 +1681,25 @@ export function semaphoreProviderTestSuite(settings) {
                     await semaphore1.release();
                     await semaphore2.release();
                     const newLimit = 3;
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         ttl,
                         limit: newLimit,
                     });
                     await semaphore3.acquire();
-                    const semaphore4 = semaphoreProvider.create(key, {
+                    const semaphore4 = semaphoreFactory.create(key, {
                         ttl,
                         limit: newLimit,
                     });
                     await semaphore4.acquire();
-                    const semaphore5 = semaphoreProvider.create(key, {
+                    const semaphore5 = semaphoreFactory.create(key, {
                         ttl,
                         limit: newLimit,
                     });
                     const result1 = await semaphore5.acquire();
                     expect(result1).toBe(true);
-                    const state = await semaphore5.getState();
+                    const state = (await semaphore5.getState());
                     expect(state.limit).toBe(newLimit);
-                    const semaphore6 = semaphoreProvider.create(key, {
+                    const semaphore6 = semaphoreFactory.create(key, {
                         ttl,
                         limit: newLimit,
                     });
@@ -1727,25 +1710,25 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
                     await semaphore2.acquire();
                     await semaphore1.release();
                     await semaphore2.release();
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
                     const result1 = await semaphore3.acquire();
                     expect(result1).toBe(true);
-                    const semaphore4 = semaphoreProvider.create(key, {
+                    const semaphore4 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1758,14 +1741,14 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         limit,
                         ttl,
                     })
                         .acquire();
                     const noneExistingKey = "c";
-                    const result = semaphoreProvider
+                    const result = semaphoreFactory
                         .create(noneExistingKey, {
                         limit,
                         ttl,
@@ -1777,14 +1760,14 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    await semaphoreProvider
+                    await semaphoreFactory
                         .create(key, {
                         limit,
                         ttl,
                     })
                         .acquire();
                     const noneExistingSlotId = "1";
-                    const result = semaphoreProvider
+                    const result = semaphoreFactory
                         .create(key, {
                         limit,
                         ttl,
@@ -1797,13 +1780,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 2;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
                     await semaphore1.acquire();
                     await delay(ttl);
-                    const result = semaphoreProvider
+                    const result = semaphoreFactory
                         .create(key, {
                         ttl,
                         limit,
@@ -1815,7 +1798,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1824,11 +1807,11 @@ export function semaphoreProviderTestSuite(settings) {
                     const result = semaphore.releaseOrFail();
                     await expect(result).rejects.toBeInstanceOf(FailedReleaseSemaphoreError);
                 });
-                test("Should not throw error when slot exists, is unexpired", async () => {
+                test("Should not throw error when slot exists and is unexpired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1836,11 +1819,11 @@ export function semaphoreProviderTestSuite(settings) {
                     const result = semaphore.releaseOrFail();
                     await expect(result).resolves.toBeUndefined();
                 });
-                test("Should not throw error when slot exists, is unexpireable", async () => {
+                test("Should not throw error when slot exists and is unexpireable", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1852,12 +1835,12 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1865,25 +1848,25 @@ export function semaphoreProviderTestSuite(settings) {
                     await semaphore1.release();
                     await semaphore2.releaseOrFail();
                     const newLimit = 3;
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         ttl,
                         limit: newLimit,
                     });
                     await semaphore3.acquire();
-                    const semaphore4 = semaphoreProvider.create(key, {
+                    const semaphore4 = semaphoreFactory.create(key, {
                         ttl,
                         limit: newLimit,
                     });
                     await semaphore4.acquire();
-                    const semaphore5 = semaphoreProvider.create(key, {
+                    const semaphore5 = semaphoreFactory.create(key, {
                         ttl,
                         limit: newLimit,
                     });
                     const result1 = await semaphore5.acquire();
                     expect(result1).toBe(true);
-                    const state = await semaphore5.getState();
+                    const state = (await semaphore5.getState());
                     expect(state.limit).toBe(newLimit);
-                    const semaphore6 = semaphoreProvider.create(key, {
+                    const semaphore6 = semaphoreFactory.create(key, {
                         ttl,
                         limit: newLimit,
                     });
@@ -1894,25 +1877,25 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
                     await semaphore2.acquire();
                     await semaphore1.release();
                     await semaphore2.releaseOrFail();
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
                     const result1 = await semaphore3.acquire();
                     expect(result1).toBe(true);
-                    const semaphore4 = semaphoreProvider.create(key, {
+                    const semaphore4 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -1925,13 +1908,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     const noneExistingKey = "c";
-                    const semaphore2 = semaphoreProvider.create(noneExistingKey, {
+                    const semaphore2 = semaphoreFactory.create(noneExistingKey, {
                         limit,
                         ttl,
                     });
@@ -1942,7 +1925,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1955,12 +1938,12 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 2;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1974,7 +1957,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = null;
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -1986,27 +1969,27 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl: ttl1,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl: ttl2,
                     });
                     await semaphore2.acquire();
                     await semaphore2.forceReleaseAll();
                     const ttl3 = null;
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         ttl: ttl3,
                         limit,
                     });
                     const result1 = await semaphore3.acquire();
                     expect(result1).toBe(true);
                     const ttl4 = null;
-                    const semaphore4 = semaphoreProvider.create(key, {
+                    const semaphore4 = semaphoreFactory.create(key, {
                         ttl: ttl4,
                         limit,
                     });
@@ -2017,37 +2000,37 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
                     await semaphore1.acquire();
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
                     await semaphore2.acquire();
                     await semaphore1.forceReleaseAll();
                     const newLimit = 3;
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         ttl,
                         limit: newLimit,
                     });
                     await semaphore3.acquire();
-                    const semaphore4 = semaphoreProvider.create(key, {
+                    const semaphore4 = semaphoreFactory.create(key, {
                         ttl,
                         limit: newLimit,
                     });
                     await semaphore4.acquire();
-                    const semaphore5 = semaphoreProvider.create(key, {
+                    const semaphore5 = semaphoreFactory.create(key, {
                         ttl,
                         limit: newLimit,
                     });
                     const result1 = await semaphore5.acquire();
                     expect(result1).toBe(true);
-                    const state = await semaphore5.getState();
+                    const state = (await semaphore5.getState());
                     expect(state.limit).toBe(newLimit);
-                    const semaphore6 = semaphoreProvider.create(key, {
+                    const semaphore6 = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -2060,14 +2043,14 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     const newTtl = TimeSpan.fromMilliseconds(100);
                     const noneExistingKey = "c";
-                    const semaphore2 = semaphoreProvider.create(noneExistingKey, {
+                    const semaphore2 = semaphoreFactory.create(noneExistingKey, {
                         ttl: newTtl,
                         limit,
                     });
@@ -2078,14 +2061,14 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     const newTtl = TimeSpan.fromMilliseconds(100);
                     const noneExistingSlotId = "1";
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: newTtl,
                         limit,
                         slotId: noneExistingSlotId,
@@ -2097,7 +2080,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -2107,25 +2090,11 @@ export function semaphoreProviderTestSuite(settings) {
                     const result = await semaphore.refresh(newTtl);
                     expect(result).toBe(false);
                 });
-                test("Should return false when slot exists, is expired", async () => {
-                    const key = "a";
-                    const ttl = TimeSpan.fromMilliseconds(50);
-                    const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
-                        ttl,
-                        limit,
-                    });
-                    await semaphore.acquire();
-                    await delay(ttl);
-                    const newTtl = TimeSpan.fromMilliseconds(100);
-                    const result = await semaphore.refresh(newTtl);
-                    expect(result).toBe(false);
-                });
-                test("Should return false when slot exists, is unexpireable", async () => {
+                test("Should return false when slot exists and is unexpireable", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -2134,11 +2103,11 @@ export function semaphoreProviderTestSuite(settings) {
                     const result = await semaphore.refresh(newTtl);
                     expect(result).toBe(false);
                 });
-                test("Should return true when slot exists, is unexpired", async () => {
+                test("Should return true when slot exists and is unexpired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -2147,17 +2116,17 @@ export function semaphoreProviderTestSuite(settings) {
                     const result = await semaphore.refresh(newTtl);
                     expect(result).toBe(true);
                 });
-                test("Should not update expiration when slot exists, is unexpireable", async () => {
+                test("Should not update expiration when slot exists and is unexpireable", async () => {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl: ttl1,
                         limit,
                     });
                     await semaphore1.acquire();
                     const ttl2 = null;
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -2165,24 +2134,24 @@ export function semaphoreProviderTestSuite(settings) {
                     const newTtl = TimeSpan.fromMilliseconds(100);
                     await semaphore2.refresh(newTtl);
                     await delay(newTtl);
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
                     const result1 = await semaphore3.acquire();
                     expect(result1).toBe(false);
                 });
-                test("Should update expiration when slot exists, is unexpired", async () => {
+                test("Should update expiration when slot exists and is unexpired", async () => {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl: ttl1,
                         limit,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl: ttl2,
                     });
@@ -2190,7 +2159,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const newTtl = TimeSpan.fromMilliseconds(100);
                     await semaphore2.refresh(newTtl);
                     await delay(newTtl.divide(2));
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -2206,14 +2175,14 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     const newTtl = TimeSpan.fromMilliseconds(100);
                     const noneExistingKey = "c";
-                    const semaphore2 = semaphoreProvider.create(noneExistingKey, {
+                    const semaphore2 = semaphoreFactory.create(noneExistingKey, {
                         ttl: newTtl,
                         limit,
                     });
@@ -2224,14 +2193,14 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
                     await semaphore1.acquire();
                     const newTtl = TimeSpan.fromMilliseconds(100);
                     const noneExistingSlotId = "1";
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: newTtl,
                         limit,
                         slotId: noneExistingSlotId,
@@ -2243,7 +2212,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -2257,7 +2226,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -2267,11 +2236,11 @@ export function semaphoreProviderTestSuite(settings) {
                     const result = semaphore.refreshOrFail(newTtl);
                     await expect(result).rejects.toBeInstanceOf(FailedRefreshSemaphoreError);
                 });
-                test("Should throw FailedRefreshSemaphoreError when slot exists, is unexpireable", async () => {
+                test("Should throw FailedRefreshSemaphoreError when slot exists and is unexpireable", async () => {
                     const key = "a";
                     const ttl = null;
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -2280,11 +2249,11 @@ export function semaphoreProviderTestSuite(settings) {
                     const result = semaphore.refreshOrFail(newTtl);
                     await expect(result).rejects.toBeInstanceOf(FailedRefreshSemaphoreError);
                 });
-                test("Should not throw error when slot exists, is unexpired", async () => {
+                test("Should not throw error when slot exists and is unexpired", async () => {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -2293,17 +2262,17 @@ export function semaphoreProviderTestSuite(settings) {
                     const result = semaphore.refreshOrFail(newTtl);
                     await expect(result).resolves.toBeUndefined();
                 });
-                test("Should not update expiration when slot exists, is unexpireable", async () => {
+                test("Should not update expiration when slot exists and is unexpireable", async () => {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl: ttl1,
                         limit,
                     });
                     await semaphore1.acquire();
                     const ttl2 = null;
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -2316,24 +2285,24 @@ export function semaphoreProviderTestSuite(settings) {
                         /* EMPTY */
                     }
                     await delay(newTtl);
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
                     const result1 = await semaphore3.acquire();
                     expect(result1).toBe(false);
                 });
-                test("Should update expiration when slot exists, is unexpired", async () => {
+                test("Should update expiration when slot exists and is unexpired", async () => {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl: ttl1,
                         limit,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         limit,
                         ttl: ttl2,
                     });
@@ -2341,7 +2310,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const newTtl = TimeSpan.fromMilliseconds(100);
                     await semaphore2.refreshOrFail(newTtl);
                     await delay(newTtl.divide(2));
-                    const semaphore3 = semaphoreProvider.create(key, {
+                    const semaphore3 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -2357,7 +2326,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const slotId = "1";
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         slotId,
                         limit,
                     });
@@ -2366,7 +2335,7 @@ export function semaphoreProviderTestSuite(settings) {
                 test("Should return semaphore id of ISemaphore instance when given explicitly", () => {
                     const key = "a";
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                     });
                     expect(semaphore.id).toBeTypeOf("string");
@@ -2378,7 +2347,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = null;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -2388,7 +2357,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl = TimeSpan.fromMilliseconds(100);
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -2401,7 +2370,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 3;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -2414,7 +2383,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -2429,13 +2398,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl: ttl1,
                         limit,
                     });
                     await semaphore1.acquire();
                     const ttl2 = null;
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -2450,13 +2419,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl: ttl1,
                     });
                     await semaphore1.acquire();
                     const ttl2 = null;
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -2472,13 +2441,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 3;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl: ttl1,
                         limit,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -2495,13 +2464,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 3;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl: ttl1,
                         limit,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -2517,16 +2486,19 @@ export function semaphoreProviderTestSuite(settings) {
                     });
                 });
                 test("Should return ISemaphoreAcquiredState when slot is unexpired", async () => {
+                    expect.addEqualityTesters([
+                        createIsTimeSpanEqualityTester(timeSpanEqualityBuffer),
+                    ]);
                     const key = "a";
                     const limit = 3;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl: ttl1,
                         limit,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -2545,13 +2517,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 1;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl: ttl1,
                         limit,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -2573,8 +2545,8 @@ export function semaphoreProviderTestSuite(settings) {
                         const limit = 2;
                         const ttl = null;
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -2593,14 +2565,14 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = TimeSpan.fromMilliseconds(50);
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore.acquire();
                         await delay(ttl);
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
                         await semaphore.acquire();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2616,17 +2588,17 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore1.acquire();
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
                         await semaphore2.acquire();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2642,19 +2614,19 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore1.acquire();
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore2.acquire();
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, handlerFn);
-                        const semaphore3 = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, handlerFn);
+                        const semaphore3 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -2673,13 +2645,13 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl1 = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl: ttl1,
                         });
                         await semaphore1.acquire();
                         const ttl2 = TimeSpan.fromMilliseconds(50);
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             limit,
                             ttl: ttl2,
                         });
@@ -2687,8 +2659,8 @@ export function semaphoreProviderTestSuite(settings) {
                         await delay(ttl2);
                         const ttl3 = null;
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore3 = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore3 = semaphoreFactory.create(key, {
                             limit,
                             ttl: ttl3,
                         });
@@ -2708,8 +2680,8 @@ export function semaphoreProviderTestSuite(settings) {
                         const limit = 2;
                         const ttl = null;
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -2730,8 +2702,8 @@ export function semaphoreProviderTestSuite(settings) {
                         const limit = 2;
                         const ttl = TimeSpan.fromMilliseconds(50);
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -2754,8 +2726,8 @@ export function semaphoreProviderTestSuite(settings) {
                         const limit = 2;
                         const ttl = null;
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -2774,14 +2746,14 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = TimeSpan.fromMilliseconds(50);
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore.acquire();
                         await delay(ttl);
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
                         await semaphore.acquireOrFail();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2797,17 +2769,17 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore1.acquire();
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
                         await semaphore2.acquireOrFail();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -2823,19 +2795,19 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore1.acquire();
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore2.acquire();
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, handlerFn);
-                        const semaphore3 = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, handlerFn);
+                        const semaphore3 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -2859,13 +2831,13 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl1 = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl: ttl1,
                         });
                         await semaphore1.acquire();
                         const ttl2 = TimeSpan.fromMilliseconds(50);
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             limit,
                             ttl: ttl2,
                         });
@@ -2873,8 +2845,8 @@ export function semaphoreProviderTestSuite(settings) {
                         await delay(ttl2);
                         const ttl3 = null;
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore3 = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore3 = semaphoreFactory.create(key, {
                             limit,
                             ttl: ttl3,
                         });
@@ -2894,8 +2866,8 @@ export function semaphoreProviderTestSuite(settings) {
                         const limit = 2;
                         const ttl = null;
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -2916,8 +2888,8 @@ export function semaphoreProviderTestSuite(settings) {
                         const limit = 2;
                         const ttl = TimeSpan.fromMilliseconds(50);
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -2940,8 +2912,8 @@ export function semaphoreProviderTestSuite(settings) {
                         const limit = 2;
                         const ttl = null;
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -2963,14 +2935,14 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = TimeSpan.fromMilliseconds(50);
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore.acquire();
                         await delay(ttl);
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
                         await semaphore.acquireBlocking({
                             time: TimeSpan.fromMilliseconds(5),
                             interval: TimeSpan.fromMilliseconds(5),
@@ -2989,17 +2961,17 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore1.acquire();
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
                         await semaphore2.acquireBlocking({
                             time: TimeSpan.fromMilliseconds(5),
                             interval: TimeSpan.fromMilliseconds(5),
@@ -3018,19 +2990,19 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore1.acquire();
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore2.acquire();
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, handlerFn);
-                        const semaphore3 = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, handlerFn);
+                        const semaphore3 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -3038,7 +3010,8 @@ export function semaphoreProviderTestSuite(settings) {
                             time: TimeSpan.fromMilliseconds(5),
                             interval: TimeSpan.fromMilliseconds(5),
                         });
-                        expect(handlerFn).toHaveBeenCalledTimes(1);
+                        expect(handlerFn.mock.calls.length).toBeGreaterThanOrEqual(1);
+                        expect(handlerFn.mock.calls.length).toBeLessThanOrEqual(4);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
                             semaphore: expect.objectContaining({
                                 key: semaphore3.key,
@@ -3052,13 +3025,13 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl1 = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl: ttl1,
                         });
                         await semaphore1.acquire();
                         const ttl2 = TimeSpan.fromMilliseconds(50);
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             limit,
                             ttl: ttl2,
                         });
@@ -3066,8 +3039,8 @@ export function semaphoreProviderTestSuite(settings) {
                         await delay(ttl2);
                         const ttl3 = null;
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore3 = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore3 = semaphoreFactory.create(key, {
                             limit,
                             ttl: ttl3,
                         });
@@ -3090,8 +3063,8 @@ export function semaphoreProviderTestSuite(settings) {
                         const limit = 2;
                         const ttl = null;
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -3115,8 +3088,8 @@ export function semaphoreProviderTestSuite(settings) {
                         const limit = 2;
                         const ttl = TimeSpan.fromMilliseconds(50);
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -3142,8 +3115,8 @@ export function semaphoreProviderTestSuite(settings) {
                         const limit = 2;
                         const ttl = null;
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -3165,14 +3138,14 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = TimeSpan.fromMilliseconds(50);
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore.acquire();
                         await delay(ttl);
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
                         await semaphore.acquireBlockingOrFail({
                             time: TimeSpan.fromMilliseconds(5),
                             interval: TimeSpan.fromMilliseconds(5),
@@ -3191,17 +3164,17 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore1.acquire();
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
                         await semaphore2.acquireBlockingOrFail({
                             time: TimeSpan.fromMilliseconds(5),
                             interval: TimeSpan.fromMilliseconds(5),
@@ -3220,19 +3193,19 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore1.acquire();
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore2.acquire();
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, handlerFn);
-                        const semaphore3 = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.LIMIT_REACHED, handlerFn);
+                        const semaphore3 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -3245,7 +3218,8 @@ export function semaphoreProviderTestSuite(settings) {
                         catch {
                             /* EMPTY */
                         }
-                        expect(handlerFn).toHaveBeenCalledTimes(1);
+                        expect(handlerFn.mock.calls.length).toBeGreaterThanOrEqual(1);
+                        expect(handlerFn.mock.calls.length).toBeLessThanOrEqual(4);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
                             semaphore: expect.objectContaining({
                                 key: semaphore3.key,
@@ -3259,13 +3233,13 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl1 = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl: ttl1,
                         });
                         await semaphore1.acquire();
                         const ttl2 = TimeSpan.fromMilliseconds(50);
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             limit,
                             ttl: ttl2,
                         });
@@ -3273,8 +3247,8 @@ export function semaphoreProviderTestSuite(settings) {
                         await delay(ttl2);
                         const ttl3 = null;
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore3 = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore3 = semaphoreFactory.create(key, {
                             limit,
                             ttl: ttl3,
                         });
@@ -3297,8 +3271,8 @@ export function semaphoreProviderTestSuite(settings) {
                         const limit = 2;
                         const ttl = null;
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -3322,8 +3296,8 @@ export function semaphoreProviderTestSuite(settings) {
                         const limit = 2;
                         const ttl = TimeSpan.fromMilliseconds(50);
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
-                        const semaphore = semaphoreProvider.create(key, {
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ACQUIRED, handlerFn);
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
@@ -3348,19 +3322,19 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        await semaphoreProvider
+                        await semaphoreFactory
                             .create(key, {
                             limit,
                             ttl,
                         })
                             .acquire();
                         const noneExistingKey = "c";
-                        const semaphore = semaphoreProvider.create(noneExistingKey, {
+                        const semaphore = semaphoreFactory.create(noneExistingKey, {
                             limit,
                             ttl,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
                         await semaphore.release();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -3376,20 +3350,20 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        await semaphoreProvider
+                        await semaphoreFactory
                             .create(key, {
                             limit,
                             ttl,
                         })
                             .acquire();
                         const noneExistingSlotId = "1";
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                             slotId: noneExistingSlotId,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
                         await semaphore.release();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -3405,18 +3379,18 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const ttl = TimeSpan.fromMilliseconds(50);
                         const limit = 2;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore1.acquire();
                         await delay(ttl);
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
                         await semaphore.release();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -3432,14 +3406,14 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const ttl = TimeSpan.fromMilliseconds(50);
                         const limit = 2;
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore.acquire();
                         await delay(ttl);
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
                         await semaphore.release();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -3451,17 +3425,17 @@ export function semaphoreProviderTestSuite(settings) {
                             }),
                         }));
                     });
-                    test("Should dispatch ReleasedSemaphoreEvent when slot exists, is unexpired", async () => {
+                    test("Should dispatch ReleasedSemaphoreEvent when slot exists and is unexpired", async () => {
                         const key = "a";
                         const ttl = TimeSpan.fromMilliseconds(50);
                         const limit = 2;
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore.acquire();
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.RELEASED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.RELEASED, handlerFn);
                         await semaphore.release();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -3473,17 +3447,17 @@ export function semaphoreProviderTestSuite(settings) {
                             }),
                         }));
                     });
-                    test("Should dispatch ReleasedSemaphoreEvent when slot exists, is unexpireable", async () => {
+                    test("Should dispatch ReleasedSemaphoreEvent when slot exists and is unexpireable", async () => {
                         const key = "a";
                         const ttl = null;
                         const limit = 2;
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore.acquire();
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.RELEASED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.RELEASED, handlerFn);
                         await semaphore.release();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -3501,19 +3475,19 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        await semaphoreProvider
+                        await semaphoreFactory
                             .create(key, {
                             limit,
                             ttl,
                         })
                             .acquire();
                         const noneExistingKey = "c";
-                        const semaphore = semaphoreProvider.create(noneExistingKey, {
+                        const semaphore = semaphoreFactory.create(noneExistingKey, {
                             limit,
                             ttl,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
                         try {
                             await semaphore.releaseOrFail();
                         }
@@ -3534,20 +3508,20 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        await semaphoreProvider
+                        await semaphoreFactory
                             .create(key, {
                             limit,
                             ttl,
                         })
                             .acquire();
                         const noneExistingSlotId = "1";
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                             slotId: noneExistingSlotId,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
                         try {
                             await semaphore.releaseOrFail();
                         }
@@ -3568,18 +3542,18 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const ttl = TimeSpan.fromMilliseconds(50);
                         const limit = 2;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore1.acquire();
                         await delay(ttl);
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
                         try {
                             await semaphore.releaseOrFail();
                         }
@@ -3600,14 +3574,14 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const ttl = TimeSpan.fromMilliseconds(50);
                         const limit = 2;
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore.acquire();
                         await delay(ttl);
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_RELEASE, handlerFn);
                         try {
                             await semaphore.releaseOrFail();
                         }
@@ -3624,17 +3598,17 @@ export function semaphoreProviderTestSuite(settings) {
                             }),
                         }));
                     });
-                    test("Should dispatch ReleasedSemaphoreEvent when slot exists, is unexpired", async () => {
+                    test("Should dispatch ReleasedSemaphoreEvent when slot exists and is unexpired", async () => {
                         const key = "a";
                         const ttl = TimeSpan.fromMilliseconds(50);
                         const limit = 2;
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore.acquire();
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.RELEASED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.RELEASED, handlerFn);
                         await semaphore.releaseOrFail();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -3646,17 +3620,17 @@ export function semaphoreProviderTestSuite(settings) {
                             }),
                         }));
                     });
-                    test("Should dispatch ReleasedSemaphoreEvent when slot exists, is unexpireable", async () => {
+                    test("Should dispatch ReleasedSemaphoreEvent when slot exists and is unexpireable", async () => {
                         const key = "a";
                         const ttl = null;
                         const limit = 2;
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore.acquire();
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.RELEASED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.RELEASED, handlerFn);
                         await semaphore.releaseOrFail();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -3674,13 +3648,13 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 3;
                         const ttl1 = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             ttl: ttl1,
                             limit,
                         });
                         await semaphore1.acquire();
                         const ttl2 = TimeSpan.fromMilliseconds(50);
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             ttl: ttl2,
                             limit,
                         });
@@ -3688,12 +3662,12 @@ export function semaphoreProviderTestSuite(settings) {
                         await delay(ttl2);
                         await semaphore1.release();
                         const ttl3 = null;
-                        const semaphore3 = semaphoreProvider.create(key, {
+                        const semaphore3 = semaphoreFactory.create(key, {
                             ttl: ttl3,
                             limit,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ALL_FORCE_RELEASED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ALL_FORCE_RELEASED, handlerFn);
                         await semaphore3.forceReleaseAll();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -3710,19 +3684,19 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl1 = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             ttl: ttl1,
                             limit,
                         });
                         await semaphore1.acquire();
                         const ttl2 = TimeSpan.fromMilliseconds(50);
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             ttl: ttl2,
                             limit,
                         });
                         await semaphore2.acquire();
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.ALL_FORCE_RELEASED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.ALL_FORCE_RELEASED, handlerFn);
                         await semaphore1.forceReleaseAll();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -3741,19 +3715,19 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore1.acquire();
                         const newTtl = TimeSpan.fromMilliseconds(100);
                         const noneExistingKey = "c";
-                        const semaphore2 = semaphoreProvider.create(noneExistingKey, {
+                        const semaphore2 = semaphoreFactory.create(noneExistingKey, {
                             ttl: newTtl,
                             limit,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
                         await semaphore2.refresh();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -3769,20 +3743,20 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore1.acquire();
                         const newTtl = TimeSpan.fromMilliseconds(100);
                         const noneExistingSlotId = "1";
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             ttl: newTtl,
                             limit,
                             slotId: noneExistingSlotId,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
                         await semaphore2.refresh();
                         expect(handlerFn).toHaveBeenCalledTimes(1);
                         expect(handlerFn).toHaveBeenCalledWith(expect.objectContaining({
@@ -3798,14 +3772,14 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = TimeSpan.fromMilliseconds(50);
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore.acquire();
                         await delay(ttl);
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
                         const newTtl = TimeSpan.fromMilliseconds(100);
                         await semaphore.refresh(newTtl);
                         expect(handlerFn).toHaveBeenCalledTimes(1);
@@ -3822,14 +3796,14 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const ttl = TimeSpan.fromMilliseconds(50);
                         const limit = 2;
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore.acquire();
                         await delay(ttl);
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
                         const newTtl = TimeSpan.fromMilliseconds(100);
                         await semaphore.refresh(newTtl);
                         expect(handlerFn).toHaveBeenCalledTimes(1);
@@ -3842,17 +3816,17 @@ export function semaphoreProviderTestSuite(settings) {
                             }),
                         }));
                     });
-                    test("Should dispatch FailedRefreshSemaphoreEvent when slot exists, is unexpireable", async () => {
+                    test("Should dispatch FailedRefreshSemaphoreEvent when slot exists and is unexpireable", async () => {
                         const key = "a";
                         const ttl = null;
                         const limit = 2;
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore.acquire();
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
                         const newTtl = TimeSpan.fromMilliseconds(100);
                         await semaphore.refresh(newTtl);
                         expect(handlerFn).toHaveBeenCalledTimes(1);
@@ -3865,17 +3839,17 @@ export function semaphoreProviderTestSuite(settings) {
                             }),
                         }));
                     });
-                    test("Should dispatch RefreshedSemaphoreEvent when slot exists, is unexpired", async () => {
+                    test("Should dispatch RefreshedSemaphoreEvent when slot exists and is unexpired", async () => {
                         const key = "a";
                         const ttl = TimeSpan.fromMilliseconds(50);
                         const limit = 2;
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore.acquire();
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.REFRESHED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.REFRESHED, handlerFn);
                         const newTtl = TimeSpan.fromMilliseconds(100);
                         await semaphore.refresh(newTtl);
                         expect(handlerFn).toHaveBeenCalledTimes(1);
@@ -3894,19 +3868,19 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore1.acquire();
                         const newTtl = TimeSpan.fromMilliseconds(100);
                         const noneExistingKey = "c";
-                        const semaphore2 = semaphoreProvider.create(noneExistingKey, {
+                        const semaphore2 = semaphoreFactory.create(noneExistingKey, {
                             ttl: newTtl,
                             limit,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
                         try {
                             await semaphore2.refreshOrFail(newTtl);
                         }
@@ -3927,20 +3901,20 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = null;
-                        const semaphore1 = semaphoreProvider.create(key, {
+                        const semaphore1 = semaphoreFactory.create(key, {
                             limit,
                             ttl,
                         });
                         await semaphore1.acquire();
                         const newTtl = TimeSpan.fromMilliseconds(100);
                         const noneExistingSlotId = "1";
-                        const semaphore2 = semaphoreProvider.create(key, {
+                        const semaphore2 = semaphoreFactory.create(key, {
                             ttl: newTtl,
                             limit,
                             slotId: noneExistingSlotId,
                         });
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
                         try {
                             await semaphore2.refreshOrFail(newTtl);
                         }
@@ -3961,14 +3935,14 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const limit = 2;
                         const ttl = TimeSpan.fromMilliseconds(50);
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore.acquire();
                         await delay(ttl);
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
                         const newTtl = TimeSpan.fromMilliseconds(100);
                         try {
                             await semaphore.refreshOrFail(newTtl);
@@ -3990,14 +3964,14 @@ export function semaphoreProviderTestSuite(settings) {
                         const key = "a";
                         const ttl = TimeSpan.fromMilliseconds(50);
                         const limit = 2;
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore.acquire();
                         await delay(ttl);
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
                         const newTtl = TimeSpan.fromMilliseconds(100);
                         try {
                             await semaphore.refreshOrFail(newTtl);
@@ -4015,17 +3989,17 @@ export function semaphoreProviderTestSuite(settings) {
                             }),
                         }));
                     });
-                    test("Should dispatch FailedRefreshSemaphoreEvent when slot exists, is unexpireable", async () => {
+                    test("Should dispatch FailedRefreshSemaphoreEvent when slot exists and is unexpireable", async () => {
                         const key = "a";
                         const ttl = null;
                         const limit = 2;
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore.acquire();
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.FAILED_REFRESH, handlerFn);
                         const newTtl = TimeSpan.fromMilliseconds(100);
                         try {
                             await semaphore.refreshOrFail(newTtl);
@@ -4043,17 +4017,17 @@ export function semaphoreProviderTestSuite(settings) {
                             }),
                         }));
                     });
-                    test("Should dispatch RefreshedSemaphoreEvent when slot exists, is unexpired", async () => {
+                    test("Should dispatch RefreshedSemaphoreEvent when slot exists and is unexpired", async () => {
                         const key = "a";
                         const ttl = TimeSpan.fromMilliseconds(50);
                         const limit = 2;
-                        const semaphore = semaphoreProvider.create(key, {
+                        const semaphore = semaphoreFactory.create(key, {
                             ttl,
                             limit,
                         });
                         await semaphore.acquire();
                         const handlerFn = vi.fn((_event) => { });
-                        await semaphoreProvider.events.addListener(SEMAPHORE_EVENTS.REFRESHED, handlerFn);
+                        await semaphoreFactory.events.addListener(SEMAPHORE_EVENTS.REFRESHED, handlerFn);
                         const newTtl = TimeSpan.fromMilliseconds(100);
                         await semaphore.refreshOrFail(newTtl);
                         expect(handlerFn).toHaveBeenCalledTimes(1);
@@ -4075,7 +4049,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 3;
                     const ttl = TimeSpan.fromMilliseconds(50);
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         limit,
                         ttl,
                     });
@@ -4089,7 +4063,7 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const ttl = TimeSpan.fromMilliseconds(50);
                     const limit = 2;
-                    const semaphore = semaphoreProvider.create(key, {
+                    const semaphore = semaphoreFactory.create(key, {
                         ttl,
                         limit,
                     });
@@ -4105,13 +4079,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl: ttl1,
                         limit,
                     });
                     await semaphore1.acquire();
                     const ttl2 = null;
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -4127,13 +4101,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 2;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         limit,
                         ttl: ttl1,
                     });
                     await semaphore1.acquire();
                     const ttl2 = null;
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -4150,13 +4124,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 3;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl: ttl1,
                         limit,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -4174,13 +4148,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 3;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl: ttl1,
                         limit,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -4197,16 +4171,19 @@ export function semaphoreProviderTestSuite(settings) {
                     });
                 });
                 test("Should return ISemaphoreAcquiredState when is derserialized and slot is unexpired", async () => {
+                    expect.addEqualityTesters([
+                        createIsTimeSpanEqualityTester(timeSpanEqualityBuffer),
+                    ]);
                     const key = "a";
                     const limit = 3;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl: ttl1,
                         limit,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -4226,13 +4203,13 @@ export function semaphoreProviderTestSuite(settings) {
                     const key = "a";
                     const limit = 1;
                     const ttl1 = null;
-                    const semaphore1 = semaphoreProvider.create(key, {
+                    const semaphore1 = semaphoreFactory.create(key, {
                         ttl: ttl1,
                         limit,
                     });
                     await semaphore1.acquire();
                     const ttl2 = TimeSpan.fromMilliseconds(50);
-                    const semaphore2 = semaphoreProvider.create(key, {
+                    const semaphore2 = semaphoreFactory.create(key, {
                         ttl: ttl2,
                         limit,
                     });
@@ -4249,4 +4226,4 @@ export function semaphoreProviderTestSuite(settings) {
         }
     });
 }
-//# sourceMappingURL=semaphore-provider.test-suite.js.map
+//# sourceMappingURL=semaphore-factory.test-suite.js.map