// Copyright (c) 2008-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 <mmf/common/mmferrors.h>

#include <caf/caf.h>

using namespace ContentAccess;

#include "tsu3gplibraryapinegative.h"

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

// C3GPLibParser_Negative 

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

//

void C3GPLibParser_Negative::CallAudioApiL(C3GPParse* aParse, TInt aExpectedError)

	{

	TInt err = KErrNone;

	// Retrieve audio stream attributes

	T3GPAudioType audioType;

	TInt framesPerSample;

	TUint length; 

	TUint avgBitRate;

	TUint timeScale;

	err = aParse->GetAudioProperties(audioType, length, framesPerSample, avgBitRate, timeScale);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("aParse->GetAudioProperties")));

	TBool available;

	T3GPFrameType type = E3GPAudio;

	err = aParse->GetFrameAvailability(type, available);

	if (aExpectedError == KErrNotSupported)

		{

		// GetFrameAvailability will return KErrNotFound when there is no audio in the 3gp files

		User::LeaveIfError(CheckError(err, KErrNotFound, _L("GetFrameAvailability")));

		}

	else

		{

		User::LeaveIfError(CheckError(err, aExpectedError, _L("GetFrameAvailability")));

		}

	TUint size;

	err = aParse->GetAudioFramesSize(size);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetAudioFramesSize")));

	RBuf8 buffer;

	CleanupClosePushL(buffer);

	if (aExpectedError == KErrNone)

		{

		buffer.CreateL(size); // Use size retrieved from GetVideoFrameSize

		}

	else

		{

		buffer.CreateL(KBufferSize); // size from above may not be assigned since this is negative tests.

		}

	TUint timeStampInMs; 

	TUint timeStampInTimescale;

	TInt returnedFrames;

	err = aParse->ReadAudioFrames(buffer, returnedFrames, timeStampInMs, timeStampInTimescale);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("ReadAudioFrames")));

	CleanupStack::PopAndDestroy(&buffer);

	TUint index;

	err = aParse->GetAudioSampleEntryIndex(index);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetAudioSampleEntryIndex")));

	T3GPQcelpStorageMode mode;

	err = aParse->GetQcelpStorageMode(mode);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetQcelpStorageMode")));

	}

void C3GPLibParser_Negative::CallVideoApiL(C3GPParse* aParse, TInt aExpectedError)

	{

	TInt err = KErrNone;

	// Retrieve video & audio stream attributes

	T3GPVideoType videoType;

	TUint length; 

	TReal frameRate;

	TUint avgBitRate;

	TSize videoSize;

	TUint timeScale;

	err = aParse->GetVideoProperties(videoType, length, frameRate, avgBitRate, videoSize, timeScale);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoProperties")));

	TBool available;

	T3GPFrameType type = E3GPVideo;

	err = aParse->GetFrameAvailability(type, available);

	if (aExpectedError == KErrNotSupported)

		{

		// GetFrameAvailability will return KErrNotFound when there is no video in the 3gp files

		User::LeaveIfError(CheckError(err, KErrNotFound, _L("GetFrameAvailability")));

		}

	else

		{

		User::LeaveIfError(CheckError(err, aExpectedError, _L("GetFrameAvailability")));

		}

	TUint size;	

	err = aParse->GetVideoFrameSize(size);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoFrameSize")));

	RBuf8 buffer;

	CleanupClosePushL(buffer);

	if (aExpectedError == KErrNone)

		{

		buffer.CreateL(size); // Use size retrieved from GetVideoFrameSize

		}

	else

		{

		buffer.CreateL(KBufferSize); // size from above may not be assigned since this is negative tests.

		}

	TBool keyFrame;

	TUint timeStampInMs; 

	TUint timeStampInTimescale;

	err = aParse->ReadVideoFrame(buffer, keyFrame, timeStampInMs, timeStampInTimescale);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("ReadVideoFrame")));

	CleanupStack::PopAndDestroy(&buffer);

	err = aParse->GetVideoTimestamp(timeStampInMs, timeStampInTimescale);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoTimestamp")));

	TUint num;

	err = aParse->GetNumberOfVideoFrames(num);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetNumberOfVideoFrames")));

	TUint index;

	err = aParse->GetVideoSampleEntryIndex(index);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoSampleEntryIndex")));

	err = aParse->GetVideoFrameSize(index, size);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoFrameSize")));

	err = aParse->GetVideoFrameStartTime(index, timeStampInMs, timeStampInTimescale);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoFrameStartTime")));

	err = aParse->GetVideoFrameKeyType(index, keyFrame);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoFrameKeyType")));

	TInt level;

	err = aParse->GetH263VideoLevel(level);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetH263VideoLevel")));

	T3GPFrameDependencies dependencies;

	err = aParse->GetVideoFrameDependencies(dependencies);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoFrameDependencies")));

	TUint numberOfFrames = 2;

	RArray<T3GPFrameInfoParameters> array;

	err = aParse->GetVideoFrameProperties(index, numberOfFrames, array);

	array.Close();

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoFrameProperties")));	

	}

