/*

* Copyright (c) 2010 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:   test agnversit2 api

*

*/

//  CLASS HEADER

#include "testagnversit2.h"

#include <BADESCA.H>

//  EXTERNAL INCLUDES

#include <EUnitMacros.h>

#include <EUnitDecorators.h>

#include <CalEntry.h>				// CCalEntry

#include <calentryview.h>           // CCalEntryView

#include <CalSession.h>				// CCalSession

#include <f32file.h>				// RFs

#include <s32file.h>				// RFileWriteStream, RFileReadStream

#include <caliterator.h>

#include <EIKENV.H>

#include <calInstanceView.h>

#include <calinstance.h>

//  INTERNAL INCLUDES

#include "AgnVersit2.h"				// CAgnVersit2

#include "AgnVersit2ExportFlags.h"	// TAgnExportMethod

#include "AgnVersit2TestConstants.h"// Constants

#include "ICalParser.h"

#include "ICal.h"

//#include <CalenUtils.h>

#include <CalenDateUtils.h>

#include <CleanupResetAndDestroy.h>

#include "AgnImportObserver.h"		// MAgnImportObserver

#include "AgnExportObserver.h"		// MAgnExportObserver

#include <tz.h>

#include <TzLocalizer.h>

#include <TzLocalizationDataTypes.h>

#include <calsession.h>

#include <calentryview.h>

// path and filename for Calendar database,owned by calendar.

// TODO: This needs to be read from central repo to remove dependancy on calendar.

_LIT( KCalendarDatabaseFilePath, "c:Calendar" );

const TUint32 KLondonTimeZoneId(2632);

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

// CCAgnVersit2Test::NewL

// Symbian OS 2 phased constructor.

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

//

CCAgnVersit2Test* CCAgnVersit2Test::NewL()

    {

    CCAgnVersit2Test* self = CCAgnVersit2Test::NewLC();

    CleanupStack::Pop();

    return self;

    }

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

// CCAgnVersit2Test::NewLC

// Symbian OS 2 phased constructor.

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

//

CCAgnVersit2Test* CCAgnVersit2Test::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCAgnVersit2Test::~CCAgnVersit2Test

// Destructor (virtual by CBase)

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

//

CCAgnVersit2Test::~CCAgnVersit2Test()

    {

  /*  SetupL();

    CleanDatabaseL();

    Teardown(); */

	SetCalendarViewStatus(ECalViewCreateNone);

	if(iEntryAsyncWait)

		{

		delete iEntryAsyncWait;

		iEntryAsyncWait =  NULL;

		}

	if(iQueueManagerAsw)

		{

		delete iQueueManagerAsw;

		iQueueManagerAsw =  NULL;

		}

	if(iEntryView)

		{

		delete iEntryView;

		iEntryView = NULL;	

		}    		

	if( iCalSession )

	    {

	    delete iCalSession;

	    iCalSession = NULL;

	    }

     }

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

// CCAgnVersit2Test::CCAgnVersit2Test

// Default constructor

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

//

CCAgnVersit2Test::CCAgnVersit2Test()

    {

    }

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

// CCAgnVersit2Test::ConstructL

// Second phase construction

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

//

void CCAgnVersit2Test::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    TInt err = KErrNone;

	// Creating session with Calendar server

	if(!iCalSession)

		{

		iCalSession = CCalSession::NewL();

		TRAP( err, iCalSession->OpenL(KCalendarDatabaseFilePath));

		User::LeaveIfError( err );

		// active scheduler wait object to wait for Calendar view creation

		iEntryAsyncWait = new(ELeave) CActiveSchedulerWait();

		// active scheduler wait object to stop new view creation req. while one is ongoing.

		iQueueManagerAsw = new(ELeave) CActiveSchedulerWait();

		}

	if(!iEntryView && !(iEntryAsyncWait->IsStarted()) )

		{

		// Creating Calendar Entry View for retrieving event details.

	    iEntryView = CCalEntryView::NewL( *iCalSession, *this );

		SetCalendarViewStatus(ECalViewCreateReqPending);

		// Since View creation is aynshronous,the thread need to wait till view creation completed

		iEntryAsyncWait->Start();

		// If Async wait  queue manager is still in in waiting,Cancel it since view creation completed.

		if(iQueueManagerAsw->IsStarted())

			{

			iQueueManagerAsw->AsyncStop();

			}

		}

	else

		{	

		// Waiting for completion of current view creation request.

		if(iQueueManagerAsw && !iQueueManagerAsw->IsStarted())

			{

			iQueueManagerAsw->Start();

			}

		}

	// Leaves if view creation failed...

	User::LeaveIfError(CalendarViewStatus());

 	/*   SetupL();

    CleanDatabaseL();

    Teardown();*/

    }

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

// CCAgnVersit2Test::SetupL

// Setup

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

//

