// distinct mapped regions per process. As of this writing:
//
//	Darwin    unlimited
//	DragonFly   1000000 (vm.max_proc_mmap)
//	FreeBSD   unlimited
//	Linux         65530 (vm.max_map_count) // TODO: query /proc/sys/vm/max_map_count?
//	NetBSD    unlimited
//	OpenBSD   unlimited
var mmapLimit int32 = 1<<31 - 1

func init() {
	// Linux is the only practically concerning OS.

# no core files, please
ulimit -c 0

# Raise soft limits to hard limits for NetBSD/OpenBSD.
# We need at least ~300 MB of bss.
[ "$(ulimit -H -d)" = "unlimited" ] || ulimit -S -d $(ulimit -H -d)

# Thread count limit on NetBSD 7.
if ulimit -T &> /dev/null; then
	[ "$(ulimit -H -T)" = "unlimited" ] || ulimit -S -T $(ulimit -H -T)
fi

export GOPATH=/nonexist-gopath

//     Optional value, default 64, range: 1-unlimited
//
//   - <S3MultiObjectDeleteLimit>
//     Some of the Veeam products use Multi Delete operations. This setting can reduce how many objects are included in one
//     multi-delete operation. The same registry key setting overwrites the storage-defined setting.
//     Optional value, default 1000, range: 1-unlimited (S3 standard maximum is 1000 and should not be set higher)
//

/**
 * Verifies that we can spawn large amounts of workers without running out of memory, because the old ones will be killed
 * if necessary.
 *
 * <p>
 *     This mostly is a test for Windows, as other OSes have effectively-unlimited virtual memory, and won't need to kill
 *     processes.
 * </p>
 */
class WorkerPruningSoakTest extends AbstractIntegrationSpec {
    def fixture = new WorkerExecutorFixture(temporaryFolder)

    def setup() {

	if err != nil {
		return err
	}

	if vssLimit > 0 && vssLimit < humanize.GiByte {
		logger.Info("WARNING: maximum virtual memory limit (%s) is too small for 'go runtime', please consider setting `ulimit -v` to unlimited",
			humanize.IBytes(vssLimit))
	}

	if ctx.MemLimit > 0 {
		maxLimit = ctx.MemLimit
	}

	if maxLimit > 0 {
		debug.SetMemoryLimit(int64(maxLimit))
	}

|:--------------------------------------------------------------------------------|:--------------------------------------------------------------------------------|
| Maximum number of buckets                                                       | unlimited (we recommend not beyond 500000 buckets) - see NOTE:                  |
| Maximum number of objects per bucket                                            | no-limit                                                                        |

          runAsGroup: 0
          runAsNonRoot: false
          runAsUser: 0
      - args:
        - -c
        - sysctl -w kernel.core_pattern=/var/lib/istio/data/core.proxy && ulimit -c
          unlimited
        command:
        - /bin/sh
        image: gcr.io/istio-testing/proxyv2:latest
        name: enable-core-dump
        resources:
          limits:
            cpu: "2"
            memory: 1Gi

    public static final String KEYS_FILE_EXT = ".keys";

    static {
        if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
            Security.setProperty("crypto.policy", "unlimited");
            Security.addProvider(new BouncyCastleProvider());
        }
    }

    public static void assertInitialized() {
    }

          runAsGroup: 0
          runAsNonRoot: false
          runAsUser: 0
      - args:
        - -c
        - sysctl -w kernel.core_pattern=/var/lib/istio/data/core.proxy && ulimit -c
          unlimited
        command:
        - /bin/sh
        image: gcr.io/istio-testing/proxyv2:latest
        name: enable-core-dump
        resources:
          limits:
            cpu: "2"
            memory: 1Gi

// the underlying io.Reader and the remaining amount of bytes if the assertion succeeds,
// otherwise it just returns the original io.Reader and the theoretical unlimited remaining amount of bytes.
func tryLimitedReader(r io.Reader) (*io.LimitedReader, io.Reader, int64) {
	var remain int64 = 1<<63 - 1 // by default, copy until EOF

	lr, ok := r.(*io.LimitedReader)
	if !ok {