Test POSIX 1003.1 2016 chapter 13 "Headers".
And fix one thing that this found: apparently <stdlib.h> should also
make the various *WAIT* macros available.
Bug: N/A
Test: builds
Change-Id: Id879bf3c1bddd1170261a809e7280150a74d6b3d
diff --git a/tests/headers/posix/signal_h.c b/tests/headers/posix/signal_h.c
new file mode 100644
index 0000000..dbfacb1
--- /dev/null
+++ b/tests/headers/posix/signal_h.c
@@ -0,0 +1,237 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <signal.h>
+
+#include "header_checks.h"
+
+static void signal_h() {
+ void (*h)(int);
+ h = SIG_DFL;
+ h = SIG_ERR;
+ h = SIG_HOLD;
+ h = SIG_IGN;
+
+ TYPE(pthread_t);
+ TYPE(size_t);
+ TYPE(uid_t);
+
+ TYPE(struct timespec);
+
+ TYPE(sig_atomic_t);
+ TYPE(pid_t);
+
+ TYPE(pthread_attr_t);
+
+ TYPE(struct sigevent);
+ STRUCT_MEMBER(struct sigevent, int, sigev_notify);
+ STRUCT_MEMBER(struct sigevent, int, sigev_signo);
+ STRUCT_MEMBER(struct sigevent, union sigval, sigev_value);
+ STRUCT_MEMBER_FUNCTION_POINTER(struct sigevent, void (*f)(union sigval), sigev_notify_function);
+#if defined(__BIONIC__) || defined(__GLIBC__)
+ STRUCT_MEMBER(struct sigevent, void*, sigev_notify_attributes);
+#else
+ STRUCT_MEMBER(struct sigevent, pthread_attr_t*, sigev_notify_attributes);
+#endif
+
+ MACRO(SIGEV_NONE);
+ MACRO(SIGEV_SIGNAL);
+ MACRO(SIGEV_THREAD);
+
+ TYPE(union sigval);
+ STRUCT_MEMBER(union sigval, int, sival_int);
+ STRUCT_MEMBER(union sigval, void*, sival_ptr);
+
+ int i;
+ i = SIGRTMIN;
+ i = SIGRTMAX;
+
+ MACRO(SIGABRT);
+ MACRO(SIGALRM);
+ MACRO(SIGBUS);
+ MACRO(SIGCHLD);
+ MACRO(SIGCONT);
+ MACRO(SIGFPE);
+ MACRO(SIGHUP);
+ MACRO(SIGILL);
+ MACRO(SIGINT);
+ MACRO(SIGKILL);
+ MACRO(SIGPIPE);
+ MACRO(SIGQUIT);
+ MACRO(SIGSEGV);
+ MACRO(SIGSTOP);
+ MACRO(SIGTERM);
+ MACRO(SIGTSTP);
+ MACRO(SIGTTIN);
+ MACRO(SIGTTOU);
+ MACRO(SIGUSR1);
+ MACRO(SIGUSR2);
+ MACRO(SIGPOLL);
+ MACRO(SIGPROF);
+ MACRO(SIGSYS);
+ MACRO(SIGTRAP);
+ MACRO(SIGURG);
+ MACRO(SIGVTALRM);
+ MACRO(SIGXCPU);
+ MACRO(SIGXFSZ);
+
+ TYPE(struct sigaction);
+ STRUCT_MEMBER_FUNCTION_POINTER(struct sigaction, void (*f)(int), sa_handler);
+ STRUCT_MEMBER(struct sigaction, sigset_t, sa_mask);
+#if defined(__BIONIC__)
+#if defined(__LP64__)
+ STRUCT_MEMBER(struct sigaction, unsigned int, sa_flags); // TODO: easily fixed!
+#else
+ STRUCT_MEMBER(struct sigaction, unsigned long, sa_flags);
+#endif
+#else
+ STRUCT_MEMBER(struct sigaction, int, sa_flags);
+#endif
+ STRUCT_MEMBER_FUNCTION_POINTER(struct sigaction, void (*f)(int, siginfo_t*, void*), sa_sigaction);
+
+ i = SIG_BLOCK;
+ i = SIG_UNBLOCK;
+ i = SIG_SETMASK;
+
+ MACRO(SA_NOCLDSTOP);
+ MACRO(SA_ONSTACK);
+ MACRO(SA_RESETHAND);
+ MACRO(SA_RESTART);
+ MACRO(SA_SIGINFO);
+ MACRO(SA_NOCLDWAIT);
+ MACRO(SA_NODEFER);
+
+ MACRO(SS_ONSTACK);
+ MACRO(SS_DISABLE);
+
+ MACRO(MINSIGSTKSZ);
+ MACRO(SIGSTKSZ);
+
+ TYPE(mcontext_t);
+
+ TYPE(ucontext_t);
+ STRUCT_MEMBER(ucontext_t, ucontext_t*, uc_link);
+ STRUCT_MEMBER(ucontext_t, sigset_t, uc_sigmask);
+ STRUCT_MEMBER(ucontext_t, stack_t, uc_stack);
+ STRUCT_MEMBER(ucontext_t, mcontext_t, uc_mcontext);
+
+ TYPE(stack_t);
+ STRUCT_MEMBER(stack_t, void*, ss_sp);
+ STRUCT_MEMBER(stack_t, size_t, ss_size);
+ STRUCT_MEMBER(stack_t, int, ss_flags);
+
+ TYPE(siginfo_t);
+ STRUCT_MEMBER(siginfo_t, int, si_signo);
+ STRUCT_MEMBER(siginfo_t, int, si_code);
+ STRUCT_MEMBER(siginfo_t, int, si_errno);
+ STRUCT_MEMBER(siginfo_t, pid_t, si_pid);
+ STRUCT_MEMBER(siginfo_t, uid_t, si_uid);
+ STRUCT_MEMBER(siginfo_t, void*, si_addr);
+ STRUCT_MEMBER(siginfo_t, int, si_status);
+ STRUCT_MEMBER(siginfo_t, long, si_band);
+ STRUCT_MEMBER(siginfo_t, union sigval, si_value);
+
+ i = ILL_ILLOPC;
+ i = ILL_ILLOPN;
+ i = ILL_ILLADR;
+ i = ILL_ILLTRP;
+ i = ILL_PRVOPC;
+ i = ILL_PRVREG;
+ i = ILL_COPROC;
+ i = ILL_BADSTK;
+
+ i = FPE_INTDIV;
+ i = FPE_INTOVF;
+ i = FPE_FLTDIV;
+ i = FPE_FLTOVF;
+ i = FPE_FLTUND;
+ i = FPE_FLTRES;
+ i = FPE_FLTINV;
+ i = FPE_FLTSUB;
+
+ i = SEGV_MAPERR;
+ i = SEGV_ACCERR;
+
+ i = BUS_ADRALN;
+ i = BUS_ADRERR;
+ i = BUS_OBJERR;
+
+ i = TRAP_BRKPT;
+ i = TRAP_TRACE;
+
+ i = CLD_EXITED;
+ i = CLD_KILLED;
+ i = CLD_DUMPED;
+ i = CLD_TRAPPED;
+ i = CLD_STOPPED;
+ i = CLD_CONTINUED;
+
+ i = POLL_IN;
+ i = POLL_OUT;
+ i = POLL_MSG;
+ i = POLL_ERR;
+ i = POLL_PRI;
+ i = POLL_HUP;
+
+ i = SI_USER;
+ i = SI_QUEUE;
+ i = SI_TIMER;
+ i = SI_ASYNCIO;
+ i = SI_MESGQ;
+
+ typedef void (*signal_handler_type)(int);
+
+ FUNCTION(kill, int (*f)(pid_t, int));
+ FUNCTION(killpg, int (*f)(pid_t, int));
+ FUNCTION(psiginfo, void (*f)(const siginfo_t*, const char*));
+ FUNCTION(psignal, void (*f)(int, const char*));
+ FUNCTION(pthread_kill, int (*f)(pthread_t, int));
+ FUNCTION(pthread_sigmask, int (*f)(int, const sigset_t*, sigset_t*));
+ FUNCTION(raise, int (*f)(int));
+ FUNCTION(sigaction, int (*f)(int, const struct sigaction*, struct sigaction*));
+ FUNCTION(sigaddset, int (*f)(sigset_t*, int));
+ FUNCTION(sigaltstack, int (*f)(const stack_t*, stack_t*));
+ FUNCTION(sigdelset, int (*f)(sigset_t*, int));
+ FUNCTION(sigemptyset, int (*f)(sigset_t*));
+ FUNCTION(sigfillset, int (*f)(sigset_t*));
+ FUNCTION(sighold, int (*f)(int));
+ FUNCTION(sigignore, int (*f)(int));
+ FUNCTION(siginterrupt, int (*f)(int, int));
+ FUNCTION(sigismember, int (*f)(const sigset_t*, int));
+ FUNCTION(signal, signal_handler_type (*f)(int, signal_handler_type));
+ FUNCTION(sigpause, int (*f)(int));
+ FUNCTION(sigpending, int (*f)(sigset_t*));
+ FUNCTION(sigprocmask, int (*f)(int, const sigset_t*, sigset_t*));
+ FUNCTION(sigqueue, int (*f)(pid_t, int, union sigval));
+ FUNCTION(sigrelse, int (*f)(int));
+ FUNCTION(sigset, signal_handler_type (*f)(int, signal_handler_type));
+ FUNCTION(sigsuspend, int (*f)(const sigset_t*));
+ FUNCTION(sigtimedwait, int (*f)(const sigset_t*, siginfo_t*, const struct timespec*));
+ FUNCTION(sigwait, int (*f)(const sigset_t*, int*));
+ FUNCTION(sigwaitinfo, int (*f)(const sigset_t*, siginfo_t*));
+}