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

//

/**

 @file 

 @internalComponent - Internal Symbian test code 

*/

#include <f32file.h>

#include <bautils.h>

#include <gdi.h>

#include <gulcolor.h>

#include <gulutil.h>

#include <eikenv.h>

#include "T_ColorStep.h"

#include <centralrepository.h>

// these constants are also defined in cone\src\CoeDataStorage.cpp

const TUint KUidSystemColorRepository=0x10272619;

const TUint KSystemColorRepositoryKey=0;

//

// CSimpleColorControl

//

void CSimpleColorControl::ConstructL()

	{

	CreateWindowL();

	Window().SetShadowDisabled(ETrue);

	SetExtentToWholeScreen();

	ActivateL();

	}

void CSimpleColorControl::Draw(const TRect&) const

	{

	CWindowGc& gc = SystemGc();

	gc.Clear(Rect());

	}

//

// CTestColorUi

//

CTestColorUi::CTestColorUi(CT_ColorStep& aStep)

: CTestAppUi(&aStep, KNullDesC), iColorStep(aStep)

	{

	}

void CTestColorUi::ConstructL()

	{

	CTestAppUi::ConstructL();

	iControl = new(ELeave) CSimpleColorControl;

	AddToStackL(iControl, ECoeStackPriorityDefault, ECoeStackFlagOwnershipTransfered);

	iControl->ConstructL();

	iTestResult = CAutoTestManager::EPass;

	AutoTestManager().StartAutoTest();

	}

CTestColorUi::~CTestColorUi()

	{

	delete iColorList;

	}

void CTestColorUi::RunTestStepL(TInt aStep)

	{

	TRAPD(err, DoRunTestStepL(aStep));

	if(err == KLeaveExit)

		{

		User::Leave(err);

		}

	else if(err != KErrNone)

		{

		// Don't propagate this error since leaving stops the test :O(

		INFO_PRINTF3(_L(" Test step %d failed: %d"), aStep, err);

		iTestResult = CAutoTestManager::EFailed;

		}

	}

void CTestColorUi::DoRunTestStepL(TInt aStep)

	{

	switch(aStep)

		{

		case CT_ColorStep::ETestColorArray:

		SetTestStepID(_L("UIF-egul-TestColorArray"));

		INFO_PRINTF1(_L("Test CColorArray"));

		iColorStep.TestColorArrayL();

		RecordTestResultL();

		break;

	case CT_ColorStep::ETestColorList:

		SetTestStepID(_L("UIF-egul-TestColorList"));

		INFO_PRINTF1(_L("Test CColorList"));

		iColorList = iColorStep.TestColorListLC();

		CleanupStack::Pop(iColorList);

		RecordTestResultL();

		break;

	case CT_ColorStep::ETestColorUtils:

		SetTestStepID(_L("UIF-egul-TestColorUtils"));

		INFO_PRINTF1(_L("Test ColorUtils"));

		iColorStep.TestColorUtilsL(*iColorList);

		RecordTestResultL();

		break;

	case CT_ColorStep::ETestColorOom:

		SetTestStepID(_L("UIF-egul-TestColorOom"));

		INFO_PRINTF1(_L("Repeat tests in low memory"));

		iColorStep.TestColorOomL();

		RecordTestResultL();

		break;

	case CT_ColorStep::ETestFileLength:

		SetTestStepID(_L("UIF-egul-FileLengthTestL"));

		INFO_PRINTF1(_L("Test access zero length file"));

		iColorStep.FileLengthTestL();

		RecordTestResultL();

		break;

	case CT_ColorStep::ETestFileCorrupt:

		SetTestStepID(_L("UIF-egul-CorruptFileTest"));

		INFO_PRINTF1(_L("Test access corrupt file"));

		iColorStep.CorruptFileTestL();

		RecordTestResultL();

		CloseTMSGraphicsStep();

		break;

	default:

		iColorStep.SetTestStepResult((iTestResult==CAutoTestManager::EPass) ? EPass : EFail);

		AutoTestManager().FinishAllTestCases(iTestResult);

		break;

		}

	}

