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

// Name        : tstdlibblocks.cpp

//

#include "tstdlib.h"

#include "sysif.h" //Backend()

#include <unistd.h> 

#include <errno.h>

#include <stdio.h>

#include <e32std.h>

#include <stdlib.h>

#include <string.h>

#include <limits.h> //MB_LEN_MAX

#include <monetary.h>

#include <locale.h>

#include <test/testexecutestepbase.h>

#include <limits.h>

#include <e32def.h>

#include <stdio.h>

#include <wchar.h>

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include <time.h>

#include <assert.h>

#include <wctype.h>

#include <inttypes.h>

#include <c32comm.h> 

#include <math.h> 

#include <e32math.h> 

#include <fcntl.h> //O_APPEND, O_RDWR, O_CREAT

#include <sys/stat.h> //S_ISWUSR

#include <sys/syslimits.h> //PATH_MAX

#include <pthread.h> //pthread_create

#include <getopt.h> //getopt, getopt_long

#include <signal.h>

#include <sys/wait.h>

#include <setjmp.h>

#include <iconv.h>

#include <grp.h>

#include <locale.h>

#include <monetary.h>

#define MAX_SIZE 50

#define BUF_SIZE 100

// ============================ GLOBAL FUNCTIONS ===============================

void exitfunc0(void) { }

void exitfunc1(void) { }

void exitfunc2(void) { }

void exitfunc3(void) { }

void exitfunc4(void) { }

void exitfunc5(void) { }

void exitfunc6(void) { }

void exitfunc7(void) { }

void exitfunc8(void) { }

void exitfunc9(void) { }

void exitfunc10(void) { }

void exitfunc11(void) { }

void exitfunc12(void) { }

void exitfunc13(void) { }

void exitfunc14(void) { }

void exitfunc15(void) { }

void exitfunc16(void) { }

void exitfunc17(void) { }

void exitfunc18(void) { }

void exitfunc19(void) { }

void exitfunc20(void) { }

void exitfunc21(void) { }

void exitfunc22(void) { }

void exitfunc23(void) { }

void exitfunc24(void) { }

void exitfunc25(void) { }

void exitfunc26(void) { }

void exitfunc27(void) { }

void exitfunc28(void) { }

void exitfunc29(void) { }

void exitfunc30(void) { }

void exitfunc31(void) { }

void exitfunc32(void) { }

// -----------------------------------------------------------------------------

// ReadStringParam :Reads path name given the buffer

// Returns: KErrNone: On Success

//          KErrGeneral: On Failure                    

// -----------------------------------------------------------------------------

//

void CTestStdlib::ReadStringParam(char* expected)

	{

	_LIT( KaKey, "Param%d" );

   	TBuf<8> pNameBuf;

    TPtrC string;

    pNameBuf.Format(KaKey,++iParamCnt);

	TBool res = GetStringFromConfig(ConfigSection(), pNameBuf, string);

	if(!res)

	 	{

	 	_LIT(Kerr , "Unable to retrieve string parameter") ;

	 	INFO_PRINTF1(Kerr);

	  	}

	TBuf8<256> bufstring;

	bufstring.Copy(string);

	TInt paramLength=string.Length();

	char* text=(char *)(bufstring.Ptr());

 	*(text+paramLength)='\0';

	strcpy(expected,text);

	return;

	}

// -----------------------------------------------------------------------------

// ReadIntParam :Reads an inteeger value given the buffer

// Returns: KErrNone: On Success

//          KErrGeneral: On Failure                    

// -----------------------------------------------------------------------------

//

void CTestStdlib::ReadIntParam(TInt &aInt)

{

	_LIT( Kparam, "Param%d" );

     TBuf<8> pNameBuf;

     TPtrC string;

     pNameBuf.Format(Kparam,++iParamCnt);

	 TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, aInt);

	 if(!res)

	 	{

	 	_LIT(Kerr , "Unable to retrieve integer parameter") ;

	 	INFO_PRINTF1(Kerr);

	  	}

	 return;

}	

// -----------------------------------------------------------------------------

//Function Name :malloc_Test0

//API Tested :malloc

//TestCase Description:malloc returns -> pointer to unitialized mem locn

