/*

* 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:

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <unistd.h> 

#include <fcntl.h> 

#include <errno.h>

#include <string.h>

#include "testpipe.h"

#include <stdio.h>

#include <sys/select.h>

#include <sys/wait.h>

#include <stdlib.h>

#include <sys/types.h>

#include <string.h>

#include <pthread.h>

#include <wchar.h>

#include <test/testexecutestepbase.h>

#include <test/testexecuteserverbase.h>

#define MAX_SIZE 	50

#define TEST_PIPE_VAL(val, exp, text)				  {\

												if ((val==exp)) \

													{ \

													INFO_PRINTF1(text); \

													INFO_PRINTF1(_L("...passed"));\

													} \

												else \

													{ \

													ERR_PRINTF1(text); \

													ERR_PRINTF3(_L("...failed with Actual: %d Expected: %d"),(val), (exp));\

													return EFail;\

													}\

												}

#define TEST_PIPE_COND(cond, text)				  {\

												if ((cond)) \

													{ \

													INFO_PRINTF1(text); \

													INFO_PRINTF1(_L("...passed"));\

													} \

												else \

													{ \

													ERR_PRINTF1(text); \

													ERR_PRINTF1(_L("...failed"));\

													return EFail;\

													}\

												}

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

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

// CTestPipe::Pipe

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

//

TInt CTestPipe::TestPipe(  )

	{

	INFO_PRINTF1(_L("Test Pipe"));

	int fds[2];

    TInt err = pipe (fds);

    if ( err < 0)

        {

         INFO_PRINTF1(_L("pipe():Error"));        

        }

    else

    	{

    	err = close(fds[0]);

    	err = close(fds[1]);	

    	}

    return err;

	}

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

// CTestPipe::PipeCheckWriteOnReadfd

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

//

TInt CTestPipe::PipeCheckWriteOnReadfd(  )

	{

	_LIT(KFunc, "PipeCheckWriteonReadfd");

	INFO_PRINTF1(KFunc);

	int fds[2];

    const char* buf = "somejunk";

    TInt err = pipe (fds);

    if ( err < 0)

        {

         INFO_PRINTF1(_L("Pipe Error!"));        

         return err;

        }

    err = write(fds[0], buf, 9); // write on the read desc

    if(err < 0 && errno == EBADF)

    {

       err = KErrNone;

    }

    else

    {

       INFO_PRINTF1( KFunc());

	   err = KErrGeneral;

    }

    close(fds[0]);

    close(fds[1]);    

    INFO_PRINTF1(KFunc());

    return err;

	}

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

// CTestPipe::PipeCheckReadOnWritefd

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

//

TInt CTestPipe::PipeCheckReadOnWritefd()

	{

	_LIT(KFunc, "PipeCheckReadOnWritefd");

	INFO_PRINTF1(KFunc);

	int fds[2];

    char buf[128];

    TInt err = pipe (fds);

    if ( err < 0)

        {

         INFO_PRINTF1(_L("Pipe Error!"));        

         return err;

        }

    err = read(fds[1], buf, 128); // read on the write desc

    if(err < 0 && errno == EBADF)

    	{

       err = KErrNone;

    	}

    else

    	{

       INFO_PRINTF1( KFunc());

	   err = KErrGeneral;

    	}

    close(fds[0]);

    close(fds[1]);    

    INFO_PRINTF1( KFunc());

    return err;

	}

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

// CTestPipe::PipeWriteRead

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

//

TInt CTestPipe::PipeWriteRead(  )

	{

	_LIT(KFunc, "PipeWriteRead");

	INFO_PRINTF1(KFunc);

	int fd[2];

    const char* bufW = "somejunk";

    char bufR[128];

    TInt err = pipe (fd);

    if ( err < 0)

        {

         INFO_PRINTF1( _L("Pipe Error!"));        

         return err;

        }

    err = write(fd[1], bufW, 9); 

    if(err < 0)

    	{

       	INFO_PRINTF1(_L("Write Error!"));

       	close(fd[0]);

       	close(fd[1]);

       	return err;

    	}

    err = read(fd[0], bufR, 128 );

    if(err < 0)

    	{

       INFO_PRINTF1(_L("Read Error!"));

       close(fd[0]);

       close(fd[1]);

       return err;

    	}

    if(strcmp(bufW, bufR) != 0)

    	{

    	err = KErrGeneral;

    	INFO_PRINTF1( KFunc());

    	}

    else

    	{

    	err = KErrNone;

    	}

    close(fd[0]);

    close(fd[1]);    

    return err;

	}

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

// CTestPipe::PipeCheckWriteFd

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

//

TInt CTestPipe::PipeCheckWriteFd(  )

	{

	_LIT(KFunc, "PipeCheckFd");

	INFO_PRINTF1(KFunc);

	int fds[2];

    const char* buf = "somejunk";

    TInt err = pipe (fds);

    if ( err < 0)

        {

         INFO_PRINTF1 (_L("Pipe() Error!"));        

         return err;

        }

    TInt saved_fd = fds[1];

    fds[1] = 99; // change value of the returned write fd

    err = write(fds[1], buf, 9);

    if(err < 0 && errno == EBADF)

    	{

       	err = KErrNone;

    	}

    else

    	{

		INFO_PRINTF1(_L("Write Error!")) ;      

	    err = KErrGeneral;

    	}

    close(fds[0]);

    close(saved_fd);        

    return err;

	}

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

// CTestPipe::PipeCheckReadFd

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

//

TInt CTestPipe::PipeCheckReadFd(  )

	{

	_LIT(KFunc, "PipeCheckReadFd");

	INFO_PRINTF1(KFunc);

	int fds[2];

    char buf[128];

    TInt err = pipe (fds);

    if ( err < 0)

        {

         INFO_PRINTF1( _L("Pipe() Error!"));        

         return err;

        }

    TInt saved_fd = fds[0];    

    fds[0] = 99; // change value of the returned read fd

    err = read(fds[0], buf, 128);

    if(err < 0 && errno == EBADF)

    	{

       err = KErrNone;

    	}

    else

    	{

       INFO_PRINTF1 (_L("Read Error!"));

	   err = KErrGeneral;

    	}

    close(saved_fd);

    close(fds[1]);        

    return err;

	}

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

// CTestPipe::PopenPipeCommandRead

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

// Tests the popen() by creating a child process and reading message from it.

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

TInt CTestPipe::PopenPipeCommandRead()

	{	

	_LIT(KCommand,	"Command");		

	TBufC<MAX_SIZE> bcommand;

	TPtrC pcommand = bcommand;	

	/*read the command from data file*/

	TBool alright = GetStringFromConfig(ConfigSection(),KCommand, pcommand);

	TBuf8<MAX_SIZE> buf;

	buf.Copy(pcommand);	

	char* command=(char*)buf.Ptr();

	command[buf.Length()]='\0';

	char mode='r';

	char readbuf[100];

	FILE* fp = popen(command, &mode); /*create a child process and a pipe for reading*/	

	TEST_PIPE_COND( (fp!=NULL), _L("popen()..."));

	/*read data into the buffer using the file pointer*/

	fgets(readbuf, sizeof (readbuf), fp);			

	/*close the opened pipe*/

	TInt ret=pclose(fp);

	TEST_PIPE_VAL(ret,0, _L("pclose()..."));	

	return EPass;

	}

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

