ReportGenerator.java

/**
 * Copyright (C) 2010-2017 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 <http://www.gnu.org/licenses/>.
 */
package org.evosuite.utils;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.net.URL;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import org.apache.commons.lang3.StringEscapeUtils;
import org.evosuite.Properties;
import org.evosuite.Properties.NoSuchParameterException;
import org.evosuite.contracts.AssertionErrorContract;
import org.evosuite.contracts.EqualsContract;
import org.evosuite.contracts.EqualsHashcodeContract;
import org.evosuite.contracts.EqualsNullContract;
import org.evosuite.contracts.EqualsSymmetricContract;
import org.evosuite.contracts.FailingTestSet;
import org.evosuite.contracts.HashCodeReturnsNormallyContract;
import org.evosuite.contracts.JCrasherExceptionContract;
import org.evosuite.contracts.NullPointerExceptionContract;
import org.evosuite.contracts.ToStringReturnsNormallyContract;
import org.evosuite.contracts.UndeclaredExceptionContract;
import org.evosuite.ga.Chromosome;
import org.evosuite.ga.metaheuristics.GeneticAlgorithm;
import org.evosuite.ga.metaheuristics.SearchListener;
import org.evosuite.runtime.sandbox.PermissionStatistics;
import org.evosuite.testcase.ExecutionResult;
import org.evosuite.testcase.ExecutionTrace;
import org.evosuite.testcase.ExecutionTracer;
import org.evosuite.testcase.JUnitTestCarvedChromosomeFactory;
import org.evosuite.testcase.TestCase;
import org.evosuite.testcase.TestCaseExecutor;
import org.evosuite.testcase.TestChromosome;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.panayotis.gnuplot.JavaPlot;
import com.panayotis.gnuplot.plot.AbstractPlot;
import com.panayotis.gnuplot.style.PlotStyle;
import com.panayotis.gnuplot.style.Style;
import com.panayotis.gnuplot.terminal.FileTerminal;
import com.panayotis.gnuplot.terminal.GNUPlotTerminal;

/**
 * <p>
 * Abstract ReportGenerator class.
 * </p>
 * 
 * @author Gordon Fraser
 */
@Deprecated
public abstract class ReportGenerator implements SearchListener, Serializable {

	private static final long serialVersionUID = -920540796220051609L;
	/** Constant <code>logger</code> */
	protected static final Logger logger = LoggerFactory.getLogger(ReportGenerator.class);

	/**
	 * Return the folder of where reports should be generated.
	 * If the folder does not exist, try to create it
	 * 
	 * @return
	 * @throws RuntimeException if folder does not exist, and we cannot create it
	 */
	public static File getReportDir() throws RuntimeException{
		File dir = new File(Properties.REPORT_DIR);
		
		if(!dir.exists()){
			boolean created = dir.mkdirs();
			if(!created){
				String msg = "Cannot create report dir: "+Properties.REPORT_DIR;
				logger.error(msg);
				throw new RuntimeException(msg);
			}
		}
		
		return dir;			
	}

	/**
	 * <p>
	 * This enumeration defines all the runtime variables we want to store in
	 * the CSV files. Note, it is perfectly fine to add new ones, in any
	 * position. Just be sure to define a proper mapper in {@code getCSVvalue}.
	 * </p>
	 * 
	 * <p>
	 * WARNING: do not change the name of any variable! If you do, current R
	 * scripts will break. If you really need to change a name, please first
	 * contact Andrea Arcuri.
	 * </p>
	 * 
	 * @author arcuri
	 * 
	 */
	@Deprecated
	public enum RuntimeVariable {
		/** The class under test */
		Class,
		/** Number of predicates */
		Predicates,
		Total_Branches,
		Covered_Branches,
		Total_Methods,
		Branchless_Methods,
		Covered_Methods,
		Covered_Branchless_Methods,
		Total_Goals,
		Covered_Goals,
		Statements_Executed,
		/** Obtained coverage of the chosen testing criterion */
		Coverage,
		/**
		 * Obtained coverage at different points in time
		 */
		CoverageTimeline,
		/**
		 * Not only the covered branches ratio, but also including the
		 * branchless methods
		 */
		BranchCoverage,
		NumberOfGeneratedTestCases,
		/**
		 * The number of serialized objects that EvoSuite is
		 * going to use for seeding strategies
		 */
		NumberOfInputPoolObjects,
		DefUseCoverage,
		WeakMutationScore,
		Creation_Time,
		Minimization_Time,
		Total_Time,
		Test_Execution_Time,
		Goal_Computation_Time,
		Result_Size,
		Result_Length,
		Minimized_Size,
		Minimized_Length,
		Chromosome_Length,
		Population_Size,
		Random_Seed,
		Budget,
		AllPermission,
		SecurityPermission,
		UnresolvedPermission,
		AWTPermission,
		FilePermission,
		SerializablePermission,
		ReflectPermission,
		RuntimePermission,
		NetPermission,
		SocketPermission,
		SQLPermission,
		PropertyPermission,
		LoggingPermission,
		SSLPermission,
		AuthPermission,
		AudioPermission,
		OtherPermission,
		Threads,
		CoveredBranchesBitString,
		MutationScore,
		Explicit_MethodExceptions,
		Explicit_TypeExceptions,
		Implicit_MethodExceptions,
		Implicit_TypeExceptions,
		Error_Predicates,
		Error_Branches_Covered,
		Error_Branchless_Methods,
		Error_Branchless_Methods_Covered,
		AssertionContract,
		EqualsContract,
		EqualsHashcodeContract,
		EqualsNullContract,
		EqualsSymmetricContract,
		HashCodeReturnsNormallyContract,
		JCrasherExceptionContract,
		NullPointerExceptionContract,
		ToStringReturnsNormallyContract,
		UndeclaredExceptionContract,
		Contract_Violations,
		Unique_Violations,
		Data_File,
		/**
		 * Dataflow stuff
		 */
		Definitions,
		Uses,
		DefUsePairs,
		IntraMethodPairs,
		InterMethodPairs,
		IntraClassPairs,
		ParameterPairs,
		AliasingIntraMethodPairs,
		AliasingInterMethodPairs,
		AliasingIntraClassPairs,
		AliasingParameterPairs,
		CoveredIntraMethodPairs,
		CoveredInterMethodPairs,
		CoveredIntraClassPairs,
		CoveredParameterPairs,
		CoveredAliasIntraMethodPairs,
		CoveredAliasInterMethodPairs,
		CoveredAliasIntraClassPairs,
		CoveredAliasParameterPairs,
		CarvedTests,
		CarvedCoverage,
		HadUnstableTests
	};

	/** Constant <code>DATE_FORMAT_NOW="yyyy-MM-dd HH:mm:ss"</code> */
	protected static final String DATE_FORMAT_NOW = "yyyy-MM-dd HH:mm:ss";

	/**
	 * Statistics about one test generation run
	 * 
	 * @author Gordon Fraser
	 * 
	 */
	public class StatisticEntry implements Serializable {

		private static final long serialVersionUID = 8690481387977534927L;

		/** Run id */
		public int id = 0;

		public String className;

		public int population_size;

		public int chromosome_length;

		/** Total number of branches */
		public int total_branches;

		public int error_branches = 0;

		public int error_branches_covered = 0;

