// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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:
// TCUSTOMWRAP.CPP 
// 
//

#include <e32base.h>
#include <msvapi.h>
#include <msvids.h>
#include <mtclreg.h>
#include <eikstart.h>

#include <basched.h>
#include <banamedplugins.h>
#include <bautils.h>
#include <coecntrl.h>
#include <coeccntx.h>
#include <coemain.h>
#include <charconv.h>
#include <convnames.h>
#include <e32keys.h>
#include <techview\eikon.hrh>
#include <eikappui.h>
#include <eikapp.h>
#include <eikdoc.h>
#include <eikenv.h>
#include <techview\eikrted.h>
#include <techview\eikedwin.h>
#include <eikdef.h>
#include <techview\eikdialg.h>
#include <techview\eikdlgtb.h>
#include <techview\eikrted.h>
#include <techview\eiksbfrm.h>
#include <techview\eikconso.h>
#include <txtrich.h>
#include <hal.h>
#include <fbs.h>
#include "TestNrl.hrh"
#include <testnrl.rsg>
#include <techview\eikon.rsg>
#include <prnsetup.h>

#include <biodb.h>	
#include <biouids.h>
#include <gdi.h>

// forward declarations
class CNRLTestAppUi;
//class CEikScrollBarFrame;

const TInt EGranularity=4;

_LIT(KNewLine,"\n");
_LIT(KLitResourceFileNameAppendage, "_NAME.RSC");
#ifdef _DEBUG
_LIT(KPanicText, "NonRom_Test");
#endif

class TDummyObserver: public MMsvSessionObserver
	{
public:
		virtual void HandleSessionEventL(TMsvSessionEvent, TAny*, TAny*, TAny*) {};
	};


//
// class CNRLTestControl
//

class CNRLTestControl : public CCoeControl
    {
public:

    void ConstructL(const TRect& aRect);
	void ActivateL();
	~CNRLTestControl();
	TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType);
	void PrintToScreen (TRefByValue<const TDesC> aFmt,...);
	void PrintLineToScreen (TRefByValue<const TDesC> aFmt,...);

private: // from CCoeControl
	void Draw(const TRect&) const;
	
private:
	CEikConsoleScreen* iConsole;
    };


CNRLTestControl::~CNRLTestControl ()
	{
	delete iConsole;
	}


void CNRLTestControl::ConstructL (const TRect& aRect)
	{
	CreateWindowL();
	Window().SetShadowDisabled(ETrue);
    Window().SetBackgroundColor(KRgbGray);
    EnableDragEvents();
	SetRect(aRect);
	SetBlank();
	TRect consoleSize = aRect;
	consoleSize.Shrink(1,1);
	iConsole=new(ELeave) CEikConsoleScreen;
	iConsole->ConstructL(_L("TEST"),TPoint(1,1),consoleSize.Size(),CEikConsoleScreen::ENoInitialCursor,EEikConsWinInPixels);
	}

void CNRLTestControl::ActivateL ()
	{
	CCoeControl::ActivateL();
	iConsole->SetKeepCursorInSight(ETrue);
	iConsole->SetHistorySizeL(500,5);
	iConsole->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff,CEikScrollBarFrame::EOn);
	iConsole->Write(_L("\nStarting tests for Non-Rom Localisation\nThis test requires some user interaction\n"));
	iConsole->FlushChars();
	iConsole->DrawCursor();
	iConsole->SetAtt(ATT_NORMAL);
	}

void CNRLTestControl::Draw(const TRect& /* aRect*/) const
	{
	CWindowGc& gc = SystemGc();
	TRect rect=Rect();
	//rect.Shrink(10,10);
	gc.DrawRect(rect);
	rect.Shrink(1,1);
	}


