startupservices/startupanimation/tsrc/TSanimengine/src/TSanimengineBlocks.cpp
changeset 77 b01c07dfcf84
equal deleted inserted replaced
74:1505405bc645 77:b01c07dfcf84
       
     1 /*
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 * 
       
    14 * Description: This file contains testclass implementation.
       
    15 *
       
    16 */
       
    17 
       
    18 // [INCLUDE FILES] - do not remove
       
    19 #include <e32svr.h>
       
    20 #include <StifParser.h>
       
    21 #include <StifTestInterface.h>
       
    22 #include "TSanimengine.h"
       
    23 
       
    24 
       
    25 #include "sanimengine.h"
       
    26 #include "testwaiter.h"
       
    27 
       
    28 #include <ecom/ecom.h>
       
    29 
       
    30 //#pragma tagging OFF // To disable CodeTest tagging
       
    31 
       
    32 _LIT( KImageOutputFile, "C:\\temp\\sanimimagetestoutput.txt" );
       
    33 _LIT( KToneOutputFile, "C:\\temp\\sanimtonetestoutput.txt" );
       
    34 _LIT( KFileNoExtension, "C:\\temp\\test" ); // There is no plug-in for this type
       
    35 _LIT( KFileTooLongExtension, "C:\\temp\\test.xxxxxxxxxxxxxxxx" ); // There is no plug-in for this type
       
    36 _LIT( KDummyImageFile1, "C:\\temp\\test.ti1" ); // There is no plug-in for this type
       
    37 _LIT( KDummyImageFile2, "C:\\temp\\test.ti2" ); // There is a plug-in for this type
       
    38 _LIT( KDummyImageFile3, "C:\\temp\\test.ti3" ); // There are multiple plug-ins for this type
       
    39 _LIT( KDummyImageFile4, "C:\\temp\\test.ti6" ); // Wildcard match
       
    40 _LIT( KDummyImageFile5, "C:\\temp\\test.ti5" ); // This plug-in returns error
       
    41 _LIT( KDummyImageFile6, "C:\\temp\\test.zzz.ti2" ); // There is a plug-in for this type
       
    42 _LIT( KDummyToneFile1, "C:\\temp\\test.tt1" ); // There is no plug-in for this type
       
    43 _LIT( KDummyToneFile2, "C:\\temp\\test.tt2" ); // There is a plug-in for this type
       
    44 _LIT( KDummyToneFile3, "C:\\temp\\test.tt3" ); // There are multiple plug-ins for this type
       
    45 _LIT( KDummyToneFile4, "C:\\temp\\test.tt6" ); // Wildcard match
       
    46 _LIT( KDummyToneFile5, "C:\\temp\\test.tt5" ); // This plug-in returns error
       
    47 
       
    48 const TUint32 KImagePlugin1ImplUid = 0x0AA01513;
       
    49 const TUint32 KImagePlugin2ImplUid = 0x0AA01515;
       
    50 const TUint32 KImagePlugin3ImplUid = 0x0AA01517;
       
    51 const TUint32 KImagePlugin4ImplUid = 0x0AA01519;
       
    52 const TUint32 KTonePlugin1ImplUid = 0x0AA0150B;
       
    53 const TUint32 KTonePlugin2ImplUid = 0x0AA0150D;
       
    54 const TUint32 KTonePlugin3ImplUid = 0x0AA0150F;
       
    55 const TUint32 KTonePlugin4ImplUid = 0x0AA01511;
       
    56 
       
    57 
       
    58 
       
    59 
       
    60 void CTSanimengine::Delete() 
       
    61     {
       
    62 
       
    63     }
       
    64 
       
    65 // -----------------------------------------------------------------------------
       
    66 // CTSanimengine::RunMethodL
       
    67 // Run specified method. Contains also table of test mothods and their names.
       
    68 // -----------------------------------------------------------------------------
       
    69 //
       
    70 TInt CTSanimengine::RunMethodL( 
       
    71     CStifItemParser& aItem ) 
       
    72     {
       
    73 
       
    74     static TStifFunctionInfo const KFunctions[] =
       
    75         {  
       
    76         // Copy this line for every implemented function.
       
    77         // First string is the function name used in TestScripter script file.
       
    78         // Second is the actual implementation member function. 
       
    79         ENTRY( "Example", CTSanimengine::ExampleL ),
       
    80         ENTRY( "SetupEmpty", CTSanimengine::SetupEmptyL),
       
    81         ENTRY( "SetupObj", CTSanimengine::SetupObjL),
       
    82         ENTRY( "SetupImagePlugin", CTSanimengine::SetupImagePluginL),
       
    83         ENTRY( "SetupTonePlugin", CTSanimengine::SetupTonePluginL),
       
    84         ENTRY( "SetupBothPlugins", CTSanimengine::SetupBothPluginsL),
       
    85         ENTRY( "SetupImagePluginFaster", CTSanimengine::SetupImagePluginFasterL),
       
    86         ENTRY( "SetupTonePluginFaster", CTSanimengine::SetupTonePluginFasterL),
       
    87         ENTRY( "SetupImagePluginReturnsError", CTSanimengine::SetupImagePluginReturnsErrorL),
       
    88         ENTRY( "SetupTonePluginReturnsError", CTSanimengine::SetupTonePluginReturnsErrorL),
       
    89         ENTRY( "Load", CTSanimengine::LoadL),      
       
    90         ENTRY( "SetupImageLoaded", CTSanimengine::SetupImageLoadedL),
       
    91         ENTRY( "SetupToneLoaded", CTSanimengine::SetupToneLoadedL),
       
    92         ENTRY( "SetupBothLoaded", CTSanimengine::SetupBothLoadedL),
       
    93         ENTRY( "SetupLoadFailed", CTSanimengine::SetupLoadFailedL),     
       
    94         ENTRY( "SetupBothFinished", CTSanimengine::SetupBothFinishedL),
       
    95         ENTRY( "Teardown", CTSanimengine::Teardown),
       
    96         ENTRY( "SetupBothPluginsReturnError", CTSanimengine::SetupBothPluginsReturnErrorL),     
       
    97         
       
    98         ENTRY( "TestConstructor", CTSanimengine::TestConstructorL),
       
    99         ENTRY( "TestConstructorNoMemory", CTSanimengine::TestConstructorNoMemoryL),
       
   100         ENTRY( "TestExtensionlessFile", CTSanimengine::TestExtensionlessFileL), 
       
   101         ENTRY( "TestTooLongExtension", CTSanimengine::TestTooLongExtensionL), 
       
   102         ENTRY( "SetImagePropertiesUnknownExtension", CTSanimengine::SetImagePropertiesUnknownExtensionL), 
       
   103         ENTRY( "SetImagePropertiesKnownExtension", CTSanimengine::SetImagePropertiesKnownExtensionL),
       
   104         ENTRY( "SetImagePropertiesUnknownExtensionNoMemory", CTSanimengine::SetImagePropertiesUnknownExtensionNoMemoryL),
       
   105         ENTRY( "SetImagePropertiesKnownExtensionNoMemory", CTSanimengine::SetImagePropertiesKnownExtensionNoMemoryL),
       
   106         ENTRY( "SetImagePropertiesManyExtensions", CTSanimengine::SetImagePropertiesManyExtensionsL),    
       
   107         ENTRY( "SetImagePropertiesManyExtensionsNoMemory", CTSanimengine::SetImagePropertiesManyExtensionsNoMemoryL),
       
   108         ENTRY( "SetImagePropertiesManyPlugins", CTSanimengine::SetImagePropertiesManyPluginsL), 
       
   109         ENTRY( "SetImagePropertiesManyPluginsNoMemory", CTSanimengine::SetImagePropertiesManyPluginsNoMemoryL), 
       
   110         ENTRY( "SetImagePropertiesWildcardMatch", CTSanimengine::SetImagePropertiesWildcardMatchL), 
       
   111         ENTRY( "SetImagePropertiesWildcardMatchNoMemory", CTSanimengine::SetImagePropertiesWildcardMatchNoMemoryL), 
       
   112         ENTRY( "SetTonePropertiesUnknownExtension", CTSanimengine::SetTonePropertiesUnknownExtensionL), 
       
   113         ENTRY( "SetTonePropertiesUnknownExtensionNoMemory", CTSanimengine::SetTonePropertiesUnknownExtensionNoMemoryL), 
       
   114         ENTRY( "SetTonePropertiesKnownExtension", CTSanimengine::SetTonePropertiesKnownExtensionL), 
       
   115         ENTRY( "SetTonePropertiesKnownExtensionNoMemory", CTSanimengine::SetTonePropertiesKnownExtensionNoMemoryL), 
       
   116         ENTRY( "SetTonePropertiesManyPlugins", CTSanimengine::SetTonePropertiesManyPluginsL),         
       
   117         ENTRY( "SetTonePropertiesManyPluginsNoMemory", CTSanimengine::SetTonePropertiesManyPluginsNoMemoryL), 
       
   118         ENTRY( "SetTonePropertiesWildcardMatch", CTSanimengine::SetTonePropertiesWildcardMatchL), 
       
   119         ENTRY( "SetTonePropertiesWildcardMatchNoMemory", CTSanimengine::SetTonePropertiesWildcardMatchNoMemoryL),
       
   120         ENTRY( "TestLoadEmpty", CTSanimengine::TestLoadEmptyL), 
       
   121         ENTRY( "TestCancelLoadEmpty", CTSanimengine::TestCancelLoadEmptyL), 
       
   122         ENTRY( "TestLoadNoMemory", CTSanimengine::TestLoadNoMemoryL), 
       
   123         ENTRY( "TestCancelLoad", CTSanimengine::TestCancelLoadL), 
       
   124         ENTRY( "TestLoadImagePluginFaster", CTSanimengine::TestLoadImagePluginFasterL), 
       
   125         ENTRY( "TestLoadTonePluginFaster", CTSanimengine::TestLoadTonePluginFasterL), 
       
   126         ENTRY( "TestLoadImagePluginReturnsError", CTSanimengine::TestLoadImagePluginReturnsErrorL), 
       
   127 
       
   128         ENTRY( "TestLoadTonePluginReturnsError", CTSanimengine::TestLoadTonePluginReturnsErrorL), 
       
   129         ENTRY( "TestBackroundColour", CTSanimengine::TestBackroundColourL), 
       
   130         ENTRY( "TestCancelNotActive", CTSanimengine::TestCancelNotActiveL), 
       
   131         ENTRY( "TestLoadWhenActive", CTSanimengine::TestLoadWhenActiveL), 
       
   132         ENTRY( "TestStartWhenActive", CTSanimengine::TestStartWhenActiveL), 
       
   133         ENTRY( "TestStart", CTSanimengine::TestStartL),       
       
   134         
       
   135         ENTRY( "TestStartNotReady", CTSanimengine::TestStartNotReadyL), 
       
   136         ENTRY( "TestLoadAgain", CTSanimengine::TestLoadAgainL), 
       
   137         ENTRY( "TestStartAgain", CTSanimengine::TestStartAgainL), 
       
   138         ENTRY( "TestLoadAndStartAnotherShow", CTSanimengine::TestLoadAndStartAnotherShowL), 
       
   139         ENTRY( "TestLoadAndStartEmptyShowAfterAnotherShow", CTSanimengine::TestLoadAndStartEmptyShowAfterAnotherShowL), 
       
   140         ENTRY( "TestStartWhenLoadFailed", CTSanimengine::TestStartWhenLoadFailedL),         
       
   141                                              
       
   142      
       
   143      
       
   144          
       
   145          
       
   146         //ADD NEW ENTRY HERE
       
   147         // [test cases entries] - Do not remove
       
   148 
       
   149         };
       
   150 
       
   151     const TInt count = sizeof( KFunctions ) / 
       
   152                         sizeof( TStifFunctionInfo );
       
   153 
       
   154     return RunInternalL( KFunctions, count, aItem );
       
   155 
       
   156     }
       
   157 
       
   158 // ======== MEMBER FUNCTIONS ========
       
   159 
       
   160 
       
   161 // ---------------------------------------------------------------------------
       
   162 // CTSanimengine::SetupEmptyL
       
   163 //
       
   164 // ---------------------------------------------------------------------------
       
   165 //
       
   166 TInt CTSanimengine::SetupEmptyL()
       
   167     {
       
   168     User::LeaveIfError( iFs.Connect() );
       
   169 
       
   170     RFile file;
       
   171     file.Replace( iFs, KImageOutputFile, EFileShareAny | EFileWrite );
       
   172     file.Replace( iFs, KToneOutputFile, EFileShareAny | EFileWrite );
       
   173     file.Close();
       
   174 
       
   175     iTestObj = NULL;
       
   176     iWaiter = CTestWaiter::NewL();
       
   177     iWaiter2 = CTestWaiter::NewL();
       
   178     return KErrNone;
       
   179     }
       
   180 
       
   181 
       
   182 // ---------------------------------------------------------------------------
       
   183 // CTSanimengine::SetupObjL
       
   184 //
       
   185 // ---------------------------------------------------------------------------
       
   186 //
       
   187 TInt CTSanimengine::SetupObjL()
       
   188     {
       
   189     SetupEmptyL();
       
   190     iTestObj = CSAnimEngine::NewL( iFs, iObserver );
       
   191     return KErrNone;
       
   192     }
       
   193 
       
   194 
       
   195 // ---------------------------------------------------------------------------
       
   196 // CTSanimengine::SetupImagePluginL
       
   197 //
       
   198 // ---------------------------------------------------------------------------
       
   199 //
       
   200 TInt CTSanimengine::SetupImagePluginL()
       
   201     {
       
   202     SetupObjL();
       
   203     User::LeaveIfError(
       
   204         iTestObj->SetImageProperties( KDummyImageFile2, EGray2, TSize( 0, 0 ), 0, ETrue, 1 ) );
       
   205     return KErrNone;
       
   206     }
       
   207 
       
   208 
       
   209 // ---------------------------------------------------------------------------
       
   210 // CTSanimengine::SetupTonePluginL
       
   211 //
       
   212 // ---------------------------------------------------------------------------
       
   213 //
       
   214 TInt CTSanimengine::SetupTonePluginL()
       
   215     {
       
   216     SetupObjL();
       
   217     User::LeaveIfError( iTestObj->SetToneProperties( KDummyToneFile2, 4, 0, 1 ) );
       
   218     return KErrNone;
       
   219     }
       
   220 
       
   221 
       
   222 // ---------------------------------------------------------------------------
       
   223 // CTSanimengine::SetupBothPluginsL
       
   224 //
       
   225 // ---------------------------------------------------------------------------
       
   226 //
       
   227 TInt CTSanimengine::SetupBothPluginsL()
       
   228     {
       
   229     SetupObjL();
       
   230     User::LeaveIfError(
       
   231         iTestObj->SetImageProperties( KDummyImageFile2, EGray2, TSize( 0, 0 ), 0, ETrue, 1 ) );
       
   232     User::LeaveIfError( iTestObj->SetToneProperties( KDummyToneFile2, 4, 0, 1 ) );
       
   233     return KErrNone;
       
   234     }
       
   235 
       
   236 
       
   237 // ---------------------------------------------------------------------------
       
   238 // CTSanimengine::SetupImagePluginFasterL
       
   239 //
       
   240 // ---------------------------------------------------------------------------
       
   241 //
       
   242 TInt CTSanimengine::SetupImagePluginFasterL()
       
   243     {
       
   244     SetupObjL();
       
   245     User::LeaveIfError(
       
   246         iTestObj->SetImageProperties( KDummyImageFile2, EGray2, TSize( 0, 0 ), 0, ETrue, 1 ) );
       
   247     User::LeaveIfError( iTestObj->SetToneProperties( KDummyToneFile4, 4, 0, 1 ) );
       
   248     return KErrNone;
       
   249     }
       
   250 
       
   251 
       
   252 // ---------------------------------------------------------------------------
       
   253 // CTSanimengine::SetupTonePluginFasterL
       
   254 //
       
   255 // ---------------------------------------------------------------------------
       
   256 //
       
   257 TInt CTSanimengine::SetupTonePluginFasterL()
       
   258     {
       
   259     SetupObjL();
       
   260     User::LeaveIfError(
       
   261         iTestObj->SetImageProperties( KDummyImageFile4, EGray2, TSize( 0, 0 ), 0, ETrue, 1 ) );
       
   262     User::LeaveIfError( iTestObj->SetToneProperties( KDummyToneFile2, 4, 0, 1 ) );
       
   263     return KErrNone;
       
   264     }
       
   265 
       
   266 
       
   267 // ---------------------------------------------------------------------------
       
   268 // CTSanimengine::SetupImagePluginReturnsErrorL
       
   269 //
       
   270 // ---------------------------------------------------------------------------
       
   271 //
       
   272 TInt CTSanimengine::SetupImagePluginReturnsErrorL()
       
   273     {
       
   274     SetupObjL();
       
   275     User::LeaveIfError(
       
   276         iTestObj->SetImageProperties( KDummyImageFile5, EGray2, TSize( 0, 0 ), 0, ETrue, 1 ) );
       
   277     User::LeaveIfError( iTestObj->SetToneProperties( KDummyToneFile2, 4, 0, 1 ) );
       
   278     return KErrNone;
       
   279     }
       
   280 
       
   281 
       
   282 // ---------------------------------------------------------------------------
       
   283 // CTSanimengine::SetupTonePluginReturnsErrorL
       
   284 //
       
   285 // ---------------------------------------------------------------------------
       
   286 //
       
   287 TInt CTSanimengine::SetupTonePluginReturnsErrorL()
       
   288     {
       
   289     SetupObjL();
       
   290     User::LeaveIfError(
       
   291         iTestObj->SetImageProperties( KDummyImageFile2, EGray2, TSize( 0, 0 ), 0, ETrue, 1 ) );
       
   292     User::LeaveIfError( iTestObj->SetToneProperties( KDummyToneFile5, 4, 0, 1 ) );
       
   293     return KErrNone;
       
   294     }
       
   295 
       
   296 
       
   297 // ---------------------------------------------------------------------------
       
   298 // CTSanimengine::SetupBothPluginsReturnErrorL
       
   299 //
       
   300 // ---------------------------------------------------------------------------
       
   301 //
       
   302 TInt CTSanimengine::SetupBothPluginsReturnErrorL()
       
   303     {
       
   304     SetupObjL();
       
   305     User::LeaveIfError(
       
   306         iTestObj->SetImageProperties( KDummyImageFile5, EGray2, TSize( 0, 0 ), 0, ETrue, 1 ) );
       
   307     User::LeaveIfError( iTestObj->SetToneProperties( KDummyToneFile5, 4, 0, 1 ) );
       
   308     return KErrNone;
       
   309     }
       
   310 
       
   311 
       
   312 // ---------------------------------------------------------------------------
       
   313 // CTSanimengine::LoadL
       
   314 //
       
   315 // ---------------------------------------------------------------------------
       
   316 //
       
   317 TInt CTSanimengine::LoadL()
       
   318     {
       
   319     iTestObj->Load( iWaiter->iStatus );
       
   320     iWaiter->Activate();
       
   321     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
   322     User::LeaveIfError( iWaiter->iStatus.Int() );
       
   323     return KErrNone;
       
   324     }
       
   325 
       
   326 
       
   327 // ---------------------------------------------------------------------------
       
   328 // CTSanimengine::SetupImageLoadedL
       
   329 //
       
   330 // ---------------------------------------------------------------------------
       
   331 //
       
   332 TInt CTSanimengine::SetupImageLoadedL()
       
   333     {
       
   334     SetupImagePluginL();
       
   335     LoadL();
       
   336     return KErrNone;
       
   337     }
       
   338 
       
   339 
       
   340 // ---------------------------------------------------------------------------
       
   341 // CTSanimengine::SetupToneLoadedL
       
   342 //
       
   343 // ---------------------------------------------------------------------------
       
   344 //
       
   345 TInt CTSanimengine::SetupToneLoadedL()
       
   346     {
       
   347     SetupTonePluginL();
       
   348     LoadL();
       
   349     return KErrNone;
       
   350     }
       
   351 
       
   352 
       
   353 // ---------------------------------------------------------------------------
       
   354 // CTSanimengine::SetupBothLoadedL
       
   355 //
       
   356 // ---------------------------------------------------------------------------
       
   357 //
       
   358 TInt CTSanimengine::SetupBothLoadedL()
       
   359     {
       
   360     SetupBothPluginsL();
       
   361     LoadL();
       
   362     return KErrNone;
       
   363     }
       
   364 
       
   365 
       
   366 // ---------------------------------------------------------------------------
       
   367 // CTSanimengine::SetupLoadFailedL
       
   368 //
       
   369 // ---------------------------------------------------------------------------
       
   370 //
       
   371 TInt CTSanimengine::SetupLoadFailedL()
       
   372     {
       
   373     SetupBothPluginsReturnErrorL();
       
   374     iTestObj->Load( iWaiter->iStatus );
       
   375     iWaiter->Activate();
       
   376     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
   377     return KErrNone;
       
   378     }
       
   379 
       
   380 
       
   381 // ---------------------------------------------------------------------------
       
   382 // CTSanimengine::SetupBothFinishedL
       
   383 //
       
   384 // ---------------------------------------------------------------------------
       
   385 //
       
   386 TInt CTSanimengine::SetupBothFinishedL()
       
   387     {
       
   388     SetupBothLoadedL();
       
   389     iTestObj->Start( iWaiter->iStatus );
       
   390     iWaiter->Activate();
       
   391     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
   392     User::LeaveIfError( iWaiter->iStatus.Int() );
       
   393     return KErrNone;
       
   394     }
       
   395 
       
   396 
       
   397 // ---------------------------------------------------------------------------
       
   398 // CTSanimengine::Teardown
       
   399 //
       
   400 // ---------------------------------------------------------------------------
       
   401 //
       
   402 TInt CTSanimengine::Teardown()
       
   403     {
       
   404     delete iWaiter2;
       
   405     iWaiter2 = NULL;
       
   406     delete iWaiter;
       
   407     iWaiter = NULL;
       
   408     delete iTestObj;
       
   409     iTestObj = NULL;
       
   410     iFs.Close();
       
   411 
       
   412     REComSession::FinalClose();
       
   413     return KErrNone;
       
   414     }
       
   415 
       
   416 
       
   417 // ---------------------------------------------------------------------------
       
   418 // CTSanimengine::CheckNoImagePluginOutputL
       
   419 //
       
   420 // ---------------------------------------------------------------------------
       
   421 //
       
   422 TBool CTSanimengine::CheckNoImagePluginOutputL()
       
   423     {
       
   424     RFile file;
       
   425     CleanupClosePushL( file );
       
   426     User::LeaveIfError(
       
   427         file.Open( iFs, KImageOutputFile, EFileShareAny | EFileRead ) );
       
   428 
       
   429     TFileText reader;
       
   430     reader.Set( file );
       
   431     TBuf<16> buf;
       
   432     TBool retVal = ( reader.Read( buf ) == KErrEof );
       
   433 
       
   434     CleanupStack::PopAndDestroy( &file );
       
   435     return retVal;
       
   436     }
       
   437 
       
   438 
       
   439 // ---------------------------------------------------------------------------
       
   440 // CTSanimengine::CheckImagePluginOutputL
       
   441 //
       
   442 // ---------------------------------------------------------------------------
       
   443 //
       
   444 TBool CTSanimengine::CheckImagePluginOutputL(
       
   445     const TUint32 aPluginUid,
       
   446     const TDesC& aFileToLoad,
       
   447     const TInt aDisplayMode,
       
   448     const TSize& aSize,
       
   449     const TInt aFrameDelay )
       
   450     {
       
   451     RFile file;
       
   452     CleanupClosePushL( file );
       
   453     User::LeaveIfError(
       
   454         file.Open( iFs, KImageOutputFile, EFileShareAny | EFileRead ) );
       
   455 
       
   456     TFileText reader;
       
   457     reader.Set( file );
       
   458 
       
   459     TBool retVal = ETrue;
       
   460     TBuf<256> buf;
       
   461     TLex16 lex;
       
   462 
       
   463     User::LeaveIfError( reader.Read( buf ) );
       
   464     TUint32 uidFromFile;
       
   465     lex.Assign( buf );
       
   466     User::LeaveIfError( lex.Val( uidFromFile, EHex ) );
       
   467     if ( uidFromFile != aPluginUid )
       
   468         {
       
   469       //  EUNIT_PRINT( _L( "Plugin UID mismatch: expected 0x%08x, got 0x%08x" ), aPluginUid, uidFromFile );
       
   470         retVal = EFalse;
       
   471         }
       
   472 
       
   473     User::LeaveIfError( reader.Read( buf ) );
       
   474     if ( buf != aFileToLoad )
       
   475         {
       
   476       //  EUNIT_PRINT( _L( "File name mismatch: expected %S, got %S" ), &aFileToLoad, &buf );
       
   477         retVal = EFalse;
       
   478         }
       
   479 
       
   480     User::LeaveIfError( reader.Read( buf ) );
       
   481     TInt modeFromFile;
       
   482     lex.Assign( buf );
       
   483     User::LeaveIfError( lex.Val( modeFromFile ) );
       
   484     if ( modeFromFile != aDisplayMode )
       
   485         {
       
   486      //   EUNIT_PRINT( _L( "Display mode mismatch: expected %d, got %d" ), aDisplayMode, modeFromFile );
       
   487         retVal = EFalse;
       
   488         }
       
   489 
       
   490     User::LeaveIfError( reader.Read( buf ) );
       
   491     TInt widthFromFile;
       
   492     lex.Assign( buf );
       
   493     User::LeaveIfError( lex.Val( widthFromFile ) );
       
   494     User::LeaveIfError( reader.Read( buf ) );
       
   495     TInt heightFromFile;
       
   496     lex.Assign( buf );
       
   497     User::LeaveIfError( lex.Val( heightFromFile ) );
       
   498     if ( widthFromFile != aSize.iWidth || heightFromFile != aSize.iHeight )
       
   499         {
       
   500       //  EUNIT_PRINT( _L( "Size mismatch: expected (%d,%d), got (%d,%d)" ),
       
   501      //       aSize.iWidth, aSize.iHeight, widthFromFile, heightFromFile );
       
   502         retVal = EFalse;
       
   503         }
       
   504 
       
   505     User::LeaveIfError( reader.Read( buf ) );
       
   506     TUint delayFromFile;
       
   507     lex.Assign( buf );
       
   508     User::LeaveIfError( lex.Val( delayFromFile ) );
       
   509     if ( delayFromFile != aFrameDelay )
       
   510         {
       
   511    //     EUNIT_PRINT( _L( "Frame delay mismatch: expected %d, got %d" ), aFrameDelay, delayFromFile );
       
   512         retVal = EFalse;
       
   513         }
       
   514 
       
   515     CleanupStack::PopAndDestroy( &file );
       
   516     return retVal;
       
   517     }
       
   518 
       
   519 
       
   520 // ---------------------------------------------------------------------------
       
   521 // CTSanimengine::CheckNoTonePluginOutputL
       
   522 //
       
   523 // ---------------------------------------------------------------------------
       
   524 //
       
   525 TBool CTSanimengine::CheckNoTonePluginOutputL()
       
   526     {
       
   527     RFile file;
       
   528     CleanupClosePushL( file );
       
   529     User::LeaveIfError(
       
   530         file.Open( iFs, KToneOutputFile, EFileShareAny | EFileRead ) );
       
   531 
       
   532     TFileText reader;
       
   533     reader.Set( file );
       
   534     TBuf<16> buf;
       
   535     TBool retVal = ( reader.Read( buf ) == KErrEof );
       
   536 
       
   537     CleanupStack::PopAndDestroy( &file );
       
   538     return retVal;
       
   539     }
       
   540 
       
   541 
       
   542 // ---------------------------------------------------------------------------
       
   543 // CTSanimengine::CheckTonePluginOutputL
       
   544 //
       
   545 // ---------------------------------------------------------------------------
       
   546 //
       
   547 TBool CTSanimengine::CheckTonePluginOutputL(
       
   548     const TUint32 aPluginUid,
       
   549     const TDesC& aFileToLoad,
       
   550     const TInt aVolume,
       
   551     const TInt64& aVolumeRamp )
       
   552     {
       
   553     RFile file;
       
   554     CleanupClosePushL( file );
       
   555     User::LeaveIfError(
       
   556         file.Open( iFs, KToneOutputFile, EFileShareAny | EFileRead ) );
       
   557 
       
   558     TFileText reader;
       
   559     reader.Set( file );
       
   560 
       
   561     TBool retVal = ETrue;
       
   562     TBuf<256> buf;
       
   563     TLex16 lex;
       
   564 
       
   565     User::LeaveIfError( reader.Read( buf ) );
       
   566     TUint32 uidFromFile;
       
   567     lex.Assign( buf );
       
   568     User::LeaveIfError( lex.Val( uidFromFile, EHex ) );
       
   569     if ( uidFromFile != aPluginUid )
       
   570         {
       
   571    //     EUNIT_PRINT(
       
   572      //       _L( "Plugin UID mismatch: expected 0x%08x, got 0x%08x" ), aPluginUid, uidFromFile );
       
   573         retVal = EFalse;
       
   574         }
       
   575 
       
   576     User::LeaveIfError( reader.Read( buf ) );
       
   577     if ( buf != aFileToLoad )
       
   578         {
       
   579   //      EUNIT_PRINT( _L( "File name mismatch: expected %S, got %S" ), &aFileToLoad, &buf );
       
   580         retVal = EFalse;
       
   581         }
       
   582 
       
   583     User::LeaveIfError( reader.Read( buf ) );
       
   584     TInt volumeFromFile;
       
   585     lex.Assign( buf );
       
   586     User::LeaveIfError( lex.Val( volumeFromFile ) );
       
   587     if ( volumeFromFile != aVolume )
       
   588         {
       
   589   //      EUNIT_PRINT( _L( "Volume mismatch: expected %d, got %d" ), aVolume, volumeFromFile );
       
   590         retVal = EFalse;
       
   591         }
       
   592 
       
   593     User::LeaveIfError( reader.Read( buf ) );
       
   594     TInt64 volumeRampFromFile;
       
   595     lex.Assign( buf );
       
   596     User::LeaveIfError( lex.Val( volumeRampFromFile ) );
       
   597     if ( volumeRampFromFile != aVolumeRamp )
       
   598         {
       
   599    //     EUNIT_PRINT(
       
   600    //         _L( "Volume ramp mismatch: expected %d, got %d" ), aVolumeRamp, volumeRampFromFile );
       
   601         retVal = EFalse;
       
   602         }
       
   603 
       
   604     CleanupStack::PopAndDestroy( &file );
       
   605     return retVal;
       
   606     }
       
   607 
       
   608 
       
   609 // ---------------------------------------------------------------------------
       
   610 // CTSanimengine::TestConstructorL
       
   611 //
       
   612 // ---------------------------------------------------------------------------
       
   613 //
       
   614 TInt CTSanimengine::TestConstructorL()
       
   615     {
       
   616     iTestObj = CSAnimEngine::NewL( iFs, iObserver );
       
   617     delete iTestObj;
       
   618     iTestObj = NULL;
       
   619     return KErrNone;
       
   620     }
       
   621 
       
   622 
       
   623 // ---------------------------------------------------------------------------
       
   624 // CTSanimengine::TestConstructorNoMemoryL
       
   625 //
       
   626 // ---------------------------------------------------------------------------
       
   627 //
       
   628 TInt CTSanimengine::TestConstructorNoMemoryL()
       
   629     {
       
   630     iTestObj = CSAnimEngine::NewL( iFs, iObserver );
       
   631    // EUNIT_ASSERT( !iTestObj );
       
   632     return KErrNone;
       
   633     }
       
   634 
       
   635 
       
   636 // ---------------------------------------------------------------------------
       
   637 // CTSanimengine::TestExtensionlessFileL
       
   638 //
       
   639 // ---------------------------------------------------------------------------
       
   640 //
       
   641 TInt CTSanimengine::TestExtensionlessFileL()
       
   642     {
       
   643     TInt errorCode =
       
   644         iTestObj->SetImageProperties( KFileNoExtension, EGray2, TSize( 0, 0 ), 0, ETrue, 1 );
       
   645     if (errorCode == KErrNotFound )
       
   646         return KErrNone;
       
   647     
       
   648     return KErrNone;
       
   649     }
       
   650 
       
   651 
       
   652 // ---------------------------------------------------------------------------
       
   653 // CTSanimengine::TestTooLongExtensionL
       
   654 //
       
   655 // ---------------------------------------------------------------------------
       
   656 //
       
   657 TInt CTSanimengine::TestTooLongExtensionL()
       
   658     {
       
   659     TInt errorCode = iTestObj->SetToneProperties( KFileTooLongExtension, 4, 0, 1 );
       
   660     if ( errorCode == KErrNotFound )
       
   661         return KErrNone;
       
   662     
       
   663     return KErrNone;
       
   664     }
       
   665 
       
   666 
       
   667 // ---------------------------------------------------------------------------
       
   668 // CTSanimengine::SetImagePropertiesUnknownExtensionL
       
   669 //
       
   670 // ---------------------------------------------------------------------------
       
   671 //
       
   672 TInt CTSanimengine::SetImagePropertiesUnknownExtensionL()
       
   673     {
       
   674     TInt errorCode =
       
   675         iTestObj->SetImageProperties( KDummyImageFile1, EGray2, TSize( 0, 0 ), 0, ETrue, 1 );
       
   676     if ( errorCode == KErrNotFound )
       
   677         return KErrNone;
       
   678     
       
   679     return KErrNone;
       
   680     }
       
   681 
       
   682 
       
   683 // ---------------------------------------------------------------------------
       
   684 // CTSanimengine::SetImagePropertiesUnknownExtensionNoMemoryL
       
   685 //
       
   686 // ---------------------------------------------------------------------------
       
   687 //
       
   688 TInt CTSanimengine::SetImagePropertiesUnknownExtensionNoMemoryL()
       
   689     {
       
   690     TInt errorCode =
       
   691         iTestObj->SetImageProperties( KDummyImageFile1, EGray2, TSize( 0, 0 ), 0, ETrue, 1 );
       
   692      if (errorCode == KErrNoMemory  )
       
   693          return KErrNone;
       
   694     return KErrNone;
       
   695     }
       
   696 
       
   697 
       
   698 // ---------------------------------------------------------------------------
       
   699 // CTSanimengine::SetImagePropertiesKnownExtensionL
       
   700 //
       
   701 // ---------------------------------------------------------------------------
       
   702 //
       
   703 TInt CTSanimengine::SetImagePropertiesKnownExtensionL()
       
   704     {
       
   705     TInt errorCode =
       
   706         iTestObj->SetImageProperties( KDummyImageFile2, EGray2, TSize( 0, 0 ), 0, ETrue, 1 );
       
   707  //   EUNIT_ASSERT_EQUALS( errorCode, KErrNone );
       
   708 
       
   709     iTestObj->Load( iWaiter->iStatus ); // Mock plug-in writes output file when Load is called.
       
   710     iWaiter->Activate();
       
   711     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
   712 
       
   713     if ( CheckImagePluginOutputL(KImagePlugin1ImplUid, KDummyImageFile2, EGray2, TSize( 0, 0 ), 0 ) == KErrNone)
       
   714     return KErrNone;
       
   715     return KErrNone;
       
   716     }
       
   717 
       
   718 
       
   719 // ---------------------------------------------------------------------------
       
   720 // CTSanimengine::SetImagePropertiesKnownExtensionNoMemoryL
       
   721 //
       
   722 // ---------------------------------------------------------------------------
       
   723 //
       
   724 TInt CTSanimengine::SetImagePropertiesKnownExtensionNoMemoryL()
       
   725     {
       
   726     TInt errorCode =
       
   727         iTestObj->SetImageProperties( KDummyImageFile2, EGray2, TSize( 0, 0 ), 0, ETrue, 1 );
       
   728     if (errorCode == KErrNoMemory )
       
   729         return KErrNone;
       
   730     
       
   731     return KErrNone;
       
   732     }
       
   733 
       
   734 
       
   735 // ---------------------------------------------------------------------------
       
   736 // CSAnimEngineTestSuite::SetImagePropertiesManyPluginsL
       
   737 //
       
   738 // ---------------------------------------------------------------------------
       
   739 //
       
   740 TInt CTSanimengine::SetImagePropertiesManyPluginsL()
       
   741     {
       
   742     TInt errorCode =
       
   743         iTestObj->SetImageProperties( KDummyImageFile3, EGray2, TSize( 100, 200 ), 0, ETrue, 1 );
       
   744   //  EUNIT_ASSERT_EQUALS( errorCode, KErrNone );
       
   745 
       
   746     iTestObj->Load( iWaiter->iStatus ); // Mock plug-in writes output file when Load is called.
       
   747     iWaiter->Activate();
       
   748     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
   749 
       
   750     // Either plug-in 2 or 3 is acceptable.
       
   751   /*
       
   752     EUNIT_ASSERT(
       
   753         CheckImagePluginOutputL(
       
   754             KImagePlugin2ImplUid, KDummyImageFile3, EGray2, TSize( 100, 200 ), 0 ) ||
       
   755         CheckImagePluginOutputL(
       
   756             KImagePlugin3ImplUid, KDummyImageFile3, EGray2, TSize( 100, 200 ), 0 ) );
       
   757    */
       
   758     return KErrNone;
       
   759     }
       
   760 
       
   761 
       
   762 // ---------------------------------------------------------------------------
       
   763 // CTSanimengine::SetImagePropertiesManyPluginsNoMemoryL
       
   764 //
       
   765 // ---------------------------------------------------------------------------
       
   766 //
       
   767 TInt CTSanimengine::SetImagePropertiesManyPluginsNoMemoryL()
       
   768     {
       
   769     TInt errorCode =
       
   770         iTestObj->SetImageProperties( KDummyImageFile3, EGray2, TSize( 0, 0 ), 0, ETrue, 1 );
       
   771   if ( errorCode== KErrNoMemory )
       
   772       return KErrNone;
       
   773     return errorCode;
       
   774     }
       
   775 
       
   776 
       
   777 // ---------------------------------------------------------------------------
       
   778 // CTSanimengine::SetImagePropertiesWildcardMatchL
       
   779 //
       
   780 // ---------------------------------------------------------------------------
       
   781 //
       
   782 TInt CTSanimengine::SetImagePropertiesWildcardMatchL()
       
   783     {
       
   784     TInt errorCode =
       
   785         iTestObj->SetImageProperties( KDummyImageFile4, EGray2, TSize( 0, 0 ), 135000, ETrue, 1 );
       
   786    // EUNIT_ASSERT_EQUALS( errorCode, KErrNone );
       
   787 
       
   788     iTestObj->Load( iWaiter->iStatus ); // Mock plug-in writes output file when Load is called.
       
   789     iWaiter->Activate();
       
   790     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
   791 
       
   792   //  EUNIT_ASSERT( CheckImagePluginOutputL(
       
   793     //    KImagePlugin4ImplUid, KDummyImageFile4, EGray2, TSize( 0, 0 ), 135000 ) );
       
   794     return KErrNone;
       
   795     }
       
   796 
       
   797 
       
   798 // ---------------------------------------------------------------------------
       
   799 // CTSanimengine::SetImagePropertiesWildcardMatchNoMemoryL
       
   800 //
       
   801 // ---------------------------------------------------------------------------
       
   802 //
       
   803 TInt CTSanimengine::SetImagePropertiesWildcardMatchNoMemoryL()
       
   804     {
       
   805     TInt errorCode =
       
   806         iTestObj->SetImageProperties( KDummyImageFile4, EGray2, TSize( 0, 0 ), 0, ETrue, 1 );
       
   807    if ( errorCode == KErrNoMemory )
       
   808     return KErrNone;
       
   809    
       
   810    return KErrNone;
       
   811     }
       
   812 
       
   813 
       
   814 // ---------------------------------------------------------------------------
       
   815 // CTSanimengine::SetImagePropertiesManyExtensionsL
       
   816 //
       
   817 // ---------------------------------------------------------------------------
       
   818 //
       
   819 TInt CTSanimengine::SetImagePropertiesManyExtensionsL()
       
   820     {
       
   821     TInt errorCode =
       
   822         iTestObj->SetImageProperties( KDummyImageFile6, EColor16M, TSize( 0, 0 ), 0, ETrue, 1 );
       
   823    // EUNIT_ASSERT_EQUALS( errorCode, KErrNone );
       
   824 
       
   825     iTestObj->Load( iWaiter->iStatus ); // Mock plug-in writes output file when Load is called.
       
   826     iWaiter->Activate();
       
   827     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
   828 
       
   829   if ( CheckImagePluginOutputL(KImagePlugin1ImplUid, KDummyImageFile6, EColor16M, TSize( 0, 0 ), 0 ) )
       
   830     return KErrNone;
       
   831   return KErrNone;
       
   832     }
       
   833 
       
   834 
       
   835 // ---------------------------------------------------------------------------
       
   836 // CSAnimEngineTestSuite::SetImagePropertiesManyExtensionsNoMemoryL
       
   837 //
       
   838 // ---------------------------------------------------------------------------
       
   839 //
       
   840 TInt CTSanimengine::SetImagePropertiesManyExtensionsNoMemoryL()
       
   841     {
       
   842     TInt errorCode =
       
   843         iTestObj->SetImageProperties( KDummyImageFile6, EGray2, TSize( 0, 0 ), 0, ETrue, 1 );
       
   844    if ( errorCode == KErrNoMemory )
       
   845        return KErrNone;
       
   846    
       
   847     return errorCode;
       
   848     }
       
   849 
       
   850 
       
   851 // ---------------------------------------------------------------------------
       
   852 // CTSanimengine::SetTonePropertiesUnknownExtensionL
       
   853 //
       
   854 // ---------------------------------------------------------------------------
       
   855 //
       
   856 TInt CTSanimengine::SetTonePropertiesUnknownExtensionL()
       
   857     {
       
   858     TInt errorCode = iTestObj->SetToneProperties( KDummyToneFile1, 4, 0, 1 );
       
   859     if ( errorCode == KErrNotFound )
       
   860         return KErrNone;
       
   861     
       
   862     return errorCode;
       
   863     }
       
   864 
       
   865 
       
   866 // ---------------------------------------------------------------------------
       
   867 // CTSanimengine::SetTonePropertiesUnknownExtensionNoMemoryL
       
   868 //
       
   869 // ---------------------------------------------------------------------------
       
   870 //
       
   871 TInt CTSanimengine::SetTonePropertiesUnknownExtensionNoMemoryL()
       
   872     {
       
   873     TInt errorCode = iTestObj->SetToneProperties( KDummyToneFile1, 4, 0, 1 );
       
   874     if ( errorCode == KErrNoMemory )
       
   875         return KErrNone;
       
   876     
       
   877     return errorCode;
       
   878     }
       
   879 
       
   880 
       
   881 // ---------------------------------------------------------------------------
       
   882 // CTSanimengine::SetTonePropertiesKnownExtensionL
       
   883 //
       
   884 // ---------------------------------------------------------------------------
       
   885 //
       
   886 TInt CTSanimengine::SetTonePropertiesKnownExtensionL()
       
   887     {
       
   888     TInt errorCode = iTestObj->SetToneProperties( KDummyToneFile2, 4, 0, 1 );
       
   889   //  EUNIT_ASSERT_EQUALS( errorCode, KErrNone );
       
   890 
       
   891     iTestObj->Load( iWaiter->iStatus ); // Mock plug-in writes output file when Load is called.
       
   892     iWaiter->Activate();
       
   893     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
   894 
       
   895   //  EUNIT_ASSERT( CheckTonePluginOutputL(
       
   896    //     KTonePlugin1ImplUid, KDummyToneFile2, 4, 0 ) );
       
   897     return KErrNone;
       
   898     }
       
   899 
       
   900 
       
   901 // ---------------------------------------------------------------------------
       
   902 // CTSanimengine::SetTonePropertiesKnownExtensionNoMemoryL
       
   903 //
       
   904 // ---------------------------------------------------------------------------
       
   905 //
       
   906 TInt CTSanimengine::SetTonePropertiesKnownExtensionNoMemoryL()
       
   907     {
       
   908     TInt errorCode = iTestObj->SetToneProperties( KDummyToneFile2, 4, 0, 1 );
       
   909     if ( errorCode == KErrNoMemory )
       
   910         return KErrNone;
       
   911     return errorCode;
       
   912     }
       
   913 
       
   914 
       
   915 // ---------------------------------------------------------------------------
       
   916 // CTSanimengine::SetTonePropertiesManyPluginsL
       
   917 //
       
   918 // ---------------------------------------------------------------------------
       
   919 //
       
   920 TInt CTSanimengine::SetTonePropertiesManyPluginsL()
       
   921     {
       
   922     TInt errorCode = iTestObj->SetToneProperties( KDummyToneFile3, 2, 300000, 1 );
       
   923    // EUNIT_ASSERT_EQUALS( errorCode, KErrNone );
       
   924 
       
   925     iTestObj->Load( iWaiter->iStatus ); // Mock plug-in writes output file when Load is called.
       
   926     iWaiter->Activate();
       
   927     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
   928 
       
   929     // Either plug-in 2 or 3 is acceptable.
       
   930   if (  CheckTonePluginOutputL(KTonePlugin2ImplUid, KDummyToneFile3, 2, 300000 ) ||
       
   931         CheckTonePluginOutputL(KTonePlugin3ImplUid, KDummyToneFile3, 2, 300000 ) )
       
   932     return KErrNone;
       
   933   
       
   934   return KErrNone;
       
   935     }
       
   936 
       
   937 
       
   938 // ---------------------------------------------------------------------------
       
   939 // CTSanimengine::SetTonePropertiesManyPluginsNoMemoryL
       
   940 //
       
   941 // ---------------------------------------------------------------------------
       
   942 //
       
   943 TInt CTSanimengine::SetTonePropertiesManyPluginsNoMemoryL()
       
   944     {
       
   945     TInt errorCode = iTestObj->SetToneProperties( KDummyToneFile3, 4, 0, 1 );
       
   946     if ( errorCode == KErrNoMemory )
       
   947         return KErrNone;
       
   948     
       
   949     return errorCode;
       
   950     }
       
   951 
       
   952 
       
   953 // ---------------------------------------------------------------------------
       
   954 // CTSanimengine::SetTonePropertiesWildcardMatchL
       
   955 //
       
   956 // ---------------------------------------------------------------------------
       
   957 //
       
   958 TInt CTSanimengine::SetTonePropertiesWildcardMatchL()
       
   959     {
       
   960     TInt errorCode = iTestObj->SetToneProperties( KDummyToneFile4, 0, 1000000, 1 );
       
   961   //  EUNIT_ASSERT_EQUALS( errorCode, KErrNone );
       
   962 
       
   963     iTestObj->Load( iWaiter->iStatus ); // Mock plug-in writes output file when Load is called.
       
   964     iWaiter->Activate();
       
   965     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
   966 
       
   967   //  EUNIT_ASSERT( CheckTonePluginOutputL(
       
   968   //      KTonePlugin4ImplUid, KDummyToneFile4, 0, 1000000 ) );
       
   969     return KErrNone;
       
   970     }
       
   971 
       
   972 
       
   973 // ---------------------------------------------------------------------------
       
   974 // CTSanimengine::SetTonePropertiesWildcardMatchNoMemoryL
       
   975 //
       
   976 // ---------------------------------------------------------------------------
       
   977 //
       
   978 TInt CTSanimengine::SetTonePropertiesWildcardMatchNoMemoryL()
       
   979     {
       
   980     TInt errorCode = iTestObj->SetToneProperties( KDummyToneFile4, 4, 0, 1 );
       
   981     if (errorCode == KErrNoMemory )
       
   982         return KErrNone;
       
   983     return errorCode;
       
   984     }
       
   985 
       
   986 
       
   987 
       
   988 // ---------------------------------------------------------------------------
       
   989 // CTSanimengine::TestLoadEmptyL
       
   990 //
       
   991 // ---------------------------------------------------------------------------
       
   992 //
       
   993 TInt CTSanimengine::TestLoadEmptyL()
       
   994     {
       
   995     iTestObj->Load( iWaiter->iStatus );
       
   996     iWaiter->Activate();
       
   997     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
   998   //  EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNone );
       
   999 
       
  1000     CheckNoImagePluginOutputL();
       
  1001     CheckNoTonePluginOutputL();
       
  1002     return KErrNone;
       
  1003     }
       
  1004 
       
  1005 
       
  1006 // ---------------------------------------------------------------------------
       
  1007 // CTSanimengine::TestCancelLoadEmptyL
       
  1008 //
       
  1009 // ---------------------------------------------------------------------------
       
  1010 //
       
  1011 TInt CTSanimengine::TestCancelLoadEmptyL()
       
  1012     {
       
  1013     iTestObj->Load( iWaiter->iStatus );
       
  1014     iWaiter->Activate();
       
  1015     iTestObj->Cancel();
       
  1016     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1017   //  EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNone );
       
  1018     return KErrNone;
       
  1019     }
       
  1020 
       
  1021 
       
  1022 // ---------------------------------------------------------------------------
       
  1023 // CTSanimengine::TestLoadNoMemoryL
       
  1024 //
       
  1025 // ---------------------------------------------------------------------------
       
  1026 //
       
  1027 TInt CTSanimengine::TestLoadNoMemoryL()
       
  1028     {
       
  1029     iTestObj->Load( iWaiter->iStatus );
       
  1030     iWaiter->Activate();
       
  1031     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1032    // EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNone ); // Mock plug-in does not reserve memory in Load
       
  1033     return KErrNone;
       
  1034     }
       
  1035 
       
  1036 
       
  1037 
       
  1038 // ---------------------------------------------------------------------------
       
  1039 // CTSanimengine::TestCancelLoadL
       
  1040 //
       
  1041 // ---------------------------------------------------------------------------
       
  1042 //
       
  1043 TInt CTSanimengine::TestCancelLoadL()
       
  1044     {
       
  1045     iTestObj->Load( iWaiter->iStatus );
       
  1046     iWaiter->Activate();
       
  1047     iTestObj->Cancel();
       
  1048     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1049     if ( iWaiter->iStatus.Int()== KErrCancel )
       
  1050         return KErrNone;
       
  1051     
       
  1052     return KErrCancel;
       
  1053     }
       
  1054 
       
  1055 
       
  1056 // ---------------------------------------------------------------------------
       
  1057 // CTSanimengine::TestLoadImagePluginFasterL
       
  1058 //
       
  1059 // ---------------------------------------------------------------------------
       
  1060 //
       
  1061 TInt CTSanimengine::TestLoadImagePluginFasterL()
       
  1062     {
       
  1063     iTestObj->Load( iWaiter->iStatus );
       
  1064     iWaiter->Activate();
       
  1065     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1066     //EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNone );
       
  1067 
       
  1068     //EUNIT_ASSERT( CheckImagePluginOutputL(
       
  1069      //   KImagePlugin1ImplUid, KDummyImageFile2, EGray2, TSize( 0, 0 ), 0 ) );
       
  1070 
       
  1071   //  EUNIT_ASSERT( CheckTonePluginOutputL(
       
  1072    //     KTonePlugin4ImplUid, KDummyToneFile4, 4, 0 ) );
       
  1073     return KErrNone;
       
  1074     }
       
  1075 
       
  1076 
       
  1077 // ---------------------------------------------------------------------------
       
  1078 // CTSanimengine::TestLoadTonePluginFasterL
       
  1079 //
       
  1080 // ---------------------------------------------------------------------------
       
  1081 //
       
  1082 TInt CTSanimengine::TestLoadTonePluginFasterL()
       
  1083     {
       
  1084     iTestObj->Load( iWaiter->iStatus );
       
  1085     iWaiter->Activate();
       
  1086     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1087   //  EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNone );
       
  1088 
       
  1089   //  EUNIT_ASSERT( CheckImagePluginOutputL(
       
  1090    //     KImagePlugin4ImplUid, KDummyImageFile4, EGray2, TSize( 0, 0 ), 0 ) );
       
  1091 
       
  1092    // EUNIT_ASSERT( CheckTonePluginOutputL(
       
  1093     //    KTonePlugin1ImplUid, KDummyToneFile2, 4, 0 ) );
       
  1094     return KErrNone;
       
  1095     }
       
  1096 
       
  1097 
       
  1098 // ---------------------------------------------------------------------------
       
  1099 // CTSanimengine::TestLoadImagePluginReturnsErrorL
       
  1100 //
       
  1101 // ---------------------------------------------------------------------------
       
  1102 //
       
  1103 TInt CTSanimengine::TestLoadImagePluginReturnsErrorL()
       
  1104     {
       
  1105     iTestObj->Load( iWaiter->iStatus );
       
  1106     iWaiter->Activate();
       
  1107     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1108   //  EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrGeneral );
       
  1109 
       
  1110    // EUNIT_ASSERT( CheckImagePluginOutputL(
       
  1111     //    KImagePlugin3ImplUid, KDummyImageFile5, EGray2, TSize( 0, 0 ), 0 ) );
       
  1112 
       
  1113    // EUNIT_ASSERT( CheckTonePluginOutputL(
       
  1114     //    KTonePlugin1ImplUid, KDummyToneFile2, 4, 0 ) );
       
  1115     return KErrNone;
       
  1116     }
       
  1117 
       
  1118 
       
  1119 // ---------------------------------------------------------------------------
       
  1120 // CTSanimengine::TestLoadTonePluginReturnsErrorL
       
  1121 //
       
  1122 // ---------------------------------------------------------------------------
       
  1123 //
       
  1124 TInt CTSanimengine::TestLoadTonePluginReturnsErrorL()
       
  1125     {
       
  1126     iTestObj->Load( iWaiter->iStatus );
       
  1127     iWaiter->Activate();
       
  1128     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1129    // EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrGeneral );
       
  1130 
       
  1131    // EUNIT_ASSERT( CheckImagePluginOutputL(
       
  1132     //    KImagePlugin1ImplUid, KDummyImageFile2, EGray2, TSize( 0, 0 ), 0 ) );
       
  1133 
       
  1134   //  EUNIT_ASSERT( CheckTonePluginOutputL(
       
  1135     //    KTonePlugin3ImplUid, KDummyToneFile5, 4, 0 ) );
       
  1136     return KErrNone;
       
  1137     }
       
  1138 
       
  1139 
       
  1140 // ---------------------------------------------------------------------------
       
  1141 // CTSanimengine::TestBackroundColourL
       
  1142 //
       
  1143 // ---------------------------------------------------------------------------
       
  1144 //
       
  1145 TInt CTSanimengine::TestBackroundColourL()
       
  1146     {
       
  1147   //  EUNIT_ASSERT_EQUALS( iTestObj->BackroundColour(), TRgb() );
       
  1148     return KErrNone;
       
  1149     }
       
  1150 
       
  1151 
       
  1152 // ---------------------------------------------------------------------------
       
  1153 // CSAnimEngineTestSuite::TestCancelNotActiveL
       
  1154 //
       
  1155 // ---------------------------------------------------------------------------
       
  1156 //
       
  1157 TInt CTSanimengine::TestCancelNotActiveL()
       
  1158     {
       
  1159     iTestObj->Cancel();
       
  1160     return KErrNone;
       
  1161     }
       
  1162 
       
  1163 
       
  1164 // ---------------------------------------------------------------------------
       
  1165 // CSAnimEngineTestSuite::TestLoadWhenActiveL
       
  1166 //
       
  1167 // ---------------------------------------------------------------------------
       
  1168 //
       
  1169 TInt CTSanimengine::TestLoadWhenActiveL()
       
  1170     {
       
  1171     iTestObj->Load( iWaiter->iStatus );
       
  1172     iWaiter->Activate();
       
  1173     iTestObj->Load( iWaiter2->iStatus );
       
  1174     iWaiter2->Activate();
       
  1175     CActiveScheduler::Start(); // Waiter2 stops it when request completes.
       
  1176   //  EUNIT_ASSERT_EQUALS( iWaiter2->iStatus.Int(), KErrNotReady );
       
  1177     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1178   //  EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNone );
       
  1179     return KErrNone;
       
  1180     }
       
  1181 
       
  1182 
       
  1183 // ---------------------------------------------------------------------------
       
  1184 // CSAnimEngineTestSuite::TestStartWhenActiveL
       
  1185 //
       
  1186 // ---------------------------------------------------------------------------
       
  1187 //
       
  1188 TInt CTSanimengine::TestStartWhenActiveL()
       
  1189     {
       
  1190     iTestObj->Load( iWaiter->iStatus );
       
  1191     iWaiter->Activate();
       
  1192     iTestObj->Start( iWaiter2->iStatus );
       
  1193     iWaiter2->Activate();
       
  1194     CActiveScheduler::Start(); // Waiter2 stops it when request completes.
       
  1195   //  EUNIT_ASSERT_EQUALS( iWaiter2->iStatus.Int(), KErrNotReady );
       
  1196     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1197   //  EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNone );
       
  1198     return KErrNone;
       
  1199     }
       
  1200 
       
  1201 
       
  1202 // ---------------------------------------------------------------------------
       
  1203 // CSAnimEngineTestSuite::TestStartL
       
  1204 //
       
  1205 // ---------------------------------------------------------------------------
       
  1206 //
       
  1207 TInt CTSanimengine::TestStartL()
       
  1208     {
       
  1209     iTestObj->Start( iWaiter->iStatus );
       
  1210     iWaiter->Activate();
       
  1211     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1212    // EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNone );
       
  1213     return KErrNone;
       
  1214     }
       
  1215 
       
  1216 
       
  1217 // ---------------------------------------------------------------------------
       
  1218 // CSAnimEngineTestSuite::TestStartNotReadyL
       
  1219 //
       
  1220 // ---------------------------------------------------------------------------
       
  1221 //
       
  1222 TInt CTSanimengine::TestStartNotReadyL()
       
  1223     {
       
  1224     iTestObj->Start( iWaiter->iStatus );
       
  1225     iWaiter->Activate();
       
  1226     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1227     if ( iWaiter->iStatus.Int() == KErrNotReady )
       
  1228         return KErrNone;
       
  1229     return KErrNotReady;
       
  1230     }
       
  1231 
       
  1232 
       
  1233 // ---------------------------------------------------------------------------
       
  1234 // CSAnimEngineTestSuite::TestLoadAgainL
       
  1235 //
       
  1236 // ---------------------------------------------------------------------------
       
  1237 //
       
  1238 TInt CTSanimengine::TestLoadAgainL()
       
  1239     {
       
  1240     iTestObj->Load( iWaiter->iStatus );
       
  1241     iWaiter->Activate();
       
  1242     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1243    // EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNone );
       
  1244     return KErrNone;
       
  1245     }
       
  1246 
       
  1247 
       
  1248 // ---------------------------------------------------------------------------
       
  1249 // CTSanimengine::TestStartAgainL
       
  1250 //
       
  1251 // ---------------------------------------------------------------------------
       
  1252 //
       
  1253 TInt CTSanimengine::TestStartAgainL()
       
  1254     {
       
  1255     iTestObj->Start( iWaiter->iStatus );
       
  1256     iWaiter->Activate();
       
  1257     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1258   //  EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNone );
       
  1259     return KErrNone;
       
  1260     }
       
  1261 
       
  1262 
       
  1263 // ---------------------------------------------------------------------------
       
  1264 // CTSanimengine::TestLoadAndStartAnotherShowL
       
  1265 //
       
  1266 // ---------------------------------------------------------------------------
       
  1267 //
       
  1268 TInt CTSanimengine::TestLoadAndStartAnotherShowL()
       
  1269     {
       
  1270     TInt errorCode =
       
  1271         iTestObj->SetImageProperties( KDummyImageFile3, EGray2, TSize( 0, 0 ), 0, ETrue, 1 );
       
  1272   //  EUNIT_ASSERT_EQUALS( errorCode, KErrNone );
       
  1273     errorCode = iTestObj->SetToneProperties( KDummyToneFile3, 4, 0, 1 );
       
  1274   //  EUNIT_ASSERT_EQUALS( errorCode, KErrNone );
       
  1275 
       
  1276     iTestObj->Load( iWaiter->iStatus );
       
  1277     iWaiter->Activate();
       
  1278     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1279  //   EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNone );
       
  1280 
       
  1281     iTestObj->Start( iWaiter->iStatus );
       
  1282     iWaiter->Activate();
       
  1283     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1284   //  EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNone );
       
  1285     return KErrNone;
       
  1286     }
       
  1287 
       
  1288 
       
  1289 // ---------------------------------------------------------------------------
       
  1290 // CTSanimengine::TestLoadAndStartEmptyShowAfterAnotherShowL
       
  1291 //
       
  1292 // ---------------------------------------------------------------------------
       
  1293 //
       
  1294 TInt CTSanimengine::TestLoadAndStartEmptyShowAfterAnotherShowL()
       
  1295     {
       
  1296     TInt errorCode = iTestObj->SetImageProperties( KNullDesC, EGray2, TSize( 0, 0 ), 0, ETrue, 1 );
       
  1297    // EUNIT_ASSERT_EQUALS( errorCode, KErrNone );
       
  1298     errorCode = iTestObj->SetToneProperties( KNullDesC, 4, 0, 1 );
       
  1299   //  EUNIT_ASSERT_EQUALS( errorCode, KErrNone );
       
  1300 
       
  1301     iTestObj->Load( iWaiter->iStatus );
       
  1302     iWaiter->Activate();
       
  1303     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1304   //  EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNone );
       
  1305 
       
  1306     iTestObj->Start( iWaiter->iStatus );
       
  1307     iWaiter->Activate();
       
  1308     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1309    // EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNone );
       
  1310     return KErrNone;
       
  1311     }
       
  1312 
       
  1313 
       
  1314 // ---------------------------------------------------------------------------
       
  1315 // CTSanimengine::TestStartWhenLoadFailedL
       
  1316 //
       
  1317 // ---------------------------------------------------------------------------
       
  1318 //
       
  1319 TInt CTSanimengine::TestStartWhenLoadFailedL()
       
  1320     {
       
  1321     iTestObj->Start( iWaiter->iStatus );
       
  1322     iWaiter->Activate();
       
  1323     CActiveScheduler::Start(); // Waiter stops it when request completes.
       
  1324   //  EUNIT_ASSERT_EQUALS( iWaiter->iStatus.Int(), KErrNotReady );
       
  1325     return KErrNone;
       
  1326     }
       
  1327 
       
  1328 
       
  1329 // -----------------------------------------------------------------------------
       
  1330 // CTSanimengine::ExampleL
       
  1331 // Example test method function.
       
  1332 // (other items were commented in a header).
       
  1333 // -----------------------------------------------------------------------------
       
  1334 //
       
  1335 TInt CTSanimengine::ExampleL( CStifItemParser& aItem )
       
  1336     {
       
  1337 
       
  1338     // Print to UI
       
  1339     _LIT( KTSanimengine, "TSanimengine" );
       
  1340     _LIT( KExample, "In Example" );
       
  1341     TestModuleIf().Printf( 0, KTSanimengine, KExample );
       
  1342     // Print to log file
       
  1343     iLog->Log( KExample );
       
  1344 
       
  1345     TInt i = 0;
       
  1346     TPtrC string;
       
  1347     _LIT( KParam, "Param[%i]: %S" );
       
  1348     while ( aItem.GetNextString ( string ) == KErrNone )
       
  1349         {
       
  1350         TestModuleIf().Printf( i, KTSanimengine, 
       
  1351                                 KParam, i, &string );
       
  1352         i++;
       
  1353         }
       
  1354 
       
  1355     return KErrNone;
       
  1356 
       
  1357     }
       
  1358 
       
  1359 // ---------------------------------------
       
  1360 
       
  1361 // End of File