maxdeliso/libc test

## libc test
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <setjmp.h>

#define BYTE (1)
#define KILOBYTE (1024*(BYTE))
#define MEGABYTE (1024*(KILOBYTE))
#define GIGABYTE (1024*(MEGABYTE))

const static char staticVar;
char globalVar;

struct memSeg {
    char label[8];
    unsigned long address;
};

void listArgs( int argc, char** argv, char** env );
void listSizes( );
void printMemLayout();
int compareMemSegs( const struct memSeg* A, const struct memSeg* B );
unsigned long long tempFileTest(unsigned long long n);
unsigned int mallocTest(unsigned int n);
void setJmpTest();

int main( int argc, char ** argv, char** envv ) {
    printf("#####LIBC PROBE LOG#####\n");

    listArgs( argc, argv, envv );
    listSizes();
    printMemLayout();

    if( tempFileTest(BYTE) ) {
       if( tempFileTest(64 * KILOBYTE) ) {
          if( tempFileTest(32 * MEGABYTE ) ) {
            printf("-----ALL TMPFILE TESTS PASSED\n");
          }
       }
    }

   if( mallocTest(BYTE) ) {
     if( mallocTest(64 * KILOBYTE) ) {
       if( mallocTest(32 * MEGABYTE ) ) {
         if( mallocTest( 128 * MEGABYTE ) ) {
                printf("-----ALL MALLOC TESTS PASSED\n");
            }
          }
       }
    }

    setJmpTest();

    return 0;
}

void listArgs( int argc, char** argv, char** envv )
{
    int i;

    printf("\n+++PROGRAM ARGUMENTS:\n");
    for( i = 0; i < argc; i++ ) {
        printf( "-----%4i: %s\n", i, argv[i] );
    }

    printf("\n+++PROGRAM ENVIRONMENTS:\n");
    i = -1;
    do {
      i++;

      if( envv[i] ) {
        printf("-----%4i: %s\n", i, envv[i] );
      }
    } while( envv[i] );
}

void listSizes( )
{
   printf("\n+++VARIABLE SIZES( bytes)\n");
   printf("-----%15s = %5i\n", "char", sizeof(char));
   printf("-----%15s = %5i\n", "int", sizeof(int));
   printf("-----%15s = %5i\n", "long", sizeof(long));
   printf("-----%15s = %5i\n", "long long", sizeof(long long));
   printf("-----%15s = %5i\n", "float", sizeof(float));
   printf("-----%15s = %5i\n", "double", sizeof(double));
}

void printMemLayout()
{
    char stackVar;
    char *heapVar = malloc(1);
    struct memSeg memorySegments[5];
    int i;

    strcpy(memorySegments[0].label, "code");
    memorySegments[0].address = (unsigned long) main;

    strcpy(memorySegments[1].label, "stack");
    memorySegments[1].address = (unsigned long) &stackVar;

    strcpy(memorySegments[2].label, "heap");
    memorySegments[2].address = (unsigned long) heapVar;

    strcpy(memorySegments[3].label, "static");
    memorySegments[3].address = (unsigned long) &staticVar;

    strcpy(memorySegments[4].label, "global");
    memorySegments[4].address = (unsigned long) &globalVar;

    qsort( memorySegments, 5, sizeof( struct memSeg ), compareMemSegs );

    printf("\n+++MEMORY LAYOUT\n");
    for( i = 0; i < 5; i++ ) {
        printf("-----%8s : 0x%08x \n",
            memorySegments[i].label, memorySegments[i].address );
    }

    free( heapVar );
}

int compareMemSegs( const struct memSeg* A, const struct memSeg* B )
{
   return A->address - B->address;
}

unsigned long long tempFileTest(unsigned long long n)
{
    FILE* tmpFile = tmpfile();
    int c, err;
    unsigned long long i;
    char errBuf[64];

    for(i=0, c='A', err=0; err == 0 && i < n; i++, c++ ) {
        if( fputc( c, tmpFile ) == EOF ) {
            err = errno;
            sprintf(errBuf, "-----TMPFILE(%i): FAILED\n", n );
            perror(errBuf);
        }
    }

    fclose( tmpFile );

    if( !err ) {
       printf("\n+++TMPFILE(%i): PASSED\n", n);
       return i;
    } else {
       return 0;
    }
}

unsigned int mallocTest(unsigned int n)
{
   void* memBlock = malloc( n );

   if( memBlock ) {
      free( memBlock );
      printf("\n+++MALLOCTEST(%i): PASSED\n", n);
      return n;
   } else {
      printf("\n+++MALLOCTEST(%i): PASSED\n", n);
      return 0;
   }
}

