}
}

func TestMetricsNilGetCapacity(t *testing.T) {
	metrics := &MetricsNil{}
	actual, err := metrics.GetMetrics()
	expected := &Metrics{}
	if *actual != *expected {
		t.Errorf("Expected empty Metrics, actual %v", *actual)
	}
	if err == nil {
		t.Errorf("Expected error when calling GetMetrics, actual nil")
	}

    validations:
      required: true

  - type: textarea
    id: generics-proposal
    attributes:
      label: Is this about generics?
      description: If so, how does this relate to the accepted design and other generics proposals?
      placeholder: |
       Yes or No

       If yes, 
        1. how does this relate to the accepted design and other generics proposals?

    validations:
      required: true

				fakeCloser := fake.NewCloser(t)
				nodeClient.SetNodeVolumeStatsResp(getRawVolumeInfo())
				return nodeClient, fakeCloser, nil
			},
		}
		metrics, err := metricsGetter.GetMetrics()
		if err != nil {
			t.Fatalf("for %s: unexpected error : %v", tc.name, err)
		}
		if metrics == nil {
			t.Fatalf("unexpected nil metrics")
		}
		expectedMetrics := getRawVolumeInfo()

# because the checksumOk function was failing because modfetch.GoSumFile
# was not set when running outside of a module.

env GOTOOLCHAIN=local

		return
	}

	for _, podMetric := range podMetrics {
		for _, metric := range podMetric.GetMetrics() {
			promMetric, err := c.criMetricToProm(metric)
			if err == nil {
				ch <- promMetric
			}
		}
		for _, ctrMetric := range podMetric.GetContainerMetrics() {
			for _, metric := range ctrMetric.GetMetrics() {
				promMetric, err := c.criMetricToProm(metric)
				if err == nil {
					ch <- promMetric
				}

 * limitations under the License.
 */

package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;

/** Simple derived class to verify that we handle generics correctly. */
@GwtCompatible
class Derived extends Base {
  public Derived(String s) {
    super(s);
  }

  private static final long serialVersionUID = 0;

	result := rootFsInfoToFsStats(rootFsInfo)
	for i, metricsProvider := range metricsProviders {
		hostMetrics, err := metricsProvider.GetMetrics()
		if err != nil {
			return nil, fmt.Errorf("failed to get stats for item %d: %v", i, err)
		}
		usedBytes := uint64(hostMetrics.Used.Value())
		inodesUsed := uint64(hostMetrics.InodesUsed.Value())

	}
	return Reduce(s[1:], s[0], Min[Elem])
}

// Append adds values to the end of a slice, returning a new slice.
// This is like the predeclared append function; it's an example
// of how to write it using generics. We used to write code like
// this before append was added to the language, but we had to write
// a separate copy for each type.
func Append[T any](s []T, t ...T) []T {
	lens := len(s)
	tot := lens + len(t)

 * limitations under the License.
 */

package com.google.common.collect.testing;

import com.google.common.annotations.GwtCompatible;

/**
 * Simple derived class to verify that we handle generics correctly.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
public class DerivedComparable extends BaseComparable {
  public DerivedComparable(String s) {
    super(s);
  }

 * limitations under the License.
 */

package org.gradle.internal.typeconversion;

import org.gradle.internal.Cast;

/**
 * Type literal, useful for nested Generics.
 */
public class TypeInfo<T> {
    private final Class<T> targetType;

    public TypeInfo(Class<?> targetType) {
        assert targetType != null;
        this.targetType = Cast.uncheckedNonnullCast(targetType);