- hostname: hostnameValue
    ip: ipValue
    nodeName: nodeNameValue
    targetRef:
      apiVersion: apiVersionValue
      fieldPath: fieldPathValue
      kind: kindValue
      name: nameValue
      namespace: namespaceValue
      resourceVersion: resourceVersionValue
      uid: uidValue
  notReadyAddresses:
  - hostname: hostnameValue
    ip: ipValue
    nodeName: nodeNameValue
    targetRef:

				}
				for j := 0; j < test.epPerService; j++ {
					nodeName := fmt.Sprintf("node-%d", j)
					if *eps[i].Endpoints[j].NodeName != nodeName {
						t.Errorf("Endpoint %d on EndpointSlice %d expected Nodename %s, got %s", j, i, nodeName, *eps[i].Endpoints[j].NodeName)
					}
				}
			}
		})
	}

}

	state, err := getStateData(cs)
	if err != nil {
		return framework.AsStatus(err)
	}
	// we don't need to hold the lock as only one node will be reserved for the given pod
	podVolumes, ok := state.podVolumesByNode[nodeName]
	if ok {
		allBound, err := pl.Binder.AssumePodVolumes(klog.FromContext(ctx), pod, nodeName, podVolumes)
		if err != nil {

        "subresource": "subresourceValue"
      }
    ]
  },
  "subsets": [
    {
      "addresses": [
        {
          "ip": "ipValue",
          "hostname": "hostnameValue",
          "nodeName": "nodeNameValue",
          "targetRef": {
            "kind": "kindValue",
            "namespace": "namespaceValue",
            "name": "nameValue",
            "uid": "uidValue",

  - hostname: hostnameValue
    ip: ipValue
    nodeName: nodeNameValue
    targetRef:
      apiVersion: apiVersionValue
      fieldPath: fieldPathValue
      kind: kindValue
      name: nameValue
      namespace: namespaceValue
      resourceVersion: resourceVersionValue
      uid: uidValue
  notReadyAddresses:
  - hostname: hostnameValue
    ip: ipValue
    nodeName: nodeNameValue
    targetRef:

			},

			Client:      client,
			Proxier:     &FakeProxier{},
			Broadcaster: broadcaster,
			Recorder:    recorder,
			NodeRef: &v1.ObjectReference{
				Kind:      "Node",
				Name:      nodeName,
				UID:       types.UID(nodeName),
				Namespace: "",
			},
		},
	}
}

func (hp *HollowProxy) Run() error {

	if err := hp.ProxyServer.Run(context.TODO()); err != nil {

	DynamicResources                = "DynamicResources"
	ImageLocality                   = "ImageLocality"
	InterPodAffinity                = "InterPodAffinity"
	NodeAffinity                    = "NodeAffinity"
	NodeName                        = "NodeName"
	NodePorts                       = "NodePorts"
	NodeResourcesBalancedAllocation = "NodeResourcesBalancedAllocation"
	NodeResourcesFit                = "NodeResourcesFit"

}

// NewActualStateOfWorld returns a new instance of ActualStateOfWorld.
func NewActualStateOfWorld(
	nodeName types.NodeName,
	volumePluginMgr *volume.VolumePluginMgr) ActualStateOfWorld {
	return &actualStateOfWorld{
		nodeName:                  nodeName,
		attachedVolumes:           make(map[v1.UniqueVolumeName]attachedVolume),

// or returns an error.
func NewKubeletServerCertificateManager(kubeClient clientset.Interface, kubeCfg *kubeletconfig.KubeletConfiguration, nodeName types.NodeName, getAddresses func() []v1.NodeAddress, certDirectory string) (certificate.Manager, error) {
	var clientsetFn certificate.ClientsetFunc
	if kubeClient != nil {

	UninstallCSIDriver(driverName string) error
}

// NewNodeInfoManager initializes nodeInfoManager
func NewNodeInfoManager(
	nodeName types.NodeName,
	volumeHost volume.VolumeHost,
	migratedPlugins map[string](func() bool)) Interface {
	return &nodeInfoManager{
		nodeName:        nodeName,
		volumeHost:      volumeHost,
		migratedPlugins: migratedPlugins,
	}
}