@daiso-tech/core 0.40.0 → 0.41.1

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

@@ -2,10 +2,10 @@
  * @module Cache
  */
 import {} from "vitest";
-import { KeyNotFoundCacheError, TypeCacheError, CACHE_EVENTS, } from "../../../cache/contracts/_module-exports.js";
+import { KeyNotFoundCacheError, CACHE_EVENTS, } from "../../../cache/contracts/_module-exports.js";
 import {} from "../../../utilities/_module-exports.js";
-import { TimeSpan } from "../../../utilities/_module-exports.js";
-import { LazyPromise } from "../../../async/_module-exports.js";
+import { Task } from "../../../task/_module-exports.js";
+import { TimeSpan } from "../../../time-span/implementations/_module-exports.js";
 /**
  * The `cacheTestSuite` function simplifies the process of testing your custom implementation of {@link ICache | `ICache`} with `vitest`.
  *
@@ -45,7 +45,7 @@ export function cacheTestSuite(settings) {
         describe("method: exists", () => {
             test("Should return true when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.exists("a")).toBe(true);
             });
             test("Should return false when keys doesnt exists", async () => {
@@ -53,14 +53,14 @@ export function cacheTestSuite(settings) {
             });
             test("Should return false when key is experied", async () => {
                 await cache.add("a", 1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 expect(await cache.exists("a")).toBe(false);
             });
         });
         describe("method: missing", () => {
             test("Should return false when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.missing("a")).toBe(false);
             });
             test("Should return true when keys doesnt exists", async () => {
@@ -68,14 +68,14 @@ export function cacheTestSuite(settings) {
             });
             test("Should return true when key is experied", async () => {
                 await cache.add("a", 1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 expect(await cache.missing("a")).toBe(true);
             });
         });
         describe("method: get", () => {
             test("Should return the value when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.get("a")).toBe(1);
             });
             test("Should return null when keys doesnt exists", async () => {
@@ -83,14 +83,14 @@ export function cacheTestSuite(settings) {
             });
             test("Should return null when key is experied", async () => {
                 await cache.add("a", 1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 expect(await cache.get("a")).toBeNull();
             });
         });
         describe("method: getOrFail", () => {
             test("Should return the value when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.getOrFail("a")).toBe(1);
             });
             test("Should throw an KeyNotFoundCacheError when keys doesnt exists", async () => {
@@ -98,7 +98,7 @@ export function cacheTestSuite(settings) {
             });
             test("Should throw an KeyNotFoundCacheError when key is experied", async () => {
                 await cache.add("a", 1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 await expect(cache.getOrFail("a")).rejects.toBeInstanceOf(KeyNotFoundCacheError);
             });
         });
@@ -117,37 +117,37 @@ export function cacheTestSuite(settings) {
                 test("Async function", async () => {
                     expect(await cache.getOr("a", () => Promise.resolve(-1))).toBe(-1);
                 });
-                test("LazyPromise", async () => {
-                    expect(await cache.getOr("a", new LazyPromise(() => Promise.resolve(-1)))).toBe(-1);
+                test("Task", async () => {
+                    expect(await cache.getOr("a", new Task(() => Promise.resolve(-1)))).toBe(-1);
                 });
             });
             describe("Should return default value when key is expired", () => {
                 test("Value", async () => {
                     await cache.add("a", 1, TTL);
-                    await LazyPromise.delay(TTL);
+                    await Task.delay(TTL);
                     expect(await cache.getOr("a", -1)).toBe(-1);
                 });
                 test("Function", async () => {
                     await cache.add("a", 1, TTL);
-                    await LazyPromise.delay(TTL);
+                    await Task.delay(TTL);
                     expect(await cache.getOr("a", () => -1)).toBe(-1);
                 });
                 test("Async function", async () => {
                     await cache.add("a", 1, TTL);
-                    await LazyPromise.delay(TTL);
+                    await Task.delay(TTL);
                     expect(await cache.getOr("a", () => Promise.resolve(-1))).toBe(-1);
                 });
-                test("LazyPromise", async () => {
+                test("Task", async () => {
                     await cache.add("a", 1, TTL);
-                    await LazyPromise.delay(TTL);
-                    expect(await cache.getOr("a", new LazyPromise(() => Promise.resolve(-1)))).toBe(-1);
+                    await Task.delay(TTL);
+                    expect(await cache.getOr("a", new Task(() => Promise.resolve(-1)))).toBe(-1);
                 });
             });
         });
         describe("method: getAndRemove", () => {
             test("Should return value when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.getAndRemove("a")).toBe(1);
             });
             test("Should return null when key doesnt exists", async () => {
@@ -155,14 +155,14 @@ export function cacheTestSuite(settings) {
             });
             test("Should return null when key is expired", async () => {
                 await cache.add("a", 1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 expect(await cache.getAndRemove("a")).toBeNull();
             });
             test("Should persist removal when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 await cache.getAndRemove("a");
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.get("a")).toBeNull();
             });
         });
@@ -184,34 +184,34 @@ export function cacheTestSuite(settings) {
                     await cache.getOrAdd("a", () => Promise.resolve(-1));
                     expect(await cache.get("a")).toBe(-1);
                 });
-                test("LazyPromise", async () => {
-                    await cache.getOrAdd("a", new LazyPromise(() => Promise.resolve(-1)));
+                test("Task", async () => {
+                    await cache.getOrAdd("a", new Task(() => Promise.resolve(-1)));
                     expect(await cache.get("a")).toBe(-1);
                 });
             });
             describe("Should persist insertion when key is expired", () => {
                 test("Value", async () => {
                     await cache.add("a", 1, TTL);
-                    await LazyPromise.delay(TTL);
+                    await Task.delay(TTL);
                     await cache.getOrAdd("a", -1);
                     expect(await cache.get("a")).toBe(-1);
                 });
                 test("Function", async () => {
                     await cache.add("a", 1, TTL);
-                    await LazyPromise.delay(TTL);
+                    await Task.delay(TTL);
                     await cache.getOrAdd("a", () => -1);
                     expect(await cache.get("a")).toBe(-1);
                 });
                 test("Async function", async () => {
                     await cache.add("a", 1, TTL);
-                    await LazyPromise.delay(TTL);
+                    await Task.delay(TTL);
                     await cache.getOrAdd("a", () => Promise.resolve(-1));
                     expect(await cache.get("a")).toBe(-1);
                 });
-                test("LazyPromise", async () => {
+                test("Task", async () => {
                     await cache.add("a", 1, TTL);
-                    await LazyPromise.delay(TTL);
-                    await cache.getOrAdd("a", new LazyPromise(() => Promise.resolve(-1)));
+                    await Task.delay(TTL);
+                    await cache.getOrAdd("a", new Task(() => Promise.resolve(-1)));
                     expect(await cache.get("a")).toBe(-1);
                 });
             });
@@ -219,49 +219,49 @@ export function cacheTestSuite(settings) {
         describe("method: add", () => {
             test("Should return true when key doesnt exists", async () => {
                 const result = await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(result).toBe(true);
             });
             test("Should return true when key is expired", async () => {
                 await cache.add("a", 1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 expect(await cache.add("a", 1, null)).toBe(true);
             });
             test("Should persist values when key doesnt exist", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.get("a")).toBe(1);
             });
             test("Should persist values when key is expired", async () => {
                 await cache.add("a", -1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 await cache.add("a", 1, null);
                 expect(await cache.get("a")).toBe(1);
             });
             test("Should return false when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.add("a", 1, null)).toBe(false);
             });
             test("Should not persist value when key exist", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 await cache.add("a", 2, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.get("a")).toBe(1);
             });
         });
         describe("method: put", () => {
             test("Should return true when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.put("a", -1, null)).toBe(true);
             });
             test("Should persist value when key exist", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 await cache.put("a", -1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.get("a")).toBe(-1);
             });
             test("Should return false when key doesnt exists", async () => {
@@ -269,42 +269,42 @@ export function cacheTestSuite(settings) {
             });
             test("Should return false when key is expired", async () => {
                 await cache.add("a", 1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 expect(await cache.put("a", -1, null)).toBe(false);
             });
             test("Should persist values when key doesnt exist", async () => {
                 await cache.put("a", -1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.get("a")).toBe(-1);
             });
             test("Should persist values when key is expired", async () => {
                 await cache.add("a", 1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 await cache.put("a", -1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.get("a")).toBe(-1);
             });
             test("Should replace the ttl value", async () => {
                 const ttlA = TimeSpan.fromMilliseconds(100);
                 await cache.add("a", 1, ttlA);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 const ttlB = TimeSpan.fromMilliseconds(50);
                 await cache.put("a", -1, ttlB);
-                await LazyPromise.delay(ttlB);
+                await Task.delay(ttlB);
                 expect(await cache.get("a")).toBeNull();
             });
         });
         describe("method: update", () => {
             test("Should return true when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.update("a", -1)).toBe(true);
             });
             test("Should persist value when key exist", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 await cache.update("a", -1);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.get("a")).toBe(-1);
             });
             test("Should return false when key doesnt exists", async () => {
@@ -312,17 +312,17 @@ export function cacheTestSuite(settings) {
             });
             test("Should return false when key is expired", async () => {
                 await cache.add("a", 1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 expect(await cache.update("a", -1)).toBe(false);
             });
             test("Should not persist value when key doesnt exist", async () => {
                 await cache.update("a", -1);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.get("a")).toBeNull();
             });
             test("Should not persist value when key is expired", async () => {
                 await cache.add("a", 1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 await cache.update("a", -1);
                 expect(await cache.get("a")).toBeNull();
             });
@@ -330,14 +330,14 @@ export function cacheTestSuite(settings) {
         describe("method: increment", () => {
             test("Should return true when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.increment("a", 1)).toBe(true);
             });
             test("Should persist increment when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 await cache.increment("a", 1);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.get("a")).toBe(2);
             });
             test("Should return false when key doesnt exists", async () => {
@@ -345,37 +345,37 @@ export function cacheTestSuite(settings) {
             });
             test("Should return false when key is expired", async () => {
                 await cache.add("a", 1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 expect(await cache.increment("a", 1)).toBe(false);
             });
             test("Should not persist increment when key doesnt exists", async () => {
                 await cache.increment("a", 1);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.get("a")).toBeNull();
             });
             test("Should not persist increment when key is expired", async () => {
                 await cache.add("a", 1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 await cache.increment("a", 1);
                 expect(await cache.get("a")).toBeNull();
             });
-            test("Should throw TypeCacheError key value is not number type", async () => {
+            test("Should throw TypeError key value is not number type", async () => {
                 await cache.add("a", "str", null);
-                await LazyPromise.delay(TTL.divide(4));
-                await expect(cache.increment("a", 1)).rejects.toBeInstanceOf(TypeCacheError);
+                await Task.delay(TTL.divide(4));
+                await expect(cache.increment("a", 1)).rejects.toBeInstanceOf(TypeError);
             });
         });
         describe("method: decrement", () => {
             test("Should return true when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.decrement("a", 1)).toBe(true);
             });
             test("Should persist decrement when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 await cache.decrement("a", 1);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.get("a")).toBe(0);
             });
             test("Should return false when key doesnt exists", async () => {
@@ -383,45 +383,45 @@ export function cacheTestSuite(settings) {
             });
             test("Should return false when key is expired", async () => {
                 await cache.add("a", 1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 expect(await cache.decrement("a", 1)).toBe(false);
             });
             test("Should not persist decrement when key doesnt exists", async () => {
                 await cache.decrement("a", 1);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.get("a")).toBeNull();
             });
             test("Should not persist decrement when key is expired", async () => {
                 await cache.add("a", 1, TTL);
-                await LazyPromise.delay(TTL.addTimeSpan(TTL.divide(4)));
+                await Task.delay(TTL.addTimeSpan(TTL.divide(4)));
                 await cache.decrement("a", 1);
                 expect(await cache.get("a")).toBeNull();
             });
-            test("Should throw TypeCacheError key value is not number type", async () => {
+            test("Should throw TypeError key value is not number type", async () => {
                 await cache.add("a", "str", null);
-                await LazyPromise.delay(TTL.divide(4));
-                await expect(cache.decrement("a", 1)).rejects.toBeInstanceOf(TypeCacheError);
+                await Task.delay(TTL.divide(4));
+                await expect(cache.decrement("a", 1)).rejects.toBeInstanceOf(TypeError);
             });
         });
         describe("method: remove", () => {
             test("Should return true when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 const result = await cache.remove("a");
                 expect(result).toBe(true);
             });
             test("Should persist the key removal when key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 await cache.remove("a");
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 expect(await cache.get("a")).toEqual(null);
             });
         });
         describe("method: removeMany", () => {
             test("Should return true when one key exists", async () => {
                 await cache.add("a", 1, null);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 const result = await cache.removeMany(["a", "b", "c"]);
                 expect(result).toBe(true);
             });
@@ -429,9 +429,9 @@ export function cacheTestSuite(settings) {
                 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 Task.delay(TTL.divide(4));
                 await cache.removeMany(["a", "b"]);
-                await LazyPromise.delay(TTL.divide(4));
+                await Task.delay(TTL.divide(4));
                 const result = [
                     await cache.get("a"),
                     await cache.get("b"),
@@ -465,7 +465,7 @@ export function cacheTestSuite(settings) {
                     event_ = event;
                 });
                 await cache.exists("a");
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -476,7 +476,7 @@ export function cacheTestSuite(settings) {
                 });
                 await cache.add("a", 1);
                 await cache.exists("a");
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 expect(event_?.value).toBe(1);
                 await unsubscribe();
@@ -489,7 +489,7 @@ export function cacheTestSuite(settings) {
                     event_ = event;
                 });
                 await cache.missing("a");
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -500,7 +500,7 @@ export function cacheTestSuite(settings) {
                 });
                 await cache.add("a", 1);
                 await cache.missing("a");
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 expect(event_?.value).toBe(1);
                 await unsubscribe();
@@ -513,7 +513,7 @@ export function cacheTestSuite(settings) {
                     event_ = event;
                 });
                 await cache.get("a");
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -524,7 +524,7 @@ export function cacheTestSuite(settings) {
                 });
                 await cache.add("a", 1);
                 await cache.get("a");
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 expect(event_?.value).toBe(1);
                 await unsubscribe();
@@ -537,7 +537,7 @@ export function cacheTestSuite(settings) {
                     event_ = event;
                 });
                 await cache.getOr("a", 1);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -548,7 +548,7 @@ export function cacheTestSuite(settings) {
                 });
                 await cache.add("a", 1);
                 await cache.getOr("a", 1);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 expect(event_?.value).toBe(1);
                 await unsubscribe();
@@ -566,7 +566,7 @@ export function cacheTestSuite(settings) {
                 catch {
                     /* Empty */
                 }
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -577,7 +577,7 @@ export function cacheTestSuite(settings) {
                 });
                 await cache.add("a", 1);
                 await cache.getOrFail("a");
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 expect(event_?.value).toBe(1);
                 await unsubscribe();
