/*

* Copyright (c) 2002 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:  AudioInputStreamTestApp class member functions

*

*/

// INCLUDE FILES

#include <Stiftestinterface.h>

#include "AudioStreamTestApp.h"

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

// Input Stream Test Cases

const TInt CAudioStreamTestApp::KTestCaseInputNew=301;

const TInt CAudioStreamTestApp::KTestCaseInputNewWithParam=302;

const TInt CAudioStreamTestApp::KTestCaseInputSetAudioProperties=303;

const TInt CAudioStreamTestApp::KTestCaseInputSetGain=304;

const TInt CAudioStreamTestApp::KTestCaseInputSetBalance=305;

const TInt CAudioStreamTestApp::KTestCaseInputSetPriority=306;

const TInt CAudioStreamTestApp::KTestCaseInputSetDataType=307;

const TInt CAudioStreamTestApp::KTestCaseInputOpen=308;

const TInt CAudioStreamTestApp::KTestCaseInputRecord=309;

const TInt CAudioStreamTestApp::KTestCaseInputBitRate=310;

// Output Stream Test Cases

const TInt CAudioStreamTestApp::KTestCaseOutputNew=351;

const TInt CAudioStreamTestApp::KTestCaseOutputNewWithParam=352;

const TInt CAudioStreamTestApp::KTestCaseOutputSetAudioProperties=353;

const TInt CAudioStreamTestApp::KTestCaseOutputOpen=354;

const TInt CAudioStreamTestApp::KTestCaseOutputSetVolume=355;

const TInt CAudioStreamTestApp::KTestCaseOutputSetPriority=356;

const TInt CAudioStreamTestApp::KTestCaseOutputPlay=357;

const TInt CAudioStreamTestApp::KTestCaseOutputSetBalance=358;

const TInt CAudioStreamTestApp::KTestCaseOutputSetDataType=359;

const TInt CAudioStreamTestApp::KTestCaseOutputStop=360;

const TInt CAudioStreamTestApp::MAX_TESTCASE_ID=360;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

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

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

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

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

//

/*

?type ?function_name(

    ?arg_type arg,  // ?description

    ?arg_type arg)  // ?description

    {

    ?code  // ?comment

    // ?comment

    ?code

    }

*/

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

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

// CAudioStreamTestApp::CAudioStreamTestApp

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CAudioStreamTestApp::CAudioStreamTestApp()

    {

	iErrName[0].Copy(_L("KErrNone"));

	iErrName[1].Copy(_L("KErrNotFound"));

	iErrName[2].Copy(_L("KErrGeneral"));

	iErrName[3].Copy(_L("KErrCancel"));

	iErrName[4].Copy(_L("KErrNoMemory"));

	iErrName[5].Copy(_L("KErrNotSupported"));

	iErrName[6].Copy(_L("KErrArgument"));

	iErrName[7].Copy(_L("KErrTotalLossOfPrecision"));

	iErrName[8].Copy(_L("KErrBadHandle"));

	iErrName[9].Copy(_L("KErrOverflow"));

	iErrName[10].Copy(_L("KErrUnderflow"));

	iErrName[11].Copy(_L("KErrAlreadyExists"));

	iErrName[12].Copy(_L("KErrPathNotFound"));

	iErrName[13].Copy(_L("KErrDied"));

	iErrName[14].Copy(_L("KErrInUse"));

	iErrName[15].Copy(_L("KErrServerTerminated"));

	iErrName[16].Copy(_L("KErrServerBusy"));

	iErrName[17].Copy(_L("KErrCompletion"));

	iErrName[18].Copy(_L("KErrNotReady"));

	iErrName[19].Copy(_L("KErrUnknown"));

	iErrName[20].Copy(_L("KErrCorrupt"));

	iErrName[21].Copy(_L("KErrAccessDenied"));

	iErrName[22].Copy(_L("KErrLocked"));

	iErrName[23].Copy(_L("KErrWrite"));

	iErrName[24].Copy(_L("KErrDisMounted"));

	iErrName[25].Copy(_L("KErrEof"));

	iErrName[26].Copy(_L("KErrDiskFull"));

	iErrName[27].Copy(_L("KErrBadDriver"));

	iErrName[28].Copy(_L("KErrBadName"));

	iErrName[29].Copy(_L("KErrCommsLineFail"));

	iErrName[30].Copy(_L("KErrCommsFrame"));

	iErrName[31].Copy(_L("KErrCommsOverrun"));

	iErrName[32].Copy(_L("KErrCommsParity"));

	iErrName[33].Copy(_L("KErrTimedOut"));

	iErrName[34].Copy(_L("KErrCouldNotConnect"));

	iErrName[35].Copy(_L("KErrCouldNotDisconnect"));

	iErrName[36].Copy(_L("KErrDisconnected"));

	iErrName[37].Copy(_L("KErrBadLibraryEntryPoint"));

	iErrName[38].Copy(_L("KErrBadDescriptor"));

	iErrName[39].Copy(_L("KErrAbort"));

	iErrName[40].Copy(_L("KErrTooBig"));

	iErrName[41].Copy(_L("KErrDivideByZero"));

	iErrName[42].Copy(_L("KErrBadPower"));

	iErrName[43].Copy(_L("KErrDirFull"));

	iErrName[44].Copy(_L("KErrHardwareNotAvailable"));

	iErrName[45].Copy(_L("KErrSessionClosed"));

	iErrName[46].Copy(_L("KErrPermissionDenied"));

    }

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