		public int error_branchless_methods = 0;

		public int error_branchless_methods_covered = 0;

		/** Total number of branches */
		public int covered_branches;

		public int total_methods;

		public int branchless_methods;

		public int covered_branchless_methods;

		public int covered_methods;

		public int total_goals;

		public int covered_goals;

		public Set<Integer> coverage = new HashSet<Integer>();

		public double mutationScore = 0.0;

		public Map<String, Double> coverageMap = new HashMap<String, Double>();

		/** Resulting test cases */
		public List<TestCase> tests = null;

		/** History of best fitness values */
		public List<Double> fitness_history = new ArrayList<Double>();

		/** History of best test suite size */
		public List<Integer> size_history = new ArrayList<Integer>();

		/** History of best test length */
		public List<Integer> length_history = new ArrayList<Integer>();

		/** History of average test length */
		public List<Double> average_length_history = new ArrayList<Double>();

		/** History of best test coverage */
		public List<Double> coverage_history = new ArrayList<Double>();

		/** History of best test length */
		public List<Long> tests_executed = new ArrayList<Long>();

		/** History of best test length */
		public List<Long> statements_executed = new ArrayList<Long>();

		/** History of the time stamps for generations */
		public List<Long> timeStamps = new ArrayList<Long>();

		/** History of best test length */
		public List<Long> fitness_evaluations = new ArrayList<Long>();

		/** Time at which this entry was created */
		public final long creationTime = System.currentTimeMillis();

		/** Number of tests after GA */
		public int size_final = 0;

		/** Total length of tests after GA */
		public int length_final = 0;

		/** Number of tests after minimization */
		public int size_minimized = 0;

		/** Total length of tests after minimization */
		public int length_minimized = 0;

		public Map<TestCase, Map<Integer, Throwable>> results = new HashMap<TestCase, Map<Integer, Throwable>>();

		public long start_time;

		public long end_time;

		public long minimized_time;

		public long testExecutionTime;

		public long goalComputationTime;

		public int result_fitness_evaluations = 0;

		public long result_tests_executed = 0;

		public long result_statements_executed = 0;

		public int age = 0;

		public double fitness = 0.0;

		public long seed = 0;

		public long stoppingCondition;

		public long globalTimeStoppingCondition;

		public boolean timedOut;

		public int numDefinitions;
		public int numUses;
		public int numDefUsePairs;

		public int numIntraMethodPairs;
		public int numInterMethodPairs;
		public int numIntraClassPairs;
		public int numParameterPairs;

		public int coveredIntraMethodPairs;
		public int coveredInterMethodPairs;
		public int coveredIntraClassPairs;
		public int coveredParameterPairs;

		public int aliasingIntraMethodPairs;
		public int aliasingInterMethodPairs;
		public int aliasingIntraClassPairs;
		public int aliasingParameterPairs;

		public int coveredAliasIntraMethodPairs;
		public int coveredAliasInterMethodPairs;
		public int coveredAliasIntraClassPairs;
		public int coveredAliasParameterPairs;

		public String goalCoverage;

		public int explicitMethodExceptions;

		public int explicitTypeExceptions;

		public int implicitMethodExceptions;

		public int implicitTypeExceptions;

		public Map<String, Set<Class<?>>> implicitExceptions;

		public Map<String, Set<Class<?>>> explicitExceptions;
		
		
		public boolean hadUnstableTests;
		
		//--------------------------------------------------

		private String[] getTimelineHeaderSuffixes() {
			int numberOfIntervals = calculateNumberOfIntervals();
			String[] suffixes = new String[numberOfIntervals];
			for (int i = 0; i < suffixes.length; i++) {
				/*
				 * NOTE: we start from T1 and not T0 because, by definition, coverage
				 * at T0 is equal to 0, and no point in showing it in a graph
				 */
				suffixes[i] = "_T" + (i + 1);
			}
			return suffixes;
		}

		private int calculateNumberOfIntervals() {
			long interval = Properties.TIMELINE_INTERVAL;
			/*
			 * TODO: this might need refactoring once we choose 
			 * a different way to handle search timeouts.
			 * 
			 * The point here is that we need to support both if we use time
			 * as search budget, and fitness/statement evaluations.
			 * We cannot just look at the obtained history, because the search might
			 * have finished earlier, eg if 100% coverage
			 */
			long totalTime = Properties.GLOBAL_TIMEOUT * 1000l;

			int numberOfIntervals = (int) (totalTime / interval);
			return numberOfIntervals;
		}

		/**
		 * Return array of variables to dump in CSV files, based on what defined
		 * in {@code Properties.OUTPUT_VARIABLES}
		 * 
		 * @return
		 */
		public String[] getUsedVariables() throws IllegalStateException {
			String property = Properties.OUTPUT_VARIABLES;

			List<String> runtimeList = new ArrayList<String>();
			for (RuntimeVariable var : RuntimeVariable.values()) {
				runtimeList.add(var.toString());
			}

			//no choice define, just dump all runtime variables
			if (property == null) {
				handleTimelineVariableHeaders(runtimeList);
				return runtimeList.toArray(new String[runtimeList.size()]);
			}

			//extract parameters
			String[] splitArray = property.split(",");
			List<String> usedList = new ArrayList<String>();
			for (int i = 0; i < splitArray.length; i++) {
				splitArray[i] = splitArray[i].trim();
				if (!splitArray[i].isEmpty()) {
					usedList.add(splitArray[i]);
				}
			}

			//check if parameters exist
			for (String param : usedList) {
				if (runtimeList.contains(param)) {
					continue;
				}
				if (Properties.hasParameter(param)) {
					continue;
				}

				throw new IllegalStateException("Parameter \"" + param
				        + "\" defined inside \"output_variables\" does not exist");
			}

			handleTimelineVariableHeaders(usedList);
			String[] usedArray = usedList.toArray(new String[usedList.size()]);
			return usedArray;
		}

		private void handleTimelineVariableHeaders(List<String> usedList) {
			/*
			 * now, handle timeline variables. For now, it is just coverage
			 */
			String covTimeline = RuntimeVariable.CoverageTimeline.toString();
			if (usedList.contains(covTimeline)) {
				usedList.remove(covTimeline);
				for (String suf : getTimelineHeaderSuffixes()) {
					usedList.add(covTimeline + suf);
				}
			}
		}

		/**
		 * Return value of a parameter, based on whether it is a EvoSuite
		 * property (e.g., population size), or something calculated at runtime
		 * (e.g. coverage)
		 * 
		 * @return
		 */
		private String getValueOfOutputVariable(String name) {
			//first check if it is an EvoSuite parameter (e.g. population size)
			if (Properties.hasParameter(name)) {
				try {
					return Properties.getStringValue(name);
				} catch (Exception e) {
					/*
					 * when we call this method, the parameters should had been already validated, and program aborted if necessary.
					 * An exception here is likely a bug
					 */
					logger.error("Error in getting value of parameter " + name, e);
					throw new Error(
					        "If this method inside EvoSuite is called, then it should never happen that the following exception is raised: "
					                + e.getMessage());
				}
			}

			if (isTimelineVariable(name)) {
				return timeLineValue(name);
			}

			//check if it is a runtime property of the search, e.g. coverage
			RuntimeVariable var = null;
			try {
				var = RuntimeVariable.valueOf(name);
			} catch (Exception e) {
				//note: we throw an Error as this protected method should never be called with wrong input / or on wrong internal state
				throw new Error("Parameter " + name + " does not exist");
			}

			//if it is not an EvoSuite property, it has to be a runtime one
			return getCSVvalue(var);
		}

