// Copyright (c) 2008-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 <e32std.h>

#include <e32des16.h>

#include <e32test.h>

#include <tzlocalizer.h> 

#include <tzlocalizationdatatypes.h>

#include <tz.h>

#include <vtzrules.h>

#include "testserver.h"

#include <e32math.h>

#include <tzlocalizedcityrecord.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <tzusernames.h>

#include <tzuserdefineddata.h>

#endif

class CTzLocalizationUserDataSuite : public CBase

	{

public:

    static CTzLocalizationUserDataSuite* NewLC();

	~CTzLocalizationUserDataSuite();

	void TestLocalizedTimeZoneL();

	void TestLocalizedTimeZoneWithLocalizeIDL();

	void TestLocalizedCityL();

	void TestDefaultCityL();

	void TestCityGroupL();

	void TestCityArrayL();

	void TestCurrentTimeZoneL();

	void TestFindTimeZoneL();

	void TestUserDataModificationL(CTzLocalizedTimeZone::TTzFrequentlyUsedZone aTimeZone);

	void TestUserDataDeletionL();

	void TestUserDataDeletionCityImpactL();

	void TestUserDefinedTimeZoneL();

private:

	CTzLocalizationUserDataSuite();

	void ConstructL();

	void ResetTzUserDataL();

	CTzId* CreateTimeZoneL();

	CTzUserNames* CreateUserRuleAndGetNamesLC(TInt& aTimeZoneId);

	void TestFindTimeZoneByNameL(TInt aTimeZoneId, const CTzUserNames& aNames,const TDesC& aNameToFind);

	CTzRules* CreateRulesLC();

	CTzUserNames* CreateNamesLC();

	TBool CompareLocalizedCity(TInt aTimeZoneId, const CTzUserNames& aNames, const CTzLocalizedCity& aCity);

	TBool CompareTimeZoneNames(TInt aTimezoneId, const CTzUserNames& aNames, const CTzLocalizedTimeZone& aLocalizedTimeZone);

	TBool CompareLocalizedCityGroup(const CTzUserNames& aNames, const CTzLocalizedCityGroup& aCityGroup);

	TBool FindCityInArrayL(const CTzLocalizedCityArray& aCityArray, TInt aTimeZoneId, const CTzUserNames& aNames);

	TBool CompareLocalizedCity(const CTzLocalizedCity& aCity, const CTzLocalizedCity& aCityToCompare);

	TBool CompareTimeZoneName(const CTzLocalizedTimeZone& aTimeZone, const CTzLocalizedTimeZone& aTimeZoneToCompare);

	void CreateString(TDes& aString);

	TBool TestTimeZoneShortStandardNameL(CTzLocalizer& aTzLocalizer, const TDesC& aShortStandardName);

private:

	CTzLocalizer* 	iLocalizer;

	RTz				iTzSession;

	CTzUserData*	iUserData;

	TInt64 			iSeed;

	};

_LIT(KTestName,"t_localizationuserdata");

_LIT(KPerFile1,"c:\\private\\100012a5\\DBS_2000836D_DBS_DSC.db");

_LIT(KPerFile2,"c:\\private\\100012a5\\DBS_10206A8B_TzLocalization.db");

_LIT(KUserAddedCity1Name, "UserAddedCity1");

_LIT(KUserAddedCity2Name, "UserAddedCity2");

_LIT(KUserAddedCity3Name, "UserAddedCity3");

const TInt KLondonTzId = 2592;

const TInt KParisTzId = 2656;

RTest test(KTestName);

LOCAL_D void ResetAndDestroyTzIdArray(TAny* aPtr)

	{

	RPointerArray<CTzId>* ids = static_cast<RPointerArray<CTzId>*>(aPtr);

	if (ids)

		{

		ids->ResetAndDestroy();

		}

	}

CTzLocalizationUserDataSuite* CTzLocalizationUserDataSuite::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return (self);

	}

CTzLocalizationUserDataSuite::CTzLocalizationUserDataSuite():iSeed(100)

	{

	}

void CTzLocalizationUserDataSuite::ConstructL()

	{

	iLocalizer = CTzLocalizer::NewL();

	iLocalizer->SetDataSource(CTzLocalizer::ETzDataSourceSystem|CTzLocalizer::ETzDataSourceUser);

	iLocalizer->SetTimeZoneL(KLondonTzId);

	User::LeaveIfError(iTzSession.Connect());

	iUserData = CTzUserData::NewL(iTzSession);

	}

