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


/**
@file
@test
@internalComponent
*/

#include <bautils.h>
#include <test/appfwk_tmsteststep.h>
#include "f32file.h"
#include <e32std.h>


_LIT(KLogLocation,"c:\\logs\\testexecute\\TMS_Log.txt");
_LIT8(KLogPass," PASS");
_LIT8(KLogFail," FAIL");
_LIT8(KRet, "\n");
_LIT8 (KBlankSpace," ");

// Special notes about using this class
//
// In any derived CTxxxxStep class after the __CONSTRUCT_STEP__(xxxx) macro (generally at the end of the file)
// if the methods void CTxxxxxStep::TestSetupL() and void CTxxxxStep::TestClose() do not exist
// they should be added as follows :-
//
//	void CTxxxxStep::TestSetupL()
//		{
//		MultipleResultsForSameID(ETrue); // true or false set on test requirements
//		}
//
//	void CTxxxxStep::TestClose()
//		{
//		iTestStepNames.Close();
//		}
//
// if the methods do already exist add the MultipleResultsForSameID and iTestStepNames.Close lines to them respectivly
//

TInt CTmsTestStep::ReadNextLineL( RFile &aFile, TDes8 &aLine )
// read a cr/lf limiited line from the file,  assumes file is a valid file
// and that aLine is of sufficient length to hold the data
	{
	aLine.Zero();
	TBuf8<1> chr;
	for (;;)
		{
		aFile.Read(chr);
		if ( chr.Length() == 0 )
			{
			break;
			}
		if (chr.CompareF(KRet) == 0)
			{
			// got a line, exctract newline as well
			aFile.Read(chr);
			break;
			}
		else
			{
			aLine.Append(chr);
			}
		}

	return aLine.Length();
	}

void CTmsTestStep::CleanUpAndWriteResults()
	{
	RFs fs;
	fs.Connect();
	CleanupClosePushL(fs);

	iTestStepPositions.Close();
	if (iTestStepNames != NULL)
		{
		iTestStepNames->Reset();
		delete iTestStepNames;
		iTestStepNames = NULL;

		if (BaflUtils::FolderExists(fs, KLogLocation))
		   	{
			RFile file;
			if (BaflUtils::FileExists( fs, KLogLocation ))
				{
				// open the temporary tms log
				TInt err = file.Open( fs, KLogLocation, EFileRead|EFileShareAny);
			    if(err == KErrInUse)
			    	{
			       	CleanupStack::PopAndDestroy();
			       	return;
				   	}
			    if (err == KErrNone)
			    	{
			    	CleanupClosePushL(file);
			    	TBuf8<256> line;
			    	TBuf<250> testID;
			    	TBuf<6> testResult;
			    	// get a line from the temporary tms log
			    	while (CTmsTestStep::ReadNextLineL(file,line))
			    		{
			    		TInt blankPos = line.Find(KBlankSpace);

			    		// get the ID from the line
			    		testID.Copy(line.Left(blankPos));

			    		//get the pass or fail result from the line
			    		testResult.Copy(line.Mid(blankPos+1,4));

			    		// print into the standard tef log the id and the result in the correct format
			    		// so that they are correctly parsed into the TMS csv file
			    		INFO_PRINTF2(_L("START_TESTCASE %S"),&testID);
			    		INFO_PRINTF2(_L("Line = 1 Command = START_TESTCASE %S"),&testID);
			    		INFO_PRINTF2(_L("END_TESTCASE %S"),&testID);
			    		INFO_PRINTF3(_L("Line = 1 Command = END_TESTCASE %S ***TestCaseResult = %S"),&testID,&testResult);
			    		}
			    	CleanupStack::PopAndDestroy();
			    	}
			    // remove the temporary tms log
			    fs.Delete(KLogLocation);
			    }
			}
		}
	CleanupStack::PopAndDestroy();
	}

EXPORT_C CTmsTestStep::CTmsTestStep() : iStepPassFail(ETrue), iShowMultipleResults(EFalse)
	{
	iCurrentTestStepName.Copy(KUnknownSYMTestCaseIDName);
	iTestStepNames=new CDesCArrayFlat(1);
	RFs fs;
	fs.Connect();
	CleanupClosePushL(fs);
	if (BaflUtils::FolderExists(fs, KLogLocation))
		   {
		   if (BaflUtils::FileExists( fs, KLogLocation ))
			   {
			   // remove the temporary tms log
			   fs.Delete(KLogLocation);
			   }
		   }
	CleanupStack::PopAndDestroy();
	}

EXPORT_C void CTmsTestStep::CloseTMSGraphicsStep()
	{
	CTmsTestStep::CleanUpAndWriteResults();

	}

EXPORT_C CTmsTestStep::~CTmsTestStep()
	{
	CTmsTestStep::CleanUpAndWriteResults();
	}

// writes out the results of a test that has just been executed to the log file(s)
// the first time a test result is written it is also added to the iTestStepNames array.
// This array is then checked on subsequent tests to see if the test has already been written to log
// if it has and multiple test results are not wanted further logging of this test is omitted.


void CTmsTestStep::DebugLogL(const TDesC8& aTestCaseID, const TDesC8& aResult, TInt aPos = -1)
	{
    TInt pos = 0;
	RFs fs;
	fs.Connect();
	CleanupClosePushL(fs);

	if (BaflUtils::FolderExists(fs, KLogLocation))
	   {
		RFile file;
		if (!BaflUtils::FileExists( fs, KLogLocation ))
			{
		    User::LeaveIfError( file.Create( fs, KLogLocation, EFileWrite|EFileShareAny));
			}
		else
			{
		    TInt err = file.Open( fs, KLogLocation, EFileWrite|EFileShareAny);
		    if(err == KErrInUse)
			   {
		       CleanupStack::PopAndDestroy();
			   return;
			   }
		    if (aPos == -1)
		    	file.Seek(ESeekEnd, pos);
		    else
		    	file.Seek(ESeekCurrent, aPos);
	        }
			file.Write(aTestCaseID);
			file.Write(aResult);
			file.Write(_L8("\r\n "));
			file.Flush();
			file.Close();
	   }
		CleanupStack::PopAndDestroy();
	}