		private String timeLineValue(String name) {

			long interval = Properties.TIMELINE_INTERVAL;

			int index = Integer.parseInt((name.split("_T"))[1]);
			long preferredTime = interval * index;

			assert this.timeStamps.size() == this.coverage_history.size();

			/*
			 * No data. Is it even possible? Maybe if population is too large,
			 * and budget was not enough to get even first generation
			 */
			if (timeStamps.size() == 0) {
				return "" + 0;
			}

			for (int i = 0; i < timeStamps.size(); i++) {
				/*
				 * find the first stamp that is after the time we would like to
				 * get coverage from
				 */
				long stamp = timeStamps.get(i);
				if (stamp < preferredTime) {
					continue;
				}

				if (i == 0) {
					/*
					 * it is the first element, so not much to do, we just use it as value
					 */
					return "" + coverage_history.get(i);
				}

				/*
				 * Now we interpolate the coverage, as usually we don't have the value for exact time we want
				 */
				long timeDelta = timeStamps.get(i) - timeStamps.get(i - 1);

				if (timeDelta > 0) {
					double covDelta = coverage_history.get(i)
					        - coverage_history.get(i - 1);
					double ratio = covDelta / timeDelta;

					long diff = preferredTime - timeStamps.get(i - 1);
					double cov = coverage_history.get(i - 1) + (diff * ratio);
					return "" + cov;
				}
			}

			/*
			 * No time stamp was higher. This might happen if coverage is 100% and we stop search.
			 * So just return last value seen
			 */

			return "" + coverage_history.get(coverage_history.size() - 1);
		}

		private boolean isTimelineVariable(String name) {
			if (name == null || name.isEmpty()) {
				return false;
			}
			if (name.startsWith(RuntimeVariable.CoverageTimeline.toString())) {
				return true;
			} else {
				return false;
			}
		}

		public String getCSVHeader() {
			StringBuilder r = new StringBuilder();

			String[] variables = getUsedVariables();
			if (variables.length > 0) {
				r.append(variables[0]);
			}

			for (int i = 1; i < variables.length; i++) {
				r.append(",");
				r.append(variables[i]);
			}

			return r.toString();
		}

		public String getCSVData() {
			StringBuilder r = new StringBuilder();

			String[] variables = getUsedVariables();
			if (variables.length > 0) {
				r.append(getValueOfOutputVariable(variables[0]));
			}

			for (int i = 1; i < variables.length; i++) {
				r.append(",");
				r.append(getValueOfOutputVariable(variables[i]));
			}

			return r.toString();
		}

