@daiso-tech/core 0.32.0 → 0.33.0

package/dist/event-bus/implementations/test-utilities/event-bus.test-suite.js

@@ -12,7 +12,7 @@ import { NoOpSerdeAdapter } from "../../../serde/implementations/adapters/_modul
  * The <i>eventBusTestSuite</i> function simplifies the process of testing your custom implementation of <i>{@link IEventBus}</i> with vitest.
  *
  * IMPORT_PATH: ```"@daiso-tech/core/event-bus/test-utilities"```
- * @group Test utilities
+ * @group TestUtilities
  */
 export function eventBusTestSuite(settings) {
     const { expect, serde = new Serde(new NoOpSerdeAdapter()), test, describe, createEventBus, beforeEach, } = settings;
@@ -22,1542 +22,801 @@ export function eventBusTestSuite(settings) {
     class SubEvent extends BaseEvent {
     }
     serde.registerEvent(AddEvent).registerEvent(SubEvent);
-    let eventBusA;
-    let eventBusB;
+    let eventBus;
     beforeEach(async () => {
-        const eventBus = await createEventBus();
-        eventBusA = eventBus;
-        eventBusB = eventBus.withGroup("b");
+        eventBus = await createEventBus();
     });
-    describe("Api tests:", () => {
-        describe("method: addListener, removeListener, dispatch", () => {
-            describe("Should be null when listener is added and event is not triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        result: null,
-                        invoke(event) {
-                            this.result = event;
-                        },
-                    };
-                    await eventBusA.addListener(AddEvent, listener);
-                    expect(listener.result).toBeNull();
-                    await eventBusA.removeListener(AddEvent, listener);
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        result = null;
-                        invoke(event) {
-                            this.result = event;
-                        }
+    describe("method: addListener, removeListener, dispatch", () => {
+        describe("Should be null when listener is added and event is not triggered", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    result: null,
+                    invoke(event) {
+                        this.result = event;
+                    },
+                };
+                await eventBus.addListener(AddEvent, listener);
+                expect(listener.result).toBeNull();
+                await eventBus.removeListener(AddEvent, listener);
+            });
+            test("Class instance listener", async () => {
+                class Listener {
+                    result = null;
+                    invoke(event) {
+                        this.result = event;
                     }
-                    const listener = new Listener();
-                    await eventBusA.addListener(AddEvent, listener);
-                    expect(listener.result).toBeNull();
-                    await eventBusA.removeListener(AddEvent, listener);
-                });
-                test("Function listener", async () => {
-                    let result = null;
-                    const listener = (event) => {
-                        result = event;
-                    };
-                    await eventBusA.addListener(AddEvent, listener);
-                    expect(result).toBeNull();
-                    await eventBusA.removeListener(AddEvent, listener);
-                });
+                }
+                const listener = new Listener();
+                await eventBus.addListener(AddEvent, listener);
+                expect(listener.result).toBeNull();
+                await eventBus.removeListener(AddEvent, listener);
             });
-            describe("Should be AddEvent when listener is added and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        result: null,
-                        invoke(event) {
-                            this.result = event;
-                        },
-                    };
-                    await eventBusA.addListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toEqual(event);
-                    expect(listener.result).toBeInstanceOf(AddEvent);
-                    await eventBusA.removeListener(AddEvent, listener);
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        result = null;
-                        invoke(event) {
-                            this.result = event;
-                        }
-                    }
-                    const listener = new Listener();
-                    await eventBusA.addListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toEqual(event);
-                    expect(listener.result).toBeInstanceOf(AddEvent);
-                    await eventBusA.removeListener(AddEvent, listener);
-                });
-                test("Function listener", async () => {
-                    let result = null;
-                    const listener = (event) => {
-                        result = event;
-                    };
-                    await eventBusA.addListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(result).toEqual(event);
-                    expect(result).toBeInstanceOf(AddEvent);
-                    await eventBusA.removeListener(AddEvent, listener);
-                });
+            test("Function listener", async () => {
+                let result = null;
+                const listener = (event) => {
+                    result = event;
+                };
+                await eventBus.addListener(AddEvent, listener);
+                expect(result).toBeNull();
+                await eventBus.removeListener(AddEvent, listener);
             });
-            describe("Should be null when listener is removed and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        result: null,
-                        invoke(event) {
-                            this.result = event;
-                        },
-                    };
-                    await eventBusA.addListener(AddEvent, listener);
-                    await eventBusA.removeListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toBeNull();
+        });
+        describe("Should be AddEvent when listener is added and event is triggered", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    result: null,
+                    invoke(event) {
+                        this.result = event;
+                    },
+                };
+                await eventBus.addListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        result = null;
-                        invoke(event) {
-                            this.result = event;
-                        }
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toEqual(event);
+                expect(listener.result).toBeInstanceOf(AddEvent);
+                await eventBus.removeListener(AddEvent, listener);
+            });
+            test("Class instance listener", async () => {
+                class Listener {
+                    result = null;
+                    invoke(event) {
+                        this.result = event;
                     }
-                    const listener = new Listener();
-                    await eventBusA.addListener(AddEvent, listener);
-                    await eventBusA.removeListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toBeNull();
+                }
+                const listener = new Listener();
+                await eventBus.addListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
-                test("Function listener", async () => {
-                    let result = null;
-                    const listener = (event) => {
-                        result = event;
-                    };
-                    await eventBusA.addListener(AddEvent, listener);
-                    await eventBusA.removeListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(result).toBeNull();
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toEqual(event);
+                expect(listener.result).toBeInstanceOf(AddEvent);
+                await eventBus.removeListener(AddEvent, listener);
+            });
+            test("Function listener", async () => {
+                let result = null;
+                const listener = (event) => {
+                    result = event;
+                };
+                await eventBus.addListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(result).toEqual(event);
+                expect(result).toBeInstanceOf(AddEvent);
+                await eventBus.removeListener(AddEvent, listener);
             });
         });
