#include <errno.h>
#include <stdlib.h>
#include <signal.h>
#include <stdio.h>
#include <setjmp.h>
#include <string.h>
#include "common/common.h"
#include <stdlib.h>

/*
 * Copyright (c) 2011 Luka Marčetić<paxcoder@gmail.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted.
 *
 * There's ABSOLUTELY NO WARRANTY, express or implied.
 */

jmp_buf env;
static void bridge_sig_jmp(int sig)
{
    longjmp(env, sig);
}

int main()
{
    union ret ret;
    int sig, err;
    unsigned int d, f, failed;
    char *call, *more;
    size_t i = 0;
    struct arguments *arg;
    struct sigaction oldact, act;
    struct {
        unsigned int
            ret:1,
            err:1,
            sig:1;
    } error, no_error;
    
    memset(&no_error, 0, sizeof(no_error));
    act.sa_handler = bridge_sig_jmp;
    act.sa_flags   = SA_NODEFER;

    struct test t[] =
    {
        {
            "realpath", 2,
            1, (struct data[])
            {
                {//data
                    (struct arguments[])
                    {//arg
                        {2, (char *[]) {".", "./123456789"}},
                        {1, (char *[]) {NULL}},
                    },
                    (char *[]){NULL},
                    ENAMETOOLONG,
                },
            }
        },
    };
    failed = 0;
    for (f=0; f<sizeof(t)/sizeof(t[0]); ++f) {
        memset(&error, 0, sizeof(error));
        sigaction(SIGSEGV, &act, &oldact);
        sig = 0;
        for (d=0; !(sig = setjmp(env)) && !memcmp(&error, &no_error, sizeof(error)) &&  d<t[f].ndata; ++d) {
            arg = t[f].data[d].arg; //shorthand args
            for (i=0; !memcmp(&error, &no_error, sizeof(error)) && i<iters(t[f],d); ++i) {
                switch (f) {
                        case 0:
                            if ((ret.s = realpath(ARGV(char *, 0), ARGV(char *, 1))) != *(char **)t[f].data[d].ret) {
                                call = sreturnf("%s(\"%s\", %d)", t[f].fn_name, ARGV(char *, 0), ARGV(int, 1));
                                error.ret=1;
                                more = sreturnf("%d instead of %d", ret.s, *(char *)t[f].data[d].ret);
                            }
                            if (t[f].data[d].err!=-1  &&  (err=errno) != t[f].data[d].err) {
                                call = sreturnf("%s(\"%s\", %d)", t[f].fn_name, ARGV(char *, 0), ARGV(int, 1));
                                error.err=1;
                            }
                        break;
                }
            }
        }
        error.sig = !(!sig);
        sigaction(SIGSEGV, &oldact, NULL);
        
        if (memcmp(&error, &no_error, sizeof(error))) {
            if (error.sig)
                fprintf(stderr, "Test %s caused a SIGSEGV (iteration %zu)\n",
                    t[f].fn_name, i
                );
            else {
                --d;
                --i;
            }
            if (error.ret) {
                fprintf(stderr, "%s returned %s \n", call, more);
                free(more);
            }
            if (error.err)
                fprintf(stderr, "%s set errno to %s instead of %s \n",
                    call, e_name(err), e_name(t[f].data[d].err)
                );
            
            free(call);
            ++failed;
        }
    }
    return failed;
}