sum += event.getUsage().getUsed();
        }
        return sum / events.size();
    }

    private static long findMaxSize(Collection<GarbageCollectionEvent> events) {
        // Maximum pool size is fixed, so we should only need to get it from the first event
        GarbageCollectionEvent first = events.iterator().next();
        return first.getUsage().getMax();
    }

        this.timestamp = timestamp;
        this.usage = usage;
        this.count = count;
    }

    public long getTimestamp() {
        return timestamp;
    }

    public MemoryUsage getUsage() {
        return usage;
    }

    public long getCount() {
        return count;
    }

/**
 * This is a legacy type and should be avoided if possible. Use {@link SoftwareComponentVariant} instead.
 */
public interface UsageContext extends SoftwareComponentVariant {
    @Deprecated
    default Usage getUsage(){
        // This method kept for backwards compatibility of plugins (like kotlin-multiplatform) using internal APIs.
        // KMP has recently stopped using this method, so we should be able to remove it

                if (memoryPoolMXBean.getType() == MemoryType.NON_HEAP && poolName.equals(nonHeapMemoryPool)) {
                    nonHeapEvents.slideAndInsert(new GarbageCollectionEvent(clock.getCurrentTime(), memoryPoolMXBean.getUsage(), -1));
                }
            }
        } catch (Throwable t) {
            // this class is used as task in a scheduled executor service, so it must not throw any throwable,

		VolumeId:   volID,
		VolumePath: targetPath,
	}

	resp, err := nodeClient.NodeGetVolumeStats(ctx, req)
	if err != nil {
		return nil, err
	}
	usages := resp.GetUsage()
	if usages == nil {
		return nil, fmt.Errorf("failed to get usage from response. usage is nil")
	}
	metrics := &volume.Metrics{
		Used:       resource.NewQuantity(int64(0), resource.BinarySI),

		VolumePath: targetPath,
	}

	c.nodeClient.SetNodeVolumeStatsResp(getRawVolumeInfo())
	resp, err := c.nodeClient.NodeGetVolumeStats(ctx, req)
	if err != nil {
		return nil, err
	}

	usages := resp.GetUsage()
	if usages == nil {
		return nil, nil
	}

	metrics := &volume.Metrics{}

	isSupportNodeVolumeCondition, err := c.nodeSupportsVolumeCondition(ctx)
	if err != nil {
		return nil, err
	}

	variant := ""
	if e.meshConfig.GetDefaultConfig().GetImage().GetImageType() != "" {
		variant = e.meshConfig.GetDefaultConfig().GetImage().GetImageType()
	}
	if e.root.GetImage().GetImageType() != "" {
		variant = e.root.GetImage().GetImageType()
	}
	if v, ok := e.namespace[pod.Metadata.FullName.Namespace.String()]; ok {
		if v.GetImage().GetImageType() != "" {
			variant = v.GetImage().GetImageType()
		}
	}

}

func diffCPUTimeRUsage(f func()) (user, system time.Duration) {
	ok := true
	var before, after syscall.Rusage

	err := syscall.Getrusage(syscall.RUSAGE_SELF, &before)
	if err != nil {
		ok = false
	}

	f()

	err = syscall.Getrusage(syscall.RUSAGE_SELF, &after)
	if err != nil {
		ok = false
	}

	if !ok {
		return 0, 0
	}

     */
    String getId();

    /**
     * The stage of this compile operation.
     * This is exposed by {@link org.gradle.internal.scripts.CompileScriptBuildOperationType.Details#getStage()}.
     * */
    String getStage();

    Transformer getTransformer();

    /**
     * The data extracted from the script. Note that this method may be called without the transformer ever being invoked, in this case of an empty script.

    }

    def "detects variants with the same name"() {
        def child1 = Stub(TestComponent) {
            getUsages() >> [
                Stub(UsageContext) {
                    getName() >> "foo"
                }
            ]
        }
        def child2 = Stub(TestComponent) {
            getUsages() >> [
                Stub(UsageContext) {
                    getName() >> "foo"
                }