import org.apache.maven.api.annotations.ThreadSafe;

/**
 * A container for data that is specific to a session.
 * All components may use this storage to associate arbitrary data with a session.
 * <p>
 * Unlike a cache, this session data is not subject to purging. For this same reason, session data should also not be
 * abused as a cache (i.e. for storing values that can be re-calculated) to avoid memory exhaustion.

        while (trace != null) {
            Object data = trace.getData();
            if (data instanceof CollectStepData) {
                collectStepTrace = (CollectStepData) data;
            } else if (data instanceof ArtifactDescriptorRequest) {
                artifactDescriptorRequest = (ArtifactDescriptorRequest) data;
            } else if (data instanceof ArtifactRequest) {

/**
 * Instances of this interface retrieve and store data for the --resume / -r feature. This data is used to ensure newer
 * builds of the same project, that have the -r command-line flag, skip successfully built projects during earlier
 * invocations of Maven.
 */
public interface BuildResumptionDataRepository {
    /**

        return (T) computeIfAbsent(new GavCacheKey(groupId, artifactId, version, tag), data);
    }

    @Override
    @SuppressWarnings({"unchecked"})
    public <T> T computeIfAbsent(Source path, String tag, Supplier<T> data) {
        return (T) computeIfAbsent(new SourceCacheKey(path, tag), data);
    }

     */
    @Nonnull
    Map<ChecksumAlgorithm, String> calculate(@Nonnull byte[] data, @Nonnull Collection<ChecksumAlgorithm> algorithms);

    /**
     * Calculates checksums for specified data.
     *
     * @param data        The content for which to calculate checksums, must not be {@code null}.
     * @param algorithms  The checksum algorithms to use, must not be {@code null}.

        }
    }

    @Override
    public Map<ChecksumAlgorithm, String> calculate(byte[] data, Collection<ChecksumAlgorithm> algorithms) {
        nonNull(data, "data");
        nonNull(algorithms, "algorithms");
        try {
            return calculate(new ByteArrayInputStream(data), algorithms);
        } catch (IOException e) {
            throw new UncheckedIOException(e); // really unexpected
        }

        }
    }

    @Override
    public Map<ChecksumAlgorithm, String> calculate(byte[] data, Collection<ChecksumAlgorithm> algorithms) {
        nonNull(data, "data");
        nonNull(algorithms, "algorithms");
        try {
            return calculate(new ByteArrayInputStream(data), algorithms);
        } catch (IOException e) {
            throw new UncheckedIOException(e); // really unexpected
        }

 * identity of a model. The tag allows for further classification of the associated data on the sole discretion of the
 * model builder.
 *
 */
public interface ModelCache {

    <T> T computeIfAbsent(String groupId, String artifactId, String version, String tag, Supplier<T> data);

    <T> T computeIfAbsent(Source path, String tag, Supplier<T> data);

These stubs form an internally consistent data-set that is not expected to change. They are
used to test the individual components in the lifecycle with data that has expected characteristics
and can be asserted as desired.

You can change/extend these stubs, and tests should not be breaking too much, since most tests
assert using expected values from the stubs. Normally, when you try to use data from the stubs that

import org.apache.maven.api.services.ModelBuilderRequest;
import org.apache.maven.api.services.ModelProblemCollector;
import org.apache.maven.api.services.model.ModelBuildingEvent;

/**
 * Holds data relevant for a model building event.
 */
record DefaultModelBuildingEvent(
        Model model, Consumer<Model> update, ModelBuilderRequest request, ModelProblemCollector problems)