jest-test-lineage-reporter 2.0.2 → 2.1.1

package/src/__tests__/gc-pressure-example.test.ts

@@ -0,0 +1,169 @@
+import {
+  badGCPressureFunction,
+  goodGCPressureFunction,
+  badStringConcatenation,
+  goodStringConcatenation,
+  badArrayOperations,
+  goodArrayOperations,
+  objectPoolExample
+} from '../gc-pressure-example';
+
+describe.skip('GC Pressure Examples', () => {
+  test.skip('should demonstrate BAD GC pressure with many small objects', () => {
+    // This test creates many small objects and should trigger 🗑️GC alerts
+    
+    const result1 = badGCPressureFunction(1000); // Creates 2000+ small objects
+    expect(result1).toBeGreaterThan(0);
+    expect(typeof result1).toBe('number');
+    
+    const result2 = badGCPressureFunction(500);  // Creates 1000+ small objects
+    expect(result2).toBeGreaterThan(0);
+    expect(result2).toBeLessThan(result1);
+    
+    // Test edge cases
+    expect(badGCPressureFunction(0)).toBe(0);
+    expect(badGCPressureFunction(1)).toBeGreaterThan(0);
+    
+    // This should show:
+    // - 🗑️GC alerts due to many small object allocations
+    // - High memory churn but relatively small total memory
+    // - Multiple expect statements for good test quality
+  });
+
+  test('should demonstrate GOOD GC behavior with object reuse', () => {
+    // This test reuses objects and should have minimal GC pressure
+    
+    const result1 = goodGCPressureFunction(1000); // Reuses same objects
+    expect(result1).toBeGreaterThan(0);
+    expect(typeof result1).toBe('number');
+    
+    const result2 = goodGCPressureFunction(500);
+    expect(result2).toBeGreaterThan(0);
+    expect(result2).toBeLessThan(result1);
+    
+    // Test edge cases
+    expect(goodGCPressureFunction(0)).toBe(0);
+    expect(goodGCPressureFunction(1)).toBeGreaterThan(0);
+    
+    // This should show:
+    // - Minimal or no 🗑️GC alerts
+    // - Lower memory usage than the bad example
+    // - Better performance consistency
+  });
+
+  test('should demonstrate BAD string concatenation GC pressure', () => {
+    // String concatenation in loops creates many temporary strings
+    
+    const items = Array.from({ length: 1000 }, (_, i) => `item${i}`);
+    
+    const result = badStringConcatenation(items);
+    expect(result).toContain('item0');
+    expect(result).toContain('item999');
+    expect(result.split(', ')).toHaveLength(1001); // 1000 items + empty string at end
+    
+    // Test with smaller arrays
+    const smallItems = ['a', 'b', 'c'];
+    const smallResult = badStringConcatenation(smallItems);
+    expect(smallResult).toBe('a, b, c, ');
+    
+    // This should trigger 🗑️GC due to many temporary string objects
+  });
+
+  test('should demonstrate GOOD string concatenation', () => {
+    // Array.join() creates only one final string
+    
+    const items = Array.from({ length: 1000 }, (_, i) => `item${i}`);
+    
+    const result = goodStringConcatenation(items);
+    expect(result).toContain('item0');
+    expect(result).toContain('item999');
+    expect(result.split(', ')).toHaveLength(1000);
+    
+    // Test with smaller arrays
+    const smallItems = ['a', 'b', 'c'];
+    const smallResult = goodStringConcatenation(smallItems);
+    expect(smallResult).toBe('a, b, c');
+    
+    // This should have minimal GC pressure
+  });
+
+  test('should demonstrate BAD array operations with multiple allocations', () => {
+    // Chained array operations create many intermediate arrays
+    
+    const numbers = Array.from({ length: 1000 }, (_, i) => i);
+    
+    const result = badArrayOperations(numbers);
+    expect(Array.isArray(result)).toBe(true);
+    expect(result.length).toBeGreaterThan(0);
+    expect(result.every(x => x % 2 === 0)).toBe(true);
+    expect(result.every(x => x > 10)).toBe(true);
+    
+    // Test edge cases
+    expect(badArrayOperations([])).toEqual([]);
+    expect(badArrayOperations([1, 2, 3])).toEqual([]);
+    expect(badArrayOperations([10, 20, 30])).toEqual([22, 42, 62]);
+    
+    // This should trigger 🗑️GC due to multiple intermediate arrays
+  });
+
+  test('should demonstrate GOOD array operations with single allocation', () => {
+    // Single reduce operation creates only one final array
+    
+    const numbers = Array.from({ length: 1000 }, (_, i) => i);
+    
+    const result = goodArrayOperations(numbers);
+    expect(Array.isArray(result)).toBe(true);
+    expect(result.length).toBeGreaterThan(0);
+    expect(result.every(x => x % 2 === 0)).toBe(true);
+    expect(result.every(x => x > 10)).toBe(true);
+    
+    // Test edge cases
+    expect(goodArrayOperations([])).toEqual([]);
+    expect(goodArrayOperations([1, 2, 3])).toEqual([]);
+    expect(goodArrayOperations([10, 20, 30])).toEqual([22, 42, 62]);
+    
+    // This should have minimal GC pressure
+  });
+
+  test('should demonstrate object pooling for optimal GC behavior', () => {
+    // Object pooling reuses pre-allocated objects
+    
+    const result1 = objectPoolExample(1000);
+    expect(result1).toBeGreaterThan(0);
+    expect(typeof result1).toBe('number');
+    
+    const result2 = objectPoolExample(500);
+    expect(result2).toBeGreaterThan(0);
+    expect(result2).toBeLessThan(result1);
+    
+    // Test edge cases
+    expect(objectPoolExample(0)).toBe(0);
+    expect(objectPoolExample(1)).toBeGreaterThan(0);
+    
+    // This should have the best GC behavior - minimal allocations
+  });
+
+  test('should compare all GC pressure patterns', () => {
+    // Compare all patterns to show the difference
+    
+    const testSize = 100;
+    
+    const badResult = badGCPressureFunction(testSize);
+    const goodResult = goodGCPressureFunction(testSize);
+    const poolResult = objectPoolExample(testSize);
+    
+    // All should produce similar numerical results
+    expect(badResult).toBeGreaterThan(0);
+    expect(goodResult).toBeGreaterThan(0);
+    expect(poolResult).toBeGreaterThan(0);
+    
+    // But GC behavior should be very different:
+    // - badResult: High 🗑️GC pressure
+    // - goodResult: Medium 🗑️GC pressure  
+    // - poolResult: Minimal 🗑️GC pressure
+    
+    expect(typeof badResult).toBe('number');
+    expect(typeof goodResult).toBe('number');
+    expect(typeof poolResult).toBe('number');
+  });
+});

