// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// This test has been converted from it original TMISC.C .

// The original was a manaul test and didn't work!

// Test code for bsearch, qsort etc. These are all functions which work directly

// without using the MSystemInterface - as such none of them use errno to indicate

// errors.

// 

//

#include <e32test.h>

#include <e32svr.h>

#include <stdarg.h>

#include <stdlib.h>

#include <stdio.h>

#include <math.h>  /* HUGE_VAL */

#include <errno.h> /* ERANGE */

#include "ESTLIB.H"

// Defined in ctest.h but contains lots of other declarations we don't want

#define test_Data		struct __testdata __td	/* declares global variable __td */

//

// Globals

static RTest TheTest(_L("TMisc"));

//

//

//Test macroses and functions

static void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		TheTest(EFalse, aLine);

		}

	}

static  void Check(TInt aValue, TInt aExpected, TInt aLine)

	{

	if(aValue != aExpected)

		{

		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

		TheTest(EFalse, aLine);

		}

	}

#define TEST(arg) ::Check((arg), __LINE__)

#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

//

// Tests

/* random numbers */

void random_numbers()

	{

	int i,r;

	int rs[20];

	TheTest.Next(_L("Random numbers"));

	for (i=0; i<20; i++)

		{

		r = rand();

		printf("%d ", r);

		}

	printf("\n");

	TheTest.Next(_L("Using srand()"));

	srand(12345678);

	for (i=0; i<20; i++)

		{

		rs[i]=rand();

		printf("%d ",rs[i]);

		}

	printf("\n");

	srand(12345678);

	for (i=0; i<20; i++)

		TEST(rand()==rs[i]);

	}

/* Sorting */

typedef struct {

	int a;

	int b;

	int c;

	} sort_item;

int compare_a (const void *left, const void *right)

	{

	sort_item *lp = (sort_item *)left;

	sort_item *rp = (sort_item *)right;

	if (lp->a < rp->a) return -1;

	if (lp->a > rp->a) return  1;

	return 0;

	}

int compare_ba (const void *left, const void *right)

	{

	sort_item *lp = (sort_item *)left;

	sort_item *rp = (sort_item *)right;

	if (lp->b < rp->b) return -1;

	if (lp->b > rp->b) return  1;

	/* b's are equal, sort on a's */

	if (lp->a < rp->a) return -1;

	if (lp->a > rp->a) return  1;

	return 0;

	}

#define NITEMS 200

sort_item list[NITEMS];

void validate(sort_item *p)

	{

	int i;

	for (i=0; i<NITEMS; i++,p++)

		{

		if (p->a==9)

			continue;

		TEST((p->a/4)+p->b == 5000);

		TEST((p->a*p->a)/4 == p->c);

		}

	}

void sorting()

	{

	int i;

	TheTest.Next(_L("Quicksort"));

	for (i=1; i<NITEMS; i++)

		{

		list[i].a = 2*i;

		list[i].b = 5000-(i/2);

		list[i].c = i*i;

		}

	/* Sort into increasing order of a. Want item 0 to sort to position 4 */

	list[0].a = 9;

	list[0].b = 10;

	list[0].c = 11;

	qsort(list, NITEMS, sizeof(list[0]), compare_a);

	TEST(list[4].c==11);

	validate(list);

	/* Resort into increasing order of b followed by a. Want item 0 to sort to position 5 */

	list[0].a = 9;

	list[0].b = 5000-((199-4)/2);

	list[0].c = 13;

	qsort(list, NITEMS, sizeof(list[0]), compare_ba);

	TEST(list[5].c==13);

	validate(list);

	}

void searching()

	{

	int i;

	sort_item *answer;

	sort_item not_there;

	TheTest.Next(_L("Binary search for existing items"));

	for (i=0; i<NITEMS; i++)

		{

		answer = (sort_item*)bsearch(&list[i],list,NITEMS,sizeof(list[0]),compare_ba);

		TEST(answer==&list[i]);

		}

	TheTest.Next(_L("Binary search for missing items"));

	for (i=0; i<NITEMS; i++)

		{

		not_there = list[i];

		not_there.a++;

		answer = (sort_item*)bsearch(&not_there,list,NITEMS,sizeof(list[0]),compare_ba);

		if (answer!=NULL)

			TEST(!compare_ba(answer,&not_there));

		}

	for (i=0; i<NITEMS; i++)

		{

		not_there = list[i];

		not_there.a--;

		answer = (sort_item*)bsearch(&not_there,list,NITEMS,sizeof(list[0]),compare_ba);

		if (answer!=NULL)

			TEST(!compare_ba(answer,&not_there));

		}

	}

