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

//

#include "TJapaneseSoundProperty.h"

// System includes

#include <vcard.h>

#include <f32file.h>

#include <e32test.h>

// Literal constants

_LIT(KTestName, "TJapaneseSoundProperty");

_LIT(KTestPath, "Z:\\VersitJapaneseVCards\\");

_LIT8(KSoundExtensionPropertyParameterName, "X-IRMC-N");

// Globals

static RFs					TheFsSession;

static RTest				TheTest(KTestName);

static void DoTestsL()

	{

	CVersitCardTest* test = CVersitCardTest::NewLC();

	test->StartTestsL();

    CleanupStack::PopAndDestroy(test);

	}

static void DriveSpaceReport()

	{

	TheTest.Printf(_L("Drive space report:\n"));

	TVolumeInfo volInfo;

	TheFsSession.Volume(volInfo, EDriveC);

	TheTest.Printf(_L("Volume C: Free Space: %D\n"), volInfo.iFree);

	TheTest.Printf(_L("Volume C: Total Size: %D\n"), volInfo.iSize);

	TheFsSession.Volume(volInfo, EDriveZ);

	TheTest.Printf(_L("Volume Z: Free Space: %D\n"), volInfo.iFree);

	TheTest.Printf(_L("Volume Z: Total Size: %D\n"), volInfo.iSize);	

	}

//@SYMTestCaseID PIM-TJAPANESESOUNDPROPERTY-0001

GLDEF_C TInt E32Main()

	{

	TTime startTime;

	startTime.UniversalTime();

	__UHEAP_MARK;

	CTrapCleanup* theCleanup = CTrapCleanup::New();

	if	(!theCleanup)

		return KErrNoMemory;

	if	(TheFsSession.Connect() < KErrNone)

		return KErrGeneral;

	// Test code to see how much space is left on c: when this is failing with 

	// -43 (KErrDirFull)

	DriveSpaceReport();

	// end of test code	

	TheTest.Start(_L("@SYMTestCaseID PIM-TJAPANESESOUNDPROPERTY-0001 TJapaneseSoundProperty"));

	TRAPD(error, DoTestsL());

	if (error != KErrNone)

		{

		TheTest.Printf(_L("Test failed with error code: %d"), error);

		// Test code to see how much space is left on c: when this is failing with 

		// -43 (KErrDirFull)

		DriveSpaceReport();

		// end of test code

		}

	TheTest(error == KErrNone);

	TheTest.End();

	TheTest.Close();

	TheFsSession.Close();

	delete theCleanup;

	__UHEAP_MARKEND;

	TTime finishTime;

	finishTime.UniversalTime();

	TReal elapsed = (TReal)finishTime.MicroSecondsFrom(startTime).Int64();

	TheTest.Printf(_L("Elapsed time: %.4f\n"), elapsed/1000000);

	return KErrNone;

	}

CVersitCardTest::~CVersitCardTest()

	{

	}

void CVersitCardTest::ConstructL()

	{

	}

