jest-test-lineage-reporter 2.0.1 → 2.1.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
+    });
+  });
+});

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

@@ -0,0 +1,222 @@
+import {
+  simpleAdd,
+  complexLogic,
+  boundaryCheck,
+  logicalOperations,
+  mathOperations,
+  stringOperations,
+  incrementOperations,
+  subtleBugFunction,
+  reallyWeakFunction,
+  guaranteedSurvivedMutations
+} from '../weak-test-example';
+
+describe('Weak Test Examples - Some mutations will survive', () => {
+  
+  // GOOD TEST - should kill mutations
+  describe('simpleAdd', () => {
+    it('should add two positive numbers', () => {
+      expect(simpleAdd(2, 3)).toBe(5);
+    });
+    
+    it('should add negative numbers', () => {
+      expect(simpleAdd(-2, -3)).toBe(-5);
+    });
+  });
+
+  // WEAK TEST - missing edge cases, mutations may survive
+  describe('complexLogic', () => {
+    it('should handle basic case', () => {
+      expect(complexLogic(5, 3)).toBe(8);  // Only tests the x + y path
+    });
+
+    it('should handle large numbers but with weak assertion', () => {
+      const result = complexLogic(15, 5);
+      expect(typeof result).toBe('number');  // Very weak! Doesn't check actual value
+      // This covers x > 10 path but doesn't verify x * 2 logic
+      // Mutations like * to / will survive!
+    });
+
+    it('should handle negative numbers but with weak assertion', () => {
+      const result = complexLogic(-5, 10);
+      expect(result).toBeGreaterThanOrEqual(0);  // Weak! Doesn't check exact value
+      // This covers x < 0 path but doesn't verify return 0 logic
+      // Mutations like return 0 to return 1 will survive!
+    });
+  });
+
+  // WEAK TEST - doesn't test boundary conditions properly
+  describe('boundaryCheck', () => {
+    it('should return medium for normal values', () => {
+      expect(boundaryCheck(50)).toBe("medium");
+    });
+
+    it('should handle high values but with weak assertion', () => {
+      const result = boundaryCheck(150);
+      expect(typeof result).toBe('string');  // Weak! Doesn't check actual value
+      // This covers >= 100 path but doesn't verify "high" result
+      // Mutations like >= to > will survive!
+    });
+
+    it('should handle low values but with weak assertion', () => {
+      const result = boundaryCheck(-10);
+      expect(result.length).toBeGreaterThan(0);  // Weak! Doesn't check actual value
+      // This covers <= 0 path but doesn't verify "low" result
+      // Mutations like <= to < will survive!
+    });
+  });
+
+  // WEAK TEST - doesn't test all logical combinations
+  describe('logicalOperations', () => {
+    it('should handle true and true', () => {
+      expect(logicalOperations(true, true)).toBe(true);
+    });
+
+    it('should handle other combinations but with weak assertions', () => {
+      const result1 = logicalOperations(true, false);
+      const result2 = logicalOperations(false, true);
+      const result3 = logicalOperations(false, false);
+
+      // Very weak assertions - just check they return booleans!
+      expect(typeof result1).toBe('boolean');
+      expect(typeof result2).toBe('boolean');
+      expect(typeof result3).toBe('boolean');
+
+      // This covers all logical paths but doesn't verify correct logic
+      // Mutations like && to ||, || to &&, !a to a will survive!
+    });
+  });
+
+  // WEAK TEST - doesn't verify the actual math
+  describe('mathOperations', () => {
+    it('should return a number', () => {
+      const result = mathOperations(10);
+      expect(typeof result).toBe('number');  // Very weak assertion!
+    });
+
+    it('should not throw errors', () => {
+      // This test covers the lines but doesn't validate the math at all!
+      expect(() => {
+        mathOperations(5);
+        mathOperations(0);
+        mathOperations(-3);
+      }).not.toThrow();
+
+      // This covers all the math operation lines but mutations will survive
+      // because we're not checking the actual results!
+    });
+  });
+
+  // WEAK TEST - incomplete string testing
+  describe('stringOperations', () => {
+    it('should handle non-empty strings', () => {
+      const result = stringOperations("hello");
+      expect(typeof result).toBe('string');  // Weak assertion
+    });
+    
+    // Missing tests for empty string, boundary lengths
+    // String comparison mutations will survive
+  });
+
+  // WEAK TEST - doesn't verify increment behavior
+  describe('incrementOperations', () => {
+    it('should return a number', () => {
+      const result = incrementOperations(5);
+      expect(result).toBeGreaterThan(0);  // Very weak assertion
+    });
+
+    it('should handle edge cases but with wrong expectations', () => {
+      // This test covers the lines but has completely wrong logic!
+      const result1 = incrementOperations(10);
+      const result2 = incrementOperations(15);
+
+      // These assertions are so generic that mutations will survive
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(typeof result1).toBe('number');
+      expect(typeof result2).toBe('number');
+
+      // This covers the increment/decrement logic but doesn't validate it!
+    });
+  });
+
+  // TERRIBLE TEST - covers lines but doesn't validate behavior at all
+  describe('subtleBugFunction', () => {
+    it('should execute without errors', () => {
+      // This test covers all branches but validates NOTHING!
+      let result1, result2, result3;
+
+      expect(() => {
+        result1 = subtleBugFunction(0, 5);    // Covers x === 0 branch
+        result2 = subtleBugFunction(3, 2);    // Covers x > 0 branch
+        result3 = subtleBugFunction(-1, 4);   // Covers x < 0 branch
+      }).not.toThrow();
+
+      // These assertions are completely useless!
+      expect(result1).toBeDefined();
+      expect(result2).toBeDefined();
+      expect(result3).toBeDefined();
+
+      // ALL mutations will survive because we don't check actual values!
+      // return 1 -> return 0: SURVIVES (we don't check result1 === 1)
+      // x + y -> x - y: SURVIVES (we don't check result2 === 5)
+      // x - y -> x + y: SURVIVES (we don't check result3 === -5)
+    });
+  });
+
+  // ABSOLUTELY TERRIBLE TEST - will definitely have survived mutations
+  describe('reallyWeakFunction', () => {
+    it('should just run without throwing errors', () => {
+      // This test only checks that the function doesn't crash!
+      // It covers all lines but validates NOTHING about the logic
+
+      let result1, result2, result3;
+
+      // Execute the function to cover the lines
+      expect(() => {
+        result1 = reallyWeakFunction(5, 10);   // Covers a * b, result > 100 (false), return result - 5
+        result2 = reallyWeakFunction(15, 8);   // Covers a * b, result > 100 (true), return result + 10
+        result3 = reallyWeakFunction(2, 3);    // Covers a * b, result > 100 (false), return result - 5
+      }).not.toThrow();
+
+      // These assertions are completely useless for catching mutations!
+      expect(result1).toBeDefined();  // Doesn't check if result1 === 45
+      expect(result2).toBeDefined();  // Doesn't check if result2 === 130
+      expect(result3).toBeDefined();  // Doesn't check if result3 === 1
+
+      // MUTATIONS THAT WILL SURVIVE:
+      // a * b -> a + b: SURVIVES (we don't check actual calculation)
+      // a * b -> a - b: SURVIVES (we don't check actual calculation)
+      // a * b -> a / b: SURVIVES (we don't check actual calculation)
+      // result > 100 -> result < 100: SURVIVES (we don't check branching logic)
+      // result > 100 -> result >= 100: SURVIVES (we don't check branching logic)
+      // result + 10 -> result - 10: SURVIVES (we don't check return values)
+      // result - 5 -> result + 5: SURVIVES (we don't check return values)
+    });
+  });
+
+  // ABSOLUTELY USELESS TEST - will definitely have survived mutations
+  describe('guaranteedSurvivedMutations', () => {
+    it('should exist as a function', () => {
+      // This test is so useless it only checks the function exists!
+      expect(typeof guaranteedSurvivedMutations).toBe('function');
+
+      // We call the function but don't check ANY return values
+      guaranteedSurvivedMutations(5);    // Covers x === 5 branch, return 42
+      guaranteedSurvivedMutations(15);   // Covers x > 10 branch, return x * 2
+      guaranteedSurvivedMutations(3);    // Covers default branch, return x + 1
+
+      // NO ASSERTIONS ON RETURN VALUES!
+      // This means ALL mutations will survive:
+      // x === 5 -> x !== 5: SURVIVES (we don't check the condition)
+      // x === 5 -> x > 5: SURVIVES (we don't check the condition)
+      // return 42 -> return 0: SURVIVES (we don't check return value)
+      // return 42 -> return 1: SURVIVES (we don't check return value)
+      // x > 10 -> x < 10: SURVIVES (we don't check the condition)
+      // x * 2 -> x + 2: SURVIVES (we don't check return value)
+      // x * 2 -> x - 2: SURVIVES (we don't check return value)
+      // x + 1 -> x - 1: SURVIVES (we don't check return value)
+      // x + 1 -> x * 1: SURVIVES (we don't check return value)
+    });
+  });
+});