		private String getCSVvalue(RuntimeVariable var) {

			PermissionStatistics pstats = PermissionStatistics.getInstance();

			switch (var) {
			case Class:
				return className;
			case Predicates:
				return "" + total_branches;
			case Total_Branches:
				return "" + (total_branches * 2);
			case Covered_Branches:
				return "" + covered_branches;
			case Total_Methods:
				return "" + total_methods;
			case Branchless_Methods:
				return "" + branchless_methods;
			case Covered_Methods:
				return "" + covered_methods;
			case Covered_Branchless_Methods:
				return "" + covered_branchless_methods;
			case Total_Goals:
				return "" + total_goals;
			case Covered_Goals:
				return "" + covered_goals;
			case Coverage:
				return "" + getCoverageDouble();
			case NumberOfGeneratedTestCases:
				return ""+ (tests!=null? tests.size() : 0);
			case NumberOfInputPoolObjects:
				String s = Properties.OBJECT_POOLS;
				if(s==null || s.isEmpty()){
					return ""+0;
				} else {
					return ""+s.split(File.pathSeparator).length;
				}
			case BranchCoverage:
				double cov = 0.0;

				if (total_branches + branchless_methods > 0)
					cov = (double) (covered_branches + covered_branchless_methods)
					        / (double) ((total_branches * 2) + branchless_methods);
				else
					cov = 1.0;

				if (!(cov >= 0 && cov <= 1)) {
					String message = "Invalid coverage: " + cov;
					message += " . covered_branches=" + covered_branches;
					message += " , covered_branchless_methods="
					        + covered_branchless_methods;
					message += " , total_branches*2=" + (total_branches * 2);
					message += " , branchless_methods=" + branchless_methods;
					logger.error(message);
					throw new AssertionError("Wrong coverage value: " + cov);
				}
				return "" + cov;
			case DefUseCoverage:
				if (coverageMap.containsKey("DEFUSE"))
					return "" + coverageMap.get("DEFUSE");
				else
					return "";
			case WeakMutationScore:
				if (coverageMap.containsKey("WEAKMUTATION"))
					return "" + coverageMap.get("WEAKMUTATION");
				else
					return "";
			case Creation_Time:
				return "" + (minimized_time - start_time);
			case Minimization_Time:
				return "" + (minimized_time - end_time);
			case Total_Time:
				return "" + (end_time - start_time);
			case Test_Execution_Time:
				return "" + testExecutionTime;
			case Goal_Computation_Time:
				return "" + goalComputationTime;
			case Result_Size:
				return "" + size_final;
			case Result_Length:
				return "" + length_final;
			case Minimized_Size:
				return "" + size_minimized;
			case Minimized_Length:
				return "" + length_minimized;
			case Chromosome_Length:
				return "" + chromosome_length;
			case Population_Size:
				return "" + population_size;
			case Random_Seed:
				return "" + seed;
			case Budget:
				return "" + Properties.SEARCH_BUDGET;
			case AllPermission:
				return "" + pstats.getNumAllPermission();
			case SecurityPermission:
				return "" + pstats.getNumSecurityPermission();
			case UnresolvedPermission:
				return "" + pstats.getNumUnresolvedPermission();
			case AWTPermission:
				return "" + pstats.getNumAWTPermission();
			case FilePermission:
				return "" + pstats.getNumFilePermission();
			case SerializablePermission:
				return "" + pstats.getNumSerializablePermission();
			case ReflectPermission:
				return "" + pstats.getNumReflectPermission();
			case RuntimePermission:
				return "" + pstats.getNumRuntimePermission();
			case NetPermission:
				return "" + pstats.getNumNetPermission();
			case SocketPermission:
				return "" + pstats.getNumSocketPermission();
			case SQLPermission:
				return "" + pstats.getNumSQLPermission();
			case PropertyPermission:
				return "" + pstats.getNumPropertyPermission();
			case LoggingPermission:
				return "" + pstats.getNumLoggingPermission();
			case SSLPermission:
				return "" + pstats.getNumSSLPermission();
			case AuthPermission:
				return "" + pstats.getNumAuthPermission();
			case AudioPermission:
				return "" + pstats.getNumAudioPermission();
			case OtherPermission:
				return "" + pstats.getNumOtherPermission();
			case Threads:
				return "" + pstats.getMaxThreads();
			case CoveredBranchesBitString:				
				return "" + goalCoverage;
			case MutationScore:
				return "" + mutationScore;
			case Explicit_MethodExceptions:
				return "" + explicitMethodExceptions;
			case Explicit_TypeExceptions:
				return "" + explicitTypeExceptions;
			case Implicit_MethodExceptions:
				return "" + implicitMethodExceptions;
			case Implicit_TypeExceptions:
				return "" + implicitTypeExceptions;
			case Error_Predicates:
				return "" + error_branches;
			case Error_Branches_Covered:
				return "" + error_branches_covered;
			case Error_Branchless_Methods:
				return "" + error_branchless_methods;
			case Error_Branchless_Methods_Covered:
				return "" + error_branchless_methods_covered;
			case AssertionContract:
				return ""
				        + FailingTestSet.getNumberOfViolations(AssertionErrorContract.class);
			case EqualsContract:
				return "" + FailingTestSet.getNumberOfViolations(EqualsContract.class);
			case EqualsHashcodeContract:
				return ""
				        + FailingTestSet.getNumberOfViolations(EqualsHashcodeContract.class);
			case EqualsNullContract:
				return ""
				        + FailingTestSet.getNumberOfViolations(EqualsNullContract.class);
			case EqualsSymmetricContract:
				return ""
				        + FailingTestSet.getNumberOfViolations(EqualsSymmetricContract.class);
			case HashCodeReturnsNormallyContract:
				return ""
				        + FailingTestSet.getNumberOfViolations(HashCodeReturnsNormallyContract.class);
			case JCrasherExceptionContract:
				return ""
				        + FailingTestSet.getNumberOfViolations(JCrasherExceptionContract.class);
			case NullPointerExceptionContract:
				return ""
				        + FailingTestSet.getNumberOfViolations(NullPointerExceptionContract.class);
			case ToStringReturnsNormallyContract:
				return ""
				        + FailingTestSet.getNumberOfViolations(ToStringReturnsNormallyContract.class);
			case UndeclaredExceptionContract:
				return ""
				        + FailingTestSet.getNumberOfViolations(UndeclaredExceptionContract.class);
			case Contract_Violations:
				return "" + FailingTestSet.getNumberOfViolations();
			case Unique_Violations:
				return "" + FailingTestSet.getNumberOfUniqueViolations();
			case Data_File:
				return getCSVFilepath();
			case Statements_Executed:
				return "" + result_statements_executed;
			case Definitions:
				//if (Properties.CRITERION == Properties.Criterion.DEFUSE
				//        || Properties.ANALYSIS_CRITERIA.toUpperCase().contains("DEFUSE"))
				//	return "" + DefUsePool.getDefCounter();
				//else
					return ""+numDefinitions;
			case Uses:
				//if (Properties.CRITERION == Properties.Criterion.DEFUSE
				//        || Properties.ANALYSIS_CRITERIA.toUpperCase().contains("DEFUSE"))
				//	return "" + DefUsePool.getUseCounter();
				//else
					return "" + numUses;
			case DefUsePairs:
				//if (Properties.CRITERION == Properties.Criterion.DEFUSE
				//        || Properties.ANALYSIS_CRITERIA.toUpperCase().contains("DEFUSE"))
				//	return "" + DefUseCoverageFactory.getDUGoals().size();
				//else
					return ""+numDefUsePairs;
			case IntraMethodPairs:
				//if (Properties.CRITERION == Properties.Criterion.DEFUSE
				//        || Properties.ANALYSIS_CRITERIA.toUpperCase().contains("DEFUSE"))
				//	return "" + DefUseCoverageFactory.getIntraMethodGoalsCount();
				//else
					return ""+numIntraMethodPairs;
			case InterMethodPairs:
				//if (Properties.CRITERION == Properties.Criterion.DEFUSE
				//        || Properties.ANALYSIS_CRITERIA.toUpperCase().contains("DEFUSE"))
				//	return "" + DefUseCoverageFactory.getInterMethodGoalsCount();
				//else
					return "" + numInterMethodPairs;
			case IntraClassPairs:
				//if (Properties.CRITERION == Properties.Criterion.DEFUSE
				//        || Properties.ANALYSIS_CRITERIA.toUpperCase().contains("DEFUSE"))
				//	return "" + DefUseCoverageFactory.getIntraClassGoalsCount();
				//else
					return ""+numIntraClassPairs;
			case ParameterPairs:
				//if (Properties.CRITERION == Properties.Criterion.DEFUSE
				//        || Properties.ANALYSIS_CRITERIA.toUpperCase().contains("DEFUSE"))
				//	return "" + DefUseCoverageFactory.getParamGoalsCount();
				//else
					return ""+numParameterPairs;
			case CoveredIntraMethodPairs:
				return "" + coveredIntraMethodPairs;
			case CoveredInterMethodPairs:
				return "" + coveredInterMethodPairs;
			case CoveredIntraClassPairs:
				return "" + coveredIntraClassPairs;
			case CoveredParameterPairs:
				return "" + coveredParameterPairs;
			case CoveredAliasIntraMethodPairs:
				return "" + coveredAliasIntraMethodPairs;
			case CoveredAliasInterMethodPairs:
				return "" + coveredAliasInterMethodPairs;
			case CoveredAliasIntraClassPairs:
				return "" + coveredAliasIntraClassPairs;
			case CoveredAliasParameterPairs:
				return "" + coveredAliasParameterPairs;
			case AliasingIntraMethodPairs:
				return "" + aliasingIntraMethodPairs;
			case AliasingInterMethodPairs:
				return "" + aliasingInterMethodPairs;
			case AliasingIntraClassPairs:
				return "" + aliasingIntraClassPairs;
			case AliasingParameterPairs:
				return "" + aliasingParameterPairs;
			case CarvedTests:
				return ""+JUnitTestCarvedChromosomeFactory.getTotalNumberOfTestsCarved();
			case CarvedCoverage:
				return ""+JUnitTestCarvedChromosomeFactory.getCoverageOfCarvedTests();
			case HadUnstableTests:
				return ""+hadUnstableTests;
			default:
				break;

			}

			/*
			 * note, this should never happen. If it does, then it is a bug in EvoSuite. But instead of throwing an exception,
			 * we just log it. In this way, we still get the CSV file for debugging 
			 */
			logger.error("No mapping defined for variable " + var.toString());

			return "-1";
		}

		public String getCSVFilepath() {
			return getReportDir().getAbsolutePath() + File.separator + getCSVFileName();
		}

		public String getCSVFileName() {
			return "data" + File.separator + "statistics_" + className + "-" + id
			        + ".csv.gz";
		}

		public String getExceptionFilepath() {
			return getReportDir().getAbsolutePath() + "/data/exceptions_" + className
			        + "-" + id + ".csv";
		}

		public String getCoverage() {
			if (total_goals == 0)
				return "100.00%";
			else
				return String.format("%.2f",
				                     (100.0 * covered_goals / (1.0 * total_goals))).replaceAll(",",
				                                                                               ".")
				        + "%";
		}

		public double getCoverageDouble() {
			if (total_goals == 0)
				return 1.0;
			else
				return covered_goals / (1.0 * total_goals);
		}
	};

	protected List<StatisticEntry> statistics = new ArrayList<StatisticEntry>();

	/** Constant <code>html_analyzer</code> */
	protected static final HtmlAnalyzer html_analyzer = new HtmlAnalyzer();