-        describe("method: addListenerMany, removeListenerMany, dispatchMany", () => {
-            describe("Should be null when listener is added and event is not triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        resultA: null,
-                        resultB: null,
-                        invoke(event) {
-                            if (event instanceof AddEvent) {
-                                this.resultA = event;
-                            }
-                            if (event instanceof SubEvent) {
-                                this.resultB = event;
-                            }
-                        },
-                    };
-                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
-                    expect(listener.resultA).toBeNull();
-                    expect(listener.resultB).toBeNull();
-                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        resultA = null;
-                        resultB = null;
-                        invoke(event) {
-                            if (event instanceof AddEvent) {
-                                this.resultA = event;
-                            }
-                            if (event instanceof SubEvent) {
-                                this.resultB = event;
-                            }
-                        }
-                    }
-                    const listener = new Listener();
-                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
-                    expect(listener.resultA).toBeNull();
-                    expect(listener.resultB).toBeNull();
-                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
-                });
-                test("Function listener", async () => {
-                    let resultA = null;
-                    let resultB = null;
-                    const listener = (event) => {
-                        if (event instanceof AddEvent) {
-                            resultA = event;
-                        }
-                        if (event instanceof SubEvent) {
-                            resultB = event;
-                        }
-                    };
-                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
-                    expect(resultA).toBeNull();
-                    expect(resultB).toBeNull();
-                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
+        describe("Should be null when listener is removed and event is triggered", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    result: null,
+                    invoke(event) {
+                        this.result = event;
+                    },
+                };
+                await eventBus.addListener(AddEvent, listener);
+                await eventBus.removeListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toBeNull();
             });
-            describe("Should be AddEvent and SubEvent when listener is added and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        resultA: null,
-                        resultB: null,
-                        invoke(event) {
-                            if (event instanceof AddEvent) {
-                                this.resultA = event;
-                            }
-                            if (event instanceof SubEvent) {
-                                this.resultB = event;
-                            }
-                        },
-                    };
-                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.resultA).toEqual(addEvent);
-                    expect(listener.resultA).toBeInstanceOf(AddEvent);
-                    expect(listener.resultB).toEqual(subEvent);
-                    expect(listener.resultB).toBeInstanceOf(SubEvent);
-                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        resultA = null;
-                        resultB = null;
-                        invoke(event) {
-                            if (event instanceof AddEvent) {
-                                this.resultA = event;
-                            }
-                            if (event instanceof SubEvent) {
-                                this.resultB = event;
-                            }
-                        }
+            test("Class instance listener", async () => {
+                class Listener {
+                    result = null;
+                    invoke(event) {
+                        this.result = event;
                     }
-                    const listener = new Listener();
-                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.resultA).toEqual(addEvent);
-                    expect(listener.resultA).toBeInstanceOf(AddEvent);
-                    expect(listener.resultB).toEqual(subEvent);
-                    expect(listener.resultB).toBeInstanceOf(SubEvent);
-                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
-                });
-                test("Function listener", async () => {
-                    let resultA = null;
-                    let resultB = null;
-                    const listener = (event) => {
-                        if (event instanceof AddEvent) {
-                            resultA = event;
-                        }
-                        if (event instanceof SubEvent) {
-                            resultB = event;
-                        }
-                    };
-                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(resultA).toEqual(addEvent);
-                    expect(resultA).toBeInstanceOf(AddEvent);
-                    expect(resultB).toEqual(subEvent);
-                    expect(resultB).toBeInstanceOf(SubEvent);
-                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
+                }
+                const listener = new Listener();
+                await eventBus.addListener(AddEvent, listener);
+                await eventBus.removeListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toBeNull();
             });
-            describe("Should be null when listener is removed and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        resultA: null,
-                        resultB: null,
-                        invoke(event) {
-                            if (event instanceof AddEvent) {
-                                this.resultA = event;
-                            }
-                            if (event instanceof SubEvent) {
-                                this.resultB = event;
-                            }
-                        },
-                    };
-                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
-                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.resultA).toBeNull();
-                    expect(listener.resultB).toBeNull();
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        resultA = null;
-                        resultB = null;
-                        invoke(event) {
-                            if (event instanceof AddEvent) {
-                                this.resultA = event;
-                            }
-                            if (event instanceof SubEvent) {
-                                this.resultB = event;
-                            }
-                        }
-                    }
-                    const listener = new Listener();
-                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
-                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.resultA).toBeNull();
-                    expect(listener.resultB).toBeNull();
-                });
-                test("Function listener", async () => {
-                    let resultA = null;
-                    let resultB = null;
-                    const listener = (event) => {
-                        if (event instanceof AddEvent) {
-                            resultA = event;
-                        }
-                        if (event instanceof SubEvent) {
-                            resultB = event;
-                        }
-                    };
-                    await eventBusA.addListenerMany([AddEvent, SubEvent], listener);
-                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(resultA).toBeNull();
-                    expect(resultB).toBeNull();
+            test("Function listener", async () => {
+                let result = null;
+                const listener = (event) => {
+                    result = event;
+                };
+                await eventBus.addListener(AddEvent, listener);
+                await eventBus.removeListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(result).toBeNull();
             });
         });
