and:
        interaction {
            snapshotRegularFile(file)
        }
        1 * calculator.calculate(file, true) >> 12
        0 * _

        when:
        result = cache.get(file)

        then:
        result == 12
        0 * _
    }

    def "calculates entry value for directory when not seen before and reuses result"() {
        def file = new File("thing.txt")

     * Returns the value, failing if it has not been calculated.
     * Does not calculate the value on demand and does not block if the value is currently being calculated.
     *
     * <p>Rethrows any exception that happened while calculating the value</p>
     */
    T get() throws IllegalStateException;

    /**
     * Returns the result of calculating the value, failing if it has not been calculated.

  EXPECT_FLOAT_EQ(bin_width, 0.125);
  int32_t actual_num_bins =
      CalculateActualNumBins(/*min_value=*/0.0, /*max_value=*/25.0, bin_width);
  EXPECT_EQ(actual_num_bins, 200);

  // Calculate the bin width with the actual num bins.
  float raw_bin_width = 25.0 / actual_num_bins;
  EXPECT_FLOAT_EQ(bin_width, raw_bin_width);
}

TEST(CalibrationParametersTest, CalculateBinWidthLargerThanOne) {

        }
    }

    @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) {

        treeTaskGraphOps[0].displayName == "Calculate build tree task graph"
        treeTaskGraphOps[0].parentId == buildSrcOps[0].id
        treeTaskGraphOps[1].displayName == "Calculate build tree task graph"
        treeTaskGraphOps[1].parentId == root.id

        def taskGraphOps = ops.all(CalculateTaskGraphBuildOperationType)
        taskGraphOps.size() == 2
        taskGraphOps[0].displayName == "Calculate task graph (:buildSrc)"

        then:
        executed ":jar", ":lib", ":child:jar", ":child:lib", ":useCompileConfiguration"

        where:
        fluid << [true, false]
    }

    def "reports failure to calculate build dependencies when artifact build dependencies cannot be queried - fluid: #fluid"() {
        makeFluid(fluid)
        buildFile << """
            dependencies {
                compile project(':child')

			inputBytes += len(k) + len(v)
		}

		// Calculate node name
		nodeName := r.Host
		if globalIsDistErasure {
			nodeName = globalLocalNodeName
		}
		if host, port, err := net.SplitHostPort(nodeName); err == nil {
			if port == "443" || port == "80" {
				nodeName = host
			}
		}

		// Calculate reqPath
		reqPath := r.URL.RawPath
		if reqPath == "" {
			reqPath = r.URL.Path

	line2InColor := fmt.Sprintf(msgLine2Fmt, color.CyanBold(updateString))

	// calculate the rectangular box size.
	maxContentWidth := max(line1Length, line2Length)

	// termWidth is set to a default one to use when we are
	// not able to calculate terminal width via OS syscalls
	termWidth := 25
	if width, err := pb.GetTerminalWidth(); err == nil {
		termWidth = width
	}

 *
 * <ul>
 * <li>Create isolated instances from that state to pass to user code, see {@link Isolatable} for more details.</li>
 * <li>Calculate a hash of the state. If you only need to calculate hashes of object graphs, then consider using {@link org.gradle.internal.snapshot.ValueSnapshotter} instead,
 * as that does the same thing but more efficiently.</li>
 * </ul>
 *

     * Returns a copy of the filter spec for the Gradle API Classloader.  This is expensive to calculate, so we create it once in
     * the build process and provide it to the worker.
     */
    FilteringClassLoader.Spec getGradleApiFilterSpec();

    /**
     * Returns the extension classloader spec for use in worker processes.  This is expensive to calculate, so we create it once in
     * the build process and provide it to the worker.
     */