diglib/test.c

Go to the documentation of this file.

/*
 ****************************************************************************
 *
 * MODULE:       Vector library 
 *              
 * AUTHOR(S):    Original author CERL, probably Dave Gerdes.
 *               Update to GRASS 5.7 Radim Blazek.
 *
 * PURPOSE:      Test portable r/w functions 
 *
 * COPYRIGHT:    (C) 2001-2009 by the GRASS Development Team
 *
 *               This program is free software under the GNU General Public
 *               License (>=v2). Read the file COPYING that comes with GRASS
 *               for details.
 *
 *****************************************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <grass/Vect.h>

/* Test portable r/w functions */

#define D_TEST 1.3333
#define L_TEST 123456789
#define S_TEST 12345
#define C_TEST 123

int main()
{
    int i, j;
    int err;
    int byte_order;
    struct Port_info port;
    GVFILE fp;

    double db, td[] = { -(PORT_DOUBLE_MAX), -(D_TEST), -(PORT_DOUBLE_MIN),
        0, PORT_DOUBLE_MIN, D_TEST, PORT_DOUBLE_MAX
    };
    float fb, tf[] = { -(PORT_FLOAT_MAX), -(D_TEST), -(PORT_FLOAT_MIN),
        0, PORT_FLOAT_MIN, D_TEST, PORT_FLOAT_MAX
    };
    long lb, tl[] = { PORT_LONG_MIN, -(L_TEST), 0, L_TEST, PORT_LONG_MAX };
    int ib, ti[] = { PORT_INT_MIN, -(L_TEST), 0, L_TEST, PORT_INT_MAX };
    short sb, ts[] = { PORT_SHORT_MIN, -(S_TEST), 0, S_TEST, PORT_SHORT_MAX };
    char cb, tc[] = { PORT_CHAR_MIN, -(C_TEST), 0, C_TEST, PORT_CHAR_MAX };

    err = EXIT_SUCCESS;
    
    if (NULL == (fp.file = fopen("test.tmp", "wb+"))) {
        G_fatal_error("Unable tp open test.tmp file");
    }
    fp.loaded = 0;

    dig_set_cur_port(&port);

    byte_order = ENDIAN_LITTLE;
    for (i = 0; i < 2; i++) {
        dig_init_portable(&(port), byte_order);
        for (j = 0; j < 7; j++) {
            dig_fseek(&fp, 0, SEEK_CUR);
            fprintf(fp.file, "double  ");
            dig__fwrite_port_D(&(td[j]), 1, &fp);
            dig_fseek(&fp, -(PORT_DOUBLE), SEEK_CUR);
            dig__fread_port_D(&db, 1, &fp);
            dig_fflush(&fp);
            if (db != td[j]) {
                G_warning("Error in read/write portable double, byte_order = %d"
                          " Written: %.16e3E Read: %.16e3E",
                          byte_order, td[j], db);
                err = EXIT_FAILURE;
            }
        }
        for (j = 0; j < 7; j++) {
            dig_fseek(&fp, 0, SEEK_CUR);
            fprintf(fp.file, "float       ");
            dig__fwrite_port_F(&(tf[j]), 1, &fp);
            dig_fseek(&fp, -(PORT_FLOAT), SEEK_CUR);
            dig__fread_port_F(&fb, 1, &fp);
            dig_fflush(&fp);
            if (fb != tf[j]) {
                G_warning("Error in read/write portable float, byte_order = %d"
                          " Written: %.8e3E Read: %.8e3E",
                          byte_order, tf[j], fb);
                err = EXIT_FAILURE;
            }
        }

        for (j = 0; j < 5; j++) {
            dig_fseek(&fp, 0, SEEK_CUR);
            fprintf(fp.file, "long        ");
            dig__fwrite_port_L(&(tl[j]), 1, &fp);
            dig_fseek(&fp, -(PORT_LONG), SEEK_CUR);
            dig__fread_port_L(&lb, 1, &fp);
            dig_fflush(&fp);
            if (lb != tl[j]) {
                G_warning("Error in read/write portable long, byte_order = %d"
                          " Written: %lu Read: %lu", 
                          byte_order, (long unsigned) tl[j], (long unsigned) lb);
                err = EXIT_FAILURE;
            }
        }

        for (j = 0; j < 5; j++) {
            dig_fseek(&fp, 0, SEEK_CUR);
            fprintf(fp.file, "int         ");
            dig__fwrite_port_I(&(ti[j]), 1, &fp);
            dig_fseek(&fp, -(PORT_INT), SEEK_CUR);
            dig__fread_port_I(&ib, 1, &fp);
            dig_fflush(&fp);
            if (ib != ti[j]) {
                G_warning("Error in read/write portable int, byte_order = %d"
                          " Written: %d Read: %d", 
                          byte_order, ti[j], ib);
                
                err = EXIT_FAILURE;
            }
        }

        for (j = 0; j < 5; j++) {
            dig_fseek(&fp, 0, SEEK_CUR);
            fprintf(fp.file, "short         ");
            dig__fwrite_port_S(&(ts[j]), 1, &fp);
            dig_fseek(&fp, -(PORT_SHORT), SEEK_CUR);
            dig__fread_port_S(&sb, 1, &fp);
            dig_fflush(&fp);
            if (sb != ts[j]) {
                G_warning("Error in read/write portable short, byte_order = %d"
                          " Written: %d Read: %d",
                          byte_order,  ts[j], sb);
                
                err = EXIT_FAILURE;
            }
        }
        for (j = 0; j < 5; j++) {
            dig_fseek(&fp, 0, SEEK_CUR);
            fprintf(fp.file, "char           ");
            dig__fwrite_port_C(&(tc[j]), 1, &fp);
            dig_fseek(&fp, -(PORT_CHAR), SEEK_CUR);
            dig__fread_port_C(&cb, 1, &fp);
            dig_fflush(&fp);
            if (cb != tc[j]) {
                G_warning("Error in read/write portable char, byte_order = %d"
                          " Written: %d Read: %d",
                          byte_order, tc[j], cb);
                err = EXIT_FAILURE;
            }


        }
        byte_order = ENDIAN_BIG;
    }

    fclose(fp.file);

    exit(err);
}