@daiso-tech/core 0.32.0 → 0.33.0

package/dist/cache/implementations/test-utilities/cache.test-suite.js

@@ -10,7 +10,7 @@ import { LazyPromise } from "../../../async/_module-exports.js";
  * The <i>cacheTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link ICache}</i> with <i>vitest</i>.
  *
  * IMPORT_PATH: ```"@daiso-tech/core/cache/test-utilities"```
- * @group Test utilities
+ * @group TestUtilities
  * @example
  * ```ts
  * import { beforeEach, describe, expect, test } from "vitest";
@@ -36,426 +36,423 @@ import { LazyPromise } from "../../../async/_module-exports.js";
  */
 export function cacheTestSuite(settings) {
     const { expect, test, createCache, describe, beforeEach } = settings;
-    let cacheA;
-    let cacheB;
+    let cache;
     beforeEach(async () => {
-        const cache = await createCache();
-        cacheA = cache;
-        cacheB = cache.withGroup("b");
+        cache = await createCache();
     });
     const TTL = TimeSpan.fromMilliseconds(50);
     const DELAY_TIME = TimeSpan.fromMilliseconds(50);
     describe("Api tests:", () => {
         describe("method: exists", () => {
             test("Should return true when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.exists("a")).toBe(true);
+                expect(await cache.exists("a")).toBe(true);
             });
             test("Should return false when keys doesnt exists", async () => {
-                expect(await cacheA.exists("a")).toBe(false);
+                expect(await cache.exists("a")).toBe(false);
             });
             test("Should return false when key is experied", async () => {
-                await cacheA.add("a", 1, TTL);
+                await cache.add("a", 1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                expect(await cacheA.exists("a")).toBe(false);
+                expect(await cache.exists("a")).toBe(false);
             });
         });
         describe("method: missing", () => {
             test("Should return false when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.missing("a")).toBe(false);
+                expect(await cache.missing("a")).toBe(false);
             });
             test("Should return true when keys doesnt exists", async () => {
-                expect(await cacheA.missing("a")).toBe(true);
+                expect(await cache.missing("a")).toBe(true);
             });
             test("Should return true when key is experied", async () => {
-                await cacheA.add("a", 1, TTL);
+                await cache.add("a", 1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                expect(await cacheA.missing("a")).toBe(true);
+                expect(await cache.missing("a")).toBe(true);
             });
         });
         describe("method: get", () => {
             test("Should return the value when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.get("a")).toBe(1);
+                expect(await cache.get("a")).toBe(1);
             });
             test("Should return null when keys doesnt exists", async () => {
-                expect(await cacheA.get("a")).toBeNull();
+                expect(await cache.get("a")).toBeNull();
             });
             test("Should return null when key is experied", async () => {
-                await cacheA.add("a", 1, TTL);
+                await cache.add("a", 1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                expect(await cacheA.get("a")).toBeNull();
+                expect(await cache.get("a")).toBeNull();
             });
         });
         describe("method: getOrFail", () => {
             test("Should return the value when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.getOrFail("a")).toBe(1);
+                expect(await cache.getOrFail("a")).toBe(1);
             });
             test("Should throw an KeyNotFoundCacheError when keys doesnt exists", async () => {
-                await expect(cacheA.getOrFail("a")).rejects.toBeInstanceOf(KeyNotFoundCacheError);
+                await expect(cache.getOrFail("a")).rejects.toBeInstanceOf(KeyNotFoundCacheError);
             });
             test("Should throw an KeyNotFoundCacheError when key is experied", async () => {
-                await cacheA.add("a", 1, TTL);
+                await cache.add("a", 1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                await expect(cacheA.getOrFail("a")).rejects.toBeInstanceOf(KeyNotFoundCacheError);
+                await expect(cache.getOrFail("a")).rejects.toBeInstanceOf(KeyNotFoundCacheError);
             });
         });
         describe("method: getOr", () => {
             test("Should return value when key exists", async () => {
-                await cacheA.add("a", 1);
-                expect(await cacheA.getOr("a", -1)).toBe(1);
+                await cache.add("a", 1);
+                expect(await cache.getOr("a", -1)).toBe(1);
             });
             describe("Should return default value when key doesnt exists", () => {
                 test("Value", async () => {
-                    expect(await cacheA.getOr("a", -1)).toBe(-1);
+                    expect(await cache.getOr("a", -1)).toBe(-1);
                 });
                 test("Function", async () => {
-                    expect(await cacheA.getOr("a", () => -1)).toBe(-1);
+                    expect(await cache.getOr("a", () => -1)).toBe(-1);
                 });
                 test("Async function", async () => {
-                    expect(await cacheA.getOr("a", () => Promise.resolve(-1))).toBe(-1);
+                    expect(await cache.getOr("a", () => Promise.resolve(-1))).toBe(-1);
                 });
                 test("LazyPromise", async () => {
-                    expect(await cacheA.getOr("a", new LazyPromise(() => Promise.resolve(-1)))).toBe(-1);
+                    expect(await cache.getOr("a", new LazyPromise(() => Promise.resolve(-1)))).toBe(-1);
                 });
             });
             describe("Should return default value when key is expired", () => {
                 test("Value", async () => {
-                    await cacheA.add("a", 1, TTL);
+                    await cache.add("a", 1, TTL);
                     await LazyPromise.delay(TTL);
-                    expect(await cacheA.getOr("a", -1)).toBe(-1);
+                    expect(await cache.getOr("a", -1)).toBe(-1);
                 });
                 test("Function", async () => {
-                    await cacheA.add("a", 1, TTL);
+                    await cache.add("a", 1, TTL);
                     await LazyPromise.delay(TTL);
-                    expect(await cacheA.getOr("a", () => -1)).toBe(-1);
+                    expect(await cache.getOr("a", () => -1)).toBe(-1);
                 });
                 test("Async function", async () => {
-                    await cacheA.add("a", 1, TTL);
+                    await cache.add("a", 1, TTL);
                     await LazyPromise.delay(TTL);
-                    expect(await cacheA.getOr("a", () => Promise.resolve(-1))).toBe(-1);
+                    expect(await cache.getOr("a", () => Promise.resolve(-1))).toBe(-1);
                 });
                 test("LazyPromise", async () => {
-                    await cacheA.add("a", 1, TTL);
+                    await cache.add("a", 1, TTL);
                     await LazyPromise.delay(TTL);
-                    expect(await cacheA.getOr("a", new LazyPromise(() => Promise.resolve(-1)))).toBe(-1);
+                    expect(await cache.getOr("a", new LazyPromise(() => Promise.resolve(-1)))).toBe(-1);
                 });
             });
         });
         describe("method: getAndRemove", () => {
             test("Should return value when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.getAndRemove("a")).toBe(1);
+                expect(await cache.getAndRemove("a")).toBe(1);
             });
             test("Should return null when key doesnt exists", async () => {
-                expect(await cacheA.getAndRemove("a")).toBeNull();
+                expect(await cache.getAndRemove("a")).toBeNull();
             });
             test("Should return null when key is expired", async () => {
-                await cacheA.add("a", 1, TTL);
+                await cache.add("a", 1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                expect(await cacheA.getAndRemove("a")).toBeNull();
+                expect(await cache.getAndRemove("a")).toBeNull();
             });
             test("Should persist removal when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                await cacheA.getAndRemove("a");
+                await cache.getAndRemove("a");
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.get("a")).toBeNull();
+                expect(await cache.get("a")).toBeNull();
             });
         });
         describe("method: getOrAdd", () => {
             test("Should return value when key exists", async () => {
-                await cacheA.add("a", 1);
-                expect(await cacheA.getOrAdd("a", -1)).toBe(1);
+                await cache.add("a", 1);
+                expect(await cache.getOrAdd("a", -1)).toBe(1);
             });
             describe("Should persist insertion when key doesnt exists", () => {
                 test("Value", async () => {
-                    await cacheA.getOrAdd("a", -1);
-                    expect(await cacheA.get("a")).toBe(-1);
+                    await cache.getOrAdd("a", -1);
+                    expect(await cache.get("a")).toBe(-1);
                 });
                 test("Function", async () => {
-                    await cacheA.getOrAdd("a", () => -1);
-                    expect(await cacheA.get("a")).toBe(-1);
+                    await cache.getOrAdd("a", () => -1);
+                    expect(await cache.get("a")).toBe(-1);
                 });
                 test("Async function", async () => {
-                    await cacheA.getOrAdd("a", () => Promise.resolve(-1));
-                    expect(await cacheA.get("a")).toBe(-1);
+                    await cache.getOrAdd("a", () => Promise.resolve(-1));
+                    expect(await cache.get("a")).toBe(-1);
                 });
                 test("LazyPromise", async () => {
-                    await cacheA.getOrAdd("a", new LazyPromise(() => Promise.resolve(-1)));
-                    expect(await cacheA.get("a")).toBe(-1);
+                    await cache.getOrAdd("a", new LazyPromise(() => Promise.resolve(-1)));
+                    expect(await cache.get("a")).toBe(-1);
                 });
             });
             describe("Should persist insertion when key is expired", () => {
                 test("Value", async () => {
-                    await cacheA.add("a", 1, TTL);
+                    await cache.add("a", 1, TTL);
                     await LazyPromise.delay(TTL);
-                    await cacheA.getOrAdd("a", -1);
-                    expect(await cacheA.get("a")).toBe(-1);
+                    await cache.getOrAdd("a", -1);
+                    expect(await cache.get("a")).toBe(-1);
                 });
                 test("Function", async () => {
-                    await cacheA.add("a", 1, TTL);
+                    await cache.add("a", 1, TTL);
                     await LazyPromise.delay(TTL);
-                    await cacheA.getOrAdd("a", () => -1);
-                    expect(await cacheA.get("a")).toBe(-1);
+                    await cache.getOrAdd("a", () => -1);
+                    expect(await cache.get("a")).toBe(-1);
                 });
                 test("Async function", async () => {
-                    await cacheA.add("a", 1, TTL);
+                    await cache.add("a", 1, TTL);
                     await LazyPromise.delay(TTL);
-                    await cacheA.getOrAdd("a", () => Promise.resolve(-1));
-                    expect(await cacheA.get("a")).toBe(-1);
+                    await cache.getOrAdd("a", () => Promise.resolve(-1));
+                    expect(await cache.get("a")).toBe(-1);
                 });
                 test("LazyPromise", async () => {
-                    await cacheA.add("a", 1, TTL);
+                    await cache.add("a", 1, TTL);
                     await LazyPromise.delay(TTL);
-                    await cacheA.getOrAdd("a", new LazyPromise(() => Promise.resolve(-1)));
-                    expect(await cacheA.get("a")).toBe(-1);
+                    await cache.getOrAdd("a", new LazyPromise(() => Promise.resolve(-1)));
+                    expect(await cache.get("a")).toBe(-1);
                 });
             });
         });
         describe("method: add", () => {
             test("Should return true when key doesnt exists", async () => {
-                const result = await cacheA.add("a", 1, null);
+                const result = await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
                 expect(result).toBe(true);
             });
             test("Should return true when key is expired", async () => {
-                await cacheA.add("a", 1, TTL);
+                await cache.add("a", 1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                expect(await cacheA.add("a", 1, null)).toBe(true);
+                expect(await cache.add("a", 1, null)).toBe(true);
             });
             test("Should persist values when key doesnt exist", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.get("a")).toBe(1);
+                expect(await cache.get("a")).toBe(1);
             });
             test("Should persist values when key is expired", async () => {
-                await cacheA.add("a", -1, TTL);
+                await cache.add("a", -1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                await cacheA.add("a", 1, null);
-                expect(await cacheA.get("a")).toBe(1);
+                await cache.add("a", 1, null);
+                expect(await cache.get("a")).toBe(1);
             });
             test("Should return false when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.add("a", 1, null)).toBe(false);
+                expect(await cache.add("a", 1, null)).toBe(false);
             });
             test("Should not persist value when key exist", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                await cacheA.add("a", 2, null);
+                await cache.add("a", 2, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.get("a")).toBe(1);
+                expect(await cache.get("a")).toBe(1);
             });
         });
         describe("method: put", () => {
             test("Should return true when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.put("a", -1, null)).toBe(true);
+                expect(await cache.put("a", -1, null)).toBe(true);
             });
             test("Should persist value when key exist", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                await cacheA.put("a", -1, null);
+                await cache.put("a", -1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.get("a")).toBe(-1);
+                expect(await cache.get("a")).toBe(-1);
             });
             test("Should return false when key doesnt exists", async () => {
-                expect(await cacheA.put("a", -1, null)).toBe(false);
+                expect(await cache.put("a", -1, null)).toBe(false);
             });
             test("Should return false when key is expired", async () => {
-                await cacheA.add("a", 1, TTL);
+                await cache.add("a", 1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                expect(await cacheA.put("a", -1, null)).toBe(false);
+                expect(await cache.put("a", -1, null)).toBe(false);
             });
             test("Should persist values when key doesnt exist", async () => {
-                await cacheA.put("a", -1, null);
+                await cache.put("a", -1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.get("a")).toBe(-1);
+                expect(await cache.get("a")).toBe(-1);
             });
             test("Should persist values when key is expired", async () => {
-                await cacheA.add("a", 1, TTL);
+                await cache.add("a", 1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                await cacheA.put("a", -1, null);
+                await cache.put("a", -1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.get("a")).toBe(-1);
+                expect(await cache.get("a")).toBe(-1);
             });
             test("Should replace the ttl value", async () => {
                 const ttlA = TimeSpan.fromMilliseconds(100);
-                await cacheA.add("a", 1, ttlA);
+                await cache.add("a", 1, ttlA);
                 await LazyPromise.delay(TTL.divide(4));
                 const ttlB = TimeSpan.fromMilliseconds(50);
-                await cacheA.put("a", -1, ttlB);
+                await cache.put("a", -1, ttlB);
                 await LazyPromise.delay(ttlB);
-                expect(await cacheA.get("a")).toBeNull();
+                expect(await cache.get("a")).toBeNull();
             });
         });
         describe("method: update", () => {
             test("Should return true when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.update("a", -1)).toBe(true);
+                expect(await cache.update("a", -1)).toBe(true);
             });
             test("Should persist value when key exist", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                await cacheA.update("a", -1);
+                await cache.update("a", -1);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.get("a")).toBe(-1);
+                expect(await cache.get("a")).toBe(-1);
             });
             test("Should return false when key doesnt exists", async () => {
-                expect(await cacheA.update("a", -1)).toBe(false);
+                expect(await cache.update("a", -1)).toBe(false);
             });
             test("Should return false when key is expired", async () => {
-                await cacheA.add("a", 1, TTL);
+                await cache.add("a", 1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                expect(await cacheA.update("a", -1)).toBe(false);
+                expect(await cache.update("a", -1)).toBe(false);
             });
             test("Should not persist value when key doesnt exist", async () => {
-                await cacheA.update("a", -1);
+                await cache.update("a", -1);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.get("a")).toBeNull();
+                expect(await cache.get("a")).toBeNull();
             });
             test("Should not persist value when key is expired", async () => {
-                await cacheA.add("a", 1, TTL);
+                await cache.add("a", 1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                await cacheA.update("a", -1);
-                expect(await cacheA.get("a")).toBeNull();
+                await cache.update("a", -1);
+                expect(await cache.get("a")).toBeNull();
             });
         });
         describe("method: increment", () => {
             test("Should return true when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.increment("a", 1)).toBe(true);
+                expect(await cache.increment("a", 1)).toBe(true);
             });
             test("Should persist increment when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                await cacheA.increment("a", 1);
+                await cache.increment("a", 1);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.get("a")).toBe(2);
+                expect(await cache.get("a")).toBe(2);
             });
             test("Should return false when key doesnt exists", async () => {
-                expect(await cacheA.increment("a", 1)).toBe(false);
+                expect(await cache.increment("a", 1)).toBe(false);
             });
             test("Should return false when key is expired", async () => {
-                await cacheA.add("a", 1, TTL);
+                await cache.add("a", 1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                expect(await cacheA.increment("a", 1)).toBe(false);
+                expect(await cache.increment("a", 1)).toBe(false);
             });
             test("Should not persist increment when key doesnt exists", async () => {
-                await cacheA.increment("a", 1);
+                await cache.increment("a", 1);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.get("a")).toBeNull();
+                expect(await cache.get("a")).toBeNull();
             });
             test("Should not persist increment when key is expired", async () => {
-                await cacheA.add("a", 1, TTL);
+                await cache.add("a", 1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                await cacheA.increment("a", 1);
-                expect(await cacheA.get("a")).toBeNull();
+                await cache.increment("a", 1);
+                expect(await cache.get("a")).toBeNull();
             });
             test("Should throw TypeCacheError key value is not number type", async () => {
-                await cacheA.add("a", "str", null);
+                await cache.add("a", "str", null);
                 await LazyPromise.delay(TTL.divide(4));
-                await expect(cacheA.increment("a", 1)).rejects.toBeInstanceOf(TypeCacheError);
+                await expect(cache.increment("a", 1)).rejects.toBeInstanceOf(TypeCacheError);
             });
         });
         describe("method: decrement", () => {
             test("Should return true when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.decrement("a", 1)).toBe(true);
+                expect(await cache.decrement("a", 1)).toBe(true);
             });
             test("Should persist decrement when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                await cacheA.decrement("a", 1);
+                await cache.decrement("a", 1);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.get("a")).toBe(0);
+                expect(await cache.get("a")).toBe(0);
             });
             test("Should return false when key doesnt exists", async () => {
-                expect(await cacheA.decrement("a", 1)).toBe(false);
+                expect(await cache.decrement("a", 1)).toBe(false);
             });
             test("Should return false when key is expired", async () => {
-                await cacheA.add("a", 1, TTL);
+                await cache.add("a", 1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                expect(await cacheA.decrement("a", 1)).toBe(false);
+                expect(await cache.decrement("a", 1)).toBe(false);
             });
             test("Should not persist decrement when key doesnt exists", async () => {
-                await cacheA.decrement("a", 1);
+                await cache.decrement("a", 1);
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.get("a")).toBeNull();
+                expect(await cache.get("a")).toBeNull();
             });
             test("Should not persist decrement when key is expired", async () => {
-                await cacheA.add("a", 1, TTL);
+                await cache.add("a", 1, TTL);
                 await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
-                await cacheA.decrement("a", 1);
-                expect(await cacheA.get("a")).toBeNull();
+                await cache.decrement("a", 1);
+                expect(await cache.get("a")).toBeNull();
             });
             test("Should throw TypeCacheError key value is not number type", async () => {
-                await cacheA.add("a", "str", null);
+                await cache.add("a", "str", null);
                 await LazyPromise.delay(TTL.divide(4));
-                await expect(cacheA.decrement("a", 1)).rejects.toBeInstanceOf(TypeCacheError);
+                await expect(cache.decrement("a", 1)).rejects.toBeInstanceOf(TypeCacheError);
             });
         });
         describe("method: remove", () => {
             test("Should return true when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                const result = await cacheA.remove("a");
+                const result = await cache.remove("a");
                 expect(result).toBe(true);
             });
             test("Should persist the key removal when key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                await cacheA.remove("a");
+                await cache.remove("a");
                 await LazyPromise.delay(TTL.divide(4));
-                expect(await cacheA.get("a")).toEqual(null);
+                expect(await cache.get("a")).toEqual(null);
             });
         });
         describe("method: removeMany", () => {
             test("Should return true when one key exists", async () => {
-                await cacheA.add("a", 1, null);
+                await cache.add("a", 1, null);
                 await LazyPromise.delay(TTL.divide(4));
-                const result = await cacheA.removeMany(["a", "b", "c"]);
+                const result = await cache.removeMany(["a", "b", "c"]);
                 expect(result).toBe(true);
             });
             test("Should persist removal of the keys that exists", async () => {
-                await cacheA.add("a", 1, null);
-                await cacheA.add("b", 2, null);
-                await cacheA.add("c", 3, null);
+                await cache.add("a", 1, null);
+                await cache.add("b", 2, null);
+                await cache.add("c", 3, null);
                 await LazyPromise.delay(TTL.divide(4));
-                await cacheA.removeMany(["a", "b"]);
+                await cache.removeMany(["a", "b"]);
                 await LazyPromise.delay(TTL.divide(4));
                 const result = [
-                    await cacheA.get("a"),
-                    await cacheA.get("b"),
-                    await cacheA.get("c"),
+                    await cache.get("a"),
+                    await cache.get("b"),
+                    await cache.get("c"),
                 ];
                 expect(result).toEqual([null, null, 3]);
             });
         });
         describe("method: clear", () => {
             test("Should remove all keys", async () => {
-                await cacheA.add("a", 1);
-                await cacheA.add("b", 2);
-                await cacheA.add("c", 3);
-                await cacheA.add("d", 4);
-                await cacheA.clear();
+                await cache.add("a", 1);
+                await cache.add("b", 2);
+                await cache.add("c", 3);
+                await cache.add("d", 4);
+                await cache.clear();
                 const result = [
-                    await cacheA.get("a"),
-                    await cacheA.get("b"),
-                    await cacheA.get("c"),
-                    await cacheA.get("d"),
+                    await cache.get("a"),
+                    await cache.get("b"),
+                    await cache.get("c"),
+                    await cache.get("d"),
                 ];
                 expect(result).toStrictEqual([null, null, null, null]);
             });
@@ -465,10 +462,10 @@ export function cacheTestSuite(settings) {
         describe("method: exists", () => {
             test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.exists("a");
+                await cache.exists("a");
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -476,11 +473,11 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.add("a", 1);
-                await cacheA.exists("a");
+                await cache.add("a", 1);
+                await cache.exists("a");
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -491,10 +488,10 @@ export function cacheTestSuite(settings) {
         describe("method: missing", () => {
             test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.missing("a");
+                await cache.missing("a");
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -502,11 +499,11 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.add("a", 1);
-                await cacheA.missing("a");
+                await cache.add("a", 1);
+                await cache.missing("a");
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -517,10 +514,10 @@ export function cacheTestSuite(settings) {
         describe("method: get", () => {
             test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.get("a");
+                await cache.get("a");
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -528,11 +525,11 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.add("a", 1);
-                await cacheA.get("a");
+                await cache.add("a", 1);
+                await cache.get("a");
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -543,10 +540,10 @@ export function cacheTestSuite(settings) {
         describe("method: getOr", () => {
             test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.getOr("a", 1);
+                await cache.getOr("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -554,11 +551,11 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.add("a", 1);
-                await cacheA.getOr("a", 1);
+                await cache.add("a", 1);
+                await cache.getOr("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -569,11 +566,11 @@ export function cacheTestSuite(settings) {
         describe("method: getOrFail", () => {
             test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
                     event_ = event;
                 });
                 try {
-                    await cacheA.getOrFail("a");
+                    await cache.getOrFail("a");
                 }
                 catch {
                     /* Empty */
@@ -585,11 +582,11 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.add("a", 1);
-                await cacheA.getOrFail("a");
+                await cache.add("a", 1);
+                await cache.getOrFail("a");
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -600,11 +597,11 @@ export function cacheTestSuite(settings) {
         describe("method: add", () => {
             test("Should dispatch KeyAddedCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyAddedCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyAddedCacheEvent, (event) => {
                     event_ = event;
                 });
                 const ttl = TimeSpan.fromMilliseconds(20);
-                await cacheA.add("a", 1, ttl);
+                await cache.add("a", 1, ttl);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyAddedCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -616,11 +613,11 @@ export function cacheTestSuite(settings) {
         describe("method: update", () => {
             test("Should dispatch KeyUpdatedCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyUpdatedCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyUpdatedCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.add("a", 1);
-                await cacheA.update("a", 2);
+                await cache.add("a", 1);
+                await cache.update("a", 2);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyUpdatedCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -629,10 +626,10 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.update("a", 2);
+                await cache.update("a", 2);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -642,11 +639,11 @@ export function cacheTestSuite(settings) {
         describe("method: put", () => {
             test("Should dispatch KeyAddedCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyAddedCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyAddedCacheEvent, (event) => {
                     event_ = event;
                 });
                 const ttl = TimeSpan.fromMilliseconds(20);
-                await cacheA.put("a", 1, ttl);
+                await cache.put("a", 1, ttl);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyAddedCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -656,11 +653,11 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyUpdatedCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyUpdatedCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyUpdatedCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.put("a", 1);
-                await cacheA.put("a", 2);
+                await cache.put("a", 1);
+                await cache.put("a", 2);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyUpdatedCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -671,11 +668,11 @@ export function cacheTestSuite(settings) {
         describe("method: remove", () => {
             test("Should dispatch KeyRemovedCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyRemovedCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyRemovedCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.add("a", 1);
-                await cacheA.remove("a");
+                await cache.add("a", 1);
+                await cache.remove("a");
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyRemovedCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -683,10 +680,10 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.remove("a");
+                await cache.remove("a");
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -696,11 +693,11 @@ export function cacheTestSuite(settings) {
         describe("method: removeMany", () => {
             test("Should dispatch KeyRemovedCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyRemovedCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyRemovedCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.add("a", 1);
-                await cacheA.removeMany(["a"]);
+                await cache.add("a", 1);
+                await cache.removeMany(["a"]);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyRemovedCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -708,10 +705,10 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.removeMany(["a"]);
+                await cache.removeMany(["a"]);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -721,10 +718,10 @@ export function cacheTestSuite(settings) {
         describe("method: getAndRemove", () => {
             test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.getAndRemove("a");
+                await cache.getAndRemove("a");
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -732,11 +729,11 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.add("a", 1);
-                await cacheA.getAndRemove("a");
+                await cache.add("a", 1);
+                await cache.getAndRemove("a");
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -745,11 +742,11 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyRemovedCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyRemovedCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyRemovedCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.add("a", 1);
-                await cacheA.getAndRemove("a");
+                await cache.add("a", 1);
+                await cache.getAndRemove("a");
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyRemovedCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -759,10 +756,10 @@ export function cacheTestSuite(settings) {
         describe("method: getOrAdd", () => {
             test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.getOrAdd("a", 1);
+                await cache.getOrAdd("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -770,11 +767,11 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyFoundCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.add("a", 1);
-                await cacheA.getOrAdd("a", 1);
+                await cache.add("a", 1);
+                await cache.getOrAdd("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -783,11 +780,11 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyAddedCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyAddedCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyAddedCacheEvent, (event) => {
                     event_ = event;
                 });
                 const ttl = TimeSpan.fromMilliseconds(50);
-                await cacheA.getOrAdd("a", 1, ttl);
+                await cache.getOrAdd("a", 1, ttl);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyAddedCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -799,11 +796,11 @@ export function cacheTestSuite(settings) {
         describe("method: increment", () => {
             test("Should dispatch KeyIncrementedCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyIncrementedCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyIncrementedCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.add("a", 1);
-                await cacheA.increment("a", 1);
+                await cache.add("a", 1);
+                await cache.increment("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyIncrementedCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -812,10 +809,10 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.increment("a", 1);
+                await cache.increment("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -825,11 +822,11 @@ export function cacheTestSuite(settings) {
         describe("method: decrement", () => {
             test("Should dispatch KeyDecrementedCacheEvent when key exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyDecrementedCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyDecrementedCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.add("a", 1);
-                await cacheA.decrement("a", 1);
+                await cache.add("a", 1);
+                await cache.decrement("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyDecrementedCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -838,10 +835,10 @@ export function cacheTestSuite(settings) {
             });
             test("Should dispatch KeyNotFoundCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeyNotFoundCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeyNotFoundCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.decrement("a", 1);
+                await cache.decrement("a", 1);
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeyNotFoundCacheEvent);
                 expect(event_?.fields.key).toBe("a");
@@ -851,209 +848,18 @@ export function cacheTestSuite(settings) {
         describe("method: clear", () => {
             test("Should dispatch KeysClearedCacheEvent when key doesnt exists", async () => {
                 let event_ = null;
-                const unsubscribe = await cacheA.subscribe(KeysClearedCacheEvent, (event) => {
+                const unsubscribe = await cache.subscribe(KeysClearedCacheEvent, (event) => {
                     event_ = event;
                 });
-                await cacheA.add("a", 1);
-                await cacheA.add("b", 2);
-                await cacheA.add("c", 3);
-                await cacheA.clear();
+                await cache.add("a", 1);
+                await cache.add("b", 2);
+                await cache.add("c", 3);
+                await cache.clear();
                 await LazyPromise.delay(DELAY_TIME);
                 expect(event_).toBeInstanceOf(KeysClearedCacheEvent);
                 await unsubscribe();
             });
         });
     });
-    describe("Group tests:", () => {
-        test("method: exists", async () => {
-            await cacheA.put("a", 1);
-            expect(await cacheA.exists("a")).toBe(true);
-            expect(await cacheB.exists("a")).toBe(false);
-        });
-        test("method: missing", async () => {
-            await cacheA.put("a", 1);
-            expect(await cacheA.missing("a")).toBe(false);
-            expect(await cacheB.missing("a")).toBe(true);
-        });
-        test("method: get", async () => {
-            await cacheA.put("a", 1);
-            expect(await cacheA.get("a")).toBe(1);
-            expect(await cacheB.get("a")).toBeNull();
-        });
-        test("method: getOr", async () => {
-            await cacheA.put("a", 1);
-            expect(await cacheA.getOr("a", -1)).toBe(1);
-            expect(await cacheB.getOr("a", -1)).toBe(-1);
-        });
-        test("method: getOrFail", async () => {
-            await cacheA.put("a", 1);
-            expect(await cacheA.getOrFail("a")).toBe(1);
-            await expect(cacheB.getOrFail("a")).rejects.toBeInstanceOf(KeyNotFoundCacheError);
-        });
-        test("method: add", async () => {
-            await cacheA.add("a", 1);
-            await cacheB.add("a", 2);
-            expect(await cacheA.get("a")).toBe(1);
-            expect(await cacheB.get("a")).toBe(2);
-        });
-        test("method: update", async () => {
-            await cacheA.add("a", 1);
-            await cacheB.add("a", 1);
-            await cacheA.update("a", 2);
-            await cacheB.update("a", 3);
-            expect(await cacheA.get("a")).toBe(2);
-            expect(await cacheB.get("a")).toBe(3);
-        });
-        test("method: put", async () => {
-            await cacheA.put("a", 2);
-            await cacheB.put("a", 3);
-            expect(await cacheA.get("a")).toBe(2);
-            expect(await cacheB.get("a")).toBe(3);
-        });
-        test("method: remove", async () => {
-            await cacheA.add("a", 1);
-            await cacheB.add("a", 1);
-            await cacheA.remove("a");
-            expect(await cacheA.get("a")).toBeNull();
-            expect(await cacheB.get("a")).toBe(1);
-        });
-        test("method: getAndRemove", async () => {
-            await cacheA.add("a", 1);
-            await cacheB.add("a", 2);
-            expect(await cacheA.getAndRemove("a")).toBe(1);
-            expect(await cacheA.get("a")).toBeNull();
-            expect(await cacheB.get("a")).toBe(2);
-        });
-        test("method: getOrAdd", async () => {
-            await cacheA.getOrAdd("a", 1);
-            await cacheB.getOrAdd("a", 2);
-            expect(await cacheA.get("a")).toBe(1);
-            expect(await cacheB.get("a")).toBe(2);
-        });
-        test("method: increment", async () => {
-            await cacheA.add("a", 1);
-            await cacheB.add("a", 1);
-            await cacheA.increment("a", 1);
-            expect(await cacheA.get("a")).toBe(2);
-            expect(await cacheB.get("a")).toBe(1);
-        });
-        test("method: decrement", async () => {
-            await cacheA.add("a", 1);
-            await cacheB.add("a", 1);
-            await cacheA.decrement("a", 1);
-            expect(await cacheA.get("a")).toBe(0);
-            expect(await cacheB.get("a")).toBe(1);
-        });
-        test("method: clear", async () => {
-            await cacheA.add("a", 1);
-            await cacheA.add("b", 2);
-            await cacheB.add("a", 3);
-            await cacheB.add("b", 4);
-            await cacheA.clear();
-            const resultA = [
-                await cacheA.get("a"),
-                await cacheA.get("b"),
-                await cacheB.get("a"),
-                await cacheB.get("b"),
-            ];
-            expect(resultA).toEqual([null, null, 3, 4]);
-        });
-        test("method: addListener / dispatch", async () => {
-            let result_a = null;
-            await cacheA.addListener(KeyAddedCacheEvent, (event) => {
-                result_a = event;
-            });
-            let result_b = null;
-            await cacheB.addListener(KeyAddedCacheEvent, (event) => {
-                result_b = event;
-            });
-            await cacheA.add("a", 1);
-            await LazyPromise.delay(DELAY_TIME);
-            expect(result_a).toBeInstanceOf(KeyAddedCacheEvent);
-            expect(result_b).toBeNull();
-        });
-        test("method: addListenerMany / dispatch", async () => {
-            let result_a = null;
-            await cacheA.addListenerMany([KeyAddedCacheEvent], (event) => {
-                result_a = event;
-            });
-            let result_b = null;
-            await cacheB.addListenerMany([KeyAddedCacheEvent], (event) => {
-                result_b = event;
-            });
-            await cacheA.add("a", 1);
-            await LazyPromise.delay(DELAY_TIME);
-            expect(result_a).toBeInstanceOf(KeyAddedCacheEvent);
-            expect(result_b).toBeNull();
-        });
-        test("method: removeListener / addListener / dispatch", async () => {
-            let result_a = null;
-            await cacheA.addListener(KeyAddedCacheEvent, (event) => {
-                result_a = event;
-            });
-            let result_b = null;
-            const listenerB = (event) => {
-                result_b = event;
-            };
-            await cacheB.addListener(KeyAddedCacheEvent, listenerB);
-            await cacheB.removeListener(KeyAddedCacheEvent, listenerB);
-            await cacheA.add("a", 1);
-            await cacheB.add("a", 1);
-            await LazyPromise.delay(DELAY_TIME);
-            expect(result_a).toBeInstanceOf(KeyAddedCacheEvent);
-            expect(result_b).toBeNull();
-        });
-        test("method: removeListenerMany / addListener / dispatch", async () => {
-            let result_a = null;
-            await cacheA.addListener(KeyAddedCacheEvent, (event) => {
-                result_a = event;
-            });
-            let result_b = null;
-            const listenerB = (event) => {
-                result_b = event;
-            };
-            await cacheB.addListener(KeyAddedCacheEvent, listenerB);
-            await cacheB.removeListenerMany([KeyAddedCacheEvent], listenerB);
-            await cacheA.add("a", 1);
-            await cacheB.add("a", 1);
-            await LazyPromise.delay(DELAY_TIME);
-            expect(result_a).toBeInstanceOf(KeyAddedCacheEvent);
-            expect(result_b).toBeNull();
-        });
-        test("method: subscribe / dispatch", async () => {
-            let result_a = null;
-            await cacheA.subscribe(KeyAddedCacheEvent, (event) => {
-                result_a = event;
-            });
-            let result_b = null;
-            const listenerB = (event) => {
-                result_b = event;
-            };
-            const unsubscribe = await cacheB.subscribe(KeyAddedCacheEvent, listenerB);
-            await unsubscribe();
-            await cacheA.add("a", 1);
-            await cacheB.add("a", 1);
-            await LazyPromise.delay(DELAY_TIME);
-            expect(result_a).toBeInstanceOf(KeyAddedCacheEvent);
-            expect(result_b).toBeNull();
-        });
-        test("method: subscribeMany / dispatch", async () => {
-            let result_a = null;
-            await cacheA.subscribeMany([KeyAddedCacheEvent], (event) => {
-                result_a = event;
-            });
-            let result_b = null;
-            const listenerB = (event) => {
-                result_b = event;
-            };
-            const unsubscribe = await cacheB.subscribeMany([KeyAddedCacheEvent], listenerB);
-            await unsubscribe();
-            await cacheA.add("a", 1);
-            await cacheB.add("a", 1);
-            await LazyPromise.delay(DELAY_TIME);
-            expect(result_a).toBeInstanceOf(KeyAddedCacheEvent);
-            expect(result_b).toBeNull();
-        });
-    });
 }
 //# sourceMappingURL=cache.test-suite.js.map