// 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)