TKeyResponse CNRLTestControl::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
    {
	if (aType!=EEventKey)
		return(EKeyWasConsumed);
    TInt modifiers=aKeyEvent.iModifiers;
    TInt code=aKeyEvent.iCode;



	TRect range = iConsole->Selection(); // get current selected range
	switch (code)
		{
		case EKeyUpArrow:
			iConsole->Up();
			if (modifiers & EModifierShift)
				{
				range.iTl = iConsole->CursorPos();
				iConsole->SetSelection(range); 
				}
			else
				iConsole->SelectCursor(); 
			break;
		case EKeyDownArrow:
			iConsole->Down();
			if (modifiers & EModifierShift)
				{
				range.iTl = iConsole->CursorPos();
				iConsole->SetSelection(range); 
				}
			else
				iConsole->SelectCursor(); 
			break;
		case EKeyLeftArrow:
			iConsole->Left();
			if (modifiers & EModifierShift)
				{
				range.iTl = iConsole->CursorPos();
				iConsole->SetSelection(range); 
				}
			else
				iConsole->SelectCursor(); 
			break;
		case EKeyRightArrow:
			iConsole->Right();
			if (modifiers & EModifierShift)
				{
				range.iTl = iConsole->CursorPos();
				iConsole->SetSelection(range); 
				}
			else
				iConsole->SelectCursor(); 
			break;
		case EKeyEnter: 
				iConsole->Cr();
				iConsole->Lf();
			break;
		default:
			{
			iConsole->SelectCursor();	// forget previous selection
			TBuf<1> chr;
			chr.Format(_L("%c"),code);
			iConsole->Write(chr);
			iConsole->FlushChars();
			}
			break;
		}
    return(EKeyWasConsumed);
    }


void CNRLTestControl::PrintToScreen(TRefByValue<const TDesC> aFmt,...)
	{
	VA_LIST list;
	VA_START(list,aFmt);
	TBuf<128> buf;
	buf.FormatList(aFmt,list);
	iConsole->Write(buf);
	}

void CNRLTestControl::PrintLineToScreen(TRefByValue<const TDesC> aFmt,...)
	{
	VA_LIST list;
	VA_START(list,aFmt);
	TBuf<128> buf;
	buf.FormatList(aFmt,list);
	iConsole->Write(buf);
	iConsole->Write(KNewLine);

	}



// 
//  ---------------------- CNRLTestAppView definition ---------------- 
//


class CNRLTestAppUi : public CEikAppUi ,private CBaNamedPlugins::MFallBackName
	{
public:
	void ConstructL();
	void CreateControlL();
	~CNRLTestAppUi();
	
	void StartTestsL();
	void TestLocaleL(const TDesC& aTestHeader);
	void TestCollation(const TDesC& aTestHeader);
	void TestResourcesL(const TDesC& aTestHeader);
	void TestCharSetNamesL(const TDesC& aTestHeader);
	void TestFEPNamesL(const TDesC& aTestHeader);
	void TestDisplayMessagingL(const TDesC& aTestHeader);
	void TestBIFL(const TDesC& aTestHeader);
	void TestPrinterNameL(const TDesC& aTestHeader);
	void TestLocalisableBitmapL(const TDesC& aTestHeader);


private: // from CEikAppUi -- framework
	void HandleCommandL(TInt aCommand);

	virtual HBufC* FallBackNameL(const TDesC& aFullResourceFileName) const;
	
	void WriteTestHeader(const TDesC& aTestHeader) const;
	void Pass(const TDesC& aTestHeader);
	void FailL(const TDesC& aTestHeader);
	void ReportEndResult() const;
private: 
	CNRLTestControl* iNRLTestControl;
	CDesCArray* iFailedTests;
	};

void CNRLTestAppUi::ConstructL()
	{
	BaseConstructL();
	CreateControlL();

	}

// The cleanup operation of the TCleanupItem

LOCAL_C void DestroyResourceFileArray(TAny* aArrayOfResourceFiles)
	{
	RArray<CBaNamedPlugins::TResourceFile>& arrayOfResourceFiles=*STATIC_CAST(RArray<CBaNamedPlugins::TResourceFile>*, aArrayOfResourceFiles);
	for (TInt i=arrayOfResourceFiles.Count()-1; i>=0; --i)
		{
		const CBaNamedPlugins::TResourceFile& resourceFile=arrayOfResourceFiles[i];
		delete resourceFile.iFullFileName;
		delete resourceFile.iIdentifier;
		}
	arrayOfResourceFiles.Close();
	}



void CNRLTestAppUi::CreateControlL()
	{
	iNRLTestControl=new(ELeave) CNRLTestControl;
    iNRLTestControl->ConstructL(ClientRect());
	AddToStackL(iNRLTestControl);
	iNRLTestControl->ActivateL();
	iFailedTests=new(ELeave) CDesCArrayFlat(3);
	}

