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

// This file contains the test steps ICL negative testing

// EPOC includes

// 

//

#include <testframework.h>

#include <caf/caf.h>

#include "TestNegativeConversion.h"

#include "rightsdatabase.h"

using namespace ContentAccess;

const TInt KMaxMimeLength = 256;

const TInt	KErrEncoderNonAvailable = -17014;//this error raises whenever you try to use 

											//unavaliable plugin 

//const TInt  KLenBufferSectionName = 64;	// EABI warning removal

//const TInt	KLenMemBuffer	= 1024;		// EABI warning removal

// DRM 

const TInt KDefaultRightsID = 1;

const TInt KDefaultRightsCount = 2;

const TInt KRightsNoCount = -1;

CTestNegativeConversion *CTestNegativeConversion::NewL(const TDesC& aTestName)

	{

	CTestNegativeConversion* self = new(ELeave) CTestNegativeConversion(aTestName);

	return self;

	}

/**

 * 

 *

 * do the test step

 *

 */

TVerdict CTestNegativeConversion::DoTestStepL()

	{

	TVerdict	currentVerdict = EPass;

	if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0501-CP")) == 0)

		currentVerdict = Step0501_CP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0502-LP")) == 0)

		currentVerdict = Step0502_LP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0503-HP")) == 0)

		currentVerdict = Step0503_HP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0504-HP")) == 0)

		currentVerdict = Step0504_HP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0505-HP")) == 0)

		currentVerdict = Step0505_HP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0506-LP")) == 0)

		currentVerdict = Step0506_LP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0507-LP")) == 0)

		currentVerdict = Step0507_LP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0508-HP")) == 0)

		currentVerdict = Step0508_HP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0509-LP")) == 0)

		currentVerdict = Step0509_LP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0510-LP")) == 0)

		currentVerdict = Step0510_LP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0511-LP")) == 0)

		currentVerdict = Step0511_LP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0512-LP")) == 0)

		currentVerdict = Step0512_LP_L();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0513-HP")) == 0)

		currentVerdict = Step0513_HP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0602-HP")) == 0)

		currentVerdict = Step0602_HP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0603-HP")) == 0)

		currentVerdict = Step0603_HP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0604-HP")) == 0)

		currentVerdict = Step0604_HP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0605-HP")) == 0)

		currentVerdict = Step0605_HP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0606-HP")) == 0)

		currentVerdict = Step0606_HP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0607-HP")) == 0)

		currentVerdict = Step0607_HP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0020-CP")) == 0)

		currentVerdict = Step0020_CP();

	else if( iTestStepName.Compare(_L("MM-ICL-FRM-I-0700-CP")) == 0)

        currentVerdict = Step0700_CP();

	return currentVerdict;

	}

/**

 * 

 * Request an encode for

 * usupported image format

 */

TVerdict	CTestNegativeConversion::Step0501_CP()

	{

	TVerdict result = EFail ;

	TInt	theRes = KErrNone;

	TRAP_IGNORE(theRes = EncodeImageToMemoryL(iFileNameSrc, 

										iImageTypeUid));

	if(theRes == KErrNotFound)

		{

		INFO_PRINTF2(_L("Error during request unsupported image format, error %d\n"),

					theRes);

		result = EPass;

		}

	return result;

	}

/**

 * 

 * Request an encode for supported

 * image format but usupported 

 * conversion type

 * 

 *	This test was removed. Cannot specify unsupported conversion type!!! (for ex. GIF89a)

 */

TVerdict	CTestNegativeConversion::Step0502_LP()

	{

	// we have no subtypes specified for GIF

	INFO_PRINTF1(_L("Warning : test not valid - ICL has no subtypes specified but not implemented"));

	return EPass;

/*	TVerdict result = EPass ;

	TInt	theRes = KErrNotSupported;

	TRAP(theRes, theRes = EncodeImageToMemoryL(iFileNameSrc, 

										iImageTypeUid));

	if(theRes == KErrNone)

		result = EPass;

	if(theRes == KErrNotFound)

		{

		INFO_PRINTF2(_L("Error during request unsupported image format, error %d\n"),

					theRes);

		}

	return result;

*/

	}

/**

 * 

 * Request load and encode 

 * of corrupt image 

 * 

 */

TVerdict	CTestNegativeConversion::Step0503_HP()

	{

	TVerdict result = EFail ;

	TInt	theRes = KErrNone;

	TInt err = RFbsSession::Connect();

	if (err != KErrNone)

		{

		INFO_PRINTF2(_L("RFbsSession::Connect() failed, err = %d"), err);

		return EInconclusive;

		}

	//iImageTypeUid is not according to file format

	TRAP_IGNORE(theRes = OpenImageForDecodeFromBufferL(iFileNameSrc, iImageTypeUid));

	RFbsSession::Disconnect();

	if(theRes == KErrNotFound)

		{

		INFO_PRINTF2(_L("Error during load and decode of corrupt image, error %d\n"),

					theRes);

			result = EPass;

		}

	return result;

	}