-        describe("method: subscribe, dispatch", () => {
-            describe("Should be null when listener is added and event is not triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        result: null,
-                        invoke(event) {
-                            this.result = event;
-                        },
-                    };
-                    const unsubscribe = await eventBusA.subscribe(AddEvent, listener);
-                    expect(listener.result).toBeNull();
-                    await unsubscribe();
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        result = null;
-                        invoke(event) {
-                            this.result = event;
-                        }
+    });
+    describe("method: subscribe, dispatch", () => {
+        describe("Should be null when listener is added and event is not triggered", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    result: null,
+                    invoke(event) {
+                        this.result = event;
+                    },
+                };
+                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                expect(listener.result).toBeNull();
+                await unsubscribe();
+            });
+            test("Class instance listener", async () => {
+                class Listener {
+                    result = null;
+                    invoke(event) {
+                        this.result = event;
                     }
-                    const listener = new Listener();
-                    const unsubscribe = await eventBusA.subscribe(AddEvent, listener);
-                    expect(listener.result).toBeNull();
-                    await unsubscribe();
-                });
-                test("Function listener", async () => {
-                    let result = null;
-                    const listener = (event) => {
-                        result = event;
-                    };
-                    const unsubscribe = await eventBusA.subscribe(AddEvent, listener);
-                    expect(result).toBeNull();
-                    await unsubscribe();
-                });
+                }
+                const listener = new Listener();
+                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                expect(listener.result).toBeNull();
+                await unsubscribe();
             });
-            describe("Should be AddEvent when listener is added and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        result: null,
-                        invoke(event) {
-                            this.result = event;
-                        },
-                    };
-                    const unsubscribe = await eventBusA.subscribe(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toEqual(event);
-                    expect(listener.result).toBeInstanceOf(AddEvent);
-                    await unsubscribe();
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        result = null;
-                        invoke(event) {
-                            this.result = event;
-                        }
-                    }
-                    const listener = new Listener();
-                    const unsubscribe = await eventBusA.subscribe(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toEqual(event);
-                    expect(listener.result).toBeInstanceOf(AddEvent);
-                    await unsubscribe();
-                });
-                test("Function listener", async () => {
-                    let result = null;
-                    const listener = (event) => {
-                        result = event;
-                    };
-                    const unsubscribe = await eventBusA.subscribe(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(result).toEqual(event);
-                    expect(result).toBeInstanceOf(AddEvent);
-                    await unsubscribe();
-                });
+            test("Function listener", async () => {
+                let result = null;
+                const listener = (event) => {
+                    result = event;
+                };
+                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                expect(result).toBeNull();
+                await unsubscribe();
             });
-            describe("Should be null when listener is removed by unsubscribe and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        result: null,
-                        invoke(event) {
-                            this.result = event;
-                        },
-                    };
-                    const unsubscribe = await eventBusA.subscribe(AddEvent, listener);
-                    await unsubscribe();
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toBeNull();
+        });
+        describe("Should be AddEvent when listener is added and event is triggered", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    result: null,
+                    invoke(event) {
+                        this.result = event;
+                    },
+                };
+                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        result = null;
-                        invoke(event) {
-                            this.result = event;
-                        }
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toEqual(event);
+                expect(listener.result).toBeInstanceOf(AddEvent);
+                await unsubscribe();
+            });
+            test("Class instance listener", async () => {
+                class Listener {
+                    result = null;
+                    invoke(event) {
+                        this.result = event;
                     }
-                    const listener = new Listener();
-                    const unsubscribe = await eventBusA.subscribe(AddEvent, listener);
-                    await unsubscribe();
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toBeNull();
-                });
-                test("Function listener", async () => {
-                    let result = null;
-                    const listener = (event) => {
-                        result = event;
-                    };
-                    const unsubscribe = await eventBusA.subscribe(AddEvent, listener);
-                    await unsubscribe();
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(result).toBeNull();
+                }
+                const listener = new Listener();
+                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toEqual(event);
+                expect(listener.result).toBeInstanceOf(AddEvent);
+                await unsubscribe();
             });
-            describe("Should be null when listener is removed by removeListener and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        result: null,
-                        invoke(event) {
-                            this.result = event;
-                        },
-                    };
-                    await eventBusA.subscribe(AddEvent, listener);
-                    await eventBusA.removeListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toBeNull();
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        result = null;
-                        invoke(event) {
-                            this.result = event;
-                        }
-                    }
-                    const listener = new Listener();
-                    await eventBusA.subscribe(AddEvent, listener);
-                    await eventBusA.removeListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toBeNull();
-                });
-                test("Function listener", async () => {
-                    let result = null;
-                    const listener = (event) => {
-                        result = event;
-                    };
-                    await eventBusA.subscribe(AddEvent, listener);
-                    await eventBusA.removeListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(result).toBeNull();
+            test("Function listener", async () => {
+                let result = null;
+                const listener = (event) => {
+                    result = event;
+                };
+                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(result).toEqual(event);
+                expect(result).toBeInstanceOf(AddEvent);
+                await unsubscribe();
             });
         });
-        describe("method: subscribeMany, dispatchMany", () => {
-            describe("Should be null when listener is added and event is not triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        resultA: null,
-                        resultB: null,
-                        invoke(event) {
-                            if (event instanceof AddEvent) {
-                                this.resultA = event;
-                            }
-                            if (event instanceof SubEvent) {
-                                this.resultB = event;
-                            }
-                        },
-                    };
-                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
-                    expect(listener.resultA).toBeNull();
-                    expect(listener.resultB).toBeNull();
-                    await unsubscribe();
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        resultA = null;
-                        resultB = null;
-                        invoke(event) {
-                            if (event instanceof AddEvent) {
-                                this.resultA = event;
-                            }
-                            if (event instanceof SubEvent) {
-                                this.resultB = event;
-                            }
-                        }
-                    }
-                    const listener = new Listener();
-                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
-                    expect(listener.resultA).toBeNull();
-                    expect(listener.resultB).toBeNull();
-                    await unsubscribe();
-                });
-                test("Function listener", async () => {
-                    let resultA = null;
-                    let resultB = null;
-                    const listener = (event) => {
-                        if (event instanceof AddEvent) {
-                            resultA = event;
-                        }
-                        if (event instanceof SubEvent) {
-                            resultB = event;
-                        }
-                    };
-                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
-                    expect(resultA).toBeNull();
-                    expect(resultB).toBeNull();
-                    await unsubscribe();
+        describe("Should be null when listener is removed by unsubscribe and event is triggered", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    result: null,
+                    invoke(event) {
+                        this.result = event;
+                    },
+                };
+                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                await unsubscribe();
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toBeNull();
             });