package/src/__tests__/performance-example.test.ts

@@ -0,0 +1,83 @@
+import { 
+  lightweightFunction,
+  mediumFunction,
+  heavyFunction,
+  memoryIntensiveFunction,
+  recursiveFunction,
+  nestedCallsFunction,
+  mixedPerformanceFunction,
+  performanceVariableFunction
+} from '../performance-example';
+
+describe.skip('Performance Tracking Examples', () => {
+  test('should track lightweight function performance', () => {
+    // This should show minimal CPU cycles
+    const result = lightweightFunction(5);
+    expect(result).toBe(6);
+  });
+
+  test('should track medium function performance', () => {
+    // This should show moderate CPU cycles
+    const result = mediumFunction(4);
+    expect(result).toBeGreaterThan(0);
+  });
+
+  test('should track heavy function performance', () => {
+    // This should show high CPU cycles
+    const result = heavyFunction(2);
+    expect(result).toBeGreaterThan(0);
+  });
+
+  test('should track memory intensive function', () => {
+    // This should show memory allocation patterns
+    const result = memoryIntensiveFunction(1000);
+    expect(result).toHaveLength(1000);
+  });
+
+  test('should track recursive function with exponential complexity', () => {
+    // This should show very high CPU cycles due to recursion
+    const result = recursiveFunction(5);
+    expect(result).toBeGreaterThan(0);
+  });
+
+  test('should track nested calls with different depths', () => {
+    // This should show performance at different call depths
+    const result = nestedCallsFunction(10);
+    expect(result).toBeGreaterThan(0);
+  });
+
+  test('should track mixed performance patterns', () => {
+    // This should show variable performance within one test
+    const result = mixedPerformanceFunction(10);
+    expect(result).toBeGreaterThan(0);
+  });
+
+  test('should track fast mode performance', () => {
+    // Fast execution path
+    const result = performanceVariableFunction('fast');
+    expect(result).toBe(43);
+  });
+
+  test('should track medium mode performance', () => {
+    // Medium execution path
+    const result = performanceVariableFunction('medium');
+    expect(result).toBeGreaterThan(0);
+  });
+
+  test('should track slow mode performance', () => {
+    // Slow execution path
+    const result = performanceVariableFunction('slow');
+    expect(result).toBeGreaterThan(0);
+  });
+
+  test('should demonstrate performance hotspot', () => {
+    // Call heavy function multiple times to create hotspot
+    let total = 0;
+    let i = 0;
+    while (i < 3) {
+      total += heavyFunction(i);
+      i++;
+    }
+    expect(total).toBeGreaterThan(0);
+  });
+});

