===> sigfpe
==== divzero ====
cc -O0 -pipe   -MD -MP  -c /home/src/regress/sys/kern/signal/sigfpe/sigfpe.c
cc   -o sigfpe sigfpe.o 
./sigfpe -z

==== oflow ====
./sigfpe -o

===> siginfo_addr
==== run-regress-siginfo_addr ====
cc -O2 -pipe   -MD -MP  -c /home/src/regress/sys/kern/signal/siginfo_addr/siginfo_addr.c
cc   -o siginfo_addr siginfo_addr.o 
./siginfo_addr

===> fpsig
==== run-regress-fpsig ====
cc -O2 -pipe   -MD -MP  -c /home/src/regress/sys/kern/signal/fpsig/fpsig.c
cc   -o fpsig fpsig.o 
./fpsig

===> earlysig
==== run-regress-earlysig ====
cc -O2 -pipe   -MD -MP  -c /home/src/regress/sys/kern/signal/earlysig/earlysig.c
cc   -o earlysig earlysig.o 
./earlysig

===> cansig
==== t-cansig ====
cc -O2 -pipe  -Wall  -MD -MP  -c /home/src/regress/sys/kern/signal/cansig/cansig.c
cc   -o cansig cansig.o 
doas -n ./cansig

===> sigaltstack_fork
==== run-regress-sigaltstack_fork ====
cc -O2 -pipe   -MD -MP  -c /home/src/regress/sys/kern/signal/sigaltstack_fork/sigaltstack_fork.c
cc   -o sigaltstack_fork sigaltstack_fork.o 
./sigaltstack_fork

===> sig-stop
==== run-regress-sig-stop ====
cc -O2 -pipe   -MD -MP  -c /home/src/regress/sys/kern/signal/sig-stop/sig-stop.c
cc   -o sig-stop sig-stop.o 
./sig-stop

===> sig-stop3
==== run-regress-sig-stop3 ====
cc -O2 -pipe   -MD -MP  -c /home/src/regress/sys/kern/signal/sig-stop3/sig-stop3.c
cc   -o sig-stop3 sig-stop3.o -lpthread
./sig-stop3
sending SIGSTOP
waiting...
got stopped notification
killing child
OK

===> siginfo-fault
==== run-regress-siginfo-fault ====
cc -Wall  -MD -MP  -c /home/src/regress/sys/kern/signal/siginfo-fault/siginfo-fault.c
cc   -o siginfo-fault siginfo-fault.o 
./siginfo-fault

===> sigio
==== run-regress-pipe_badpgid ====
cc -O2 -pipe  -Wall -Wpointer-arith -Wuninitialized -Wstrict-prototypes -Wmissing-prototypes -Wunused -Wsign-compare -Wshadow  -MD -MP  -c /home/src/regress/sys/kern/signal/sigio/main.c
cc -O2 -pipe  -Wall -Wpointer-arith -Wuninitialized -Wstrict-prototypes -Wmissing-prototypes -Wunused -Wsign-compare -Wshadow  -MD -MP  -c /home/src/regress/sys/kern/signal/sigio/sigio_common.c
cc -O2 -pipe  -Wall -Wpointer-arith -Wuninitialized -Wstrict-prototypes -Wmissing-prototypes -Wunused -Wsign-compare -Wshadow  -MD -MP  -c /home/src/regress/sys/kern/signal/sigio/sigio_pipe.c
cc -O2 -pipe  -Wall -Wpointer-arith -Wuninitialized -Wstrict-prototypes -Wmissing-prototypes -Wunused -Wsign-compare -Wshadow  -MD -MP  -c /home/src/regress/sys/kern/signal/sigio/sigio_socket.c
cc -O2 -pipe  -Wall -Wpointer-arith -Wuninitialized -Wstrict-prototypes -Wmissing-prototypes -Wunused -Wsign-compare -Wshadow  -MD -MP  -c /home/src/regress/sys/kern/signal/sigio/util.c
cc   -o sigio_test main.o sigio_common.o sigio_pipe.o sigio_socket.o util.o 
./sigio_test pipe_badpgid