-            describe("Should be AddEvent and SubEvent when listener is added and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        resultA: null,
-                        resultB: null,
-                        invoke(event) {
-                            if (event instanceof AddEvent) {
-                                this.resultA = event;
-                            }
-                            if (event instanceof SubEvent) {
-                                this.resultB = event;
-                            }
-                        },
-                    };
-                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.resultA).toEqual(addEvent);
-                    expect(listener.resultA).toBeInstanceOf(AddEvent);
-                    expect(listener.resultB).toEqual(subEvent);
-                    expect(listener.resultB).toBeInstanceOf(SubEvent);
-                    await unsubscribe();
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        resultA = null;
-                        resultB = null;
-                        invoke(event) {
-                            if (event instanceof AddEvent) {
-                                this.resultA = event;
-                            }
-                            if (event instanceof SubEvent) {
-                                this.resultB = event;
-                            }
-                        }
+            test("Class instance listener", async () => {
+                class Listener {
+                    result = null;
+                    invoke(event) {
+                        this.result = event;
                     }
-                    const listener = new Listener();
-                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.resultA).toEqual(addEvent);
-                    expect(listener.resultA).toBeInstanceOf(AddEvent);
-                    expect(listener.resultB).toEqual(subEvent);
-                    expect(listener.resultB).toBeInstanceOf(SubEvent);
-                    await unsubscribe();
-                });
-                test("Function listener", async () => {
-                    let resultA = null;
-                    let resultB = null;
-                    const listener = (event) => {
-                        if (event instanceof AddEvent) {
-                            resultA = event;
-                        }
-                        if (event instanceof SubEvent) {
-                            resultB = event;
-                        }
-                    };
-                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(resultA).toEqual(addEvent);
-                    expect(resultA).toBeInstanceOf(AddEvent);
-                    expect(resultB).toEqual(subEvent);
-                    expect(resultB).toBeInstanceOf(SubEvent);
-                    await unsubscribe();
+                }
+                const listener = new Listener();
+                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                await unsubscribe();
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toBeNull();
             });
-            describe("Should be null when listener is removed by unsubscribe and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        resultA: null,
-                        resultB: null,
-                        invoke(event) {
-                            if (event instanceof AddEvent) {
-                                this.resultA = event;
-                            }
-                            if (event instanceof SubEvent) {
-                                this.resultB = event;
-                            }
-                        },
-                    };
-                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
-                    await unsubscribe();
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.resultA).toBeNull();
-                    expect(listener.resultB).toBeNull();
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        resultA = null;
-                        resultB = null;
-                        invoke(event) {
-                            if (event instanceof AddEvent) {
-                                this.resultA = event;
-                            }
-                            if (event instanceof SubEvent) {
-                                this.resultB = event;
-                            }
-                        }
-                    }
-                    const listener = new Listener();
-                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
-                    await unsubscribe();
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.resultA).toBeNull();
-                    expect(listener.resultB).toBeNull();
-                });
-                test("Function listener", async () => {
-                    let resultA = null;
-                    let resultB = null;
-                    const listener = (event) => {
-                        if (event instanceof AddEvent) {
-                            resultA = event;
-                        }
-                        if (event instanceof SubEvent) {
-                            resultB = event;
-                        }
-                    };
-                    const unsubscribe = await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
-                    await unsubscribe();
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(resultA).toBeNull();
-                    expect(resultB).toBeNull();
+            test("Function listener", async () => {
+                let result = null;
+                const listener = (event) => {
+                    result = event;
+                };
+                const unsubscribe = await eventBus.subscribe(AddEvent, listener);
+                await unsubscribe();
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(result).toBeNull();
             });
-            describe("Should be null when listener is removed by removeListener and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        resultA: null,
-                        resultB: null,
-                        invoke(event) {
-                            if (event instanceof AddEvent) {
-                                this.resultA = event;
-                            }
-                            if (event instanceof SubEvent) {
-                                this.resultB = event;
-                            }
-                        },
-                    };
-                    await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
-                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.resultA).toBeNull();
-                    expect(listener.resultB).toBeNull();
+        });
+        describe("Should be null when listener is removed by removeListener and event is triggered", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    result: null,
+                    invoke(event) {
+                        this.result = event;
+                    },
+                };
+                await eventBus.subscribe(AddEvent, listener);
+                await eventBus.removeListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        resultA = null;
-                        resultB = null;
-                        invoke(event) {
-                            if (event instanceof AddEvent) {
-                                this.resultA = event;
-                            }
-                            if (event instanceof SubEvent) {
-                                this.resultB = event;
-                            }
-                        }
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toBeNull();
+            });
+            test("Class instance listener", async () => {
+                class Listener {
+                    result = null;
+                    invoke(event) {
+                        this.result = event;
                     }
-                    const listener = new Listener();
-                    await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
-                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.resultA).toBeNull();
-                    expect(listener.resultB).toBeNull();
+                }
+                const listener = new Listener();
+                await eventBus.subscribe(AddEvent, listener);
+                await eventBus.removeListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
-                test("Function listener", async () => {
-                    let resultA = null;
-                    let resultB = null;
-                    const listener = (event) => {
-                        if (event instanceof AddEvent) {
-                            resultA = event;
-                        }
-                        if (event instanceof SubEvent) {
-                            resultB = event;
-                        }
-                    };
-                    await eventBusA.subscribeMany([AddEvent, SubEvent], listener);
-                    await eventBusA.removeListenerMany([AddEvent, SubEvent], listener);
-                    const addEvent = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    const subEvent = new SubEvent({
-                        c: 1,
-                        d: 2,
-                    });
-                    await eventBusA.dispatchMany([addEvent, subEvent]);
-                    await LazyPromise.delay(TTL);
-                    expect(resultA).toBeNull();
-                    expect(resultB).toBeNull();
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toBeNull();
+            });
+            test("Function listener", async () => {
+                let result = null;
+                const listener = (event) => {
+                    result = event;
+                };
+                await eventBus.subscribe(AddEvent, listener);
+                await eventBus.removeListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(result).toBeNull();
             });
         });
