/*
 *  Module: rgtest.c
 *
 *  $Revision: 1.1.1.2 $
 *  $Date: 2002/10/29 08:05:59 $
 *  $Source: /root/leakn64/depot/rf/sw/n64os20l/apps/rgtest/rgtest.c,v $
 *
 *  Description:
 *	This program generates test cases for all the basic paths for the 
 *	region routine in libultra.
 *
 */

#include "rgtest.h"

#ifdef _STANDALONE
#include <stdio.h>
#include <stdlib.h>

#define	OPTARG		"v"
#define rmonPrintf	printf

int verbose	= 0;
#endif  /* _STANDALONE */

#define	_PRINT_REGION_HEADER(rp) {	\
    if (verbose) \
      rmonPrintf("\t  (rp=0x%x, sdata=0x%x, bufsz=%d, bufcnt=%d, free=%d, align=%d)\n", \
	rp, RP(startBufferAddress), \
	RP(bufferSize), RP(bufferCount), RP(freeList), RP(alignSize)); \
    }

char	bootStack[STACKSIZE];

static void	idle(void *);

static OSThread	idleThread;
static char	idleThreadStack[STACKSIZE];

static OSThread	mainThread;
static char	mainThreadStack[STACKSIZE];

static OSThread	rmonThread;
static char	rmonThreadStack[RMON_STACKSIZE];

static int	directedTests(void);
static int	rangeTests(void);
static u32	doAlign(u32, int);
static int	isAlign(void *, int);

#ifndef _STANDALONE

static void	main(void *);

boot(void)
{
    osInitialize();

    parse();

    osCreateThread(&mainThread, 1, main, (void *)0,
		   mainThreadStack+STACKSIZE, 10);
    osStartThread(&mainThread);
}

