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 void CTWindowSizeCacheTest::TestCreateRWindowL(TSizeCacheStatus aEnableWindowSizeCache)

    37     {

    38     __UHEAP_MARK;

    39     // w* State Initial

    40     RWsSession rws;

    41     TInt err = rws.Connect();

    42     CleanupClosePushL(rws);

    43     TEST(KErrNone == err);

    44 

    45     if (ETestSizeCacheEnabled == aEnableWindowSizeCache)

    46         {

    47         rws.EnableWindowSizeCacheL();

    48         }

    49     

    50     RWindowGroup wg(rws);

    51     err = wg.Construct(0);

    52     CleanupClosePushL(wg);

    53     TEST(KErrNone == err);

    54 

    55     // w1 State 0

    56     RWindow w1(rws);

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

    58     CleanupClosePushL(w1);

    59     TEST(KErrNone == err);

    60 

    61     // w2 State 0

    62     RWindow w2(rws);

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

    64     CleanupClosePushL(w2);

    65     TEST(KErrNone == err);

    66 

    67     CleanupStack::Pop(2);

    68     

    69     // w1 State Final

    70     w1.Close();

    71     // w2 State Final

    72     w2.Close();

    73     

    74     RWindow w3(rws);

    75     // w3 State 0

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

    77     CleanupClosePushL(w3);

    78     TEST(KErrNone == err);

    79     

    80     CleanupStack::Pop(2);

    81 

    82     // w3 State Final

    83     w3.Close();

    84     

    85     wg.Close();

    86 

    87     RWindowGroup wg2(rws);

    88     err = wg2.Construct(0);

    89     CleanupClosePushL(wg2);

    90     TEST(KErrNone == err);

    91     

    92     RWindowGroup wg3(rws);

    93     err = wg3.Construct(1);

    94     CleanupClosePushL(wg3);    

    95     TEST(KErrNone == err);

    96 

    97     // w4 State 0

    98     RWindow w4(rws);

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

   100     CleanupClosePushL(w4);    

   101     TEST(KErrNone == err);

   102     

   103     // w5 State 0

   104     RWindow w5(rws);

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

   106     CleanupClosePushL(w5);    

   107     TEST(KErrNone == err);

   108     

   109     CleanupStack::Pop(5);

   110 

   111     // w4 State Final

   112     w4.Close();

   113     

   114     // w5 State Final

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

   116     w5.Close();

   117     w5.Close();

   118 

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

   120     wg2.Close();

   121     wg2.Close();

   122     

   123     wg3.Close();

   124     

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

   126     rws.Close();

   127     rws.Close();

   128     __UHEAP_MARKEND;

   129     }

   130 

   131 void CTWindowSizeCacheTest::TestCreateRBlankWindowL(TSizeCacheStatus aEnableWindowSizeCache)

   132     {

   133     __UHEAP_MARK;

   134     // w* State Initial

   135     RWsSession rws;

   136     TInt err = rws.Connect();

   137     CleanupClosePushL(rws);

   138     TEST(KErrNone == err);

   139 

   140     if (ETestSizeCacheEnabled == aEnableWindowSizeCache)

   141         {

   142         rws.EnableWindowSizeCacheL();

   143         }

   144     

   145     RWindowGroup wg(rws);

   146     err = wg.Construct(0);

   147     CleanupClosePushL(wg);

   148     TEST(KErrNone == err);

   149 

   150     // w1 State 0

   151     RBlankWindow w1(rws);

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

   153     CleanupClosePushL(w1);

   154     TEST(KErrNone == err);

   155 

   156     // w2 State 0

   157     RBlankWindow w2(rws);

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

   159     CleanupClosePushL(w2);

   160     TEST(KErrNone == err);

   161 

   162     CleanupStack::Pop(2);

   163 

   164     // w1 State Final

   165     w1.Close();

   166     // w2 State Final

   167     w2.Close();

   168     

   169     RBlankWindow w3(rws);

   170     // w3 State 0

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

   172     CleanupClosePushL(w3);

   173     TEST(KErrNone == err);

   174     

   175     CleanupStack::Pop(2);

   176     

   177     // w3 State Final

   178     w3.Close();

   179     

   180     wg.Close();

   181 

   182     RWindowGroup wg2(rws);

   183     err = wg2.Construct(0);

   184     CleanupClosePushL(wg2);

   185     TEST(KErrNone == err);

   186     

   187     RWindowGroup wg3(rws);

   188     err = wg3.Construct(1);

   189     CleanupClosePushL(wg3);    

   190     TEST(KErrNone == err);

   191 

   192     // w4 State 0

   193     RBlankWindow w4(rws);

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

   195     CleanupClosePushL(w4);    

   196     TEST(KErrNone == err);

   197     

   198     // w5 State 0

   199     RBlankWindow w5(rws);

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

   201     CleanupClosePushL(w5);    

   202     TEST(KErrNone == err);

   203     

   204     CleanupStack::Pop(5);

   205 

   206     // w4 State Final

   207     w4.Close();

   208     

   209     // w5 State Final

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

   211     w5.Close();

   212     w5.Close();

   213 

   214     wg2.Close();

   215     wg3.Close();

   216     rws.Close();

   217     __UHEAP_MARKEND;

   218     }

   219 

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

   221     {

   222     __UHEAP_MARK;

   223     // w* State Initial

   224     RWsSession rws;

   225     TInt err = rws.Connect();

   226     CleanupClosePushL(rws);

   227     TEST(KErrNone == err);

   228 

   229     if (ETestSizeCacheEnabled == aEnableWindowSizeCache)

   230         {

   231         rws.EnableWindowSizeCacheL();

   232         }

   233     

   234     RWindowGroup wg(rws);

   235     err = wg.Construct(0);

   236     CleanupClosePushL(wg);

   237     TEST(KErrNone == err);

   238 

   239     // w1 State 0

   240     RBackedUpWindow w1(rws);

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

   242     CleanupClosePushL(w1);

   243     TEST(KErrNone == err);

   244 

   245     // w2 State 0

   246     RBackedUpWindow w2(rws);

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

   248     CleanupClosePushL(w2);

   249     TEST(KErrNone == err);

   250 

   251     CleanupStack::Pop(2);

   252 

   253     // w1 State Final

   254     w1.Close();

   255     

   256     // w2 State Final

   257     w2.Close();

   258     

   259     RBackedUpWindow w3(rws);

   260     // w3 State 0

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

   262     CleanupClosePushL(w3);

   263     TEST(KErrNone == err);

   264     

   265     CleanupStack::Pop(2);

   266 

   267     // w3 State Final

   268     w3.Close();

   269     

   270     wg.Close();

   271 

   272     RWindowGroup wg2(rws);

   273     CleanupClosePushL(wg2);

   274     err = wg2.Construct(0);

   275     TEST(KErrNone == err);

   276     

   277     RWindowGroup wg3(rws);

   278     err = wg3.Construct(1);

   279     CleanupClosePushL(wg3);    

   280     TEST(KErrNone == err);

   281 

   282     // w4 State 0

   283     RBackedUpWindow w4(rws);

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

   285     CleanupClosePushL(w4);    

   286     TEST(KErrNone == err);

   287     

   288     // w5 State 0

   289     RBackedUpWindow w5(rws);

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

   291     CleanupClosePushL(w5);    

   292     TEST(KErrNone == err);

   293     

   294     CleanupStack::Pop(5);

   295 

   296     // w4 State Final

   297     w4.Close();

   298     

   299     // w5 State Final

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

   301     w5.Close();

   302     w5.Close();

   303 

   304     wg2.Close();

   305     wg3.Close();

   306     rws.Close();

   307     __UHEAP_MARKEND;

   308     }

   309 

   310 void CTWindowSizeCacheTest::TestRWindowNoCacheEntryL(TSizeCacheStatus aEnableWindowSizeCache)

   311     {

   312     __UHEAP_MARK;

   313     // w* State Initial

   314     RWsSession rws;

   315     TInt err = rws.Connect();

   316     CleanupClosePushL(rws);

   317     TEST(err==KErrNone);

   318 

   319     if (aEnableWindowSizeCache)

   320         {

   321         rws.EnableWindowSizeCacheL();

   322         }

   323 

   324     RWindowGroup wg(rws);

   325     wg.Construct(0);

   326     CleanupClosePushL(rws);

   327 

   328     // w1 State 0

   329     RWindow w1(rws);

   330     w1.Construct(wg,1);

   331     CleanupClosePushL(w1);

   332     

   333     // w1 State Final

   334     CleanupStack::Pop();

   335     w1.Close();

   336     

   337     CleanupStack::Pop();

   338     wg.Close();

   339     

   340     CleanupStack::Pop();

   341     rws.Close();

   342 

   343     __UHEAP_MARKEND;

   344     }

   345 

   346 void CTWindowSizeCacheTest::TestRWindowNoCacheEntrySetExtentErrL(TSizeCacheStatus aEnableWindowSizeCache)

   347     {

   348     __UHEAP_MARK;

   349     // w* State Initial

   350     RWsSession rws;

   351     TInt err = rws.Connect();

   352     CleanupClosePushL(rws);

   353     TEST(err==KErrNone);

   354 

   355     if (aEnableWindowSizeCache)

   356         {

   357         rws.EnableWindowSizeCacheL();

   358         }

   359 

   360     RWindowGroup wg(rws);

   361     wg.Construct(0);

   362     CleanupClosePushL(rws);

   363 

   364     // w1 State 0

   365     RWindow w1(rws);

   366     w1.Construct(wg,1);

   367     CleanupClosePushL(w1);

   368 

   369     // w1 State 0

   370     TPoint point1 (10101,897);

   371     TSize size1 (10001,123);

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

   373     TEST(KErrNone == err);

   374     

   375     // w1 State Final

   376     CleanupStack::Pop();

   377     w1.Close();

   378     

   379     CleanupStack::Pop();

   380     wg.Close();

   381     

   382     CleanupStack::Pop();

   383     rws.Close();

   384 

   385     __UHEAP_MARKEND;

   386     }

   387 

   388 void CTWindowSizeCacheTest::TestRWindowNoCacheEntrySetSizeErrL(TSizeCacheStatus aEnableWindowSizeCache)

   389     {

   390     __UHEAP_MARK;

   391     // w* State Initial

   392     RWsSession rws;

   393     TInt err = rws.Connect();

   394     CleanupClosePushL(rws);

   395     TEST(err==KErrNone);

   396 

   397     if (aEnableWindowSizeCache)

   398         {

   399         rws.EnableWindowSizeCacheL();

   400         }

   401 

   402     RWindowGroup wg(rws);

   403     wg.Construct(0);

   404     CleanupClosePushL(rws);

   405 

   406     // w1 State 0

   407     RWindow w1(rws);

   408     w1.Construct(wg,1);

   409     CleanupClosePushL(w1);

   410 

   411     // w1 State 0

   412     TSize size1 (10001,123);

   413     err = w1.SetSizeErr(size1);

   414     TEST(KErrNone == err);

   415     

   416     // w1 State Final

   417     CleanupStack::Pop();

   418     w1.Close();

   419     

   420     CleanupStack::Pop();

   421     wg.Close();

   422     

   423     CleanupStack::Pop();

   424     rws.Close();

   425 

   426     __UHEAP_MARKEND;

   427     }

   428 

   429 void CTWindowSizeCacheTest::TestRWindowNoCacheEntrySetExtentL(TSizeCacheStatus aEnableWindowSizeCache)

   430     {

   431     __UHEAP_MARK;

   432     // w* State Initial

   433     RWsSession rws;

   434     TInt err = rws.Connect();

   435     CleanupClosePushL(rws);

   436     TEST(err==KErrNone);

   437 

   438     if (aEnableWindowSizeCache)

   439         {

   440         rws.EnableWindowSizeCacheL();

   441         }

   442 

   443     RWindowGroup wg(rws);

   444     wg.Construct(0);

   445     CleanupClosePushL(rws);

   446 

   447     // w1 State 0

   448     RWindow w1(rws);

   449     w1.Construct(wg,1);

   450     CleanupClosePushL(w1);

   451 

   452     // w1 State 0

   453     TPoint point1 (10101,897);

   454     TSize size1 (10001,123);

   455     w1.SetExtent(point1, size1);

   456     rws.Flush();

   457     

   458     // w1 State Final

   459     CleanupStack::Pop();

   460     w1.Close();

   461     

   462     CleanupStack::Pop();

   463     wg.Close();

   464     

   465     CleanupStack::Pop();

   466     rws.Close();

   467 

   468     __UHEAP_MARKEND;

   469     }

   470 

   471 void CTWindowSizeCacheTest::TestRWindowNoCacheEntrySetSizeL(TSizeCacheStatus aEnableWindowSizeCache)

   472     {

   473     __UHEAP_MARK;

   474     // w* State Initial

   475     RWsSession rws;

   476     TInt err = rws.Connect();

   477     CleanupClosePushL(rws);

   478     TEST(err==KErrNone);

   479 

   480     if (aEnableWindowSizeCache)

   481         {

   482         rws.EnableWindowSizeCacheL();

   483         }

   484 

   485     RWindowGroup wg(rws);

   486     wg.Construct(0);

   487     CleanupClosePushL(rws);

   488 

   489     // w1 State 0

   490     RWindow w1(rws);

   491     w1.Construct(wg,1);

   492     CleanupClosePushL(w1);

   493 

   494     // w1 State 0

   495     TSize size1 (10001,123);

   496     w1.SetSize(size1);

   497     rws.Flush();

   498     

   499     // w1 State Final

   500     CleanupStack::Pop();

   501     w1.Close();

   502     

   503     CleanupStack::Pop();

   504     wg.Close();

   505     

   506     CleanupStack::Pop();

   507     rws.Close();

   508 

   509     __UHEAP_MARKEND;

   510     }

   511 

   512 void CTWindowSizeCacheTest::TestRWindowNoCacheEntryEnableWindowSizeCacheL()

   513     {

   514     __UHEAP_MARK;

   515     // w* State Initial

   516     RWsSession rws;

   517     TInt err = rws.Connect();

   518     CleanupClosePushL(rws);

   519     TEST(err==KErrNone);

   520 

   521     rws.EnableWindowSizeCacheL();

   522 

   523     RWindowGroup wg(rws);

   524     wg.Construct(0);

   525     CleanupClosePushL(rws);

   526 

   527     // w1 State 0

   528     RWindow w1(rws);

   529     w1.Construct(wg,1);

   530     CleanupClosePushL(w1);

   531 

   532     // w1 State 0

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

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

   535     rws.EnableWindowSizeCacheL();

   536     

   537     // w1 State Final

   538     CleanupStack::Pop();

   539     w1.Close();

   540     

   541     CleanupStack::Pop();

   542     wg.Close();

   543     

   544     CleanupStack::Pop();

   545     rws.Close();

   546 

   547     __UHEAP_MARKEND;

   548     }

   549 

   550 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheCleanL(TSizeCacheStatus aEnableWindowSizeCache)

   551     {

   552     __UHEAP_MARK;

   553     // w* State Initial

   554     RWsSession rws;

   555     TInt err = rws.Connect();

   556     CleanupClosePushL(rws);

   557     TEST(err==KErrNone);

   558 

   559     if (aEnableWindowSizeCache)

   560         {

   561         rws.EnableWindowSizeCacheL();

   562         }

   563 

   564     RWindowGroup wg(rws);

   565     wg.Construct(0);

   566     CleanupClosePushL(rws);

   567 

   568     // w1 State 0

   569     RWindow w1(rws);

   570     w1.Construct(wg,1);

   571     CleanupClosePushL(w1);

   572 

   573     // w1 State 0

   574     TSize size1 (10001,123);

   575     w1.SetSize(size1);

   576     rws.Flush();

   577     

   578     // w1 State 1

   579     TSize retSize1 = w1.Size();

   580     TEST(retSize1 == size1);

   581 

   582 #ifdef SYMBIAN_GRAPHICS_FIXNATIVEORIENTATION

   583     TSize retSizeForEgl1 = w1.SizeForEgl();

   584     TEST(retSizeForEgl1 == size1);

   585 #endif

   586 

   587     // w1 State Final

   588     CleanupStack::Pop();

   589     w1.Close();

   590     

   591     CleanupStack::Pop();

   592     wg.Close();

   593     

   594     CleanupStack::Pop();

   595     rws.Close();

   596 

   597     __UHEAP_MARKEND;

   598     }

   599 

   600 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheCleanSizeL(TSizeCacheStatus aEnableWindowSizeCache)

   601     {

   602     __UHEAP_MARK;

   603     // w* State Initial

   604     RWsSession rws;

   605     TInt err = rws.Connect();

   606     CleanupClosePushL(rws);

   607     TEST(err==KErrNone);

   608 

   609     if (aEnableWindowSizeCache)

   610         {

   611         rws.EnableWindowSizeCacheL();

   612         }

   613 

   614     RWindowGroup wg(rws);

   615     wg.Construct(0);

   616     CleanupClosePushL(rws);

   617 

   618     // w1 State 0

   619     RWindow w1(rws);

   620     w1.Construct(wg,1);

   621     CleanupClosePushL(w1);

   622 

   623     // w1 State 0

   624     TSize size1 (10001,123);

   625     w1.SetSize(size1);

   626     rws.Flush();

   627     

   628     // w1 State 1

   629     TSize retSize1 = w1.Size();

   630     TEST(retSize1 == size1);

   631 

   632 #ifdef SYMBIAN_GRAPHICS_FIXNATIVEORIENTATION

   633     TSize retSizeForEgl1 = w1.SizeForEgl();

   634     TEST(retSizeForEgl1 == size1);

   635 #endif

   636 

   637     // w1 State 1

   638     TSize retSize2 = w1.Size();

   639     TEST(retSize2 == size1);

   640 

   641 #ifdef SYMBIAN_GRAPHICS_FIXNATIVEORIENTATION

   642     TSize retSizeForEgl2 = w1.SizeForEgl();

   643     TEST(retSizeForEgl2 == size1);

   644 #endif

   645 

   646     // w1 State Final

   647     CleanupStack::Pop();

   648     w1.Close();

   649     

   650     CleanupStack::Pop();

   651     wg.Close();

   652     

   653     CleanupStack::Pop();

   654     rws.Close();

   655 

   656     __UHEAP_MARKEND;

   657     }

   658 

   659 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheCleanEnableWindowSizeCacheL()

   660     {

   661     __UHEAP_MARK;

   662     // w* State Initial

   663     RWsSession rws;

   664     TInt err = rws.Connect();

   665     CleanupClosePushL(rws);

   666     TEST(err==KErrNone);

   667 

   668     rws.EnableWindowSizeCacheL();

   669 

   670     RWindowGroup wg(rws);

   671     wg.Construct(0);

   672     CleanupClosePushL(rws);

   673 

   674     // w1 State 0

   675     RWindow w1(rws);

   676     w1.Construct(wg,1);

   677     CleanupClosePushL(w1);

   678 

   679     // w1 State 0

   680     TSize size1 (10001,123);

   681     w1.SetSize(size1);

   682     rws.Flush();

   683     

   684     // w1 State 1

   685     TSize retSize1 = w1.Size();

   686     TEST(retSize1 == size1);

   687 

   688 #ifdef SYMBIAN_GRAPHICS_FIXNATIVEORIENTATION

   689     TSize retSizeForEgl1 = w1.SizeForEgl();

   690     TEST(retSizeForEgl1 == size1);

   691 #endif

   692 

   693     // w1 State 1

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

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

   696     rws.EnableWindowSizeCacheL();

   697 

   698     // w1 State Final

   699     CleanupStack::Pop();

   700     w1.Close();

   701     

   702     CleanupStack::Pop();

   703     wg.Close();

   704     

   705     CleanupStack::Pop();

   706     rws.Close();

   707 

   708     __UHEAP_MARKEND;

   709     }

   710 

   711 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheCleanEnableWindowSizeCacheLSizeL()

   712     {

   713     __UHEAP_MARK;

   714     // w* State Initial

   715     RWsSession rws;

   716     TInt err = rws.Connect();

   717     CleanupClosePushL(rws);

   718     TEST(err==KErrNone);

   719 

   720     rws.EnableWindowSizeCacheL();

   721 

   722     RWindowGroup wg(rws);

   723     wg.Construct(0);

   724     CleanupClosePushL(rws);

   725 

   726     // w1 State 0

   727     RWindow w1(rws);

   728     w1.Construct(wg,1);

   729     CleanupClosePushL(w1);

   730 

   731     // w1 State 0

   732     TSize size1 (10001,123);

   733     w1.SetSize(size1);

   734     rws.Flush();

   735     

   736     // w1 State 1

   737     TSize retSize1 = w1.Size();

   738     TEST(retSize1 == size1);

   739 

   740 #ifdef SYMBIAN_GRAPHICS_FIXNATIVEORIENTATION

   741     TSize retSizeForEgl1 = w1.SizeForEgl();

   742     TEST(retSizeForEgl1 == size1);

   743 #endif

   744     

   745     // w1 State 1

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

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

   748     rws.EnableWindowSizeCacheL();

   749 

   750     // w1 State 1

   751     TSize retSize2 = w1.Size();

   752     TEST(retSize2 == size1);

   753 

   754 #ifdef SYMBIAN_GRAPHICS_FIXNATIVEORIENTATION

   755     TSize retSizeForEgl2 = w1.SizeForEgl();

   756     TEST(retSizeForEgl2 == size1);

   757 #endif

   758 

   759     // w1 State Final

   760     CleanupStack::Pop();

   761     w1.Close();

   762     

   763     CleanupStack::Pop();

   764     wg.Close();

   765     

   766     CleanupStack::Pop();

   767     rws.Close();

   768 

   769     __UHEAP_MARKEND;

   770     }

   771 

   772 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeL(TSizeCacheStatus aEnableWindowSizeCache)

   773     {

   774     __UHEAP_MARK;

   775     // w* State Initial

   776     RWsSession rws;

   777     TInt err = rws.Connect();

   778     CleanupClosePushL(rws);

   779     TEST(err==KErrNone);

   780 

   781     if (aEnableWindowSizeCache)

   782         {

   783         rws.EnableWindowSizeCacheL();

   784         }

   785 

   786     RWindowGroup wg(rws);

   787     wg.Construct(0);

   788     CleanupClosePushL(rws);

   789 

   790     // w1 State 0

   791     RWindow w1(rws);

   792     w1.Construct(wg,1);

   793     CleanupClosePushL(w1);

   794 

   795     // w1 State 0

   796     TSize size1 (10001,123);

   797     w1.SetSize(size1);

   798     rws.Flush();

   799     

   800     // w1 State 1

   801     TSize retSize1 = w1.Size();

   802     TEST(retSize1 == size1);

   803 

   804 #ifdef SYMBIAN_GRAPHICS_FIXNATIVEORIENTATION

   805     TSize retSizeForEgl1 = w1.SizeForEgl();

   806     TEST(retSizeForEgl1 == size1);

   807 #endif

   808     

   809     // w1 State 2

   810     TSize size2 (20002,223);

   811     w1.SetSize(size2); 

   812     rws.Flush();

   813 

   814     // w1 State Final

   815     CleanupStack::Pop();

   816     w1.Close();

   817     

   818     CleanupStack::Pop();

   819     wg.Close();

   820     

   821     CleanupStack::Pop();

   822     rws.Close();

   823 

   824     __UHEAP_MARKEND;

   825     }

   826 

   827 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetExtentL(TSizeCacheStatus aEnableWindowSizeCache)

   828     {

   829     __UHEAP_MARK;

   830     // w* State Initial

   831     RWsSession rws;

   832     TInt err = rws.Connect();

   833     CleanupClosePushL(rws);

   834     TEST(err==KErrNone);

   835 

   836     if (aEnableWindowSizeCache)

   837         {

   838         rws.EnableWindowSizeCacheL();

   839         }

   840 

   841     RWindowGroup wg(rws);

   842     wg.Construct(0);

   843     CleanupClosePushL(rws);

   844 

   845     // w1 State 0

   846     RWindow w1(rws);

   847     w1.Construct(wg,1);

   848     CleanupClosePushL(w1);

   849 

   850     // w1 State 0

   851     TSize size1 (10001,123);

   852     w1.SetSize(size1);

   853     rws.Flush();

   854     

   855     // w1 State 1

   856     TSize retSize1 = w1.Size();

   857     TEST(retSize1 == size1);

   858 

   859 #ifdef SYMBIAN_GRAPHICS_FIXNATIVEORIENTATION

   860     TSize retSizeForEgl1 = w1.SizeForEgl();

   861     TEST(retSizeForEgl1 == size1);

   862 #endif

   863     

   864     // w1 State 2

   865     TPoint point2 (20202,223);

   866     TSize size2 (20002,223);

   867     w1.SetExtent(point2, size2); 

   868     rws.Flush();

   869 

   870     // w1 State Final

   871     CleanupStack::Pop();

   872     w1.Close();

   873     

   874     CleanupStack::Pop();

   875     wg.Close();

   876     

   877     CleanupStack::Pop();

   878     rws.Close();

   879 

   880     __UHEAP_MARKEND;

   881     }

   882 

   883 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeErrL(TSizeCacheStatus aEnableWindowSizeCache)

   884     {

   885     __UHEAP_MARK;

   886     // w* State Initial

   887     RWsSession rws;

   888     TInt err = rws.Connect();

   889     CleanupClosePushL(rws);

   890     TEST(err==KErrNone);

   891 

   892     if (aEnableWindowSizeCache)

   893         {

   894         rws.EnableWindowSizeCacheL();

   895         }

   896 

   897     RWindowGroup wg(rws);

   898     wg.Construct(0);

   899     CleanupClosePushL(rws);

   900 

   901     // w1 State 0

   902     RWindow w1(rws);

   903     w1.Construct(wg,1);

   904     CleanupClosePushL(w1);

   905 

   906     // w1 State 0

   907     TSize size1 (10001,123);

   908     w1.SetSize(size1);

   909     rws.Flush();

   910     

   911     // w1 State 1

   912     TSize retSize1 = w1.Size();

   913     TEST(retSize1 == size1);

   914 

   915 #ifdef SYMBIAN_GRAPHICS_FIXNATIVEORIENTATION

   916     TSize retSizeForEgl1 = w1.SizeForEgl();

   917     TEST(retSizeForEgl1 == size1);

   918 #endif

   919     

   920     // w1 State 2

   921     TSize size2 (20002,223);

   922     err = w1.SetSizeErr(size2); 

   923     TEST(KErrNone == err);

   924 

   925     // w1 State Final

   926     CleanupStack::Pop();

   927     w1.Close();

   928     

   929     CleanupStack::Pop();

   930     wg.Close();

   931     

   932     CleanupStack::Pop();

   933     rws.Close();

   934 

   935     __UHEAP_MARKEND;

   936     }

   937 

   938 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetExtentErrL(TSizeCacheStatus aEnableWindowSizeCache)

   939     {

   940     __UHEAP_MARK;

   941     // w* State Initial

   942     RWsSession rws;

   943     TInt err = rws.Connect();

   944     CleanupClosePushL(rws);

   945     TEST(err==KErrNone);

   946 

   947     if (aEnableWindowSizeCache)

   948         {

   949         rws.EnableWindowSizeCacheL();

   950         }

   951 

   952     RWindowGroup wg(rws);

   953     wg.Construct(0);

   954     CleanupClosePushL(rws);

   955 

   956     // w1 State 0

   957     RWindow w1(rws);

   958     w1.Construct(wg,1);

   959     CleanupClosePushL(w1);

   960 

   961     // w1 State 0

   962     TSize size1 (10001,123);

   963     w1.SetSize(size1);

   964     rws.Flush();

   965     

   966     // w1 State 1

   967     TSize retSize1 = w1.Size();

   968     TEST(retSize1 == size1);

   969 

   970 #ifdef SYMBIAN_GRAPHICS_FIXNATIVEORIENTATION

   971     TSize retSizeForEgl1 = w1.SizeForEgl();

   972     TEST(retSizeForEgl1 == size1);

   973 #endif

   974     

   975     // w1 State 2

   976     TPoint point2 (20202,223);

   977     TSize size2 (20002,223);

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

   979     TEST(KErrNone == err);

   980 

   981     // w1 State Final

   982     CleanupStack::Pop();

   983     w1.Close();

   984     

   985     CleanupStack::Pop();

   986     wg.Close();

   987     

   988     CleanupStack::Pop();

   989     rws.Close();

   990 

   991     __UHEAP_MARKEND;

   992     }

   993 

   994 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeTwiceL(TSizeCacheStatus aEnableWindowSizeCache)

   995     {

   996     __UHEAP_MARK;

   997     // w* State Initial

   998     RWsSession rws;

   999     TInt err = rws.Connect();

  1000     CleanupClosePushL(rws);

  1001     TEST(err==KErrNone);

  1002 

  1003     if (aEnableWindowSizeCache)

  1004         {

  1005         rws.EnableWindowSizeCacheL();

  1006         }

  1007 

  1008     RWindowGroup wg(rws);

  1009     wg.Construct(0);

  1010     CleanupClosePushL(rws);

  1011 

  1012     // w1 State 0

  1013     RWindow w1(rws);

  1014     w1.Construct(wg,1);

  1015     CleanupClosePushL(w1);

  1016 

  1017     // w1 State 0

  1018     TSize size1 (10001,123);

  1019     w1.SetSize(size1);

  1020     rws.Flush();

  1021     

  1022     // w1 State 1

  1023     TSize retSize1 = w1.Size();

  1024     TEST(retSize1 == size1);

  1025 

  1026 #ifdef SYMBIAN_GRAPHICS_FIXNATIVEORIENTATION

  1027     TSize retSizeForEgl1 = w1.SizeForEgl();

  1028     TEST(retSizeForEgl1 == size1);

  1029 #endif

  1030     

  1031     // w1 State 2

  1032     TSize size2 (20002,223);

  1033     w1.SetSize(size2); 

  1034 

  1035     TSize size3 (30003,323);

  1036     // w1 State 2

  1037     w1.SetSize(size3); 

  1038     rws.Flush();

  1039 

  1040     // w1 State Final

  1041     CleanupStack::Pop();

  1042     w1.Close();

  1043     

  1044     CleanupStack::Pop();

  1045     wg.Close();

  1046     

  1047     CleanupStack::Pop();

  1048     rws.Close();

  1049 

  1050     __UHEAP_MARKEND;

  1051     }

  1052 

  1053 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeSetExtentL(TSizeCacheStatus aEnableWindowSizeCache)

  1054     {

  1055     __UHEAP_MARK;

  1056     // w* State Initial

  1057     RWsSession rws;

  1058     TInt err = rws.Connect();

  1059     CleanupClosePushL(rws);

  1060     TEST(err==KErrNone);

  1061 

  1062     if (aEnableWindowSizeCache)

  1063         {

  1064         rws.EnableWindowSizeCacheL();

  1065         }

  1066 

  1067     RWindowGroup wg(rws);

  1068     wg.Construct(0);

  1069     CleanupClosePushL(rws);

  1070 

  1071     // w1 State 0

  1072     RWindow w1(rws);

  1073     w1.Construct(wg,1);

  1074     CleanupClosePushL(w1);

  1075 

  1076     // w1 State 0

  1077     TSize size1 (10001,123);

  1078     w1.SetSize(size1);

  1079     rws.Flush();

  1080     

  1081     // w1 State 1

  1082     TSize retSize1 = w1.Size();

  1083     TEST(retSize1 == size1);

  1084 

  1085 #ifdef SYMBIAN_GRAPHICS_FIXNATIVEORIENTATION

  1086     TSize retSizeForEgl1 = w1.SizeForEgl();

  1087     TEST(retSizeForEgl1 == size1);

  1088 #endif

  1089     

  1090     // w1 State 2

  1091     TSize size2 (20002,223);

  1092     w1.SetSize(size2); 

  1093 

  1094     // w1 State 2

  1095     TPoint point3 (30303,232);

  1096     TSize size3 (30003,323);

  1097     w1.SetExtent(point3, size3); 

  1098     rws.Flush();

  1099 

  1100     // w1 State Final

  1101     CleanupStack::Pop();

  1102     w1.Close();

  1103     

  1104     CleanupStack::Pop();

  1105     wg.Close();

  1106     

  1107     CleanupStack::Pop();

  1108     rws.Close();

  1109 

  1110     __UHEAP_MARKEND;

  1111     }

  1112 

  1113 void CTWindowSizeCacheTest::TestRWindowCacheEntryExistsCacheDirtySetSizeSetSizeErrL(TSizeCacheStatus aEnableWindowSizeCache)

  1114     {

  1115     __UHEAP_MARK;

  1116     // w* State Initial

  1117     RWsSession rws;

  1118     TInt err = rws.Connect();

  1119     CleanupClosePushL(rws);

  1120     TEST(err==KErrNone);

  1121 

  1122     if (aEnableWindowSizeCache)

  1123         {

  1124         rws.EnableWindowSizeCacheL();

  1125         }

  1126 

  1127     RWindowGroup wg(rws);

  1128     wg.Construct(0);

  1129     CleanupClosePushL(rws);

  1130 

  1131     // w1 State 0

  1132     RWindow w1(rws);

  1133     w1.Construct(wg,1);

  1134     CleanupClosePushL(w1);

  1135