// license that can be found in the LICENSE file.

// Test escape analysis for hash/maphash.

package escape

import (
	"hash/maphash"
)

func f() {
	var x maphash.Hash // should be stack allocatable
	x.WriteString("foo")
	x.Sum64()

    controller: true
    kind: kindValue
    name: nameValue
    uid: uidValue
  resourceVersion: resourceVersionValue
  selfLink: selfLinkValue
  uid: uidValue
spec:
  drivers:
  - allocatable:
      count: 1
    name: nameValue
    nodeID: nodeIDValue
    topologyKeys:

      }
    ]
  },
  "spec": {
    "drivers": [
      {
        "name": "nameValue",
        "nodeID": "nodeIDValue",
        "topologyKeys": [
          "topologyKeysValue"
        ],
        "allocatable": {
          "count": 1
        }
      }
    ]
  }

    controller: true
    kind: kindValue
    name: nameValue
    uid: uidValue
  resourceVersion: resourceVersionValue
  selfLink: selfLinkValue
  uid: uidValue
spec:
  drivers:
  - allocatable:
      count: 1
    name: nameValue
    nodeID: nodeIDValue
    topologyKeys:

	resources := m.getNodeAllocatable()
	allocatableResource, ok := resources[v1.ResourceMemory]
	if !ok {
		klog.V(2).InfoS("Allocatable memory value could not be determined, not setting QoS memory limits")
		return
	}
	allocatable := allocatableResource.Value()
	if allocatable == 0 {
		klog.V(2).InfoS("Allocatable memory reported as 0, might be in standalone mode, not setting QoS memory limits")
		return
	}

			}

			allocation, createErr := controller.Allocate(tCtx, tc.model)
			if createErr != nil {
				if !tc.expectAllocateErr {
					tCtx.Fatalf("unexpected allocate error: %v", createErr)
				}
				return
			}
			if tc.expectAllocateErr {
				tCtx.Fatalf("did not get expected allocate error")
			}

			expectAllocation := []*resourceapi.NamedResourcesAllocationResult{}

      }
    ]
  },
  "spec": {
    "drivers": [
      {
        "name": "nameValue",
        "nodeID": "nodeIDValue",
        "topologyKeys": [
          "topologyKeysValue"
        ],
        "allocatable": {
          "count": 1
        }
      }
    ]
  }

      }
    ]
  },
  "spec": {
    "drivers": [
      {
        "name": "nameValue",
        "nodeID": "nodeIDValue",
        "topologyKeys": [
          "topologyKeysValue"
        ],
        "allocatable": {
          "count": 1
        }
      }
    ]
  }

	return nil
}

// Allocate attempts to reserve the provided IP. ErrNotInRange or
// ErrAllocated will be returned if the IP is not valid for this range
// or has already been reserved.  ErrFull will be returned if there
// are no addresses left.
// Only for testing, it will fail to create the IPAddress object because
// the Service reference is required.
func (a *Allocator) Allocate(ip net.IP) error {

	)
	// nodePortAllocationErrors counts the number of error trying to allocate a nodePort and allocation mode: static or dynamic.
	nodePortAllocationErrors = metrics.NewCounterVec(
		&metrics.CounterOpts{
			Namespace:      namespace,
			Subsystem:      subsystem,
			Name:           "allocation_errors_total",
			Help:           "Number of errors trying to allocate NodePort",
			StabilityLevel: metrics.ALPHA,
		},
		[]string{"scope"},