// must not import anything (like net, but also like os/signal)
// that kicks off background goroutines during init.

package main

import (
	"os/signal"
	"syscall"
)

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

func SignalIgnoreSIGTRAP() {
	signal.Ignore(syscall.SIGTRAP)
	syscall.Kill(syscall.Getpid(), syscall.SIGTRAP)
	println("OK")

// This program hung when run under the C/C++ ThreadSanitizer.
// TSAN defers asynchronous signals until the signaled thread calls into libc.
// Since the Go runtime makes direct futex syscalls, Go runtime threads could
// run for an arbitrarily long time without triggering the libc interceptors.
// See https://golang.org/issue/18717.

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

/*
#cgo CFLAGS: -g -fsanitize=thread

	// Should die immediately, but we've seen flakiness on various
	// systems (see issue 14063). It's possible that the signal is
	// being delivered to a different thread and we are returning
	// and exiting before that thread runs again. Give the program
	// a little while to die to make sure we pick up the signal
	// before we return and exit the program. The time here
	// shouldn't matter--we'll never really sleep this long.

type lifecycleSignal interface {
	// Signal signals the event, indicating that the event has occurred.
	// Signal is idempotent, once signaled the event stays signaled and
	// it immediately unblocks any goroutine waiting for this event.
	Signal()

	// Signaled returns a channel that is closed when the underlying event
	// has been signaled. Successive calls to Signaled return the same value.
	Signaled() <-chan struct{}

	// an asynchronous process.
	signals.AfterShutdownDelayDuration = wrapLifecycleSignal(t, signals.AfterShutdownDelayDuration, before, nil)
	signals.PreShutdownHooksStopped = wrapLifecycleSignal(t, signals.PreShutdownHooksStopped, before, nil)
	signals.NotAcceptingNewRequest = wrapLifecycleSignal(t, signals.NotAcceptingNewRequest, before, nil)
	signals.HTTPServerStoppedListening = wrapLifecycleSignal(t, signals.HTTPServerStoppedListening, before, nil)

// This program hung when run under the C/C++ ThreadSanitizer. TSAN defers
// asynchronous signals until the signaled thread calls into libc. The runtime's
// sysmon goroutine idles itself using direct usleep syscalls, so it could
// run for an arbitrarily long time without triggering the libc interceptors.
// See https://golang.org/issue/18717.

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

/*
#cgo CFLAGS: -g -fsanitize=thread

// If not, -1 and false.
func terminationSignal(err error) (os.Signal, bool) {
	exitErr, ok := err.(*exec.ExitError)
	if !ok || exitErr.ExitCode() >= 0 {
		return syscall.Signal(-1), false
	}
	status := exitErr.Sys().(syscall.WaitStatus)
	return status.Signal(), status.Signaled()
}

// isCrashSignal returns whether a signal was likely to have been caused by an
// error in the program that received it, triggered by a fuzz input. For

import (
	"fmt"
	"io"
	"log"
	"os"
	"os/signal"
	"syscall"
	"time"
)

func main() {
	// Ensure that this process terminates when the test times out,
	// even if the expected signal never arrives.
	go func() {
		io.Copy(io.Discard, os.Stdin)
		log.Fatal("stdin is closed; terminating")
	}()

	// Register to receive all signals.
	c := make(chan os.Signal, 1)
	signal.Notify(c)

	// Get console window handle.

}

// A Signal is a number describing a process signal.
// It implements the [os.Signal] interface.
type Signal int

const (
	_ Signal = iota
	SIGCHLD
	SIGINT
	SIGKILL
	SIGTRAP
	SIGQUIT
	SIGTERM
)

func (s Signal) Signal() {}

func (s Signal) String() string {
	if 0 <= s && int(s) < len(signals) {
		str := signals[s]
		if str != "" {
			return str
		}

		flags = sigtable[sig].flags
	}

	// If the signal is ignored, raising the signal is no-op.
	if handler == _SIG_IGN || (handler == _SIG_DFL && flags&_SigIgn != 0) {
		return
	}

	// Reset the signal handler and raise the signal.
	// We are currently running inside a signal handler, so the
	// signal is blocked. We need to unblock it before raising the
	// signal, or the signal we raise will be ignored until we return