How to use coveringTests method in stryker-parent

Best JavaScript code snippet using stryker-parent

incremental-differ.ts

Source:incremental-differ.ts

1import path from 'path';2import { diff_match_patch as DiffMatchPatch } from 'diff-match-patch';3import chalk from 'chalk';4import { schema, Mutant, Position, Location, MutantStatus, StrykerOptions, FileDescriptions, MutateDescription } from '@stryker-mutator/api/core';5import { Logger } from '@stryker-mutator/api/logging';6import { TestResult, TestStatus } from '@stryker-mutator/api/test-runner';7import { I, normalizeFileName, normalizeLineEndings, notEmpty } from '@stryker-mutator/util';8import { TestDefinition } from 'mutation-testing-report-schema';9import { commonTokens } from '@stryker-mutator/api/plugin';10import { DiffChange, DiffStatisticsCollector } from './diff-statistics-collector.js';11import { TestCoverage } from './test-coverage.js';12/**13 * The 'diff match patch' high-performant 'diffing' of files.14 * @see https://github.com/google/diff-match-patch15 */16const diffMatchPatch = new DiffMatchPatch();17/**18 * This class is responsible for calculating the diff between a run and a previous run based on the incremental report.19 *20 * Since the ids of tests and mutants can differ across reports (they are only unique within 1 report), this class21 * identifies mutants and tests by attributes that make them unique:22 * - Mutant: file name, mutator name, location and replacement23 * - Test: test name, test file name (if present) and location (if present).24 *25 * We're storing these identifiers in local variables (maps and sets) as strings.26 * We should move to 'records' for these when they come available: https://github.com/tc39/proposal-record-tuple27 *28 * A mutant result from the previous run is reused if the following conditions were met:29 * - The location of the mutant refers to a piece of code that didn't change30 * - If mutant was killed:31 *   - The culprit test wasn't changed32 * - If the mutant survived:33 *   - No test was added34 *35 * It uses google's "diff-match-patch" project to calculate the new locations for tests and mutants, see link.36 * @link https://github.com/google/diff-match-patch37 */38export class IncrementalDiffer {39  public mutantStatisticsCollector: DiffStatisticsCollector | undefined;40  public testStatisticsCollector: DiffStatisticsCollector | undefined;41  private readonly mutateDescriptionByRelativeFileName: Map<string, MutateDescription>;42  public static inject = [commonTokens.logger, commonTokens.options, commonTokens.fileDescriptions] as const;43  constructor(private readonly logger: Logger, private readonly options: StrykerOptions, fileDescriptions: FileDescriptions) {44    this.mutateDescriptionByRelativeFileName = new Map(45      Object.entries(fileDescriptions).map(([name, description]) => [toRelativeNormalizedFileName(name), description.mutate])46    );47  }48  private isInMutatedScope(relativeFileName: string, mutant: schema.MutantResult): boolean {49    const mutate = this.mutateDescriptionByRelativeFileName.get(relativeFileName);50    return mutate === true || (Array.isArray(mutate) && mutate.some((range) => locationIncluded(range, mutant.location)));51  }52  public diff(53    currentMutants: readonly Mutant[],54    testCoverage: I<TestCoverage>,55    incrementalReport: schema.MutationTestResult,56    currentRelativeFiles: Map<string, string>57  ): readonly Mutant[] {58    const { files, testFiles } = incrementalReport;59    const mutantStatisticsCollector = new DiffStatisticsCollector();60    const testStatisticsCollector = new DiffStatisticsCollector();61    // Expose the collectors for unit testing purposes62    this.mutantStatisticsCollector = mutantStatisticsCollector;63    this.testStatisticsCollector = testStatisticsCollector;64    // Collect what we can reuse, while correcting for diff in the locations65    const reusableMutantsByKey = collectReusableMutantsByKey(this.logger);66    const { byId: oldTestsById, byKey: oldTestInfoByKey } = collectReusableTestInfo(this.logger);67    // Collect some helper maps and sets68    const { oldCoverageByMutantKey: oldCoverageTestKeysByMutantKey, oldKilledByMutantKey: oldKilledTestKeysByMutantKey } =69      collectOldKilledAndCoverageMatrix();70    const oldTestKeys = new Set([...oldTestsById.values()].map(({ key }) => key));71    const newTestKeys = new Set(72      [...testCoverage.testsById].map(([, test]) => testToIdentifyingKey(test, toRelativeNormalizedFileName(test.fileName)))73    );74    // Create a dictionary to more easily get test information75    const testInfoByKey = collectCurrentTestInfo();76    // Mark which tests are added77    for (const [key, { relativeFileName }] of testInfoByKey) {78      if (!oldTestKeys.has(key)) {79        testStatisticsCollector.count(relativeFileName, 'added');80      }81    }82    // Make sure that tests that didn't run this time around aren't forgotten83    for (const [84      testKey,85      {86        test: { name, location },87        relativeFileName,88      },89    ] of oldTestInfoByKey) {90      if (!testInfoByKey.has(testKey)) {91        const test: TestResult = {92          status: TestStatus.Success,93          id: testKey,94          name,95          startPosition: location?.start,96          timeSpentMs: 0,97          fileName: path.resolve(relativeFileName),98        };99        testInfoByKey.set(testKey, { test, relativeFileName: relativeFileName });100        testCoverage.addTest(test);101      }102    }103    // Done with preparations, time to map over the mutants104    let reusedMutantCount = 0;105    const currentMutantKeys = new Set<string>();106    const mutants = currentMutants.map((mutant) => {107      const relativeFileName = toRelativeNormalizedFileName(mutant.fileName);108      const mutantKey = mutantToIdentifyingKey(mutant, relativeFileName);109      currentMutantKeys.add(mutantKey);110      if (!mutant.status && !this.options.force) {111        const oldMutant = reusableMutantsByKey.get(mutantKey);112        if (oldMutant) {113          const coveringTests = testCoverage.forMutant(mutant.id);114          const killedByTestKeys = oldKilledTestKeysByMutantKey.get(mutantKey);115          if (mutantCanBeReused(mutant, oldMutant, mutantKey, coveringTests, killedByTestKeys)) {116            reusedMutantCount++;117            const { status, statusReason, testsCompleted } = oldMutant;118            return {119              ...mutant,120              status,121              statusReason,122              testsCompleted,123              coveredBy: [...(coveringTests ?? [])].map(({ id }) => id),124              killedBy: testKeysToId(killedByTestKeys),125            };126          }127        } else {128          mutantStatisticsCollector.count(relativeFileName, 'added');129        }130      }131      return mutant;132    });133    // Make sure that old mutants that didn't run this time around aren't forgotten134    for (const [mutantKey, oldResult] of reusableMutantsByKey) {135      // Do an additional check to see if the mutant is in mutated range.136      //137      // For example:138      // ```diff139      // - return a || b;140      // + return a && b;141      // ```142      // The conditional expression mutator here decides to _not_ mutate b to `false` the second time around. (even though the text of "b" itself didn't change)143      // Not doing this additional check would result in a sticky mutant that is never removed144      if (!currentMutantKeys.has(mutantKey) && !this.isInMutatedScope(oldResult.relativeFileName, oldResult)) {145        const coverage = oldCoverageTestKeysByMutantKey.get(mutantKey) ?? [];146        const killed = oldKilledTestKeysByMutantKey.get(mutantKey) ?? [];147        const coveredBy = testKeysToId(coverage);148        const killedBy = testKeysToId(killed);149        const reusedMutant = {150          ...oldResult,151          id: mutantKey,152          fileName: path.resolve(oldResult.relativeFileName),153          replacement: oldResult.replacement ?? oldResult.mutatorName,154          coveredBy,155          killedBy,156        };157        mutants.push(reusedMutant);158        testCoverage.addCoverage(reusedMutant.id, coveredBy);159      }160    }161    if (this.logger.isInfoEnabled()) {162      const testInfo = testCoverage.hasCoverage ? `\n\tTests:\t\t${testStatisticsCollector.createTotalsReport()}` : '';163      this.logger.info(164        `Incremental report:\n\tMutants:\t${mutantStatisticsCollector.createTotalsReport()}` +165          testInfo +166          `\n\tResult:\t\t${chalk.yellowBright(reusedMutantCount)} of ${currentMutants.length} mutant result(s) are reused.`167      );168    }169    if (this.logger.isDebugEnabled()) {170      const lineSeparator = '\n\t\t';171      const noChanges = 'No changes';172      const detailedMutantSummary = `${lineSeparator}${mutantStatisticsCollector.createDetailedReport().join(lineSeparator) || noChanges}`;173      const detailedTestsSummary = `${lineSeparator}${testStatisticsCollector.createDetailedReport().join(lineSeparator) || noChanges}`;174      this.logger.debug(`Detailed incremental report:\n\tMutants: ${detailedMutantSummary}\n\tTests: ${detailedTestsSummary}`);175    }176    return mutants;177    function testKeysToId(testKeys: Iterable<string> | undefined) {178      return [...(testKeys ?? [])]179        .map((id) => testInfoByKey.get(id))180        .filter(notEmpty)181        .map(({ test: { id } }) => id);182    }183    function collectReusableMutantsByKey(log: Logger) {184      return new Map(185        Object.entries(files).flatMap(([fileName, oldFile]) => {186          const relativeFileName = toRelativeNormalizedFileName(fileName);187          const currentFileSource = currentRelativeFiles.get(relativeFileName);188          if (currentFileSource) {189            log.trace('Diffing %s', relativeFileName);190            const { results, removeCount } = performFileDiff(oldFile.source, currentFileSource, oldFile.mutants);191            mutantStatisticsCollector.count(relativeFileName, 'removed', removeCount);192            return results.map((m) => [193              mutantToIdentifyingKey(m, relativeFileName),194              {195                ...m,196                relativeFileName,197              },198            ]);199          }200          mutantStatisticsCollector.count(relativeFileName, 'removed', oldFile.mutants.length);201          // File has since been deleted, these mutants are not reused202          return [];203        })204      );205    }206    function collectReusableTestInfo(log: Logger) {207      const byId = new Map<string, { relativeFileName: string; test: TestDefinition; key: string }>();208      const byKey = new Map<string, TestInfo>();209      Object.entries(testFiles ?? {}).forEach(([fileName, oldTestFile]) => {210        const relativeFileName = toRelativeNormalizedFileName(fileName);211        const currentFileSource = currentRelativeFiles.get(relativeFileName);212        if (currentFileSource !== undefined && oldTestFile.source !== undefined) {213          log.trace('Diffing %s', relativeFileName);214          const locatedTests = closeLocations(oldTestFile);215          const { results, removeCount } = performFileDiff(oldTestFile.source, currentFileSource, locatedTests);216          testStatisticsCollector.count(relativeFileName, 'removed', removeCount);217          results.forEach((test) => {218            const key = testToIdentifyingKey(test, relativeFileName);219            const testInfo = { key, test, relativeFileName };220            byId.set(test.id, testInfo);221            byKey.set(key, testInfo);222          });223        } else {224          // No sources to compare, we should do our best with the info we do have225          oldTestFile.tests.map((test) => {226            const key = testToIdentifyingKey(test, relativeFileName);227            const testInfo = { key, test, relativeFileName };228            byId.set(test.id, testInfo);229            byKey.set(key, testInfo);230          });231        }232      });233      return { byId, byKey };234    }235    function collectOldKilledAndCoverageMatrix() {236      const oldCoverageByMutantKey = new Map<string, Set<string>>();237      const oldKilledByMutantKey = new Map<string, Set<string>>();238      for (const [key, mutant] of reusableMutantsByKey) {239        const killedRow = new Set(mutant.killedBy?.map((testId) => oldTestsById.get(testId)?.key).filter(notEmpty));240        const coverageRow = new Set(mutant.coveredBy?.map((testId) => oldTestsById.get(testId)?.key).filter(notEmpty));241        killedRow.forEach((killed) => coverageRow.add(killed));242        oldCoverageByMutantKey.set(key, coverageRow);243        oldKilledByMutantKey.set(key, killedRow);244      }245      return { oldCoverageByMutantKey, oldKilledByMutantKey };246    }247    function collectCurrentTestInfo() {248      const byTestKey = new Map<string, { relativeFileName: string; test: TestResult }>();249      for (const testResult of testCoverage.testsById.values()) {250        const relativeFileName = toRelativeNormalizedFileName(testResult.fileName);251        const key = testToIdentifyingKey(testResult, relativeFileName);252        const info = { relativeFileName, test: testResult, key: key };253        byTestKey.set(key, info);254      }255      return byTestKey;256    }257    function mutantCanBeReused(258      mutant: Mutant,259      oldMutant: schema.MutantResult,260      mutantKey: string,261      coveringTests: ReadonlySet<TestResult> | undefined,262      oldKillingTests: Set<string> | undefined263    ): boolean {264      if (!testCoverage.hasCoverage) {265        // This is the best we can do when the test runner didn't report coverage.266        // We assume that all mutant test results can be reused,267        // End users can use --force to force retesting of certain mutants268        return true;269      }270      if (oldMutant.status === MutantStatus.Ignored) {271        // Was previously ignored, but not anymore, we need to run it now272        return false;273      }274      const testsDiff = diffTestCoverage(mutant.id, oldCoverageTestKeysByMutantKey.get(mutantKey), coveringTests);275      if (oldMutant.status === MutantStatus.Killed) {276        if (oldKillingTests) {277          for (const killingTest of oldKillingTests) {278            if (testsDiff.get(killingTest) === 'same') {279              return true;280            }281          }282        }283        // Killing tests has changed or no longer exists284        return false;285      }286      for (const action of testsDiff.values()) {287        if (action === 'added') {288          // A non-killed mutant got a new test, we need to run it289          return false;290        }291      }292      // A non-killed mutant did not get new tests, no need to rerun it293      return true;294    }295    /**296     * Determines if there is a diff between old test coverage and new test coverage.297     */298    function diffTestCoverage(299      mutantId: string,300      oldCoveringTestKeys: Set<string> | undefined,301      newCoveringTests: ReadonlySet<TestResult> | undefined302    ): Map<string, DiffAction> {303      const result = new Map<string, DiffAction>();304      if (newCoveringTests) {305        for (const newTest of newCoveringTests) {306          const key = testToIdentifyingKey(newTest, toRelativeNormalizedFileName(newTest.fileName));307          result.set(key, oldCoveringTestKeys?.has(key) ? 'same' : 'added');308        }309      }310      if (oldCoveringTestKeys) {311        const isStatic = testCoverage.hasStaticCoverage(mutantId);312        for (const oldTestKey of oldCoveringTestKeys) {313          if (!result.has(oldTestKey)) {314            // Static mutants might not have covering tests, but the test might still exist315            if (isStatic && newTestKeys.has(oldTestKey)) {316              result.set(oldTestKey, 'same');317            } else {318              result.set(oldTestKey, 'removed');319            }320          }321        }322      }323      return result;324    }325  }326}327/**328 * Finds the diff of mutants and tests. Removes mutants / tests that no longer exist (changed or removed). Updates locations of mutants or tests that do still exist.329 * @param oldCode The old code to use for the diff330 * @param newCode The new (current) code to use for the diff331 * @param items The mutants or tests to be looked . These will be treated as immutable.332 * @returns A list of items with updated locations, without items that are changed.333 */334function performFileDiff<T extends { location: Location }>(oldCode: string, newCode: string, items: T[]): { results: T[]; removeCount: number } {335  const oldSourceNormalized = normalizeLineEndings(oldCode);336  const currentSrcNormalized = normalizeLineEndings(newCode);337  const diffChanges = diffMatchPatch.diff_main(oldSourceNormalized, currentSrcNormalized);338  const toDo = new Set(items.map((m) => ({ ...m, location: deepClone(m.location) })));339  const [added, removed] = [1, -1];340  const done: T[] = [];341  const currentPosition: Position = { column: 0, line: 0 };342  let removeCount = 0;343  for (const [change, text] of diffChanges) {344    if (toDo.size === 0) {345      // There are more changes, but nothing left to update.346      break;347    }348    const offset = calculateOffset(text);349    if (change === added) {350      for (const test of toDo) {351        const { location } = test;352        if (gte(currentPosition, location.start) && gte(location.end, currentPosition)) {353          // This item cannot be reused, code was added here354          removeCount++;355          toDo.delete(test);356        } else {357          locationAdd(location, offset, currentPosition.line === location.start.line);358        }359      }360      positionMove(currentPosition, offset);361    } else if (change === removed) {362      for (const item of toDo) {363        const {364          location: { start },365        } = item;366        const endOffset = positionMove({ ...currentPosition }, offset);367        if (gte(endOffset, start)) {368          // This item cannot be reused, the code it covers has changed369          removeCount++;370          toDo.delete(item);371        } else {372          locationAdd(item.location, negate(offset), currentPosition.line === start.line);373        }374      }375    } else {376      positionMove(currentPosition, offset);377      toDo.forEach((item) => {378        const { end } = item.location;379        if (gte(currentPosition, end)) {380          // We're done with this item, it can be reused381          toDo.delete(item);382          done.push(item);383        }384      });385    }386  }387  done.push(...toDo);388  return { results: done, removeCount };389}390/**391 * A greater-than-equals implementation for positions392 */393function gte(a: Position, b: Position) {394  return a.line > b.line || (a.line === b.line && a.column >= b.column);395}396function locationIncluded(haystack: Location, needle: Location) {397  const startIncluded = gte(needle.start, haystack.start);398  const endIncluded = gte(haystack.end, needle.end);399  return startIncluded && endIncluded;400}401function deepClone(loc: Location): Location {402  return { start: { ...loc.start }, end: { ...loc.end } };403}404/**405 * Reduces a mutant to a string that identifies the mutant across reports.406 * Consists of the relative file name, mutator name, replacement, and location407 */408function mutantToIdentifyingKey(409  { mutatorName, replacement, location: { start, end } }: Pick<Mutant, 'location' | 'mutatorName'> & { replacement?: string },410  relativeFileName: string411) {412  return `${relativeFileName}@${start.line}:${start.column}-${end.line}:${end.column}\n${mutatorName}: ${replacement}`;413}414function testToIdentifyingKey(415  { name, location, startPosition }: Pick<schema.TestDefinition, 'location' | 'name'> & Pick<TestResult, 'startPosition'>,416  relativeFileName: string | undefined417) {418  startPosition = startPosition ?? location?.start ?? { line: 0, column: 0 };419  return `${relativeFileName}@${startPosition.line}:${startPosition.column}\n${name}`;420}421export function toRelativeNormalizedFileName(fileName: string | undefined): string {422  return normalizeFileName(path.relative(process.cwd(), fileName ?? ''));423}424function calculateOffset(text: string): Position {425  const pos: Position = { line: 0, column: 0 };426  for (const char of text) {427    if (char === '\n') {428      pos.line++;429      pos.column = 0;430    } else {431      pos.column++;432    }433  }434  return pos;435}436function positionMove(pos: Position, diff: Position): Position {437  pos.line += diff.line;438  if (diff.line === 0) {439    pos.column += diff.column;440  } else {441    pos.column = diff.column;442  }443  return pos;444}445function locationAdd({ start, end }: Location, { line, column }: Position, currentLine: boolean) {446  start.line += line;447  if (currentLine) {448    start.column += column;449  }450  end.line += line;451  if (line === 0 && currentLine) {452    end.column += column;453  }454}455function negate({ line, column }: Position): Position {456  return { line: -1 * line, column: -1 * column };457}458interface TestInfo {459  relativeFileName: string;460  test: TestDefinition;461  key: string;462}463type DiffAction = DiffChange | 'same';464/**465 * Sets the end position of each test to the start position of the next test.466 * This is an educated guess and necessary.467 * If a test has no location, it is assumed it spans the entire file (line 0 to Infinity)468 *469 * Knowing the end location of tests is necessary in order to know if the test was changed.470 */471function closeLocations(testFile: schema.TestFile): LocatedTest[] {472  const locatedTests: LocatedTest[] = [];473  const openEndedTests: OpenEndedTest[] = [];474  testFile.tests.forEach((test) => {475    if (testHasLocation(test)) {476      if (isClosed(test)) {477        locatedTests.push(test);478      } else {479        openEndedTests.push(test);480      }481    } else {482      locatedTests.push({ ...test, location: { start: { line: 0, column: 0 }, end: { line: Number.POSITIVE_INFINITY, column: 0 } } });483    }484  });485  if (openEndedTests.length) {486    // Sort the opened tests in order to close their locations487    openEndedTests.sort((a, b) => a.location.start.line - b.location.start.line);488    const startPositions = uniqueStartPositions(openEndedTests);489    let currentPositionIndex = 0;490    let currentPosition = startPositions[currentPositionIndex];491    openEndedTests.forEach((test) => {492      if (currentPosition && test.location.start.line === currentPosition.line && test.location.start.column === currentPosition.column) {493        currentPositionIndex++;494        currentPosition = startPositions[currentPositionIndex];495      }496      if (currentPosition) {497        locatedTests.push({ ...test, location: { start: test.location.start, end: currentPosition } });498      }499    });500    // Don't forget about the last test501    const lastTest = openEndedTests[openEndedTests.length - 1];502    locatedTests.push({ ...lastTest, location: { start: lastTest.location.start, end: { line: Number.POSITIVE_INFINITY, column: 0 } } });503  }504  return locatedTests;505}506/**507 * Determines the unique start positions of a sorted list of tests in order508 */509function uniqueStartPositions(sortedTests: OpenEndedTest[]) {510  let current: Position | undefined;511  const startPositions = sortedTests.reduce<Position[]>((collector, { location: { start } }) => {512    if (!current || current.line !== start.line || current.column !== start.column) {513      current = start;514      collector.push(current);515    }516    return collector;517  }, []);518  return startPositions;519}520function testHasLocation(test: schema.TestDefinition): test is OpenEndedTest {521  return !!test.location?.start;522}523function isClosed(test: Required<schema.TestDefinition>): test is LocatedTest {524  return !!test.location.end;525}526type LocatedTest = schema.TestDefinition & { location: Location };...

TestGenerator.ts

Source:TestGenerator.ts

1/*2 * Copyright (C) 2020 Whisker contributors3 *4 * This file is part of the Whisker test generator for Scratch.5 *6 * Whisker is free software: you can redistribute it and/or modify7 * it under the terms of the GNU General Public License as published by8 * the Free Software Foundation, either version 3 of the License, or9 * (at your option) any later version.10 *11 * Whisker is distributed in the hope that it will be useful, but12 * WITHOUT ANY WARRANTY; without even the implied warranty of13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU14 * General Public License for more details.15 *16 * You should have received a copy of the GNU General Public License17 * along with Whisker. If not, see http://www.gnu.org/licenses/.18 *19 */20import {WhiskerTest} from './WhiskerTest';21import {ScratchProject} from '../scratch/ScratchProject';22import {WhiskerSearchConfiguration} from "../utils/WhiskerSearchConfiguration";23import {StatisticsCollector} from "../utils/StatisticsCollector";24import {FitnessFunction} from "../search/FitnessFunction";25import {SearchAlgorithmBuilder} from "../search/SearchAlgorithmBuilder";26import {SearchAlgorithm} from "../search/SearchAlgorithm";27import {TestChromosome} from "../testcase/TestChromosome";28import {WhiskerTestListWithSummary} from "./WhiskerTestListWithSummary";29import Arrays from "../utils/Arrays";30import {TestMinimizer} from "./TestMinimizer";31import {Randomness} from "../utils/Randomness";32import {Container} from "../utils/Container";33export abstract class TestGenerator {34    /**35     * Search parameters set by the config file.36     */37    protected _config: WhiskerSearchConfiguration;38    /**39     * Maps each FitnessFunction to a unique identifier40     */41    protected _fitnessFunctions: Map<number, FitnessFunction<TestChromosome>>;42    constructor(configuration: WhiskerSearchConfiguration) {43        this._config = configuration;44    }45    public abstract generateTests(project: ScratchProject): Promise<WhiskerTestListWithSummary>;46    protected buildSearchAlgorithm(initializeFitnessFunction: boolean): SearchAlgorithm<any> {47        const builder = new SearchAlgorithmBuilder(this._config.getAlgorithm())48            .addSelectionOperator(this._config.getSelectionOperator())49            .addLocalSearchOperators(this._config.getLocalSearchOperators())50            .addProperties(this._config.searchAlgorithmProperties);51        if (initializeFitnessFunction) {52            builder.initializeFitnessFunction(this._config.getFitnessFunctionType(),53                this._config.searchAlgorithmProperties['chromosomeLength'], // FIXME: unsafe access54                this._config.getFitnessFunctionTargets());55            this._fitnessFunctions = builder.fitnessFunctions;56        }57        builder.addChromosomeGenerator(this._config.getChromosomeGenerator());58        return builder.buildSearchAlgorithm();59    }60    protected extractCoverageGoals(): Map<number, FitnessFunction<any>> {61        return new SearchAlgorithmBuilder(this._config.getAlgorithm())62            .initializeFitnessFunction(this._config.getFitnessFunctionType(),63                this._config.searchAlgorithmProperties['chromosomeLength'], // FIXME: unsafe access64                this._config.getFitnessFunctionTargets()).fitnessFunctions;65    }66    protected collectStatistics(testSuite: WhiskerTest[]): void {67        const statistics = StatisticsCollector.getInstance();68        StatisticsCollector.getInstance().bestCoverage =69            statistics.coveredFitnessFunctionsCount / statistics.fitnessFunctionCount;70        statistics.bestTestSuiteSize = testSuite.length;71        for (const test of testSuite) {72            statistics.testEventCount += test.getEventsCount();73        }74    }75    protected async getTestSuite(tests: TestChromosome[]): Promise<WhiskerTest[]> {76        if (this._config.isMinimizationActive()) {77            return await this.getMinimizedTestSuite(tests);78        } else {79            return this.getCoveringTestSuite(tests);80        }81    }82    protected async getMinimizedTestSuite(tests: TestChromosome[]): Promise<WhiskerTest[]> {83        const minimizedSuite: WhiskerTest[] = [];84        const coveredObjectives = new Set<number>();85        Container.debugLog("Pre-minimization: "+tests.length+" tests");86        const sortedFitnessFunctions = new Map<number, FitnessFunction<TestChromosome>>([...this._fitnessFunctions].sort((a, b) =>87            b[1].getCDGDepth() - a[1].getCDGDepth()88        ));89        for (const [objective, fitnessFunction] of sortedFitnessFunctions.entries()) {90            if (coveredObjectives.has(objective)) {91                continue;92            }93            const coveringTests: TestChromosome[] = [];94            for (const test of tests) {95                if (fitnessFunction.isCovered(test)) {96                    coveringTests.push(test);97                }98            }99            if (coveringTests.length > 0) {100                const minimizer = new TestMinimizer(fitnessFunction, Container.config.searchAlgorithmProperties['reservedCodons']);101                const test = await minimizer.minimize(Randomness.getInstance().pick(coveringTests));102                minimizedSuite.push(new WhiskerTest(test));103                this.updateCoveredObjectives(coveredObjectives, test);104            }105        }106        Container.debugLog("Post-minimization: "+minimizedSuite.length+" tests");107        return minimizedSuite;108    }109    protected getCoveringTestSuite(tests: TestChromosome[]): WhiskerTest[] {110        const testSuite: WhiskerTest[] = [];111        const coveringTestsPerObjective = this.getCoveringTestsPerObjective(tests);112        const coveredObjectives = new Set<number>();113        // For each uncovered objective with a single covering test: Add the test114        for (const objective of coveringTestsPerObjective.keys()) {115            if (!coveredObjectives.has(objective) && coveringTestsPerObjective.get(objective).length === 1) {116                const [test] = coveringTestsPerObjective.get(objective);117                testSuite.push(new WhiskerTest(test));118                this.updateCoveredObjectives(coveredObjectives, test);119            }120        }121        // For each yet uncovered objective: Add the shortest test122        for (const objective of coveringTestsPerObjective.keys()) {123            if (!coveredObjectives.has(objective)) {124                let shortestTest = undefined;125                for (const test of coveringTestsPerObjective.get(objective)) {126                    if (shortestTest == undefined || shortestTest.getLength() > test.getLength()) {127                        shortestTest = test;128                    }129                }130                testSuite.push(new WhiskerTest(shortestTest));131                this.updateCoveredObjectives(coveredObjectives, shortestTest);132            }133        }134        return testSuite;135    }136    private getCoveringTestsPerObjective(tests: TestChromosome[]): Map<number, TestChromosome[]> {137        const coveringTestsPerObjective = new Map<number, TestChromosome[]>();138        for (const objective of this._fitnessFunctions.keys()) {139            const fitnessFunction = this._fitnessFunctions.get(objective);140            const coveringTests: TestChromosome[] = [];141            for (const test of tests) {142                if (fitnessFunction.isCovered(test)) {143                    coveringTests.push(test);144                }145            }146            if (coveringTests.length > 0) {147                coveringTestsPerObjective.set(objective, coveringTests);148            }149        }150        return coveringTestsPerObjective;151    }152    private updateCoveredObjectives(coveredObjectives: Set<number>, test: TestChromosome): void {153        for (const objective of this._fitnessFunctions.keys()) {154            if (this._fitnessFunctions.get(objective).isCovered(test)) {155                coveredObjectives.add(objective);156            }157        }158    }159    /**160     * Summarizes all uncovered statements with the following information:161     *   - ApproachLevel162     *   - BranchDistance163     *   - Fitness164     * @returns string in JSON format165     */166    public summarizeSolution(archive: Map<number, TestChromosome>): string {167        const summary = [];168        const bestIndividuals = Arrays.distinct(archive.values());169        for (const fitnessFunctionKey of this._fitnessFunctions.keys()) {170            const curSummary = {};171            if (!archive.has(fitnessFunctionKey)) {172                const fitnessFunction = this._fitnessFunctions.get(fitnessFunctionKey);173                curSummary['block'] = fitnessFunction.toString();174                let fitness = Number.MAX_VALUE;175                let approachLevel = Number.MAX_VALUE;176                let branchDistance = Number.MAX_VALUE;177                let CFGDistance = Number.MAX_VALUE;178                for (const chromosome of bestIndividuals) {179                    const curFitness = chromosome.getFitness(fitnessFunction);180                    if (curFitness < fitness) {181                        fitness = curFitness;182                        approachLevel = fitnessFunction.getApproachLevel(chromosome);183                        branchDistance = fitnessFunction.getBranchDistance(chromosome);184                        if (branchDistance === 0) {185                            CFGDistance = fitnessFunction.getCFGDistance(chromosome, approachLevel > 0);186                        }187                        else {188                            CFGDistance = Number.MAX_VALUE;189                            //this means that it was unnecessary to calculate cfg distance, since190                            //branch distance was not 0;191                        }192                    }193                }194                curSummary['ApproachLevel'] = approachLevel;195                curSummary['BranchDistance'] = branchDistance;196                curSummary['CFGDistance'] = CFGDistance;197                curSummary['Fitness'] = fitness;198                if (Object.keys(curSummary).length > 0) {199                    summary.push(curSummary);200                }201            }202        }203        return JSON.stringify({'uncoveredBlocks': summary}, undefined, 4);204    }...

Using AI Code Generation

1const { Stryker } = require('stryker-parent');2const { CoverageInstrumenter } = require('stryker-javascript-mutator');3const { TestRunner } = require('stryker-jest-runner');4const { Reporter } = require('stryker-html-reporter');5const { Mutator } = require('stryker-javascript-mutator');6const { ConfigReader } = require('stryker-api/config');7const { Config } = require('stryker-api/config');8const { Logger } = require('stryker-api/logging');9const config = new Config();10config.set({11});12const configReader = new ConfigReader(config);13const log = new Logger('stryker');14const testRunner = new TestRunner(configReader, null, log);15const mutator = new Mutator(configReader, log);16const reporter = new Reporter(configReader, log);17const instrumenter = new CoverageInstrumenter(mutator, configReader, log);18const stryker = new Stryker(configReader, instrumenter, testRunner, reporter, log);19stryker.coveringTests(['src/**/*.js']).then(console.log);20{21  "scripts": {22  },23  "dependencies": {24  }25}26function add(a, b) {27  return a + b;28}29function add2(a, b) {30  return a + b;31}

Using AI Code Generation

1const { Stryker } = require('stryker-parent');2const stryker = new Stryker();3stryker.config.set({4});5stryker.runMutationTest().then(() => {6  const coveringTests = stryker.coveringTests;7  console.log(coveringTests);8});

Using AI Code Generation

1var coveringTests = require('stryker-parent').coveringTests;2var testRunner = require('stryker-jasmine-runner').testRunner;3var childProcess = require('child_process');4var path = require('path');5var fs = require('fs');6var files = [];7var testFiles = [];8var testFramework = 'jasmine';9var config = {10};11coveringTests(config).then(function (result) {12    var file = path.resolve(__dirname, 'result.json');13    fs.writeFileSync(file, JSON.stringify(result, null, 2));14    console.log('Wrote result to ' + file);15    process.exit(0);16}, function (error) {17    console.error('Error while running tests', error);18    process.exit(1);19});

Using AI Code Generation

1var stryker = require('stryker-parent');2var files = ['test.js', 'test2.js'];3var result = stryker.coveringTests(files);4console.log(result);5var stryker = require('stryker-parent');6var files = ['test.js', 'test2.js'];7var result = stryker.coveringTests(files);8console.log(result);9var stryker = require('stryker-parent');10var files = ['test.js', 'test2.js'];11var result = stryker.coveringTests(files);12console.log(result);13var stryker = require('stryker-parent');14var files = ['test.js', 'test2.js'];15var result = stryker.coveringTests(files);16console.log(result);17var stryker = require('stryker-parent');18var files = ['test.js', 'test2.js'];19var result = stryker.coveringTests(files);20console.log(result);21var stryker = require('stryker-parent');22var files = ['test.js', 'test2.js'];23var result = stryker.coveringTests(files);24console.log(result);

Using AI Code Generation

1var stryker = require('stryker-parent');2var testRunner = require('stryker-jasmine-runner');3var config = require('./stryker.conf.js');4var options = config();5var files = options.files;6var testFramework = options.testFramework;7var testFiles = options.testFiles;8var mutate = options.mutate;9var log = options.log;10var port = options.port;11var timeoutFactor = options.timeoutFactor;12var timeoutMs = options.timeoutMs;13var timeoutValue = options.timeoutValue;14var reporters = options.reporters;15var plugins = options.plugins;16var strykerOptions = options.strykerOptions;17var strykerConfig = options.strykerConfig;18var testFrameworkOptions = options.testFrameworkOptions;19var coverageAnalysis = options.coverageAnalysis;20var karmaConfig = options.karmaConfig;21var karmaConfigFile = options.karmaConfigFile;22var karmaConfigOverrides = options.karmaConfigOverrides;23var karmaConfigOverridden = options.karmaConfigOverridden;24var karmaConfigOverriddenFile = options.karmaConfigOverriddenFile;25stryker.coveringTests(testRunner, files, testFramework, testFiles, mutate, log, port, timeoutFactor, timeoutMs, timeoutValue, reporters, plugins, strykerOptions, strykerConfig, testFrameworkOptions, coverageAnalysis, karmaConfig, karmaConfigFile, karmaConfigOverrides, karmaConfigOverridden, karmaConfigOverriddenFile).then(function (result) {26  console.log(result);27});28module.exports = function () {29  return {30    strykerOptions: {31      karma: {32        config: {

Using AI Code Generation

1const stryker = require('stryker-parent');2const config = stryker.config;3const log = stryker.log;4log.setLevel('debug');5];6];7const testFramework = 'mocha';8const testRunner = 'mocha';9const coverageAnalysis = 'perTest';10const config = {11};12const stryker = stryker.coveringTests(config);13console.log(stryker);14{ files:15  dashboard: { reportType: 'full' },16  thresholds: { high: 80, low: 60, break: null },17  strykerOptions: { config: 'stryker.conf.js' },18  log: { appenders: [ [Object] ], level: 'debug' },19  fileLog: { appenders: [ [Object] ], level: 'trace' },

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.