}
            ImmutableList<ResourcePattern> artifactResources = artifactResourcesBuilder.build();

            String id = calculateId(MavenResolver.class, metadataResources, artifactResources, metadataSources, hasher -> {});

            return new MavenRepositoryDescriptor(
                id,
                checkNotNull(name),
                url,

            this.authenticationSchemes = ImmutableList.copyOf(authenticationSchemes);
            return self();
        }

        protected String calculateId(
            Class<? extends ExternalResourceResolver> implementation,
            List<ResourcePattern> metadataResources,
            List<ResourcePattern> artifactResources,
            List<String> metadataSources,

            ImmutableList<ResourcePattern> effectiveIvyResources = ivyResourcesBuilder.build();
            ImmutableList<ResourcePattern> effectiveArtifactResources = artifactResourcesBuilder.build();

            String id = calculateId(IvyResolver.class, effectiveIvyResources, effectiveArtifactResources, metadataSources, hasher -> hasher.putBoolean(m2Compatible));

            return new IvyRepositoryDescriptor(
                id,

    @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}.
     * @return The calculated checksums, indexed by algorithms, never {@code null}.

     */
    Try<T> getValue() throws IllegalStateException;

    /**
     * Returns true if this value is already calculated.
     * Note that some other thread may currently be calculating the value even if this method returns false.
     */
    boolean isFinalized();

    /**
     * Calculates the value, if not already calculated. Collects any exception and does not rethrow them.

        1 * fileSystemAccess.readRegularFileContentHash(file.absolutePath) >> Optional.empty()
        1 * calculator.calculate(file, false) >> 12
        0 * _

        when:
        result = cache.get(file)

        then:
        result == 12
        0 * _
    }

    def "reuses calculated value for file across cache instances"() {
        def file = new File("thing.txt")

        e.message == 'Value for <thing> has not been calculated yet.'

        when:
        container.getValue().get()

        then:
        def e2 = thrown(IllegalStateException)
        e2.message == 'Value for <thing> has not been calculated yet.'
    }

    def "at most one thread calculates the value"() {
        // Don't use a spock mock as these apply their own synchronization

    private final DisplayName displayName;
    // Null when the value has been calculated and assigned to the result field. When not null the result has not been calculated
    // or is currently being calculated or has just been calculated. It is possible for both this field and the result field to be
    // non-null at the same time for a brief period just after the result has been calculated
    @Nullable
    private volatile CalculationState<T, S> calculationState;

  MinMax calibration calculates the global min and global max values.

  global min = min of given sample inputs
  global max = max of given sample inputs
  """

  def get_min_max_value(self) -> tuple[float, float]:
    """Calculates the global min and max values.

    Returns:
      (min_value, max_value): Min and max calculated using MinMax
    """
    return (

     */
    void finalizeValue();

    /**
     * Requests that the final value of this object be calculated on the next read of the value, if not already known.
     *
     * <p>Changes to the value of this object or to the source for the value are still permitted until the final value is calculated, after which time attempts to make changes will fail with an exception.</p>
     *