	/**
	 * <p>
	 * writeIntegerChart
	 * </p>
	 * 
	 * @param values
	 *            a {@link java.util.List} object.
	 * @param className
	 *            a {@link java.lang.String} object.
	 * @param title
	 *            a {@link java.lang.String} object.
	 * @return a {@link java.lang.String} object.
	 */
	protected String writeIntegerChart(List<Integer> values, String className,
	        String title) {
		File file = new File(getReportDir().getAbsolutePath() + "/img/statistics_"
		        + title + "_" + className + ".png");
		JavaPlot plot = new JavaPlot();
		GNUPlotTerminal terminal = new FileTerminal("png", getReportDir()
		        + "/img/statistics_" + title + "_" + className + ".png");
		plot.setTerminal(terminal);

		// plot.set("size", "1, 0.5");
		plot.set("xlabel", "\"Generation\"");
		plot.set("ylabel", "\"" + title + "\"");
		// plot.set("xrange", "[0:]");
		// plot.set("yrange", "[0:]");
		plot.set("autoscale", "ymax");

		int[][] data = new int[values.size()][2];
		for (int i = 0; i < values.size(); i++) {
			data[i][0] = i;
			data[i][1] = values.get(i);
		}

		plot.addPlot(data);
		PlotStyle stl = ((AbstractPlot) plot.getPlots().get(0)).getPlotStyle();
		stl.setStyle(Style.LINESPOINTS);
		plot.setKey(JavaPlot.Key.OFF);
		plot.plot();

		return file.getName();
	}

	/**
	 * <p>
	 * writeDoubleChart
	 * </p>
	 * 
	 * @param values
	 *            a {@link java.util.List} object.
	 * @param className
	 *            a {@link java.lang.String} object.
	 * @param title
	 *            a {@link java.lang.String} object.
	 * @return a {@link java.lang.String} object.
	 */
	protected String writeDoubleChart(List<Double> values, String className, String title) {

		File file = new File(getReportDir().getAbsolutePath() + "/img/statistics_"
		        + title + "_" + className + ".png");
		JavaPlot plot = new JavaPlot();
		GNUPlotTerminal terminal = new FileTerminal("png", getReportDir()
		        + "/img/statistics_" + title + "_" + className + ".png");
		plot.setTerminal(terminal);
		//plot.set("size", "1, 0.8");

		plot.set("xlabel", "\"Generation\"");
		plot.set("ylabel", "\"" + title + "\"");
		// plot.set("xrange", "[0:]");
		// plot.set("yrange", "[0:]");
		plot.set("autoscale", "ymax");

		double[][] data = new double[values.size()][2];
		for (int i = 0; i < values.size(); i++) {
			data[i][0] = i;
			data[i][1] = values.get(i);
		}
		plot.addPlot(data);

		PlotStyle stl = ((AbstractPlot) plot.getPlots().get(0)).getPlotStyle();
		stl.setStyle(Style.LINESPOINTS);
		plot.setKey(JavaPlot.Key.OFF);

		plot.plot();

		return file.getName();
	}

	/**
	 * HTML header
	 * 
	 * @param buffer
	 *            a {@link java.lang.StringBuffer} object.
	 * @param title
	 *            a {@link java.lang.String} object.
	 */
	public static void writeHTMLHeader(StringBuffer buffer, String title) {
		buffer.append("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\" \"http://www.w3.org/TR/html4/frameset.dtd\">\n");
		buffer.append("<html>\n");
		buffer.append("<head>\n");
		buffer.append("<title>\n");
		buffer.append(title);
		buffer.append("\n</title>\n");

		buffer.append("<link href=\"files/prettify.css\" type=\"text/css\" rel=\"stylesheet\" />\n");
		buffer.append("<link href=\"files/style.css\" rel=\"stylesheet\" type=\"text/css\" media=\"screen\"/>\n");
		buffer.append("<script type=\"text/javascript\" src=\"files/prettify.js\"></script>\n");
		buffer.append("<script type=\"text/javascript\" src=\"files/jquery.js\"></script>\n");
		buffer.append("<script type=\"text/javascript\" src=\"files/foldButton.js\"></script>\n");
		buffer.append("<script type=\"text/javascript\">\n");
		buffer.append("  $(document).ready(function() {\n");
		//buffer.append("    $('div.tests').foldButton({'closedText':'open TITLE' });\n");
		//buffer.append("    $('div.source').foldButton({'closedText':'open TITLE' });\n");
		//buffer.append("    $('div.statistics').foldButton({'closedText':'open TITLE' });\n");
		buffer.append("    $('H2#tests').foldButton();\n");
		buffer.append("    $('H2#source').foldButton();\n");
		buffer.append("    $('H2#parameters').foldButton();\n");
		buffer.append("  });");
		buffer.append("</script>\n");
		buffer.append("<link href=\"files/foldButton.css\" rel=\"stylesheet\" type=\"text/css\">\n");
		buffer.append("</head>\n");
		buffer.append("<body onload=\"prettyPrint()\">\n");
		buffer.append("<div id=\"wrapper\">\n");
		buffer.append("<img src=\"files/evosuite.png\" height=\"40\"/>\n");
	}

	/**
	 * HTML footer
	 * 
	 * @param buffer
	 *            a {@link java.lang.StringBuffer} object.
	 */
	public static void writeHTMLFooter(StringBuffer buffer) {
		buffer.append("</div>\n");
		buffer.append("</body>\n");
		buffer.append("</html>\n");
	}

	/**
	 * <p>
	 * writeCSVData
	 * </p>
	 * 
	 * @param filename
	 *            a {@link java.lang.String} object.
	 * @param data
	 *            a {@link java.util.List} object.
	 */
	protected void writeCSVData(String filename, List<?>... data) {
		try {
			ZipOutputStream out = new ZipOutputStream(new FileOutputStream(filename,
			        false));
			out.putNextEntry(new ZipEntry(filename.replace(".gz", "")));

			//BufferedWriter out = new BufferedWriter(new FileWriter(filename, true));
			int length = Integer.MAX_VALUE;

			out.write("Generation,Fitness,Coverage,Size,Length,AverageLength,Evaluations,Tests,Statements,Time\n".getBytes());
			for (List<?> d : data) {
				length = Math.min(length, d.size());
			}
			for (int i = 0; i < length; i++) {
				out.write(("" + i).getBytes());
				for (List<?> d : data) {
					out.write(("," + d.get(i)).getBytes());
				}
				out.write("\n".getBytes());
			}
			out.close();
		} catch (IOException e) {
			logger.info("Exception while writing CSV data: " + e);
		}
	}

	/**
	 * <p>
	 * writeExceptionData
	 * </p>
	 * 
	 * @param filename
	 *            a {@link java.lang.String} object.
	 * @param exceptions
	 *            a {@link java.util.Map} object.
	 */
	protected void writeExceptionData(String filename,
	        Map<String, Set<Class<?>>> implicitExceptions,
	        Map<String, Set<Class<?>>> explicitExceptions) {
		try {
			BufferedWriter out = new BufferedWriter(new FileWriter(filename, true));
			out.write("Method,Exception,Explicit\n");
			for (String key : explicitExceptions.keySet()) {
				for (Class<?> exception : explicitExceptions.get(key)) {
					out.write(key + "," + exception.getCanonicalName() + ",1\n");
				}
			}
			for (String key : implicitExceptions.keySet()) {
				for (Class<?> exception : implicitExceptions.get(key)) {
					out.write(key + "," + exception.getCanonicalName() + ",0\n");
				}
			}
			out.close();
		} catch (IOException e) {
			logger.info("Exception while writing exception data: " + e);
		}
	}

