jest-test-lineage-reporter 2.0.1 → 2.1.0

package/src/__tests__/assertion-test.test.ts

@@ -0,0 +1,59 @@
+import { directFunction } from '../depth-example';
+
+describe('Assertion Counting Test', () => {
+  test('should count multiple expect statements correctly', () => {
+    // This test has many expect statements to test assertion counting
+    
+    const result1 = directFunction(5);
+    expect(result1).toBe(10);
+    expect(result1).toBeGreaterThan(5);
+    expect(result1).toBeLessThan(20);
+    
+    const result2 = directFunction(0);
+    expect(result2).toBe(0);
+    expect(result2).toEqual(0);
+    expect(result2).not.toBe(1);
+    
+    const result3 = directFunction(-5);
+    expect(result3).toBe(-10);
+    expect(result3).toBeLessThan(0);
+    expect(result3).toBeGreaterThan(-20);
+    
+    // Test arrays and objects
+    const results = [result1, result2, result3];
+    expect(results).toHaveLength(3);
+    expect(results).toContain(10);
+    expect(results).toContain(0);
+    expect(results).toContain(-10);
+    
+    // Test properties
+    const obj = { value: result1 };
+    expect(obj).toHaveProperty('value');
+    expect(obj).toHaveProperty('value', 10);
+    
+    // Test null/undefined
+    expect(result1).toBeDefined();
+    expect(result1).not.toBeNull();
+    expect(result1).not.toBeUndefined();
+    
+    // Test truthiness
+    expect(result1).toBeTruthy();
+    expect(result2).toBeFalsy();
+    
+    // Test error handling
+    expect(() => {
+      if (result1 < 0) {
+        throw new Error('Should not be negative');
+      }
+    }).not.toThrow();
+    
+    // This test should show:
+    // - 22+ expect statements (high assertion count)
+    // - Error handling with expect().not.toThrow()
+    // - Property testing with toHaveProperty()
+    // - Array testing with toContain() and toHaveLength()
+    // - Boundary testing with toBeGreaterThan/toBeLessThan
+    // - Null/undefined testing
+    // - Truthiness testing
+  });
+});

package/src/__tests__/calculator.test.ts

@@ -0,0 +1,30 @@
+import { add, subtract, multiply } from '../calculator';
+
+describe('Calculator', () => {
+  it('should correctly add two numbers', () => {
+    expect(add(1, 2)).toBe(3);
+  });
+
+  it('should subtract a smaller number from a larger one', () => {
+    expect(subtract(5, 2)).toBe(3); // This will hit line 9
+  });
+
+  it('should subtract a larger number from a smaller one and return a positive result', () => {
+    expect(subtract(2, 5)).toBe(3); // This will hit line 7
+  });
+    
+  // This test covers the same line as the first subtraction test, which our report will show.
+  it('should handle zero correctly in subtraction', () => {
+    expect(subtract(10, 0)).toBe(10); // This will also hit line 9
+  });
+
+  // This test ONLY calls multiply, so it will show different coverage
+  it('should multiply two numbers correctly', () => {
+    expect(multiply(3, 4)).toBe(12); // This will ONLY hit line 13 (multiply function)
+  });
+
+  // This test ONLY calls add, so it will show different coverage
+  it('should add negative numbers', () => {
+    expect(add(-5, -3)).toBe(-8); // This will ONLY hit lines 2-3 (add function)
+  });
+});

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

