/**

  * $Id$

  * 

  * Test data loader.

  *

  * Copyright (c) 2006 Nathan Keynes.

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation; either version 2 of the License, or

  * (at your option) any later version.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  */

 #include <stdlib.h>

 #include <string.h>

 #include <ctype.h>

 #include <math.h>

 #include "testdata.h"

 #define DEFAULT_SIZE 1024

 /* get the next 32-byte aligned address that is no less than x */

 #define ALIGN_32(x)  ((char *)((((unsigned int)(x))+0x1F)&0xFFFFFFE0))

 void free_test_dataset( test_data_t tests ) 

 {

     test_data_t next;

     do {

 	next = tests->next;

 	free(tests);

 	tests = next;

     } while( next != NULL );

 }

 test_data_block_t get_test_data( test_data_t data, char *name )

 {

     int i;

     for( i=0; i<MAX_DATA_BLOCKS; i++ ) {

 	if( data->item[i].name != NULL &&

 	    strcmp(name, data->item[i].name) == 0 ) {

 	    return &data->item[i];

 	}

     }

     return NULL;

 }

 void dump_test_dataset( FILE *f, test_data_t dataset )

 {

     test_data_t test = dataset;

     int i;

     while( test != NULL ) {

 	fprintf( f, "Test: %s\n", test->test_name );

 	for( i=0; i<MAX_DATA_BLOCKS; i++ ) {

 	    if( test->item[i].name != NULL ) {

 		fprintf( f, "Block: %s, %d bytes\n", test->item[i].name, test->item[i].length );

 		fwrite_dump( f, test->item[i].data, test->item[i].length );

 	    }

 	}

 	test = test->next;

     }

 }

 int test_block_compare( test_data_block_t block, char *result, int result_length )

 {

     if( block->length != result_length )

 	return -1;

     return memcmp( block->data, result, block->length );

 }

 /**

  * Load a batch of test data from the given IO stream.

  */

 test_data_t load_test_dataset( FILE *f )

 {

     test_data_t head = NULL;

     test_data_t current = NULL;

     test_data_t last = NULL;

     int current_size = 0;

     int current_block = -1;

     char *current_end = NULL;

     char *dataptr = NULL;

     char buf[512];

     char *line;

     while( fgets(buf, sizeof(buf), f ) != NULL ) {

 	line = buf;

 	while( isspace(*line) ) /* Trim leading whitespace */

 	    line++;

 	if( line[0] == '[' ) { /* New test */

 	    char *test_name = line+1;

 	    char *end = strchr(test_name, ']');

 	    if( end != NULL )

 		*end = '\0';

 	    current_size = DEFAULT_SIZE;

 	    test_data_t test = malloc(current_size);

 	    if( test == NULL ) {

 		fprintf( stderr, "Memory alloc failed: %d\n", current_size );

 		return NULL;

 	    }

 	    memset( test, 0, current_size );

 	    dataptr = (char *)(test+1);

 	    test->next = NULL;

 	    if( head == NULL )

 		head = test;

 	    if( current != NULL )

 		current->next = test;

 	    last = current;

 	    current = test;

 	    current_end = ((char *)test) + current_size;

 	    current_block = -1;

 	    strcpy( dataptr, test_name );

 	    test->test_name = dataptr;

 	    dataptr = ALIGN_32(dataptr + strlen(test_name)+1);

 	} else if( *line == '#' ) { /* Comment */

 	} else {

 	    char *equals = strrchr( line, '=' );

 	    if( equals != NULL ) {

 		char *block_name = line;

 		int len;

 		char *p = equals;

 		*p-- = '\0';

 		while( isspace(*p) )

 		    *p-- = '\0';

 		len = strlen(line)+1;

 		if( dataptr + len > current_end ) {

 		    current_end += current_size;

 		    current_size *= 2;

 		    current = realloc(current, current_size );

 		    if( current == NULL ) {

 			fprintf( stderr, "Memory alloc failed: %d\n", current_size );

 			return NULL;

 		    }

 		    if( last != NULL )

 			last->next = current;

 		}

 		current_block++;

 		strcpy( dataptr, block_name );

 		current->item[current_block].name = dataptr;

 		dataptr = ALIGN_32(dataptr+len);

 		current->item[current_block].data = dataptr;

 		current->item[current_block].length = 0;

 		line = equals+1;

 		while( isspace(*line) )

 		    line++;

 	    } 

 	    /* Data */

 	    if( current == NULL || current_block == -1 )

 		continue;

 	    char *p = strtok(line, "\t\r\n ");

 	    while( p != NULL ) {

 		if( dataptr + 8 > current_end ) {

 		    int old_size = current_size;

 		    current_end += current_size;

 		    current_size *= 2;

 		    current = realloc(current, current_size );

 		    if( current == NULL ) {

 			fprintf( stderr, "Memory alloc failed: %d\n", current_size );

 			return NULL;

 		    }

 		    memset( current + old_size, 0, old_size );

 		    if( last != NULL )

 			last->next = current;

 		}

 		int len = strlen(p);

 		int datalen = 0;

 		char *dot = strchr(p, '.');

 		if( dot != NULL ) { /* FP */

 		    if( p[len-1] == 'L' ) { /* Ending in L */

 			p[len-1] = '\0';

 			double d = strtod(p, NULL);

 			*((double *)dataptr) = d;

 			datalen = 8;

 		    } else {

 			float f = (float)strtod(p,NULL);

 			*((float *)dataptr) = f;

 			datalen = 4;

 		    }

 		} else {

 		    unsigned long value = strtoul(p, NULL, 16);

 		    if( len == 8 ) {

 			*((unsigned int *)dataptr) = value;

 			datalen = 4;

 		    } else if( len == 4 ) {

 			*((unsigned short *)dataptr) = value;

 			datalen = 2;

 		    } else if( len == 2 ) {

 			*((unsigned char *)dataptr) = value;

 			datalen = 1;

 		    }

 		}

 		dataptr += datalen;

 		current->item[current_block].length += datalen;

 		p = strtok(NULL, "\t\r\n ");

 	    }

 	}

     }

     fclose(f);

     return head;

 }

 int run_tests( test_func_t *test_fns ) {

     int test_count, test_failures = 0;

     for( test_count=0; test_fns[test_count] != NULL; test_count++ ) {

 	if( test_fns[test_count]() != 0 ) {

 	    fprintf( stderr, "Test %d failed\n", test_count+1 );

 	    test_failures++;

 	}

     }

     /* report */

     fprintf( stderr, "%d/%d tests passed!\n", test_count - test_failures, test_count );

     return test_failures;

 }