@@ -593,7 +593,7 @@ export function cacheTestSuite(settings) {
                 });
                 const ttl = TimeSpan.fromMilliseconds(20);
                 await cache.add("a", 1, ttl);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 expect(event_?.value).toBe(1);
                 expect(event_?.ttl?.toMilliseconds()).toBe(ttl.toMilliseconds());
@@ -610,7 +610,7 @@ export function cacheTestSuite(settings) {
                 });
                 await cache.add("a", 1);
                 await cache.update("a", 2);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 expect(event_?.value).toBe(2);
                 await unsubscribe();
@@ -621,7 +621,7 @@ export function cacheTestSuite(settings) {
                     event_ = event;
                 });
                 await cache.update("a", 2);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -636,7 +636,7 @@ export function cacheTestSuite(settings) {
                 });
                 const ttl = TimeSpan.fromMilliseconds(20);
                 await cache.put("a", 1, ttl);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 expect(event_?.value).toBe(1);
                 expect(event_?.ttl?.toMilliseconds()).toBe(ttl.toMilliseconds());
@@ -651,7 +651,7 @@ export function cacheTestSuite(settings) {
                 });
                 await cache.put("a", 1);
                 await cache.put("a", 2);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 expect(event_?.value).toBe(2);
                 await unsubscribe();
