diff options
Diffstat (limited to 'tests')
35 files changed, 2031 insertions, 0 deletions
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); +} |