--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/tauto/TGWHANDLE.CPP	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,1870 @@
+// Copyright (c) 1996-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:
+// GWHANDLE.CPP
+// Test group window handle functions
+// 
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+#include "TGWHANDLE.H"
+
+
+CTGwHandle::CTGwHandle(CTestStep* aStep):
+	CTWsGraphicsBase(aStep)
+	{
+	}
+
+void CTGwHandle::ConstructL()
+	{
+	}
+
+CTGwHandle::~CTGwHandle()
+	{
+	}
+
+TInt CTGwHandle::NumberOfWndGroupsWithZeroPriority(TInt aScreenNumber)
+	{
+	__ASSERT_ALWAYS(aScreenNumber <= 1, User::Invariant());
+	return TheClient->iWs.NumWindowGroups(aScreenNumber,0);
+	}
+
+void CTGwHandle::GetGwListL(CArrayFixFlat<TInt> *aWindowHandles)
+	{
+	User::LeaveIfError(TheClient->iWs.WindowGroupList(aWindowHandles));
+	}
+
+void CTGwHandle::GetGwListL(CArrayFixFlat<TInt> *aWindowHandles, TInt aScreenNumber)
+	{
+	User::LeaveIfError(TheClient->iWs.WindowGroupList(aWindowHandles, aScreenNumber));
+	}
+
+void CTGwHandle::GetGwListL(TInt aPriority, CArrayFixFlat<TInt> *aWindowHandles)
+	{
+	User::LeaveIfError(TheClient->iWs.WindowGroupList(aPriority,aWindowHandles));
+	}
+
+void CTGwHandle::GetGwListL(RArray<RWsSession::TWindowGroupChainInfo>* aWindowHandles)
+	{
+	User::LeaveIfError(TheClient->iWs.WindowGroupList(aWindowHandles));
+	}
+
+void CTGwHandle::GetGwListL(TInt aPriority, RArray<RWsSession::TWindowGroupChainInfo>* aWindowHandles)
+	{
+	User::LeaveIfError(TheClient->iWs.WindowGroupList(aPriority, aWindowHandles));
+	}
+
+void CTGwHandle::GwNamesL()
+	{
+	enum {EConnectHandle1=123456};
+	enum {EWindowGroupHandle1=234567};
+	enum {EWindowGroupHandle2=666666};
+//
+	TInt foreground;
+	User::LeaveIfError(foreground=TheClient->iWs.GetFocusWindowGroup());
+	RWsSession ws1;
+	User::LeaveIfError(ws1.Connect());
+
+	// assign to the correct screen
+	CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws1);
+	CleanupStack::PushL(screen);
+	User::LeaveIfError(screen->Construct(iTest->iScreenNumber));
+
+	RWindowGroup gw1(ws1);
+	User::LeaveIfError(gw1.Construct(EWindowGroupHandle1));
+	gw1.SetOwningWindowGroup(foreground);
+	RWindowGroup gw2(ws1);
+	User::LeaveIfError(gw2.Construct(EWindowGroupHandle2));
+	gw2.SetOwningWindowGroup(foreground);
+//
+	TBuf<8> getName;
+//
+// Check default name is simply a null string
+//
+	TInt retVal = gw1.Name(getName);
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("gw1.Name(getName) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	TEST(getName==_L(""));
+	if (getName!=_L(""))
+		INFO_PRINTF3(_L("getName==_L() - Expected: %d, Actual: %d"), ETrue, EFalse);
+//
+	TBuf<8> name1(_L("A_Name1"));
+	TBuf<8> name2(_L("A_Name2"));
+//
+	retVal = gw1.SetName(name1);
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("gw1.SetName(name1) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	retVal = gw2.SetName(name2);
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("(gw2.SetName(name2) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	retVal = gw1.Name(getName);
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("(gw1.Name(getName) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	TEST(getName==name1);
+	if (getName!=name1)
+		INFO_PRINTF3(_L("getName==name1 - Expected: %d, Actual: %d"), ETrue, EFalse);
+//
+	retVal = gw2.Name(getName);
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("(gw2.Name(getName) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	TEST(getName==name2);
+	if (getName!=name2)
+		INFO_PRINTF3(_L("getName==name2 - Expected: %d, Actual: %d"), ETrue, EFalse);
+
+//
+// A few weird characters in the name should work fine
+//
+	retVal = gw2.SetName(_L("xx*"));
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("(gw2.SetName(_L(xx*)) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	retVal = gw2.Name(getName);
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("(gw2.Name(getName) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	TEST(getName==_L("xx*"));
+	if (getName!=_L("xx*"))
+		INFO_PRINTF3(_L("getName==_L(xx*) - Expected: %d, Actual: %d"), ETrue, EFalse);
+
+//
+	retVal = gw2.SetName(_L(":"));
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("(gw2.SetName(_L(:)) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	retVal = gw2.Name(getName);
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("(gw2.Name(getName) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	TEST(getName==_L(":"));
+	if (getName!=_L(":"))
+		INFO_PRINTF3(_L("getName==_L(:) - Expected: %d, Actual: %d"), ETrue, EFalse);
+
+//
+// Setting the name back to a null name
+//
+	retVal = gw2.SetName(_L(""));
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("gw2.SetName(_L()) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	retVal = gw2.Name(getName);
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("gw2.Name(getName) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	TEST(getName==_L(""));
+	if (getName!=_L(""))
+		INFO_PRINTF3(_L("getName==_L() - Expected: %d, Actual: %d"), ETrue, EFalse);
+
+//
+// Getting a name into a too short buffer should fill thew whole buffer from the left hand part
+// of the window name and return KErrOverflow
+//
+	gw2.SetName(name2);
+	TBuf<4> shortBuf;
+	retVal = gw2.Name(shortBuf);
+	TEST(retVal==KErrOverflow);
+	if (retVal!=KErrOverflow)
+		INFO_PRINTF3(_L("gw2.Name(shortBuf) return value - Expected: %d, Actual: %d"), KErrOverflow, retVal);
+
+	TEST(shortBuf==name2.Left(4));
+	if (shortBuf!=name2.Left(4))
+		INFO_PRINTF3(_L("shortBuf==name2.Left(4) - Expected: %d, Actual: %d"), ETrue, EFalse);
+
+//
+// passing a 0 length TPtr pointing to NULL should be safe, simply returning KErrOverflow
+//
+	TPtr nullPtr(NULL,0);
+	retVal = gw2.Name(nullPtr);
+	TEST(retVal==KErrOverflow);
+	if (retVal!=KErrOverflow)
+		INFO_PRINTF3(_L("gw2.Name(nullPtr) return value - Expected: %d, Actual: %d"), KErrOverflow, retVal);
+
+	TEST(nullPtr==_L(""));
+	if (nullPtr!=_L(""))
+		INFO_PRINTF3(_L("nullPtr==_L() - Expected: %d, Actual: %d"), ETrue, EFalse);
+
+//
+// Getting a null name into a null descriptor
+//
+	gw2.SetName(_L(""));
+	TPtr nullPtr2(NULL,0);
+	retVal = gw2.Name(nullPtr);
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("gw2.Name(nullPtr) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	TEST(nullPtr2==_L(""));
+	if (nullPtr2!=_L(""))
+		INFO_PRINTF3(_L("nullPtr2==_L() - Expected: %d, Actual: %d"), ETrue, EFalse);
+//
+	gw1.Close();
+	gw2.Close();
+	CleanupStack::PopAndDestroy(screen);
+	ws1.Close();
+	}
+
+void CTGwHandle::GwIdentifierTestL()
+	{
+	enum {EWindowGroupHandle1=234567};
+	enum {EWindowGroupHandle2=666666};
+	enum {EWindowGroupHandle3=999};
+//
+	CArrayFixFlat<TInt>* windowHandles=new(ELeave) CArrayFixFlat<TInt>(5);
+	CleanupStack::PushL(windowHandles);
+	GetGwListL(0, windowHandles);
+	TInt retVal = TheClient->iWs.GetFocusWindowGroup();
+	TEST(retVal==(*windowHandles)[0]);
+	if (retVal!=(*windowHandles)[0])
+		INFO_PRINTF3(_L("TheClient->iWs.GetFocusWindowGroup() return value - Expected: %d, Actual: %d"), (*windowHandles)[0], retVal);
+
+//
+	RWsSession ws1;
+	User::LeaveIfError(ws1.Connect());
+	CleanupClosePushL(ws1);
+
+	// assign to the correct screen
+	CWsScreenDevice* screen1 = new (ELeave) CWsScreenDevice(ws1);
+	CleanupStack::PushL(screen1);
+	User::LeaveIfError(screen1->Construct(iTest->iScreenNumber));
+
+	RWindowGroup gw1(ws1);
+	User::LeaveIfError(gw1.Construct(EWindowGroupHandle1));
+	gw1.SetOwningWindowGroup((*windowHandles)[0]);
+	RWsSession ws2;
+	User::LeaveIfError(ws2.Connect());
+	CleanupClosePushL(ws2);
+
+	// assign to the correct screen
+	CWsScreenDevice* screen2 = new (ELeave) CWsScreenDevice(ws2);
+	CleanupStack::PushL(screen2);
+	User::LeaveIfError(screen2->Construct(iTest->iScreenNumber));
+
+	RWindowGroup gw2(ws2);
+	User::LeaveIfError(gw2.Construct(EWindowGroupHandle2));
+//
+	GetGwListL(0, windowHandles);
+//
+
+	retVal = gw2.Identifier();
+	TEST(retVal==(*windowHandles)[0]);
+	if (retVal!=(*windowHandles)[0])
+		INFO_PRINTF3(_L("gw2.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[0], retVal);
+
+	retVal = gw1.Identifier();
+	TEST(retVal==(*windowHandles)[1]);
+	if (retVal!=(*windowHandles)[1])
+		INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[1], retVal);
+
+	retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]);
+	TEST(retVal==EWindowGroupHandle2);
+	if (retVal!=EWindowGroupHandle2)
+		INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle2, retVal);
+
+	retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]);
+	TEST(retVal==EWindowGroupHandle1);
+	if (retVal!=EWindowGroupHandle1)
+		INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle1, retVal);
+//
+	retVal = TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[1]);
+	TEST(retVal==0);
+	if (retVal!=0)
+		INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[1]) return value - Expected: %d, Actual: %d"), 0, retVal);
+
+	retVal = TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[0]);
+	TEST(retVal==0);
+	if (retVal!=0)
+		INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[0]) return value - Expected: %d, Actual: %d"), 0, retVal);
+
+//
+	TThreadId threadId;
+	TheClient->iWs.GetWindowGroupClientThreadId((*windowHandles)[0],threadId);
+
+	TUint64 ret = RThread().Id();
+	TEST(ret==threadId);
+	if (ret!=threadId)
+		INFO_PRINTF3(_L("RThread().Id() return value - Expected: %d, Actual: %d"), (TInt)threadId, (TInt)ret);
+
+	TheClient->iWs.GetWindowGroupClientThreadId((*windowHandles)[1],threadId);
+
+	TUint64 retVal2 = RThread().Id();
+	TEST(retVal2==threadId);
+	if (retVal2!=threadId)
+		INFO_PRINTF3(_L("RThread().Id() return value - Expected: %d, Actual: %d"), (TInt)threadId, (TInt)retVal2);
+//
+	retVal = gw1.OrdinalPosition();
+	TEST(retVal==1);
+	if (retVal!=1)
+		INFO_PRINTF3(_L("gw1.OrdinalPosition() return value - Expected: %d, Actual: %d"), 1, retVal);
+
+	retVal = gw2.OrdinalPosition();
+	TEST(retVal==0);
+	if (retVal!=0)
+		INFO_PRINTF3(_L("gw2.OrdinalPosition() return value - Expected: %d, Actual: %d"), 0, retVal);
+
+	retVal = TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[1],0);
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[1],0) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	retVal = gw1.OrdinalPosition();
+	TEST(retVal==0);
+	if (retVal!=0)
+		INFO_PRINTF3(_L("gw1.OrdinalPosition() return value - Expected: %d, Actual: %d"), 0, retVal);
+
+	retVal = gw2.OrdinalPosition();
+	TEST(retVal==1);
+	if (retVal!=1)
+		INFO_PRINTF3(_L("gw2.OrdinalPosition() return value - Expected: %d, Actual: %d"), 1, retVal);
+//
+	retVal = TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[1],1);
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[1],1) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	retVal = gw1.OrdinalPosition();
+	TEST(retVal==1);
+	if (retVal!=1)
+		INFO_PRINTF3(_L("gw1.OrdinalPosition() return value - Expected: %d, Actual: %d"), 1, retVal);
+
+	retVal = gw2.OrdinalPosition();
+	TEST(retVal==0);
+	if (retVal!=0)
+		INFO_PRINTF3(_L("gw2.OrdinalPosition() return value - Expected: %d, Actual: %d"), 0, retVal);
+
+	retVal = TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[0],1);
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+		INFO_PRINTF3(_L("TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[0],1) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	GetGwListL(0, windowHandles);
+	retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]);
+	TEST(retVal==EWindowGroupHandle1);
+	if (retVal!=EWindowGroupHandle1)
+		INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle1, retVal);
+
+	retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]);
+	TEST(retVal==EWindowGroupHandle2);
+	if (retVal!=EWindowGroupHandle2)
+		INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle2, retVal);
+//
+	RWindowGroup gw3(ws2);
+	User::LeaveIfError(gw3.Construct(EWindowGroupHandle3));
+	gw1.SetOrdinalPosition(0,100000);	// Assume nothing else in the system is higher, else test will fail
+	gw3.SetOrdinalPosition(0,100000);
+	ws1.Flush();
+	ws2.Flush();
+//
+	GetGwListL(100000, windowHandles);
+	retVal = windowHandles->Count();
+	TEST(retVal==2);
+	if (retVal!=2)
+		INFO_PRINTF3(_L("windowHandles->Count() return value - Expected: %d, Actual: %d"), 2, retVal);
+
+	retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]);
+	TEST(retVal==EWindowGroupHandle3);
+	if (retVal!=EWindowGroupHandle3)
+		INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle3, retVal);
+
+	retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]);
+	TEST(retVal==EWindowGroupHandle1);
+	if (retVal!=EWindowGroupHandle1)
+		INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle1, retVal);
+
+//
+	retVal = TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[0]);
+	TEST(retVal==100000);
+	if (retVal!=100000)
+		INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[0]) return value - Expected: %d, Actual: %d"), 100000, retVal);
+
+	retVal = TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[1]);
+	TEST(retVal==100000);
+	if (retVal!=100000)
+		INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupOrdinalPriority((*windowHandles)[1]) return value - Expected: %d, Actual: %d"), 100000, retVal);
+//
+	GetGwListL(-12453, windowHandles);	// Test 0 count, Assumes no window with priority
+	retVal = windowHandles->Count();
+	TEST(retVal==0);
+	if (retVal!=0)
+		INFO_PRINTF3(_L("windowHandles->Count() return value - Expected: %d, Actual: %d"), 0, retVal);
+
+//
+	GetGwListL(windowHandles, iTest->iScreenNumber);
+	retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]);
+	TEST(retVal==EWindowGroupHandle3);
+	if (retVal!=EWindowGroupHandle3)
+		INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[0]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle3, retVal);
+
+	retVal = TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]);
+	TEST(retVal==EWindowGroupHandle1);
+	if (retVal!=EWindowGroupHandle1)
+		INFO_PRINTF3(_L("TheClient->iWs.GetWindowGroupHandle((*windowHandles)[1]) return value - Expected: %d, Actual: %d"), EWindowGroupHandle1, retVal);
+//
+// Check passing bad identifiers
+//
+	retVal = TheClient->iWs.SetWindowGroupOrdinalPosition(-1,0);
+	TEST(retVal==KErrNotFound);
+	if (retVal!=KErrNotFound)
+		INFO_PRINTF3(_L("TheClient->iWs.SetWindowGroupOrdinalPosition(-1,0) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
+
+	retVal = TheClient->iWs.GetWindowGroupHandle(-3);
+	TEST(retVal==KErrNotFound);
+	if (retVal!=KErrNotFound)
+		INFO_PRINTF3(_L("TTheClient->iWs.GetWindowGroupHandle(-3) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
+
+//
+	gw1.Close();
+	gw2.Close();
+	gw3.Close();
+	
+	CleanupStack::PopAndDestroy(5, windowHandles);
+	}
+
+void CTGwHandle::OwnerToForegroundL()
+	{
+	enum {EWindowGroupHandle1=234567};
+	enum {EWindowGroupHandle2a=666666};
+	enum {EWindowGroupHandle2b=666667};
+//
+	CArrayFixFlat<TInt> *windowHandles=new(ELeave) CArrayFixFlat<TInt>(5);
+	CleanupStack::PushL(windowHandles);
+	GetGwListL(0, windowHandles);
+	TInt oldForeground=(*windowHandles)[0];
+//
+	RWsSession ws1;
+	User::LeaveIfError(ws1.Connect());
+	CleanupClosePushL(ws1);
+
+	// assign to the correct screen
+	CWsScreenDevice* screen1 = new (ELeave) CWsScreenDevice(ws1);
+	CleanupStack::PushL(screen1);
+	User::LeaveIfError(screen1->Construct(iTest->iScreenNumber));
+
+	RWindowGroup gw1(ws1);
+	User::LeaveIfError(gw1.Construct(EWindowGroupHandle1));
+	CleanupClosePushL(gw1);
+	RWsSession ws2;
+	User::LeaveIfError(ws2.Connect());
+	CleanupClosePushL(ws2);
+
+	// assign to the correct screen
+	CWsScreenDevice* screen2 = new (ELeave) CWsScreenDevice(ws2);
+	CleanupStack::PushL(screen2);
+	User::LeaveIfError(screen2->Construct(iTest->iScreenNumber));
+
+	RWindowGroup gw2a(ws2);
+	User::LeaveIfError(gw2a.Construct(EWindowGroupHandle2a));
+	CleanupClosePushL(gw2a);
+	RWindowGroup gw2b(ws2);
+	User::LeaveIfError(gw2b.Construct(EWindowGroupHandle2b));
+	CleanupClosePushL(gw2b);
+	gw1.SetOrdinalPosition(1);
+//
+// Turn auto flushing on as we're using multiple connections and it would be easy to forget to flush one
+//
+	ws1.SetAutoFlush(ETrue);
+	ws2.SetAutoFlush(ETrue);
+	TheClient->iWs.SetAutoFlush(ETrue);
+//
+	GetGwListL(0, windowHandles);
+//
+	TInt  retVal = gw2b.Identifier();
+	TEST(retVal==(*windowHandles)[0]);
+	if (retVal!=(*windowHandles)[0])
+		INFO_PRINTF3(_L("gw2b.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[0], retVal);
+
+	retVal = gw1.Identifier();
+	TEST(retVal==(*windowHandles)[1]);
+	if (retVal!=(*windowHandles)[1])
+		INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[1], retVal);
+
+	retVal = gw2a.Identifier();
+	TEST(retVal==(*windowHandles)[2]);
+	if (retVal!=(*windowHandles)[2])
+		INFO_PRINTF3(_L("gw2a.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[2], retVal);
+
+	retVal = oldForeground;
+	TEST(retVal==(*windowHandles)[3]);
+	if (retVal!=(*windowHandles)[3])
+		INFO_PRINTF3(_L("oldForeground - Expected: %d, Actual: %d"), (*windowHandles)[3], oldForeground);
+//
+	CleanupStack::PopAndDestroy(&gw2b);
+	GetGwListL(0, windowHandles);
+
+	retVal = gw2a.Identifier();
+	TEST(retVal==(*windowHandles)[0]);
+	if (retVal!=(*windowHandles)[0])
+		INFO_PRINTF3(_L("gw2a.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[0], retVal);
+	// Check 2a jumped over 1 in the ordinal list
+
+	retVal = gw1.Identifier();
+	TEST(retVal==(*windowHandles)[1]);
+	if (retVal!=(*windowHandles)[1])
+		INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[1], retVal);
+
+	retVal = oldForeground;
+	TEST(retVal==(*windowHandles)[2]);
+	if (retVal!=(*windowHandles)[2])
+		INFO_PRINTF3(_L("oldForeground - Expected: %d, Actual: %d"), (*windowHandles)[2], oldForeground);
+
+//
+	User::LeaveIfError(gw2b.Construct(EWindowGroupHandle2b));
+	CleanupClosePushL(gw2b);
+	gw2b.SetOwningWindowGroup(oldForeground);
+	CleanupStack::PopAndDestroy(&gw2b);
+	GetGwListL(0, windowHandles);
+	retVal = oldForeground;
+	TEST(retVal==(*windowHandles)[0]);
+	if (retVal!=(*windowHandles)[0])
+		INFO_PRINTF3(_L("oldForeground - Expected: %d, Actual: %d"), (*windowHandles)[0], oldForeground);
+	// Check old foreground bought to foreground
+
+	retVal = gw2a.Identifier();
+	TEST(retVal==(*windowHandles)[1]);
+	if (retVal!=(*windowHandles)[1])
+		INFO_PRINTF3(_L("gw2a.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[1], retVal);
+
+	retVal = gw1.Identifier();
+	TEST(retVal==(*windowHandles)[2]);
+	if (retVal!=(*windowHandles)[2])
+		INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[2], retVal);
+
+	TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[0],2);
+//
+	User::LeaveIfError(gw2b.Construct(EWindowGroupHandle2b));
+	CleanupClosePushL(gw2b);
+	gw2b.SetOwningWindowGroup((*windowHandles)[1]);
+	gw2b.SetOrdinalPosition(KOrdinalPositionSwitchToOwningWindow);	// Should bring 2a to foreground
+	GetGwListL(0, windowHandles);
+
+	retVal = gw2a.Identifier();
+	TEST(retVal==(*windowHandles)[0]);
+	if (retVal!=(*windowHandles)[0])
+		INFO_PRINTF3(_L("gw2a.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[0], retVal);
+
+	retVal = gw2b.Identifier();
+	TEST(retVal==(*windowHandles)[1]);
+	if (retVal!=(*windowHandles)[1])
+		INFO_PRINTF3(_L("gw2b.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[1], retVal);
+
+	retVal = gw1.Identifier();
+	TEST(retVal==(*windowHandles)[2]);
+	if (retVal!=(*windowHandles)[2])
+		INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[2], retVal);
+//
+	CleanupStack::PopAndDestroy(&gw2b);
+	GetGwListL(0, windowHandles);
+	retVal = gw2a.Identifier();
+	TEST(retVal==(*windowHandles)[0]);
+	if (retVal!=(*windowHandles)[0])
+		INFO_PRINTF3(_L("gw2a.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[0], retVal);
+
+	retVal = gw1.Identifier();
+	TEST(retVal==(*windowHandles)[1]);
+	if (retVal!=(*windowHandles)[1])
+		INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[1], retVal);
+//
+	CleanupStack::PopAndDestroy(&gw2a);		// Should bring shell to foreground
+	GetGwListL(0, windowHandles);
+
+// check whether the shell is on
+	TThreadId threadId;
+	ws2.GetWindowGroupClientThreadId((*windowHandles)[0],threadId);
+	TBool shellRunning=ETrue;
+
+	TFullName shellName;
+	// apply to primary screen only where SHELL is running
+	TFindThread findThread(iTest->iScreenNumber==KDefaultScreen?_L("WSHELL*::*"):_L("WxSHELL*::*"));
+	if(findThread.Next(shellName)==KErrNone)
+		{
+		RThread shell;
+		User::LeaveIfError(shell.Open(shellName));
+		TEST(shell.Id()==threadId);
+		if (retVal!=(*windowHandles)[1])
+		INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[1], retVal);
+
+		shell.Close();
+		}
+	else
+		{
+		shellRunning=EFalse;
+		}
+
+
+	// Check gw1 second
+	retVal = gw1.Identifier();
+	TEST(retVal==(*windowHandles)[shellRunning ? 1 : 0]);
+	if (retVal!=(*windowHandles)[shellRunning ? 1 : 0])
+		INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[shellRunning ? 1 : 0], retVal);
+
+	retVal = oldForeground;
+	TEST(retVal==(*windowHandles)[shellRunning ? 2 : 1]);
+	if (retVal!=(*windowHandles)[shellRunning ? 2 : 1])
+		INFO_PRINTF3(_L("gw1.Identifier() return value - Expected: %d, Actual: %d"), (*windowHandles)[shellRunning ? 2 : 1], retVal);
+	// and oldforeground second
+
+//
+	CleanupStack::PopAndDestroy(5, &ws1);
+//
+// Kick shell back into background, 'cause that's where it belongs
+//
+	TheClient->iWs.SetWindowGroupOrdinalPosition((*windowHandles)[0],-1);
+	TheClient->iWs.SetAutoFlush(EFalse);
+//
+	CleanupStack::PopAndDestroy(windowHandles);
+	}
+
+void CTGwHandle::FindWindowGroupIdentifierTestL()
+	{
+	enum {EWindowGroupHandle1=234567};
+	enum {EWindowGroupHandle2=666666};
+	enum {EWindowGroupHandle3=123};
+	TInt foreground=TheClient->iWs.GetFocusWindowGroup();
+	RWsSession ws1;
+	User::LeaveIfError(ws1.Connect());
+
+	// assign to the correct screen
+	CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws1);
+	CleanupStack::PushL(screen);
+	User::LeaveIfError(screen->Construct(iTest->iScreenNumber));
+	CleanupStack::Pop(screen);
+
+	CleanupClosePushL(ws1);
+//
+	RWindowGroup gw1(ws1);
+	User::LeaveIfError(gw1.Construct(EWindowGroupHandle1));
+	CleanupClosePushL(gw1);
+	gw1.SetOwningWindowGroup(foreground);
+	RWindowGroup gw2(ws1);
+	User::LeaveIfError(gw2.Construct(EWindowGroupHandle2));
+	CleanupClosePushL(gw2);
+	gw1.SetOwningWindowGroup(foreground);
+	RWindowGroup gw3(ws1);
+	User::LeaveIfError(gw3.Construct(EWindowGroupHandle3));
+	CleanupClosePushL(gw3);
+	gw3.SetOwningWindowGroup(foreground);
+//
+	TInt id1=gw1.Identifier();
+	TInt id2=gw2.Identifier();
+	TInt id3=gw3.Identifier();
+//
+	gw1.SetName(_L("qwerty123abcd"));
+	gw2.SetName(_L("123"));
+	gw3.SetName(_L("qqqabcdxxx123"));
+//
+	TInt retVal = ws1.FindWindowGroupIdentifier(0,_L("123"),0);
+	TEST(retVal==id2);
+	if (retVal!=id2)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(0,_L(123),0) return value - Expected: %d, Actual: %d"), id2, retVal);
+
+//
+	retVal = ws1.FindWindowGroupIdentifier(0,_L("*123*"),0);
+	TEST(retVal==id3);
+	if (retVal!=id3)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(0,_L(*123*),0) return value - Expected: %d, Actual: %d"), id3, retVal);
+
+	retVal = ws1.FindWindowGroupIdentifier(id3,_L("*123*"),0);
+	TEST(retVal==id2);
+	if (retVal!=id2)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id3,_L(*123*),0) return value - Expected: %d, Actual: %d"), id2, retVal);
+
+	retVal = ws1.FindWindowGroupIdentifier(id2,_L("*123*"),0);
+	TEST(retVal==id1);
+	if (retVal!=id1)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id2,_L(*123*),0) return value - Expected: %d, Actual: %d"), id1, retVal);
+
+//
+	retVal = ws1.FindWindowGroupIdentifier(0,_L("*abcd*"),0);
+	TEST(retVal==id3);
+	if (retVal!=id3)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(0,_L(*abcd*),0) return value - Expected: %d, Actual: %d"), id3, retVal);
+
+	retVal = ws1.FindWindowGroupIdentifier(id3,_L("*abcd*"),0);
+	TEST(retVal==id1);
+	if (retVal!=id1)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id3,_L(*abcd*),0)return value - Expected: %d, Actual: %d"), id1, retVal);
+//
+	retVal = ws1.FindWindowGroupIdentifier(0,_L("*123*"),7);
+	TEST(retVal==id3);
+	if (retVal!=id3)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(0,_L(*123*),7)return value - Expected: %d, Actual: %d"), id3, retVal);
+
+	retVal = ws1.FindWindowGroupIdentifier(id3,_L("*123*"),7);
+	TEST(retVal==KErrNotFound);
+	if (retVal!=KErrNotFound)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id3,_L(*123*),7) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
+
+	retVal = ws1.FindWindowGroupIdentifier(0,_L("*abc*"),4);
+	TEST(retVal==id1);
+	if (retVal!=id1)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(0,_L(*abc*),4) return value - Expected: %d, Actual: %d"), id1, retVal);
+
+	retVal = ws1.FindWindowGroupIdentifier(id1,_L("*abc*"),4);
+	TEST(retVal==KErrNotFound);
+	if (retVal!=KErrNotFound)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id1,_L(*abc*),4) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
+
+	retVal = ws1.FindWindowGroupIdentifier(0,_L("xxx*"),7);
+	TEST(retVal==id3);
+	if (retVal!=id3)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(0,_L(xxx*),7) return value - Expected: %d, Actual: %d"), id3, retVal);
+
+	retVal = ws1.FindWindowGroupIdentifier(0,_L("xxx*"),8);
+	TEST(retVal==KErrNotFound);
+	if (retVal!=KErrNotFound)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(0,_L(xxx*),8) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
+//
+	retVal = ws1.FindWindowGroupIdentifier(id1,_L("12"),0);
+	TEST(retVal==KErrNotFound);
+	if (retVal!=KErrNotFound)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id1,_L(12),0) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
+
+	retVal = ws1.FindWindowGroupIdentifier(id1,_L("qqq"),0);
+	TEST(retVal==KErrNotFound);
+	if (retVal!=KErrNotFound)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id1,_L(qqq),0) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
+
+	retVal = ws1.FindWindowGroupIdentifier(id1,_L("abcd"),3);
+	TEST(retVal==KErrNotFound);
+	if (retVal!=KErrNotFound)
+		INFO_PRINTF3(_L("ws1.FindWindowGroupIdentifier(id1,_L(abcd),3) return value - Expected: %d, Actual: %d"), KErrNotFound, retVal);
+//
+	delete screen;
+	CleanupStack::PopAndDestroy(4, &ws1);
+	}
+
+void CTGwHandle::DefaultOwningWindowL()
+	{
+	TInt foreground=TheClient->iWs.GetFocusWindowGroup();
+	RWsSession ws1;
+	User::LeaveIfError(ws1.Connect());
+
+	// assign to the correct screen
+	CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws1);
+	CleanupStack::PushL(screen);
+	User::LeaveIfError(screen->Construct(iTest->iScreenNumber));
+
+//
+	INFO_PRINTF1(_L("DefaultOwningWindow1"));
+	RWindowGroup gw1(ws1);
+	User::LeaveIfError(gw1.Construct(1));
+	gw1.SetOwningWindowGroup(foreground);
+	RWindowGroup gw2(ws1);
+	User::LeaveIfError(gw2.Construct(2));
+	gw2.SetOwningWindowGroup(foreground);
+	RWindowGroup gw3(ws1);
+	User::LeaveIfError(gw3.Construct(3));
+	gw3.SetOwningWindowGroup(foreground);
+	RWindowGroup gw4(ws1);
+	User::LeaveIfError(gw4.Construct(4));
+	gw4.SetOwningWindowGroup(foreground);
+	INFO_PRINTF1(_L(" Created Group Window"));
+//
+	TInt prevOwningGroup=ws1.GetDefaultOwningWindow();
+	gw1.DefaultOwningWindow();
+	TEST(gw1.Identifier()==ws1.GetDefaultOwningWindow());
+	if (gw1.Identifier()!=ws1.GetDefaultOwningWindow())
+		INFO_PRINTF3(_L("gw1.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1.Identifier());
+
+	gw2.DefaultOwningWindow();
+	TEST(gw2.Identifier()==ws1.GetDefaultOwningWindow());
+	if (gw2.Identifier()!=ws1.GetDefaultOwningWindow())
+		INFO_PRINTF3(_L("gw2.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw2.Identifier());
+
+	gw2.Close();
+	TEST(gw1.Identifier()==ws1.GetDefaultOwningWindow());
+	if (gw1.Identifier()!=ws1.GetDefaultOwningWindow())
+		INFO_PRINTF3(_L("gw1.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1.Identifier());
+
+	gw3.DefaultOwningWindow();
+	gw4.DefaultOwningWindow();
+	gw3.Close();
+	TEST(gw4.Identifier()==ws1.GetDefaultOwningWindow());
+	if (gw4.Identifier()!=ws1.GetDefaultOwningWindow())
+		INFO_PRINTF3(_L("gw4.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw4.Identifier());
+
+	gw4.Close();
+	TEST(gw1.Identifier()==ws1.GetDefaultOwningWindow());
+	if (gw1.Identifier()!=ws1.GetDefaultOwningWindow())
+		INFO_PRINTF3(_L("gw1.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1.Identifier());
+
+	gw1.Close();
+	TEST(prevOwningGroup==ws1.GetDefaultOwningWindow());
+	if (prevOwningGroup!=ws1.GetDefaultOwningWindow())
+		INFO_PRINTF3(_L("prevOwningGroup==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), prevOwningGroup);
+
+	INFO_PRINTF1(_L(" Closed Group Window"));
+
+	User::LeaveIfError(gw1.Construct(1));
+	gw1.SetOwningWindowGroup(foreground);
+	User::LeaveIfError(gw2.Construct(2));
+	gw2.SetOwningWindowGroup(foreground);
+	User::LeaveIfError(gw3.Construct(3));
+	gw3.SetOwningWindowGroup(foreground);
+	INFO_PRINTF1(_L(" ReCreated Group Window"));
+	gw1.DefaultOwningWindow();
+	gw1.DefaultOwningWindow();
+ 	gw1.Close();
+	gw2.DefaultOwningWindow();
+	gw2.DefaultOwningWindow();
+	gw3.Close();
+	gw2.Close();
+	INFO_PRINTF1(_L(" Re-Closed Group Window"));
+
+	User::LeaveIfError(gw1.Construct(1));
+	gw1.SetOwningWindowGroup(foreground);
+	User::LeaveIfError(gw2.Construct(2));
+	gw2.SetOwningWindowGroup(foreground);
+	User::LeaveIfError(gw3.Construct(3));
+	gw3.SetOwningWindowGroup(foreground);
+	User::LeaveIfError(gw4.Construct(4));
+	gw4.SetOwningWindowGroup(foreground);
+	INFO_PRINTF1(_L(" ReCreated Group Window Again"));
+	gw1.DefaultOwningWindow();
+	gw2.DefaultOwningWindow();
+	gw1.DefaultOwningWindow();
+ 	gw1.Close();
+	gw2.Close();
+	gw3.DefaultOwningWindow();
+	gw4.DefaultOwningWindow();
+	gw3.DefaultOwningWindow();
+ 	gw4.Close();
+	gw3.Close();
+	INFO_PRINTF1(_L(" Re-Closed Group Window Again"));
+
+	User::LeaveIfError(gw1.Construct(1));
+	gw1.DefaultOwningWindow();
+	TEST(gw1.Identifier()==ws1.GetDefaultOwningWindow());
+	if (gw1.Identifier()!=ws1.GetDefaultOwningWindow())
+		INFO_PRINTF3(_L("gw1.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1.Identifier());
+
+	gw1.DefaultOwningWindow();
+	TEST(gw1.Identifier()==ws1.GetDefaultOwningWindow());
+	if (gw1.Identifier()!=ws1.GetDefaultOwningWindow())
+		INFO_PRINTF3(_L("gw1.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1.Identifier());
+
+	User::LeaveIfError(gw2.Construct(2));
+	TEST(gw1.Identifier()==ws1.GetDefaultOwningWindow());
+	if (gw1.Identifier()!=ws1.GetDefaultOwningWindow())
+		INFO_PRINTF3(_L("gw1.Identifier()==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1.Identifier());
+
+	gw2.Close();
+	gw1.Close();
+
+	CleanupStack::PopAndDestroy(screen);
+	ws1.Close();
+	}
+
+void CTGwHandle::DefaultOwningWindow2L()
+//This test originally resulted in a crash, while the above test originally resulted in lockups.
+	{
+	RWsSession ws1;
+	User::LeaveIfError(ws1.Connect());
+
+	// assign to the correct screen
+	CWsScreenDevice* screen1 = new (ELeave) CWsScreenDevice(ws1);
+	CleanupStack::PushL(screen1);
+	User::LeaveIfError(screen1->Construct(iTest->iScreenNumber));
+
+	RWsSession ws2;
+	User::LeaveIfError(ws2.Connect());
+
+	// assign to the correct screen
+	CWsScreenDevice* screen2 = new (ELeave) CWsScreenDevice(ws2);
+	CleanupStack::PushL(screen2);
+	User::LeaveIfError(screen2->Construct(iTest->iScreenNumber));
+
+//
+	RWindowGroup gw1(ws1);
+	User::LeaveIfError(gw1.Construct(1));
+	RWindowGroup gw2(ws2);
+	User::LeaveIfError(gw2.Construct(2));
+	RWindowGroup gw3(ws1);
+	User::LeaveIfError(gw3.Construct(3));
+//
+	const TInt gw1Id=gw1.Identifier();
+	gw1.DefaultOwningWindow();
+	gw2.DefaultOwningWindow();
+	/*const TInt gw2Id=*/gw2.Identifier();
+	gw1.DefaultOwningWindow();
+	TEST(gw1Id==ws1.GetDefaultOwningWindow());
+	if (gw1Id!=ws1.GetDefaultOwningWindow())
+		INFO_PRINTF3(_L("gw1Id==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1Id);
+
+	gw3.DefaultOwningWindow();
+	gw3.Close();
+	TEST(gw1Id==ws1.GetDefaultOwningWindow());
+	if (gw1Id!=ws1.GetDefaultOwningWindow())
+		INFO_PRINTF3(_L("gw1Id==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw1Id);
+
+	gw1.Close();
+	TInt gw2Id=gw2.Identifier();
+	TEST(gw2Id==ws1.GetDefaultOwningWindow());
+	if (gw2Id!=ws1.GetDefaultOwningWindow())
+		INFO_PRINTF3(_L("gw2Id==ws1.GetDefaultOwningWindow() - Expected: %d, Actual: %d"), ws1.GetDefaultOwningWindow(), gw2Id);
+
+	gw2.SetOrdinalPosition(0);
+	gw2.Close();
+	ws2.Flush();
+	TRawEvent rawEvent;
+	rawEvent.Set(TRawEvent::EKeyDown,32);
+	TheClient->iWs.SimulateRawEvent(rawEvent);
+	TheClient->iWs.Flush();
+//
+	CleanupStack::PopAndDestroy(2,screen1);
+	ws1.Close();
+	ws2.Close();
+	}
+
+#define FREQ 500
+void CTGwHandle::IdentifierWrapAroundTestL()
+	{
+	TInt report=-1;
+	RWsSession ws1;
+	User::LeaveIfError(ws1.Connect());
+
+	// assign to the correct screen
+	CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws1);
+	CleanupStack::PushL(screen);
+	User::LeaveIfError(screen->Construct(iTest->iScreenNumber));
+
+	RWindowGroup gw1(ws1);
+	User::LeaveIfError(gw1.Construct(1));
+	gw1.EnableReceiptOfFocus(EFalse);
+	TInt id1=gw1.Identifier();
+	RWindowGroup gw2(ws1);
+	User::LeaveIfError(gw2.Construct(2));
+	gw2.EnableReceiptOfFocus(EFalse);
+	TInt id2=gw2.Identifier();
+	gw2.Close();	// Allow gw2 id to be re-used
+	TInt id3;
+
+	do
+		{
+		RWindowGroup gw3(ws1);
+		User::LeaveIfError(gw3.Construct(2));
+		gw3.EnableReceiptOfFocus(EFalse);
+		id3=gw3.Identifier();
+		if ((id3/FREQ)!=(report/FREQ))	// || id3<=10)
+			{
+			report=id3;
+			iTest->LogMessage(id3);
+			}
+		TEST(id3!=id1);	// Check id1 is not re-used as the window hasn't been freed yet
+		if (id3==id1)
+			{
+			_LIT(KErr,"Window Group Id Reused!");
+			LOG_MESSAGE(KErr);
+			}
+		gw3.Close();
+		} while(id3!=id2);
+
+	CleanupStack::PopAndDestroy(screen);
+	ws1.Close();
+	}
+
+void GwHandleDestroyWindow(TAny* aWindow)
+	{
+	static_cast<RWindowTreeNode*>(aWindow)->Destroy();
+	}
+
+RWindowGroup* CTGwHandle::CreateWindowGroupLC(RWsSession& aWs,TUint32 aClientHandle,TInt aParentId/*=0*/)
+	{
+	RWindowGroup* gw=new(ELeave) RWindowGroup(aWs);
+	CleanupStack::PushL(TCleanupItem(&GwHandleDestroyWindow,gw));
+	if (aParentId>0)
+		{
+		User::LeaveIfError(gw->ConstructChildApp(aParentId,aClientHandle,EFalse));
+		}
+	else
+		{
+		User::LeaveIfError(gw->Construct(aClientHandle,EFalse));
+		}
+	return gw;
+	}
+
+void CTGwHandle::CreateGroupWindowsLC(RWsSession& aWs)
+	{
+	for(TInt ii=ENumGroups-1;ii>=0;--ii)
+		iGroups[ii]=CreateWindowGroupLC(aWs,ii);
+	}
+
+void CTGwHandle::CreateChainedGroupWindowsLC(RWsSession& aWs,TBool aSecondChain)
+	{
+	TInt parentId=0;
+	for(TInt ii=ENumChained-1;ii>=0;--ii)
+		{
+		iChained[ii]=CreateWindowGroupLC(aWs,ENumGroups+ii,parentId);
+		parentId=iChained[ii]->Identifier();
+		}
+	if(aSecondChain)
+		{
+		parentId =0;
+		for(TInt ii=ENumChained-1;ii>=0;--ii)
+			{
+			iChained2[ii]=CreateWindowGroupLC(aWs,ENumGroups+ENumGroups+ii,parentId);
+			parentId=iChained2[ii]->Identifier();
+			}
+		}
+	}
+
+void CTGwHandle::MoveGroups(RWindowGroup** aGroups,TInt aGp,TInt aNum,TInt aPos,TInt aInc/*=2*/)
+	{
+	TInt ii;
+	for(ii=aNum;ii>0;--ii)
+		{
+		aGroups[aGp]->SetOrdinalPosition(aPos);
+		aGp+=(aInc>0?1:-1);
+		aPos+=aInc;
+		}
+	}
+
+void CTGwHandle::TestGroups(TInt aPos)
+	{
+	TInt retVal;
+	TInt ii = 0;
+	for(ii=0;ii<ENumChained;++ii)
+		{
+		retVal = iChained[ii]->OrdinalPosition();
+		TEST(retVal==aPos+ii);
+		if (retVal!=aPos+ii)
+			INFO_PRINTF3(_L("iChained[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), aPos+ii, retVal);
+		}
+
+	for(ii=0;ii<ENumGroups;++ii)
+		{
+		retVal = iGroups[ii]->OrdinalPosition();
+		TInt ret = (ii<aPos?ii:ii+ENumChained);
+		TEST(retVal==ret);
+		if (retVal!=ret)
+			INFO_PRINTF3(_L("iGroups[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), ret, retVal);
+		}
+	}
+
+void CTGwHandle::TestGroupsBefore(TInt aPos)
+	{
+	TInt ii;
+	TInt retVal;
+	if (aPos>0)
+		{
+		for (ii=0;ii<aPos;++ii)
+			{
+			retVal = iGroups[ii]->OrdinalPosition();
+			TEST(retVal==ii);
+			if (retVal!=ii)
+				INFO_PRINTF3(_L("iGroups[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), ii, retVal);
+			}
+		}
+	for (ii=0;ii<ENumChained;++ii)
+		{
+		retVal = iChained[ii]->OrdinalPosition();
+		TEST(retVal==aPos+2*ii);
+		if (retVal!=aPos+2*ii)
+			INFO_PRINTF3(_L("iChained[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), aPos+2*ii, retVal);
+		}
+	for (ii=0;ii<ENumChained-1;++ii)
+		{
+		retVal = iGroups[aPos+ii]->OrdinalPosition();
+		TEST(retVal==aPos+1+2*ii);
+		if (retVal!=aPos+1+2*ii)
+			INFO_PRINTF3(_L("iGroups[aPos+ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), aPos+1+2*ii, retVal);
+		}
+	for (ii=aPos+ENumChained-1;ii<ENumGroups;++ii)
+		{
+		retVal = iGroups[ii]->OrdinalPosition();
+		TEST(retVal==ii+ENumChained);
+		if (retVal!=ii+ENumChained)
+			INFO_PRINTF3(_L("iGroups[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), ii+ENumChained, retVal);
+		}
+	}
+
+void CTGwHandle::WindowGroupChaining()
+	{
+	RWsSession& ws=TheClient->iWs;
+	CreateGroupWindowsLC(ws);
+	CreateChainedGroupWindowsLC(ws);
+	TestGroups(0);
+	TInt start,target,moveGp;
+	for(moveGp=0;moveGp<ENumChained;++moveGp)
+		{
+		for(target=0;target<ENumGroups+1;++target)
+			{
+			for(start=0;start<ENumGroups-ENumChained+2;++start)
+				{
+				if (target>start+1)
+					MoveGroups(iGroups,target-1,target-start-1,ENumChained+target-1,-1);
+				if (target<start && start>0)
+					MoveGroups(iGroups,0,start,0,1);
+				MoveGroups(iGroups,start,ENumChained-1,start+1);
+				TestGroupsBefore(start);
+				iChained[moveGp]->SetOrdinalPosition(target+moveGp);
+				TestGroups(target);
+				}
+			}
+		iChained[0]->SetOrdinalPosition(0);
+		TestGroups(0);
+		}
+	CleanupStack::PopAndDestroy(ENumGroups+ENumChained,iGroups[ENumGroups-1]);
+	}
+
+void CTGwHandle::WindowGroupChaining2()
+	{
+	RWsSession& ws=TheClient->iWs;
+	RWindowGroup* chain1=CreateWindowGroupLC(ws,1);
+	chain1->SetOrdinalPosition(0,1);
+	RWindowGroup* chain2=CreateWindowGroupLC(ws,2,chain1->Identifier());
+	TInt retVal = chain2->OrdinalPriority();
+	TEST(retVal==1);
+	if (retVal!=1)
+			INFO_PRINTF3(_L("chain2->OrdinalPriority() return value - Expected: %d, Actual: %d"), 1, retVal);
+
+	chain1->SetOrdinalPosition(0,2);
+	retVal = chain2->OrdinalPriority();
+	TEST(retVal==2);
+	if (retVal!=2)
+			INFO_PRINTF3(_L("chain2->OrdinalPriority() return value - Expected: %d, Actual: %d"), 2, retVal);
+
+	chain2->SetOrdinalPosition(0,3);
+	retVal = chain1->OrdinalPriority();
+	TEST(retVal==3);
+	if (retVal!=3)
+			INFO_PRINTF3(_L("chain1->OrdinalPriority() return value - Expected: %d, Actual: %d"), 3, retVal);
+
+	CleanupStack::PopAndDestroy(2,chain1);
+	
+	//Test that two different sessions can't chain window-groups without permisson.
+	//Both sessions must use the same screen.
+	RWsSession ws2;
+	User::LeaveIfError(ws2.Connect());
+	CleanupClosePushL(ws2);
+	chain1=CreateWindowGroupLC(ws2,1);
+	TInt id1=chain1->Identifier();
+	
+	RWsSession ws3;
+	User::LeaveIfError(ws3.Connect());
+	CleanupClosePushL(ws3);
+	RWindowGroup chain(ws3);
+	
+	RDebug::Print(KPlatsecBegin);
+	retVal = chain.ConstructChildApp(id1,2);
+	TEST(retVal==KErrPermissionDenied);
+	if (retVal!=KErrPermissionDenied)
+			INFO_PRINTF3(_L("chain.ConstructChildApp(id1,2) return value - Expected: %d, Actual: %d"), KErrPermissionDenied, retVal);
+
+	RDebug::Print(KPlatsecEnd);
+	chain1->AllowProcessToCreateChildWindowGroups(TUid::Uid(0x10205152));	//Secure ID
+	retVal = chain.ConstructChildApp(id1,2);
+	TEST(retVal==KErrNone);
+	if (retVal!=KErrNone)
+			INFO_PRINTF3(_L("chain.ConstructChildApp(id1,2) return value - Expected: %d, Actual: %d"), KErrNone, retVal);
+
+	chain.Close();
+	CleanupStack::PopAndDestroy(3,&ws2);
+	}
+
+void CTGwHandle::UnchainWindowGroupsL()
+	{
+	RArray<RWsSession::TWindowGroupChainInfo>* windowHandles=new(ELeave) RArray<RWsSession::TWindowGroupChainInfo>;
+	CleanupStack::PushL(windowHandles);
+	GetGwListL(0,windowHandles);
+	TInt shellWindow=windowHandles->Count();
+	//Creating chained window groups.
+	CreateChainedGroupWindowsLC(TheClient->iWs);
+	GetGwListL(0,windowHandles);
+	//Test total window groups in the list
+	TInt retVal = windowHandles->Count();
+	TEST(retVal==ENumChained+shellWindow);
+	if (retVal!=ENumChained+shellWindow)
+			INFO_PRINTF3(_L("windowHandles->Count() return value - Expected: %d, Actual: %d"), ENumChained+shellWindow, retVal);
+	//Two unchained group windows
+
+	//Test Parent Id
+	TInt parentId=0;
+	for(TInt ii=ENumChained-1;ii>=0;ii--)
+		{
+		RWsSession::TWindowGroupChainInfo window;
+		window.iId=iChained[ii]->Identifier();
+		TInt loc=windowHandles->Find(window);
+		TEST(loc!=KErrNotFound);
+		if (loc==KErrNotFound)
+			INFO_PRINTF3(_L("windowHandles->Find(window) return value - Expected: %d, Actual: %d"), KErrNotFound, loc);
+
+		if(loc!=KErrNotFound)
+			{
+			TEST((*windowHandles)[loc].iParentId==parentId);
+			if ((*windowHandles)[loc].iParentId!=parentId)
+				INFO_PRINTF3(_L("(*windowHandles)[loc].iParentId==parentId - Expected: %d, Actual: %d"), parentId, (*windowHandles)[loc].iParentId);
+
+			parentId=window.iId;
+			}
+		}
+	//Test unchaining of chained window groups
+	for(TInt count=ENumChained-1;count>=0;count--)
+		{
+		iChained[count]->Close();
+		GetGwListL(0,windowHandles);
+		TEST(windowHandles->Count()== count+shellWindow);
+		if (windowHandles->Count()!= count+shellWindow)
+				INFO_PRINTF3(_L("windowHandles->Count()==count+shellWindow - Expected: %d, Actual: %d"), count+shellWindow, windowHandles->Count());
+
+		}
+	CleanupStack::PopAndDestroy(ENumChained,iChained[ENumChained-1]);
+
+	//delete middle windowgroup of chain which should kill all the child windows
+	CreateChainedGroupWindowsLC(TheClient->iWs);
+	TInt windowPos=2;
+	CleanupStack::Pop(2,iChained[1]);	//Pop first 2 items iChained[0] and iChained[1]
+	iChained[windowPos]->Close();//Close the 3rd WindowGroup in the chain.should unchain 4 and 5 window group.
+	CleanupStack::PopAndDestroy(iChained[windowPos]);
+	CleanupStack::PushL(TCleanupItem(&GwHandleDestroyWindow,iChained[1]));
+	CleanupStack::PushL(TCleanupItem(&GwHandleDestroyWindow,iChained[0]));
+	GetGwListL(0,windowHandles);
+	retVal = ChainedWindowCount(windowHandles);
+	TEST(retVal==ENumChained-windowPos-1);
+	if (retVal!=ENumChained-windowPos-1)
+				INFO_PRINTF3(_L("ChainedWindowCount(windowHandles) return value - Expected: %d, Actual: %d"), ENumChained-windowPos-1, retVal);
+
+//	CleanupStack::PopAndDestroy(ENumChained-1,iChained[ENumChained-1]);
+
+	windowPos=3;
+	CleanupStack::Pop(2,iChained[1]);
+	iChained[windowPos]->Close();//Close the 2nd WindowGroup in the chain.
+								//should unchain all .
+	CleanupStack::PopAndDestroy(iChained[windowPos]);
+	CleanupStack::PushL(TCleanupItem(&GwHandleDestroyWindow,iChained[1]));
+	CleanupStack::PushL(TCleanupItem(&GwHandleDestroyWindow,iChained[0]));
+	GetGwListL(0,windowHandles);
+	retVal = ChainedWindowCount(windowHandles);
+	TEST(retVal==ENumChained-windowPos-2);
+	if (retVal!=ENumChained-windowPos-2)
+				INFO_PRINTF3(_L("ChainedWindowCount(windowHandles) return value - Expected: %d, Actual: %d"), ENumChained-windowPos-2, retVal);
+
+	windowPos=4;
+	CleanupStack::Pop(2,iChained[1]);
+	iChained[windowPos]->Close();//Closing parent window group in chain. There should be no chain
+	CleanupStack::PopAndDestroy(iChained[windowPos]);
+	CleanupStack::PushL(TCleanupItem(&GwHandleDestroyWindow,iChained[1]));
+	CleanupStack::PushL(TCleanupItem(&GwHandleDestroyWindow,iChained[0]));
+	GetGwListL(0,windowHandles);
+	retVal = ChainedWindowCount(windowHandles);
+	TEST(retVal==ENumChained-windowPos-1);
+	if (retVal!=ENumChained-windowPos-1)
+				INFO_PRINTF3(_L("ChainedWindowCount(windowHandles) return value - Expected: %d, Actual: %d"), ENumChained-windowPos-1, retVal);
+
+	CleanupStack::PopAndDestroy(ENumChained-3,iChained[ENumChained-4]);
+	windowHandles->Close();
+	CleanupStack::PopAndDestroy(windowHandles);
+	}
+
+TInt CTGwHandle::ChainedWindowCount(RArray<RWsSession::TWindowGroupChainInfo>* aWindowHandles)
+	{
+	TInt wndGrpCount=0;
+	for(TInt ii=0;ii<aWindowHandles->Count();ii++)
+		{
+		if((*aWindowHandles)[ii].iParentId!=-1)
+			wndGrpCount++;
+		}
+	return wndGrpCount;
+	}
+
+void CTGwHandle::TestOrdinalPositionL()
+	{
+	TInt noOfGroupWnds = NumberOfWndGroupsWithZeroPriority(iTest->iScreenNumber);
+	//Creating the chained window groups
+	CreateChainedGroupWindowsLC(TheClient->iWs);
+	TestOrdinalPos(0);
+	//Test the ordinal position of all chained windows by setting the WndPos window
+	//to chainPos position
+	for(TInt wndPos=0;wndPos<ENumChained;wndPos++)
+		{
+		for(TInt chainPos=0;chainPos<15;chainPos++)
+			{
+			iChained[wndPos]->SetOrdinalPosition(chainPos);
+			TInt dung = chainPos-wndPos;
+			if(dung > noOfGroupWnds)
+				{
+				dung = noOfGroupWnds;
+				}
+			dung = Max(dung, 0);
+			TestOrdinalPos(chainPos - wndPos > noOfGroupWnds ? noOfGroupWnds : Max(chainPos - wndPos, 0));
+			}
+		}
+	//Test for negative ordinal number
+	iChained[0]->SetOrdinalPosition(-2);
+	TestOrdinalPos(noOfGroupWnds);
+	CleanupStack::PopAndDestroy(ENumChained,iChained[ENumChained-1]);
+	}
+
+void CTGwHandle::TestOrdinalPositionNoDebugL()
+	{
+	TInt noOfGroupWnds = NumberOfWndGroupsWithZeroPriority(iTest->iScreenNumber);
+	//Creating the chained window groups
+	CreateChainedGroupWindowsLC(TheClient->iWs);
+	//Test the ordinal position of all chained windows
+	TestOrdinalPosNoDebug(0);
+	//Test the ordinal position of all chained windows by setting the WndPos window
+	//to chainPos position
+	for(TInt wndPos=0;wndPos<ENumChained;wndPos++)
+		{
+		for(TInt chainPos=0;chainPos<15;chainPos++)
+			{
+			iChained[wndPos]->SetOrdinalPosition(chainPos);
+			TestOrdinalPosNoDebug(chainPos - wndPos > noOfGroupWnds ? noOfGroupWnds : Max(chainPos - wndPos, 0));
+			}
+		}
+	//Test for negative ordinal number
+	iChained[0]->SetOrdinalPosition(-2);
+	TestOrdinalPosNoDebug(noOfGroupWnds);
+	CleanupStack::PopAndDestroy(ENumChained,iChained[ENumChained-1]);
+	}
+
+void CTGwHandle::TestOrdinalPos(TInt aPos)
+	{
+	for(TInt ii=0;ii<ENumChained;ii++)
+		{
+		TInt iCha = iChained[ii]->OrdinalPosition();
+		TEST(iCha==aPos++);
+		if (iCha!=aPos-1)
+			{
+			INFO_PRINTF3(_L("iChained[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), aPos-1, iCha);
+			}
+		}
+	}
+
+void CTGwHandle::TestOrdinalPosNoDebug(TInt aPos)
+	{
+	for(TInt ii=0;ii<ENumChained;ii++)
+		{
+		TInt iCha = iChained[ii]->OrdinalPosition();
+		TEST(iCha==aPos++);
+		if (iCha!=aPos-1)
+			INFO_PRINTF3(_L("iChained[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), aPos-1, iCha);
+
+		}
+	}
+
+void CTGwHandle:: TestclosingclientL()
+	{
+	RWsSession ws1;
+	User::LeaveIfError(ws1.Connect());
+	CleanupClosePushL(ws1);
+
+	// assign to the correct screen
+	CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws1);
+	CleanupStack::PushL(screen);
+	User::LeaveIfError(screen->Construct(iTest->iScreenNumber));
+
+	// Creating first Window Group
+	RWindowGroup gw1(ws1);
+	User::LeaveIfError(gw1.Construct(ENullWsHandle));
+	ws1.SetWindowGroupOrdinalPosition(gw1.Identifier(),0);
+
+	// Creating second Window Group
+	RWindowGroup gw2(ws1);
+	User::LeaveIfError(gw2.Construct(ENullWsHandle));
+	gw2.SetOwningWindowGroup(gw1.Identifier());
+	gw2.SetOrdinalPosition(1);
+	CleanupStack::PopAndDestroy(screen);
+	CleanupStack::PopAndDestroy(&ws1);
+	}
+
+void CTGwHandle::TestClearingAndSettingChildGroupsL()
+	{
+	RArray<RWsSession::TWindowGroupChainInfo> windowHandles;
+	CleanupClosePushL(windowHandles);
+	//Creating a chain of 5 window groups.
+	CreateChainedGroupWindowsLC(TheClient->iWs);
+	TInt ret=KErrNone;
+	// Want to test clearing and setting of window groups for chain lengths of 5 down to 2
+	for(TInt jj=ENumChained-1;jj>0;jj--)
+		{
+		// For each window group in the chain, test clearing and setting a child group
+		for(TInt ii=jj;ii>0;ii--)
+			{
+			RWsSession::TWindowGroupChainInfo window1;
+			window1.iId=iChained[ii]->Identifier();
+			GetGwListL(0,&windowHandles);
+			TInt loc=windowHandles.Find(window1);
+			TEST(loc!=KErrNotFound);
+			if(loc!=KErrNotFound)
+				{
+				RWsSession::TWindowGroupChainInfo window2;
+				window2.iId=iChained[ii-1]->Identifier();
+				loc = windowHandles.Find(window2);
+				TEST(loc!=KErrNotFound);
+				// First test that the parent of the next window in the chain is the previous in the chain
+				if(loc!=KErrNotFound)
+					{
+					TEST(windowHandles[loc].iParentId==window1.iId);
+					}
+				// Then clear and test that the parent of the next window in the chain
+				// is no longer the previous window in the chain
+				ret=iChained[ii]->ClearChildGroup();
+				TEST(ret==KErrNone);
+				// Try to clear a child group when it's already cleared - should return KErrArgument
+				ret=iChained[ii]->ClearChildGroup();
+				TEST(ret==KErrArgument);
+				GetGwListL(0,&windowHandles);
+				loc = windowHandles.Find(window2);
+				TEST(loc!=KErrNotFound);
+				// Test that it has no parent (0) or is unchained (-1)
+				if(loc!=KErrNotFound)
+					{
+					if(ii==1) // last in chain therefore unchained, should return -1
+						TEST(windowHandles[loc].iParentId==-1);
+					else // otherwise should return 0 signifying in a chain but with no parent
+						TEST(windowHandles[loc].iParentId==0);
+					}
+				// Reset the former child group as a child to the current group
+				ret=iChained[ii]->SetChildGroup(window2.iId);
+				TEST(ret==KErrNone);
+				// Test that it has now got it's parent back
+				GetGwListL(0,&windowHandles);
+				loc = windowHandles.Find(window2);
+				TEST(loc!=KErrNotFound);
+				if(loc!=KErrNotFound)
+					{
+					TEST(windowHandles[loc].iParentId==window1.iId);
+					}
+				}
+			}
+			// Reduce chain length by 1
+			ret=iChained[jj]->ClearChildGroup();
+			TEST(ret==KErrNone);
+		}
+	// Try to clear the child group of a window that's not in a queue - returns KErrArgument
+	ret=iChained[0]->ClearChildGroup();
+	TEST(ret==KErrArgument);
+	// Test calling set on a non-existent window group - fictional id, larger than what exists
+	ret=iChained[0]->SetChildGroup(9999);
+	TEST(ret==KErrArgument);
+	// Cleanup
+	CleanupStack::PopAndDestroy(ENumChained,iChained[ENumChained-1]);
+	CleanupStack::PopAndDestroy(&windowHandles);
+	}
+
+void CTGwHandle::TestAgainstLoopsWhenAddingChildGroupsL()
+	{
+	//Creating two chains of 5 window groups.
+	CreateChainedGroupWindowsLC(TheClient->iWs,ETrue);
+	TInt ret=KErrNone;
+	
+	//Try to append any of element of this chain to the lastone (itself included)
+	//All these attempts should fail (otherwise a infinite loop will be set up)
+	for(TInt ii=ENumChained-1;ii>=0;ii--)
+		{
+		TInt windowId = iChained[ii]->Identifier();
+		// Try to append it to the last one
+		ret=iChained[0]->SetChildGroup(windowId);
+		TEST(ret==KErrArgument);
+		if(ret!=KErrArgument)
+			{
+			_LIT(KLog,"Error: SetChildGroup with a GpWin belonging to the same queue succeeded, return value :%d");
+			LOG_MESSAGE2(KLog,ret);
+			}
+		}
+	//Try to append any elements belonging to another chain to the last one of this chain
+	//All these trials should fail (otherwise a infinite loop will be set up)
+	//Except for the parent of the second chain.
+	for(TInt ii=0;ii<ENumChained;ii++)
+		{
+		TInt windowId = iChained2[ii]->Identifier();
+		// Try to append it to the last one
+		ret=iChained[0]->SetChildGroup(windowId);
+		if(ii != ENumChained-1)
+			{
+			TEST(ret==KErrArgument);
+			if(ret!=KErrArgument)
+				{
+				_LIT(KLog,"Error: SetChildGroup with a GpWin which already has a parent succeeded, return value :%d");
+				LOG_MESSAGE2(KLog,ret);
+				}
+			iChained[0]->ClearChildGroup();
+			}
+		else
+			{
+			TEST(ret==KErrNone);
+			if(ret!=KErrNone)
+				{
+				_LIT(KLog,"Error: SetChildGroup with a GpWin with no parent failed, return value :%d");
+				LOG_MESSAGE2(KLog,ret);
+				}
+			}
+		}
+	TInt windowId = iChained2[ENumChained-1]->Identifier();
+	ret=iChained[ENumChained-1]->SetChildGroup(windowId);
+	TEST(ret==KErrArgument);
+	if(ret!=KErrArgument)
+		{
+		_LIT(KLog,"Error: SetChildGroup successful on a GpWin which already has a child, return value :%d");
+		LOG_MESSAGE2(KLog,ret);
+		}
+	//Now take a window group not belonging to any queue
+	//just take the parent's chain and pop it 
+	//and try to append it to itself
+	ret=iChained[ENumChained-1]->ClearChildGroup();
+	TEST(ret==KErrNone);
+	ret=iChained[ENumChained-1]->SetChildGroup(iChained[ENumChained-1]->Identifier());
+	TEST(ret==KErrArgument);
+	if(ret!=KErrArgument)
+		{
+		_LIT(KLog,"Error: Setting GpWin as a child of itself succeeded, return value :%d");
+		LOG_MESSAGE2(KLog,ret);
+		}
+    CleanupStack::PopAndDestroy(ENumChained+ENumChained,iChained[ENumChained-1]);
+	}
+void CTGwHandle::RunTestCaseL(TInt /*aCurTestCase*/)
+	{
+	_LIT(KTest0,"Window group names");
+	_LIT(KTest1,"Window group identifiers");
+	_LIT(KTest2,"Owner to foreground");
+	_LIT(KTest3,"FindWindowGroupIdentifier test");
+	_LIT(KTest4,"IdentifierWrapAround test");
+	_LIT(KTest5,"DefaultOwningWindow test");
+	_LIT(KTest6,"DefaultOwningWindow2 test");
+	_LIT(KTest7,"Window Group Chaining");
+	_LIT(KTest8,"Window Group Chaining2");
+	_LIT(KTest9,"Unchaining window group");
+	_LIT(KTest10,"Ordinal Postion Test");
+	_LIT(KTest11,"CrashTest on closing client");
+	_LIT(KTest12,"Setting and Clearing Child Groups");
+	_LIT(KTest13,"No Infinite Loops in Setting Child Groups");
+	((CTGwHandleStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
+	switch(++iTest->iState)
+		{
+/**
+
+  @SYMTestCaseID GRAPHICS-WSERV-0316
+
+  @SYMDEF             DEF081259
+
+  @SYMTestCaseDesc Test setting window group names
+
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions Set the name of a window group to different values and check the
+  					value is set correctly
+
+  @SYMTestExpectedResults The window group name is set correctly
+
+*/
+		case 1:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0316"));
+			//iState=9; break;
+			iTest->LogSubTest(KTest0);
+			GwNamesL();
+			break;
+/**
+
+  @SYMTestCaseID GRAPHICS-WSERV-0317
+
+  @SYMDEF             DEF081259
+
+  @SYMTestCaseDesc Test setting window group identifiers
+
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions Set the identifiers of a window groups. manipulate the window groups and
+  					check the identifiers remain correct
+
+  @SYMTestExpectedResults The identifiers are correct for each window group after
+  							manipulation
+
+*/
+		case 2:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0317"));
+			iTest->LogSubTest(KTest1);
+			GwIdentifierTestL();
+			break;
+/**
+
+  @SYMTestCaseID GRAPHICS-WSERV-0318
+
+  @SYMDEF             DEF081259
+
+  @SYMTestCaseDesc Test moving different window groups to the foreground and bringing
+  					back the backgorund
+
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions Create some window groups and move them in turn to the foreground before
+  					restoring the background
+
+  @SYMTestExpectedResults Window groups move to and from the foreground with error
+
+*/
+		case 3:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0318"));
+			iTest->LogSubTest(KTest2);
+			OwnerToForegroundL();
+			break;
+/**
+
+  @SYMTestCaseID GRAPHICS-WSERV-0319
+
+  @SYMDEF             DEF081259
+
+  @SYMTestCaseDesc Test returning different window groups identifiers by searching
+  					on the name
+
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions Create some window groups and return their identifiers by searching on
+  					their names
+
+  @SYMTestExpectedResults The correct identifiers are returned for each name
+
+*/
+		case 4:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0319"));
+			iTest->LogSubTest(KTest3);
+			FindWindowGroupIdentifierTestL();
+			break;
+/**
+
+  @SYMTestCaseID GRAPHICS-WSERV-0320
+
+  @SYMDEF             DEF081259
+
+  @SYMTestCaseDesc Test that a windows group identifier is not used twice
+
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions Assign a window group identifier to one window group and check
+  					the same identifier can not be used for a second group
+
+  @SYMTestExpectedResults Window group identifier can not be reused
+
+*/
+		case 5:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0320"));
+			iTest->LogSubTest(KTest4);
+			IdentifierWrapAroundTestL();
+			break;
+/**
+
+  @SYMTestCaseID GRAPHICS-WSERV-0321
+
+  @SYMDEF             DEF081259
+
+  @SYMTestCaseDesc Test that the default owning window for window groups is set
+  					correctly
+
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions Set different default owning windows for different window groups.
+  					Check the windows have been set correctly.
+
+  @SYMTestExpectedResults The default owning windows for the groups are set correctly
+
+*/
+		case 6:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0321"));
+			iTest->LogSubTest(KTest5);
+			DefaultOwningWindowL();
+			break;
+/**
+
+  @SYMTestCaseID GRAPHICS-WSERV-0322
+
+  @SYMDEF             DEF081259
+
+  @SYMTestCaseDesc Test that the default owning window for window groups is set
+  					correctly
+
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions Set different default owning windows for different window groups.
+  					Check the windows have been set correctly.
+
+  @SYMTestExpectedResults The default owning windows for the groups are set correctly
+
+*/
+		case 7:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0322"));
+			iTest->LogSubTest(KTest6);
+			DefaultOwningWindow2L();
+			TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0);
+			break;
+/**
+
+  @SYMTestCaseID GRAPHICS-WSERV-0323
+
+  @SYMDEF             DEF081259
+
+  @SYMTestCaseDesc Test that window groups can be chained correctly
+
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions Create a chain of window groups and check that the chain of groups
+  					can be manipluated correctly
+
+  @SYMTestExpectedResults The chain can be manipulated correctly
+
+*/
+		case 8:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0323"));
+			iTest->LogSubTest(KTest7);
+			WindowGroupChaining();
+			break;
+/**
+
+  @SYMTestCaseID GRAPHICS-WSERV-0324
+
+  @SYMDEF             DEF081259
+
+  @SYMTestCaseDesc Test that window groups can be chained correctly
+
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions Create a chain of window groups and check that the chain of groups
+  					can be manipluated correctly
+
+  @SYMTestExpectedResults The chain can be manipulated correctly
+
+*/
+		case 9:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0324"));
+			iTest->LogSubTest(KTest8);
+			WindowGroupChaining2();
+			break;
+/**
+
+  @SYMTestCaseID GRAPHICS-WSERV-0325
+
+  @SYMDEF             DEF081259
+
+  @SYMTestCaseDesc Test that window groups can be unchained correctly
+
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions Create chains of window groups and check that the window groups can be
+  					unchained correctly
+
+  @SYMTestExpectedResults The chain can be unchained correctly
+
+*/
+		case 10:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0325"));
+			iTest->LogSubTest(KTest9);
+			UnchainWindowGroupsL();
+			break;
+/**
+
+  @SYMTestCaseID GRAPHICS-WSERV-0326
+
+  @SYMDEF             DEF081259
+
+  @SYMTestCaseDesc Test the ordinal position of chained window groups
+
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions Create chains of window groups and check their ordinal position is correct
+  					for different scenarios
+
+  @SYMTestExpectedResults Ordinal position of chained window group is correct
+
+*/
+		case 11:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0326"));
+			iTest->LogSubTest(KTest10);
+			TestOrdinalPositionL();
+			break;
+		case 12:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0326"));
+			iTest->LogSubTest(KTest10);
+			TestOrdinalPositionNoDebugL();
+			break;
+/**
+
+  @SYMTestCaseID GRAPHICS-WSERV-0327
+
+  @SYMDEF             DEF081259
+
+  @SYMTestCaseDesc Test that window groups are dealt with correctly if their client is closed
+
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions Create window groups and then close there client.
+
+  @SYMTestExpectedResults The window groups of the closed client are handled without error
+
+*/
+		case 13:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0327"));
+			iTest->LogSubTest(KTest11);
+			TestclosingclientL();
+			break;
+		case 14:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0327"));
+			iTest->LogSubTest(KTest12);
+			TestClearingAndSettingChildGroupsL();
+			break;
+		case 15:
+			((CTGwHandleStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0327"));
+			iTest->LogSubTest(KTest13);
+			TestAgainstLoopsWhenAddingChildGroupsL();
+			break;
+		default:
+			((CTGwHandleStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+			((CTGwHandleStep*)iStep)->CloseTMSGraphicsStep();
+			TestComplete();
+			break;
+		}
+	((CTGwHandleStep*)iStep)->RecordTestResultL();
+	}
+
+__WS_CONSTRUCT_STEP__(GwHandle)