TInt CTmsTestStep::DebugLogPosL()
	{
    TInt pos = 0;
    TInt pos1 = 0;
	RFs fs;
	fs.Connect();
	CleanupClosePushL(fs);

	if (BaflUtils::FolderExists(fs, KLogLocation))
	   {
		RFile file;
		if (!BaflUtils::FileExists( fs, KLogLocation ))
			{
		    User::LeaveIfError( file.Create( fs, KLogLocation, EFileWrite|EFileShareAny));
			}
		else
			{
		    TInt err = file.Open( fs, KLogLocation, EFileWrite|EFileShareAny);
		    if(err == KErrInUse)
			   {
		       CleanupStack::PopAndDestroy();
			   return KErrGeneral;
			   }
		    file.Seek(ESeekEnd, pos);
		    file.Seek(ESeekCurrent, pos1);
		    file.Close();
	        }


	   }
	   CleanupStack::PopAndDestroy();
	   return pos1;
	}

EXPORT_C void CTmsTestStep::RecordTestResultL()
	{
	TBuf<64> unknownTMSID(KUnknownSYMTestCaseIDName);
	TBuf8<64> unknownID8;
	unknownID8.Copy(unknownTMSID);

	TBuf<64> undefinedTMSID(KUndefinedSYMTestCaseIDName);
	TBuf8<64> undefinedID8;
	undefinedID8.Copy(undefinedTMSID);

	TBuf<64> notaTMSID(KNotATestSYMTestCaseIDName);
	TBuf8<64> notaID8;
	notaID8.Copy(notaTMSID);

	TBuf<128> currentTSName;
	currentTSName.Copy(iCurrentTestStepName);

	if (iCurrentTestStepName.Compare(unknownID8) == 0) 	// unknown tests logged to warning file
		{
		INFO_PRINTF1(_L("ID NOT SET"));
		}
	else if (iCurrentTestStepName.Compare(undefinedID8) == 0)	// undefined tests logged to warning file
		{
		INFO_PRINTF1(_L("ID UNDEFINED"));
		}
	else if (iCurrentTestStepName.Compare(notaID8) == 0)
		{
		}
	else if(iShowMultipleResults)	// multiple results for same test should be logged
		{
		if( iStepPassFail == EFalse)
			{
			INFO_PRINTF2(_L("%S FAILED"), &currentTSName );
			DebugLogL(iCurrentTestStepName, KLogFail);
			}
		else
			{
			INFO_PRINTF2(_L("%S PASSED"), &currentTSName );
			DebugLogL(iCurrentTestStepName, KLogPass);
			}
		}
	else if (!iShowMultipleResults)
		{
		TInt existsInArray;
		if (iTestStepNames == NULL)
			iTestStepNames=new CDesCArrayFlat(1);

		if( iTestStepNames->Find(currentTSName,existsInArray) == 0)
			{
			if( iStepPassFail == EFalse)
				{
					INFO_PRINTF2(_L("%S FAILED"), &currentTSName );
					DebugLogL(iCurrentTestStepName, KLogFail, iTestStepPositions[existsInArray] );
				}
			}
		else
			{
			iTestStepPositions.AppendL(DebugLogPosL());
			iTestStepNames->AppendL(currentTSName);

			if( iStepPassFail == EFalse)
				{
					INFO_PRINTF2(_L("%S FAILED"), &currentTSName );
					DebugLogL(iCurrentTestStepName, KLogFail );
				}
				else
				{
					INFO_PRINTF2(_L("%S PASSED"), &currentTSName );
					DebugLogL(iCurrentTestStepName, KLogPass);
				}
			}
		}
	}

// sets the name and pass/fail state of the individual test that is about to be executed
EXPORT_C void CTmsTestStep::SetTestStepID(const TDesC& aStepName)
	{
	iCurrentTestStepName.Copy(aStepName);
	iStepPassFail = ETrue;
	}

EXPORT_C void CTmsTestStep::SetOverallTestStepID(const TDesC& aStepName)
	{
	iCurrentTestStepName.Copy(aStepName);
	iStepPassFail = ETrue;
	if (!TestStepResult() == EPass)
				TEST(EFalse);
	}

// needed for the overide of CTGraphicsBase::testBooleanTrue to allow us to set
// whether an individual test has passed or failed
EXPORT_C void CTmsTestStep::MQCTest(TBool aCondition, const TText8* aFile, TInt aLine)
	{
	if(!aCondition)
		{
		iStepPassFail = EFalse;
		}
	testBooleanTrue( aCondition, aFile, aLine, ETrue);
	}

// needed for the overide of CTGraphicsBase::testBooleanTrue to allow us to set
// whether an individual test has passed or failed
EXPORT_C void CTmsTestStep::MQCTestL(TBool aCondition, const TText8* aFile, TInt aLine)
	{
	if(!aCondition)
		{
		iStepPassFail = EFalse;
		}
	testBooleanTrueL( aCondition, aFile, aLine, ETrue);
	}

// sets whether tests with the same @SYMTestCaseID xxxxxx name are printed multiple times in the log files
EXPORT_C void CTmsTestStep::MultipleResultsForSameID(TBool aShowMultipleResults)
	{
	iShowMultipleResults = aShowMultipleResults;
	}