1 // Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 // Test system includes

    17 #include "TSU_MMF_SWCDWRAP_Step.h"

    18 #include "TSU_MMF_SWCDWRAP_TestDeviceImplementationUID.hrh"

    19 #include "TSU_MMF_SWCDWRAP_HwDevObserver.h"

    20 

    21 #ifdef SYMBIAN_MDF_SHAREDCHUNK_SOUNDDRIVER 

    22 #include "TSU_MMF_SWCDWRAP_PlayHwDevObserver.h"

    23 #endif

    24 

    25 

    26 /**

    27  * Pre-amble for sw codec test step

    28  * Sets __MM_HEAP_MARK for memory leak detection

    29  */

    30 TVerdict CTestStep_MMF_SWCDWRAP::DoTestStepPreambleL()

    31 	{

    32 	 __MM_HEAP_MARK;

    33 	 return EPass;

    34 	}

    35 

    36 /**

    37  * Post-amble for sw codec test step

    38  * Sets __MM_HEAP_MARKEND for memory leak detection

    39  */

    40 TVerdict CTestStep_MMF_SWCDWRAP::DoTestStepPostambleL()

    41 	{

    42 	__MM_HEAP_MARKEND;

    43 	return EPass;

    44 	}

    45 

    46 

    47 

    48 CTestStep_MMF_SWCDWRAP_U_0001::CTestStep_MMF_SWCDWRAP_U_0001()

    49 /** Constructor

    50  */

    51 	{

    52 	iTestStepName = _L("MM-MMF-SWCDWRAP-U-0001-HP");

    53 	}

    54  

    55 

    56 TVerdict CTestStep_MMF_SWCDWRAP_U_0001::DoTestStepL( void )

    57 /**

    58  * Use case: N/A

    59  * Instantiate a test CMMFSwCodeWrapper CMMFHwDevice

    60  * via uid.

    61  * @test Req. under test REQ1931.2

    62  */

    63 	 {

    64 	 TVerdict verdict = EPass;

    65 	 CMMFHwDevice* hwDevice = NULL;

    66 	 TUid hwDeviceUid;

    67 	 hwDeviceUid.iUid = KMmfUidTSUSWCDWRAPTestDevice;

    68 

    69 	 TRAPD(err, hwDevice = CMMFHwDevice::NewL(hwDeviceUid));

    70 

    71 	 //check hw device has been created

    72 	 if (err != KErrNone)

    73 		 {

    74 		 INFO_PRINTF2(_L("could not create hw device plugin error %d" ), err );

    75 		 verdict = EFail;

    76 		 }

    77 

    78 	 if (!hwDevice)

    79 		 {

    80 		 verdict = EFail;

    81 		 }

    82 	 else

    83 		 {

    84 		 delete hwDevice;

    85 		 }

    86 	

    87 	 return verdict ;

    88 	} 

    89 

    90 

    91 CTestStep_MMF_SWCDWRAP_U_0002::CTestStep_MMF_SWCDWRAP_U_0002()

    92 /** Constructor

    93  */

    94 	{

    95 	iTestStepName = _L("MM-MMF-SWCDWRAP-U-0002-HP");

    96 	}

    97 

    98 

    99 TVerdict CTestStep_MMF_SWCDWRAP_U_0002::DoTestStepL( void )

   100 /**

   101  * Use case: N/A

   102  * Instantiate an invalid CMMFHwDevice

   103  * @test Req. under test REQ1931.2

   104  */

   105 	 {

   106 	 TVerdict verdict = EPass;

   107 	 CMMFHwDevice* hwDevice = NULL;

   108 	 TUid hwDeviceUid;

   109 	 hwDeviceUid.iUid = 0xFFFFFFFF;//invalid uid

   110 

   111 	 TRAPD(err, hwDevice = CMMFHwDevice::NewL(hwDeviceUid));

   112 

   113 	 //check hw device has not been created

   114 	 if (err != KErrNotFound)

   115 		 {

   116 		 INFO_PRINTF2(_L("unexpected result %d" ), err );

   117 		 verdict = EFail;

   118 		 }

   119 

   120 	 if (hwDevice)

   121 		 {

   122 		 verdict = EFail;

   123 		 delete hwDevice;

   124 		 }

   125 	

   126 	 return verdict ;

   127 	} 

   128 

   129 

   130 CTestStep_MMF_SWCDWRAP_U_0003::CTestStep_MMF_SWCDWRAP_U_0003()

   131 /** Constructor

   132  */

   133 	{

   134 	iTestStepName = _L("MM-MMF-SWCDWRAP-U-0003-HP");

   135 	}

   136  

   137 

   138 TVerdict CTestStep_MMF_SWCDWRAP_U_0003::DoTestStepL( void )

   139 /**

   140  * Use case: N/A

   141  * Initialize sw codec wrapper HwDevice checking that the

   142  * device drivers are loaded

   143  * @test Req. under test REQ1931.2

   144  */

   145 	{

   146 	TVerdict verdict = EPass;

   147 	CMMFHwDevice* hwDevice = NULL;

   148 	TUid hwDeviceUid;

   149 	hwDeviceUid.iUid = KMmfUidTSUSWCDWRAPTestDevice;

   150 

   151 #ifdef SYMBIAN_MDF_SHAREDCHUNK_SOUNDDRIVER //Adapter loads the drivers

   152 	CActiveScheduler* activeScheduler;

   153 	activeScheduler = CActiveScheduler::Current();

   154 	if (!activeScheduler)

   155 		{

   156 		activeScheduler = new(ELeave)CActiveScheduler;

   157 		}

   158 	CActiveScheduler::Install(activeScheduler);

   159 #endif

   160 

   161 	TRAPD(err, hwDevice = CMMFHwDevice::NewL(hwDeviceUid));

   162 

   163 	THwDeviceInitParams hwDeviceInitParams;

   164 

   165 	CTestMMFHwDeviceObserver* hwDeviceObserver = new(ELeave)CTestMMFHwDeviceObserver(hwDevice);

   166 

   167 	hwDeviceInitParams.iHwDeviceObserver = hwDeviceObserver;

   168 

   169 

   170 #ifdef SYMBIAN_MDF_SHAREDCHUNK_SOUNDDRIVER 

   171 	CTestPlayMMFHwDeviceObserver* hwPlayDeviceObserver = new(ELeave)CTestPlayMMFHwDeviceObserver(hwDevice);

   172 	hwDeviceInitParams.iHwDeviceObserver = hwPlayDeviceObserver;

   173 #endif	

   174 

   175 	if (!err)

   176 		{

   177 		//check device drivers are not loaded prior to initialization

   178 		User::FreePhysicalDevice(KPddFileName);

   179 		User::FreeLogicalDevice(KLddFileName);

   180 		err = hwDevice->Init(hwDeviceInitParams);

   181 		

   182 #ifdef SYMBIAN_MDF_SHAREDCHUNK_SOUNDDRIVER

   183 		if (!err)

   184 			{

   185 			TUid playCustomInterfaceUid;

   186 			playCustomInterfaceUid.iUid = KMmfPlaySettingsCustomInterface;

   187 			MPlayCustomInterface* playCustomInterface = 

   188 			static_cast<MPlayCustomInterface*>(hwDevice->CustomInterface(playCustomInterfaceUid));

   189 			playCustomInterface->SetVolume(50000);

   190 			

   191 			TTaskConfig taskConfig;

   192 			taskConfig.iUid = KUidRefDevSoundTaskConfig;

   193 			taskConfig.iRate = 8000;

   194 			taskConfig.iStereoMode = ETaskMono;

   195 			

   196 			if (hwDevice->SetConfig(taskConfig) != KErrNone)

   197 				{

   198 				return EFail;

   199 				}

   200 			

   201 			TInt KTestBufferSize = 0x2000;

   202 			 _LIT(filename,"\\mm\\mmf\\testfiles\\swcdwrap\\TSU_MMF_SWCDWRAPpcm16_8m.raw");

   203 

   204 			err = hwPlayDeviceObserver->FillBufferFromFileSync(filename, KTestBufferSize/2);

   205 	

   206 			err = hwDevice->Start(EDevDecode, EDevOutFlow);

   207 			

   208 			activeScheduler->Start();

   209 			TInt error = hwPlayDeviceObserver->ErrorStatus();

   210 			if ((error != KErrNone)&&(error != KErrUnderflow))

   211 				{

   212 				INFO_PRINTF2(_L("error during audio playback %d" ), err );

   213 				verdict = EFail;

   214 				}

   215 			}

   216 #endif

   217 		if (!err)

   218 			{

   219 			TInt ret = User::LoadPhysicalDevice(KPddFileName);

   220 			if (ret!=KErrAlreadyExists)

   221 				verdict = EFail;

   222 			ret = User::LoadLogicalDevice(KLddFileName);

   223 			if (ret!=KErrAlreadyExists)

   224 				verdict = EFail;

   225 			}

   226 		else

   227 			{

   228 			verdict = EFail;

   229 			}

   230 		}

   231 	

   232 	User::FreePhysicalDevice(KPddFileName);

   233 	User::FreeLogicalDevice(KLddFileName);

   234 	delete hwDevice;

   235 	delete hwDeviceObserver;

   236 #ifdef SYMBIAN_MDF_SHAREDCHUNK_SOUNDDRIVER 

   237 	delete activeScheduler;

   238 	delete hwPlayDeviceObserver;

   239 #endif

   240 	return verdict ;

   241 	} 

   242 

   243 

   244 CTestStep_MMF_SWCDWRAP_U_0004::CTestStep_MMF_SWCDWRAP_U_0004()

   245 /** Constructor

   246  */

   247 	{

   248 	iTestStepName = _L("MM-MMF-SWCDWRAP-U-0004-HP");

   249 	}

   250 

   251 TVerdict CTestStep_MMF_SWCDWRAP_U_0004::DoTestStepL( void )

   252 /**

   253  * Use case: N/A

   254  * Initialize sw codec wrapper HwDevice using an invalid hwdevice observer

   255  * @test Req. under test REQ1931.2

   256  */

   257 	{

   258 	TVerdict verdict = EPass;

   259 	CMMFHwDevice* hwDevice = NULL;

   260 	TUid hwDeviceUid;

   261 	hwDeviceUid.iUid = KMmfUidTSUSWCDWRAPTestDevice;

   262 

   263 	TRAPD(err, hwDevice = CMMFHwDevice::NewL(hwDeviceUid));

   264 	if (err)

   265 		{

   266 		return EInconclusive;

   267 		}

   268 

   269 	THwDeviceInitParams hwDeviceInitParams;

   270 

   271 	hwDeviceInitParams.iHwDeviceObserver = NULL;

   272 

   273 	if (!err)

   274 		{

   275 		err = hwDevice->Init(hwDeviceInitParams);

   276 		if (err != KErrArgument)

   277 			{

   278 			verdict = EFail;

   279 			}

   280 		}

   281 	delete hwDevice;

   282 	return verdict;

   283 	}

   284  

   285 

   286 

   287 CTestStep_MMF_SWCDWRAP_U_0300::CTestStep_MMF_SWCDWRAP_U_0300()

   288 /** Constructor

   289  */

   290 	{

   291 	iTestStepName = _L("MM-MMF-SWCDWRAP-U-0300-HP");

   292 	}

   293 

   294 /** 

   295  * Verify CMMFHwDevice OOM

   296  * Use case: N/A

   297  * @test Req. under test REQ1931.2

   298  */

   299 TVerdict CTestStep_MMF_SWCDWRAP_U_0300::DoTestStepL( void )

   300 	 {

   301 	 TVerdict verdict = EPass;

   302  

   303 	 CMMFHwDevice* hwDevice = NULL;

   304 	 TUid hwDeviceUid;

   305 	 hwDeviceUid.iUid = KMmfUidTSUSWCDWRAPTestDevice;

   306 

   307 	 TInt KMaxFailRate = 100000;

   308 	 TBool complete = EFalse;

   309 	 TBool nullAlloc = EFalse;

   310 	 TInt failCount;

   311 

   312 	 for (failCount=1; !complete && failCount<KMaxFailRate; ++failCount)

   313 		{

   314 		__UHEAP_SETFAIL(RHeap::EFailNext, failCount);

   315 		TRAPD(err, hwDevice = CMMFHwDevice::NewL(hwDeviceUid));

   316 		if (err == KErrNone)

   317 			{//need to check if next alloc fails

   318 			TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test

   319 			if (testAlloc==NULL)

   320 				{

   321 				nullAlloc = ETrue;

   322 				}

   323 			else

   324 				{

   325 				User::Free(testAlloc);

   326 				complete = ETrue;

   327 				}

   328 			//check the hw device has been created

   329 			if (!hwDevice) 

   330 				{

   331 				verdict = EFail;

   332 				complete = ETrue;

   333 				}

   334 			else 

   335 				{

   336 				delete hwDevice;

   337 				hwDevice = NULL;

   338 				}

   339 			}

   340 		else if (err != KErrNoMemory)

   341 			{

   342 			verdict = EFail; // bad error code

   343 			complete = ETrue;

   344 			INFO_PRINTF2(_L("OOM test error %d" ), err );

   345 			}

   346 		}

   347 

   348 	 if (failCount >= KMaxFailRate-1)

   349 		 {

   350 		 INFO_PRINTF2(_L("fail count too high %d" ), failCount );

   351 		 verdict = EFail;

   352 		 }

   353 

   354 	 if (!nullAlloc)

   355 		 {

   356 		 INFO_PRINTF1(_L("never alloced after no OOM "));

   357 		 }

   358 

   359 

   360 	 __UHEAP_RESET;

   361 

   362 	 delete hwDevice;

   363 

   364 	 return verdict ;

   365 	 }