unit_test.inc.h

Go to the documentation of this file.

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <execinfo.h>
 
#if !(defined _WIN32 || defined __WIN32__)
#include <unistd.h>
#include <libgen.h>
#include <sys/stat.h>
#include <sys/utsname.h>
#endif
#include <hpdf.h>
#include <math.h>
#include <setjmp.h>
#include <time.h>
#include "../src/hpdftbl.h"
 
_Bool run_as_unit_test = FALSE;
 
jmp_buf _hpdftbl_jmp_env;
 
#ifndef _MSC_VER
// Silent gcc about unused "arg" in the callback and error functions
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
 
#define TESTS_DIR "./tests_libharu/"
 
static void
error_handler(HPDF_STATUS error_no, HPDF_STATUS detail_no,
                          void *user_data) {
    fprintf(stderr, "*** PDF ERROR: \"%s\", [0x%04X : %d]\n",
            hpdftbl_hpdf_get_errstr(error_no), (unsigned int)error_no, (int)detail_no);
    longjmp(_hpdftbl_jmp_env, 1);
}
 
static void
table_error_handler(hpdftbl_t t, int r, int c, int err) {
 
    int lineno;
    char *filename;
    char *extrainfo;
 
    hpdftbl_get_last_err_file(&lineno, &filename, &extrainfo);
    if (r > -1 && c > -1) {
        fprintf(stderr, "*** Table Error: [%d] \"%s\" at cell (%d, %d)", err,
                hpdftbl_get_errstr(err), r, c);
    } else {
        fprintf(stderr, "*** Table Error: [%d] \"%s\"", err,
                hpdftbl_get_errstr(err));
    }
    if( filename != NULL ) {
        fprintf(stderr," in %s:%d",filename, lineno);
    }
    if( extrainfo != NULL ) {
        fprintf(stderr,". Info: \"%s\"\n",extrainfo);
    }
    else {
        fprintf(stderr,"\n");
    }
 
    // Also print the available stacktrace
    void* callstack[128];
    int i, frames = backtrace(callstack, 128);
    char** callstack_sym = backtrace_symbols(callstack, frames);
    if( callstack_sym != NULL ) {
        fprintf(stderr, "Stacktrace:\n");
        for (i = 0; i < frames; ++i) {
            fprintf(stderr, "%s\n", callstack_sym[i]);
        }
        free(callstack_sym);
    }
 
    longjmp(_hpdftbl_jmp_env, 1);
}
 
 
#ifndef _MSC_VER
#pragma GCC diagnostic pop
#endif
 
// Setup a new PDF document with one page
void
setup_hpdf(HPDF_Doc* pdf_doc, HPDF_Page* pdf_page, _Bool addgrid) {
    *pdf_doc = HPDF_New(error_handler, NULL);
    *pdf_page = HPDF_AddPage(*pdf_doc);
    HPDF_SetCompressionMode(*pdf_doc, HPDF_COMP_ALL);
    HPDF_Page_SetSize(*pdf_page, HPDF_PAGE_SIZE_A4, HPDF_PAGE_PORTRAIT);
    if (addgrid) {
        hpdftbl_stroke_grid(*pdf_doc, *pdf_page);
    }
}
 
char *
setup_filename(int argc, char **argv) {
    static char file[1024];
    if ( 2==argc ) {
        strncpy(file, argv[1], sizeof file);
        file[sizeof(file)-1] = 0;
    } else if ( 1==argc ) {
        char fbuff[255];
        strncpy(fbuff, argv[0], sizeof fbuff);
        fbuff[sizeof(fbuff) - 1] = 0;
        char *bname = basename(fbuff);
        snprintf(file, sizeof file, "out/%s.pdf", bname);
    } else {
        return NULL;
    }
    return file;
}
 
int
stroke_to_file(HPDF_Doc pdf_doc, int argc, char **argv) {
    char *file;
    if( NULL == (file=setup_filename(argc, argv)) ) {
        fprintf(stderr,"ERROR: Unknown arguments!\n");
        return -1;
    }
 
    printf("Sending to file \"%s\" ...\n", file);
    if ( -1 == hpdftbl_stroke_pdfdoc(pdf_doc, file) ) {
        fprintf(stderr,"ERROR: Cannot save to file. Does the full directory path exist?\n");
        return -1;
    }
    printf("Done.\n");
    return 0;
}
 
 
typedef char **content_t;
 
void setup_dummy_content(content_t *content, size_t rows, size_t cols) {
    char buff[255];
    *content = calloc(rows*cols, sizeof(char*));
    size_t cnt = 0;
    for (size_t r = 0; r < rows; r++) {
        for (size_t c = 0; c < cols; c++) {
            snprintf(buff, sizeof(buff), "Content %zu", cnt);
            (*content)[cnt] = strdup(buff);
            cnt++;
        }
    }
}
 
void setup_dummy_content_label(content_t *content, content_t *labels, size_t rows, size_t cols) {
    char buff[255];
    *content = calloc(rows*cols, sizeof(char*));
    *labels = calloc(rows*cols, sizeof(char*));
    size_t cnt = 0;
    for (size_t r = 0; r < rows; r++) {
        for (size_t c = 0; c < cols; c++) {
            snprintf(buff, sizeof(buff), "Content %zu", cnt);
            (*content)[cnt] = strdup(buff);
            snprintf(buff, sizeof(buff), "Label %zu:", cnt);
            (*labels)[cnt] = strdup(buff);
            cnt++;
        }
    }
}
 
char *
mkfullpath(char *filename) {
    const size_t len=strlen(filename)+strlen(TESTS_DIR)+1;
    char *fullpath = calloc(len, sizeof(char));
    if( NULL==fullpath ) {
/*
 * ISO C does not support ‘__FUNCTION__’ predefined identifier, so we need to relax the
 * pedantic error checking for the fprintf() statement.
 */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
        fprintf(stderr,"Error: Failed to allocate dynamic buffer (%s:%d)\n", __FUNCTION__ , __LINE__);
#pragma GCC diagnostic pop
        exit(1);
    }
    xstrlcat(fullpath,TESTS_DIR,len);
    xstrlcat(fullpath,filename,len);
    return fullpath;
}
 
 
#define TUTEX_MAIN(_tbl_, _showgrid_) int \
main(int argc, char **argv) { \
    HPDF_Doc pdf_doc; \
    HPDF_Page pdf_page;   \
    run_as_unit_test = 2==argc ; \
    if (setjmp(_hpdftbl_jmp_env)) { \
        return EXIT_FAILURE; \
    }  \
    hpdftbl_set_errhandler(table_error_handler); \
    setup_hpdf(&pdf_doc, &pdf_page, _showgrid_); \
    _tbl_(pdf_doc, pdf_page); \
    if( -1 == stroke_to_file(pdf_doc, argc, argv) ) \
        return EXIT_FAILURE; \
    else \
        return EXIT_SUCCESS; \
}