/**

	@SYMTestCaseID UIF-egul-TestColorArray

	@SYMPREQ

	@SYMTestCaseDesc

	Test basic functionality of the CColorArray class.

	@SYMTestPriority High

	@SYMTestStatus Implemented

	@SYMTestActions

	Create a new CColorList object.

	Add some logical colors to it.

	Check that the presence of the colors may be detected.

	Check that the values of the logical colors may be retrieved.

	@SYMTestExpectedResults

	Logical colors may be stored in, and retrieved from, a CColorArray object.

*/

void CT_ColorStep::TestColorArrayL()

	{

	CColorArray* array=CColorArray::NewL();

	TEST(array!=NULL);

	delete array;

	array=0;

	array=CColorArray::NewLC();

	TEST(array!=NULL);

	TEST(array->Contains(101)==EFalse);

	TEST(array->Count()==0);

	array->AddL(101,KRgbWhite);

	array->AddL(102,KRgbBlack);

	array->AddL(104,KRgbDarkBlue);

	array->AddL(103,KRgbGreen);

	TEST(array->Count()==4);

	TEST(array->Contains(101));

	TEST(!array->Contains(105));

	TEST(array->Color(102)==KRgbBlack);

	TEST(array->Color(103)==KRgbGreen);

	array->SetColor(104,KRgbYellow);

	TEST(array->Color(104)==KRgbYellow);

	TEST(array->Contains(104));

	array->Remove(102);

	array->Remove(104);

	TEST(array->Count()==2);

	TEST(array->Contains(101));

	TEST(array->Contains(103));

	TEST(!array->Contains(104));

	array->Reset();

	TEST(array->Count()==0);

	CleanupStack::PopAndDestroy(); // array

	}

/**

	@SYMTestCaseID UIF-egul-TestColorList

	@SYMPREQ

	@SYMTestCaseDesc

	Test basic functionality of the CColorList class.

	@SYMTestPriority High

	@SYMTestStatus Implemented

	@SYMTestActions

	Create a new CColorList object.

	Add some logical colors to it.

	Check that the presence of the colors may be detected.

	Check that the values of the logical colors may be retrieved.

	Add some CColorArray objects to it.

	Check that the presence of the color arrays may be detected.

	Check that the values of the colors in the color arrays may be retrieved.

	@SYMTestExpectedResults

	Logical colors and color arrays may be stored in, and retrieved from,

	a CColorList object.

*/

CColorList* CT_ColorStep::TestColorListLC()

	{

	CArrayFix<TRgb>* rgbs=new(ELeave) CArrayFixFlat<TRgb>(3);

	CleanupStack::PushL(rgbs);

	rgbs->AppendL(KRgbWhite);

	rgbs->AppendL(KRgbGray);

	rgbs->AppendL(KRgbCyan);

	rgbs->AppendL(KRgbDarkRed);

	CColorList* list=CColorList::NewL(rgbs);

	CleanupStack::Pop(); // rgbs

	CleanupStack::PushL(list);

	TEST(list->Color(TLogicalColor(0))==KRgbWhite);

	CColorArray* array=CColorArray::NewLC();

	array->AddL(200,KRgbDarkMagenta);

	array->AddL(201,KRgbDarkCyan);

	array->AddL(202,KRgbDarkMagenta);

	list->AddColorArrayL(TUid::Uid(KEikCustomColorsArrayValue),array);

	CleanupStack::Pop(); // array

	array=CColorArray::NewLC();

	array->AddL(300,KRgbDarkGray);

	array->AddL(301,KRgbRed);

	list->AddColorArrayL(TUid::Uid(1001),array);

	CleanupStack::Pop(); // array

	TEST(list->ContainsColorArray(TUid::Uid(KEikCustomColorsArrayValue)));

	TEST(!list->ContainsColorArray(TUid::Uid(1005)));

	TEST(list->ContainsColorArray(TUid::Uid(1001)));

	array=list->ColorArray(TUid::Uid(KEikCustomColorsArrayValue));

	TEST(array->Count()==3);

	TEST(list->Color(TUid::Uid(1001),300)==KRgbDarkGray);

	TEST(list->Color(TUid::Uid(KEikCustomColorsArrayValue),201)==KRgbDarkCyan);

	array=list->ColorArray(TUid::Uid(1001));

	TEST(array->Count()==2);

	list->DeleteColorArray(TUid::Uid(1001));

	TEST(list->ContainsColorArray(TUid::Uid(KEikCustomColorsArrayValue)));

	TEST(!list->ContainsColorArray(TUid::Uid(1005)));

	TEST(!list->ContainsColorArray(TUid::Uid(1001)));

	list->SetColor(TLogicalColor(1),KRgbBlack);

	TEST(list->Color(TLogicalColor(0))==KRgbWhite);

	TEST(list->Color(TLogicalColor(1))==KRgbBlack);

	return list;

	}

