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

    17 

    18 /**

    19  @file

    20  @test

    21  @internalComponent - Internal Symbian test code

    22 */

    23 

    24 #include "twindowsizecache.h"

    25 

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

    27     {}

    28 

    29 CTWindowSizeCacheTest::~CTWindowSizeCacheTest()

    30     {

    31     }

    32 

    33 void CTWindowSizeCacheTest::ConstructL()

    34     {}

    35 

    36 

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

    45 

    46     if (ETestSizeCacheEnabled == aEnableWindowSizeCache)

    47         {

    48         rws.EnableWindowSizeCacheL();

    49         }

    50     

    51     RWindowGroup wg(rws);

    52     err = wg.Construct(0);

    53     CleanupClosePushL(wg);

    54     TEST(KErrNone == err);

    55 

    56     // w1 State 0

    57     RWindow w1(rws);

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

    59     CleanupClosePushL(w1);

    60     TEST(KErrNone == err);

    61 

    62     // w2 State 0

    63     RWindow w2(rws);

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

    65     CleanupClosePushL(w2);

    66     TEST(KErrNone == err);

    67 

    68     CleanupStack::Pop(2);

    69     

    70     // w1 State Final

    71     w1.Close();

    72     // w2 State Final

    73     w2.Close();

    74     

    75     RWindow w3(rws);

    76     // w3 State 0

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

    78     CleanupClosePushL(w3);

    79     TEST(KErrNone == err);

    80     

    81     CleanupStack::Pop(2);

    82 

    83     // w3 State Final

    84     w3.Close();

    85     

    86     wg.Close();

    87 

    88     RWindowGroup wg2(rws);

    89     err = wg2.Construct(0);

    90     CleanupClosePushL(wg2);

    91     TEST(KErrNone == err);

    92     

    93     RWindowGroup wg3(rws);

    94     err = wg3.Construct(1);

    95     CleanupClosePushL(wg3);    

    96     TEST(KErrNone == err);

    97 

    98     // w4 State 0

    99     RWindow w4(rws);

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

   101     CleanupClosePushL(w4);    

   102     TEST(KErrNone == err);

   103     

   104     // w5 State 0

   105     RWindow w5(rws);

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

   107     CleanupClosePushL(w5);    

   108     TEST(KErrNone == err);

   109     

   110     CleanupStack::Pop(5);

   111 

   112     // w4 State Final

   113     w4.Close();

   114     

   115     // w5 State Final

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

   117     w5.Close();

   118     w5.Close();

   119 

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

   121     wg2.Close();

   122     wg2.Close();

   123     

   124     wg3.Close();

   125     

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

   127     rws.Close();

   128     rws.Close();

   129     __UHEAP_MARKEND;

   130     }

   131 

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

   140 

   141     if (ETestSizeCacheEnabled == aEnableWindowSizeCache)

   142         {

   143         rws.EnableWindowSizeCacheL();

   144         }

   145     

   146     RWindowGroup wg(rws);

   147     err = wg.Construct(0);

   148     CleanupClosePushL(wg);

   149     TEST(KErrNone == err);

   150 

   151     // w1 State 0

   152     RBlankWindow w1(rws);

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

   154     CleanupClosePushL(w1);

   155     TEST(KErrNone == err);

   156 

   157     // w2 State 0

   158     RBlankWindow w2(rws);

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

   160     CleanupClosePushL(w2);

   161     TEST(KErrNone == err);

   162 

   163     CleanupStack::Pop(2);

   164 

   165     // w1 State Final

   166     w1.Close();

   167     // w2 State Final

   168     w2.Close();

   169     

   170     RBlankWindow w3(rws);

   171     // w3 State 0

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

   173     CleanupClosePushL(w3);

   174     TEST(KErrNone == err);

   175     

   176     CleanupStack::Pop(2);

   177     

   178     // w3 State Final

   179     w3.Close();

   180     

   181     wg.Close();

   182 

   183     RWindowGroup wg2(rws);

   184     err = wg2.Construct(0);

   185     CleanupClosePushL(wg2);

   186     TEST(KErrNone == err);

   187     

   188     RWindowGroup wg3(rws);

   189     err = wg3.Construct(1);

   190     CleanupClosePushL(wg3);    

   191     TEST(KErrNone == err);

   192 

   193     // w4 State 0

   194     RBlankWindow w4(rws);

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

   196     CleanupClosePushL(w4);    

   197     TEST(KErrNone == err);

   198     

   199     // w5 State 0

   200     RBlankWindow w5(rws);

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

   202     CleanupClosePushL(w5);    

   203     TEST(KErrNone == err);

   204     

   205     CleanupStack::Pop(5);

   206 

   207     // w4 State Final

   208     w4.Close();

   209     

   210     // w5 State Final

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

   212     w5.Close();

   213     w5.Close();

   214 

   215     wg2.Close();

   216     wg3.Close();

   217     rws.Close();

   218     __UHEAP_MARKEND;

   219     }

   220 

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

   229 

   230     if (ETestSizeCacheEnabled == aEnableWindowSizeCache)

   231         {

   232         rws.EnableWindowSizeCacheL();

   233         }

   234     

   235     RWindowGroup wg(rws);

   236     err = wg.Construct(0);

   237     CleanupClosePushL(wg);

   238     TEST(KErrNone == err);

   239 

   240     // w1 State 0

   241     RBackedUpWindow w1(rws);

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

   243     CleanupClosePushL(w1);

   244     TEST(KErrNone == err);

   245 

   246     // w2 State 0

   247     RBackedUpWindow w2(rws);

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

   249     CleanupClosePushL(w2);

   250     TEST(KErrNone == err);

   251 

   252     CleanupStack::Pop(2);

   253 

   254     // w1 State Final

   255     w1.Close();

   256     

   257     // w2 State Final

   258     w2.Close();

   259     

   260     RBackedUpWindow w3(rws);

   261     // w3 State 0

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

   263     CleanupClosePushL(w3);

   264     TEST(KErrNone == err);

   265     

   266     CleanupStack::Pop(2);

   267 

   268     // w3 State Final

   269     w3.Close();

   270     

   271     wg.Close();

   272 

   273     RWindowGroup wg2(rws);

   274     CleanupClosePushL(wg2);

   275     err = wg2.Construct(0);

   276     TEST(KErrNone == err);

   277     

   278     RWindowGroup wg3(rws);

   279     err = wg3.Construct(1);

   280     CleanupClosePushL(wg3);    

   281     TEST(KErrNone == err);

   282 

   283     // w4 State 0

   284     RBackedUpWindow w4(rws);

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

   286     CleanupClosePushL(w4);    

   287     TEST(KErrNone == err);

   288     

   289     // w5 State 0

   290     RBackedUpWindow w5(rws);

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

   292     CleanupClosePushL(w5);    

   293     TEST(KErrNone == err);

   294     

   295     CleanupStack::Pop(5);

   296 

   297     // w4 State Final

   298     w4.Close();

   299     

   300     // w5 State Final

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

   302     w5.Close();

   303     w5.Close();

   304 

   305     wg2.Close();

   306     wg3.Close();

   307     rws.Close();

   308     __UHEAP_MARKEND;

   309     }

   310 

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

   319 

   320     if (aEnableWindowSizeCache)

   321         {

   322         rws.EnableWindowSizeCacheL();

   323         }

   324 

   325     RWindowGroup wg(rws);

   326     wg.Construct(0);

   327     CleanupClosePushL(rws);

   328 

   329     // w1 State 0

   330     RWindow w1(rws);

   331     w1.Construct(wg,1);

   332     CleanupClosePushL(w1);

   333     

   334     // w1 State Final

   335     CleanupStack::Pop();

   336     w1.Close();

   337     

   338     CleanupStack::Pop();

   339     wg.Close();

   340     

   341     CleanupStack::Pop();

   342     rws.Close();

   343 

   344     __UHEAP_MARKEND;

   345     }

   346 

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

   355 

   356     if (aEnableWindowSizeCache)

   357         {

   358         rws.EnableWindowSizeCacheL();

   359         }

   360 

   361     RWindowGroup wg(rws);

   362     wg.Construct(0);

   363     CleanupClosePushL(rws);

   364 

   365     // w1 State 0

   366     RWindow w1(rws);

   367     w1.Construct(wg,1);

   368     CleanupClosePushL(w1);

   369 

   370     // w1 State 0

   371     TPoint point1 (10101,897);

   372     TSize size1 (10001,123);

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

   374     TEST(KErrNone == err);

   375     

   376     // w1 State Final

   377     CleanupStack::Pop();

   378     w1.Close();

   379     

   380     CleanupStack::Pop();

   381     wg.Close();

   382     

   383     CleanupStack::Pop();

   384     rws.Close();

   385 

   386     __UHEAP_MARKEND;

   387     }

   388 

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

   397 

   398     if (aEnableWindowSizeCache)

   399         {

   400         rws.EnableWindowSizeCacheL();

   401         }

   402 

   403     RWindowGroup wg(rws);

   404     wg.Construct(0);

   405     CleanupClosePushL(rws);

   406 

   407     // w1 State 0

   408     RWindow w1(rws);

   409     w1.Construct(wg,1);

   410     CleanupClosePushL(w1);

   411 

   412     // w1 State 0

   413     TSize size1 (10001,123);

   414     err = w1.SetSizeErr(size1);

   415     TEST(KErrNone == err);

   416     

   417     // w1 State Final

   418     CleanupStack::Pop();

   419     w1.Close();

   420     

   421     CleanupStack::Pop();

   422     wg.Close();

   423     

   424     CleanupStack::Pop();

   425     rws.Close();

   426 

   427     __UHEAP_MARKEND;

   428     }

   429 

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

   438 

   439     if (aEnableWindowSizeCache)

   440         {

   441         rws.EnableWindowSizeCacheL();

   442         }

   443 

   444     RWindowGroup wg(rws);

   445     wg.Construct(0);

   446     CleanupClosePushL(rws);

   447 

   448     // w1 State 0

   449     RWindow w1(rws);

   450     w1.Construct(wg,1);

   451     CleanupClosePushL(w1);

   452 

   453     // w1 State 0

   454     TPoint point1 (10101,897);

   455     TSize size1 (10001,123);

   456     w1.SetExtent(point1, size1);

   457     rws.Flush();

   458     

   459     // w1 State Final

   460     CleanupStack::Pop();

   461     w1.Close();

   462     

   463     CleanupStack::Pop();

   464     wg.Close();

   465     

   466     CleanupStack::Pop();

   467     rws.Close();

   468 

   469     __UHEAP_MARKEND;

   470     }

   471 

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

   480 

   481     if (aEnableWindowSizeCache)

   482         {

   483         rws.EnableWindowSizeCacheL();

   484         }

   485 

   486     RWindowGroup wg(rws);

   487     wg.Construct(0);

   488     CleanupClosePushL(rws);

   489 

   490     // w1 State 0

   491     RWindow w1(rws);

   492     w1.Construct(wg,1);

   493     CleanupClosePushL(w1);

   494 

   495     // w1 State 0

   496     TSize size1 (10001,123);

   497     w1.SetSize(size1);

   498     rws.Flush();

   499     

   500     // w1 State Final

   501     CleanupStack::Pop();

   502     w1.Close();

   503     

   504     CleanupStack::Pop();

   505     wg.Close();

   506     

   507     CleanupStack::Pop();

   508     rws.Close();

   509 

   510     __UHEAP_MARKEND;

   511     }

   512 

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

   521 

   522     rws.EnableWindowSizeCacheL();

   523 

   524     RWindowGroup wg(rws);

   525     wg.Construct(0);

   526     CleanupClosePushL(rws);

   527 

   528     // w1 State 0

   529     RWindow w1(rws);

   530     w1.Construct(wg,1);

   531     CleanupClosePushL(w1);

   532 

   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();

   537     

   538     // w1 State Final

   539     CleanupStack::Pop();

   540     w1.Close();

   541     

   542     CleanupStack::Pop();

   543     wg.Close();

   544     

   545     CleanupStack::Pop();

   546     rws.Close();

   547 

   548     __UHEAP_MARKEND;

   549     }

   550 

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

   559 

   560     if (aEnableWindowSizeCache)

   561         {

   562         rws.EnableWindowSizeCacheL();

   563         }

   564 

   565     RWindowGroup wg(rws);

   566     wg.Construct(0);

   567     CleanupClosePushL(rws);

   568 

   569     // w1 State 0

   570     RWindow w1(rws);

   571     w1.Construct(wg,1);

   572     CleanupClosePushL(w1);

   573 

   574     // w1 State 0

   575     TSize size1 (10001,123);

   576     w1.SetSize(size1);

   577     rws.Flush();

   578     

   579     // w1 State 1

   580     TSize retSize1 = w1.Size();

   581     TEST(retSize1 == size1);

   582     

   583     // w1 State Final

   584     CleanupStack::Pop();

   585     w1.Close();

   586     

   587     CleanupStack::Pop();

   588     wg.Close();

   589     

   590     CleanupStack::Pop();

   591     rws.Close();

   592 

   593     __UHEAP_MARKEND;

   594     }

   595 

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

   604 

   605     if (aEnableWindowSizeCache)

   606         {

   607         rws.EnableWindowSizeCacheL();

   608         }

   609 

   610     RWindowGroup wg(rws);

   611     wg.Construct(0);

   612     CleanupClosePushL(rws);

   613 

   614     // w1 State 0

   615     RWindow w1(rws);

   616     w1.Construct(wg,1);

   617     CleanupClosePushL(w1);

   618 

   619     // w1 State 0

   620     TSize size1 (10001,123);

   621     w1.SetSize(size1);

   622     rws.Flush();

   623     

   624     // w1 State 1

   625     TSize retSize1 = w1.Size();

   626     TEST(retSize1 == size1);

   627     

   628     // w1 State 1

   629     TSize retSize2 = w1.Size();

   630     TEST(retSize2 == size1);

   631 

   632     // w1 State Final

   633     CleanupStack::Pop();

   634     w1.Close();

   635     

   636     CleanupStack::Pop();

   637     wg.Close();

   638     

   639     CleanupStack::Pop();

   640     rws.Close();

   641 

   642     __UHEAP_MARKEND;

   643     }

   644 

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

   653 

   654     rws.EnableWindowSizeCacheL();

   655 

   656     RWindowGroup wg(rws);

   657     wg.Construct(0);

   658     CleanupClosePushL(rws);

   659 

   660     // w1 State 0

   661     RWindow w1(rws);

   662     w1.Construct(wg,1);

   663     CleanupClosePushL(w1);

   664 

   665     // w1 State 0

   666     TSize size1 (10001,123);

   667     w1.SetSize(size1);

   668     rws.Flush();

   669     

   670     // w1 State 1

   671     TSize retSize1 = w1.Size();

   672     TEST(retSize1 == size1);

   673     

   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();

   678 

   679     // w1 State Final

   680     CleanupStack::Pop();

   681     w1.Close();

   682     

   683     CleanupStack::Pop();

   684     wg.Close();

   685     

   686     CleanupStack::Pop();

   687     rws.Close();

   688 

   689     __UHEAP_MARKEND;

   690     }

   691 

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

   700 

   701     rws.EnableWindowSizeCacheL();

   702 

   703     RWindowGroup wg(rws);

   704     wg.Construct(0);

   705     CleanupClosePushL(rws);

   706 

   707     // w1 State 0

   708     RWindow w1(rws);

   709     w1.Construct(wg,1);

   710     CleanupClosePushL(w1);

   711 

   712     // w1 State 0

   713     TSize size1 (10001,123);

   714     w1.SetSize(size1);

   715     rws.Flush();

   716     

   717     // w1 State 1

   718     TSize retSize1 = w1.Size();

   719     TEST(retSize1 == size1);

   720     

   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();

   725 

   726     // w1 State 1

   727     TSize retSize2 = w1.Size();

   728     TEST(retSize2 == size1);

   729 

   730     // w1 State Final

   731     CleanupStack::Pop();

   732     w1.Close();

   733     

   734     CleanupStack::Pop();

   735     wg.Close();

   736     

   737     CleanupStack::Pop();

   738     rws.Close();

   739 

   740     __UHEAP_MARKEND;

   741     }

   742 

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

   751 

   752     if (aEnableWindowSizeCache)

   753         {

   754         rws.EnableWindowSizeCacheL();

   755         }

   756 

   757     RWindowGroup wg(rws);

   758     wg.Construct(0);

   759     CleanupClosePushL(rws);

   760 

   761     // w1 State 0

   762     RWindow w1(rws);

   763     w1.Construct(wg,1);

   764     CleanupClosePushL(w1);

   765 

   766     // w1 State 0

   767     TSize size1 (10001,123);

   768     w1.SetSize(size1);

   769     rws.Flush();

   770     

   771     // w1 State 1

   772     TSize retSize1 = w1.Size();

   773     TEST(retSize1 == size1);

   774     

   775     // w1 State 2

   776     TSize size2 (20002,223);

   777     w1.SetSize(size2); 

   778     rws.Flush();

   779 

   780     // w1 State Final

   781     CleanupStack::Pop();

   782     w1.Close();

   783     

   784     CleanupStack::Pop();

   785     wg.Close();

   786     

   787     CleanupStack::Pop();

   788     rws.Close();

   789 

   790     __UHEAP_MARKEND;

   791     }

   792 

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

   801 

   802     if (aEnableWindowSizeCache)

   803         {

   804         rws.EnableWindowSizeCacheL();

   805         }

   806 

   807     RWindowGroup wg(rws);

   808     wg.Construct(0);

   809     CleanupClosePushL(rws);

   810 

   811     // w1 State 0

   812     RWindow w1(rws);

   813     w1.Construct(wg,1);

   814     CleanupClosePushL(w1);

   815 

   816     // w1 State 0

   817     TSize size1 (10001,123);

   818     w1.SetSize(size1);

   819     rws.Flush();

   820     

   821     // w1 State 1

   822     TSize retSize1 = w1.Size();

   823     TEST(retSize1 == size1);

   824     

   825     // w1 State 2

   826     TPoint point2 (20202,223);

   827     TSize size2 (20002,223);

   828     w1.SetExtent(point2, size2); 

   829     rws.Flush();

   830 

   831     // w1 State Final

   832     CleanupStack::Pop();

   833     w1.Close();

   834     

   835     CleanupStack::Pop();

   836     wg.Close();

   837     

   838     CleanupStack::Pop();

   839     rws.Close();

   840 

   841     __UHEAP_MARKEND;

   842     }

   843 

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

   852 

   853     if (aEnableWindowSizeCache)

   854         {

   855         rws.EnableWindowSizeCacheL();

   856         }

   857 

   858     RWindowGroup wg(rws);

   859     wg.Construct(0);

   860     CleanupClosePushL(rws);

   861 

   862     // w1 State 0

   863     RWindow w1(rws);

   864     w1.Construct(wg,1);

   865     CleanupClosePushL(w1);

   866 

   867     // w1 State 0

   868     TSize size1 (10001,123);

   869     w1.SetSize(size1);

   870     rws.Flush();

   871     

   872     // w1 State 1

   873     TSize retSize1 = w1.Size();

   874     TEST(retSize1 == size1);

   875     

   876     // w1 State 2

   877     TSize size2 (20002,223);

   878     err = w1.SetSizeErr(size2); 

   879     TEST(KErrNone == err);

   880 

   881     // w1 State Final

   882     CleanupStack::Pop();

   883     w1.Close();

   884     

   885     CleanupStack::Pop();

   886     wg.Close();

   887     

   888     CleanupStack::Pop();

   889     rws.Close();

   890 

   891     __UHEAP_MARKEND;

   892     }

   893 

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

   902 

   903     if (aEnableWindowSizeCache)

   904         {

   905         rws.EnableWindowSizeCacheL();

   906         }

   907 

   908     RWindowGroup wg(rws);

   909     wg.Construct(0);

   910     CleanupClosePushL(rws);

   911 

   912     // w1 State 0

   913     RWindow w1(rws);

   914     w1.Construct(wg,1);

   915     CleanupClosePushL(w1);

   916 

   917     // w1 State 0

   918     TSize size1 (10001,123);

   919     w1.SetSize(size1);

   920     rws.Flush();

   921     

   922     // w1 State 1

   923     TSize retSize1 = w1.Size();

   924     TEST(retSize1 == size1);

   925     

   926     // w1 State 2

   927     TPoint point2 (20202,223);

   928     TSize size2 (20002,223);

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

   930     TEST(KErrNone == err);

   931 

   932     // w1 State Final

   933     CleanupStack::Pop();

   934     w1.Close();

   935     

   936     CleanupStack::Pop();

   937     wg.Close();

   938     

   939     CleanupStack::Pop();

   940     rws.Close();

   941 

   942     __UHEAP_MARKEND;

   943     }

   944 

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

   953 

   954     if (aEnableWindowSizeCache)

   955         {

   956         rws.EnableWindowSizeCacheL();

   957         }

   958 

   959     RWindowGroup wg(rws);

   960     wg.Construct(0);

   961     CleanupClosePushL(rws);

   962 

   963     // w1 State 0

   964     RWindow w1(rws);

   965     w1.Construct(wg,1);

   966     CleanupClosePushL(w1);

   967 

   968     // w1 State 0

   969     TSize size1 (10001,123);

   970     w1.SetSize(size1);

   971     rws.Flush();

   972     

   973     // w1 State 1

   974     TSize retSize1 = w1.Size();

   975     TEST(retSize1 == size1);

   976     

   977     // w1 State 2

   978     TSize size2 (20002,223);

   979     w1.SetSize(size2); 

   980 

   981     TSize size3 (30003,323);

   982     // w1 State 2

   983     w1.SetSize(size3); 

   984     rws.Flush();

   985 

   986     // w1 State Final

   987     CleanupStack::Pop();

   988     w1.Close();

   989     

   990     CleanupStack::Pop();

   991     wg.Close();

   992     

   993     CleanupStack::Pop();

   994     rws.Close();

   995 

   996     __UHEAP_MARKEND;

   997     }

   998 

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

  1007 

  1008     if (aEnableWindowSizeCache)

  1009         {

  1010         rws.EnableWindowSizeCacheL();

  1011         }

  1012 

  1013     RWindowGroup wg(rws);

  1014     wg.Construct(0);

  1015     CleanupClosePushL(rws);

  1016 

  1017     // w1 State 0

  1018     RWindow w1(rws);

  1019     w1.Construct(wg,1);

  1020     CleanupClosePushL(w1);

  1021 

  1022     // w1 State 0

  1023     TSize size1 (10001,123);

  1024     w1.SetSize(size1);

  1025     rws.Flush();

  1026     

  1027     // w1 State 1

  1028     TSize retSize1 = w1.Size();

  1029     TEST(retSize1 == size1);

  1030     

  1031     // w1 State 2

  1032     TSize size2 (20002,223);

  1033     w1.SetSize(size2); 

  1034 

  1035     // w1 State 2

  1036     TPoint point3 (30303,232);

  1037     TSize size3 (30003,323);

  1038     w1.SetExtent(point3, size3); 

  1039     rws.Flush();

  1040 

  1041     // w1 State Final

  1042     CleanupStack::Pop();

  1043     w1.Close();

  1044     

  1045     CleanupStack::Pop();

  1046     wg.Close();

  1047     

  1048     CleanupStack::Pop();

  1049     rws.Close();

  1050 

  1051     __UHEAP_MARKEND;

  1052     }

  1053 

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

  1062 

  1063     if (aEnableWindowSizeCache)

  1064         {

  1065         rws.EnableWindowSizeCacheL();

  1066         }

  1067 

  1068     RWindowGroup wg(rws);

  1069     wg.Construct(0);

  1070     CleanupClosePushL(rws);

  1071 

  1072     // w1 State 0

  1073     RWindow w1(rws);

  1074     w1.Construct(wg,1);

  1075     CleanupClosePushL(w1);

  1076 

  1077     // w1 State 0

  1078     TSize size1 (10001,123);

  1079     w1.SetSize(size1);

  1080     rws.Flush();

  1081     

  1082     // w1 State 1

  1083     TSize retSize1 = w1.Size();

  1084     TEST(retSize1 == size1);

  1085     

  1086     // w1 State 2

  1087     TSize size2 (20002,223);

  1088     w1.SetSize(size2); 

  1089 

  1090     // w1 State 2

  1091     TSize size3 (30003,323);

  1092     err = w1.SetSizeErr(size3);

  1093     TEST(KErrNone == err);

  1094 

  1095     // w1 State Final

  1096     CleanupStack::Pop();

  1097     w1.Close();

  1098     

  1099     CleanupStack::Pop();

  1100     wg.Close();

  1101     

  1102     CleanupStack::Pop();

  1103     rws.Close();

  1104 

  1105     __UHEAP_MARKEND;

  1106     }

  1107 

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

  1116 

  1117     if (aEnableWindowSizeCache)

  1118         {

  1119         rws.EnableWindowSizeCacheL();

  1120         }

  1121 

  1122     RWindowGroup wg(rws);

  1123     wg.Construct(0);

  1124     CleanupClosePushL(rws);

  1125 

  1126     // w1 State 0

  1127     RWindow w1(rws);

  1128     w1.Construct(wg,1);

  1129     CleanupClosePushL(w1);

  1130 

  1131     // w1 State 0

  1132     TSize size1 (10001,123);

  1133     w1.SetSize(size1);

  1134     rws.Flush();

  1135