void sscanf_test()

	{

	int in[4], i;

	TheTest.Next(_L("Simple SSCANF tests"));

	in[0] = in[1] = in[2] = in[3] = 6789;

	i = sscanf("1.2.3.4", "%d.%d.%d.%d", &in[0], &in[1], &in[2], &in[3]);

	TEST (in[0]==1);

	TEST (in[1]==2);

	TEST (in[2]==3);

	TEST (in[3]==4);

	TEST (i==4);

	i = sscanf("194.223.254.9", "%d.%d.%d.%d", &in[0], &in[1], &in[2], &in[3]);

	TEST (in[0]==194);

	TEST (in[1]==223);

	TEST (in[2]==254);

	TEST (in[3]==9);

	TEST (i==4);

	i = sscanf("17.183.hello.11", "%d.%d.%d.%d", &in[0], &in[1], &in[2], &in[3]);

	TEST (in[0]==17);

	TEST (in[1]==183);

	TEST (in[2]==254);

	TEST (in[3]==9);

	TEST (i==2);

	}

/* setjmp, longjmp */

#include <setjmp.h>

#include <string.h>

jmp_buf jbufs[4];

int count=0;

static int getStackPointer(void)

	{

	static char there;

	char here;

	return &here-&there;

	}

static int getgetStackPointer(void)

	{

	int n=4;	// local variable to cause change to stack pointer

	n+=getStackPointer();

	if (n==0)

		n=getStackPointer()+37;	// this never happens - it's just to defeat the optimiser

	return (n-4);

	}

void jmp_nest(int n)

	{

	int m=n+100;	// local variable to induce a stack frame

	if (n>0)

		jmp_nest(n-1);

	longjmp(jbufs[3],m);

	}

#ifdef __VC32__

#pragma optimize( "", off )		//stop the compiler breaking this TEST

#endif

void setjmp_longjmp()

	{

	volatile int i,r,j,k,l,m; // volatile to rid us of warnings

	volatile int sp1,sp2;

	TheTest.Next(_L("Setjmp"));

	sp1=getStackPointer();

	sp2=getgetStackPointer();

	TEST(sp1!=sp2);	// call from deeper function nesting should give a different answer

	memset(jbufs[0],0,sizeof(jmp_buf));

	memset(jbufs[1],0,sizeof(jmp_buf));

	memset(jbufs[2],0,sizeof(jmp_buf));

	r=setjmp(jbufs[0]);

	TEST(r==0);

	for (i=0,j=1,k=2,l=3,m=4; i<3; i++,j*=3,k+=j,l*=m,m-=2)

		{

		r=setjmp(jbufs[i]);

		TEST(r==0);

		TEST(j>i);

		}

	r=memcmp(jbufs[0],jbufs[2], sizeof(jmp_buf));

	if (r!=0)

		{

		RDebug::Print(_L("  Test code appears to be using preserved registers (a good thing)\n"));

		RDebug::Print(_L("  buf @   %08x %08x\n"), jbufs[0], jbufs[2]);

		for (i=0;i<16;i++)

			{

			if (jbufs[0][i] != jbufs[2][i])

				RDebug::Print(_L("  buf+%02d: %08x %08x\n"), i*4, jbufs[0][i], jbufs[2][i]);

			}

		}

	else

		RDebug::Print(_L("  Test code appears not to exercise preserved registers\n"));

	r=setjmp(jbufs[0]);

	TEST(r==0);

	r=setjmp(jbufs[2]);

	TEST(r==0);

	r=memcmp(jbufs[0],jbufs[2], sizeof(jmp_buf));

	TEST(r!=0);	/* must change the return address! */

	TheTest.Next(_L("Setjmp and longjmp"));

	r=setjmp(jbufs[0]);

	if (r==0)

		{

		TEST(count==0);

		count++;

		longjmp(jbufs[0],7);

		}

	else if (r==7)

		{

		TEST(count==1);

		count++;

		longjmp(jbufs[0],3);

		}

	else if (r==3)

		{

		TEST(count==2);

		count++;

		longjmp(jbufs[0],0);	/* 0 must be turned into 1 */

		}

	else

		{

		TEST(r==1);

		TEST(count==3);

		count++;

		}

	sp1=getStackPointer();

	r=setjmp(jbufs[3]);

	if (r==0)

		{

		sp2=getStackPointer();

		TEST(sp1==sp2);

		longjmp(jbufs[3],1);		// simple setjmp/longjmp

		}

	else if (r==1)

		{

		sp2=getStackPointer();

		TEST(sp1==sp2);

		jmp_nest(20);			// more complex example

		}

	else

		{

		TEST(r==100);

		sp2=getStackPointer();

		TEST(sp1==sp2);

		}

	}

#ifdef __VC32__

#pragma optimize( "", on )	//stop the compiler breaking this TEST

#endif

/* case-insensitive comparison */