CNRLTestAppUi::~CNRLTestAppUi()
	{
	RemoveFromStack(iNRLTestControl);
	delete iNRLTestControl;
	for (TInt i=0; i<iFailedTests->Count();i++)
		iFailedTests->Delete(i);
	delete iFailedTests;
	}

void CNRLTestAppUi::HandleCommandL(TInt aCommand)
	{
	switch(aCommand)
		{
		case EAppCmdExit:
			Exit();
			break;
		case EAppCmdTest:
			StartTestsL ();
			break;
		default:
			break;
		}
	} 


_LIT(KTestAnnouncer,"----------------");
_LIT(KLocaleTestTitle,"Locale ");
_LIT(KResourceTestTitle,"Application Resource ");
_LIT(KCharSetNamesTest,"Charset Names ");
_LIT(KFEPNameTestTitle,"FEP Names ");
_LIT(KCollationTestTitle, "Collation Table ");
_LIT(KTDisplayMessaging,"Messaging Resources ");
_LIT(KBIFTestTitle,"BIF Files ");
_LIT(KPrinterNameTestTitle,"Printer Names ");
_LIT(KLocalisableBimap,"Bitmap Files ");
_LIT(KOriginalBitmapPath,"z:\\resource\\apps\\testnrl.mbm");
_LIT(KNonROM,"Non-ROM");

void CNRLTestAppUi::WriteTestHeader(const TDesC& aTestHeader) const 
	{
	iNRLTestControl->PrintToScreen(KNewLine);
	iNRLTestControl->PrintToScreen(aTestHeader);
	iNRLTestControl->PrintLineToScreen (_L("Test"));
	iNRLTestControl->PrintToScreen(KNewLine);

	}


void CNRLTestAppUi::StartTestsL ()
	{
	TestLocaleL(KLocaleTestTitle);
	TestResourcesL (KResourceTestTitle);
	TestCharSetNamesL(KCharSetNamesTest);
	TestCollation(KCollationTestTitle);
	TestFEPNamesL(KFEPNameTestTitle);
	TestDisplayMessagingL(KTDisplayMessaging);
	TestBIFL(KBIFTestTitle);
	TestPrinterNameL (KPrinterNameTestTitle);
	TestLocalisableBitmapL (KLocalisableBimap);
	ReportEndResult();
	
	}


void CNRLTestAppUi::TestLocaleL (const TDesC& aTestHeader)
	{

	// print on console that we are starting the Locale Testing
	// just checking it is not enough, need to display as well that 
	// the result is as expected. 
	//Test a few other things besides the 
	// locale number, some thing like a currency symbol. == $$$ 
	
	WriteTestHeader(aTestHeader);
	iNRLTestControl->PrintLineToScreen(_L("Have to ensure that the correct locale is picked up"));
	iNRLTestControl->PrintLineToScreen(_L("Expected Locale with language extension"));

	TInt language; 
	(void)HAL::Get(HAL::ELanguageIndex,language);
	iNRLTestControl->PrintLineToScreen(_L("%d"),language);
	iNRLTestControl->PrintToScreen(_L("Current Locales language extension:	"));

	TInt currentLangId;
	currentLangId = TInt(User::Language());
	iNRLTestControl->PrintLineToScreen(_L("%d"),currentLangId);

	if (currentLangId == 95 )
		{
		TCurrencySymbol theCurrencySymbol;
		_LIT(KExpectedCurrencySymbol,"$$$");
		if(theCurrencySymbol==KExpectedCurrencySymbol)
			{
			iNRLTestControl->PrintLineToScreen(_L("The correct locale was loaded"));
			Pass(aTestHeader);
			}
		}
	else
		{
		iNRLTestControl->PrintToScreen(_L("The correct locale was not loaded"));
		FailL(aTestHeader);
		}
	}

