org.pitest.mutationtest.MutationTestBuilder Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of pitest Show documentation
Mutation testing system for Java.
There is a newer version: 1.16.1
/*
 * Copyright 2011 Henry Coles
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and limitations under the License.
 */
package org.pitest.mutationtest;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.logging.Logger;

import org.pitest.classinfo.ClassName;
import org.pitest.coverage.domain.TestInfo;
import org.pitest.extension.Configuration;
import org.pitest.functional.F;
import org.pitest.functional.FCollection;
import org.pitest.functional.FunctionalList;
import org.pitest.functional.Prelude;
import org.pitest.mutationtest.instrument.KnownStatusMutationTestUnit;
import org.pitest.mutationtest.instrument.MutationTestUnit;
import org.pitest.mutationtest.instrument.PercentAndConstantTimeoutStrategy;
import org.pitest.mutationtest.results.DetectionStatus;
import org.pitest.mutationtest.results.MutationResult;
import org.pitest.util.JavaAgent;
import org.pitest.util.Log;

public class MutationTestBuilder {

  private final static Logger    LOG = Log.getLogger();

  private final MutationSource   mutationSource;
  private final MutationAnalyser analyser;
  private final ReportOptions    data;
  private final MutationConfig   mutationConfig;
  private final Configuration    configuration;
  private final JavaAgent        javaAgent;
  private final File             baseDir;

  public MutationTestBuilder(final File baseDir,
      final MutationConfig mutationConfig, final MutationAnalyser analyser,
      final MutationSource mutationSource, final ReportOptions data,
      final Configuration configuration, final JavaAgent javaAgent) {
    this.data = data;
    this.mutationConfig = mutationConfig;
    this.mutationSource = mutationSource;
    this.analyser = analyser;
    this.configuration = configuration;
    this.javaAgent = javaAgent;
    this.baseDir = baseDir;
  }

  public List createMutationTestUnits(
      final Collection codeClasses) {
    final List tus = new ArrayList();

    for (final ClassName clazz : codeClasses) {
      final Collection mutationsForClasses = this.mutationSource
          .createMutations(clazz);
      if (mutationsForClasses.isEmpty()) {
        LOG.fine("No mutations found for " + clazz);
      } else {
        createMutationAnalysisUnits(tus, clazz, mutationsForClasses);
      }
    }

    Collections.sort(tus, new AnalysisPriorityComparator());
    return tus;
  }

  private void createMutationAnalysisUnits(
      final List tus, final ClassName clazz,
      final Collection mutationsForClasses) {
    if (this.data.getMutationUnitSize() > 0) {
      final FunctionalList> groupedMutations = FCollection
          .splitToLength(this.data.getMutationUnitSize(), mutationsForClasses);
      FCollection
          .mapTo(groupedMutations, mutationDetailsToTestUnit(clazz), tus);
    } else {
      tus.add(createMutationTestUnit(mutationsForClasses));
    }
  }

  private F, MutationAnalysisUnit> mutationDetailsToTestUnit(
      final ClassName clazz) {
    return new F, MutationAnalysisUnit>() {
      public MutationAnalysisUnit apply(final List mutations) {
        return createMutationTestUnit(mutations);
      }
    };
  }

  private MutationAnalysisUnit createMutationTestUnit(
      final Collection mutationsForClasses) {

    final Collection analysedMutations = this.analyser
        .analyse(mutationsForClasses);

    final Collection needAnalysis = FCollection.filter(
        analysedMutations, statusNotKnown()).map(resultToDetails());
    final Collection analysed = FCollection.filter(
        analysedMutations, Prelude.not(statusNotKnown()));

    if (needAnalysis.isEmpty()) {
      return makePreAnalysedUnit(analysed);
    }

    if (analysed.isEmpty()) {
      return makeUnanalysedUnit(needAnalysis);
    }

    return new MixedAnalysisUnit(Arrays.asList(makePreAnalysedUnit(analysed),
        makeUnanalysedUnit(needAnalysis)));

  }

  private MutationAnalysisUnit makePreAnalysedUnit(
      final Collection analysed) {
    return new KnownStatusMutationTestUnit(
        this.mutationConfig.getMutatorNames(), analysed);
  }

  private MutationAnalysisUnit makeUnanalysedUnit(
      final Collection needAnalysis) {
    final Set uniqueTestClasses = new HashSet();
    FCollection.flatMapTo(needAnalysis, mutationDetailsToTestClass(),
        uniqueTestClasses);

    return new MutationTestUnit(this.baseDir, needAnalysis, uniqueTestClasses,
        this.configuration, this.mutationConfig, this.javaAgent,
        new PercentAndConstantTimeoutStrategy(this.data.getTimeoutFactor(),
            this.data.getTimeoutConstant()), this.data.isVerbose(), this.data
            .getClassPath().getLocalClassPath());
  }

  private static F resultToDetails() {
    return new F() {
      public MutationDetails apply(final MutationResult a) {
        return a.getDetails();
      }
    };
  }

  private static F statusNotKnown() {
    return new F() {
      public Boolean apply(final MutationResult a) {
        return a.getStatus() == DetectionStatus.NOT_STARTED;
      }
    };
  }

  private static F> mutationDetailsToTestClass() {
    return new F>() {
      public Iterable apply(final MutationDetails a) {
        return FCollection.map(a.getTestsInOrder(),
            TestInfo.toDefiningClassName());
      }
    };
  }

}