// 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 <e32base.h>

#include <e32test.h>

#include <e32property.h>

#include <tz.h>

#include <tzupdate.h>

#include "testserver.h"

_LIT(KSrcTzRulesDb, "z:\\testresourcefiles\\tzdb.dbz");

_LIT(KDestTzRulesDb, "c:\\private\\1020383e\\tzdb.dbz");

_LIT(KSrcTzUserDb, "z:\\testresourcefiles\\tz_userdata_empty.db");

_LIT(KDestTzUserDb, "c:\\private\\1020383e\\SQLite__tzuserdata.db");

_LIT(KSrcTzLocRscDir, "z:\\testresourcefiles\\");

_LIT(KDestTzLocRscDir, "c:\\resource\\timezonelocalization\\");

_LIT(KTimeStampFile, "c:\\private\\1020383e\\timestamps");

_LIT(KSrcTzLocRscFile1, "z:\\testresourcefiles\\timezonegroups.r01");

_LIT(KSrcTzLocRscFile2, "z:\\testresourcefiles\\timezonegroups.r02");

_LIT(KSrcTzLocRscFile3, "z:\\testresourcefiles\\timezonegroups.rsc");

_LIT(KSrcTzLocRscFile4, "z:\\testresourcefiles\\timezones.r01");

_LIT(KSrcTzLocRscFile5, "z:\\testresourcefiles\\timezones.r02");

_LIT(KSrcTzLocRscFile6, "z:\\testresourcefiles\\timezones.rsc");

_LIT(KDestTzLocRscFile1, "c:\\resource\\timezonelocalization\\timezonegroups.r01");

_LIT(KDestTzLocRscFile2, "c:\\resource\\timezonelocalization\\timezonegroups.r02");

_LIT(KDestTzLocRscFile3, "c:\\resource\\timezonelocalization\\timezonegroups.rsc");

_LIT(KDestTzLocRscFile4, "c:\\resource\\timezonelocalization\\timezones.r01");

_LIT(KDestTzLocRscFile5, "c:\\resource\\timezonelocalization\\timezones.r02");

_LIT(KDestTzLocRscFile6, "c:\\resource\\timezonelocalization\\timezones.rsc");

RTest test(_L("TZ Data Change Notification Test Suite"));

/**

Timer used to detect if a test case times out.

*/

class CTestTimeOut : public CTimer

	{

public:

    static CTestTimeOut* NewL();

	void Start(TInt aTimeOut);

	void Stop();

	TBool TimedOut();

private:

	CTestTimeOut();

	void ConstructL();

    // From CActive.

    void RunL();

private:

	TBool iTimedOut;

	};

CTestTimeOut* CTestTimeOut::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CTestTimeOut::CTestTimeOut()

	:

	CTimer(EPriorityStandard)

	{

	CActiveScheduler::Add(this);

	iTimedOut = EFalse;

	}

void CTestTimeOut::ConstructL()

	{

	CTimer::ConstructL();

	}

void CTestTimeOut::Start(TInt aTimeOut)

	{

	iTimedOut = EFalse;

	Cancel();

	After(aTimeOut);

	}

void CTestTimeOut::Stop()

	{

	Cancel();

	}

TBool CTestTimeOut::TimedOut()

	{

	return iTimedOut;

	}

void CTestTimeOut::RunL()

	{

	iTimedOut = ETrue;

	CActiveScheduler::Stop();

	}

/**

Watches for a change to the given NTzUpdate::TPropertyKeys property.  The

property key should only be NTzUpdate::ETzRulesChange or NTzUpdate::ETzNames-

Change.

*/

class CTzDataChangeObserver : public CActive

    {

public:

    static CTzDataChangeObserver* NewL(NTzUpdate::TPropertyKeys

    	aChangePropertyKey);

    ~CTzDataChangeObserver();

	void Start();

	void Stop();

    TTime TimeOfChange();

private:

    // From CActive.

    void RunL();

    void DoCancel();

    CTzDataChangeObserver(NTzUpdate::TPropertyKeys aChangePropertyKey);

    void ConstructL();

    void RespondToChange();

private:

    NTzUpdate::TPropertyKeys iChangePropertyKey;

    RProperty iChangeProperty;

    TTime iTimeOfChange;

    };

