/*

* Copyright (c) 2008 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 calenimporter api

*

*/

//  CLASS HEADER

#include "testcalenimporter.h"

#include "calenimptestconstants.h"

//  EXTERNAL INCLUDES

#include <EUnitMacros.h>

#include <calsession.h>

#include <CalEntry.h>				// CCalEntry

#include <DelimitedPathSegment8.h>

#include <UTF.H>

#include <CalenImporter.h>

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

// CCalenImporterTest::NewL

// Two-phased constructor.

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

//

CCalenImporterTest* CCalenImporterTest::NewL()

    {

    CCalenImporterTest* self = CCalenImporterTest::NewLC();

    CleanupStack::Pop();

    return self;

    }

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

// CCalenImporterTest::NewLC

// Two-phased constructor.

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

//

CCalenImporterTest* CCalenImporterTest::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCalenImporterTest::~CCalenImporterTest()

// Destructor (virtual by CBase)

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

//

CCalenImporterTest::~CCalenImporterTest()

    {

    }

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

// CCalenImporterTest::CCalenImporterTest()

// Default constructor

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

//

CCalenImporterTest::CCalenImporterTest(): iImportFile( NULL ),

                          iExportFile( NULL ),

                          iCheckFile( NULL ),

                          iType( NULL )

    {

    }

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

// CCalenImporterTest::ConstructL

// Second phase construction

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

//

void CCalenImporterTest::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//============================================================================================

// Import/export ical and vcal

//============================================================================================

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

// CCalenImporterTest::SetupL

// Setup & Teardown

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

//

void CCalenImporterTest::SetupL()

    {

    //Create file server session

	EUNIT_ASSERT_EQUALS(iFs.Connect(), KErrNone);

	//Make an output directory if needed

	iFs.MkDirAll( KOutputDirName );

	iCalSession = CCalSession::NewL();

    iCalSession->OpenL( iCalSession->DefaultFileNameL()  );

    iCalenImporter = CCalenImporter::NewL( *iCalSession );    

    }

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

// CCalenImporterTest::Teardown

// Teardown

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

//

void CCalenImporterTest::Teardown()

    {

    if( iType )

        {

        delete iType;

        iType = NULL;

        }

    if( iImportFile )

        {

        delete iImportFile;	// File to import from

        iImportFile = NULL;

        }

    if( iExportFile )

        {

        delete iExportFile;	// File to export to

        iExportFile = NULL;

        }

    if( iCheckFile )

        {

        delete iCheckFile;	// File to verify export against

        iCheckFile = NULL;

        }

    iEntries.ResetAndDestroy();

    if( iCalenImporter )

        {

        delete iCalenImporter;

        iCalenImporter = NULL;

        }

    if( iCalSession )

        {

        delete iCalSession;

        iCalSession = NULL;

        }

    //Close File Server

    iFs.Close();

    }

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

// CCalenImporterTest::ImportL

// Imports an iCalendar entry from iImportFile.

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

// @internalTechnology

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

//

void CCalenImporterTest::ImportL()

	{

	//iEntries.ResetAndDestroy();

	RFileReadStream fileStream;

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

	CleanupClosePushL(fileStream);

	if( iType->Match( KTypeVCal ) != KErrNotFound )

        {

        TRAPD( error, iCalenImporter->ImportVCalendarL( fileStream, iEntries ) );

        if(error)

        	{

        	//to avoid warning

        	}

        }

    else if( iType->Match( KTypeICal ) != KErrNotFound )

        {

        TRAPD( error, iCalenImporter->ImportICalendarL( fileStream, iEntries ) );

        if(error)

        	{

        	//to avoid warning

        	}

        }

	CleanupStack::PopAndDestroy(); // fileStream

	}

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

// CCalenImporterTest::ParseFileL

// Parses the ini file and sends the content to ParseLineL.

// @param aFile the ini file.

// @internalTechnology

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

//

void CCalenImporterTest::ParseFileL( const TDesC16& aFile )	

    {

    HBufC* configFile	= HBufC::NewLC( KInputDirName().Length() + aFile.Length() );

    configFile->Des().Insert( 0, KInputDirName );

	configFile->Des().Append( aFile );    

    RFileReadStream fileStream;

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

	CleanupClosePushL(fileStream);

	// Buffer to hold each line of a file

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

	TPtr8 bufPtr = buf->Des();

	TInt error(KErrNone);

	TBool found = EFalse;

    while (error == KErrNone && !found)

		{

		TRAP( error, fileStream.ReadL( bufPtr, TChar(KNewline) ) );

        if( error == KErrNone )

            {

            ParseLineL( bufPtr );

			RunTestL();

		    }

		}

	CleanupStack::PopAndDestroy(buf);

    CleanupStack::PopAndDestroy(&fileStream);

    CleanupStack::PopAndDestroy(configFile);

    }

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