static void
main(void *arg)
{
    int numFailures = 0;

    /*
     * Create idle thread
     */
    osCreateThread(&idleThread, 3, idle, (void *)0,
		   idleThreadStack+STACKSIZE, 0);
    osStartThread(&idleThread);

    /*
     * Create rmon thread
     */
    osCreateThread(&rmonThread, 0, rmonMain, (void *)0,
		rmonThreadStack+RMON_STACKSIZE, OS_PRIORITY_RMON);
    osStartThread(&rmonThread);

#else
void
main(int argc, char **argv)
{
    int numFailures = 0;
    int c;

    while ((c = getopt(argc, argv, OPTARG)) != EOF) {
        switch (c) {
            case 'v': {		/* Verbose */
                verbose = 1;
                break;
            }
            default: {
                rmonPrintf("usage: %s [-v]\n", argv[0]);
                exit(0);
            }
        }
    }
#endif  /* _STANDALONE */

    rmonPrintf("Region tests begin\n");

    numFailures = directedTests();

    numFailures += rangeTests();

    rmonPrintf("\nRegion tests complete, total failures = %d\n", numFailures);
}


/*
 * Target specific behavior
 */
static int
directedTests(void)
{
    OSRegion	*rp;
    char	*bp;
    u16		freeList;
    s32		i;
    int		numFailures = 0;
    u32		alignSize = 8;

    rmonPrintf("Directed region tests begin\n");

    /* 
     * Test #1: osCreateRegion(x,50,50)
     */
    rmonPrintf("\nTest #%2d: osCreateRegion(x,50,50,%d) = NULL ->  ", 
        1, alignSize);
    rp = (OSRegion *)osCreateRegion(memory, 50, 50, alignSize);
    if (rp == NULL) {
	rmonPrintf("passed\n");
    } else {
	rmonPrintf("failed\n");
	numFailures++;
    }

    
    /* 
     * Test #2: osCreateRegion(x,15,13)
     */
    rmonPrintf("\nTest #%2d: osCreateRegion(x,15,13,%d) = NULL -> ", 
	2, alignSize);
    rp = (OSRegion *)osCreateRegion(memory, 15, 13, alignSize);
    if (rp == NULL) {
	rmonPrintf("passed\n");
    } else {
	rmonPrintf("failed\n");
	numFailures++;
    }
    

    /* 
     * Test #3: osCreateRegion(x,40,11)
     */
    rmonPrintf("\nTest #%2d: osCreateRegion(x,40,11,%d) != NULL --> ", 
	3, alignSize);
    rp = (OSRegion *)osCreateRegion(memory, 40, 11, alignSize);
    if (rp != NULL) {
	rmonPrintf("passed\n");
    	_PRINT_REGION_HEADER(rp);
    } else {
	rmonPrintf("failed\n");
	numFailures++;
    }

    
    /* 
     * Test #4: osCreateRegion(x,40,12)
     */
    rmonPrintf("\nTest #%2d: osCreateRegion(x,40,12,%d) != NULL --> ", 
	4, alignSize);
    rp = (OSRegion *)osCreateRegion(memory, 40, 12, alignSize);
    if (rp != NULL) {
	rmonPrintf("passed\n");
    	_PRINT_REGION_HEADER(rp);
    } else {
	rmonPrintf("failed\n");
	numFailures++;
    }

    
    /* 
     * Test #5: osCreateRegion(x,41,11)
     */
    rmonPrintf("\nTest #%2d: osCreateRegion(x,41,11,%d) != NULL --> ", 
	5, alignSize);
    rp = (OSRegion *)osCreateRegion(memory, 41, 11, alignSize);
    if (rp != NULL) {
    	rmonPrintf("passed\n");
    	_PRINT_REGION_HEADER(rp);
    } else {
    	rmonPrintf("failed\n");
	numFailures++;
    }

    
    /* 
     * Test #6: osCreateRegion(x,41,16)
     */
    rmonPrintf("\nTest #%2d: osCreateRegion(x,41,16,%d) != NULL --> ", 
	6, alignSize);
    rp = (OSRegion *)osCreateRegion(memory, 41, 16, alignSize);
    if (rp != NULL) {
    	rmonPrintf("passed\n");
    	_PRINT_REGION_HEADER(rp);
    } else {
    	rmonPrintf("failed\n");
	numFailures++;
    }

    
    /* 
     * Test #7: osCreateRegion(x, (35K*8), 3)
     *	     Test for count > 32K
     */
    rmonPrintf("\nTest #%2d: osCreateRegion(x,(35K*8),3,%d) != NULL --> ", 
	7, alignSize);
    rp = (OSRegion *)osCreateRegion(memory, (35*1024*8), 3, alignSize);
    if (rp != NULL) {
    	rmonPrintf("passed\n");
    	_PRINT_REGION_HEADER(rp);
    } else {
    	rmonPrintf("failed\n");
	numFailures++;
    }

    /* 
     * Test #8: osCreateRegion(x,41,16)
     */
    rmonPrintf("\nTest #%2d: osCreateRegion(x,40,10,%d) != NULL --> ", 
	8, alignSize);
    rp = (OSRegion *)osCreateRegion(memory, 40, 10, alignSize);
    if (rp == NULL) {
    	rmonPrintf("failed\n");
	numFailures++;
    } else {
    	rmonPrintf("passed\n");
	_PRINT_REGION_HEADER(rp);
	/* 
	 * Test #9: osMalloc(rp) (one buffer)
	 */
	rmonPrintf("\nTest #%2d: osMalloc(rp) {one buffer} != NULL ", 9);
	bp = (char *)osMalloc((void *)rp);
	if (bp != NULL) {
	    if (verbose)
		    rmonPrintf("\n\t  (1st buffer address =0x%x)\n", bp);
	    _PRINT_REGION_HEADER(rp);
	    bp = (char *)osMalloc((void *)rp);
	    if (bp == NULL) {
		rmonPrintf("--> passed\n");
	    } else {
		if (verbose)
		    rmonPrintf("\t  (2nd buffer is NULL)\n");
		rmonPrintf("--> failed\n");
		numFailures++;
	    }
	} else {
	    rmonPrintf("--> failed\n");
	    numFailures++;
	}
	_PRINT_REGION_HEADER(rp);
    }
	
    /* 
     * Test #10: osCreateRegion(x,60,12)
     */
    rmonPrintf("\nTest #%2d: osCreateRegion(x,60,12,%d) != NULL --> ", 
	10, alignSize);
    rp = (OSRegion *)osCreateRegion(memory, 60, 12, alignSize);
    if (rp == NULL) {
    	rmonPrintf("failed\n");
	numFailures++;
    } else {
    	rmonPrintf("passed\n");
	_PRINT_REGION_HEADER(rp);
	 /* 
	 * Test #11: osMalloc(rp) (one buffer)
	 */
	rmonPrintf("\nTest #%2d: osMalloc(rp) {one buffer} != NULL --> ", 11);
	bp = (char *)osMalloc((void *)rp);
	if (bp == NULL) {
    	    rmonPrintf("failed\n");
	    numFailures++;
	} else {
    	    rmonPrintf("passed\n");
	    freeList = RP(freeList);

	    /*
	     * Test #12: osFree(rp,x)
	     */
	    rmonPrintf("\nTest #%2d: osFree(rp,x) ", 12);
	    osFree((void *)rp, bp);
	    if (RP(freeList) != freeList) {
		rmonPrintf("--> passed\n");
	    } else {
		rmonPrintf("--> failed\n");
		numFailures++;
	    }
	    _PRINT_REGION_HEADER(rp);


	    /* 
	     * Test #13: osGetRegionBufCount(rp)
	     */
	    rmonPrintf("\nTest #%2d: osGetRegionBufCount(rp) = count ", 13);
	    i = osGetRegionBufCount((void *)rp);
	    if (i == 2) {
		rmonPrintf("--> passed\n");
	    } else {
		rmonPrintf("--> failed\n");
		numFailures++;
	    }
	    _PRINT_REGION_HEADER(rp);

	    /* 
	     * Test #14: osGetRegionBufSize(rp)
	     */
	    rmonPrintf("\nTest #%2d: osGetRegionBufSize(rp) = count ", 14);
	    i = osGetRegionBufSize((void *)rp);
	    if (i == 16) {
		rmonPrintf("--> passed\n");
	    } else {
		rmonPrintf("--> failed\n");
		numFailures++;
	    }
	    _PRINT_REGION_HEADER(rp);
	}
    }

    return(numFailures);
}

/*
 * Vary parameters and call all of the API
 */
static int
rangeTests(void)
{
    OSRegion	*rp;
    char	*m1;
    char	*buf[MEMSIZE/BUFSIZE];
    char	*bp;
    u32		 bufferSize, memorySize, alignSize;
    int		i, j, k, numOfBuf, dataFail;
    int		numFailures = 0;

    u32		alignTable[] = { 
        0, OS_RG_ALIGN_2B, OS_RG_ALIGN_4B, OS_RG_ALIGN_8B, OS_RG_ALIGN_16B
    };
    u32		alignTableSize = sizeof(alignTable)/sizeof(alignTable[0]);

    rmonPrintf("Range region tests begin\n");

    for (k = 0; k < alignTableSize; k++) {
         alignSize = alignTable[k];
    for (m1 = memory-1; m1 <= memory; m1++) {
    for (memorySize = MEMSIZE-1; memorySize <= MEMSIZE; memorySize++) {
    for (bufferSize = BUFSIZE-1; bufferSize <= BUFSIZE; bufferSize++) {

    /* 
     * Test #30: osCreateRegion(x,x,x)
     */
    rmonPrintf("\nTest #%2d: osCreateRegion(0x%x,0x%x,0x%x,%d) != NULL --> ",
		30, m1, memorySize, bufferSize, alignSize);
    rp = (OSRegion *)osCreateRegion(m1, memorySize, bufferSize, alignSize);
    if (rp == NULL) {
    	rmonPrintf("failed\n");
	numFailures++;
    } else {
    	rmonPrintf("passed\n");
	_PRINT_REGION_HEADER(rp);

	i = 0;
	while ((buf[i] = (char *)osMalloc((void *)rp)) != (char *)NULL) {
	    /* 
	     * Test #31: osGetRegionBufCount(rp)
	     */
	   rmonPrintf("\nTest #%2d: check alignment (%d) of osMalloc buffer %d",
		       31, alignSize, i);
	    if (isAlign(buf[i], 
		(alignSize == 0) ? OS_RG_ALIGN_DEFAULT : alignSize)) {
		rmonPrintf("--> passed\n");
	    } else {
		rmonPrintf("--> failed\n");
		numFailures++;
	    }
	    _PRINT_REGION_HEADER(rp);
	    if (verbose)
		rmonPrintf("\tinitializing buffer[%d] (0x%x) data...\n ",
			   i, buf[i]);
	    for (j = 0; j < bufferSize; j++)
		buf[i][j] = i;
	    i++;
	}
	_PRINT_REGION_HEADER(rp);

	numOfBuf = i;
	if (verbose) {
	    rmonPrintf("\n\tTotal # of buffers malloced = %d\n", numOfBuf);
	    rmonPrintf("\n\tDumping buffer memory:\n");
	    for (i = 0; i < numOfBuf; i++) {
		unsigned long addr;

		addr=(unsigned long)(RP(startBufferAddress)+(RP(bufferSize)*i));
		rmonPrintf("\t[%d]. 0x%x: ", i, addr);
		for (j = 0; j < RP(bufferSize); j++) 
		    rmonPrintf("%2x ", *(u8 *)(addr+j));
		rmonPrintf("\n");
	    }
	}

	/* 
	 * Test #32: check data of osMalloc buffer
	 */
	rmonPrintf("\nTest #%2d: check data of osMalloc buffer ",
		   32);

 	dataFail = 0;
	for (i = 0; i < numOfBuf; i++) {
	    for (j = 0; j < bufferSize; j++) {
		if (buf[i][j] != i) {
		    dataFail = 1;
		    break;
		}
	    }
	}
	if (dataFail == 0) {
	    rmonPrintf("--> passed\n");
	} else {
	    rmonPrintf("--> failed\n");
	    numFailures++;
	}

	for (i = 0; i < numOfBuf; i++) {
	    if (verbose)
		rmonPrintf("\n\tcalling osFree: rp=0x%x, buf=0x%x\n ", 
			   rp, buf[i]);
	    osFree((void *)rp, (void *)buf[i]);
	    _PRINT_REGION_HEADER(rp);
	}

	/* 
	 * Test #33: osGetRegionBufCount(rp)
	 */
	rmonPrintf("\nTest #%2d: osGetRegionBufCount(rp) = %d ",
		   33, numOfBuf);
	if (osGetRegionBufCount((void *)rp) == numOfBuf) {
	    rmonPrintf("--> passed\n");
	} else {
	    rmonPrintf("--> failed\n");
	    numFailures++;
	}

	/* 
	 * Test #34: osGetRegionBufSize(rp)
	 */
	rmonPrintf("\nTest #%2d: osGetRegionBufSize(rp) = 0x%x ",
		   34, doAlign(bufferSize, 
		   (alignSize == 0) ? OS_RG_ALIGN_DEFAULT : alignSize));
	if (osGetRegionBufSize((void *)rp) == doAlign(bufferSize, 
            (alignSize == 0) ? OS_RG_ALIGN_DEFAULT : alignSize)) {
	    rmonPrintf("--> passed\n");
	} else {
	    rmonPrintf("--> failed\n");
	    numFailures++;
	}
    }	/* if (rp == NULL) */

    }	/* for (m1 = memory; ...; ...) */
    }	/* for (memorySize = MEMSIZE; ...; ...) */
    }	/* for (bufferSize = BUFSIZE; ...; ...) */
    }	/* for (alignSize  = OS_RG_ALIGN_2B; ...; ...) */

    return(numFailures);
}

static void
idle(void *arg)
{
    for (;;);
}

static u32
doAlign(u32 count, int size)
{
	return((((count + size -1)) / size) * size);
}

static int
isAlign(void *addr, int size)
{
	return(!((u32)addr & (size-1)));
}