@daiso-tech/core 0.32.0 → 0.33.0

package/dist/lock/implementations/test-utilities/lock-provider.test-suite.js

@@ -54,12 +54,9 @@ import { Serde } from "../../../serde/implementations/derivables/_module-exports
  */
 export function lockProviderTestSuite(settings) {
     const { expect, test, createLockProvider, describe, beforeEach, serde = new Serde(new NoOpSerdeAdapter()), } = settings;
-    let lockProviderA;
-    let lockProviderB;
+    let lockProvider;
     beforeEach(async () => {
-        const lockProvider = await createLockProvider();
-        lockProviderA = lockProvider;
-        lockProviderB = lockProvider.withGroup("b");
+        lockProvider = await createLockProvider();
     });
     const TTL = TimeSpan.fromMilliseconds(50);
     const DELAY_TIME = TimeSpan.fromMilliseconds(50);
@@ -68,7 +65,7 @@ export function lockProviderTestSuite(settings) {
             test("Should return string when lock is available", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 const [result, error] = await lock.run(async () => {
@@ -81,7 +78,7 @@ export function lockProviderTestSuite(settings) {
             test("Should return null when lock is already acquired", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquire();
@@ -95,7 +92,7 @@ export function lockProviderTestSuite(settings) {
             test("Should work with LazyPromise", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 const [result, error] = await lock.run(new LazyPromise(async () => {
@@ -110,7 +107,7 @@ export function lockProviderTestSuite(settings) {
             test("Should return string when lock is available", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 const result = await lock.runOrFail(async () => {
@@ -122,7 +119,7 @@ export function lockProviderTestSuite(settings) {
             test("Should throw KeyAlreadyAcquiredLockError when lock is already acquired", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquire();
@@ -135,7 +132,7 @@ export function lockProviderTestSuite(settings) {
             test("Should work with LazyPromise", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 const result = await lock.runOrFail(new LazyPromise(async () => {
@@ -149,7 +146,7 @@ export function lockProviderTestSuite(settings) {
             test("Should return string when lock is available", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 const [result, error] = await lock.runBlocking(async () => {
@@ -165,7 +162,7 @@ export function lockProviderTestSuite(settings) {
             test("Should return null when lock is already acquired", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquire();
@@ -182,7 +179,7 @@ export function lockProviderTestSuite(settings) {
             test("Should work with LazyPromise", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 const [result, error] = await lock.runBlocking(new LazyPromise(async () => {
@@ -198,12 +195,12 @@ export function lockProviderTestSuite(settings) {
             test("Should retry acquire the lock", async () => {
                 const key = "a";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquire();
                 let index = 0;
-                await lock.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
+                await lockProvider.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
                     index++;
                 });
                 await lock.runBlocking(async () => {
@@ -219,7 +216,7 @@ export function lockProviderTestSuite(settings) {
             test("Should return string when lock is available", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 const result = await lock.runBlockingOrFail(async () => {
@@ -234,7 +231,7 @@ export function lockProviderTestSuite(settings) {
             test("Should throw KeyAlreadyAcquiredLockError when lock is already acquired", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquire();
@@ -250,7 +247,7 @@ export function lockProviderTestSuite(settings) {
             test("Should work with LazyPromise", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 const result = await lock.runBlockingOrFail(new LazyPromise(async () => {
@@ -265,12 +262,12 @@ export function lockProviderTestSuite(settings) {
             test("Should retry acquire the lock", async () => {
                 const key = "a";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquire();
                 let index = 0;
-                await lock.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
+                await lockProvider.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
                     index++;
                 });
                 try {
@@ -291,7 +288,7 @@ export function lockProviderTestSuite(settings) {
             test("Should return true when lock is available", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 const result = await lock.acquire();
@@ -300,7 +297,7 @@ export function lockProviderTestSuite(settings) {
             test("Should return false when lock is already acquired", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquire();
@@ -311,7 +308,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -323,7 +320,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -336,7 +333,7 @@ export function lockProviderTestSuite(settings) {
             test("Should not throw KeyAlreadyAcquiredLockError when lock is available", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 const result = lock.acquireOrFail();
@@ -345,7 +342,7 @@ export function lockProviderTestSuite(settings) {
             test("Should throw KeyAlreadyAcquiredLockError when lock is already acquired", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquireOrFail();
@@ -357,7 +354,7 @@ export function lockProviderTestSuite(settings) {
             test("Should return true when lock is available", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 const result = await lock.acquireBlocking({
@@ -369,7 +366,7 @@ export function lockProviderTestSuite(settings) {
             test("Should return false when lock is already acquired", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquireBlocking({
@@ -386,7 +383,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -401,7 +398,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -415,12 +412,12 @@ export function lockProviderTestSuite(settings) {
             test("Should retry acquire the lock", async () => {
                 const key = "a";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquire();
                 let index = 0;
-                await lock.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
+                await lockProvider.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
                     index++;
                 });
                 await lock.acquireBlocking({
@@ -434,7 +431,7 @@ export function lockProviderTestSuite(settings) {
             test("Should not throw KeyAlreadyAcquiredLockError when lock is available", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 const promise = lock.acquireBlockingOrFail({
@@ -446,7 +443,7 @@ export function lockProviderTestSuite(settings) {
             test("Should throw KeyAlreadyAcquiredLockError when lock is already acquired", async () => {
                 const key = "a";
                 const ttl = null;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquireBlockingOrFail({
@@ -463,7 +460,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -478,7 +475,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -492,12 +489,12 @@ export function lockProviderTestSuite(settings) {
             test("Should retry acquire the lock", async () => {
                 const key = "a";
                 const ttl = TimeSpan.fromMilliseconds(50);
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                 });
                 await lock.acquire();
                 let index = 0;
-                await lock.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
+                await lockProvider.addListener(KeyAlreadyAcquiredLockEvent, (_event) => {
                     index++;
                 });
                 try {
@@ -517,7 +514,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -529,13 +526,13 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner1 = "b";
-                const lock1 = lockProviderA.create(key, {
+                const lock1 = lockProvider.create(key, {
                     ttl,
                     owner: owner1,
                 });
                 await lock1.acquire();
                 const owner2 = "c";
-                const lock2 = lockProviderA.create(key, {
+                const lock2 = lockProvider.create(key, {
                     ttl,
                     owner: owner2,
                 });
@@ -546,7 +543,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -559,7 +556,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -574,7 +571,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -586,13 +583,13 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner1 = "b";
-                const lock1 = lockProviderA.create(key, {
+                const lock1 = lockProvider.create(key, {
                     ttl,
                     owner: owner1,
                 });
                 await lock1.acquire();
                 const owner2 = "c";
-                const lock2 = lockProviderA.create(key, {
+                const lock2 = lockProvider.create(key, {
                     ttl,
                     owner: owner2,
                 });
@@ -603,7 +600,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -616,7 +613,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -631,13 +628,13 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner1 = "b";
-                const lock1 = lockProviderA.create(key, {
+                const lock1 = lockProvider.create(key, {
                     ttl,
                     owner: owner1,
                 });
                 await lock1.acquire();
                 const owner2 = "c";
-                const lock2 = lockProviderA.create(key, {
+                const lock2 = lockProvider.create(key, {
                     ttl,
                     owner: owner2,
                 });
@@ -649,7 +646,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -662,7 +659,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -677,7 +674,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -689,7 +686,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const owner = "b";
                 const ttl = TTL;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -701,7 +698,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const owner = "b";
                 const ttl = TTL;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -716,7 +713,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -728,7 +725,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const owner = "b";
                 const ttl = TTL;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -740,7 +737,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const owner = "b";
                 const ttl = TTL;
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -755,7 +752,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = TTL;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -768,13 +765,13 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = TTL;
                 const owner1 = "b";
-                const lock1 = lockProviderA.create(key, {
+                const lock1 = lockProvider.create(key, {
                     ttl,
                     owner: owner1,
                 });
                 await lock1.acquire();
                 const owner2 = "c";
-                const lock2 = lockProviderA.create(key, {
+                const lock2 = lockProvider.create(key, {
                     ttl,
                     owner: owner2,
                 });
@@ -785,7 +782,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = TTL;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -801,7 +798,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = TTL;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -814,13 +811,13 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = TTL;
                 const owner1 = "b";
-                const lock1 = lockProviderA.create(key, {
+                const lock1 = lockProvider.create(key, {
                     ttl,
                     owner: owner1,
                 });
                 await lock1.acquire();
                 const owner2 = "c";
-                const lock2 = lockProviderA.create(key, {
+                const lock2 = lockProvider.create(key, {
                     ttl,
                     owner: owner2,
                 });
@@ -831,7 +828,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = TTL;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -847,7 +844,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -858,7 +855,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = null;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -870,7 +867,7 @@ export function lockProviderTestSuite(settings) {
                 const key = "a";
                 const ttl = TTL;
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     ttl,
                     owner,
                 });
@@ -883,7 +880,7 @@ export function lockProviderTestSuite(settings) {
             test("Should return the owner", async () => {
                 const key = "a";
                 const owner = "b";
-                const lock = lockProviderA.create(key, {
+                const lock = lockProvider.create(key, {
                     owner,
                 });
                 const result = await lock.getOwner();
@@ -891,7 +888,7 @@ export function lockProviderTestSuite(settings) {
             });
             test("Should return the auto generated owner", async () => {
                 const key = "a";
-                const lock = lockProviderA.create(key);
+                const lock = lockProvider.create(key);
                 const result = await lock.getOwner();
                 expect(result).toBeDefined();
                 expect(typeof result).toBe("string");
@@ -904,12 +901,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.run(async () => {
@@ -924,12 +921,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.run(async () => {
@@ -943,12 +940,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lock.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.run(async () => {
@@ -964,12 +961,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
@@ -987,12 +984,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
@@ -1009,12 +1006,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lock.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
@@ -1033,12 +1030,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.runOrFail(async () => {
@@ -1053,12 +1050,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.runOrFail(async () => {
@@ -1072,12 +1069,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lock.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     try {
@@ -1098,12 +1095,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.acquire();
@@ -1116,12 +1113,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lock.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.acquire();
@@ -1135,12 +1132,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.acquireBlocking({
@@ -1156,7 +1153,7 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     let event_ = null;
@@ -1164,7 +1161,7 @@ export function lockProviderTestSuite(settings) {
                         time: TimeSpan.fromMilliseconds(5),
                         interval: TimeSpan.fromMilliseconds(5),
                     });
-                    const unsubscribe = await lock.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.acquireBlocking({
@@ -1181,12 +1178,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.acquireOrFail();
@@ -1199,12 +1196,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     let event_ = null;
                     await lock.acquireOrFail();
-                    const unsubscribe = await lock.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     try {
@@ -1223,12 +1220,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyReleasedLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lock.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.release();
@@ -1240,16 +1237,16 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch UnownedReleaseLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
+                    const lock1 = lockProvider.create(key, {
                         owner: owner1,
                     });
                     await lock1.acquire();
                     const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
+                    const lock2 = lockProvider.create(key, {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock1.subscribe(UnownedReleaseLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(UnownedReleaseLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock2.release();
@@ -1263,12 +1260,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyReleasedLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lock.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.releaseOrFail();
@@ -1280,16 +1277,16 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch UnownedReleaseLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
+                    const lock1 = lockProvider.create(key, {
                         owner: owner1,
                     });
                     await lock1.acquire();
                     const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
+                    const lock2 = lockProvider.create(key, {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock1.subscribe(UnownedReleaseLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(UnownedReleaseLockEvent, (event) => {
                         event_ = event;
                     });
                     try {
@@ -1308,16 +1305,16 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyForceReleasedLockEvent when lock forcefully released", async () => {
                     const key = "a";
                     const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
+                    const lock1 = lockProvider.create(key, {
                         owner: owner1,
                     });
                     await lock1.acquire();
                     const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
+                    const lock2 = lockProvider.create(key, {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock1.subscribe(KeyForceReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyForceReleasedLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock2.forceRelease();
@@ -1330,13 +1327,13 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyRefreshedLockEvent when refreshed by same owner", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lock.subscribe(KeyRefreshedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyRefreshedLockEvent, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
@@ -1351,17 +1348,17 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch UnownedRefreshLockEvent when refreshed by different owner", async () => {
                     const key = "a";
                     const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
+                    const lock1 = lockProvider.create(key, {
                         owner: owner1,
                         ttl: TTL,
                     });
                     await lock1.acquire();
                     const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
+                    const lock2 = lockProvider.create(key, {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock1.subscribe(UnownedRefreshLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(UnownedRefreshLockEvent, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
@@ -1377,13 +1374,13 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyRefreshedLockEvent when refreshed by same owner", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lock.subscribe(KeyRefreshedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyRefreshedLockEvent, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
@@ -1398,17 +1395,17 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch UnownedRefreshLockEvent when refreshed by different owner", async () => {
                     const key = "a";
                     const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
+                    const lock1 = lockProvider.create(key, {
                         owner: owner1,
                         ttl: TTL,
                     });
                     await lock1.acquire();
                     const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
+                    const lock2 = lockProvider.create(key, {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock1.subscribe(UnownedRefreshLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(UnownedRefreshLockEvent, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
@@ -1431,12 +1428,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.run(async () => {
@@ -1451,12 +1448,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.run(async () => {
@@ -1470,12 +1467,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lockProviderA.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.run(async () => {
@@ -1491,12 +1488,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
@@ -1514,12 +1511,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
@@ -1536,12 +1533,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lockProviderA.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.runBlocking(async () => {
@@ -1560,12 +1557,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.runOrFail(async () => {
@@ -1580,12 +1577,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyReleasedLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.runOrFail(async () => {
@@ -1599,12 +1596,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lockProviderA.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     try {
@@ -1625,12 +1622,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.acquire();
@@ -1643,12 +1640,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lockProviderA.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.acquire();
@@ -1662,12 +1659,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.acquire();
@@ -1680,12 +1677,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     let event_ = null;
                     await lock.acquire();
-                    const unsubscribe = await lockProviderA.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.acquire();
@@ -1699,12 +1696,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAcquiredLockEvent when lock is not acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(KeyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.acquireOrFail();
@@ -1717,12 +1714,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyAlreadyAcquiredLockEvent when lock is acquired", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     let event_ = null;
                     await lock.acquireOrFail();
-                    const unsubscribe = await lockProviderA.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyAlreadyAcquiredLockEvent, (event) => {
                         event_ = event;
                     });
                     try {
@@ -1741,12 +1738,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyReleasedLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.release();
@@ -1758,16 +1755,16 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch UnownedReleaseLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
+                    const lock1 = lockProvider.create(key, {
                         owner: owner1,
                     });
                     await lock1.acquire();
                     const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
+                    const lock2 = lockProvider.create(key, {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock1.subscribe(UnownedReleaseLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(UnownedReleaseLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock2.release();
@@ -1781,12 +1778,12 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyReleasedLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(KeyReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyReleasedLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock.releaseOrFail();
@@ -1798,16 +1795,16 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch UnownedReleaseLockEvent when released by same owner", async () => {
                     const key = "a";
                     const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
+                    const lock1 = lockProvider.create(key, {
                         owner: owner1,
                     });
                     await lock1.acquire();
                     const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
+                    const lock2 = lockProvider.create(key, {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock1.subscribe(UnownedReleaseLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(UnownedReleaseLockEvent, (event) => {
                         event_ = event;
                     });
                     try {
@@ -1826,16 +1823,16 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyForceReleasedLockEvent when lock forcefully released", async () => {
                     const key = "a";
                     const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
+                    const lock1 = lockProvider.create(key, {
                         owner: owner1,
                     });
                     await lock1.acquire();
                     const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
+                    const lock2 = lockProvider.create(key, {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock1.subscribe(KeyForceReleasedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyForceReleasedLockEvent, (event) => {
                         event_ = event;
                     });
                     await lock2.forceRelease();
@@ -1848,13 +1845,13 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyRefreshedLockEvent when refreshed by same owner", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(KeyRefreshedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyRefreshedLockEvent, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
@@ -1869,17 +1866,17 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch UnownedRefreshLockEvent when refreshed by different owner", async () => {
                     const key = "a";
                     const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
+                    const lock1 = lockProvider.create(key, {
                         owner: owner1,
                         ttl: TTL,
                     });
                     await lock1.acquire();
                     const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
+                    const lock2 = lockProvider.create(key, {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock1.subscribe(UnownedRefreshLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(UnownedRefreshLockEvent, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
@@ -1895,13 +1892,13 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch KeyRefreshedLockEvent when refreshed by same owner", async () => {
                     const key = "a";
                     const owner = "b";
-                    const lock = lockProviderA.create(key, {
+                    const lock = lockProvider.create(key, {
                         owner,
                         ttl: TTL,
                     });
                     await lock.acquire();
                     let event_ = null;
-                    const unsubscribe = await lockProviderA.subscribe(KeyRefreshedLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(KeyRefreshedLockEvent, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
@@ -1916,17 +1913,17 @@ export function lockProviderTestSuite(settings) {
                 test("Should dispatch UnownedRefreshLockEvent when refreshed by different owner", async () => {
                     const key = "a";
                     const owner1 = "b";
-                    const lock1 = lockProviderA.create(key, {
+                    const lock1 = lockProvider.create(key, {
                         owner: owner1,
                         ttl: TTL,
                     });
                     await lock1.acquire();
                     const owner2 = "c";
-                    const lock2 = lockProviderA.create(key, {
+                    const lock2 = lockProvider.create(key, {
                         owner: owner2,
                     });
                     let event_ = null;
-                    const unsubscribe = await lock1.subscribe(UnownedRefreshLockEvent, (event) => {
+                    const unsubscribe = await lockProvider.subscribe(UnownedRefreshLockEvent, (event) => {
                         event_ = event;
                     });
                     await LazyPromise.delay(TTL.divide(2));
@@ -1945,489 +1942,11 @@ export function lockProviderTestSuite(settings) {
             });
         });
     });
-    describe("Group tests:", () => {
-        test("method: run", async () => {
-            const key = "a";
-            const ownerA = "b";
-            const lockA = lockProviderA.create(key, {
-                owner: ownerA,
-            });
-            const promiseA = lockA.run(async () => {
-                await LazyPromise.delay(DELAY_TIME);
-                return "a";
-            });
-            const ownerB = "c";
-            const lockB = lockProviderB.create(key, {
-                owner: ownerB,
-            });
-            const promiseB = lockB.run(async () => {
-                await LazyPromise.delay(DELAY_TIME);
-                return "a";
-            });
-            const [[resultA, errorA], [resultB, errorB]] = await Promise.all([
-                promiseA,
-                promiseB,
-            ]);
-            expect(resultA).toBe("a");
-            expect(errorA).toBeNull();
-            expect(resultB).toBe("a");
-            expect(errorB).toBeNull();
-        });
-        test("method: runBlocking", async () => {
-            const key = "a";
-            const ownerA = "b";
-            const lockA = lockProviderA.create(key, {
-                owner: ownerA,
-            });
-            const promiseA = lockA.run(async () => {
-                await LazyPromise.delay(DELAY_TIME);
-                return "a";
-            });
-            const ownerB = "c";
-            const lockB = lockProviderB.create(key, {
-                owner: ownerB,
-            });
-            const promiseB = lockB.runBlocking(async () => {
-                await LazyPromise.delay(DELAY_TIME);
-                return "a";
-            }, {
-                time: TimeSpan.fromMilliseconds(5),
-                interval: TimeSpan.fromMilliseconds(5),
-            });
-            const [[resultA, errorA], [resultB, errorB]] = await Promise.all([
-                promiseA,
-                promiseB,
-            ]);
-            expect(resultA).toBe("a");
-            expect(errorA).toBeNull();
-            expect(resultB).toBe("a");
-            expect(errorB).toBeNull();
-        });
-        test("method: runOrFail", async () => {
-            const key = "a";
-            const ownerA = "b";
-            const lockA = lockProviderA.create(key, {
-                owner: ownerA,
-            });
-            const promiseA = lockA.runOrFail(async () => {
-                await LazyPromise.delay(DELAY_TIME);
-                return "a";
-            });
-            const ownerB = "c";
-            const lockB = lockProviderB.create(key, {
-                owner: ownerB,
-            });
-            const promiseB = lockB.runOrFail(async () => {
-                await LazyPromise.delay(DELAY_TIME);
-                return "a";
-            });
-            const [resultA, resultB] = await Promise.all([promiseA, promiseB]);
-            expect(resultA).toBe("a");
-            expect(resultB).toBe("a");
-        });
-        test("method: acquire", async () => {
-            const key = "a";
-            const ownerA = "b";
-            const lockA = lockProviderA.create(key, {
-                owner: ownerA,
-            });
-            const resultA = await lockA.acquire();
-            const ownerB = "c";
-            const lockB = lockProviderB.create(key, {
-                owner: ownerB,
-            });
-            const resultB = await lockB.acquire();
-            expect(resultA).toBe(true);
-            expect(resultB).toBe(true);
-        });
-        test("method: acquireBlocking", async () => {
-            const key = "a";
-            const ownerA = "b";
-            const lockA = lockProviderA.create(key, {
-                owner: ownerA,
-            });
-            const resultA = await lockA.acquireBlocking({
-                time: TimeSpan.fromMilliseconds(5),
-                interval: TimeSpan.fromMilliseconds(5),
-            });
-            const ownerB = "c";
-            const lockB = lockProviderB.create(key, {
-                owner: ownerB,
-            });
-            const resultB = await lockB.acquire();
-            expect(resultA).toBe(true);
-            expect(resultB).toBe(true);
-        });
-        test("method: acquireOrFail", async () => {
-            const key = "a";
-            const ownerA = "b";
-            const lockA = lockProviderA.create(key, {
-                owner: ownerA,
-            });
-            const promiseA = lockA.acquireOrFail();
-            const ownerB = "c";
-            const lockB = lockProviderB.create(key, {
-                owner: ownerB,
-            });
-            const promiseB = lockB.acquireOrFail();
-            await expect(promiseA).resolves.toBeUndefined();
-            await expect(promiseB).resolves.toBeUndefined();
-        });
-        test("method: release", async () => {
-            const key = "a";
-            const owner = "b";
-            const lockA = lockProviderA.create(key, {
-                owner,
-            });
-            await lockA.acquire();
-            const lockB = lockProviderB.create(key, {
-                owner,
-            });
-            await lockB.acquire();
-            await lockA.release();
-            const resultA = await lockA.isLocked();
-            const resultB = await lockB.isLocked();
-            expect(resultA).toBe(false);
-            expect(resultB).toBe(true);
-        });
-        test("method: releaseOrFail", async () => {
-            const key = "a";
-            const owner = "b";
-            const lockA = lockProviderA.create(key, {
-                owner,
-            });
-            await lockA.acquire();
-            const lockB = lockProviderB.create(key, {
-                owner,
-            });
-            await lockB.acquire();
-            await lockA.releaseOrFail();
-            const resultA = await lockA.isLocked();
-            const resultB = await lockB.isLocked();
-            expect(resultA).toBe(false);
-            expect(resultB).toBe(true);
-        });
-        test("method: forceRelease", async () => {
-            const key = "a";
-            const owner = "b";
-            const lockA = lockProviderA.create(key, {
-                owner,
-            });
-            await lockA.acquire();
-            const lockB = lockProviderB.create(key, {
-                owner,
-            });
-            await lockB.acquire();
-            await lockA.forceRelease();
-            const resultA = await lockA.isLocked();
-            const resultB = await lockB.isLocked();
-            expect(resultA).toBe(false);
-            expect(resultB).toBe(true);
-        });
-        test("method: isExpired", async () => {
-            const key = "a";
-            const owner = "b";
-            const lockA = lockProviderA.create(key, { owner });
-            const lockB = lockProviderB.create(key, { owner });
-            await lockA.acquire();
-            await lockB.acquire();
-            await lockA.release();
-            const resultA = await lockA.isExpired();
-            const resultB = await lockB.isExpired();
-            expect(resultA).toBe(true);
-            expect(resultB).toBe(false);
-        });
-        test("method: isLocked", async () => {
-            const key = "a";
-            const owner = "b";
-            const lockA = lockProviderA.create(key, { owner });
-            const lockB = lockProviderB.create(key, { owner });
-            await lockA.acquire();
-            await lockB.acquire();
-            await lockA.release();
-            const resultA = await lockA.isLocked();
-            const resultB = await lockB.isLocked();
-            expect(resultA).toBe(false);
-            expect(resultB).toBe(true);
-        });
-        test("method: refresh", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = TTL;
-            const lockA = lockProviderA.create(key, {
-                owner,
-                ttl,
-            });
-            const lockB = lockProviderB.create(key, {
-                owner,
-                ttl,
-            });
-            await Promise.all([lockA.acquire(), lockB.acquire()]);
-            await LazyPromise.delay(ttl.divide(2));
-            await lockA.refresh();
-            await LazyPromise.delay(ttl.divide(2));
-            const resultA = await lockA.isExpired();
-            const resultB = await lockB.isExpired();
-            expect(resultA).toBe(false);
-            expect(resultB).toBe(true);
-        });
-        test("method: refreshOrFail", async () => {
-            const key = "a";
-            const owner = "b";
-            const ttl = TTL;
-            const lockA = lockProviderA.create(key, {
-                owner,
-                ttl,
-            });
-            const lockB = lockProviderB.create(key, {
-                owner,
-                ttl,
-            });
-            await Promise.all([lockA.acquire(), lockB.acquire()]);
-            await LazyPromise.delay(ttl.divide(2));
-            await lockA.refreshOrFail();
-            await LazyPromise.delay(ttl.divide(2));
-            const resultA = await lockA.isExpired();
-            const resultB = await lockB.isExpired();
-            expect(resultA).toBe(false);
-            expect(resultB).toBe(true);
-        });
-        describe("class: Lock", () => {
-            test("method: addListener / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockA.addListener(KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const lockB = lockProviderB.create(key);
-                await lockB.addListener(KeyAcquiredLockEvent, (event) => {
-                    result_b = event;
-                });
-                await lockA.acquire();
-                await LazyPromise.delay(DELAY_TIME);
-                expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: addListenerMany / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockA.addListenerMany([KeyAcquiredLockEvent], (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const lockB = lockProviderB.create(key);
-                await lockB.addListenerMany([KeyAcquiredLockEvent], (event) => {
-                    result_b = event;
-                });
-                await lockA.acquire();
-                await LazyPromise.delay(DELAY_TIME);
-                expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: removeListener / addListener / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockA.addListener(KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                await lockB.addListener(KeyAcquiredLockEvent, listenerB);
-                await lockB.removeListener(KeyAcquiredLockEvent, listenerB);
-                await lockA.acquire();
-                await lockB.acquire();
-                await LazyPromise.delay(DELAY_TIME);
-                expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: removeListenerMany / addListener / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockA.addListener(KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                await lockB.addListener(KeyAcquiredLockEvent, listenerB);
-                await lockB.removeListenerMany([KeyAcquiredLockEvent], listenerB);
-                await lockA.acquire();
-                await lockB.acquire();
-                await LazyPromise.delay(DELAY_TIME);
-                expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: subscribe / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockA.subscribe(KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                const unsubscribe = await lockB.subscribe(KeyAcquiredLockEvent, listenerB);
-                await unsubscribe();
-                await lockA.acquire();
-                await lockB.acquire();
-                await LazyPromise.delay(DELAY_TIME);
-                expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: subscribeMany / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockA.subscribeMany([KeyAcquiredLockEvent], (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                const unsubscribe = await lockB.subscribeMany([KeyAcquiredLockEvent], listenerB);
-                await unsubscribe();
-                await lockA.acquire();
-                await lockB.acquire();
-                await LazyPromise.delay(DELAY_TIME);
-                expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-        });
-        describe("class: LockProvider", () => {
-            test("method: addListener / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockProviderA.addListener(KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                await lockProviderB.addListener(KeyAcquiredLockEvent, (event) => {
-                    result_b = event;
-                });
-                await lockA.acquire();
-                await LazyPromise.delay(DELAY_TIME);
-                expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: addListenerMany / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockProviderA.addListenerMany([KeyAcquiredLockEvent], (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                await lockProviderB.addListenerMany([KeyAcquiredLockEvent], (event) => {
-                    result_b = event;
-                });
-                await lockA.acquire();
-                await LazyPromise.delay(DELAY_TIME);
-                expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: removeListener / addListener / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockProviderA.addListener(KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                await lockProviderB.addListener(KeyAcquiredLockEvent, listenerB);
-                await lockProviderB.removeListener(KeyAcquiredLockEvent, listenerB);
-                await lockA.acquire();
-                await lockB.acquire();
-                await LazyPromise.delay(DELAY_TIME);
-                expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: removeListenerMany / addListener / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockProviderA.addListener(KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                await lockProviderB.addListener(KeyAcquiredLockEvent, listenerB);
-                await lockProviderB.removeListenerMany([KeyAcquiredLockEvent], listenerB);
-                await lockA.acquire();
-                await lockB.acquire();
-                await LazyPromise.delay(DELAY_TIME);
-                expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: subscribe / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockProviderA.subscribe(KeyAcquiredLockEvent, (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                const unsubscribe = await lockProviderB.subscribe(KeyAcquiredLockEvent, listenerB);
-                await unsubscribe();
-                await lockA.acquire();
-                await lockB.acquire();
-                await LazyPromise.delay(DELAY_TIME);
-                expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-            test("method: subscribeMany / dispatch", async () => {
-                let result_a = null;
-                const key = "a";
-                const lockA = lockProviderA.create(key);
-                await lockProviderA.subscribeMany([KeyAcquiredLockEvent], (event) => {
-                    result_a = event;
-                });
-                let result_b = null;
-                const listenerB = (event) => {
-                    result_b = event;
-                };
-                const lockB = lockProviderB.create(key);
-                const unsubscribe = await lockProviderB.subscribeMany([KeyAcquiredLockEvent], listenerB);
-                await unsubscribe();
-                await lockA.acquire();
-                await lockB.acquire();
-                await LazyPromise.delay(DELAY_TIME);
-                expect(result_a).toBeInstanceOf(KeyAcquiredLockEvent);
-                expect(result_b).toBeNull();
-            });
-        });
-    });
     describe("Serde tests:", () => {
         test("Should preserve state", async () => {
             const key = "a";
             const owner = "b";
-            const lock = lockProviderA.create(key, {
+            const lock = lockProvider.create(key, {
                 owner,
             });
             await lock.acquire();
@@ -2438,7 +1957,7 @@ export function lockProviderTestSuite(settings) {
         test("Should preserve owner", async () => {
             const key = "a";
             const owner = "b";
-            const lock = lockProviderA.create(key, {
+            const lock = lockProvider.create(key, {
                 owner,
             });
             const deserializedLock = serde.deserialize(serde.serialize(lock));
@@ -2448,7 +1967,7 @@ export function lockProviderTestSuite(settings) {
             const key = "a";
             const owner = "b";
             const ttl = TTL.multiply(2);
-            const lock = lockProviderA.create(key, {
+            const lock = lockProvider.create(key, {
                 owner,
                 ttl,
             });