-        describe("method: subscribeOnce", () => {
-            describe("Should be null when listener added and event is not triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        result: null,
-                        invoke(event) {
-                            this.result = event;
-                        },
-                    };
-                    await eventBusA.subscribeOnce(AddEvent, listener);
-                    expect(listener.result).toBeNull();
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        result = null;
-                        invoke(event) {
-                            this.result = event;
-                        }
+    });
+    describe("method: subscribeOnce", () => {
+        describe("Should be null when listener added and event is not triggered", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    result: null,
+                    invoke(event) {
+                        this.result = event;
+                    },
+                };
+                await eventBus.subscribeOnce(AddEvent, listener);
+                expect(listener.result).toBeNull();
+            });
+            test("Class instance listener", async () => {
+                class Listener {
+                    result = null;
+                    invoke(event) {
+                        this.result = event;
                     }
-                    const listener = new Listener();
-                    await eventBusA.subscribeOnce(AddEvent, listener);
-                    expect(listener.result).toBeNull();
-                });
-                test("Function listener", async () => {
-                    let result = null;
-                    const listener = (event) => {
-                        result = event;
-                    };
-                    await eventBusA.subscribeOnce(AddEvent, listener);
-                    expect(result).toBeNull();
-                });
+                }
+                const listener = new Listener();
+                await eventBus.subscribeOnce(AddEvent, listener);
+                expect(listener.result).toBeNull();
             });
-            describe("Should be AddEvent when listener added and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        result: null,
-                        invoke(event) {
-                            this.result = event;
-                        },
-                    };
-                    await eventBusA.subscribeOnce(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toEqual(event);
-                    expect(listener.result).toBeInstanceOf(AddEvent);
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        result = null;
-                        invoke(event) {
-                            this.result = event;
-                        }
-                    }
-                    const listener = new Listener();
-                    await eventBusA.subscribeOnce(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toEqual(event);
-                    expect(listener.result).toBeInstanceOf(AddEvent);
-                });
-                test("Function listener", async () => {
-                    let result = null;
-                    const listener = (event) => {
-                        result = event;
-                    };
-                    await eventBusA.subscribeOnce(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(result).toEqual(event);
-                    expect(result).toBeInstanceOf(AddEvent);
-                });
+            test("Function listener", async () => {
+                let result = null;
+                const listener = (event) => {
+                    result = event;
+                };
+                await eventBus.subscribeOnce(AddEvent, listener);
+                expect(result).toBeNull();
             });
-            describe("Should only listen for event once", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        i: 0,
-                        invoke(_event) {
-                            this.i++;
-                        },
-                    };
-                    await eventBusA.subscribeOnce(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.i).toBe(1);
+        });
+        describe("Should be AddEvent when listener added and event is triggered", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    result: null,
+                    invoke(event) {
+                        this.result = event;
+                    },
+                };
+                await eventBus.subscribeOnce(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        i = 0;
-                        invoke(_event) {
-                            this.i++;
-                        }
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toEqual(event);
+                expect(listener.result).toBeInstanceOf(AddEvent);
+            });
+            test("Class instance listener", async () => {
+                class Listener {
+                    result = null;
+                    invoke(event) {
+                        this.result = event;
                     }
-                    const listener = new Listener();
-                    await eventBusA.subscribeOnce(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.i).toBe(1);
-                });
-                test("Function listener", async () => {
-                    let i = 0;
-                    const listener = () => {
-                        i++;
-                    };
-                    await eventBusA.subscribeOnce(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(i).toBe(1);
+                }
+                const listener = new Listener();
+                await eventBus.subscribeOnce(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toEqual(event);
+                expect(listener.result).toBeInstanceOf(AddEvent);
             });
-            describe("Should be null when listener is removed by unsubscribe function and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        result: null,
-                        invoke(event) {
-                            this.result = event;
-                        },
-                    };
-                    const unsubscribe = await eventBusA.subscribeOnce(AddEvent, listener);
-                    await unsubscribe();
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toBeNull();
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        result = null;
-                        invoke(event) {
-                            this.result = event;
-                        }
-                    }
-                    const listener = new Listener();
-                    const unsubscribe = await eventBusA.subscribeOnce(AddEvent, listener);
-                    await unsubscribe();
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toBeNull();
-                });
-                test("Function listener", async () => {
-                    let result = null;
-                    const listener = (event) => {
-                        result = event;
-                    };
-                    const unsubscribe = await eventBusA.subscribeOnce(AddEvent, listener);
-                    await unsubscribe();
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(result).toBeNull();
+            test("Function listener", async () => {
+                let result = null;
+                const listener = (event) => {
+                    result = event;
+                };
+                await eventBus.subscribeOnce(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(result).toEqual(event);
+                expect(result).toBeInstanceOf(AddEvent);
             });
-            describe("Should be null when listener is removed by removeListener method and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        result: null,
-                        invoke(event) {
-                            this.result = event;
-                        },
-                    };
-                    await eventBusA.subscribeOnce(AddEvent, listener);
-                    await eventBusA.removeListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toBeNull();
+        });
+        describe("Should only listen for event once", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    i: 0,
+                    invoke(_event) {
+                        this.i++;
+                    },
+                };
+                await eventBus.subscribeOnce(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        result = null;
-                        invoke(event) {
-                            this.result = event;
-                        }
+                await eventBus.dispatch(event);
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.i).toBe(1);
+            });
+            test("Class instance listener", async () => {
+                class Listener {
+                    i = 0;
+                    invoke(_event) {
+                        this.i++;
                     }
-                    const listener = new Listener();
-                    await eventBusA.subscribeOnce(AddEvent, listener);
-                    await eventBusA.removeListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toBeNull();
+                }
+                const listener = new Listener();
+                await eventBus.subscribeOnce(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
-                test("Function listener", async () => {
-                    let result = null;
-                    const listener = (event) => {
-                        result = event;
-                    };
-                    await eventBusA.subscribeOnce(AddEvent, listener);
-                    await eventBusA.removeListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(result).toBeNull();
+                await eventBus.dispatch(event);
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.i).toBe(1);
+            });
+            test("Function listener", async () => {
+                let i = 0;
+                const listener = () => {
+                    i++;
+                };
+                await eventBus.subscribeOnce(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(i).toBe(1);
             });
         });
-        describe("method: listenOnce", () => {
-            describe("Should be null when listener added and event is not triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        result: null,
-                        invoke(event) {
-                            this.result = event;
-                        },
-                    };
-                    await eventBusA.listenOnce(AddEvent, listener);
-                    expect(listener.result).toBeNull();
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        result = null;
-                        invoke(event) {
-                            this.result = event;
-                        }
-                    }
-                    const listener = new Listener();
-                    await eventBusA.listenOnce(AddEvent, listener);
-                    expect(listener.result).toBeNull();
-                });
-                test("Function listener", async () => {
-                    let result = null;
-                    const listener = (event) => {
-                        result = event;
-                    };
-                    await eventBusA.listenOnce(AddEvent, listener);
-                    expect(result).toBeNull();
+        describe("Should be null when listener is removed by unsubscribe function and event is triggered", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    result: null,
+                    invoke(event) {
+                        this.result = event;
+                    },
+                };
+                const unsubscribe = await eventBus.subscribeOnce(AddEvent, listener);
+                await unsubscribe();
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toBeNull();
             });
