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/unistd_h.c b/tests/headers/posix/unistd_h.c
new file mode 100644
index 0000000..b713f53
--- /dev/null
+++ b/tests/headers/posix/unistd_h.c
@@ -0,0 +1,383 @@
+/*
+ * 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 <unistd.h>
+
+#include "header_checks.h"
+
+static void unistd_h() {
+ MACRO(_POSIX_VERSION);
+ MACRO(_POSIX2_VERSION);
+ MACRO(_XOPEN_VERSION);
+
+ MACRO(_POSIX_ADVISORY_INFO);
+ MACRO(_POSIX_ASYNCHRONOUS_IO);
+ MACRO(_POSIX_BARRIERS);
+ MACRO(_POSIX_CHOWN_RESTRICTED);
+ MACRO(_POSIX_CLOCK_SELECTION);
+ MACRO(_POSIX_CPUTIME);
+ MACRO(_POSIX_FSYNC);
+ MACRO(_POSIX_IPV6);
+ MACRO(_POSIX_JOB_CONTROL);
+ MACRO(_POSIX_MAPPED_FILES);
+ MACRO(_POSIX_MEMLOCK);
+ MACRO(_POSIX_MEMLOCK_RANGE);
+ MACRO(_POSIX_MEMORY_PROTECTION);
+ MACRO(_POSIX_MESSAGE_PASSING);
+ MACRO(_POSIX_MONOTONIC_CLOCK);
+ MACRO(_POSIX_NO_TRUNC);
+ MACRO(_POSIX_PRIORITIZED_IO);
+ MACRO(_POSIX_PRIORITY_SCHEDULING);
+ MACRO(_POSIX_RAW_SOCKETS);
+ MACRO(_POSIX_READER_WRITER_LOCKS);
+ MACRO(_POSIX_REALTIME_SIGNALS);
+ MACRO(_POSIX_REGEXP);
+ MACRO(_POSIX_SAVED_IDS);
+ MACRO(_POSIX_SEMAPHORES);
+ MACRO(_POSIX_SHARED_MEMORY_OBJECTS);
+ MACRO(_POSIX_SHELL);
+ MACRO(_POSIX_SPAWN);
+ MACRO(_POSIX_SPIN_LOCKS);
+ MACRO(_POSIX_SPORADIC_SERVER);
+ MACRO(_POSIX_SYNCHRONIZED_IO);
+ MACRO(_POSIX_THREAD_ATTR_STACKADDR);
+ MACRO(_POSIX_THREAD_ATTR_STACKSIZE);
+ MACRO(_POSIX_THREAD_CPUTIME);
+ MACRO(_POSIX_THREAD_PRIO_INHERIT);
+ MACRO(_POSIX_THREAD_PRIO_PROTECT);
+ MACRO(_POSIX_THREAD_PRIORITY_SCHEDULING);
+ MACRO(_POSIX_THREAD_PROCESS_SHARED);
+ MACRO(_POSIX_THREAD_ROBUST_PRIO_INHERIT);
+ MACRO(_POSIX_THREAD_ROBUST_PRIO_PROTECT);
+ MACRO(_POSIX_THREAD_SAFE_FUNCTIONS);
+ MACRO(_POSIX_THREAD_SPORADIC_SERVER);
+ MACRO(_POSIX_THREADS);
+ MACRO(_POSIX_TIMEOUTS);
+ MACRO(_POSIX_TIMERS);
+ MACRO(_POSIX_TYPED_MEMORY_OBJECTS);
+ MACRO(_POSIX2_C_BIND);
+ MACRO(_POSIX2_CHAR_TERM);
+ MACRO(_POSIX2_LOCALEDEF);
+ MACRO(_POSIX2_SW_DEV);
+#if 0 // No libc I can find actually has this.
+ MACRO(_POSIX2_UPE);
+#endif
+ MACRO(_XOPEN_CRYPT);
+ MACRO(_XOPEN_ENH_I18N);
+ MACRO(_XOPEN_REALTIME);
+ MACRO(_XOPEN_REALTIME_THREADS);
+ MACRO(_XOPEN_SHM);
+ MACRO(_XOPEN_UNIX);
+#if defined(_XOPEN_UUCP)
+#if _XOPEN_UUCP != -1 && _XOPEN_UUCP != 0 && _XOPEN_UUCP != 200809L
+#error _XOPEN_UUCP
+#endif
+#endif
+
+ MACRO(NULL);
+
+ MACRO(F_OK);
+ MACRO(R_OK);
+ MACRO(W_OK);
+ MACRO(X_OK);
+
+#if !defined(__BIONIC__) // No confstr on Android.
+ MACRO(_CS_PATH);
+ MACRO(_CS_POSIX_V7_ILP32_OFF32_CFLAGS);
+ MACRO(_CS_POSIX_V7_ILP32_OFF32_LDFLAGS);
+ MACRO(_CS_POSIX_V7_ILP32_OFF32_LIBS);
+ MACRO(_CS_POSIX_V7_ILP32_OFFBIG_CFLAGS);
+ MACRO(_CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS);
+ MACRO(_CS_POSIX_V7_ILP32_OFFBIG_LIBS);
+ MACRO(_CS_POSIX_V7_LP64_OFF64_CFLAGS);
+ MACRO(_CS_POSIX_V7_LP64_OFF64_LDFLAGS);
+ MACRO(_CS_POSIX_V7_LP64_OFF64_LIBS);
+ MACRO(_CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS);
+ MACRO(_CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS);
+ MACRO(_CS_POSIX_V7_LPBIG_OFFBIG_LIBS);
+ MACRO(_CS_POSIX_V7_WIDTH_RESTRICTED_ENVS);
+ MACRO(_CS_V7_ENV);
+#endif
+
+ MACRO(SEEK_CUR);
+ MACRO(SEEK_END);
+ MACRO(SEEK_SET);
+
+ MACRO(F_LOCK);
+ MACRO(F_TEST);
+ MACRO(F_TLOCK);
+ MACRO(F_ULOCK);
+
+ MACRO(_PC_2_SYMLINKS);
+ MACRO(_PC_ALLOC_SIZE_MIN);
+ MACRO(_PC_ASYNC_IO);
+ MACRO(_PC_CHOWN_RESTRICTED);
+ MACRO(_PC_FILESIZEBITS);
+ MACRO(_PC_LINK_MAX);
+ MACRO(_PC_MAX_CANON);
+ MACRO(_PC_MAX_INPUT);
+ MACRO(_PC_NAME_MAX);
+ MACRO(_PC_NO_TRUNC);
+ MACRO(_PC_PATH_MAX);
+ MACRO(_PC_PIPE_BUF);
+ MACRO(_PC_PRIO_IO);
+ MACRO(_PC_REC_INCR_XFER_SIZE);
+ MACRO(_PC_REC_MAX_XFER_SIZE);
+ MACRO(_PC_REC_MIN_XFER_SIZE);
+ MACRO(_PC_REC_XFER_ALIGN);
+ MACRO(_PC_SYMLINK_MAX);
+ MACRO(_PC_SYNC_IO);
+#if 0 // No libc I can find actually has this.
+ MACRO(_PC_TIMESTAMP_RESOLUTION);
+#endif
+ MACRO(_PC_VDISABLE);
+
+ MACRO(_SC_2_C_BIND);
+ MACRO(_SC_2_C_DEV);
+ MACRO(_SC_2_CHAR_TERM);
+ MACRO(_SC_2_FORT_DEV);
+ MACRO(_SC_2_FORT_RUN);
+ MACRO(_SC_2_LOCALEDEF);
+ MACRO(_SC_2_SW_DEV);
+ MACRO(_SC_2_UPE);
+ MACRO(_SC_2_VERSION);
+ MACRO(_SC_ADVISORY_INFO);
+ MACRO(_SC_AIO_LISTIO_MAX);
+ MACRO(_SC_AIO_MAX);
+ MACRO(_SC_AIO_PRIO_DELTA_MAX);
+ MACRO(_SC_ARG_MAX);
+ MACRO(_SC_ASYNCHRONOUS_IO);
+ MACRO(_SC_ATEXIT_MAX);
+ MACRO(_SC_BARRIERS);
+ MACRO(_SC_BC_BASE_MAX);
+ MACRO(_SC_BC_DIM_MAX);
+ MACRO(_SC_BC_SCALE_MAX);
+ MACRO(_SC_BC_STRING_MAX);
+ MACRO(_SC_CHILD_MAX);
+ MACRO(_SC_CLK_TCK);
+ MACRO(_SC_CLOCK_SELECTION);
+ MACRO(_SC_COLL_WEIGHTS_MAX);
+ MACRO(_SC_CPUTIME);
+ MACRO(_SC_DELAYTIMER_MAX);
+ MACRO(_SC_EXPR_NEST_MAX);
+ MACRO(_SC_FSYNC);
+ MACRO(_SC_GETGR_R_SIZE_MAX);
+ MACRO(_SC_GETPW_R_SIZE_MAX);
+ MACRO(_SC_HOST_NAME_MAX);
+ MACRO(_SC_IOV_MAX);
+ MACRO(_SC_IPV6);
+ MACRO(_SC_JOB_CONTROL);
+ MACRO(_SC_LINE_MAX);
+ MACRO(_SC_LOGIN_NAME_MAX);
+ MACRO(_SC_MAPPED_FILES);
+ MACRO(_SC_MEMLOCK);
+ MACRO(_SC_MEMLOCK_RANGE);
+ MACRO(_SC_MEMORY_PROTECTION);
+ MACRO(_SC_MESSAGE_PASSING);
+ MACRO(_SC_MONOTONIC_CLOCK);
+ MACRO(_SC_MQ_OPEN_MAX);
+ MACRO(_SC_MQ_PRIO_MAX);
+ MACRO(_SC_NGROUPS_MAX);
+ MACRO(_SC_OPEN_MAX);
+ MACRO(_SC_PAGE_SIZE);
+ MACRO(_SC_PAGESIZE);
+ MACRO(_SC_PRIORITIZED_IO);
+ MACRO(_SC_PRIORITY_SCHEDULING);
+ MACRO(_SC_RAW_SOCKETS);
+ MACRO(_SC_RE_DUP_MAX);
+ MACRO(_SC_READER_WRITER_LOCKS);
+ MACRO(_SC_REALTIME_SIGNALS);
+ MACRO(_SC_REGEXP);
+ MACRO(_SC_RTSIG_MAX);
+ MACRO(_SC_SAVED_IDS);
+ MACRO(_SC_SEM_NSEMS_MAX);
+ MACRO(_SC_SEM_VALUE_MAX);
+ MACRO(_SC_SEMAPHORES);
+ MACRO(_SC_SHARED_MEMORY_OBJECTS);
+ MACRO(_SC_SHELL);
+ MACRO(_SC_SIGQUEUE_MAX);
+ MACRO(_SC_SPAWN);
+ MACRO(_SC_SPIN_LOCKS);
+ MACRO(_SC_SPORADIC_SERVER);
+ MACRO(_SC_SS_REPL_MAX);
+ MACRO(_SC_STREAM_MAX);
+ MACRO(_SC_SYMLOOP_MAX);
+ MACRO(_SC_SYNCHRONIZED_IO);
+ MACRO(_SC_THREAD_ATTR_STACKADDR);
+ MACRO(_SC_THREAD_ATTR_STACKSIZE);
+ MACRO(_SC_THREAD_CPUTIME);
+ MACRO(_SC_THREAD_DESTRUCTOR_ITERATIONS);
+ MACRO(_SC_THREAD_KEYS_MAX);
+ MACRO(_SC_THREAD_PRIO_INHERIT);
+ MACRO(_SC_THREAD_PRIO_PROTECT);
+ MACRO(_SC_THREAD_PRIORITY_SCHEDULING);
+ MACRO(_SC_THREAD_PROCESS_SHARED);
+ MACRO(_SC_THREAD_ROBUST_PRIO_INHERIT);
+ MACRO(_SC_THREAD_ROBUST_PRIO_PROTECT);
+ MACRO(_SC_THREAD_SAFE_FUNCTIONS);
+ MACRO(_SC_THREAD_SPORADIC_SERVER);
+ MACRO(_SC_THREAD_STACK_MIN);
+ MACRO(_SC_THREAD_THREADS_MAX);
+ MACRO(_SC_THREADS);
+ MACRO(_SC_TIMEOUTS);
+ MACRO(_SC_TIMER_MAX);
+ MACRO(_SC_TIMERS);
+ MACRO(_SC_TRACE);
+ MACRO(_SC_TRACE_EVENT_FILTER);
+ MACRO(_SC_TRACE_EVENT_NAME_MAX);
+ MACRO(_SC_TRACE_INHERIT);
+ MACRO(_SC_TRACE_LOG);
+ MACRO(_SC_TRACE_NAME_MAX);
+ MACRO(_SC_TRACE_SYS_MAX);
+ MACRO(_SC_TRACE_USER_EVENT_MAX);
+ MACRO(_SC_TYPED_MEMORY_OBJECTS);
+ MACRO(_SC_TZNAME_MAX);
+ MACRO(_SC_V7_ILP32_OFF32);
+ MACRO(_SC_VERSION);
+ MACRO(_SC_XOPEN_CRYPT);
+ MACRO(_SC_XOPEN_ENH_I18N);
+ MACRO(_SC_XOPEN_REALTIME);
+ MACRO(_SC_XOPEN_REALTIME_THREADS);
+ MACRO(_SC_XOPEN_SHM);
+ MACRO(_SC_XOPEN_STREAMS);
+ MACRO(_SC_XOPEN_UNIX);
+#if 0 // No libc I can find actually has this.
+ MACRO(_SC_XOPEN_UUCP);
+#endif
+ MACRO(_SC_XOPEN_VERSION);
+
+ MACRO_VALUE(STDERR_FILENO, 2);
+ MACRO_VALUE(STDIN_FILENO, 0);
+ MACRO_VALUE(STDOUT_FILENO, 1);
+
+ MACRO(_POSIX_VDISABLE);
+
+ TYPE(size_t);
+ TYPE(ssize_t);
+ TYPE(uid_t);
+ TYPE(gid_t);
+ TYPE(off_t);
+ TYPE(pid_t);
+ TYPE(intptr_t);
+
+ FUNCTION(access, int (*f)(const char*, int));
+ FUNCTION(alarm, unsigned (*f)(unsigned));
+ FUNCTION(chdir, int (*f)(const char*));
+ FUNCTION(chown, int (*f)(const char*, uid_t, gid_t));
+ FUNCTION(close, int (*f)(int));
+#if !defined(__BIONIC__)
+ FUNCTION(confstr, size_t (*f)(int, char*, size_t));
+ FUNCTION(crypt, char* (*f)(const char*, const char*));
+#endif
+ FUNCTION(dup, int (*f)(int));
+ FUNCTION(dup2, int (*f)(int, int));
+ FUNCTION(_exit, void (*f)(int));
+#if !defined(__BIONIC__)
+ FUNCTION(encrypt, void (*f)(char[64], int));
+#endif
+ FUNCTION(execl, int (*f)(const char*, const char*, ...));
+ FUNCTION(execle, int (*f)(const char*, const char*, ...));
+ FUNCTION(execlp, int (*f)(const char*, const char*, ...));
+ FUNCTION(execv, int (*f)(const char*, char* const[]));
+ FUNCTION(execve, int (*f)(const char*, char* const[], char* const[]));
+ FUNCTION(execvp, int (*f)(const char*, char* const[]));
+ FUNCTION(faccessat, int (*f)(int, const char*, int, int));
+ FUNCTION(fchdir, int (*f)(int));
+ FUNCTION(fchown, int (*f)(int, uid_t, gid_t));
+ FUNCTION(fchownat, int (*f)(int, const char*, uid_t, gid_t, int));
+ FUNCTION(fdatasync, int (*f)(int));
+ FUNCTION(fexecve, int (*f)(int, char* const[], char* const[]));
+ FUNCTION(fork, pid_t (*f)(void));
+ FUNCTION(fpathconf, long (*f)(int, int));
+ FUNCTION(fsync, int (*f)(int));
+ FUNCTION(ftruncate, int (*f)(int, off_t));
+ FUNCTION(getcwd, char* (*f)(char*, size_t));
+ FUNCTION(getegid, gid_t (*f)(void));
+ FUNCTION(geteuid, uid_t (*f)(void));
+ FUNCTION(getgid, gid_t (*f)(void));
+ FUNCTION(getgroups, int (*f)(int, gid_t[]));
+#if !defined(__BIONIC__)
+ FUNCTION(gethostid, long (*f)(void));
+#endif
+ FUNCTION(gethostname, int (*f)(char*, size_t));
+ FUNCTION(getlogin, char* (*f)(void));
+ FUNCTION(getlogin_r, int (*f)(char*, size_t));
+ FUNCTION(getopt, int (*f)(int, char* const[], const char*));
+ FUNCTION(getpgid, pid_t (*f)(pid_t));
+ FUNCTION(getpgrp, pid_t (*f)(void));
+ FUNCTION(getpid, pid_t (*f)(void));
+ FUNCTION(getppid, pid_t (*f)(void));
+ FUNCTION(getsid, pid_t (*f)(pid_t));
+ FUNCTION(getuid, uid_t (*f)(void));
+ FUNCTION(isatty, int (*f)(int));
+ FUNCTION(lchown, int (*f)(const char*, uid_t, gid_t));
+ FUNCTION(link, int (*f)(const char*, const char*));
+ FUNCTION(linkat, int (*f)(int, const char*, int, const char*, int));
+ FUNCTION(lockf, int (*f)(int, int, off_t));
+ FUNCTION(lseek, off_t (*f)(int, off_t, int));
+ FUNCTION(nice, int (*f)(int));
+ FUNCTION(pathconf, long (*f)(const char*, int));
+ FUNCTION(pause, int (*f)(void));
+ FUNCTION(pipe, int (*f)(int[2]));
+ FUNCTION(pread, ssize_t (*f)(int, void*, size_t, off_t));
+ FUNCTION(pwrite, ssize_t (*f)(int, const void*, size_t, off_t));
+ FUNCTION(read, ssize_t (*f)(int, void*, size_t));
+ FUNCTION(readlink, ssize_t (*f)(const char*, char*, size_t));
+ FUNCTION(readlinkat, ssize_t (*f)(int, const char*, char*, size_t));
+ FUNCTION(rmdir, int (*f)(const char*));
+ FUNCTION(setegid, int (*f)(gid_t));
+ FUNCTION(seteuid, int (*f)(uid_t));
+ FUNCTION(setgid, int (*f)(gid_t));
+ FUNCTION(setpgid, int (*f)(pid_t, pid_t));
+ FUNCTION(setpgrp, pid_t (*f)(void));
+ FUNCTION(setregid, int (*f)(gid_t, gid_t));
+ FUNCTION(setreuid, int (*f)(uid_t, uid_t));
+ FUNCTION(setsid, pid_t (*f)(void));
+ FUNCTION(setuid, int (*f)(uid_t));
+ FUNCTION(sleep, unsigned (*f)(unsigned));
+ FUNCTION(swab, void (*f)(const void*, void*, ssize_t));
+ FUNCTION(symlink, int (*f)(const char*, const char*));
+ FUNCTION(symlinkat, int (*f)(const char*, int, const char*));
+ FUNCTION(sync, void (*f)(void));
+ FUNCTION(sysconf, long (*f)(int));
+ FUNCTION(tcgetpgrp, pid_t (*f)(int));
+ FUNCTION(tcsetpgrp, int (*f)(int, pid_t));
+ FUNCTION(truncate, int (*f)(const char*, off_t));
+ FUNCTION(ttyname, char* (*f)(int));
+ FUNCTION(ttyname_r, int (*f)(int, char*, size_t));
+ FUNCTION(unlink, int (*f)(const char*));
+ FUNCTION(unlinkat, int (*f)(int, const char*, int));
+ FUNCTION(write, ssize_t (*f)(int, const void*, size_t));
+
+ char* cp;
+ cp = optarg;
+ int i;
+ i = opterr;
+ i = optind;
+ i = optopt;
+}