@@ -0,0 +1,237 @@
+import {
+  directFunction,
+  oneLevel,
+  twoLevels,
+  threeLevels,
+  complexFunction,
+  recursiveFunction,
+  memoryLeakFunction,
+  clearMemoryLeaks,
+  getMemoryLeakCount
+} from '../depth-example';
+
+describe('Call Depth Tracking Examples', () => {
+  test('should call directFunction directly (depth 1)', () => {
+    const result = directFunction(5);
+    expect(result).toBe(10);
+  });
+
+  test('should call directFunction through oneLevel (depth 2)', () => {
+    const result = oneLevel(5);
+    expect(result).toBe(11);
+  });
+
+  test('should call directFunction through twoLevels (depth 3)', () => {
+    const result = twoLevels(5);
+    expect(result).toBe(12);
+  });
+
+  test('should call directFunction through threeLevels (depth 4)', () => {
+    const result = threeLevels(5);
+    expect(result).toBe(13);
+  });
+
+  test('should call directFunction at multiple depths in complexFunction', () => {
+    const result = complexFunction(5);
+    expect(result).toBe(33); // 10 + 11 + 12 = 33
+  });
+
+  test('should call directFunction through recursive calls (very deep)', () => {
+    const result = recursiveFunction(5);
+    expect(result).toBe(13); // 10 + 1 + 1 + 1 = 13
+  });
+
+  test('should demonstrate memory leak detection with large allocations', () => {
+    // This test intentionally creates memory leaks to demonstrate tracking
+    const largeArrays = [];
+
+    // Create multiple large arrays (each >1MB) to trigger memory leak detection
+    for (let i = 0; i < 3; i++) {
+      // Allocate ~2MB array (will trigger 🚨LEAK alert)
+      const largeArray = new Array(500000).fill(0).map((_, index) => ({
+        id: index,
+        data: `Large data string for item ${index} with extra padding to increase memory usage`,
+        timestamp: Date.now(),
+        metadata: {
+          created: new Date(),
+          processed: false,
+          tags: ['memory', 'test', 'large', 'allocation']
+        }
+      }));
+
+      largeArrays.push(largeArray);
+
+      // Call our function to track memory usage at different call depths
+      const result = directFunction(i);
+      expect(result).toBe(i * 2);
+    }
+
+    // Verify we created the expected number of arrays
+    expect(largeArrays).toHaveLength(3);
+    expect(largeArrays[0]).toHaveLength(500000);
+
+    // Test edge cases with memory allocation
+    expect(largeArrays[0][0]).toHaveProperty('id', 0);
+    expect(largeArrays[0][0]).toHaveProperty('data');
+    expect(largeArrays[0][0].metadata).toHaveProperty('tags');
+    expect(largeArrays[0][0].metadata.tags).toContain('memory');
+
+    // Test error conditions
+    expect(() => {
+      if (largeArrays.length === 0) {
+        throw new Error('No arrays created');
+      }
+    }).not.toThrow();
+
+    // Test boundary conditions
+    expect(largeArrays[2][499999]).toHaveProperty('id', 499999);
+
+    // This should show high memory usage, multiple assertions, and good error handling
+    // Expected quality metrics:
+    // - High assertion count (8+ expect statements)
+    // - Error handling (try/catch equivalent with expect().not.toThrow())
+    // - Edge case testing (boundary values, null checks)
+    // - Memory leak detection (large allocations)
+  });
+
+  test('should demonstrate GC pressure with many small allocations', () => {
+    const smallObjects = [];
+
+    // Create many small objects to trigger GC pressure detection
+    for (let i = 0; i < 1000; i++) {
+      // Small allocations (<1KB each) to trigger 🗑️GC alert
+      const smallObj = {
+        id: i,
+        value: Math.random(),
+        processed: false
+      };
+      smallObjects.push(smallObj);
+
+      // Call function at different depths to test performance impact
+      if (i % 100 === 0) {
+        const result = oneLevel(i);
+        expect(result).toBeGreaterThan(i);
+      }
+    }
+
+    expect(smallObjects).toHaveLength(1000);
+    expect(smallObjects[999]).toHaveProperty('id', 999);
+
+    // This should show GC pressure but smaller memory footprint
+  });
+
+  test('should demonstrate slow execution patterns', () => {
+    const results = [];
+
+    // Create intentionally variable performance to trigger slow execution detection
+    for (let i = 0; i < 5; i++) {
+      const startTime = Date.now();
+
+      // Sometimes do heavy work, sometimes light work (creates performance variance)
+      if (i % 2 === 0) {
+        // Heavy work - should be slower
+        let heavyResult = 0;
+        for (let j = 0; j < 10000; j++) {
+          heavyResult += Math.sin(j) * Math.cos(j);
+        }
+        results.push(heavyResult);
+      } else {
+        // Light work - should be faster
+        results.push(i * 2);
+      }
+
+      const result = directFunction(i);
+      expect(result).toBe(i * 2);
+
+      const endTime = Date.now();
+      expect(endTime).toBeGreaterThanOrEqual(startTime);
+    }
+
+    expect(results).toHaveLength(5);
+
+    // This should show performance variance and trigger 🐌SLOW alert
+  });
+
+  test('should create actual memory leaks with large objects', () => {
+    // Clear any existing leaks first
+    const initialCount = getMemoryLeakCount();
+    expect(initialCount).toBeGreaterThanOrEqual(0);
+
+    // Create multiple memory leaks with large objects
+    for (let i = 0; i < 3; i++) {
+      // Each call creates ~1MB of leaked memory (1000 items * 1KB each)
+      const result = memoryLeakFunction(1000);
+      expect(result).toBe(1000 * 2); // directFunction returns x * 2
+
+      // Verify memory leak count is increasing
+      const currentCount = getMemoryLeakCount();
+      expect(currentCount).toBe(initialCount + i + 1);
+    }
+
+    // Verify we have created 3 memory leaks
+    const finalCount = getMemoryLeakCount();
+    expect(finalCount).toBe(initialCount + 3);
+
+    // This test should show:
+    // - High memory usage (3MB+ leaked)
+    // - 🚨LEAK alerts in console
+    // - Multiple expect() statements (good assertion count)
+    // - Error handling with expect().toBe() validations
+  });
+
+  test('should create massive memory leak for testing', () => {
+    // Create a very large memory leak to ensure detection
+    const initialMemoryCount = getMemoryLeakCount();
+
+    // Create 5 large objects (each ~2MB)
+    for (let i = 0; i < 5; i++) {
+      const result = memoryLeakFunction(2000); // 2000 items * ~1KB each = ~2MB
+      expect(result).toBe(2000 * 2);
+
+      // Verify the leak is growing
+      expect(getMemoryLeakCount()).toBeGreaterThan(initialMemoryCount + i);
+    }
+
+    // Verify total memory leaks
+    const totalLeaks = getMemoryLeakCount();
+    expect(totalLeaks).toBeGreaterThanOrEqual(initialMemoryCount + 5);
+
+    // Test edge cases
+    expect(() => memoryLeakFunction(0)).not.toThrow();
+    expect(memoryLeakFunction(0)).toBe(0);
+
+    // Test error conditions
+    expect(() => {
+      if (totalLeaks < 0) {
+        throw new Error('Invalid leak count');
+      }
+    }).not.toThrow();
+
+    // This should create ~10MB of leaked memory and trigger multiple 🚨LEAK alerts
+    // Quality metrics should show:
+    // - High assertion count (8+ expect statements)
+    // - Good error handling (expect().not.toThrow())
+    // - Edge case testing (zero values, negative checks)
+    // - Boundary testing (memory thresholds)
+  });
+
+  test('should demonstrate memory cleanup', () => {
+    // Create some leaks first
+    const result1 = memoryLeakFunction(500);
+    const result2 = memoryLeakFunction(500);
+
+    expect(result1).toBe(1000);
+    expect(result2).toBe(1000);
+    expect(getMemoryLeakCount()).toBeGreaterThanOrEqual(2);
+
+    // Clear all memory leaks
+    const clearedCount = clearMemoryLeaks();
+    expect(clearedCount).toBeGreaterThanOrEqual(2);
+    expect(getMemoryLeakCount()).toBe(0);
+
+    // Verify cleanup worked
+    expect(getMemoryLeakCount()).toBe(0);
+
+    // This test shows proper cleanup and should have fewer memory issues
+  });
+});

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);
+  });
+});