CVersitCardTest* CVersitCardTest::NewLC()

	{

	CVersitCardTest* self = new(ELeave) CVersitCardTest;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

//********************************************************************************************

void CVersitCardTest::StartTestsL()

	{

	CParserVCard* parser;

    // TEST 0

    _LIT(KTestFileName0, "escaped.vcf"); //SOUND;X-IRMC-N:This \;Is The \;First\;\;;\;Second\; Bit \;

	parser = InternalizeCardLC(KTestPath, KTestFileName0);

    CheckNumberOfSoundPropertiesL(KTestFileName0, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 1

    _LIT(KTestFileName1, "amano.vcf");  //SOUND;X-IRMC-N:Amano;Yoshitaka

	parser = InternalizeCardLC(KTestPath, KTestFileName1);

    CheckNumberOfSoundPropertiesL(KTestFileName1, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 2

    _LIT(KTestFileName2, "aoki.vcf");  //SOUND;X-IRMC-N;CHARSET=SHIFT_JIS:?A?I?L;?C?T?I

	parser = InternalizeCardLC(KTestPath, KTestFileName2);

    CheckNumberOfSoundPropertiesL(KTestFileName2, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 3

    _LIT(KTestFileName3, "barbara.vcf"); //SOUND;X-IRMC-N;CHARSET=SHIFT_JIS:?o?[?o?‰;?J?^?I?J

	parser = InternalizeCardLC(KTestPath, KTestFileName3);

    CheckNumberOfSoundPropertiesL(KTestFileName3, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 4

    _LIT(KTestFileName4, "Digit1.vcf");	 //SOUND;X-IRMC-N:999999;99999

	parser = InternalizeCardLC(KTestPath, KTestFileName4);

    CheckNumberOfSoundPropertiesL(KTestFileName4, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 5

    _LIT(KTestFileName5, "Digit2.vcf"); //SOUND;X-IRMC-N:‚R‚R‚R‚R‚R‚R;‚T‚T‚T‚T‚T‚T

	parser = InternalizeCardLC(KTestPath, KTestFileName5);

    CheckNumberOfSoundPropertiesL(KTestFileName5, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 6

    _LIT(KTestFileName6, "haga.vcf");  //SOUND;X-IRMC-N;CHARSET=SHIFT_JIS:?n?K;?„?X?V

	parser = InternalizeCardLC(KTestPath, KTestFileName6);

    CheckNumberOfSoundPropertiesL(KTestFileName6, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 7

    _LIT(KTestFileName7, "kasai.vcf");

	parser = InternalizeCardLC(KTestPath, KTestFileName7);

    CheckNumberOfSoundPropertiesL(KTestFileName7, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 8

    _LIT(KTestFileName8, "kitajima.vcf");

	parser = InternalizeCardLC(KTestPath, KTestFileName8);

    CheckNumberOfSoundPropertiesL(KTestFileName8, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 9

    _LIT(KTestFileName9, "Longest.vcf");

	parser = InternalizeCardLC(KTestPath, KTestFileName9);

    CheckNumberOfSoundPropertiesL(KTestFileName9, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 10

    _LIT(KTestFileName10, "matsui.vcf");

	parser = InternalizeCardLC(KTestPath, KTestFileName10);

    CheckNumberOfSoundPropertiesL(KTestFileName10, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 11

    _LIT(KTestFileName11, "miyazaki.vcf");

	parser = InternalizeCardLC(KTestPath, KTestFileName11);

    CheckNumberOfSoundPropertiesL(KTestFileName11, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 12

    _LIT(KTestFileName12, "nakai.vcf");

	parser = InternalizeCardLC(KTestPath, KTestFileName12);

    CheckNumberOfSoundPropertiesL(KTestFileName12, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 13

    _LIT(KTestFileName13, "powell.vcf");

	parser = InternalizeCardLC(KTestPath, KTestFileName13);

    CheckNumberOfSoundPropertiesL(KTestFileName13, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 14

    _LIT(KTestFileName14, "prolongedsound.vcf");

	parser = InternalizeCardLC(KTestPath, KTestFileName14);

    CheckNumberOfSoundPropertiesL(KTestFileName14, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 15

    _LIT(KTestFileName15, "SpecialCharacter1.vcf");

	parser = InternalizeCardLC(KTestPath, KTestFileName15);

    CheckNumberOfSoundPropertiesL(KTestFileName15, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 16

    _LIT(KTestFileName16, "SpecialCharacter1.vcf");

	parser = InternalizeCardLC(KTestPath, KTestFileName16);

    CheckNumberOfSoundPropertiesL(KTestFileName16, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 17

    _LIT(KTestFileName17, "SpecialCharacter2.vcf");

	parser = InternalizeCardLC(KTestPath, KTestFileName17);

    CheckNumberOfSoundPropertiesL(KTestFileName17, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 18

    _LIT(KTestFileName18, "takashiro.vcf");

	parser = InternalizeCardLC(KTestPath, KTestFileName18);

    CheckNumberOfSoundPropertiesL(KTestFileName18, *parser, 2);

    CleanupStack::PopAndDestroy(parser);

    // TEST 19

    _LIT(KTestFileName19, "MultipleSounds.vcf");

	parser = InternalizeCardLC(KTestPath, KTestFileName19);

    CheckNumberOfSoundPropertiesL(KTestFileName19, *parser, 2, 2);

    CleanupStack::PopAndDestroy(parser);

    // Create vCard with sound property and export it.

    CreateVCardTestL();

	}

//********************************************************************************************

CParserVCard* CVersitCardTest::InternalizeCardLC(const TDesC& aFile)

//

//	Internalize the specified file

//

	{

    CParserVCard* parser = CParserVCard::NewL();

	CleanupStack::PushL(parser);

    //

    TInt pos = 0;

	RFile file;

	User::LeaveIfError(file.Open(TheFsSession, aFile, EFileRead));

	CleanupClosePushL(file);

	// Read from the file

	static_cast<CVersitParser*>(parser)->InternalizeL(file, pos);

	CleanupStack::PopAndDestroy(); // file

    //

    return parser;

    }

//********************************************************************************************

CParserVCard* CVersitCardTest::InternalizeCardLC(const TDesC& aPath, const TDesC& aFileName)

//

//	Internalize the specified file from the specified path

//

	{

    TFileName name(aPath);

    name += aFileName;

    return InternalizeCardLC(name);

    }

//********************************************************************************************

void CVersitCardTest::CheckNumberOfSoundPropertiesL(const TDesC& aFileName, const CParserVCard& aParser, TInt aExpectedArrayElementCount, TInt aExpectedPropertyCount)

//

//	Check that the number of SOUND sub-elements are as expected

//

	{

    TheTest.Printf(_L("%S\n"), &aFileName);

    (void) aFileName;

    //

    TBool passedTest = EFalse;

    CArrayPtr<CParserProperty>* properties = aParser.PropertyL(KVersitTokenSOUND, TUid::Uid(KVersitPropertyHBufCUid), EFalse);

    TheTest(properties != NULL);

    if  (properties)

        {

        //

        CleanupStack::PushL(properties);

        const TInt count = properties->Count();

        TheTest(count == aExpectedPropertyCount);

        //

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

            {

            const CParserProperty* property = properties->At(i);

            // Check that the X-IRMC-N property parameter exists

            const TBool foundParam = property->Param(KSoundExtensionPropertyParameterName) != NULL;

	        TheTest(foundParam);

            // Check property value

            TheTest(property->Value() != NULL);

            CParserPropertyValueHBufC* propertyAsHBufC = static_cast<CParserPropertyValueHBufC*>(property->Value());

            // Check property value as an array

            CParserPropertyValueCDesCArray* valueAsArray = propertyAsHBufC->TreatAsArrayPropertyLC(*property);

            TheTest(valueAsArray->Value() != NULL);

            CDesCArray& array = *valueAsArray->Value();

            //

            const TInt arrayItemCount = array.Count();

            TheTest(arrayItemCount == aExpectedArrayElementCount);

            for(TInt j=0; j<arrayItemCount; j++)

                {

                const TPtrC pValue(array[j]);

                TheTest.Printf(_L("%S\n"), &pValue);

                }

            TheTest.Printf(_L("\n"));

            CleanupStack::PopAndDestroy(valueAsArray);

            //

            passedTest = ETrue;

            }

        CleanupStack::PopAndDestroy(properties);

        }

    TheTest(passedTest);

	}

//********************************************************************************************

void CVersitCardTest::CreateVCardTestL()

//

//

//

    {

	CVersitParser* parser = CParserVCard::NewL();

	CleanupStack::PushL(parser);

    // Add Name

    {

    CDesCArrayFlat* nameArray = new(ELeave) CDesCArrayFlat(2);

    CleanupStack::PushL(nameArray);

    nameArray->AppendL(_L("Wibble"));

    nameArray->AppendL(_L("Wobble"));

    //

    CParserPropertyValue* propNameValue = new(ELeave) CParserPropertyValueCDesCArray(nameArray);

    CleanupStack::Pop(nameArray);

    CleanupStack::PushL(propNameValue);

    CParserProperty* propName = CParserProperty::NewL(*propNameValue, KVersitTokenN, NULL);

    CleanupStack::Pop(propNameValue);

    parser->AddPropertyL(propName);

    }

    // Add Sound

    {

    CDesCArrayFlat* soundArray = new(ELeave) CDesCArrayFlat(2);

    CleanupStack::PushL(soundArray);

    soundArray->AppendL(_L("Sound1"));

    soundArray->AppendL(_L("Sound2"));

    //

    CParserPropertyValue* propSoundValue = new(ELeave) CParserPropertyValueCDesCArray(soundArray);

    CleanupStack::Pop(soundArray);

    CleanupStack::PushL(propSoundValue);

    CParserProperty* propSound = CParserProperty::NewL(*propSoundValue, KVersitTokenSOUND, NULL);

    CleanupStack::Pop(propSoundValue);

    //

	CParserParam* param = CParserParam::NewL(KSoundExtensionPropertyParameterName, KNullDesC8);

	CleanupStack::PushL(param);

    propSound->AddParamL(param);

	CleanupStack::Pop(param);

    //

    parser->AddPropertyL(propSound);

    }

    // Export vCard

    _LIT(KFileName, "C:\\JapaneseSound.vcf");

	RFile file;

	User::LeaveIfError(file.Replace(TheFsSession, KFileName, EFileWrite));

	CleanupClosePushL(file);

    parser->ExternalizeL(file);

	CleanupStack::PopAndDestroy(&file);

    // Test

    CParserVCard* importedCard = CVersitCardTest::InternalizeCardLC(KFileName);

    CheckNumberOfSoundPropertiesL(KFileName, *importedCard, 2);

    CleanupStack::PopAndDestroy(importedCard);

    // Tidy up

    CleanupStack::PopAndDestroy(parser);    

    }