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

// This is a support executable used by "Cone\tef\TConeTestServer" (TCone4Step in particular)

// This application covers the following tests for the static objects

// Test 1 : Existing CCoeStatic derived objects using the 2 parameter

// constructor must be destroyed before the app ui.

// Way to test this,

// Case 1: Get hold of a particular static using CCoeEnv::Static(TUid aUid) 

// in an application's override of CEikAppUi::PrepareToExit() and confirm the 

// returned pointer is not null. 

// Case 2: Then, the same thing is done in the app ui's destructor to check that 

// the pointer is now null.

// Test 2: A static constructed with a negative priority should be accessible from the 

// app ui's destructor, but then destroyed before another static that has a lower priority value.

// Way to test this,

// Case 1: Construct a static (A) using the 3 parameter constructor, specifying a negative priority.

// Then construct another static (B) specifying a priority (A's priority - 1). 

// Check that static A is still non-null when accessed from the app ui's destructor. 

// Case 2: Then check that static A is null when accessed from B's destructor.

// Test 3: Given two statics with different positive priorities,

// the higher priority one should be destroyed first.

// Way to test this,

// Case 1: If (for example) static A has priority EDefaultDestructionPriority,

// and static B has EDefaultDestructionPriority-1, A's destructor should be able to access B,

// Case 2: But B's destructor shouldn't be able to access A.

// Test 4: Statics with priorities immediately either side of the pre/post-destroy app ui should be destroyed before/after the app ui. Should also test that 

// the first negative priority static is destroyed and not "skipped over" when the code calculates

// which static should be destroyed next after the app ui has been destroyed.

// Way to test this,

// Case 1: We could create statics A, B and C with priority zero, -1 and -2 respectively. 

// Then check in the app ui destructor that A is null, and B and C are both non-null.

// Case 2: Then in B's destructor check that C is still non-null.

// Case 3: And in C's destructor check that B is now null.

// 

//

/**

 @file

 @internalComponent - Internal Symbian test code 

*/

#include <coeccntx.h>

#include <apgtask.h>

#include <eikenv.h>

#include <eikappui.h>

#include <eikapp.h>

#include <eikdoc.h>

#include <techview/eikmenup.h>

#include <f32file.h>

#include <techview/eikon.hrh>

#include <eikstart.h> //TKAS added for exe-app

#include <tconetestexe.rsg>

//! File which stores the test results.\n

_LIT(KConeTestResultsFileName, "c:\\system\\conetest\\ConeTestResultsFile2.txt");

//! Cone Test Directory.\n

_LIT(KConeTestDir, "c:\\system\\conetest\\");

//! Literal for Test Pass.\n

_LIT8(KTestPass ,"PASS\r\n");

//! Literal for Test Fail.\n

_LIT8(KTestFail,"FAIL\r\n");

//! Literal to indicate Test number one.\n

_LIT8(KConeTest1,"Test1:");

//! Literal to indicate Test number two.\n

_LIT8(KConeTest2,"Test2:");

//! Literal to indicate Test number three.\n

_LIT8(KConeTest3,"Test3:");

//! Literal to indicate Test number four.\n

_LIT8(KConeTest4,"Test4:");

//! Literal to indicate case number one.\n

_LIT8(KConeTestCase1,"Case1:");

//! Literal to indicate case number Two.\n

_LIT8(KConeTestCase2,"Case2:");

//! Literal to indicate Case number three.\n

_LIT8(KConeTestCase3,"Case3:");

//! Uid for Cone Test Application.\n

const TUid KUidConeTestApp = {0x10004C5A};

//! Uids for diffent classes for static 

//! Unique Uid for object of Singleton Class CTConeTestStatic.\n

const TUid KUidTestStatic		 = 	{0x13003ACE}; 

//! Unique Uid for object of Singleton Class CTConeTestNegativePrioStaticA.\n

const TUid KUidTestStaticNegativePrioA = {0x13004ACE}; 