	/**
	 * <p>
	 * getNumber
	 * </p>
	 * 
	 * @param className
	 *            a {@link java.lang.String} object.
	 * @return a int.
	 */
	protected int getNumber(final String className) {
		int num = 0;
		FilenameFilter filter = new FilenameFilter() {
			@Override
			public boolean accept(File dir, String name) {
				return name.startsWith("statistics_" + className)
				        && (name.endsWith(".csv.gz") || name.endsWith(".csv")); // && !dir.isDirectory();
			}
		};
		List<String> filenames = new ArrayList<String>();

		File[] files = (new File(getReportDir().getAbsolutePath() + "/data")).listFiles(filter);
		if (files != null) {
			for (File f : files)
				filenames.add(f.getName());
			while (filenames.contains("statistics_" + className + "-" + num + ".csv")
			        || filenames.contains("statistics_" + className + "-" + num
			                + ".csv.gz"))
				num++;
		}

		return num;
	}

	/**
	 * Write a file for a particular run
	 * 
	 * @param run
	 *            a {@link org.evosuite.utils.ReportGenerator.StatisticEntry}
	 *            object.
	 * @return a {@link java.lang.String} object.
	 */
	protected String writeRunPage(StatisticEntry run) {

		StringBuffer sb = new StringBuffer();
		writeHTMLHeader(sb, run.className);

		sb.append("<div id=\"header\"><div id=\"logo\">");
		sb.append("<h2>");
		sb.append(run.className);
		sb.append(": ");
		sb.append(String.format("%.2f", 100.0 * run.covered_goals / run.total_goals));
		sb.append("%");
		sb.append("</h2></div></div>\n");
		sb.append("<p><a href=\"../report-generation.html\">Overview</a></p>\n");

		writeResultTable(sb, run);
		// writeMutationTable(sb);
		sb.append("<div id=\"page\"><div id=\"page-bgtop\"><div id=\"page-bgbtm\"><div id=\"content\">");
		sb.append("<div id=\"post\">");

		// Resulting test case
		sb.append("<h2 class=title>Test suite</h2>\n");
		if (run.tests != null) {
			int num = 0;
			for (TestCase test : run.tests) {
				sb.append("<h3>Test case ");
				sb.append(++num);
				sb.append("</h3>\n");
				/*
				 * if(test.exceptionThrown != null) { sb.append("<p>Raises:");
				 * sb.append(test.exceptionThrown); sb.append("</p>"); }
				 */
				sb.append("<pre class=\"prettyprint\" style=\"border: 1px solid #888;padding: 2px\">\n");
				int linecount = 1;
				String code = null;
				if (run.results.containsKey(test))
					code = test.toCode(run.results.get(test));
				else
					code = test.toCode();

				for (String line : code.split("\n")) {
					sb.append(String.format("<span class=\"nocode\"><a name=\"%d\">%3d: </a></span>",
					                        linecount, linecount));
					/*
					 * if(test.exceptionsThrown != null &&
					 * test.exception_statement == test_line)
					 * sb.append("<span style=\"background: #FF0000\">");
					 */
					sb.append(StringEscapeUtils.escapeHtml4(line));
					/*
					 * if(test.exceptionThrown != null &&
					 * test.exception_statement == test_line)
					 * sb.append("</span>");
					 */
					linecount++;
					sb.append("\n");
				}
				sb.append("</pre>\n");
			}
		} else {
			sb.append("No test cases generated");
		}
		sb.append("</div>");
		sb.append("<div id=\"post\">");

		// Source code
		/*
		 * Iterable<String> source =
		 * html_analyzer.getClassContent(run.className);
		 * sb.append("<h2>Coverage</h2>\n"); sb.append("<p>"); sb.append(
		 * "<pre class=\"prettyprint\" style=\"border: 1px solid #888;padding: 2px\">"
		 * ); int line_num = run.mutation.getLineNumber() - 3; if(line_num < 0)
		 * line_num = 0; int linecount = 1; for (String line : source) {
		 * if(linecount >= line_num && linecount < (line_num + 6)) {
		 * sb.append(String.format( "<span class=\"nocode\">%3d: </span>",
		 * linecount)); sb.append(StringEscapeUtils.escapeHtml(line));
		 * sb.append("\n"); } linecount++; } sb.append("</pre>\n");
		 */

		// Chart of fitness
		if (Properties.PLOT) {
			if (run.fitness_history.isEmpty()) {
				sb.append("<h2>No fitness history</h2>\n");
			} else {
				String filename = writeDoubleChart(run.fitness_history, run.className
				        + "-" + run.id, "Fitness");
				sb.append("<h2>Fitness</h2>\n");
				sb.append("<p>");
				sb.append("<img src=\"../img/");
				sb.append(filename);
				sb.append("\">");
				sb.append("</p>\n");
			}

			// Chart of size
			if (run.size_history.isEmpty()) {
				sb.append("<h2>No size history</h2>\n");
			} else {
				String filename = writeIntegerChart(run.size_history, run.className + "-"
				        + run.id, "Size");
				sb.append("<h2>Size</h2>\n");
				sb.append("<p>");
				sb.append("<img src=\"../img/");
				sb.append(filename);
				sb.append("\">");
				sb.append("</p>\n");
			}

			// Chart of length
			if (run.length_history.isEmpty()) {
				sb.append("<h2>No length history</h2>\n");
			} else {
				String filename = writeIntegerChart(run.length_history, run.className
				        + "-" + run.id, "Length");
				sb.append("<h2>Length</h2>\n");
				sb.append("<p>");
				sb.append("<img src=\"../img/");
				sb.append(filename);
				sb.append("\">");
				sb.append("</p>\n");
			}

			// Chart of average length
			if (run.average_length_history.isEmpty()) {
				sb.append("<h2>No average length history</h2>\n");
			} else {
				String filename = writeDoubleChart(run.average_length_history,
				                                   run.className + "-" + run.id, "Length");
				sb.append("<h2>Average Length</h2>\n");
				sb.append("<p>");
				sb.append("<img src=\"../img/");
				sb.append(filename);
				sb.append("\">");
				sb.append("</p>\n");
			}
		}
		sb.append("</div>");
		sb.append("<div id=\"post\">");

		// Source code
		try {
			Iterable<String> source = html_analyzer.getClassContent(run.className);
			sb.append("<h2 class=title>Source Code</h2>\n");
			sb.append("<p>");
			sb.append("<pre class=\"prettyprint\" style=\"border: 1px solid #888;padding: 2px\">");
			int linecount = 1;
			for (String line : source) {
				sb.append(String.format("<span class=\"nocode\"><a name=\"%d\">%3d: </a></span>",
				                        linecount, linecount));
				if (run.coverage.contains(linecount)) {
					sb.append("<span style=\"background-color: #ffffcc\">");
					sb.append(StringEscapeUtils.escapeHtml4(line));
					sb.append("</span>");
				}

				else
					sb.append(StringEscapeUtils.escapeHtml4(line));
				sb.append("\n");
				linecount++;
			}
			sb.append("</pre>\n");

			sb.append("</p>\n");
		} catch (Exception e) {
			// Don't display source if there is an error
		}
		sb.append("</div>");
		sb.append("<div id=\"post\">");

		writeParameterTable(sb, run);
		sb.append("</div>");

		writeHTMLFooter(sb);

		String filename = "report-" + run.className + "-" + run.id + ".html";
		File file = new File(getReportDir().getAbsolutePath() + "/html/" + filename);
		Utils.writeFile(sb.toString(), file);
		// return file.getAbsolutePath();
		return filename;
	}