package/src/__tests__/quality-example.test.ts

@@ -0,0 +1,122 @@
+import { 
+  simpleFunction,
+  complexFunction,
+  asyncFunction,
+  errorProneFunction,
+  wellTestedFunction,
+  Calculator
+} from '../quality-example';
+
+describe('Test Quality Examples', () => {
+  // High quality test - good assertions, error handling, edge cases
+  test('wellTestedFunction should handle all edge cases properly', async () => {
+    // Test normal cases
+    expect(wellTestedFunction(5, 3)).toBe(8);
+    expect(wellTestedFunction(0, 0)).toBe(0);
+    expect(wellTestedFunction(1.5, 2.5)).toBe(4);
+    
+    // Test error cases
+    expect(() => wellTestedFunction(null as any, 5)).toThrow('Parameter a is required');
+    expect(() => wellTestedFunction(5, undefined as any)).toThrow('Parameter b is required');
+    expect(() => wellTestedFunction('5' as any, 3)).toThrow('Both parameters must be numbers');
+    expect(() => wellTestedFunction(-1, 5)).toThrow('Parameters must be non-negative');
+    expect(() => wellTestedFunction(5, -1)).toThrow('Parameters must be non-negative');
+    
+    // Test boundary cases
+    expect(wellTestedFunction(Number.MAX_SAFE_INTEGER, 0)).toBe(Number.MAX_SAFE_INTEGER);
+    expect(wellTestedFunction(0.1, 0.2)).toBeCloseTo(0.3);
+  });
+
+  // Medium quality test - some assertions, basic testing
+  test('complexFunction should handle different data types', () => {
+    expect(complexFunction('hello')).toBe('HELLO');
+    expect(complexFunction(5)).toBe(25);
+    expect(complexFunction(-3)).toBe(3);
+    expect(complexFunction(0)).toBe(1);
+    expect(complexFunction([1, 2, 3])).toEqual([2, 4, 6]);
+    expect(complexFunction({ key: 'value' })).toBe('{"key":"value"}');
+    
+    // Test error cases
+    expect(() => complexFunction(null)).toThrow('Data is required');
+    expect(() => complexFunction(undefined)).toThrow('Data is required');
+  });
+
+  // Low quality test - minimal assertions, no error handling
+  test('simpleFunction basic test', () => {
+    expect(simpleFunction(5)).toBe(10);
+  });
+
+  // Async test with proper error handling
+  test('asyncFunction should handle async operations correctly', async () => {
+    const result = await asyncFunction(10);
+    expect(result).toBe('Completed after 10ms');
+    
+    // Test error case
+    await expect(asyncFunction(-1)).rejects.toThrow('Delay cannot be negative');
+  });
+
+  // Poor quality test - no error handling for error-prone function
+  test('errorProneFunction test', () => {
+    expect(errorProneFunction('hello')).toBe('HELLO');
+    expect(errorProneFunction(123)).toBe('123');
+    // Missing: null/undefined tests that would reveal bugs
+  });
+
+  // Test with mocking (affects isolation score)
+  test('Calculator with mocking', () => {
+    const calculator = new Calculator();
+    const spy = jest.spyOn(calculator, 'add');
+    
+    calculator.add(2, 3);
+    expect(spy).toHaveBeenCalledWith(2, 3);
+    expect(calculator.getHistory()).toEqual([5]);
+    
+    spy.mockRestore();
+  });
+
+  // Long test (test smell)
+  test('long test with many assertions', () => {
+    const calc = new Calculator();
+    
+    // Too many assertions in one test
+    expect(calc.add(1, 1)).toBe(2);
+    expect(calc.add(2, 2)).toBe(4);
+    expect(calc.add(3, 3)).toBe(6);
+    expect(calc.add(4, 4)).toBe(8);
+    expect(calc.add(5, 5)).toBe(10);
+    expect(calc.add(6, 6)).toBe(12);
+    expect(calc.add(7, 7)).toBe(14);
+    expect(calc.add(8, 8)).toBe(16);
+    expect(calc.add(9, 9)).toBe(18);
+    expect(calc.add(10, 10)).toBe(20);
+    expect(calc.add(11, 11)).toBe(22);
+    expect(calc.add(12, 12)).toBe(24);
+    
+    expect(calc.getHistory()).toHaveLength(12);
+    calc.clearHistory();
+    expect(calc.getHistory()).toHaveLength(0);
+  });
+
+  // Test with complex control flow (high complexity)
+  test('complex control flow test', () => {
+    let result = 0;
+    
+    for (let i = 0; i < 10; i++) {
+      if (i % 2 === 0) {
+        if (i % 4 === 0) {
+          result += complexFunction(i);
+        } else {
+          result += simpleFunction(i);
+        }
+      } else {
+        if (i > 5) {
+          result -= i;
+        } else {
+          result += i;
+        }
+      }
+    }
+    
+    expect(result).toBeGreaterThan(0);
+  });
+});

