}

	for _, usage := range usages {
		if usage == nil {
			continue
		}
		unit := usage.GetUnit()
		switch unit {
		case csipbv1.VolumeUsage_BYTES:
			metrics.Available = resource.NewQuantity(usage.GetAvailable(), resource.BinarySI)
			metrics.Capacity = resource.NewQuantity(usage.GetTotal(), resource.BinarySI)
			metrics.Used = resource.NewQuantity(usage.GetUsed(), resource.BinarySI)

        }
    }
}

/**
 * Registers services which are not covered by [FirStandaloneServiceRegistrar]. In general, this concerns services which need to be
 * registered for production Standalone and Standalone test usages, but *not* for IDE mode Analysis API tests, which rely on
 * [FirStandaloneServiceRegistrar] as a basis.
 *

  let summary = "Removes `stablehlo.custom_call @Sharding`";
  let description = [{
    Finds `stablehlo.custom_call @Sharding` and removes all instances of them,
    replacing the usages by its operand. This is used where sharding doesn't
    make much sense or sharding custom calls are incompatible, e.g. on-device
    targets.
  }];
  let dependentDialects = ["mlir::stablehlo::StablehloDialect"];
}

    //  We cannot use this syntax until adopting JSpecify with e.g. Jetbrains Annotations, because IDEA wrongly treats all usages as having a nullable type, even when
    //  it is explicitly spelled.

    private final DisplayName displayName;

    //  We cannot use this syntax until adopting JSpecify with e.g. Jetbrains Annotations, because IDEA wrongly treats all Try usages as having a nullable type, even when
    //  it is explicitly spelled, e.g.
    //  Try<String> t = Try.successful("some")

```

To make old plugins compatible we need to replace all the usages of old JavaCompile with the new one.

Let’s say it’s used in a plugin as:

```java
public void applyPlugin(Project project) {
     project.tasks.named("compileJava", JavaCompile.class, task -> {
         task.setSourceCompatibility("1.8");
     });
}
```

We will then replace all such usages with interception code:
```java

							BindPort:         6443,
						},
						BootstrapTokens: []bootstraptokenv1.BootstrapToken{
							{
								Token:  &bootstraptokenv1.BootstrapTokenString{ID: "abcdef", Secret: "0123456789abcdef"},
								Usages: []string{"signing", "authentication"},
								TTL: &metav1.Duration{
									Duration: bootstraptokenv1.DefaultTokenDuration,
								},
								Groups: []string{"system:bootstrappers:kubeadm:default-node-token"},

 * com.google.common.collect.Ordering} (otherwise).
 *
 * <h3>Relationship to {@code Ordering}</h3>
 *
 * <p>In light of the significant enhancements to {@code Comparator} in Java 8, the overwhelming
 * majority of usages of {@code Ordering} can be written using only built-in JDK APIs. This class is
 * intended to "fill the gap" and provide those features of {@code Ordering} not already provided by
 * the JDK.
 *
 * @since 21.0

				},
			},
		},
		leaf: leafSpec{
			sans: []string{"dns:example.com"},
			ekus: []string{"serverAuth"},
		},
		expectedError: "incompatible key usage",
	},

	// #67: SGC key usages used to permit serverAuth and clientAuth,
	// but don't anymore.
	{
		roots: []constraintsSpec{
			{},
		},
		intermediates: [][]constraintsSpec{
			{
				{

                )
            )""".trimIndent()
        parse(code).assert(expected)
    }

    @Test
    fun `rejects annotation usages`() {
        val code = """
            @A val x = 1
            @A b { }
            b(@A x)
            b { @A f() }
        """.trimIndent()
        val expected = """
            ErroneousStatement (