void C3GPLibParser_Negative::CallVideoDecoderInfoApiL(C3GPParse* aParse, TInt aExpectedError)

	{

	RBuf8 buffer;

	CleanupClosePushL(buffer);

	TInt dsiSize;

	TInt err = aParse->GetVideoDecoderSpecificInfoSize(dsiSize);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoDecoderSpecificInfoSize")));

	if (aExpectedError == KErrNone)

		{

		buffer.CreateL(dsiSize);

		}

	else

		{

		buffer.CreateL(KBufferSize); // size from above may not be assigned since this is negative tests.

		}

	err = aParse->GetVideoDecoderSpecificInfo(buffer);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoDecoderSpecificInfo")));

	CleanupStack::PopAndDestroy(&buffer);

	}

void C3GPLibParser_Negative::CallAudioDecoderInfoApiL(C3GPParse* aParse, TInt aExpectedError)

	{

	RBuf8 buffer;

	CleanupClosePushL(buffer);

	TInt dsiSize;

	TInt err = aParse->GetAudioDecoderSpecificInfoSize(dsiSize);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetAudioDecoderSpecificInfoSize")));

	if (aExpectedError == KErrNone)

		{

		buffer.CreateL(dsiSize);

		}

	else

		{

		buffer.CreateL(KBufferSize); // size from above may not be assigned since this is negative tests.

		}

	err = aParse->GetAudioDecoderSpecificInfo(buffer);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetAudioDecoderSpecificInfo")));

	CleanupStack::PopAndDestroy(&buffer);

	}

// Retrieve user data atom. 

void C3GPLibParser_Negative::CallUDTApiL(C3GPParse* aParse, TUint32 aUdtType, TUint& aIndex, TInt aExpectedError, T3GPUdtaLocation aLocation)

	{

	TInt err = KErrNone;

	TInt udtSize;

	TUint tempIndex = aIndex;	// use the copy of the aIndex so it does not get overwritten by GetUserDataAtomSize

	err = aParse->GetUserDataAtomSize(aUdtType, aLocation, tempIndex, udtSize);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetUserDataAtomSize")));

	RBuf8 buffer;	

	CleanupClosePushL(buffer);

	if (aExpectedError == KErrNone && err == KErrNone)

		{

		buffer.CreateL(udtSize); // Use size retrieved from GetUserDataAtomSize

		}

	else

		{

		buffer.CreateL(KBufferSize); // size from above may not be assigned since this is negative tests.

		}

	err = aParse->GetUserDataAtom(aUdtType, aLocation, buffer, aIndex);

	CleanupStack::PopAndDestroy(&buffer);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetUserDataAtom")));

	}

void C3GPLibParser_Negative::CallCommonApiL(C3GPParse* aParse, TInt aExpectedError)

	{

	TInt err = KErrNone;

	TUint size;

	TUint avgBitRate;

	err = aParse->GetContainerProperties(size, avgBitRate);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetContainerProperties")));

	T3GPFrameType type;

	err = aParse->C3GPParse::GetFrameType(type);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetFrameType")));

	TBool streamable;

	err = aParse->GetStreamable(streamable);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetStreamable")));

	TUint position = 0;

	TBool keyFrame = EFalse;

	TUint audioPosition;

	TUint videoPosition;

	err = aParse->Seek(position, keyFrame, audioPosition, videoPosition);

	User::LeaveIfError(CheckError(err, aExpectedError, _L("Seek")));

	}

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

// Create 3GP Parser to read zero size file content and call all APIs except

// asynchrounous read

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

//

C3GPLibParser_0101::C3GPLibParser_0101()

	{	

	}

TVerdict C3GPLibParser_0101::doTestStepL()

	{

	if(TestStepResult() == EPass)

		{

		C3GPParse* parser = C3GPParse::NewL();

		CleanupStack::PushL(parser);

		TRAPD(err, EmptyFileFailedCorruptL(parser));

		if (err != KErrNone)

			{

			SetTestStepResult(EFail);

			}

		CleanupStack::PopAndDestroy(parser);

		}

	return TestStepResult();

	}