==== run-regress-pipe_badsession ====
./sigio_test pipe_badsession

==== run-regress-pipe_cansigio ====
doas -n ./sigio_test pipe_cansigio

==== run-regress-pipe_getown ====
./sigio_test pipe_getown

==== run-regress-pipe_read ====
./sigio_test pipe_read

==== run-regress-socket_badpgid ====
./sigio_test socket_badpgid

==== run-regress-socket_badsession ====
./sigio_test socket_badsession

==== run-regress-socket_cansigio ====
doas -n ./sigio_test socket_cansigio

==== run-regress-socket_getown ====
./sigio_test socket_getown

==== run-regress-socket_inherit ====
./sigio_test socket_inherit

==== run-regress-socket_read ====
./sigio_test socket_read

==== run-regress-socket_write ====
./sigio_test socket_write

===> signal-stress
==== run-regress-signal-stress ====
cc -O2 -pipe   -MD -MP  -c /home/src/regress/sys/kern/signal/signal-stress/signal-stress.c
cc   -o signal-stress signal-stress.o 
./signal-stress

===> sigpending
==== run-regress-sigpending ====
cc -O2 -pipe   -MD -MP  -c /home/src/regress/sys/kern/signal/sigpending/sigpending.c
cc   -o sigpending sigpending.o 
./sigpending

===> sigprof
==== run-regress-sigprof ====
cc -O2 -pipe   -MD -MP  -c /home/src/regress/sys/kern/signal/sigprof/sigprof.c
cc   -o sigprof sigprof.o -lpthread
./sigprof
total profiling signals: 400
minimum signals per thread: 50
main thread - 0
thread 1 - 110
thread 2 - 102
thread 3 - 119
thread 4 - 69

===> sigpthread
==== run-block-thread-3-unblock-0 ====
cc -O2 -pipe  -Wall -Wpointer-arith -Wuninitialized -Wstrict-prototypes -Wmissing-prototypes -Wunused -Wsign-compare -Wshadow  -MD -MP  -c /home/src/regress/sys/kern/signal/sigpthread/sigpthread.c
/home/src/regress/sys/kern/signal/sigpthread/sigpthread.c:199:8: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
        ret = (int)val;
              ^~~~~~~~
/home/src/regress/sys/kern/signal/sigpthread/sigpthread.c:205:9: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
                ret = (int)val;
                      ^~~~~~~~
/home/src/regress/sys/kern/signal/sigpthread/sigpthread.c:247:13: warning: cast to smaller integer type 'int' from 'void *' [-Wvoid-pointer-to-int-cast]
        int tnum = (int)arg;
                   ^~~~~~~~
3 warnings generated.
cc   -o sigpthread sigpthread.o -lpthread
# block signal
# run 3 threads
# kill process
# suspend threads until signaled
# unblock thread 0
# handle signal
./sigpthread -b -t 3 -u 0 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-unblock-0 ====
# block signal
# run 3 threads
# suspend threads until signaled
# sleep in main thread, signal should be received while suspended
# kill process
# unblock thread 0
# handle signal
./sigpthread -b -s -t 3 -u 0 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-unblock-0-sleep-thread ====

