@controlium/utils 1.0.2-alpha.1 → 1.0.2-alpha.3

package/dist/cjs/logger/logger.spec.js

@@ -1,875 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const logger_1 = require("./logger");
-const fs_1 = require("fs");
-// =============================================================================
-// Helpers
-// =============================================================================
-/** Builds a standard log-capture callback and returns the output array. */
-function makeLogCapture() {
-    const logOutput = [];
-    const callback = (message, mediaType) => {
-        logOutput.push(`MediaType: [${mediaType ?? "Not Defined"}], Message: [${message}]`);
-    };
-    return { logOutput, callback };
-}
-// =============================================================================
-// Top-level suite
-// =============================================================================
-describe("Logger", () => {
-    afterEach(() => {
-        logger_1.Logger.reset(true);
-    });
-    // ---------------------------------------------------------------------------
-    // Getters and setters (non-output)
-    // ---------------------------------------------------------------------------
-    describe("Getters and setters", () => {
-        it("logToConsole round-trips correctly", () => {
-            logger_1.Logger.logToConsole = true;
-            expect(logger_1.Logger.logToConsole).toBe(true);
-            logger_1.Logger.logToConsole = false;
-            expect(logger_1.Logger.logToConsole).toBe(false);
-        });
-        it("panicMode round-trips correctly", () => {
-            logger_1.Logger.panicMode = true;
-            expect(logger_1.Logger.panicMode).toBe(true);
-            logger_1.Logger.panicMode = false;
-            expect(logger_1.Logger.panicMode).toBe(false);
-        });
-        it("throwErrorIfLogOutputFails round-trips correctly", () => {
-            logger_1.Logger.throwErrorIfLogOutputFails = true;
-            expect(logger_1.Logger.throwErrorIfLogOutputFails).toBe(true);
-            logger_1.Logger.throwErrorIfLogOutputFails = false;
-            expect(logger_1.Logger.throwErrorIfLogOutputFails).toBe(false);
-        });
-        it("writeLineOptions getter returns the active writeLine configuration", () => {
-            const opts = logger_1.Logger.writeLineOptions;
-            expect(opts).toBeDefined();
-            expect(typeof opts.maxLines).toBe("number");
-        });
-        it("clearOutputCallback sets callback to undefined", () => {
-            logger_1.Logger.logOutputCallback = () => { };
-            expect(logger_1.Logger.logOutputCallback).toBeDefined();
-            logger_1.Logger.clearOutputCallback();
-            expect(logger_1.Logger.logOutputCallback).toBeUndefined();
-        });
-        describe("reset()", () => {
-            it("reset(false) preserves the existing start time", () => {
-                // Give Logger a known start time by resetting with true first
-                logger_1.Logger.reset(true);
-                const timeBefore = logger_1.Logger["startTime"];
-                // Wait a tick to ensure time would differ if reset
-                // (no actual sleep needed — just check the value is unchanged)
-                logger_1.Logger.reset(false);
-                const timeAfter = logger_1.Logger["startTime"];
-                expect(timeAfter).toBe(timeBefore);
-            });
-            it("reset(true) updates the start time to approximately now", () => {
-                const before = Date.now();
-                logger_1.Logger.reset(true);
-                const after = Date.now();
-                const startTime = logger_1.Logger["startTime"];
-                expect(startTime).toBeGreaterThanOrEqual(before);
-                expect(startTime).toBeLessThanOrEqual(after);
-            });
-            it("reset() restores default options (logToConsole becomes false)", () => {
-                logger_1.Logger.logToConsole = true;
-                logger_1.Logger.reset();
-                expect(logger_1.Logger.logToConsole).toBe(false);
-            });
-            it("reset() clears the output callback", () => {
-                logger_1.Logger.logOutputCallback = () => { };
-                logger_1.Logger.reset();
-                expect(logger_1.Logger.logOutputCallback).toBeUndefined();
-            });
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // Logging level — numeric
-    // ---------------------------------------------------------------------------
-    describe("Logging level (numeric)", () => {
-        it.each([
-            [logger_1.Logger.Levels.FrameworkDebug],
-            [logger_1.Logger.Levels.FrameworkInformation],
-            [logger_1.Logger.Levels.TestDebug],
-            [logger_1.Logger.Levels.TestInformation],
-            [logger_1.Logger.Levels.Error],
-            [logger_1.Logger.Levels.NoOutput],
-            [7],
-        ])("level %p round-trips correctly", (level) => {
-            logger_1.Logger.loggingLevel = level;
-            expect(logger_1.Logger.loggingLevel).toEqual(level);
-        });
-        it("negative value defaults to FrameworkDebug and emits a warning", () => {
-            const { logOutput, callback } = makeLogCapture();
-            logger_1.Logger.logOutputCallback = callback;
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.NoOutput;
-            logger_1.Logger.loggingLevel = -1;
-            expect(logger_1.Logger.loggingLevel).toEqual(logger_1.Logger.Levels.FrameworkDebug);
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(/WARNG.*Invalid Log Level \[-1\] \(Must be integer greater than zero\)\. Defaulting to Framework Debug!/);
-        });
-        it("decimal value defaults to FrameworkDebug and emits a warning", () => {
-            const { logOutput, callback } = makeLogCapture();
-            logger_1.Logger.logOutputCallback = callback;
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.NoOutput;
-            logger_1.Logger.loggingLevel = 3.7;
-            expect(logger_1.Logger.loggingLevel).toEqual(logger_1.Logger.Levels.FrameworkDebug);
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(/WARNG.*Invalid Log Level \[3\.7\] \(Must be integer greater than zero\)\. Defaulting to Framework Debug!/);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // Logging level — text
-    // ---------------------------------------------------------------------------
-    describe("Logging level (text)", () => {
-        it.each([
-            ["Framework debug", "Framework debug (FKDBG)"],
-            ["Framework information", "Framework information (FKINF)"],
-            ["TEST DEBUG", "Test debug (TSDBG)"],
-            ["test information", "Test information (TSINF)"],
-            ["Error", "Errors only (ERROR)"],
-            ["No Output", "No output from Log (NOOUT)"],
-            ["verbose", "Special Level"],
-            ["maximum", "Special Level"],
-            ["max", "Special Level"],
-            ["special", "Special Level"],
-            [32, "Special Level"]
-        ])("text '%s' resolves to '%s'", (input, expected) => {
-            logger_1.Logger.loggingLevel = input;
-            expect(logger_1.Logger.loggingLevelText).toMatch(expected);
-        });
-        it.each([
-            ["fkdbg", "Framework debug (FKDBG)"],
-            ["fkINF", "Framework information (FKINF)"],
-            ["ts dbg", "Test debug (TSDBG)"],
-            ["TSINF", "Test information (TSINF)"],
-            ["noout", "No output from Log (NOOUT)"],
-        ])("shortcode '%s' resolves to '%s'", (input, expected) => {
-            logger_1.Logger.loggingLevel = input;
-            expect(logger_1.Logger.loggingLevelText).toMatch(expected);
-        });
-        it("unknown text defaults to FrameworkDebug and emits a warning", () => {
-            const { logOutput, callback } = makeLogCapture();
-            logger_1.Logger.logOutputCallback = callback;
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.NoOutput;
-            logger_1.Logger.loggingLevel = "wibble";
-            expect(logger_1.Logger.loggingLevel).toEqual(logger_1.Logger.Levels.FrameworkDebug);
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(/WARNG.*Unknown Log Level \[wibble\]\. Defaulting to Framework Debug!/);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // Logging level — loggingLevelText
-    // ---------------------------------------------------------------------------
-    describe("loggingLevelText", () => {
-        it.each([
-            [logger_1.Logger.Levels.FrameworkDebug, "Framework debug (FKDBG)"],
-            [logger_1.Logger.Levels.FrameworkInformation, "Framework information (FKINF)"],
-            [logger_1.Logger.Levels.TestDebug, "Test debug (TSDBG)"],
-            [logger_1.Logger.Levels.TestInformation, "Test information (TSINF)"],
-            [logger_1.Logger.Levels.Error, "Errors only (ERROR)"],
-            [logger_1.Logger.Levels.NoOutput, "No output from Log (NOOUT)"],
-            [7, "Special Level - (7)"],
-        ])("level %p returns '%s'", (level, expectedText) => {
-            logger_1.Logger.loggingLevel = level;
-            expect(logger_1.Logger.loggingLevelText).toMatch(expectedText);
-        });
-        it("negative internal level returns 'Unknown!'", () => {
-            logger_1.Logger["options"]["loggingCurrentLevel"] = -10;
-            expect(logger_1.Logger.loggingLevelText).toMatch("Unknown!");
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // loggingLevelDescription
-    // ---------------------------------------------------------------------------
-    describe("loggingLevelDescription", () => {
-        it("returns plain level name when no filter is active", () => {
-            const result = logger_1.Logger.loggingLevelDescription(logger_1.Logger.Levels.FrameworkDebug, logger_1.Logger.Levels.NoOutput, logger_1.Logger.Levels.NoOutput);
-            expect(result).toMatch("Framework debug (FKDBG)");
-        });
-        it("returns single-level description when min equals max", () => {
-            const result = logger_1.Logger.loggingLevelDescription(logger_1.Logger.Levels.Error, logger_1.Logger.Levels.Warning, logger_1.Logger.Levels.Warning);
-            expect(result).toMatch(/Levels \[.*\] and \[.*\]/);
-        });
-        it("returns range description when min is less than max", () => {
-            const result = logger_1.Logger.loggingLevelDescription(logger_1.Logger.Levels.Error, logger_1.Logger.Levels.TestInformation, logger_1.Logger.Levels.FrameworkDebug);
-            expect(result).toMatch(/Between levels \[.*\]/);
-        });
-        it("includes panic preamble when panicMode is active", () => {
-            logger_1.Logger.panicMode = true;
-            const result = logger_1.Logger.loggingLevelDescription(logger_1.Logger.Levels.Error, logger_1.Logger.Levels.NoOutput, logger_1.Logger.Levels.NoOutput);
-            expect(result).toMatch(/^P: /);
-        });
-        it("returns plain level name when filter range is inverted (min > max)", () => {
-            const result = logger_1.Logger.loggingLevelDescription(logger_1.Logger.Levels.Error, logger_1.Logger.Levels.FrameworkDebug, logger_1.Logger.Levels.TestInformation);
-            expect(result).toBeDefined();
-            expect(typeof result).toBe("string");
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // loggingFilter
-    // ---------------------------------------------------------------------------
-    describe("loggingFilter", () => {
-        it("getter returns { min, max } matching what was set", () => {
-            logger_1.Logger.loggingFilter = { min: 20, max: 25 };
-            expect(logger_1.Logger.loggingFilter).toEqual({ min: 20, max: 25 });
-        });
-        it("round-trips correctly via getter after setter", () => {
-            logger_1.Logger.loggingFilter = { min: logger_1.Logger.Levels.Error, max: logger_1.Logger.Levels.Warning };
-            const filter = logger_1.Logger.loggingFilter;
-            expect(filter.min).toBe(logger_1.Logger.Levels.Error);
-            expect(filter.max).toBe(logger_1.Logger.Levels.Warning);
-        });
-        it("accepts string level names", () => {
-            logger_1.Logger.loggingFilter = { min: "Error", max: "Warning" };
-            expect(logger_1.Logger.loggingFilter).toEqual({
-                min: logger_1.Logger.Levels.Error,
-                max: logger_1.Logger.Levels.Warning,
-            });
-        });
-        it("invalid min defaults to NoOutput and emits a warning", () => {
-            const { logOutput, callback } = makeLogCapture();
-            logger_1.Logger.logOutputCallback = callback;
-            logger_1.Logger.loggingFilter = { min: -5, max: 10 };
-            expect(logger_1.Logger.loggingFilter.min).toBe(logger_1.Logger.Levels.NoOutput);
-            expect(logOutput.length).toBeGreaterThanOrEqual(1);
-            expect(logOutput[0]).toMatch(/WARNG.*Invalid Log Level/);
-        });
-        it("invalid max defaults to NoOutput and emits a warning", () => {
-            const { logOutput, callback } = makeLogCapture();
-            logger_1.Logger.logOutputCallback = callback;
-            logger_1.Logger.loggingFilter = { min: 1, max: -5 };
-            expect(logger_1.Logger.loggingFilter.max).toBe(logger_1.Logger.Levels.NoOutput);
-            expect(logOutput.length).toBeGreaterThanOrEqual(1);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // writeLine — preamble and filtering (normal mode)
-    // ---------------------------------------------------------------------------
-    describe("writeLine — normal mode", () => {
-        let logOutput;
-        beforeEach(() => {
-            const capture = makeLogCapture();
-            logOutput = capture.logOutput;
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Verbose;
-            logger_1.Logger.logOutputCallback = capture.callback;
-        });
-        it("emits the correct write-type label for every built-in level", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "error test");
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Warning, "warn test");
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.FrameworkDebug, "framework debug test");
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.FrameworkInformation, "framework info test");
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.TestDebug, "test debug test");
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.TestInformation, "test info test");
-            logger_1.Logger.writeLine(20, "special stuff");
-            expect(logOutput).toHaveLength(7);
-            expect(logOutput[0]).toMatch(/Message: \[ERROR - /);
-            expect(logOutput[1]).toMatch(/Message: \[WARNG - /);
-            expect(logOutput[2]).toMatch(/Message: \[FKDBG - /);
-            expect(logOutput[3]).toMatch(/Message: \[FKINF - /);
-            expect(logOutput[4]).toMatch(/Message: \[TSDBG - /);
-            expect(logOutput[5]).toMatch(/Message: \[TSINF - /);
-            expect(logOutput[6]).toMatch(/Message: \[00020 - /);
-        });
-        it("preamble contains a wall-clock timestamp and an elapsed time", () => {
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "timestamp test");
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(/- \[\d{2}:\d{2}:\d{2}\]\[00:00\.\d{3}\] \[/);
-        });
-        it("preamble contains the caller's file, line, and column", () => {
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "caller test");
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(/\[Object\.<anonymous>\(logger\.spec\.ts:\d{1,3}:\d{1,2}\)\]/);
-        });
-        it("message text appears at the end of the log line", () => {
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "hello world");
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(/: hello world]$/);
-        });
-        it("NoOutput level produces no output", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.NoOutput, "should be silent");
-            expect(logOutput).toHaveLength(0);
-        });
-        it("custom timestamp and elapsed format strings are applied", () => {
-            logger_1.Logger.writeLineOptions.timeFormat = ">>'TIME:' yyyy<<";
-            logger_1.Logger.writeLineOptions.elapsedFormat = ">>'ELAP:' MMM<<";
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "format test");
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(/\[>>TIME: 20\d{2}<<\]\[>>ELAP: Jan<<\]/);
-        });
-        it("suppressTimeStamp omits the timestamp from the preamble", () => {
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "no timestamp", {
-                suppressTimeStamp: true,
-            });
-            expect(logOutput).toHaveLength(1);
-            // Timestamp bracket should be absent; elapsed bracket should still be present
-            expect(logOutput[0]).not.toMatch(/\[\d{2}:\d{2}:\d{2}\]/);
-            expect(logOutput[0]).toMatch(/\[00:00\.\d{3}\]/);
-        });
-        it("suppressElapsed omits the elapsed time from the preamble", () => {
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "no elapsed", {
-                suppressElapsed: true,
-            });
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(/\[\d{2}:\d{2}:\d{2}\]/);
-            expect(logOutput[0]).not.toMatch(/\[00:00\.\d{3}\]/);
-        });
-        it("suppressTimeStamp and suppressElapsed together remove both from preamble", () => {
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "no time parts", {
-                suppressTimeStamp: true,
-                suppressElapsed: true,
-            });
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).not.toMatch(/\[\d{2}:\d{2}:\d{2}\]/);
-            expect(logOutput[0]).not.toMatch(/\[00:00\.\d{3}\]/);
-        });
-        describe("level filtering", () => {
-            it("only emits messages at or below the current level", () => {
-                logger_1.Logger.loggingLevel = logger_1.Logger.Levels.TestDebug;
-                logger_1.Logger.writeLine(logger_1.Logger.Levels.TestInformation, "should pass");
-                logger_1.Logger.writeLine(logger_1.Logger.Levels.TestDebug, "should pass");
-                logger_1.Logger.writeLine(logger_1.Logger.Levels.FrameworkInformation, "should be filtered");
-                expect(logOutput).toHaveLength(2);
-                expect(logOutput[0]).toMatch(/TSINF/);
-                expect(logOutput[1]).toMatch(/TSDBG/);
-            });
-            it("filter range passes messages within [min, max] regardless of current level", () => {
-                logger_1.Logger.loggingLevel = logger_1.Logger.Levels.TestDebug;
-                logger_1.Logger.loggingFilter = { min: 20, max: 25 };
-                logger_1.Logger.writeLine(logger_1.Logger.Levels.TestInformation, "pass — within level");
-                logger_1.Logger.writeLine(logger_1.Logger.Levels.TestDebug, "pass — within level");
-                logger_1.Logger.writeLine(logger_1.Logger.Levels.FrameworkInformation, "filtered — above level, outside range");
-                logger_1.Logger.writeLine(19, "filtered — below range");
-                logger_1.Logger.writeLine(20, "pass — range min");
-                logger_1.Logger.writeLine(25, "pass — range max");
-                logger_1.Logger.writeLine(26, "filtered — above range");
-                expect(logOutput).toHaveLength(4);
-                expect(logOutput[0]).toMatch(/TSINF/);
-                expect(logOutput[1]).toMatch(/TSDBG/);
-                expect(logOutput[2]).toMatch(/00020/);
-                expect(logOutput[3]).toMatch(/00025/);
-            });
-        });
-        it("logs to console.error when callback throws (throwErrorIfLogOutputFails=false)", () => {
-            const consoleSpy = jest.spyOn(console, "error").mockImplementation(() => { });
-            logger_1.Logger.logOutputCallback = () => { throw new Error("callback boom"); };
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "test");
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringMatching(/Error thrown from Log Output Callback during writeLine/));
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringMatching(/callback boom/));
-            consoleSpy.mockRestore();
-        });
-        it("re-throws when callback throws and throwErrorIfLogOutputFails=true", () => {
-            jest.spyOn(console, "error").mockImplementation(() => { });
-            logger_1.Logger.throwErrorIfLogOutputFails = true;
-            logger_1.Logger.logOutputCallback = () => { throw new Error("callback boom"); };
-            expect(() => logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "test")).toThrow(/Error thrown from Log Output Callback during writeLine/);
-            jest.restoreAllMocks();
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // writeLine — panic mode
-    // ---------------------------------------------------------------------------
-    describe("writeLine — panic mode", () => {
-        let logOutput;
-        beforeEach(() => {
-            const capture = makeLogCapture();
-            logOutput = capture.logOutput;
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.panicMode = true;
-            logger_1.Logger.logOutputCallback = capture.callback;
-        });
-        it("prepends 'P' to each write-type label", () => {
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Verbose;
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "error test");
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Warning, "warn test");
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.FrameworkDebug, "framework debug test");
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.FrameworkInformation, "framework info test");
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.TestDebug, "test debug test");
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.TestInformation, "test info test");
-            logger_1.Logger.writeLine(20, "special stuff");
-            expect(logOutput).toHaveLength(7);
-            expect(logOutput[0]).toMatch(/Message: \[PERROR - /);
-            expect(logOutput[1]).toMatch(/Message: \[PWARNG - /);
-            expect(logOutput[2]).toMatch(/Message: \[PFKDBG - /);
-            expect(logOutput[3]).toMatch(/Message: \[PFKINF - /);
-            expect(logOutput[4]).toMatch(/Message: \[PTSDBG - /);
-            expect(logOutput[5]).toMatch(/Message: \[PTSINF - /);
-            expect(logOutput[6]).toMatch(/Message: \[P00020 - /);
-        });
-        it("outputs all messages regardless of current logging level", () => {
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.TestDebug;
-            logger_1.Logger.loggingFilter = { min: 20, max: 25 };
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.TestInformation, "should pass");
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.TestDebug, "should pass");
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.FrameworkInformation, "should pass — panic");
-            logger_1.Logger.writeLine(19, "should pass — panic");
-            logger_1.Logger.writeLine(20, "should pass");
-            logger_1.Logger.writeLine(25, "should pass");
-            logger_1.Logger.writeLine(26, "should pass — panic");
-            expect(logOutput).toHaveLength(7);
-        });
-        it("NoOutput level is still suppressed in panic mode", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.NoOutput, "should still be silent");
-            expect(logOutput).toHaveLength(1);
-        });
-        it("preamble still contains timestamp and elapsed time", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "panic timestamp test");
-            expect(logOutput[0]).toMatch(/- \[\d{2}:\d{2}:\d{2}\]\[00:00\.\d{3}\] \[/);
-        });
-        it("preamble still shows the caller's file and location", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "panic caller test");
-            expect(logOutput[0]).toMatch(/\[Object\.<anonymous>\(logger\.spec\.ts:\d{1,3}:\d{1,2}\)\]/);
-        });
-        it("custom timestamp and elapsed formats are applied in panic mode", () => {
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Verbose;
-            logger_1.Logger.writeLineOptions.timeFormat = ">>'TIME:' yyyy<<";
-            logger_1.Logger.writeLineOptions.elapsedFormat = ">>'ELAP:' MMM<<";
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "format test");
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(/\[PERROR - \[>>TIME: 20\d{2}<<\]\[>>ELAP: Jan<<\]/);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // writeLine — multiline
-    // ---------------------------------------------------------------------------
-    describe("writeLine — multiline", () => {
-        let logOutput;
-        beforeEach(() => {
-            const capture = makeLogCapture();
-            logOutput = capture.logOutput;
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.logOutputCallback = (message) => logOutput.push(message);
-        });
-        it("splits a two-line string into two separate log entries", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "line 1\nline 2");
-            expect(logOutput).toHaveLength(2);
-            expect(logOutput[0]).toMatch(/: line 1$/);
-            expect(logOutput[1]).toMatch(/: line 2$/);
-        });
-        it("respects maxLines and inserts a truncation notice for skipped lines", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "line 1\nline 2\nline 3\nline 4\nline 5\nline 6", { maxLines: 4 });
-            expect(logOutput).toHaveLength(4);
-            expect(logOutput[0]).toMatch(/: line 1$/);
-            expect(logOutput[1]).toMatch(/: line 2$/);
-            expect(logOutput[2]).toMatch(/\.\.\. \(Skipping some lines as total length \(6\) > 4!!\)$/);
-            expect(logOutput[3]).toMatch(/: line 6$/);
-        });
-        it("maxLines of 1 is treated as 1 (not 0 or negative)", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "line 1\nline 2\nline 3\nline 4", {
-                maxLines: 3,
-            });
-            // maxLines=1: first line becomes the truncation notice, last line is kept
-            expect(logOutput).toHaveLength(3);
-        });
-        it("throws and logs an error when maxLines is less than 3", () => {
-            expect(() => {
-                logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "line 1\nline 2", { maxLines: 2 });
-            }).toThrow("maxLines must be 3 or greater!  Number given was <2>");
-            expect(logOutput.some((line) => line.includes("maxLines must be 3 or greater!  Number given was <2>"))).toBe(true);
-        });
-        it("outputs all lines when line count exactly equals maxLines", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "line 1\nline 2\nline 3", { maxLines: 3 });
-            expect(logOutput).toHaveLength(3);
-            expect(logOutput[0]).toMatch(/: line 1$/);
-            expect(logOutput[1]).toMatch(/: line 2$/);
-            expect(logOutput[2]).toMatch(/: line 3$/);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // writeLine — preamble suppression
-    // ---------------------------------------------------------------------------
-    describe("writeLine — preamble suppression", () => {
-        let logOutput;
-        beforeEach(() => {
-            logOutput = [];
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.logOutputCallback = (message) => logOutput.push(message);
-        });
-        it("suppressAllPreamble removes preamble from a single-line message", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "plain text", {
-                suppressAllPreamble: true,
-            });
-            expect(logOutput[0]).toBe("plain text");
-        });
-        it("suppressAllPreamble removes preamble from every line of a multi-line message", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "line 1\nline 2\nline 3", { suppressAllPreamble: true });
-            expect(logOutput[0]).toBe("line 1");
-            expect(logOutput[1]).toBe("line 2");
-            expect(logOutput[2]).toBe("line 3");
-        });
-        it("suppressMultilinePreamble keeps preamble on the first line only", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "line 1\nline 2\nline 3", { suppressMultilinePreamble: true });
-            expect(logOutput[0]).toMatch(/^.*: line 1$/);
-            expect(logOutput[1]).toBe("line 2");
-            expect(logOutput[2]).toBe("line 3");
-        });
-        it("suppressAllPreamble takes precedence over suppressMultilinePreamble", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "line 1\nline 2\nline 3", { suppressMultilinePreamble: true, suppressAllPreamble: true });
-            expect(logOutput[0]).toBe("line 1");
-            expect(logOutput[1]).toBe("line 2");
-            expect(logOutput[2]).toBe("line 3");
-        });
-        it("suppressAllPreamble with maxLines: truncation notice has no preamble", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "line 1\nline 2\nline 3\nline 4\nline 5\nline 6", { maxLines: 4, suppressAllPreamble: true });
-            expect(logOutput[0]).toBe("line 1");
-            expect(logOutput[1]).toBe("line 2");
-            expect(logOutput[2]).toMatch(/^\.\.\. \(Skipping/);
-            expect(logOutput[3]).toBe("line 6");
-        });
-        it("suppressMultilinePreamble with maxLines: truncation notice has no preamble", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "line 1\nline 2\nline 3\nline 4\nline 5\nline 6", { maxLines: 4, suppressMultilinePreamble: true });
-            expect(logOutput[0]).toMatch(/^.*: line 1$/);
-            expect(logOutput[1]).toBe("line 2");
-            expect(logOutput[2]).toMatch(/^\.\.\. \(Skipping some lines as total length \(6\) > 4!!\)$/);
-            expect(logOutput[3]).toBe("line 6");
-        });
-        it("both suppression flags with maxLines: all lines bare", () => {
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.Error, "line 1\nline 2\nline 3\nline 4\nline 5\nline 6", { maxLines: 4, suppressMultilinePreamble: true, suppressAllPreamble: true });
-            expect(logOutput[0]).toBe("line 1");
-            expect(logOutput[1]).toBe("line 2");
-            expect(logOutput[2]).toMatch(/^\.\.\. \(Skipping/);
-            expect(logOutput[3]).toBe("line 6");
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // Console output behaviour
-    // ---------------------------------------------------------------------------
-    describe("Console output", () => {
-        let logSpy;
-        let logOutput;
-        beforeEach(() => {
-            logOutput = [];
-            logSpy = jest.spyOn(console, "log").mockImplementation();
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.FrameworkDebug;
-        });
-        afterEach(() => {
-            logSpy.mockRestore();
-        });
-        it("logToConsole=true writes to console in addition to the callback", () => {
-            logger_1.Logger.logOutputCallback = (message) => logOutput.push(message);
-            logger_1.Logger.logToConsole = true;
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.TestInformation, "console test");
-            expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/TSINF - \[.*console test/));
-            expect(logOutput).toHaveLength(1);
-        });
-        it("logToConsole=false does not write to console when callback is set", () => {
-            logger_1.Logger.logOutputCallback = (message) => logOutput.push(message);
-            logger_1.Logger.logToConsole = false;
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.TestInformation, "silent console");
-            expect(logSpy).not.toHaveBeenCalled();
-            expect(logOutput).toHaveLength(1);
-        });
-        it("with no callback and logToConsole=false, still writes to console as fallback", () => {
-            logger_1.Logger.clearOutputCallback();
-            logger_1.Logger.logToConsole = false;
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.TestInformation, "fallback console");
-            expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/TSINF - \[.*fallback console/));
-        });
-        it("with no callback and logToConsole=true, writes to console exactly once", () => {
-            logger_1.Logger.clearOutputCallback();
-            logger_1.Logger.logToConsole = true;
-            logger_1.Logger.writeLine(logger_1.Logger.Levels.TestInformation, "once only");
-            expect(logSpy).toHaveBeenCalledTimes(1);
-        });
-        it("logToConsole getter matches what was set", () => {
-            logger_1.Logger.logToConsole = true;
-            expect(logger_1.Logger.logToConsole).toBe(true);
-            logger_1.Logger.logToConsole = false;
-            expect(logger_1.Logger.logToConsole).toBe(false);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // attach()
-    // ---------------------------------------------------------------------------
-    describe("attach()", () => {
-        let logOutput;
-        beforeEach(() => {
-            const capture = makeLogCapture();
-            logOutput = capture.logOutput;
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.logOutputCallback = capture.callback;
-        });
-        it("passes data and mediaType through to the callback", () => {
-            logger_1.Logger.attach(logger_1.Logger.Levels.Error, "<b>hi</b>", "text/html");
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(/MediaType: \[text\/html\], Message: \[<b>hi<\/b>\]/);
-        });
-        it("is suppressed when logLevel is below the current logging level", () => {
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.attach(logger_1.Logger.Levels.Warning, "should be filtered", "text/plain");
-            expect(logOutput).toHaveLength(0);
-        });
-        it("logs an error when callback is not a function", () => {
-            const consoleSpy = jest.spyOn(console, "log").mockImplementation();
-            logger_1.Logger.clearOutputCallback();
-            logger_1.Logger.logToConsole = false;
-            logger_1.Logger.attach(logger_1.Logger.Levels.Error, "test", "text/plain");
-            // Output goes to console fallback since no callback is set
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringMatching(/Log Output callback is type \[undefined\]/));
-            consoleSpy.mockRestore();
-        });
-        it("when callback is set to a non-function, error is logged via console", () => {
-            logger_1.Logger.logOutputCallback = "not-a-function";
-            const consoleSpy = jest.spyOn(console, "log").mockImplementation();
-            logger_1.Logger.attach(logger_1.Logger.Levels.Error, "test", "text/plain");
-            expect(consoleSpy).toHaveBeenCalledWith(expect.stringMatching(/Log Output callback is type \[string\]/));
-            consoleSpy.mockRestore();
-        });
-        it("non-string data is described correctly in the error message", () => {
-            logger_1.Logger.logOutputCallback = (message, mediaType) => {
-                if (mediaType === "base64:image/png")
-                    throw new Error("deliberate");
-                logOutput.push(`MediaType: [${mediaType ?? "Not Defined"}], Message: [${message}]`);
-            };
-            logger_1.Logger.attach(logger_1.Logger.Levels.Error, 24, "base64:image/png");
-            // Error details are written back through writeLine -> logOutput
-            const combined = logOutput.join("\n");
-            expect(combined).toMatch(/Not a string! Is type number/);
-        });
-        it("long data strings are truncated in the error message", () => {
-            logger_1.Logger.logOutputCallback = (message, mediaType) => {
-                if (mediaType === "base64:image/png")
-                    throw new Error("deliberate");
-                logOutput.push(`MediaType: [${mediaType ?? "Not Defined"}], Message: [${message}]`);
-            };
-            logger_1.Logger.attach(logger_1.Logger.Levels.Error, "A very long text that will have to be truncated so that it doesnt overrun", "base64:image/png");
-            const combined = logOutput.join("\n");
-            expect(combined).toMatch(/A very long text that wil\.\.\.run/);
-        });
-        it("throwErrorIfLogOutputFails=true re-throws callback errors", () => {
-            logger_1.Logger.throwErrorIfLogOutputFails = true;
-            logger_1.Logger.logOutputCallback = () => {
-                throw new Error("callback failure");
-            };
-            expect(() => logger_1.Logger.attach(logger_1.Logger.Levels.Error, "data", "text/plain")).toThrow("callback failure");
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // attachHTML()
-    // ---------------------------------------------------------------------------
-    describe("attachHTML()", () => {
-        let logOutput;
-        beforeEach(() => {
-            const capture = makeLogCapture();
-            logOutput = capture.logOutput;
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.logOutputCallback = capture.callback;
-        });
-        it("sends HTML content with text/html media type", () => {
-            const html = "<div>hello</div>";
-            logger_1.Logger.attachHTML(logger_1.Logger.Levels.Error, html);
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(new RegExp(`MediaType: \\[text/html\\], Message: \\[${html.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\]`));
-        });
-        it("is suppressed when logLevel is below the current logging level", () => {
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.attachHTML(logger_1.Logger.Levels.Warning, "<p>filtered</p>");
-            expect(logOutput).toHaveLength(0);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // attachScreenshot()
-    // ---------------------------------------------------------------------------
-    describe("attachScreenshot()", () => {
-        let logOutput;
-        beforeEach(() => {
-            const capture = makeLogCapture();
-            logOutput = capture.logOutput;
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.logOutputCallback = capture.callback;
-        });
-        it("attaches a Buffer as a base64-encoded PNG", () => {
-            const buffer = Buffer.from("Test string", "utf8");
-            const expected = buffer.toString("base64");
-            logger_1.Logger.attachScreenshot(logger_1.Logger.Levels.Error, buffer);
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(new RegExp(`MediaType: \\[base64:image/png\\], Message: \\[${expected}\\]`));
-        });
-        it("attaches a plain string by base64-encoding it", () => {
-            const input = "Test string";
-            const expected = Buffer.from(input, "utf8").toString("base64");
-            logger_1.Logger.attachScreenshot(logger_1.Logger.Levels.Error, input);
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(new RegExp(`MediaType: \\[base64:image/png\\], Message: \\[${expected}\\]`));
-        });
-        it("is suppressed when logLevel is below the current logging level", () => {
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.attachScreenshot(logger_1.Logger.Levels.Warning, "filtered");
-            expect(logOutput).toHaveLength(0);
-        });
-        it("processes callback errors via processError when callback throws", () => {
-            const errorMessage = "reporter rejected";
-            logger_1.Logger.logOutputCallback = (message, mediaType) => {
-                if (mediaType === "base64:image/png")
-                    throw new Error(errorMessage);
-                logOutput.push(message);
-            };
-            logger_1.Logger.attachScreenshot(logger_1.Logger.Levels.Error, "test");
-            const combined = logOutput.join("\n");
-            expect(combined).toMatch(/Error thrown from Log Output Callback/);
-            expect(combined).toMatch(new RegExp(errorMessage));
-        });
-        it("re-throws callback errors when throwErrorIfLogOutputFails=true", () => {
-            const screenshot = "test-screenshot";
-            logger_1.Logger.throwErrorIfLogOutputFails = true;
-            logger_1.Logger.logOutputCallback = (_, mediaType) => {
-                if (mediaType === "base64:image/png")
-                    throw new Error("No Like");
-                logOutput.push(`MediaType: [${mediaType}]`);
-            };
-            let thrown = "";
-            try {
-                logger_1.Logger.attachScreenshot(logger_1.Logger.Levels.Error, screenshot);
-            }
-            catch (err) {
-                thrown = err.message;
-            }
-            const lines = thrown.split("\n");
-            expect(lines[0]).toMatch(/Error thrown from Log Output Callback/);
-            expect(lines[1]).toMatch(/No Like/);
-            expect(lines[3]).toMatch(new RegExp(Buffer.from(screenshot, "utf8").toString("base64")));
-            expect(lines[5]).toMatch(/base64:image\/png/);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // attachVideo() and attachVideoFile()
-    // ---------------------------------------------------------------------------
-    describe("attachVideo()", () => {
-        let logOutput;
-        beforeEach(() => {
-            const capture = makeLogCapture();
-            logOutput = capture.logOutput;
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.logOutputCallback = capture.callback;
-        });
-        it("wraps the buffer in a <video> tag with default options", () => {
-            const buffer = Buffer.from("Test string", "utf8");
-            const base64 = buffer.toString("base64");
-            logger_1.Logger.attachVideo(logger_1.Logger.Levels.Error, buffer);
-            const expected = `<video controls width="320" height="180"><source src="data:video/webm;base64,${base64}" type="video/webm">Video (Codec webm) not supported by browser</video>`;
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(new RegExp(`MediaType: \\[text/html\\], Message: \\[${expected.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\]`));
-        });
-        it("uses caller-supplied VideoOptions over the defaults", () => {
-            const buffer = Buffer.from("Test string", "utf8");
-            const base64 = buffer.toString("base64");
-            logger_1.Logger.attachVideo(logger_1.Logger.Levels.Error, buffer, {
-                width: 640,
-                height: 360,
-                videoCodec: "mp4",
-            });
-            const expected = `<video controls width="640" height="360"><source src="data:video/mp4;base64,${base64}" type="video/mp4">Video (Codec mp4) not supported by browser</video>`;
-            expect(logOutput[0]).toMatch(new RegExp(`MediaType: \\[text/html\\], Message: \\[${expected.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\]`));
-        });
-        it("is suppressed when logLevel is below the current logging level", () => {
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.attachVideo(logger_1.Logger.Levels.Warning, Buffer.from("x"));
-            expect(logOutput).toHaveLength(0);
-        });
-        it("adds title='PANIC_MODE' to the video element when panicMode is active", () => {
-            logger_1.Logger.panicMode = true;
-            const buffer = Buffer.from("test", "utf8");
-            logger_1.Logger.attachVideo(logger_1.Logger.Levels.Error, buffer);
-            expect(logOutput[0]).toMatch(/title="PANIC_MODE"/);
-        });
-    });
-    describe("attachVideoFile()", () => {
-        let logOutput;
-        beforeEach(() => {
-            const capture = makeLogCapture();
-            logOutput = capture.logOutput;
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.logOutputCallback = capture.callback;
-        });
-        it("reads the file and attaches it as video", () => {
-            const fileName = "testData/testData.txt";
-            const buffer = (0, fs_1.readFileSync)(fileName);
-            const base64 = buffer.toString("base64");
-            logger_1.Logger.attachVideoFile(logger_1.Logger.Levels.Error, fileName);
-            const expected = `<video controls width="320" height="180"><source src="data:video/webm;base64,${base64}" type="video/webm">Video (Codec webm) not supported by browser</video>`;
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(new RegExp(`MediaType: \\[text/html\\], Message: \\[${expected.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\]`));
-        });
-        it("logs an error when the file does not exist", () => {
-            logger_1.Logger.attachVideoFile(logger_1.Logger.Levels.Error, "testData/does-not-exist.txt");
-            expect(logOutput).toHaveLength(2);
-            expect(logOutput[0]).toMatch(/\[ERROR.*Error thrown reading video data/);
-            expect(logOutput[1]).toMatch(/ENOENT.*no such file or directory/);
-        });
-        it("is suppressed when logLevel is below the current logging level", () => {
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Error;
-            logger_1.Logger.attachVideoFile(logger_1.Logger.Levels.Warning, "testData/testData.txt");
-            expect(logOutput).toHaveLength(0);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // videoOptions getter/setter
-    // ---------------------------------------------------------------------------
-    describe("videoOptions", () => {
-        let logOutput;
-        beforeEach(() => {
-            const capture = makeLogCapture();
-            logOutput = capture.logOutput;
-            logger_1.Logger.loggingLevel = logger_1.Logger.Levels.Warning;
-            logger_1.Logger.logOutputCallback = capture.callback;
-            logger_1.Logger.videoOptions = { height: 180, width: 320 };
-        });
-        it("accepts valid dimensions within limits", () => {
-            logger_1.Logger.videoOptions = { height: 181, width: 320 };
-            expect(logOutput).toHaveLength(0);
-            expect(logger_1.Logger.videoOptions).toEqual({ videoCodec: "webm", height: 181, width: 320 });
-        });
-        it("accepts a codec-only change without altering dimensions", () => {
-            logger_1.Logger.videoOptions = { videoCodec: "mp4" };
-            expect(logOutput).toHaveLength(0);
-            expect(logger_1.Logger.videoOptions).toEqual({ videoCodec: "mp4", height: 180, width: 320 });
-        });
-        it("accepts a height-only change without altering width", () => {
-            logger_1.Logger.videoOptions = { height: 200 };
-            expect(logOutput).toHaveLength(0);
-            expect(logger_1.Logger.videoOptions).toEqual({ videoCodec: "webm", height: 200, width: 320 });
-        });
-        it("accepts a width-only change without altering height", () => {
-            logger_1.Logger.videoOptions = { width: 640 };
-            expect(logOutput).toHaveLength(0);
-            expect(logger_1.Logger.videoOptions).toEqual({ videoCodec: "webm", height: 180, width: 640 });
-        });
-        it("rejects both dimensions when height is too low; existing values are preserved", () => {
-            logger_1.Logger.videoOptions = { height: 179, width: 319 };
-            expect(logOutput).toHaveLength(2);
-            expect(logOutput[0]).toMatch(/WARNG.*Invalid video window height \[179\]/);
-            expect(logOutput[1]).toMatch(/WARNG.*Invalid video window width \[319\]/);
-            expect(logger_1.Logger.videoOptions).toEqual({ videoCodec: "webm", height: 180, width: 320 });
-        });
-        it("rejects both dimensions when height is too high; existing values are preserved", () => {
-            logger_1.Logger.videoOptions = { height: 4321, width: 7681 };
-            expect(logOutput).toHaveLength(2);
-            expect(logOutput[0]).toMatch(/WARNG.*Invalid video window height \[4321\]/);
-            expect(logOutput[1]).toMatch(/WARNG.*Invalid video window width \[7681\]/);
-        });
-        it("rejects only width when width is invalid; height and width both preserved", () => {
-            logger_1.Logger.videoOptions = { height: 1000, width: 3 };
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(/WARNG.*Invalid video window width \[3\]/);
-            expect(logger_1.Logger.videoOptions).toEqual({ videoCodec: "webm", height: 180, width: 320 });
-        });
-        it("rejects only height when height is invalid; height and width both preserved", () => {
-            logger_1.Logger.videoOptions = { height: 2, width: 1000 };
-            expect(logOutput).toHaveLength(1);
-            expect(logOutput[0]).toMatch(/WARNG.*Invalid video window height \[2\]/);
-            expect(logger_1.Logger.videoOptions).toEqual({ videoCodec: "webm", height: 180, width: 320 });
-        });
-        it("throws when a non-number is passed as a resolution value", () => {
-            expect(() => {
-                logger_1.Logger.isValidVideoResolutionNumber("not-a-number", 180, 4320, "bad value");
-            }).toThrow(/Resolution number given was a <string>/);
-        });
-    });
-});