//! Unique Uid for object of Singleton Class CTConeTestNegativePrioStaticB.\n

const TUid KUidTestStaticNegativePrioB = {0x13005ACE}; 

//! Unique Uid for object of Singleton Class CTConeTestPosPrioStaticA.\n

const TUid KUidTestStaticPosPriA =	{0x13006ACE};

//! Unique Uid for object of Singleton Class CTConeTestPosPrioStaticB.\n

const TUid KUidTestStaticPosPriB = 	{0x13007ACE};

//! Unique Uid for object of Singleton Class CTConeTestPrioZeroStaticA.\n

const TUid KUidTestStaticPriZeroA=	{0x13009ACE};

//! Unique Uid for object of Singleton Class CTConeTestPrioOneStaticB.\n

const TUid KUidTestStaticPriOneB =	{0x1300AACE};

//! Unique Uid for object of Singleton Class CTConeTestPrioTwoStaticC.\n

const TUid KUidTestStaticPriTwoC =	{0x1300BACE};

//! Priorities for static objects

enum {ENegativePriortyStaticA = -3};

enum {EPriorityTwoStaticC= -2,EPriorityOneStaticB = -1,EPriorityZeroStaticA= 0};

//! A CCoeStatic derived class.\n

/**

  Class used to test the deletion of a CCoeStatic members before deletion of appUi class.\n

*/

class CTConeTestStatic : public CCoeStatic

	{

public:

	inline CTConeTestStatic(RFile& aFile);

	inline static CTConeTestStatic* Self();

	~CTConeTestStatic();

	RFile iFile;

	};

/**

  Destructor for CTConeTestStatic Class.\n

*/

CTConeTestStatic::~CTConeTestStatic()

	{

	}

//! A CCoeStatic derived class.\n

/**

  A Static Class with Negative priority for Test Case 2.\n

*/

class CTConeTestNegativePrioStaticA : public CCoeStatic

	{

public:

	inline CTConeTestNegativePrioStaticA(RFile& aFile);

	inline static CTConeTestNegativePrioStaticA* Self();

	~CTConeTestNegativePrioStaticA();

	RFile& iFile;

	};

//! A CCoeStatic derived class.\n

/**

  Static class with negative priority for Test case 2. (priority less than CTConeTestNegativePrioStaticA).\n

*/

class CTConeTestNegativePrioStaticB : public CCoeStatic

	{

public:

	inline CTConeTestNegativePrioStaticB();

	inline static CTConeTestNegativePrioStaticB* Self();

	~CTConeTestNegativePrioStaticB();

	RFile iFile;

	RFs iFs;

	};

/**

  Destructor for CTConeTestNegativePrioStaticA Class.\n

*/

CTConeTestNegativePrioStaticA::~CTConeTestNegativePrioStaticA()

	{

	}

/**

   @SYMTestCaseID UIF-TConeTestApp-Test2Case2

   @SYMPREQ

   @SYMTestCaseDesc Check for the order of deletion of CCoeStatic objects with 

   negative priorities.\n

   @SYMTestPriority High

   @SYMTestStatus Implemented

   @SYMTestActions : CTConeTestNegativePrioStaticA and CTConeTestNegativePrioStaticB objects

   have negative priorities.\n

   CTConeTestNegativePrioStaticB has lower negative priority than CTConeTestNegativePrioStaticA object.\n

   CTConeTestNegativePrioStaticA object should be deleted before  CTConeTestNegativePrioStaticB object.\n

   Hence a pointer to CTConeTestNegativePrioStaticA is obtained in CTConeTestNegativePrioStaticB destructor.\n

   @SYMTestExpectedResults The CTConeTestNegativePrioStaticA object pointer should be NULL.\n

   @SYMTestType : CIT 

 */

