this.exception = exception;
    }

    @Override
    public String getSource() {
        return source;
    }

    @Override
    public int getLineNumber() {
        return lineNumber;
    }

    @Override
    public int getColumnNumber() {
        return columnNumber;
    }

    @Override
    public String getLocation() {

data class PerformanceTestCoverage(
    private val uuid: Int,
    override val type: PerformanceTestType,
    override val os: Os,
    override val arch: Arch = Arch.AMD64,
    val numberOfBuckets: Int = 40,
    private val oldUuid: String? = null,
    override val failsStage: Boolean = true,
) : PerformanceTestBuildSpec,
    PerformanceTestProjectSpec {
    override fun asConfigurationId(
        model: CIBuildModel,

    private String globalChecksumPolicy;

    @Inject
    private Map<String, ArtifactRepositoryLayout> repositoryLayouts;

    @Override
    public ArtifactRepositoryLayout getLayout(String layoutId) throws UnknownRepositoryLayoutException {
        return repositoryLayouts.get(layoutId);
    }

    @Override
    public ArtifactRepository createDeploymentArtifactRepository(

            @Override
            public String get(String key) {
                // Override to return empty string instead of null to avoid NullPointerException
                return "";
            }

            @Override
            public String getIndexFieldTitle() {
                return "title";
            }

            @Override
            public String getIndexFieldContent() {

  protected ForwardingNavigableSet() {}

  @Override
  protected abstract NavigableSet<E> delegate();

  @Override
  public @Nullable E lower(@ParametricNullness E e) {
    return delegate().lower(e);
  }

  /**
   * A sensible definition of {@link #lower} in terms of the {@code descendingIterator} method of
   * {@link #headSet(Object, boolean)}. If you override {@link #headSet(Object, boolean)}, you may

            }
            return list;
        }

        @Override
        public void add(int index, V element) {
            asList().add(index, element);
        }

        @Override
        public V remove(int index) {
            return asList().remove(index);
        }

        @Override
        public V get(int index) {
            return asList().get(index);

  public ForwardingSetMultimap() {}

  @Override
  protected abstract SetMultimap<K, V> delegate();

  @Override
  public Set<Entry<K, V>> entries() {
    return delegate().entries();
  }

  @Override
  public Set<V> get(@ParametricNullness K key) {
    return delegate().get(key);
  }

  @CanIgnoreReturnValue
  @Override
  public Set<V> removeAll(@Nullable Object key) {

  @Override
  @SuppressWarnings("unchecked")
  public final Entry<AnEnum, String>[] createArray(int length) {
    return (Entry<AnEnum, String>[]) new Entry<?, ?>[length];
  }

  @Override
  public final AnEnum[] createKeyArray(int length) {
    return new AnEnum[length];
  }

  @Override
  public final String[] createValueArray(int length) {

  public boolean contains(@Nullable Object element) {
    return count(element) > 0;
  }

  // Modification Operations
  @CanIgnoreReturnValue
  @Override
  public final boolean add(@ParametricNullness E element) {
    add(element, 1);
    return true;
  }

  @CanIgnoreReturnValue
  @Override
  public int add(@ParametricNullness E element, int occurrences) {
    throw new UnsupportedOperationException();
  }

    }

    @Override
    public void debug(Throwable error) {
        logger.debug("", error);
    }

    @Override
    public void info(CharSequence content) {
        logger.info(toString(content));
    }

    @Override
    public void info(CharSequence content, Throwable error) {
        logger.info(toString(content), error);
    }

    @Override
    public void info(Throwable error) {