	/**
	 * Write some overall stats
	 * 
	 * @param buffer
	 *            a {@link java.lang.StringBuffer} object.
	 * @param entry
	 *            a {@link org.evosuite.utils.ReportGenerator.StatisticEntry}
	 *            object.
	 */
	protected void writeParameterTable(StringBuffer buffer, StatisticEntry entry) {
		buffer.append("<h2 id=parameters>EvoSuite Parameters</h2>\n");
		buffer.append("<div class=statistics><ul>\n");
		for (String key : Properties.getParameters()) {
			try {
				buffer.append("<li>" + key + ": " + Properties.getStringValue(key) + "\n"); // TODO
			} catch (NoSuchParameterException e) {
				logger.error(e.getMessage(),e);
			} catch (IllegalArgumentException e) {
				logger.error(e.getMessage(),e);
			} catch (IllegalAccessException e) {
				logger.error(e.getMessage(),e);
			}
		}
		buffer.append("</ul></div>\n");

	}

	/**
	 * Write some overall stats
	 * 
	 * @param buffer
	 *            a {@link java.lang.StringBuffer} object.
	 * @param entry
	 *            a {@link org.evosuite.utils.ReportGenerator.StatisticEntry}
	 *            object.
	 */
	protected void writeResultTable(StringBuffer buffer, StatisticEntry entry) {

		//buffer.append("<h2>Statistics</h2>\n");
		buffer.append("<ul>\n");

		buffer.append("<li>");
		buffer.append(entry.result_fitness_evaluations);
		buffer.append(" fitness evaluations, ");
		buffer.append(entry.age);
		buffer.append(" generations, ");
		buffer.append(entry.result_statements_executed);
		buffer.append(" statements, ");
		buffer.append(entry.result_tests_executed);
		buffer.append(" tests.\n");

		long duration_GA = (entry.end_time - entry.start_time) / 1000;
		long duration_MI = (entry.minimized_time - entry.end_time) / 1000;
		long duration_TO = (entry.minimized_time - entry.start_time) / 1000;

		buffer.append("<li>Time: "
		        + String.format("%d:%02d:%02d", duration_TO / 3600,
		                        (duration_TO % 3600) / 60, (duration_TO % 60)));

		buffer.append("(Search: "
		        + String.format("%d:%02d:%02d", duration_GA / 3600,
		                        (duration_GA % 3600) / 60, (duration_GA % 60)) + ", ");
		buffer.append("minimization: "
		        + String.format("%d:%02d:%02d", duration_MI / 3600,
		                        (duration_MI % 3600) / 60, (duration_MI % 60)) + ")\n");

		buffer.append("<li>Coverage: " + entry.covered_branches + "/"
		        + (2 * entry.total_branches) + " branches, ");
		buffer.append(entry.covered_methods + "/" + entry.total_methods + " methods, ");
		buffer.append(entry.covered_goals + "/" + entry.total_goals + " total goals\n");
		buffer.append("<li>Mutation score: "
		        + NumberFormat.getPercentInstance().format(entry.mutationScore) + "\n");

		buffer.append("</ul>\n");
	}

	/**
	 * The big table of results
	 * 
	 * @param buffer
	 *            a {@link java.lang.StringBuffer} object.
	 */
	protected void writeRunTable(StringBuffer buffer) {
		SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT_NOW);