void setJmpTest()
{
   jmp_buf env;
   int val;

   printf("\n+++SETJMPTEST\n");

   if( !( val = setjmp( env ) ) )
   {
      printf("-----val = %i\n", val );
      longjmp( env, 1 );
   } else {
      printf("-----val = %i\n", val );
   }
}
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <errno.h>
	#include <setjmp.h>

	#define BYTE (1)
	#define KILOBYTE (1024*(BYTE))
	#define MEGABYTE (1024*(KILOBYTE))
	#define GIGABYTE (1024*(MEGABYTE))

	const static char staticVar;
	char globalVar;

	struct memSeg {
	char label[8];
	unsigned long address;
	};

	void listArgs( int argc, char argv, char env );
	void listSizes( );
	void printMemLayout();
	int compareMemSegs( const struct memSeg* A, const struct memSeg* B );
	unsigned long long tempFileTest(unsigned long long n);
	unsigned int mallocTest(unsigned int n);
	void setJmpTest();

	int main( int argc, char argv, char envv ) {
	printf("#####LIBC PROBE LOG#####\n");

	listArgs( argc, argv, envv );
	listSizes();
	printMemLayout();

	if( tempFileTest(BYTE) ) {
	if( tempFileTest(64 * KILOBYTE) ) {
	if( tempFileTest(32 * MEGABYTE ) ) {
	printf("-----ALL TMPFILE TESTS PASSED\n");
	}
	}
	}

	if( mallocTest(BYTE) ) {
	if( mallocTest(64 * KILOBYTE) ) {
	if( mallocTest(32 * MEGABYTE ) ) {
	if( mallocTest( 128 * MEGABYTE ) ) {
	printf("-----ALL MALLOC TESTS PASSED\n");
	}
	}
	}
	}

	setJmpTest();

	return 0;
	}

	void listArgs( int argc, char argv, char envv )
	{
	int i;

	printf("\n+++PROGRAM ARGUMENTS:\n");
	for( i = 0; i < argc; i++ ) {
	printf( "-----%4i: %s\n", i, argv[i] );
	}

	printf("\n+++PROGRAM ENVIRONMENTS:\n");
	i = -1;
	do {
	i++;

	if( envv[i] ) {
	printf("-----%4i: %s\n", i, envv[i] );
	}
	} while( envv[i] );
	}

	void listSizes( )
	{
	printf("\n+++VARIABLE SIZES( bytes)\n");
	printf("-----%15s = %5i\n", "char", sizeof(char));
	printf("-----%15s = %5i\n", "int", sizeof(int));
	printf("-----%15s = %5i\n", "long", sizeof(long));
	printf("-----%15s = %5i\n", "long long", sizeof(long long));
	printf("-----%15s = %5i\n", "float", sizeof(float));
	printf("-----%15s = %5i\n", "double", sizeof(double));
	}

	void printMemLayout()
	{
	char stackVar;
	char *heapVar = malloc(1);
	struct memSeg memorySegments[5];
	int i;

	strcpy(memorySegments[0].label, "code");
	memorySegments[0].address = (unsigned long) main;

	strcpy(memorySegments[1].label, "stack");
	memorySegments[1].address = (unsigned long) &stackVar;

	strcpy(memorySegments[2].label, "heap");
	memorySegments[2].address = (unsigned long) heapVar;

	strcpy(memorySegments[3].label, "static");
	memorySegments[3].address = (unsigned long) &staticVar;

	strcpy(memorySegments[4].label, "global");
	memorySegments[4].address = (unsigned long) &globalVar;

	qsort( memorySegments, 5, sizeof( struct memSeg ), compareMemSegs );

	printf("\n+++MEMORY LAYOUT\n");
	for( i = 0; i < 5; i++ ) {
	printf("-----%8s : 0x%08x \n",
	memorySegments[i].label, memorySegments[i].address );
	}

	free( heapVar );
	}

	int compareMemSegs( const struct memSeg* A, const struct memSeg* B )
	{
	return A->address - B->address;
	}

	unsigned long long tempFileTest(unsigned long long n)
	{
	FILE* tmpFile = tmpfile();
	int c, err;
	unsigned long long i;
	char errBuf[64];

	for(i=0, c='A', err=0; err == 0 && i < n; i++, c++ ) {
	if( fputc( c, tmpFile ) == EOF ) {
	err = errno;
	sprintf(errBuf, "-----TMPFILE(%i): FAILED\n", n );
	perror(errBuf);
	}
	}

	fclose( tmpFile );

	if( !err ) {
	printf("\n+++TMPFILE(%i): PASSED\n", n);
	return i;
	} else {
	return 0;
	}
	}

	unsigned int mallocTest(unsigned int n)
	{
	void* memBlock = malloc( n );

	if( memBlock ) {
	free( memBlock );
	printf("\n+++MALLOCTEST(%i): PASSED\n", n);
	return n;
	} else {
	printf("\n+++MALLOCTEST(%i): PASSED\n", n);
	return 0;
	}
	}

	void setJmpTest()
	{
	jmp_buf env;
	int val;

	printf("\n+++SETJMPTEST\n");

	if( !( val = setjmp( env ) ) )
	{
	printf("-----val = %i\n", val );
	longjmp( env, 1 );
	} else {
	printf("-----val = %i\n", val );
	}
	}