/*
 * Test harness for the aif library.
 *
 * Originally written by Raphael Finkel 8/2000 raphael@cs.uky.edu
 *
 * Copyright (c) 1996-2002 by Guardsoft Pty Ltd.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */

#include <stdio.h>
#include <stdlib.h>
#include <string.h> /* memcpy */
#include <unistd.h> /* getopt */
#ifdef __alpha
#include <string.h> /* memcpy */
#endif
#include "aif.h"
#include "aifint.h"
#include "testaif.h"

#define TEST_SERIES_1 0x01
#define TEST_SERIES_2 0x02
#define TEST_SERIES_3 0x04
#define TEST_SERIES_4 0x08
#define TEST_SERIES_5 0x10
#define TEST_SERIES_6 0x20


TestFlags all = {
	1,1,1,
	1,1,1,1,1,1,1,1,1,1,1,1,1,1,
	1,1,
	(AIF*)SELF, (AIF*)NULL, (AIF*)NULL,
	(AIF*)NULL, (AIF*)NULL, (AIF*)NULL, (AIF*)NULL, (AIF*)NULL,
	NULL,
	0};

TestFlags none = {
	0,0,0,
	0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,
	NULL,NULL,
	NULL,NULL,NULL,NULL,NULL,
	NULL,
	0};


/*****************************************
 ***        Function Prototypes        ***
 *****************************************/

void 	TestAllConstructors();
void 	TestAllAscii();
void 	TestAllArithmetic();
void 	TestAllCircularData();
void 	TestAllEPS();
void 	TestAllCompareByName();
void 	_testAscii(char *, char *, char *, char *, TestFlags);
void 	_testArithmetic(char *, AIF *, char *, TestFlags, AIF *);
void 	_testCircularData(char *, AIF *, AIF *, TestFlags);
void 	_testEPS(AIF *, AIF *, AIF *);
void 	_testCompareByName(int, AIF *, AIF *, char *);

int 	AIFTest(char *, AIF *, char *, TestFlags);
int 	AIFTestInt(char *, AIF *, char *, TestFlags);
int 	_aif_test(AIF *, TestFlags);
int 	_aif_test_general(AIF *, TestFlags);
int 	_aif_test_bool(AIF *, TestFlags);
int 	_aif_test_char(AIF *, TestFlags);
int 	_aif_test_int(AIF *, TestFlags);
int 	_aif_test_float(AIF *, TestFlags);
int 	_aif_test_array(AIF *, TestFlags);
int 	_aif_test_pointer(AIF *, TestFlags);
int 	_aif_test_region(AIF *, TestFlags);
int 	_aif_test_struct(AIF *, TestFlags);
int 	_aif_test_name(AIF *, TestFlags);
int 	_aif_test_reference(AIF *, TestFlags);
int 	_aif_test_string(AIF *, TestFlags);
int 	_aif_test_enum(AIF *, TestFlags);
int 	_aif_test_union(AIF *, TestFlags);


/*****************************************
 ***           Main Function           ***
 *****************************************/

int 
main(int argc, char *argv[])
{
	int	c;
	int	tests = 0;

	while ( (c = getopt(argc, argv, "123456")) != EOF )
	{
		switch ( c )
		{
		case '1':
			tests |= TEST_SERIES_1;
			break;

		case '2':
			tests |= TEST_SERIES_2;
			break;

		case '3':
			tests |= TEST_SERIES_3;
			break;
		
		case '4':
			tests |= TEST_SERIES_4;
			break;
		
		case '5':
			tests |= TEST_SERIES_5;
			break;
		
		case '6':
			tests |= TEST_SERIES_6;
			break;
		
		default:
			fprintf(stderr, "usage: testaif [-1] [-2] [-3] [-4] [-5] [-6]\n");
			exit(0);
		}
	}

	if ( tests == 0 || tests & TEST_SERIES_1 )
		TestAllConstructors();

	if ( tests == 0 || tests & TEST_SERIES_2 )
		TestAllAscii();

	if ( tests == 0 || tests & TEST_SERIES_3 )
		TestAllArithmetic();

	if ( tests == 0 || tests & TEST_SERIES_4 )
		TestAllCircularData();

	if ( tests == 0 || tests & TEST_SERIES_5 )
		TestAllEPS();

	if ( tests == 0 || tests & TEST_SERIES_6 )
		TestAllCompareByName();

        fprintf(stdout, "\n****** END OF TEST ******\n");

	return 0;

}


/*****************************************
 ***       Function Definitions        ***
 *****************************************/

void 
TestAllConstructors()
{
	AIF *aString, *aFloat, *aDouble, *anInt, *aPointer, *aStruct;
	AIF *anArray, *anEnum, *aUnion;
	TestFlags flag = all;
	int min, max;


        fprintf(stdout, "*********************************** \n");
        fprintf(stdout, "*** TEST SERIES 1: constructors *** \n");
        fprintf(stdout, "*********************************** \n\n");


	aString = StringToAIF("hello, world!");
	AIFTest("subtest1", aString, "string: hello, world!", flag);

	aFloat = FloatToAIF(2);
	AIFTest("subtest2", aFloat, "float: 2", flag);

	aDouble = DoubleToAIF(0);
	AIFTest("subtest3", aDouble, "double: 0", flag);

	anInt = IntToAIF(16);
	AIFTest("subtest4", anInt, "integer: 16", flag);

	aPointer = PointerToAIF(NULL, anInt);
	AIFTest("subtest5", aPointer, "a pointer", flag);

	aPointer = PointerToAIF(NULL, aPointer);
	AIFTest("subtest6", aPointer, "a double pointer", flag);

	aStruct = EmptyStructToAIF("test_struct");
	AIFTest("subtest7", aStruct, "empty struct", flag);

        AIFAddFieldToStruct(aStruct, "field1", aFloat);
        AIFTest("subtest8", aStruct, "with one field", flag);

        AIFAddFieldToStruct(aStruct, "field2", IntToAIF(16));
        AIFTest("subtest9", aStruct, "with two fields", flag);

        AIFAddFieldToStruct(aStruct, "field3", aStruct);
	AIFTest("subtest10", aStruct, "with three fields", flag);

        min = 0; max = 9;
        anArray = ArrayToAIF(1, &min, &max, "abcdefghij", 10, "c");
        AIFTest("subtest11", anArray, "array of 10 chars", flag);

        AIFAddFieldToStruct(aStruct, "field4", anArray);
        AIFTest("subtest12", aStruct, "after the array is field 4", flag);

        /* test a linked list: 1 -> 2 -> nil */
        aStruct = EmptyStructToAIF("test_struct");
        aStruct = NameAIF(aStruct, 0);
        AIFAddFieldToStruct(aStruct, "value", IntToAIF(2));
        AIFAddFieldToStruct(aStruct, "next", AIFNull(aStruct));
        aPointer = PointerToAIF(NULL, aStruct);
        aStruct = EmptyStructToAIF("test_struct");
        AIFAddFieldToStruct(aStruct, "value", IntToAIF(1));
        AIFAddFieldToStruct(aStruct, "next", aPointer);
        aPointer = PointerToAIF(NULL, aStruct);
        AIFTest("subtest13", aPointer, "linked list 1 -> 2 ", flag);

	/* test an array of structs. */
	{
		char data[BUFSIZ], *dest;
		int min=1, max=9, subMin = 1, subMax = 2;
		int index;
		int smallArray[2] = {1,2};

		aStruct = EmptyStructToAIF("test_struct");
		AIFAddFieldToStruct(aStruct, "a", FloatToAIF(2.1));
		dest = data;
		for (index = 0; index < 2; index++) 
		{
			AIFNormalise(dest, sizeof(int), (char *)(smallArray+index), sizeof(int));
			dest += sizeof(int);
		}
		anArray = ArrayToAIF(1, &subMin, &subMax, data, 2*sizeof(int),
			AIF_FORMAT(IntToAIF(0)));
		AIFAddFieldToStruct(aStruct, "b", anArray);
		AIFTest("subtest14", aStruct, "underlying struct: {a=2.1 b=[1 2]}", flag);


		dest = data;
		for (index = min; index <= max; index++) 
		{
			memcpy(dest, AIF_DATA(aStruct), AIF_LEN(aStruct));
			dest += AIF_LEN(aStruct);
		}
		anArray = ArrayToAIF(1, &min, &max, data, (max-min+1)*AIF_LEN(aStruct), AIF_FORMAT(aStruct));
		AIFTest("subtest15", anArray, "array of 9 underlying structs", flag);
	}


	anEnum = EmptyEnumToAIF("test_enum");
	AIFTest("subtest16", anEnum, "empty enum", flag);

	AIFAddConstToEnum(anEnum, "const1", IntToAIF(10));
	AIFAddConstToEnum(anEnum, "const2", IntToAIF(20));
	AIFAddConstToEnum(anEnum, "const3", IntToAIF(0));
	AIFSetEnum(anEnum, "const1");
	AIFTest("subtest17", anEnum, "enum: 10", flag);

	aStruct = EmptyStructToAIF("test_enum");
	AIFAddFieldToStruct(aStruct, "field1", anEnum);
	AIFTest("subtest18", aStruct, "an enum in a struct", flag);

	AIFSetEnum(anEnum, "const3");
	aStruct = EmptyStructToAIF("test_enum");
	AIFAddFieldToStruct(aStruct, "field1", anEnum);
	AIFTest("subtest19", aStruct, "same struct but the enum is set to another value", flag);

	AIFSetEnum(anEnum, "const2");
	aPointer = PointerToAIF(NULL, anEnum);
	aPointer = PointerToAIF(NULL, aPointer);
	AIFAddFieldToStruct(aStruct, "field2", aPointer);
	AIFTest("subtest20", aStruct, "field2 is a pointer to a pointer to an enum", flag);


	/* test an array of enums. */
	{
		char data[BUFSIZ], *dest;
		int min=1, max=15, index, val;
                dest = data;
                for (index = min; index <= max; index++)
                {
			val = rand() % 3;
			switch (val)
			{
				case 0:
					AIFSetEnum(anEnum, "const1");
					break;
				case 1:
					AIFSetEnum(anEnum, "const2");
					break;
				case 2:
					AIFSetEnum(anEnum, "const3");
					break;
			}
                        memcpy(dest, AIF_DATA(anEnum), AIF_LEN(anEnum));
                        dest += AIF_LEN(anEnum);
                }

                anArray = ArrayToAIF(1, &min, &max, data, (max-min+1)*AIF_LEN(anEnum), AIF_FORMAT(anEnum));
                AIFTest("subtest21", anArray, "array of 15 underlying enums (random)", flag);
        }


	aUnion = EmptyUnionToAIF("test_union");
	AIFTest("subtest22", aUnion, "empty union", flag);

	AIFAddFieldToUnion(aUnion, "const1", "is4");
	AIFAddFieldToUnion(aUnion, "const2", "is4");
	AIFSetUnion(aUnion, "const1", IntToAIF(10));
	AIFTest("subtest23", aUnion, "union: 10", flag);

	aStruct = EmptyStructToAIF("test_struct");
        AIFAddFieldToStruct(aStruct, "field1", IntToAIF(1));
        AIFAddFieldToStruct(aStruct, "field2", StringToAIF("Hello World"));
        AIFAddFieldToStruct(aStruct, "field3", IntToAIF(2));
	AIFTest("subtest24", aStruct, "a struct: 1, Hello World, 2", flag);

	/* Testing for a long string */
	aString = StringToAIF("AIF0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789AIF");
	AIFTest("subtest25", aString, "string: AIF100digitsAIF", flag);

	fprintf(stdout, "\n");
}