		for (StatisticEntry entry : statistics) {
			buffer.append("<tr>");
			// buffer.append("<td>" + entry.id + "</td>");
			buffer.append("<td>");
			buffer.append(sdf.format(new Date(entry.start_time)));
			buffer.append("</td>");
			long duration_TO = (entry.minimized_time - entry.start_time) / 1000;
			buffer.append("<td>");
			buffer.append(String.format("%d:%02d:%02d", duration_TO / 3600,
			                            (duration_TO % 3600) / 60, (duration_TO % 60)));
			buffer.append("</td>");
			buffer.append("<td>");
			buffer.append(entry.getCoverage());
			buffer.append("</td>");
			buffer.append("<td><a href=\"html/");
			String filename = writeRunPage(entry);
			buffer.append(filename);
			buffer.append("\">");
			buffer.append(entry.className);
			// buffer.append("</a></td>");
			// buffer.append("<td><a href=\"");
			// buffer.append(entry.getCSVFileName());
			// buffer.append("\">CSV</a></td>");
			buffer.append("</tr>\n");
		}
		//  
		buffer.append("<!-- EVOSUITE INSERTION POINT -->\n");
		buffer.append("<tr class=\"top\"><td colspan=\"3\"> <td></tr>\n");
		buffer.append("</table>");
	}

	/**
	 * <p>
	 * writeCSV
	 * </p>
	 */
	public void writeCSV() {
		if (statistics.isEmpty())
			return;

		StatisticEntry entry = statistics.get(statistics.size() - 1);
		try {
			File f = new File(getReportDir().getAbsolutePath() + "/statistics.csv");
			logger.info("Writing CSV to "+f.getAbsolutePath());
			BufferedWriter out = new BufferedWriter(new FileWriter(f, true));
			if (f.length() == 0L) {
				out.write(entry.getCSVHeader() + "\n");
			}
			out.write(entry.getCSVData() + "\n");
			out.close();

		} catch (IOException e) {
			logger.warn("Error while writing statistics: " + e.getMessage());
		}

		if (Properties.SAVE_ALL_DATA) {
		    if (ArrayUtil.contains(Properties.CRITERION, Properties.Criterion.EXCEPTION)) {
				writeExceptionData(entry.getExceptionFilepath(),
				                   entry.implicitExceptions, entry.explicitExceptions);
			}
			writeCSVData(entry.getCSVFilepath(), entry.fitness_history,
			             entry.coverage_history, entry.size_history,
			             entry.length_history, entry.average_length_history,
			             entry.fitness_evaluations, entry.tests_executed,
			             entry.statements_executed, entry.timeStamps);
		}
	}

	/**
	 * <p>
	 * copyFile
	 * </p>
	 * 
	 * @param src
	 *            a {@link java.net.URL} object.
	 * @param dest
	 *            a {@link java.io.File} object.
	 */
	public static void copyFile(URL src, File dest) {
		try {
			InputStream in;
			in = src.openStream();
			OutputStream out = new FileOutputStream(dest);
			byte[] buf = new byte[1024];
			int len;
			while ((len = in.read(buf)) > 0) {
				out.write(buf, 0, len);
			}
			in.close();
			out.close();
		} catch (IOException e) {
			logger.error(e.getMessage(),e);
		}
	}

	/**
	 * <p>
	 * copyFile
	 * </p>
	 * 
	 * @param name
	 *            a {@link java.lang.String} object.
	 */
	public static void copyFile(String name) {
		URL systemResource = ClassLoader.getSystemResource("report/" + name);
		logger.debug("Copying from resource: " + systemResource);
		copyFile(systemResource, new File(getReportDir(), "files/" + name));
		copyFile(systemResource, new File(getReportDir().getAbsolutePath()
		        + "/html/files/" + name));
	}

	/**
	 * Write an HTML report
	 */
	public void writeReport() {
		if (!Properties.HTML)
			return;

		if (statistics.isEmpty())
			return;

		new File(getReportDir().getAbsolutePath() + "/img").mkdirs();
		new File(getReportDir().getAbsolutePath() + "/html/files/").mkdirs();
		new File(getReportDir().getAbsolutePath() + "/data/").mkdirs();
		new File(getReportDir().getAbsolutePath() + "/files/").mkdirs();

		copyFile("prettify.js");
		copyFile("prettify.css");
		copyFile("style.css");
		copyFile("foldButton.js");
		copyFile("foldButton.css");
		copyFile("jquery.js");
		copyFile("detected.png");
		copyFile("not_detected.png");
		copyFile("img01.jpg");
		copyFile("img02.jpg");
		copyFile("img03.jpg");
		copyFile("img04.png");
		copyFile("evosuite.png");
		File file = new File(getReportDir(), "report-generation.html");
		StringBuffer report = new StringBuffer();

		if (file.exists()) {
			List<String> lines = Utils.readFile(file);
			for (String line : lines) {
				if (line.contains("<!-- EVOSUITE INSERTION POINT -->")) {
					break;
				}
				report.append(line);
			}
		} else {

			writeHTMLHeader(report, Properties.PROJECT_PREFIX);
			report.append("<div id=\"header\"><div id=\"logo\">");
			/*
			if (!Properties.PROJECT_PREFIX.isEmpty()) {
				report.append("<h1 class=title>EvoSuite: " + Properties.PROJECT_PREFIX
				        + "</h1>\n");
			}
			*/
			report.append("</div><br></div>");
			try {
				report.append("Run on "
				        + java.net.InetAddress.getLocalHost().getHostName() + "\n");
			} catch (Exception e) {
			}

			report.append("<div id=\"page\"><div id=\"page-bgtop\"><div id=\"page-bgbtm\"><div id=\"content\">");
			report.append("<div id=\"post\">");
			report.append("<h2 class=\"title\">Test generation runs:</h2>\n");
			report.append("<div style=\"clear: both;\"> </div><div class=\"entry\">");
			report.append("<table cellspacing=0>"); // border=0 cellspacing=0 cellpadding=3>");
			report.append("<tr class=\"top bottom\">");
			// report.append("<td>Run</td>");
			report.append("<td>Date</td>");
			report.append("<td>Time</td>");
			report.append("<td>Coverage</td>");
			report.append("<td>Class</td>");
			// report.append("<td></td>");
			report.append("</tr>\n");
		}
		writeRunTable(report);
		report.append("</div></div></div></div></div></div>");

		writeHTMLFooter(report);

		Utils.writeFile(report.toString(), file);
	}

	/**
	 * <p>
	 * getCoveredLines
	 * </p>
	 * 
	 * @param trace
	 *            a {@link org.evosuite.testcase.ExecutionTrace} object.
	 * @param className
	 *            a {@link java.lang.String} object.
	 * @return a {@link java.util.Set} object.
	 */
	public Set<Integer> getCoveredLines(ExecutionTrace trace, String className) {
		return trace.getCoveredLines(className);
	}

	/**
	 * <p>
	 * executeTest
	 * </p>
	 * 
	 * @param testChromosome
	 *            a {@link org.evosuite.testcase.TestChromosome} object.
	 * @param className
	 *            a {@link java.lang.String} object.
	 * @return a {@link org.evosuite.testcase.ExecutionResult} object.
	 */
	public ExecutionResult executeTest(TestChromosome testChromosome, String className) {
		ExecutionResult result = testChromosome.getLastExecutionResult();

		if (result == null || testChromosome.isChanged()) {
			try {
				if (logger.isTraceEnabled()) {
					logger.trace(testChromosome.getTestCase().toCode());
				}
				TestCaseExecutor executor = TestCaseExecutor.getInstance();
				result = executor.execute(testChromosome.getTestCase());

			} catch (Exception e) {
				logger.error("TG: Exception caught: " + e.getMessage(), e);
				try {
					Thread.sleep(1000);
					result.setTrace(ExecutionTracer.getExecutionTracer().getTrace());
				} catch (Exception e1) {
					logger.error("Cannot set trace in test case with exception. Going to kill client",
					             e1);
					throw new Error(e1);
				}
			}
		}

		StatisticEntry entry = statistics.get(statistics.size() - 1);
		entry.results.put(testChromosome.getTestCase(),
		                  result.getCopyOfExceptionMapping());

		return result;
	}

	/**
	 * <p>
	 * minimized
	 * </p>
	 * 
	 * @param result
	 *            a {@link org.evosuite.ga.Chromosome} object.
	 */
	public abstract void minimized(Chromosome result);

	/**
	 * <p>
	 * makeDirs
	 * </p>
	 */
	protected void makeDirs() {
		getReportDir().mkdirs();
		if (Properties.SAVE_ALL_DATA)
			(new File(getReportDir().getAbsolutePath() + "/data")).mkdir();
		if (Properties.PLOT)
			(new File(getReportDir().getAbsolutePath() + "/img")).mkdir();
		if (Properties.HTML)
			(new File(getReportDir().getAbsolutePath() + "/html")).mkdir();
	}

	/** {@inheritDoc} */
	@Override
	public void searchStarted(GeneticAlgorithm<?> algorithm) {
		StatisticEntry entry = new StatisticEntry();
		entry.className = Properties.TARGET_CLASS;
		entry.id = getNumber(entry.className);

		entry.start_time = System.currentTimeMillis();
		entry.population_size = Properties.POPULATION;
		entry.chromosome_length = Properties.CHROMOSOME_LENGTH;
		entry.seed = Randomness.getSeed();
		statistics.add(entry);
	}

	/** {@inheritDoc} */
	@Override
	public void iteration(GeneticAlgorithm<?> algorithm) {
		StatisticEntry entry = statistics.get(statistics.size() - 1);
		Chromosome best = algorithm.getBestIndividual();
		entry.fitness_history.add(best.getFitness());
		entry.size_history.add(best.size());

		double average = 0.0;
		for (Chromosome individual : algorithm.getPopulation()) {
			average += individual.size();
		}

		entry.average_length_history.add(average / algorithm.getPopulation().size());

		// TODO: Need to get data of average size in here - how? Pass population
		// as parameter?
		entry.age++;
	}

	/** {@inheritDoc} */
	@Override
	public void fitnessEvaluation(Chromosome result) {
		StatisticEntry entry = statistics.get(statistics.size() - 1);
		entry.result_fitness_evaluations++;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.evosuite.ga.SearchListener#mutation(org.evosuite
	 * .ga.Chromosome)
	 */
	/** {@inheritDoc} */
	@Override
	public void modification(Chromosome individual) {
		// TODO Auto-generated method stub

	}
}