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