#include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <sys/resource.h>
#include <unistd.h>

int main(void) {
    struct rlimit original;
    struct rlimit current;
    struct rlimit invalid;

    errno = 0;
    assert(getrlimit(RLIMIT_NOFILE, &original) == 0);

    errno = 0;
    assert(getrlimit(RLIMIT_NLIMITS, &current) == -1);
    assert(errno == EINVAL);

    errno = 0;
    assert(getrlimit(RLIMIT_NOFILE, NULL) == -1);
    assert(errno == EFAULT);

    errno = 0;
    assert(getrusage(RUSAGE_SELF, NULL) == -1);
    assert(errno == EFAULT);

    errno = 0;
    assert(setrlimit(RLIMIT_NOFILE, NULL) == -1);
    assert(errno == EFAULT);

    invalid.rlim_cur = original.rlim_max;
    invalid.rlim_max = original.rlim_cur;
    errno = 0;
    assert(setrlimit(RLIMIT_NOFILE, &invalid) == -1);
    assert(errno == EINVAL);

    if (original.rlim_max != RLIM_INFINITY) {
        invalid.rlim_cur = original.rlim_max + 1;
        invalid.rlim_max = original.rlim_max + 1;
        errno = 0;
        assert(setrlimit(RLIMIT_NOFILE, &invalid) == -1);
        assert(errno == EPERM);
    }

    current.rlim_cur = original.rlim_cur > 16 ? original.rlim_cur - 16 : original.rlim_cur;
    current.rlim_max = original.rlim_max;
    errno = 0;
    assert(setrlimit(RLIMIT_NOFILE, &current) == 0);

    struct rlimit roundtrip;
    errno = 0;
    assert(getrlimit(RLIMIT_NOFILE, &roundtrip) == 0);
    assert(roundtrip.rlim_cur == current.rlim_cur);
    assert(roundtrip.rlim_max == current.rlim_max);

    long open_max = sysconf(_SC_OPEN_MAX);
    if (current.rlim_cur == RLIM_INFINITY) {
        assert(open_max == -1);
    } else if (current.rlim_cur > LONG_MAX) {
        assert(open_max == LONG_MAX);
    } else {
        assert(open_max == (long)current.rlim_cur);
    }

    if (current.rlim_cur > INT_MAX) {
        assert(getdtablesize() == INT_MAX);
    } else {
        assert(getdtablesize() == (int)current.rlim_cur);
    }

    errno = 0;
    assert(setrlimit(RLIMIT_NOFILE, &original) == 0);
    assert(getrlimit(RLIMIT_NOFILE, &roundtrip) == 0);
    assert(roundtrip.rlim_cur == original.rlim_cur);
    assert(roundtrip.rlim_max == original.rlim_max);

    puts("rlimit roundtrip ok");
    return 0;
}