org.evosuite.xsd.ProjectUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of evosuite-master Show documentation
There is a newer version: 1.0.6
/**
 * Copyright (C) 2010-2016 Gordon Fraser, Andrea Arcuri and EvoSuite
 * contributors
 *
 * This file is part of EvoSuite.
 *
 * EvoSuite is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3.0 of the License, or
 * (at your option) any later version.
 *
 * EvoSuite is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with EvoSuite. If not, see .
 */
package org.evosuite.xsd;

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.OptionalInt;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * ProjectUtil class
 * 
 * Useful to get data (total, averages, etc) from a {@code Project} instance.
 * 
 * @author José Campos
 */
public abstract class ProjectUtil {

  /**
   * Total Numbers
   */

  /**
   * Returns the total number of tested classes
   * 
   * @param project
   * @return
   */
  public static int getTotalNumberTestedClasses(Project project) {
    return project.getCut().size();
  }

  /**
   * Returns the total number of tested classes on the latest execution
   * 
   * @param project
   * @return
   */
  public static int getNumberLatestTestedClasses(Project project) {
    if (project.getCut().isEmpty()) {
      return 0;
    }

    final OptionalInt highestID = project.getCut().parallelStream()
        .mapToInt(c -> CUTUtil.getLatestGeneration(c).getId().intValue()).reduce(Integer::max);
    return (int) project.getCut().parallelStream()
        .filter(c -> CUTUtil.getTimeBudget(c, highestID.getAsInt()) > 0).count();
  }

  /**
   * Returns the total number of testable classes
   * 
   * @param project
   * @return
   */
  public static int getNumberTestableClasses(Project project) {
    return project.getTotalNumberOfTestableClasses().intValue();
  }

  /**
   * Returns the total time (minutes) spent on all successful generations
   * 
   * @param project
   * @return total time (minutes) or 0 if there is not any {@code CUT}
   */
  public static int getTotalEffort(Project project) {
    if (project.getCut().isEmpty()) {
      return 0;
    }

    final OptionalInt highestID = project.getCut().parallelStream()
        .mapToInt(c -> CUTUtil.getLatestGeneration(c).getId().intValue()).reduce(Integer::max);
    return (int) Math.ceil(project.getCut().parallelStream()
        .mapToDouble(c -> CUTUtil.getTotalEffort(c, highestID.getAsInt())).sum());
  }

  /**
   * Returns the total time (minutes) settled by the scheduler on all successful generations
   * 
   * @param project
   * @return total time (minutes) or 0 if there is not any {@code CUT}
   */
  public static int getTimeBudget(Project project) {
    if (project.getCut().isEmpty()) {
      return 0;
    }

    final OptionalInt highestID = project.getCut().parallelStream()
        .mapToInt(c -> CUTUtil.getLatestGeneration(c).getId().intValue()).reduce(Integer::max);
    return (int) Math.ceil(project.getCut().parallelStream()
        .mapToDouble(c -> CUTUtil.getTimeBudget(c, highestID.getAsInt())).sum());
  }

  /**
   * Returns the total number of generated test suites of all successful generations
   * 
   * @param project
   * @return number of generated test suites or 0 if there is not any {@code CUT}
   */
  public static int getNumberGeneratedTestSuites(Project project) {
    if (project.getCut().isEmpty()) {
      return 0;
    }

    return ProjectUtil.getAllSuccessfulGenerations(project).size();
  }

  /**
   * Returns all criteria used on all successful generations
   * 
   * @param project
   * @return all criteria used or an empty Set<> if there is not any {@code CUT}
   */
  public static Set getUnionCriteria(Project project) {
    Set criteria = new LinkedHashSet();
    if (project.getCut().isEmpty()) {
      return criteria;
    }

    return ProjectUtil.getAllSuccessfulGenerations(project).parallelStream()
        .map(g -> GenerationUtil.getCriteria(g)).flatMap(s -> s.stream())
        .collect(Collectors.toSet());
  }

  /**
   * Averages
   */

  /**
   * Returns the average length (i.e., number of statements) of all successful generations
   * 
   * @param project
   * @return average length or 0.0 if there is not any {@code CUT}
   */
  public static double getAverageNumberStatements(Project project) {
    if (project.getCut().isEmpty()) {
      return 0.0;
    }

    return ProjectUtil.getAllSuccessfulGenerations(project).parallelStream()
        .mapToDouble(g -> g.getSuite().getTotalNumberOfStatements().doubleValue()).sum()
        / project.getTotalNumberOfTestableClasses().doubleValue();
  }

  /**
   * Returns the overall coverage of all successful generations
   * 
   * @param project
   * @return overall coverage or 0.0 if there is not any {@code CUT}
   */
  public static double getOverallCoverage(Project project) {
    if (project.getCut().isEmpty()) {
      return 0.0;
    }

    return ProjectUtil.getAllSuccessfulGenerations(project).parallelStream()
        .mapToDouble(g -> GenerationUtil.getOverallCoverage(g)).sum()
        / project.getTotalNumberOfTestableClasses().doubleValue();
  }

  /**
   * Returns the coverage of a particular criterion of all successful generations
   * 
   * @param project
   * @param criterionName
   * @return average coverage of a criterion or 0.0 if there is not any {@code CUT}
   */
  public static double getAverageCriterionCoverage(Project project, String criterionName) {
    if (project.getCut().isEmpty()) {
      return 0.0;
    }

    return ProjectUtil.getAllSuccessfulGenerations(project).parallelStream()
        .mapToDouble(g -> GenerationUtil.getCriterionCoverage(g, criterionName)).sum()
        / project.getTotalNumberOfTestableClasses().doubleValue();
  }

  /**
   * Returns the average number of generated tests of all successful generations
   * 
   * @param project
   * @return average number of tests or 0.0 if there is not any {@code CUT}
   */
  public static double getAverageNumberTests(Project project) {
    if (project.getCut().isEmpty()) {
      return 0.0;
    }

    return ProjectUtil.getAllSuccessfulGenerations(project).parallelStream()
        .mapToDouble(g -> g.getSuite().getNumberOfTests().doubleValue()).sum()
        / project.getTotalNumberOfTestableClasses().doubleValue();
  }

  /**
   * Aux
   */

  /**
   * Returns the {@code CUT} object of a particular class name
   * 
   * @param project
   * @param className
   * @return a {@code CUT} object or null if there is not any {@code CUT} with class name
   */
  public static CUT getCUT(Project project, String className) {
    return project.getCut().parallelStream()
        .filter(p -> p.getFullNameOfTargetClass().equals(className)).findFirst().orElse(null);
  }

  /**
   * Returns all successful generations
   * 
   * @param project
   * @return all successful generations or an empty Set<> if: there is not any {@code CUT}; or if
   *         there is not any successful generation at all
   */
  protected static List getAllSuccessfulGenerations(Project project) {
    List all = new ArrayList();
    if (project.getCut().isEmpty()) {
      return all;
    }

    for (CUT cut : project.getCut()) {
      // search for the latest successful test generation of 'cut'
      Generation lastSuccessfulGeneration = CUTUtil.getLatestSuccessfulGeneration(cut);
      if (lastSuccessfulGeneration != null) {
        all.add(lastSuccessfulGeneration);
      }
    }

    return all;
  }
}