void CNRLTestAppUi::TestResourcesL(const TDesC& aTestHeader)
	{
	WriteTestHeader(aTestHeader);
	iNRLTestControl->PrintLineToScreen (_L("Reading information from resource file..."));

	TResourceReader resourceReader;
	CCoeEnv::Static()->CreateResourceReaderLC(resourceReader,R_NRL_COLLATE);
	CDesCArray* collation=new(ELeave) CDesCArrayFlat(3);
	CleanupStack::PushL(collation);
	TInt n=resourceReader.ReadUint16();
	
	for (TInt i=0;i<n;i++)
		collation->AppendL(resourceReader.ReadTPtrC());

	for (TInt j=0;j<n;j++)
		{
		iNRLTestControl->PrintLineToScreen((*collation)[j]);
		}
	
	_LIT(KResourceData,"David");
	TInt resourceTest; 
	collation->Find(KResourceData,resourceTest,ECmpCollated);
	if(resourceTest!=collation->MdcaCount())
		{
		Pass(aTestHeader);
		}
	else
		{
		FailL(aTestHeader);
		}
	CleanupStack::PopAndDestroy(2);//resourceReader,collation
	}

void CNRLTestAppUi::TestCharSetNamesL(const TDesC& aTestHeader)
	{
	WriteTestHeader(aTestHeader);
	RFs& aSession = iCoeEnv->FsSession();
	CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* charsetArray=CCnvCharacterSetConverter::CreateArrayOfCharacterSetsAvailableLC(aSession);
	MDesCArray* nameArry=CCnvCharacterSetNames::NewL(aSession,charsetArray->Array());
	TInt index=((CCnvCharacterSetNames*)nameArry)->IndexOfIdentifier(KCharacterSetIdentifierAscii);
	TInt testResult;
	testResult=0;
	TPtrC bigFive=nameArry->MdcaPoint(index);
	TInt findNonROM;
	findNonROM=bigFive.Find(KNonROM);
	if(findNonROM!=KErrNotFound)
		{
		iNRLTestControl->PrintToScreen(KNewLine);
		iNRLTestControl->PrintLineToScreen(bigFive);
		testResult=1;
		}
	if(testResult)
		Pass(aTestHeader);
	else
		FailL(aTestHeader);
	delete nameArry;
	CleanupStack::PopAndDestroy();//charsetArray
	}



void CNRLTestAppUi::TestCollation(const TDesC& aTestHeader)
	{
	WriteTestHeader(aTestHeader);
	iNRLTestControl->PrintToScreen(_L("This test locale has it's own collation table\n"));
	iNRLTestControl->PrintToScreen(_L("Set Collation values in the order E-D-C-B-A\n"));
	iNRLTestControl->PrintToScreen(_L("Loading a few names which have been sorted using collation\n"));
	iNRLTestControl->PrintToScreen(_L("David should appear before BeiBei\n\n"));
	TResourceReader resourceReader;
	CCoeEnv::Static()->CreateResourceReaderLC(resourceReader,R_NRL_COLLATE);
	CDesCArray* collation=new(ELeave) CDesCArrayFlat(3);
	CleanupStack::PushL(collation);
	TInt n=resourceReader.ReadUint16();
	
	for (TInt i=0;i<n;i++)
		collation->AppendL(resourceReader.ReadTPtrC());
	//David is the first name stored in the array before the array is sorted.
	//When the array is sorted, David should still be the first name
	// because this locales collation table reverses the ordering between A & E 
	TPtrC david = (*collation)[0];
	collation->Sort(ECmpCollated);
	for (TInt j=0;j<n;j++)
		{
		iNRLTestControl->PrintLineToScreen((*collation)[j]);
		}
	
	TInt coltest;
	
	// searching for Davids name in the array,
	// according to the new collation rules David's name should be 
	// the first itm in the array. 

	collation->Find(david,coltest,ECmpCollated);
	// if coltest=0 then Davids is the first item, 
	// the new collation table was used. 
	if (!coltest)
		{
		Pass(aTestHeader);
		}
	else
		{
		FailL(aTestHeader);
		}
		
	CleanupStack::PopAndDestroy(2);//resourceReader,collation
	}


