// Copyright (c) 2005-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:

 //

 #include <string.h>

 #include <e32test.h> //this includes e32cmn.h

 #include <e32debug.h>

 #include <sys/types.h>

 #include <sys/socket.h>

 #include <sys/ioctl.h>

 #include <libc/netinet/in.h>

 #include <libc/arpa/inet.h>

 #include <limits.h>

 #include <sys/errno.h>

 #include <stdlib.h>

 #include <math.h>

 LOCAL_D RTest				TheTest (_L("T_StdlibDefect"));

 //

 //

 //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__) 

 const TInt KTestDataLen = 10000;

 const TInt KTestIterations = 1000;

 #ifdef __ARMCC__

 const TInt KMinCharARMCC = 0;

 const TInt KMaxCharARMCC = 255;

 #else

 const TInt KMinCharNoARMCC = -128;

 const TInt KMaxCharNoARMCC = 127;

 #endif

 /**

 DEF062679  : memcpy in stdlib is slow

 */ 

 void Defect_DEF062679_memcpy()

 	{

 	TUint8* src1 = new TUint8[KTestDataLen];

 	TEST(src1 != NULL);

 	Mem::Fill(src1, KTestDataLen, 'A');

 	TUint8* dst1 = new TUint8[KTestDataLen];

 	TEST(dst1 != NULL);

 	TTime startTime, stopTime;

 	TInt i;

 	//Loop to check time spent using Mem::Copy

 	startTime.UniversalTime();

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

 		Mem::Copy(dst1, src1, KTestDataLen );

 	stopTime.UniversalTime();

 	TTimeIntervalMicroSeconds timeTaken = stopTime.MicroSecondsFrom(startTime);

 	TheTest.Printf(_L("Time taken using Mem::Copy :%d microseconds\n"), timeTaken.Int64() );

 	//Loop to check the time spent using memcpy after the change

 	startTime.UniversalTime();

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

 		memcpy(dst1, src1, KTestDataLen );

 	stopTime.UniversalTime();

 	TTimeIntervalMicroSeconds timeTaken2 = stopTime.MicroSecondsFrom(startTime);

 	TheTest.Printf(_L("Time taken using  memcpy: %d microseconds\n"), timeTaken2.Int64() );

 	TheTest.Printf(_L("Time taken using  memcpy before the change about 613125 microseconds\n"));

 	//Test memcpy works fine

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

 		TEST(dst1[i] == src1[i]);

 	delete [] src1;

 	delete [] dst1;

 	}

 /**

 DEF062679  : memcpy in stdlib is slow

 */ 

 void Defect_DEF062679_memcmp()

 	{

 	TUint8* str1 = new TUint8[KTestDataLen];

 	TEST(str1 != NULL);

 	Mem::Fill(str1, KTestDataLen, 'A');

 	TUint8* str2 = new TUint8[KTestDataLen];

 	TEST(str2 != NULL);

 	Mem::Fill(str2, KTestDataLen, 'A');

 	TTime startTime, stopTime;

 	//Loop to check the time using Mem::Copy

 	startTime.UniversalTime();

 	TInt i,ret;

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

 		ret = Mem::Compare(str2,KTestDataLen, str1, KTestDataLen );

 	stopTime.UniversalTime();

 	TTimeIntervalMicroSeconds timeTaken = stopTime.MicroSecondsFrom(startTime);

 	TheTest.Printf(_L("Time taken using Mem::Compare :%ld microseconds\n"), timeTaken.Int64() );

 	//Loop to check the time spent using memcpy after the change

 	startTime.UniversalTime();

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

 		ret = memcmp(str2,str1, KTestDataLen );

 	TEST(ret==0); //check that memcmp works fine	

 	stopTime.UniversalTime();

 	TTimeIntervalMicroSeconds timeTaken2 = stopTime.MicroSecondsFrom(startTime);

 	TheTest.Printf(_L("Time taken using  memcmp: %ld microseconds\n"), timeTaken2.Int64() );

 	TheTest.Printf(_L("Time taken using  memcmp before changes 1007000 microseconds\n"));

 	//Test memcmp works fine

 	TUint8* str3 = new TUint8[KTestDataLen];

 	TEST(str3 != NULL);

 	Mem::Fill(str3, KTestDataLen, 'B');

 	ret = memcmp(str3, str1, KTestDataLen);

 	TEST(ret>0);

 	ret = memcmp(str1, str3, KTestDataLen);

 	TEST(ret<0);

 	delete str1;

 	delete str2;

 	delete str3;

 	}	

 /**

 INC073740: inet_addr and inet_aton returns wrong results with invalid input on STDLIB

 */ 

 void Defect_INC073740()

 	{

 	TheTest.Next(_L("INC073740: inet_addr and inet_aton returns wrong results with invalid input on STDLIB"));

 	int err;

 	struct in_addr iaddr;	

 	char* good_addr="16.33.50.67";

 	char* bad_addr="256.33.50.67";

 	char* worse_addr="16.1456.50.67";

 	char* worst_addr="16.33.333333.67";

 	err=inet_aton(good_addr, &iaddr);

 	TEST2(err, 1);

 	err=inet_aton(bad_addr, &iaddr);

 	TEST2(err, 0);

 	err=inet_aton(worse_addr, &iaddr);

 	TEST2(err, 0);

 	err=inet_aton(worst_addr, &iaddr);

 	TEST2(err, 0);

 	}

 /**

 @SYMTestCaseID         	SYSLIB-STDLIB-CT-1863

 @SYMTestCaseDesc        Tests for minimum and maximum values type "char" with ARMCC macro

 @SYMTestPriority        High

 @SYMTestActions         Tests for checking minimum and maximum values for a variable of type "char"

 @SYMTestExpectedResults Tests must not fail

 @SYMDEF                 PDEF091928

 */ 

 void Defect_PDEF091928()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-STDLIB-CT-1863 PDEF091928: limits.h not correct for ARM RVCT compiler "));

 	char charmn=CHAR_MIN;

 	char charmx=CHAR_MAX;

 #ifdef __ARMCC__

 	TEST2(charmn, KMinCharARMCC);

 	TEST2(charmx, KMaxCharARMCC);

 #else

 	TEST2(charmn, KMinCharNoARMCC);

 	TEST2(charmx, KMaxCharNoARMCC);

 #endif

 	}

 /**

 @SYMTestCaseID         	SYSLIB-STDLIB-UT-3612

 @SYMTestCaseDesc        Tests for __errno().

 @SYMTestPriority        Normal

 @SYMTestActions         Tests for __errno(). Test whether it is correctly exported and functioning 

 						as expected after being declared with IMPORT_C. 

 @SYMTestExpectedResults Tests must not fail

 @SYMDEF                 DEF110593

 */ 

 void Defect_DEF110593()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-STDLIB-UT-3612 DEF110593: IMPORT_C/EXPORT_C: ERRNO.H "));

 	// randomly selected 24 macros from errno.h

 	const int errMacros[24] =

 		{

 		EPERM,		ENOENT,		ESRCH,		EINTR,		EIO,

 		EBADF,		ENOMEM,		EFAULT,		EBUSY,		ENOTDIR,

 		ENFILE,		ESPIPE,		ERANGE,		ENOMSG,		EDEADLK,

 		ENOLCK,		ENOTSOCK,	ENOLINK,	EBADMSG,	ENOTUNIQ,

 		EBADFD,		ENOSYS,		EILSEQ, 	__ELASTERROR

 		};

 	// Step 1: setting errno using assign "=", test value returned by errno

 	errno = 0;

 	TEST(errno == 0);

 	int i;

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

 		{

 		errno = errMacros[i];

 		TEST(errno == errMacros[i]);

 		}

 	// Step 2: setting errno using the library globals struct, test value returned by errno

 	struct _reent *r = _REENT2;

 	r->_errno = 0;

 	TEST(errno == 0);

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

 		{

 		r->_errno = errMacros[i];

 		TEST(errno == errMacros[i]);

 		}

 	r->_errno = 0;

 	TEST(errno == 0);

 	// Step3: Test errno by using other C function in STDLIB

 	// Test using ldexp(double value, int exp);

 	// Giving val a huge number to make res overflow. errno should return ERANGE

 	double val = 1.5E+308;

 	int exp = 10;

 	ldexp(val, exp);

 	TEST(errno == ERANGE);

 	//finish

 	CloseSTDLIB();	

 	}

 /**

 @SYMTestCaseID          SYSLIB-STDLIB-CT-4001

 @SYMTestCaseDesc        Test strtoul() with a string whose first character is '-' or '+'. 

 @SYMTestPriority        3. Medium

 @SYMTestActions         Test strtoul() with a string whose first character is '-' or '+'. 

 @SYMTestExpectedResults Tests must not fail

 @SYMDEF                 PDEF114447 

 */ 

 void Defect_PDEF114447 ()

     {

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-STDLIB-CT-4001 PDEF114447 : add the processing for '-' and '+' in a string passed to strtoul() "));

     unsigned long result;

     result = strtoul("+80", NULL, 10);    

     TEST2(result, 80);

     result = strtoul("-80", NULL, 10);    

     TEST2(result, -80);    

     }

 /**

 Calls ImpurePtr2() to allocate memory for the library globals struct then calls CloseSTDLIB() 

 to release it.

 Leaves if system-wide error occurs.

 */

 LOCAL_C void TestImpurePtrL()

 {

 	struct _reent * p = ImpurePtr2();

 	User::LeaveIfNull(p);

 	CloseSTDLIB();

 }

 /**

 @SYMTestCaseID         	SYSLIB-STDLIB-UT-4002

 @SYMTestCaseDesc        Test checks the constructor of CLocalSystemInterface does not panics in OOM test

 						or when error KErrNoMemory occurs.

 @SYMTestPriority        Normal

 @SYMTestActions         In an OOM test, repeats calling ImpurePtr2(), which creates CLocalSystemInterface instance. 

 @SYMTestExpectedResults The test program should not panic or fail.

 @SYMDEF                 DEF114383

 */ 

 LOCAL_C void Defect_DEF114383()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-STDLIB-UT-4002 DEF114383: STDLIB, CLocalSystemInterface::CLocalSystemInterface() panics in OOM "));		

 	TInt err=KErrNone;

 	TInt tryCount = 0;

 	do

 		{

 		__UHEAP_MARK;

 		__UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount);

 		TRAP(err, TestImpurePtrL());

 		__UHEAP_SETFAIL(RHeap::ENone, 0);

 		if (err!=KErrNoMemory)

 			TEST(err == KErrNone);

 		__UHEAP_MARKEND;

 		} while(err == KErrNoMemory);

 	TEST(err == KErrNone);

 	TheTest.Printf(_L("- ImpurePtr2() succeeded at heap failure rate of %i\n"), tryCount);

 	} 

 /**

 Invoke the tests

 */

 LOCAL_C void RunTestsL ()

     {

 	Defect_DEF062679_memcpy();

 	Defect_DEF062679_memcmp();

 	Defect_INC073740();

 	Defect_PDEF091928();

 	Defect_DEF110593(); 

 	Defect_PDEF114447();

 	Defect_DEF114383();

 	}

 GLDEF_C TInt E32Main()

  {		

 	CTrapCleanup* tc = CTrapCleanup::New();

 	TEST(tc != NULL);

 	__UHEAP_MARK;

 	TheTest.Title();

 	TheTest.Start (_L("Defect Tests"));

 	TInt err;

 	TRAP(err, ::RunTestsL())

 	TEST2(err, KErrNone);

 	TheTest.End();

 	TheTest.Close();

 	delete tc;

 	__UHEAP_MARKEND;

 	return(KErrNone);

 	}