}
	defer out.Close()

	// Try fallocate first.
	for {
		err = out.fallocate(1 << 10)
		if errors.Is(err, errors.ErrUnsupported) || err == errNoFallocate { // The underlying file system may not support fallocate
			t.Skip("fallocate is not supported")
		}
		if err == syscall.EINTR {
			continue // try again
		}
		if err != nil {
			t.Fatalf("fallocate failed: %v", err)
		}
		break
	}

				continue TestCase
			}
			cidrs = append(cidrs, cidr)
		}
		// No allocated CIDR range should intersect with serviceCIDR.
		for _, c := range cidrs {
			if c.Contains(serviceCIDR.IP) || serviceCIDR.Contains(c.IP) {
				t.Errorf("test case %+v: allocated CIDR %v from service range", tc, c)
			}
		}
	}

// DefaultServiceNodePortRange is the default port range for NodePort services.
var DefaultServiceNodePortRange = utilnet.PortRange{Base: 30000, Size: 2768}

// DefaultServiceIPCIDR is a CIDR notation of IP range from which to allocate service cluster IPs
var DefaultServiceIPCIDR = net.IPNet{IP: netutils.ParseIPSloppy("10.0.0.0"), Mask: net.CIDRMask(24, 32)}

// DefaultEtcdPathPrefix is the default key prefix of etcd for API Server

	}
	return c.allocN(npages)
}

// allocN is a helper which attempts to allocate npages worth of pages
// from the cache. It represents the general case for allocating from
// the page cache.
//
// Returns a base address and the amount of scavenged memory in the
// allocated region in bytes.
func (c *pageCache) allocN(npages uintptr) (uintptr, uintptr) {
	i := findBitRange64(c.cache, uint(npages))

// Verify that we don't consider a Go'd function's
// arguments as pointers when they aren't.

package main

import (
	"unsafe"
)

var badPtr uintptr

var sink []byte

func init() {
	// Allocate large enough to use largeAlloc.
	b := make([]byte, 1<<16-1)
	sink = b // force heap allocation
	//  Any space between the object and the end of page is invalid to point to.
	badPtr = uintptr(unsafe.Pointer(&b[len(b)-1])) + 1

// (compiled into a DLL).

#include <windows.h>
#include <stdio.h>

#ifndef STACK_SIZE_PARAM_IS_A_RESERVATION
#define STACK_SIZE_PARAM_IS_A_RESERVATION 0x00010000
#endif

typedef void callback(char*);

// Allocate a stack that's much larger than the default.
static const int STACK_SIZE = 16<<20;

static callback *bigStackCallback;

static void useStack(int bytes) {

import (
	"errors"
	"fmt"
	"net"

	api "k8s.io/kubernetes/pkg/apis/core"
)

// Interface manages the allocation of IP addresses out of a range. Interface
// should be threadsafe.
type Interface interface {
	Allocate(net.IP) error
	AllocateNext() (net.IP, error)
	Release(net.IP) error
	ForEach(func(net.IP))
	CIDR() net.IPNet
	IPFamily() api.IPFamily
	Has(ip net.IP) bool
	Destroy()
	EnableMetrics()

  }

  fun assertRequests(vararg expectedHosts: String?) {
    assertThat(requestedHosts).containsExactly(*expectedHosts)
    requestedHosts.clear()
  }

  /** Allocates and returns `count` fake IPv4 addresses like [255.0.0.100, 255.0.0.101].  */
  fun allocate(count: Int): List<InetAddress> {
    val from = nextAddress
    nextAddress += count
    return (from until nextAddress)
      .map {

 * Such work can reuse outputs from a previous execution.
 */
public interface MutableUnitOfWork extends UnitOfWork {
    /**
     * Returns the {@link MutableWorkspaceProvider} to allocate a workspace to execution this work in.
     */
    MutableWorkspaceProvider getWorkspaceProvider();

 */
public interface ImmutableUnitOfWork extends UnitOfWork {
    /**
     * Returns the {@link ImmutableWorkspaceProvider} to allocate a workspace to execution this work in.
     */
    ImmutableWorkspaceProvider getWorkspaceProvider();