--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tzservices/tzloc/test/rtest/T_MultiThreadTimeZoneChange.cpp	Tue Feb 02 10:12:00 2010 +0200
@@ -0,0 +1,302 @@
+// 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 <e32std.h>
+#include <e32des16.h>
+#include <e32test.h>
+#include <tzlocalizer.h> 
+
+
+_LIT(KFormatErrorCode, " the error code is %d \n");
+
+
+_LIT(KThread1,"thread1");
+_LIT(KThread2,"thread2");
+_LIT(KThread3,"thread3");
+_LIT(KThread4,"thread4");
+_LIT(KThread5,"thread5");
+_LIT(KThread6,"thread6");
+_LIT(KThread7,"thread7");
+_LIT(KThread8,"thread8");
+_LIT(KThread9,"thread9");
+_LIT(KThread10,"thread10");
+
+_LIT(KTxtEPOC32EX,"EPOC32EX");
+
+
+const TUint32 KLondon = 2592;
+const TInt KHeapSize = 0x2000;
+
+
+RTest test (_L("T_MultiThreadTimeZoneChange"));
+
+
+LOCAL_C void TestConvertByUsingCTzConverterL()
+	{
+	//create a CTzLocalizer object for setting the timezone
+	CTzLocalizer* localizer = CTzLocalizer::NewLC();  
+	
+	//Set timezone to be London
+	localizer->SetTimeZoneL(KLondon);
+	
+	CleanupStack::PopAndDestroy(localizer);
+	}
+
+
+/**
+ * Start converting function.
+ */
+LOCAL_C void StartConvertL()
+    {
+	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler();
+	CleanupStack::PushL(scheduler);
+	CActiveScheduler::Install(scheduler);
+	
+    TestConvertByUsingCTzConverterL();
+    
+	CleanupStack::PopAndDestroy(scheduler);
+	}
+
+/**
+ * Run single thread. 
+ */
+LOCAL_C TInt RunThread()
+    {
+	__UHEAP_MARK;
+    CTrapCleanup* cleanup = CTrapCleanup::New();    // get clean-up stack
+
+    TRAPD(error, StartConvertL());    // more initialization
+    __ASSERT_ALWAYS( !error, User::Panic(KTxtEPOC32EX, error));
+	
+	delete cleanup;             // destroy clean-up stack
+    __UHEAP_MARKEND;
+    
+	return error;
+    }	
+
+/**
+ * Thread function entry  point 
+ */
+LOCAL_C TInt ThreadFunc(TAny* /*aAny*/)  
+    {
+	return RunThread();
+	}
+
+/**
+ * Thread function entry  point 
+ */
+LOCAL_C void PrintStatus(TRequestStatus& aThreadResult, TInt aThreadNumber)
+	{
+	if(aThreadResult.Int() != KErrNone)
+		{
+		test.Printf(KFormatErrorCode, aThreadResult.Int());
+		}
+	else
+		{
+		test.Printf(_L("Thread %d was successfull\n"), aThreadNumber);
+		}	
+	}
+
+/**
+ * Run Multi threads for testing the converting performance
+ * 
+ */
+LOCAL_C void RunMultiThreadsL()
+    {
+	RThread thread1;
+	RThread thread2;
+	RThread thread3;	
+	RThread thread4;
+	RThread thread5;
+	RThread thread6;
+	RThread thread7;
+	RThread thread8;	
+	RThread thread9;
+	RThread thread10;
+	
+	TInt tResult = KErrNone;
+	
+	tResult = thread1.Create(KThread1, ThreadFunc, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
+	User::LeaveIfError(tResult);
+	
+	tResult = thread2.Create(KThread2, ThreadFunc, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
+	User::LeaveIfError(tResult);
+	
+	tResult = thread3.Create(KThread3, ThreadFunc, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
+	User::LeaveIfError(tResult);
+	
+	tResult = thread4.Create(KThread4, ThreadFunc, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
+	User::LeaveIfError(tResult);
+	
+	tResult = thread5.Create(KThread5, ThreadFunc, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
+	User::LeaveIfError(tResult);
+	
+	tResult = thread6.Create(KThread6, ThreadFunc, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
+	User::LeaveIfError(tResult);
+	
+	tResult = thread7.Create(KThread7, ThreadFunc, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
+	User::LeaveIfError(tResult);
+	
+	tResult = thread8.Create(KThread8, ThreadFunc, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
+	User::LeaveIfError(tResult);
+	
+	tResult = thread9.Create(KThread9, ThreadFunc, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
+	User::LeaveIfError(tResult);
+	
+	tResult = thread10.Create(KThread10, ThreadFunc, KDefaultStackSize, KHeapSize, KHeapSize, NULL);
+	User::LeaveIfError(tResult);
+	
+	// Request notification when these threads die using Logon
+	// function.
+	TRequestStatus status1;
+	TRequestStatus status2;
+	TRequestStatus status3;
+	TRequestStatus status4;
+	TRequestStatus status5;
+	TRequestStatus status6;
+	TRequestStatus status7;
+	TRequestStatus status8; 
+	TRequestStatus status9;
+	TRequestStatus status10;
+	
+	thread1.Logon(status1);
+	thread2.Logon(status2);
+	thread3.Logon(status3);
+	thread4.Logon(status4);
+	thread5.Logon(status5);
+	thread6.Logon(status6);
+	thread7.Logon(status7);
+	thread8.Logon(status8);
+	thread9.Logon(status9);
+	thread10.Logon(status10);
+		
+	CTzLocalizer* localizer = CTzLocalizer::NewLC();
+	//set timezone to be London
+	localizer->SetTimeZoneL(KLondon);		
+	CleanupStack::PopAndDestroy(localizer);
+	
+	// Make all threads eligible for execution using Resume
+	// function.
+	thread1.Resume();
+	thread2.Resume();
+	thread3.Resume();
+	thread4.Resume();
+	thread5.Resume();
+	thread6.Resume();
+	thread7.Resume();
+	thread8.Resume();
+	thread9.Resume();
+	thread10.Resume();
+
+	// Wait for the above requests to complete. Use 
+	// WaitForRequest of the User class. 
+	
+	User::WaitForRequest(status1);
+	PrintStatus(status1, 1);
+	
+	User::WaitForRequest(status2);
+	PrintStatus(status2, 2);
+	
+	User::WaitForRequest(status3);
+	PrintStatus(status3, 3);
+	
+	User::WaitForRequest(status4);
+	PrintStatus(status4, 4);
+
+	User::WaitForRequest(status5);
+	PrintStatus(status5, 5);
+		
+	User::WaitForRequest(status6);
+	PrintStatus(status6, 6);
+	
+	User::WaitForRequest(status7);
+	PrintStatus(status7, 7);
+	
+	User::WaitForRequest(status8);
+	PrintStatus(status8, 8);
+	
+	User::WaitForRequest(status9);
+	PrintStatus(status9, 9);
+
+	User::WaitForRequest(status10);
+	PrintStatus(status10, 10);
+
+	
+	// End threads. Use Kill function.
+	thread1.Kill(KErrNone);
+	thread2.Kill(KErrNone);
+	thread3.Kill(KErrNone);
+	thread4.Kill(KErrNone);
+	thread5.Kill(KErrNone);
+	thread6.Kill(KErrNone);
+	thread7.Kill(KErrNone);
+	thread8.Kill(KErrNone);
+	thread9.Kill(KErrNone);
+	thread10.Kill(KErrNone);
+	
+	// Close the handle to threads
+	thread1.Close();
+	thread2.Close();
+	thread3.Close();
+	thread4.Close();
+	thread5.Close();
+	thread6.Close();
+	thread7.Close();
+	thread8.Close();
+	thread9.Close();
+	thread10.Close();	
+	}
+
+
+LOCAL_C void DoStartL()
+	{
+	// Create active scheduler (to run active objects)
+	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
+	CleanupStack::PushL(scheduler);
+	CActiveScheduler::Install(scheduler);
+
+	RunMultiThreadsL();
+
+	// Delete active scheduler
+	CleanupStack::PopAndDestroy(scheduler);
+	}
+
+//  Global Functions
+
+/**
+@SYMTestCaseID PIM-TMULTITHREADTIMEZONECHANGE-0001
+*/	
+GLDEF_C TInt E32Main()
+	{
+	// Create cleanup stack
+	__UHEAP_MARK;
+	test.Start(_L("@SYMTestCaseID PIM-TMULTITHREADTIMEZONECHANGE-0001 Starting Test T_MultiThreadTimeZoneChange"));
+	CTrapCleanup* cleanup = CTrapCleanup::New();
+
+	// Run application code inside TRAP harness.
+	TRAPD(mainError, DoStartL());
+	
+	test(mainError == KErrNone);
+	
+	delete cleanup;
+	test.End();
+	test.Close();
+	__UHEAP_MARKEND;
+	return KErrNone;
+	}
+
+
+