Symaptic: os/graphics/windowing/windowserver/test/tauto/twindowsizecache.cpp@260cb5ec6c19

     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 // General window tests

    15 //

    16 //

    18 /**

    19  @file

    20  @test

    21  @internalComponent - Internal Symbian test code

    22 */

    24 #include "twindowsizecache.h"

    26 CTWindowSizeCacheTest::CTWindowSizeCacheTest(CTestStep* aStep) : CTWsGraphicsBase(aStep)

    27     {}

    29 CTWindowSizeCacheTest::~CTWindowSizeCacheTest()

    30     {

    31     }

    33 void CTWindowSizeCacheTest::ConstructL()

    34     {}

    37 void CTWindowSizeCacheTest::TestCreateRWindowL(TSizeCacheStatus aEnableWindowSizeCache)

    38     {

    39     __UHEAP_MARK;

    40     // w* State Initial

    41     RWsSession rws;

    42     TInt err = rws.Connect();

    43     CleanupClosePushL(rws);

    44     TEST(KErrNone == err);

    46     if (ETestSizeCacheEnabled == aEnableWindowSizeCache)

    47         {

    48         rws.EnableWindowSizeCacheL();

    49         }

    51     RWindowGroup wg(rws);

    52     err = wg.Construct(0);

    53     CleanupClosePushL(wg);

    54     TEST(KErrNone == err);

    56     // w1 State 0

    57     RWindow w1(rws);

    58     err = w1.Construct(wg,1);

    59     CleanupClosePushL(w1);

    60     TEST(KErrNone == err);

    62     // w2 State 0

    63     RWindow w2(rws);

    64     err = w2.Construct(wg,2);

    65     CleanupClosePushL(w2);

    66     TEST(KErrNone == err);

    68     CleanupStack::Pop(2);

    70     // w1 State Final

    71     w1.Close();

    72     // w2 State Final

    73     w2.Close();

    75     RWindow w3(rws);

    76     // w3 State 0

    77     err = w3.Construct(wg,1);

    78     CleanupClosePushL(w3);

    79     TEST(KErrNone == err);

    81     CleanupStack::Pop(2);

    83     // w3 State Final

    84     w3.Close();

    86     wg.Close();

    88     RWindowGroup wg2(rws);

    89     err = wg2.Construct(0);

    90     CleanupClosePushL(wg2);

    91     TEST(KErrNone == err);

    93     RWindowGroup wg3(rws);

    94     err = wg3.Construct(1);

    95     CleanupClosePushL(wg3);

    96     TEST(KErrNone == err);

    98     // w4 State 0

    99     RWindow w4(rws);

   100     err = w4.Construct(wg2,2);

   101     CleanupClosePushL(w4);

   102     TEST(KErrNone == err);

   104     // w5 State 0

   105     RWindow w5(rws);

   106     err = w5.Construct(wg3,3);

   107     CleanupClosePushL(w5);

   108     TEST(KErrNone == err);

   110     CleanupStack::Pop(5);

   112     // w4 State Final

   113     w4.Close();

   115     // w5 State Final

   116     // Check nothing bad happens when calling Close more than once on RWindow

   117     w5.Close();

   118     w5.Close();

   120     // Check nothing bad happens when calling Close more than once on RWindowGroup

   121     wg2.Close();

   122     wg2.Close();

   124     wg3.Close();

   126     // Check nothing bad happens when calling Close more than once on RWsSession

   127     rws.Close();

   128     rws.Close();

   129     __UHEAP_MARKEND;

   130     }

   132 void CTWindowSizeCacheTest::TestCreateRBlankWindowL(TSizeCacheStatus aEnableWindowSizeCache)

   133     {

   134     __UHEAP_MARK;

   135     // w* State Initial

   136     RWsSession rws;

   137     TInt err = rws.Connect();

   138     CleanupClosePushL(rws);

   139     TEST(KErrNone == err);

   141     if (ETestSizeCacheEnabled == aEnableWindowSizeCache)

   142         {

   143         rws.EnableWindowSizeCacheL();

   144         }

   146     RWindowGroup wg(rws);

   147     err = wg.Construct(0);

   148     CleanupClosePushL(wg);

   149     TEST(KErrNone == err);

   151     // w1 State 0

   152     RBlankWindow w1(rws);

   153     err = w1.Construct(wg,1);

   154     CleanupClosePushL(w1);

   155     TEST(KErrNone == err);

   157     // w2 State 0

   158     RBlankWindow w2(rws);

   159     err = w2.Construct(wg,2);

   160     CleanupClosePushL(w2);

   161     TEST(KErrNone == err);

   163     CleanupStack::Pop(2);

   165     // w1 State Final

   166     w1.Close();

   167     // w2 State Final

   168     w2.Close();

   170     RBlankWindow w3(rws);

   171     // w3 State 0

   172     err = w3.Construct(wg,1);

   173     CleanupClosePushL(w3);

   174     TEST(KErrNone == err);

   176     CleanupStack::Pop(2);

   178     // w3 State Final

   179     w3.Close();

   181     wg.Close();

   183     RWindowGroup wg2(rws);

   184     err = wg2.Construct(0);

   185     CleanupClosePushL(wg2);

   186     TEST(KErrNone == err);

   188     RWindowGroup wg3(rws);

   189     err = wg3.Construct(1);

   190     CleanupClosePushL(wg3);

   191     TEST(KErrNone == err);

   193     // w4 State 0

   194     RBlankWindow w4(rws);

   195     err = w4.Construct(wg2,2);

   196     CleanupClosePushL(w4);

   197     TEST(KErrNone == err);

   199     // w5 State 0

   200     RBlankWindow w5(rws);

   201     err = w5.Construct(wg3,3);

   202     CleanupClosePushL(w5);

   203     TEST(KErrNone == err);

   205     CleanupStack::Pop(5);

   207     // w4 State Final

   208     w4.Close();

   210     // w5 State Final

   211     // Check nothing bad happens when calling Close more than once on RBlankWindow

   212     w5.Close();

   213     w5.Close();

   215     wg2.Close();

   216     wg3.Close();

   217     rws.Close();

   218     __UHEAP_MARKEND;

   219     }

   221 void CTWindowSizeCacheTest::TestCreateRBackedUpWindowL(TSizeCacheStatus aEnableWindowSizeCache, TDisplayMode aDisplayMode)

   222     {

   223     __UHEAP_MARK;

   224     // w* State Initial

   225     RWsSession rws;

   226     TInt err = rws.Connect();

   227     CleanupClosePushL(rws);

   228     TEST(KErrNone == err);

   230     if (ETestSizeCacheEnabled == aEnableWindowSizeCache)

   231         {

   232         rws.EnableWindowSizeCacheL();

   233         }

   235     RWindowGroup wg(rws);

   236     err = wg.Construct(0);

   237     CleanupClosePushL(wg);

   238     TEST(KErrNone == err);

   240     // w1 State 0

   241     RBackedUpWindow w1(rws);

   242     err = w1.Construct(wg,aDisplayMode,1);

   243     CleanupClosePushL(w1);

   244     TEST(KErrNone == err);

   246     // w2 State 0

   247     RBackedUpWindow w2(rws);

   248     err = w2.Construct(wg,aDisplayMode,2);

   249     CleanupClosePushL(w2);

   250     TEST(KErrNone == err);

   252     CleanupStack::Pop(2);

   254     // w1 State Final

   255     w1.Close();

   257     // w2 State Final

   258     w2.Close();

   260     RBackedUpWindow w3(rws);

   261     // w3 State 0

   262     err = w3.Construct(wg,aDisplayMode,1);

   263     CleanupClosePushL(w3);

   264     TEST(KErrNone == err);

   266     CleanupStack::Pop(2);

   268     // w3 State Final

   269     w3.Close();

   271     wg.Close();

   273     RWindowGroup wg2(rws);

   274     CleanupClosePushL(wg2);

   275     err = wg2.Construct(0);

   276     TEST(KErrNone == err);

   278     RWindowGroup wg3(rws);

   279     err = wg3.Construct(1);

   280     CleanupClosePushL(wg3);

   281     TEST(KErrNone == err);

   283     // w4 State 0

   284     RBackedUpWindow w4(rws);

   285     err = w4.Construct(wg2,aDisplayMode,2);

   286     CleanupClosePushL(w4);

   287     TEST(KErrNone == err);

   289     // w5 State 0

   290     RBackedUpWindow w5(rws);

   291     err = w5.Construct(wg3,aDisplayMode,3);

   292     CleanupClosePushL(w5);

   293     TEST(KErrNone == err);

   295     CleanupStack::Pop(5);

   297     // w4 State Final

   298     w4.Close();

   300     // w5 State Final

   301     // Check nothing bad happens when calling Close more than once on RBackedUpWindow

   302     w5.Close();

   303     w5.Close();

   305     wg2.Close();

   306     wg3.Close();

   307     rws.Close();

   308     __UHEAP_MARKEND;

   309     }

   311 void CTWindowSizeCacheTest::TestRWindowNoCacheEntryL(TSizeCacheStatus aEnableWindowSizeCache)

   312     {

   313     __UHEAP_MARK;

   314     // w* State Initial

   315     RWsSession rws;

   316     TInt err = rws.Connect();

   317     CleanupClosePushL(rws);

   318     TEST(err==KErrNone);

   320     if (aEnableWindowSizeCache)

   321         {

   322         rws.EnableWindowSizeCacheL();

   323         }

   325     RWindowGroup wg(rws);

   326     wg.Construct(0);

   327     CleanupClosePushL(rws);

   329     // w1 State 0

   330     RWindow w1(rws);

   331     w1.Construct(wg,1);

   332     CleanupClosePushL(w1);

   334     // w1 State Final

   335     CleanupStack::Pop();

   336     w1.Close();

   338     CleanupStack::Pop();

   339     wg.Close();

   341     CleanupStack::Pop();

   342     rws.Close();

   344     __UHEAP_MARKEND;

   345     }

   347 void CTWindowSizeCacheTest::TestRWindowNoCacheEntrySetExtentErrL(TSizeCacheStatus aEnableWindowSizeCache)

   348     {

   349     __UHEAP_MARK;

   350     // w* State Initial

   351     RWsSession rws;

   352     TInt err = rws.Connect();

   353     CleanupClosePushL(rws);

   354     TEST(err==KErrNone);

   356     if (aEnableWindowSizeCache)

   357         {

   358         rws.EnableWindowSizeCacheL();

   359         }

   361     RWindowGroup wg(rws);

   362     wg.Construct(0);

   363     CleanupClosePushL(rws);

   365     // w1 State 0

   366     RWindow w1(rws);

   367     w1.Construct(wg,1);

   368     CleanupClosePushL(w1);

   370     // w1 State 0

   371     TPoint point1 (10101,897);

   372     TSize size1 (10001,123);

   373     err = w1.SetExtentErr(point1, size1);

   374     TEST(KErrNone == err);

   376     // w1 State Final

   377     CleanupStack::Pop();

   378     w1.Close();

   380     CleanupStack::Pop();

   381     wg.Close();

   383     CleanupStack::Pop();

   384     rws.Close();

   386     __UHEAP_MARKEND;

   387     }

   389 void CTWindowSizeCacheTest::TestRWindowNoCacheEntrySetSizeErrL(TSizeCacheStatus aEnableWindowSizeCache)

   390     {

   391     __UHEAP_MARK;

   392     // w* State Initial

   393     RWsSession rws;

   394     TInt err = rws.Connect();

   395     CleanupClosePushL(rws);

   396     TEST(err==KErrNone);

   398     if (aEnableWindowSizeCache)

   399         {

   400         rws.EnableWindowSizeCacheL();

   401         }

   403     RWindowGroup wg(rws);

   404     wg.Construct(0);

   405     CleanupClosePushL(rws);

   407     // w1 State 0

   408     RWindow w1(rws);

   409     w1.Construct(wg,1);

   410     CleanupClosePushL(w1);

   412     // w1 State 0

   413     TSize size1 (10001,123);

   414     err = w1.SetSizeErr(size1);

   415     TEST(KErrNone == err);

   417     // w1 State Final

   418     CleanupStack::Pop();

   419     w1.Close();

   421     CleanupStack::Pop();

   422     wg.Close();

   424     CleanupStack::Pop();

   425     rws.Close();

   427     __UHEAP_MARKEND;

   428     }

   430 void CTWindowSizeCacheTest::TestRWindowNoCacheEntrySetExtentL(TSizeCacheStatus aEnableWindowSizeCache)

   431     {

   432     __UHEAP_MARK;

   433     // w* State Initial

   434     RWsSession rws;

   435     TInt err = rws.Connect();

   436     CleanupClosePushL(rws);

   437     TEST(err==KErrNone);

   439     if (aEnableWindowSizeCache)

   440         {

   441         rws.EnableWindowSizeCacheL();

   442         }

   444     RWindowGroup wg(rws);

   445     wg.Construct(0);

   446     CleanupClosePushL(rws);

   448     // w1 State 0

   449     RWindow w1(rws);

   450     w1.Construct(wg,1);

   451     CleanupClosePushL(w1);

   453     // w1 State 0

   454     TPoint point1 (10101,897);

   455     TSize size1 (10001,123);

   456     w1.SetExtent(point1, size1);

   457     rws.Flush();

   459     // w1 State Final

   460     CleanupStack::Pop();

   461     w1.Close();

   463     CleanupStack::Pop();

   464     wg.Close();

   466     CleanupStack::Pop();

   467     rws.Close();

   469     __UHEAP_MARKEND;

   470     }

   472 void CTWindowSizeCacheTest::TestRWindowNoCacheEntrySetSizeL(TSizeCacheStatus aEnableWindowSizeCache)

   473     {

   474     __UHEAP_MARK;

   475     // w* State Initial

   476     RWsSession rws;

   477     TInt err = rws.Connect();

   478     CleanupClosePushL(rws);

   479     TEST(err==KErrNone);

   481     if (aEnableWindowSizeCache)

   482         {

   483         rws.EnableWindowSizeCacheL();

   484         }

   486     RWindowGroup wg(rws);

   487     wg.Construct(0);

   488     CleanupClosePushL(rws);

   490     // w1 State 0

   491     RWindow w1(rws);

   492     w1.Construct(wg,1);

   493     CleanupClosePushL(w1);

   495     // w1 State 0

   496     TSize size1 (10001,123);

   497     w1.SetSize(size1);

   498     rws.Flush();

   500     // w1 State Final

   501     CleanupStack::Pop();

   502     w1.Close();

   504     CleanupStack::Pop();

   505     wg.Close();

   507     CleanupStack::Pop();

   508     rws.Close();

   510     __UHEAP_MARKEND;

   511     }

   513 void CTWindowSizeCacheTest::TestRWindowNoCacheEntryEnableWindowSizeCacheL()

   514     {

   515     __UHEAP_MARK;

   516     // w* State Initial

   517     RWsSession rws;

   518     TInt err = rws.Connect();

   519     CleanupClosePushL(rws);

   520     TEST(err==KErrNone);

   522     rws.EnableWindowSizeCacheL();

   524     RWindowGroup wg(rws);

   525     wg.Construct(0);

   526     CleanupClosePushL(rws);

   528     // w1 State 0

   529     RWindow w1(rws);

   530     w1.Construct(wg,1);

   531     CleanupClosePushL(w1);

   533     // w1 State 0

   534     // Only the first call to EnableWindowSizeCacheL() should have an effect

   535     // All subsequent calls to EnableWindowSizeCacheL() should have no effect

   536     rws.EnableWindowSizeCacheL();

   538     // w1 State Final

   539     CleanupStack::Pop();

   540     w1.Close();

   542     CleanupStack::Pop();

   543     wg.Close();

   545     CleanupStack::Pop();

   546     rws.Close();

   548     __UHEAP_MARKEND;

   549     }

   551 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheCleanL(TSizeCacheStatus aEnableWindowSizeCache)

   552     {

   553     __UHEAP_MARK;

   554     // w* State Initial

   555     RWsSession rws;

   556     TInt err = rws.Connect();

   557     CleanupClosePushL(rws);

   558     TEST(err==KErrNone);

   560     if (aEnableWindowSizeCache)

   561         {

   562         rws.EnableWindowSizeCacheL();

   563         }

   565     RWindowGroup wg(rws);

   566     wg.Construct(0);

   567     CleanupClosePushL(rws);

   569     // w1 State 0

   570     RWindow w1(rws);

   571     w1.Construct(wg,1);

   572     CleanupClosePushL(w1);

   574     // w1 State 0

   575     TSize size1 (10001,123);

   576     w1.SetSize(size1);

   577     rws.Flush();

   579     // w1 State 1

   580     TSize retSize1 = w1.Size();

   581     TEST(retSize1 == size1);

   583     // w1 State Final

   584     CleanupStack::Pop();

   585     w1.Close();

   587     CleanupStack::Pop();

   588     wg.Close();

   590     CleanupStack::Pop();

   591     rws.Close();

   593     __UHEAP_MARKEND;

   594     }

   596 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheCleanSizeL(TSizeCacheStatus aEnableWindowSizeCache)

   597     {

   598     __UHEAP_MARK;

   599     // w* State Initial

   600     RWsSession rws;

   601     TInt err = rws.Connect();

   602     CleanupClosePushL(rws);

   603     TEST(err==KErrNone);

   605     if (aEnableWindowSizeCache)

   606         {

   607         rws.EnableWindowSizeCacheL();

   608         }

   610     RWindowGroup wg(rws);

   611     wg.Construct(0);

   612     CleanupClosePushL(rws);

   614     // w1 State 0

   615     RWindow w1(rws);

   616     w1.Construct(wg,1);

   617     CleanupClosePushL(w1);

   619     // w1 State 0

   620     TSize size1 (10001,123);

   621     w1.SetSize(size1);

   622     rws.Flush();

   624     // w1 State 1

   625     TSize retSize1 = w1.Size();

   626     TEST(retSize1 == size1);

   628     // w1 State 1

   629     TSize retSize2 = w1.Size();

   630     TEST(retSize2 == size1);

   632     // w1 State Final

   633     CleanupStack::Pop();

   634     w1.Close();

   636     CleanupStack::Pop();

   637     wg.Close();

   639     CleanupStack::Pop();

   640     rws.Close();

   642     __UHEAP_MARKEND;

   643     }

   645 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheCleanEnableWindowSizeCacheL()

   646     {

   647     __UHEAP_MARK;

   648     // w* State Initial

   649     RWsSession rws;

   650     TInt err = rws.Connect();

   651     CleanupClosePushL(rws);

   652     TEST(err==KErrNone);

   654     rws.EnableWindowSizeCacheL();

   656     RWindowGroup wg(rws);

   657     wg.Construct(0);

   658     CleanupClosePushL(rws);

   660     // w1 State 0

   661     RWindow w1(rws);

   662     w1.Construct(wg,1);

   663     CleanupClosePushL(w1);

   665     // w1 State 0

   666     TSize size1 (10001,123);

   667     w1.SetSize(size1);

   668     rws.Flush();

   670     // w1 State 1

   671     TSize retSize1 = w1.Size();

   672     TEST(retSize1 == size1);

   674     // w1 State 1

   675     // Only the first call to EnableWindowSizeCacheL() should have an effect

   676     // All subsequent calls to EnableWindowSizeCacheL() should have no effect

   677     rws.EnableWindowSizeCacheL();

   679     // w1 State Final

   680     CleanupStack::Pop();

   681     w1.Close();

   683     CleanupStack::Pop();

   684     wg.Close();

   686     CleanupStack::Pop();

   687     rws.Close();

   689     __UHEAP_MARKEND;

   690     }

   692 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheCleanEnableWindowSizeCacheLSizeL()

   693     {

   694     __UHEAP_MARK;

   695     // w* State Initial

   696     RWsSession rws;

   697     TInt err = rws.Connect();

   698     CleanupClosePushL(rws);

   699     TEST(err==KErrNone);

   701     rws.EnableWindowSizeCacheL();

   703     RWindowGroup wg(rws);

   704     wg.Construct(0);

   705     CleanupClosePushL(rws);

   707     // w1 State 0

   708     RWindow w1(rws);

   709     w1.Construct(wg,1);

   710     CleanupClosePushL(w1);

   712     // w1 State 0

   713     TSize size1 (10001,123);

   714     w1.SetSize(size1);

   715     rws.Flush();

   717     // w1 State 1

   718     TSize retSize1 = w1.Size();

   719     TEST(retSize1 == size1);

   721     // w1 State 1

   722     // Only the first call to EnableWindowSizeCacheL() should have an effect

   723     // All subsequent calls to EnableWindowSizeCacheL() should have no effect

   724     rws.EnableWindowSizeCacheL();

   726     // w1 State 1

   727     TSize retSize2 = w1.Size();

   728     TEST(retSize2 == size1);

   730     // w1 State Final

   731     CleanupStack::Pop();

   732     w1.Close();

   734     CleanupStack::Pop();

   735     wg.Close();

   737     CleanupStack::Pop();

   738     rws.Close();

   740     __UHEAP_MARKEND;

   741     }

   743 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeL(TSizeCacheStatus aEnableWindowSizeCache)

   744     {

   745     __UHEAP_MARK;

   746     // w* State Initial

   747     RWsSession rws;

   748     TInt err = rws.Connect();

   749     CleanupClosePushL(rws);

   750     TEST(err==KErrNone);

   752     if (aEnableWindowSizeCache)

   753         {

   754         rws.EnableWindowSizeCacheL();

   755         }

   757     RWindowGroup wg(rws);

   758     wg.Construct(0);

   759     CleanupClosePushL(rws);

   761     // w1 State 0

   762     RWindow w1(rws);

   763     w1.Construct(wg,1);

   764     CleanupClosePushL(w1);

   766     // w1 State 0

   767     TSize size1 (10001,123);

   768     w1.SetSize(size1);

   769     rws.Flush();

   771     // w1 State 1

   772     TSize retSize1 = w1.Size();

   773     TEST(retSize1 == size1);

   775     // w1 State 2

   776     TSize size2 (20002,223);

   777     w1.SetSize(size2);

   778     rws.Flush();

   780     // w1 State Final

   781     CleanupStack::Pop();

   782     w1.Close();

   784     CleanupStack::Pop();

   785     wg.Close();

   787     CleanupStack::Pop();

   788     rws.Close();

   790     __UHEAP_MARKEND;

   791     }

   793 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetExtentL(TSizeCacheStatus aEnableWindowSizeCache)

   794     {

   795     __UHEAP_MARK;

   796     // w* State Initial

   797     RWsSession rws;

   798     TInt err = rws.Connect();

   799     CleanupClosePushL(rws);

   800     TEST(err==KErrNone);

   802     if (aEnableWindowSizeCache)

   803         {

   804         rws.EnableWindowSizeCacheL();

   805         }

   807     RWindowGroup wg(rws);

   808     wg.Construct(0);

   809     CleanupClosePushL(rws);

   811     // w1 State 0

   812     RWindow w1(rws);

   813     w1.Construct(wg,1);

   814     CleanupClosePushL(w1);

   816     // w1 State 0

   817     TSize size1 (10001,123);

   818     w1.SetSize(size1);

   819     rws.Flush();

   821     // w1 State 1

   822     TSize retSize1 = w1.Size();

   823     TEST(retSize1 == size1);

   825     // w1 State 2

   826     TPoint point2 (20202,223);

   827     TSize size2 (20002,223);

   828     w1.SetExtent(point2, size2);

   829     rws.Flush();

   831     // w1 State Final

   832     CleanupStack::Pop();

   833     w1.Close();

   835     CleanupStack::Pop();

   836     wg.Close();

   838     CleanupStack::Pop();

   839     rws.Close();

   841     __UHEAP_MARKEND;

   842     }

   844 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeErrL(TSizeCacheStatus aEnableWindowSizeCache)

   845     {

   846     __UHEAP_MARK;

   847     // w* State Initial

   848     RWsSession rws;

   849     TInt err = rws.Connect();

   850     CleanupClosePushL(rws);

   851     TEST(err==KErrNone);

   853     if (aEnableWindowSizeCache)

   854         {

   855         rws.EnableWindowSizeCacheL();

   856         }

   858     RWindowGroup wg(rws);

   859     wg.Construct(0);

   860     CleanupClosePushL(rws);

   862     // w1 State 0

   863     RWindow w1(rws);

   864     w1.Construct(wg,1);

   865     CleanupClosePushL(w1);

   867     // w1 State 0

   868     TSize size1 (10001,123);

   869     w1.SetSize(size1);

   870     rws.Flush();

   872     // w1 State 1

   873     TSize retSize1 = w1.Size();

   874     TEST(retSize1 == size1);

   876     // w1 State 2

   877     TSize size2 (20002,223);

   878     err = w1.SetSizeErr(size2);

   879     TEST(KErrNone == err);

   881     // w1 State Final

   882     CleanupStack::Pop();

   883     w1.Close();

   885     CleanupStack::Pop();

   886     wg.Close();

   888     CleanupStack::Pop();

   889     rws.Close();

   891     __UHEAP_MARKEND;

   892     }

   894 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetExtentErrL(TSizeCacheStatus aEnableWindowSizeCache)

   895     {

   896     __UHEAP_MARK;

   897     // w* State Initial

   898     RWsSession rws;

   899     TInt err = rws.Connect();

   900     CleanupClosePushL(rws);

   901     TEST(err==KErrNone);

   903     if (aEnableWindowSizeCache)

   904         {

   905         rws.EnableWindowSizeCacheL();

   906         }

   908     RWindowGroup wg(rws);

   909     wg.Construct(0);

   910     CleanupClosePushL(rws);

   912     // w1 State 0

   913     RWindow w1(rws);

   914     w1.Construct(wg,1);

   915     CleanupClosePushL(w1);

   917     // w1 State 0

   918     TSize size1 (10001,123);

   919     w1.SetSize(size1);

   920     rws.Flush();

   922     // w1 State 1

   923     TSize retSize1 = w1.Size();

   924     TEST(retSize1 == size1);

   926     // w1 State 2

   927     TPoint point2 (20202,223);

   928     TSize size2 (20002,223);

   929     err = w1.SetExtentErr(point2, size2);

   930     TEST(KErrNone == err);

   932     // w1 State Final

   933     CleanupStack::Pop();

   934     w1.Close();

   936     CleanupStack::Pop();

   937     wg.Close();

   939     CleanupStack::Pop();

   940     rws.Close();

   942     __UHEAP_MARKEND;

   943     }

   945 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeTwiceL(TSizeCacheStatus aEnableWindowSizeCache)

   946     {

   947     __UHEAP_MARK;

   948     // w* State Initial

   949     RWsSession rws;

   950     TInt err = rws.Connect();

   951     CleanupClosePushL(rws);

   952     TEST(err==KErrNone);

   954     if (aEnableWindowSizeCache)

   955         {

   956         rws.EnableWindowSizeCacheL();

   957         }

   959     RWindowGroup wg(rws);

   960     wg.Construct(0);

   961     CleanupClosePushL(rws);

   963     // w1 State 0

   964     RWindow w1(rws);

   965     w1.Construct(wg,1);

   966     CleanupClosePushL(w1);

   968     // w1 State 0

   969     TSize size1 (10001,123);

   970     w1.SetSize(size1);

   971     rws.Flush();

   973     // w1 State 1

   974     TSize retSize1 = w1.Size();

   975     TEST(retSize1 == size1);

   977     // w1 State 2

   978     TSize size2 (20002,223);

   979     w1.SetSize(size2);

   981     TSize size3 (30003,323);

   982     // w1 State 2

   983     w1.SetSize(size3);

   984     rws.Flush();

   986     // w1 State Final

   987     CleanupStack::Pop();

   988     w1.Close();

   990     CleanupStack::Pop();

   991     wg.Close();

   993     CleanupStack::Pop();

   994     rws.Close();

   996     __UHEAP_MARKEND;

   997     }

   999 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeSetExtentL(TSizeCacheStatus aEnableWindowSizeCache)

  1000     {

  1001     __UHEAP_MARK;

  1002     // w* State Initial

  1003     RWsSession rws;

  1004     TInt err = rws.Connect();

  1005     CleanupClosePushL(rws);

  1006     TEST(err==KErrNone);

  1008     if (aEnableWindowSizeCache)

  1009         {

  1010         rws.EnableWindowSizeCacheL();

  1011         }

  1013     RWindowGroup wg(rws);

  1014     wg.Construct(0);

  1015     CleanupClosePushL(rws);

  1017     // w1 State 0

  1018     RWindow w1(rws);

  1019     w1.Construct(wg,1);

  1020     CleanupClosePushL(w1);

  1022     // w1 State 0

  1023     TSize size1 (10001,123);

  1024     w1.SetSize(size1);

  1025     rws.Flush();

  1027     // w1 State 1

  1028     TSize retSize1 = w1.Size();

  1029     TEST(retSize1 == size1);

  1031     // w1 State 2

  1032     TSize size2 (20002,223);

  1033     w1.SetSize(size2);

  1035     // w1 State 2

  1036     TPoint point3 (30303,232);

  1037     TSize size3 (30003,323);

  1038     w1.SetExtent(point3, size3);

  1039     rws.Flush();

  1041     // w1 State Final

  1042     CleanupStack::Pop();

  1043     w1.Close();

  1045     CleanupStack::Pop();

  1046     wg.Close();

  1048     CleanupStack::Pop();

  1049     rws.Close();

  1051     __UHEAP_MARKEND;

  1052     }

  1054 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeSetSizeErrL(TSizeCacheStatus aEnableWindowSizeCache)

  1055     {

  1056     __UHEAP_MARK;

  1057     // w* State Initial

  1058     RWsSession rws;

  1059     TInt err = rws.Connect();

  1060     CleanupClosePushL(rws);

  1061     TEST(err==KErrNone);

  1063     if (aEnableWindowSizeCache)

  1064         {

  1065         rws.EnableWindowSizeCacheL();

  1066         }

  1068     RWindowGroup wg(rws);

  1069     wg.Construct(0);

  1070     CleanupClosePushL(rws);

  1072     // w1 State 0

  1073     RWindow w1(rws);

  1074     w1.Construct(wg,1);

  1075     CleanupClosePushL(w1);

  1077     // w1 State 0

  1078     TSize size1 (10001,123);

  1079     w1.SetSize(size1);

  1080     rws.Flush();

  1082     // w1 State 1

  1083     TSize retSize1 = w1.Size();

  1084     TEST(retSize1 == size1);

  1086     // w1 State 2

  1087     TSize size2 (20002,223);

  1088     w1.SetSize(size2);

  1090     // w1 State 2

  1091     TSize size3 (30003,323);

  1092     err = w1.SetSizeErr(size3);

  1093     TEST(KErrNone == err);

  1095     // w1 State Final

  1096     CleanupStack::Pop();

  1097     w1.Close();

  1099     CleanupStack::Pop();

  1100     wg.Close();

  1102     CleanupStack::Pop();

  1103     rws.Close();

  1105     __UHEAP_MARKEND;

  1106     }

  1108 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeSetExtentErrL(TSizeCacheStatus aEnableWindowSizeCache)

  1109     {

  1110     __UHEAP_MARK;

  1111     // w* State Initial

  1112     RWsSession rws;

  1113     TInt err = rws.Connect();

  1114     CleanupClosePushL(rws);

  1115     TEST(err==KErrNone);

  1117     if (aEnableWindowSizeCache)

  1118         {

  1119         rws.EnableWindowSizeCacheL();

  1120         }

  1122     RWindowGroup wg(rws);

  1123     wg.Construct(0);

  1124     CleanupClosePushL(rws);

  1126     // w1 State 0

  1127     RWindow w1(rws);

  1128     w1.Construct(wg,1);

  1129     CleanupClosePushL(w1);

  1131     // w1 State 0

  1132     TSize size1 (10001,123);

  1133     w1.SetSize(size1);

  1134     rws.Flush();

  1136     // w1 State 1

  1137     TSize retSize1 = w1.Size();

  1138     TEST(retSize1 == size1);

  1140     // w1 State 2

  1141     TSize size2 (20002,223);

  1142     w1.SetSize(size2);

  1144     // w1 State 2

  1145     TPoint point3 (30303,232);

  1146     TSize size3 (30003,323);

  1147     err = w1.SetExtentErr(point3, size3);

  1148     TEST(KErrNone == err);

  1150     // w1 State Final

  1151     CleanupStack::Pop();

  1152     w1.Close();

  1154     CleanupStack::Pop();

  1155     wg.Close();

  1157     CleanupStack::Pop();

  1158     rws.Close();

  1160     __UHEAP_MARKEND;

  1161     }

  1163 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeEnableWindowSizeCacheL()

  1164     {

  1165     __UHEAP_MARK;

  1166     // w* State Initial

  1167     RWsSession rws;

  1168     TInt err = rws.Connect();

  1169     CleanupClosePushL(rws);

  1170     TEST(err==KErrNone);

  1172     rws.EnableWindowSizeCacheL();

  1174     RWindowGroup wg(rws);

  1175     wg.Construct(0);

  1176     CleanupClosePushL(rws);

  1178     // w1 State 0

  1179     RWindow w1(rws);

  1180     w1.Construct(wg,1);

  1181     CleanupClosePushL(w1);

  1183     // w1 State 0

  1184     TSize size1 (10001,123);

  1185     w1.SetSize(size1);

  1186     rws.Flush();

  1188     // w1 State 1

  1189     TSize retSize1 = w1.Size();

  1190     TEST(retSize1 == size1);

  1192     // w1 State 2

  1193     TSize size2 (20002,223);

  1194     w1.SetSize(size2);

  1196     // Only the first call to EnableWindowSizeCacheL() should have an effect

  1197     // All subsequent calls to EnableWindowSizeCacheL() should have no effect

  1198     rws.EnableWindowSizeCacheL();

  1200     // w1 State Final

  1201     CleanupStack::Pop();

  1202     w1.Close();

  1204     CleanupStack::Pop();

  1205     wg.Close();

  1207     CleanupStack::Pop();

  1208     rws.Close();

  1210     __UHEAP_MARKEND;

  1211     }

  1213 //-------------------------------------------------------------------------------------------

  1214 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeL(TSizeCacheStatus aEnableWindowSizeCache)

  1215     {

  1216     __UHEAP_MARK;

  1217     // w* State Initial

  1218     RWsSession rws;

  1219     TInt err = rws.Connect();

  1220     CleanupClosePushL(rws);

  1221     TEST(err==KErrNone);

  1223     if (aEnableWindowSizeCache)

  1224         {

  1225         rws.EnableWindowSizeCacheL();

  1226         }

  1228     RWindowGroup wg(rws);

  1229     wg.Construct(0);

  1230     CleanupClosePushL(rws);

  1232     // w1 State 0

  1233     RWindow w1(rws);

  1234     w1.Construct(wg,1);

  1235     CleanupClosePushL(w1);

  1237     // w1 State 0

  1238     TSize size1 (10001,123);

  1239     w1.SetSize(size1);

  1240     rws.Flush();

  1242     // w1 State 1

  1243     TSize retSize1 = w1.Size();

  1244     TEST(retSize1 == size1);

  1246     // w1 State 2

  1247     TSize size2 (20002,223);

  1248     w1.SetSize(size2);

  1249     rws.Flush();

  1251     // w1 State 1

  1252     TSize retSize2 = w1.Size();

  1253     TEST(retSize2 == size2);

  1255     // w1 State Final

  1256     CleanupStack::Pop();

  1257     w1.Close();

  1259     CleanupStack::Pop();

  1260     wg.Close();

  1262     CleanupStack::Pop();

  1263     rws.Close();

  1265     __UHEAP_MARKEND;

  1266     }

  1268 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetExtentL(TSizeCacheStatus aEnableWindowSizeCache)

  1269     {

  1270     __UHEAP_MARK;

  1271     // w* State Initial

  1272     RWsSession rws;

  1273     TInt err = rws.Connect();

  1274     CleanupClosePushL(rws);

  1275     TEST(err==KErrNone);

  1277     if (aEnableWindowSizeCache)

  1278         {

  1279         rws.EnableWindowSizeCacheL();

  1280         }

  1282     RWindowGroup wg(rws);

  1283     wg.Construct(0);

  1284     CleanupClosePushL(rws);

  1286     // w1 State 0

  1287     RWindow w1(rws);

  1288     w1.Construct(wg,1);

  1289     CleanupClosePushL(w1);

  1291     // w1 State 0

  1292     TSize size1 (10001,123);

  1293     w1.SetSize(size1);

  1294     rws.Flush();

  1296     // w1 State 1

  1297     TSize retSize1 = w1.Size();

  1298     TEST(retSize1 == size1);

  1300     // w1 State 2

  1301     TPoint point2 (20202,223);

  1302     TSize size2 (20002,223);

  1303     w1.SetExtent(point2, size2);

  1304     rws.Flush();

  1306     // w1 State 1

  1307     TSize retSize2 = w1.Size();

  1308     TEST(retSize2 == size2);

  1310     // w1 State Final

  1311     CleanupStack::Pop();

  1312     w1.Close();

  1314     CleanupStack::Pop();

  1315     wg.Close();

  1317     CleanupStack::Pop();

  1318     rws.Close();

  1320     __UHEAP_MARKEND;

  1321     }

  1323 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeErrL(TSizeCacheStatus aEnableWindowSizeCache)

  1324     {

  1325     __UHEAP_MARK;

  1326     // w* State Initial

  1327     RWsSession rws;

  1328     TInt err = rws.Connect();

  1329     CleanupClosePushL(rws);

  1330     TEST(err==KErrNone);

  1332     if (aEnableWindowSizeCache)

  1333         {

  1334         rws.EnableWindowSizeCacheL();

  1335         }

  1337     RWindowGroup wg(rws);

  1338     wg.Construct(0);

  1339     CleanupClosePushL(rws);

  1341     // w1 State 0

  1342     RWindow w1(rws);

  1343     w1.Construct(wg,1);

  1344     CleanupClosePushL(w1);

  1346     // w1 State 0

  1347     TSize size1 (10001,123);

  1348     w1.SetSize(size1);

  1349     rws.Flush();

  1351     // w1 State 1

  1352     TSize retSize1 = w1.Size();

  1353     TEST(retSize1 == size1);

  1355     // w1 State 2

  1356     TSize size2 (20002,223);

  1357     err = w1.SetSizeErr(size2);

  1358     TEST(KErrNone == err);

  1360     // w1 State 1

  1361     TSize retSize2 = w1.Size();

  1362     TEST(retSize2 == size2);

  1364     // w1 State Final

  1365     CleanupStack::Pop();

  1366     w1.Close();

  1368     CleanupStack::Pop();

  1369     wg.Close();

  1371     CleanupStack::Pop();

  1372     rws.Close();

  1374     __UHEAP_MARKEND;

  1375     }

  1377 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetExtentErrL(TSizeCacheStatus aEnableWindowSizeCache)

  1378     {

  1379     __UHEAP_MARK;

  1380     // w* State Initial

  1381     RWsSession rws;

  1382     TInt err = rws.Connect();

  1383     CleanupClosePushL(rws);

  1384     TEST(err==KErrNone);

  1386     if (aEnableWindowSizeCache)

  1387         {

  1388         rws.EnableWindowSizeCacheL();

  1389         }

  1391     RWindowGroup wg(rws);

  1392     wg.Construct(0);

  1393     CleanupClosePushL(rws);

  1395     // w1 State 0

  1396     RWindow w1(rws);

  1397     w1.Construct(wg,1);

  1398     CleanupClosePushL(w1);

  1400     // w1 State 0

  1401     TSize size1 (10001,123);

  1402     w1.SetSize(size1);

  1403     rws.Flush();

  1405     // w1 State 1

  1406     TSize retSize1 = w1.Size();

  1407     TEST(retSize1 == size1);

  1409     // w1 State 2

  1410     TPoint point2 (20202,223);

  1411     TSize size2 (20002,223);

  1412     err = w1.SetExtentErr(point2, size2);

  1413     TEST(KErrNone == err);

  1415     // w1 State 1

  1416     TSize retSize2 = w1.Size();

  1417     TEST(retSize2 == size2);

  1419     // w1 State Final

  1420     CleanupStack::Pop();

  1421     w1.Close();

  1423     CleanupStack::Pop();

  1424     wg.Close();

  1426     CleanupStack::Pop();

  1427     rws.Close();

  1429     __UHEAP_MARKEND;

  1430     }

  1432 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeTwiceL(TSizeCacheStatus aEnableWindowSizeCache)

  1433     {

  1434     __UHEAP_MARK;

  1435     // w* State Initial

  1436     RWsSession rws;

  1437     TInt err = rws.Connect();

  1438     CleanupClosePushL(rws);

  1439     TEST(err==KErrNone);

  1441     if (aEnableWindowSizeCache)

  1442         {

  1443         rws.EnableWindowSizeCacheL();

  1444         }

  1446     RWindowGroup wg(rws);

  1447     wg.Construct(0);

  1448     CleanupClosePushL(rws);

  1450     // w1 State 0

  1451     RWindow w1(rws);

  1452     w1.Construct(wg,1);

  1453     CleanupClosePushL(w1);

  1455     // w1 State 0

  1456     TSize size1 (10001,123);

  1457     w1.SetSize(size1);

  1458     rws.Flush();

  1460     // w1 State 1

  1461     TSize retSize1 = w1.Size();

  1462     TEST(retSize1 == size1);

  1464     // w1 State 2

  1465     TSize size2 (20002,223);

  1466     w1.SetSize(size2);

  1468     TSize size3 (30003,323);

  1469     // w1 State 2

  1470     w1.SetSize(size3);

  1471     rws.Flush();

  1473     // w1 State 1

  1474     TSize retSize2 = w1.Size();

  1475     TEST(retSize2 == size3);

  1477     // w1 State Final

  1478     CleanupStack::Pop();

  1479     w1.Close();

  1481     CleanupStack::Pop();

  1482     wg.Close();

  1484     CleanupStack::Pop();

  1485     rws.Close();

  1487     __UHEAP_MARKEND;

  1488     }

  1490 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetExtentL(TSizeCacheStatus aEnableWindowSizeCache)

  1491     {

  1492     __UHEAP_MARK;

  1493     // w* State Initial

  1494     RWsSession rws;

  1495     TInt err = rws.Connect();

  1496     CleanupClosePushL(rws);

  1497     TEST(err==KErrNone);

  1499     if (aEnableWindowSizeCache)

  1500         {

  1501         rws.EnableWindowSizeCacheL();

  1502         }

  1504     RWindowGroup wg(rws);

  1505     wg.Construct(0);

  1506     CleanupClosePushL(rws);

  1508     // w1 State 0

  1509     RWindow w1(rws);

  1510     w1.Construct(wg,1);

  1511     CleanupClosePushL(w1);

  1513     // w1 State 0

  1514     TSize size1 (10001,123);

  1515     w1.SetSize(size1);

  1516     rws.Flush();

  1518     // w1 State 1

  1519     TSize retSize1 = w1.Size();

  1520     TEST(retSize1 == size1);

  1522     // w1 State 2

  1523     TSize size2 (20002,223);

  1524     w1.SetSize(size2);

  1526     // w1 State 2

  1527     TPoint point3 (30303,232);

  1528     TSize size3 (30003,323);

  1529     w1.SetExtent(point3, size3);

  1530     rws.Flush();

  1532     // w1 State 1

  1533     TSize retSize2 = w1.Size();

  1534     TEST(retSize2 == size3);

  1536     // w1 State Final

  1537     CleanupStack::Pop();

  1538     w1.Close();

  1540     CleanupStack::Pop();

  1541     wg.Close();

  1543     CleanupStack::Pop();

  1544     rws.Close();

  1546     __UHEAP_MARKEND;

  1547     }

  1549 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetSizeErrL(TSizeCacheStatus aEnableWindowSizeCache)

  1550     {

  1551     __UHEAP_MARK;

  1552     // w* State Initial

  1553     RWsSession rws;

  1554     TInt err = rws.Connect();

  1555     CleanupClosePushL(rws);

  1556     TEST(err==KErrNone);

  1558     if (aEnableWindowSizeCache)

  1559         {

  1560         rws.EnableWindowSizeCacheL();

  1561         }

  1563     RWindowGroup wg(rws);

  1564     wg.Construct(0);

  1565     CleanupClosePushL(rws);

  1567     // w1 State 0

  1568     RWindow w1(rws);

  1569     w1.Construct(wg,1);

  1570     CleanupClosePushL(w1);

  1572     // w1 State 0

  1573     TSize size1 (10001,123);

  1574     w1.SetSize(size1);

  1575     rws.Flush();

  1577     // w1 State 1

  1578     TSize retSize1 = w1.Size();

  1579     TEST(retSize1 == size1);

  1581     // w1 State 2

  1582     TSize size2 (20002,223);

  1583     w1.SetSize(size2);

  1585     // w1 State 2

  1586     TSize size3 (30003,323);

  1587     err = w1.SetSizeErr(size3);

  1588     TEST(KErrNone == err);

  1590     // w1 State 1

  1591     TSize retSize2 = w1.Size();

  1592     TEST(retSize2 == size3);

  1594     // w1 State Final

  1595     CleanupStack::Pop();

  1596     w1.Close();

  1598     CleanupStack::Pop();

  1599     wg.Close();

  1601     CleanupStack::Pop();

  1602     rws.Close();

  1604     __UHEAP_MARKEND;

  1605     }

  1607 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetExtentErrL(TSizeCacheStatus aEnableWindowSizeCache)

  1608     {

  1609     __UHEAP_MARK;

  1610     // w* State Initial

  1611     RWsSession rws;

  1612     TInt err = rws.Connect();

  1613     CleanupClosePushL(rws);

  1614     TEST(err==KErrNone);

  1616     if (aEnableWindowSizeCache)

  1617         {

  1618         rws.EnableWindowSizeCacheL();

  1619         }

  1621     RWindowGroup wg(rws);

  1622     wg.Construct(0);

  1623     CleanupClosePushL(rws);

  1625     // w1 State 0

  1626     RWindow w1(rws);

  1627     w1.Construct(wg,1);

  1628     CleanupClosePushL(w1);

  1630     // w1 State 0

  1631     TSize size1 (10001,123);

  1632     w1.SetSize(size1);

  1633     rws.Flush();

  1635     // w1 State 1

  1636     TSize retSize1 = w1.Size();

  1637     TEST(retSize1 == size1);

  1639     // w1 State 2

  1640     TSize size2 (20002,223);

  1641     w1.SetSize(size2);

  1643     // w1 State 2

  1644     TPoint point3 (30303,232);

  1645     TSize size3 (30003,323);

  1646     err = w1.SetExtentErr(point3, size3);

  1647     TEST(KErrNone == err);

  1649     // w1 State 1

  1650     TSize retSize2 = w1.Size();

  1651     TEST(retSize2 == size3);

  1653     // w1 State Final

  1654     CleanupStack::Pop();

  1655     w1.Close();

  1657     CleanupStack::Pop();

  1658     wg.Close();

  1660     CleanupStack::Pop();

  1661     rws.Close();

  1663     __UHEAP_MARKEND;

  1664     }

  1666 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeEnableWindowSizeCacheL()

  1667     {

  1668     __UHEAP_MARK;

  1669     // w* State Initial

  1670     RWsSession rws;

  1671     TInt err = rws.Connect();

  1672     CleanupClosePushL(rws);

  1673     TEST(err==KErrNone);

  1675     rws.EnableWindowSizeCacheL();

  1677     RWindowGroup wg(rws);

  1678     wg.Construct(0);

  1679     CleanupClosePushL(rws);

  1681     // w1 State 0

  1682     RWindow w1(rws);

  1683     w1.Construct(wg,1);

  1684     CleanupClosePushL(w1);

  1686     // w1 State 0

  1687     TSize size1 (10001,123);

  1688     w1.SetSize(size1);

  1689     rws.Flush();

  1691     // w1 State 1

  1692     TSize retSize1 = w1.Size();

  1693     TEST(retSize1 == size1);

  1695     // w1 State 2

  1696     TSize size2 (20002,223);

  1697     w1.SetSize(size2);

  1699     // Only the first call to EnableWindowSizeCacheL() should have an effect

  1700     // All subsequent calls to EnableWindowSizeCacheL() should have no effect

  1701     rws.EnableWindowSizeCacheL();

  1703     // w1 State 1

  1704     TSize retSize2 = w1.Size();

  1705     TEST(retSize2 == size2);

  1707     // w1 State Final

  1708     CleanupStack::Pop();

  1709     w1.Close();

  1711     CleanupStack::Pop();

  1712     wg.Close();

  1714     CleanupStack::Pop();

  1715     rws.Close();

  1717     __UHEAP_MARKEND;

  1718     }

  1720 //------------------------------------------------------------------------------------------

  1722 void CTWindowSizeCacheTest::TestRBlankWindowSetSizeSetExtentL(TSizeCacheStatus aEnableWindowSizeCache)

  1723     {

  1724     __UHEAP_MARK;

  1725     // w* State Initial

  1726     RWsSession rws;

  1727     TInt err = rws.Connect();

  1728     CleanupClosePushL(rws);

  1729     TEST(err==KErrNone);

  1731     if (aEnableWindowSizeCache)

  1732         {

  1733         rws.EnableWindowSizeCacheL();

  1734         }

  1736     RWindowGroup wg(rws);

  1737     err = wg.Construct(0);

  1738     CleanupClosePushL(rws);

  1739     TEST(err==KErrNone);

  1741     // w1 State 0

  1742     RBlankWindow w1(rws);

  1743     err = w1.Construct(wg,1);

  1744     CleanupClosePushL(w1);

  1745     TEST(err==KErrNone);

  1747     // w1 State 0

  1748     TSize size1 (10001,123);

  1749     w1.SetSize(size1);

  1750     rws.Flush();

  1752     // w1 State 1

  1753     TSize retSize1 = w1.Size();

  1754     TEST(retSize1 == size1);

  1756     // w1 State 2

  1757     TSize size2 (20002,223);

  1758     w1.SetSize(size2);

  1760     // w1 State 2

  1761     TPoint point3 (30303,232);

  1762     TSize size3 (30003,323);

  1763     w1.SetExtent(point3, size3);

  1764     rws.Flush();

  1766     // w1 State 1

  1767     TSize retSize2 = w1.Size();

  1768     TEST(retSize2 == size3);

  1770     // w1 State 2

  1771     TSize size4 (40004,423);

  1772     w1.SetSize(size4);

  1774     // w1 State 1

  1775     TSize retSize3 = w1.Size();

  1776     TEST(retSize3 == size4);

  1778     // w1 State Final

  1779     CleanupStack::Pop();

  1780     w1.Close();

  1782     CleanupStack::Pop();

  1783     wg.Close();

  1785     CleanupStack::Pop();

  1786     rws.Close();

  1788     __UHEAP_MARKEND;

  1789     }

  1791 //------------------------------------------------------------------------------------------

  1793 void CTWindowSizeCacheTest::TestRBackedUpWindowSetSizeErrSetExtentErrL(TSizeCacheStatus aEnableWindowSizeCache)

  1794     {

  1795     __UHEAP_MARK;

  1796     // w* State Initial

  1797     RWsSession rws;

  1798     TInt err = rws.Connect();

  1799     CleanupClosePushL(rws);

  1800     TEST(err==KErrNone);

  1802     if (aEnableWindowSizeCache)

  1803         {

  1804         rws.EnableWindowSizeCacheL();

  1805         }

  1807     RWindowGroup wg(rws);

  1808     err = wg.Construct(0);

  1809     CleanupClosePushL(rws);

  1810     TEST(err==KErrNone);

  1812     // w1 State 0

  1813     RBlankWindow w1(rws);

  1814     err = w1.Construct(wg,1);

  1815     CleanupClosePushL(w1);

  1816     TEST(err==KErrNone);

  1818     // w1 State 0

  1819     TSize size1 (10001,123);

  1820     err = w1.SetSizeErr(size1);

  1821     TEST(err==KErrNone);

  1823     // w1 State 1

  1824     TSize retSize1 = w1.Size();

  1825     TEST(retSize1 == size1);

  1827     // w1 State 2

  1828     TSize size2 (20002,223);

  1829     err = w1.SetSizeErr(size2);

  1830     TEST(err==KErrNone);

  1832     // w1 State 2

  1833     TPoint point3 (30303,232);

  1834     TSize size3 (30003,323);

  1835     err = w1.SetExtentErr(point3, size3);

  1836     TEST(err==KErrNone);

  1838     // w1 State 1

  1839     TSize retSize2 = w1.Size();

  1840     TEST(retSize2 == size3);

  1842     // w1 State 2

  1843     TSize size4 (40004,423);

  1844     err = w1.SetSizeErr(size4);

  1845     TEST(err==KErrNone);

  1847     // w1 State 1

  1848     TSize retSize3 = w1.Size();

  1849     TEST(retSize3 == size4);

  1851     // w1 State Final

  1852     CleanupStack::Pop();

  1853     w1.Close();

  1855     CleanupStack::Pop();

  1856     wg.Close();

  1858     CleanupStack::Pop();

  1859     rws.Close();

  1861     __UHEAP_MARKEND;

  1862     }

  1864 //------------------------------------------------------------------------------------------

  1866 TUint64 CTWindowSizeCacheTest::TestRWindowSizePerformanceL(TSizeCacheStatus aEnableWindowSizeCache, TUint aIterations)

  1867     {

  1868     TUint64 timeDeltaMicroSeconds = 0;

  1870     __UHEAP_MARK;

  1871     // w* State Initial

  1872     RWsSession rws;

  1873     TInt err = rws.Connect();

  1874     TEST(KErrNone == err);

  1875     CleanupClosePushL(rws);

  1877     if (ETestSizeCacheEnabled == aEnableWindowSizeCache)

  1878         {

  1879         rws.EnableWindowSizeCacheL();

  1880         }

  1882     RWindowGroup wg(rws);

  1883     err = wg.Construct(0);

  1884     TEST(KErrNone == err);

  1885     CleanupClosePushL(wg);

  1887     // w1 State 0

  1888     RWindow w1(rws);

  1889     err = w1.Construct(wg,1);

  1890     TEST(KErrNone == err);

  1891     CleanupClosePushL(w1);

  1893     TSize size1 (10001,123);

  1894     w1.SetSize(size1);

  1896     TTime start;

  1897     TTime end;

  1898     start.UniversalTime();

  1899     for (TUint iter = 0; iter < aIterations; ++iter)

  1900         {

  1901         // w1 State 1

  1902         TSize retSize1 = w1.Size();

  1903         TEST(retSize1 == size1);

  1904         }

  1905     end.UniversalTime();

  1907     TTimeIntervalMicroSeconds delta = end.MicroSecondsFrom(start);

  1908     timeDeltaMicroSeconds = delta.Int64();

  1909     INFO_PRINTF4(_L("TestRWindowSizePerformanceL - WindowSizeCacheEnabled %d, Iterations %d, Microseconds %Ld"), aEnableWindowSizeCache, aIterations, timeDeltaMicroSeconds);

  1911     // w1 State Final

  1912     CleanupStack::Pop();

  1913     w1.Close();

  1915     CleanupStack::Pop();

  1916     wg.Close();

  1918     CleanupStack::Pop();

  1919     rws.Close();

  1921     __UHEAP_MARKEND;

  1922     return timeDeltaMicroSeconds;

  1923     }

  1926 //------------------------------------------------------------------------------------------

  1927 /*

  1928 Sets the random seed used by CTWindowSizeCacheTest::NextRandom.

  1929  */

  1930 void CTWindowSizeCacheTest::SetRandomSeed(TInt64 aSeed)

  1931     {

  1932     INFO_PRINTF2(_L("Random Seed - %d"), aSeed);

  1933     iSeed = aSeed;

  1934     }

  1936 /*

  1937 Performs an action on RWindow or RWsSession as specified by TRWindowAction aAction.

  1938 When the size of the window is changed, aExpectedSize is changed to the size we expect the window to be the next time RWindow::Size is called.

  1939 When RWindow::Size is called, we check the size returned matches aExpectedSize.

  1940 If aAction requests RWsSession::EnableWindowSizeCache, we call this if TSizeCacheStatus allows this.

  1942 This function was designed for use with random stress tests, with a pseudo-random sequence driving TRWindowAction.

  1943  */

  1944 void CTWindowSizeCacheTest::RWindowPerformAction(TRWindowAction aAction, TSizeCacheStatus aEnableWindowSizeCache, RWsSession& aWs, RWindow& aWindow, TSize& aExpectedSize)

  1945     {

  1946     switch (aAction)

  1947         {

  1948         case ESetExtent :

  1949             {

  1950             TPoint point(NextRandom(), NextRandom());

  1951             aExpectedSize.iHeight = NextRandom();

  1952             aExpectedSize.iWidth = NextRandom();

  1953             aWindow.SetExtent(point, aExpectedSize);

  1954             aExpectedSize.iHeight = (aExpectedSize.iHeight < 0) ? 0 : aExpectedSize.iHeight;

  1955             aExpectedSize.iWidth = (aExpectedSize.iWidth < 0) ? 0 : aExpectedSize.iWidth;

  1956             }

  1957             break;

  1958         case ESetExtentErr :

  1959             {

  1960             TPoint point(NextRandom(), NextRandom());

  1961             aExpectedSize.iHeight = NextRandom();

  1962             aExpectedSize.iWidth = NextRandom();

  1963             TInt err = aWindow.SetExtentErr(point, aExpectedSize);

  1964             TEST(KErrNone == err);

  1965             aExpectedSize.iHeight = (aExpectedSize.iHeight < 0) ? 0 : aExpectedSize.iHeight;

  1966             aExpectedSize.iWidth = (aExpectedSize.iWidth < 0) ? 0 : aExpectedSize.iWidth;

  1967             }

  1968             break;

  1969         case ESetSize :

  1970             {

  1971             aExpectedSize.iHeight = NextRandom();

  1972             aExpectedSize.iWidth = NextRandom();

  1973             aWindow.SetSize(aExpectedSize);

  1974             aExpectedSize.iHeight = (aExpectedSize.iHeight < 0) ? 0 : aExpectedSize.iHeight;

  1975             aExpectedSize.iWidth = (aExpectedSize.iWidth < 0) ? 0 : aExpectedSize.iWidth;

  1976             }

  1977             break;

  1978         case ESetSizeErr :

  1979             {

  1980             aExpectedSize.iHeight = NextRandom();

  1981             aExpectedSize.iWidth = NextRandom();

  1982             TInt err = aWindow.SetSizeErr(aExpectedSize);

  1983             TEST(KErrNone == err);

  1984             aExpectedSize.iHeight = (aExpectedSize.iHeight < 0) ? 0 : aExpectedSize.iHeight;

  1985             aExpectedSize.iWidth = (aExpectedSize.iWidth < 0) ? 0 : aExpectedSize.iWidth;

  1986             }

  1987             break;

  1988         case ECheckSize :

  1989             {

  1990             TSize retSize1 = aWindow.Size();

  1991             TEST(retSize1 == aExpectedSize);

  1992             }

  1993             break;

  1994         case EFlushSession :

  1995             {

  1996             aWs.Flush();

  1997             }

  1998             break;

  1999         case EEnableWindowSizeCache :

  2000             {

  2001             if (ETestSizeCacheEnabled == aEnableWindowSizeCache)

  2002                 {

  2003                 aWs.EnableWindowSizeCacheL();

  2004                 }

  2005             }

  2006             break;

  2007         default :

  2008             break;

  2009         }

  2010     }

  2012 void CTWindowSizeCacheTest::TestRandomisedStressL(TSizeCacheStatus aEnableWindowSizeCache, TUint aIterations)

  2013     {

  2014     __UHEAP_MARK;

  2015     // w* State Initial

  2016     RWsSession rws;

  2017     TInt err = rws.Connect();

  2018     TEST(KErrNone == err);

  2019     CleanupClosePushL(rws);

  2021     if (aEnableWindowSizeCache)

  2022         {

  2023         rws.EnableWindowSizeCacheL();

  2024         }

  2026     RWindowGroup wg(rws);

  2027     err = wg.Construct(0);

  2028     TEST(KErrNone == err);

  2029     CleanupClosePushL(wg);

  2031     // w1 State 0

  2032     RWindow w1(rws);

  2033     err = w1.Construct(wg,1);

  2034     TEST(KErrNone == err);

  2035     CleanupClosePushL(w1);

  2037     TSize size1 (10001,123);

  2038     w1.SetSize(size1);

  2040     for (TUint iter = 0; iter < aIterations; ++iter)

  2041         {

  2042         TRWindowAction action = static_cast<TRWindowAction>(NextRandom(EMaxAction));

  2043         RWindowPerformAction(action, aEnableWindowSizeCache, rws, w1, size1);

  2044         }

  2046     // w1 State Final

  2047     CleanupStack::Pop();

  2048     w1.Close();

  2050     CleanupStack::Pop();

  2051     wg.Close();

  2053     CleanupStack::Pop();

  2054     rws.Close();

  2055     __UHEAP_MARKEND;

  2056     }

  2058 /*

  2059 TCleanupOperation for a window pool, implemented as RPointerArray<RWindow>.

  2060  */

  2061 void CTWindowSizeCacheTest::CleanupWindowPool(TAny* aPtr)

  2062     {

  2063     RPointerArray<RWindow> windowPool = *(static_cast<RPointerArray<RWindow>*>(aPtr));

  2064     const TUint poolSize = windowPool.Count();

  2065     // Note: ResetAndDestroy deletes referenced objects, so no need to delete items in loop

  2066     for (TUint iter = 0; iter < poolSize; ++iter)

  2067         {

  2068         windowPool[iter]->Close();

  2069         }

  2070     windowPool.ResetAndDestroy();

  2071     }

  2073 void CTWindowSizeCacheTest::TestRandomisedStressMultiSessionL(TSizeCacheStatus aEnableWindowSizeCache, TUint aIterations)

  2074     {

  2075     __UHEAP_MARK;

  2076     // w* State Initial

  2077     RWsSession rws1;

  2078     TInt err = rws1.Connect();

  2079     TEST(KErrNone == err);

  2080     CleanupClosePushL(rws1);

  2082     // Multiple sessions in one thread

  2083     RWsSession rws2;

  2084     err = rws2.Connect();

  2085     TEST(KErrNone == err);

  2086     CleanupClosePushL(rws2);

  2088     RWindowGroup rws1_wg1(rws1);

  2089     err = rws1_wg1.Construct(0);

  2090     CleanupClosePushL(rws1_wg1);

  2091     TEST(KErrNone == err);

  2093     RWindowGroup rws2_wg1(rws2);

  2094     err = rws2_wg1.Construct(0);

  2095     CleanupClosePushL(rws2_wg1);

  2096     TEST(KErrNone == err);

  2098     // Multiple window groups in one session

  2099     RWindowGroup rws2_wg2(rws2);

  2100     err = rws2_wg2.Construct(1);

  2101     CleanupClosePushL(rws2_wg2);

  2102     TEST(KErrNone == err);

  2104     // Window pool for all windows owned by session rws1

  2105     RPointerArray<RWindow> rws1_windowPool;

  2106     CleanupStack::PushL(TCleanupItem(CleanupWindowPool,&rws1_windowPool));

  2107     // Each window in window pool has a corresponding expected size at corresponding array index

  2108     RArray<TSize> rws1_expectedSizePool;

  2109     CleanupClosePushL(rws1_expectedSizePool);

  2111     // Window pool for all windows owned by session rws2

  2112     RPointerArray<RWindow> rws2_windowPool;

  2113     CleanupStack::PushL(TCleanupItem(CleanupWindowPool,&rws2_windowPool));

  2114     // Each window in window pool has a corresponding expected size at corresponding array index

  2115     RArray<TSize> rws2_expectedSizePool;

  2116     CleanupClosePushL(rws2_expectedSizePool);

  2118     // Populate window pool

  2119     const TUint KWindowCount_rws1_wg1 = 50;

  2120     const TUint KWindowCount_rws2_wg1 = 50;

  2121     const TUint KWindowCount_rws2_wg2 = 50;

  2123     // Windows for session 1 belonging to rws1_wg1

  2124     // Many windows - siblings

  2125     for (TUint iter = 0; iter < KWindowCount_rws1_wg1; ++iter)

  2126         {

  2127         RWindow* win = new (ELeave) RWindow(rws1);

  2128         CleanupStack::PushL(win);

  2129         TInt err = win->Construct(rws1_wg1,iter+1);

  2130         TEST(KErrNone == err);

  2131         rws1_windowPool.AppendL(win);

  2132         CleanupStack::Pop(win);

  2133         TSize expectedSize (NextRandom(),NextRandom());

  2134         win->SetSize(expectedSize);

  2135         // Wserv flattens size to zero

  2136         expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;

  2137         expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;

  2138         rws1_expectedSizePool.AppendL(expectedSize);

  2139         TSize retSize1 = win->Size();

  2140         TEST(retSize1 == expectedSize);

  2141         }

  2143     // Windows for session 2 belonging to rws2_wg1

  2144     // Many windows - siblings

  2145     for (TUint iter = 0; iter < KWindowCount_rws2_wg1; ++iter)

  2146         {

  2147         RWindow* win = new (ELeave) RWindow(rws2);

  2148         CleanupStack::PushL(win);

  2149         TInt err = win->Construct(rws2_wg1,iter+2);

  2150         TEST(KErrNone == err);

  2151         rws2_windowPool.AppendL(win);

  2152         CleanupStack::Pop();

  2153         TSize expectedSize (NextRandom(),NextRandom());

  2154         win->SetSize(expectedSize);

  2155         // Wserv flattens size to zero

  2156         expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;

  2157         expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;

  2158         rws2_expectedSizePool.AppendL(expectedSize);

  2159         TSize retSize1 = win->Size();

  2160         TEST(retSize1 == expectedSize);

  2161         }

  2163     // Windows for session 2 belonging to rws2_wg2

  2164     // Many windows - children

  2165     RWindowTreeNode parent = rws2_wg2;

  2166     for (TUint iter = 0; iter < KWindowCount_rws2_wg2; ++iter)

  2167         {

  2168         RWindow* win = new (ELeave) RWindow(rws2);

  2169         CleanupStack::PushL(win);

  2170         TInt err = win->Construct(parent,KWindowCount_rws2_wg1+iter+2);

  2171         TEST(KErrNone == err);

  2172         parent = *win;

  2173         rws2_windowPool.AppendL(win);

  2174         CleanupStack::Pop();

  2175         TSize expectedSize (NextRandom(),NextRandom());

  2176         win->SetSize(expectedSize);

  2177         // Wserv flattens size to zero

  2178         expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;

  2179         expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;

  2180         rws2_expectedSizePool.AppendL(expectedSize);

  2181         TSize retSize1 = win->Size();

  2182         TEST(retSize1 == expectedSize);

  2183         }

  2185     // Stress system by performing actions on windows

  2186     for (TUint iter = 0; iter < aIterations; ++iter)

  2187         {

  2188         TRWindowAction action = static_cast<TRWindowAction>(NextRandom(EMaxAction));

  2189         TUint32 windowPool = NextRandom(2);

  2190         switch (windowPool)

  2191             {

  2192             case 0 :

  2193                 {

  2194                 TUint32 target = NextRandom(rws1_windowPool.Count());

  2195                 RWindowPerformAction(action, aEnableWindowSizeCache, rws1, *(rws1_windowPool[target]) , rws1_expectedSizePool[target]);

  2196                 }

  2197                 break;

  2198             case 1 :

  2199                 {

  2200                 TUint32 target = NextRandom(rws2_windowPool.Count());

  2201                 RWindowPerformAction(action, aEnableWindowSizeCache, rws2, *(rws2_windowPool[target]) , rws2_expectedSizePool[target]);

  2202                 }

  2203                 break;

  2204             default :

  2205                 User::Invariant();

  2206             }

  2207         }

  2210     // Cleanup afterwards

  2211     CleanupStack::Pop(9);

  2213     CleanupWindowPool(&rws1_windowPool);

  2214     rws1_expectedSizePool.Close();

  2215     rws1_wg1.Close();

  2216     rws1.Close();

  2218     CleanupWindowPool(&rws2_windowPool);

  2219     rws2_expectedSizePool.Close();

  2220     rws2_wg1.Close();

  2221     rws2_wg2.Close();

  2222     rws2.Close();

  2223     }

  2225 void CTWindowSizeCacheTest::TestRandomisedStressCacheEntryVolumeL(TSizeCacheStatus aEnableWindowSizeCache, TUint aIterations, TUint aWindowPoolSize)

  2226     {

  2227     __UHEAP_MARK;

  2228     // w* State Initial

  2229     RWsSession rws1;

  2230     TInt err = rws1.Connect();

  2231     TEST(KErrNone == err);

  2232     CleanupClosePushL(rws1);

  2234     if (aEnableWindowSizeCache)

  2235         {

  2236         rws1.EnableWindowSizeCacheL();

  2237         }

  2239     RWindowGroup rws1_wg1(rws1);

  2240     err = rws1_wg1.Construct(0);

  2241     TEST(KErrNone == err);

  2242     CleanupClosePushL(rws1_wg1);

  2244     RPointerArray<RWindow> windowPool;

  2245     CleanupStack::PushL(TCleanupItem(CleanupWindowPool,&windowPool));

  2246     // Each window in window pool has a corresponding expected size at corresponding array index

  2247     RArray<TSize> expectedSizePool;

  2248     CleanupClosePushL(expectedSizePool);

  2250     // Populate window pool

  2251     for (TUint iter = 0; iter < aWindowPoolSize; ++iter)

  2252         {

  2253         RWindow* win = new (ELeave) RWindow(rws1);

  2254         CleanupStack::PushL(win);

  2255         TInt err = win->Construct(rws1_wg1,iter+1);

  2256         TEST(KErrNone == err);

  2257         windowPool.AppendL(win);

  2258         CleanupStack::Pop(win);

  2260         TSize expectedSize (NextRandom(),NextRandom());

  2261         win->SetSize(expectedSize);

  2262         // Wserv flattens size to zero

  2263         expectedSize.iHeight = (expectedSize.iHeight < 0) ? 0 : expectedSize.iHeight;

  2264         expectedSize.iWidth = (expectedSize.iWidth < 0) ? 0 : expectedSize.iWidth;

  2265         expectedSizePool.AppendL(expectedSize);

  2266         TSize retSize1 = win->Size();

  2267         TEST(retSize1 == expectedSize);

  2268         }

  2270     // Stress system by performing actions on windows

  2271     for (TUint iter = 0; iter < aIterations; ++iter)

  2272         {

  2273         TRWindowAction action = static_cast<TRWindowAction>(NextRandom(EMaxAction));

  2274         TUint32 target = NextRandom(aWindowPoolSize);

  2275         RWindowPerformAction(action, aEnableWindowSizeCache, rws1, *(windowPool[target]), expectedSizePool[target]);

  2276         }

  2278     // Cleanup afterwards

  2279     CleanupStack::Pop(4);

  2281     CleanupWindowPool(&windowPool);

  2282     expectedSizePool.Close();

  2283     rws1_wg1.Close();

  2284     rws1.Close();

  2286     __UHEAP_MARKEND;

  2287     }

  2289 //------------------------------------------------------------------------------------------

  2291 void CTWindowSizeCacheTest::TestStressEnableWindowSizeCacheL(TUint aIterations)

  2292     {

  2293     __UHEAP_MARK;

  2294     // w* State Initial

  2295     RWsSession rws;

  2296     TInt err = rws.Connect();

  2297     CleanupClosePushL(rws);

  2298     TEST(err==KErrNone);

  2300     // Only the first call to EnableWindowSizeCacheL() should have an effect

  2301     // All subsequent calls to EnableWindowSizeCacheL() should have no effect

  2302     for (TUint iter = 0; iter < aIterations; iter++)

  2303         {

  2304         rws.EnableWindowSizeCacheL();

  2305         }

  2307     RWindowGroup wg(rws);

  2308     wg.Construct(0);

  2309     CleanupClosePushL(rws);

  2311     // w1 State 0

  2312     RWindow w1(rws);

  2313     w1.Construct(wg,1);

  2314     CleanupClosePushL(w1);

  2316     TSize size1 (10001,123);

  2317     w1.SetSize(size1);

  2319     // w1 State 1

  2320     TSize retSize1 = w1.Size();

  2321     TEST(retSize1 == size1);

  2323     // w1 State 2

  2324     TSize size2 (20002,223);

  2325     w1.SetSize(size2);

  2327     // w1 State 2

  2328     // Only the first call to EnableWindowSizeCacheL() should have an effect

  2329     // All subsequent calls to EnableWindowSizeCacheL() should have no effect

  2330     for (TUint iter = 0; iter < aIterations; iter++)

  2331         {

  2332         rws.EnableWindowSizeCacheL();

  2333         }

  2335     // w1 State 1

  2336     TSize retSize2 = w1.Size();

  2337     TEST(retSize2 == size2);

  2339     // w1 State Final

  2340     CleanupStack::Pop();

  2341     w1.Close();

  2343     CleanupStack::Pop();

  2344     wg.Close();

  2346     CleanupStack::Pop();

  2347     rws.Close();

  2349     __UHEAP_MARKEND;

  2350     }

  2352 /*

  2353 Tests 701-706 focus on window creation operating correctly, alternating use of the window size cache.

  2354 Tests 707-710 aim to cover state transitions for cache entries in the window size cache for RWindow.

  2355 Tests 711-712 performs basic verification of size related functionality for RBlankWindow and RBackedUpWindow.

  2356 Test 713 focusses on ensuring a performance gain is achieved with window size caching enabled.

  2357 Tests 714-720 aim to stress the window size cache with pseudo-random sequences of RWindow size related functions.

  2359 The states in the state machine model used for testing the RWindow size cache in tests 707-710 is as follows:

  2361 State: Initial

  2362     Window not yet in existence

  2364 State 0: No Cache entry

  2365     Window created, window size cache does not contain an entry for this window

  2367 State 1: Cache entry exists, cache clean

  2368     Window created, window size cache exists, contains a valid size

  2370 State 2: Cache entry exists, cache dirty

  2371     Window created, window size cache exists, does not contain a valid size

  2373 State: Final

  2374     Window destroyed

  2375  */

  2376 void CTWindowSizeCacheTest::RunTestCaseL(TInt /*aCurTestCase*/)

  2377     {

  2378     _LIT(KTest1,"Create RWindow, window size cache off");

  2379     _LIT(KTest2,"Create RWindow, window size cache on");

  2380     _LIT(KTest3,"Create RBlankWindow, window size cache off");

  2381     _LIT(KTest4,"Create RBlankWindow, window size cache on");

  2382     _LIT(KTest5,"Create RBackedUpWindow, window size cache off");

  2383     _LIT(KTest6,"Create RBackedUpWindow, window size cache on");

  2385     _LIT(KTest7,"RWindow - No cache entry");

  2386     _LIT(KTest8,"RWindow - Cache entry exists, cache clean");

  2387     _LIT(KTest9,"RWindow - Cache entry exists, cache dirty");

  2388     _LIT(KTest10,"RWindow - Cache entry exists, cache dirty->clean");

  2390     _LIT(KTest11,"RBlankWindow size cache");

  2391     _LIT(KTest12,"RBackedUpWindow size cache");

  2393     _LIT(KTest13,"RWindow Size Performance");

  2394     _LIT(KTest14,"RWindow Randomised Stress window size cache off");

  2395     _LIT(KTest15,"RWindow Randomised Stress window size cache on");

  2396     _LIT(KTest16,"RWindow Randomised Stress MultiSession cache off");

  2397     _LIT(KTest17,"RWindow Randomised Stress MultiSession cache on");

  2398     _LIT(KTest18,"RWindow Randomised Stress Entry Volume cache off");

  2399     _LIT(KTest19,"RWindow Randomised Stress Entry Volume cache on");

  2400     _LIT(KTest20,"RWsSession stress EnableWindowSizeCacheL");

  2402     const TDisplayMode displayMode = EColor16MAP;

  2403     const TUint KPerformanceIterations = 50000;

  2404     const TUint KStressTestIterations = 3000;

  2405     const TUint KStressWindowPoolSize = 100;

  2407     ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

  2409     switch(++iTest->iState)

  2410         {

  2411 /**

  2412 @SYMTestCaseID      GRAPHICS-WSERV-0701

  2414 @SYMDEF             DevCR BBRE-7UWGHL

  2416 @SYMTestCaseDesc    Test creation and destruction for instances of RWindow, window size cache off

  2418 @SYMTestPriority    High

  2420 @SYMTestStatus      Implemented

  2422 @SYMTestActions     Creates an RWsSession, some RWindowGroup and RWindow instances, and closes them.

  2424 @SYMTestExpectedResults Window objects created successfully, no memory leaks.

  2425 */

  2426         case 1:

  2427             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0701"));

  2428             iTest->LogSubTest(KTest1);

  2429             TestCreateRWindowL(ETestSizeCacheNotEnabled);

  2430             break;

  2431 /**

  2432 @SYMTestCaseID      GRAPHICS-WSERV-0702

  2434 @SYMDEF             DevCR BBRE-7UWGHL

  2436 @SYMTestCaseDesc    Test creation and destruction for instances of RWindow, window size cache on

  2438 @SYMTestPriority    High

  2440 @SYMTestStatus      Implemented

  2442 @SYMTestActions     Creates an RWsSession, enables window size cache, creates some RWindowGroup and RWindow instances, and closes them.

  2444 @SYMTestExpectedResults Window objects created successfully, no memory leaks.

  2445 */

  2446         case 2:

  2447             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0702"));

  2448             iTest->LogSubTest(KTest2);

  2449             TestCreateRWindowL(ETestSizeCacheEnabled);

  2450             break;

  2451 /**

  2452 @SYMTestCaseID      GRAPHICS-WSERV-0703

  2454 @SYMDEF             DevCR BBRE-7UWGHL

  2456 @SYMTestCaseDesc    Test creation and destruction for instances of RBlankWindow, window size cache off

  2458 @SYMTestPriority    High

  2460 @SYMTestStatus      Implemented

  2462 @SYMTestActions     Creates an RWsSession, creates some RWindowGroup and RBlankWindow instances, and closes them.

  2464 @SYMTestExpectedResults Window objects created successfully, no memory leaks.

  2465 */

  2466         case 3:

  2467             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0703"));

  2468             iTest->LogSubTest(KTest3);

  2469             TestCreateRBlankWindowL(ETestSizeCacheNotEnabled);

  2470             break;

  2471 /**

  2472 @SYMTestCaseID      GRAPHICS-WSERV-0704

  2474 @SYMDEF             DevCR BBRE-7UWGHL

  2476 @SYMTestCaseDesc    Test creation and destruction for instances of RBlankWindow, window size cache on

  2478 @SYMTestPriority    High

  2480 @SYMTestStatus      Implemented

  2482 @SYMTestActions     Creates an RWsSession, enables window size cache, creates some RWindowGroup and RBlankWindow instances, and closes them.

  2484 @SYMTestExpectedResults Window objects created successfully, no memory leaks.

  2485 */

  2486         case 4:

  2487             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0704"));

  2488             iTest->LogSubTest(KTest4);

  2489             TestCreateRBlankWindowL(ETestSizeCacheEnabled);

  2490             break;

  2491 /**

  2492 @SYMTestCaseID      GRAPHICS-WSERV-0705

  2494 @SYMDEF             DevCR BBRE-7UWGHL

  2496 @SYMTestCaseDesc    Test creation and destruction for instances of RBackedUpWindow, window size cache off

  2498 @SYMTestPriority    High

  2500 @SYMTestStatus      Implemented

  2502 @SYMTestActions     Creates an RWsSession, creates some RWindowGroup and RBackedUpWindow instances, and closes them.

  2504 @SYMTestExpectedResults Window objects created successfully, no memory leaks.

  2505 */

  2506         case 5:

  2507             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0705"));

  2508             iTest->LogSubTest(KTest5);

  2509             TestCreateRBackedUpWindowL(ETestSizeCacheNotEnabled, displayMode);

  2510             break;

  2511 /**

  2512 @SYMTestCaseID      GRAPHICS-WSERV-0706

  2514 @SYMDEF             DevCR BBRE-7UWGHL

  2516 @SYMTestCaseDesc    Test creation and destruction for instances of RBackedUpWindow, window size cache on

  2518 @SYMTestPriority    High

  2520 @SYMTestStatus      Implemented

  2522 @SYMTestActions     Creates an RWsSession, enables window size cache, creates some RWindowGroup and RBackedUpWindow instances, and closes them.

  2524 @SYMTestExpectedResults Window objects created successfully, no memory leaks.

  2525 */

  2526         case 6:

  2527             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0706"));

  2528             iTest->LogSubTest(KTest6);

  2529             TestCreateRBackedUpWindowL(ETestSizeCacheEnabled, displayMode);

  2530             break;

  2531 /**

  2532 @SYMTestCaseID      GRAPHICS-WSERV-0707

  2534 @SYMDEF             DevCR BBRE-7UWGHL

  2536 @SYMTestCaseDesc    Test RWindow size cache - State: No Cache Entry

  2538 @SYMTestPriority    High

  2540 @SYMTestStatus      Implemented

  2542 @SYMTestActions     Perform the following with window size cache on and off:

  2543                         Create RWsSession, creates RWindowGroup and RWindow.

  2544                         Perform one of SetExtent/SetSize/SetExtentErr/SetSizeErr/EnableWindowSizeCacheL.

  2545                         Clean up.

  2547 @SYMTestExpectedResults Window objects created successfully, no memory leaks.

  2548 */

  2549         case 7:

  2550             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0707"));

  2551             iTest->LogSubTest(KTest7);

  2552             TestRWindowNoCacheEntryL(ETestSizeCacheNotEnabled);

  2553             TestRWindowNoCacheEntryL(ETestSizeCacheEnabled);

  2554             TestRWindowNoCacheEntrySetExtentErrL(ETestSizeCacheNotEnabled);

  2555             TestRWindowNoCacheEntrySetExtentErrL(ETestSizeCacheEnabled);

  2556             TestRWindowNoCacheEntrySetSizeErrL(ETestSizeCacheNotEnabled);

  2557             TestRWindowNoCacheEntrySetSizeErrL(ETestSizeCacheEnabled);

  2558             TestRWindowNoCacheEntrySetExtentL(ETestSizeCacheNotEnabled);

  2559             TestRWindowNoCacheEntrySetExtentL(ETestSizeCacheEnabled);

  2560             TestRWindowNoCacheEntrySetSizeL(ETestSizeCacheNotEnabled);

  2561             TestRWindowNoCacheEntrySetSizeL(ETestSizeCacheEnabled);

  2562             TestRWindowNoCacheEntryEnableWindowSizeCacheL();

  2563             break;

  2565 /**

  2566 @SYMTestCaseID      GRAPHICS-WSERV-0708

  2568 @SYMDEF             DevCR BBRE-7UWGHL

  2570 @SYMTestCaseDesc    Test RWindow size cache State: Cache entry exists, cache clean

  2572 @SYMTestPriority    High

  2574 @SYMTestStatus      Implemented

  2576 @SYMTestActions     Perform the following with window size cache on and off:

  2577                         Create RWsSession, creates RWindowGroup and RWindow, calls SetSize.

  2578                         Perform one of Size/EnableWindowSizeCacheL.

  2579                         Check that size returned matches expected size.

  2580                         Clean up.

  2582 @SYMTestExpectedResults Window objects created successfully, no memory leaks.

  2583 */

  2584         case 8:

  2585             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0708"));

  2586             iTest->LogSubTest(KTest8);

  2587             TestRWindowCacheEntryExistsCacheCleanL(ETestSizeCacheNotEnabled);

  2588             TestRWindowCacheEntryExistsCacheCleanL(ETestSizeCacheEnabled);

  2589             TestRWindowCacheEntryExistsCacheCleanSizeL(ETestSizeCacheNotEnabled);

  2590             TestRWindowCacheEntryExistsCacheCleanSizeL(ETestSizeCacheEnabled);

  2591             TestRWindowCacheEntryExistsCacheCleanEnableWindowSizeCacheL();

  2592             TestRWindowCacheEntryExistsCacheCleanEnableWindowSizeCacheLSizeL();

  2593             break;

  2595 /**

  2596 @SYMTestCaseID      GRAPHICS-WSERV-0709

  2598 @SYMDEF             DevCR BBRE-7UWGHL

  2600 @SYMTestCaseDesc    Test RWindow size cache State: Cache entry exists, cache dirty

  2602 @SYMTestPriority    High

  2604 @SYMTestStatus      Implemented

  2606 @SYMTestActions     Perform the following with window size cache on and off:

  2607                         Create RWsSession, creates RWindowGroup and RWindow.

  2608                         Calls SetSize, Size, then SetSize to enter state with dirty cache entry.

  2609                         Perform combinations of SetSize/SetExtent/SetSizeErr/SetExtentErr/EnableWindowSizeCacheL.

  2610                         Check that size returned matches the last size set on the window whenever size is queried.

  2611                         Clean up.

  2613 @SYMTestExpectedResults Window objects created successfully, no memory leaks.

  2614 */

  2615         case 9:

  2616             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0709"));

  2617             iTest->LogSubTest(KTest9);

  2618             TestRWindowCacheEntryExistsCacheDirtySetSizeL(ETestSizeCacheNotEnabled);

  2619             TestRWindowCacheEntryExistsCacheDirtySetSizeL(ETestSizeCacheEnabled);

  2620             TestRWindowCacheEntryExistsCacheDirtySetExtentL(ETestSizeCacheNotEnabled);

  2621             TestRWindowCacheEntryExistsCacheDirtySetExtentL(ETestSizeCacheEnabled);

  2622             TestRWindowCacheEntryExistsCacheDirtySetSizeErrL(ETestSizeCacheNotEnabled);

  2623             TestRWindowCacheEntryExistsCacheDirtySetSizeErrL(ETestSizeCacheEnabled);

  2624             TestRWindowCacheEntryExistsCacheDirtySetExtentErrL(ETestSizeCacheNotEnabled);

  2625             TestRWindowCacheEntryExistsCacheDirtySetExtentErrL(ETestSizeCacheEnabled);

  2626             TestRWindowCacheEntryExistsCacheDirtySetSizeTwiceL(ETestSizeCacheNotEnabled);

  2627             TestRWindowCacheEntryExistsCacheDirtySetSizeTwiceL(ETestSizeCacheEnabled);

  2628             TestRWindowCacheEntryExistsCacheDirtySetSizeSetExtentL(ETestSizeCacheNotEnabled);

  2629             TestRWindowCacheEntryExistsCacheDirtySetSizeSetExtentL(ETestSizeCacheEnabled);

  2630             TestRWindowCacheEntryExistsCacheDirtySetSizeSetSizeErrL(ETestSizeCacheNotEnabled);

  2631             TestRWindowCacheEntryExistsCacheDirtySetSizeSetSizeErrL(ETestSizeCacheEnabled);

  2632             TestRWindowCacheEntryExistsCacheDirtySetSizeSetExtentErrL(ETestSizeCacheNotEnabled);

  2633             TestRWindowCacheEntryExistsCacheDirtySetSizeSetExtentErrL(ETestSizeCacheEnabled);

  2634             TestRWindowCacheEntryExistsCacheDirtySetSizeEnableWindowSizeCacheL();

  2635             break;

  2638 /**

  2639 @SYMTestCaseID      GRAPHICS-WSERV-0710

  2641 @SYMDEF             DevCR BBRE-7UWGHL

  2643 @SYMTestCaseDesc    Test RWindow size cache State: Cache entry exists, cache dirty -> State: Cache entry exists, cache clean

  2645 @SYMTestPriority    High

  2647 @SYMTestStatus      Implemented

  2649 @SYMTestActions     Perform the following with window size cache on and off:

  2650                         Create RWsSession, creates RWindowGroup and RWindow.

  2651                         Calls SetSize, Size, to enter state with clean cache entry.

  2652                         Perform combinations of SetSize/SetExtent/SetSizeErr/SetExtentErr/EnableWindowSizeCacheL to enter state with dirty cache entry.

  2653                         Calls RWindow::Size to re-enter state with clean cache entry.

  2654                         Check that size returned matches the last size set on the window whenever size is queried.

  2655                         Clean up.

  2657 @SYMTestExpectedResults Window objects created successfully, no memory leaks.

  2658 */

  2659         case 10:

  2660             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0710"));

  2661             iTest->LogSubTest(KTest10);

  2662             TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeL(ETestSizeCacheNotEnabled);

  2663             TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeL(ETestSizeCacheEnabled);

  2664             TestRWindowCacheEntryExistsCacheDirtyToCleanSetExtentL(ETestSizeCacheNotEnabled);

  2665             TestRWindowCacheEntryExistsCacheDirtyToCleanSetExtentL(ETestSizeCacheEnabled);

  2666             TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeErrL(ETestSizeCacheNotEnabled);

  2667             TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeErrL(ETestSizeCacheEnabled);

  2668             TestRWindowCacheEntryExistsCacheDirtyToCleanSetExtentErrL(ETestSizeCacheNotEnabled);

  2669             TestRWindowCacheEntryExistsCacheDirtyToCleanSetExtentErrL(ETestSizeCacheEnabled);

  2670             TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeTwiceL(ETestSizeCacheNotEnabled);

  2671             TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeTwiceL(ETestSizeCacheEnabled);

  2672             TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetExtentL(ETestSizeCacheNotEnabled);

  2673             TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetExtentL(ETestSizeCacheEnabled);

  2674             TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetSizeErrL(ETestSizeCacheNotEnabled);

  2675             TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetSizeErrL(ETestSizeCacheEnabled);

  2676             TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetExtentErrL(ETestSizeCacheNotEnabled);

  2677             TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeSetExtentErrL(ETestSizeCacheEnabled);

  2678             TestRWindowCacheEntryExistsCacheDirtyToCleanSetSizeEnableWindowSizeCacheL();

  2679             break;

  2681 /**

  2682 @SYMTestCaseID      GRAPHICS-WSERV-0711

  2684 @SYMDEF             DevCR BBRE-7UWGHL

  2686 @SYMTestCaseDesc    Test RBlankWindow Size cache behaviour

  2688 @SYMTestPriority    High

  2690 @SYMTestStatus      Implemented

  2692 @SYMTestActions     Utilises RBlankWindow::SetSize, RBlankWindow::SetExtent, RBlankWindow::Size.

  2693                     Checks size returned by RBlankWindow::Size.

  2694                     Cleans up.

  2696 @SYMTestExpectedResults Window objects created successfully, no memory leaks, size returned should be last size set on window

  2697 */

  2698         case 11:

  2699             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0711"));

  2700             iTest->LogSubTest(KTest11);

  2701             TestRBlankWindowSetSizeSetExtentL(ETestSizeCacheNotEnabled);

  2702             TestRBlankWindowSetSizeSetExtentL(ETestSizeCacheEnabled);

  2703             break;

  2704 /**

  2705 @SYMTestCaseID      GRAPHICS-WSERV-0712

  2707 @SYMDEF             DevCR BBRE-7UWGHL

  2709 @SYMTestCaseDesc    Test RBackedUpWindow Size cache behaviour

  2711 @SYMTestPriority    High

  2713 @SYMTestStatus      Implemented

  2715 @SYMTestActions     Utilises RBackedUpWindow::SetSizeErr, RBackedUpWindow::SetExtentErr, RBackedUpWindow::Size.

  2716                     Checks size returned by RBackedUpWindow::Size.

  2717                     Cleans up.

  2719 @SYMTestExpectedResults Window objects created successfully, no memory leaks, size returned should be last size set on window

  2720 */

  2721         case 12:

  2722             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0712"));

  2723             iTest->LogSubTest(KTest12);

  2724             TestRBackedUpWindowSetSizeErrSetExtentErrL(ETestSizeCacheNotEnabled);

  2725             TestRBackedUpWindowSetSizeErrSetExtentErrL(ETestSizeCacheEnabled);

  2726             break;

  2728 /**

  2729 @SYMTestCaseID      GRAPHICS-WSERV-0713

  2731 @SYMDEF             DevCR BBRE-7UWGHL

  2733 @SYMTestCaseDesc    Compare performance of RWindow::Size function with size cache on and off

  2735 @SYMTestPriority    High

  2737 @SYMTestStatus      Implemented

  2739 @SYMTestActions     Creates an RWsSession, optionally enables window size cache, creates an RWindowGroup and an RWindow

  2740                     Calls RWindow::Size KPerformanceIterations times.

  2741                     Measures time taken - with and without size cache enabled

  2743 @SYMTestExpectedResults Window objects created successfully, no memory leaks, time taken for KPerformanceIterations RWindow::Size() calls with cache enabled should be faster.

  2744 */

  2745         case 13:

  2746             {

  2747             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0713"));

  2748             iTest->LogSubTest(KTest13);

  2749             TUint64 sizeCacheOffDeltaMicroSeconds = TestRWindowSizePerformanceL(ETestSizeCacheNotEnabled, KPerformanceIterations);

  2750             TUint64 sizeCacheOnDeltaMicroSeconds = TestRWindowSizePerformanceL(ETestSizeCacheEnabled, KPerformanceIterations);

  2751             TEST(sizeCacheOnDeltaMicroSeconds < sizeCacheOffDeltaMicroSeconds);

  2752             INFO_PRINTF1(_L("Accessing size using cache is faster"));

  2753             }

  2754             break;

  2755 /**

  2756 @SYMTestCaseID      GRAPHICS-WSERV-0714

  2758 @SYMDEF             DevCR BBRE-7UWGHL

  2760 @SYMTestCaseDesc    Randomised stress test - RWindow size related functions

  2762 @SYMTestPriority    High

  2764 @SYMTestStatus      Implemented

  2766 @SYMTestActions     Creates an RWsSession, creates some RWindowGroup and RWindow instances, performs random size related actions, cleans up.

  2768 @SYMTestExpectedResults Window objects created successfully, no memory leaks, size for each window matches last size set on window

  2769 */

  2770         case 14:

  2771             {

  2772             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0714"));

  2773             iTest->LogSubTest(KTest14);

  2774             TInt seed = Math::Random();

  2775             // To replicate a test run, take the random seed from the test log and pass into SetRandomSeed

  2776             SetRandomSeed(seed);

  2777             TestRandomisedStressL(ETestSizeCacheNotEnabled, KStressTestIterations);

  2778             }

  2779             break;

  2780 /**

  2781 @SYMTestCaseID      GRAPHICS-WSERV-0714

  2783 @SYMDEF             DevCR BBRE-7UWGHL

  2785 @SYMTestCaseDesc    Randomised stress test - RWindow size related functions, size cache on

  2787 @SYMTestPriority    High

  2789 @SYMTestStatus      Implemented

  2791 @SYMTestActions     Creates an RWsSession, enables window size cache, creates some RWindowGroup and RWindow instances, performs random size related actions, cleans up.

  2793 @SYMTestExpectedResults Window objects created successfully, no memory leaks, size for each window matches last size set on window

  2794 */

  2795         case 15:

  2796             {

  2797             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0715"));

  2798             iTest->LogSubTest(KTest15);

  2799             TInt seed = Math::Random();

  2800             // To replicate a test run, take the random seed from the test log and pass into SetRandomSeed

  2801             SetRandomSeed(seed);

  2802             TestRandomisedStressL(ETestSizeCacheEnabled, KStressTestIterations);

  2803             }

  2804             break;

  2807 /**

  2808 @SYMTestCaseID      GRAPHICS-WSERV-0716

  2810 @SYMDEF             DevCR BBRE-7UWGHL

  2812 @SYMTestCaseDesc    Randomised stress test - RWindow size related functions, multiple sessions

  2814 @SYMTestPriority    High

  2816 @SYMTestStatus      Implemented

  2818 @SYMTestActions     Creates two RWsSession instances, creates some RWindowGroup and RWindow instances, performs random size related actions, cleans up.

  2820 @SYMTestExpectedResults Window objects created successfully, no memory leaks, size for each window matches last size set on window

  2821 */

  2822         case 16:

  2823             {

  2824             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0716"));

  2825             iTest->LogSubTest(KTest16);

  2826             TInt seed = Math::Random();

  2827             // To replicate a test run, take the random seed from the test log and pass into SetRandomSeed

  2828             SetRandomSeed(seed);

  2829             TestRandomisedStressMultiSessionL(ETestSizeCacheNotEnabled, KStressTestIterations);

  2830             }

  2831             break;

  2832 /**

  2833 @SYMTestCaseID      GRAPHICS-WSERV-0717

  2835 @SYMDEF             DevCR BBRE-7UWGHL

  2837 @SYMTestCaseDesc    Randomised stress test - RWindow size related functions, multiple sessions, size cache on

  2839 @SYMTestPriority    High

  2841 @SYMTestStatus      Implemented

  2843 @SYMTestActions     Creates two RWsSession instances, enables window size cache, creates some RWindowGroup and RWindow instances, performs random size related actions, cleans up.

  2845 @SYMTestExpectedResults Window objects created successfully, no memory leaks, size for each window matches last size set on window

  2846 */

  2847         case 17:

  2848             {

  2849             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0717"));

  2850             iTest->LogSubTest(KTest17);

  2851             TInt seed = Math::Random();

  2852             // To replicate a test run, take the random seed from the test log and pass into SetRandomSeed

  2853             SetRandomSeed(seed);

  2854             TestRandomisedStressMultiSessionL(ETestSizeCacheEnabled, KStressTestIterations);

  2855             }

  2856             break;

  2858 /**

  2859 @SYMTestCaseID      GRAPHICS-WSERV-0718

  2861 @SYMDEF             DevCR BBRE-7UWGHL

  2863 @SYMTestCaseDesc    Randomised stress test - RWindow size related functions, large number of windows

  2865 @SYMTestPriority    High

  2867 @SYMTestStatus      Implemented

  2869 @SYMTestActions     Creates an RWsSession, creates some RWindowGroup and RWindow instances, performs random size related actions, cleans up.

  2871 @SYMTestExpectedResults Window objects created successfully, no memory leaks, size for each window matches last size set on window

  2872 */

  2873         case 18:

  2874             {

  2875             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0718"));

  2876             iTest->LogSubTest(KTest18);

  2877             TInt seed = Math::Random();

  2878             // To replicate a test run, take the random seed from the test log and pass into SetRandomSeed

  2879             SetRandomSeed(seed);

  2880             TestRandomisedStressCacheEntryVolumeL(ETestSizeCacheNotEnabled, KStressTestIterations, KStressWindowPoolSize);

  2881             }

  2882             break;

  2883 /**

  2884 @SYMTestCaseID      GRAPHICS-WSERV-0719

  2886 @SYMDEF             DevCR BBRE-7UWGHL

  2888 @SYMTestCaseDesc    Randomised stress test - RWindow size related functions, large number of windows

  2890 @SYMTestPriority    High

  2892 @SYMTestStatus      Implemented

  2894 @SYMTestActions     Creates an RWsSession, enables window size cache, creates some RWindowGroup and RWindow instances, performs random size related actions, cleans up.

  2896 @SYMTestExpectedResults Window objects created successfully, no memory leaks, size for each window matches last size set on window

  2897 */

  2898         case 19:

  2899             {

  2900             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0719"));

  2901             iTest->LogSubTest(KTest19);

  2902             TInt seed = Math::Random();

  2903             // To replicate a test run, take the random seed from the test log and pass into SetRandomSeed

  2904             SetRandomSeed(seed);

  2905             TestRandomisedStressCacheEntryVolumeL(ETestSizeCacheEnabled, KStressTestIterations, KStressWindowPoolSize);

  2906             }

  2907             break;

  2909 /**

  2910 @SYMTestCaseID      GRAPHICS-WSERV-0720

  2912 @SYMDEF             DevCR BBRE-7UWGHL

  2914 @SYMTestCaseDesc    Test RWsSession::EnableWindowSizeCacheL() API

  2916 @SYMTestPriority    High

  2918 @SYMTestStatus      Implemented

  2920 @SYMTestActions     Creates an RWsSession, calls EnableWindowSizeCacheL() multiple times, uses Size related APIs.

  2922 @SYMTestExpectedResults No memory leaks.

  2923 */

  2924         case 20:

  2925             {

  2926             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0720"));

  2927             iTest->LogSubTest(KTest20);

  2928             TestStressEnableWindowSizeCacheL(KStressTestIterations);

  2929             }

  2930             break;

  2931         default:

  2932             ((CTWindowSizeCacheTestStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

  2933             ((CTWindowSizeCacheTestStep*)iStep)->CloseTMSGraphicsStep();

  2934             TestComplete();

  2935             break;

  2936         }

  2937     ((CTWindowSizeCacheTestStep*)iStep)->RecordTestResultL();

  2938     }

  2940 __WS_CONSTRUCT_STEP__(WindowSizeCacheTest)

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--