@@ -667,7 +667,7 @@ export function cacheTestSuite(settings) {
                 });
                 await cache.add("a", 1);
                 await cache.remove("a");
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -677,7 +677,7 @@ export function cacheTestSuite(settings) {
                     event_ = event;
                 });
                 await cache.remove("a");
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -692,7 +692,7 @@ export function cacheTestSuite(settings) {
                 });
                 await cache.add("a", 1);
                 await cache.removeMany(["a"]);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -702,7 +702,7 @@ export function cacheTestSuite(settings) {
                     event_ = event;
                 });
                 await cache.removeMany(["a"]);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -714,7 +714,7 @@ export function cacheTestSuite(settings) {
                     event_ = event;
                 });
                 await cache.getAndRemove("a");
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -725,7 +725,7 @@ export function cacheTestSuite(settings) {
                 });
                 await cache.add("a", 1);
                 await cache.getAndRemove("a");
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 expect(event_?.value).toBe(1);
                 await unsubscribe();
@@ -739,7 +739,7 @@ export function cacheTestSuite(settings) {
                 });
                 await cache.add("a", 1);
                 await cache.getAndRemove("a");
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -751,7 +751,7 @@ export function cacheTestSuite(settings) {
                     event_ = event;
                 });
                 await cache.getOrAdd("a", 1);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -762,7 +762,7 @@ export function cacheTestSuite(settings) {
                 });
                 await cache.add("a", 1);
                 await cache.getOrAdd("a", 1);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 expect(event_?.value).toBe(1);
                 await unsubscribe();