==== run-block-thread-3-sleep-unblock-unblock-0 ====
# block signal
# run 3 threads
# kill process
# suspend threads until signaled
# sleep in thread 0, others should be exited when unblocking
# unblock thread 0
# handle signal
./sigpthread -b -t 3 -U -u 0 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-kill-0-unblock-0 ====
# block signal
# run 3 threads
# kill thread 0
# suspend threads until signaled
# unblock thread 0
# handle signal
./sigpthread -b -k 0 -t 3 -u 0 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-kill-0-unblock-0 ====
# block signal
# run 3 threads
# suspend threads until signaled
# sleep in main thread, signal should be received while suspended
# kill thread 0
# unblock thread 0
# handle signal
./sigpthread -b -k 0 -s -t 3 -u 0 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-kill-0-sleep-thread-unblock-0 ====
# block signal
# run 3 threads
# kill thread 0
# sleep in threads, signal should be pending when suspending
# suspend threads until signaled
# unblock thread 0
# handle signal
./sigpthread -b -k 0 -S -t 3 -u 0 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-kill-0-unblock-0-sleep-unblock ====
# block signal
# run 3 threads
# kill thread 0
# suspend threads until signaled
# sleep in thread 0, others should be exited when unblocking
# unblock thread 0
# handle signal
./sigpthread -b -k 0 -t 3 -U -u 0 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-kill-0 ====
# block signal
# run 3 threads
# kill thread 0
# suspend threads until signaled
# unblock all threads
# handle signal
./sigpthread -b -k 0 -t 3 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-kill-0 ====
# block signal
# run 3 threads
# suspend threads until signaled
# sleep in main thread, signal should be received while suspended
# kill thread 0
# unblock all threads
# handle signal
./sigpthread -b -k 0 -s -t 3 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-kill-0-sleep-thread ====
# block signal
# run 3 threads
# kill thread 0
# sleep in threads, signal should be pending when suspending
# suspend threads until signaled
# unblock all threads
# handle signal
./sigpthread -b -k 0 -S -t 3 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-kill-0-sleep-unblock ====
# block signal
# run 3 threads
# kill thread 0
# suspend threads until signaled
# sleep in all threads
# unblock all threads
# handle signal
./sigpthread -b -k 0 -t 3 -U >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-unblock-1 ====
# block signal
# run 3 threads
# kill process
# suspend threads until signaled
# unblock thread 1
# handle signal
./sigpthread -b -t 3 -u 1 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-unblock-1 ====
# block signal
# run 3 threads
# suspend threads until signaled
# sleep in main thread, signal should be received while suspended
# kill process
# unblock thread 1
# handle signal
./sigpthread -b -s -t 3 -u 1 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-unblock-1-sleep-thread ====

==== run-block-thread-3-sleep-unblock-unblock-1 ====
# block signal
# run 3 threads
# kill process
# suspend threads until signaled
# sleep in thread 1, others should be exited when unblocking
# unblock thread 1
# handle signal
./sigpthread -b -t 3 -U -u 1 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-kill-1-unblock-1 ====
# block signal
# run 3 threads
# kill thread 1
# suspend threads until signaled
# unblock thread 1
# handle signal
./sigpthread -b -k 1 -t 3 -u 1 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-kill-1-unblock-1 ====
# block signal
# run 3 threads
# suspend threads until signaled
# sleep in main thread, signal should be received while suspended
# kill thread 1
# unblock thread 1
# handle signal
./sigpthread -b -k 1 -s -t 3 -u 1 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-kill-1-sleep-thread-unblock-1 ====
# block signal
# run 3 threads
# kill thread 1
# sleep in threads, signal should be pending when suspending
# suspend threads until signaled
# unblock thread 1
# handle signal
./sigpthread -b -k 1 -S -t 3 -u 1 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-kill-1-unblock-1-sleep-unblock ====
# block signal
# run 3 threads
# kill thread 1
# suspend threads until signaled
# sleep in thread 1, others should be exited when unblocking
# unblock thread 1
# handle signal
./sigpthread -b -k 1 -t 3 -U -u 1 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-kill-1 ====
# block signal
# run 3 threads
# kill thread 1
# suspend threads until signaled
# unblock all threads
# handle signal
./sigpthread -b -k 1 -t 3 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-kill-1 ====
# block signal
# run 3 threads
# suspend threads until signaled
# sleep in main thread, signal should be received while suspended
# kill thread 1
# unblock all threads
# handle signal
./sigpthread -b -k 1 -s -t 3 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-kill-1-sleep-thread ====
# block signal
# run 3 threads
# kill thread 1
# sleep in threads, signal should be pending when suspending
# suspend threads until signaled
# unblock all threads
# handle signal
./sigpthread -b -k 1 -S -t 3 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-kill-1-sleep-unblock ====
# block signal
# run 3 threads
# kill thread 1
# suspend threads until signaled
# sleep in all threads
# unblock all threads
# handle signal
./sigpthread -b -k 1 -t 3 -U >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-unblock-2 ====
# block signal
# run 3 threads
# kill process
# suspend threads until signaled
# unblock thread 2
# handle signal
./sigpthread -b -t 3 -u 2 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-unblock-2 ====
# block signal
# run 3 threads
# suspend threads until signaled
# sleep in main thread, signal should be received while suspended
# kill process
# unblock thread 2
# handle signal
./sigpthread -b -s -t 3 -u 2 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-unblock-2-sleep-thread ====