/**

 * 

 * Request load and decode 

 * of corrupt WMF image 

 * 

 */

TVerdict	CTestNegativeConversion::Step0020_CP()

	{

	TVerdict result = EFail ;

	TInt	theRes = KErrNone;

	TInt err = RFbsSession::Connect();

	if (err != KErrNone)

		{

		INFO_PRINTF2(_L("RFbsSession::Connect() failed, err = %d"), err);

		return EInconclusive;

		}

	//try to open corrupted file

	TRAP_IGNORE(theRes = OpenImageForDecodeFromBufferL(iFileNameSrc, iImageTypeUid));

	RFbsSession::Disconnect();

	if(theRes == KErrCorrupt)

		{

		INFO_PRINTF2(_L("Error during load and decode of corrupt image, error %d\n"),

					theRes);

		result = EPass;	

		}

	return result;

	}

/**

 * 

 * Request load and decode of 

 * image from which content type

 * cannot be identified

 * 

 */

TVerdict	CTestNegativeConversion::Step0504_HP()

	{

	TVerdict result = EFail ;

	TInt	theRes = KErrNone;

	TInt err = RFbsSession::Connect();

	if (err != KErrNone)

		{

		INFO_PRINTF2(_L("RFbsSession::Connect() failed, err = %d"), err);

		return EInconclusive;

		}

	TRAP_IGNORE(theRes = OpenImageForDecodeFromBufferL(iFileNameSrc));

	RFbsSession::Disconnect();

	if(theRes == KErrNotFound)

		{

		INFO_PRINTF2(_L("Error decode cropped image format, error %d\n"),

					theRes);

		result = EPass;

		}

	return result;

	}

/**

 * 

 * Request load of non-existent 

 * image 

 * 

 */

TVerdict	CTestNegativeConversion::Step0505_HP()

	{

	TVerdict result = EFail ;

	TInt	theRes = KErrNone;

	TRAP_IGNORE(theRes = OpenImageForDecodeFromFileL(iFileNameSrc));

	if(theRes == KErrNotFound)

		{

		INFO_PRINTF2(_L("Error load of non-existent image, error %d\n"),

					theRes);

		result = EPass;

		}

	return result;

	}

/**

 * 

 * Request incremental load and 

 * decode of an image, then break the connection

 * before completion

 *		Test was removed!!!. Every attempt to close file server causes crash

 */

TVerdict	CTestNegativeConversion::Step0506_LP()

	{

	INFO_PRINTF1(_L("Warning : test not valid - cannot break incremental load in Test Framework"));

	INFO_PRINTF1(_L("Run visual test in TImageViewer"));

	return EPass;

/*	TVerdict result = EFail ;

	TInt	theRes = KErrNone;

	TInt	theNumStepBeforeCancel = 0;	

	TBuf<KLenBufferSectionName>	nameSection;

	TPtrC ptr = iTestStepName;

	nameSection = ptr.Right(KLenNameInSection);

	GetIntFromConfig(nameSection, _L("NumStepBeforeCancel"), theNumStepBeforeCancel);

	TRAP(theRes, theRes = ReadAndDecodeIncrementallyL(iFileNameSrc, theNumStepBeforeCancel));

	if(theRes == KErrNone)

		result = EPass;

	if(theRes == KErrNotFound)

		{

		INFO_PRINTF2(_L("Error during break connection before completion, error %d\n"),

					theRes);

		}

	return result;

*/

	}

/**

 * 

 * Request incremental load and decode 

 * of an image, then delete the image at the server 

 * before completion

 *		Test was removed!!!. During reading and decoding image incrementally 

 *		cannot delete source file

 */

TVerdict	CTestNegativeConversion::Step0507_LP()

	{

	INFO_PRINTF1(_L("Warning : test not valid - cannot delete source image during decode in Test Framework"));

	INFO_PRINTF1(_L("Run visual test in TImageViewer"));

	return EPass;

/*

	TVerdict result = EFail ;

	TInt	theRes = KErrNone;

	TRAP(theRes, theRes = OpenImageForDecodeFromFileL(iFileNameSrc));

	if(theRes == KErrNone)

		result = EPass;

	if(theRes == KErrNotFound)

		{

		INFO_PRINTF2(_L("Error during delete the image before completion, error %d\n"),

					theRes);

		}

	return result;

*/

	}

