Disable domain tests, started base tests.

common/package-lock.json

@@ -19,9 +19,11 @@
       },
       "devDependencies": {
         "@types/chai": "^5.0.0",
+        "@types/chai-spies": "^1.0.6",
         "@types/mocha": "^10.0.8",
         "chai": "^5.1.1",
         "chai-as-promised": "^8.0.0",
+        "chai-spies": "^1.1.0",
         "esm": "^3.2.25",
         "mocha": "^10.7.3"
       }
@@ -2199,6 +2201,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/chai-spies": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/@types/chai-spies/-/chai-spies-1.0.6.tgz",
+      "integrity": "sha512-xkk4HmhBB9OQeTAifa9MJ+6R5/Rq9+ungDe4JidZD+vqZVeiWZwc2i7/pd1ZKjyGlSBIQePoWdyUyFUGT0rv5w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/chai": "*"
+      }
+    },
     "node_modules/@types/estree": {
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz",
@@ -2514,6 +2526,19 @@
         "chai": ">= 2.1.2 < 6"
       }
     },
+    "node_modules/chai-spies": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/chai-spies/-/chai-spies-1.1.0.tgz",
+      "integrity": "sha512-ikaUhQvQWchRYj2K54itFp3nrcxaFRpSDQxDlRzSn9aWgu9Pi7lD8yFxTso4WnQ39+WZ69oB/qOvqp+isJIIWA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4.0.0"
+      },
+      "peerDependencies": {
+        "chai": "*"
+      }
+    },
     "node_modules/chalk": {
       "version": "2.4.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",

common/package.json

@@ -24,9 +24,11 @@
   },
   "devDependencies": {
     "@types/chai": "^5.0.0",
+    "@types/chai-spies": "^1.0.6",
     "@types/mocha": "^10.0.8",
     "chai": "^5.1.1",
     "chai-as-promised": "^8.0.0",
+    "chai-spies": "^1.1.0",
     "esm": "^3.2.25",
     "mocha": "^10.7.3"
   }

common/src/events.mjs