void CCAgnVersit2Test::SetupL()

    {

	//Create file server session

	EUNIT_ASSERT_EQUALS(iFs.Connect(), KErrNone);

	//Create AgnVersit2 interface through ECOM

	iInterface = CAgnExternalInterface::NewL(KICalMimeType);

	iInputDir 	= HBufC::NewL(KFileNameLength);

	iOutputDir	= HBufC::NewL(KFileNameLength);

	iInputDir->Des().Append(_L("E://testing//data//unittest//agnversit2//input//"));

	iOutputDir->Des().Append(_L("E://testing//data//unittest//agnversit2//output//"));

	//Make an output directory if needed

	iFs.MkDirAll(*iOutputDir);

	//Get the filenames to use from the ini file

	iImportFile = HBufC::NewL(KFileNameLength);

	iExportFile1 = HBufC::NewL(KFileNameLength);

	iExportFile2 = HBufC::NewL(KFileNameLength);	

	iCheckFile	= HBufC::NewL(KFileNameLength);

    iEikEnv = CEikonEnv::Static();

    }

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

// CCAgnVersit2Test::Teardown

// Teardown

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

//  

void CCAgnVersit2Test::Teardown()

    {

    delete iString;

    iString = NULL;

	delete iImportFile;

	iImportFile = NULL;

	delete iExportFile1;

	iExportFile1 = NULL;

	delete iExportFile2;

	iExportFile2 = NULL;	

	delete iCheckFile;

	iCheckFile = NULL;

	delete iInputDir;

	iInputDir = NULL;

	delete iOutputDir;

	iOutputDir = NULL;

	iImportedEntries.ResetAndDestroy();

   	iEntriesFromDb1.ResetAndDestroy();

   	iEntriesFromDb2.ResetAndDestroy();

	delete iInterface;

	iInterface = NULL;

	iFs.Close();

    }

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

// CCAgnVersit2Test::AgnImportErrorL

// From MAgnImportObserver. Reports errors ocurring during import. Displays a

// warning message, and requests the import should attempt to continue if possible.

// @param aType The type of error

// @param aUid uid of the component the error ocurred in

// @param aContext type of the component that the error ocurred in.

// @return Value specified in ini file as OnError

// @leave KErrDied if OnError is Die

// @internalTechnology

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

//

MAgnImportObserver::TImpResponse CCAgnVersit2Test::AgnImportErrorL(

	TImpError aType,

	const TDesC8& /*aUid*/, 

	const TDesC& aContext)

	{

	if (!iOOMTesting)

		{

		switch (aType)

			{

			case EImpErrorMissingData:

			    EUNIT_PRINT(KImpErrorMissingData());

			    EUNIT_PRINT(aContext);

				break;

			case EImpErrorNotSupported:

			    EUNIT_PRINT(KImpErrorNotSupported());

			    EUNIT_PRINT(aContext);

				break;

			case EImpErrorInvalidData:

			    EUNIT_PRINT(KImpErrorInvalidData());

			    EUNIT_PRINT(aContext);

				break;

			default:

			    EUNIT_PRINT(KImpError());

			    EUNIT_PRINT(aContext);

				break;

			}

		}

	if (iDieOnError)

		{

		EUNIT_ASSERT_SPECIFIC_LEAVE(User::Leave(KErrDied), KErrDied);

		}

	return iOnImpError;

	}

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

// CCAgnVersit2Test::

// From MAgnExportObserver. Reports errors ocurring during export. Displays a

// warning message, and requests the export should attempt to continue if possible.

// @param aType The type of error

// @param aUid uid of the component the error ocurred in

// @param aContext type of the component that the error ocurred in.

// @return Value specified in ini file as OnError

// @leave KErrDied if OnError is Die

// @internalTechnology

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

//

MAgnExportObserver::TExpResponse CCAgnVersit2Test::AgnExportErrorL(

	TExpError /*aType*/,

	const TDesC8& /*aUid*/, 

	const TDesC& aContext)

	{

	if (!iOOMTesting)

		{

		EUNIT_PRINT(KExpError());

		EUNIT_PRINT(aContext);

		}

	if (iDieOnError)

		{

		EUNIT_ASSERT_SPECIFIC_LEAVE(User::Leave(KErrDied), KErrDied);

		}

	return iOnExpError;

	}

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

// CCAgnVersit2Test::ImportL

// Imports an iCalendar entry from iImportFile.

// @param aExportFile the file to import from. Default 0 means take from ini file.

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

//

void CCAgnVersit2Test::ImportL()

	{

	RFileReadStream fileStream;

	EUNIT_ASSERT_EQUALS(fileStream.Open(iFs, *iImportFile, EFileRead), KErrNone);

	CleanupClosePushL(fileStream);

	iInterface->ImportL(iImportedEntries, fileStream, 0, *this);

	CleanupStack::PopAndDestroy(); // fileStream

	}

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

// CCAgnVersit2Test::ExportL

// Exports an iCalendar entry to iExportFile.

// @param aExportFile the file to export to. Default 0 means take from ini file.

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

//

void CCAgnVersit2Test::ExportL(const RPointerArray<CCalEntry> &aEntryArray,  HBufC* aExportFile )

	{

	RFileWriteStream writeStream;

	EUNIT_ASSERT_EQUALS(writeStream.Replace(iFs, *aExportFile, EFileWrite), KErrNone);

	CleanupClosePushL(writeStream);

	//Export the entries

	TInt count = aEntryArray.Count();

	TInt flags = EExportAll;

	for (TInt ent = 0; ent < count; ++ent)

		{

		flags = GetExportFlagsL(*aEntryArray[ent]);	

		iInterface->ExportL(*aEntryArray[ent], writeStream, flags, *this);

		}

	CleanupStack::PopAndDestroy(); // Close writeStream.

	}

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