CTzDataChangeObserver* CTzDataChangeObserver::NewL(NTzUpdate::TPropertyKeys

	aChangePropertyKey)

    {

    CTzDataChangeObserver* self =

    	new(ELeave) CTzDataChangeObserver(aChangePropertyKey);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CTzDataChangeObserver::CTzDataChangeObserver(NTzUpdate::TPropertyKeys

	aChangePropertyKey)

    :

    CActive(CActive::EPriorityStandard),

    iChangePropertyKey(aChangePropertyKey)

    {

    CActiveScheduler::Add(this);

    iTimeOfChange = Time::NullTTime();

    }

void CTzDataChangeObserver::ConstructL()

    {

    User::LeaveIfError(iChangeProperty.Attach(NTzUpdate::KPropertyCategory,

    	iChangePropertyKey));

    }

CTzDataChangeObserver::~CTzDataChangeObserver()

    {

    Cancel();    

    iChangeProperty.Close();

    }

void CTzDataChangeObserver::Start()

    {

    iChangeProperty.Subscribe(iStatus);

	SetActive();

	}

void CTzDataChangeObserver::Stop()

    {

	Cancel();

	}

void CTzDataChangeObserver::RespondToChange()

    {

    TPckgBuf<TTime> changeBuf;

    TInt err = iChangeProperty.Get(changeBuf);

    if (err == KErrNone)

        {

        iTimeOfChange = changeBuf();

        }

    }

TTime CTzDataChangeObserver::TimeOfChange()

    {

    return iTimeOfChange;

    }

void CTzDataChangeObserver::RunL()

    {	

    if (iStatus.Int() == KErrNone)

        {

		RespondToChange();

		CActiveScheduler::Stop();

        }

    }

void CTzDataChangeObserver::DoCancel()

    {

    iChangeProperty.Cancel();

    }

/**

Base class for TZ data change notification test cases.

*/

class CTzDataChangeNotificationTestCase : public CBase

	{

public:

    ~CTzDataChangeNotificationTestCase();

	void TestChangeNotificationL();

protected:

    CTzDataChangeNotificationTestCase();

    void ConstructL(NTzUpdate::TPropertyKeys aChangePropertyKey);

private:

	void TearDownL();

	void PrintTime(const TDesC& aDesc, const TTime& aTime);

	virtual void SetUpL();

	virtual void TriggerChangeNotificationL() = 0;

	virtual void TidyUpAfterChangeNotificationL() = 0;

protected:

	RTz iTzServer;

	RPIMTestServer iTestServer;

private:

	CTestTimeOut* iTestTimeOut;

	CTzDataChangeObserver* iTzDataChangeObserver;

	};

CTzDataChangeNotificationTestCase::CTzDataChangeNotificationTestCase()

    {

	// Nothing to do.

    }

void CTzDataChangeNotificationTestCase::ConstructL(NTzUpdate::TPropertyKeys

	aChangePropertyKey)

    {

	iTestTimeOut = CTestTimeOut::NewL();

	iTzDataChangeObserver = CTzDataChangeObserver::NewL(aChangePropertyKey);

    }

CTzDataChangeNotificationTestCase::~CTzDataChangeNotificationTestCase()

    {

	delete iTestTimeOut;

	delete iTzDataChangeObserver;

    }

void CTzDataChangeNotificationTestCase::SetUpL()

	{

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

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

	}

void CTzDataChangeNotificationTestCase::TearDownL()

	{

	iTestServer.Close();

	iTzServer.Close();

	}

void CTzDataChangeNotificationTestCase::PrintTime(const TDesC& aDesc,

	const TTime& aTime)

	{

	TDateTime dt = aTime.DateTime();

	test.Printf(_L("%S: %02d:%02d:%02d:%06d\n"), &aDesc, dt.Hour(), dt.Minute(),

		dt.Second(), dt.MicroSecond());

	}

void CTzDataChangeNotificationTestCase::TestChangeNotificationL()

	{

	SetUpL();

	TTime timeBeforeChangeNotification;

	timeBeforeChangeNotification.UniversalTime();

	_LIT(KTimeBeforeChangeNotification, "Time before change notification");

	PrintTime(KTimeBeforeChangeNotification, timeBeforeChangeNotification);

	iTzDataChangeObserver->Start();

	TriggerChangeNotificationL();

	const TInt KTestTimeOut = 50000000 /* microseconds */;

	iTestTimeOut->Start(KTestTimeOut);

	// The thread will be blocked after this call until either the test times

	// out or the change in the observed property occurs. 

	CActiveScheduler::Start();

	iTzDataChangeObserver->Stop();

	iTestTimeOut->Stop();

	TidyUpAfterChangeNotificationL();

	test(iTestTimeOut->TimedOut() == EFalse);

	TTime timeOfPropertyChange = iTzDataChangeObserver->TimeOfChange();

	_LIT(KTimeOfPropertyChange, "Time of property change");

	PrintTime(KTimeOfPropertyChange, timeOfPropertyChange);

	// We have received a change to the property - sanity check that the time

	// of the property change is later than the time of the event which

	// initiated the change.

	test(timeOfPropertyChange > timeBeforeChangeNotification);

	TearDownL();

	}

/**

@SYMTestCaseID 	PIM-APPSERV-TZ-TZS-CN-0001

@SYMTestCaseDesc

	The purpose of this test is to verify that a change to the system TZ rules

	database causes a change in value of the TZ rules change property.

@SYMTestActions

	1. Subscribe to the TZ rules change property.

	2. Copy a system TZ rules database to the appropriate location on the C:

	   drive.

@SYMTestExpectedResults

	The TZ rules change property changes value.

@SYMREQ

	REQ9950, REQ9951

@SYMTestType

	CT

@SYMTestPriority

	1

*/

class CTestSysTzRulesDbChangeNotification : public CTzDataChangeNotificationTestCase

	{

public:

    static CTestSysTzRulesDbChangeNotification* NewL();

    ~CTestSysTzRulesDbChangeNotification();

protected:

	CTestSysTzRulesDbChangeNotification();

	void ConstructL();

private:

	void TriggerChangeNotificationL();

	void TidyUpAfterChangeNotificationL();

	};

CTestSysTzRulesDbChangeNotification* CTestSysTzRulesDbChangeNotification::NewL()

    {

    CTestSysTzRulesDbChangeNotification* self =

    	new(ELeave) CTestSysTzRulesDbChangeNotification();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CTestSysTzRulesDbChangeNotification::CTestSysTzRulesDbChangeNotification()

	{

	// Nothing to do.

	}

void CTestSysTzRulesDbChangeNotification::ConstructL()

    {

	CTzDataChangeNotificationTestCase::ConstructL(NTzUpdate::ETzRulesChange);

	}

CTestSysTzRulesDbChangeNotification::~CTestSysTzRulesDbChangeNotification()

	{

	// Nothing to do.

	}

void CTestSysTzRulesDbChangeNotification::TriggerChangeNotificationL()

	{

	// By copying the TZ rules database to the C: drive a change in the

	// NTzUpdate::ETzRulesChange property should occur. 

	iTestServer.CopyFileL(KSrcTzRulesDb, KDestTzRulesDb);

	iTzServer.SwiObsBeginL();

	iTzServer.SwiObsFileChangedL(RTz::EFilterTzPrivate);

	iTzServer.SwiObsEndL();

	}

void CTestSysTzRulesDbChangeNotification::TidyUpAfterChangeNotificationL()

	{

	iTestServer.DeleteFileL(KDestTzRulesDb);

	}

/**

@SYMTestCaseID 	PIM-APPSERV-TZ-TZS-CN-0002

@SYMTestCaseDesc

	The purpose of this test is to verify that a change to the system TZ

	localization resources causes a change in value of the TZ names change

	property.

@SYMTestActions

	1. Subscribe to the TZ names change property.

	2. Copy system TZ localization resources to the appropriate location on the

	   C: drive.

@SYMTestExpectedResults

	The TZ names change property changes value.

@SYMREQ

	REQ9950, REQ9951

@SYMTestType

	CT

@SYMTestPriority

	1

*/

class CTestSysTzLocRscChangeNotification : public CTzDataChangeNotificationTestCase

	{

public:

    static CTestSysTzLocRscChangeNotification* NewL();

    ~CTestSysTzLocRscChangeNotification();

protected:

	CTestSysTzLocRscChangeNotification();

	void ConstructL();

private:

	void TriggerChangeNotificationL();

	void TidyUpAfterChangeNotificationL();

	};

CTestSysTzLocRscChangeNotification* CTestSysTzLocRscChangeNotification::NewL()

    {

    CTestSysTzLocRscChangeNotification* self =

    	new(ELeave) CTestSysTzLocRscChangeNotification();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CTestSysTzLocRscChangeNotification::CTestSysTzLocRscChangeNotification()

	{

	// Nothing to do.

	}

void CTestSysTzLocRscChangeNotification::ConstructL()

    {

	CTzDataChangeNotificationTestCase::ConstructL(NTzUpdate::ETzNamesChange);

	}

CTestSysTzLocRscChangeNotification::~CTestSysTzLocRscChangeNotification()

	{

	// Nothing to do.

	}

void CTestSysTzLocRscChangeNotification::TriggerChangeNotificationL()

	{

	// By copying the TZ localization resources to the C: drive a change in the

	// NTzUpdate::ETzNamesChange property should occur. 

	iTestServer.CopyFileL(KSrcTzLocRscFile1, KDestTzLocRscFile1);

	iTestServer.CopyFileL(KSrcTzLocRscFile2, KDestTzLocRscFile2);

	iTestServer.CopyFileL(KSrcTzLocRscFile3, KDestTzLocRscFile3);

	iTestServer.CopyFileL(KSrcTzLocRscFile4, KDestTzLocRscFile4);

	iTestServer.CopyFileL(KSrcTzLocRscFile5, KDestTzLocRscFile5);

	iTestServer.CopyFileL(KSrcTzLocRscFile6, KDestTzLocRscFile6);

	iTzServer.SwiObsBeginL();

	iTzServer.SwiObsFileChangedL(RTz::EFilterResourceTimezonelocalization);