}

			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{}

	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
	}

	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 {

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

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

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

				TopologyKeys: []string{"company.com/zone1", "company.com/zone2"},
				Allocatable:  &storage.VolumeNodeResources{Count: utilpointer.Int32(20)},
			}, {
				Name:         "io.kubernetes.storage.csi.driver-3",
				NodeID:       nodeID,
				TopologyKeys: []string{"company.com/zone1", "company.com/zone2"},
				Allocatable:  &storage.VolumeNodeResources{Count: utilpointer.Int32(30)},
			}},
		},
	}, {

			return false, nil
		}
		allocator.ipAddressSynced = func() bool { return true }
		return allocator.ready.Load(), nil
	})
	if err != nil {
		t.Fatal(err)
	}
	// allocate one IP from the new allocator
	err = r.Allocate(netutils.ParseIPSloppy("10.0.0.11"))
	if err != nil {
		t.Fatalf("error allocating IP 10.0.0.11 from new allocator: %v", err)
	}
	count++
	for r.Free() > 0 {
		ip, err := r.AllocateNext()

//go:nosplit
func osyield_no_g() {
	osyield()
}

type sigset struct{}

// Called to initialize a new m (including the bootstrap m).
// Called on the parent thread (main thread in case of bootstrap), can allocate memory.
func mpreinit(mp *m) {
	mp.gsignal = malg(32 * 1024)
	mp.gsignal.m = mp
}

//go:nosplit
func usleep_no_g(usec uint32) {
	usleep(usec)
}

//go:nosplit
func sigsave(p *sigset) {
}

  static TFRTypeStorage* construct(TypeStorageAllocator& allocator, KeyTy key) {
    // Allocate a new storage instance.
    auto byteSize = TFRTypeStorage::totalSizeToAlloc<StringAttr>(key.size());
    auto rawMem = allocator.allocate(byteSize, alignof(TFRTypeStorage));
    auto result = ::new (rawMem) TFRTypeStorage(key.size());