void CNRLTestAppUi::TestFEPNamesL(const TDesC& aTestHeader)
	{
	WriteTestHeader(aTestHeader);
	iNRLTestControl->PrintLineToScreen (_L("Fep Names are stored in resource files in the fep directory in system"));
	iNRLTestControl->PrintLineToScreen (_L("Compiled new resources with the word Non-ROM added into a few test fep names"));
	
	RArray<CBaNamedPlugins::TResourceFile> arrayOfResourceFiles;
	CleanupStack::PushL(TCleanupItem(DestroyResourceFileArray, &arrayOfResourceFiles));//arrayOfResourceFiles
	RFs& fileServerSession=iCoeEnv->FsSession();
	TInt numberofsession=fileServerSession.ResourceCount();
	TInt i;
	TParse* parser=new(ELeave) TParse;
	CleanupStack::PushL(parser);//parser
	TFileName* fileName=new(ELeave) TFileName;
	CleanupStack::PushL(fileName);//fileName
	 

	RArray<TUid> uidsOfAvailableFeps;
	CleanupClosePushL(uidsOfAvailableFeps);
	CDesCArray*  fileNamesOfAvailableFeps = new(ELeave) CDesCArrayFlat(EGranularity);
	CleanupDeletePushL(fileNamesOfAvailableFeps);//fileNamesOfAvailableFeps
	iCoeEnv->AvailableFepsL(uidsOfAvailableFeps,fileNamesOfAvailableFeps);//it is allocated some memory here!!!
	
	
	
	for (i=fileNamesOfAvailableFeps->MdcaCount()-1; i>=0; --i)
		{
		const TPtrC fullFileNameOfDll(fileNamesOfAvailableFeps->MdcaPoint(i));
		*fileName=TParsePtrC(fullFileNameOfDll).Name();
		fileName->Append(KLitResourceFileNameAppendage);
		User::LeaveIfError(parser->SetNoWild(*fileName, &fullFileNameOfDll, NULL));
		CBaNamedPlugins::TResourceFile resourceFile;
		resourceFile.iFullFileName=parser->FullName().AllocLC();
		resourceFile.iIdentifier=fullFileNameOfDll.AllocLC();
		resourceFile.iUid=uidsOfAvailableFeps[i];
		resourceFile.iFormat=CBaNamedPlugins::TResourceFile::EFormatTbuf;
		User::LeaveIfError(arrayOfResourceFiles.Append(resourceFile));
		CleanupStack::Pop(2, resourceFile.iFullFileName);//iFullFileName,iIdentifier
		}
	CleanupStack::PopAndDestroy(4, parser);//parser,fileName,uidsOfAvailableFeps,fileNamesOfAvailableFeps

	CBaNamedPlugins::CParameters* parameters=CBaNamedPlugins::CParameters::NewLC(fileServerSession, arrayOfResourceFiles.Array());
	parameters->SetFallBackName(*this);
	CBaNamedPlugins* namedPlugins=CBaNamedPlugins::NewL(*parameters);//numberofsession increased after this
	numberofsession=fileServerSession.ResourceCount(); 
	const TInt numberOfAvailableFeps=namedPlugins->MdcaCount();
	TInt testResult; 
	testResult=0;
	for (i=0; i<numberOfAvailableFeps; ++i)
		{
		TPtrC fepNames = namedPlugins->MdcaPoint(i);
		RDebug::Print(fepNames);
		TInt findNonROM;
		findNonROM=fepNames.Find(KNonROM);
		if (findNonROM!=KErrNotFound)
			{
			iNRLTestControl->PrintLineToScreen(fepNames);
			testResult =1;
			}
		}
	if (testResult)
		{
		Pass(aTestHeader);
		}
	else
		{
		FailL(aTestHeader);
		}
	delete namedPlugins;
	CleanupStack::PopAndDestroy(2, &arrayOfResourceFiles);//arrayOfResourceFiles,parameters
	}

HBufC* CNRLTestAppUi::FallBackNameL(const TDesC& aFullResourceFileName) const
	{
	const TPtrC nameAndExtension(TParsePtrC(aFullResourceFileName).NameAndExt());
	__ASSERT_DEBUG(nameAndExtension.Right(KLitResourceFileNameAppendage().Length())==KLitResourceFileNameAppendage, User::Panic(KPanicText,-1));
	return nameAndExtension.Left(nameAndExtension.Length()-KLitResourceFileNameAppendage().Length()).AllocL();
	}

