/*

* Copyright (c) 2002 - 2007 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:  MpxCollectionTest test module.

*

*/

// INCLUDE FILES

#include <mpxcollectionutility.h>

#include <mpxcollectionpath.h>

#include <mpxcollectionplaylist.h>

#include <mpxplaybackframeworkdefs.h>

#include <mpxcollectionmessage.h>

#include <mpxcollectionframeworkdefs.h>

#include <mpxmessagegeneraldefs.h> // KMPXMessageGeneralEvent, KMPXMessageGeneralType

#include <mpxmediageneraldefs.h>

#include <mpxmediaarray.h>

#include <mpxmediacontainerdefs.h>

#include <mpxattribute.h>

#include <stiflogger.h>

#include "testutility.h"

#include "testplaybackview.h"

#include "pathoptionmenu.h" 

#include "collectiontests.h"

#include "testpanic.h"

// MACROS

#define DELETE_PTR( PTR_VAR )\

	if( PTR_VAR )\

		{\

		delete PTR_VAR;\

		PTR_VAR = NULL;\

		}

#define DELETE_COLLECTION_PTR( PTR_VAR )\

	if( PTR_VAR )\

		{\

		PTR_VAR->Close();\

		PTR_VAR = NULL;\

		}

// return on failure

#define TMC_ASSERT( _TMCcode, _TMCcheckpt )\

	{\

	AssertL( _TMCcode, _TMCcheckpt );\

	if( !(_TMCcode ) )\

		{\

		return;\

		}\

	}

// DATA TYPES

// ============================ MEMBER FUNCTIONS ===============================

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

// CCollectionTests::NewL

// Two-phased constructor.

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

//

CCollectionTests* CCollectionTests::NewL(CConsoleMain* aConsoleMain,

                                    	 CTestBaseView* aParent,

                                   		 const TDesC& aName,

                                   	     CStifLogger* aLogger,

                                   	     TInt testIndex)

    {

    CCollectionTests* self = CCollectionTests::NewLC(aConsoleMain,

                                                     aParent,

                                                   	 aName,

                                                     aLogger,

                                                     testIndex);

    CleanupStack::PopAndDestroy(self);

    return self;

    }

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

// CCollectionTests::NewLC

// Two-phased constructor.

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

//