CTzLocalizationUserDataSuite::~CTzLocalizationUserDataSuite()	

	{

	TRAP_IGNORE(iLocalizer->SetTimeZoneL(KLondonTzId));

	delete iLocalizer;

	delete iUserData;

	iTzSession.Close();

	}

CTzUserNames* CTzLocalizationUserDataSuite::CreateUserRuleAndGetNamesLC(TInt& aTimeZoneId)

	{

	CTzId* tzid = CreateTimeZoneL();

	CleanupStack::PushL(tzid);

	CTzUserNames* names = iUserData->ReadNamesL(*tzid);

	aTimeZoneId = tzid->TimeZoneNumericID();

	CleanupStack::PopAndDestroy(tzid);

	CleanupStack::PushL(names);

	return names;

	}

TBool CTzLocalizationUserDataSuite::CompareTimeZoneNames(TInt aTimeZoneId, const CTzUserNames& aNames, const CTzLocalizedTimeZone& aLocalizedTimeZone)

	{

	if (aTimeZoneId != aLocalizedTimeZone.TimeZoneId())

		{

		return EFalse; 

		}

	if (aNames.StandardName() !=  aLocalizedTimeZone.StandardName())

		{

		return EFalse; 

		}

	if (aNames.ShortStandardName() != aLocalizedTimeZone.ShortStandardName())

		{

		return EFalse;

		}

	if (aNames.DaylightSaveName() != aLocalizedTimeZone.DaylightName())

		{

		return EFalse;

		}

	if (aNames.ShortDaylightSaveName() != aLocalizedTimeZone.ShortDaylightName())

		{

		return EFalse;

		}

	return ETrue;

	}

TBool CTzLocalizationUserDataSuite::CompareLocalizedCity(TInt aTimeZoneId, const CTzUserNames& aNames, const CTzLocalizedCity& aCity)

	{	

	if (aNames.CityName() != aCity.Name())

		{

		return EFalse;

		}

	if (aTimeZoneId != aCity.TimeZoneId())

		{

		return EFalse;

		}

	if (aCity.GroupId()!=0)

		{

		return EFalse;

		}

	return ETrue;

	}

TBool CTzLocalizationUserDataSuite::CompareLocalizedCityGroup(const CTzUserNames& aNames, const CTzLocalizedCityGroup& aCityGroup)

	{	

	if (aNames.RegionName() != aCityGroup.Name())

		{

		return EFalse;

		}

	if (aCityGroup.Id()!=0)

		{

		return EFalse;

		}

	return ETrue;

	}

TBool CTzLocalizationUserDataSuite::CompareLocalizedCity(const CTzLocalizedCity& aCity, const CTzLocalizedCity& aCityToCompare)

	{

	if(aCity.TimeZoneId() != aCityToCompare.TimeZoneId() )

		{

		return EFalse;

		}

	if(aCity.GroupId() != aCityToCompare.GroupId())

		{

		return EFalse;

		}

	if(aCity.Name() != aCityToCompare.Name())

		{

		return EFalse;

		}

	return ETrue;

	}

TBool CTzLocalizationUserDataSuite::CompareTimeZoneName(const CTzLocalizedTimeZone& aTimeZone, const CTzLocalizedTimeZone& aTimeZoneToCompare)

	{

	if(aTimeZone.StandardName() != aTimeZoneToCompare.StandardName())

		{

		return EFalse;

		}

	if(aTimeZone.ShortStandardName() != aTimeZoneToCompare.ShortStandardName())

		{

		return EFalse;

		}

	if(aTimeZone.DaylightName() != aTimeZoneToCompare.DaylightName())

		{

		return EFalse;

		}

	if(aTimeZone.ShortDaylightName() != aTimeZoneToCompare.ShortDaylightName())

		{

		return EFalse;

		}

	return ETrue;	

	}