CTConeTestNegativePrioStaticB::~CTConeTestNegativePrioStaticB()

	{

	// Test 2, Case 2

	CTConeTestNegativePrioStaticA* testCoeStaticA = CTConeTestNegativePrioStaticA::Self();

	iFile.Write(KConeTest2);

	iFile.Write(KConeTestCase2);

	if(testCoeStaticA == NULL)

		iFile.Write(KTestPass);

	else

		iFile.Write(KTestFail);

	// CTConeTestNegativePrioStaticB class object is the most negative prioritised

	// static objects .Hence the file and session handles are closed here as no

	// more logging is required hereafter. 	

	iFile.Close();

	iFs.Close();	

	}

// Static class with positive priority for Test case 3:

//! A CCoeStatic derived class.\n

/**

  Static class with positive priority for Test case 3:

*/

class CTConeTestPosPrioStaticA : public CCoeStatic

	{

public:

	inline CTConeTestPosPrioStaticA(RFile& aFile);

	inline static CTConeTestPosPrioStaticA* Self();

	~CTConeTestPosPrioStaticA();

	RFile& iFile;

	};

// static class with positive priority less than CTConeTestPosPrioStaticA for Test case 3.

//! A CCoeStatic derived class.\n

/**

  Static class with positive priority less than CTConeTestPosPrioStaticA for Test case 3.\n

*/

class CTConeTestPosPrioStaticB : public CCoeStatic

	{

public:

	inline CTConeTestPosPrioStaticB(RFile& aFile);

	inline static CTConeTestPosPrioStaticB* Self();

	~CTConeTestPosPrioStaticB();

	RFile& iFile;

	};

/**

   @SYMTestCaseID UIF-TConeTestApp-Test3Case1

   @SYMPREQ

   @SYMTestCaseDesc Check for the availabity of CCoeStatic object with 

   lower positive priority in destructor of higher positive priority object.\n

   @SYMTestPriority High

   @SYMTestStatus Implemented

   @SYMTestActions : CTConeTestPosPrioStaticA and CTConeTestPosPrioStaticB objects

   have positive priorities.\n

   CTConeTestPosPrioStaticB has lower priority than CTConeTestPosPrioStaticA object.\n

   CTConeTestNegativePrioStaticB object should be available in  CTConeTestPosPrioStaticA object's destructor.\n

   Hence a pointer to CTConeTestPosPrioStaticB is obtained in CTConeTestPosPrioStaticA's destructor.\n

   @SYMTestExpectedResults The CTConeTestPosPrioStaticB object pointer should not be NULL.\n

   @SYMTestType : CIT 

 */

CTConeTestPosPrioStaticA::~CTConeTestPosPrioStaticA()

	{

	// Test 3 , Case 1

	CTConeTestPosPrioStaticB* testPosPrioStaticB = CTConeTestPosPrioStaticB::Self();

	iFile.Write(KConeTest3);

	iFile.Write(KConeTestCase1);

	if(testPosPrioStaticB != NULL)

		iFile.Write(KTestPass);

	else

		iFile.Write(KTestFail);

	}

/**

   @SYMTestCaseID UIF-TConeTestApp-Test3Case2

   @SYMPREQ

   @SYMTestCaseDesc Check for the order of deletion of CCoeStatics object with 

   different positive priorities.\n

   @SYMTestPriority High

   @SYMTestStatus Implemented

   @SYMTestActions : CTConeTestPosPrioStaticA and CTConeTestPosPrioStaticB objects

   have positive priorities.\n

   CTConeTestPosPrioStaticB has lower priority than CTConeTestPosPrioStaticA object.\n

   CTConeTestNegativePrioStaticA object should be deleted before CTConeTestPosPrioStaticB object's destructor is called.\n

   Hence a pointer to CTConeTestPosPrioStaticA is obtained in CTConeTestPosPrioStaticB's destructor.\n

   @SYMTestExpectedResults The CTConeTestPosPrioStaticA object pointer should be NULL.\n

   @SYMTestType : CIT 

 */