void C3GPLibParser_0101::EmptyFileFailedCorruptL(C3GPParse* aParse)

	{

	// all api test with empty file using file path

	// When the parser is in use, calling parser open again should fail with KErrInUse

	ParserOpenFileL(aParse, KErrInUse);

	CallCommonApiL(aParse, KErrCorrupt);

	CallVideoApiL(aParse, KErrCorrupt);

	CallAudioApiL(aParse, KErrCorrupt);

	CallVideoDecoderInfoApiL(aParse, KErrCorrupt);

	CallAudioDecoderInfoApiL(aParse, KErrCorrupt);

	TUint32 udtType = 0x7469746c;

	TUint index;

	CallUDTApiL(aParse, udtType, index, KErrCorrupt);

	T3GPUdtaLocation location = E3GPUdtaAudioTrak;

	CallUDTApiL(aParse, udtType, index, KErrCorrupt, location);

	ParserCompleteL(aParse);	

	// all api test with empty file using file handle

	// When the parser is in use, calling parser open again should fail with KErrInUse

	ParserOpenFileHandleL(aParse, EFileRead | EFileShareReadersOnly, KErrInUse);

	CallCommonApiL(aParse, KErrCorrupt);

	CallVideoApiL(aParse, KErrCorrupt);

	CallAudioApiL(aParse, KErrCorrupt);

	CallVideoDecoderInfoApiL(aParse, KErrCorrupt);

	CallAudioDecoderInfoApiL(aParse, KErrCorrupt);

	CallUDTApiL(aParse, udtType, index, KErrCorrupt);

	CallUDTApiL(aParse, udtType, index, KErrCorrupt, location);

	ParserCompleteHandleL(aParse);

	// all api test with empty file using CAF

	// When the parser is in use, calling parser open again should fail with KErrInUse

	ParserOpenCafLC(aParse, KErrInUse);

	CallCommonApiL(aParse, KErrCorrupt);

	CallVideoApiL(aParse, KErrCorrupt);

	CallAudioApiL(aParse, KErrCorrupt);

	CallVideoDecoderInfoApiL(aParse, KErrCorrupt);

	CallAudioDecoderInfoApiL(aParse, KErrCorrupt);

	CallUDTApiL(aParse, udtType, index, KErrCorrupt);

	CallUDTApiL(aParse, udtType, index, KErrCorrupt, location);

	ParserCompleteCafL(aParse);

	// test open using buffer mode

	// When the parser is in use, calling parser open again should fail with KErrInUse

	ParserOpenL(aParse, KErrInUse);

	ParserCompleteL(aParse);

	// Call complete again, should pass with no error

	ParserCompleteL(aParse);

	}

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

// Initialise a 3GP file parse with an empty filename and file path pointing 

// at non-existent files

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

//

C3GPLibParser_0102::C3GPLibParser_0102()

	{	

	}

TVerdict C3GPLibParser_0102::doTestStepL()

	{

	if(TestStepResult() == EPass)

		{

		C3GPParse* parser = C3GPParse::NewL();

		CleanupStack::PushL(parser);

		// Initialise a 3GP file parse with an empty filename and it should fail with KErrUnderflow

		TInt err = parser->Open(KEmptyFileString);		

		if (err != KErrUnderflow)

			{

			ERR_PRINTF2(_L("parser->Open(KEmptyFileString) expects KErrUnderflow. Returns with %d"), err);

			SetTestStepResult(EFail);

			}

		// Setup 3GP Parser with a file path of a non-existing file.  This should fail with KErrAccessDenied.

		err = parser->Open(KInvalidFileString);

		if (err != KErrAccessDenied)

			{

			ERR_PRINTF2(_L("parser->Open(KEmptyFileString) expects KErrAccessDenied. Returns with %d"), err);

			SetTestStepResult(EFail);

			}

		CleanupStack::PopAndDestroy(parser);

		}

	return TestStepResult();

	}

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

// Create parser by passing in a file path of a file already opened in 

// EFileShareExclusive mode. 

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

//

C3GPLibParser_0104::C3GPLibParser_0104()

	{	

	}

TVerdict C3GPLibParser_0104::doTestStepL()

	{

	if(TestStepResult() == EPass)

		{

		C3GPParse* parser = C3GPParse::NewL();

		CleanupStack::PushL(parser);

		// Open a valid mp4/3gp/3g2 file with EFileShareExclusive mode

		// Instantiate a 3GP parser object with the same file path already opened above

		FileOpenL(EFileShareExclusive);

		TInt err = parser->Open(iInputFile);

		if (err != KErrAccessDenied)

			{

			ERR_PRINTF2(_L("parser->Open(iInputFile) expects KErrAccessDenied. Returns with %d"), err);

			SetTestStepResult(EFail);

			}

		ParserCompleteL(parser);

		FileClose();

		CleanupStack::PopAndDestroy(parser);

		}

	return TestStepResult();

	}

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