/**

	@SYMTestCaseID UIF-egul-TestColorUtils

	@SYMPREQ

	@SYMTestCaseDesc

	Test basic functionality of the ColorUtils class.

	@SYMTestPriority High

	@SYMTestStatus Implemented

	@SYMTestActions

	Remove the current color scheme file.

	Check that an attempt to read the color scheme returns a NULL CColorList object.

	Create a new color scheme file from a supplied CColorList.

	Check that an attempt to read the new color scheme returns a CColorList object

	containing the expected colors and color arrays.

	Restore the original color scheme file.

	@SYMTestExpectedResults

	The system color scheme may be changed.

*/

void CT_ColorStep::TestColorUtilsL(CColorList& aColorList)

	{

	RFs& fs = iFs;

//	if (BaflUtils::FileExists(fs,????KColorSchemeFile))

//		{

//		if (BaflUtils::FileExists(fs,KColorSchemeFileOriginalRenamed))

//			{

//			User::LeaveIfError(fs.Delete(KColorSchemeFileOriginalRenamed));

//			}

//		User::LeaveIfError(fs.Rename(KColorSchemeFile,KColorSchemeFileOriginalRenamed));

//		}

	CColorList* list=ColorUtils::CreateSystemColorListL(fs);

	delete list;

	ColorUtils::UpdateSystemColorListL(fs,aColorList);

	list=ColorUtils::CreateSystemColorListL(fs);

	CleanupStack::PushL(list);

	TEST(list->Color(TLogicalColor(0))==KRgbWhite);

	TEST(list->ContainsColorArray(TUid::Uid(KEikCustomColorsArrayValue)));

	TEST(!list->ContainsColorArray(TUid::Uid(1005)));

	TEST(!list->ContainsColorArray(TUid::Uid(1001)));

	CColorArray* array=list->ColorArray(TUid::Uid(KEikCustomColorsArrayValue));

	TEST(array->Count()==3);

	TEST(list->Color(TUid::Uid(KEikCustomColorsArrayValue),201)==KRgbDarkCyan);

	CleanupStack::PopAndDestroy(list);

	//restore original file

//	User::LeaveIfError(fs.Delete(KColorSchemeFile));

//	if (BaflUtils::FileExists(fs,KColorSchemeFileOriginalRenamed))

//		{

//		User::LeaveIfError(fs.Rename(KColorSchemeFileOriginalRenamed,KColorSchemeFile));

//		}

	}

void CT_ColorStep::DoOomTestsL()

	{

	TestColorArrayL();

	CColorList* list=TestColorListLC();

	TestColorUtilsL(*list);

	CleanupStack::PopAndDestroy(list);

	}

/**

	@SYMTestCaseID UIF-egul-TestColorOom

	@SYMPREQ

	@SYMTestCaseDesc

	Test basic functionality of the CColorArray, CColorList and ColorUtils classes under low memory conditions.

	@SYMTestPriority High

	@SYMTestStatus Implemented

	@SYMTestActions

	Perform the CT_ColScm_TestColorArray, CT_ColScm_TestColorList, and CT_ColScm_TestColorUtils test cases

	under low memory conditions, where each memory allocation is made to fail once.

	@SYMTestExpectedResults

	All methods should report KErrNoMemory if they cannot allocate sufficient memory to complete.

	All methods should recover gracefully from low memory situations and subsequently succeed when sufficient

	memory is available.

*/

void CT_ColorStep::TestColorOomL()

	{

	TInt err=KErrNoMemory;

	for (TInt ii=0;err==KErrNoMemory;ii++)

		{

		__UHEAP_FAILNEXT(ii);

		__UHEAP_MARK;

		TRAP(err,DoOomTestsL());

		__UHEAP_MARKEND;

		}

	__UHEAP_SETFAIL(RHeap::ENone,0);

	User::LeaveIfError(err);

	}

