// resourceAllocationScorer contains information to calculate resource allocation score.
type resourceAllocationScorer struct {
	Name string
	// used to decide whether to use Requested or NonZeroRequested for
	// cpu and memory.
	useRequested bool
	scorer       func(requested, allocable []int64) int64
	resources    []config.ResourceSpec
}

// score will use `scorer` function to calculate the score.
func (r *resourceAllocationScorer) score(

 */
public interface TaskDependencyContainer {
    TaskDependencyContainer EMPTY = context -> {
    };

    /**
     * Adds the dependencies from this container to the given context. Failures to calculate the build dependencies should be supplied to the context rather than thrown.
     */
    void visitDependencies(TaskDependencyResolveContext context);

               .assertHasCause("Could not resolve all dependencies for configuration ':compileClasspath'.")
               .assertHasCause("Failed to calculate the value of task ':compileJava' property 'javaCompiler'.")

                .runWithFailure()

        then:
        failure.assertHasDescription("Could not determine the dependencies of task ':compileJava'.")
               .assertHasCause("Failed to calculate the value of task ':compileJava' property 'javaCompiler'.")

 * to substitute the closed gradle projects in the eclipse workspace.
 *
 * This is a parameterized model and requires an {@link EclipseRuntime} parameter to calculate the
 * closed projects.
 *
 * @since 5.6
 */
public interface RunClosedProjectBuildDependencies {

     */
    <V> FileContentCache<V> newCache(String name, int normalizedCacheSize, Calculator<? extends V> calculator, Serializer<V> serializer);

    interface Calculator<V> {
        V calculate(File file, boolean isRegularFile);
    }

			trace := utiltrace.New(fmt.Sprintf("Calculate volume metrics of %v for pod %v/%v", name, s.pod.Namespace, s.pod.Name))
			defer trace.LogIfLong(1 * time.Second)
			return v.GetMetrics()
		}()
		if err != nil {
			// Expected for Volumes that don't support Metrics
			if !volume.IsNotSupported(err) {

	mockStats.EXPECT().ListBlockVolumesForPod(fakePod.UID).Return(blockVolumes, true)

	eventStore := make(chan string, 1)
	fakeEventRecorder := record.FakeRecorder{
		Events: eventStore,
	}

	// Calculate stats for pod
	statsCalculator := newVolumeStatCalculator(mockStats, time.Minute, fakePod, &fakeEventRecorder)
	statsCalculator.calcAndStoreStats()
	vs, _ := statsCalculator.GetLatest()

 * limitations under the License.
 */

package org.gradle.performance.measure

import spock.lang.Specification

class DataSeriesTest extends Specification {
    def "can calculate statistics for samples"() {
        def v1 = DataAmount.kbytes(10)
        def v2 = DataAmount.kbytes(20)
        def v3 = DataAmount.kbytes(30)
        def series = new DataSeries([v1, v2, v3])

        expect:

/**
 * Responsible for preparing the work graph for the build tree.
 */
public interface BuildTreeWorkPreparer {
    /**
     * Prepares the given work graph for execution. May configure the build model and calculate the task graph from this, or may load a cached task graph if available.
     */
    BuildTreeWorkGraph.FinalizedGraph scheduleRequestedTasks(BuildTreeWorkGraph graph, @Nullable EntryTaskSelector selector);