com.teamscale.service.testimpact.prioritization.PrioritizableTestBase Maven / Gradle / Ivy

Go to download
package com.teamscale.service.testimpact.prioritization;

import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

import org.checkerframework.checker.nullness.qual.Nullable;
import org.conqat.lib.commons.js_export.ExportToTypeScript;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.google.common.collect.Sets;
import com.teamscale.index.testimpact.MethodId;

/**
 * Base class for test and test clusters. It holds common static info like
 * duration and the covered methods, but also dynamic content such as the
 * current score needed for the prioritization and the additional covered
 * methods. Additional means relative to the tests that have already been
 * selected in the current prioritization round.
 */
@ExportToTypeScript
public abstract class PrioritizableTestBase implements IPrioritizableTests {

	/**
	 * Covered method that represent additional coverage in the current
	 * prioritization round. This is a mapping from all methods that are both
	 * covered by the current test and should be tested because they changed in the
	 * given timeframe. The value is true when the method has not been executed by
	 * any other test in the current prioritization round and can therefore be
	 * treated as additionally covered.
	 * 
	 * The value is initialized with {@link #initAdditionallyCoveredMethods(Set)},
	 * values are set to false when new tests are selected via
	 * {@link IPrioritizableTests#removeFromCurrentAdditionallyCoveredMethods(Collection)}
	 * and finally reset after every round with
	 * {@link #resetCurrentAdditionallyCoveredMethods()}.
	 */
	@JsonIgnore
	protected final Set coveredChangedMethods = new HashSet<>();

	/**
	 * The number of additionally covered methods that are not yet covered in the
	 * current round. This matches the number of entries with value
	 * true in {@link #coveredChangedMethods}.
	 */
	@JsonIgnore
	private int currentAdditionallyCoveredMethodsCount = 0;

	/**
	 * The {@link MethodId}s covered by the test or set of tests.
	 */
	@JsonIgnore
	protected Set coveredMethods = null;

	/** Duration in ms. May be null if not set. */
	@JsonProperty("durationInMs")
	@Nullable
	protected Long durationInMs = null;

	/**
	 * Field for tracking {@link IPrioritizableTests#getCurrentScore()}.
	 */
	@JsonProperty("currentScore")
	private double currentScore;

	@JsonProperty("additionallyCoveredMethodCount")
	private int numberOfAdditionallyCoveredMethods = 0;

	/**
	 * Field for storing the tests rank. The rank is the 1-based index of the test
	 * in the prioritized list.
	 */
	@JsonProperty("rank")
	private Integer rank;

	@JsonIgnore
	private Set changedMethodLocations = Collections.emptySet();

	public PrioritizableTestBase() {
	}

	public PrioritizableTestBase(Set changedMethodLocations) {
		this.changedMethodLocations = changedMethodLocations;
	}

	/**
	 * Sets the methods that we are interested in testing e.g. because they changed
	 * in the given timeframe.
	 */
	@Override
	public void initAdditionallyCoveredMethods(Set methodsToTest) {
		Sets.SetView intersection = Sets.intersection(getCoveredMethods(), methodsToTest);
		coveredChangedMethods.addAll(intersection);
		currentAdditionallyCoveredMethodsCount = coveredChangedMethods.size();
	}

	@Override
	public void resetCurrentAdditionallyCoveredMethods() {
		currentAdditionallyCoveredMethodsCount = coveredChangedMethods.size();
	}

	@Override
	public void removeFromCurrentAdditionallyCoveredMethods(Collection methodsToRemove) {
		for (MethodId methodId : methodsToRemove) {
			if (coveredChangedMethods.contains(methodId)) {
				currentAdditionallyCoveredMethodsCount--;
			}
		}
	}

	@Override
	public long getNumberOfCoveredMethods() {
		return getCoveredMethods().size();
	}

	@Override
	public long getNumberOfCurrentAdditionallyCoveredMethods() {
		return currentAdditionallyCoveredMethodsCount;
	}

	@Override
	public Set getCoveredChangedMethods() {
		return coveredChangedMethods;
	}

	@Override
	public void setCurrentScore(double currentScore) {
		this.currentScore = currentScore;
	}

	public Integer getRank() {
		return rank;
	}

	@Override
	public void setRank(int rank) {
		this.rank = rank;
	}

	@Override
	public double getCurrentScore() {
		return currentScore;
	}

	@Override
	public Set getChangedMethodLocations() {
		return changedMethodLocations;
	}

	@Override
	public void incrementNumberOfAdditionallyCoveredMethods() {
		numberOfAdditionallyCoveredMethods++;
	}
}