void CT_ColorStep::SetSystemColorSchemeL(const TDesC8& aBuffer)

	{ // static

	CRepository* const repository=CRepository::NewL(TUid::Uid(KUidSystemColorRepository));

	CleanupStack::PushL(repository);

	User::LeaveIfError(repository->Set(KSystemColorRepositoryKey, aBuffer));

	CleanupStack::PopAndDestroy(repository);

	}

/**

   @SYMTestCaseID UIF-egul-FileLengthTestL

   @SYMPREQ DEF043427

   @SYMTestCaseDesc

   Color scheme file should be checked for zero length.\n

   @SYMTestPriority High

   @SYMTestStatus Implemented

   @SYMTestActions

   Open the color scheme file in write mode and set its length as zero.\n

   API Calls:

   static CColorList* ColorUtils::CreateSystemColorListL(RFs& aFs);\n

   @SYMTestExpectedResults

   If the file length is zero then it should be deleted and the \n

   CreateSystemColorListL should return NULL.\n

 */

void CT_ColorStep::FileLengthTestL()

	{

	SetSystemColorSchemeL(KNullDesC8);

	CColorList* colorlist=NULL;

	TRAPD(err,colorlist=ColorUtils::CreateSystemColorListL(iFs));

	TEST(err == KErrNone);

	TEST(colorlist == NULL);

	}

/**

   @SYMTestCaseID UIF-egul-CorruptFileTest

   @SYMPREQ DEF043427

   @SYMTestCaseDesc

   Color scheme file length should be set to abnormal value.\n

   @SYMTestPriority High

   @SYMTestStatus Implemented

   @SYMTestActions

   Open the color scheme file in write mode and set its length as half.\n

   the actual file length.

   API Calls:

   static CColorList* ColorUtils::CreateSystemColorListL(RFs& aFs);\n

   @SYMTestExpectedResults

   CreateSystemColorListL should return NULL and delete the file.

 */

void CT_ColorStep::CorruptFileTestL()

	{

	SetSystemColorSchemeL(_L8("blah blah some rubbish binary data\xab\xcd\xef"));

	CColorList* colorlist=NULL;

	TRAPD(err,colorlist=ColorUtils::CreateSystemColorListL(iFs));

	TEST(err == KErrNone);

	TEST(colorlist == NULL);

	}

CT_ColorStep::~CT_ColorStep()

/**

   Destructor

 */

	{

	iFs.Close();

	}

CT_ColorStep::CT_ColorStep()

/**

   Constructor

 */

	{

	// Call base class method to set up the human readable name for logging

	SetTestStepName(KT_ColorStep);

	}

void CT_ColorStep::ConstructAppL(CEikonEnv* aCoeEnv)

	{

	/** CEikonEnv will install a CEikEnvDataStorage object instance to access the EikSrv data cage.

	    Using the system colour scheme from EikSrv for these tests causes problems in the rest of the system,

	    (e.g. Shell app panics with EEgulPanicLogicalColorNotFound) because these tests set up a non-standard

	    colour scheme.

	    So, here we remove the CEikEnvDataStorage object and install a test data storage object

	    that stores the colour scheme file in c:\\EGulTest\\, keeping it out of the way of everything else.

	*/

	aCoeEnv->ConstructL();

	CTestColorUi* appUi=new(ELeave) CTestColorUi(*this);

	appUi->ConstructL();

	aCoeEnv->SetAppUi(appUi);

	}

TVerdict CT_ColorStep::doTestStepL()

	{

	INFO_PRINTF1(_L("Test Started"));

	PreallocateHALBuffer();

	__UHEAP_MARK;

	User::LeaveIfError(iFs.Connect());

	CEikonEnv* coe=new(ELeave) CEikonEnv;

	TRAPD(err,ConstructAppL(coe));

	if (!err)

		coe->ExecuteD();

	else

		{

		SetTestStepResult(EFail);

		delete coe;

		}

	INFO_PRINTF1(_L("Test Finished"));

	__UHEAP_MARKEND;

	return TestStepResult();

	}