CTConeTestPosPrioStaticB::~CTConeTestPosPrioStaticB()

	{

	// Test 3 , Case 2

	CTConeTestPosPrioStaticA* testPosPrioStaticA = CTConeTestPosPrioStaticA::Self();

	iFile.Write(KConeTest3);

	iFile.Write(KConeTestCase2);

	if(testPosPrioStaticA == NULL)

		iFile.Write(KTestPass);

	else

		iFile.Write(KTestFail);

	}

//! A CCoeStatic derived class.\n

/**

  A static class with  priority 0 for test case 4

*/

class CTConeTestPrioZeroStaticA : public CCoeStatic

	{

public:

	inline CTConeTestPrioZeroStaticA(RFile& aFile);

	inline static CTConeTestPrioZeroStaticA* Self();

	~CTConeTestPrioZeroStaticA();

	RFile& iFile;

	};

//! A CCoeStatic derived class.\n

/**

  A static class with priority -1 for test case 4

*/

class CTConeTestPrioOneStaticB : public CCoeStatic

	{

public:

	inline CTConeTestPrioOneStaticB(RFile& aFile);

	inline static CTConeTestPrioOneStaticB* Self();

	~CTConeTestPrioOneStaticB();

	RFile& iFile;

	};

//! A CCoeStatic derived class.\n

/**

  A static class with priority -2 for test case 4	

*/

class CTConeTestPrioTwoStaticC : public CCoeStatic

	{

public:

	inline CTConeTestPrioTwoStaticC(RFile& aFile);

	inline static CTConeTestPrioTwoStaticC* Self();

	~CTConeTestPrioTwoStaticC();

	RFile& iFile;

	};

/**

  Destructor for CTConeTestPrioZeroStaticA Class.\n

*/ 

CTConeTestPrioZeroStaticA::~CTConeTestPrioZeroStaticA()

	{

	}

/**

   @SYMTestCaseID UIF-TConeTestApp-Test4Case2

   @SYMPREQ

   @SYMTestCaseDesc Check for the availability of CTConeTestPrioTwoStaticC object in 

   CTConeTestPrioOneStaticB's destructor.\n

   @SYMTestPriority High

   @SYMTestStatus Implemented

   @SYMTestActions : CTConeTestPrioOneStaticB and CTConeTestPrioTwoStaticC objects

   have negative priorities of -1 and -2 respectively.\n

   CTConeTestPrioTwoStaticC object should be available in CTConeTestPrioOneStaticB object's destructor is called.\n

   Hence a pointer to CTConeTestPrioTwoStaticC is obtained in CTConeTestPrioOneStaticB's destructor.\n

   @SYMTestExpectedResults The CTConeTestPosPrioStaticA object pointer should not be NULL.\n

   @SYMTestType : CIT 

 */	

CTConeTestPrioOneStaticB::~CTConeTestPrioOneStaticB()

	{

	// Test 4 , Case 2

	CTConeTestPrioTwoStaticC* testPrioTwoCoeStaticC = CTConeTestPrioTwoStaticC::Self();

	iFile.Write(KConeTest4);

	iFile.Write(KConeTestCase2);

	if(testPrioTwoCoeStaticC != NULL)

		iFile.Write(KTestPass);

	else

		iFile.Write(KTestFail);

	}

/**

   @SYMTestCaseID UIF-TConeTestApp-Test4Case3

   @SYMPREQ

   @SYMTestCaseDesc Check for the deletion of CTConeTestPrioOneStaticB object before  

   CTConeTestPrioTwoStaticC's destructor is called.\n

   @SYMTestPriority High

   @SYMTestStatus Implemented

   @SYMTestActions : CTConeTestPrioOneStaticB and CTConeTestPrioTwoStaticC objects

   have negative priorities of -1 and -2 respectively.\n

   CTConeTestPrioOneStaticB object should be deleted before CTConeTestPrioTwoStaticC object's destructor is called.\n

   Hence a pointer to CTConeTestPrioOneStaticB is obtained in CTConeTestPrioTwoStaticC's destructor.\n

   @SYMTestExpectedResults The CTConeTestPosPrioStaticA object pointer should be NULL.\n

   @SYMTestType : CIT 

 */	

