@therealtinhtute/baroiplayer 1.0.8 → 1.2.0

package/src/core/performance/performance-testing.ts

@@ -1,459 +1,461 @@
-import { performanceMonitor, PerformanceRegressionDetector } from './performance-monitor';
-import type { PerformanceMetrics } from './performance-monitor';
+import { PerformanceRegressionDetector, performanceMonitor } from "./performance-monitor"
+import type { PerformanceMetrics } from "./performance-monitor"
 
 // Performance test configuration
 export interface PerformanceTestConfig {
-  name: string;
-  iterations: number;
-  warmupIterations: number;
-  timeout: number;
-  expectedThreshold: {
-    renderTime: number;
-    memoryUsage: number;
-  };
+	name: string
+	iterations: number
+	warmupIterations: number
+	timeout: number
+	expectedThreshold: {
+		renderTime: number
+		memoryUsage: number
+	}
 }
 
 // Performance test result
 export interface PerformanceTestResult {
-  testName: string;
-  passed: boolean;
-  metrics: {
-    averageRenderTime: number;
-    minRenderTime: number;
-    maxRenderTime: number;
-    memoryUsage: number;
-    iterations: number;
-  };
-  threshold: PerformanceTestConfig['expectedThreshold'];
-  error?: string;
+	testName: string
+	passed: boolean
+	metrics: {
+		averageRenderTime: number
+		minRenderTime: number
+		maxRenderTime: number
+		memoryUsage: number
+		iterations: number
+	}
+	threshold: PerformanceTestConfig["expectedThreshold"]
+	error?: string
 }
 
 // Performance benchmark suite
 export class PerformanceBenchmark {
-  private results: PerformanceTestResult[] = [];
-  private regressionDetector = new PerformanceRegressionDetector();
-
-  async runTest(
-    config: PerformanceTestConfig,
-    testFunction: () => any | Promise<any>
-  ): Promise<PerformanceTestResult> {
-    const renderTimes: number[] = [];
-    let memoryBefore = 0;
-    let memoryAfter = 0;
-    let error: string | undefined;
-
-    try {
-      // Warmup iterations
-      for (let i = 0; i < config.warmupIterations; i++) {
-        await testFunction();
-      }
-
-      // Force garbage collection if available
-      if (global.gc) {
-        global.gc();
-      }
-
-      memoryBefore = this.getMemoryUsage();
-
-      // Main test iterations
-      for (let i = 0; i < config.iterations; i++) {
-        const startTime = performance.now();
-        await testFunction();
-        const endTime = performance.now();
-        renderTimes.push(endTime - startTime);
-      }
-
-      memoryAfter = this.getMemoryUsage();
-
-    } catch (err) {
-      error = err instanceof Error ? err.message : String(err);
-    }
-
-    const averageRenderTime = renderTimes.reduce((sum, time) => sum + time, 0) / renderTimes.length;
-    const minRenderTime = Math.min(...renderTimes);
-    const maxRenderTime = Math.max(...renderTimes);
-    const memoryUsage = memoryAfter - memoryBefore;
-
-    const passed = !error && 
-      averageRenderTime <= config.expectedThreshold.renderTime &&
-      memoryUsage <= config.expectedThreshold.memoryUsage;
-
-    const result: PerformanceTestResult = {
-      testName: config.name,
-      passed,
-      metrics: {
-        averageRenderTime,
-        minRenderTime: isFinite(minRenderTime) ? minRenderTime : 0,
-        maxRenderTime: isFinite(maxRenderTime) ? maxRenderTime : 0,
-        memoryUsage,
-        iterations: config.iterations
-      },
-      threshold: config.expectedThreshold,
-      error
-    };
-
-    this.results.push(result);
-    return result;
-  }
-
-  private getMemoryUsage(): number {
-    if ('memory' in performance) {
-      return (performance as any).memory.usedJSHeapSize || 0;
-    }
-    return 0;
-  }
-
-  // Component rendering performance test
-  async testComponentRender(
-    componentName: string,
-    renderFunction: () => any,
-    expectedRenderTime = 16 // 60fps target
-  ): Promise<PerformanceTestResult> {
-    const config: PerformanceTestConfig = {
-      name: `${componentName} Render Performance`,
-      iterations: 100,
-      warmupIterations: 10,
-      timeout: 5000,
-      expectedThreshold: {
-        renderTime: expectedRenderTime,
-        memoryUsage: 1024 * 1024 // 1MB
-      }
-    };
-
-    return this.runTest(config, renderFunction);
-  }
-
-  // Bundle loading performance test
-  async testBundleLoading(
-    bundlePath: string,
-    expectedLoadTime = 1000 // 1 second
-  ): Promise<PerformanceTestResult> {
-    const config: PerformanceTestConfig = {
-      name: `Bundle Loading: ${bundlePath}`,
-      iterations: 5,
-      warmupIterations: 1,
-      timeout: 10000,
-      expectedThreshold: {
-        renderTime: expectedLoadTime,
-        memoryUsage: 5 * 1024 * 1024 // 5MB
-      }
-    };
-
-    return this.runTest(config, async () => {
-      // Simulate bundle loading
-      const startTime = performance.now();
-      try {
-        // Use fetch instead of dynamic import to avoid bundler issues
-        const response = await fetch(bundlePath);
-        if (!response.ok) {
-          throw new Error(`Failed to load bundle: ${response.status}`);
-        }
-        await response.blob(); // Consume the response
-      } catch (error) {
-        console.warn(`Bundle loading test failed for ${bundlePath}:`, error);
-        // Return a mock time for testing purposes
-      }
-      const endTime = performance.now();
-      return endTime - startTime;
-    });
-  }
-
-  // Memory leak detection test
-  async testMemoryLeaks(
-    testFunction: () => any,
-    iterations = 1000
-  ): Promise<PerformanceTestResult> {
-    const config: PerformanceTestConfig = {
-      name: 'Memory Leak Detection',
-      iterations,
-      warmupIterations: 100,
-      timeout: 30000,
-      expectedThreshold: {
-        renderTime: Infinity, // Not testing render time
-        memoryUsage: 10 * 1024 * 1024 // 10MB max increase
-      }
-    };
-
-    const memoryBefore = this.getMemoryUsage();
-    
-    const result = await this.runTest(config, testFunction);
-    
-    const memoryAfter = this.getMemoryUsage();
-    const memoryIncrease = memoryAfter - memoryBefore;
-    
-    // Check for memory leaks (memory should not increase significantly)
-    const hasMemoryLeak = memoryIncrease > config.expectedThreshold.memoryUsage;
-    
-    return {
-      ...result,
-      passed: result.passed && !hasMemoryLeak,
-      error: hasMemoryLeak ? `Potential memory leak detected: ${Math.round(memoryIncrease / 1024 / 1024)}MB increase` : result.error
-    };
-  }
-
-  // Interaction delay test
-  async testInteractionDelay(
-    interactionFunction: () => any,
-    expectedDelay = 100 // 100ms
-  ): Promise<PerformanceTestResult> {
-    const config: PerformanceTestConfig = {
-      name: 'Interaction Delay',
-      iterations: 50,
-      warmupIterations: 5,
-      timeout: 5000,
-      expectedThreshold: {
-        renderTime: expectedDelay,
-        memoryUsage: 1024 * 1024 // 1MB
-      }
-    };
-
-    return this.runTest(config, interactionFunction);
-  }
-
-  // Regression testing
-  async runRegressionTests(
-    currentMetrics: PerformanceMetrics,
-    baselineMetrics?: PerformanceMetrics
-  ): Promise<{
-    passed: boolean;
-    regressions: ReturnType<PerformanceRegressionDetector['detectRegression']>;
-  }> {
-    if (baselineMetrics) {
-      this.regressionDetector.setBaseline(baselineMetrics);
-    }
-
-    const regressions = this.regressionDetector.detectRegression(currentMetrics);
-    const passed = regressions.length === 0;
-
-    return { passed, regressions };
-  }
-
-  // Get all test results
-  getResults(): PerformanceTestResult[] {
-    return [...this.results];
-  }
-
-  // Get test summary
-  getSummary(): {
-    totalTests: number;
-    passedTests: number;
-    failedTests: number;
-    passRate: number;
-  } {
-    const totalTests = this.results.length;
-    const passedTests = this.results.filter(result => result.passed).length;
-    const failedTests = totalTests - passedTests;
-    const passRate = totalTests > 0 ? (passedTests / totalTests) * 100 : 0;
-
-    return { totalTests, passedTests, failedTests, passRate };
-  }
-
-  // Clear test results
-  clearResults(): void {
-    this.results = [];
-  }
-
-  // Generate performance report
-  generateReport(): string {
-    const summary = this.getSummary();
-    let report = `Performance Test Report\n`;
-    report += `========================\n\n`;
-    report += `Total Tests: ${summary.totalTests}\n`;
-    report += `Passed: ${summary.passedTests}\n`;
-    report += `Failed: ${summary.failedTests}\n`;
-    report += `Pass Rate: ${summary.passRate.toFixed(1)}%\n\n`;
-
-    if (this.results.length > 0) {
-      report += `Detailed Results:\n`;
-      report += `-----------------\n\n`;
-
-      this.results.forEach((result, index) => {
-        report += `${index + 1}. ${result.testName}\n`;
-        report += `   Status: ${result.passed ? 'PASS' : 'FAIL'}\n`;
-        report += `   Average Render Time: ${result.metrics.averageRenderTime.toFixed(2)}ms\n`;
-        report += `   Min/Max Render Time: ${result.metrics.minRenderTime.toFixed(2)}ms / ${result.metrics.maxRenderTime.toFixed(2)}ms\n`;
-        report += `   Memory Usage: ${Math.round(result.metrics.memoryUsage / 1024)} KB\n`;
-        report += `   Iterations: ${result.metrics.iterations}\n`;
-        
-        if (result.error) {
-          report += `   Error: ${result.error}\n`;
-        }
-        
-        report += `\n`;
-      });
-    }
-
-    return report;
-  }
+	private results: PerformanceTestResult[] = []
+	private regressionDetector = new PerformanceRegressionDetector()
+
+	async runTest(
+		config: PerformanceTestConfig,
+		testFunction: () => any | Promise<any>
+	): Promise<PerformanceTestResult> {
+		const renderTimes: number[] = []
+		let memoryBefore = 0
+		let memoryAfter = 0
+		let error: string | undefined
+
+		try {
+			// Warmup iterations
+			for (let i = 0; i < config.warmupIterations; i++) {
+				await testFunction()
+			}
+
+			// Force garbage collection if available
+			if (global.gc) {
+				global.gc()
+			}
+
+			memoryBefore = this.getMemoryUsage()
+
+			// Main test iterations
+			for (let i = 0; i < config.iterations; i++) {
+				const startTime = performance.now()
+				await testFunction()
+				const endTime = performance.now()
+				renderTimes.push(endTime - startTime)
+			}
+
+			memoryAfter = this.getMemoryUsage()
+		} catch (err) {
+			error = err instanceof Error ? err.message : String(err)
+		}
+
+		const averageRenderTime = renderTimes.reduce((sum, time) => sum + time, 0) / renderTimes.length
+		const minRenderTime = Math.min(...renderTimes)
+		const maxRenderTime = Math.max(...renderTimes)
+		const memoryUsage = memoryAfter - memoryBefore
+
+		const passed =
+			!error &&
+			averageRenderTime <= config.expectedThreshold.renderTime &&
+			memoryUsage <= config.expectedThreshold.memoryUsage
+
+		const result: PerformanceTestResult = {
+			testName: config.name,
+			passed,
+			metrics: {
+				averageRenderTime,
+				minRenderTime: isFinite(minRenderTime) ? minRenderTime : 0,
+				maxRenderTime: isFinite(maxRenderTime) ? maxRenderTime : 0,
+				memoryUsage,
+				iterations: config.iterations
+			},
+			threshold: config.expectedThreshold,
+			error
+		}
+
+		this.results.push(result)
+		return result
+	}
+
+	private getMemoryUsage(): number {
+		if ("memory" in performance) {
+			return (performance as any).memory.usedJSHeapSize || 0
+		}
+		return 0
+	}
+
+	// Component rendering performance test
+	async testComponentRender(
+		componentName: string,
+		renderFunction: () => any,
+		expectedRenderTime = 16 // 60fps target
+	): Promise<PerformanceTestResult> {
+		const config: PerformanceTestConfig = {
+			name: `${componentName} Render Performance`,
+			iterations: 100,
+			warmupIterations: 10,
+			timeout: 5000,
+			expectedThreshold: {
+				renderTime: expectedRenderTime,
+				memoryUsage: 1024 * 1024 // 1MB
+			}
+		}
+
+		return this.runTest(config, renderFunction)
+	}
+
+	// Bundle loading performance test
+	async testBundleLoading(
+		bundlePath: string,
+		expectedLoadTime = 1000 // 1 second
+	): Promise<PerformanceTestResult> {
+		const config: PerformanceTestConfig = {
+			name: `Bundle Loading: ${bundlePath}`,
+			iterations: 5,
+			warmupIterations: 1,
+			timeout: 10000,
+			expectedThreshold: {
+				renderTime: expectedLoadTime,
+				memoryUsage: 5 * 1024 * 1024 // 5MB
+			}
+		}
+
+		return this.runTest(config, async () => {
+			// Simulate bundle loading
+			const startTime = performance.now()
+			try {
+				// Use fetch instead of dynamic import to avoid bundler issues
+				const response = await fetch(bundlePath)
+				if (!response.ok) {
+					throw new Error(`Failed to load bundle: ${response.status}`)
+				}
+				await response.blob() // Consume the response
+			} catch (error) {
+				console.warn(`Bundle loading test failed for ${bundlePath}:`, error)
+				// Return a mock time for testing purposes
+			}
+			const endTime = performance.now()
+			return endTime - startTime
+		})
+	}
+
+	// Memory leak detection test
+	async testMemoryLeaks(
+		testFunction: () => any,
+		iterations = 1000
+	): Promise<PerformanceTestResult> {
+		const config: PerformanceTestConfig = {
+			name: "Memory Leak Detection",
+			iterations,
+			warmupIterations: 100,
+			timeout: 30000,
+			expectedThreshold: {
+				renderTime: Infinity, // Not testing render time
+				memoryUsage: 10 * 1024 * 1024 // 10MB max increase
+			}
+		}
+
+		const memoryBefore = this.getMemoryUsage()
+
+		const result = await this.runTest(config, testFunction)
+
+		const memoryAfter = this.getMemoryUsage()
+		const memoryIncrease = memoryAfter - memoryBefore
+
+		// Check for memory leaks (memory should not increase significantly)
+		const hasMemoryLeak = memoryIncrease > config.expectedThreshold.memoryUsage
+
+		return {
+			...result,
+			passed: result.passed && !hasMemoryLeak,
+			error: hasMemoryLeak
+				? `Potential memory leak detected: ${Math.round(memoryIncrease / 1024 / 1024)}MB increase`
+				: result.error
+		}
+	}
+
+	// Interaction delay test
+	async testInteractionDelay(
+		interactionFunction: () => any,
+		expectedDelay = 100 // 100ms
+	): Promise<PerformanceTestResult> {
+		const config: PerformanceTestConfig = {
+			name: "Interaction Delay",
+			iterations: 50,
+			warmupIterations: 5,
+			timeout: 5000,
+			expectedThreshold: {
+				renderTime: expectedDelay,
+				memoryUsage: 1024 * 1024 // 1MB
+			}
+		}
+
+		return this.runTest(config, interactionFunction)
+	}
+
+	// Regression testing
+	async runRegressionTests(
+		currentMetrics: PerformanceMetrics,
+		baselineMetrics?: PerformanceMetrics
+	): Promise<{
+		passed: boolean
+		regressions: ReturnType<PerformanceRegressionDetector["detectRegression"]>
+	}> {
+		if (baselineMetrics) {
+			this.regressionDetector.setBaseline(baselineMetrics)
+		}
+
+		const regressions = this.regressionDetector.detectRegression(currentMetrics)
+		const passed = regressions.length === 0
+
+		return { passed, regressions }
+	}
+
+	// Get all test results
+	getResults(): PerformanceTestResult[] {
+		return [...this.results]
+	}
+
+	// Get test summary
+	getSummary(): {
+		totalTests: number
+		passedTests: number
+		failedTests: number
+		passRate: number
+	} {
+		const totalTests = this.results.length
+		const passedTests = this.results.filter((result) => result.passed).length
+		const failedTests = totalTests - passedTests
+		const passRate = totalTests > 0 ? (passedTests / totalTests) * 100 : 0
+
+		return { totalTests, passedTests, failedTests, passRate }
+	}
+
+	// Clear test results
+	clearResults(): void {
+		this.results = []
+	}
+
+	// Generate performance report
+	generateReport(): string {
+		const summary = this.getSummary()
+		let report = `Performance Test Report\n`
+		report += `========================\n\n`
+		report += `Total Tests: ${summary.totalTests}\n`
+		report += `Passed: ${summary.passedTests}\n`
+		report += `Failed: ${summary.failedTests}\n`
+		report += `Pass Rate: ${summary.passRate.toFixed(1)}%\n\n`
+
+		if (this.results.length > 0) {
+			report += `Detailed Results:\n`
+			report += `-----------------\n\n`
+
+			this.results.forEach((result, index) => {
+				report += `${index + 1}. ${result.testName}\n`
+				report += `   Status: ${result.passed ? "PASS" : "FAIL"}\n`
+				report += `   Average Render Time: ${result.metrics.averageRenderTime.toFixed(2)}ms\n`
+				report += `   Min/Max Render Time: ${result.metrics.minRenderTime.toFixed(2)}ms / ${result.metrics.maxRenderTime.toFixed(2)}ms\n`
+				report += `   Memory Usage: ${Math.round(result.metrics.memoryUsage / 1024)} KB\n`
+				report += `   Iterations: ${result.metrics.iterations}\n`
+
+				if (result.error) {
+					report += `   Error: ${result.error}\n`
+				}
+
+				report += `\n`
+			})
+		}
+
+		return report
+	}
 }
 
 // Global performance benchmark instance