#include <string.h>

char agrave[2]= {191,0};

void casecmp()

	{

	int r;

	char *s1,*s2;

	TheTest.Next(_L("Case-insensitive string comparison"));

	s1="abcd";

	r=strcasecmp(s1,s1);

	TEST(r==0);

	s2="abcde";

	r=strcasecmp(s1,s2);

	TEST(r<0);

	r=strcasecmp(s2,s1);

	TEST(r>0);

	r=strncasecmp(s1,s2,10);

	TEST(r<0);

	r=strncasecmp(s1,s2,4);

	TEST(r==0);

	s2="ABcD";

	r=strcmp(s1,s2);

	TEST(r!=0);

	r=strcasecmp(s1,s2);

	TEST(r==0);

#if 0

	/* Need some way to set up a proper folding example */

	r=strncasecmp(s2,agrave,1);

	TEST(r==0);

#endif

	}

void arguments(int argc, char *argv[])

	{

	int i;

	TheTest.Next(_L("Command line arguments"));

	TEST(argc>0);

	TEST(argv!=0);

	printf("  argc=%d\r\n", argc);

	for (i=0; i<argc; i++)

		{

		int j;

		int length=strlen(argv[i]);

		TEST(argv[i]!=0);

		printf("  argv[%d]= ", i);

		for (j=0;j<4;j++)

			{

			printf("%02x ", ((unsigned char *)argv[i])[j]);

			if (argv[i][j]=='\0')

				break;

			}

		for (;j<3;j++)

			printf("   ");

		printf(" \"%s\" length %d\r\n", argv[i], length);

		}

	}

struct double_conv {

	char* source;

	double answer;

	int tail_offset;

	};

struct double_conv strtods[] = {

	{ "1",		1.0,	1 },

	{ "0.1",	0.1,	3 },

	{ ".1",		0.1,	2 },

	{ " 0.1",	0.1,	4 },

	{ " 1 ",	1.0,	2 },

	{ "1x",		1.0,	1 },

	{ "x",		0.0,	0 },

	{ "1.5.3",	1.5,	3 },

	{ "1.0e-1m solid red;}...",	0.1,	6 },

	{ "1.0e2blah",	100.0,	5 },

	{ "3.1415e2blah",	314.15,	8 },

	{ "0.2em solid red;}...",	0.2,	3 },

	{ "0.2e5m solid red;}...",	20000.0,	5 },

	{ 0 }

	};

void strtod_test()

	{

	double d;

	char* p;

	struct double_conv *dc;

	TheTest.Next(_L("text to double conversion"));

	for (dc=strtods; dc->source; dc++)

		{

		d=strtod(dc->source,NULL);

		TEST(d==dc->answer);

		}

	for (dc=strtods; dc->source; dc++)

		{

		p=(char*)1;

		d=strtod(dc->source,&p);

		TEST(d==dc->answer);

		TEST(p==dc->source+dc->tail_offset);

		}

	/* overflow positive number */

	d=strtod("9e9999", NULL);

	TEST(d==HUGE_VAL && errno==ERANGE);

	/* overflow negative number */

	d=strtod("-9e9999", NULL);

	TEST(d==-HUGE_VAL && errno==ERANGE);

	/* underflow number */

	d=strtod("9e-9999", NULL);

	TEST(d==0 && errno==ERANGE);

	d=strtod("-9e-9999", NULL);

	TEST(d==0 && errno==ERANGE);

}

#define TEST_8	0x88

#define TEST_16	0x1617

#define TEST_32	0x32333435

#define TEST_LIST \

	TEST_8,  TEST_16, TEST_32, \

	TEST_8,  TEST_32, TEST_16, \

	TEST_16, TEST_8,  TEST_32, \

	TEST_16, TEST_32, TEST_8,  \

	TEST_32, TEST_8,  TEST_16, \

	TEST_32, TEST_16, TEST_8

/*

   Suppressing RVCT compiler warning (for char/short/long types):

   Warning:  #1256-D: "unsigned char" would have been promoted to "int" when passed through the ellipsis parameter;

   use the latter type instead.

          b = va_arg(ap, unsigned char);

              ^

*/

#pragma diag_suppress 1256

// The above RCVT warning is a compiler error in GCC. Below is the GGC friendly version of the function.

#ifdef __GCC32__

void va_va_bwlblwwblwlblbwlwb(va_list ap)

	{

	unsigned long l;

	unsigned short w;

	unsigned char b;

	l=0; w=0; b=0;

	b = va_arg(ap, int);

	TEST(b==TEST_8);

	w = va_arg(ap, int);

	TEST(w==TEST_16);

	l = va_arg(ap, unsigned long);

	TEST(l==TEST_32);

	l=0; w=0; b=0;