|
1 // Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // Test the text cursor. |
|
15 // |
|
16 // This suite of tests checks to see if the TextCursors are operating |
|
17 // correctly for a number of use case scenarios; see doxygen comments |
|
18 // for each sub-test. This test suite is applicable on both winscw |
|
19 // emulator and armv5 target hardware. However, it must be noted that |
|
20 // text cursors are special due to their timeliness. The text cursor |
|
21 // must flash every second: half a second ON, half a second OFF. One |
|
22 // consequence of this is that when the test suite is run on emulator, |
|
23 // the PC must be otherwise quiescent. No other IO or CPU intensive |
|
24 // activities may occur on the system, because these will cause delays |
|
25 // to the flashing of the text cursor giving unreliable results. |
|
26 // Where timeliness is a consideration, we use TEST_SOFTFAIL_WINSCW so |
|
27 // that if the test fails and we are running on the PC emulator, we only |
|
28 // record the fact, but don't mark the test as failing. |
|
29 |
|
30 /** |
|
31 @file |
|
32 @test |
|
33 @internalComponent - Internal Symbian test code |
|
34 */ |
|
35 |
|
36 #include "TTEXTCURS.H" |
|
37 #include "graphics/windowserverconstants.h" |
|
38 |
|
39 const TInt KNumberOfCustoTextCursors = 3; |
|
40 const TInt KTextCursorInitialIdValue = 1001; |
|
41 const TInt KTextCursorPanicUid1 = 200; |
|
42 const TInt KTextCursorPanicUid2 = 2000; |
|
43 const TInt KTextCursorPanicUid3 = 3000; |
|
44 const TInt KTextCursorPanicUid4 = 4000; |
|
45 const TInt KTextCursorPanicUid5 = 5000; |
|
46 |
|
47 CTestBase* CTCursorTest::iStaticTest = NULL; |
|
48 const TInt kWinWidth=400; |
|
49 const TInt kWinHeight=100; |
|
50 const TSize kWinSize(kWinWidth,kWinHeight); |
|
51 const TInt kWinXPos=150; |
|
52 const TInt kCursorWidth = 10; |
|
53 const TInt kCursorHeight = 20; |
|
54 const TSize kCursorSize(kCursorWidth,kCursorHeight); |
|
55 const TPoint kWin1TopLeft(kWinXPos,0); |
|
56 const TPoint kWin2TopLeft(kWinXPos,kWinHeight+10); |
|
57 |
|
58 LOCAL_D void DeleteSpriteMember(TAny* aSpriteMember) |
|
59 { |
|
60 TSpriteMember* member=reinterpret_cast<TSpriteMember*>(aSpriteMember); |
|
61 delete member->iBitmap; |
|
62 member->iBitmap=NULL; |
|
63 delete member->iMaskBitmap; |
|
64 member->iMaskBitmap=NULL; |
|
65 } |
|
66 |
|
67 CCustomTextCursor::~CCustomTextCursor() |
|
68 { |
|
69 const TInt count = iSpriteMemberArray.Count(); |
|
70 for (TInt index=0; index<count; ++index) |
|
71 { |
|
72 DeleteSpriteMember(&iSpriteMemberArray[index]); |
|
73 } |
|
74 iSpriteMemberArray.Close(); |
|
75 } |
|
76 |
|
77 CCustomTextCursor::CCustomTextCursor(CTestBase* aTest) |
|
78 : iTest(aTest) |
|
79 { |
|
80 } |
|
81 |
|
82 void CCustomTextCursor::ConstructL(TInt aScreenNumber,TInt aBmpIndex) |
|
83 { |
|
84 ASSERT(aBmpIndex < KNumberOfCustoTextCursors); |
|
85 |
|
86 |
|
87 TSpriteMember spriteMember; |
|
88 spriteMember.iBitmap = NULL; |
|
89 spriteMember.iMaskBitmap = NULL; |
|
90 spriteMember.iInvertMask =EFalse; |
|
91 spriteMember.iDrawMode = CGraphicsContext::EDrawModePEN; |
|
92 spriteMember.iOffset = TPoint(); |
|
93 spriteMember.iInterval = TTimeIntervalMicroSeconds32(0); |
|
94 CleanupStack::PushL(TCleanupItem(DeleteSpriteMember, &spriteMember)); |
|
95 spriteMember.iBitmap = new (ELeave) CFbsBitmap; |
|
96 User::LeaveIfError(spriteMember.iBitmap->Load(TEST_BITMAP_NAME, EMbmWsautotestBmp1)); |
|
97 spriteMember.iMaskBitmap = new (ELeave) CFbsBitmap; |
|
98 User::LeaveIfError(spriteMember.iMaskBitmap->Load(TEST_BITMAP_NAME, EMbmWsautotestBmp1mask)); |
|
99 |
|
100 User::LeaveIfError(iSpriteMemberArray.Append(spriteMember)); |
|
101 CleanupStack::Pop(&spriteMember); |
|
102 |
|
103 // create unique-id accross screens |
|
104 // |
|
105 iIdentifier = KTextCursorInitialIdValue + aScreenNumber*KNumberOfCustoTextCursors + aBmpIndex; |
|
106 iAlignment = (RWsSession::TCustomTextCursorAlignment)(aBmpIndex); |
|
107 } |
|
108 |
|
109 CCustomTextCursor* CCustomTextCursor::CreateCustomTextCursorL(TInt aScreenNumber,TInt aBmpIndex,CTestBase* aTest) |
|
110 { |
|
111 CCustomTextCursor* customTextCursor = new (ELeave) CCustomTextCursor(aTest); |
|
112 CleanupStack::PushL(customTextCursor); |
|
113 customTextCursor->ConstructL(aScreenNumber,aBmpIndex); |
|
114 CleanupStack::Pop(customTextCursor); |
|
115 return customTextCursor; |
|
116 } |
|
117 |
|
118 /* |
|
119 * Wrapper class for a list of custom text cursor. |
|
120 */ |
|
121 class CCustomTextCursorsWrapper : public CBase |
|
122 { |
|
123 public: |
|
124 static CCustomTextCursorsWrapper* NewLC(TInt aScreenNumber,CTestBase* aTest); |
|
125 ~CCustomTextCursorsWrapper(); |
|
126 inline RPointerArray<CCustomTextCursor>& CustomTextCursorsArray(); |
|
127 inline CCustomTextCursor& CustomTextCursor(TInt aIndex); |
|
128 private: |
|
129 void ConstructL(TInt aScreenNumber,CTestBase* aTest); |
|
130 private: |
|
131 RPointerArray<CCustomTextCursor> iCustomTextCursors; |
|
132 }; |
|
133 |
|
134 inline RPointerArray<CCustomTextCursor>& CCustomTextCursorsWrapper::CustomTextCursorsArray() |
|
135 { |
|
136 return iCustomTextCursors; |
|
137 } |
|
138 |
|
139 inline CCustomTextCursor& CCustomTextCursorsWrapper::CustomTextCursor(TInt aIndex) |
|
140 { |
|
141 return *(iCustomTextCursors[aIndex]); |
|
142 } |
|
143 |
|
144 CCustomTextCursorsWrapper* CCustomTextCursorsWrapper::NewLC(TInt aScreenNumber,CTestBase* aTest) |
|
145 { |
|
146 CCustomTextCursorsWrapper* self = new(ELeave) CCustomTextCursorsWrapper(); |
|
147 CleanupStack::PushL(self); |
|
148 self->ConstructL(aScreenNumber,aTest); |
|
149 return self; |
|
150 } |
|
151 |
|
152 CCustomTextCursorsWrapper::~CCustomTextCursorsWrapper() |
|
153 { |
|
154 iCustomTextCursors.ResetAndDestroy(); |
|
155 iCustomTextCursors.Close(); |
|
156 } |
|
157 |
|
158 void CCustomTextCursorsWrapper::ConstructL(TInt aScreenNumber, CTestBase* aTest) |
|
159 { |
|
160 for (TInt index=0; index<KNumberOfCustoTextCursors; ++index) |
|
161 { |
|
162 CCustomTextCursor* customTextCursor=CCustomTextCursor::CreateCustomTextCursorL(aScreenNumber,index, aTest); |
|
163 CleanupStack::PushL(customTextCursor); |
|
164 User::LeaveIfError(iCustomTextCursors.Append(customTextCursor)); |
|
165 CleanupStack::Pop(customTextCursor); |
|
166 } |
|
167 } |
|
168 |
|
169 CTCursorTest::CTCursorTest(CTestStep* aStep) : |
|
170 CTWsGraphicsBase(aStep) |
|
171 { |
|
172 iCursorType = TTextCursor::ETypeFirst; |
|
173 iStaticTest=iTest; |
|
174 } |
|
175 |
|
176 CTCursorTest::~CTCursorTest() |
|
177 { |
|
178 delete iWorkInProgress; |
|
179 delete iComparisonWindow; |
|
180 } |
|
181 |
|
182 TInt CTCursorTest::DoPanicTest(TInt aInt, TAny *aScreenNumber) |
|
183 { |
|
184 RWsSession ws; |
|
185 if (ws.Connect()==KErrNone) |
|
186 { |
|
187 // use correct screen |
|
188 CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws); |
|
189 User::LeaveIfError(screen->Construct((TInt)aScreenNumber)); |
|
190 RWindowGroup group(ws); |
|
191 if (group.Construct(444)==KErrNone) |
|
192 { |
|
193 group.EnableReceiptOfFocus(EFalse); // Stop auto group switching on close |
|
194 RWindow wnd(ws); |
|
195 if (wnd.Construct(group, TInt32(&ws))==KErrNone) |
|
196 { |
|
197 TTextCursor tc; |
|
198 tc.iHeight=10; |
|
199 tc.iAscent=5; |
|
200 tc.iWidth=10; |
|
201 tc.iFlags=0; |
|
202 tc.iColor=TRgb(0,0,0); |
|
203 switch(aInt) |
|
204 { |
|
205 case 0: |
|
206 { |
|
207 /* TESTCASE: 6.1 |
|
208 * TITLE: Invalid use of a custom text cursor ID (basic text cursor). |
|
209 * IMPORTANCE: 1 |
|
210 * REQUIREMENT: Unknown. |
|
211 * |
|
212 * ACTION: This test tries to set a text cursor using an ID which is invalid. |
|
213 * |
|
214 * CHECK: The thread should panic with the exit reason EWservPanicInvalidTextCursor |
|
215 */ |
|
216 tc.iType=(TTextCursor::EType)KTextCursorPanicUid1; |
|
217 group.SetTextCursor(wnd,TPoint(10,10),tc); |
|
218 } |
|
219 break; |
|
220 case 1: |
|
221 { |
|
222 /* TESTCASE: 6.2 |
|
223 * TITLE: Invalid use of a window for a text cursor. |
|
224 * IMPORTANCE: 1 |
|
225 * REQUIREMENT: REQ 1079, CR RDEF-5F7Q24 (10/04/2003). |
|
226 * |
|
227 * ACTION: This test tries to set a text cursor using a window which is not part |
|
228 * of the window group calling the setting API. |
|
229 * |
|
230 * CHECK: The thread should panic with the exit reason EWservPanicWindow |
|
231 */ |
|
232 tc.iType=(TTextCursor::EType)KTextCursorPanicUid2; |
|
233 group.SetTextCursor(*TestWin->Win(),TPoint(10,10),tc); |
|
234 } |
|
235 break; |
|
236 case 2: |
|
237 { |
|
238 /* TESTCASE: 6.3 |
|
239 * TITLE: Invalid use of a custom text cursor ID. |
|
240 * IMPORTANCE: 1 |
|
241 * REQUIREMENT: REQ 1079, CR RDEF-5F7Q24 (10/04/2003). |
|
242 * |
|
243 * ACTION: This test tries to set a text cursor using an ID which is associated to |
|
244 * an non-existing custom text cursor. |
|
245 * |
|
246 * CHECK: The thread should panic with the exit reason EWservPanicNoCustomTextCursor |
|
247 */ |
|
248 tc.iType=(TTextCursor::EType)KTextCursorPanicUid3; |
|
249 group.SetTextCursor(wnd,TPoint(10,10),tc); |
|
250 } |
|
251 break; |
|
252 case 3: |
|
253 { |
|
254 /* TESTCASE: 6.4 |
|
255 * TITLE: Invalid use of a custom text cursor ID. |
|
256 * IMPORTANCE: 1 |
|
257 * REQUIREMENT: REQ 1079, CR RDEF-5F7Q24 (10/04/2003). |
|
258 * |
|
259 * ACTION: This test tries to set a custom text cursor which has been set to use |
|
260 * an invalid alignment. |
|
261 * |
|
262 * CHECK: The thread should panic with the exit reason EWservPanicCustomTextCursorAlign |
|
263 */ |
|
264 CCustomTextCursor* customTextCursor=NULL; |
|
265 TRAPD(error, customTextCursor=CCustomTextCursor::CreateCustomTextCursorL((TInt)aScreenNumber,0,iStaticTest)); |
|
266 if (error==KErrNone) |
|
267 { |
|
268 error = ws.SetCustomTextCursor(KTextCursorPanicUid4, customTextCursor->iSpriteMemberArray.Array(), 0, (RWsSession::TCustomTextCursorAlignment)(RWsSession::ECustomTextCursorAlignBottom+1)); |
|
269 if (error==KErrNone || error==KErrAlreadyExists) |
|
270 { |
|
271 tc.iType=(TTextCursor::EType)KTextCursorPanicUid4; |
|
272 group.SetTextCursor(wnd,TPoint(10,10),tc); |
|
273 } |
|
274 } |
|
275 delete customTextCursor; |
|
276 } |
|
277 break; |
|
278 case 4: |
|
279 { |
|
280 /* TESTCASE: 6.5 |
|
281 * TITLE: Use of an invalid custom text cursor |
|
282 * IMPORTANCE: 1 |
|
283 * REQUIREMENT: REQ 1079, CR RDEF-5F7Q24 (10/04/2003). |
|
284 * |
|
285 * ACTION: This test tries to set a custom text cursor which does not have |
|
286 * any sprite member set. |
|
287 * |
|
288 * CHECK: The thread should panic with the exit reason EWservPanicNoSpriteMember |
|
289 */ |
|
290 RArray<TSpriteMember> spriteMemberArray; |
|
291 const TInt error = ws.SetCustomTextCursor(KTextCursorPanicUid5, spriteMemberArray.Array(), 0, (RWsSession::TCustomTextCursorAlignment)(RWsSession::ECustomTextCursorAlignBottom)); |
|
292 if (error==KErrNone || error==KErrAlreadyExists) |
|
293 { |
|
294 tc.iType=(TTextCursor::EType)KTextCursorPanicUid5; |
|
295 group.SetTextCursor(wnd,TPoint(10,10),tc); |
|
296 } |
|
297 } |
|
298 break; |
|
299 case 5: |
|
300 { |
|
301 // Uncover set.cursor.iType < TTextCursor::ETypeFirst code path |
|
302 tc.iType=(TTextCursor::EType)TTextCursor::ETypeFirst - 1; |
|
303 group.SetTextCursor(wnd,TPoint(10,10),tc); |
|
304 } |
|
305 break; |
|
306 case 6: |
|
307 { |
|
308 // Uncover (set.cursor.iFlags&static_cast<TUint>(TTextCursor::EPrivateFlags) code path |
|
309 tc.iFlags=ETextCursorPrivateFlags; |
|
310 group.SetTextCursor(wnd,TPoint(10,10),tc); |
|
311 } |
|
312 break; |
|
313 case 7: |
|
314 { |
|
315 // Uncover (iGroupWin != searchWin) i.e. bogus group window |
|
316 tc.iType=(TTextCursor::EType)TTextCursor::ETypeRectangle; |
|
317 RWindow windowNotAssociatedWithAGroup(ws); |
|
318 group.SetTextCursor(windowNotAssociatedWithAGroup, TPoint(10,10),tc); |
|
319 } |
|
320 break; |
|
321 } |
|
322 } |
|
323 ws.Flush(); |
|
324 } |
|
325 } |
|
326 return(EWsExitReasonBad); |
|
327 } |
|
328 |
|
329 void CTCursorTest::TestPanicsL() |
|
330 { |
|
331 TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicInvalidTextCursor, 0, (TAny*)iTest->iScreenNumber)); |
|
332 TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicWindow, 1, (TAny*)iTest->iScreenNumber)); |
|
333 TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicNoCustomTextCursor, 2, (TAny*)iTest->iScreenNumber)); |
|
334 TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicCustomTextCursorAlign, 3, (TAny*)iTest->iScreenNumber)); |
|
335 TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicNoSpriteMember, 4, (TAny*)iTest->iScreenNumber)); |
|
336 TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicInvalidTextCursor, 5, (TAny*)iTest->iScreenNumber)); |
|
337 TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicInvalidTextCursor, 6, (TAny*)iTest->iScreenNumber)); |
|
338 TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicWindow, 7, (TAny*)iTest->iScreenNumber)); |
|
339 iTest->CloseAllPanicWindows(); |
|
340 } |
|
341 |
|
342 void CTCursorTest::TextCursorSetLCoverageTests() |
|
343 { |
|
344 ValidateWin(BaseWin,TRgb::Gray256(255)); |
|
345 ValidateWin(TestWin,TRgb::Gray256(255)); |
|
346 TTextCursor textCursor; |
|
347 textCursor.iHeight = 10; |
|
348 textCursor.iAscent = 0; |
|
349 textCursor.iWidth = 10; |
|
350 textCursor.iFlags = 0; |
|
351 textCursor.iColor = KRgbBlack; |
|
352 textCursor.iType = (TTextCursor::EType)TTextCursor::ETypeRectangle; |
|
353 TPoint position(10, 10); |
|
354 TRect clipRect0(10, 10, 10, 10); |
|
355 TRect clipRect1(10, 10, 5, 5); |
|
356 RWindowGroup *group = TheClient->iGroup->GroupWin(); |
|
357 group->SetTextCursor(*TestWin->Win(), position, textCursor); |
|
358 /* |
|
359 * Duplicate the previous SetTextCursor command to uncover the code which checks for any delta in SetL |
|
360 * compared to the current settings. |
|
361 */ |
|
362 group->SetTextCursor(*TestWin->Win(), position, textCursor); |
|
363 /* |
|
364 * Change the type only to pick up that difference in SetL. |
|
365 */ |
|
366 textCursor.iType++; |
|
367 group->SetTextCursor(*TestWin->Win(), position, textCursor); |
|
368 textCursor.iType--; |
|
369 /* |
|
370 * Vary the clipping rectangle. |
|
371 */ |
|
372 group->SetTextCursor(*TestWin->Win(), position, textCursor, clipRect0); |
|
373 group->SetTextCursor(*TestWin->Win(), position, textCursor, clipRect1); |
|
374 /* |
|
375 * Vary the color. |
|
376 */ |
|
377 textCursor.iColor = KRgbGreen; |
|
378 group->SetTextCursor(*TestWin->Win(), position, textCursor); |
|
379 textCursor.iColor = KRgbBlack; |
|
380 group->SetTextCursor(*TestWin->Win(), position, textCursor); |
|
381 /* |
|
382 * Vary the target Window. |
|
383 */ |
|
384 group->SetTextCursor(*BaseWin->Win(), position, textCursor); |
|
385 group->SetTextCursor(*TestWin->Win(), position, textCursor); |
|
386 /* |
|
387 * Vary the size of the cursor. |
|
388 */ |
|
389 textCursor.iWidth++; |
|
390 group->SetTextCursor(*TestWin->Win(), position, textCursor); |
|
391 textCursor.iWidth--; |
|
392 /* |
|
393 * Set different custom cursors. |
|
394 */ |
|
395 CCustomTextCursorsWrapper* customTextCursorsWrapper = CCustomTextCursorsWrapper::NewLC(iTest->iScreenNumber, iTest); |
|
396 const TInt count = customTextCursorsWrapper->CustomTextCursorsArray().Count(); |
|
397 for (TInt index=0; index<count; ++index) |
|
398 { |
|
399 CCustomTextCursor& customTextCursor = customTextCursorsWrapper->CustomTextCursor(index); |
|
400 textCursor.iType = customTextCursor.iIdentifier; |
|
401 group->SetTextCursor(*TestWin->Win(), position, textCursor); |
|
402 } |
|
403 CleanupStack::PopAndDestroy(customTextCursorsWrapper); |
|
404 /* |
|
405 * Set the last custom cursor from the above loop again so the |
|
406 * product code sees the same Custom Text Cursor settings come |
|
407 * in a second time. |
|
408 */ |
|
409 group->SetTextCursor(*TestWin->Win(), position, textCursor); |
|
410 textCursor.iType = (TTextCursor::EType)TTextCursor::ETypeRectangle; |
|
411 /* |
|
412 * Vary the horizontal clipping. |
|
413 */ |
|
414 textCursor.iFlags = TTextCursor::EFlagClipHorizontal; |
|
415 group->SetTextCursor(*TestWin->Win(), position, textCursor); |
|
416 /* |
|
417 * Vary the horizontal clipping. |
|
418 */ |
|
419 textCursor.iFlags = TTextCursor::EFlagClipVertical; |
|
420 group->SetTextCursor(*TestWin->Win(), position, textCursor); |
|
421 /* |
|
422 * Try both horizontal and vertical clipping. |
|
423 */ |
|
424 textCursor.iFlags = TTextCursor::EFlagClipVertical|TTextCursor::EFlagClipHorizontal; |
|
425 group->SetTextCursor(*TestWin->Win(), position, textCursor); |
|
426 textCursor.iFlags = 0; |
|
427 |
|
428 TheClient->iWs.Flush(); |
|
429 CancelTextCursor(); |
|
430 } |
|
431 |
|
432 void CTCursorTest::SetCursor(const TPoint &aPos,const TSize &aSize,TRgb aColor, const TRect &aRect, TUint aFlags) |
|
433 { |
|
434 TTextCursor tc; |
|
435 tc.iType=iCursorType; |
|
436 tc.iHeight=aSize.iHeight; |
|
437 tc.iAscent=aSize.iHeight*4/5; |
|
438 tc.iWidth=aSize.iWidth; |
|
439 tc.iFlags=aFlags; |
|
440 tc.iColor=aColor; |
|
441 TheClient->iGroup->GroupWin()->SetTextCursor(*TestWin->Win(),TPoint(aPos.iX,aPos.iY+tc.iAscent),tc,aRect); |
|
442 } |
|
443 |
|
444 void CTCursorTest::SetCursor(const TPoint &aPos,const TSize &aSize,TRgb aColor, TUint aFlags) |
|
445 { |
|
446 TTextCursor tc; |
|
447 tc.iType=iCursorType; |
|
448 tc.iHeight=aSize.iHeight; |
|
449 tc.iAscent=aSize.iHeight*4/5; |
|
450 tc.iWidth=aSize.iWidth; |
|
451 tc.iFlags=aFlags; |
|
452 tc.iColor=aColor; |
|
453 TheClient->iGroup->GroupWin()->SetTextCursor(*TestWin->Win(),TPoint(aPos.iX,aPos.iY+tc.iAscent),tc); |
|
454 } |
|
455 |
|
456 void CTCursorTest::SetCursorPlusBox(const TPoint &aPos,const TSize &aSize,TRgb aColor, const TRect *aClipRect, TUint aFlags) |
|
457 { |
|
458 if (aClipRect) |
|
459 SetCursor(aPos,aSize,aColor,*aClipRect,aFlags); |
|
460 else |
|
461 SetCursor(aPos,aSize,aColor,aFlags); |
|
462 TRect rect(aPos,aSize); |
|
463 if (aClipRect) |
|
464 rect.Intersection(*aClipRect); |
|
465 rect.Grow(2,2); |
|
466 |
|
467 TheClient->iGc->Activate(*(TestWin->Win())); |
|
468 TestWin->Invalidate(rect); |
|
469 TestWin->Win()->BeginRedraw(rect); |
|
470 TheClient->iGc->SetPenColor(aColor); |
|
471 TheClient->iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR); |
|
472 |
|
473 TheClient->iGc->DrawRect(rect); |
|
474 TheClient->iGc->Deactivate(); |
|
475 TestWin->Win()->EndRedraw(); |
|
476 |
|
477 } |
|
478 |
|
479 void CTCursorTest::CancelTextCursor() |
|
480 { |
|
481 TheClient->iGroup->GroupWin()->CancelTextCursor(); |
|
482 } |
|
483 |
|
484 void CTCursorTest::ConstructL() |
|
485 { |
|
486 // for allocating some cached memory |
|
487 CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; |
|
488 CleanupStack::PushL(bitmap); |
|
489 User::LeaveIfError(bitmap->Load(TEST_BITMAP_NAME, 0)); |
|
490 CleanupStack::PopAndDestroy(bitmap); |
|
491 |
|
492 CCustomTextCursorsWrapper* customTextCursorsWrapper = CCustomTextCursorsWrapper::NewLC(iTest->iScreenNumber, iTest); |
|
493 const TInt count = customTextCursorsWrapper->CustomTextCursorsArray().Count(); |
|
494 for (TInt index=0; index<count; ++index) |
|
495 { |
|
496 CCustomTextCursor& customTextCursor = customTextCursorsWrapper->CustomTextCursor(index); |
|
497 TInt err = TheClient->iWs.SetCustomTextCursor(customTextCursor.iIdentifier, customTextCursor.iSpriteMemberArray.Array(), customTextCursor.iSpriteFlags, customTextCursor.iAlignment); |
|
498 TEST(err == KErrNone || err == KErrAlreadyExists); |
|
499 if (err!=KErrNone && err != KErrAlreadyExists) |
|
500 INFO_PRINTF4(_L("TheClient->iWs.SetCustomTextCursor return value - Expected: %d or %d, Actual: %d"), KErrNone, KErrAlreadyExists, err); |
|
501 |
|
502 __UHEAP_MARK; |
|
503 err = TheClient->iWs.SetCustomTextCursor(customTextCursor.iIdentifier, customTextCursor.iSpriteMemberArray.Array(), customTextCursor.iSpriteFlags, customTextCursor.iAlignment); |
|
504 __UHEAP_MARKEND; |
|
505 TEST(err == KErrAlreadyExists); |
|
506 if (err != KErrAlreadyExists) |
|
507 INFO_PRINTF3(_L("TheClient->iWs.SetCustomTextCursor return value - Expected: %d, Actual: %d"), KErrAlreadyExists, err); |
|
508 |
|
509 } |
|
510 _LIT(KLog,"Text Cursor: Loaded %d Custom Cursors"); |
|
511 TLogMessageText buf; |
|
512 buf.Format(KLog,count); |
|
513 TheClient->LogMessage(buf); |
|
514 CleanupStack::PopAndDestroy(customTextCursorsWrapper); |
|
515 // |
|
516 ValidateWin(BaseWin,TRgb::Gray256(204)); |
|
517 ValidateWin(TestWin,TRgb::Gray256(204)); |
|
518 // |
|
519 SetCursor(TPoint(10,90),TSize(80,100),TRgb(255,255,255)); |
|
520 // |
|
521 iWinState=0; |
|
522 iWinPos=TPoint(2*TheClient->iGroup->Size().iWidth/3,0); |
|
523 // |
|
524 iMoveWin=new(ELeave) CBlankWindow(TRgb::Gray256(220)); |
|
525 TDisplayMode mode=EGray16; |
|
526 TInt testWinWidth = TestWin->Size().iWidth; |
|
527 TInt halfTestWinWidth = testWinWidth/2; |
|
528 TInt halfTestWinHeight = TestWin->Size().iHeight/2; |
|
529 |
|
530 iMoveWin->SetUpL(iWinPos,TSize(halfTestWinHeight,halfTestWinHeight), |
|
531 TheClient->iGroup,*TheClient->iGc,&mode); |
|
532 |
|
533 iCheckWin=new(ELeave) CBlankWindow(TRgb::Gray256(220)); |
|
534 iCheckWin->SetUpL(TPoint(testWinWidth+halfTestWinWidth,halfTestWinHeight), |
|
535 TSize(halfTestWinWidth,halfTestWinHeight), |
|
536 TheClient->iGroup,*TheClient->iGc,&mode); |
|
537 } |
|
538 |
|
539 void CTCursorTest::DeleteMoveWindows() |
|
540 { |
|
541 delete iMoveWin; |
|
542 delete iCheckWin; |
|
543 CancelTextCursor(); |
|
544 } |
|
545 |
|
546 void CTCursorTest::ResetMoveWindowsL() |
|
547 { |
|
548 SetCursor(TPoint(10,90),TSize(80,100),TRgb(255,255,255)); |
|
549 iWinState=0; |
|
550 iWinPos=TPoint(2*TheClient->iGroup->Size().iWidth/3,0); |
|
551 iMoveWin->SetExtL(iWinPos,TSize(TestWin->Size().iWidth/2,TestWin->Size().iHeight/2)); |
|
552 iCheckWin->SetExtL(TPoint(TestWin->Size().iWidth+(TestWin->Size().iWidth>>1),TestWin->Size().iHeight>>1), |
|
553 TSize(TestWin->Size().iWidth/2,TestWin->Size().iHeight/2)); |
|
554 } |
|
555 |
|
556 TBool CTCursorTest::MoveWindow() |
|
557 { |
|
558 TSize scrSize(TheClient->iScreen->SizeInPixels()); |
|
559 iWinState++; |
|
560 if (iWinState<20) |
|
561 iWinPos+=TPoint((4*scrSize.iWidth)/640,(4*scrSize.iHeight)/240); |
|
562 else if (iWinState<40) |
|
563 iWinPos+=TPoint((1*scrSize.iWidth)/640,(-3*scrSize.iHeight)/240); |
|
564 else if (iWinState<60) |
|
565 iWinPos+=TPoint((-6*scrSize.iWidth)/640,(3*scrSize.iHeight)/240); |
|
566 else |
|
567 iWinPos+=TPoint((1*scrSize.iWidth)/640,(-2*scrSize.iHeight)/240); |
|
568 iMoveWin->SetPos(iWinPos); |
|
569 return (iWinState==80); |
|
570 } |
|
571 |
|
572 void CTCursorTest::ValidateWin(TestWindow *aWin, TRgb aColor) |
|
573 { |
|
574 aWin->Win()->Invalidate(); |
|
575 RedrawWin(*aWin->Win(),aColor); |
|
576 } |
|
577 |
|
578 void CTCursorTest::RedrawWin(RWindow &aWin, TRgb aColor) |
|
579 { |
|
580 aWin.BeginRedraw(); |
|
581 TheClient->iGc->Activate(aWin); |
|
582 TheClient->iGc->SetBrushColor(aColor); |
|
583 TheClient->iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); |
|
584 TheClient->iGc->SetPenStyle(CGraphicsContext::ENullPen); |
|
585 TheClient->iGc->Clear(); |
|
586 TheClient->iGc->Deactivate(); |
|
587 aWin.EndRedraw(); |
|
588 } |
|
589 |
|
590 void CTCursorTest::ScrollTest() |
|
591 { |
|
592 const TSize size(20,40); |
|
593 ValidateWin(TestWin,TRgb::Gray256(255)); |
|
594 |
|
595 SetCursor(TPoint(10,20),size,TRgb::Gray256(255),TTextCursor::EFlagNoFlash); |
|
596 TheClient->iWs.Flush(); |
|
597 TheClient->WaitForRedrawsToFinish(); |
|
598 TheClient->iWs.Finish(); |
|
599 |
|
600 for(TInt ii=0;ii<20;ii++) |
|
601 { |
|
602 TInt dist=(ii&3)*2; |
|
603 TInt nx=ii&0x1?1:-1; |
|
604 TInt ny=ii&0x2?1:-1; |
|
605 TestWin->Win()->Scroll(TPoint(dist*nx,dist*ny),TRect(10,20,30,40)); |
|
606 TheClient->iWs.Flush(); |
|
607 } |
|
608 TheClient->WaitForRedrawsToFinish(); |
|
609 TheClient->iWs.Finish(); |
|
610 |
|
611 BaseWin->Win()->Invalidate(); |
|
612 BaseWin->Win()->BeginRedraw(); |
|
613 TheClient->iGc->Activate(*(BaseWin->Win())); |
|
614 TheClient->iGc->Clear(); |
|
615 TheClient->iGc->SetBrushColor(TRgb::Gray256(255)); |
|
616 TheClient->iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); |
|
617 TheClient->iGc->SetPenStyle(CGraphicsContext::ENullPen); |
|
618 TheClient->iGc->Clear(TRect(TPoint(10,20),size)); |
|
619 TheClient->iGc->Deactivate(); |
|
620 BaseWin->Win()->EndRedraw(); |
|
621 |
|
622 TheClient->iWs.Flush(); |
|
623 TheClient->WaitForRedrawsToFinish(); |
|
624 TheClient->iWs.Finish(); |
|
625 |
|
626 /* |
|
627 * NOTE: Reason for removal of COMPARE_WINDOWS_SOFTFAIL_WINSCW |
|
628 * Due to the new implementation of sprites in wserv2, the sprites no longer keep a |
|
629 * backup bitmap of what the screen looks like beneath them. As it is not possible to |
|
630 * move the sprites associated with the custom text cursors that were created in second |
|
631 * phase construction of the CTCursorTest object, the COMPARE_WINDOWS_SOFTFAIL_WINSCW; |
|
632 * macro function has been removed. Otherwise the test case is going to subject to the |
|
633 * timing of the flashing sprite. An alternative solution would be to assign NULL values |
|
634 * to the sprite bitmaps in second phase construction, but this is avoided as it would |
|
635 * trigger failures in some test cases later on (that are depended on these "embedded" |
|
636 * sprite images). |
|
637 */ |
|
638 CancelTextCursor(); |
|
639 } |
|
640 |
|
641 void DrawTestSprite(CBitmapContext *aGc,TInt , const TSize &aSize, TBool aDoMask, TAny *) |
|
642 { |
|
643 aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 0 : 2)); |
|
644 aGc->SetBrushStyle(CGraphicsContext::ESolidBrush); |
|
645 aGc->SetPenStyle(CGraphicsContext::ENullPen); |
|
646 aGc->DrawRect(TRect(aSize)); |
|
647 aGc->SetPenStyle(CGraphicsContext::ESolidPen); |
|
648 aGc->SetPenColor(TRgb::Gray4(aDoMask ? 3 : 0)); |
|
649 aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 3 : 1)); |
|
650 aGc->DrawEllipse(TRect(aSize)); |
|
651 } |
|
652 |
|
653 CTSprite *CTCursorTest::CreateTestSpriteLC(RWindowTreeNode &aWindow, const TPoint &aPos, TInt aCount) |
|
654 // |
|
655 // At the moment aCount must be 1 or 2 |
|
656 // |
|
657 { |
|
658 TSpriteCreateParams params(TSize(30,70),TPoint(0,0),DrawTestSprite); |
|
659 TSpriteCreateParams paramarray[2]; |
|
660 params.iInterval=TTimeIntervalMicroSeconds32(200000); |
|
661 |
|
662 paramarray[0]=params; |
|
663 paramarray[1]=params; |
|
664 paramarray[1].iSize=TSize(100,10); |
|
665 CTSprite *sprite=new(ELeave) CTSprite(TheClient->iWs); |
|
666 CleanupStack::PushL(sprite); |
|
667 sprite->ConstructL(aWindow,aPos,aCount,¶marray[0],0); |
|
668 return(sprite); |
|
669 } |
|
670 |
|
671 void CTCursorTest::doMoveWindowTestL() |
|
672 { |
|
673 RBlankWindow blankwin(TheClient->iWs); |
|
674 User::LeaveIfError(blankwin.Construct(*TestWin->Win(),1)); |
|
675 CleanupStack::PushL(TCleanupItem(CleanUpWindow,&blankwin)); |
|
676 // |
|
677 blankwin.SetExtent(TPoint(35,165),TSize(40,40)); |
|
678 blankwin.SetColor(TRgb::Gray256(220)); |
|
679 blankwin.Activate(); |
|
680 TheClient->iWs.SetAutoFlush(ETrue); |
|
681 User::After(500000); |
|
682 blankwin.SetPosition(TPoint(25,55)); |
|
683 User::After(500000); |
|
684 blankwin.SetPosition(TPoint(30,160)); |
|
685 User::After(500000); |
|
686 blankwin.SetPosition(TPoint(12,22)); // Almost totally covering sprite |
|
687 User::After(500000); |
|
688 blankwin.SetPosition(TPoint(-100,-100)); // Totally off the sprite |
|
689 User::After(500000); |
|
690 blankwin.SetPosition(TPoint(10,20)); // Write on top of sprite |
|
691 User::After(500000); |
|
692 blankwin.SetPosition(TPoint(24,24)); // moving off... |
|
693 User::After(500000); |
|
694 blankwin.SetPosition(TPoint(38,28)); // ... |
|
695 User::After(500000); |
|
696 blankwin.SetPosition(TPoint(58,48)); // ... |
|
697 User::After(500000); |
|
698 blankwin.SetPosition(TPoint(92,62)); // ... off |
|
699 User::After(500000); |
|
700 CleanupStack::PopAndDestroy(); // blank window |
|
701 TheClient->iWs.Flush(); |
|
702 TheClient->WaitForRedrawsToFinish(); |
|
703 TheClient->iWs.Finish(); |
|
704 |
|
705 TheClient->iWs.SetAutoFlush(EFalse); |
|
706 } |
|
707 |
|
708 void CTCursorTest::MoveWindowTest1L() |
|
709 { |
|
710 ValidateWin(TestWin,TRgb::Gray256(255)); |
|
711 // Check it with a static sprite |
|
712 CTSprite * sprite_static = CreateTestSpriteLC(*TestWin->Win(), TPoint(10,20), 1); |
|
713 doMoveWindowTestL(); |
|
714 (sprite_static->Sprite()).SetPosition(TPoint(500,500)); //move the sprite out of the viewing area before the window comparison |
|
715 CleanupStack::PopAndDestroy(1); // sprite |
|
716 // Check it an animated sprite |
|
717 CTSprite * sprite_anim = CreateTestSpriteLC(*TestWin->Win(), TPoint(10,20), 2); |
|
718 doMoveWindowTestL(); |
|
719 (sprite_anim->Sprite()).SetPosition(TPoint(500,500)); //move the sprite out of the viewing area before the window comparison |
|
720 CleanupStack::PopAndDestroy(1); // sprite |
|
721 } |
|
722 |
|
723 void CTCursorTest::MoveWindowTest2L() |
|
724 { |
|
725 const TSize size(20,40); |
|
726 // Check it with a text cursor |
|
727 ValidateWin(TestWin,TRgb::Gray256(255)); |
|
728 SetCursor(TPoint(10,25),size,TRgb::Gray256(255),TTextCursor::EFlagNoFlash); |
|
729 doMoveWindowTestL(); |
|
730 CancelTextCursor(); |
|
731 // Check it with an anaimated sprite and a text cursor |
|
732 ValidateWin(TestWin,TRgb::Gray256(255)); |
|
733 CTSprite * sprite_anim = CreateTestSpriteLC(*TestWin->Win(), TPoint(10,20), 2); |
|
734 SetCursor(TPoint(10,45),size,TRgb::Gray256(255),TTextCursor::EFlagNoFlash); |
|
735 doMoveWindowTestL(); |
|
736 (sprite_anim->Sprite()).SetPosition(TPoint(500,500)); |
|
737 CancelTextCursor(); |
|
738 CleanupStack::PopAndDestroy(1); // sprite |
|
739 } |
|
740 |
|
741 TBool CTCursorTest::IncrementCursorType() |
|
742 { |
|
743 // each screen has it own set of cursor |
|
744 // |
|
745 // the values would be ETypeLast=2 ETypeLastBasic=1009 |
|
746 // |
|
747 if (iCursorType == TTextCursor::ETypeFirst) |
|
748 { |
|
749 iCursorType = (TTextCursor::EType)(TTextCursor::ETypeLastBasic + 1 + iTest->iScreenNumber*KNumberOfCustoTextCursors); |
|
750 return ETrue; |
|
751 } |
|
752 else if (iCursorType >= TTextCursor::ETypeLastBasic + (iTest->iScreenNumber+1)*KNumberOfCustoTextCursors) |
|
753 { |
|
754 iCursorType = TTextCursor::ETypeFirst; |
|
755 return EFalse; |
|
756 } |
|
757 else |
|
758 { |
|
759 iCursorType = (TTextCursor::EType)(iCursorType + 1); |
|
760 return ETrue; |
|
761 } |
|
762 } |
|
763 |
|
764 void CTCursorTest::GeneralTestsL() |
|
765 { |
|
766 const TInt winColor=255; //Best to use Light Grey that is 170, but this code is bugged and doing so shows them up. |
|
767 ValidateWin(BaseWin,TRgb::Gray256(255)); |
|
768 ValidateWin(TestWin,TRgb::Gray256(255)); |
|
769 SetCursor(TPoint(-1000,10),TSize(10,30),TRgb::Gray256(255)); |
|
770 TheClient->iWs.Flush(); |
|
771 SetCursor(TPoint(10,10),TSize(10,30),TRgb::Gray256(255)); |
|
772 TheClient->iWs.Flush(); |
|
773 TRect rect(15,15,18,25); |
|
774 SetCursorPlusBox(TPoint(10,10),TSize(10,30),TRgb::Gray256(255), &rect); |
|
775 CancelTextCursor(); |
|
776 // |
|
777 ValidateWin(BaseWin,TRgb::Gray256(255)); |
|
778 ValidateWin(TestWin,TRgb::Gray256(255)); |
|
779 TheClient->iWs.Flush(); |
|
780 for(TInt winType=0;winType<3;winType++) |
|
781 { |
|
782 RWindowBase *cursorwin=NULL; |
|
783 RBackedUpWindow backcursorwin(TheClient->iWs); |
|
784 RWindow backwindow(TheClient->iWs); |
|
785 RBlankWindow backblankwin(TheClient->iWs); |
|
786 switch(winType) |
|
787 { |
|
788 case 0: |
|
789 cursorwin=&backcursorwin; |
|
790 User::LeaveIfError(backcursorwin.Construct(*TestWin->BaseWin(),EGray4,1)); |
|
791 break; |
|
792 case 1: |
|
793 cursorwin=&backwindow; |
|
794 User::LeaveIfError(backwindow.Construct(*TestWin->BaseWin(),1)); |
|
795 break; |
|
796 case 2: |
|
797 cursorwin=&backblankwin; |
|
798 User::LeaveIfError(backblankwin.Construct(*TestWin->BaseWin(),1)); |
|
799 break; |
|
800 } |
|
801 CleanupStack::PushL(TCleanupItem(CleanUpWindow,cursorwin)); |
|
802 User::LeaveIfError(cursorwin->SetSizeErr(TestWin->BaseWin()->Size())); |
|
803 cursorwin->Activate(); |
|
804 // |
|
805 TTextCursor tc; |
|
806 tc.iType=iCursorType; |
|
807 tc.iHeight=30; |
|
808 tc.iAscent=0; |
|
809 tc.iWidth=50; |
|
810 tc.iFlags=0; |
|
811 tc.iColor=TRgb::Gray256(255); |
|
812 TheClient->iGroup->GroupWin()->SetTextCursor(*cursorwin,TPoint(10,10),tc); |
|
813 // |
|
814 CreateTestSpriteLC(*cursorwin, TPoint(10,20), 2); |
|
815 // |
|
816 if (cursorwin==&backwindow) |
|
817 RedrawWin(backwindow,TRgb::Gray256(255)); |
|
818 for(TInt count=0;count<9;count++) |
|
819 { |
|
820 RWindowBase *pwin=NULL; |
|
821 RBackedUpWindow backedup(TheClient->iWs); |
|
822 RWindow window(TheClient->iWs); |
|
823 RBlankWindow blankwin(TheClient->iWs); |
|
824 switch(count%3) |
|
825 { |
|
826 case 0: |
|
827 pwin=&window; |
|
828 window.Construct(*cursorwin,2); |
|
829 window.SetBackgroundColor(TRgb(winColor,winColor,winColor)); |
|
830 break; |
|
831 case 1: |
|
832 pwin=&backedup; |
|
833 backedup.Construct(*cursorwin,EGray4,2); |
|
834 break; |
|
835 case 2: |
|
836 pwin=&blankwin; |
|
837 blankwin.Construct(*cursorwin,2); |
|
838 blankwin.SetColor(TRgb(winColor,winColor,winColor)); |
|
839 break; |
|
840 } |
|
841 CleanupStack::PushL(TCleanupItem(CleanUpWindow,pwin)); |
|
842 pwin->SetExtentErr(TPoint(30,30),TSize(50,80)); |
|
843 pwin->Activate(); |
|
844 TheClient->iWs.Flush(); |
|
845 CleanupStack::PopAndDestroy(); // window |
|
846 if (cursorwin==&backwindow) |
|
847 RedrawWin(backwindow,TRgb::Gray256(255)); |
|
848 TheClient->iWs.Flush(); |
|
849 TheClient->WaitForRedrawsToFinish(); |
|
850 COMPARE_WINDOWS_SOFTFAIL_WINSCW; |
|
851 User::After(200000); // Wait a fifth of a second to make sure the test is run during different states of flashing |
|
852 } |
|
853 for(TInt count2=0;count2<4;count2++) |
|
854 { |
|
855 cursorwin->SetPosition(TPoint(10,5)); |
|
856 TheClient->iWs.Flush(); |
|
857 User::After(100000); |
|
858 cursorwin->SetPosition(TPoint(5,10)); |
|
859 TheClient->iWs.Flush(); |
|
860 User::After(100000); |
|
861 cursorwin->SetPosition(TPoint(0,0)); |
|
862 TheClient->iWs.Flush(); |
|
863 User::After(100000); |
|
864 TheClient->WaitForRedrawsToFinish(); |
|
865 COMPARE_WINDOWS_SOFTFAIL_WINSCW; |
|
866 } |
|
867 CleanupStack::PopAndDestroy(2); // sprite & window containing sprite and cursor |
|
868 } |
|
869 CancelTextCursor(); |
|
870 } |
|
871 |
|
872 void CTCursorTest::INC040489L() |
|
873 { |
|
874 INFO_PRINTF1(_L("AUTO_TCur INC040489 ")); |
|
875 RWindowGroup group1(TheClient->iWs); |
|
876 PushWindowL(&group1); |
|
877 User::LeaveIfError(group1.Construct(ENullWsHandle)); |
|
878 RBlankWindow blank1(TheClient->iWs); |
|
879 PushWindowL(&blank1); |
|
880 User::LeaveIfError(blank1.Construct(group1,ENullWsHandle)); |
|
881 blank1.SetRequiredDisplayMode(EColor4K); |
|
882 blank1.SetColor(TRgb(250,150,0)); |
|
883 blank1.Activate(); |
|
884 RWindowGroup group2(TheClient->iWs); |
|
885 PushWindowL(&group2); |
|
886 User::LeaveIfError(group2.Construct(ENullWsHandle)); |
|
887 RBlankWindow blank2(TheClient->iWs); |
|
888 PushWindowL(&blank2); |
|
889 User::LeaveIfError(blank2.Construct(group2,ENullWsHandle)); |
|
890 blank2.SetRequiredDisplayMode(EColor4K); |
|
891 blank2.SetColor(TRgb(75,200,125)); |
|
892 blank2.Activate(); |
|
893 TheClient->Flush(); |
|
894 INFO_PRINTF1(_L(" Created Windows ")); |
|
895 TTextCursor tc; |
|
896 tc.iType=KTextCursorInitialIdValue + iTest->iScreenNumber*KNumberOfCustoTextCursors; |
|
897 tc.iHeight=80; |
|
898 tc.iAscent=10; |
|
899 tc.iWidth=30; |
|
900 tc.iFlags=0; |
|
901 tc.iColor=TRgb::Gray256(255); |
|
902 INFO_PRINTF1(_L(" About to Set Text Cursor 1 ")); |
|
903 group2.SetTextCursor(blank2,TPoint(20,20),tc); |
|
904 TheClient->Flush(); |
|
905 INFO_PRINTF1(_L(" Set Text Cursor 1 ")); |
|
906 User::After(2000000); //2sec |
|
907 TheClient->iWs.PrepareForSwitchOff(); |
|
908 TheClient->Flush(); |
|
909 User::After(2000000); //2sec |
|
910 group1.SetOrdinalPosition(0); |
|
911 group2.CancelTextCursor(); |
|
912 TheClient->Flush(); |
|
913 INFO_PRINTF1(_L(" Canceled Text Cursor ")); |
|
914 User::After(2000000); //2sec |
|
915 // |
|
916 // Before applying the fix, the following operations makes the Custom Text |
|
917 // Cursor Sprite invisible (happens even without wserv heartbeat suppression) |
|
918 INFO_PRINTF1(_L(" About to Set Text Cursor 2 ")); |
|
919 group1.SetOrdinalPosition(2); |
|
920 group2.SetTextCursor(blank2,TPoint(20,20),tc); |
|
921 TheClient->Flush(); |
|
922 INFO_PRINTF1(_L(" Set Text Cursor 2 ")); |
|
923 User::After(2000000); //2sec |
|
924 TRawEvent event; |
|
925 event.Set(TRawEvent::EActive); |
|
926 TheClient->iWs.SimulateRawEvent(event); |
|
927 TheClient->Flush(); |
|
928 INFO_PRINTF1(_L(" Simulated Active Event ")); |
|
929 User::After(2000000); //2sec |
|
930 CleanupStack::PopAndDestroy(4, &group1); |
|
931 INFO_PRINTF1(_L(" End of test ")); |
|
932 } |
|
933 |
|
934 void CTCursorTest::CursorUpdatedBeforeWindowRenderedL() |
|
935 { |
|
936 INFO_PRINTF1(_L("CursorUpdatedBeforeWindowRenderedL")); |
|
937 TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0); |
|
938 // We use some unique looking colors otherwise its harder |
|
939 // to spot which test is which |
|
940 TRgb kAqua(134, 242, 251); |
|
941 |
|
942 iWorkInProgress = new(ELeave) CBlankWindow(kAqua); |
|
943 iComparisonWindow = new(ELeave) CBlankWindow(kAqua); |
|
944 CancelTextCursor(); |
|
945 |
|
946 const TSize screenSize=TheClient->iGroup->Size(); |
|
947 const TInt kPad = 5; |
|
948 const TInt kThirdOfScreenWidth = screenSize.iWidth/3; |
|
949 const TInt kWinWidth = kThirdOfScreenWidth - 2*kPad; |
|
950 const TInt kWinHeight = screenSize.iHeight - 2*kPad; |
|
951 const TSize kWinSize(kWinWidth, kWinHeight); |
|
952 const TPoint kCursorPos(30, 30); |
|
953 iComparisonWindow->SetUpL(TPoint(2*kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc); |
|
954 iWorkInProgress->SetUpL( TPoint( kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc); |
|
955 |
|
956 TTextCursor nonFlashingCursor; |
|
957 nonFlashingCursor.iType = TTextCursor::ETypeRectangle; |
|
958 nonFlashingCursor.iHeight=kCursorHeight; |
|
959 nonFlashingCursor.iAscent=0; |
|
960 nonFlashingCursor.iWidth=kCursorWidth; |
|
961 nonFlashingCursor.iFlags=TTextCursor::EFlagNoFlash; |
|
962 nonFlashingCursor.iColor = KRgbBlack; |
|
963 TheClient->iGroup->GroupWin()->SetTextCursor(*iWorkInProgress->BaseWin(), kCursorPos, nonFlashingCursor); |
|
964 |
|
965 // Up till this point, there has not been a CWsWindow::Render() for iWorkInProgress |
|
966 // because the window has not been invalid |
|
967 |
|
968 /* |
|
969 * Here is the crux of the test. We want to create the following condition in a window group: |
|
970 * 1) None of its windows have yet been Rendered using CWsWindow::Render() |
|
971 * 2) A text cursor is present |
|
972 * 3) Focus is lost then received |
|
973 * |
|
974 * It used to be the case that Wserv picked up the handle to the Render Stage Text Cursor |
|
975 * drawer upon a Refresh caused by Rendering the window. But drawing the Text Cursor could |
|
976 * come either from a Window Render or a change to the state of the Text Cursor, such as |
|
977 * receiving focus in the window. A bug was experienced when the Text Cursor was drawn in |
|
978 * a window which never had been rendered. This meant that the handle was not set up causing |
|
979 * an assert. |
|
980 * |
|
981 * The code has been modified since then, to setup the handle to the Render Stage Text |
|
982 * Cursor during Wserv initialisation. However, to guard against future changes, its |
|
983 * worthwhile to have this corner case test to ensure it is possible to receive focus |
|
984 * in a window which has never been rendered. That is because the text cursor state |
|
985 * is updated in such circumstances, and that might trigger a draw of the cursor in a |
|
986 * future version of the text cursor code. |
|
987 */ |
|
988 TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(1); // lose focus |
|
989 TheClient->iWs.Finish(); |
|
990 TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0); // gain focus |
|
991 TheClient->iWs.Finish(); |
|
992 |
|
993 // If we get this far without a panic or assert, we have passed this test. |
|
994 |
|
995 // Now allow CWsWindow::Render() to occur in iWorkInProgress |
|
996 // The reason for doing this is so that when you watch the test |
|
997 // progress you can see visual confirmation via the progress message and |
|
998 // the coloured windows appear on the screen. Otherwise you would think |
|
999 // that the test had either been skipped or had broken. |
|
1000 iWorkInProgress->Invalidate(); |
|
1001 iWorkInProgress->Redraw(); |
|
1002 iComparisonWindow->Invalidate(); |
|
1003 iComparisonWindow->Redraw(); |
|
1004 TheClient->iWs.Finish(); |
|
1005 delete iWorkInProgress; |
|
1006 iWorkInProgress = NULL; |
|
1007 delete iComparisonWindow; |
|
1008 iComparisonWindow = NULL; |
|
1009 INFO_PRINTF1(_L("End of test")); |
|
1010 } |
|
1011 |
|
1012 void CTCursorTest::INC097774() |
|
1013 { |
|
1014 TTimeIntervalMicroSeconds32 initialRepeatRate; |
|
1015 TTimeIntervalMicroSeconds32 repeatRate; |
|
1016 TheClient->iWs.GetKeyboardRepeatRate(initialRepeatRate,repeatRate); |
|
1017 |
|
1018 //simulates a text cursor moving across the screen as if a user was holding down |
|
1019 //a key to scroll the cursor through a section of text. |
|
1020 //before applying the fix the cursor only shows up intermittently instead of smoothly |
|
1021 //scrolling across the screen. |
|
1022 const TSize cursorSize(3,20); |
|
1023 const TInt moveInterval=10; |
|
1024 SetCursor(TPoint(0,20),cursorSize,TRgb::Gray256(255),TTextCursor::EFlagNoFlash); |
|
1025 TheClient->Flush(); |
|
1026 User::After(initialRepeatRate); |
|
1027 for(TInt offset=10;offset<=100;offset+=moveInterval) |
|
1028 { |
|
1029 SetCursor(TPoint(offset,20),cursorSize,TRgb::Gray256(255),TTextCursor::EFlagNoFlash); |
|
1030 TheClient->Flush(); |
|
1031 User::After(repeatRate); |
|
1032 } |
|
1033 |
|
1034 //simulate clipped text cursor moving accross the screen |
|
1035 TRect rect(0,20,3,40); |
|
1036 SetCursor(TPoint(0,20),cursorSize,TRgb::Gray256(255),rect,TTextCursor::EFlagNoFlash); |
|
1037 TheClient->Flush(); |
|
1038 User::After(initialRepeatRate); |
|
1039 for(TInt offset=10;offset<=100;offset+=moveInterval) |
|
1040 { |
|
1041 rect.Move(moveInterval,0); |
|
1042 SetCursor(TPoint(offset,20),cursorSize,TRgb::Gray256(255),rect,TTextCursor::EFlagNoFlash); |
|
1043 TheClient->Flush(); |
|
1044 User::After(repeatRate); |
|
1045 } |
|
1046 } |
|
1047 /** What happens when a cursor becomes off-screen when the screen is resized/rotated? |
|
1048 * |
|
1049 * |
|
1050 **/ |
|
1051 void CTCursorTest::INC117232() |
|
1052 { |
|
1053 const TInt initialRepeatRate=300000; // 3/10 seconds should be long enough to update everything! |
|
1054 TInt currMode=TheClient->iScreen->CurrentScreenMode(); |
|
1055 TInt testMode=currMode; |
|
1056 TPixelsTwipsAndRotation currModeSize; |
|
1057 TheClient->iScreen->GetScreenModeSizeAndRotation(currMode, currModeSize); |
|
1058 //find a (rotated) mode where the dimensions of the screen shrank |
|
1059 for (TInt mode=0;mode<TheClient->iScreenModes.Count();mode++) |
|
1060 { |
|
1061 TPixelsTwipsAndRotation testModeSize; |
|
1062 TheClient->iScreen->GetScreenModeSizeAndRotation(mode,testModeSize); |
|
1063 if ( testModeSize.iPixelSize.iWidth<currModeSize.iPixelSize.iWidth-10 |
|
1064 || testModeSize.iPixelSize.iHeight<currModeSize.iPixelSize.iHeight-10 |
|
1065 ) |
|
1066 { |
|
1067 testMode=mode; |
|
1068 break; |
|
1069 } |
|
1070 } |
|
1071 if (testMode==currMode) |
|
1072 { |
|
1073 _LIT(KLog,"No smaller screen-size modes available - INC117232 test skipped"); |
|
1074 LOG_MESSAGE(KLog); |
|
1075 //iStep->SetTestStepResult(EInconclusive); //With this line the whole test fails which is too drastic |
|
1076 return; |
|
1077 } |
|
1078 //enable a cursor on the bottom right corner of the screen |
|
1079 TestWin->SetFullScreenExtL(); |
|
1080 TheClient->Flush(); |
|
1081 iCursorType=TTextCursor::ETypeRectangle; |
|
1082 SetCursor(TPoint(-20,-20)+TestWin->Size(),TSize(40,40),KRgbDarkMagenta,TTextCursor::EFlagNoFlash); |
|
1083 TheClient->Flush(); |
|
1084 User::After(initialRepeatRate); |
|
1085 //shrink the screen |
|
1086 TheClient->iScreen->SetScreenMode(testMode); |
|
1087 TheClient->iScreen->SetAppScreenMode(testMode); |
|
1088 //The defect was that WServ would now crash! |
|
1089 TheClient->Flush(); |
|
1090 User::After(initialRepeatRate); |
|
1091 //Set everything back |
|
1092 TheClient->iScreen->SetScreenMode(currMode); |
|
1093 TheClient->iScreen->SetAppScreenMode(currMode); |
|
1094 TheClient->Flush(); |
|
1095 User::After(initialRepeatRate); |
|
1096 } |
|
1097 |
|
1098 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA |
|
1099 /** |
|
1100 * Sets up a text cursor whose attributes indicate it should not be flashing |
|
1101 * and then checks to ensure this is the actual behaviour. |
|
1102 */ |
|
1103 void CTCursorTest::TextCursorNoFlashTestL() |
|
1104 { |
|
1105 TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0); |
|
1106 // We use some unique looking colors otherwise its harder |
|
1107 // to spot which test is which |
|
1108 TRgb kGentleYellow(251, 249, 198); |
|
1109 TRgb kGentlePink(253, 196, 221); |
|
1110 |
|
1111 iWorkInProgress = new(ELeave) CBlankWindow(kGentleYellow); |
|
1112 iComparisonWindow = new(ELeave) CBlankWindow(kGentleYellow); |
|
1113 CancelTextCursor(); |
|
1114 TheClient->Flush(); |
|
1115 |
|
1116 const TSize screenSize=TheClient->iGroup->Size(); |
|
1117 const TInt kPad = 5; |
|
1118 const TInt kThirdOfScreenWidth = screenSize.iWidth/3; |
|
1119 const TInt kWinWidth = kThirdOfScreenWidth - 2*kPad; |
|
1120 const TInt kWinHeight = screenSize.iHeight - 2*kPad; |
|
1121 const TSize kWinSize(kWinWidth, kWinHeight); |
|
1122 const TPoint kCursorPos(30, 30); |
|
1123 iWorkInProgress->SetUpL( TPoint( kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc); |
|
1124 iComparisonWindow->SetUpL(TPoint(2*kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc); |
|
1125 |
|
1126 TTextCursor nonFlashingCursor; |
|
1127 |
|
1128 nonFlashingCursor.iType = TTextCursor::ETypeRectangle; |
|
1129 nonFlashingCursor.iHeight=kCursorHeight; |
|
1130 nonFlashingCursor.iAscent=0; |
|
1131 nonFlashingCursor.iWidth=kCursorWidth; |
|
1132 nonFlashingCursor.iFlags=TTextCursor::EFlagNoFlash; |
|
1133 nonFlashingCursor.iColor = kGentlePink; // We expect a Flicker Buffer Render Stage to ignore this color |
|
1134 |
|
1135 iWorkInProgress->Invalidate(); |
|
1136 iWorkInProgress->Redraw(); |
|
1137 iComparisonWindow->Invalidate(); |
|
1138 iComparisonWindow->Redraw(); |
|
1139 |
|
1140 DrawTextCursorSimilarToRenderStage(*TheClient->iGc, *iComparisonWindow->Win(), kCursorPos, nonFlashingCursor); |
|
1141 TheClient->iGroup->GroupWin()->SetTextCursor(*iWorkInProgress->BaseWin(), kCursorPos, nonFlashingCursor); |
|
1142 TheClient->Flush(); |
|
1143 |
|
1144 CheckCursorDoesNotFlash(iWorkInProgress->BaseWin()->Size()); |
|
1145 |
|
1146 delete iWorkInProgress; |
|
1147 iWorkInProgress = NULL; |
|
1148 delete iComparisonWindow; |
|
1149 iComparisonWindow = NULL; |
|
1150 } |
|
1151 |
|
1152 void CTCursorTest::TextCursorFlashTestL() |
|
1153 { |
|
1154 TheClient->iGroup->WinTreeNode()->SetOrdinalPosition(0); |
|
1155 // We use some unique looking colors otherwise its harder |
|
1156 // to spot which test is which |
|
1157 TRgb kMildPurple(218, 155, 244); |
|
1158 TRgb kPaleGreen(146, 190, 12); |
|
1159 |
|
1160 iWorkInProgress = new(ELeave) CBlankWindow(kMildPurple); |
|
1161 iComparisonWindow = new(ELeave) CBlankWindow(kMildPurple); |
|
1162 CancelTextCursor(); |
|
1163 TheClient->Flush(); |
|
1164 |
|
1165 const TSize screenSize=TheClient->iGroup->Size(); |
|
1166 const TInt kPad = 5; |
|
1167 const TInt kThirdOfScreenWidth = screenSize.iWidth/3; |
|
1168 const TInt kWinWidth = kThirdOfScreenWidth - 2*kPad; |
|
1169 const TInt kWinHeight = screenSize.iHeight - 2*kPad; |
|
1170 const TSize kWinSize(kWinWidth, kWinHeight); |
|
1171 const TPoint kCursorPos(30, 30); |
|
1172 iWorkInProgress->SetUpL( TPoint( kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc); |
|
1173 iComparisonWindow->SetUpL(TPoint(2*kThirdOfScreenWidth + kPad, kPad), kWinSize, TheClient->iGroup, *TheClient->iGc); |
|
1174 |
|
1175 TTextCursor flashingCursor; |
|
1176 |
|
1177 flashingCursor.iType = TTextCursor::ETypeRectangle; |
|
1178 flashingCursor.iHeight=kCursorHeight; |
|
1179 flashingCursor.iAscent=0; |
|
1180 flashingCursor.iWidth=kCursorWidth; |
|
1181 flashingCursor.iFlags=0; // implies that cursor SHOULD flash |
|
1182 flashingCursor.iColor = kPaleGreen; // We expect a Flicker Buffer Render Stage to ignore this color |
|
1183 |
|
1184 iWorkInProgress->Invalidate(); |
|
1185 iWorkInProgress->Redraw(); |
|
1186 iComparisonWindow->Invalidate(); |
|
1187 iComparisonWindow->Redraw(); |
|
1188 |
|
1189 DrawTextCursorSimilarToRenderStage(*TheClient->iGc, *iComparisonWindow->Win(), kCursorPos, flashingCursor); |
|
1190 TheClient->iGroup->GroupWin()->SetTextCursor(*iWorkInProgress->BaseWin(), kCursorPos, flashingCursor); |
|
1191 TheClient->Flush(); |
|
1192 |
|
1193 CheckCursorDoesFlash(kCursorPos, flashingCursor, kMildPurple); |
|
1194 CancelTextCursor(); |
|
1195 TheClient->Flush(); |
|
1196 |
|
1197 delete iWorkInProgress; |
|
1198 iWorkInProgress = NULL; |
|
1199 delete iComparisonWindow; |
|
1200 iComparisonWindow = NULL; |
|
1201 } |
|
1202 |
|
1203 void CTCursorTest::DrawTextCursorSimilarToRenderStage(CWindowGc& aGc, RWindow& aWin, const TPoint& aPos, const TTextCursor& aTextCursor) |
|
1204 { |
|
1205 // This method duplicates the way in which the default FlickerBuffer Render |
|
1206 // Stage draws a Text Cursor of ETypeRectangle. @see CFbRenderStage::DrawTextCursor |
|
1207 // This code must be kept in sync with the FlickerBuffer Render Stage |
|
1208 |
|
1209 ASSERT(aTextCursor.iType == TTextCursor::ETypeRectangle); |
|
1210 const TRect updatedRegion(aPos,TSize(aTextCursor.iWidth,aTextCursor.iHeight)); |
|
1211 aWin.Invalidate(); |
|
1212 aWin.BeginRedraw(); |
|
1213 aGc.Activate(aWin); |
|
1214 aGc.Clear(); |
|
1215 aGc.SetBrushStyle(CGraphicsContext::ESolidBrush); |
|
1216 aGc.SetBrushColor(KRgbBlack); |
|
1217 aGc.SetPenStyle(CGraphicsContext::ENullPen); |
|
1218 aGc.Clear(updatedRegion); |
|
1219 aGc.Deactivate(); |
|
1220 aWin.EndRedraw(); |
|
1221 } |
|
1222 |
|
1223 void CTCursorTest::CheckCursorDoesNotFlash(const TSize& aSize) |
|
1224 { |
|
1225 const TInt kSampleTime = 100000; // one tenth of a second |
|
1226 const TInt kSampleLimit = 100; |
|
1227 TInt sampleIteration = 0; |
|
1228 TBool comparisonOkay = EFalse; |
|
1229 |
|
1230 while (sampleIteration < kSampleLimit) |
|
1231 { |
|
1232 comparisonOkay = DoCheckRect(iWorkInProgress, iComparisonWindow, TRect(TPoint(), aSize), CWsScreenDevice::EIncludeTextCursor); |
|
1233 if (!comparisonOkay) |
|
1234 { |
|
1235 INFO_PRINTF2(_L("CheckCursorDoesNotFlash difference found after %d milliseconds"), sampleIteration*100); |
|
1236 break; |
|
1237 } |
|
1238 sampleIteration++; |
|
1239 User::After(kSampleTime); |
|
1240 } |
|
1241 TEST(comparisonOkay); |
|
1242 } |
|
1243 |
|
1244 void CTCursorTest::UpdateCountersOnCursorTransition( |
|
1245 const TBool aTransitionedToOn, |
|
1246 TTime& aNow, |
|
1247 TInt64& aDeltaTime, |
|
1248 TTime& aLastDeltaTime, |
|
1249 TInt& aWarmUpIterations, |
|
1250 const TInt& aFlashChangeTime, |
|
1251 const TInt& aToleranceMargin, |
|
1252 TInt& aSampleNumber, |
|
1253 TInt& aToleranceViolations |
|
1254 ) |
|
1255 { |
|
1256 _LIT(KTxtOn, " On"); |
|
1257 _LIT(KTxtOff, "Off"); |
|
1258 TBufC<3> transitionType; |
|
1259 transitionType = aTransitionedToOn ? KTxtOn : KTxtOff; |
|
1260 |
|
1261 aNow.UniversalTime(); |
|
1262 aDeltaTime = aNow.MicroSecondsFrom(aLastDeltaTime).Int64(); |
|
1263 aLastDeltaTime = aNow; |
|
1264 |
|
1265 if (aWarmUpIterations > 0) |
|
1266 { |
|
1267 aWarmUpIterations--; |
|
1268 } |
|
1269 else |
|
1270 { |
|
1271 if (aDeltaTime > aFlashChangeTime + aToleranceMargin || |
|
1272 aDeltaTime < aFlashChangeTime - aToleranceMargin) |
|
1273 { |
|
1274 INFO_PRINTF5(_L(" Iteration %d, Cursor %S after %d, errorDelta %d microseconds"), |
|
1275 aSampleNumber, &transitionType, I64INT(aDeltaTime), I64INT(aDeltaTime - aFlashChangeTime)); |
|
1276 aToleranceViolations++; |
|
1277 } |
|
1278 } |
|
1279 } |
|
1280 void CTCursorTest::CheckCursorDoesFlash(const TPoint& aPos, const TTextCursor& aTextCursor, TRgb /* aBackgroundColor */) |
|
1281 { |
|
1282 |
|
1283 /** |
|
1284 * Quality of Service based thresholding |
|
1285 * |
|
1286 * The idea behind this test is to identify tolerances which would either |
|
1287 * cause the test to fail when the user would perceive the text cursor as |
|
1288 * not flashing uniformly, or would point to an unexpected delay outside |
|
1289 * the way the flashing (and scheduling of animations) is supposed to work. |
|
1290 * |
|
1291 * Potentially the cursor can be late if we miss a V-SYNC from hardware. In |
|
1292 * such cases we expect to see the cursor on the next frame. Since the V-SYNC |
|
1293 * is typically 1/50 second, a tolerance of two frames, or 1/25 second is reasonable. |
|
1294 * |
|
1295 * If the cursor is delayed longer than this, say a long time of 1 second, but this |
|
1296 * does not happen too often, then the user is likely to still be happy. So we |
|
1297 * set the period of testing to 60 seconds, and set the violations limit to 2. |
|
1298 */ |
|
1299 const TInt kOneSecond = 1000000; |
|
1300 const TInt kFlashPeriod = kOneSecond; // comprises one "ON" and one "OFF" |
|
1301 const TInt kToleranceFactor = 25; // meaning 1/25 of a Flash Period |
|
1302 const TInt kNumberTestFlashPeriods = 60; // meaning 60 Flash Periods worth of testing |
|
1303 const TInt kMaximumToleranceViolations = 2; // number of times an occassional flash may be late or early |
|
1304 |
|
1305 const TInt kToleranceMargin = kFlashPeriod / kToleranceFactor; |
|
1306 const TInt kNumberSamples = kNumberTestFlashPeriods * kToleranceFactor; |
|
1307 const TInt kFlashChangeTime = kFlashPeriod / 2; |
|
1308 |
|
1309 // The first couple of changes to the cursor should be ignored because |
|
1310 // when the test is started, the cursor may have been on for a while. |
|
1311 // Then when the cursor goes off, it appears to have switched to the |
|
1312 // off state too early. We therefore ignore the first two changes |
|
1313 // so we start cleanly. |
|
1314 TInt warmUpIterations = 2; |
|
1315 |
|
1316 // Empirically we see that cursors mostly flash with good timeliness apart from |
|
1317 // occasional events causing them to be either early or late. In order to keep |
|
1318 // a tight tolerance (1/50 second is around the screen refresh time) but still |
|
1319 // allow for the occasional variance (seen to be 1/23 second) we use a counter |
|
1320 // toleranceViolations < kMaximumToleranceViolations |
|
1321 TInt toleranceViolations = 0; |
|
1322 TBool cursorShownLastTime = EFalse; |
|
1323 TBool cursorShown = EFalse; |
|
1324 TTime lastDeltaTime; |
|
1325 TTime now; |
|
1326 TInt64 deltaTime = 0; |
|
1327 lastDeltaTime.UniversalTime(); |
|
1328 now.UniversalTime(); |
|
1329 |
|
1330 TRect textCursorRect(TRect(aPos, TSize(aTextCursor.iWidth, aTextCursor.iHeight))); |
|
1331 |
|
1332 for (TInt sampleNumber = 0; sampleNumber < kNumberSamples; sampleNumber++) |
|
1333 { |
|
1334 cursorShown = DoCheckRect(iWorkInProgress, iComparisonWindow, textCursorRect, CWsScreenDevice::EIncludeTextCursor); |
|
1335 |
|
1336 if (cursorShown && !cursorShownLastTime) |
|
1337 { |
|
1338 cursorShownLastTime = ETrue; |
|
1339 UpdateCountersOnCursorTransition( |
|
1340 cursorShownLastTime, now, deltaTime, lastDeltaTime, warmUpIterations, kFlashChangeTime, |
|
1341 kToleranceMargin, sampleNumber, toleranceViolations); |
|
1342 } |
|
1343 else if (!cursorShown && cursorShownLastTime) |
|
1344 { |
|
1345 cursorShownLastTime = EFalse; |
|
1346 UpdateCountersOnCursorTransition( |
|
1347 cursorShownLastTime, now, deltaTime, lastDeltaTime, warmUpIterations, kFlashChangeTime, |
|
1348 kToleranceMargin, sampleNumber, toleranceViolations); |
|
1349 } |
|
1350 |
|
1351 if (toleranceViolations > kMaximumToleranceViolations) |
|
1352 break; |
|
1353 |
|
1354 User::After(kToleranceMargin); |
|
1355 } |
|
1356 // Check was some flashing |
|
1357 TEST_SOFTFAIL_WINSCW(warmUpIterations == 0); |
|
1358 // Check cursor flashed on and off, regularly and on-time |
|
1359 TEST_SOFTFAIL_WINSCW(toleranceViolations <= kMaximumToleranceViolations); |
|
1360 } |
|
1361 #endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA |
|
1362 |
|
1363 void CTCursorTest::MakeCursors(TTextCursor& aTextCursor, TTextCursor& aCustomCursor) |
|
1364 { |
|
1365 aCustomCursor.iType = KTextCursorInitialIdValue + iTest->iScreenNumber*KNumberOfCustoTextCursors; // custom text cursor |
|
1366 aCustomCursor.iAscent=0; |
|
1367 aCustomCursor.iHeight=kCursorHeight; |
|
1368 aCustomCursor.iWidth=kCursorWidth; |
|
1369 aCustomCursor.iFlags=TTextCursor::EFlagNoFlash; |
|
1370 aCustomCursor.iColor=TRgb::Color256(217); |
|
1371 |
|
1372 // Create a standard cursor for the tests |
|
1373 aTextCursor.iType = TTextCursor::ETypeRectangle; // Normal rectangular text cursor |
|
1374 aTextCursor.iHeight=kCursorHeight; |
|
1375 aTextCursor.iAscent=0; |
|
1376 aTextCursor.iWidth=kCursorWidth; |
|
1377 aTextCursor.iFlags=TTextCursor::EFlagNoFlash; |
|
1378 } |
|
1379 |
|
1380 void CTCursorTest::StartDoubleCursorTestL(TInt aTestNumber) |
|
1381 { |
|
1382 // general setup |
|
1383 CBlankWindow* win1=new(ELeave) CBlankWindow(KRgbWhite); |
|
1384 CleanupStack::PushL(win1); |
|
1385 |
|
1386 win1->SetUpL(kWin1TopLeft,kWinSize,TheClient->iGroup,*TheClient->iGc,EColor64K); |
|
1387 |
|
1388 win1->Redraw(); |
|
1389 |
|
1390 // Create the second window |
|
1391 CBlankWindow* win2=new(ELeave) CBlankWindow(KRgbWhite); |
|
1392 CleanupStack::PushL(win2); |
|
1393 |
|
1394 win2->SetUpL(kWin2TopLeft,kWinSize,TheClient->iGroup,*TheClient->iGc,EColor64K); |
|
1395 win2->Redraw(); |
|
1396 |
|
1397 // Create normal and custom cursor for the tests |
|
1398 TTextCursor textCursor; |
|
1399 TTextCursor customCursor; |
|
1400 MakeCursors(textCursor, customCursor); |
|
1401 |
|
1402 TheClient->Flush(); |
|
1403 CWindowGc* winGc = TheClient->iGc; |
|
1404 |
|
1405 switch(aTestNumber) |
|
1406 { |
|
1407 case 1: |
|
1408 CheckNoDoubleCursorTest1L(win1, win2, textCursor, customCursor, winGc); |
|
1409 break; |
|
1410 |
|
1411 case 2: |
|
1412 CheckNoDoubleCursorTest2L(win1, win2, textCursor, customCursor, winGc); |
|
1413 break; |
|
1414 |
|
1415 case 3: |
|
1416 CheckNoDoubleCursorTest3L(win1, win2, textCursor, customCursor, winGc); |
|
1417 break; |
|
1418 |
|
1419 default: |
|
1420 TEST(EFalse); |
|
1421 break; |
|
1422 } |
|
1423 CleanupStack::PopAndDestroy(2); |
|
1424 } |
|
1425 |
|
1426 // DEF098704 |
|
1427 void CTCursorTest::CheckNoDoubleCursorTest1L(CBlankWindow* aWin1, CBlankWindow* aWin2, TTextCursor& /*aTextCursor*/, TTextCursor& aCustomCursor, CWindowGc* aWinGc) |
|
1428 { |
|
1429 // Test that changing the focus of a custom text cursor does not leave that cursor drawn where it was (INC093898) |
|
1430 |
|
1431 TheClient->iGroup->GroupWin()->SetTextCursor(*aWin1->BaseWin(),TPoint(),aCustomCursor); |
|
1432 |
|
1433 // Bit blit the TEST_BITMAP_NAME image to the second window to use as a comparison |
|
1434 // this is the same image that the custom cursor is using |
|
1435 CFbsBitmap* bitmap = new(ELeave) CFbsBitmap; |
|
1436 CleanupStack::PushL(bitmap); |
|
1437 TEST(KErrNone == bitmap->Load(TEST_BITMAP_NAME,0,ETrue)); |
|
1438 |
|
1439 aWinGc->Activate(*aWin2->Win()); |
|
1440 TRect updateArea(TPoint(0,0), bitmap->SizeInPixels()); |
|
1441 aWin2->Win()->Invalidate(updateArea); |
|
1442 aWin2->Win()->BeginRedraw(updateArea); |
|
1443 aWinGc->BitBlt(TPoint(0,0),bitmap); |
|
1444 aWinGc->Deactivate(); |
|
1445 aWin2->Win()->EndRedraw(); |
|
1446 TheClient->Flush(); |
|
1447 doCheckNoDoubleCursor(aWin1,aWin2,kWin1TopLeft,kWin2TopLeft,aCustomCursor,bitmap->SizeInPixels(),CWsScreenDevice::EIncludeSprite); |
|
1448 CleanupStack::PopAndDestroy(1); // bitmap |
|
1449 } |
|
1450 |
|
1451 // DEF098704 |
|
1452 void CTCursorTest::CheckNoDoubleCursorTest2L(CBlankWindow* aWin1, CBlankWindow* aWin2, TTextCursor& /*aTextCursor*/, TTextCursor& aCustomCursor, CWindowGc* aWinGc) |
|
1453 { |
|
1454 //TEST 2: Checks that no artifacts are left behind when a text cursor is moved from under a transparent sprite |
|
1455 |
|
1456 // Construct the window win1 with a transparent sprite |
|
1457 |
|
1458 // Clear the top and bottom windows |
|
1459 ResetWindows(aWinGc,aWin1,aWin2); |
|
1460 |
|
1461 // Create a bitmap and a corresponding bitmap mask |
|
1462 CFbsBitmap* bitmap = new(ELeave) CFbsBitmap; |
|
1463 CleanupStack::PushL(bitmap); |
|
1464 TEST(KErrNone == bitmap->Load(TEST_BITMAP_NAME,0,ETrue)); |
|
1465 CBitmap* spriteBitmap=CBitmap::NewL(kWinSize,EColor256); |
|
1466 CleanupStack::PushL(spriteBitmap); |
|
1467 spriteBitmap->Gc().SetBrushColor(KRgbBlack); |
|
1468 spriteBitmap->Gc().SetBrushStyle(CGraphicsContext::ESolidBrush); |
|
1469 spriteBitmap->Gc().SetPenStyle(CGraphicsContext::ESolidPen); |
|
1470 spriteBitmap->Gc().DrawRect(TRect(kWinSize)); |
|
1471 CBitmap* mask=CBitmap::NewL(kWinSize,EColor256); |
|
1472 CleanupStack::PushL(mask); |
|
1473 mask->Gc().SetBrushStyle(CGraphicsContext::ESolidBrush); |
|
1474 mask->Gc().SetBrushColor(KRgbBlack); |
|
1475 mask->Gc().DrawRect(TRect(kWinSize)); |
|
1476 |
|
1477 // Create a sprite |
|
1478 RWsSprite sprite = RWsSprite(TheClient->iWs); |
|
1479 CleanupClosePushL(sprite); |
|
1480 TEST(KErrNone == sprite.Construct(*aWin1->BaseWin(),TPoint(),0)); |
|
1481 |
|
1482 // Add the bitmap to the sprite |
|
1483 TSpriteMember member; |
|
1484 member.iInvertMask=EFalse; |
|
1485 member.iDrawMode=CGraphicsContext::EDrawModePEN; |
|
1486 member.iOffset=TPoint(); |
|
1487 member.iInterval=TTimeIntervalMicroSeconds32(0); |
|
1488 member.iBitmap = &spriteBitmap->Bitmap(); |
|
1489 member.iMaskBitmap = &mask->Bitmap(); |
|
1490 TEST(KErrNone == sprite.AppendMember(member)); |
|
1491 |
|
1492 // Activate the sprite in win1 |
|
1493 TEST(KErrNone == sprite.Activate()); |
|
1494 |
|
1495 // Put a cursor in win1 |
|
1496 TheClient->iGroup->GroupWin()->SetTextCursor(*aWin1->BaseWin(),TPoint(),aCustomCursor); |
|
1497 |
|
1498 // Bit blit the matching bitmap to the bottom window |
|
1499 TRect bitmapArea(TPoint(0,0), bitmap->SizeInPixels()); |
|
1500 aWin2->Win()->Invalidate(bitmapArea); |
|
1501 aWin2->Win()->BeginRedraw(bitmapArea); |
|
1502 aWinGc->Activate(*aWin2->Win()); |
|
1503 aWinGc->BitBlt(TPoint(),bitmap); |
|
1504 aWinGc->Deactivate(); |
|
1505 aWin2->Win()->EndRedraw(); |
|
1506 |
|
1507 TheClient->Flush(); |
|
1508 doCheckNoDoubleCursor(aWin1,aWin2,kWin1TopLeft,kWin2TopLeft,aCustomCursor,bitmap->SizeInPixels(),CWsScreenDevice::EIncludeSprite); |
|
1509 CleanupStack::PopAndDestroy(4); // sprite, mask, spriteBitmap, bitmap |
|
1510 } |
|
1511 |
|
1512 // DEF098704 |
|
1513 void CTCursorTest::CheckNoDoubleCursorTest3L(CBlankWindow* aWin1, CBlankWindow* aWin2, TTextCursor& aTextCursor,TTextCursor& aCustomCursor, CWindowGc* aWinGc) |
|
1514 { |
|
1515 // |
|
1516 // TEST 3: Test a flashing text cursor does not leave artifacts when a redraw + change position happens during |
|
1517 // the time the cursor flashing 'off' |
|
1518 // |
|
1519 // This test moves a flashing cursor a number of times over a two second period to a seconds position. |
|
1520 // it does it a number of times so some of the redraws will occur during the 'flash off' period |
|
1521 // We then compare the 'after' position to what we expect |
|
1522 // |
|
1523 // There are four possible outcomes when we look at the bitmap after the redraw + move |
|
1524 // Position 1 is the original position, position 2 is the new position after the redraw |
|
1525 // |
|
1526 // cursor artifact @ pos1 and flashed on cursor @ pos2 |
|
1527 // cursor artifact at pos1 and flashed off cursor @ pos2 |
|
1528 // no artifact at pos1 and flashed off cursor @ pos2 |
|
1529 // no artifact at pos1 and flashed on cursor @ pos2 |
|
1530 // |
|
1531 // any artifacts left over will cause the complete test to fail. |
|
1532 // |
|
1533 |
|
1534 // |
|
1535 // PART A: |
|
1536 aTextCursor.iFlags=0; // flashing |
|
1537 |
|
1538 ResetWindows(aWinGc,aWin1,aWin2); |
|
1539 TestForArtifacts(aWin1, aTextCursor); |
|
1540 |
|
1541 // |
|
1542 // PART B - For a non-custom text cursor |
|
1543 aCustomCursor.iFlags=0; // flashing |
|
1544 |
|
1545 ResetWindows(aWinGc,aWin1,aWin2); |
|
1546 TestForArtifacts(aWin1, aCustomCursor); |
|
1547 } |
|
1548 |
|
1549 // moves the cursor between two positions while flashing and tests no artifacts are left at the position it moved from |
|
1550 // The moves take place in a loop so it is tested happening when the cursor is flashed on and also off |
|
1551 void CTCursorTest::TestForArtifacts(CBlankWindow* aWin1, TTextCursor& aCursor) |
|
1552 { |
|
1553 const TInt KIterations = 30; |
|
1554 const TPoint kStartPos(0,0); |
|
1555 const TPoint kMoveToPos(200,0); |
|
1556 TRect r1(kWin1TopLeft,kCursorSize); |
|
1557 TRect r2(kWin2TopLeft,kCursorSize); |
|
1558 const TPoint kWin1TopLeft; |
|
1559 const TPoint kWin2TopLeft; |
|
1560 const TSize aCursorSize; |
|
1561 |
|
1562 TheClient->iGroup->GroupWin()->SetTextCursor(*aWin1->BaseWin(),kStartPos,aCursor); |
|
1563 TheClient->Flush(); |
|
1564 |
|
1565 TInt initialRepeatRate = 1000000; |
|
1566 const TInt KIncrement = 30000; |
|
1567 TInt i=0; |
|
1568 |
|
1569 for(i=0; i<KIterations; i++) |
|
1570 { |
|
1571 // move the cursor to its new position |
|
1572 TheClient->iGroup->GroupWin()->SetTextCursor(*aWin1->BaseWin(),kMoveToPos,aCursor); |
|
1573 TheClient->Flush(); |
|
1574 |
|
1575 User::After(initialRepeatRate); |
|
1576 |
|
1577 // check no artifact was left in position 1 by comparing against (blank) win2 |
|
1578 if(!TheClient->iScreen->RectCompare( r1,r2, CWsScreenDevice::EIncludeTextCursor)) |
|
1579 { |
|
1580 break; // detected an artifact remaining, test failed |
|
1581 } |
|
1582 |
|
1583 // move the cursor back to its start position, this resets the flash timer which is why we increment initialRepeatRate |
|
1584 TheClient->iGroup->GroupWin()->SetTextCursor(*aWin1->BaseWin(),kStartPos,aCursor); |
|
1585 TheClient->Flush(); |
|
1586 initialRepeatRate += KIncrement; |
|
1587 } |
|
1588 |
|
1589 // if all went well i should equal KIterations, if it doesnt its because we detected |
|
1590 // an artifact and quit the test early |
|
1591 TEST_SOFTFAIL_WINSCW(i==KIterations); |
|
1592 } |
|
1593 |
|
1594 |
|
1595 // Tests the two windows match, moves the cursor off win 1 then tests they no longer match |
|
1596 void CTCursorTest::doCheckNoDoubleCursor(CBlankWindow* aWin1, |
|
1597 CBlankWindow* aWin2, |
|
1598 const TPoint& aWin1Tl, |
|
1599 const TPoint& aWin2Tl, |
|
1600 const TTextCursor& aCursor, |
|
1601 const TSize& aCursorSize, |
|
1602 CWsScreenDevice::TSpriteInCompare aFlags) |
|
1603 { |
|
1604 TRect r1(aWin1Tl,aCursorSize); |
|
1605 TRect r2(aWin2Tl,aCursorSize); |
|
1606 |
|
1607 TInt compareTries = 0; |
|
1608 const TInt compareLimit = 5; |
|
1609 |
|
1610 TBool correctComparison = EFalse; |
|
1611 while (!correctComparison && compareTries < compareLimit) |
|
1612 { |
|
1613 compareTries++; |
|
1614 User::After(500000); |
|
1615 correctComparison = TheClient->iScreen->RectCompare(r1,r2, aFlags); |
|
1616 } |
|
1617 |
|
1618 INFO_PRINTF3(_L("Result Before %d (attempts %d)"), correctComparison, compareTries); |
|
1619 TEST_SOFTFAIL_WINSCW(correctComparison); |
|
1620 |
|
1621 |
|
1622 // Change the focus off win1, by drawing the text cursor on the second window |
|
1623 TheClient->iGroup->GroupWin()->SetTextCursor(*aWin2->BaseWin(),aWin2Tl,aCursor); |
|
1624 TheClient->Flush(); |
|
1625 |
|
1626 // Cause a redraw |
|
1627 aWin1->CTWin::DrawNow(); |
|
1628 TheClient->WaitForRedrawsToFinish(); |
|
1629 |
|
1630 // make sure any cursor has actually moved |
|
1631 User::After(1000000); // 1 sec |
|
1632 |
|
1633 TBool resultAfter; |
|
1634 resultAfter = !TheClient->iScreen->RectCompare(r1,r2, aFlags); |
|
1635 INFO_PRINTF2(_L("Result After %d"), resultAfter); |
|
1636 TEST_SOFTFAIL_WINSCW(resultAfter); |
|
1637 } |
|
1638 |
|
1639 // resets the windows to their initial state |
|
1640 void CTCursorTest::ResetWindows(CWindowGc* aWinGc,CBlankWindow* aWin1,CBlankWindow* aWin2) |
|
1641 { |
|
1642 TheClient->iGroup->GroupWin()->CancelTextCursor(); |
|
1643 aWinGc->Activate(*aWin1->Win()); |
|
1644 aWinGc->Reset(); |
|
1645 aWinGc->Clear(); |
|
1646 aWinGc->Deactivate(); |
|
1647 |
|
1648 aWin1->Invalidate(); |
|
1649 aWin1->Redraw(); |
|
1650 aWin2->Invalidate(); |
|
1651 aWin2->Redraw(); |
|
1652 TheClient->Flush(); |
|
1653 } |
|
1654 |
|
1655 void CTCursorTest::RunTestCaseL(TInt /*aCurTestCase*/) |
|
1656 { |
|
1657 TBool deleteMove=EFalse; |
|
1658 ((CTCursorTestStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); |
|
1659 |
|
1660 switch(++iTest->iState) |
|
1661 { |
|
1662 /** |
|
1663 @SYMTestCaseID GRAPHICS-WSERV-0241 |
|
1664 |
|
1665 @SYMDEF DEF081259 |
|
1666 |
|
1667 @SYMTestCaseDesc Test the text cursor functions properly as a window is moved |
|
1668 |
|
1669 @SYMTestPriority High |
|
1670 |
|
1671 @SYMTestStatus Implemented |
|
1672 |
|
1673 @SYMTestActions Move a window about the screen and meanwhile check the text |
|
1674 cursor functions correctly |
|
1675 |
|
1676 @SYMTestExpectedResults The text cursor functions correctly as the window is moved |
|
1677 */ |
|
1678 case 1: |
|
1679 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0241")); |
|
1680 while (!deleteMove) |
|
1681 { |
|
1682 if (iCursorType==TTextCursor::ETypeFirst) |
|
1683 iTest->LogSubTest(_L("Cursor 1")); |
|
1684 if (MoveWindow()) |
|
1685 { |
|
1686 if (IncrementCursorType()) |
|
1687 { |
|
1688 ResetMoveWindowsL(); |
|
1689 } |
|
1690 else |
|
1691 { |
|
1692 DeleteMoveWindows(); |
|
1693 deleteMove =true; |
|
1694 } |
|
1695 } |
|
1696 } |
|
1697 break; |
|
1698 |
|
1699 /** |
|
1700 @SYMTestCaseID GRAPHICS-WSERV-0242 |
|
1701 |
|
1702 @SYMDEF DEF081259 |
|
1703 |
|
1704 @SYMTestCaseDesc Test the text cursor functions properly as the window is scrolled |
|
1705 |
|
1706 @SYMTestPriority High |
|
1707 |
|
1708 @SYMTestStatus Implemented |
|
1709 |
|
1710 @SYMTestActions Scroll the window and meanwhile check the text cursor functions correctly |
|
1711 |
|
1712 @SYMTestExpectedResults The text cursor functions correctly as the window is scrolled |
|
1713 */ |
|
1714 case 2: |
|
1715 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0242")); |
|
1716 iTest->LogSubTest(_L("Cursor 2")); |
|
1717 iCursorType=TTextCursor::ETypeRectangle; |
|
1718 ScrollTest(); |
|
1719 iCursorType=TTextCursor::ETypeFirst; |
|
1720 break; |
|
1721 /** |
|
1722 @SYMTestCaseID GRAPHICS-WSERV-0244 |
|
1723 |
|
1724 @SYMDEF DEF081259 |
|
1725 |
|
1726 @SYMTestCaseDesc Test the text cursor functions properly as a blank window is moved |
|
1727 |
|
1728 @SYMTestPriority High |
|
1729 |
|
1730 @SYMTestStatus Implemented |
|
1731 |
|
1732 @SYMTestActions Move a blank window about the screen and meanwhile check the text |
|
1733 cursor functions correctly |
|
1734 |
|
1735 @SYMTestExpectedResults The text cursor functions correctly as the blank window is moved |
|
1736 */ |
|
1737 case 3: |
|
1738 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0244")); |
|
1739 iTest->LogSubTest(_L("Move window1")); |
|
1740 MoveWindowTest1L(); |
|
1741 break; |
|
1742 /** |
|
1743 @SYMTestCaseID GRAPHICS-WSERV-0245 |
|
1744 |
|
1745 @SYMDEF DEF081259 |
|
1746 |
|
1747 @SYMTestCaseDesc Test that a non flashing text cursor functions properly as a |
|
1748 blank window is moved |
|
1749 |
|
1750 @SYMTestPriority High |
|
1751 |
|
1752 @SYMTestStatus Implemented |
|
1753 |
|
1754 @SYMTestActions Move a blank window about the screen and meanwhile check that a non |
|
1755 flashing text cursor functions correctly |
|
1756 |
|
1757 @SYMTestExpectedResults The text cursor functions correctly as the blank window is moved |
|
1758 */ |
|
1759 case 4: |
|
1760 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0245")); |
|
1761 while (IncrementCursorType()) |
|
1762 { |
|
1763 iTest->LogSubTest(_L("Move window2")); |
|
1764 MoveWindowTest2L(); |
|
1765 } |
|
1766 break; |
|
1767 /** |
|
1768 @SYMTestCaseID GRAPHICS-WSERV-0247 |
|
1769 |
|
1770 @SYMDEF DEF081259 |
|
1771 |
|
1772 @SYMTestCaseDesc Tests a Custom Text Cursor Sprite visibility after wserv hearbeat suppression |
|
1773 REQUIREMENT: INC040489. |
|
1774 |
|
1775 @SYMTestPriority High |
|
1776 |
|
1777 @SYMTestStatus Implemented |
|
1778 |
|
1779 @SYMTestActions Create a window group with an associated window for it, then activate it. |
|
1780 Create another window group with an associated window along with a custom cursor, |
|
1781 then active it. Make a call to suppress the wserv hearbeat, which will stop |
|
1782 the custom cursor from flashing with flash ON state. Bring the first window |
|
1783 group to the foreground and cancel the custom test cursor in the second window group. |
|
1784 After that, put the first window group to the background and set the custom test |
|
1785 cursor in the second window group. Simulate a raw key event to start |
|
1786 the wserv heartbeat, which will make the custom cursor flashing. |
|
1787 |
|
1788 @SYMTestExpectedResults The Custom text cursor in the second window group should be visible and flashing, |
|
1789 when it comes to the foreground after the first window group sent to the background. |
|
1790 */ |
|
1791 case 5: |
|
1792 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0247")); |
|
1793 iTest->LogSubTest(_L("Custom Text Cursor Sprite visibility")); |
|
1794 INC040489L(); |
|
1795 break; |
|
1796 /** |
|
1797 @SYMTestCaseID GRAPHICS-WSERV-2095-0015 |
|
1798 |
|
1799 @SYMTestCaseDesc Text Cursor allows Update before Rendering the owning window |
|
1800 |
|
1801 @SYMTestPriority Normal |
|
1802 |
|
1803 @SYMTestStatus Implemented |
|
1804 |
|
1805 @SYMTestActions Create a window group and two windows, one with a Text Cursor. |
|
1806 Stimulate a state change in the Text Cursor by receiving |
|
1807 window focus, but before the Window has ever been Rendered. |
|
1808 This shakes out logic in RWsTextCursor which depends on |
|
1809 side effects arising from having executed CWsWindow::Render() |
|
1810 |
|
1811 @SYMTestExpectedResults |
|
1812 There should be no panic or assertion. |
|
1813 */ |
|
1814 case 6: |
|
1815 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-2095-0015")); |
|
1816 iTest->LogSubTest(_L("Update before Render")); |
|
1817 CursorUpdatedBeforeWindowRenderedL(); |
|
1818 break; |
|
1819 |
|
1820 /** |
|
1821 @SYMTestCaseID GRAPHICS-WSERV-0248 |
|
1822 |
|
1823 @SYMDEF DEF081259 |
|
1824 |
|
1825 @SYMTestCaseDesc Tests a bad use of text cursor functionality from a client. |
|
1826 REQ 1079, CR RDEF-5F7Q24 (10/04/2003). |
|
1827 |
|
1828 @SYMTestPriority High |
|
1829 |
|
1830 @SYMTestStatus Implemented |
|
1831 |
|
1832 @SYMTestActions This test case checks whether the window server is able to detect a bad |
|
1833 use of the text cursor functionality (including the custom text cursor) |
|
1834 by a client. |
|
1835 This test case launches several threads and each of them will try |
|
1836 to use the text cursor functionality in a non-proper way. |
|
1837 |
|
1838 @SYMTestExpectedResults Each new thread has panic code associated to it. This is the expected panic when |
|
1839 the thread dies. |
|
1840 The thread once launched is expected to panic and the returning panic code should |
|
1841 match the expected one. |
|
1842 */ |
|
1843 case 7: |
|
1844 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0248")); |
|
1845 iTest->LogSubTest(_L("Panic")); |
|
1846 TestPanicsL(); |
|
1847 break; |
|
1848 /** |
|
1849 @SYMTestCaseID GRAPHICS-WSERV-0400 |
|
1850 |
|
1851 @SYMDEF PDEF099013 |
|
1852 |
|
1853 @SYMTestCaseDesc Cursor moves slowly in text editors. |
|
1854 |
|
1855 @SYMTestPriority High |
|
1856 |
|
1857 @SYMTestStatus Implemented |
|
1858 |
|
1859 @SYMTestActions This test case is a VISUAL TEST only on whether a scrolling text cursor is drawn to the |
|
1860 screen correctly. 2 types of cursor are checked both clipped and non clipped cursors. |
|
1861 In each case the test simulates a text cursor moving across the screen as if a user were |
|
1862 holding down a key to scroll the cursor through a section of text. |
|
1863 |
|
1864 @SYMTestExpectedResults The text cursor in both cases should scroll smoothly to the centre of the screen. |
|
1865 In versions prior to this fix the cursor was not correctly drawn and appeared to move |
|
1866 slowly. |
|
1867 */ |
|
1868 case 8: |
|
1869 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0400")); |
|
1870 iTest->LogSubTest(_L("Text Cursor Update Tests")); |
|
1871 INC097774(); |
|
1872 break; |
|
1873 |
|
1874 /** |
|
1875 @SYMTestCaseID GRAPHICS-WSERV-0401 |
|
1876 |
|
1877 @SYMDEF DEF098704 |
|
1878 |
|
1879 @SYMTestCaseDesc Test code for implemented fix to remove double cursors |
|
1880 |
|
1881 @SYMTestPriority Normal |
|
1882 |
|
1883 @SYMTestStatus Implemented |
|
1884 |
|
1885 @SYMTestActions This test case tests for artifacts left over when normal/custon flashing/non-flashing cursors are drawn. |
|
1886 Test that changing the focus of a custom text cursor does not leave that cursor drawn where it was (INC093898) |
|
1887 |
|
1888 @SYMTestExpectedResults |
|
1889 */ |
|
1890 case 9: |
|
1891 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0401")); |
|
1892 iTest->LogSubTest(_L("Double cursors test 1")); |
|
1893 StartDoubleCursorTestL(1); |
|
1894 break; |
|
1895 |
|
1896 /** |
|
1897 @SYMTestCaseID GRAPHICS-WSERV-0402 |
|
1898 |
|
1899 @SYMDEF DEF098704 |
|
1900 |
|
1901 @SYMTestCaseDesc Test code for implemented fix to remove double cursors |
|
1902 |
|
1903 @SYMTestPriority Normal |
|
1904 |
|
1905 @SYMTestStatus Implemented |
|
1906 |
|
1907 @SYMTestActions Checks that no artifacts are left behind when a text cursor is moved from under a transparent sprite |
|
1908 |
|
1909 @SYMTestExpectedResults |
|
1910 */ |
|
1911 case 10: |
|
1912 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0402")); |
|
1913 iTest->LogSubTest(_L("Double cursors test 2")); |
|
1914 StartDoubleCursorTestL(2); |
|
1915 break; |
|
1916 |
|
1917 /** |
|
1918 @SYMTestCaseID GRAPHICS-WSERV-0403 |
|
1919 |
|
1920 @SYMDEF DEF098704 |
|
1921 |
|
1922 @SYMTestCaseDesc Test code for implemented fix to remove double cursors |
|
1923 |
|
1924 @SYMTestPriority Normal |
|
1925 |
|
1926 @SYMTestStatus Implemented |
|
1927 |
|
1928 @SYMTestActions This test moves a flashing cursor a number of times over a two second period to a seconds position. |
|
1929 it does it a number of times so some of the redraws will occur during the 'flash off' period |
|
1930 We then compare the 'after' position to what we expect |
|
1931 |
|
1932 @SYMTestExpectedResults |
|
1933 */ |
|
1934 case 11: |
|
1935 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0403")); |
|
1936 iTest->LogSubTest(_L("Double cursors test 3")); |
|
1937 StartDoubleCursorTestL(3); |
|
1938 break; |
|
1939 |
|
1940 /** |
|
1941 @SYMTestCaseID GRAPHICS-WSERV-0483 |
|
1942 |
|
1943 @SYMDEF INC117232 |
|
1944 |
|
1945 @SYMTestCaseDesc Test code: Refreshing cursors becoming offscreen due to screen size change should not panic |
|
1946 |
|
1947 @SYMTestPriority Normal |
|
1948 |
|
1949 @SYMTestStatus Implemented |
|
1950 |
|
1951 @SYMTestActions Create a cursor on bottom right of screen, change to a screen mode that excludes that coordinate |
|
1952 |
|
1953 @SYMTestExpectedResults |
|
1954 The server should not panic. |
|
1955 */ |
|
1956 case 12: |
|
1957 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0483")); |
|
1958 iTest->LogSubTest(_L("Screen resize invalidate cursor off-screen")); |
|
1959 INC117232(); |
|
1960 break; |
|
1961 |
|
1962 /** |
|
1963 @SYMTestCaseID GRAPHICS-WSERV-2095-0016 |
|
1964 |
|
1965 @SYMTestCaseDesc Text Cursor flag TTextCursor::EFlagNoFlash honored |
|
1966 |
|
1967 @SYMTestPriority Normal |
|
1968 |
|
1969 @SYMTestStatus Implemented |
|
1970 |
|
1971 @SYMTestActions Create a text cursor with the TTextCursor::EFlagNoFlash setting. Observe the screen over |
|
1972 a short period of time to verify that it remains continuously in the Flash ON state. |
|
1973 |
|
1974 @SYMTestExpectedResults |
|
1975 The text cursor should be always shown. |
|
1976 */ |
|
1977 case 13: |
|
1978 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA |
|
1979 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-2095-0016")); |
|
1980 iTest->LogSubTest(_L("Text cursor EFlagNoFlash test")); |
|
1981 TextCursorNoFlashTestL(); |
|
1982 #endif |
|
1983 break; |
|
1984 |
|
1985 /** |
|
1986 @SYMTestCaseID GRAPHICS-WSERV-2095-0009 |
|
1987 |
|
1988 @SYMTestCaseDesc Text Cursor flashes when flag value is 0 |
|
1989 |
|
1990 @SYMTestPriority Normal |
|
1991 |
|
1992 @SYMTestStatus Implemented |
|
1993 |
|
1994 @SYMTestActions Create a text cursor with the 0 flag setting. Observe the screen over |
|
1995 a short period of time to verify that the cursor flashes ON and OFF at |
|
1996 the correct period of one second. |
|
1997 |
|
1998 @SYMTestExpectedResults |
|
1999 The text cursor should flash. |
|
2000 */ |
|
2001 case 14: |
|
2002 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA |
|
2003 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-2095-0009")); |
|
2004 iTest->LogSubTest(_L("Text cursor will Flash test")); |
|
2005 TextCursorFlashTestL(); |
|
2006 #endif |
|
2007 break; |
|
2008 |
|
2009 /** |
|
2010 @SYMTestCaseID GRAPHICS-WSERV-2095-0017 |
|
2011 |
|
2012 @SYMTestCaseDesc Text Cursor handles different valid Cursor Setttings |
|
2013 |
|
2014 @SYMTestPriority Normal |
|
2015 |
|
2016 @SYMTestStatus Implemented |
|
2017 |
|
2018 @SYMTestActions Create a text cursor and then issue a SetTextCursor. Then repeatedly |
|
2019 call SetTextCursor, varying the arguments relating to the Text Cursor |
|
2020 as well as keeping the arguments the same on one occassion. |
|
2021 |
|
2022 @SYMTestExpectedResults |
|
2023 The system should not panic as the arguments supplied are never invalid. |
|
2024 */ |
|
2025 case 15: |
|
2026 ((CTCursorTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-2095-0017")); |
|
2027 iTest->LogSubTest(_L("SetTextCursor test")); |
|
2028 TextCursorSetLCoverageTests(); |
|
2029 break; |
|
2030 |
|
2031 default: |
|
2032 ((CTCursorTestStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); |
|
2033 ((CTCursorTestStep*)iStep)->CloseTMSGraphicsStep(); |
|
2034 TestComplete(); |
|
2035 break; |
|
2036 } |
|
2037 ((CTCursorTestStep*)iStep)->RecordTestResultL(); |
|
2038 } |
|
2039 |
|
2040 __WS_CONSTRUCT_STEP__(CursorTest) |