-export const performanceBenchmark = new PerformanceBenchmark();
+export const performanceBenchmark = new PerformanceBenchmark()
 
 // Utility functions for common performance tests
 export const performanceTestUtils = {
-  // Test component rendering performance
-  async testComponent(
-    Component: any,
-    props: any = {},
-    expectedRenderTime = 16
-  ): Promise<PerformanceTestResult> {
-    return performanceBenchmark.testComponentRender(
-      Component.displayName || Component.name || 'Component',
-      () => {
-        // This would need React Testing Library in a real test environment
-        // For now, we'll simulate component rendering
-        return { type: Component, props }; // Mock element
-      },
-      expectedRenderTime
-    );
-  },
-
-  // Test hook performance
-  async testHook(
-    hookFunction: () => any,
-    hookName: string,
-    expectedExecutionTime = 1
-  ): Promise<PerformanceTestResult> {
-    const config: PerformanceTestConfig = {
-      name: `Hook Performance: ${hookName}`,
-      iterations: 1000,
-      warmupIterations: 100,
-      timeout: 5000,
-      expectedThreshold: {
-        renderTime: expectedExecutionTime,
-        memoryUsage: 1024 * 1024 // 1MB
-      }
-    };
-
-    return performanceBenchmark.runTest(config, hookFunction);
-  },
-
-  // Test async operation performance
-  async testAsyncOperation(
-    operation: () => Promise<any>,
-    operationName: string,
-    expectedTime = 1000
-  ): Promise<PerformanceTestResult> {
-    const config: PerformanceTestConfig = {
-      name: `Async Operation: ${operationName}`,
-      iterations: 10,
-      warmupIterations: 2,
-      timeout: 30000,
-      expectedThreshold: {
-        renderTime: expectedTime,
-        memoryUsage: 2 * 1024 * 1024 // 2MB
-      }
-    };
-
-    return performanceBenchmark.runTest(config, operation);
-  },
-
-  // Test bundle size impact
-  async measureBundleImpact(
-    beforeFunction: () => void,
-    afterFunction: () => void,
-    featureName: string
-  ): Promise<{
-    bundleIncrease: number;
-    memoryIncrease: number;
-    renderTimeImpact: number;
-  }> {
-    const beforeMemory = (performance as any).memory?.usedJSHeapSize || 0;
-    const beforeTime = performance.now();
-    
-    beforeFunction();
-    
-    const midMemory = (performance as any).memory?.usedJSHeapSize || 0;
-    const midTime = performance.now();
-    
-    afterFunction();
-    
-    const afterMemory = (performance as any).memory?.usedJSHeapSize || 0;
-    const afterTime = performance.now();
-
-    return {
-      bundleIncrease: afterMemory - beforeMemory,
-      memoryIncrease: midMemory - beforeMemory,
-      renderTimeImpact: (afterTime - midTime) - (midTime - beforeTime)
-    };
-  }
-};
+	// Test component rendering performance
+	async testComponent(
+		Component: any,
+		props: any = {},
+		expectedRenderTime = 16
+	): Promise<PerformanceTestResult> {
+		return performanceBenchmark.testComponentRender(
+			Component.displayName || Component.name || "Component",
+			() => {
+				// This would need React Testing Library in a real test environment
+				// For now, we'll simulate component rendering
+				return { type: Component, props } // Mock element
+			},
+			expectedRenderTime
+		)
+	},
+
+	// Test hook performance
+	async testHook(
+		hookFunction: () => any,
+		hookName: string,
+		expectedExecutionTime = 1
+	): Promise<PerformanceTestResult> {
+		const config: PerformanceTestConfig = {
+			name: `Hook Performance: ${hookName}`,
+			iterations: 1000,
+			warmupIterations: 100,
+			timeout: 5000,
+			expectedThreshold: {
+				renderTime: expectedExecutionTime,
+				memoryUsage: 1024 * 1024 // 1MB
+			}
+		}
+
+		return performanceBenchmark.runTest(config, hookFunction)
+	},
+
+	// Test async operation performance
+	async testAsyncOperation(
+		operation: () => Promise<any>,
+		operationName: string,
+		expectedTime = 1000
+	): Promise<PerformanceTestResult> {
+		const config: PerformanceTestConfig = {
+			name: `Async Operation: ${operationName}`,
+			iterations: 10,
+			warmupIterations: 2,
+			timeout: 30000,
+			expectedThreshold: {
+				renderTime: expectedTime,
+				memoryUsage: 2 * 1024 * 1024 // 2MB
+			}
+		}
+
+		return performanceBenchmark.runTest(config, operation)
+	},
+
+	// Test bundle size impact
+	async measureBundleImpact(
+		beforeFunction: () => void,
+		afterFunction: () => void,
+		featureName: string
+	): Promise<{
+		bundleIncrease: number
+		memoryIncrease: number
+		renderTimeImpact: number
+	}> {
+		const beforeMemory = (performance as any).memory?.usedJSHeapSize || 0
+		const beforeTime = performance.now()
+
+		beforeFunction()
+
+		const midMemory = (performance as any).memory?.usedJSHeapSize || 0
+		const midTime = performance.now()
+
+		afterFunction()
+
+		const afterMemory = (performance as any).memory?.usedJSHeapSize || 0
+		const afterTime = performance.now()
+
+		return {
+			bundleIncrease: afterMemory - beforeMemory,
+			memoryIncrease: midMemory - beforeMemory,
+			renderTimeImpact: afterTime - midTime - (midTime - beforeTime)
+		}
+	}
+}
 
 // Performance testing framework
 export class PerformanceTestFramework {
-  private benchmark = new PerformanceBenchmark();
-  private suites: Map<string, PerformanceTestConfig[]> = new Map();
-
-  // Register a test suite
-  registerSuite(suiteName: string, tests: PerformanceTestConfig[]) {
-    this.suites.set(suiteName, tests);
-  }
-
-  // Run all tests in a suite
-  async runSuite(
-    suiteName: string,
-    testImplementations: Map<string, () => any>
-  ): Promise<PerformanceTestResult[]> {
-    const tests = this.suites.get(suiteName);
-    if (!tests) {
-      throw new Error(`Test suite '${suiteName}' not found`);
-    }
-
-    const results: PerformanceTestResult[] = [];
-
-    for (const test of tests) {
-      const implementation = testImplementations.get(test.name);
-      if (!implementation) {
-        console.warn(`No implementation found for test '${test.name}'`);
-        continue;
-      }
-
-      const result = await this.benchmark.runTest(test, implementation);
-      results.push(result);
-    }
-
-    return results;
-  }
-
-  // Run all registered test suites
-  async runAllSuites(
-    implementations: Map<string, Map<string, () => any>>
-  ): Promise<Map<string, PerformanceTestResult[]>> {
-    const allResults = new Map<string, PerformanceTestResult[]>();
-
-    for (const [suiteName] of this.suites) {
-      const suiteImplementations = implementations.get(suiteName);
-      if (!suiteImplementations) {
-        console.warn(`No implementations found for suite '${suiteName}'`);
-        continue;
-      }
-
-      const results = await this.runSuite(suiteName, suiteImplementations);
-      allResults.set(suiteName, results);
-    }
-
-    return allResults;
-  }
-
-  // Generate comprehensive report
-  generateComprehensiveReport(): string {
-    const summary = this.benchmark.getSummary();
-    let report = this.benchmark.generateReport();
-
-    // Add suite breakdown if available
-    if (this.suites.size > 0) {
-      report += `\nTest Suites:\n`;
-      report += `============\n\n`;
-
-      for (const [suiteName, tests] of this.suites) {
-        report += `Suite: ${suiteName}\n`;
-        report += `Tests: ${tests.length}\n\n`;
-      }
-    }
-
-    return report;
-  }
+	private benchmark = new PerformanceBenchmark()
+	private suites: Map<string, PerformanceTestConfig[]> = new Map()
+
+	// Register a test suite
+	registerSuite(suiteName: string, tests: PerformanceTestConfig[]) {
+		this.suites.set(suiteName, tests)
+	}
+
+	// Run all tests in a suite
+	async runSuite(
+		suiteName: string,
+		testImplementations: Map<string, () => any>
+	): Promise<PerformanceTestResult[]> {
+		const tests = this.suites.get(suiteName)
+		if (!tests) {
+			throw new Error(`Test suite '${suiteName}' not found`)
+		}
+
+		const results: PerformanceTestResult[] = []
+
+		for (const test of tests) {
+			const implementation = testImplementations.get(test.name)
+			if (!implementation) {
+				console.warn(`No implementation found for test '${test.name}'`)
+				continue
+			}
+
+			const result = await this.benchmark.runTest(test, implementation)
+			results.push(result)
+		}
+
+		return results
+	}
+
+	// Run all registered test suites
+	async runAllSuites(
+		implementations: Map<string, Map<string, () => any>>
+	): Promise<Map<string, PerformanceTestResult[]>> {
+		const allResults = new Map<string, PerformanceTestResult[]>()
+
+		for (const [suiteName] of this.suites) {
+			const suiteImplementations = implementations.get(suiteName)
+			if (!suiteImplementations) {
+				console.warn(`No implementations found for suite '${suiteName}'`)
+				continue
+			}
+
+			const results = await this.runSuite(suiteName, suiteImplementations)
+			allResults.set(suiteName, results)
+		}
+
+		return allResults
+	}
+
+	// Generate comprehensive report
+	generateComprehensiveReport(): string {
+		const summary = this.benchmark.getSummary()
+		let report = this.benchmark.generateReport()
+
+		// Add suite breakdown if available
+		if (this.suites.size > 0) {
+			report += `\nTest Suites:\n`
+			report += `============\n\n`
+
+			for (const [suiteName, tests] of this.suites) {
+				report += `Suite: ${suiteName}\n`
+				report += `Tests: ${tests.length}\n\n`
+			}
+		}
+
+		return report
+	}
 }
 
-export const performanceTestFramework = new PerformanceTestFramework();
+export const performanceTestFramework = new PerformanceTestFramework()