{
					Signal: evictionapi.SignalNodeFsAvailable,
				},
				{
					Signal: evictionapi.SignalPIDAvailable,
				},
				{
					Signal: evictionapi.SignalMemoryAvailable,
				},
			},
			expected: []evictionapi.Threshold{
				{
					Signal: evictionapi.SignalMemoryAvailable,
				},
				{
					Signal: evictionapi.SignalNodeFsAvailable,
				},
				{

package main

import (
	"context"
	"os"
	"os/signal"
	"syscall"

	"istio.io/istio/cni/pkg/cmd"
	"istio.io/istio/pkg/log"
)

func main() {
	// Create context that cancels on termination signal
	ctx, cancel := context.WithCancel(context.Background())
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
	go func(sigChan chan os.Signal, cancel context.CancelFunc) {
		sig := <-sigChan

	SIGJVM1    = Signal(0x27)
	SIGJVM2    = Signal(0x28)
	SIGKILL    = Signal(0x9)
	SIGLOST    = Signal(0x25)
	SIGLWP     = Signal(0x21)
	SIGPIPE    = Signal(0xd)
	SIGPOLL    = Signal(0x16)
	SIGPROF    = Signal(0x1d)
	SIGPWR     = Signal(0x13)
	SIGQUIT    = Signal(0x3)
	SIGSEGV    = Signal(0xb)
	SIGSTOP    = Signal(0x17)
	SIGSYS     = Signal(0xc)
	SIGTERM    = Signal(0xf)

	SIGPROF   = Signal(0x1b)
	SIGPWR    = Signal(0x20)
	SIGQUIT   = Signal(0x3)
	SIGSEGV   = Signal(0xb)
	SIGSTOP   = Signal(0x11)
	SIGSYS    = Signal(0xc)
	SIGTERM   = Signal(0xf)
	SIGTRAP   = Signal(0x5)
	SIGTSTP   = Signal(0x12)
	SIGTTIN   = Signal(0x15)
	SIGTTOU   = Signal(0x16)
	SIGURG    = Signal(0x10)
	SIGUSR1   = Signal(0x1e)
	SIGUSR2   = Signal(0x1f)
	SIGVTALRM = Signal(0x1a)

                }
            }
        }

        then:
        poll {
            assert signal.waiting
        }

        when:
        signal.trigger()

        then:
        poll {
            assert signalCount.get() == 1
            assert signal.waiting
        }

        when:
        signal.trigger()

        then:
        poll {
            assert signalCount.get() == 2
        }

// libc interceptor that writes signal handlers to a global variable within the
// TSAN runtime instead of making a sigaction system call. A bug in
// syscall.runtime_AfterForkInChild corrupted TSAN's signal forwarding table
// during calls to (*os/exec.Cmd).Run, causing the parent process to fail to
// invoke signal handlers.

import (
	"fmt"
	"os"
	"os/exec"
	"os/signal"
	"syscall"
)

import "C"

			switch {
			case test.signalAttachedToContext:
				if test.signal == nil || test.signal != signalGot {
					t.Errorf("expected request context to have server shutdown signal: %p, but got: %p", test.signal, signalGot)
				}
			default:
				if signalGot != nil {
					t.Errorf("expected request context to not have server shutdown signal: %p, but got: %p", test.signal, signalGot)
				}
			}
			if test.wg == nil {
				return

import (
	"fmt"
	"io/fs"
	"os"
	"os/exec"
	"os/signal"
	"sync"
	"syscall"
)

func init() {
	register("CgoExecSignalMask", CgoExecSignalMask)
}

func CgoExecSignalMask() {
	if len(os.Args) > 2 && os.Args[2] == "testsigint" {
		if C.SIGINTBlocked() != 0 {
			os.Exit(1)
		}
		os.Exit(0)
	}

	c := make(chan os.Signal, 1)
	signal.Notify(c, syscall.SIGTERM)
	go func() {
		for range c {
		}

	SIGINFO    = syscall.Signal(0x29)
	SIGINT     = syscall.Signal(0x2)
	SIGIO      = syscall.Signal(0x16)
	SIGIOT     = syscall.Signal(0x6)
	SIGJVM1    = syscall.Signal(0x27)
	SIGJVM2    = syscall.Signal(0x28)
	SIGKILL    = syscall.Signal(0x9)
	SIGLOST    = syscall.Signal(0x25)
	SIGLWP     = syscall.Signal(0x21)
	SIGPIPE    = syscall.Signal(0xd)
	SIGPOLL    = syscall.Signal(0x16)

	"runtime"
	"syscall"
	"time"
)

// The only signal values guaranteed to be present in the os package
// on all systems are Interrupt (send the process an interrupt) and
// Kill (force the process to exit). Interrupt is not implemented on
// Windows; using it with [os.Process.Signal] will return an error.
var (
	Interrupt Signal = syscall.Note("interrupt")
	Kill      Signal = syscall.Note("kill")
)