CCollectionTests* CCollectionTests::NewLC(CConsoleMain* aConsoleMain,

                                    	  CTestBaseView* aParent,

                                   		  const TDesC& aName,

                                   	      CStifLogger* aLogger,

                                   	      TInt testIndex)

    {

    CCollectionTests* self = new (ELeave) CCollectionTests(aConsoleMain,

                                                           aParent,

                                                   	       aName,

                                                           aLogger,

                                                           testIndex);

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// C++ default constructor.

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

CCollectionTests::CCollectionTests(CConsoleMain* aConsoleMain,

                                   CTestBaseView* aParent,

                                   const TDesC& aName,

                                   CStifLogger* aLogger,

                                   TInt testIndex)

    : CTestMenuView(aConsoleMain, aParent, aName),

      iCollectionUtility1(NULL), 

      iCollectionUtility2(NULL),

      iLogger(aLogger), 

      iTestIndex(testIndex), 

      iStopAtTestIndex(testIndex), 

      iTempCnt(0),

      iLatestTestResult(KErrNone)

    {    

    // set stop index for groups

    switch(iTestIndex)

    	{

    	case  21: iStopAtTestIndex =  35; break;

    	case  36: iStopAtTestIndex =  41; break;

    	case  42: iStopAtTestIndex =  53; break;

    	case  54: iStopAtTestIndex =  60; break;

    	case  70: iStopAtTestIndex =  81; break;

    	case  82: iStopAtTestIndex = 100; break;

    	case 101: iStopAtTestIndex = 109; break;

    	case 110: iStopAtTestIndex = 120; break;

    	case 121: iStopAtTestIndex = 140; break;

    	case 141: iStopAtTestIndex = 149; break;

    	case 150: iStopAtTestIndex = 169; break;

    	case 170: iStopAtTestIndex = 184; break;

    	case 185: iStopAtTestIndex = 189; break;

    	case 194: iStopAtTestIndex = 202; break;

    	}

    }

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

// Second phase constructor

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

void CCollectionTests::ConstructL()

    {

    CTestMenuView::ConstructL();

    }

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

// Destructor

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

CCollectionTests::~CCollectionTests()

    {

    iLogger->Log(_L("+CCollectionTests::~CCollectionTests"));  

    DELETE_COLLECTION_PTR(iCollectionUtility1);    	

    DELETE_COLLECTION_PTR(iCollectionUtility2);	    

    iLogger->Log(_L("-CCollectionTests::~CCollectionTests"));

    }

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

// Return whether test requires scheduler for aysynchronous wait.

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

TBool CCollectionTests::IsTestSynchronous(int testIndex)

	{

	// some cases do not use callbacks; so, no need to use scheduler

	return (testIndex == 20 ) || (testIndex >= 190 && testIndex <= 193);

	}

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

// Result from latest test

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

TInt CCollectionTests::GetLatestTestResult()

    {

    return iLatestTestResult;

	}

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

// Stop the current test

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

void CCollectionTests::TestCompleteL()

	{

	CurrentViewDoneL();

	}

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

// From CTestBaseView

// Handle number key press

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

void CCollectionTests::HandleNumKeyL()

    {            

    }

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

// From CTestBaseView

// Handle left key press

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

void CCollectionTests::HandleLeftKeyL()

    {

    iLogger->Log(_L("+CCollectionTests::HandleLeftKeyL"));

    iLogger->Log(_L("-CCollectionTests::HandleLeftKeyL"));

    }

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

// From CTestBaseView

// Handle right/enter key press

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

void CCollectionTests::HandleRightKeyL()

    {

    iLogger->Log(_L("+CCollectionTests::HandleRightKeyL"));

    iLogger->Log(_L("-CCollectionTests::HandleRightKeyL"));

    }   

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

// From CTestBaseView

// Cleanup the view before deactivate/destroy view

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

void CCollectionTests::CleanupViewL()

    {  

    }

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

// From CTestBaseView

// Initialize the view before display view

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

void CCollectionTests::InitializeViewL()

    {

    Collection1_Initialize();

    }          

void CCollectionTests::RunNext()

	{        

	if(iStopAtTestIndex == iTestIndex)

		{

		TestCompleteL();

		return;

		}

	iTestIndex++;

    StartNextTestL();

	}

void CCollectionTests::StartNextTestL()

{	

    switch(iTestIndex)

    	{

    	case   1: StartTest0001L(); break;

    	case   2: StartTest0002L(); break;

    	case   3: StartTest0003L(); break;

    	case   4: StartTest0004L(); break;

    	case   5: StartTest0005L(); break;

    	case   6: StartTest0006L(); break;

    	case   7: StartTest0007L(); break;

    	case   8: StartTest0008L(); break;

    	case   9: StartTest0009L(); break;

    	case  10: StartTest0010L(); break;

    	case  11: StartTest0011L(); break;

    	case  12: StartTest0012L(); break;

    	case  13: StartTest0013L(); break;

    	case  14: StartTest0014L(); break;

    	case  15: StartTest0015L(); break;

    	case  16: StartTest0016L(); break;

    	case  17: StartTest0017L(); break;

    	case  18: StartTest0018L(); break;

    	case  19: StartTest0019L(); break;

    	case  20: StartTest0020L(); break;

    	case  21: StartTest0021L(); break;

    	case  22: StartTest0022L(); break;

    	case  23: StartTest0023L(); break;

    	case  24: StartTest0024L(); break;

    	case  25: StartTest0025L(); break;

    	case  26: StartTest0026L(); break;

    	case  27: StartTest0027L(); break;

    	case  28: StartTest0028L(); break;

    	case  29: StartTest0029L(); break;

    	case  30: StartTest0030L(); break;

    	case  31: StartTest0031L(); break;

    	case  32: StartTest0032L(); break;

    	case  33: StartTest0033L(); break;

    	case  34: StartTest0034L(); break;

    	case  35: StartTest0035L(); break;

    	case  36: StartTest0036L(); break;

    	case  37: StartTest0037L(); break;

    	case  38: StartTest0038L(); break;

    	case  39: StartTest0039L(); break;

    	case  40: StartTest0040L(); break;

    	case  41: StartTest0041L(); break;

    	case  42: StartTest0042L(); break;

    	case  43: StartTest0043L(); break;

    	case  44: StartTest0044L(); break;

    	case  45: StartTest0045L(); break;

    	case  46: StartTest0046L(); break;

    	case  47: StartTest0047L(); break;

    	case  48: StartTest0048L(); break;

    	case  49: StartTest0049L(); break;

    	case  50: StartTest0050L(); break;

    	case  51: StartTest0051L(); break;

    	case  52: StartTest0052L(); break;

    	case  53: StartTest0053L(); break;

    	case  54: StartTest0054L(); break;

    	case  55: StartTest0055L(); break;

    	case  56: StartTest0056L(); break;

    	case  57: StartTest0057L(); break;

    	case  58: StartTest0058L(); break;

    	case  59: StartTest0059L(); break;

    	case  60: StartTest0060L(); break;

    	case  61: StartTest0061L(); break;

    	case  62: StartTest0062L(); break;

    	case  63: StartTest0063L(); break;

    	case  64: StartTest0064L(); break;

    	case  65: StartTest0065L(); break;

    	case  66: StartTest0066L(); break;

    	case  67: StartTest0067L(); break;

    	case  68: StartTest0068L(); break;

    	case  69: StartTest0069L(); break;

    	case  70: StartTest0070L(); break;

    	case  71: StartTest0071L(); break;

    	case  72: StartTest0072L(); break;

    	case  73: StartTest0073L(); break;

    	case  74: StartTest0074L(); break;

    	case  75: StartTest0075L(); break;

    	case  76: StartTest0076L(); break;

    	case  77: StartTest0077L(); break;

    	case  78: StartTest0078L(); break;

    	case  79: StartTest0079L(); break;

    	case  80: StartTest0080L(); break;

    	case  81: StartTest0081L(); break;

    	case  82: StartTest0082L(); break;

    	case  83: StartTest0083L(); break;

    	case  84: StartTest0084L(); break;

    	case  85: StartTest0085L(); break;

    	case  86: StartTest0086L(); break;

    	case  87: StartTest0087L(); break;

    	case  88: StartTest0088L(); break;

    	case  89: StartTest0089L(); break;

    	case  90: StartTest0090L(); break;

    	case  91: StartTest0091L(); break;

    	case  92: StartTest0092L(); break;

    	case  93: StartTest0093L(); break;

    	case  94: StartTest0094L(); break;

    	case  95: StartTest0095L(); break;

    	case  96: StartTest0096L(); break;

    	case  97: StartTest0097L(); break;

    	case  98: StartTest0098L(); break;

    	case  99: StartTest0099L(); break;

    	case 100: StartTest0100L(); break;

    	case 101: StartTest0101L(); break;

    	case 102: StartTest0102L(); break;

    	case 103: StartTest0103L(); break;

    	case 104: StartTest0104L(); break;

    	case 105: StartTest0105L(); break;

    	case 106: StartTest0106L(); break;

    	case 107: StartTest0107L(); break;

    	case 108: StartTest0108L(); break;

    	case 109: StartTest0109L(); break;

    	case 110: StartTest0110L(); break;

    	case 111: StartTest0111L(); break;

    	case 112: StartTest0112L(); break;

    	case 113: StartTest0113L(); break;

    	case 114: StartTest0114L(); break;

    	case 115: StartTest0115L(); break;

    	case 116: StartTest0116L(); break;

    	case 117: StartTest0117L(); break;

    	case 118: StartTest0118L(); break;

    	case 119: StartTest0119L(); break;

    	case 120: StartTest0120L(); break;

    	case 121: StartTest0121L(); break;

    	case 122: StartTest0122L(); break;

    	case 123: StartTest0123L(); break;

    	case 124: StartTest0124L(); break;

    	case 125: StartTest0125L(); break;

    	case 126: StartTest0126L(); break;

    	case 127: StartTest0127L(); break;

    	case 128: StartTest0128L(); break;

    	case 129: StartTest0129L(); break;

    	case 130: StartTest0130L(); break;

    	case 131: StartTest0131L(); break;

    	case 132: StartTest0132L(); break;

    	case 133: StartTest0133L(); break;

    	case 134: StartTest0134L(); break;

    	case 135: StartTest0135L(); break;

    	case 136: StartTest0136L(); break;

    	case 137: StartTest0137L(); break;

    	case 138: StartTest0138L(); break;

    	case 139: StartTest0139L(); break;

    	case 140: StartTest0140L(); break;

    	case 141: StartTest0141L(); break;

    	case 142: StartTest0142L(); break;

    	case 143: StartTest0143L(); break;

    	case 144: StartTest0144L(); break;

    	case 145: StartTest0145L(); break;

    	case 146: StartTest0146L(); break;

    	case 147: StartTest0147L(); break;

    	case 148: StartTest0148L(); break;

    	case 149: StartTest0149L(); break;

    	case 150: StartTest0150L(); break;

    	case 151: StartTest0151L(); break;

    	case 152: StartTest0152L(); break;

    	case 153: StartTest0153L(); break;

    	case 154: StartTest0154L(); break;

    	case 155: StartTest0155L(); break;

    	case 156: StartTest0156L(); break;

    	case 157: StartTest0157L(); break;

    	case 158: StartTest0158L(); break;

    	case 159: StartTest0159L(); break;

    	case 160: StartTest0160L(); break;

    	case 161: StartTest0161L(); break;

    	case 162: StartTest0162L(); break;

    	case 163: StartTest0163L(); break;

    	case 164: StartTest0164L(); break;

    	case 165: StartTest0165L(); break;

    	case 166: StartTest0166L(); break;

    	case 167: StartTest0167L(); break;

    	case 168: StartTest0168L(); break;

    	case 169: StartTest0169L(); break;

    	case 170: StartTest0170L(); break;

    	case 171: StartTest0171L(); break;

    	case 172: StartTest0172L(); break;

    	case 173: StartTest0173L(); break;

    	case 174: StartTest0174L(); break;

    	case 175: StartTest0175L(); break;

    	case 176: StartTest0176L(); break;

    	case 177: StartTest0177L(); break;

    	case 178: StartTest0178L(); break;

    	case 179: StartTest0179L(); break;

    	case 180: StartTest0180L(); break;

    	case 181: StartTest0181L(); break;

    	case 182: StartTest0182L(); break;

    	case 183: StartTest0183L(); break;

    	case 184: StartTest0184L(); break;

    	case 185: StartTest0185L(); break;

    	case 186: StartTest0186L(); break;

    	case 187: StartTest0187L(); break;

    	case 188: StartTest0188L(); break;

    	case 189: StartTest0189L(); break;

    	case 190: StartTest0190L(); break;

    	case 191: StartTest0191L(); break;

    	case 192: StartTest0192L(); break;

    	case 193: StartTest0193L(); break;

    	case 194: StartTest0194L(); break;

    	case 195: StartTest0195L(); break;

    	case 196: StartTest0196L(); break;

    	case 197: StartTest0197L(); break;

    	case 198: StartTest0198L(); break;

    	case 199: StartTest0199L(); break;

    	case 200: StartTest0200L(); break;

    	case 201: StartTest0201L(); break;

    	case 202: StartTest0202L(); break;

    	}

    }

TInt CCollectionTests::StartTest0001L()

    {

    // Initialization

    iLogger->Log( KTextApiNewL );

    iCollectionUtility1->Collection().OpenL();

    return 0;

    }

TInt CCollectionTests::StartTest0002L()

    {

    // MMPXCollectionUtility::CollectionIDL not implemented

    iLogger->Log( KTextApiCollectionIDL );

    iLogger->Log( KTextNotImplemented );

    RunNext();

    return 0;

    }

TInt CCollectionTests::StartTest0003L()

    {

    // MMPXCollectionUtility::CollectionIDL not implemented

    iLogger->Log( KTextApiCollectionIDL );

    iLogger->Log( KTextNotImplemented );

    RunNext();

    return 0;

    }

TInt CCollectionTests::StartTest0004L()

    {

    // MMPXCollectionUtility::CollectionIDL not implemented

    iLogger->Log( KTextApiCollectionIDL );

    iLogger->Log( KTextNotImplemented );

    RunNext();

    return 0;

    }

TInt CCollectionTests::StartTest0005L()

    {

    // MMPXCollectionUtility::CollectionIDL not implemented

    iLogger->Log( KTextApiCollectionIDL );

    RunNext();

    return 0;

    }

TInt CCollectionTests::StartTest0006L()

    {

    // MMPXCollectionUtility::CollectionIDL not implemented

    iLogger->Log( KTextApiCollectionIDL );

    iLogger->Log( KTextNotImplemented );

    RunNext();

    return 0;

    }

TInt CCollectionTests::StartTest0007L()

    {

    // MMPXCollectionUtility::CollectionIDL not implemented

    iLogger->Log( KTextApiCollectionIDL );

    RunNext();

    return 0;

    }

TInt CCollectionTests::StartTest0008L()

    {

    // MMPXCollectionUtility::CollectionIDL not implemented