// CCalenImporterTest::ParseLineL

// Parses a RFC2396 specified line.

// @param aLine the line to parse.

// @internalTechnology

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

//

void CCalenImporterTest::ParseLineL( const TDesC8& aLine )

	{

	EUNIT_PRINT( aLine );

	/*

	TDelimitedPathSegmentParser8 Parses path segments whose 

	components are delimited by the ';' character, 

	as defined in RFC2396.

	*/

   	TDelimitedPathSegmentParser8 parser;

	parser.Parse( aLine );

	TPtrC8 segment;

    TPtr8 test(NULL, 0);

    //The line parsed from the file is expected to have the following format:

    //type;import_file_name;check_file_name;export_file_name;

   //Get type vcal/ical

    if( parser.GetNext( segment ) != KErrNotFound )

	    {

	    if( iType )

	        {

	        delete iType;

	        iType = NULL;

	        }

	    iType = CnvUtfConverter::ConvertToUnicodeFromUtf8L( segment);

	    }

    //Get Import file name

    if( parser.GetNext( segment ) != KErrNotFound )

	    {

	    if( iImportFile )

	        {

	        delete iImportFile;

	        iImportFile = NULL;

	        }

	    iImportFile = CnvUtfConverter::ConvertToUnicodeFromUtf8L( segment);

	    iImportFile = iImportFile->ReAlloc( iImportFile->Length() + KInputDirName().Length() );

	    iImportFile->Des().Insert( 0, KInputDirName );

      	}

	//Get Check file name

	if( parser.GetNext( segment ) != KErrNotFound )

	    {

	    if( iCheckFile )

	        {

	        delete iCheckFile;

	        iCheckFile = NULL;

	        }

	    iCheckFile = CnvUtfConverter::ConvertToUnicodeFromUtf8L( segment);

	    iCheckFile = iCheckFile->ReAlloc( iCheckFile->Length() + KInputDirName().Length() );

	    iCheckFile->Des().Insert( 0, KInputDirName);

      	}

	//Get Export file name

	if( parser.GetNext( segment ) != KErrNotFound )

	    {

	    if( iExportFile )

	        {

	        delete iExportFile;

	        iExportFile = NULL;

	        }

	    iExportFile = CnvUtfConverter::ConvertToUnicodeFromUtf8L( segment);

	    iExportFile = iExportFile->ReAlloc( iExportFile->Length() + KOutputDirName().Length() );

	    iExportFile->Des().Insert( 0, KOutputDirName );

      	}

	}

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

// CCalenImporterTest::

// This function is called by ParseFileL for each 

// line in the ini file

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

//

void CCalenImporterTest::RunTestL()

    {

    ImportL();    

    }

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

// CCalenImporterTest::ImportTestL

// 

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

//

void CCalenImporterTest::ImportTestL(  )

    {

    /*

    Starts the whole test

    ImportExportTestL -->

                        ParseFileL --> (Loops through the whole file)

                                     ParseLineL

                                     RunTest    -->

                                                  ImportL();

                                                  ExportL();

                                                  CompareFilesL();

    */

    EUNIT_ASSERT_NO_LEAVE( ParseFileL( KTestIniFile ) );

    }

//============================================================================================

// specific import function test cases

//============================================================================================

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

// CCalenImporterTest::SetupImporterL

// Setup only importer

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

//

void CCalenImporterTest::SetupImporterL()

    {

	  iCalSession = CCalSession::NewL();

    iCalSession->OpenL( iCalSession->DefaultFileNameL()  );

    iCalenImporter = CCalenImporter::NewL( *iCalSession );

    }

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

// CCalenImporterTest::TeardownImporter

// Teardown only importer

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

//

void CCalenImporterTest::TeardownImporter()

    {

    if( iCalenImporter )

        {

        delete iCalenImporter;

        iCalenImporter = NULL;

        }

    if( iCalSession )

        {

        delete iCalSession;

        iCalSession = NULL;

        }

    }

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

// CCalenImporterTest::SetImportModeTestL

// SetImportMode

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

//

void CCalenImporterTest::SetImportModeTestL()

    {

    iCalenImporter->SetImportMode( ECalenImportModeNormal );

    iCalenImporter->SetImportMode( ECalenImportModeExtended );

    }

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE(

    CCalenImporterTest,

    "Add test suite description here.",

    "MODULE" )

//Import and Export

EUNIT_TEST(

    "Test a bunch of iCal and vCal",

    "CCalenImporter",

    "Add tested function name here",

    "FUNCTIONALITY",

    SetupL, ImportTestL, Teardown )

//Specific import test cases

EUNIT_TEST(

    "Test setting the import mode",

    "CCalenImporter",

    "Add tested function name here",

    "FUNCTIONALITY",

    SetupImporterL, SetImportModeTestL, TeardownImporter )

EUNIT_END_TEST_TABLE

//  END OF FILE