package/src/__tests__/survived-mutations-example.test.ts

@@ -0,0 +1,32 @@
+import { demonstrateSurvivedMutations, anotherWeakFunction } from '../survived-mutations-example';
+
+describe('Survived Mutations Example', () => {
+  // This test is intentionally terrible to demonstrate survived mutations
+  
+  describe('demonstrateSurvivedMutations', () => {
+    it('should just call the function', () => {
+      // This test literally does NOTHING except call the function
+      // No assertions whatsoever!
+
+      demonstrateSurvivedMutations(42);   // Covers input === 42, return 100
+      demonstrateSurvivedMutations(60);   // Covers input > 50, return input * 2
+      demonstrateSurvivedMutations(5);    // Covers default case, return input + 10
+
+      // NO EXPECTATIONS AT ALL!
+      // This means ALL mutations will survive because we don't check anything
+    });
+  });
+
+  describe('anotherWeakFunction', () => {
+    it('should execute the function', () => {
+      // This test calls the function but makes NO assertions!
+
+      anotherWeakFunction(10, 5);   // Covers x > y, return true
+      anotherWeakFunction(3, 8);    // Covers x <= y, return false
+
+      // NO EXPECTATIONS AT ALL!
+      // return true -> return false: SURVIVES
+      // return false -> return true: SURVIVES
+    });
+  });
+});