@@ -776,7 +776,7 @@ export function cacheTestSuite(settings) {
                 });
                 const ttl = TimeSpan.fromMilliseconds(50);
                 await cache.getOrAdd("a", 1, ttl);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 expect(event_?.value).toBe(1);
                 expect(event_?.ttl?.toMilliseconds()).toBe(ttl.toMilliseconds());
@@ -793,7 +793,7 @@ export function cacheTestSuite(settings) {
                 });
                 await cache.add("a", 1);
                 await cache.increment("a", 1);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 expect(event_?.value).toBe(1);
                 await unsubscribe();
@@ -804,7 +804,7 @@ export function cacheTestSuite(settings) {
                     event_ = event;
                 });
                 await cache.increment("a", 1);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -819,7 +819,7 @@ export function cacheTestSuite(settings) {
                 });
                 await cache.add("a", 1);
                 await cache.decrement("a", 1);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 expect(event_?.value).toBe(1);
                 await unsubscribe();
@@ -830,7 +830,7 @@ export function cacheTestSuite(settings) {
                     event_ = event;
                 });
                 await cache.decrement("a", 1);
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 expect(event_?.key).toBe("a");
                 await unsubscribe();
             });
@@ -845,7 +845,7 @@ export function cacheTestSuite(settings) {
                 await cache.add("b", 2);
                 await cache.add("c", 3);
                 await cache.clear();
-                await LazyPromise.delay(DELAY_TIME);
+                await Task.delay(DELAY_TIME);
                 await unsubscribe();
                 expect(event_).toStrictEqual({});
             });