// CTestPipe::MultiplePopenPipeCommandRead

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

TInt CTestPipe::MultiplePopenPipeCommandRead()

	{	

	_LIT(KCommand,	"Command1");		

	TBufC<MAX_SIZE> bcommand;

	TPtrC pcommand = bcommand;	

	/*read the command from data file*/

	TBool alright = GetStringFromConfig(ConfigSection(),KCommand, pcommand);

	TBuf8<MAX_SIZE> buf;

	buf.Copy(pcommand);	

	char* command=(char*)buf.Ptr();

	command[buf.Length()]='\0';

	char mode='r';

	char readbuf[100];

	FILE* fp = popen(command, &mode); /*create a child process and a pipe for reading*/	

	TEST_PIPE_COND( (fp!=NULL), _L("popen()..."));

	/*read data into the buffer using the file pointer*/

	fgets(readbuf, sizeof (readbuf), fp);			

	/*close the opened pipe*/

	TInt ret=pclose(fp);

	fp = popen(command, &mode); /*create a child process and a pipe for reading*/	

	TEST_PIPE_COND( (fp!=NULL), _L("popen()..."));

	/*read data into the buffer using the file pointer*/

	fgets(readbuf, sizeof (readbuf), fp);				

	/*close the opened pipe*/

	ret=pclose(fp);

	TEST_PIPE_VAL(ret,0, _L("pclose()..."));	

	fp = popen(command, &mode); /*create a child process and a pipe for reading*/	

	TEST_PIPE_COND( (fp!=NULL), _L("popen()..."));

	/*read data into the buffer using the file pointer*/

	fgets(readbuf, sizeof (readbuf), fp);				

	/*close the opened pipe*/

	ret=pclose(fp);

	TEST_PIPE_VAL(ret,0, _L("pclose()..."));	

	fp = popen(command, &mode); /*create a child process and a pipe for reading*/	

	TEST_PIPE_COND( (fp!=NULL), _L("popen()..."));

	/*read data into the buffer using the file pointer*/

	fgets(readbuf, sizeof (readbuf), fp);			

	/*close the opened pipe*/

	ret=pclose(fp);

	TEST_PIPE_VAL(ret,0, _L("pclose()..."));		

	fp = popen(command, &mode); /*create a child process and a pipe for reading*/	

	TEST_PIPE_COND( (fp!=NULL), _L("popen()..."));

	/*read data into the buffer using the file pointer*/

	fgets(readbuf, sizeof (readbuf), fp);				

	/*close the opened pipe*/

	ret=pclose(fp);

	TEST_PIPE_VAL(ret,0, _L("pclose()..."));		

	return EPass;

	}	

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