-            describe("Should be AddEvent when listener added and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        result: null,
-                        invoke(event) {
-                            this.result = event;
-                        },
-                    };
-                    await eventBusA.listenOnce(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toEqual(event);
-                    expect(listener.result).toBeInstanceOf(AddEvent);
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        result = null;
-                        invoke(event) {
-                            this.result = event;
-                        }
+            test("Class instance listener", async () => {
+                class Listener {
+                    result = null;
+                    invoke(event) {
+                        this.result = event;
                     }
-                    const listener = new Listener();
-                    await eventBusA.listenOnce(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toEqual(event);
-                    expect(listener.result).toBeInstanceOf(AddEvent);
-                });
-                test("Function listener", async () => {
-                    let result = null;
-                    const listener = (event) => {
-                        result = event;
-                    };
-                    await eventBusA.listenOnce(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(result).toEqual(event);
-                    expect(result).toBeInstanceOf(AddEvent);
+                }
+                const listener = new Listener();
+                const unsubscribe = await eventBus.subscribeOnce(AddEvent, listener);
+                await unsubscribe();
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toBeNull();
             });
-            describe("Should only listen for event once", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        i: 0,
-                        invoke(_event) {
-                            this.i++;
-                        },
-                    };
-                    await eventBusA.listenOnce(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.i).toBe(1);
-                });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        i = 0;
-                        invoke(_event) {
-                            this.i++;
-                        }
-                    }
-                    const listener = new Listener();
-                    await eventBusA.listenOnce(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.i).toBe(1);
-                });
-                test("Function listener", async () => {
-                    let i = 0;
-                    const listener = () => {
-                        i++;
-                    };
-                    await eventBusA.listenOnce(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(i).toBe(1);
+            test("Function listener", async () => {
+                let result = null;
+                const listener = (event) => {
+                    result = event;
+                };
+                const unsubscribe = await eventBus.subscribeOnce(AddEvent, listener);
+                await unsubscribe();
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(result).toBeNull();
             });
-            describe("Should be null when listener is removed and event is triggered", () => {
-                test("Object literal listener", async () => {
-                    const listener = {
-                        result: null,
-                        invoke(event) {
-                            this.result = event;
-                        },
-                    };
-                    await eventBusA.listenOnce(AddEvent, listener);
-                    await eventBusA.removeListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toBeNull();
+        });
+        describe("Should be null when listener is removed by removeListener method and event is triggered", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    result: null,
+                    invoke(event) {
+                        this.result = event;
+                    },
+                };
+                await eventBus.subscribeOnce(AddEvent, listener);
+                await eventBus.removeListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
-                test("Class instance listener", async () => {
-                    class Listener {
-                        result = null;
-                        invoke(event) {
-                            this.result = event;
-                        }
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toBeNull();
+            });
+            test("Class instance listener", async () => {
+                class Listener {
+                    result = null;
+                    invoke(event) {
+                        this.result = event;
                     }
-                    const listener = new Listener();
-                    await eventBusA.listenOnce(AddEvent, listener);
-                    await eventBusA.removeListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(listener.result).toBeNull();
+                }
+                const listener = new Listener();
+                await eventBus.subscribeOnce(AddEvent, listener);
+                await eventBus.removeListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
-                test("Function listener", async () => {
-                    let result = null;
-                    const listener = (event) => {
-                        result = event;
-                    };
-                    await eventBusA.listenOnce(AddEvent, listener);
-                    await eventBusA.removeListener(AddEvent, listener);
-                    const event = new AddEvent({
-                        a: 1,
-                        b: 2,
-                    });
-                    await eventBusA.dispatch(event);
-                    await LazyPromise.delay(TTL);
-                    expect(result).toBeNull();
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toBeNull();
+            });
+            test("Function listener", async () => {
+                let result = null;
+                const listener = (event) => {
+                    result = event;
+                };
+                await eventBus.subscribeOnce(AddEvent, listener);
+                await eventBus.removeListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
                 });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(result).toBeNull();
             });
         });
-        describe("method: asPromise", () => {
-            test("Should be null when listener added and event is not triggered", () => {
+    });
+    describe("method: listenOnce", () => {
+        describe("Should be null when listener added and event is not triggered", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    result: null,
+                    invoke(event) {
+                        this.result = event;
+                    },
+                };
+                await eventBus.listenOnce(AddEvent, listener);
+                expect(listener.result).toBeNull();
+            });
+            test("Class instance listener", async () => {
+                class Listener {
+                    result = null;
+                    invoke(event) {
+                        this.result = event;
+                    }
+                }
+                const listener = new Listener();
+                await eventBus.listenOnce(AddEvent, listener);
+                expect(listener.result).toBeNull();
+            });
+            test("Function listener", async () => {
                 let result = null;
                 const listener = (event) => {
                     result = event;
                 };
-                eventBusA.asPromise(AddEvent).then(listener);
+                await eventBus.listenOnce(AddEvent, listener);
                 expect(result).toBeNull();
             });
-            test("Should be AddEvent when listener added and event is triggered", async () => {
+        });
+        describe("Should be AddEvent when listener added and event is triggered", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    result: null,
+                    invoke(event) {
+                        this.result = event;
+                    },
+                };
+                await eventBus.listenOnce(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
+                });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toEqual(event);
+                expect(listener.result).toBeInstanceOf(AddEvent);
+            });
+            test("Class instance listener", async () => {
+                class Listener {
+                    result = null;
+                    invoke(event) {
+                        this.result = event;
+                    }
+                }
+                const listener = new Listener();
+                await eventBus.listenOnce(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
+                });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toEqual(event);
+                expect(listener.result).toBeInstanceOf(AddEvent);
+            });
+            test("Function listener", async () => {
                 let result = null;
                 const listener = (event) => {
                     result = event;
                 };
-                eventBusA.asPromise(AddEvent).then(listener);
+                await eventBus.listenOnce(AddEvent, listener);
                 const event = new AddEvent({
                     a: 1,
                     b: 2,
                 });
-                await eventBusA.dispatch(event);
+                await eventBus.dispatch(event);
                 await LazyPromise.delay(TTL);
                 expect(result).toEqual(event);
                 expect(result).toBeInstanceOf(AddEvent);
             });
         });