CTConeTestPrioTwoStaticC::~CTConeTestPrioTwoStaticC()

	{

	// Test 4 , Case 3

	CTConeTestPrioOneStaticB* testPrioOneCoeStaticB = CTConeTestPrioOneStaticB::Self();

	iFile.Write(KConeTest4);

	iFile.Write(KConeTestCase3);

	if(testPrioOneCoeStaticB == NULL)

		iFile.Write(KTestPass);

	else

		iFile.Write(KTestFail);

	}

//

//

// CTConeTestAppView

//

//

//! A CCoeControl derived class.\n

/**

  View Class for TConeTestApp Application.\n

*/

class CTConeTestAppView : public CCoeControl

    {

public:

	static CTConeTestAppView* NewL(const TRect& aRect);

	CTConeTestAppView();

	~CTConeTestAppView();

    void ConstructL(const TRect& aRect);

private:

    // Inherited from CCoeControl

	void Draw(const TRect& /*aRect*/) const;

private:

	HBufC*  iConeTestText;

    };

/**

  Constructor for the View Class.\n

*/

CTConeTestAppView::CTConeTestAppView()

	{

	}

/**

  Static function used to instantiate the View Class.\n

  @return CTConeTestAppView*, Pointer to the newly created View.\n

*/

CTConeTestAppView* CTConeTestAppView::NewL(const TRect& aRect)

	{

	CTConeTestAppView* self = new(ELeave) CTConeTestAppView();

	CleanupStack::PushL(self);

	self->ConstructL(aRect);

	CleanupStack::Pop();

	return self;

	}

/**

  Destructor for the View Class.\n

*/

CTConeTestAppView::~CTConeTestAppView()

	{

	delete iConeTestText;

	}

/**

  Second phase constructor for CTConeTestAppView Class.\n

*/

void CTConeTestAppView::ConstructL(const TRect& aRect)

    {

	iConeTestText = iEikonEnv->AllocReadResourceL(R_TCONETEST_TEXT_TITLE);

	CreateWindowL();

	SetRect(aRect);

	ActivateL();

	}

/**

  Draws the TConeTestApp Application's View.\n

*/

void CTConeTestAppView::Draw(const TRect& /*aRect*/) const

	{

	CWindowGc& gc = SystemGc();

	TRect      drawRect = Rect();

	const CFont*  fontUsed = iEikonEnv->TitleFont();

	gc.Clear();

	gc.UseFont(fontUsed);

	TInt   baselineOffset=(drawRect.Height() - fontUsed->HeightInPixels())/2; 

	gc.DrawText(*iConeTestText,drawRect,baselineOffset,CGraphicsContext::ECenter, 0);

	gc.DiscardFont();

	}

//

//

// CTConeTestAppUi

//

//

//! A CEikAppUi derived class.\n

/**

  The class is the AppUi class for the TCone4Step test case.\n

*/

class CTConeTestAppUi : public CEikAppUi

    {

public:

    void ConstructL();

	~CTConeTestAppUi();

private:

    // Inherirted from class CEikAppUi

	void PrepareToExit();

	void HandleCommandL(TInt aCommand);

	void TestSetLogicalToPixelFontSizesL();

private:

	CCoeControl*	iAppView;

	};

/**

  Second phase constructor for  CTConeTestAppUi Class.\n

  Creates the following singleton objects.\n

  1. CTConeTestStatic.\n

  2. CTConeTestNegativePrioStaticA.\n

  3. CTConeTestPrioTwoStaticC.\n

  4. CTConeTestPosPrioStaticA.\n

  5. CTConeTestPosPrioStaticB.\n

  6. CTConeTestPrioZeroStaticA.\n

  7. CTConeTestPrioOneStaticB.\n