// -----------------------------------------------------------------------------

TInt CTestStdlib::malloc_Test0()

    {

    INFO_PRINTF1(_L("In malloc_Test0L"));

    //--------------------------

	char  *pc = (char *)malloc( sizeof(char) * 3);

	//--------------------------

    INFO_PRINTF1(_L("{Expected: some char}"));

	if (pc == NULL)

		{

		INFO_PRINTF1(_L("malloc failed to allocate memory"));

		return KErrGeneral;

		}

	int i = 0;

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

		{

		INFO_PRINTF2(_L(" %c"), pc[i]);

		}

	free(pc);

	return KErrNone;

    }

// -----------------------------------------------------------------------------

//Function Name :malloc_Test1

//API Tested :malloc

//TestCase Description:malloc returns -> NULL

// -----------------------------------------------------------------------------

TInt CTestStdlib::malloc_Test1()

    {

    TInt ret = KErrNone;

    INFO_PRINTF1(_L("In malloc_Test1L"));

	errno = 0;

    //--------------------------

	char  *pc = (char *)malloc(1024 * 1024);	

    //--------------------------

    bool i = (pc == NULL);

	INFO_PRINTF2(_L("{Expected: 1} %d"), (int)i);

	free(pc);

	if (i != true || errno != ENOMEM)

		{

		INFO_PRINTF2(_L("errno was set to - %d"), errno);

		ret = KErrGeneral;

		}

	return ret;

    }

// -----------------------------------------------------------------------------

//Function Name :malloc_Test2

//API Tested :malloc

//TestCase Description:malloc returns -> NULL

// -----------------------------------------------------------------------------

TInt CTestStdlib::malloc_Test2()

    {

	TInt ret = KErrNone;

    INFO_PRINTF1(_L("In malloc_Test2L"));

    //--------------------------

	char  *pc = (char *)malloc(NULL);	

    //--------------------------

    bool i = (pc == NULL);

	INFO_PRINTF2(_L("{Expected: 1} %d"), (int)i);

	free(pc);

	if (i != true)

		{

		ret = KErrGeneral;

		}

	return ret;

    }

    // -----------------------------------------------------------------------------

//Function Name :calloc_Test0

//API Tested :calloc

//TestCase Description:calloc returns -> pointer to mem locn intialized to zero

// -----------------------------------------------------------------------------

TInt CTestStdlib::calloc_Test0()

    {

	TInt ret = KErrNone;

    INFO_PRINTF1(_L("In calloc_Test0L"));

    //--------------------------

	int  *pint = (int *)calloc(2, sizeof (int) * 2);

	//--------------------------

	if (pint == NULL)

		{

		INFO_PRINTF1(_L("calloc failed to allocate memory"));

		return KErrNoMemory;

		}

    INFO_PRINTF1(_L("{Expected: zeros}"));

	int i = 0;

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

		{

	   INFO_PRINTF2(_L(" %d"), pint[i]);

		}

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

		{

		if (pint[i] != 0)

			{

			ret = KErrGeneral;

			}

		}

	free(pint);

	return ret;

    }

// -----------------------------------------------------------------------------

//Function Name :calloc_Test1

//API Tested :calloc

//TestCase Description:calloc returns -> NULL

// -----------------------------------------------------------------------------

TInt CTestStdlib::calloc_Test1()

    {

    INFO_PRINTF1(_L("In calloc_Test1L"));

    //--------------------------

	char  *pc = (char *)calloc(3, 1024 * 1024);	

    bool i = (pc == NULL);

	//--------------------------

	INFO_PRINTF2(_L("{Expected: 1} %d"), (int)i);

	free(pc);

	if (i != true)

		{

		return KErrGeneral;

		}

    return KErrNone;

    }

// -----------------------------------------------------------------------------

//Function Name :calloc_Test2

//API Tested :calloc

//TestCase Description:calloc returns -> NULL

// -----------------------------------------------------------------------------

TInt CTestStdlib::calloc_Test2()

    {

    INFO_PRINTF1(_L("In calloc_Test2L"));

    //--------------------------

	char  *pc = (char *)calloc(0, 1);	

    bool i = (pc == NULL);

	//--------------------------

	INFO_PRINTF2(_L("{Expected: 1} %d"), (int)i);

	free(pc);

	if (i != true)

		{

		return KErrGeneral;

		} 

	return KErrNone;

    }