CTzId* CTzLocalizationUserDataSuite::CreateTimeZoneL()

	{	

	//Create a user defined rule - CTzRules.

	TTime dston (TDateTime(2005, EMarch, 0, 0, 0, 0, 0)); 

	TTime dstoff (TDateTime(2005, ESeptember, 0, 0, 0, 0, 0));

	TMonth monthOn = dston.DateTime().Month();

	TInt dayOn = dston.DateTime().Day();

	TMonth monthOff = dstoff.DateTime().Month();

	TInt dayOff = dstoff.DateTime().Day();

	TTzRule dstOff(0, 9999, 0, 0, monthOn,  ETzFixedDate, dayOn,  0, ETzWallTimeReference, 0);

	TTzRule dstOn (0, 9999, 0, 0, monthOff, ETzFixedDate, dayOff, 0, ETzWallTimeReference, 0);

	CTzRules* rules = CTzRules::NewL(0, KMaxTUint);

	CleanupStack::PushL(rules);

	rules->AddRuleL(dstOff);

	rules->AddRuleL(dstOn);

	//Create a user defined rule names- CTzUserNames.

	_LIT(KStandardName, "UserTzName");

	_LIT(KShortName, "UserTzSh");

	_LIT(KDaylightSaveName, "UserDLSaveName");

	_LIT(KShortDaylightSaveName, "UserShDLS");

	_LIT(KCityNameName, "UserCityName");

	_LIT(KRegionName, "UserRegionName");

	CTzUserNames* names = CTzUserNames::NewLC(KStandardName(), KShortName(), KDaylightSaveName(), KShortDaylightSaveName(), KCityNameName(), KRegionName());

	//Add the rule to the database

	CTzId* tzid = iUserData->CreateL(*rules, *names);

	CleanupStack::PopAndDestroy(2, rules);

	return tzid;

	}

void CTzLocalizationUserDataSuite::ResetTzUserDataL()

	{

	RPointerArray<CTzId> ids;

	CleanupStack::PushL(TCleanupItem(ResetAndDestroyTzIdArray, &ids));

	iUserData->GetTzIdsL(ids);

	TInt count = ids.Count();

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

		{

		iUserData->DeleteL(*ids[ii]);	

		}

	CleanupStack::PopAndDestroy(&ids);	

	}

TBool CTzLocalizationUserDataSuite::FindCityInArrayL(const CTzLocalizedCityArray& aCityArray, TInt aTimeZoneId, const CTzUserNames& aNames)

	{

	TBool found = EFalse;

	const TInt count = aCityArray.Count();

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

		{

		if(CompareLocalizedCity(aTimeZoneId, aNames, aCityArray.At(ii)))

			{

			found = ETrue;

			break;

			}

		}

	return found;

	}

void CTzLocalizationUserDataSuite::TestFindTimeZoneByNameL(TInt aTimeZoneId, const CTzUserNames& aNames,const TDesC& aNameToFind)

	{

	CTzLocalizedTimeZone* timeZone = iLocalizer->FindTimeZoneByNameL(aNameToFind);

	CleanupStack::PushL(timeZone);

	test(CompareTimeZoneNames(aTimeZoneId, aNames, *timeZone));

	CleanupStack::PopAndDestroy(timeZone);

	}

/**

@SYMTestCaseID	PIM-APPSERV-TZL-TZN-0001

@SYMTestCaseDesc

	The purpose of this test is to verify that the localized time zone names for

	a user defined time zone is correct.

@SYMTestActions     

	1.	Create a user defined zone and store the returned time zone identifier.

	2.	Get the localized time zone information for the user defined time zone

		identifier obtained in action 1. 

@SYMTestExpectedResults

	The following information is the same as that used to create the user

	defined time zone in action 1:

	- Standard time zone name

 	- Short standard time zone name

 	- Standard daylight saving time name

 	- Short daylight saving time name

@SYMTestType: 	CT

@SYMTestPriority: 1

*/

void CTzLocalizationUserDataSuite::TestLocalizedTimeZoneL()

	{

	test.Next(_L("@SYMTestCaseID PIM-APPSERV-TZL-TZN-0001 Test Localized Time Zone"));

	TInt tzid = 0;

	CTzUserNames* names = CreateUserRuleAndGetNamesLC(tzid);

	CTzLocalizedTimeZone* locTimezone = iLocalizer->GetLocalizedTimeZoneL(tzid);

	CleanupStack::PushL(locTimezone);

	test(CompareTimeZoneNames(tzid, *names, *locTimezone));

	CleanupStack::PopAndDestroy(2, names);

	ResetTzUserDataL();

	}

void CTzLocalizationUserDataSuite::TestLocalizedTimeZoneWithLocalizeIDL()

	{

	test.Next(_L("Test Localized Time Zone"));

	TInt tzid = 0;

	CTzUserNames* names = CreateUserRuleAndGetNamesLC(tzid);

	CTzLocalizedCity* city = iLocalizer->GetDefaultCityL(tzid);

	CleanupStack::PushL(city);

	CTzLocalizedTimeZone* locTimezone = iLocalizer->GetLocalizedTimeZoneL(*city);

	CleanupStack::PopAndDestroy(city);

	CleanupStack::PushL(locTimezone);

	test(CompareTimeZoneNames(tzid, *names, *locTimezone));

	CleanupStack::PopAndDestroy(2, names);

	ResetTzUserDataL();

	}

