1 /*

     2 * Copyright (c) 2002 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: DRM Player

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include <StifTestInterface.h>

    20 #include "DRMAudioPlay.h"

    21 #include <caf.h>

    22 #include <caf/supplier.h>

    23 #include <caf/importfile.h>

    24 #include <BAUTILS.H>

    25 

    26 using namespace ContentAccess;

    27 

    28 	// Constants

    29 	const TInt CDRMAudioPlay::MAX_TESTCASE_ID = 1046;

    30 	const TInt CDRMAudioPlay::KDefaultRepeats = 5;

    31 	const TInt CDRMAudioPlay::KDefaultRepeatForever = -2;

    32 	const TInt CDRMAudioPlay::KDefaultPauseDelay = 1000000;

    33 	const TInt CDRMAudioPlay::KDefaultPlayDelay = 3000000;

    34 	const TInt CDRMAudioPlay::KDefaultStopOpenPlayDelay = 1000000;

    35 	const TInt CDRMAudioPlay::KDefaultReportDelay = 500000;

    36 	

    37 	// Taken from Oma2Agent.h

    38 	_LIT8(KOma1XmlRoContentType, "application/vnd.oma.drm.rights+xml");

    39 

    40 	//Cases

    41 	const TInt CDRMAudioPlay::KCaseImplementationInformation                        = 1001;

    42 	const TInt CDRMAudioPlay::KCasePlayFile                                         = 1002;

    43 	const TInt CDRMAudioPlay::KCasePlayFileStopOpen                                 = 1003;

    44     const TInt CDRMAudioPlay::KCasePlayDes                                          = 1004;

    45     const TInt CDRMAudioPlay::KCasePlayDesStopOpen                                  = 1005;

    46     const TInt CDRMAudioPlay::KCasePlayUrl                                          = 1006;

    47     const TInt CDRMAudioPlay::KCasePlayUrlStopOpen                                  = 1007;

    48 	const TInt CDRMAudioPlay::KCasePlayFileWithPause                                = 1008;

    49 	const TInt CDRMAudioPlay::KCasePlayFileWithPosition                             = 1009;

    50 	const TInt CDRMAudioPlay::KCasePlayFileReportPosition                           = 1010;

    51 	const TInt CDRMAudioPlay::KCasePlayFileReportDuration                           = 1011;

    52     const TInt CDRMAudioPlay::KCasePlayFilesWithVolumes                             = 1012;

    53     const TInt CDRMAudioPlay::KCasePlayFileWithRamp                                 = 1013;

    54     const TInt CDRMAudioPlay::KCasePlayFileMetaInfo                                 = 1014;

    55     const TInt CDRMAudioPlay::KCasePlayFileWindow                                   = 1015;

    56     const TInt CDRMAudioPlay::KCasePlayFileClearWindow                              = 1016;

    57     const TInt CDRMAudioPlay::KCasePlayFileWithRepeats                              = 1017;

    58     const TInt CDRMAudioPlay::KCasePlayFileWithBalance                              = 1018;

    59     const TInt CDRMAudioPlay::KCasePlayFilesWithPriorities                          = 1019;

    60     const TInt CDRMAudioPlay::KCasePlayHandler                                      = 1020;

    61     const TInt CDRMAudioPlay::KCasePlayHandlerStopOpen                              = 1021;

    62     const TInt CDRMAudioPlay::KCasePlayHandlerWithPause                             = 1022;

    63     const TInt CDRMAudioPlay::KCasePlayFileHandlerWithRamp                          = 1023;

    64     const TInt CDRMAudioPlay::KCasePlayFileHandlerWithSetPosition                   = 1024;

    65     const TInt CDRMAudioPlay::KCasePlayFileHandlerWithGetPosition                   = 1025;

    66     const TInt CDRMAudioPlay::KCasePlayFileHandlerWithDuration                      = 1026;

    67     const TInt CDRMAudioPlay::KCasePlayFileHandlerWithWindow                        = 1027;

    68     const TInt CDRMAudioPlay::KCasePlayFileHandlerWithClearWindow                   = 1028;

    69     const TInt CDRMAudioPlay::KCasePlayFileSetVolume                                = 1029;

    70     const TInt CDRMAudioPlay::KCasePlayFileGetBalance                               = 1030;

    71     const TInt CDRMAudioPlay::KCasePlayFileGetBitRate                               = 1031;

    72     const TInt CDRMAudioPlay::KCasePlayFileGetAudioLoadingProgress                  = 1032;

    73     const TInt CDRMAudioPlay::KCasePlayFileRegisterForAudioLoadingNotification      = 1033;

    74     const TInt CDRMAudioPlay::KCasePlayFileImplementationInformation                = 1034;

    75     const TInt CDRMAudioPlay::KCasePlayFileMaxVolume                                = 1035;

    76     const TInt CDRMAudioPlay::KCasePlayFileSetBalance                               = 1036;

    77     const TInt CDRMAudioPlay::KCasePlayFileSetPriority                              = 1037;

    78     const TInt CDRMAudioPlay::KCasePlayFileSetRepeats                               = 1038;

    79 	const TInt CDRMAudioPlay::KCasePlayFilesGetMetaDataEntry                        = 1039;

    80 	const TInt CDRMAudioPlay::KCasePlayFilesGetNumberOfMetaDataEntries              = 1040;

    81     const TInt CDRMAudioPlay::KCasePlayRepeatDRMFile                                = 1041;

    82     const TInt CDRMAudioPlay::KCasePlayPauseRepeatDRMFile                           = 1042;

    83     const TInt CDRMAudioPlay::KCasePlayRepeatDRMFileForever                         = 1043;

    84     const TInt CDRMAudioPlay::KCasePlayRepeatDRMFileWithPlayWindow                  = 1044;

    85     const TInt CDRMAudioPlay::KCasePlayPauseRepeatDRMFileWithPlayWindow             = 1045;

    86     const TInt CDRMAudioPlay::KCasePlayRepeatForeverDRMFileWithPlayWindow           = 1046;

    87 

    88 // ** FilePlay *******************************************************

    89 TInt CDRMAudioPlay::TestCasePlayFileWithPauseL(CStifSectionParser *section , TTestResult &aResult)

    90 	{

    91 	TPtrC FileNamePtr;

    92 	TTimeIntervalMicroSeconds32 PauseDelay=KDefaultPauseDelay;

    93 	TTimeIntervalMicroSeconds32 PlayDelay=KDefaultPlayDelay;

    94 

    95 	if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )

    96 		{

    97 		TFileName FileName = FileNamePtr;

    98 		iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);

    99 		CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);

   100 		CleanupStack::PushL(sndPlayer);

   101 

   102 		//*********************************************

   103 		TBool UsingDefault;

   104 		PauseDelay = GetTimeIntervalL(section, KTagPauseDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPauseDelay);

   105 		if (UsingDefault) {iLogger->Log(_L("Error retrieving pause delay, using default"));}

   106 

   107 		PlayDelay = GetTimeIntervalL(section, KTagPlayDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPlayDelay);

   108 		if (UsingDefault) {iLogger->Log(_L("Error retrieving play delay, using default"));}

   109 

   110 		if (PauseDelay > PlayDelay)

   111 			{

   112 			//Pause delay longer than play delay. Switching

   113 			TTimeIntervalMicroSeconds32 TempDelay = PlayDelay;

   114 			PlayDelay = PauseDelay;

   115 			PauseDelay = TempDelay;

   116 			}

   117 		iLogger->Log(_L("Setting Pause and Play delays to [%d] and [%d]"), PauseDelay.Int(), PlayDelay.Int());

   118 

   119 		TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);

   120 		if (UsingDefault) {iLogger->Log(_L("Using default error range"));}

   121 

   122 		//*********************************************

   123 

   124 		CParameters *pauseParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionPause );

   125 		CleanupStack::PushL(pauseParams);

   126 

   127 		CParameters *playParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionPlay );

   128 		CleanupStack::PushL(playParams);

   129 

   130 		CMediaEvent *mEventPlay = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PlayDelay, PlayDelay, sndPlayer, playParams);

   131 		CMediaEvent *mEventPause = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PauseDelay, PauseDelay, sndPlayer, pauseParams, CActive::EPriorityStandard+1);

   132 

   133 		iLogger->Log(_L("Starting scheduler"));

   134 		TTime StartTime, EndTime;

   135 		StartTime.HomeTime();

   136 		CActiveScheduler::Start();

   137 		EndTime.HomeTime();

   138 

   139 		iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );

   140 

   141 		TTimeIntervalMicroSeconds PerceivedDuration = EndTime.MicroSecondsFrom( StartTime );

   142 

   143 		TTime ExpectedEnd = StartTime + sndPlayer->GetDuration() + PlayDelay - PauseDelay;

   144 		TTime Range1 = ExpectedEnd - ErrorRange;

   145 		TTime Range2 = ExpectedEnd + ErrorRange;

   146 

   147 		TTimeIntervalMicroSeconds ExpectedDuration = ExpectedEnd.MicroSecondsFrom( StartTime );

   148 

   149 		iLogger->Log(_L("Perceived duration (%d)") , PerceivedDuration.Int64() );

   150 

   151 		iLogger->Log(_L("Expected duration  (%d)"), ExpectedDuration.Int64() );

   152 	//	iLogger->Log(_L("Difference = (%d)") , ExpectedEnd.MicroSecondsFrom(EndTime) );

   153 

   154 		if (mEventPlay->GetCount()<=0 || mEventPause->GetCount()<=0)

   155 			{

   156 			iLogger->Log( KTestCaseResultFailSkippedEvents() );

   157 			aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );

   158 			aResult.iResult = KErrSkippedEvents;

   159 			}

   160 		else if (EndTime < Range1 || Range2 < EndTime)

   161 			{	//Durations too different

   162 			iLogger->Log(_L("The clips duration + silence duration (%d) is too different from the actual duration (%d)") , ExpectedDuration.Int64() , PerceivedDuration.Int64() );

   163 			aResult.iResult = KErrExpectedValueDifferent;

   164 			aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());

   165 			}

   166 		else if (sndPlayer->iFinalError)

   167 			{

   168 			aResult.iResult = sndPlayer->iFinalError;

   169 			iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);

   170 			aResult.iResultDes.Copy(KTestCaseResultFail());

   171 			}

   172 		else

   173 			{

   174 			iLogger->Log(_L("Test was successful"));

   175 			aResult.iResultDes.Copy(KTestCaseResultSuccess());

   176 			}

   177 		CleanupStack::PopAndDestroy(mEventPause);

   178 		CleanupStack::PopAndDestroy(mEventPlay);

   179 		CleanupStack::Pop(playParams);

   180 		CleanupStack::Pop(pauseParams);

   181 		CleanupStack::PopAndDestroy(sndPlayer);

   182 		return KErrExecuted;

   183 

   184 		}

   185 	else

   186 		{

   187 		//The file name of the clip to play is missing

   188 		aResult.iResultDes.Copy(KConfigInvalid());

   189 		aResult.iResult = KErrNotExecuted;

   190 		return KErrConfigInvalid;

   191 		}

   192 	}

   193 

   194 

   195 TInt CDRMAudioPlay::TestCasePlayHandlerWithPauseL(CStifSectionParser *section , TTestResult &aResult)

   196 	{

   197 

   198 	TPtrC FileNamePtr;

   199 	User::LeaveIfError(iFs.Connect());

   200 	iFs.ShareProtected();

   201 

   202 	TTimeIntervalMicroSeconds32 PauseDelay = KDefaultPauseDelay;

   203 	TTimeIntervalMicroSeconds32 PlayDelay = KDefaultPlayDelay;

   204 

   205 	if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )

   206 		{

   207 		TFileName FileName = FileNamePtr;

   208 

   209 		iLogger->Log(_L("Creating simple player with file handler [%S]"), &FileNamePtr);

   210 		User::LeaveIfError(iFile.Open( iFs, FileName, EFileRead));

   211 

   212 		CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);

   213 

   214 		iFile.Close();

   215 	//	iFs.Close();

   216 

   217 		CleanupStack::PushL(sndPlayer);

   218 

   219 		//*********************************************

   220 		TBool UsingDefault;

   221 		PauseDelay = GetTimeIntervalL(section, KTagPauseDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPauseDelay);

   222 		if (UsingDefault) {iLogger->Log(_L("Error retrieving pause delay, using default"));}

   223 

   224 		PlayDelay = GetTimeIntervalL(section, KTagPlayDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPlayDelay);

   225 		if (UsingDefault) {iLogger->Log(_L("Error retrieving play delay, using default"));}

   226 

   227 		if (PauseDelay > PlayDelay)

   228 			{

   229 			//Pause delay longer than play delay. Switching

   230 			TTimeIntervalMicroSeconds32 TempDelay = PlayDelay;

   231 			PlayDelay = PauseDelay;

   232 			PauseDelay = TempDelay;

   233 			}

   234 		iLogger->Log(_L("Setting Pause and Play delays to [%d] and [%d]"), PauseDelay.Int(), PlayDelay.Int());

   235 

   236 		TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);

   237 		if (UsingDefault) {iLogger->Log(_L("Using default error range"));}

   238 

   239 		//*********************************************

   240 

   241 		CParameters *pauseParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionPause );

   242 		CleanupStack::PushL(pauseParams);

   243 

   244 		CParameters *playParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionPlay );

   245 		CleanupStack::PushL(playParams);

   246 

   247 		CMediaEvent *mEventPlay = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PlayDelay, PlayDelay, sndPlayer, playParams);

   248 		CMediaEvent *mEventPause = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PauseDelay, PauseDelay, sndPlayer, pauseParams, CActive::EPriorityStandard+1);

   249 

   250 		iLogger->Log(_L("Starting scheduler"));

   251 		TTime StartTime, EndTime;

   252 		StartTime.HomeTime();

   253 		CActiveScheduler::Start();

   254 		EndTime.HomeTime();

   255 

   256 		iFs.Close();

   257 

   258 		iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );

   259 

   260 		TTimeIntervalMicroSeconds PerceivedDuration = EndTime.MicroSecondsFrom( StartTime );

   261 

   262 		TTime ExpectedEnd = StartTime + sndPlayer->GetDuration() + PlayDelay - PauseDelay;

   263 		TTime Range1 = ExpectedEnd - ErrorRange;

   264 		TTime Range2 = ExpectedEnd + ErrorRange;

   265 

   266 		TTimeIntervalMicroSeconds ExpectedDuration = ExpectedEnd.MicroSecondsFrom( StartTime );

   267 

   268 		iLogger->Log(_L("Perceived duration (%d)") , PerceivedDuration.Int64() );

   269 

   270 		iLogger->Log(_L("Expected duration  (%d)"), ExpectedDuration.Int64() );

   271 

   272 	//	iLogger->Log(_L("Difference = (%d)") , ExpectedEnd.MicroSecondsFrom(EndTime) );

   273 

   274 		if (mEventPlay->GetCount()<=0 || mEventPause->GetCount()<=0)

   275 			{

   276 			iLogger->Log( KTestCaseResultFailSkippedEvents() );

   277 			aResult.iResultDes.Copy( KTestCaseResultFailSkippedEvents() );

   278 			aResult.iResult = KErrSkippedEvents;

   279 			}

   280 		else if (EndTime < Range1 || Range2 < EndTime)

   281 			{	//Durations too different

   282 			iLogger->Log(_L("The clips duration + silence duration (%d) is too different from the actual duration (%d)") , ExpectedDuration.Int64() , PerceivedDuration.Int64() );

   283 			aResult.iResult = KErrExpectedValueDifferent;

   284 			aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());

   285 			}

   286 		else if (sndPlayer->iFinalError)

   287 			{

   288 			aResult.iResult = sndPlayer->iFinalError;

   289 			iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);

   290 			aResult.iResultDes.Copy(KTestCaseResultFail());

   291 			}

   292 		else

   293 			{

   294 			iLogger->Log(_L("Test was successful"));

   295 			aResult.iResultDes.Copy(KTestCaseResultSuccess());

   296 			}

   297 

   298 		CleanupStack::PopAndDestroy(mEventPause);

   299 		CleanupStack::PopAndDestroy(mEventPlay);

   300 		CleanupStack::Pop(playParams);

   301 		CleanupStack::Pop(pauseParams);

   302 		CleanupStack::PopAndDestroy(sndPlayer);

   303 		return KErrExecuted;

   304 

   305 		}

   306 	else

   307 		{

   308 		//The file name of the clip to play is missing

   309 		aResult.iResultDes.Copy(KConfigInvalid());

   310 		aResult.iResult = KErrNotExecuted;

   311 		return KErrConfigInvalid;

   312 		}

   313 	}

   314 

   315 

   316 TInt CDRMAudioPlay::TestCasePlayFileL(CStifSectionParser *section , TTestResult &aResult)

   317 	{

   318 	TPtrC FileNamePtr;

   319     CStifItemParser *item;

   320     TInt parseError = KErrNone;

   321     TBool Immediate = 0;

   322 	if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )

   323 		{

   324 		TFileName FileName = FileNamePtr;

   325 		iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);

   326         item = section->GetItemLineL(KTagImmediate);

   327         if (item)

   328             {

   329             CleanupStack::PushL(item);

   330             parseError = item->GetInt(KTagImmediate, Immediate);

   331             CleanupStack::PopAndDestroy(item);

   332             }

   333         item = NULL;

   334         TBool FileType = EFalse;

   335         item = section->GetItemLineL(KTagFileType);

   336         if (item)

   337         	{

   338         	CleanupStack::PushL(item);

   339         	parseError = item->GetInt(KTagFileType, FileType);

   340         	CleanupStack::PopAndDestroy(item);

   341         	}

   342 

   343         CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger, Immediate, FileType);

   344 

   345 		CleanupStack::PushL(sndPlayer);

   346 		iLogger->Log(_L("Starting scheduler"));

   347 

   348 		CActiveScheduler::Start();

   349 

   350 

   351 		iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );

   352 		aResult.iResult = sndPlayer->iFinalError ;

   353 

   354 		TBool DontCheckExpectedDuration;

   355 		TTimeIntervalMicroSeconds ErrorRange=GetTimeIntervalL(section, KTagErrorRange, DontCheckExpectedDuration);

   356 		if (!DontCheckExpectedDuration && !aResult.iResult)

   357 			{

   358 			TBool DontUseExpectedDuration;

   359 			TTimeIntervalMicroSeconds ExpectedDuration=GetTimeIntervalL(section, KTagExpectedDuration, DontUseExpectedDuration);

   360 			if (!IsDurationInRange(0, (DontUseExpectedDuration ? sndPlayer->GetDuration() : ExpectedDuration), TTimeIntervalMicroSeconds(0), ErrorRange, sndPlayer->GetPlayStartTime(), sndPlayer->GetPlayStopTime() ) )

   361 				{

   362 				iLogger->Log(_L("Duration too different"));

   363 				aResult.iResult = KErrExpectedValueDifferent;

   364 				}

   365 			}

   366 

   367 		if (aResult.iResult)

   368 			{

   369 			iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);

   370 			aResult.iResultDes.Copy(KTestCaseResultFail());

   371 			}

   372 		else

   373 			{

   374 			iLogger->Log(_L("Test was successful"));

   375 			aResult.iResultDes.Copy(KTestCaseResultSuccess());

   376 			}

   377 

   378 		CleanupStack::PopAndDestroy(sndPlayer);

   379 		return KErrExecuted;

   380 

   381 		}

   382 	else

   383 		{

   384 		//The file name of the clip to play is missing

   385 		aResult.iResultDes.Copy(KConfigInvalid());

   386 		aResult.iResult = KErrNotExecuted;

   387 		return KErrConfigInvalid;

   388 		}

   389 	}

   390 

   391 TInt CDRMAudioPlay::TestCasePlayHandlerL(CStifSectionParser *section , TTestResult &aResult)

   392 	{

   393 	TPtrC FileNamePtr;

   394 

   395 	User::LeaveIfError(iFs.Connect());

   396 	iFs.ShareProtected();

   397 

   398 	if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )

   399 		{

   400 		TFileName FileName = FileNamePtr;

   401 		iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);

   402 

   403 		User::LeaveIfError(iFile.Open( iFs, FileName, EFileRead));

   404 	//	TRAP(err, iAudioPlayer->OpenFileL( iFile ));

   405 

   406 	//	CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);

   407 		CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);

   408 

   409 		iFile.Close();

   410 	//	iFs.Close();

   411 

   412 		CleanupStack::PushL(sndPlayer);

   413 		iLogger->Log(_L("Starting scheduler"));

   414 

   415 		CActiveScheduler::Start();

   416 

   417 		iFs.Close();

   418 		iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );

   419 		aResult.iResult = sndPlayer->iFinalError ;

   420 

   421 		TBool DontCheckExpectedDuration;

   422 		TTimeIntervalMicroSeconds ErrorRange=GetTimeIntervalL(section, KTagErrorRange, DontCheckExpectedDuration);

   423 		if (!DontCheckExpectedDuration && !aResult.iResult)

   424 			{

   425 			TBool DontUseExpectedDuration;

   426 			TTimeIntervalMicroSeconds ExpectedDuration=GetTimeIntervalL(section, KTagExpectedDuration, DontUseExpectedDuration);

   427 			if (!IsDurationInRange(0, (DontUseExpectedDuration ? sndPlayer->GetDuration() : ExpectedDuration), TTimeIntervalMicroSeconds(0), ErrorRange, sndPlayer->GetPlayStartTime(), sndPlayer->GetPlayStopTime() ) )

   428 				{

   429 				iLogger->Log(_L("Duration too different"));

   430 				aResult.iResult = KErrExpectedValueDifferent;

   431 				}

   432 			}

   433 

   434 		if (aResult.iResult)

   435 			{

   436 			iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);

   437 			aResult.iResultDes.Copy(KTestCaseResultFail());

   438 			}

   439 		else

   440 			{

   441 			iLogger->Log(_L("Test was successful"));

   442 			aResult.iResultDes.Copy(KTestCaseResultSuccess());

   443 			}

   444 

   445 		CleanupStack::PopAndDestroy(sndPlayer);

   446 		return KErrExecuted;

   447 

   448 		}

   449 	else

   450 		{

   451 		//The file name of the clip to play is missing

   452 		aResult.iResultDes.Copy(KConfigInvalid());

   453 		aResult.iResult = KErrNotExecuted;

   454 		return KErrConfigInvalid;

   455 		}

   456 	}

   457 

   458 TInt CDRMAudioPlay::TestCasePlayFileWithRepeatsL(CStifSectionParser *section , TTestResult &aResult)

   459 	{

   460 	TPtrC FileNamePtr;

   461 	TInt Repeats = KDefaultRepeats;

   462 	TTimeIntervalMicroSeconds SilenceDuration = KDefaultSilenceDuration;

   463 	TInt ParseError=KErrNone;

   464 	CStifItemParser *item;

   465 

   466 	if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )

   467 		{

   468 		TFileName FileName = FileNamePtr;

   469 		TBool DontCheckExpectedDuration;

   470 		TTimeIntervalMicroSeconds ErrorRange=GetTimeIntervalL(section, KTagErrorRange, DontCheckExpectedDuration);

   471 

   472 		iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);

   473 		CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);

   474 		CleanupStack::PushL(sndPlayer);

   475 

   476 		//Setup repeat count

   477 		ParseError=KErrNotFound;

   478 		item = section->GetItemLineL(KTagRepeatTimes);

   479 		if (item)

   480 			{

   481 			CleanupStack::PushL(item);

   482 			ParseError = item->GetInt(KTagRepeatTimes, Repeats);

   483 			CleanupStack::PopAndDestroy(item);

   484 			}

   485 		iLogger->Log(_L("Setting up repeat count to %d"), Repeats);

   486 		if (ParseError)

   487 			{

   488 			iLogger->Log(_L("Using default value of %d"), KDefaultRepeats); Repeats=KDefaultRepeats;

   489 			}

   490 

   491 		TBool UsingDefault;

   492 		SilenceDuration = GetTimeIntervalL(section, KTagSilenceDuration, UsingDefault, KDefaultSilenceDuration);

   493 		// * ****************************************************

   494 		iLogger->Log(_L("Setting interval to %d"), SilenceDuration.Int64());

   495 

   496 		if (UsingDefault) { iLogger->Log(_L("Using default of %d"), KDefaultSilenceDuration.Int64()) ; }

   497 		sndPlayer->SetRepeats(Repeats, SilenceDuration);

   498 

   499 		iLogger->Log(_L("Starting scheduler"));

   500 		CActiveScheduler::Start();

   501 

   502 		iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );

   503 		aResult.iResult = sndPlayer->iFinalError;

   504 

   505 		if (!DontCheckExpectedDuration && !aResult.iResult)

   506 			{

   507 			TBool DontUseExpectedDuration;

   508 			TTimeIntervalMicroSeconds ExpectedDuration=GetTimeIntervalL(section, KTagExpectedDuration, DontUseExpectedDuration);

   509 			if (!IsDurationInRange(Repeats, ( DontUseExpectedDuration ? sndPlayer->GetDuration() : ExpectedDuration), SilenceDuration, ErrorRange, sndPlayer->GetPlayStartTime(), sndPlayer->GetPlayStopTime() ) )

   510 				{

   511 				iLogger->Log(_L("Duration too different"));

   512 				aResult.iResult = KErrExpectedValueDifferent;

   513 				}

   514 			}

   515 

   516 		CleanupStack::PopAndDestroy(sndPlayer);

   517 		if (aResult.iResult)

   518 			{

   519 			iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);

   520 			aResult.iResultDes.Copy(KTestCaseResultFail());

   521 			}

   522 		else

   523 			{

   524 			iLogger->Log(_L("Test was successful"));

   525 			aResult.iResultDes.Copy(KTestCaseResultSuccess());

   526 			}

   527 		return KErrExecuted;	//aResult.iResult;

   528 

   529 		}

   530 	else

   531 		{

   532 		//The file name of the clip to play is missing

   533 		aResult.iResultDes.Copy(KConfigInvalid());

   534 		aResult.iResult = KErrNotExecuted;

   535 		return KErrConfigInvalid;

   536 		}

   537 	}

   538 

   539 TInt CDRMAudioPlay::TestCasePlayFileWithPositionL(CStifSectionParser *section, TTestResult & aResult)

   540 	{

   541 	TPtrC FileNamePtr;

   542 	TTimeIntervalMicroSeconds Position = KDefaultPosition;

   543 

   544 	if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )

   545 		{

   546 		TFileName FileName = FileNamePtr;

   547 		iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);

   548 		CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);

   549 		CleanupStack::PushL(sndPlayer);

   550 

   551 		TBool UsingDefault;

   552 		Position = GetTimeIntervalL(section, KTagPosition, UsingDefault, KDefaultPosition);

   553 

   554 		iLogger->Log(_L("Seting position to: %d"), Position.Int64());

   555 		if (UsingDefault) {iLogger->Log(_L("Using default position duration of: (%d)") , KDefaultPosition.Int64());}

   556 		sndPlayer->iPosition = Position;

   557 

   558 		TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);

   559 		if (UsingDefault) {iLogger->Log(_L("Using default error range"));}

   560 		// * **************************************************************

   561 

   562 		iLogger->Log(_L("Starting scheduler"));

   563 		TTime StartTime,EndTime;

   564 		StartTime.HomeTime();

   565 		CActiveScheduler::Start();

   566 		EndTime.HomeTime();

   567 

   568 

   569 

   570 		TTimeIntervalMicroSeconds PerceivedDuration = EndTime.MicroSecondsFrom( StartTime );

   571 

   572 		iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );

   573 		iLogger->Log(_L("Perceived duration: %d") , PerceivedDuration.Int64() );

   574 

   575 

   576 		TTimeIntervalMicroSeconds ExpectedDuration = TTimeIntervalMicroSeconds(I64INT(sndPlayer->GetDuration().Int64()) - I64INT(Position.Int64()));

   577 		iLogger->Log(_L("ExpectedDuration: %d") ,ExpectedDuration.Int64() );

   578 

   579 		if (  Abs(ExpectedDuration.Int64() - PerceivedDuration.Int64()) > ErrorRange.Int64() )

   580 			{	//Durations too different

   581 			iLogger->Log(_L("The clips duration is too different from the actual duration + position") );

   582 			aResult.iResult = KErrExpectedValueDifferent;

   583 			aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());

   584 			}

   585 		else

   586 			{

   587 			aResult.iResult = sndPlayer->iFinalError;

   588 			if (aResult.iResult)

   589 				{

   590 				iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);

   591 				aResult.iResultDes.Copy(KTestCaseResultFail());

   592 				}

   593 			else

   594 				{

   595 				iLogger->Log(_L("Test was successful"));

   596 				aResult.iResultDes.Copy(KTestCaseResultSuccess());

   597 				}

   598 			}

   599 		CleanupStack::PopAndDestroy(sndPlayer);

   600 		return KErrExecuted;

   601 		}

   602 	else

   603 		{

   604 		aResult.iResultDes.Copy(KConfigInvalid());

   605 		aResult.iResult = KErrNotExecuted;

   606 		return KErrConfigInvalid;

   607 		}

   608 	}

   609 

   610 

   611 //FH

   612 TInt CDRMAudioPlay::TestCasePlayHandlerWithSetPositionL(CStifSectionParser *section, TTestResult & aResult)

   613 	{

   614 

   615 	TPtrC FileNamePtr;

   616 	User::LeaveIfError(iFs.Connect());

   617 	iFs.ShareProtected();

   618 

   619 	TTimeIntervalMicroSeconds Position = KDefaultPosition;

   620 

   621 	if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )

   622 		{

   623 		TFileName FileName = FileNamePtr;

   624 		iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);

   625 		User::LeaveIfError(iFile.Open( iFs, FileName, EFileRead));

   626 	//	CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);

   627 		CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);

   628 		iFile.Close();

   629 		CleanupStack::PushL(sndPlayer);

   630 

   631 		TBool UsingDefault;

   632 		Position = GetTimeIntervalL(section, KTagPosition, UsingDefault, KDefaultPosition);

   633 

   634 		iLogger->Log(_L("Seting position to: %d"), Position.Int64());

   635 		if (UsingDefault) {iLogger->Log(_L("Using default position duration of: (%d)") , KDefaultPosition.Int64());}

   636 		sndPlayer->iPosition = Position;

   637 

   638 		TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);

   639 		if (UsingDefault) {iLogger->Log(_L("Using default error range"));}

   640 		// * **************************************************************

   641 

   642 		iLogger->Log(_L("Starting scheduler"));

   643 		TTime StartTime,EndTime;

   644 		StartTime.HomeTime();

   645 		CActiveScheduler::Start();

   646 		EndTime.HomeTime();

   647 

   648 		iFs.Close();

   649 

   650 		TTimeIntervalMicroSeconds PerceivedDuration = EndTime.MicroSecondsFrom( StartTime );

   651 

   652 		iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );

   653 		iLogger->Log(_L("Perceived duration: %d") , PerceivedDuration.Int64() );

   654 

   655 

   656 		TTimeIntervalMicroSeconds ExpectedDuration = TTimeIntervalMicroSeconds(I64INT(sndPlayer->GetDuration().Int64()) - I64INT(Position.Int64()));

   657 		iLogger->Log(_L("ExpectedDuration: %d") ,ExpectedDuration.Int64() );

   658 

   659 		if (  Abs(ExpectedDuration.Int64() - PerceivedDuration.Int64()) > ErrorRange.Int64() )

   660 			{	//Durations too different

   661 			iLogger->Log(_L("The clips duration is too different from the actual duration + position") );

   662 			aResult.iResult = KErrExpectedValueDifferent;

   663 			aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());

   664 			}

   665 		else

   666 			{

   667 			aResult.iResult = sndPlayer->iFinalError;

   668 			if (aResult.iResult)

   669 				{

   670 				iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);

   671 				aResult.iResultDes.Copy(KTestCaseResultFail());

   672 				}

   673 			else

   674 				{

   675 				iLogger->Log(_L("Test was successful"));

   676 				aResult.iResultDes.Copy(KTestCaseResultSuccess());

   677 				}

   678 			}

   679 		CleanupStack::PopAndDestroy(sndPlayer);

   680 		return KErrExecuted;

   681 		}

   682 	else

   683 		{

   684 		aResult.iResultDes.Copy(KConfigInvalid());

   685 		aResult.iResult = KErrNotExecuted;

   686 		return KErrConfigInvalid;

   687 		}

   688 	}

   689 

   690 TInt CDRMAudioPlay::TestCasePlayFileStopOpenL(CStifSectionParser *section , TTestResult &aResult)

   691 	{

   692 		TPtrC FileNamePtr;

   693 		TTimeIntervalMicroSeconds32 StopDelay=KDefaultPauseDelay;

   694 		TTimeIntervalMicroSeconds32 PlayDelay=KDefaultPlayDelay;

   695 

   696 		if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )

   697 		{

   698 			TFileName FileName = FileNamePtr;

   699 			iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);

   700 			CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);

   701 			CleanupStack::PushL(sndPlayer);

   702 

   703 

   704 			CParameters *playParams;

   705 			if ( section->GetNextLine(KTagSoundFile, FileNamePtr, ENoTag) )

   706 			{

   707 				playParams = CFileNameParameters::NewLC(CSimpleSoundPlayer::KPlayerActionOpen, FileName );

   708 				iLogger->Log(_L("Second filename not found, using the same file twice"));

   709 			}

   710 			else

   711 			{

   712 				playParams = CFileNameParameters::NewLC(CSimpleSoundPlayer::KPlayerActionOpen, FileNamePtr );

   713 				iLogger->Log(_L("Second filename set to [%S]") , &FileNamePtr );

   714 			}

   715 

   716 			//*********************************************

   717 			TBool UsingDefault;

   718 			StopDelay = GetTimeIntervalL(section, KTagStopDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPauseDelay);

   719 			if (UsingDefault)

   720 			{

   721 				iLogger->Log(_L("Error retrieving pause delay, using default"));

   722 			}

   723 

   724 			PlayDelay = GetTimeIntervalL(section, KTagPlayDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPlayDelay);

   725 			if (UsingDefault) {iLogger->Log(_L("Error retrieving play delay, using default"));}

   726 

   727 			if (StopDelay > PlayDelay)

   728 			{

   729 				//Pause delay longer than play delay. Switching

   730 				TTimeIntervalMicroSeconds32 TempDelay = PlayDelay;

   731 				PlayDelay = StopDelay;

   732 				StopDelay = TempDelay;

   733 			}

   734 

   735 			TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);

   736 			if (UsingDefault) {iLogger->Log(_L("Using default error range"));}

   737 

   738 			//*********************************************

   739 

   740 			CParameters *stopParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionStopPlayFile );

   741 			CleanupStack::PushL(stopParams);

   742 

   743 			CMediaEvent *mEventPlay = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PlayDelay, PlayDelay, sndPlayer, playParams);

   744 			CMediaEvent *mEventStop = CMediaEvent::NewLC(TestModuleIf() , *iLogger, StopDelay, StopDelay, sndPlayer, stopParams, CActive::EPriorityStandard+1);

   745 

   746 			iLogger->Log(_L("Starting scheduler"));

   747 			TTime StartTime, EndTime;

   748 			StartTime.HomeTime();

   749 			CActiveScheduler::Start();

   750 			EndTime.HomeTime();

   751 

   752 			iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );

   753 			aResult.iResult = sndPlayer->iFinalError;

   754 			iLogger->Log(_L("Playcount: (%d)") , mEventStop->GetCount() );

   755 			if (mEventStop->GetCount() <= 0)

   756 			{

   757 				aResult.iResult = KErrSkippedEvents;

   758 				iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);

   759 				aResult.iResultDes.Copy(KTestCaseResultFailSkippedEvents());

   760 			}

   761 			else if (sndPlayer->iFinalError)

   762 				{

   763 					iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);

   764 					aResult.iResultDes.Copy(KTestCaseResultFail());

   765 					aResult.iResult = sndPlayer->iFinalError;

   766 				}

   767 				else

   768 				{

   769 					iLogger->Log(_L("Test was successful"));

   770 					aResult.iResultDes.Copy(KTestCaseResultSuccess());

   771 					aResult.iResult = sndPlayer->iFinalError;

   772 				}

   773 

   774 			CleanupStack::PopAndDestroy(mEventStop);

   775 			CleanupStack::PopAndDestroy(mEventPlay);

   776 			CleanupStack::Pop(stopParams);

   777 			CleanupStack::Pop(playParams);

   778 			CleanupStack::PopAndDestroy(sndPlayer);

   779 			return KErrExecuted;

   780 

   781 		}

   782 		else

   783 		{

   784 		aResult.iResultDes.Copy(KConfigInvalid());

   785 		aResult.iResult = KErrNotExecuted;

   786 		return KErrConfigInvalid;

   787 		}

   788 	}

   789 

   790 

   791 TInt CDRMAudioPlay::TestCasePlayHandlerStopOpenL(CStifSectionParser *section , TTestResult &aResult)

   792 	{

   793 

   794 	TPtrC FileNamePtr;

   795 	User::LeaveIfError(iFs.Connect());

   796 	iFs.ShareProtected();

   797 

   798 	TTimeIntervalMicroSeconds32 StopDelay=KDefaultStopOpenPlayDelay;

   799 	TTimeIntervalMicroSeconds32 PlayDelay=KDefaultPlayDelay;

   800 

   801 	if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )

   802 	{

   803 		TFileName FileName = FileNamePtr;

   804 		iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);

   805 		User::LeaveIfError(iFile.Open( iFs, FileName, EFileRead));

   806 

   807 		CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);

   808 

   809 		iFile.Close();

   810 		CleanupStack::PushL(sndPlayer);

   811 

   812 

   813 		CParameters *playParams;

   814 		if ( section->GetNextLine(KTagSoundFile, FileNamePtr, ENoTag) )

   815 		{

   816 			playParams = CFileNameParameters::NewLC(CSimpleSoundPlayer::KPlayerActionOpenFileHandler, FileName );

   817 			iLogger->Log(_L("Second filename not found, using the same file twice"));

   818 		}

   819 		else

   820 		{

   821 			playParams = CFileNameParameters::NewLC(CSimpleSoundPlayer::KPlayerActionOpenFileHandler, FileNamePtr );

   822 			iLogger->Log(_L("Second filename set to [%S]") , &FileNamePtr );

   823 		}

   824 

   825 		//*********************************************

   826 		TBool UsingDefault;

   827 		StopDelay = GetTimeIntervalL(section, KTagStopDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPauseDelay);

   828 		if (UsingDefault) {iLogger->Log(_L("Error retrieving pause delay, using default"));}

   829 

   830 		PlayDelay = GetTimeIntervalL(section, KTagPlayDelay, UsingDefault, (TTimeIntervalMicroSeconds32)KDefaultPlayDelay);

   831 		if (UsingDefault) {iLogger->Log(_L("Error retrieving play delay, using default"));}

   832 

   833 		if (StopDelay > PlayDelay)

   834 		{

   835 			//Pause delay longer than play delay. Switching

   836 			TTimeIntervalMicroSeconds32 TempDelay = PlayDelay;

   837 			PlayDelay = StopDelay;

   838 			StopDelay = TempDelay;

   839 		}

   840 

   841 		TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);

   842 		if (UsingDefault) {iLogger->Log(_L("Using default error range"));}

   843 

   844 		//*********************************************

   845 

   846 		CParameters *stopParams = new (ELeave) CParameters( CSimpleSoundPlayer::KPlayerActionStopPlayFileHandler );

   847 		CleanupStack::PushL(stopParams);

   848 

   849 		CMediaEvent *mEventPlay = CMediaEvent::NewLC(TestModuleIf() , *iLogger, PlayDelay, PlayDelay, sndPlayer, playParams);

   850 		CMediaEvent *mEventStop = CMediaEvent::NewLC(TestModuleIf() , *iLogger, StopDelay, StopDelay, sndPlayer, stopParams, CActive::EPriorityStandard+1);

   851 

   852 		iLogger->Log(_L("Starting scheduler"));

   853 		TTime StartTime, EndTime;

   854 		StartTime.HomeTime();

   855 		CActiveScheduler::Start();

   856 		EndTime.HomeTime();

   857 

   858 		iFs.Close();

   859 

   860 		iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );

   861 		aResult.iResult = sndPlayer->iFinalError;

   862 		iLogger->Log(_L("Playcount: (%d)") , mEventStop->GetCount() );

   863 		if (mEventStop->GetCount() <= 0)

   864 		{

   865 			aResult.iResult = KErrSkippedEvents;

   866 			iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);

   867 			aResult.iResultDes.Copy(KTestCaseResultFailSkippedEvents());

   868 		}

   869 		else if (sndPlayer->iFinalError)

   870 			{

   871 				iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);

   872 				aResult.iResultDes.Copy(KTestCaseResultFail());

   873 				aResult.iResult = sndPlayer->iFinalError;

   874 			}

   875 			else

   876 			{

   877 				iLogger->Log(_L("Test was successful"));

   878 				aResult.iResultDes.Copy(KTestCaseResultSuccess());

   879 				aResult.iResult = sndPlayer->iFinalError;

   880 			}

   881 

   882 		CleanupStack::PopAndDestroy(mEventStop);

   883 		CleanupStack::PopAndDestroy(mEventPlay);

   884 		CleanupStack::Pop(stopParams);

   885 		CleanupStack::Pop(playParams);

   886 		CleanupStack::PopAndDestroy(sndPlayer);

   887 		return KErrExecuted;

   888 

   889 	}

   890 	else

   891 	{

   892 	aResult.iResultDes.Copy(KConfigInvalid());

   893 	aResult.iResult = KErrNotExecuted;

   894 	return KErrConfigInvalid;

   895 	}

   896 }

   897 

   898 

   899 TInt CDRMAudioPlay::TestCasePlayFileWithBalanceL(CStifSectionParser *section , TTestResult &aResult)

   900 	{

   901 	TPtrC FileNamePtr;

   902 	TInt Balance = KMMFBalanceCenter;

   903 	TInt ParseError=KErrNone;

   904 	CStifItemParser *item;

   905 

   906 	if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )

   907 		{

   908 	//	TInt BalanceError=KErrNone;

   909 		TFileName FileName = FileNamePtr;

   910 		iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);

   911 		CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);

   912 		CleanupStack::PushL(sndPlayer);

   913 

   914 		//*********************

   915 		ParseError=KErrNotFound;

   916 		item = section->GetItemLineL(KTagBalance);

   917 		if (item)

   918 			{

   919 			CleanupStack::PushL(item);

   920 			ParseError = item->GetInt(KTagBalance, Balance);

   921 			CleanupStack::PopAndDestroy(item);

   922 			}

   923 		if (ParseError)

   924 			{

   925 			iLogger->Log(_L("Value for Balance not found, using default (%d)") , KMMFBalanceCenter);

   926 			Balance = KMMFBalanceCenter;

   927 			}

   928 		else

   929 			{

   930 			iLogger->Log(_L("Setting Balance to: %d"), Balance);

   931 			sndPlayer->iBalance = Balance;

   932 			}

   933 

   934 		sndPlayer->iSetBalance = true;

   935 

   936 //		iLogger->Log(_L("Setting Balance to: %d"), Balance);

   937 //		BalanceError = sndPlayer->SetBalance(Balance);

   938 	//	if (BalanceError)

   939 		//	{

   940 		//	iLogger->Log(_L("Error setting balance"));

   941 		//	aResult.iResult = BalanceError;

   942 		//	}

   943 	//	else

   944 		//	{

   945 			iLogger->Log(_L("Starting scheduler"));

   946 			CActiveScheduler::Start();

   947 

   948 			iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );

   949 			aResult.iResult = sndPlayer->iFinalError;

   950 		//	}

   951 

   952 		if (aResult.iResult)

   953 			{

   954 			iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);

   955 			aResult.iResultDes.Copy(KTestCaseResultFail());

   956 			}

   957 		else

   958 			{

   959 			iLogger->Log(_L("Test was successful"));

   960 			aResult.iResultDes.Copy(KTestCaseResultSuccess());

   961 			}

   962 		CleanupStack::PopAndDestroy(sndPlayer);

   963 		return KErrExecuted;

   964 

   965 		}

   966 	else

   967 		{

   968 		//The file name of the clip to play is missing

   969 		aResult.iResultDes.Copy(KConfigInvalid());

   970 		aResult.iResult = KErrNotExecuted;

   971 		return KErrConfigInvalid;

   972 		}

   973 	}

   974 

   975 TInt CDRMAudioPlay::TestCasePlayDesL(CStifSectionParser *section , TTestResult &aResult)

   976 	{

   977 	TPtrC FileNamePtr;

   978     CStifItemParser *item;

   979     TInt parseError = KErrNone;

   980     TBool Immediate = 0;

   981     TBool DesReadOnly = 0;

   982 	if ( !section->GetLine(KTagSoundDes, FileNamePtr, ENoTag) )

   983 		{

   984 		TFileName FileName = FileNamePtr;

   985 

   986 		HBufC8 *SoundFile = GetDescriptor8LC(FileName, section);

   987 

   988         item = section->GetItemLineL(KTagImmediate);

   989         if (item)

   990             {

   991             CleanupStack::PushL(item);

   992             parseError = item->GetInt(KTagImmediate, Immediate);

   993             CleanupStack::PopAndDestroy(item);

   994             }

   995         item = NULL;

   996         item = section->GetItemLineL(KTagDesReadOnly);

   997         if (item)

   998         	{

   999         	CleanupStack::PushL(item);

  1000         	parseError = item->GetInt(KTagDesReadOnly, DesReadOnly);

  1001         	CleanupStack::PopAndDestroy(item);

  1002         	}

  1003 

  1004 		iLogger->Log(_L("Creating simple player with descriptor from [%S]"), &FileNamePtr);

  1005 		CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( *SoundFile, TestModuleIf() , *iLogger, Immediate, DesReadOnly);

  1006 

  1007 		CleanupStack::PushL(sndPlayer);

  1008 

  1009 		iLogger->Log(_L("Starting scheduler"));

  1010 

  1011 		CActiveScheduler::Start();

  1012 

  1013 		iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );

  1014 		aResult.iResult = sndPlayer->iFinalError ;

  1015 

  1016 		TBool DontCheckExpectedDuration;

  1017 		TTimeIntervalMicroSeconds ErrorRange=GetTimeIntervalL(section, KTagErrorRange, DontCheckExpectedDuration);

  1018 

  1019 		if (!DontCheckExpectedDuration && !aResult.iResult)

  1020 			{

  1021 			TBool DontUseExpectedDuration;

  1022 			TTimeIntervalMicroSeconds ExpectedDuration=GetTimeIntervalL(section, KTagExpectedDuration, DontUseExpectedDuration);

  1023 			if (!IsDurationInRange(0, (DontUseExpectedDuration

  1024 						? sndPlayer->GetDuration()

  1025 						: ExpectedDuration

  1026 						), TTimeIntervalMicroSeconds(0), ErrorRange, sndPlayer->GetPlayStartTime(), sndPlayer->GetPlayStopTime() ) )

  1027 				{

  1028 				iLogger->Log(_L("Duration too different"));

  1029 				aResult.iResult = KErrExpectedValueDifferent;

  1030 				}

  1031 			}

  1032 

  1033 

  1034 		CleanupStack::PopAndDestroy(sndPlayer);

  1035 

  1036 		CleanupStack::PopAndDestroy(SoundFile);

  1037 

  1038 		if (aResult.iResult)

  1039 			{

  1040 			iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);

  1041 			aResult.iResultDes.Copy(KTestCaseResultFail());

  1042 			}

  1043 		else

  1044 			{

  1045 			iLogger->Log(_L("Test was successful"));

  1046 			aResult.iResultDes.Copy(KTestCaseResultSuccess());

  1047 			}

  1048 		return KErrExecuted;

  1049 		}

  1050 	else

  1051 		{

  1052 		aResult.iResultDes.Copy(KConfigInvalid());

  1053 		aResult.iResult = KErrNotExecuted;

  1054 

  1055 		return KErrConfigInvalid;

  1056 		}

  1057 	}

  1058 

  1059 

  1060 TInt CDRMAudioPlay::TestCasePlayFileReportPositionL(CStifSectionParser *section , TTestResult &aResult)

  1061 	{

  1062 	TPtrC FileNamePtr;

  1063 	TTimeIntervalMicroSeconds32 ReportDelay = KDefaultReportDelay;

  1064 

  1065 	if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )

  1066 		{

  1067 		TFileName FileName = FileNamePtr;

  1068 		TBool UsingDefaultReportDelay;

  1069 		iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);

  1070 		CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);

  1071 		CleanupStack::PushL(sndPlayer);

  1072 

  1073 		//*********************************************

  1074 		ReportDelay = GetTimeIntervalL(section, KTagDelay, UsingDefaultReportDelay, (TTimeIntervalMicroSeconds32)KDefaultReportDelay);

  1075 		iLogger->Log(_L("Setting delays to report position to [%d]"), ReportDelay.Int());

  1076 		//*********************************************

  1077 

  1078 		CParameters *reportParams = new(ELeave)CParameters(CSimpleSoundPlayer::KPlayerActionReportPosition);

  1079 		CleanupStack::PushL(reportParams);

  1080 		CMediaEvent *mEventReportPosition = CMediaEvent::NewLC(TestModuleIf() , *iLogger, ReportDelay, ReportDelay, sndPlayer, reportParams);

  1081 

  1082 		iLogger->Log(_L("Starting scheduler"));

  1083 		CActiveScheduler::Start();

  1084 

  1085 		CleanupStack::PopAndDestroy(mEventReportPosition);

  1086 		CleanupStack::Pop(reportParams);

  1087 

  1088 		iLogger->Log(_L("Returned from player, errorcode: %d"), sndPlayer->iFinalError );

  1089 		aResult.iResult = sndPlayer->iFinalError;

  1090 		if (aResult.iResult)

  1091 			{

  1092 			iLogger->Log(_L("Test failed, error code %d"), aResult.iResult);

  1093 			aResult.iResultDes.Copy(KTestCaseResultFail());

  1094 			}

  1095 		else

  1096 			{

  1097 			iLogger->Log(_L("Test was successful"));

  1098 			aResult.iResultDes.Copy(KTestCaseResultSuccess());

  1099 			}

  1100 		CleanupStack::PopAndDestroy(sndPlayer);

  1101 		return aResult.iResult;

  1102 

  1103 		}

  1104 	else

  1105 		{

  1106 		//The file name of the clip to play is missing

  1107 		aResult.iResultDes.Copy(KConfigInvalid());

  1108 		aResult.iResult = KErrNotExecuted;

  1109 		return KErrConfigInvalid;

  1110 		}

  1111 	}

  1112 

  1113 //FH

  1114 TInt CDRMAudioPlay::TestCasePlayHandlerWithGetPositionL(CStifSectionParser *section , TTestResult &aResult)

  1115 	{

  1116 

  1117 	TPtrC FileNamePtr;

  1118 	User::LeaveIfError(iFs.Connect());

  1119 	iFs.ShareProtected();

  1120 

  1121 	TTimeIntervalMicroSeconds32 ReportDelay = KDefaultReportDelay;

  1122 

  1123 	if ( !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) )

  1124 		{

  1125 		TFileName FileName = FileNamePtr;

  1126 		TBool UsingDefaultReportDelay;

  1127 		User::LeaveIfError(iFile.Open( iFs, FileName, EFileRead));

  1128 		iLogger->Log(_L("Creating simple player with file [%S]"), &FileNamePtr);

  1129 	//	CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( FileName, TestModuleIf() , *iLogger);

  1130 		CSimpleSoundPlayer *sndPlayer = CSimpleSoundPlayer::NewL( iFile, TestModuleIf() , *iLogger);

  1131 		iFile.Close();

  1132 		CleanupStack::PushL(sndPlayer);

  1133 

  1134 		//*********************************************