317 lines
9.8 KiB
JavaScript
317 lines
9.8 KiB
JavaScript
/**
|
|
* Windows Performance Tests
|
|
* Tests TUI performance specifically on Windows systems
|
|
*/
|
|
|
|
const {
|
|
detectWindowsTerminal,
|
|
getWindowsTerminalCapabilities,
|
|
} = require("../../../src/tui/utils/modernTerminal.js");
|
|
|
|
// Mock Windows environment
|
|
const mockWindowsEnvironment = (terminalType = "windows-terminal") => {
|
|
Object.defineProperty(process, "platform", {
|
|
value: "win32",
|
|
writable: true,
|
|
});
|
|
|
|
// Clear environment first
|
|
delete process.env.WT_SESSION;
|
|
delete process.env.TERM_PROGRAM;
|
|
delete process.env.PSModulePath;
|
|
delete process.env.COMSPEC;
|
|
delete process.env.COLORTERM;
|
|
|
|
switch (terminalType) {
|
|
case "windows-terminal":
|
|
process.env.WT_SESSION = "test-session";
|
|
process.env.TERM_PROGRAM = "Windows Terminal";
|
|
process.env.COLORTERM = "truecolor";
|
|
break;
|
|
case "cmd":
|
|
process.env.COMSPEC = "C:\\Windows\\system32\\cmd.exe";
|
|
break;
|
|
case "powershell":
|
|
process.env.PSModulePath = "C:\\Program Files\\PowerShell\\Modules";
|
|
process.env.TERM_PROGRAM = "PowerShell";
|
|
break;
|
|
}
|
|
};
|
|
|
|
describe("Windows Performance Tests", () => {
|
|
const originalPlatform = process.platform;
|
|
const originalEnv = process.env;
|
|
|
|
afterEach(() => {
|
|
process.env = originalEnv;
|
|
Object.defineProperty(process, "platform", {
|
|
value: originalPlatform,
|
|
writable: true,
|
|
});
|
|
});
|
|
|
|
describe("Terminal Detection Performance", () => {
|
|
test("should detect Windows Terminal capabilities quickly", () => {
|
|
mockWindowsEnvironment("windows-terminal");
|
|
|
|
const startTime = Date.now();
|
|
const capabilities = getWindowsTerminalCapabilities();
|
|
const detectionTime = Date.now() - startTime;
|
|
|
|
expect(detectionTime).toBeLessThan(10); // Should detect within 10ms
|
|
expect(capabilities.isWindowsTerminal).toBe(true);
|
|
expect(capabilities.supportsUnicode).toBe(true);
|
|
expect(capabilities.supportsTrueColor).toBe(true);
|
|
});
|
|
|
|
test("should detect Command Prompt capabilities efficiently", () => {
|
|
mockWindowsEnvironment("cmd");
|
|
|
|
const startTime = Date.now();
|
|
const capabilities = getWindowsTerminalCapabilities();
|
|
const detectionTime = Date.now() - startTime;
|
|
|
|
expect(detectionTime).toBeLessThan(10);
|
|
expect(capabilities.isCommandPrompt).toBe(true);
|
|
expect(capabilities.supportsUnicode).toBe(false);
|
|
expect(capabilities.supportsTrueColor).toBe(false);
|
|
});
|
|
|
|
test("should detect PowerShell capabilities quickly", () => {
|
|
mockWindowsEnvironment("powershell");
|
|
|
|
const startTime = Date.now();
|
|
const capabilities = getWindowsTerminalCapabilities();
|
|
const detectionTime = Date.now() - startTime;
|
|
|
|
expect(detectionTime).toBeLessThan(10);
|
|
expect(capabilities.isPowerShell).toBe(true);
|
|
expect(capabilities.supportsUnicode).toBe(true);
|
|
expect(capabilities.supports256Color).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("Memory Usage", () => {
|
|
test("should not leak memory during Windows Terminal detection", () => {
|
|
mockWindowsEnvironment("windows-terminal");
|
|
|
|
const initialMemory = process.memoryUsage().heapUsed;
|
|
|
|
// Run detection multiple times
|
|
for (let i = 0; i < 1000; i++) {
|
|
detectWindowsTerminal();
|
|
getWindowsTerminalCapabilities();
|
|
}
|
|
|
|
// Force garbage collection if available
|
|
if (global.gc) {
|
|
global.gc();
|
|
}
|
|
|
|
const finalMemory = process.memoryUsage().heapUsed;
|
|
const memoryIncrease = finalMemory - initialMemory;
|
|
|
|
// Memory increase should be minimal (less than 1MB)
|
|
expect(memoryIncrease).toBeLessThan(1024 * 1024);
|
|
});
|
|
|
|
test("should handle rapid terminal capability checks", () => {
|
|
const terminals = ["windows-terminal", "cmd", "powershell"];
|
|
const startTime = Date.now();
|
|
|
|
// Rapidly switch between terminal types
|
|
for (let i = 0; i < 100; i++) {
|
|
const terminalType = terminals[i % terminals.length];
|
|
mockWindowsEnvironment(terminalType);
|
|
getWindowsTerminalCapabilities();
|
|
}
|
|
|
|
const totalTime = Date.now() - startTime;
|
|
|
|
// Should complete 300 operations in less than 1 second
|
|
expect(totalTime).toBeLessThan(1000);
|
|
});
|
|
});
|
|
|
|
describe("Character Rendering Performance", () => {
|
|
test("should generate character fallbacks efficiently", () => {
|
|
mockWindowsEnvironment("cmd");
|
|
|
|
const startTime = Date.now();
|
|
const capabilities = getWindowsTerminalCapabilities();
|
|
|
|
// Generate character mappings
|
|
const chars = {
|
|
progress: capabilities.supportsUnicode ? "█" : "#",
|
|
empty: capabilities.supportsUnicode ? "░" : "-",
|
|
status: capabilities.supportsUnicode ? "●" : "*",
|
|
arrow: capabilities.supportsUnicode ? "►" : ">",
|
|
check: capabilities.supportsUnicode ? "✓" : "v",
|
|
cross: capabilities.supportsUnicode ? "✗" : "x",
|
|
};
|
|
|
|
// Generate progress bar strings
|
|
const progressBars = [];
|
|
for (let i = 0; i <= 100; i += 10) {
|
|
const filled = Math.round((i / 100) * 20);
|
|
progressBars.push(
|
|
chars.progress.repeat(filled) + chars.empty.repeat(20 - filled)
|
|
);
|
|
}
|
|
|
|
const generationTime = Date.now() - startTime;
|
|
|
|
expect(generationTime).toBeLessThan(50);
|
|
expect(progressBars).toHaveLength(11);
|
|
expect(progressBars[0]).toBe("--------------------"); // 0% with fallback chars
|
|
expect(progressBars[10]).toBe("####################"); // 100% with fallback chars
|
|
});
|
|
|
|
test("should handle Unicode character generation efficiently", () => {
|
|
mockWindowsEnvironment("windows-terminal");
|
|
|
|
const startTime = Date.now();
|
|
const capabilities = getWindowsTerminalCapabilities();
|
|
|
|
// Generate Unicode character strings
|
|
const unicodeStrings = [];
|
|
for (let i = 0; i < 100; i++) {
|
|
const progressChar = capabilities.supportsUnicode ? "█" : "#";
|
|
const emptyChar = capabilities.supportsUnicode ? "░" : "-";
|
|
unicodeStrings.push(progressChar.repeat(10) + emptyChar.repeat(10));
|
|
}
|
|
|
|
const generationTime = Date.now() - startTime;
|
|
|
|
expect(generationTime).toBeLessThan(50);
|
|
expect(unicodeStrings).toHaveLength(100);
|
|
expect(unicodeStrings[0]).toBe("██████████░░░░░░░░░░");
|
|
});
|
|
});
|
|
|
|
describe("Windows-Specific Optimizations", () => {
|
|
test("should optimize for Windows file path handling", () => {
|
|
const windowsPaths = [
|
|
"C:\\Users\\Test\\AppData\\Local\\Temp\\test.log",
|
|
"D:\\Projects\\MyApp\\logs\\error.log",
|
|
"\\\\server\\share\\file.txt",
|
|
"C:\\Program Files\\App\\config.json",
|
|
];
|
|
|
|
const startTime = Date.now();
|
|
|
|
const normalizedPaths = windowsPaths.map((path) => {
|
|
// Simulate path normalization
|
|
return path.replace(/\\/g, "/");
|
|
});
|
|
|
|
const processingTime = Date.now() - startTime;
|
|
|
|
expect(processingTime).toBeLessThan(10);
|
|
expect(normalizedPaths).toEqual([
|
|
"C:/Users/Test/AppData/Local/Temp/test.log",
|
|
"D:/Projects/MyApp/logs/error.log",
|
|
"//server/share/file.txt",
|
|
"C:/Program Files/App/config.json",
|
|
]);
|
|
});
|
|
|
|
test("should handle Windows environment variable processing efficiently", () => {
|
|
const windowsEnvVars = {
|
|
USERPROFILE: "C:\\Users\\TestUser",
|
|
APPDATA: "C:\\Users\\TestUser\\AppData\\Roaming",
|
|
LOCALAPPDATA: "C:\\Users\\TestUser\\AppData\\Local",
|
|
PROGRAMFILES: "C:\\Program Files",
|
|
SYSTEMROOT: "C:\\Windows",
|
|
};
|
|
|
|
const startTime = Date.now();
|
|
|
|
// Simulate environment variable processing
|
|
Object.entries(windowsEnvVars).forEach(([key, value]) => {
|
|
expect(typeof value).toBe("string");
|
|
expect(value.length).toBeGreaterThan(0);
|
|
expect(value).toMatch(/^[A-Z]:\\/); // Windows path format
|
|
});
|
|
|
|
const processingTime = Date.now() - startTime;
|
|
expect(processingTime).toBeLessThan(10);
|
|
});
|
|
|
|
test("should efficiently detect Windows version compatibility", () => {
|
|
const startTime = Date.now();
|
|
|
|
// Simulate Windows version detection
|
|
const isWindows = process.platform === "win32";
|
|
const hasModernTerminal = Boolean(process.env.WT_SESSION);
|
|
const hasLegacyTerminal = Boolean(process.env.COMSPEC);
|
|
|
|
const detectionTime = Date.now() - startTime;
|
|
|
|
expect(detectionTime).toBeLessThan(5);
|
|
expect(typeof isWindows).toBe("boolean");
|
|
expect(typeof hasModernTerminal).toBe("boolean");
|
|
expect(typeof hasLegacyTerminal).toBe("boolean");
|
|
});
|
|
});
|
|
|
|
describe("Stress Testing", () => {
|
|
test("should handle repeated terminal type switching", () => {
|
|
const terminals = ["windows-terminal", "cmd", "powershell"];
|
|
const results = [];
|
|
|
|
const startTime = Date.now();
|
|
|
|
for (let i = 0; i < 1000; i++) {
|
|
const terminalType = terminals[i % terminals.length];
|
|
mockWindowsEnvironment(terminalType);
|
|
const capabilities = getWindowsTerminalCapabilities();
|
|
results.push(capabilities.terminalType);
|
|
}
|
|
|
|
const totalTime = Date.now() - startTime;
|
|
|
|
expect(totalTime).toBeLessThan(500); // 1000 switches in less than 500ms
|
|
expect(results).toHaveLength(1000);
|
|
|
|
// Verify correct distribution
|
|
const windowsTerminalCount = results.filter(
|
|
(t) => t === "windows-terminal"
|
|
).length;
|
|
const cmdCount = results.filter((t) => t === "cmd").length;
|
|
const powershellCount = results.filter((t) => t === "powershell").length;
|
|
|
|
expect(windowsTerminalCount).toBeGreaterThan(300);
|
|
expect(windowsTerminalCount).toBeLessThan(350);
|
|
expect(cmdCount).toBeGreaterThan(300);
|
|
expect(cmdCount).toBeLessThan(350);
|
|
expect(powershellCount).toBeGreaterThan(300);
|
|
expect(powershellCount).toBeLessThan(350);
|
|
});
|
|
|
|
test("should maintain performance under concurrent capability checks", async () => {
|
|
mockWindowsEnvironment("windows-terminal");
|
|
|
|
const startTime = Date.now();
|
|
|
|
// Simulate concurrent capability checks
|
|
const promises = Array.from({ length: 100 }, () =>
|
|
Promise.resolve(getWindowsTerminalCapabilities())
|
|
);
|
|
|
|
const results = await Promise.all(promises);
|
|
const totalTime = Date.now() - startTime;
|
|
|
|
expect(totalTime).toBeLessThan(100);
|
|
expect(results).toHaveLength(100);
|
|
|
|
// All results should be identical
|
|
results.forEach((result) => {
|
|
expect(result.isWindowsTerminal).toBe(true);
|
|
expect(result.supportsUnicode).toBe(true);
|
|
expect(result.supportsTrueColor).toBe(true);
|
|
});
|
|
});
|
|
});
|
|
});
|