==== run-block-thread-3-sleep-unblock-unblock-2 ====
# block signal
# run 3 threads
# kill process
# suspend threads until signaled
# sleep in thread 2, others should be exited when unblocking
# unblock thread 2
# handle signal
./sigpthread -b -t 3 -U -u 2 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-kill-2-unblock-2 ====
# block signal
# run 3 threads
# kill thread 2
# suspend threads until signaled
# unblock thread 2
# handle signal
./sigpthread -b -k 2 -t 3 -u 2 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-kill-2-unblock-2 ====
# block signal
# run 3 threads
# suspend threads until signaled
# sleep in main thread, signal should be received while suspended
# kill thread 2
# unblock thread 2
# handle signal
./sigpthread -b -k 2 -s -t 3 -u 2 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-kill-2-sleep-thread-unblock-2 ====
# block signal
# run 3 threads
# kill thread 2
# sleep in threads, signal should be pending when suspending
# suspend threads until signaled
# unblock thread 2
# handle signal
./sigpthread -b -k 2 -S -t 3 -u 2 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-kill-2-unblock-2-sleep-unblock ====
# block signal
# run 3 threads
# kill thread 2
# suspend threads until signaled
# sleep in thread 2, others should be exited when unblocking
# unblock thread 2
# handle signal
./sigpthread -b -k 2 -t 3 -U -u 2 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-kill-2 ====
# block signal
# run 3 threads
# kill thread 2
# suspend threads until signaled
# unblock all threads
# handle signal
./sigpthread -b -k 2 -t 3 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-kill-2 ====
# block signal
# run 3 threads
# suspend threads until signaled
# sleep in main thread, signal should be received while suspended
# kill thread 2
# unblock all threads
# handle signal
./sigpthread -b -k 2 -s -t 3 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-kill-2-sleep-thread ====
# block signal
# run 3 threads
# kill thread 2
# sleep in threads, signal should be pending when suspending
# suspend threads until signaled
# unblock all threads
# handle signal
./sigpthread -b -k 2 -S -t 3 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-kill-2-sleep-unblock ====
# block signal
# run 3 threads
# kill thread 2
# suspend threads until signaled
# sleep in all threads
# unblock all threads
# handle signal
./sigpthread -b -k 2 -t 3 -U >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3 ====
# block signal
# run 3 threads
# kill process
# suspend threads until signaled
# unblock all threads
# handle signal
./sigpthread -b -t 3 >out
grep 'signal [0-2]' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main ====
# block signal
# run 3 threads
# suspend threads until signaled
# sleep in main thread, signal should be received while suspended
# kill process
# unblock all threads
# handle signal
./sigpthread -b -s -t 3 >out
grep 'signal [0-2]' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-sleep-thread ====
# block signal
# run 3 threads
# kill process
# sleep in threads, signal should be pending when suspending
# suspend threads until signaled
# unblock all threads
# handle signal
./sigpthread -b -S -t 3 >out
grep 'signal [0-2]' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-sleep-unblock ====
# block signal
# run 3 threads
# kill process
# suspend threads until signaled
# sleep in all threads
# unblock all threads
# handle signal
./sigpthread -b -t 3 -U >out
grep 'signal [0-2]' out
signal 2
test `wc -l <out` = 1

