jest-test-lineage-reporter 2.0.1 → 2.1.0

package/src/performance-example.ts

@@ -0,0 +1,82 @@
+// Example file to demonstrate CPU cycle and performance tracking
+
+export function lightweightFunction(x: number): number {
+  return x + 1; // Very fast operation - minimal CPU cycles
+}
+
+export function mediumFunction(x: number): number {
+  let result = x;
+  let i = 0;
+  while (i < 100) { // Medium CPU usage
+    result = Math.sqrt(result + i);
+    i++;
+  }
+  return result;
+}
+
+export function heavyFunction(x: number): number {
+  let result = x;
+  let i = 0;
+  while (i < 1000) { // Heavy CPU usage - many cycles (reduced for testing)
+    result = Math.sin(Math.cos(Math.sqrt(result + i)));
+    i++;
+  }
+  return result;
+}
+
+export function memoryIntensiveFunction(size: number): number[] {
+  const array = new Array(size); // Memory allocation
+  let i = 0;
+  while (i < size) {
+    array[i] = Math.random() * i; // Memory writes
+    i++;
+  }
+  return array;
+}
+
+export function recursiveFunction(n: number): number {
+  if (n <= 1) {
+    return lightweightFunction(n); // Light operation at leaf
+  }
+  if (n > 5) return n; // Prevent exponential explosion
+  return recursiveFunction(n - 1) + recursiveFunction(n - 2); // Limited recursion
+}
+
+export function nestedCallsFunction(x: number): number {
+  const light = lightweightFunction(x);     // Depth 2
+  const medium = mediumFunction(light);     // Depth 2  
+  const heavy = heavyFunction(medium);      // Depth 2
+  return heavy;
+}
+
+export function mixedPerformanceFunction(iterations: number): number {
+  let result = 0;
+  let i = 0;
+
+  while (i < iterations) {
+    if (i % 3 === 0) {
+      result += lightweightFunction(i);     // Fast path
+    } else if (i % 3 === 1) {
+      result += mediumFunction(i);          // Medium path
+    } else {
+      result += heavyFunction(i);           // Slow path
+    }
+    i++;
+  }
+
+  return result;
+}
+
+// Function that demonstrates different performance characteristics
+export function performanceVariableFunction(mode: 'fast' | 'medium' | 'slow'): number {
+  switch (mode) {
+    case 'fast':
+      return lightweightFunction(42);
+    case 'medium':
+      return mediumFunction(42);
+    case 'slow':
+      return heavyFunction(42);
+    default:
+      return 0;
+  }
+}

package/src/quality-example.ts

@@ -0,0 +1,79 @@
+// Example file to demonstrate test quality metrics
+
+export function simpleFunction(x: number): number {
+  return x * 2;
+}
+
+export function complexFunction(data: any): any {
+  if (data === null || data === undefined) {
+    throw new Error('Data is required');
+  }
+  
+  if (typeof data === 'string') {
+    return data.toUpperCase();
+  } else if (typeof data === 'number') {
+    if (data < 0) {
+      return Math.abs(data);
+    } else if (data === 0) {
+      return 1;
+    } else {
+      return data * data;
+    }
+  } else if (Array.isArray(data)) {
+    return data.map(item => item * 2);
+  } else {
+    return JSON.stringify(data);
+  }
+}
+
+export async function asyncFunction(delay: number): Promise<string> {
+  return new Promise((resolve, reject) => {
+    if (delay < 0) {
+      reject(new Error('Delay cannot be negative'));
+    } else {
+      setTimeout(() => {
+        resolve(`Completed after ${delay}ms`);
+      }, delay);
+    }
+  });
+}
+
+export function errorProneFunction(input: any): string {
+  // This function has potential issues
+  return input.toString().toUpperCase();
+}
+
+export function wellTestedFunction(a: number, b: number): number {
+  if (a === null || a === undefined) {
+    throw new Error('Parameter a is required');
+  }
+  if (b === null || b === undefined) {
+    throw new Error('Parameter b is required');
+  }
+  if (typeof a !== 'number' || typeof b !== 'number') {
+    throw new Error('Both parameters must be numbers');
+  }
+  if (a < 0 || b < 0) {
+    throw new Error('Parameters must be non-negative');
+  }
+  
+  return a + b;
+}
+
+export class Calculator {
+  private history: number[] = [];
+  
+  add(a: number, b: number): number {
+    const result = a + b;
+    this.history.push(result);
+    return result;
+  }
+  
+  getHistory(): number[] {
+    return [...this.history];
+  }
+  
+  clearHistory(): void {
+    this.history = [];
+  }
+}

