capacity := int64(statfs.Blocks) * int64(statfs.Bsize)

	// Usage is block being used * fragment size (aka block size).
	usage := (int64(statfs.Blocks) - int64(statfs.Bfree)) * int64(statfs.Bsize)

	inodes := int64(statfs.Files)
	inodesFree := int64(statfs.Ffree)
	inodesUsed := inodes - inodesFree

	return available, capacity, usage, inodes, inodesFree, inodesUsed, nil
}

    // Parse known flags
    string usage = tensorflow::Flags::Usage(
        absl::StrCat(*argv[0], " Op1 [Op2 ...]"), flags);
    QCHECK(tensorflow::Flags::Parse(argc, *argv, flags)) << usage;  // Crash OK

    // Initialize any TensorFlow support, parsing boilerplate flags (e.g. logs)
    tensorflow::port::InitMain(usage.c_str(), argc, argv);

    // Validate flags
    if (help_) {

    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());

                extendsFrom(configurations.implementation)
                attributes {
                    // This is what AGP 7 will most likely do:
                    attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_API))
                    attribute(TargetJvmEnvironment.TARGET_JVM_ENVIRONMENT_ATTRIBUTE, objects.named(TargetJvmEnvironment, TargetJvmEnvironment.ANDROID))
                }
            }

     *
     * Does <strong>NOT</strong> check anything to do with deprecated usage.
     *
     * @param conf the existing configuration
     * @return the existing configuration, with its usage now matching the requested usage
     * @throws UnmodifiableUsageException if the usage doesn't match this request and cannot be mutated
     */
    Configuration verifyExistingConfigurationUsage(Configuration conf);

    /**