Mercurial Mercurial > oss > MCL > sf > app > photos / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
photosgallery/slideshow/engine/tsrc/t_cshwdefaulteffectmanager/t_cshwdefaulteffectmanager.cpp
branchRCL_3
changeset 13 bcb43dc84c44
parent 2 7d9067c6fcb1
equal deleted inserted replaced
12:ce1c7ad1f18b 13:bcb43dc84c44 
    49 
    49 
    50 // CONSTRUCTION
 
    50 // CONSTRUCTION
 
    51 T_CShwDefaultEffectManager* T_CShwDefaultEffectManager::NewL()
 
    51 T_CShwDefaultEffectManager* T_CShwDefaultEffectManager::NewL()
 
    52     {
 
    52     {
 
    53     T_CShwDefaultEffectManager* self = T_CShwDefaultEffectManager::NewLC();
 
    53     T_CShwDefaultEffectManager* self = T_CShwDefaultEffectManager::NewLC();
 
    54     CleanupStack::Pop();
 
    54     CleanupStack::Pop( self );
 
    55 
       
    56     return self;
 
    55     return self;
 
    57     }
 
    56     }
 
    58 
    57 
    59 T_CShwDefaultEffectManager* T_CShwDefaultEffectManager::NewLC()
 
    58 T_CShwDefaultEffectManager* T_CShwDefaultEffectManager::NewLC()
 
    60     {
 
    59     {
 
    61     T_CShwDefaultEffectManager* self = new( ELeave ) T_CShwDefaultEffectManager();
 
    60     T_CShwDefaultEffectManager* self = new( ELeave ) T_CShwDefaultEffectManager();
 
    62     CleanupStack::PushL( self );
 
    61     CleanupStack::PushL( self );
 
    63 
       
    64     self->ConstructL();
 
    62     self->ConstructL();
 
    65 
       
    66     return self;
 
    63     return self;
 
    67     }
 
    64     }
 
    68 
    65 
    69 // Destructor (virtual by CBase)
 
    66 // Destructor (virtual by CBase)
 
    70 T_CShwDefaultEffectManager::~T_CShwDefaultEffectManager()
 
    67 T_CShwDefaultEffectManager::~T_CShwDefaultEffectManager()
 
   120 
   117 
   121     CleanupStack::PushL( effect );
 
   118     CleanupStack::PushL( effect );
 
   122     iDefaultEffectManager->AddEffectL( effect );  // takes ownership
 
   119     iDefaultEffectManager->AddEffectL( effect );  // takes ownership
 
   123     CleanupStack::Pop( effect );
 
   120     CleanupStack::Pop( effect );
 
   124 
   121 
   125 	// TRAP since we expect it to leave
 
       
   126 	//TRAPD( error, iDefaultEffectManager->CurrentEffect() );
 
       
   127    // EUNIT_ASSERT_EQUALS_DESC( 
       
   128    // 	NShwEngine::EIncorrectEffectIndex, error, "iEffects was not set");
 
       
   129 	// get effects info
 
   122 	// get effects info
 
   130    	TShwEffectInfo info = effect->EffectInfo();
 
   123    	TShwEffectInfo info = effect->EffectInfo();
 
   131 	// set effect order
 
   124 	// set effect order
 
   132 	iDefaultEffectManager->SetDefaultEffectL( info );
 
   125 	iDefaultEffectManager->SetDefaultEffectL( info );
 
   133 	// ask for effect again
 
   126 	// ask for effect again
 
   138     }
 
   131     }
 
   139 	
   132 	
   140 void T_CShwDefaultEffectManager::TestAddNullEffectL()
 
   133 void T_CShwDefaultEffectManager::TestAddNullEffectL()
 
   141     {
 
   134     {
 
   142     iDefaultEffectManager->AddEffectL( NULL );
 
   135     iDefaultEffectManager->AddEffectL( NULL );
 
   143 
       
   144 	// TRAP since we expect it to leave
 
       
   145 	//TRAPD( error, iDefaultEffectManager->CurrentEffect() );
 
       
   146     //EUNIT_ASSERT_EQUALS_DESC( 
       
   147     //	NShwEngine::EIncorrectEffectIndex, error, "iEffects was not set");
 
       
   148 
       
   149 	// create empty effect info
 
   136 	// create empty effect info
 
   150    	TShwEffectInfo info;
 
   137    	TShwEffectInfo info;
 
   151 	TInt error ;
 
   138 	TInt error ;
 
   152 	// set effect order
 
   139 	// set effect order
 
   153 	TRAP( error, iDefaultEffectManager->SetDefaultEffectL( info ) );
 
   140 	TRAP( error, iDefaultEffectManager->SetDefaultEffectL( info ) );
 
   187     EUNIT_ASSERT( effect1 == iDefaultEffectManager->Effect( 1 ) );
 
   174     EUNIT_ASSERT( effect1 == iDefaultEffectManager->Effect( 1 ) );
 
   188     EUNIT_ASSERT( effect1 == iDefaultEffectManager->Effect( -1 ) );
 
   175     EUNIT_ASSERT( effect1 == iDefaultEffectManager->Effect( -1 ) );
 
   189     EUNIT_ASSERT( effect2 == iDefaultEffectManager->Effect( 2 ) );
 
   176     EUNIT_ASSERT( effect2 == iDefaultEffectManager->Effect( 2 ) );
 
   190     }
 
   177     }
 
   191 
   178 
   192 /*
 
       
   193 void T_CShwDefaultEffectManager::TestProgrammedEffectL()
 
       
   194     {
 
       
   195     // Create two effects
 
       
   196     T_MShwTestEffect* effect0 = new(ELeave) T_MShwTestEffect(0);
 
       
   197     CleanupStack::PushL(effect0);
 
       
   198     T_MShwTestEffect* effect1 = new(ELeave) T_MShwTestEffect(1);
 
       
   199     CleanupStack::PushL(effect1);
 
       
   200     
       
   201     // Add the effects
 
       
   202     iDefaultEffectManager->AddEffectL(effect0);  // takes ownership
 
       
   203     iDefaultEffectManager->AddEffectL(effect1);  // takes ownership
 
       
   204     
       
   205     CleanupStack::Pop(2, effect0);
 
       
   206     
       
   207     // Specify programmed order
 
       
   208     iDefaultEffectManager->SetEffectOrder(MShwEffectManager::EShwEffectOrderProgrammed);
 
       
   209     
       
   210     // Create the programmed order
 
       
   211     RArray<MShwEffect*> programme;
 
       
   212     CleanupClosePushL(programme);
 
       
   213 //    CleanupStack::PushL(&programme);
 
       
   214     programme.AppendL(effect1);
 
       
   215     programme.AppendL(effect0);
 
       
   216     programme.AppendL(effect1);
 
       
   217     
       
   218     // Set the order
 
       
   219     iDefaultEffectManager->SetProgrammedEffects(programme);
 
       
   220     
       
   221     // 
       
   222     // Check the first effect
 
       
   223     MShwEffect* inEffect = static_cast<MShwEffect*>(effect1);
 
       
   224     MShwEffect* outEffect = iDefaultEffectManager->CurrentEffect();
 
       
   225     EUNIT_ASSERT_EQUALS(inEffect, outEffect);
 
       
   226    
       
   227     inEffect = static_cast<MShwEffect*>(effect0); 
       
   228     outEffect = iDefaultEffectManager->NextEffect(); 
       
   229     EUNIT_ASSERT_EQUALS(inEffect, outEffect);
 
       
   230 
       
   231     iDefaultEffectManager->ProceedToNextEffect();
 
       
   232     
       
   233     inEffect = static_cast<MShwEffect*>(effect1); 
       
   234     outEffect = iDefaultEffectManager->NextEffect(); 
       
   235     EUNIT_ASSERT_EQUALS(inEffect, outEffect);
 
       
   236     
       
   237     CleanupStack::PopAndDestroy(&programme);
 
       
   238     }
 
       
   239  
       
   240     
       
   241 void T_CShwDefaultEffectManager::TestMultiProgrammedEffectL()
 
       
   242     {
 
       
   243     // Create two effects
 
       
   244     T_MShwTestEffect* effect0 = new(ELeave) T_MShwTestEffect(0);
 
       
   245     CleanupStack::PushL(effect0);
 
       
   246     T_MShwTestEffect* effect1 = new(ELeave) T_MShwTestEffect(1);
 
       
   247     CleanupStack::PushL(effect1);
 
       
   248     T_MShwTestEffect* effect2 = new(ELeave) T_MShwTestEffect(2);
 
       
   249     CleanupStack::PushL(effect2);
 
       
   250     
       
   251     // Add the effects
 
       
   252     iDefaultEffectManager->AddEffectL(effect0);  // takes ownership
 
       
   253     iDefaultEffectManager->AddEffectL(effect1);  // takes ownership
 
       
   254     iDefaultEffectManager->AddEffectL(effect2);  // takes ownership
 
       
   255     
       
   256     CleanupStack::Pop(3, effect0);
 
       
   257     
       
   258     // Specify programmed order
 
       
   259     iDefaultEffectManager->SetEffectOrder(MShwEffectManager::EShwEffectOrderProgrammed);
 
       
   260     
       
   261     // Create the programmed order
 
       
   262     RArray<MShwEffect*> programme;
 
       
   263     CleanupClosePushL(programme);
 
       
   264 //    CleanupStack::PushL(&programme);
 
       
   265     programme.AppendL(effect2);
 
       
   266     programme.AppendL(effect1);
 
       
   267     programme.AppendL(effect0);
 
       
   268     programme.AppendL(effect2);
 
       
   269     programme.AppendL(effect1);
 
       
   270     programme.AppendL(effect0); 
       
   271        
       
   272     // Set the order
 
       
   273     iDefaultEffectManager->SetProgrammedEffects(programme);
 
       
   274     
       
   275     // 
       
   276     // Check the effect order is retrieved as 2, 1, 0
 
       
   277     MShwEffect* inEffect = static_cast<MShwEffect*>(effect2);
 
       
   278     MShwEffect* outEffect = iDefaultEffectManager->CurrentEffect();
 
       
   279     EUNIT_ASSERT_EQUALS(inEffect, outEffect);
 
       
   280 
       
   281     inEffect = static_cast<MShwEffect*>(effect1); 
       
   282     outEffect = iDefaultEffectManager->NextEffect(); 
       
   283     EUNIT_ASSERT_EQUALS(inEffect, outEffect);
 
       
   284     
       
   285     iDefaultEffectManager->ProceedToNextEffect();
 
       
   286        
       
   287     inEffect = static_cast<MShwEffect*>(effect2); 
       
   288     outEffect = iDefaultEffectManager->NextEffect(); 
       
   289     EUNIT_ASSERT_EQUALS(inEffect, outEffect);
 
       
   290     
       
   291     iDefaultEffectManager->ProceedToNextEffect();
 
       
   292        
       
   293     inEffect = static_cast<MShwEffect*>(effect1); 
       
   294     outEffect = iDefaultEffectManager->NextEffect(); 
       
   295     EUNIT_ASSERT_EQUALS(inEffect, outEffect);
 
       
   296     
       
   297     iDefaultEffectManager->ProceedToNextEffect();
 
       
   298        
       
   299     inEffect = static_cast<MShwEffect*>(effect0); 
       
   300     outEffect = iDefaultEffectManager->NextEffect(); 
       
   301     EUNIT_ASSERT_EQUALS(inEffect, outEffect);    
       
   302     iDefaultEffectManager->ProceedToNextEffect();
 
       
   303        
       
   304     CleanupStack::PopAndDestroy(&programme);
 
       
   305     }
 
       
   306 */    
       
   307 
       
   308 //  TEST TABLE
 
   179 //  TEST TABLE
 
   309 EUNIT_BEGIN_TEST_TABLE(
 
   180 EUNIT_BEGIN_TEST_TABLE(
 
   310     T_CShwDefaultEffectManager,
 
   181     T_CShwDefaultEffectManager,
 
   311     "Test suite for CShwDefaultEffectManager.",
 
   182     "Test suite for CShwDefaultEffectManager.",
 
   312     "UNIT" )
 
   183     "UNIT" )
 
   336     "Next Effect Test",
 
   207     "Next Effect Test",
 
   337     "CShwDefaultEffectManager",
 
   208     "CShwDefaultEffectManager",
 
   338     "CShwDefaultEffectManager",
 
   209     "CShwDefaultEffectManager",
 
   339     "FUNCTIONALITY",
 
   210     "FUNCTIONALITY",
 
   340     SetupL, TestNextEffectL, Teardown )
 
   211     SetupL, TestNextEffectL, Teardown )
 
   341     
       
   342 /*    
       
   343 EUNIT_TEST(
 
       
   344     "Programmed Effect Test",
 
       
   345     "CShwDefaultEffectManager",
 
       
   346     "CShwDefaultEffectManager",
 
       
   347     "FUNCTIONALITY",
 
       
   348     SetupL, TestProgrammedEffectL, Teardown )
 
       
   349     
       
   350 EUNIT_TEST(
 
       
   351     "Multi Prog Test",
 
       
   352     "CShwDefaultEffectManager",
 
       
   353     "CShwDefaultEffectManager",
 
       
   354     "FUNCTIONALITY",
 
       
   355     SetupL, TestMultiProgrammedEffectL, Teardown )
 
       
   356 */    
       
   357 
   212 
   358 EUNIT_END_TEST_TABLE
 
   213 EUNIT_END_TEST_TABLE
 
   359 
   214 
   360 //  END OF FILE
 
   215 //  END OF FILE
MCL/sf/app/photos