==== run-thread-3-kill-0 ====
# run 3 threads
# kill thread 0
# handle signal
# suspend threads until signaled
./sigpthread -k 0 -t 3 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-thread-3-sleep-main-kill-0 ====
# run 3 threads
# suspend threads until signaled
# sleep in main thread, signal should be received while suspended
# kill thread 0
# handle signal
./sigpthread -k 0 -s -t 3 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-thread-3-kill-0-sleep-thread ====
# run 3 threads
# kill thread 0
# sleep in threads, signal should be received while sleeping
# handle signal
# suspend threads until signaled
./sigpthread -k 0 -S -t 3 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-thread-3-kill-0-sleep-unblock ====
# run 3 threads
# kill thread 0
# handle signal
# suspend threads until signaled
# sleep in all threads
./sigpthread -k 0 -t 3 -U >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-thread-3-kill-1 ====
# run 3 threads
# kill thread 1
# handle signal
# suspend threads until signaled
./sigpthread -k 1 -t 3 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-thread-3-sleep-main-kill-1 ====
# run 3 threads
# suspend threads until signaled
# sleep in main thread, signal should be received while suspended
# kill thread 1
# handle signal
./sigpthread -k 1 -s -t 3 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-thread-3-kill-1-sleep-thread ====
# run 3 threads
# kill thread 1
# sleep in threads, signal should be received while sleeping
# handle signal
# suspend threads until signaled
./sigpthread -k 1 -S -t 3 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-thread-3-kill-1-sleep-unblock ====
# run 3 threads
# kill thread 1
# handle signal
# suspend threads until signaled
# sleep in all threads
./sigpthread -k 1 -t 3 -U >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-thread-3-kill-2 ====
# run 3 threads
# kill thread 2
# handle signal
# suspend threads until signaled
./sigpthread -k 2 -t 3 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-thread-3-sleep-main-kill-2 ====
# run 3 threads
# suspend threads until signaled
# sleep in main thread, signal should be received while suspended
# kill thread 2
# handle signal
./sigpthread -k 2 -s -t 3 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-thread-3-kill-2-sleep-thread ====
# run 3 threads
# kill thread 2
# sleep in threads, signal should be received while sleeping
# handle signal
# suspend threads until signaled
./sigpthread -k 2 -S -t 3 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-thread-3-kill-2-sleep-unblock ====
# run 3 threads
# kill thread 2
# handle signal
# suspend threads until signaled
# sleep in all threads
./sigpthread -k 2 -t 3 -U >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-thread-3 ====
# run 3 threads
# kill process
# handle signal
# suspend threads until signaled
./sigpthread -t 3 >out
grep 'signal [0-2]' out
signal 0
test `wc -l <out` = 1

==== run-thread-3-sleep-main ====
# block signal
# run 3 threads
# suspend threads until signaled
# sleep in main thread, signal should be received while suspended
# kill process
# handle signal
./sigpthread -s -t 3 >out
grep 'signal [0-2]' out
signal 0
test `wc -l <out` = 1

==== run-thread-3-sleep-thread ====
# run 3 threads
# kill process
# sleep in threads, signal should be received while sleeping
# handle signal
# suspend threads until signaled
./sigpthread -S -t 3 >out
grep 'signal [0-2]' out
signal 0
test `wc -l <out` = 1

==== run-thread-3-sleep-unblock ====
# run 3 threads
# kill process
# handle signal
# suspend threads until signaled
# sleep in all threads
./sigpthread -t 3 -U >out
grep 'signal [0-2]' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-waiter-0 ====
# block signal
# run 3 threads
# kill process
# wait for signal in thread 0
# suspend threads until signaled
./sigpthread -b -t 3 -w 0 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-waiter-0 ====
# block signal
# run 3 threads
# wait for signal in thread 0
# suspend threads until signaled
# sleep in main thread, signal should be received while waiting
# kill process
./sigpthread -b -s -t 3 -w 0 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-waiter-0-sleep-thread ====