/**

 * 

 * Request incremental load and decode of an image, 

 * then cancel the incremental load at the client

 * before completion.

 *

 *	Test was removed!!!.

 *	Was replaced by MM-ICL-COD-U-08d4-HP

 *	

 */

TVerdict	CTestNegativeConversion::Step0508_HP()

	{

	INFO_PRINTF1(_L("Warning : Was replaced by MM-ICL-COD-U-08d4-HP"));

	return EFail;

/*

	TVerdict result = EFail ;

	TInt	theNumStepBeforeCancel = 0;	

	TInt	theRes = KErrNone;

	TBuf<KLenBuffer>	nameSection;

	TPtrC ptr = iTestStepName;

	nameSection = ptr.Right(KLenNameInSection);

	GetIntFromConfig(nameSection, _L("NumStepBeforeCancel"), theNumStepBeforeCancel);

	TRAPD(theRes1, theRes = ReadAndDecodeIncrementallyL(iFileNameSrc, theNumStepBeforeCancel));

	if(theRes == KErrCancel)

		{

		INFO_PRINTF2(_L("The incremental load and decode was canceled at the client before completion, error %d"),

					theRes);

		result = EPass;

		}

	else

		{

		if(theRes1 != KErrNone)

			theRes = theRes1;

		INFO_PRINTF2(_L("Unexpected error during request incremental load and decode of an image, error %d"),

					theRes);

		}

	return result;

	*/

	}

/**

 * 

 * List available encoders/decoders 

 * where no plugin are available

 * 

 */

TVerdict	CTestNegativeConversion::Step0509_LP()

	{

	TInt	theRes = KErrNone;

	TInt	theRes1 = KErrNone;

	theRes = ListAllAvailableEncoders();

	if(theRes == KErrEncoderNonAvailable)

		{

		INFO_PRINTF2(_L("List encoders plugin are not available, error %d\n"),

					theRes);

		}

	theRes1 = ListAllAvailableDecoders();

	if(theRes1 == KErrEncoderNonAvailable)

		{

		INFO_PRINTF2(_L("List decoders plugin are not available, error %d\n"),

					theRes1);

		}

	INFO_PRINTF1(_L("Warning : test not valid - cannot delete plugins / Ecom registry in Test Framework"));

	INFO_PRINTF1(_L("To test, run on clean system with no plugins installed"));

	return EPass;

/*

	TVerdict result = EFail ;

	if(theRes == KErrEncoderNonAvailable && theRes1 == KErrEncoderNonAvailable)

		result = EPass;

	return result;

*/

	}

/**

 * 

 * List MIME types / UIDs for encodes/decoders 

 * where no plugins are available

 * 

 */

TVerdict	CTestNegativeConversion::Step0510_LP()

	{

	TInt theRes = KErrNone;

	TInt theRes1 = KErrNone;

	__MM_HEAP_MARK;

	TInt err = RFbsSession::Connect();

	if (err != KErrNone)

		{

		INFO_PRINTF2(_L("RFbsSession::Connect() failed, err = %d"), err);

		return EInconclusive;

		}

	// request list of encoders

	theRes = ListAvailableMIMEEncoders();

	if(theRes == KErrEncoderNonAvailable)

		{

		INFO_PRINTF2(_L("A list of MIME types for encoders is not available, error %d\n"),

						theRes);

		}

	// request list of decoders

	theRes1 = ListAvailableMIMEDecoders();

	if(theRes1 == KErrEncoderNonAvailable)

		{

		INFO_PRINTF2(_L("A list of MIME types for decoders is not available, error %d\n"),

						theRes1);

		}

	RFbsSession::Disconnect();

	__MM_HEAP_MARKEND;

	INFO_PRINTF1(_L("Warning : test not valid - cannot delete plugins / Ecom registry in Test Framework"));

	INFO_PRINTF1(_L("To test, run on clean system with no plugins installed"));

	return EPass;

/*

	TVerdict result = EFail ;

	if(theRes == KErrEncoderNonAvailable && theRes1 == KErrEncoderNonAvailable)

		result = EPass;

	return result;	

*/

	}

/**

 * 

 * Request a load and decode/encode 

 * from a corrupt plugin 

 * 

 */

TVerdict	CTestNegativeConversion::Step0511_LP()

	{

	INFO_PRINTF1(_L("Warning : test not valid - corrupt plugin not available"));

	return EPass;

/*	TVerdict result = EFail ;

	TInt	theRes = KErrNone;

	TInt	theRes1 = KErrNone;

	TInt	theRes2 = KErrNone;

	TRAP(theRes2, theRes = OpenImageForDecodeFromFileL(iFileNameSrc));