// CAudioStreamTestApp::ConstructL

// Symbian 2nd phase constructor can leave.

// Note: If OOM test case uses STIF Logger, then STIF Logger must be created

// with static buffer size parameter (aStaticBufferSize). Otherwise Logger 

// allocates memory from heap and therefore causes error situations with OOM 

// testing. For more information about STIF Logger construction, see STIF Users 

// Guide.

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

//

void CAudioStreamTestApp::ConstructL()

    {

	if ( ! iScheduler) 

		{

		iScheduler = new (ELeave) CActiveScheduler;

		CActiveScheduler::Install(iScheduler); // install as active scheduler

		}

    }

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

// CAudioStreamTestApp::NewL

// Two-phased constructor.

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

//

CAudioStreamTestApp* CAudioStreamTestApp::NewL()

    {

    CAudioStreamTestApp* self = new (ELeave) CAudioStreamTestApp;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CAudioStreamTestApp::~CAudioStreamTestApp()

    { 

    delete iLogger;

	delete iScheduler;

    }

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

// CAudioStreamTestApp::InitL

// InitL is used to initialize the Test Module.

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

//

TInt CAudioStreamTestApp::InitL( 

    TFileName& aIniFile, 

    TBool /*aFirstTime*/ )

    {

	CStifParser *parser;

	RDebug::Print(_L("CAudioStreamTestApp::InitL:"));

	TParsePtrC fp(aIniFile);

	//fp.Set();

	parser = CStifParser::NewL(fp.DriveAndPath() , fp.NameAndExt() );

	CleanupStack::PushL(parser);

	if (parser) 

		{

		RDebug::Print(_L("CAudioStreamTestApp::InitL: parser is not null"));

		CStifSectionParser *section;

		section = parser->SectionL(KSectionStart, KSectionEnd);

		CleanupStack::PushL(section);

		TPtrC logFileName;

		TPtrC logPath;

		if (section) 

			{

			RDebug::Print(_L("CAudioStreamTestApp::InitL: section is not null"));

			if ( (section->GetLine(KLogFileTag, logFileName, ENoTag) == KErrNone)  && (section->GetLine(KLogPathTag, logPath, ENoTag) == KErrNone) ) 

				{

				RDebug::Print(_L("CAudioStreamTestApp::InitL: InitLoggerL(logPath, logFileName);"));

				InitLoggerL(logPath, logFileName);

				}			

			}

		if (!iLogger) 

			{

			RDebug::Print(_L("CAudioStreamTestApp::InitL: InitLoggerL(); again"));

			InitLoggerL();

			}

		iLogger->Log(KOpeningLogFilepath, &logPath);

		iLogger->Log(KLoggerStarted, &aIniFile);

		CleanupStack::PopAndDestroy(section);	//section

		}

	CleanupStack::PopAndDestroy(parser);	//parser

    return KErrNone;

    }

/* -------------------------------------------------------------------------------

    Class: CMmfTsPlay

    Method: InitLoggerL

    Description: Initialize the logger for this test module

    Parameters:	File name where to append data

    Return Values: Error value

    Errors/Exceptions: <description how errors and exceptions are handled>

    Status: Draft

------------------------------------------------------------------------------- */

void CAudioStreamTestApp::InitLoggerL( const TFileName& aLogPath , const TFileName& aLogFile)

    {

		iLogger = CStifLogger::NewL(aLogPath, aLogFile, CStifLogger::ETxt, CStifLogger::EFile, EFalse) ;

		if (  ! iLogger  ) 

			{

			RDebug::Print(_L("CAudioStreamTestApp::InitL: InitLoggerL(); with filename failed"));

			InitLoggerL();

			}

    }

void CAudioStreamTestApp::InitLoggerL() 

	{

	RDebug::Print(_L("CAudioStreamTestApp::InitL: InitLoggerL(); with default"));

	iLogger = CStifLogger::NewL(KDefLogPath, KDefLogFile, CStifLogger::ETxt, CStifLogger::EFile, EFalse);

	}

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

// CAudioStreamTestApp::GetTestCasesL

// GetTestCases is used to inquire test cases from the Test Module. Test

// cases are stored to array of test cases. The Test Framework will be 

// the owner of the data in the RPointerArray after GetTestCases return

// and it does the memory deallocation. 

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

//

TInt CAudioStreamTestApp::GetTestCasesL( 

    const TFileName& aConfig, 

    RPointerArray<TTestCaseInfo>& aTestCases )

    {

   //Get a parser for the config file

	iLogger->Log(KOpeningConfig, &aConfig);

	if (! aConfig.Length() ) {

		iLogger->Log(KConfigRequired() );

		return KErrConfigInvalid;

	}

	TParsePtrC fp(aConfig);

	CStifParser *parser = CStifParser::NewL(fp.DriveAndPath() , fp.NameAndExt() );

	CleanupStack::PushL(parser);

	//Get a section parser

	CStifSectionParser *section;

	TInt x = 0;

	//Read all cases in config file

	//while ( section = parser->SectionL(KTestCaseConfigStart , KTestCaseConfigEnd, x++) )

	while ( (section = parser->NextSectionL(KTestCaseConfigStart , KTestCaseConfigEnd) ),section  )	// use comma to avoid warning

		{

		CleanupStack::PushL(section);

		TInt id = -1;

		TPtrC TestCaseTitle;

		TInt ErrorResult = KErrNone;

		CStifItemParser *item;

		item = section->GetItemLineL(KTagId);

		if (item) 

			{

			CleanupStack::PushL(item);

			if (!item->GetInt(KTagId, id)) 

				{

				ErrorResult = section->GetLine(KTagTitle, TestCaseTitle, ENoTag);

				if (!ErrorResult) {iLogger->Log( _L("Adding case: (%d) %S") , id, &TestCaseTitle ); }

				}

			else

				{

				id = -1;

				}

			CleanupStack::PopAndDestroy(item);	//item

			}

		if (0<id && id<=MAX_TESTCASE_ID)

			{

			TTestCaseInfo* testCase = new ( ELeave ) TTestCaseInfo();

			CleanupStack::PushL( testCase );

			testCase->iCaseNumber = x++;

			testCase->iTitle.Format(KTestCaseTitleFormat, id, &TestCaseTitle);	//testCase->iTitle.Copy( KTestCaseTitleFormat() );

			User::LeaveIfError( aTestCases.Append( testCase ) );

			CleanupStack::Pop( testCase );	//testCase

			}

		CleanupStack::PopAndDestroy(section);	//section

		}

	CleanupStack::PopAndDestroy(parser);	//parser

    return KErrNone;

    }

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

// CAudioStreamTestApp::RunTestCaseL

// RunTestCaseL is used to run an individual test case specified 

// by aTestCase. Test cases that can be run may be requested from 

// Test Module by GetTestCases method before calling RunTestCase.

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

//

TInt CAudioStreamTestApp::RunTestCaseL(

    const TInt aCaseNumber,

    const TFileName& aConfig,

    TTestResult& aResult )

    {

	TInt id=-1;

	//Get a parser for the config file

	iLogger->Log(KOpeningConfig, &aConfig);

	if (! aConfig.Length() ) {

		iLogger->Log(KConfigRequired() );

		aResult.iResultDes.Copy(KConfigRequired());

		aResult.iResult = KErrNotExecuted;

		return KErrConfigInvalid;

	}

	TParsePtrC fp(aConfig);

	iLogger->Log(_L("Opening configuration file [%S], case #%d"), &aConfig, aCaseNumber);

	CStifParser *parser = CStifParser::NewL(fp.DriveAndPath() , fp.NameAndExt() );

	CleanupStack::PushL(parser);

	//Get a section parser

	TInt retVal=0;

	CStifSectionParser *section=0;

	CStifItemParser *item=0;

	section = parser->NextSectionL(KTestCaseConfigStart , KTestCaseConfigEnd, aCaseNumber+1);

	if (section) {

		CleanupStack::PushL(section);

		item = section->GetItemLineL(KTagId);

		if (item) {

			CleanupStack::PushL(item);

			if (!item->GetInt(KTagId, id)) {

				TPtrC TestCaseTitle;

				TInt TitleErrorResult = section->GetLine(KTagTitle, TestCaseTitle, ENoTag);

				if (!TitleErrorResult) {iLogger->Log( _L("Executing test case (%d) %S") , id, &TestCaseTitle ); }

				//Call Funtion to perform test

				__UHEAP_MARK;

				TRAPD(error, retVal = RunTestCaseFunctionL(id, section, aResult););

                                REComSession::FinalClose();

				__UHEAP_MARKEND;

				if (error)

					{

					retVal = KErrLeft;

					aResult.iResult=error;

					aResult.iResultDes.Copy( KTestCaseResultLeft() );

					}				

				iLogger->Log( _L("Finished Executing test case (%d)"), id);

				iLogger->Log( _L("  Error code (%d)"), retVal);

				iLogger->Log( _L("  aResult.iResult=(%d)") , aResult.iResult);

				iLogger->Log( _L("  aResult.iResultDes=(%S)\r\n") , &aResult.iResultDes);

			} else {

				id=-1;

			}

			CleanupStack::PopAndDestroy(item);

		}		

		CleanupStack::PopAndDestroy(section);

	}

	CleanupStack::PopAndDestroy(parser);

	if (-1!=id) 

	{

		return retVal;

	}

	iLogger->Log(KConfigInvalid() );

	aResult.iResultDes.Copy(KConfigInvalid());

	aResult.iResult = KErrNotFound;

    return KErrNotFound;

    }

TInt CAudioStreamTestApp::RunTestCaseFunctionL(TInt id, CStifSectionParser *section, TTestResult &aResult) 

	{

	TInt retValue=KErrConfigInvalid;

	aResult.iResult=KErrNotExecuted;

	switch (id)

		{

		// Audio Input Stream Test Cases

		case KTestCaseInputNew:

		    retValue = TestCaseInputNewL(section, aResult);

		    break;

		case KTestCaseInputNewWithParam:

		    retValue = TestCaseInputNewWithParamL(section, aResult);

		    break;

		case KTestCaseInputSetAudioProperties:

		    retValue = TestCaseInputSetPropL(section, aResult);

		    break;

		case KTestCaseInputSetGain:

		    retValue = TestCaseInputSetGainL(section, aResult);

		    break;

		case KTestCaseInputSetBalance:

		    retValue = TestCaseInputSetBalanceL(section, aResult);

		    break;

		case KTestCaseInputSetPriority:

		    retValue = TestCaseInputSetPriorityL(section, aResult);

		    break;

		case KTestCaseInputSetDataType:

		    retValue = TestCaseInputSetDataTypeL(section, aResult);

		    break;

		case KTestCaseInputOpen:

		    retValue = TestCaseInputOpenL(section, aResult);

		    break;

		case KTestCaseInputRecord:

		    retValue = TestCaseInputRecordL(section, aResult);

		    break;

		case KTestCaseInputBitRate:

		    retValue = TestCaseInputBitRateL(section, aResult);

		    break;

		// Audio Output Stream Test Cases

		case KTestCaseOutputNew:

		    retValue = TestCaseOutputNewL(section, aResult);

		    break;

		case KTestCaseOutputNewWithParam:

		    retValue = TestCaseOutputNewWithParamL(section, aResult);

		    break;

		case KTestCaseOutputSetAudioProperties:

		    retValue = TestCaseOutputSetPropL(section, aResult);

		    break;

		case KTestCaseOutputOpen:

		    retValue = TestCaseOutputOpenL(section, aResult);

		    break;

		case KTestCaseOutputSetVolume:

		    retValue = TestCaseOutputSetVolumeL(section, aResult);

		    break;

		case KTestCaseOutputSetPriority:

		    retValue = TestCaseOutputSetPriorityL(section, aResult);

		    break;

		case KTestCaseOutputPlay:

		    retValue = TestCaseOutputPlayL(section, aResult);

		    break;

		case KTestCaseOutputSetBalance:

		    retValue = TestCaseOutputSetBalanceL(section, aResult);

		    break;

		case KTestCaseOutputSetDataType:

		    retValue = TestCaseOutputSetDataTypeL(section, aResult);

		    break;

		case KTestCaseOutputStop:

		    retValue = TestCaseOutputStopL(section, aResult);

		    break;

		default:

			aResult.iResultDes.Copy(KConfigInvalid());

			aResult.iResult = KErrNotExecuted;

		}

	return retValue;

	}

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

// CAudioStreamTestApp::OOMTestQueryL

// Used to check if a particular test case should be run in OOM conditions and 

// which memory allocations should fail.    

//

// NOTE: This method is virtual and must be implemented only if test case