package/src/__tests__/truly-weak-example.test.ts

@@ -0,0 +1,90 @@
+import { definitelyWillSurvive, anotherSurvivor, booleanSurvivor, guaranteedSurvivor } from '../truly-weak-example';
+
+describe('Truly Weak Example - Guaranteed Survived Mutations', () => {
+  
+  describe('definitelyWillSurvive', () => {
+    it('should just execute', () => {
+      // This test literally does NOTHING except call the function
+      // It covers all branches but validates NOTHING
+      
+      definitelyWillSurvive(5);    // Covers x === 5, return 42
+      definitelyWillSurvive(15);   // Covers x > 10, return x + 100
+      definitelyWillSurvive(3);    // Covers default case, return x * 2
+      
+      // NO ASSERTIONS WHATSOEVER!
+      // ALL mutations will survive:
+      // return 42 -> return 0: SURVIVES
+      // return 42 -> return 1: SURVIVES
+      // x + 100 -> x - 100: SURVIVES
+      // x + 100 -> x * 100: SURVIVES
+      // x * 2 -> x + 2: SURVIVES
+      // x * 2 -> x - 2: SURVIVES
+    });
+  });
+
+  describe('anotherSurvivor', () => {
+    it('should execute without any validation', () => {
+      // This test covers all lines but checks NOTHING
+      
+      anotherSurvivor(30, 25);  // Covers sum > 50, return sum - 10
+      anotherSurvivor(10, 5);   // Covers sum <= 50, return sum / 2
+      
+      // NO EXPECTATIONS!
+      // Mutations that will survive:
+      // a + b -> a - b: SURVIVES
+      // a + b -> a * b: SURVIVES
+      // sum > 50 -> sum < 50: SURVIVES
+      // sum - 10 -> sum + 10: SURVIVES
+      // sum / 2 -> sum * 2: SURVIVES
+    });
+  });
+
+  describe('booleanSurvivor', () => {
+    it('should call the function', () => {
+      // This test calls the function but ignores the result completely
+
+      booleanSurvivor(5);   // Covers x > 0, return true
+      booleanSurvivor(-3);  // Covers x <= 0, return false
+
+      // NO VALIDATION OF BOOLEAN RESULTS!
+      // Mutations that will survive:
+      // x > 0 -> x < 0: SURVIVES
+      // x > 0 -> x >= 0: SURVIVES
+      // return true -> return false: SURVIVES
+      // return false -> return true: SURVIVES
+    });
+  });
+
+  describe('guaranteedSurvivor', () => {
+    it('should execute without any validation whatsoever', () => {
+      // This test is designed to be completely useless
+      // It catches ALL exceptions and validates NOTHING
+
+      try {
+        guaranteedSurvivor(10);   // Should return 100, but we don't check
+        guaranteedSurvivor(20);   // Should return 200, but we don't check
+        guaranteedSurvivor(5);    // Should return 10, but we don't check
+        guaranteedSurvivor(-1);   // Should return 4, but we don't check
+      } catch (e) {
+        // Even if mutations cause errors, we ignore them!
+        // This ensures mutations that change behavior but don't crash will survive
+      }
+
+      // NO ASSERTIONS AT ALL!
+      // ALL mutations will survive because:
+      // 1. We don't check return values
+      // 2. We catch all exceptions
+      // 3. We have no expectations
+      //
+      // Expected survived mutations:
+      // input === 10 -> input !== 10: SURVIVES
+      // input === 10 -> input > 10: SURVIVES
+      // result = 100 -> result = 0: SURVIVES
+      // result = 100 -> result = 1: SURVIVES
+      // input === 20 -> input !== 20: SURVIVES
+      // result = 200 -> result = 0: SURVIVES
+      // input + 5 -> input - 5: SURVIVES
+      // input + 5 -> input * 5: SURVIVES
+    });
+  });
+});