@@ -79,7 +79,8 @@ export class BaseEventEmitter {
         if(eventType.includes(" ")) { // Unlisten to several different events with the same listener.
             let found = false
             for(const type of eventType.split(" "))
-                found ||= this.off(eventType, eventListener)
+                found ||= this.off(type, eventListener)
+            return found
         } else {
             if(!this.constructor.emits.includes(eventType)) {
                 const className = this.constructor.name

common/test/general/events.mjs

@@ -0,0 +1,122 @@
+/**
+ *  LogarithmPlotter - 2D plotter software to make BODE plots, sequences and distribution functions.
+ *  Copyright (C) 2021-2024  Ad5001
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import { BaseEventEmitter, BaseEvent } from "../../src/events.mjs"
+
+import { describe, it } from "mocha"
+import { expect, use } from "chai"
+import spies from "chai-spies"
+
+// Setting up modules
+const { spy } = use(spies)
+
+
+class MockEmitter extends BaseEventEmitter {
+    static emits = ["example1", "example2"]
+}
+
+class MockEvent1 extends BaseEvent {
+    constructor() {
+        super("example1")
+    }
+}
+
+class MockEvent2 extends BaseEvent {
+    constructor(parameter) {
+        super("example2")
+        this.parameter = parameter
+    }
+}
+
+const sandbox = spy.sandbox()
+
+describe("Events", function() {
+
+    afterEach(() => {
+        sandbox.restore()
+    })
+
+    it("should forward events to all of its listeners", function() {
+        const emitter = new MockEmitter()
+        const listener1 = spy()
+        const listener2 = spy()
+        emitter.on("example1", listener1)
+        emitter.on("example1", listener2)
+        emitter.emit(new MockEvent1())
+        expect(listener1).to.have.been.called.once
+        expect(listener2).to.have.been.called.once
+    })
+
+    it("should forward multiple events to a singular listener", function() {
+        const emitter = new MockEmitter()
+        const listener = spy()
+        const mockEvent1 = new MockEvent1()
+        const mockEvent2 = new MockEvent2(3)
+        emitter.on("example1 example2", listener)
+        emitter.emit(mockEvent1)
+        emitter.emit(mockEvent2)
+        expect(listener).to.have.been.called.twice
+        expect(listener).to.have.been.called.with.exactly(mockEvent1)
+        expect(listener).to.have.been.called.with.exactly(mockEvent2)
+    })
+
+    it("should be able to remove listeners", function() {
+        const emitter = new MockEmitter()
+        const listener = spy()
+        emitter.on("example1", listener)
+        const removedFromEventItDoesntListenTo = emitter.off("example2", listener)
+        const removedFromEventItListensTo = emitter.off("example1", listener)
+        const removedFromEventASecondTime = emitter.off("example1", listener)
+        expect(removedFromEventItDoesntListenTo).to.be.false
+        expect(removedFromEventItListensTo).to.be.true
+        expect(removedFromEventASecondTime).to.be.false
+        emitter.on("example1 example2", listener)
+        const removedFromBothEvents = emitter.off("example1 example2", listener)
+        expect(removedFromBothEvents).to.be.true
+        emitter.on("example1", listener)
+        const removedFromOneOfTheEvents = emitter.off("example1 example2", listener)
+        expect(removedFromOneOfTheEvents).to.be.true
+    })
+
+    it("should be able to remove listening to one event when listener listens to multiple", function() {
+        const emitter = new MockEmitter()
+        const listener = spy()
+        const mockEvent1 = new MockEvent1()
+        const mockEvent2 = new MockEvent2(3)
+        emitter.on("example1 example2", listener)
+        // Disable listener for example1
+        emitter.off("example1", listener)
+        emitter.emit(mockEvent1)
+        emitter.emit(mockEvent2)
+        expect(listener).to.have.been.called.once
+        expect(listener).to.have.been.called.with.exactly(mockEvent2)
+    })
+
+    it("shouldn't be able to listen/unlisten/emit inexistant events", function() {
+        const emitter = new MockEmitter()
+        const listener = spy()
+        expect(() => emitter.on("inexistant", listener)).to.throw(Error)
+        expect(() => emitter.off("inexistant", listener)).to.throw(Error)
+        expect(() => emitter.emit(new BaseEvent("inexistant"))).to.throw(Error)
+    })
+
+    it("shouldn't be able to emit non-events", function() {
+        const emitter = new MockEmitter()
+        expect(() => emitter.emit("not-an-event")).to.throw(Error)
+    })
+})

common/test/hooks.mjs

@@ -19,12 +19,10 @@ import * as fs from "./mock/fs.mjs";
 import Qt from "./mock/qt.mjs";
 import { MockHelper } from "./mock/helper.mjs";
 import { MockLatex } from "./mock/latex.mjs";
-import Modules from "../src/module/index.mjs";
 
 function setup() {
     globalThis.Helper = new MockHelper()
     globalThis.Latex = new MockLatex()
-    Modules.Latex.initialize({ latex: Latex, helper: Helper })
 }
 
 setup()

common/test/math/domain.mjs

@@ -19,46 +19,46 @@
 import { describe, it } from "mocha"
 import { expect } from "chai"
 
-import { Domain, parseDomainSimple } from "../../src/math/domain.mjs"
+// import { Domain, parseDomainSimple } from "../../src/math/domain.mjs"
-
+//
-describe("math.domain", function() {
+// describe("math.domain", function() {
-    describe("#parseDomainSimple", function() {
+//     describe("#parseDomainSimple", function() {
-        it("returns predefined domains", function() {
+//         it("returns predefined domains", function() {
-            const predefinedToCheck = [
+//             const predefinedToCheck = [
-                // Real domains
+//                 // Real domains
-                { domain: Domain.R, shortcuts: ["R", "ℝ"] },
+//                 { domain: Domain.R, shortcuts: ["R", "ℝ"] },
-                // Zero exclusive real domains
+//                 // Zero exclusive real domains
-                { domain: Domain.RE, shortcuts: ["RE", "R*", "ℝ*"] },
+//                 { domain: Domain.RE, shortcuts: ["RE", "R*", "ℝ*"] },
-                // Real positive domains
+//                 // Real positive domains
-                { domain: Domain.RP, shortcuts: ["RP", "R+", "ℝ⁺", "ℝ+"] },
+//                 { domain: Domain.RP, shortcuts: ["RP", "R+", "ℝ⁺", "ℝ+"] },
-                // Zero-exclusive real positive domains
+//                 // Zero-exclusive real positive domains
-                { domain: Domain.RPE, shortcuts: ["RPE", "REP", "R+*", "R*+", "ℝ*⁺", "ℝ⁺*", "ℝ*+", "ℝ+*"] },
+//                 { domain: Domain.RPE, shortcuts: ["RPE", "REP", "R+*", "R*+", "ℝ*⁺", "ℝ⁺*", "ℝ*+", "ℝ+*"] },
-                // Real negative domain
+//                 // Real negative domain
-                { domain: Domain.RM, shortcuts: ["RM", "R-", "ℝ⁻", "ℝ-"] },
+//                 { domain: Domain.RM, shortcuts: ["RM", "R-", "ℝ⁻", "ℝ-"] },
-                // Zero-exclusive real negative domains
+//                 // Zero-exclusive real negative domains
-                { domain: Domain.RME, shortcuts: ["RME", "REM", "R-*", "R*-", "ℝ⁻*", "ℝ*⁻", "ℝ-*", "ℝ*-"] },
+//                 { domain: Domain.RME, shortcuts: ["RME", "REM", "R-*", "R*-", "ℝ⁻*", "ℝ*⁻", "ℝ-*", "ℝ*-"] },
-                // Natural integers domain
+//                 // Natural integers domain
-                { domain: Domain.N, shortcuts: ["ℕ", "N", "ZP", "Z+", "ℤ⁺", "ℤ+"] },
+//                 { domain: Domain.N, shortcuts: ["ℕ", "N", "ZP", "Z+", "ℤ⁺", "ℤ+"] },
-                // Zero-exclusive natural integers domain
+//                 // Zero-exclusive natural integers domain
-                { domain: Domain.NE, shortcuts: ["NE", "NP", "N*", "N+", "ℕ*", "ℕ⁺", "ℕ+", "ZPE", "ZEP", "Z+*", "Z*+", "ℤ⁺*", "ℤ*⁺", "ℤ+*", "ℤ*+"] },
+//                 { domain: Domain.NE, shortcuts: ["NE", "NP", "N*", "N+", "ℕ*", "ℕ⁺", "ℕ+", "ZPE", "ZEP", "Z+*", "Z*+", "ℤ⁺*", "ℤ*⁺", "ℤ+*", "ℤ*+"] },
-                // Logarithmic natural domains
+//                 // Logarithmic natural domains
-                { domain: Domain.NLog, shortcuts: ["NLOG", "ℕˡᵒᵍ", "ℕLOG"] },
+//                 { domain: Domain.NLog, shortcuts: ["NLOG", "ℕˡᵒᵍ", "ℕLOG"] },
-                // All integers domains
+//                 // All integers domains
-                { domain: Domain.Z, shortcuts: ["Z", "ℤ"] },
+//                 { domain: Domain.Z, shortcuts: ["Z", "ℤ"] },
-                // Zero-exclusive all integers domain
+//                 // Zero-exclusive all integers domain
-                { domain: Domain.ZE, shortcuts: ["ZE", "Z*", "ℤ*"] },
+//                 { domain: Domain.ZE, shortcuts: ["ZE", "Z*", "ℤ*"] },
-                // Negative integers domain
+//                 // Negative integers domain
-                { domain: Domain.ZM, shortcuts: ["ZM", "Z-", "ℤ⁻", "ℤ-"] },
+//                 { domain: Domain.ZM, shortcuts: ["ZM", "Z-", "ℤ⁻", "ℤ-"] },
-                // Zero-exclusive negative integers domain
+//                 // Zero-exclusive negative integers domain
-                { domain: Domain.ZME, shortcuts: ["ZME", "ZEM", "Z-*", "Z*-", "ℤ⁻*", "ℤ*⁻", "ℤ-*", "ℤ*-"] },
+//                 { domain: Domain.ZME, shortcuts: ["ZME", "ZEM", "Z-*", "Z*-", "ℤ⁻*", "ℤ*⁻", "ℤ-*", "ℤ*-"] },
-            ]
+//             ]
-
+//
-            // Real domains
+//             // Real domains
-            for(const { domain, shortcuts } of predefinedToCheck)
+//             for(const { domain, shortcuts } of predefinedToCheck)
-                for(const shortcut of shortcuts)
+//                 for(const shortcut of shortcuts)
-                    expect(parseDomainSimple(shortcut)).to.be.equal(domain)
+//                     expect(parseDomainSimple(shortcut)).to.be.equal(domain)
-        })
+//         })
-
+//
-        it("")
+//         it("")
-    })
+//     })
-})
+// })