// Use 3GP Parser to parse file before it has been setup

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

//

C3GPLibParser_0106::C3GPLibParser_0106()

	{	

	}

TVerdict C3GPLibParser_0106::doTestStepL()

	{

	if(TestStepResult() == EPass)

		{

		C3GPParse* parser = C3GPParse::NewL();

		CleanupStack::PushL(parser);

		TRAPD(err, AllApiFailedNotReadyL(parser));

		if (err != KErrNone)

			{

			SetTestStepResult(EFail);

			}

		CleanupStack::PopAndDestroy(parser);

		}

	return TestStepResult();

	}

void C3GPLibParser_0106::AllApiFailedNotReadyL(C3GPParse* aParse)

	{

	CallCommonApiL(aParse, KErrNotReady);

	CallVideoApiL(aParse, KErrNotReady);

	CallAudioApiL(aParse, KErrNotReady);

	CallVideoDecoderInfoApiL(aParse, KErrNotReady);

	CallAudioDecoderInfoApiL(aParse, KErrNotReady);

	TUint32 udtType = 0x7469746c;

	TUint index;

	CallUDTApiL(aParse, udtType, index, KErrNotReady);

	RBuf8 buffer;

	CleanupClosePushL(buffer);

	// create 0 size buffer for negative test when API is called before parse is opened

	buffer.CreateL(0); 

	TInt err = aParse->InsertData(buffer);

	User::LeaveIfError(CheckError(err, KErrNotReady, _L("aParse->InsertData")));

	CleanupStack::PopAndDestroy(&buffer);

	TInt num;

	err = aParse->GetNumBufferedBytes(num);

	User::LeaveIfError(CheckError(err, KErrNotReady, _L("aParse->InsertData")));

	}

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

// Use invalid frame type for all frame type API.

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

//

C3GPLibParser_0107::C3GPLibParser_0107()

	{

	}

TVerdict C3GPLibParser_0107::doTestStepL()

	{

	if(TestStepResult() == EPass)

		{

		C3GPParse* parser = C3GPParse::NewL();

		CleanupStack::PushL(parser);

		TRAPD(err, InvalidFrameTypeL(parser));

		if (err != KErrNone)

			{

			SetTestStepResult(EFail);

			}

		CleanupStack::PopAndDestroy(parser);

		}

	return TestStepResult();

	}

void C3GPLibParser_0107::InvalidFrameTypeL(C3GPParse* aParse)

	{

	// file mode

	ParserOpenFileL(aParse);

	// Invalid type tests

	TInt invalidType = 10;	

	T3GPVideoType invalidVideoType = static_cast<T3GPVideoType>(invalidType);

	TUint length; 

	TReal frameRate;

	TUint avgBitRate;

	TSize videoSize;

	TUint timeScale;

	 // should pass

	TInt err = aParse->GetVideoProperties(invalidVideoType, length, frameRate, avgBitRate, videoSize, timeScale);

	User::LeaveIfError(CheckError(err, KErrNone, _L("GetVideoProperties")));

	T3GPAudioType invalidAudioType = static_cast<T3GPAudioType>(invalidType);

	TInt framesPerSample;

	 // should pass

	err = aParse->GetAudioProperties(invalidAudioType, length, framesPerSample, avgBitRate, timeScale);

	User::LeaveIfError(CheckError(err, KErrNone, _L("aParse->GetAudioProperties")));

	T3GPFrameType invalidFrameType = static_cast<T3GPFrameType>(invalidType);

	// should pass

	err = aParse->GetFrameType(invalidFrameType); 

	User::LeaveIfError(CheckError(err, KErrNone, _L("aParse->GetAudioProperties")));

	T3GPQcelpStorageMode invalidMode = static_cast<T3GPQcelpStorageMode>(invalidType);

	 //Should pass

	err = aParse->GetQcelpStorageMode(invalidMode);

	User::LeaveIfError(CheckError(err, KErrNone, _L("aParse->GetVideoProperties() invalid type")));

	ParserCompleteL(aParse);

	}

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

// Use invalid frame index for video frame APIs and Get video frame properties for more 

// than the total number of video frames in the video clip

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

//