replicaCount = statusReplicas
	usageRatio := float64(usage) / (float64(targetAverageUsage) * float64(replicaCount))
	if math.Abs(1.0-usageRatio) > c.tolerance {
		// update number of replicas if change is large enough
		replicaCount = int32(math.Ceil(float64(usage) / float64(targetAverageUsage)))
	}
	usage = int64(math.Ceil(float64(usage) / float64(statusReplicas)))
	return replicaCount, usage, timestamp, nil
}

import static org.gradle.api.attributes.LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE
import static org.gradle.api.attributes.Usage.JAVA_API
import static org.gradle.api.attributes.Usage.JAVA_RUNTIME
import static org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE
import static org.gradle.api.attributes.java.TargetJvmEnvironment.STANDARD_JVM

        final Usage javaApi;
        final Usage javaRuntime;
        final Usage javaApiJars;
        final Usage javaRuntimeJars;

        final ImmutableSet<Usage> apiVariants;
        final ImmutableSet<Usage> runtimeVariants;

        @Inject
        public UsageDisambiguationRules(Usage javaApi,

        consumer                     | producer                     | compatible
        Usage.JAVA_API               | Usage.JAVA_API               | true
        Usage.JAVA_API               | Usage.JAVA_RUNTIME           | true

        Usage.JAVA_RUNTIME           | Usage.JAVA_API               | false
        Usage.JAVA_RUNTIME           | Usage.JAVA_RUNTIME           | true
    }

    private final MemoryUsage usage;
    private final long count;

    public GarbageCollectionEvent(long timestamp, MemoryUsage usage, long count) {
        this.timestamp = timestamp;
        this.usage = usage;
        this.count = count;
    }

    public long getTimestamp() {
        return timestamp;
    }

    public MemoryUsage getUsage() {
        return usage;
    }

    public long getCount() {

	evaluator := NewPersistentVolumeClaimEvaluator(nil)
	testCases := map[string]struct {
		pvc                        *core.PersistentVolumeClaim
		usage                      corev1.ResourceList
		enableRecoverFromExpansion bool
	}{
		"pvc-usage": {
			pvc: validClaim,
			usage: corev1.ResourceList{
				corev1.ResourceRequestsStorage:        resource.MustParse("10Gi"),
				corev1.ResourcePersistentVolumeClaims: resource.MustParse("1"),

		}
		expectedMetrics := getRawVolumeInfo()
		for _, usage := range expectedMetrics.Usage {
			if usage.Unit == csipbv1.VolumeUsage_BYTES {
				availableBytes := resource.NewQuantity(usage.Available, resource.BinarySI)
				totalBytes := resource.NewQuantity(usage.Total, resource.BinarySI)
				usedBytes := resource.NewQuantity(usage.Used, resource.BinarySI)
				if metrics.Available.Cmp(*availableBytes) != 0 {

                    name: 'api',
                    usage: objects.named(Usage, 'api'),
                    dependencies: configurations.implementation.allDependencies,
                    attributes: testAttributes))

            comp.usages.add(new TestUsage(
                    name: 'impl',
                    usage: objects.named(Usage, 'api'),

                        attributeProvider(Usage.USAGE_ATTRIBUTE, testProvider)
                    }
                }
            }
            """.stripIndent()

        expect:
        fails "outgoingVariants"
        failure.assertHasCause("Unexpected type for attribute 'org.gradle.usage' provided. Expected a value of type org.gradle.api.attributes.Usage but found a value of type java.lang.Integer.")
    }

        Configuration ipc = configurations.resolvableDependencyScopeUnlocked(names.withPrefix("cppCompile"));
        includePathConfiguration = ipc;
        includePathConfiguration.getAttributes().attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.class, Usage.C_PLUS_PLUS_API));
        includePathConfiguration.getAttributes().attribute(DEBUGGABLE_ATTRIBUTE, identity.isDebuggable());