==== run-block-thread-3-kill-0-waiter-0 ====
# block signal
# run 3 threads
# kill thread 0
# wait for signal in thread 0
# suspend threads until signaled
./sigpthread -b -k 0 -t 3 -w 0 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-kill-0-waiter-0 ====
# block signal
# run 3 threads
# wait for signal in thread 0
# suspend threads until signaled
# sleep in main thread, signal should be received while waiting
# kill thread 0
./sigpthread -b -k 0 -s -t 3 -w 0 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-kill-0-sleep-thread-waiter-0 ====
# block signal
# run 3 threads
# kill thread 0
# sleep in threads, signal should be pending when waiting
# wait for signal in thread 0
# suspend threads until signaled
./sigpthread -b -k 0 -S -t 3 -w 0 >out
grep 'signal 0' out
signal 0
test `wc -l <out` = 1

==== run-block-thread-3-waiter-1 ====
# block signal
# run 3 threads
# kill process
# wait for signal in thread 1
# suspend threads until signaled
./sigpthread -b -t 3 -w 1 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-waiter-1 ====
# block signal
# run 3 threads
# wait for signal in thread 1
# suspend threads until signaled
# sleep in main thread, signal should be received while waiting
# kill process
./sigpthread -b -s -t 3 -w 1 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-waiter-1-sleep-thread ====

==== run-block-thread-3-kill-1-waiter-1 ====
# block signal
# run 3 threads
# kill thread 1
# wait for signal in thread 1
# suspend threads until signaled
./sigpthread -b -k 1 -t 3 -w 1 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-kill-1-waiter-1 ====
# block signal
# run 3 threads
# wait for signal in thread 1
# suspend threads until signaled
# sleep in main thread, signal should be received while waiting
# kill thread 1
./sigpthread -b -k 1 -s -t 3 -w 1 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-kill-1-sleep-thread-waiter-1 ====
# block signal
# run 3 threads
# kill thread 1
# sleep in threads, signal should be pending when waiting
# wait for signal in thread 1
# suspend threads until signaled
./sigpthread -b -k 1 -S -t 3 -w 1 >out
grep 'signal 1' out
signal 1
test `wc -l <out` = 1

==== run-block-thread-3-waiter-2 ====
# block signal
# run 3 threads
# kill process
# wait for signal in thread 2
# suspend threads until signaled
./sigpthread -b -t 3 -w 2 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-waiter-2 ====
# block signal
# run 3 threads
# wait for signal in thread 2
# suspend threads until signaled
# sleep in main thread, signal should be received while waiting
# kill process
./sigpthread -b -s -t 3 -w 2 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-waiter-2-sleep-thread ====

==== run-block-thread-3-kill-2-waiter-2 ====
# block signal
# run 3 threads
# kill thread 2
# wait for signal in thread 2
# suspend threads until signaled
./sigpthread -b -k 2 -t 3 -w 2 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-sleep-main-kill-2-waiter-2 ====
# block signal
# run 3 threads
# wait for signal in thread 2
# suspend threads until signaled
# sleep in main thread, signal should be received while waiting
# kill thread 2
./sigpthread -b -k 2 -s -t 3 -w 2 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-3-kill-2-sleep-thread-waiter-2 ====
# block signal
# run 3 threads
# kill thread 2
# sleep in threads, signal should be pending when waiting
# wait for signal in thread 2
# suspend threads until signaled
./sigpthread -b -k 2 -S -t 3 -w 2 >out
grep 'signal 2' out
signal 2
test `wc -l <out` = 1

==== run-block-thread-100-unblock-23 ====
# block signal
# run 100 threads
# kill process
# suspend threads until signaled
# unblock thread 23
# handle signal
./sigpthread -b -t 100 -u 23 >out
grep 'signal 23' out
signal 23
test `wc -l <out` = 1

==== run-block-thread-100-waiter-42 ====
# block signal
# run 100 threads
# kill process
# wait for signal in thread 42
# suspend threads until signaled
./sigpthread -b -t 100 -w 42 >out
grep 'signal 42' out
signal 42
test `wc -l <out` = 1

===> sigsuspend
==== run-regress-sigsuspend ====
cc -O2 -pipe   -MD -MP  -c /home/src/regress/sys/kern/signal/sigsuspend/sigsuspend.c
cc   -o sigsuspend sigsuspend.o 
./sigsuspend