diff -r bf7481649c98 -r 2717213c588a windowing/windowserver/test/tauto/TGWHANDLE.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/windowing/windowserver/test/tauto/TGWHANDLE.CPP Tue Jun 22 15:21:29 2010 +0300 @@ -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 *aWindowHandles) + { + User::LeaveIfError(TheClient->iWs.WindowGroupList(aWindowHandles)); + } + +void CTGwHandle::GetGwListL(CArrayFixFlat *aWindowHandles, TInt aScreenNumber) + { + User::LeaveIfError(TheClient->iWs.WindowGroupList(aWindowHandles, aScreenNumber)); + } + +void CTGwHandle::GetGwListL(TInt aPriority, CArrayFixFlat *aWindowHandles) + { + User::LeaveIfError(TheClient->iWs.WindowGroupList(aPriority,aWindowHandles)); + } + +void CTGwHandle::GetGwListL(RArray* aWindowHandles) + { + User::LeaveIfError(TheClient->iWs.WindowGroupList(aWindowHandles)); + } + +void CTGwHandle::GetGwListL(TInt aPriority, RArray* 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* windowHandles=new(ELeave) CArrayFixFlat(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 *windowHandles=new(ELeave) CArrayFixFlat(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(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;iiOrdinalPosition(); + 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;iiOrdinalPosition(); + TInt ret = (iiOrdinalPosition() return value - Expected: %d, Actual: %d"), ret, retVal); + } + } + +void CTGwHandle::TestGroupsBefore(TInt aPos) + { + TInt ii; + TInt retVal; + if (aPos>0) + { + for (ii=0;iiOrdinalPosition(); + TEST(retVal==ii); + if (retVal!=ii) + INFO_PRINTF3(_L("iGroups[ii]->OrdinalPosition() return value - Expected: %d, Actual: %d"), ii, retVal); + } + } + for (ii=0;iiOrdinalPosition(); + 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;iiOrdinalPosition(); + 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;iiOrdinalPosition(); + 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;moveGpstart+1) + MoveGroups(iGroups,target-1,target-start-1,ENumChained+target-1,-1); + if (target0) + 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* windowHandles=new(ELeave) RArray; + 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* aWindowHandles) + { + TInt wndGrpCount=0; + for(TInt ii=0;iiCount();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;wndPosSetOrdinalPosition(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;wndPosSetOrdinalPosition(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;iiOrdinalPosition(); + 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;iiOrdinalPosition(); + 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 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;iiIdentifier(); + // 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)