limitations under the License.
*/

package rlimit

import (
	"errors"
)

// SetNumFiles sets the rlimit for the maximum open files.
func SetNumFiles(maxOpenFiles uint64) error {
	return errors.New("SetRLimit unsupported in this platform")

	"runtime"
	"strconv"
	"sync"
)

var NetLimitGodebug = godebug.New("#cmdgonetlimit")

// NetLimit returns the limit on concurrent network operations
// configured by GODEBUG=cmdgonetlimit, if any.
//
// A limit of 0 (indicated by 0, true) means that network operations should not
// be allowed.
func NetLimit() (int, bool) {
	netLimitOnce.Do(func() {
		s := NetLimitGodebug.Value()
		if s == "" {
			return
		}

//go:cgo_import_dynamic libc_ioctl ioctl "libc.so"
//go:cgo_import_dynamic libc_setgid setgid "libc.so"
//go:cgo_import_dynamic libc_setgroups setgroups "libc.so"
//go:cgo_import_dynamic libc_setrlimit setrlimit "libc.so"
//go:cgo_import_dynamic libc_setsid setsid "libc.so"
//go:cgo_import_dynamic libc_setuid setuid "libc.so"
//go:cgo_import_dynamic libc_setpgid setpgid "libc.so"
//go:cgo_import_dynamic libc_syscall syscall "libc.so"

limitations under the License.
*/

package rlimit

import (
	"golang.org/x/sys/unix"
)

// SetNumFiles sets the linux rlimit for the maximum open files.
func SetNumFiles(maxOpenFiles uint64) error {
	return unix.Setrlimit(unix.RLIMIT_NOFILE, &unix.Rlimit{Max: maxOpenFiles, Cur: maxOpenFiles})

pkg syscall (freebsd-386-cgo), func Getpgid(int) (int, error)
pkg syscall (freebsd-386-cgo), func Getpgrp() int
pkg syscall (freebsd-386-cgo), func Getpriority(int, int) (int, error)
pkg syscall (freebsd-386-cgo), func Getrlimit(int, *Rlimit) error
pkg syscall (freebsd-386-cgo), func Getrusage(int, *Rusage) error
pkg syscall (freebsd-386-cgo), func Getsid(int) (int, error)
pkg syscall (freebsd-386-cgo), func Getsockname(int) (Sockaddr, error)

		}
	}()
	return true
}

// SetLimit limits the number of active goroutines in this group to at most n.
// A negative value indicates no limit.
//
// Any subsequent call to the Go method will block until it can add an active
// goroutine without exceeding the configured limit.
//
// The limit must not be modified while any goroutines in the group are active.
func (g *Group) SetLimit(n int) {
	if n < 0 {
		g.sem = nil

TEXT ·RawSyscall6(SB),NOSPLIT,$0
	JMP	runtime·syscall_rawsyscall6(SB)

TEXT ·setgid(SB),NOSPLIT,$0
	JMP	runtime·syscall_setgid(SB)

TEXT ·setgroups1(SB),NOSPLIT,$0
	JMP	runtime·syscall_setgroups(SB)

TEXT ·setrlimit1(SB),NOSPLIT,$0
	JMP	runtime·syscall_setrlimit(SB)

TEXT ·setsid(SB),NOSPLIT,$0
	JMP	runtime·syscall_setsid(SB)

TEXT ·setuid(SB),NOSPLIT,$0
	JMP	runtime·syscall_setuid(SB)

TEXT ·setpgid(SB),NOSPLIT,$0

     */
    @Input
    List<String> getExcludes();

    /**
     * Gets all limits defined for this rule. Defaults to an empty list.
     */
    @Input
    List<JacocoLimit> getLimits();

    /**
     * Adds a limit for this rule. Any number of limits can be added.
     */
    JacocoLimit limit(Action<? super JacocoLimit> configureAction);

	for i := range iov {
		if iov[i].Len > 0 {
			return false
		}
	}
	return true
}

// Setrlimit sets a resource limit.
func Setrlimit(resource int, rlim *Rlimit) error {
	// Just call the syscall version, because as of Go 1.21
	// it will affect starting a new process.
	return syscall.Setrlimit(resource, (*syscall.Rlimit)(rlim))

        this.excludes = excludes;
    }

    @Override
    public List<String> getExcludes() {
        return Collections.unmodifiableList(excludes);
    }

    @Override
    public List<JacocoLimit> getLimits() {
        return Collections.unmodifiableList(limits);
    }

    @Override
    public JacocoLimit limit(Action<? super JacocoLimit> configureAction) {
        JacocoLimit limit = new JacocoLimitImpl();