Add mqueue rt api, add header tests

47 files changed, 2158 insertions, 5 deletions

diff --git a/include/mqueue.h b/include/mqueue.h
index c4582748..109123e4 100644
--- a/include/mqueue.h
+++ b/include/mqueue.h
@@ -1,11 +1,9 @@
 #ifndef __MQUEUE_H
 #define __MQUEUE_H
 
-#include <stddef.h>
-#include <time.h>
-#define __BITS_TIMESPEC_H_
-#include <bits/timespec.h>
-#undef __BITS_TIMESPEC_H_
+#include <sys/cdefs.h>
+
+__BEGIN_DECLS
 
 #undef O_RDONLY
 #define O_RDONLY 000000000
@@ -26,6 +24,7 @@ typedef __SIZE_TYPE__ size_t;
 typedef __INT64_TYPE__ ssize_t;
 
 struct sigevent;
+struct timespec;
 struct mq_attr {
 	long mq_flags;
 	long mq_maxmsg;
@@ -46,4 +45,6 @@ int mq_timedsend(mqd_t, const char *, size_t, unsigned,
 		 const struct timespec *);
 int mq_unlink(const char *);
 
+__END_DECLS
+
 #endif
diff --git a/lib/libc/Kbuild b/lib/libc/Kbuild
index 7de874f6..28ef1c99 100644
--- a/lib/libc/Kbuild
+++ b/lib/libc/Kbuild
@@ -19,6 +19,7 @@ obj-y += inttypes/
 obj-y += libgen/
 obj-y += mman/
 obj-y += monetary/
+obj-y += mqueue/
 obj-y += msg/
 obj-y += poll/
 obj-y += pwd/
diff --git a/lib/libc/mqueue/Kbuild b/lib/libc/mqueue/Kbuild
new file mode 100644
index 00000000..52c3dbbc
--- /dev/null
+++ b/lib/libc/mqueue/Kbuild
@@ -0,0 +1,9 @@
+obj-y += mq_close.o
+obj-y += mq_getattr.o
+obj-y += mq_notify.o
+obj-y += mq_open.o
+obj-y += mq_receive.o
+obj-y += mq_setattr.o
+obj-y += mq_timedreceive.o
+obj-y += mq_timedsend.o
+obj-y += mq_unlink.o
diff --git a/lib/libc/mqueue/mq_close.c b/lib/libc/mqueue/mq_close.c
new file mode 100644
index 00000000..50877fb1
--- /dev/null
+++ b/lib/libc/mqueue/mq_close.c
@@ -0,0 +1,7 @@
+#include <mqueue.h>
+#include <syscall.h>
+
+int mq_close(mqd_t mqdes)
+{
+	return syscall(close, mqdes);
+}
diff --git a/lib/libc/mqueue/mq_getattr.c b/lib/libc/mqueue/mq_getattr.c
new file mode 100644
index 00000000..f5ca62de
--- /dev/null
+++ b/lib/libc/mqueue/mq_getattr.c
@@ -0,0 +1,7 @@
+#include <mqueue.h>
+#include <syscall.h>
+
+int mq_getattr(mqd_t mqdes, struct mq_attr *mqstat)
+{
+	return mq_setattr(mqdes, 0, mqstat);
+}
diff --git a/lib/libc/mqueue/mq_notify.c b/lib/libc/mqueue/mq_notify.c
new file mode 100644
index 00000000..a7617375
--- /dev/null
+++ b/lib/libc/mqueue/mq_notify.c
@@ -0,0 +1,15 @@
+#include <mqueue.h>
+#include <signal.h>
+#include <syscall.h>
+
+int mq_notify(mqd_t mqdes, const struct sigevent *notification)
+{
+	if (notification == NULL ||
+	    notification->sigev_notify != SIGEV_THREAD) {
+		return syscall(mq_notify, mqdes, notification);
+	}
+
+	// TODO: implement SIGEV_THREAD notification
+	errno = ENOSYS;
+	return -1;
+}
diff --git a/lib/libc/mqueue/mq_open.c b/lib/libc/mqueue/mq_open.c
new file mode 100644
index 00000000..15ae9e18
--- /dev/null
+++ b/lib/libc/mqueue/mq_open.c
@@ -0,0 +1,26 @@
+#include <fcntl.h>
+#include <mqueue.h>
+#include <stdarg.h>
+#include <syscall.h>
+
+mqd_t mq_open(const char *name, int oflag, ...)
+{
+	mode_t mode;
+	struct mq_attr *attr;
+
+	if (*name == '/')
+		name++;
+
+	if (oflag & O_CREAT) {
+		va_list ap;
+		va_start(ap, oflag);
+		mode = va_arg(ap, mode_t);
+		attr = va_arg(ap, struct mq_attr *);
+		va_end(ap);
+	} else {
+		mode = 0;
+		attr = 0;
+	}
+
+	return syscall(mq_open, name, oflag, mode, attr);
+}
diff --git a/lib/libc/mqueue/mq_receive.c b/lib/libc/mqueue/mq_receive.c
new file mode 100644
index 00000000..98d3cd9e
--- /dev/null
+++ b/lib/libc/mqueue/mq_receive.c
@@ -0,0 +1,7 @@
+#include <mqueue.h>
+
+ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len,
+		   unsigned *msg_prio)
+{
+	return mq_timedreceive(mqdes, msg_ptr, msg_len, msg_prio, 0);
+}
diff --git a/lib/libc/mqueue/mq_setattr.c b/lib/libc/mqueue/mq_setattr.c
new file mode 100644
index 00000000..be2a3b3d
--- /dev/null
+++ b/lib/libc/mqueue/mq_setattr.c
@@ -0,0 +1,8 @@
+#include <mqueue.h>
+#include <syscall.h>
+
+int mq_setattr(mqd_t mqdes, const struct mq_attr *restrict mqstat,
+	       struct mq_attr *restrict omqstat)
+{
+	return syscall(mq_getsetattr, mqdes, mqstat, omqstat);
+}
diff --git a/lib/libc/mqueue/mq_timedreceive.c b/lib/libc/mqueue/mq_timedreceive.c
new file mode 100644
index 00000000..bf877fa5
--- /dev/null
+++ b/lib/libc/mqueue/mq_timedreceive.c
@@ -0,0 +1,10 @@
+#include <mqueue.h>
+#include <syscall.h>
+
+ssize_t mq_timedreceive(mqd_t mqdes, char *restrict msg_ptr, size_t msg_len,
+			unsigned *restrict msg_prio,
+			const struct timespec *restrict abstime)
+{
+	return syscall(mq_timedreceive, mqdes, msg_ptr, msg_len, msg_prio,
+		       abstime);
+}
diff --git a/lib/libc/mqueue/mq_timedsend.c b/lib/libc/mqueue/mq_timedsend.c
new file mode 100644
index 00000000..228a5d06
--- /dev/null
+++ b/lib/libc/mqueue/mq_timedsend.c
@@ -0,0 +1,9 @@
+#include <mqueue.h>
+#include <syscall.h>
+
+int mq_timedsend(mqd_t mqdes, const char *msg_ptr, size_t msg_len,
+		 unsigned msg_prio, const struct timespec *abstime)
+{
+	return syscall(mq_timedsend, mqdes, msg_ptr, msg_len, msg_prio,
+		       abstime);
+}
diff --git a/lib/libc/mqueue/mq_unlink.c b/lib/libc/mqueue/mq_unlink.c
new file mode 100644
index 00000000..d136f109
--- /dev/null
+++ b/lib/libc/mqueue/mq_unlink.c
@@ -0,0 +1,22 @@
+#include <mqueue.h>
+#include <syscall.h>
+
+int mq_unlink(const char *name)
+{
+	int r;
+
+	if (*name == '/')
+		name++;
+
+	r = __syscall(mq_unlink, name);
+
+	if (r < 0) {
+		// Correct errno for POSIX compliance
+		if (r == -EPERM)
+			r = -EACCES;
+		errno = -r;
+		return -1;
+	}
+
+	return r;
+}
diff --git a/tests/headers/aio.c b/tests/headers/aio.c
new file mode 100644
index 00000000..eabdf4be
--- /dev/null
+++ b/tests/headers/aio.c
@@ -0,0 +1,36 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/aio.h.html
+
+#include "core.h"
+
+#include <aio.h>
+
+TEST(aio_h)
+{
+	MACRO_VALUE(AIO_CANCELED, 0);
+	MACRO_VALUE(AIO_NOTCANCELED, 1);
+	MACRO_VALUE(AIO_ALLDONE, 2);
+
+	MACRO_VALUE(LIO_READ, 0);
+	MACRO_VALUE(LIO_WRITE, 1);
+	MACRO_VALUE(LIO_NOP, 2);
+
+	MACRO_VALUE(LIO_WAIT, 0);
+	MACRO_VALUE(LIO_NOWAIT, 1);
+
+	TYPE(off_t);
+	TYPE(size_t);
+	TYPE(ssize_t);
+	TYPE(struct aiocb);
+	TYPE(struct sigevent);
+	TYPE(struct timespec);
+
+	FUNCTION(aio_cancel, int (*_)(int, struct aiocb *));
+	FUNCTION(aio_error, int (*_)(const struct aiocb *));
+	FUNCTION(aio_fsync, int (*_)(int, struct aiocb *));
+	FUNCTION(aio_read, int (*_)(struct aiocb *));
+	FUNCTION(aio_return, ssize_t(*_)(struct aiocb *));
+	FUNCTION(aio_suspend, int (*_)(const struct aiocb *const[], int,
+				       const struct timespec *));
+	FUNCTION(lio_listio, int (*_)(int, struct aiocb *restrict const[], int,
+				      struct sigevent *restrict));
+}
diff --git a/tests/headers/arpa_inet.c b/tests/headers/arpa_inet.c
new file mode 100644
index 00000000..b5a5c33a
--- /dev/null
+++ b/tests/headers/arpa_inet.c
@@ -0,0 +1,30 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/arpa_inet.h.html
+
+#include "core.h"
+
+#include <arpa/inet.h>
+
+TEST(arpa_inet_h)
+{
+	TYPE(in_port_t);
+	TYPE(in_addr_t);
+
+	TYPE(struct in_addr);
+
+	MACRO(INET_ADDRSTRLEN);
+	MACRO(INET6_ADDRSTRLEN);
+
+	FUNCTION(htonl, FN(uint32_t, uint32_t))
+	FUNCTION(htons, FN(uint16_t, uint16_t))
+	FUNCTION(ntohl, FN(uint32_t, uint32_t))
+	FUNCTION(ntohs, FN(uint16_t, uint16_t))
+
+	TYPE(uint32_t);
+	TYPE(uint16_t);
+
+	FUNCTION(inet_addr, FN(in_addr_t, const char *))
+	FUNCTION(inet_ntoa, FN(char *, struct in_addr))
+	FUNCTION(inet_ntop, FN(const char *, int, const void *restrict,
+			       char *restrict, socklen_t));
+	FUNCTION(inet_pton, FN(int, int, const char *restrict, void *restrict))
+}
diff --git a/tests/headers/assert.c b/tests/headers/assert.c
new file mode 100644
index 00000000..13ee506c
--- /dev/null
+++ b/tests/headers/assert.c
@@ -0,0 +1,15 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/assert.h.html
+
+#include "core.h"
+
+#define NDEBUG
+#include <assert.h>
+#ifndef assert
+#error
+#endif
+
+#undef NDEBUG
+#include <assert.h>
+#ifndef assert
+#error
+#endif
diff --git a/tests/headers/complex.c b/tests/headers/complex.c
new file mode 100644
index 00000000..054d25ac
--- /dev/null
+++ b/tests/headers/complex.c
@@ -0,0 +1,117 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/complex.h.html
+
+#include "core.h"
+
+#include <complex.h>
+
+#ifndef complex
+#error complex
+#endif
+
+#ifndef _Complex_I
+#error _Complex_I
+#endif
+
+#ifndef imaginary
+#error imaginary
+#endif
+
+#ifndef _Imaginary_I
+#error _Imaginary_I
+#endif
+
+#if !defined(I)
+#error I
+#endif
+
+TEST(complex_h)
+{
+	FUNCTION(cabs, double (*f)(double complex));
+	FUNCTION(cabsf, float (*f)(float complex));
+	FUNCTION(cabsl, long double (*f)(long double complex));
+
+	FUNCTION(cacos, double complex (*f)(double complex));
+	FUNCTION(cacosf, float complex (*f)(float complex));
+	FUNCTION(cacosl, long double complex (*f)(long double complex));
+
+	FUNCTION(cacosh, double complex (*f)(double complex));
+	FUNCTION(cacoshf, float complex (*f)(float complex));
+	FUNCTION(cacoshl, long double complex (*f)(long double complex));
+
+	FUNCTION(carg, double (*f)(double complex));
+	FUNCTION(cargf, float (*f)(float complex));
+	FUNCTION(cargl, long double (*f)(long double complex));
+
+	FUNCTION(casin, double complex (*f)(double complex));
+	FUNCTION(casinf, float complex (*f)(float complex));
+	FUNCTION(casinl, long double complex (*f)(long double complex));
+
+	FUNCTION(casinh, double complex (*f)(double complex));
+	FUNCTION(casinhf, float complex (*f)(float complex));
+	FUNCTION(casinhl, long double complex (*f)(long double complex));
+
+	FUNCTION(catan, double complex (*f)(double complex));
+	FUNCTION(catanf, float complex (*f)(float complex));
+	FUNCTION(catanl, long double complex (*f)(long double complex));
+
+	FUNCTION(catanh, double complex (*f)(double complex));
+	FUNCTION(catanhf, float complex (*f)(float complex));
+	FUNCTION(catanhl, long double complex (*f)(long double complex));
+
+	FUNCTION(ccos, double complex (*f)(double complex));
+	FUNCTION(ccosf, float complex (*f)(float complex));
+	FUNCTION(ccosl, long double complex (*f)(long double complex));
+
+	FUNCTION(ccosh, double complex (*f)(double complex));
+	FUNCTION(ccoshf, float complex (*f)(float complex));
+	FUNCTION(ccoshl, long double complex (*f)(long double complex));
+
+	FUNCTION(cexp, double complex (*f)(double complex));
+	FUNCTION(cexpf, float complex (*f)(float complex));
+	FUNCTION(cexpl, long double complex (*f)(long double complex));
+
+	FUNCTION(cimag, double (*f)(double complex));
+	FUNCTION(cimagf, float (*f)(float complex));
+	FUNCTION(cimagl, long double (*f)(long double complex));
+
+	FUNCTION(clog, double complex (*f)(double complex));
+	FUNCTION(clogf, float complex (*f)(float complex));
+	FUNCTION(clogl, long double complex (*f)(long double complex));
+
+	FUNCTION(conj, double complex (*f)(double complex));
+	FUNCTION(conjf, float complex (*f)(float complex));
+	FUNCTION(conjl, long double complex (*f)(long double complex));
+
+	FUNCTION(cpow, double complex (*f)(double complex, double complex));
+	FUNCTION(cpowf, float complex (*f)(float complex, float complex));
+	FUNCTION(cpowl, long double complex (*f)(long double complex,
+						 long double complex));
+
+	FUNCTION(cproj, double complex (*f)(double complex));
+	FUNCTION(cprojf, float complex (*f)(float complex));
+	FUNCTION(cprojl, long double complex (*f)(long double complex));
+
+	FUNCTION(creal, double (*f)(double complex));
+	FUNCTION(crealf, float (*f)(float complex));
+	FUNCTION(creall, long double (*f)(long double complex));
+
+	FUNCTION(csin, double complex (*f)(double complex));
+	FUNCTION(csinf, float complex (*f)(float complex));
+	FUNCTION(csinl, long double complex (*f)(long double complex));
+
+	FUNCTION(csinh, double complex (*f)(double complex));
+	FUNCTION(csinhf, float complex (*f)(float complex));
+	FUNCTION(csinhl, long double complex (*f)(long double complex));
+
+	FUNCTION(csqrt, double complex (*f)(double complex));
+	FUNCTION(csqrtf, float complex (*f)(float complex));
+	FUNCTION(csqrtl, long double complex (*f)(long double complex));
+
+	FUNCTION(ctan, double complex (*f)(double complex));
+	FUNCTION(ctanf, float complex (*f)(float complex));
+	FUNCTION(ctanl, long double complex (*f)(long double complex));
+
+	FUNCTION(ctanh, double complex (*f)(double complex));
+	FUNCTION(ctanhf, float complex (*f)(float complex));
+	FUNCTION(ctanhl, long double complex (*f)(long double complex));
+}
diff --git a/tests/headers/core.h b/tests/headers/core.h
new file mode 100644
index 00000000..01c6aa5e
--- /dev/null
+++ b/tests/headers/core.h
@@ -0,0 +1,54 @@
+#define FN(__r, ...) __r (*_)(__VA_ARGS__)
+
+#define FUNCTION(__f, __t) \
+	{                  \
+		__t = __f; \
+	}
+
+#define MACRO(__m)                   \
+	{                            \
+		typeof(__m) v = __m; \
+	}
+
+#define MACRO_VALUE(__m, __v) _Static_assert(__m == __v, #__m)
+
+#define MACRO_VALUE_STRING(__m, __v)                                       \
+	do {                                                               \
+		(void)sizeof(                                              \
+			char[(__builtin_strcmp(__m, __v) == 0) ? 1 : -1]); \
+	} while (0)
+
+#define MACRO_TYPE(__t, __m) \
+	{                    \
+		__t v = __m; \
+	}
+
+#define TYPE(__t)      \
+	{              \
+		__t v; \
+	}
+
+#define INCOMPLETE_TYPE(__t) \
+	{                    \
+		__t *v;      \
+	}
+
+#define STRUCT_MEMBER(__s, __t, __n) \
+	{                            \
+		__s s;               \
+		__t *_ = &(s.__n);   \
+	}
+
+#define STRUCT_MEMBER_ARRAY(__s, __t, __n) \
+	{                                  \
+		__s s;                     \
+		__t *p = &(s.__n[0]);      \
+	}
+
+#define STRUCT_MEMBER_FUNCTION_POINTER(__s, __t, __n) \
+	{                                             \
+		__s s;                                \
+		__t = (s.__n);                        \
+	}
+
+#define TEST(__name) static void __name(void)
diff --git a/tests/headers/cpio.c b/tests/headers/cpio.c
new file mode 100644
index 00000000..da30327f
--- /dev/null
+++ b/tests/headers/cpio.c
@@ -0,0 +1,38 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/cpio.h.html
+
+#include "core.h"
+
+#include <cpio.h>
+
+#ifndef MAGIC
+#error MAGIC
+#endif
+
+TEST(cpio_h)
+{
+	MACRO_VALUE(C_IRUSR, 0400);
+	MACRO_VALUE(C_IWUSR, 0200);
+	MACRO_VALUE(C_IXUSR, 0100);
+
+	MACRO_VALUE(C_IRGRP, 040);
+	MACRO_VALUE(C_IWGRP, 020);
+	MACRO_VALUE(C_IXGRP, 010);
+
+	MACRO_VALUE(C_IROTH, 04);
+	MACRO_VALUE(C_IWOTH, 02);
+	MACRO_VALUE(C_IXOTH, 01);
+
+	MACRO_VALUE(C_ISUID, 04000);
+	MACRO_VALUE(C_ISGID, 02000);
+	MACRO_VALUE(C_ISVTX, 01000);
+
+	MACRO_VALUE(C_ISDIR, 040000);
+	MACRO_VALUE(C_ISFIFO, 010000);
+	MACRO_VALUE(C_ISREG, 0100000);
+	MACRO_VALUE(C_ISBLK, 060000);
+	MACRO_VALUE(C_ISCHR, 020000);
+
+	MACRO_VALUE(C_ISCTG, 0110000);
+	MACRO_VALUE(C_ISLNK, 0120000);
+	MACRO_VALUE(C_ISSOCK, 0140000);
+}
diff --git a/tests/headers/ctype.c b/tests/headers/ctype.c
new file mode 100644
index 00000000..86ae02a8
--- /dev/null
+++ b/tests/headers/ctype.c
@@ -0,0 +1,35 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/ctype.h.html
+
+#include "core.h"
+
+#include <ctype.h>
+
+TEST(ctype_h)
+{
+	TYPE(locale_t);
+
+	FUNCTION(isalnum, int (*f)(int));
+	FUNCTION(isalnum_l, int (*f)(int, locale_t));
+	FUNCTION(isalpha, int (*f)(int));
+	FUNCTION(isalpha_l, int (*f)(int, locale_t));
+	FUNCTION(isblank, int (*f)(int));
+	FUNCTION(isblank_l, int (*f)(int, locale_t));
+	FUNCTION(iscntrl, int (*f)(int));
+	FUNCTION(iscntrl_l, int (*f)(int, locale_t));
+	FUNCTION(isdigit, int (*f)(int));
+	FUNCTION(isdigit_l, int (*f)(int, locale_t));
+	FUNCTION(isgraph, int (*f)(int));
+	FUNCTION(isgraph_l, int (*f)(int, locale_t));
+	FUNCTION(islower, int (*f)(int));
+	FUNCTION(islower_l, int (*f)(int, locale_t));
+	FUNCTION(isprint, int (*f)(int));
+	FUNCTION(isprint_l, int (*f)(int, locale_t));
+	FUNCTION(ispunct, int (*f)(int));
+	FUNCTION(ispunct_l, int (*f)(int, locale_t));
+	FUNCTION(isspace, int (*f)(int));
+	FUNCTION(isspace_l, int (*f)(int, locale_t));
+	FUNCTION(isupper, int (*f)(int));
+	FUNCTION(isupper_l, int (*f)(int, locale_t));
+	FUNCTION(isxdigit, int (*f)(int));
+	FUNCTION(isxdigit_l, int (*f)(int, locale_t));
+}
diff --git a/tests/headers/devctl.c b/tests/headers/devctl.c
new file mode 100644
index 00000000..cf40ac37
--- /dev/null
+++ b/tests/headers/devctl.c
@@ -0,0 +1,13 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/devctl.h.html
+
+#include "core.h"
+
+#include <devctl.h>
+
+TEST(devctl_h)
+{
+	TYPE(size_t);
+
+	FUNCTION(posix_devctl,
+		 FN(int, int, int, void *restrict, size_t, int *restrict));
+}
diff --git a/tests/headers/dirent.c b/tests/headers/dirent.c
new file mode 100644
index 00000000..6001a558
--- /dev/null
+++ b/tests/headers/dirent.c
@@ -0,0 +1,57 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/dirent.h.html
+
+#include "core.h"
+
+#include <dirent.h>
+
+TEST(dirent_h)
+{
+	TYPE(ino_t);
+	TYPE(size_t);
+	TYPE(ssize_t);
+	TYPE(reclen_t);
+
+	INCOMPLETE_TYPE(DIR);
+
+	TYPE(struct dirent);
+	STRUCT_MEMBER(struct dirent, ino_t, d_ino);
+	STRUCT_MEMBER_ARRAY(struct dirent, char, d_name);
+
+	TYPE(struct posix_dent);
+	STRUCT_MEMBER(struct posix_dent, ino_t, d_ino);
+	STRUCT_MEMBER(struct posix_dent, reclen_t, d_reclen);
+	STRUCT_MEMBER(struct posix_dent, unsigned char, d_type);
+	STRUCT_MEMBER_ARRAY(struct posix_dent, char, d_name);
+
+	MACRO_VALUE(DT_BLK, 0x6);
+	MACRO_VALUE(DT_CHR, 0x2);
+	MACRO_VALUE(DT_DIR, 0x4);
+	MACRO_VALUE(DT_FIFO, 0x1);
+	MACRO_VALUE(DT_LNK, 0xa);
+	MACRO_VALUE(DT_REG, 0x8);
+	MACRO_VALUE(DT_SOCK, 0xc);
+	MACRO_VALUE(DT_UNKNOWN, 0x0);
+
+	MACRO_VALUE(DT_MQ, 0xe);
+	MACRO_VALUE(DT_SEM, 0x10);
+	MACRO_VALUE(DT_SHM, 0x12);
+	MACRO_VALUE(DT_TMO, 0x14);
+
+	FUNCTION(alphasort,
+		 FN(int, const struct dirent **, const struct dirent **));
+	FUNCTION(closedir, FN(int, DIR *));
+	FUNCTION(dirfd, FN(int, DIR *));
+	FUNCTION(fdopendir, FN(DIR *, int));
+	FUNCTION(opendir, FN(DIR *, const char *));
+	FUNCTION(posix_getdents, FN(ssize_t, int, void *, size_t, int));
+	FUNCTION(readdir, FN(struct dirent *, DIR *));
+	FUNCTION(readdir_r, FN(int, DIR *restrict, struct dirent *restrict,
+			       struct dirent **restrict));
+	FUNCTION(rewinddir, FN(void, DIR *));
+	FUNCTION(scandir,
+		 FN(int, const char *, struct dirent ***,
+		    int (*)(const struct dirent *),
+		    int (*)(const struct dirent **, const struct dirent **)));
+	FUNCTION(seekdir, FN(void, DIR *, long));
+	FUNCTION(telldir, FN(long, DIR *));
+}
diff --git a/tests/headers/dlfcn.c b/tests/headers/dlfcn.c
new file mode 100644
index 00000000..0a1242d2
--- /dev/null
+++ b/tests/headers/dlfcn.c
@@ -0,0 +1,26 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/dlfcn.h.html
+
+#include "core.h"
+
+#include <dlfcn.h>
+
+TEST(dlfcn_h)
+{
+	TYPE(Dl_info_t);
+
+	STRUCT_MEMBER(Dl_info_t, const char *, dli_fname);
+	STRUCT_MEMBER(Dl_info_t, void *, dli_fbase);
+	STRUCT_MEMBER(Dl_info_t, const char *, dli_sname);
+	STRUCT_MEMBER(Dl_info_t, void *, dli_saddr);
+
+	MACRO_VALUE(RTLD_LAZY, 1);
+	MACRO_VALUE(RTLD_NOW, 2);
+	MACRO_VALUE(RTLD_GLOBAL, 256);
+	MACRO_VALUE(RTLD_LOCAL, 0);
+
+	FUNCTION(dladdr, int (*f)(const void *restrict, Dl_info_t *restrict));
+	FUNCTION(dlclose, int (*f)(void *));
+	FUNCTION(dlerror, char *(*f)(void));
+	FUNCTION(dlopen, void *(*f)(const char *, int));
+	FUNCTION(dlsym, void *(*f)(void *restrict, const char *restrict));
+}
diff --git a/tests/headers/endian.c b/tests/headers/endian.c
new file mode 100644
index 00000000..db18c5fc
--- /dev/null
+++ b/tests/headers/endian.c
@@ -0,0 +1,32 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/endian.h.html
+
+#include "core.h"
+
+#include <endian.h>
+
+TEST(endian_h)
+{
+	MACRO(BYTE_ORDER);
+	MACRO(LITTLE_ENDIAN);
+	MACRO(BIG_ENDIAN);
+
+	FUNCTION(be16toh, FN(uint16_t, uint16_t));
+	FUNCTION(be32toh, FN(uint32_t, uint32_t));
+	FUNCTION(be64toh, FN(uint64_t, uint64_t));
+
+	FUNCTION(htobe16, FN(uint16_t, uint16_t));
+	FUNCTION(htobe32, FN(uint32_t, uint32_t));
+	FUNCTION(htobe64, FN(uint64_t, uint64_t));
+
+	FUNCTION(htole16, FN(uint16_t, uint16_t));
+	FUNCTION(htole32, FN(uint32_t, uint32_t));
+	FUNCTION(htole64, FN(uint64_t, uint64_t));
+
+	FUNCTION(le16toh, FN(uint16_t, uint16_t));
+	FUNCTION(le32toh, FN(uint32_t, uint32_t));
+	FUNCTION(le64toh, FN(uint64_t, uint64_t));
+
+	TYPE(uint16_t);
+	TYPE(uint32_t);
+	TYPE(uint64_t);
+}
diff --git a/tests/headers/errno.c b/tests/headers/errno.c
new file mode 100644
index 00000000..f04fd1ae
--- /dev/null
+++ b/tests/headers/errno.c
@@ -0,0 +1,145 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/errno.h.html
+
+#include "core.h"
+
+#include <errno.h>
+
+TEST(errno_h)
+{
+	int e = errno;
+
+	MACRO_VALUE(EPERM, 1);
+	MACRO_VALUE(ENOENT, 2);
+	MACRO_VALUE(ESRCH, 3);
+	MACRO_VALUE(EINTR, 4);
+	MACRO_VALUE(EIO, 5);
+	MACRO_VALUE(ENXIO, 6);
+	MACRO_VALUE(E2BIG, 7);
+	MACRO_VALUE(ENOEXEC, 8);
+	MACRO_VALUE(EBADF, 9);
+	MACRO_VALUE(ECHILD, 10);
+	MACRO_VALUE(EAGAIN, 11);
+	MACRO_VALUE(ENOMEM, 12);
+	MACRO_VALUE(EACCES, 13);
+	MACRO_VALUE(EFAULT, 14);
+	MACRO_VALUE(ENOTBLK, 15);
+	MACRO_VALUE(EBUSY, 16);
+	MACRO_VALUE(EEXIST, 17);
+	MACRO_VALUE(EXDEV, 18);
+	MACRO_VALUE(ENODEV, 19);
+	MACRO_VALUE(ENOTDIR, 20);
+	MACRO_VALUE(EISDIR, 21);
+	MACRO_VALUE(EINVAL, 22);
+	MACRO_VALUE(ENFILE, 23);
+	MACRO_VALUE(EMFILE, 24);
+	MACRO_VALUE(ENOTTY, 25);
+	MACRO_VALUE(ETXTBSY, 26);
+	MACRO_VALUE(EFBIG, 27);
+	MACRO_VALUE(ENOSPC, 28);
+	MACRO_VALUE(ESPIPE, 29);
+	MACRO_VALUE(EROFS, 30);
+	MACRO_VALUE(EMLINK, 31);
+	MACRO_VALUE(EPIPE, 32);
+	MACRO_VALUE(EDOM, 33);
+	MACRO_VALUE(ERANGE, 34);
+	MACRO_VALUE(EDEADLK, 35);
+	MACRO_VALUE(ENAMETOOLONG, 36);
+	MACRO_VALUE(ENOLCK, 37);
+	MACRO_VALUE(ENOSYS, 38);
+	MACRO_VALUE(ENOTEMPTY, 39);
+	MACRO_VALUE(ELOOP, 40);
+	MACRO_VALUE(EWOULDBLOCK, EAGAIN);
+	MACRO_VALUE(ENOMSG, 42);
+	MACRO_VALUE(EIDRM, 43);
+	MACRO_VALUE(ECHRNG, 44);
+	MACRO_VALUE(EL2NSYNC, 45);
+	MACRO_VALUE(EL3HLT, 46);
+	MACRO_VALUE(EL3RST, 47);
+	MACRO_VALUE(ELNRNG, 48);
+	MACRO_VALUE(EUNATCH, 49);
+	MACRO_VALUE(ENOCSI, 50);
+	MACRO_VALUE(EL2HLT, 51);
+	MACRO_VALUE(EBADE, 52);
+	MACRO_VALUE(EBADR, 53);
+	MACRO_VALUE(EXFULL, 54);
+	MACRO_VALUE(ENOANO, 55);
+	MACRO_VALUE(EBADRQC, 56);
+	MACRO_VALUE(EBADSLT, 57);
+	MACRO_VALUE(EDEADLOCK, EDEADLK);
+	MACRO_VALUE(EBFONT, 59);
+	MACRO_VALUE(ENOSTR, 60);
+	MACRO_VALUE(ENODATA, 61);
+	MACRO_VALUE(ETIME, 62);
+	MACRO_VALUE(ENOSR, 63);
+	MACRO_VALUE(ENONET, 64);
+	MACRO_VALUE(ENOPKG, 65);
+	MACRO_VALUE(EREMOTE, 66);
+	MACRO_VALUE(ENOLINK, 67);
+	MACRO_VALUE(EADV, 68);
+	MACRO_VALUE(ESRMNT, 69);
+	MACRO_VALUE(ECOMM, 70);
+	MACRO_VALUE(EPROTO, 71);
+	MACRO_VALUE(EMULTIHOP, 72);
+	MACRO_VALUE(EDOTDOT, 73);
+	MACRO_VALUE(EBADMSG, 74);
+	MACRO_VALUE(EOVERFLOW, 75);
+	MACRO_VALUE(ENOTUNIQ, 76);
+	MACRO_VALUE(EBADFD, 77);
+	MACRO_VALUE(EREMCHG, 78);
+	MACRO_VALUE(ELIBACC, 79);
+	MACRO_VALUE(ELIBBAD, 80);
+	MACRO_VALUE(ELIBSCN, 81);
+	MACRO_VALUE(ELIBMAX, 82);
+	MACRO_VALUE(ELIBEXEC, 83);
+	MACRO_VALUE(EILSEQ, 84);
+	MACRO_VALUE(ERESTART, 85);
+	MACRO_VALUE(ESTRPIPE, 86);
+	MACRO_VALUE(EUSERS, 87);
+	MACRO_VALUE(ENOTSOCK, 88);
+	MACRO_VALUE(EDESTADDRREQ, 89);
+	MACRO_VALUE(EMSGSIZE, 90);
+	MACRO_VALUE(EPROTOTYPE, 91);
+	MACRO_VALUE(ENOPROTOOPT, 92);
+	MACRO_VALUE(EPROTONOSUPPORT, 93);
+	MACRO_VALUE(ESOCKTNOSUPPORT, 94);
+	MACRO_VALUE(EOPNOTSUPP, 95);
+	MACRO_VALUE(ENOTSUP, EOPNOTSUPP);
+	MACRO_VALUE(EPFNOSUPPORT, 96);
+	MACRO_VALUE(EAFNOSUPPORT, 97);
+	MACRO_VALUE(EADDRINUSE, 98);
+	MACRO_VALUE(EADDRNOTAVAIL, 99);
+	MACRO_VALUE(ENETDOWN, 100);
+	MACRO_VALUE(ENETUNREACH, 101);
+	MACRO_VALUE(ENETRESET, 102);
+	MACRO_VALUE(ECONNABORTED, 103);
+	MACRO_VALUE(ECONNRESET, 104);
+	MACRO_VALUE(ENOBUFS, 105);
+	MACRO_VALUE(EISCONN, 106);
+	MACRO_VALUE(ENOTCONN, 107);
+	MACRO_VALUE(ESHUTDOWN, 108);
+	MACRO_VALUE(ETOOMANYREFS, 109);
+	MACRO_VALUE(ETIMEDOUT, 110);
+	MACRO_VALUE(ECONNREFUSED, 111);
+	MACRO_VALUE(EHOSTDOWN, 112);
+	MACRO_VALUE(EHOSTUNREACH, 113);
+	MACRO_VALUE(EALREADY, 114);
+	MACRO_VALUE(EINPROGRESS, 115);
+	MACRO_VALUE(ESTALE, 116);
+	MACRO_VALUE(EUCLEAN, 117);
+	MACRO_VALUE(ENOTNAM, 118);
+	MACRO_VALUE(ENAVAIL, 119);
+	MACRO_VALUE(EISNAM, 120);
+	MACRO_VALUE(EREMOTEIO, 121);
+	MACRO_VALUE(EDQUOT, 122);
+	MACRO_VALUE(ENOMEDIUM, 123);
+	MACRO_VALUE(EMEDIUMTYPE, 124);
+	MACRO_VALUE(ECANCELED, 125);
+	MACRO_VALUE(ENOKEY, 126);
+	MACRO_VALUE(EKEYEXPIRED, 127);
+	MACRO_VALUE(EKEYREVOKED, 128);
+	MACRO_VALUE(EKEYREJECTED, 129);
+	MACRO_VALUE(EOWNERDEAD, 130);
+	MACRO_VALUE(ENOTRECOVERABLE, 131);
+	MACRO_VALUE(ERFKILL, 132);
+	MACRO_VALUE(EHWPOISON, 133);
+}
diff --git a/tests/headers/fcntl.c b/tests/headers/fcntl.c
new file mode 100644
index 00000000..bccc51c7
--- /dev/null
+++ b/tests/headers/fcntl.c
@@ -0,0 +1,86 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/fcntl.h.html
+
+#include "core.h"
+
+#include <fcntl.h>
+
+TEST(fcntl_h)
+{
+	TYPE(mode_t);
+	TYPE(off_t);
+	TYPE(pid_t);
+
+	TYPE(struct f_owner_ex);
+	STRUCT_MEMBER(struct f_owner_ex, int, type);
+	STRUCT_MEMBER(struct f_owner_ex, pid_t, pid);
+
+	TYPE(struct flock);
+	STRUCT_MEMBER(struct flock, short, l_type);
+	STRUCT_MEMBER(struct flock, short, l_whence);
+	STRUCT_MEMBER(struct flock, off_t, l_start);
+	STRUCT_MEMBER(struct flock, off_t, l_len);
+	STRUCT_MEMBER(struct flock, pid_t, l_pid);
+
+	MACRO(F_DUPFD);
+	MACRO(F_DUPFD_CLOEXEC);
+	MACRO(F_GETFD);
+	MACRO(F_SETFD);
+	MACRO(F_GETFL);
+	MACRO(F_SETFL);
+	MACRO(F_GETLK);
+	MACRO(F_SETLK);
+	MACRO(F_SETLKW);
+	MACRO(F_GETOWN);
+	MACRO(F_SETOWN);
+
+	MACRO(FD_CLOEXEC);
+
+	MACRO(F_RDLCK);
+	MACRO(F_UNLCK);
+	MACRO(F_WRLCK);
+
+	MACRO(SEEK_SET);
+	MACRO(SEEK_CUR);
+	MACRO(SEEK_END);
+
+	MACRO(O_CLOEXEC);
+	MACRO(O_CREAT);
+	MACRO(O_DIRECTORY);
+	MACRO(O_EXCL);
+	MACRO(O_NOCTTY);
+	MACRO(O_NOFOLLOW);
+	MACRO(O_TRUNC);
+	MACRO(O_TTY_INIT);
+
+	MACRO(O_APPEND);
+	MACRO(O_DSYNC);
+	MACRO(O_NONBLOCK);
+	MACRO(O_RSYNC);
+	MACRO(O_SYNC);
+
+	MACRO(O_ACCMODE);
+	MACRO(O_EXEC);
+	MACRO(O_RDONLY);
+	MACRO(O_RDWR);
+	MACRO(O_SEARCH);
+	MACRO(O_WRONLY);
+
+	MACRO(AT_FDCWD);
+	MACRO(AT_EACCESS);
+	MACRO(AT_SYMLINK_NOFOLLOW);
+	MACRO(AT_REMOVEDIR);
+
+	MACRO(POSIX_FADV_DONTNEED);
+	MACRO(POSIX_FADV_NOREUSE);
+	MACRO(POSIX_FADV_NORMAL);
+	MACRO(POSIX_FADV_RANDOM);
+	MACRO(POSIX_FADV_SEQUENTIAL);
+	MACRO(POSIX_FADV_WILLNEED);
+
+	FUNCTION(creat, int (*f)(const char *, mode_t));
+	FUNCTION(fcntl, int (*f)(int, int, ...));
+	FUNCTION(open, int (*f)(const char *, int, ...));
+	FUNCTION(openat, int (*f)(int, const char *, int, ...));
+	FUNCTION(posix_fadvise, int (*f)(int, off_t, off_t, int));
+	FUNCTION(posix_fallocate, int (*f)(int, off_t, off_t));
+}
diff --git a/tests/headers/fenv.c b/tests/headers/fenv.c
new file mode 100644
index 00000000..5f82c524
--- /dev/null
+++ b/tests/headers/fenv.c
@@ -0,0 +1,38 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/fenv.h.html
+
+#include "core.h"
+
+#include <fenv.h>
+
+TEST(fenv_h)
+{
+	TYPE(fenv_t);
+	TYPE(fexcept_t);
+
+	MACRO(FE_DIVBYZERO);
+	MACRO(FE_INEXACT);
+	MACRO(FE_INVALID);
+	MACRO(FE_OVERFLOW);
+	MACRO(FE_UNDERFLOW);
+
+	MACRO(FE_ALL_EXCEPT);
+
+	MACRO(FE_DOWNWARD);
+	MACRO(FE_TONEAREST);
+	MACRO(FE_TOWARDZERO);
+	MACRO(FE_UPWARD);
+
+	const fenv_t *fe_dfl_env = FE_DFL_ENV;
+
+	FUNCTION(feclearexcept, int (*f)(int));
+	FUNCTION(fegetenv, int (*f)(fenv_t *));
+	FUNCTION(fegetexceptflag, int (*f)(fexcept_t *, int));
+	FUNCTION(fegetround, int (*f)(void));
+	FUNCTION(feholdexcept, int (*f)(fenv_t *));
+	FUNCTION(feraiseexcept, int (*f)(int));
+	FUNCTION(fesetenv, int (*f)(const fenv_t *));
+	FUNCTION(fesetexceptflag, int (*f)(const fexcept_t *, int));
+	FUNCTION(fesetround, int (*f)(int));
+	FUNCTION(fetestexcept, int (*f)(int));
+	FUNCTION(feupdateenv, int (*f)(const fenv_t *));
+}
diff --git a/tests/headers/float.c b/tests/headers/float.c
new file mode 100644
index 00000000..a476f09f
--- /dev/null
+++ b/tests/headers/float.c
@@ -0,0 +1,41 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/float.h.html
+
+#include "core.h"
+
+#include <float.h>
+
+TEST(float_h)
+{
+	int flt_rounds = FLT_ROUNDS;
+
+	MACRO(FLT_EVAL_METHOD);
+	MACRO(FLT_RADIX);
+	MACRO(FLT_MANT_DIG);
+	MACRO(DBL_MANT_DIG);
+	MACRO(LDBL_MANT_DIG);
+	MACRO(DECIMAL_DIG);
+	MACRO(FLT_DIG);
+	MACRO(DBL_DIG);
+	MACRO(LDBL_DIG);
+	MACRO(FLT_MIN_EXP);
+	MACRO(DBL_MIN_EXP);
+	MACRO(LDBL_MIN_EXP);
+	MACRO(FLT_MIN_10_EXP);
+	MACRO(DBL_MIN_10_EXP);
+	MACRO(LDBL_MIN_10_EXP);
+	MACRO(FLT_MAX_EXP);
+	MACRO(DBL_MAX_EXP);
+	MACRO(LDBL_MAX_EXP);
+	MACRO(FLT_MAX_10_EXP);
+	MACRO(DBL_MAX_10_EXP);
+	MACRO(LDBL_MAX_10_EXP);
+	MACRO(FLT_MAX);
+	MACRO(DBL_MAX);
+	MACRO(LDBL_MAX);
+	MACRO(FLT_EPSILON);
+	MACRO(DBL_EPSILON);
+	MACRO(LDBL_EPSILON);
+	MACRO(FLT_MIN);
+	MACRO(DBL_MIN);
+	MACRO(LDBL_MIN);
+}
diff --git a/tests/headers/fmtmsg.c b/tests/headers/fmtmsg.c
new file mode 100644
index 00000000..c23edd35
--- /dev/null
+++ b/tests/headers/fmtmsg.c
@@ -0,0 +1,38 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/fmtmsg.h.html
+
+#include "core.h"
+
+#include <fmtmsg.h>
+
+TEST(fmtmsg_h)
+{
+	MACRO(MM_HARD)
+	MACRO(MM_SOFT)
+	MACRO(MM_FIRM)
+	MACRO(MM_APPL)
+	MACRO(MM_UTIL)
+	MACRO(MM_OPSYS)
+	MACRO(MM_RECOVER)
+	MACRO(MM_NRECOV)
+	MACRO(MM_PRINT)
+	MACRO(MM_CONSOLE)
+	MACRO(MM_NOSEV)
+	MACRO(MM_HALT)
+	MACRO(MM_ERROR)
+	MACRO(MM_WARNING)
+	MACRO(MM_INFO)
+	MACRO(MM_NOTOK);
+	MACRO(MM_OK);
+	MACRO(MM_NOMSG);
+	MACRO(MM_NOCON);
+
+	MACRO_VALUE(MM_NULLLBL, ((char *)0));
+	MACRO_VALUE(MM_NULLSEV, 0);
+	MACRO_VALUE(MM_NULLMC, ((char *)0));
+	MACRO_VALUE(MM_NULLTXT, ((char *)0));
+	MACRO_VALUE(MM_NULLACT, ((char *)0));
+	MACRO_VALUE(MM_NULLTAG, ((char *)0));
+
+	FUNCTION(fmtmsg, FN(int, long, const char *, int, const char *,
+			    const char *, const char *));
+}
diff --git a/tests/headers/fnmatch.c b/tests/headers/fnmatch.c
new file mode 100644
index 00000000..563425cc
--- /dev/null
+++ b/tests/headers/fnmatch.c
@@ -0,0 +1,17 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/fmtmsg.h.html
+
+#include "core.h"
+
+#include <fnmatch.h>
+
+TEST(fnmatch_h)
+{
+	MACRO(FNM_PATHNAME)
+	MACRO(FNM_NOESCAPE)
+	MACRO(FNM_PERIOD)
+	MACRO(FNM_CASEFOLD)
+	MACRO(FNM_NOMATCH)
+	MACRO(FNM_IGNORECASE)
+
+	FUNCTION(fnmatch, FN(int, const char *, const char *, int))
+}
diff --git a/tests/headers/ftw.c b/tests/headers/ftw.c
new file mode 100644
index 00000000..a6c3c38d
--- /dev/null
+++ b/tests/headers/ftw.c
@@ -0,0 +1,26 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/ftw.h.html
+
+#include "core.h"
+
+#include <ftw.h>
+
+TEST(ftw_h)
+{
+	TYPE(struct FTW);
+	STRUCT_MEMBER(struct FTW, int, base);
+	STRUCT_MEMBER(struct FTW, int, level);
+
+	MACRO(FTW_F);
+	MACRO(FTW_D);
+	MACRO(FTW_DNR);
+	MACRO(FTW_DP);
+	MACRO(FTW_NS);
+	MACRO(FTW_SL);
+	MACRO(FTW_SLN);
+
+	MACRO(FTW_PHYS);
+	MACRO(FTW_MOUNT);
+	MACRO(FTW_XDEV);
+	MACRO(FTW_DEPTH);
+	MACRO(FTW_CHDIR);
+}
diff --git a/tests/headers/glob.c b/tests/headers/glob.c
new file mode 100644
index 00000000..6f0ed3c6
--- /dev/null
+++ b/tests/headers/glob.c
@@ -0,0 +1,32 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/glob.h.html
+
+#include "core.h"
+
+#include <glob.h>
+
+TEST(glob_h)
+{
+	TYPE(glob_t);
+	STRUCT_MEMBER(glob_t, size_t, gl_pathc);
+	STRUCT_MEMBER(glob_t, char **, gl_pathv);
+	STRUCT_MEMBER(glob_t, size_t, gl_offs);
+
+	TYPE(size_t);
+
+	MACRO(GLOB_APPEND);
+	MACRO(GLOB_DOOFFS);
+	MACRO(GLOB_ERR);
+	MACRO(GLOB_MARK);
+	MACRO(GLOB_NOCHECK);
+	MACRO(GLOB_NOESCAPE);
+	MACRO(GLOB_NOSORT);
+
+	MACRO(GLOB_ABORTED);
+	MACRO(GLOB_NOMATCH);
+	MACRO(GLOB_NOSPACE);
+
+	FUNCTION(glob, FN(int, const char *, int, int (*)(const char *, int),
+			  glob_t *));
+
+	FUNCTION(globfree, FN(void, glob_t *));
+}
diff --git a/tests/headers/grp.c b/tests/headers/grp.c
new file mode 100644
index 00000000..9ca3029e
--- /dev/null
+++ b/tests/headers/grp.c
@@ -0,0 +1,26 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/glob.h.html
+
+#include "core.h"
+
+#include <grp.h>
+
+TEST(grp_h)
+{
+	TYPE(struct group);
+	STRUCT_MEMBER(struct group, char *, gr_name);
+	STRUCT_MEMBER(struct group, gid_t, gr_gid);
+	STRUCT_MEMBER(struct group, char **, gr_mem);
+
+	TYPE(gid_t);
+	TYPE(size_t);
+
+	FUNCTION(endgrent, FN(void, void));
+	FUNCTION(getgrent, FN(struct group *, void));
+	FUNCTION(getgrgid, FN(struct group *, gid_t));
+	FUNCTION(getgrgid_r, FN(int, gid_t, struct group *, char *, size_t,
+				struct group **));
+	FUNCTION(getgrnam, FN(struct group *, const char *));
+	FUNCTION(getgrnam_r, FN(int, const char *, struct group *, char *,
+				size_t, struct group **));
+	FUNCTION(setgrent, FN(void, void));
+}
diff --git a/tests/headers/iconv.h b/tests/headers/iconv.h
new file mode 100644
index 00000000..904731fc
--- /dev/null
+++ b/tests/headers/iconv.h
@@ -0,0 +1,16 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/iconv.h.html
+
+#include "core.h"
+
+#include <iconv.h>
+
+TEST(iconv_h)
+{
+	TYPE(iconv_t);
+	TYPE(size_t);
+
+	FUNCTION(iconv,
+		 FN(size_t, iconv_t, char **, size_t *, char **, size_t *));
+	FUNCTION(iconv_close, FN(int, iconv_t));
+	FUNCTION(iconv_open, FN(iconv_t, const char *, const char *));
+}
diff --git a/tests/headers/inttypes.c b/tests/headers/inttypes.c
new file mode 100644
index 00000000..c60ca709
--- /dev/null
+++ b/tests/headers/inttypes.c
@@ -0,0 +1,173 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/inttypes.h.html
+
+#include "core.h"
+
+#include <inttypes.h>
+
+TEST(inttypes_h)
+{
+	TYPE(wchar_t);
+	TYPE(imaxdiv_t);
+
+	MACRO_VALUE_STRING(PRId8, "d");
+	MACRO_VALUE_STRING(PRId16, "d");
+	MACRO_VALUE_STRING(PRId32, "d");
+	MACRO_VALUE_STRING(PRId64, __PRI64 "d");
+	MACRO_VALUE_STRING(PRIdLEAST8, "d");
+	MACRO_VALUE_STRING(PRIdLEAST16, "d");
+	MACRO_VALUE_STRING(PRIdLEAST32, "d");
+	MACRO_VALUE_STRING(PRIdLEAST64, __PRI64 "d");
+	MACRO_VALUE_STRING(PRIdFAST8, "d");
+	MACRO_VALUE_STRING(PRIdFAST16, "d");
+	MACRO_VALUE_STRING(PRIdFAST32, "d");
+	MACRO_VALUE_STRING(PRIdFAST64, __PRI64 "d");
+	MACRO_VALUE_STRING(PRIi8, "i");
+	MACRO_VALUE_STRING(PRIi16, "i");
+	MACRO_VALUE_STRING(PRIi32, "i");
+	MACRO_VALUE_STRING(PRIi64, __PRI64 "i");
+	MACRO_VALUE_STRING(PRIiLEAST8, "i");
+	MACRO_VALUE_STRING(PRIiLEAST16, "i");
+	MACRO_VALUE_STRING(PRIiLEAST32, "i");
+	MACRO_VALUE_STRING(PRIiLEAST64, __PRI64 "i");
+	MACRO_VALUE_STRING(PRIiFAST8, "i");
+	MACRO_VALUE_STRING(PRIiFAST16, "i");
+	MACRO_VALUE_STRING(PRIiFAST32, "i");
+	MACRO_VALUE_STRING(PRIiFAST64, __PRI64 "i");
+	MACRO_VALUE_STRING(PRIo8, "o");
+	MACRO_VALUE_STRING(PRIo16, "o");
+	MACRO_VALUE_STRING(PRIo32, "o");
+	MACRO_VALUE_STRING(PRIo64, __PRI64 "o");
+	MACRO_VALUE_STRING(PRIoLEAST8, "o");
+	MACRO_VALUE_STRING(PRIoLEAST16, "o");
+	MACRO_VALUE_STRING(PRIoLEAST32, "o");
+	MACRO_VALUE_STRING(PRIoLEAST64, __PRI64 "o");
+	MACRO_VALUE_STRING(PRIoFAST8, "o");
+	MACRO_VALUE_STRING(PRIoFAST16, "o");
+	MACRO_VALUE_STRING(PRIoFAST32, "o");
+	MACRO_VALUE_STRING(PRIoFAST64, __PRI64 "o");
+	MACRO_VALUE_STRING(PRIu8, "u");
+	MACRO_VALUE_STRING(PRIu16, "u");
+	MACRO_VALUE_STRING(PRIu32, "u");
+	MACRO_VALUE_STRING(PRIu64, __PRI64 "u");
+	MACRO_VALUE_STRING(PRIuLEAST8, "u");
+	MACRO_VALUE_STRING(PRIuLEAST16, "u");
+	MACRO_VALUE_STRING(PRIuLEAST32, "u");
+	MACRO_VALUE_STRING(PRIuLEAST64, __PRI64 "u");
+	MACRO_VALUE_STRING(PRIuFAST8, "u");
+	MACRO_VALUE_STRING(PRIuFAST16, "u");
+	MACRO_VALUE_STRING(PRIuFAST32, "u");
+	MACRO_VALUE_STRING(PRIuFAST64, __PRI64 "u");
+	MACRO_VALUE_STRING(PRIx8, "x");
+	MACRO_VALUE_STRING(PRIx16, "x");
+	MACRO_VALUE_STRING(PRIx32, "x");
+	MACRO_VALUE_STRING(PRIx64, __PRI64 "x");
+	MACRO_VALUE_STRING(PRIxLEAST8, "x");
+	MACRO_VALUE_STRING(PRIxLEAST16, "x");
+	MACRO_VALUE_STRING(PRIxLEAST32, "x");
+	MACRO_VALUE_STRING(PRIxLEAST64, __PRI64 "x");
+	MACRO_VALUE_STRING(PRIxFAST8, "x");
+	MACRO_VALUE_STRING(PRIxFAST16, "x");
+	MACRO_VALUE_STRING(PRIxFAST32, "x");
+	MACRO_VALUE_STRING(PRIxFAST64, __PRI64 "x");
+	MACRO_VALUE_STRING(PRIX8, "X");
+	MACRO_VALUE_STRING(PRIX16, "X");
+	MACRO_VALUE_STRING(PRIX32, "X");
+	MACRO_VALUE_STRING(PRIX64, __PRI64 "X");
+	MACRO_VALUE_STRING(PRIXLEAST8, "X");
+	MACRO_VALUE_STRING(PRIXLEAST16, "X");
+	MACRO_VALUE_STRING(PRIXLEAST32, "X");
+	MACRO_VALUE_STRING(PRIXLEAST64, __PRI64 "X");
+	MACRO_VALUE_STRING(PRIXFAST8, "X");
+	MACRO_VALUE_STRING(PRIXFAST16, "X");
+	MACRO_VALUE_STRING(PRIXFAST32, "X");
+	MACRO_VALUE_STRING(PRIXFAST64, __PRI64 "X");
+	MACRO_VALUE_STRING(PRIdMAX, __PRI64 "d");
+	MACRO_VALUE_STRING(PRIiMAX, __PRI64 "i");
+	MACRO_VALUE_STRING(PRIoMAX, __PRI64 "o");
+	MACRO_VALUE_STRING(PRIuMAX, __PRI64 "u");
+	MACRO_VALUE_STRING(PRIxMAX, __PRI64 "x");
+	MACRO_VALUE_STRING(PRIXMAX, __PRI64 "X");
+	MACRO_VALUE_STRING(PRIdPTR, __PRIPTR "d");
+	MACRO_VALUE_STRING(PRIiPTR, __PRIPTR "i");
+	MACRO_VALUE_STRING(PRIoPTR, __PRIPTR "o");
+	MACRO_VALUE_STRING(PRIuPTR, __PRIPTR "u");
+	MACRO_VALUE_STRING(PRIxPTR, __PRIPTR "x");
+	MACRO_VALUE_STRING(PRIXPTR, __PRIPTR "X");
+	MACRO_VALUE_STRING(SCNd8, "hhd");
+	MACRO_VALUE_STRING(SCNd16, "hd");
+	MACRO_VALUE_STRING(SCNd32, "d");
+	MACRO_VALUE_STRING(SCNd64, __PRI64 "d");
+	MACRO_VALUE_STRING(SCNdLEAST8, "hhd");
+	MACRO_VALUE_STRING(SCNdLEAST16, "hd");
+	MACRO_VALUE_STRING(SCNdLEAST32, "d");
+	MACRO_VALUE_STRING(SCNdLEAST64, __PRI64 "d");
+	MACRO_VALUE_STRING(SCNdFAST8, "hhd");
+	MACRO_VALUE_STRING(SCNdFAST16, "d");
+	MACRO_VALUE_STRING(SCNdFAST32, "d");
+	MACRO_VALUE_STRING(SCNdFAST64, __PRI64 "d");
+	MACRO_VALUE_STRING(SCNi8, "hhi");
+	MACRO_VALUE_STRING(SCNi16, "hi");
+	MACRO_VALUE_STRING(SCNi32, "i");
+	MACRO_VALUE_STRING(SCNi64, __PRI64 "i");
+	MACRO_VALUE_STRING(SCNiLEAST8, "hhi");
+	MACRO_VALUE_STRING(SCNiLEAST16, "hi");
+	MACRO_VALUE_STRING(SCNiLEAST32, "i");
+	MACRO_VALUE_STRING(SCNiLEAST64, __PRI64 "i");
+	MACRO_VALUE_STRING(SCNiFAST8, "hhi");
+	MACRO_VALUE_STRING(SCNiFAST16, "i");
+	MACRO_VALUE_STRING(SCNiFAST32, "i");
+	MACRO_VALUE_STRING(SCNiFAST64, __PRI64 "i");
+	MACRO_VALUE_STRING(SCNu8, "hhu");
+	MACRO_VALUE_STRING(SCNu16, "hu");
+	MACRO_VALUE_STRING(SCNu32, "u");
+	MACRO_VALUE_STRING(SCNu64, __PRI64 "u");
+	MACRO_VALUE_STRING(SCNuLEAST8, "hhu");
+	MACRO_VALUE_STRING(SCNuLEAST16, "hu");
+	MACRO_VALUE_STRING(SCNuLEAST32, "u");
+	MACRO_VALUE_STRING(SCNuLEAST64, __PRI64 "u");
+	MACRO_VALUE_STRING(SCNuFAST8, "hhu");
+	MACRO_VALUE_STRING(SCNuFAST16, "u");
+	MACRO_VALUE_STRING(SCNuFAST32, "u");
+	MACRO_VALUE_STRING(SCNuFAST64, __PRI64 "u");
+	MACRO_VALUE_STRING(SCNo8, "hho");
+	MACRO_VALUE_STRING(SCNo16, "ho");
+	MACRO_VALUE_STRING(SCNo32, "o");
+	MACRO_VALUE_STRING(SCNo64, __PRI64 "o");
+	MACRO_VALUE_STRING(SCNoLEAST8, "hho");
+	MACRO_VALUE_STRING(SCNoLEAST16, "ho");
+	MACRO_VALUE_STRING(SCNoLEAST32, "o");
+	MACRO_VALUE_STRING(SCNoLEAST64, __PRI64 "o");
+	MACRO_VALUE_STRING(SCNoFAST8, "hho");
+	MACRO_VALUE_STRING(SCNoFAST16, "o");
+	MACRO_VALUE_STRING(SCNoFAST32, "o");
+	MACRO_VALUE_STRING(SCNoFAST64, __PRI64 "o");
+	MACRO_VALUE_STRING(SCNx8, "hhx");
+	MACRO_VALUE_STRING(SCNx16, "hx");
+	MACRO_VALUE_STRING(SCNx32, "x");
+	MACRO_VALUE_STRING(SCNx64, __PRI64 "x");
+	MACRO_VALUE_STRING(SCNxLEAST8, "hhx");
+	MACRO_VALUE_STRING(SCNxLEAST16, "hx");
+	MACRO_VALUE_STRING(SCNxLEAST32, "x");
+	MACRO_VALUE_STRING(SCNxLEAST64, __PRI64 "x");
+	MACRO_VALUE_STRING(SCNxFAST8, "hhx");
+	MACRO_VALUE_STRING(SCNxFAST16, "x");
+	MACRO_VALUE_STRING(SCNxFAST32, "x");
+	MACRO_VALUE_STRING(SCNxFAST64, __PRI64 "x");
+	MACRO_VALUE_STRING(SCNdMAX, __PRI64 "d");
+	MACRO_VALUE_STRING(SCNiMAX, __PRI64 "i");
+	MACRO_VALUE_STRING(SCNoMAX, __PRI64 "o");
+	MACRO_VALUE_STRING(SCNuMAX, __PRI64 "u");
+	MACRO_VALUE_STRING(SCNxMAX, __PRI64 "x");
+	MACRO_VALUE_STRING(SCNdPTR, __PRIPTR "d");
+	MACRO_VALUE_STRING(SCNiPTR, __PRIPTR "i");
+	MACRO_VALUE_STRING(SCNoPTR, __PRIPTR "o");
+	MACRO_VALUE_STRING(SCNuPTR, __PRIPTR "u");
+	MACRO_VALUE_STRING(SCNxPTR, __PRIPTR "x");
+
+	FUNCTION(imaxabs, FN(intmax_t, intmax_t));
+	FUNCTION(imaxdiv, FN(imaxdiv_t, intmax_t, intmax_t));
+	FUNCTION(strtoimax, FN(intmax_t, const char *, char **, int));
+	FUNCTION(strtoumax, FN(uintmax_t, const char *, char **, int));
+	FUNCTION(wcstoimax, FN(intmax_t, const wchar_t *, wchar_t **, int));
+	FUNCTION(wcstoumax, FN(uintmax_t, const wchar_t *, wchar_t **, int));
+}
diff --git a/tests/headers/iso646.c b/tests/headers/iso646.c
new file mode 100644
index 00000000..258b8fcc
--- /dev/null
+++ b/tests/headers/iso646.c
@@ -0,0 +1,23 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/iso646.h.html
+
+#include "core.h"
+
+#include <iso646.h>
+
+#define STRINGIFY_(x) #x
+#define STRINGIFY(x)  STRINGIFY_(x)
+
+TEST(iso646_h)
+{
+	MACRO_VALUE_STRING(STRINGIFY(and), "&&");
+	MACRO_VALUE_STRING(STRINGIFY(and_eq), "&=");
+	MACRO_VALUE_STRING(STRINGIFY(bitand), "&");
+	MACRO_VALUE_STRING(STRINGIFY(bitor), "|");
+	MACRO_VALUE_STRING(STRINGIFY(compl), "~");
+	MACRO_VALUE_STRING(STRINGIFY(not), "!");
+	MACRO_VALUE_STRING(STRINGIFY(not_eq), "!=");
+	MACRO_VALUE_STRING(STRINGIFY(or), "||");
+	MACRO_VALUE_STRING(STRINGIFY(or_eq), "|=");
+	MACRO_VALUE_STRING(STRINGIFY(xor), "^");
+	MACRO_VALUE_STRING(STRINGIFY(xor_eq), "^=");
+}
diff --git a/tests/headers/langinfo.c b/tests/headers/langinfo.c
new file mode 100644
index 00000000..2eb6b3c5
--- /dev/null
+++ b/tests/headers/langinfo.c
@@ -0,0 +1,93 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/langinfo.h.html
+
+#include "core.h"
+
+#include <langinfo.h>
+
+TEST(langinfo_h)
+{
+	TYPE(locale_t);
+	TYPE(nl_item);
+
+	MACRO(CODESET);
+	MACRO(D_T_FMT)
+	MACRO(D_FMT);
+	MACRO(T_FMT);
+	MACRO(T_FMT_AMPM);
+	MACRO(PM_STR);
+	MACRO(DAY_1);
+	MACRO(DAY_2);
+	MACRO(DAY_3);
+	MACRO(DAY_4);
+	MACRO(DAY_5);
+	MACRO(DAY_6);
+	MACRO(DAY_7);
+	MACRO(ABDAY_1);
+	MACRO(ABDAY_2);
+	MACRO(ABDAY_3);
+	MACRO(ABDAY_4);
+	MACRO(ABDAY_5);
+	MACRO(ABDAY_6);
+	MACRO(ABDAY_7);
+	MACRO(MON_1);
+	MACRO(MON_2);
+	MACRO(MON_3);
+	MACRO(MON_4);
+	MACRO(MON_5);
+	MACRO(MON_6);
+	MACRO(MON_7);
+	MACRO(MON_8);
+	MACRO(MON_9);
+	MACRO(MON_10);
+	MACRO(MON_11);
+	MACRO(MON_12);
+	MACRO(ALTMON_1);
+	MACRO(ALTMON_2);
+	MACRO(ALTMON_3);
+	MACRO(ALTMON_4);
+	MACRO(ALTMON_5);
+	MACRO(ALTMON_6);
+	MACRO(ALTMON_7);
+	MACRO(ALTMON_8);
+	MACRO(ALTMON_9);
+	MACRO(ALTMON_1);
+	MACRO(ALTMON_11);
+	MACRO(ALTMON_12);
+	MACRO(ABMON_1);
+	MACRO(ABMON_2);
+	MACRO(ABMON_3);
+	MACRO(ABMON_4);
+	MACRO(ABMON_5);
+	MACRO(ABMON_6);
+	MACRO(ABMON_7);
+	MACRO(ABMON_8);
+	MACRO(ABMON_9);
+	MACRO(ABMON_10);
+	MACRO(ABMON_11);
+	MACRO(ABMON_12);
+	MACRO(ABALTMON_1);
+	MACRO(ABALTMON_2);
+	MACRO(ABALTMON_3);
+	MACRO(ABALTMON_4);
+	MACRO(ABALTMON_5);
+	MACRO(ABALTMON_6);
+	MACRO(ABALTMON_7);
+	MACRO(ABALTMON_8);
+	MACRO(ABALTMON_9);
+	MACRO(ABALTMON_10);
+	MACRO(ABALTMON_11);
+	MACRO(ABALTMON_12);
+	MACRO(ERA);
+	MACRO(ERA_D_FMT);
+	MACRO(ERA_D_T_FMT);
+	MACRO(ERA_T_FMT);
+	MACRO(ALT_DIGITS);
+	MACRO(RADIXCHAR);
+	MACRO(THOUSEP);
+	MACRO(YESEXPR);
+	MACRO(NOEXPR);
+	MACRO(CRNCYSTR);
+
+	FUNCTION(nl_langinfo, FN(char *, nl_item))
+	FUNCTION(nl_langinfo_l, FN(char *, nl_item, locale_t))
+}
diff --git a/tests/headers/libgen.c b/tests/headers/libgen.c
new file mode 100644
index 00000000..162c52d2
--- /dev/null
+++ b/tests/headers/libgen.c
@@ -0,0 +1,11 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/libgen.h.html
+
+#include "core.h"
+
+#include <libgen.h>
+
+TEST(libgen_h)
+{
+	FUNCTION(basename, FN(char *, char *));
+	FUNCTION(dirname, FN(char *, char *));
+}
diff --git a/tests/headers/libintl.c b/tests/headers/libintl.c
new file mode 100644
index 00000000..bc9d579c
--- /dev/null
+++ b/tests/headers/libintl.c
@@ -0,0 +1,35 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/libintl.h.html
+
+#include "core.h"
+
+#include <libintl.h>
+
+TEST(libintl_h)
+{
+	MACRO(TEXTDOMAIN_MAX);
+	TYPE(locale_t);
+
+	FUNCTION(bindtextdomain, FN(char *, const char *, const char *));
+	FUNCTION(bind_textdomain_codeset,
+		 FN(char *, const char *, const char *));
+	FUNCTION(dcgettext, FN(char *, const char *, const char *, int));
+	FUNCTION(dcgettext_l,
+		 FN(char *, const char *, const char *, int, locale_t));
+	FUNCTION(dcngettext, FN(char *, const char *, const char *,
+				const char *, unsigned long, int));
+	FUNCTION(dcngettext_l, FN(char *, const char *, const char *,
+				  const char *, unsigned long, int, locale_t));
+	FUNCTION(dgettext, FN(char *, const char *, const char *));
+	FUNCTION(dgettext_l, FN(char *, const char *, const char *, locale_t));
+	FUNCTION(dngettext, FN(char *, const char *, const char *, const char *,
+			       unsigned long));
+	FUNCTION(dngettext_l, FN(char *, const char *, const char *,
+				 const char *, unsigned long, locale_t));
+	FUNCTION(gettext, FN(char *, const char *));
+	FUNCTION(gettext_l, FN(char *, const char *, locale_t));
+	FUNCTION(ngettext,
+		 FN(char *, const char *, const char *, unsigned long));
+	FUNCTION(ngettext_l, FN(char *, const char *, const char *,
+				unsigned long, locale_t));
+	FUNCTION(textdomain, FN(char *, const char *));
+}
diff --git a/tests/headers/limits.c b/tests/headers/limits.c
new file mode 100644
index 00000000..0d6fbdef
--- /dev/null
+++ b/tests/headers/limits.c
@@ -0,0 +1,151 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/limits.h.html
+
+#include "core.h"
+
+#include <limits.h>
+
+TEST(limits_h)
+{
+	MACRO(AIO_LISTIO_MAX);
+	MACRO(AIO_MAX);
+	MACRO(AIO_PRIO_DELTA_MAX);
+	MACRO(ARG_MAX);
+	MACRO(ATEXIT_MAX);
+	MACRO(CHILD_MAX);
+	MACRO(DELAYTIMER_MAX);
+	MACRO(HOST_NAME_MAX);
+	MACRO(IOV_MAX);
+	MACRO(LOGIN_NAME_MAX);
+	MACRO(MQ_OPEN_MAX);
+	MACRO(MQ_PRIO_MAX);
+	MACRO(OPEN_MAX);
+	MACRO(PAGESIZE);
+	MACRO(PAGE_SIZE);
+
+	MACRO(PTHREAD_DESTRUCTOR_ITERATIONS);
+	MACRO(PTHREAD_KEYS_MAX);
+	MACRO(PTHREAD_STACK_MIN);
+	MACRO(PTHREAD_THREADS_MAX);
+	MACRO(RTSIG_MAX);
+	MACRO(SEM_NSEMS_MAX);
+	MACRO(SEM_VALUE_MAX);
+	MACRO(SIGQUEUE_MAX);
+	MACRO(SS_REPL_MAX);
+	MACRO(STREAM_MAX);
+	MACRO(SYMLOOP_MAX);
+	MACRO(TIMER_MAX);
+	MACRO(TTY_NAME_MAX);
+	MACRO(TZNAME_MAX);
+
+	MACRO(FILESIZEBITS);
+	MACRO(LINK_MAX);
+	MACRO(MAX_CANON);
+	MACRO(MAX_INPUT);
+
+	MACRO(NAME_MAX);
+	MACRO(PATH_MAX);
+	MACRO(PIPE_BUF);
+
+	MACRO(POSIX_ALLOC_SIZE_MIN);
+	MACRO(POSIX_REC_INCR_XFER_SIZE);
+	MACRO(POSIX_REC_MAX_XFER_SIZE);
+	MACRO(POSIX_REC_MIN_XFER_SIZE);
+	MACRO(POSIX_REC_XFER_ALIGN);
+
+	MACRO(SYMLINK_MAX);
+	MACRO(TEXTDOMAIN_MAX);
+
+	MACRO(BC_BASE_MAX);
+	MACRO(BC_DIM_MAX);
+	MACRO(BC_SCALE_MAX);
+	MACRO(BC_STRING_MAX);
+	MACRO(CHARCLASS_NAME_MAX);
+	MACRO(COLL_WEIGHTS_MAX);
+	MACRO(EXPR_NEST_MAX);
+	MACRO(LINE_MAX);
+	MACRO(NGROUPS_MAX);
+	MACRO(RE_DUP_MAX);
+
+	MACRO_VALUE(_POSIX_CLOCKRES_MIN, 20000000);
+	MACRO_VALUE(_POSIX_AIO_LISTIO_MAX, 2);
+	MACRO_VALUE(_POSIX_AIO_MAX, 1);
+	MACRO_VALUE(_POSIX_ARG_MAX, 4096);
+	MACRO_VALUE(_POSIX_CHILD_MAX, 25);
+	MACRO_VALUE(_POSIX_DELAYTIMER_MAX, 32);
+	MACRO_VALUE(_POSIX_HOST_NAME_MAX, 255);
+	MACRO_VALUE(_POSIX_LINK_MAX, 8);
+	MACRO_VALUE(_POSIX_LOGIN_NAME_MAX, 9);
+	MACRO_VALUE(_POSIX_MAX_CANON, 255);
+	MACRO_VALUE(_POSIX_MAX_INPUT, 255);
+	MACRO_VALUE(_POSIX_MQ_OPEN_MAX, 8);
+	MACRO_VALUE(_POSIX_MQ_PRIO_MAX, 32);
+	MACRO_VALUE(_POSIX_NAME_MAX, 14);
+	MACRO_VALUE(_POSIX_NGROUPS_MAX, 8);
+	MACRO_VALUE(_POSIX_OPEN_MAX, 20);
+	MACRO_VALUE(_POSIX_PATH_MAX, 256);
+	MACRO_VALUE(_POSIX_PIPE_BUF, 512);
+	MACRO_VALUE(_POSIX_RE_DUP_MAX, 255);
+	MACRO_VALUE(_POSIX_RTSIG_MAX, 8);
+	MACRO_VALUE(_POSIX_SEM_NSEMS_MAX, 256);
+	MACRO_VALUE(_POSIX_SEM_VALUE_MAX, 32767);
+	MACRO_VALUE(_POSIX_SIGQUEUE_MAX, 32);
+	MACRO_VALUE(_POSIX_SSIZE_MAX, 32767);
+	MACRO_VALUE(_POSIX_SS_REPL_MAX, 4);
+	MACRO_VALUE(_POSIX_STREAM_MAX, 8);
+	MACRO_VALUE(_POSIX_SYMLINK_MAX, 255);
+	MACRO_VALUE(_POSIX_SYMLOOP_MAX, 8);
+	MACRO_VALUE(_POSIX_THREAD_DESTRUCTOR_ITERATIONS, 4);
+	MACRO_VALUE(_POSIX_THREAD_KEYS_MAX, 128);
+	MACRO_VALUE(_POSIX_THREAD_THREADS_MAX, 64);
+	MACRO_VALUE(_POSIX_TIMER_MAX, 32);
+	MACRO_VALUE(_POSIX_TRACE_EVENT_NAME_MAX, 30);
+	MACRO_VALUE(_POSIX_TRACE_NAME_MAX, 8);
+	MACRO_VALUE(_POSIX_TRACE_SYS_MAX, 8);
+	MACRO_VALUE(_POSIX_TRACE_USER_EVENT_MAX, 32);
+	MACRO_VALUE(_POSIX_TTY_NAME_MAX, 9);
+	MACRO_VALUE(_POSIX_TZNAME_MAX, 6);
+	MACRO_VALUE(_POSIX2_BC_BASE_MAX, 99);
+	MACRO_VALUE(_POSIX2_BC_DIM_MAX, 2048);
+	MACRO_VALUE(_POSIX2_BC_SCALE_MAX, 99);
+	MACRO_VALUE(_POSIX2_BC_STRING_MAX, 1000);
+	MACRO_VALUE(_POSIX2_CHARCLASS_NAME_MAX, 14);
+	MACRO_VALUE(_POSIX2_COLL_WEIGHTS_MAX, 2);
+	MACRO_VALUE(_POSIX2_EXPR_NEST_MAX, 32);
+	MACRO_VALUE(_POSIX2_LINE_MAX, 2048);
+	MACRO_VALUE(_POSIX2_RE_DUP_MAX, 255);
+
+	MACRO_VALUE(_XOPEN_IOV_MAX, 16);
+	MACRO_VALUE(_XOPEN_NAME_MAX, 255);
+	MACRO_VALUE(_XOPEN_PATH_MAX, 1024);
+
+	MACRO_VALUE(CHAR_BIT, 8);
+	MACRO(CHAR_MAX);
+	MACRO(CHAR_MIN);
+	MACRO(INT_MAX);
+	MACRO(INT_MIN);
+	MACRO(LLONG_MAX);
+	MACRO(LLONG_MIN);
+	MACRO(LONG_BIT);
+	MACRO(LONG_MAX);
+	MACRO(LONG_MIN);
+	MACRO(MB_LEN_MAX);
+	MACRO_VALUE(SCHAR_MAX, 127);
+	MACRO_VALUE(SCHAR_MIN, -128);
+	MACRO(SHRT_MAX);
+	MACRO(SHRT_MIN);
+	MACRO(SSIZE_MAX);
+	MACRO_VALUE(UCHAR_MAX, 255);
+	MACRO(UINT_MAX);
+	MACRO(ULLONG_MAX);
+	MACRO(ULONG_MAX);
+	MACRO(USHRT_MAX);
+	MACRO(WORD_BIT);
+	MACRO(GETENTROPY_MAX);
+
+	MACRO(NL_ARGMAX);
+	MACRO(NL_LANGMAX);
+	MACRO(NL_MSGMAX);
+	MACRO(NL_SETMAX);
+	MACRO(NL_TEXTMAX);
+	MACRO(NZERO);
+}
diff --git a/tests/headers/locale.c b/tests/headers/locale.c
new file mode 100644
index 00000000..9a302e4f
--- /dev/null
+++ b/tests/headers/locale.c
@@ -0,0 +1,61 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/locale.h.html
+
+#include "core.h"
+
+#include <locale.h>
+
+TEST(locale_h)
+{
+	TYPE(struct lconv);
+	STRUCT_MEMBER(struct lconv, char *, currency_symbol);
+	STRUCT_MEMBER(struct lconv, char *, decimal_point);
+	STRUCT_MEMBER(struct lconv, char, frac_digits);
+	STRUCT_MEMBER(struct lconv, char *, grouping);
+	STRUCT_MEMBER(struct lconv, char *, int_curr_symbol);
+	STRUCT_MEMBER(struct lconv, char, int_frac_digits);
+	STRUCT_MEMBER(struct lconv, char, int_n_cs_precedes);
+	STRUCT_MEMBER(struct lconv, char, int_n_sep_by_space);
+	STRUCT_MEMBER(struct lconv, char, int_n_sign_posn);
+	STRUCT_MEMBER(struct lconv, char, int_p_cs_precedes);
+	STRUCT_MEMBER(struct lconv, char, int_p_sep_by_space);
+	STRUCT_MEMBER(struct lconv, char, int_p_sign_posn);
+	STRUCT_MEMBER(struct lconv, char *, mon_decimal_point);
+	STRUCT_MEMBER(struct lconv, char *, mon_grouping);
+	STRUCT_MEMBER(struct lconv, char *, mon_thousands_sep);
+	STRUCT_MEMBER(struct lconv, char *, negative_sign);
+	STRUCT_MEMBER(struct lconv, char, n_cs_precedes);
+	STRUCT_MEMBER(struct lconv, char, n_sep_by_space);
+	STRUCT_MEMBER(struct lconv, char, n_sign_posn);
+	STRUCT_MEMBER(struct lconv, char *, positive_sign);
+	STRUCT_MEMBER(struct lconv, char, p_cs_precedes);
+	STRUCT_MEMBER(struct lconv, char, p_sep_by_space);
+	STRUCT_MEMBER(struct lconv, char, p_sign_posn);
+	STRUCT_MEMBER(struct lconv, char *, thousands_sep);
+
+	MACRO(NULL);
+
+	MACRO(LC_ALL);
+	MACRO(LC_COLLATE);
+	MACRO(LC_CTYPE);
+	MACRO(LC_MONETARY);
+	MACRO(LC_NUMERIC);
+	MACRO(LC_TIME);
+
+	MACRO(LC_COLLATE_MASK);
+	MACRO(LC_CTYPE_MASK);
+	MACRO(LC_MESSAGES_MASK);
+	MACRO(LC_MONETARY_MASK);
+	MACRO(LC_NUMERIC_MASK);
+	MACRO(LC_TIME_MASK);
+	MACRO(LC_ALL_MASK);
+
+	MACRO_TYPE(locale_t, LC_GLOBAL_LOCALE);
+	TYPE(locale_t);
+
+	FUNCTION(duplocale, FN(locale_t, locale_t));
+	FUNCTION(freelocale, FN(void, locale_t));
+	FUNCTION(localeconv, FN(struct lconv *));
+	FUNCTION(newlocale, FN(locale_t, int, const char *, locale_t));
+	FUNCTION(setlocale, FN(char *, int, const char *));
+	FUNCTION(uselocale, FN(locale_t, locale_t));
+}
diff --git a/tests/headers/math.c b/tests/headers/math.c
new file mode 100644
index 00000000..0b02e1eb
--- /dev/null
+++ b/tests/headers/math.c
@@ -0,0 +1,327 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/math.h.html
+
+#include "core.h"
+
+#include <math.h>
+
+TEST(math_h)
+{
+	TYPE(float_t);
+	TYPE(double_t);
+
+#ifndef fpclassify
+#error fpclassify
+#endif
+
+#ifndef isfinite
+#error isfinite
+#endif
+
+#ifndef isgreater
+#error isgreater
+#endif
+
+#ifndef isgreaterequal
+#error isgreaterequal
+#endif
+
+#ifndef isinf
+#error isinf
+#endif
+
+#ifndef isless
+#error isless
+#endif
+
+#ifndef islessequal
+#error islessequal
+#endif
+
+#ifndef islessgreater
+#error islessgreater
+#endif
+
+#ifndef isnan
+#error isnan
+#endif
+
+#ifndef isnormal
+#error isnormal
+#endif
+
+#ifndef isunordered
+#error isunordered
+#endif
+
+#ifndef signbit
+#error signbit
+#endif
+
+	MACRO(M_E);
+	MACRO(M_EGAMMA);
+	MACRO(M_LOG2E);
+	MACRO(M_LOG10E);
+	MACRO(M_LN2);
+	MACRO(M_LN10);
+	MACRO(M_PHI);
+	MACRO(M_PI);
+	MACRO(M_PI_2);
+	MACRO(M_PI_4);
+	MACRO(M_1_PI);
+	MACRO(M_1_SQRTPI);
+	MACRO(M_2_PI);
+	MACRO(M_2_SQRTPI);
+	MACRO(M_SQRT2);
+	MACRO(M_SQRT3);
+	MACRO(M_SQRT1_2);
+	MACRO(M_SQRT1_3);
+
+	MACRO(HUGE_VAL);
+	MACRO(HUGE_VALF);
+	MACRO(HUGE_VALL);
+	MACRO(INFINITY);
+	MACRO(NAN);
+
+	MACRO(FP_INFINITE);
+	MACRO(FP_NAN);
+	MACRO(FP_NORMAL);
+	MACRO(FP_SUBNORMAL);
+	MACRO(FP_ZERO);
+
+	MACRO_VALUE(FP_FAST_FMA, 1);
+	MACRO_VALUE(FP_FAST_FMAF, 1);
+	MACRO_VALUE(FP_FAST_FMAL, 1);
+
+	MACRO(FP_ILOGB0);
+	MACRO(FP_ILOGBNAN);
+
+	MACRO_VALUE(MATH_ERRNO, 1);
+	MACRO_VALUE(MATH_ERREXCEPT, 2);
+
+	MACRO(math_errhandling);
+	MACRO_TYPE(int, math_errhandling);
+
+	FUNCTION(acos, double (*f)(double));
+	FUNCTION(acosf, float (*f)(float));
+	FUNCTION(acosh, double (*f)(double));
+	FUNCTION(acoshf, float (*f)(float));
+	FUNCTION(acoshl, long double (*f)(long double));
+	FUNCTION(acosl, long double (*f)(long double));
+
+	FUNCTION(asin, double (*f)(double));
+	FUNCTION(asinf, float (*f)(float));
+	FUNCTION(asinh, double (*f)(double));
+	FUNCTION(asinhf, float (*f)(float));
+	FUNCTION(asinhl, long double (*f)(long double));
+	FUNCTION(asinl, long double (*f)(long double));
+
+	FUNCTION(atan, double (*f)(double));
+	FUNCTION(atan2, double (*f)(double, double));
+	FUNCTION(atan2f, float (*f)(float, float));
+	FUNCTION(atan2l, long double (*f)(long double, long double));
+	FUNCTION(atanf, float (*f)(float));
+	FUNCTION(atanh, double (*f)(double));
+	FUNCTION(atanhf, float (*f)(float));
+	FUNCTION(atanhl, long double (*f)(long double));
+	FUNCTION(atanl, long double (*f)(long double));
+
+	FUNCTION(cbrt, double (*f)(double));
+	FUNCTION(cbrtf, float (*f)(float));
+	FUNCTION(cbrtl, long double (*f)(long double));
+
+	FUNCTION(ceil, double (*f)(double));
+	FUNCTION(ceilf, float (*f)(float));
+	FUNCTION(ceill, long double (*f)(long double));
+
+	FUNCTION(copysign, double (*f)(double, double));
+	FUNCTION(copysignf, float (*f)(float, float));
+	FUNCTION(copysignl, long double (*f)(long double, long double));
+
+	FUNCTION(cos, double (*f)(double));
+	FUNCTION(cosf, float (*f)(float));
+	FUNCTION(cosh, double (*f)(double));
+	FUNCTION(coshf, float (*f)(float));
+	FUNCTION(coshl, long double (*f)(long double));
+	FUNCTION(cosl, long double (*f)(long double));
+
+	FUNCTION(erf, double (*f)(double));
+	FUNCTION(erfc, double (*f)(double));
+	FUNCTION(erfcf, float (*f)(float));
+	FUNCTION(erfcl, long double (*f)(long double));
+	FUNCTION(erff, float (*f)(float));
+	FUNCTION(erfl, long double (*f)(long double));
+
+	FUNCTION(exp, double (*f)(double));
+	FUNCTION(exp2, double (*f)(double));
+	FUNCTION(exp2f, float (*f)(float));
+	FUNCTION(exp2l, long double (*f)(long double));
+	FUNCTION(expf, float (*f)(float));
+	FUNCTION(expl, long double (*f)(long double));
+	FUNCTION(expm1, double (*f)(double));
+	FUNCTION(expm1f, float (*f)(float));
+	FUNCTION(expm1l, long double (*f)(long double));
+
+	FUNCTION(fabs, double (*f)(double));
+	FUNCTION(fabsf, float (*f)(float));
+	FUNCTION(fabsl, long double (*f)(long double));
+
+	FUNCTION(fdim, double (*f)(double, double));
+	FUNCTION(fdimf, float (*f)(float, float));
+	FUNCTION(fdiml, long double (*f)(long double, long double));
+
+	FUNCTION(floor, double (*f)(double));
+	FUNCTION(floorf, float (*f)(float));
+	FUNCTION(floorl, long double (*f)(long double));
+
+	FUNCTION(fma, double (*f)(double, double, double));
+	FUNCTION(fmaf, float (*f)(float, float, float));
+	FUNCTION(fmal, long double (*f)(long double, long double, long double));
+
+	FUNCTION(fmax, double (*f)(double, double));
+	FUNCTION(fmaxf, float (*f)(float, float));
+	FUNCTION(fmaxl, long double (*f)(long double, long double));
+
+	FUNCTION(fmin, double (*f)(double, double));
+	FUNCTION(fminf, float (*f)(float, float));
+	FUNCTION(fminl, long double (*f)(long double, long double));
+
+	FUNCTION(fmod, double (*f)(double, double));
+	FUNCTION(fmodf, float (*f)(float, float));
+	FUNCTION(fmodl, long double (*f)(long double, long double));
+
+	FUNCTION(frexp, double (*f)(double, int *));
+	FUNCTION(frexpf, float (*f)(float, int *));
+	FUNCTION(frexpl, long double (*f)(long double, int *));
+
+	FUNCTION(hypot, double (*f)(double, double));
+	FUNCTION(hypotf, float (*f)(float, float));
+	FUNCTION(hypotl, long double (*f)(long double, long double));
+
+	FUNCTION(ilogb, int (*f)(double));
+	FUNCTION(ilogbf, int (*f)(float));
+	FUNCTION(ilogbl, int (*f)(long double));
+
+	FUNCTION(j0, double (*f)(double));
+	FUNCTION(j1, double (*f)(double));
+	FUNCTION(jn, double (*f)(int, double));
+
+	FUNCTION(ldexp, double (*f)(double, int));
+	FUNCTION(ldexpf, float (*f)(float, int));
+	FUNCTION(ldexpl, long double (*f)(long double, int));
+
+	FUNCTION(lgamma, double (*f)(double));
+	FUNCTION(lgammaf, float (*f)(float));
+	FUNCTION(lgammal, long double (*f)(long double));
+
+	FUNCTION(llrint, long long (*f)(double));
+	FUNCTION(llrintf, long long (*f)(float));
+	FUNCTION(llrintl, long long (*f)(long double));
+
+	FUNCTION(llround, long long (*f)(double));
+	FUNCTION(llroundf, long long (*f)(float));
+	FUNCTION(llroundl, long long (*f)(long double));
+
+	FUNCTION(log, double (*f)(double));
+	FUNCTION(log10, double (*f)(double));
+	FUNCTION(log10f, float (*f)(float));
+	FUNCTION(log10l, long double (*f)(long double));
+	FUNCTION(log1p, double (*f)(double));
+	FUNCTION(log1pf, float (*f)(float));
+	FUNCTION(log1pl, long double (*f)(long double));
+	FUNCTION(log2, double (*f)(double));
+	FUNCTION(log2f, float (*f)(float));
+	FUNCTION(log2l, long double (*f)(long double));
+	FUNCTION(logb, double (*f)(double));
+	FUNCTION(logbf, float (*f)(float));
+	FUNCTION(logbl, long double (*f)(long double));
+	FUNCTION(logf, float (*f)(float));
+	FUNCTION(logl, long double (*f)(long double));
+
+	FUNCTION(lrint, long (*f)(double));
+	FUNCTION(lrintf, long (*f)(float));
+	FUNCTION(lrintl, long (*f)(long double));
+
+	FUNCTION(lround, long (*f)(double));
+	FUNCTION(lroundf, long (*f)(float));
+	FUNCTION(lroundl, long (*f)(long double));
+
+	FUNCTION(modf, double (*f)(double, double *));
+	FUNCTION(modff, float (*f)(float, float *));
+	FUNCTION(modfl, long double (*f)(long double, long double *));
+
+	FUNCTION(nan, double (*f)(const char *));
+	FUNCTION(nanf, float (*f)(const char *));
+	FUNCTION(nanl, long double (*f)(const char *));
+
+	FUNCTION(nearbyint, double (*f)(double));
+	FUNCTION(nearbyintf, float (*f)(float));
+	FUNCTION(nearbyintl, long double (*f)(long double));
+
+	FUNCTION(nextafter, double (*f)(double, double));
+	FUNCTION(nextafterf, float (*f)(float, float));
+	FUNCTION(nextafterl, long double (*f)(long double, long double));
+
+	FUNCTION(nexttoward, double (*f)(double, long double));
+	FUNCTION(nexttowardf, float (*f)(float, long double));
+	FUNCTION(nexttowardl, long double (*f)(long double, long double));
+
+	FUNCTION(pow, double (*f)(double, double));
+	FUNCTION(powf, float (*f)(float, float));
+	FUNCTION(powl, long double (*f)(long double, long double));
+
+	FUNCTION(remainder, double (*f)(double, double));
+	FUNCTION(remainderf, float (*f)(float, float));
+	FUNCTION(remainderl, long double (*f)(long double, long double));
+
+	FUNCTION(remquo, double (*f)(double, double, int *));
+	FUNCTION(remquof, float (*f)(float, float, int *));
+	FUNCTION(remquol, long double (*f)(long double, long double, int *));
+
+	FUNCTION(rint, double (*f)(double));
+	FUNCTION(rintf, float (*f)(float));
+	FUNCTION(rintl, long double (*f)(long double));
+
+	FUNCTION(round, double (*f)(double));
+	FUNCTION(roundf, float (*f)(float));
+	FUNCTION(roundl, long double (*f)(long double));
+
+	FUNCTION(scalbln, double (*f)(double, long));
+	FUNCTION(scalblnf, float (*f)(float, long));
+	FUNCTION(scalblnl, long double (*f)(long double, long));
+
+	FUNCTION(scalbn, double (*f)(double, int));
+	FUNCTION(scalbnf, float (*f)(float, int));
+	FUNCTION(scalbnl, long double (*f)(long double, int));
+
+	FUNCTION(sin, double (*f)(double));
+	FUNCTION(sinf, float (*f)(float));
+	FUNCTION(sinh, double (*f)(double));
+	FUNCTION(sinhf, float (*f)(float));
+	FUNCTION(sinhl, long double (*f)(long double));
+	FUNCTION(sinl, long double (*f)(long double));
+
+	FUNCTION(sqrt, double (*f)(double));
+	FUNCTION(sqrtf, float (*f)(float));
+	FUNCTION(sqrtl, long double (*f)(long double));
+
+	FUNCTION(tan, double (*f)(double));
+	FUNCTION(tanf, float (*f)(float));
+	FUNCTION(tanh, double (*f)(double));
+	FUNCTION(tanhf, float (*f)(float));
+	FUNCTION(tanhl, long double (*f)(long double));
+	FUNCTION(tanl, long double (*f)(long double));
+
+	FUNCTION(tgamma, double (*f)(double));
+	FUNCTION(tgammaf, float (*f)(float));
+	FUNCTION(tgammal, long double (*f)(long double));
+
+	FUNCTION(trunc, double (*f)(double));
+	FUNCTION(truncf, float (*f)(float));
+	FUNCTION(truncl, long double (*f)(long double));
+
+	FUNCTION(y0, double (*f)(double));
+	FUNCTION(y1, double (*f)(double));
+	FUNCTION(yn, double (*f)(int, double));
+
+	int _ = signgam;
+}
diff --git a/tests/headers/monetary.c b/tests/headers/monetary.c
new file mode 100644
index 00000000..8a04ecc5
--- /dev/null
+++ b/tests/headers/monetary.c
@@ -0,0 +1,17 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/monetary.h.html
+
+#include "core.h"
+
+#include <monetary.h>
+
+TEST(monetary_h)
+{
+	TYPE(locale_t);
+	TYPE(size_t);
+	TYPE(ssize_t);
+
+	FUNCTION(strfmon, FN(ssize_t, char *restrict, size_t,
+			     const char *restrict, ...));
+	FUNCTION(strfmon_l, FN(ssize_t, char *restrict, size_t, locale_t,
+			       const char *restrict, ...));
+}
diff --git a/tests/headers/mqueue.c b/tests/headers/mqueue.c
new file mode 100644
index 00000000..28193a3c
--- /dev/null
+++ b/tests/headers/mqueue.c
@@ -0,0 +1,36 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/mqueue.h.html
+
+#include "core.h"
+
+#include <mqueue.h>
+
+TEST(mqueue_h)
+{
+	TYPE(mqd_t);
+	TYPE(size_t);
+	TYPE(ssize_t);
+	TYPE(struct timespec);
+
+	INCOMPLETE_TYPE(struct sigevent);
+
+	TYPE(struct mq_attr);
+	STRUCT_MEMBER(struct mq_attr, long, mq_flags);
+	STRUCT_MEMBER(struct mq_attr, long, mq_maxmsg);
+	STRUCT_MEMBER(struct mq_attr, long, mq_msgsize);
+	STRUCT_MEMBER(struct mq_attr, long, mq_curmsgs);
+
+	FUNCTION(mq_close, FN(int, mqd_t));
+	FUNCTION(mq_getattr, FN(int, mqd_t, struct mq_attr *));
+	FUNCTION(mq_notify, FN(int, mqd_t, const struct sigevent *));
+	FUNCTION(mq_open, FN(mqd_t, const char *, int, ...));
+	FUNCTION(mq_receive, FN(ssize_t, mqd_t, char *, size_t, unsigned *));
+	FUNCTION(mq_send, FN(int, mqd_t, const char *, size_t, unsigned));
+	FUNCTION(mq_setattr, FN(int, mqd_t, const struct mq_attr *restrict,
+				struct mq_attr *restrict));
+	FUNCTION(mq_timedreceive,
+		 FN(ssize_t, mqd_t, char *restrict, size_t, unsigned *restrict,
+		    const struct timespec *restrict));
+	FUNCTION(mq_timedsend, FN(int, mqd_t, const char *, size_t, unsigned,
+				  const struct timespec *));
+	FUNCTION(mq_unlink, FN(int, const char *));
+}
diff --git a/tests/headers/ndbm.c b/tests/headers/ndbm.c
new file mode 100644
index 00000000..757f99a2
--- /dev/null
+++ b/tests/headers/ndbm.c
@@ -0,0 +1,30 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/netdb.h.html
+
+#include "core.h"
+
+#include <ndbm.h>
+
+TEST(ndbm_h)
+{
+	TYPE(datum);
+	STRUCT_MEMBER(datum, void *, dptr);
+	STRUCT_MEMBER(datum, size_t, dsize);
+
+	TYPE(size_t);
+
+	INCOMPLETE_TYPE(DBM);
+	MACRO(DBM_INSERT);
+	MACRO(DBM_REPLACE);
+
+	FUNCTION(dbm_clearerr, FN(int, DBM *));
+	FUNCTION(dbm_close, FN(void, DBM *));
+	FUNCTION(dbm_delete, FN(int, DBM *, datum));
+	FUNCTION(dbm_error, FN(int, DBM *));
+	FUNCTION(dbm_fetch, FN(datum, DBM *, datum));
+	FUNCTION(dbm_firstkey, FN(datum, DBM *));
+	FUNCTION(dbm_nextkey, FN(datum, DBM *));
+	FUNCTION(dbm_open, FN(DBM *, const char *, int, mode_t));
+	FUNCTION(dbm_store, FN(int, DBM *, datum, datum, int));
+
+	TYPE(mode_t);
+}
diff --git a/tests/headers/net_if.c b/tests/headers/net_if.c
new file mode 100644
index 00000000..b2a5a29c
--- /dev/null
+++ b/tests/headers/net_if.c
@@ -0,0 +1,19 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/net_if.h.html
+
+#include "core.h"
+
+#include <net/if.h>
+
+TEST(net_if_h)
+{
+	TYPE(struct if_nameindex);
+	STRUCT_MEMBER(struct if_nameindex, unsigned, if_index);
+	STRUCT_MEMBER(struct if_nameindex, char *, if_name);
+
+	MACRO(IF_NAMESIZE);
+
+	FUNCTION(if_freenameindex, FN(void, struct if_nameindex *));
+	FUNCTION(if_indextoname, FN(char *, unsigned, char *));
+	FUNCTION(if_nameindex, FN(struct if_nameindex *));
+	FUNCTION(if_nametoindex, FN(unsigned, const char *));
+}
diff --git a/tests/headers/netdb.c b/tests/headers/netdb.c
new file mode 100644
index 00000000..a9346efe
--- /dev/null
+++ b/tests/headers/netdb.c
@@ -0,0 +1,127 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/netdb.h.html
+
+#include "core.h"
+
+#include <netdb.h>
+
+TEST(netdb_h)
+{
+	TYPE(struct hostent);
+	STRUCT_MEMBER(struct hostent, char *, h_name);
+	STRUCT_MEMBER(struct hostent, char **, h_aliases);
+	STRUCT_MEMBER(struct hostent, int, h_addrtype);
+	STRUCT_MEMBER(struct hostent, int, h_length);
+	STRUCT_MEMBER(struct hostent, char **, h_addr_list);
+
+	TYPE(struct netent);
+	STRUCT_MEMBER(struct netent, char *, n_name);
+	STRUCT_MEMBER(struct netent, char **, n_aliases);
+	STRUCT_MEMBER(struct netent, int, n_addrtype);
+	STRUCT_MEMBER(struct netent, uint32_t, n_net);
+
+	TYPE(uint32_t);
+	TYPE(struct protoent);
+	STRUCT_MEMBER(struct protoent, char *, p_name);
+	STRUCT_MEMBER(struct protoent, char **, p_aliases);
+	STRUCT_MEMBER(struct protoent, int, p_proto);
+
+	TYPE(struct servent);
+	STRUCT_MEMBER(struct servent, char *, s_name);
+	STRUCT_MEMBER(struct servent, char **, s_aliases);
+	STRUCT_MEMBER(struct servent, int, s_port);
+	STRUCT_MEMBER(struct servent, char *, s_proto);
+
+	MACRO(IPPORT_RESERVED);
+
+	TYPE(struct addrinfo);
+	STRUCT_MEMBER(struct addrinfo, int, ai_flags);
+	STRUCT_MEMBER(struct addrinfo, int, ai_family);
+	STRUCT_MEMBER(struct addrinfo, int, ai_socktype);
+	STRUCT_MEMBER(struct addrinfo, int, ai_protocol);
+	STRUCT_MEMBER(struct addrinfo, socklen_t, ai_addrlen);
+	STRUCT_MEMBER(struct addrinfo, struct sockaddr *, ai_addr);
+	STRUCT_MEMBER(struct addrinfo, char *, ai_canonname);
+	STRUCT_MEMBER(struct addrinfo, struct addrinfo *, ai_next);
+
+	MACRO(AI_PASSIVE);
+	MACRO(AI_CANONNAME);
+	MACRO(AI_NUMERICHOST);
+	MACRO(AI_NUMERICSERV);
+	MACRO(AI_V4MAPPED);
+	MACRO(AI_ALL);
+	MACRO(AI_ADDRCONFIG);
+
+	MACRO(NI_NOFQDN);
+	MACRO(NI_NUMERICHOST);
+	MACRO(NI_NAMEREQD);
+	MACRO(NI_NUMERICSERV);
+	MACRO(NI_NUMERICSCOPE);
+	MACRO(NI_DGRAM);
+
+	MACRO(EAI_AGAIN);
+	MACRO(EAI_BADFLAGS);
+	MACRO(EAI_FAIL);
+	MACRO(EAI_FAMILY);
+	MACRO(EAI_MEMORY);
+	MACRO(EAI_NONAME);
+	MACRO(EAI_SERVICE);
+	MACRO(EAI_SOCKTYPE);
+	MACRO(EAI_SYSTEM);
+	MACRO(EAI_OVERFLOW);
+
+	void endhostent(void);
+	void endnetent(void);
+	void endprotoent(void);
+	void endservent(void);
+	void freeaddrinfo(struct addrinfo *);
+	const char *gai_strerror(int);
+	int getaddrinfo(const char *restrict, const char *restrict,
+			const struct addrinfo *restrict,
+			struct addrinfo **restrict);
+	struct hostent *gethostent(void);
+	int getnameinfo(const struct sockaddr *restrict, socklen_t,
+			char *restrict, socklen_t, char *restrict, socklen_t,
+			int);
+	struct netent *getnetbyaddr(uint32_t, int);
+	struct netent *getnetbyname(const char *);
+	struct netent *getnetent(void);
+	struct protoent *getprotobyname(const char *);
+	struct protoent *getprotobynumber(int);
+	struct protoent *getprotoent(void);
+	struct servent *getservbyname(const char *, const char *);
+	struct servent *getservbyport(int, const char *);
+	struct servent *getservent(void);
+	void sethostent(int);
+	void setnetent(int);
+	void setprotoent(int);
+	void setservent(int);
+
+	FUNCTION(endhostent, FN(void, void));
+	FUNCTION(endnetent, FN(void, void));
+	FUNCTION(endprotoent, FN(void, void));
+	FUNCTION(endservent, FN(void, void));
+	FUNCTION(freeaddrinfo, FN(void, struct addrinfo *));
+	FUNCTION(gai_strerror, FN(const char *, int));
+	FUNCTION(getaddrinfo,
+		 FN(int, const char *restrict, const char *restrict,
+		    const struct addrinfo *restrict,
+		    struct addrinfo **restrict));
+	FUNCTION(gethostent, FN(struct hostent *, void));
+	FUNCTION(getnameinfo,
+		 FN(int, const struct sockaddr *restrict, socklen_t,
+		    char *restrict, socklen_t, char *restrict, socklen_t, int));
+	FUNCTION(getnetbyaddr, FN(struct netent *, uint32_t, int));
+	FUNCTION(getnetbyname, FN(struct netent *, const char *));
+	FUNCTION(getnetent, FN(struct netent *, void));
+	FUNCTION(getprotobyname, FN(struct protoent *, const char *));
+	FUNCTION(getprotobynumber, FN(struct protoent *, int));
+	FUNCTION(getprotoent, FN(struct protoent *, void));
+	FUNCTION(getservbyname,
+		 FN(struct servent *, const char *, const char *));
+	FUNCTION(getservbyport, FN(struct servent *, int, const char *));
+	FUNCTION(getservent, FN(struct servent *, void));
+	FUNCTION(sethostent, FN(void, int));
+	FUNCTION(setnetent, FN(void, int));
+	FUNCTION(setprotoent, FN(void, int));
+	FUNCTION(setservent, FN(void, int));
+}
diff --git a/tests/headers/netinet_tcp.c b/tests/headers/netinet_tcp.c
new file mode 100644
index 00000000..dad932be
--- /dev/null
+++ b/tests/headers/netinet_tcp.c
@@ -0,0 +1,10 @@
+// https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/netinet_tcp.h.html
+
+#include "core.h"
+
+#include <netinet/tcp.h>
+
+TEST(netinet_tcp_h)
+{
+	MACRO(TCP_NODELAY);
+}