package/src/survived-mutations-example.ts

@@ -0,0 +1,19 @@
+// This file contains functions with absolutely terrible tests that guarantee survived mutations
+
+export function demonstrateSurvivedMutations(input: number): number {
+  if (input === 42) {
+    return 100;
+  } else if (input > 50) {
+    return input * 2;
+  } else {
+    return input + 10;
+  }
+}
+
+export function anotherWeakFunction(x: number, y: number): boolean {
+  if (x > y) {
+    return true;
+  } else {
+    return false;
+  }
+}

package/src/truly-weak-example.ts

@@ -0,0 +1,37 @@
+// This file contains functions with absolutely terrible tests that guarantee survived mutations
+
+export function definitelyWillSurvive(x: number): number {
+  if (!(!(x === 5))) {
+    return 42;
+  } else if (x > 10) {
+    return x + 100;
+  } else {
+    return x * 2;
+  }
+}
+export function anotherSurvivor(a: number, b: number): number {
+  const sum = a + b;
+  if (sum > 50) {
+    return sum - 10;
+  } else {
+    return sum / 2;
+  }
+}
+export function booleanSurvivor(x: number): boolean {
+  if (x > 0) {
+    return true;
+  } else {
+    return false;
+  }
+}
+export function guaranteedSurvivor(input: number): number {
+  if (input === 10) {
+    const result = 100;
+    return result;
+  } else if (input === 20) {
+    const result = 200;
+    return result;
+  } else {
+    return input + 5;
+  }
+}

package/src/weak-test-example.ts

@@ -0,0 +1,91 @@
+// This file contains functions with weak tests that will allow mutations to survive
+
+export function simpleAdd(a: number, b: number): number {
+  return a + b;
+}
+
+export function complexLogic(x: number, y: number): number {
+  if (x > 10) {
+    return x * 2;
+  } else if (x < 0) {
+    return 0;
+  } else {
+    return x + y;
+  }
+}
+
+export function boundaryCheck(value: number): string {
+  if (value >= 100) {
+    return "high";
+  } else if (value <= 0) {
+    return "low";
+  } else {
+    return "medium";
+  }
+}
+
+export function logicalOperations(a: boolean, b: boolean): boolean {
+  if (a && b) {
+    return true;
+  } else if (a || b) {
+    return !a;
+  } else {
+    return false;
+  }
+}
+
+export function mathOperations(x: number): number {
+  const squared = x * x;
+  const doubled = x * 2;
+  const halved = x / 2;
+  return squared + doubled - halved;
+}
+
+export function stringOperations(str: string): string {
+  if (str.length > 5) {
+    return str.toUpperCase();
+  } else if (str.length === 0) {
+    return "empty";
+  } else {
+    return str.toLowerCase();
+  }
+}
+
+export function incrementOperations(x: number): number {
+  if (x > 10) {
+    return ++x;
+  } else if (x > 15) {
+    return --x;
+  } else {
+    return x;
+  }
+}
+
+export function subtleBugFunction(x: number, y: number): number {
+  if (x === 0) {
+    return 1;
+  } else if (x > 0) {
+    return x + y;
+  } else {
+    return x - y;
+  }
+}
+
+export function reallyWeakFunction(a: number, b: number): number {
+  const result = a * b;
+  if (result > 100) {
+    return result + 10;
+  } else {
+    return result - 5;
+  }
+}
+
+export function guaranteedSurvivedMutations(x: number): number {
+  if (x === 5) {
+    return 42;
+  } else if (x > 10) {
+    return x * 2;
+  } else {
+    return x + 1;
+  }
+}