//
// * The cloudproviders have the own names: GCE has InstanceName, AWS has InstanceId.
//
//	For GCE, InstanceName is the Name of an Instance object in the GCE API.  On GCE, Instance.Name becomes the
//	Hostname, and thus it makes sense also to use it as the Node.Name.  But that is GCE specific, and it is up
//	to the cloudprovider how to do this mapping.
//
//	For AWS, the InstanceID is not yet suitable for use as a Node.Name, so we actually use the

		// if overflow, set it to max int64
		if maxConnAge < 0 {
			maxConnAge = time.Duration(math.MaxInt64)
		}
	}
	c := &Controller{
		instanceID:       instanceID,
		store:            store,
		cleanupLimit:     rate.NewLimiter(rate.Limit(20), 1),
		cleanupQueue:     queue.NewDelayed(),
		adsConnections:   newAdsConnections(),
		maxConnectionAge: maxConnAge,
	}
	c.queue = controllers.NewQueue("unregister_workloadentry",

	// Simulate a machine with 1 core and 3.75GB of memory.
	// We set it to non-zero values to make non-zero-capacity machines in Kubemark.
	return &cadvisorapi.MachineInfo{
		NumCores:       fakeNumCores,
		InstanceID:     cadvisorapi.InstanceID(c.NodeName),
		MemoryCapacity: fakeMemoryCapacity,
	}, nil
}

// VersionInfo is a fake implementation of Interface.VersionInfo.
func (c *Fake) VersionInfo() (*cadvisorapi.VersionInfo, error) {

    }

    private LenientPlatformGraphResolveState(long instanceId, LenientPlatformResolveMetadata metadata, ComponentIdGenerator componentIdGenerator, ResolveState resolveState) {
        super(instanceId, metadata, metadata, resolveState.getAttributeDesugaring(), componentIdGenerator);
        this.componentIdGenerator = componentIdGenerator;

              },
              {
                "instanceId": "VisualStudio.14.0",
                "installationPath": "${TextUtil.escapeString(localRoot.absolutePath)}/Program Files/Microsoft Visual Studio 14.0/",
                "installationVersion": "14.0"
              },
              {
                "instanceId": "VisualStudio.12.0",

		if _, exists := rdev[resourceName]; !exists {
			continue
		}
		filtered[resourceName] = DeviceInstances{}
		for instanceID, instance := range rdev[resourceName] {
			if filterIDs.Has(instanceID) {
				filtered[resourceName][instanceID] = instance
			}
		}
	}
	return filtered

        _ * componentMetadata.moduleVersionId >> DefaultModuleVersionIdentifier.newId(DefaultModuleIdentifier.newId(org, name), ver)

        def componentState = Stub(ComponentGraphResolveState)
        _ * componentState.instanceId >> componentId
        _ * componentState.id >> DefaultModuleComponentIdentifier.newId(DefaultModuleIdentifier.newId(org, name), ver)
        _ * componentState.metadata >> componentMetadata

		if err != nil {
			log.Warnf("unable to retrieve instance labels: %v", err)
			success <- false
			return

		}
		defer resp.Body.Close()
		instance := &GcpInstance{}
		if err := json.NewDecoder(resp.Body).Decode(instance); err != nil {
			log.Warnf("failed to decode response: %v", err)
			success <- false
			return
		}
		instanceLabels = instance.Labels
		success <- true
	}()
	select {

	sort.Stable(out)
	return out
}

// Copy this Instances array.
func (i Instances) Copy() Instances {
	return append(Instances{}, i...)
}

// Append returns a new Instances array with the given values appended.
func (i Instances) Append(instances Instances) Instances {
	return append(i.Copy(), instances...)
}

// Restart each Instance
func (i Instances) Restart() error {
	g := multierror.Group{}

}

//sys	setupDiGetDeviceInstanceId(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, instanceId *uint16, instanceIdSize uint32, instanceIdRequiredSize *uint32) (err error) = setupapi.SetupDiGetDeviceInstanceIdW

// SetupDiGetDeviceInstanceId function retrieves the instance ID of the device.
func SetupDiGetDeviceInstanceId(deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (string, error) {