-    });
-    describe("Group tests:", () => {
-        test("method: addListener / dispatch", async () => {
-            let result_a = null;
-            await eventBusA.addListener(AddEvent, (event) => {
-                result_a = event;
-            });
-            let result_b = null;
-            await eventBusB.addListener(AddEvent, (event) => {
-                result_b = event;
-            });
-            const event = new AddEvent({
-                a: 1,
-                b: 2,
-            });
-            await eventBusA.dispatch(event);
-            await LazyPromise.delay(TTL);
-            expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(AddEvent);
-            expect(result_b).toBeNull();
-        });
-        test("method: addListenerMany / dispatch", async () => {
-            let result_a = null;
-            await eventBusA.addListenerMany([AddEvent], (event) => {
-                result_a = event;
+        describe("Should only listen for event once", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    i: 0,
+                    invoke(_event) {
+                        this.i++;
+                    },
+                };
+                await eventBus.listenOnce(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
+                });
+                await eventBus.dispatch(event);
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.i).toBe(1);
             });
-            let result_b = null;
-            await eventBusB.addListenerMany([AddEvent], (event) => {
-                result_b = event;
+            test("Class instance listener", async () => {
+                class Listener {
+                    i = 0;
+                    invoke(_event) {
+                        this.i++;
+                    }
+                }
+                const listener = new Listener();
+                await eventBus.listenOnce(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
+                });
+                await eventBus.dispatch(event);
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.i).toBe(1);
             });
-            const event = new AddEvent({
-                a: 1,
-                b: 2,
+            test("Function listener", async () => {
+                let i = 0;
+                const listener = () => {
+                    i++;
+                };
+                await eventBus.listenOnce(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
+                });
+                await eventBus.dispatch(event);
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(i).toBe(1);
             });
-            await eventBusA.dispatch(event);
-            await LazyPromise.delay(TTL);
-            expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(AddEvent);
-            expect(result_b).toBeNull();
         });
-        test("method: removeListener / addListener / dispatch", async () => {
-            let result_a = null;
-            await eventBusA.addListener(AddEvent, (event) => {
-                result_a = event;
-            });
-            let result_b = null;
-            const listenerB = (event) => {
-                result_b = event;
-            };
-            await eventBusB.addListener(AddEvent, listenerB);
-            await eventBusB.removeListener(AddEvent, listenerB);
-            const event = new AddEvent({
-                a: 1,
-                b: 2,
+        describe("Should be null when listener is removed and event is triggered", () => {
+            test("Object literal listener", async () => {
+                const listener = {
+                    result: null,
+                    invoke(event) {
+                        this.result = event;
+                    },
+                };
+                await eventBus.listenOnce(AddEvent, listener);
+                await eventBus.removeListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
+                });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toBeNull();
             });
-            await eventBusA.dispatch(event);
-            await eventBusB.dispatch(event);
-            await LazyPromise.delay(TTL);
-            expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(AddEvent);
-            expect(result_b).toBeNull();
-        });
-        test("method: removeListenerMany / addListener / dispatch", async () => {
-            let result_a = null;
-            await eventBusA.addListener(AddEvent, (event) => {
-                result_a = event;
+            test("Class instance listener", async () => {
+                class Listener {
+                    result = null;
+                    invoke(event) {
+                        this.result = event;
+                    }
+                }
+                const listener = new Listener();
+                await eventBus.listenOnce(AddEvent, listener);
+                await eventBus.removeListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
+                });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(listener.result).toBeNull();
             });
-            let result_b = null;
-            const listenerB = (event) => {
-                result_b = event;
-            };
-            await eventBusB.addListener(AddEvent, listenerB);
-            await eventBusB.removeListenerMany([AddEvent], listenerB);
-            const event = new AddEvent({
-                a: 1,
-                b: 2,
+            test("Function listener", async () => {
+                let result = null;
+                const listener = (event) => {
+                    result = event;
+                };
+                await eventBus.listenOnce(AddEvent, listener);
+                await eventBus.removeListener(AddEvent, listener);
+                const event = new AddEvent({
+                    a: 1,
+                    b: 2,
+                });
+                await eventBus.dispatch(event);
+                await LazyPromise.delay(TTL);
+                expect(result).toBeNull();
             });
-            await eventBusA.dispatch(event);
-            await eventBusB.dispatch(event);
-            await LazyPromise.delay(TTL);
-            expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(AddEvent);
-            expect(result_b).toBeNull();
         });
-        test("method: subscribe / dispatch", async () => {
-            let result_a = null;
-            await eventBusA.subscribe(AddEvent, (event) => {
-                result_a = event;
-            });
-            let result_b = null;
-            const listenerB = (event) => {
-                result_b = event;
+    });
+    describe("method: asPromise", () => {
+        test("Should be null when listener added and event is not triggered", () => {
+            let result = null;
+            const listener = (event) => {
+                result = event;
             };
-            const unsubscribe = await eventBusB.subscribe(AddEvent, listenerB);
-            await unsubscribe();
-            const event = new AddEvent({
-                a: 1,
-                b: 2,
-            });
-            await eventBusA.dispatch(event);
-            await eventBusB.dispatch(event);
-            await LazyPromise.delay(TTL);
-            expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(AddEvent);
-            expect(result_b).toBeNull();
+            eventBus.asPromise(AddEvent).then(listener);
+            expect(result).toBeNull();
         });
-        test("method: subscribeMany / dispatch", async () => {
-            let result_a = null;
-            await eventBusA.subscribeMany([AddEvent], (event) => {
-                result_a = event;
-            });
-            let result_b = null;
-            const listenerB = (event) => {
-                result_b = event;
+        test("Should be AddEvent when listener added and event is triggered", async () => {
+            let result = null;
+            const listener = (event) => {
+                result = event;
             };
-            const unsubscribe = await eventBusB.subscribeMany([AddEvent], listenerB);
-            await unsubscribe();
-            const event = new AddEvent({
-                a: 1,
-                b: 2,
-            });
-            await eventBusA.dispatch(event);
-            await eventBusB.dispatch(event);
-            await LazyPromise.delay(TTL);
-            expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(AddEvent);
-            expect(result_b).toBeNull();
-        });
-        test("method: subscribeOnce", async () => {
-            let result_a = null;
-            await eventBusA.subscribeOnce(AddEvent, (event) => {
-                result_a = event;
-            });
-            let result_b = null;
-            await eventBusB.subscribeOnce(AddEvent, (event) => {
-                result_b = event;
-            });
-            const event = new AddEvent({
-                a: 1,
-                b: 2,
-            });
-            await eventBusA.dispatch(event);
-            await LazyPromise.delay(TTL);
-            expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(AddEvent);
-            expect(result_b).toBeNull();
-        });
-        test("method: listenOnce", async () => {
-            let result_a = null;
-            await eventBusA.listenOnce(AddEvent, (event) => {
-                result_a = event;
-            });
-            let result_b = null;
-            await eventBusB.listenOnce(AddEvent, (event) => {
-                result_b = event;
-            });
-            const event = new AddEvent({
-                a: 1,
-                b: 2,
-            });
-            await eventBusA.dispatch(event);
-            await LazyPromise.delay(TTL);
-            expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(AddEvent);
-            expect(result_b).toBeNull();
-        });
-        test("method: asPromise", async () => {
-            let result_a = null;
-            eventBusA.asPromise(AddEvent).then((event) => {
-                result_a = event;
-            });
-            let result_b = null;
-            eventBusB.asPromise(AddEvent).then((event) => {
-                result_b = event;
-            });
+            eventBus.asPromise(AddEvent).then(listener);
             const event = new AddEvent({
                 a: 1,
                 b: 2,
             });
-            await eventBusA.dispatch(event);
+            await eventBus.dispatch(event);
             await LazyPromise.delay(TTL);
-            expect(result_a).toEqual(event);
-            expect(result_a).toBeInstanceOf(AddEvent);
-            expect(result_b).toBeNull();
+            expect(result).toEqual(event);
+            expect(result).toBeInstanceOf(AddEvent);
         });
     });
 }