/**

@SYMTestCaseID PIM-APPSERV-TZL-TZN-0002

@SYMTestCaseDesc

	The purpose of this test is to verify that the localized city information

	for a user defined time zone is correct.

@SYMTestActions     

	1.	Create a user defined zone and store the returned time zone identifier.

	2.	Get the localized city information for the user defined zone identifier

		obtained in action 1. 

@SYMTestExpectedResults

	The following information is the same as that used to create the user

	defined time zone in action 1:

	- City name

 	- Time zone identifier

 	- Group identifier (0 for all user defined time zones)

@SYMTestType

	CT

@SYMTestPriority

	1

*/

void CTzLocalizationUserDataSuite::TestLocalizedCityL()

	{

	test.Next(_L("@SYMTestCaseID PIM-APPSERV-TZL-TZN-0002 Test Localized City"));

	TInt tzid = 0;

	CTzUserNames* names = CreateUserRuleAndGetNamesLC(tzid);

	CTzLocalizedCityArray* locCityArray = iLocalizer->GetCitiesL(tzid);

	CleanupStack::PushL(locCityArray);

	test(CompareLocalizedCity(tzid, *names, locCityArray->At(0)));

	CleanupStack::PopAndDestroy(2, names);

	ResetTzUserDataL();

	}

/**

@SYMTestCaseID PIM-APPSERV-TZL-TZN-0003

@SYMTestCaseDesc

	The purpose of this test is to verify that the default localized city

	information for a user defined time zone is correct.

@SYMTestActions     

	1.	Create a user defined zone and store the returned time zone identifier.

	2.	Get the default localized city information for the user defined zone

		identifier obtained in action 1. 

@SYMTestExpectedResults

	The following information is the same as that used to create the user

	defined time zone in action 1:

	 - City name

 	- Time zone identifier

 	- Group identifier (0 for all user defined time zones)

@SYMTestType

	CT

@SYMTestPriority

	1

*/

void CTzLocalizationUserDataSuite::TestDefaultCityL()

	{

	test.Next(_L("@SYMTestCaseID PIM-APPSERV-TZL-TZN-0003  Test Default City"));

	TInt tzid = 0;

	CTzUserNames* names = CreateUserRuleAndGetNamesLC(tzid);

	CTzLocalizedCity*  defaultCity = iLocalizer->GetDefaultCityL(tzid);

	CleanupStack::PushL(defaultCity);

	test(CompareLocalizedCity(tzid, *names, *defaultCity));

	CleanupStack::PopAndDestroy(2, names);

	ResetTzUserDataL();

	}

/**

@SYMTestCaseID PIM-APPSERV-TZL-TZN-0004

@SYMTestCaseDesc

	The purpose of this test is to verify that the localized city group

	information for a user defined time zone fails as expected.

@SYMTestActions     

	1.	Create a user defined zone and store the returned time zone identifier.

	2.	Verify that the localized city group information for a user defined time

		zone fails as expected. 

@SYMTestExpectedResults

	The localized city group information cannot be obtained (the call leaves

	with KErrArgument).

@SYMTestType

	CT

@SYMTestPriority

	1

*/

void CTzLocalizationUserDataSuite::TestCityGroupL()

	{

	test.Next(_L("@SYMTestCaseID PIM-APPSERV-TZL-TZN-0004 Test City Group"));

	TInt tzid = 0;

	CTzUserNames* names = CreateUserRuleAndGetNamesLC(tzid);

	CTzLocalizedCityArray* locCityArray = iLocalizer->GetCitiesL(tzid);

	CleanupStack::PushL(locCityArray);

	TRAPD(err, iLocalizer->GetCityGroupL(locCityArray->At(0).GroupId())); 

	test(err == KErrArgument);

	CleanupStack::PopAndDestroy(2, names);

	ResetTzUserDataL();

	}

/**

@SYMTestCaseID 	PIM-APPSERV-TZL-TZN-0005

@SYMTestCaseDesc

	The purpose of this test is to verify that the localized city array

	information for user defined time zones is correct.

@SYMTestActions     

	1.	Create two user defined time zones.

	2.	Get the localized city array information for the user defined time zone

		group identifier (always 0).

@SYMTestExpectedResults

	The localized city array contains the two city names used to create the user

	defined time zones in action 1.

@SYMTestType

	CT

@SYMTestPriority

	1

*/