void CNRLTestAppUi::TestDisplayMessagingL(const TDesC& aTestHeader)
	{
	WriteTestHeader(aTestHeader);
	iNRLTestControl->PrintLineToScreen (_L("MTM are stored in resource files in the MTM directory in System"));
	iNRLTestControl->PrintLineToScreen (_L("Compiled new resources with the word Non-ROM added into the MTM resources"));

	TDummyObserver obs;
	CMsvSession *session=CMsvSession::OpenSyncL(obs);
	CleanupStack::PushL(session);
	CClientMtmRegistry *reg=CClientMtmRegistry::NewL(*session);
	CleanupStack::PushL(reg);
	TInt count=reg->NumRegisteredMtmDlls();
	
	TInt testResult; 
	testResult=0;
	while(count--)
		{
		const CMtmDllInfo& info=reg->RegisteredMtmDllInfo(reg->MtmTypeUid(count));
		TPtrC mtmNames = info.HumanReadableName();
		TInt findNonROM;
		findNonROM=mtmNames.Find(KNonROM);
		if (findNonROM!=KErrNotFound)
			{
			iNRLTestControl->PrintLineToScreen (mtmNames);
			testResult =1;
			}
		
		}

	CleanupStack::PopAndDestroy(reg);

	CMsvEntry *entry=session->GetEntryL(KMsvRootIndexEntryId);
	CleanupStack::PushL(entry);

	entry->SetEntryL(KMsvDraftEntryId);
	iNRLTestControl->PrintLineToScreen (entry->Entry().iDetails);
	

	entry->SetEntryL(KMsvGlobalInBoxIndexEntryId);
	iNRLTestControl->PrintLineToScreen (entry->Entry().iDetails);

	entry->SetEntryL(KMsvGlobalOutBoxIndexEntryId);
	iNRLTestControl->PrintLineToScreen (entry->Entry().iDetails);

	entry->SetEntryL(KMsvSentEntryId);
	iNRLTestControl->PrintLineToScreen (entry->Entry().iDetails);

	CleanupStack::PopAndDestroy(entry);
	CleanupStack::PopAndDestroy(session);
	
	if (testResult)
		{
		Pass(aTestHeader);
		}
	else
		{
		FailL(aTestHeader);
		}
	}



void CNRLTestAppUi::TestBIFL (const TDesC& aTestHeader)
	{
	WriteTestHeader(aTestHeader);
	iNRLTestControl->PrintLineToScreen(_L("BIF files are now stored as resources in System\\BIf directory"));
	iNRLTestControl->PrintLineToScreen(_L("Compiled new BIF resources with the phrase Non-ROM added ... "));

	RFs& gFs=iCoeEnv->FsSession();
	
	iNRLTestControl->PrintLineToScreen(_L("Opening & Searching DB"));

	CBIODatabase* bioDB = CBIODatabase::NewL(gFs);
	CleanupStack::PushL( bioDB );
	iNRLTestControl->PrintLineToScreen(_L("Opened DB Successfully!"));

	TInt testResult; 
	testResult=0;
	for (TInt i=0; i < bioDB->BIOCount(); i++)
		{
			const CBioInfoFileReader& bifReader = bioDB->BifReader(i);

			TPtrC desc;
			desc.Set(bifReader.Description()); 
			TInt findNonROM;
			findNonROM=desc.Find((KNonROM));
			if (findNonROM!=KErrNotFound)
				{
				iNRLTestControl->PrintLineToScreen(desc);
				testResult =1;
				}
		}

	if (testResult)
		{
		Pass(aTestHeader);
		}
	else
		{
		FailL(aTestHeader);
		}
	CleanupStack::PopAndDestroy();	// bioDB
	
	}