void
_testAscii(char *tst, char *fds, char *data, char *msg, TestFlags flag)
{
        AIF *toTest;
        toTest = AsciiToAIF(fds, data);
	AIFTest(tst, toTest, msg, flag);
	AIFFree(toTest);
}

void 
TestAllAscii()
{
	TestFlags flag = all;


        fprintf(stdout, "********************************** \n");
        fprintf(stdout, "*** TEST SERIES 2: ascii input *** \n");
        fprintf(stdout, "********************************** \n\n");


	_testAscii("subtest1", "is4", "00000004", "4", flag);

	_testAscii("subtest2", "f4", "3f8ccccd", "1.1", flag);

	_testAscii("subtest3", "f8", "4005bf0a8b145769", "2.718281828459045235360287471352 (f8)", flag);

	_testAscii("subtest4", "f16", "40005bf0a8b1457695355fb8ac404e7a", "2.718281828459045235360287471352662497 (f16)", flag);

	_testAscii("subtest5", "{|a=is4,b=is4;;;}", "0000000200000003", "{a=2, b=3}", flag);

	_testAscii("subtest6", "[r0..1is4]is4", "0000000200000003", "[2, 3]", flag);

	_testAscii("subtest7", "%0/{|val=is4,next=^>0/,msg=^c;;;}", "00000003000163", "{val=3, next=nil, msg=^c}", flag);

	_testAscii("subtest8", "%0/{|val=is4,next=^>0/,msg=^c;;;}", "0000000101000000020200000000000000030300000000016301620161", "a->b->c->self", flag);

	_testAscii("subtest9", "[r0..1is4]%0/{|val=is4,next=^>0/,msg=^c;;;}", "00000001010000000202000000000000000303000000000163016201610000000203000000000162", "array of two lists of pointers", flag);

	_testAscii("subtest10", "%0/{|val=is4,next=^>0/,msg=^c;;;}", "00000003020000000000000003030000000001630163", "{val=3, next=self, msg=^c}", flag);

	_testAscii("subtest11", "s", "000b613a20686f20686f20686f", "a: ho ho ho", flag);

	_testAscii("subtest12", "[r0..1is4]%0/{|val=is4,next=^>0/,msg=s;;;}", "0000000101000000020200000000000000030300000000000b633a20686f20686f20686f000b623a20686f20686f20686f000b613a20686f20686f20686f000000020300000000000b623a20686f20686f20686f", "d[,]", flag);

	_testAscii("subtest13", "[r0..99is4]^%0/{|name=s,data=is4,next=^>0/}", "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "empty hash table", flag);

	_testAscii("subtest14", "[r0..99is4]^%0/{|name=s,data=is4,next=^>0/;;;}", "00000000000000000000000000000000000100057468657265000000010000000000010005746865726500000001000000000000000000010002686900000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "hash table containing hi, there, there", flag);

	_testAscii("subtest15", "[r0..1is4]%0/{|val=is4,next=^>0/,msg=s;;;}", "0011111101000000020200000111000000030300000111000b633a20686f20686f20686f000b623a20686f20686f20616f000b613a20686f20686f20686f000000020300000111000b623a20686f20686f20686f", "d[,]", flag);

	_testAscii("subtest16", "%0/{|val=is4,next=^>0/,msg=^c;;;}", "0000000101000000020200000133000000030300000133016301620161", "a->b->c->self", flag);

	_testAscii("subtest17", "[r0..1is4]%0/{|val=is4,next=^>0/,msg=^c;;;}", "00000001010000000202000001330000000303000001330163016201610000000203000001330162", "array of two lists of pointers", flag);

	_testAscii("subtest18", "[r0..2is4][r0..1is4]is4", "000000060000000700000002000000030000000400000005", "array of two lists of pointers", flag);

	_testAscii("subtest19", "v4", "00000006", "void", flag);

	_testAscii("subtest20", "&is4,^^c/is4", "6D61696E00", "function with args (int, char **) returning int", flag);

	fprintf(stdout, "\n");

}


void
_testArithmetic(char *msg1, AIF *a, char *msg2, TestFlags flag, AIF *b)
{
	flag.AIFAdd = b;
	flag.AIFSub = flag.AIFMul = flag.AIFDiv = flag.AIFRem = flag.AIFAdd;
	flag.AIFAnd = flag.AIFOr = flag.AIFAdd;
	AIFTestInt(msg1, a, msg2, flag);
}

void 
TestAllArithmetic()
{
	AIF *anEnum1, *anEnum2, *aStruct1, *aStruct2;
	TestFlags flag = none;

	flag.AIFNeg = 1;
	flag.AIFNot = 1;


        fprintf(stdout, "********************************* \n");
        fprintf(stdout, "*** TEST SERIES 3: arithmetic *** \n");
        fprintf(stdout, "********************************* \n\n");


	_testArithmetic("subtest1", IntToAIF(16), "16 and 17", flag, IntToAIF(17));

	_testArithmetic("subtest2", IntToAIF(18), "18 and 17", flag, IntToAIF(17));

	_testArithmetic("subtest3", IntToAIF(0), "0 and -1", flag, IntToAIF(-1));

	_testArithmetic("subtest4", IntToAIF(-1), "-1 and -1", flag, IntToAIF(-1));

	_testArithmetic("subtest5", IntToAIF(1073741824L), "1073741824L and 1073741825L", flag, IntToAIF(1073741825L));

	_testArithmetic("subtest6", LongestToAIF(1073741824L), "1073741824L and 1073741825L", flag, LongestToAIF(1073741825L));

	_testArithmetic("subtest7", LongestToAIF(7L), "7L and 3", flag, IntToAIF(3));

	_testArithmetic("subtest8", FloatToAIF(3.0), "3.0 and 1.5", flag, FloatToAIF(1.5));

	_testArithmetic("subtest9", FloatToAIF(7.0), "7.0 and 3", flag, IntToAIF(3));

	_testArithmetic("subtest10", IntToAIF(3), "3 and 7.0", flag, FloatToAIF(7.0));


        anEnum1 = EmptyEnumToAIF("test_enum1");
        anEnum2 = EmptyEnumToAIF("test_enum2");
        AIFAddConstToEnum(anEnum1, "const1", IntToAIF(16));
        AIFAddConstToEnum(anEnum1, "const2", IntToAIF(18));
        AIFAddConstToEnum(anEnum2, "const1", IntToAIF(17));
        AIFAddConstToEnum(anEnum2, "const2", IntToAIF(17));
        AIFSetEnum(anEnum1, "const1");
        AIFSetEnum(anEnum2, "const1");
	_testArithmetic("subtest11", anEnum1, "anEnum1 and anEnum2", flag, anEnum2);

        aStruct1 = EmptyStructToAIF("test_struct1");
        aStruct2 = EmptyStructToAIF("test_struct2");
        AIFAddFieldToStruct(aStruct1, "field1", IntToAIF(16));
        AIFAddFieldToStruct(aStruct1, "field2", IntToAIF(18));
        AIFAddFieldToStruct(aStruct2, "field1", IntToAIF(17));
        AIFAddFieldToStruct(aStruct2, "field2", IntToAIF(17));
	_testArithmetic("subtest12", aStruct1, "aStruct1 and aStruct2", flag, aStruct2);

	aStruct1 = EmptyStructToAIF("test_struct1");
        aStruct2 = EmptyStructToAIF("test_struct2");
        AIFAddFieldToStruct(aStruct1, "field1", IntToAIF(18));
        AIFAddFieldToStruct(aStruct1, "field2", anEnum1);
        AIFAddFieldToStruct(aStruct2, "field1", IntToAIF(17));
        AIFAddFieldToStruct(aStruct2, "field2", anEnum2);
	_testArithmetic("subtest13", aStruct1, "aStruct1 and aStruct2", flag, aStruct2);

	_testArithmetic("subtest14", anEnum1, "anEnum1 and 17", flag, IntToAIF(17));

	_testArithmetic("subtest15", anEnum1, "anEnum1 and 17", flag, FloatToAIF(17));

	_testArithmetic("subtest16", IntToAIF(17), "17 and anEnum1", flag, anEnum1);

	_testArithmetic("subtest17", FloatToAIF(17), "17 and anEnum1", flag, anEnum1);


	{
		char data[BUFSIZ], *dest;
		int min=1, max=2;
		AIF *anArray1, *anArray2;
		AIF *anInt1 = IntToAIF(10);
		AIF *anInt2 = IntToAIF(20);

                dest = data;
                memcpy(dest, AIF_DATA(anInt1), AIF_LEN(anInt1));
                dest += AIF_LEN(anInt1);
                memcpy(dest, AIF_DATA(anInt1), AIF_LEN(anInt1));
                dest += AIF_LEN(anInt1);
                anArray1 = ArrayToAIF(1, &min, &max, data, (max-min+1)*AIF_LEN(anInt1), AIF_FORMAT(anInt1));

                dest = data;
                memcpy(dest, AIF_DATA(anInt2), AIF_LEN(anInt2));
                dest += AIF_LEN(anInt2);
                memcpy(dest, AIF_DATA(anInt2), AIF_LEN(anInt2));
                dest += AIF_LEN(anInt2);
                anArray2 = ArrayToAIF(1, &min, &max, data, (max-min+1)*AIF_LEN(anInt2), AIF_FORMAT(anInt2));

		_testArithmetic("subtest18", anArray1, "anArray1 and anArray2", flag, anArray2);
        }

	{
		char data[BUFSIZ], *dest;
		int min=1, max=2;
		AIF *anArray1, *anArray2;

                dest = data;
		AIFSetEnum(anEnum1, "const1");
                memcpy(dest, AIF_DATA(anEnum1), AIF_LEN(anEnum1));
                dest += AIF_LEN(anEnum1);
		AIFSetEnum(anEnum1, "const2");
                memcpy(dest, AIF_DATA(anEnum1), AIF_LEN(anEnum1));
                dest += AIF_LEN(anEnum1);
                anArray1 = ArrayToAIF(1, &min, &max, data, (max-min+1)*AIF_LEN(anEnum1), AIF_FORMAT(anEnum1));

                dest = data;
		AIFSetEnum(anEnum2, "const1");
                memcpy(dest, AIF_DATA(anEnum2), AIF_LEN(anEnum2));
                dest += AIF_LEN(anEnum2);
		AIFSetEnum(anEnum2, "const2");
                memcpy(dest, AIF_DATA(anEnum2), AIF_LEN(anEnum2));
                dest += AIF_LEN(anEnum2);
                anArray2 = ArrayToAIF(1, &min, &max, data, (max-min+1)*AIF_LEN(anEnum2), AIF_FORMAT(anEnum2));

		_testArithmetic("subtest19", anArray1, "anArray1 and anArray2", flag, anArray2);
        }

	{
		char data[BUFSIZ], *dest;
		int min=1, max=2;
		AIF *anArray1, *anArray2;
		AIF *anInt = IntToAIF(3);
		AIF *aFloat = FloatToAIF(7);

                dest = data;
                memcpy(dest, AIF_DATA(anInt), AIF_LEN(anInt));
                dest += AIF_LEN(anInt);
                memcpy(dest, AIF_DATA(anInt), AIF_LEN(anInt));
                dest += AIF_LEN(anInt);
                anArray1 = ArrayToAIF(1, &min, &max, data, (max-min+1)*AIF_LEN(anInt), AIF_FORMAT(anInt));

                dest = data;
                memcpy(dest, AIF_DATA(aFloat), AIF_LEN(aFloat));
                dest += AIF_LEN(aFloat);
                memcpy(dest, AIF_DATA(aFloat), AIF_LEN(aFloat));
                dest += AIF_LEN(aFloat);
                anArray2 = ArrayToAIF(1, &min, &max, data, (max-min+1)*AIF_LEN(aFloat), AIF_FORMAT(aFloat));

		_testArithmetic("subtest20", anArray1, "anArray1 and anArray2", flag, anArray2);
        }

	aStruct1 = EmptyStructToAIF("test_struct1");
	aStruct2 = EmptyStructToAIF("test_struct2");
	AIFAddFieldToStruct(aStruct1, "field1", IntToAIF(10));
	AIFAddFieldToStruct(aStruct1, "field2", IntToAIF(10));
	AIFAddFieldToStruct(aStruct2, "field1", FloatToAIF(7));
	AIFAddFieldToStruct(aStruct2, "field2", FloatToAIF(7));
	_testArithmetic("subtest21", aStruct1, "aStruct1 and aStruct2", flag, aStruct2);


	_testArithmetic("subtest22", UnsignedIntToAIF(16), "unsigned 16 and unsigned 17", flag, UnsignedIntToAIF(17));

	_testArithmetic("subtest23", UnsignedIntToAIF(18), "unsigned 18 and unsigned 17", flag, UnsignedIntToAIF(17));

	_testArithmetic("subtest24", UnsignedIntToAIF(0), "unsigned 0 and unsigned -1", flag, UnsignedIntToAIF(-1));

	_testArithmetic("subtest25", UnsignedIntToAIF(-1), "unsigned -1 and unsigned -1", flag, UnsignedIntToAIF(-1));

	_testArithmetic("subtest26", UnsignedIntToAIF(1073741824L), "unsigned 1073741824L and unsigned 1073741825L", flag, UnsignedIntToAIF(1073741825L));

	fprintf(stdout, "\n");

}


void
_testCircularData(char * msg, AIF *a, AIF *b, TestFlags flag)
{
	TestFlags f = flag;
	char txt[BUFSIZ];

	AIFTest(msg, a, "(a) with depth = 0", f);
	AIFTest(msg, b, "(b) with depth = 0", f);

	for (f.D_AIFPrint = -2; f.D_AIFPrint <= flag.D_AIFPrint; f.D_AIFPrint++)
	{
		if (f.D_AIFPrint == 0) continue;

		sprintf(txt, "(a) with depth = %d", f.D_AIFPrint);
		AIFTest(">>>>>>>>", a, txt, f);

		sprintf(txt, "(b) with depth = %d", f.D_AIFPrint);
		AIFTest(">>>>>>>>", b, txt, f);
	}

	_testArithmetic("\n\narithmetic", a, "(a) and (b)", flag, b);

	f = none;
	f.AIFDiff = b;
	AIFTest("\n\nAIFDiff", a, "AIFDiff(a, b)", f);

	printf("\n----------------------------------\n\n");
}

void 
TestAllCircularData()
{
	AIF *a, *b;

	TestFlags flag = none;

        fprintf(stdout, "************************************ \n");
        fprintf(stdout, "*** TEST SERIES 4: circular data *** \n");
        fprintf(stdout, "************************************ \n\n");

	a = AsciiToAIF((char *)strdup("^%0/{|a=is4,b=^>0/,c=is4;;;}"), (char *)strdup("02000000000000000a03000000000000000a"));
        b = AsciiToAIF((char *)strdup("^%0/{|a=is4,b=^>0/,c=is4;;;}"), (char *)strdup("02000000000000000b03000000000000000c"));
	flag.D_AIFPrint = 3;
        _testCircularData("subtest1", a, b, flag);


        a = AsciiToAIF((char *)strdup("^%0/{|a=is4,b=^>0/,c=is4;;;}"), (char *)strdup("02000000000000000a01000000140300000000000000150000000b"));
        b = AsciiToAIF((char *)strdup("^%0/{|a=is4,b=^>0/,c=is4;;;}"), (char *)strdup("02000000000000000b01000000160300000000000000180000000f"));
	flag.D_AIFPrint = 4;
        _testCircularData("subtest2", a, b, flag);


        a = AsciiToAIF((char *)strdup("^%0/{|a=is4,b=^>0/,c=^%1/{|a=is4,b=^>0/,c=^>1/,d=is4;;;},d=is4;;;}"), (char *)strdup("02000000000000000a010000001400010000001e0300000000000000001e00000014000000000a"));
        b = AsciiToAIF((char *)strdup("^%0/{|a=is4,b=^>0/,c=^%1/{|a=is4,b=^>0/,c=^>1/,d=is4;;;},d=is4;;;}"), (char *)strdup("02000000000000000b01000000170001000000230300000000000000002400000018000000000c"));
	flag.D_AIFPrint = 5;
        _testCircularData("subtest3", a, b, flag);


        a = AsciiToAIF((char *)strdup("^%0/{|a=is4,b=^>0/,c=^%1/{|a=is4,b=^>0/,c=^>1/,d=is4;;;},d=is4;;;}"), (char *)strdup("02000000000000000a0100000014010000001e00010000002800010000003200010000003c0300000000000000003c00000032000000280000001e0000000014000000000a"));
        b = AsciiToAIF((char *)strdup("^%0/{|a=is4,b=^>0/,c=^%1/{|a=is4,b=^>0/,c=^>1/,d=is4;;;},d=is4;;;}"), (char *)strdup("02000000000000000a0100000014010000001e00010000002800010000003200010000003c0300000000000000003c00000032000000280000001e0000000014000000000a"));
	flag.D_AIFPrint = 7;
        _testCircularData("subtest4", a, b, flag);


}


void
_testEPS(AIF *lo, AIF *hi, AIF *a)
{
	int val;
        int ret;

        ret = AIFEPS(lo, hi, a, &val);
        if (ret == 0)
        {
                printf("AIFEPS(lo = ");
                AIFPrint(stdout, 0, lo);
                printf(", hi = ");
                AIFPrint(stdout, 0, hi);
                printf(", a = ");
                AIFPrint(stdout, 0, a);
                printf("): val = %d\n", val);
        }
        else
                printf("*** ERROR *** : %s\n", AIFErrorStr());
}

void 
TestAllEPS()
{
	AIF * a;
	AIF * lo;
	AIF * hi;

        fprintf(stdout, "********************************** \n");
        fprintf(stdout, "*** TEST SERIES 5: AIFEPS      *** \n");
        fprintf(stdout, "********************************** \n\n");

	//AIF_BOOLEAN
	printf("\n>>>>>>> BOOLEAN\n");
	a = BoolToAIF(0); lo = BoolToAIF(0); hi = BoolToAIF(1);
	_testEPS(lo, hi, a);
	_testEPS(a, lo, hi);
	_testEPS(hi, a, lo);
	AIFFree(a); AIFFree(lo); AIFFree(hi);

	//AIF_INTEGER
	printf("\n>>>>>>> INTEGER\n");
	a = IntToAIF(5); lo = IntToAIF(3); hi = IntToAIF(8);
	_testEPS(lo, hi, a);
	_testEPS(a, lo, hi);
	_testEPS(hi, a, lo);
	AIFFree(a); AIFFree(lo); AIFFree(hi);

	//AIF_CHARACTER
	printf("\n>>>>>>> CHARACTER\n");
	a = CharToAIF('c'); lo = CharToAIF('b'); hi = CharToAIF('d');
	_testEPS(lo, hi, a);
	_testEPS(a, lo, hi);
	_testEPS(hi, a, lo);
	AIFFree(a); AIFFree(lo); AIFFree(hi);

	//AIF_ENUM
	printf("\n>>>>>>> ENUM\n");
        a = EmptyEnumToAIF("test_enum");
        AIFAddConstToEnum(a, "const1", IntToAIF(10));
        AIFAddConstToEnum(a, "const2", IntToAIF(20));
        AIFAddConstToEnum(a, "const3", IntToAIF(15));
        AIFSetEnum(a, "const3");
        lo = EmptyEnumToAIF(NULL);
        AIFAddConstToEnum(lo, "const1", IntToAIF(10));
        AIFAddConstToEnum(lo, "const2", IntToAIF(20));
        AIFAddConstToEnum(lo, "const3", IntToAIF(15));
        AIFSetEnum(lo, "const1");
        hi = EmptyEnumToAIF(NULL);
        AIFAddConstToEnum(hi, "const1", IntToAIF(10));
        AIFAddConstToEnum(hi, "const2", IntToAIF(20));
        AIFAddConstToEnum(hi, "const3", IntToAIF(15));
        AIFSetEnum(hi, "const2");
	_testEPS(lo, hi, a);
	_testEPS(a, lo, hi);
	_testEPS(hi, a, lo);
	AIFFree(a); AIFFree(lo); AIFFree(hi);

        a = EmptyEnumToAIF("test_enum");
        AIFAddConstToEnum(a, "const1a", IntToAIF(10));
        AIFAddConstToEnum(a, "const2a", IntToAIF(20));
        AIFAddConstToEnum(a, "const3a", IntToAIF(15));
        AIFSetEnum(a, "const3a");
        lo = EmptyEnumToAIF(NULL);
        AIFAddConstToEnum(lo, "const1lo", IntToAIF(10));
        AIFAddConstToEnum(lo, "const2lo", IntToAIF(20));
        AIFAddConstToEnum(lo, "const3lo", IntToAIF(15));
        AIFSetEnum(lo, "const1lo");
        hi = EmptyEnumToAIF(NULL);
        AIFAddConstToEnum(hi, "const1hi", IntToAIF(10));
        AIFAddConstToEnum(hi, "const2hi", IntToAIF(20));
        AIFAddConstToEnum(hi, "const3hi", IntToAIF(15));
        AIFSetEnum(hi, "const2hi");
	_testEPS(lo, hi, a);
	_testEPS(a, lo, hi);
	_testEPS(hi, a, lo);
	AIFFree(a); AIFFree(lo); AIFFree(hi);

	//AIF_STRING
	printf("\n>>>>>>> STRING\n");
        a = StringToAIF("b");
        lo = StringToAIF("a");
        hi = StringToAIF("c");
	_testEPS(lo, hi, a);
	_testEPS(a, lo, hi);
	_testEPS(hi, a, lo);
	AIFFree(a); AIFFree(lo); AIFFree(hi);

	//AIF_FLOATING
	printf("\n>>>>>>> FLOAT\n");
	a = FloatToAIF(5); lo = FloatToAIF(3); hi = FloatToAIF(8);
	_testEPS(lo, hi, a);
	_testEPS(a, lo, hi);
	_testEPS(hi, a, lo);
	AIFFree(a); AIFFree(lo); AIFFree(hi);
	a = DoubleToAIF(5); lo = DoubleToAIF(3); hi = DoubleToAIF(8);
	_testEPS(lo, hi, a);
	_testEPS(a, lo, hi);
	_testEPS(hi, a, lo);
	AIFFree(a); AIFFree(lo); AIFFree(hi);

	//AIF_ARRAY
	printf("\n>>>>>>> ARRAY\n");
	{
		char data[BUFSIZ], *dest;
		int index, submin, submax;
		int smallArray[5] = {3,4,5,6,7};
		dest = data;
		submin = 1;
		submax = 5;
		for (index = 0; index < 5; index++)
		{
			AIFNormalise(dest, sizeof(int), (char *) (smallArray+index), sizeof(int));
			dest += sizeof(int);
		}
		a = ArrayToAIF(1, &submin, &submax, data, 5*sizeof(int), AIF_FORMAT(IntToAIF(0)));

	}
	lo = IntToAIF(10);
	hi = IntToAIF(20);
	_testEPS(lo, hi, a);
	AIFFree(lo); AIFFree(hi);

	lo = IntToAIF(1);
	hi = IntToAIF(20);
	_testEPS(lo, hi, a);
	AIFFree(lo); AIFFree(hi);

	lo = IntToAIF(1);
	hi = IntToAIF(2);
	_testEPS(lo, hi, a);
	AIFFree(lo); AIFFree(hi);
	AIFFree(a);

	//AIF_STRUCT
	printf("\n>>>>>>> STRUCT\n");
	{
		a = EmptyStructToAIF("test_struct");
		AIFAddFieldToStruct(a, "val1", IntToAIF(11));
		AIFAddFieldToStruct(a, "val2", IntToAIF(12));
		AIFAddFieldToStruct(a, "val3", IntToAIF(13));
	}
	lo = IntToAIF(18);
	hi = IntToAIF(20);
	_testEPS(lo, hi, a);
	AIFFree(lo); AIFFree(hi);

	lo = IntToAIF(1);
	hi = IntToAIF(20);
	_testEPS(lo, hi, a);
	AIFFree(lo); AIFFree(hi);

	lo = IntToAIF(1);
	hi = IntToAIF(2);
	_testEPS(lo, hi, a);
	AIFFree(lo); AIFFree(hi);
	AIFFree(a);

	//AIF_POINTER
	printf("\n>>>>>>> POINTER\n");
	a = IntToAIF(5); lo = IntToAIF(3); hi = IntToAIF(8);
	a = PointerToAIF(NULL, a);
	_testEPS(lo, hi, a);
	AIFFree(lo); AIFFree(hi);

	lo = IntToAIF(1);
	hi = IntToAIF(2);
	_testEPS(lo, hi, a);
	AIFFree(lo); AIFFree(hi);

	lo = IntToAIF(6);
	hi = IntToAIF(7);
	_testEPS(lo, hi, a);
	AIFFree(lo); AIFFree(hi);
	AIFFree(a);

}


void
_testCompareByName(int dep, AIF *a, AIF *b, char *method)
{
	AIF * c;
	int res;

	if (strcmp(method, "AIFDiff") == 0)
	{
		c = AIFDiff(dep, a, b);
		if (c == NULL)
			printf("*** ERROR *** : %s\n", AIFErrorStr());
		else
		{
			printf("a = ");
			AIFPrint(stdout, 0, a);
			printf("\nb = ");
			AIFPrint(stdout, 0, b);
			printf("\nAIFDiff(depth = %d, a, b) = c = ", dep);
			AIFPrint(stdout, 0, c);
			printf("\n\n");

			AIFFree(c);
		}
	}
	else if (strcmp(method, "AIFCompare") == 0)
	{
		if (AIFCompare(dep, a, b, &res) < 0)
			printf("*** ERROR *** : %s\n", AIFErrorStr());
		else
		{
			printf("a = ");
			AIFPrint(stdout, 0, a);
			printf("\nb = ");
			AIFPrint(stdout, 0, b);
			printf("\nAIFCompare(depth = %d, a, b) = ", dep);
			printf("%d\n\n", res);
		}
	}
	else
		return;
}

void 
TestAllCompareByName()
{
	AIF * a;
	AIF * b;

	AIFSetOption(AIFOPT_CMP_METHOD, AIF_CMP_BY_NAME);

        fprintf(stdout, "************************************** \n");
        fprintf(stdout, "*** TEST SERIES 6: compare by name *** \n");
        fprintf(stdout, "************************************** \n\n");

	a = AsciiToAIF("{|a=is4,b=s;;;}", "0000000400026363");
        b = AsciiToAIF("{|b=s,a=is4;;;}", "0002646400000002");
	_testCompareByName(0, a, b, "AIFDiff");
	AIFFree(a); AIFFree(b);

        a = AsciiToAIF("^%0/{|c=is4,b=^>0/,a=is4;;;}", "02000000000000000a01000000140300000000000000150000000b");
        b = AsciiToAIF("^%2/{|a=is4,b=^>2/,c=is4;;;}", "02000000000000000b01000000160300000000000000180000000f");
	_testCompareByName(0, a, b, "AIFDiff");
	_testCompareByName(1, a, b, "AIFDiff");
	_testCompareByName(2, a, b, "AIFDiff");
	_testCompareByName(3, a, b, "AIFDiff");
	AIFFree(a); AIFFree(b);

        a = AsciiToAIF("^%0/{|a=is4,b=^>0/,c=^%1/{|a=is4,b=^>0/,c=^>1/,d=is4;;;},d=is4;;;}", "02000000000000000a010000001400010000001e0300000000000000001e00000014000000000a");
        b = AsciiToAIF("^%2/{|d=is4,b=^>2/,c=^%3/{|d=is4,b=^>2/,c=^>3/,a=is4;;;},a=is4;;;}", "02000000000000000b01000000170001000000230300000000000000002400000018000000000c");
	_testCompareByName(0, a, b, "AIFDiff");
	_testCompareByName(1, a, b, "AIFDiff");
	_testCompareByName(2, a, b, "AIFDiff");
	_testCompareByName(3, a, b, "AIFDiff");
	AIFFree(a); AIFFree(b);

	/* This one works even though b will be rearranged to
        ** "{|a=is4,c=>0/,b=%0/is4;;;}" since
	** _fds_resolve() in _fds_skip_data() is called before the
	** rearrangement
	*/

        a = AsciiToAIF("{|a=is4,c=is4,b=is4;;;}", "0000000b0000001500000016");
        b = AsciiToAIF("{|a=is4,b=%0/is4,c=>0/;;;}", "0000000a0000001400000015");
	_testCompareByName(0, a, b, "AIFDiff");
	AIFFree(a); AIFFree(b);

	a = AsciiToAIF("{|a=is4,b=s;;;}", "0000000400026363");
	b = AsciiToAIF("{|b=s,a=is4;;;}", "0002636300000004");
	_testCompareByName(0, a, b, "AIFCompare");
	AIFFree(a); AIFFree(b);

        a = AsciiToAIF("{|a=is4,c=is4,b=is4;;;}", "0000000b0000001500000016");
        b = AsciiToAIF("{|a=is4,b=%0/is4,c=>0/;;;}", "0000000b0000001600000015");
	_testCompareByName(0, a, b, "AIFCompare");
	AIFFree(a); AIFFree(b);

        a = AsciiToAIF("^%0/{|a=is4,b=^>0/,c=^%1/{|a=is4,b=^>0/,c=^>1/,d=is4;;;},d=is4;;;}", "02000000000000000b010000001400010000001e0300000000000000001e00000014000000000a");
        b = AsciiToAIF("^%2/{|d=is4,b=^>2/,c=^%3/{|d=is4,b=^>2/,c=^>3/,a=is4;;;},a=is4;;;}", "02000000000000000a01000000170001000000230300000000000000002400000018000000000b");
	_testCompareByName(0, a, b, "AIFCompare");
	_testCompareByName(1, a, b, "AIFCompare");
	AIFFree(a); AIFFree(b);

	AIFSetOption(AIFOPT_CMP_METHOD, AIF_CMP_BY_POSITION);
}


/*
 * There are some test codes that share the same code in this file,
 * thus probably we can replace the similarities with C macros. However,
 * macros can make the code hard to read whereas we want a simple
 * test functions (to avoid the testing of the test functions)
 */


int
AIFTest(char *title, AIF *a, char *msg, TestFlags f)
{
	int ret;

       	if ( title != NULL )
		fprintf(stdout, "%s > ", title);

       	if ( msg != NULL )
        	fprintf(stdout, "%s:", msg);

        fprintf(stdout, "\n\tAIFPrint: ");
        if (AIFPrint(stdout, f.D_AIFPrint, a) != 0)
		fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
        fprintf(stdout, " (%s)", AIF_FORMAT(a));

	ret = _aif_test(a, f);

        fprintf(stdout, "\n");

	return ret;
}

int
_aif_test(AIF *a, TestFlags f)
{
        //char * tmp;
        //_fds_resolve(fds);

	_aif_test_general(a, f);

        switch ( AIFType(a) )
        {
        case AIF_BOOLEAN:
                return _aif_test_bool(a, f);

        case AIF_CHARACTER:
                return _aif_test_char(a, f);

        case AIF_INTEGER:
                return _aif_test_int(a, f);

        case AIF_FLOATING:
                return _aif_test_float(a, f);

        case AIF_ARRAY:
                return _aif_test_array(a, f);

        case AIF_POINTER:
                return _aif_test_pointer(a, f);

        case AIF_REGION:
                return _aif_test_region(a, f);

        case AIF_STRUCT:
                return _aif_test_struct(a, f);

        case AIF_NAME:
                return _aif_test_name(a, f);

        case AIF_REFERENCE:
                //tmp = (char *) _fds_lookup(fds);
                //return _aif_test(fp, depth, &tmp, data);

        case AIF_STRING:
                return _aif_test_string(a, f);

        case AIF_ENUM:
                return _aif_test_enum(a, f);

        case AIF_UNION:
                return _aif_test_union(a, f);

        case AIF_FUNCTION:
        case AIF_VOID:
        default:
		fprintf(stdout, "Unsupported Type\n");
                break;
        }

	return -1;
}

int
_aif_test_general(AIF *a, TestFlags f)
{
	int zeroVal, compareVal;
	AIF * result;

	// Test AIFIsZero
	if (f.AIFIsZero == 1){

	if (AIFIsZero(a, &zeroVal)) 
		fprintf(stdout, "\n\tAIFIsZero ERROR: trouble checking against zero: %s", AIFErrorStr());
	else
		fprintf(stdout, "\n\tAIFIsZero: %sequal to zero", zeroVal ? "" : "not ");

	}

	// Test AIFCompare
	if (f.AIFCompare == 1){

	if (AIFCompare(0, a, a, &compareVal))  
		fprintf(stdout, "\n\tAIFCompare (a,a) ERROR: trouble comparing against self: %s", AIFErrorStr());
	else if (compareVal) 
		fprintf(stdout, "\n\tAIFCompare (a,a) ERROR: not equal to itself");
	else
		fprintf(stdout, "\n\tAIFCompare (a,a): OK");

	}

	// Test AIFTypeCompare
	if (f.AIFTypeCompare == 1){

	if (!AIFTypeCompare(a, a)) 
		fprintf(stdout, "\n\tAIFTypeCompare (a,a) ERROR: not the same type as itself");
	else
		fprintf(stdout, "\n\tAIFTypeCompare (a,a): OK");

	}

	// Test AIFDiff
	if (f.AIFDiff != NULL){

	if ( f.AIFDiff == (AIF*)SELF ) 
		result = AIFDiff(0, a, a); 
	else  
		result = AIFDiff(0, a, f.AIFDiff);
	if ( result != NULL ) 
	{
		fprintf(stdout, "\n\tAIFDiff (a,a or f.AIFDiff): ");
        	if (AIFPrint(stdout, 0, result) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(result));
	}
	else
		fprintf(stdout, "\n\tAIFDiff (a,a or f.AIFDiff) ERROR: %s", AIFErrorStr());

	}

	return 0;
}

int
_aif_test_bool(AIF *a, TestFlags f)
{
	AIF * result;

	// Test AIFAnd
	if (f.AIFAnd != NULL){

	if ( f.AIFAnd == (AIF*)SELF ) 
		result = AIFAnd(a,a); 
	else
		result = AIFAnd(a, f.AIFAnd);
        if ( result != (AIF *)NULL )
	{
                fprintf(stdout, "\n\tAIFAnd (a, a or f.AIFAnd): ");
        	if (AIFPrint(stdout, 0, result) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(result));
                AIFFree(result);
        }
	else 
		fprintf(stdout, "\n\tAIFAnd (a, a or f.AIFAnd) ERROR: %s", AIFErrorStr());

        }

	// Test AIFOr
	if (f.AIFOr != NULL){

	if ( f.AIFOr == (AIF*)SELF )
		result = AIFOr(a,a);
        else
		result = AIFOr(a, f.AIFOr);
        if ( result != (AIF *)NULL )
	{
                fprintf(stdout, "\n\tAIFOr (a, a or f.AIFOr): ");
        	if (AIFPrint(stdout, 0, result) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(result));
                AIFFree(result);
        }
	else 
		fprintf(stdout, "\n\tAIFOr (a, a or f.AIFOr) ERROR: %s", AIFErrorStr());

        }

	// Test AIFNeg
	if (f.AIFNeg == 1){

	result = AIFNeg(a);
        if ( result != (AIF *)NULL )
	{
                fprintf(stdout, "\n\tAIFNeg: ");
        	if (AIFPrint(stdout, 0, result) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(result));
                AIFFree(result);
        }
	else 
		fprintf(stdout, "\n\tAIFNeg ERROR: %s", AIFErrorStr());

        }

	// Test AIFNot
	if (f.AIFNot == 1){

	result = AIFNot(a);
        if ( result != (AIF *)NULL )
	{
                fprintf(stdout, "\n\tAIFNot: ");
        	if (AIFPrint(stdout, 0, result) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(result));
                AIFFree(result);
        }
	else 
		fprintf(stdout, "\n\tAIFNot ERROR: %s", AIFErrorStr());

        }

	return 0;
}

int
_aif_test_char(AIF *a, TestFlags f)
{
	_aif_test_bool(a, f);

	return 0;
}

int
_aif_test_int(AIF *a, TestFlags f)
{
	AIF * result;

	_aif_test_bool(a, f);

	// Test AIFAdd
	if (f.AIFAdd != NULL){

	if ( f.AIFAdd == (AIF*)SELF ) 
		result = AIFAdd(a,a);
        else
		result = AIFAdd(a, f.AIFAdd);
        if ( result != (AIF *)NULL )
	{
                fprintf(stdout, "\n\tAIFAdd (a, a or f.AIFAdd): ");
        	if (AIFPrint(stdout, 0, result) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(result));
                AIFFree(result);
        }
	else 
		fprintf(stdout, "\n\tAIFAdd (a, a or f.AIFAdd) ERROR: %s", AIFErrorStr());

        }

	// Test AIFSub
	if (f.AIFSub != NULL){

	if (f.AIFSub == (AIF*)SELF) 
		result = AIFSub(a,a); 
	else
		result = AIFSub(a, f.AIFSub);
        if ( result != (AIF *)NULL )
	{
                fprintf(stdout, "\n\tAIFSub (a, a or f.AIFSub): ");
        	if (AIFPrint(stdout, 0, result) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(result));
                AIFFree(result);
        }
	else 
		fprintf(stdout, "\n\tAIFSub (a, a or f.AIFSub) ERROR: %s", AIFErrorStr());

        }

	// Test AIFMul
	if (f.AIFMul != NULL){

	if ( f.AIFMul == (AIF*)SELF) 
		result = AIFMul(a,a); 
	else
		result = AIFMul(a, f.AIFMul);
        if ( result != (AIF *)NULL )
	{
                fprintf(stdout, "\n\tAIFMul (a, a or f.AIFMul): ");
        	if (AIFPrint(stdout, 0, result) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(result));
                AIFFree(result);
        }
	else 
		fprintf(stdout, "\n\tAIFMul (a, a or f.AIFMul) ERROR: %s", AIFErrorStr());

        }

	// Test AIFDiv
	if (f.AIFDiv != NULL){

	if (f.AIFDiv == (AIF*)SELF) 
		result = AIFDiv(a,a);
	else 
		result = AIFDiv(a, f.AIFDiv);
        if ( result != (AIF *)NULL )
	{
                fprintf(stdout, "\n\tAIFDiv (a, a or f.AIFDiv): ");
        	if (AIFPrint(stdout, 0, result) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(result));
                AIFFree(result);
        }
	else 
		fprintf(stdout, "\n\tAIFDiv (a, a or f.AIFDiv) ERROR: %s", AIFErrorStr());

        }

	// Test AIFRem
	if (f.AIFRem != NULL){

	if (f.AIFRem == (AIF*)SELF) 
		result = AIFRem(a,a);
	else 
		result = AIFRem(a, f.AIFRem);
        if ( result != (AIF *)NULL )
	{
                fprintf(stdout, "\n\tAIFRem (a, a or f.AIFRem): ");
        	if (AIFPrint(stdout, 0, result) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(result));
                AIFFree(result);
        }
	else 
		fprintf(stdout, "\n\tAIFRem (a, a or f.AIFRem) ERROR: %s", AIFErrorStr());

        }

	return 0;
}

int
_aif_test_float(AIF *a, TestFlags f)
{
	_aif_test_int(a, f);

	return 0;
}

int
_aif_test_array(AIF *a, TestFlags f)
{
	int 		tmp1;
	char * 		tmp2;
	int		tmp3;
	AIFIndex * 	tmp4;

	AIFIndex * ix;
	AIF * ax;

	ix = AIFArrayIndexInit(a);
        if (ix == NULL)
	{
		fprintf(stdout, "\n\tAIFArrayIndexInit FATAL ERROR: %s", AIFErrorStr());
		exit(100);
	}


	// Test AIFArrayRank
	if (f.AIFArrayRank == 1){

	if ( (tmp1 = AIFArrayRank(a)) < 0) 
		fprintf(stdout, "\n\tAIFArrayRank ERROR: %s", AIFErrorStr());
	else
		fprintf(stdout, "\n\tAIFArrayRank: %d", tmp1);

	}

	// Test AIFArrayInfo
	if (f.AIFArrayInfo == 1){

	if ( AIFArrayInfo(a, &tmp1, &tmp2, &tmp3) ) 
		fprintf(stdout, "\n\tAIFArrayInfo ERROR: %s", AIFErrorStr());
	else
	{
		fprintf(stdout, "\n\tAIFArrayInfo: rank (%d), type (%s), type_id (%d)", tmp1, tmp2, tmp3);
		_aif_free(tmp2);
	}

	}

	// Test AIFArrayBounds
	if (f.AIFArrayBounds == 1){

	int *min, *max, *size;

	if ( AIFArrayBounds(a, ix->i_rank, &min, &max, &size) < 0 )
		fprintf(stdout, "\n\tAIFArrayBounds ERROR: %s", AIFErrorStr());
	else
	{
		fprintf(stdout, "\n\tAIFArrayBounds: ");

		for ( tmp3 = 0; tmp3 < ix->i_rank; tmp3++)
			fprintf(stdout, "[rank:%d min:%d max:%d size:%d] ", 
					tmp3, min[tmp3], max[tmp3], size[tmp3]);

		_aif_free(min);
		_aif_free(max);
		_aif_free(size);
	}

	}

	// Test AIFArrayIndexType
	if (f.AIFArrayIndexType == 1){

	if ( (tmp2 = AIFArrayIndexType(a)) == NULL )
		fprintf(stdout, "\n\tAIFArrayIndexType ERROR: %s", AIFErrorStr());
	else
	{
		fprintf(stdout, "\n\tAIFArrayIndexType: %s", tmp2);
		_aif_free(tmp2);
	}

	}

	// Test AIFArrayMinIndex
	if (f.AIFArrayMinIndex == 1){

	for ( tmp1 = 0 ; tmp1 < ix->i_rank ; tmp1++ )
	{
		if ( (tmp3 = AIFArrayMinIndex(a, tmp1)) < 0 )
			fprintf(stdout, "\n\tAIFArrayMinIndex ERROR: %s", 
					AIFErrorStr());
		else
			fprintf(stdout, "\n\tAIFArrayMinIndex: [rank %d: %d]", tmp1, tmp3);
	}

	}

	// Test AIFArrayMaxIndex
	if (f.AIFArrayMaxIndex == 1){

	for ( tmp1 = 0 ; tmp1 < ix->i_rank ; tmp1++ )
	{
		if ( (tmp3 = AIFArrayMaxIndex(a, tmp1)) < 0 )
			fprintf(stdout, "\n\tAIFArrayMaxIndex ERROR: %s", 
					AIFErrorStr());
		else
			fprintf(stdout, "\n\tAIFArrayMaxIndex: [rank %d: %d]", tmp1, tmp3);
	}

	}


	// Test AIFArraySize
	if (f.AIFArraySize == 1){

	if ( (tmp1 = AIFArraySize(a)) < 0) 
		fprintf(stdout, "\n\tAIFArraySize ERROR: %s", AIFErrorStr());
	else
		fprintf(stdout, "\n\tAIFArraySize: %d", tmp1);

	}

	// Test AIFArraySlice
	if (f.AIFArraySlice == 1){
	
	int * mn; 
	int * mx;

	mn = (int *)_aif_alloc(sizeof(int) * ix->i_rank);
	mx = (int *)_aif_alloc(sizeof(int) * ix->i_rank);

	// AIFArraySlice (first element)
	for (tmp3 = 0; tmp3 < ix->i_rank; tmp3++)
	{
		mn[tmp3] = ix->i_min[tmp3];
		mx[tmp3] = ix->i_min[tmp3];
	}
	ax = AIFArraySlice(a, ix->i_rank, mn, mx);
        if ( ax != (AIF *)NULL )
	{
                fprintf(stdout, "\n\tAIFArraySlice (first): ");
        	if (AIFPrint(stdout, 0, ax) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(ax));
                AIFFree(ax);
        }
	else 
		fprintf(stdout, "\n\tAIFArraySlice (first) ERROR: %s", AIFErrorStr());

	// AIFArraySlice (last element)
	for (tmp3 = 0; tmp3 < ix->i_rank; tmp3++)
	{
		mn[tmp3] = ix->i_max[tmp3];
		mx[tmp3] = ix->i_max[tmp3];
	}
	ax = AIFArraySlice(a, ix->i_rank, mn, mx);
        if ( ax != (AIF *)NULL )
	{
                fprintf(stdout, "\n\tAIFArraySlice (last): ");
        	if (AIFPrint(stdout, 0, ax) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(ax));
                AIFFree(ax);
        }
	else 
		fprintf(stdout, "\n\tAIFArraySlice (last) ERROR: %s", AIFErrorStr());

	// AIFArraySlice (2nd to 2nd last or all)
	for (tmp3 = 0; tmp3 < ix->i_rank; tmp3++)
	{
		if (ix->i_min[tmp3] < ix->i_max[tmp3] - 1)
		{
			mn[tmp3] = ix->i_min[tmp3] + 1;
			mx[tmp3] = ix->i_max[tmp3] - 1;
		}
		else
		{
			mn[tmp3] = ix->i_min[tmp3];
			mx[tmp3] = ix->i_max[tmp3];
		}
	}
	ax = AIFArraySlice(a, ix->i_rank, mn, mx);
        if ( ax != (AIF *)NULL )
	{
                fprintf(stdout, "\n\tAIFArraySlice (2nd to 2nd last or all): ");
        	if (AIFPrint(stdout, 0, ax) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(ax));
                AIFFree(ax);
        }
	else 
		fprintf(stdout, "\n\tAIFArraySlice (2nd to 2nd last or all) ERROR: %s", AIFErrorStr());


	_aif_free(mn);
	_aif_free(mx);

	}


	// Test AIFArrayPerm (the rank must be > 1)
	if (f.AIFArrayPerm == 1 && ix->i_rank > 1){

	int *perm;

	perm = (int *) _aif_alloc(sizeof(int) * ix->i_rank);

	for ( tmp3 = ix->i_rank-1; tmp3 >= 0; tmp3-- )
		perm[tmp3] = ix->i_rank - tmp3 - 1;

	if ( (ax = AIFArrayPerm(a, perm)) == NULL )
		fprintf(stdout, "\n\tAIFArrayPerm ERROR: %s", AIFErrorStr());
	else
	{
		fprintf(stdout, "\n\tAIFArrayPerm: "); 
        	if (AIFPrint(stdout, 0, ax) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(ax));
                AIFFree(ax);
	}

	_aif_free(perm);

	}

	// Test AIFArrayElementToInt
	tmp4 = AIFArrayIndexInit(a);
        if (tmp4 == NULL)
		fprintf(stdout, "\n\tAIFArrayIndexInit ERROR: %s", AIFErrorStr());

	if (f.AIFArrayElementToInt == 1 && AIFBaseType(a) == AIF_INTEGER ){

	while (tmp4->i_finished != 1)
	{
		int x;
		if (AIFArrayElementToInt(a, tmp4, &x) < 0)
			fprintf(stdout, "\n\tAIFArrayElementToInt ERROR: %s", AIFErrorStr());
		else
			printf("\n\tAIFArrayElementToInt: %d (int)", x);

		AIFArrayIndexInc(tmp4);
	}

        AIFArrayIndexFree(tmp4);

	}

	// Test AIFArrayElementToLongest
	tmp4 = AIFArrayIndexInit(a);
        if (tmp4 == NULL)
		fprintf(stdout, "\n\tAIFArrayIndexInit ERROR: %s", AIFErrorStr());

	if (f.AIFArrayElementToLongest == 1 && AIFBaseType(a) == AIF_INTEGER ){

	while (tmp4->i_finished != 1)
	{
		AIFLONGEST x;
		if (AIFArrayElementToLongest(a, tmp4, &x) < 0)
			fprintf(stdout, "\n\tAIFArrayElementToLongest ERROR: %s", AIFErrorStr());
		else
			printf("\n\tAIFArrayElementToLongest: %lld (AIFLONGEST)", x);

		AIFArrayIndexInc(tmp4);
	}

        AIFArrayIndexFree(tmp4);

	}

	// Test AIFArrayElementToDouble
	tmp4 = AIFArrayIndexInit(a);
        if (tmp4 == NULL)
		fprintf(stdout, "\n\tAIFArrayIndexInit ERROR: %s", AIFErrorStr());

	if (f.AIFArrayElementToDouble == 1 && AIFBaseType(a) == AIF_FLOATING ){

	while (tmp4->i_finished != 1)
	{
		double x;
		if (AIFArrayElementToDouble(a, tmp4, &x) < 0)
			fprintf(stdout, "\n\tAIFArrayElementToDouble ERROR: %s", AIFErrorStr());
		else
			printf("\n\tAIFArrayElementToDouble: %f (double)", x);

		AIFArrayIndexInc(tmp4);
	}

        AIFArrayIndexFree(tmp4);

	}

	// Test AIFArrayElementToDoublest
	tmp4 = AIFArrayIndexInit(a);
        if (tmp4 == NULL)
		fprintf(stdout, "\n\tAIFArrayIndexInit ERROR: %s", AIFErrorStr());

	if (f.AIFArrayElementToDoublest == 1 && AIFBaseType(a) == AIF_FLOATING ){

	while (tmp4->i_finished != 1)
	{
		AIFDOUBLEST x;
		if (AIFArrayElementToDoublest(a, tmp4, &x) < 0)
			fprintf(stdout, "\n\tAIFArrayElementToDoublest ERROR: %s", AIFErrorStr());
		else
		{
#ifdef HAVE_LONG_DOUBLE
			printf("\n\tAIFArrayElementToDoublest: %Lf (AIFDOUBLEST)", x);
#else
			printf("\n\tAIFArrayElementToDoublest: %f (AIFDOUBLEST)", x);
#endif
		}

		AIFArrayIndexInc(tmp4);
	}

        AIFArrayIndexFree(tmp4);

	}


	// Test AIFArrayRef
	if (f.AIFArrayRef == 1){

	int * loc;

	loc = (int *)_aif_alloc(sizeof(int) * ix->i_rank);

	for (tmp1 = 0; tmp1 < ix->i_rank; tmp1++)
		loc[tmp1] = ix->i_min[tmp1];

	ax = AIFArrayRef(a, ix->i_rank, loc);
        if ( ax != (AIF *)NULL )
	{
                fprintf(stdout, "\n\tAIFArrayRef (first): ");
        	if (AIFPrint(stdout, 0, ax) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(ax));
                AIFFree(ax);
        }
	else 
		fprintf(stdout, "\n\tAIFArrayRef (first) ERROR: %s", AIFErrorStr());

	for (tmp1 = 0; tmp1 < ix->i_rank; tmp1++)
		loc[tmp1] = ix->i_max[tmp1];

	ax = AIFArrayRef(a, ix->i_rank, loc);
        if ( ax != (AIF *)NULL )
	{
                fprintf(stdout, "\n\tAIFArrayRef (last): ");
        	if (AIFPrint(stdout, 0, ax) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
                fprintf(stdout, " (%s)", AIF_FORMAT(ax));
                AIFFree(ax);
        }
	else 
		fprintf(stdout, "\n\tAIFArrayRef (last) ERROR: %s", AIFErrorStr());

	_aif_free(loc);
	}


	// Test AIFSetArrayData
	if (f.AIFSetArrayData != NULL) {

	AIF * result;

	tmp4 = AIFArrayIndexInit(a);
       	if (tmp4 == NULL)
		fprintf(stdout, "\n\tAIFArrayIndexInit ERROR: %s", AIFErrorStr());

	if ( (result = CopyAIF(a)) == NULL) 
		fprintf(stdout, "\n\tCopyAIF ERROR: %s", AIFErrorStr());

	if ( f.AIFSetArrayData == (AIF *) SELF )
		tmp1 = AIFSetArrayData(result, tmp4, result );
	else
		tmp1 = AIFSetArrayData(result, tmp4, f.AIFSetArrayData );

	if ( tmp1 < 0) 
		fprintf(stdout, "\n\tAIFSetArrayData ERROR: %s", AIFErrorStr());
	else
	{
		fprintf(stdout, "\n\tAIFSetArrayData: Set [0] to ");
		if (AIFPrint(stdout, 0, f.AIFSetArrayData) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
               	fprintf(stdout, " (%s): ", AIF_FORMAT((AIF *)f.AIFSetArrayData));

		if (AIFPrint(stdout, 0, result) != 0)
			fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
               	fprintf(stdout, " (%s)", AIF_FORMAT(result));
	}

       	AIFArrayIndexFree(tmp4);
	}


	// Test each of the array elements
	printf("\n");
	tmp1 = 0;
	tmp2 = (char *) _aif_alloc(sizeof(char) * 100);
	tmp4 = AIFArrayIndexInit(a);
        if (tmp4 == NULL)
		fprintf(stdout, "\n\tAIFArrayIndexInit ERROR: %s", AIFErrorStr());
	while ( (ax = AIFArrayElement(a, tmp4)) != NULL )
        {
		sprintf(tmp2, "\t --> Element %d", tmp1);
		AIFTest(NULL, ax, tmp2, f);
	        AIFFree(ax);
		tmp1++;
		AIFArrayIndexInc(tmp4);
	}  

	if ( ax == NULL && AIFError() != AIFERR_NOERR )
		fprintf(stdout, "\n\tAIFArrayElement ERROR: %s", AIFErrorStr());

	_aif_free(tmp2);
        AIFArrayIndexFree(tmp4);


        AIFArrayIndexFree(ix);
	return 0;
}

int
_aif_test_pointer(AIF *a, TestFlags f)
{
	return 0;
}

int
_aif_test_region(AIF *a, TestFlags f)
{
	return 0;
}

int
_aif_test_struct(AIF *a, TestFlags f)
{
	return 0;
}

int
_aif_test_name(AIF *a, TestFlags f)
{
	return 0;
}

int
_aif_test_reference(AIF *a, TestFlags f)
{
	return 0;
}

int
_aif_test_string(AIF *a, TestFlags f)
{
	return 0;
}

int
_aif_test_enum(AIF *a, TestFlags f)
{
	return 0;
}

int
_aif_test_union(AIF *a, TestFlags f)
{
	return 0;
}


int
AIFTestInt(char *title, AIF *a, char *msg, TestFlags f)
{
	int ret;

       	if ( title != NULL )
		fprintf(stdout, "%s > ", title);

       	if ( msg != NULL )
        	fprintf(stdout, "%s:", msg);

        fprintf(stdout, "\n\tAIFPrint: ");
        if (AIFPrint(stdout, 0, a) != 0)
		fprintf(stdout, "\n\tAIFPrint ERROR: %s", AIFErrorStr());
        fprintf(stdout, " (%s)", AIF_FORMAT(a));

	ret = _aif_test_int(a, f);

        fprintf(stdout, "\n");

	return ret;
}