// -----------------------------------------------------------------------------

//Function Name :realloc_Test0

//API Tested :realloc

//TestCase Description:realloc returns -> pointer to mem locn with old contents

//unchanged and the new -unintialized.

// -----------------------------------------------------------------------------

TInt CTestStdlib::realloc_Test0()

    {

    INFO_PRINTF1(_L("In realloc_Test0L"));

    //--------------------------

	int  *pint = (int *)calloc(2, sizeof (int) * 2);

	pint = (int *)realloc(pint, (sizeof (int) * 6) );

	if (pint == NULL)

		{

		INFO_PRINTF1(_L("realloc failed to allocate memory"));

		return KErrNoMemory;

		}

	//--------------------------

    INFO_PRINTF1(_L("{Expected: zeros(4) and some uninitialized values}"));

	int i = 0;

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

		{

	   INFO_PRINTF2(_L(" %d"), pint[i]);

		}

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

		{

		if (pint[i] != 0)

			{

			free(pint);

			return KErrGeneral;

			}	

		}

	free(pint);

	return KErrNone;

	}

// -----------------------------------------------------------------------------

//Function Name :realloc_Test1

//API Tested :realloc

//TestCase Description:realloc returns -> pointer to mem locn with old contents

//unchanged and the new -unintialized.

// -----------------------------------------------------------------------------

TInt CTestStdlib::realloc_Test1()

    {

    INFO_PRINTF1(_L("In realloc_Test1L"));

    //--------------------------

	int  *pint = (int *)calloc(2, sizeof (int) * 2);

	pint = (int *)realloc(pint, (sizeof (int) ) );

	if (pint == NULL)

		{

		INFO_PRINTF1(_L("realloc failed to allocate memory"));

		return KErrNoMemory;

		}

	//--------------------------

    INFO_PRINTF1(_L("{Expected: zeros}"));

	int i = 0;

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

		{

	   INFO_PRINTF2(_L(" %d"), pint[i]);

		}

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

		{

		if (pint[i] != 0)

			{	

			free(pint);

			return KErrGeneral;

			}

		}

	free(pint);

	return KErrNone;

    }

// -----------------------------------------------------------------------------

//Function Name :realloc_Test2

//API Tested :realloc

//TestCase Description:realloc returns -> pointer that could be freed.

// -----------------------------------------------------------------------------

TInt CTestStdlib::realloc_Test2()

    {

    INFO_PRINTF1(_L("In realloc_Test2L"));

    //--------------------------

	int  *pint = (int *)calloc(1, sizeof(int) * 3);

	if (pint == NULL)

		{

		INFO_PRINTF1(_L("calloc failed to allocate memory"));

		return KErrNoMemory;

		}

	pint = (int *)realloc(pint, 0);

	//--------------------------

	INFO_PRINTF2(_L("{Expected: some int value} %d"), pint[0]);

	free(pint);

	return KErrNone;

    }

// -----------------------------------------------------------------------------

//Function Name :realloc_Test3

//API Tested :realloc

//TestCase Description:realloc returns -> pointer to mem locn unintialized.

// -----------------------------------------------------------------------------

TInt CTestStdlib::realloc_Test3()

    {

    INFO_PRINTF1(_L("In realloc_Test3L"));

    //--------------------------

	int  *pint = (int *)realloc(NULL, ( sizeof(int) * 2 ) );

	if (pint == NULL)

		{

		INFO_PRINTF1(_L("realloc failed to allocate memory"));

		return KErrNoMemory;

		}

	//--------------------------

    INFO_PRINTF1(_L("{Expected: some int values}"));

	int i = 0;

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

		{

	   INFO_PRINTF2(_L(" %d"), pint[i]);

		}

	free(pint);

	return KErrNone;

    }

// -----------------------------------------------------------------------------

//Function Name :realloc_Test4

//API Tested :realloc

//TestCase Description:realloc returns -> NULL but leaves the old mem block

//unchanged.

// -----------------------------------------------------------------------------

TInt CTestStdlib::realloc_Test4()

    {