void CNRLTestAppUi::TestPrinterNameL (const TDesC& aTestHeader)
	{
	
	WriteTestHeader(aTestHeader);

	CDesCArray* list=new(ELeave) CDesCArrayFlat(EGranularity);
	CleanupStack::PushL(list);

	CPrintSetup* aPrintSetup = CPrintSetup::NewL();
	CleanupStack::PushL(aPrintSetup);
	aPrintSetup->AddPrinterDriverDirL( KDefaultPrinterDriverPath );
	RFs& filesession = iCoeEnv->FsSession();
	CPrinterModelList* aModelList;
	aModelList = aPrintSetup->ModelNameListL(filesession);
	CEikonEnv::GetPrinterNamesL(aModelList,*list);

	aPrintSetup->FreeModelList();

	TInt foundNonRomResource=0; 

	for (TInt i=0; i < list->Count(); ++i)
		{
		TPtrC desc;
		desc.Set((*list)[i]);
		TInt findNonROM; 
		findNonROM = desc.Find((KNonROM));
		if (findNonROM!=KErrNotFound)
			{
			iNRLTestControl->PrintLineToScreen (desc);
			foundNonRomResource=1;
			}
		}
	if (foundNonRomResource)
		Pass(aTestHeader);
	else
		FailL(aTestHeader);


	CleanupStack::PopAndDestroy(2); // list, aPrintSetup, aModelList
	
	}

void CNRLTestAppUi::TestLocalisableBitmapL(const TDesC& aTestHeader)
	{
	WriteTestHeader(aTestHeader);

	TFileName filename(KOriginalBitmapPath);
	CWsBitmap* aBitmap;
	aBitmap=iEikonEnv->CreateBitmapL(filename,1);
	TBool nonROM;
	nonROM=aBitmap->IsRomBitmap();
	if(nonROM)
		{
		FailL(aTestHeader);
		}
	else
		{
		iNRLTestControl->PrintLineToScreen(_L("Right, the bitmap loaded should not be in ROM"));
		Pass(aTestHeader);
		}

	delete aBitmap;
	}


void CNRLTestAppUi::Pass(const TDesC& aTestHeader)
	{
	iNRLTestControl->PrintToScreen(KNewLine);
	iNRLTestControl->PrintLineToScreen(KTestAnnouncer);
	iNRLTestControl->PrintLineToScreen(_L("Expected new %S loaded"),&aTestHeader);
	iNRLTestControl->PrintLineToScreen(KTestAnnouncer);
	}

void CNRLTestAppUi::FailL(const TDesC& aTestHeader)
	{
	iNRLTestControl->PrintToScreen(KNewLine);
	iNRLTestControl->PrintLineToScreen(KTestAnnouncer);
	iNRLTestControl->PrintLineToScreen(_L("Unexpected old %S loaded"),&aTestHeader);
	iNRLTestControl->PrintLineToScreen(KTestAnnouncer);
	iFailedTests->AppendL(aTestHeader);

	}

void CNRLTestAppUi::ReportEndResult() const
	{
	TInt failedTestsCount = iFailedTests->Count();
	if (failedTestsCount)
		{
		// Print a list of the Tests Failed 
		iNRLTestControl->PrintLineToScreen(_L("The following tests failed\n"));
		for (TInt i=0; i<failedTestsCount; ++i)
			{
			iNRLTestControl->PrintLineToScreen ((*iFailedTests)[i]);
			}
		}
	else
		{
		// No Tests Failed, say that new resources were loaded where expected to
		}
	}


//
//  --------------------- CNRLTestAppDoc class Definition ------------ 
//

class CNRLTestAppDoc : public CEikDocument
	{
public:
	CNRLTestAppDoc(CEikApplication& aApp);
private:
	CEikAppUi* CreateAppUiL();
	};


CNRLTestAppDoc::CNRLTestAppDoc(CEikApplication& aApp):CEikDocument(aApp)
	{
	// Nothing else to do, just call the base class constructor
	//
	}

CEikAppUi* CNRLTestAppDoc::CreateAppUiL()
	{
	return new (ELeave) CNRLTestAppUi;
	}
//
//  ------------------------------ CNRLTestApp ----------------------- 
//


const TUid KTestNRLid = {0x1000AC5D};

class CNRLTestApp : public CEikApplication
	{
private:
	CApaDocument* CreateDocumentL();
	TUid AppDllUid() const;

	};

TUid CNRLTestApp::AppDllUid() const 
	{
	return KTestNRLid;
	}

CApaDocument* CNRLTestApp::CreateDocumentL()
	{
	return new (ELeave) CNRLTestAppDoc(*this);
	}

////////////////////////////////////////////////////////////////////////////////////////////
//

	static CApaApplication* NewApplication()
		{
		return new CNRLTestApp;
		}

	TInt E32Main()
		{
		return EikStart::RunApplication(&NewApplication);
		}