// CCAgnVersit2Test::GetExportFlagsL

// Get the correct flags for export

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

//

TInt CCAgnVersit2Test::GetExportFlagsL(const CCalEntry& aEntry)

	{

	switch (aEntry.EntryTypeL())

		{

		case CCalEntry::EEvent:

			{

			switch (aEntry.MethodL())

				{

				case CCalEntry::EMethodNone:

					return EExportAll;

				case CCalEntry::EMethodPublish:

					return EVEventPublish;

				case CCalEntry::EMethodRequest:

					return EVEventRequest;

				case CCalEntry::EMethodReply:

					return EVEventReply;

				case CCalEntry::EMethodAdd:

					return EVEventAdd;

				case CCalEntry::EMethodCancel:

					return EVEventCancel;

				case CCalEntry::EMethodRefresh:

					return EVEventRefresh;

				case CCalEntry::EMethodCounter:

					return EVEventCounter;

				case CCalEntry::EMethodDeclineCounter:

					return EVEventDeclineCounter;

				}

			}

		break;

		case CCalEntry::ETodo:

			{

			switch (aEntry.MethodL())

				{

				case CCalEntry::EMethodNone:

					return EExportAll;

				case CCalEntry::EMethodPublish:

					return EVTodoPublish;

				case CCalEntry::EMethodRequest:

					return EVTodoRequest;

				case CCalEntry::EMethodReply:

					return EVTodoReply;

				case CCalEntry::EMethodAdd:

					return EVTodoAdd;

				case CCalEntry::EMethodCancel:

					return EVTodoCancel;

				case CCalEntry::EMethodRefresh:

					return EVTodoRefresh;

				case CCalEntry::EMethodCounter:

					return EVTodoCounter;

				case CCalEntry::EMethodDeclineCounter:

					return EVTodoDeclineCounter;

				}

			}

		}

	return EExportAll;

	}

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

// CCAgnVersit2Test::CompareFilesL

// Compares the contents of iImportFile against the contents of iExportFile line by line

// @return ETrue if the files are identical, otherwise EFalse 

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

//

TBool CCAgnVersit2Test::CompareFilesL( HBufC* aExportFile, HBufC* aCheckFile )

	{

	TBool identical = ETrue;

	// Open a read stream on both files

	RFileReadStream fileStream1;

	RFileReadStream fileStream2;

	EUNIT_ASSERT_EQUALS(fileStream1.Open(iFs, *aExportFile, EFileRead), KErrNone);

	CleanupClosePushL(fileStream1);

	EUNIT_ASSERT_EQUALS(fileStream2.Open(iFs, *aCheckFile, EFileRead), KErrNone);

	CleanupClosePushL(fileStream2);

	// Buffer to hold each line of a file

	HBufC8* buf1 = HBufC8::NewLC(KICalMaxContentLineLength);

	HBufC8* buf2 = HBufC8::NewLC(KICalMaxContentLineLength);

	TPtr8 buf1Ptr = buf1->Des();

	TPtr8 buf2Ptr = buf2->Des();

	TInt error1(KErrNone);

	TInt error2(KErrNone);

	// Compare the files line by line, excluding certain

	// properties we expect to be different (eg the time stamp)

	while (error1 == KErrNone && error2 == KErrNone && identical)

		{

		TRAP(error1, GetLineL(fileStream1, buf1Ptr));

		TRAP(error2, GetLineL(fileStream2, buf2Ptr));

		if (error1 != error2)

			{

			identical = EFalse;

			}

		else if (error1 == KErrNone)

			{

			if (buf1Ptr.Find(KDtStamp) == 0)

				{

				EUNIT_ASSERT_EQUALS(identical = buf2Ptr.Find(KDtStamp), 0);

				identical = (buf2Ptr.Find(KDtStamp) == 0);

				}

			else if (buf1Ptr.Find(KCreated) == 0)

				{

				EUNIT_ASSERT_EQUALS(identical = buf2Ptr.Find(KCreated), 0);

				identical = (buf2Ptr.Find(KCreated) == 0);

				}

			else if (buf1Ptr.Find(KLastMod) == 0)

				{

				EUNIT_ASSERT_EQUALS(identical = buf2Ptr.Find(KLastMod), 0);

				identical = (buf2Ptr.Find(KLastMod) == 0);

				}

			else if (buf1Ptr.Find(KProdId)==0)

				{

				EUNIT_ASSERT_EQUALS(identical = buf2Ptr.Find(KProdId), 0);

				identical = (buf2Ptr.Find(KProdId) == 0);	

				}

			else

				{

				EUNIT_ASSERT_EQUALS(identical = buf1Ptr.CompareF(buf2Ptr), 0);

				identical = (buf1Ptr.CompareF(buf2Ptr) == 0);

				}

			}

		}