// CTestPipe::PopenPipeOEExeRead

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

// tests popen for a OE exe(entry thru main()).

TInt CTestPipe::PopenPipeOEExeRead()

	{	

	_LIT(KCommand2,	"Command2");		

	TBufC<MAX_SIZE> bcommand2;

	TPtrC pcommand2 = bcommand2;	

	/*read the command from data file*/

	GetStringFromConfig(ConfigSection(),KCommand2, pcommand2);

	TBuf8<MAX_SIZE> buf2;

	buf2.Copy(pcommand2);	

	char* command2=(char*)buf2.Ptr();

	command2[buf2.Length()]='\0';

	char mode='r';	

	char readbuf2[100];

	FILE* fp = popen(command2, &mode); /*create a child process and a pipe for reading*/	

	TEST_PIPE_COND( (fp!=NULL), _L("popen()..."));

	/*read data into the buffer using the file pointer*/

	fgets(readbuf2, sizeof (readbuf2), fp);		

	/*close the opened pipe*/

	TInt ret=pclose(fp);

	TEST_PIPE_VAL(ret,0, _L("pclose()..."));	

	return EPass;

	}

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

// CTestPipe::PopenPipeInvalidPathRead

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

// tests popen for executable not in //sys//bin

TInt CTestPipe::PopenPipeInvalidPathRead()

	{	

	_LIT(KCommand3,	"Command3");		

	TBufC<MAX_SIZE> bcommand3;

	TPtrC pcommand3 = bcommand3;	

	/*read the command from data file*/

	GetStringFromConfig(ConfigSection(),KCommand3, pcommand3);

	TBuf8<MAX_SIZE> buf3;

	buf3.Copy(pcommand3);	

	char* command3=(char*)buf3.Ptr();

	command3[buf3.Length()]='\0';

	char mode='r';	

	FILE* fp = popen(command3, &mode); /*create a child process and a pipe for reading*/	

	TEST_PIPE_COND( (fp==NULL), _L("popen()..."));

	/*close the opened pipe*/

	TInt ret=pclose(fp);

	TEST_PIPE_VAL(ret,-1, _L("pclose()..."));	

	return EPass;

	}

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

// CTestPipe::PopenPipeInvalidCommandAndModeRead

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

// tests popen with invalid arguments

TInt CTestPipe::PopenPipeInvalidCommand()

	{

    /*tests the invalid command*/

	_LIT(KInvalidCmd,	"InvalidCommand");			

	TBufC<MAX_SIZE> invcommand;

	TPtrC pinvcommand = invcommand;			

	GetStringFromConfig(ConfigSection(),KInvalidCmd, pinvcommand);	

	TBuf8<MAX_SIZE> bufinv;

	bufinv.Copy(pinvcommand);	

	char* ptrinvcommand=(char*)bufinv.Ptr();

	ptrinvcommand[bufinv.Length()]='\0';

	char mode='r';

	FILE* fp=popen(ptrinvcommand, &mode); /*create a child process and a pipe for reading*/	

	TEST_PIPE_COND(fp==NULL, _L("popen()..."));

	TInt ret=pclose(fp);

	TEST_PIPE_VAL(ret,-1, _L("pclose()..."));	

	return EPass;

	}	

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

// CTestPipe::PopenPipeInvalidMode

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

TInt CTestPipe::PopenPipeInvalidMode()

	{

	_LIT(KCommand1,	"Command1");		

	TBufC<MAX_SIZE> bcommand1;

	TPtrC pcommand1 = bcommand1;	

	/*read the command from data file*/

	GetStringFromConfig(ConfigSection(),KCommand1, pcommand1);

	TBuf8<MAX_SIZE> buf1;

	buf1.Copy(pcommand1);	

	char* command1=(char*)buf1.Ptr();

	command1[buf1.Length()]='\0';

	char* rwmode="x";

	FILE* fp = popen(command1, rwmode); /*create a child process and a pipe for reading*/	

	TEST_PIPE_COND( (fp==NULL), _L("popen()..."));

    TInt ret=pclose(fp);

	TEST_PIPE_VAL(ret,-1, _L("pclose()..."));		

	return EPass;