diff -r 000000000000 -r 40261b775718 mmlibs/mmfw/tsrc/mmfintegrationtest/vclntavi/src/testvideoplayer2.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmlibs/mmfw/tsrc/mmfintegrationtest/vclntavi/src/testvideoplayer2.cpp Tue Feb 02 01:56:55 2010 +0200 @@ -0,0 +1,2250 @@ +// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include +#include "testvideoplayer2.h" + +#ifdef SYMBIAN_BUILD_GCE +#include +#endif + +const TInt KSettingsAndAlignmentTest = 3; + +// +// RTestVclntPlayAviFile +// + +/** + * RTestVclnt2PlayFile::Constructor + */ +RTestVclnt2PlayFile::RTestVclnt2PlayFile(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2AviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2PlayFile::NewL + */ +RTestVclnt2PlayFile* RTestVclnt2PlayFile::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError) + { + RTestVclnt2PlayFile* self = new (ELeave) RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +/** + * RTestVclnt2PlayFile::DoTestStepPreambleL + */ +TVerdict RTestVclnt2PlayFile::DoTestStepPreambleL() + { + return RTestVclnt2AviPlayerStep::DoTestStepPreambleL(); + } + +/** + * RTestVclnt2PlayFile::DoTestStepPostambleL + */ +TVerdict RTestVclnt2PlayFile::DoTestStepPostambleL() + { + return RTestVclnt2AviPlayerStep::DoTestStepPostambleL(); + } + +/** + * RTestVclnt2PlayFile::FsmL + */ +void RTestVclnt2PlayFile::FsmL(TVclntTestPlayEvents aEventCode) + { + if (FsmCheck(aEventCode)) + { + switch (aEventCode) + { + case EVPIdle: + HandleIdleL(); + break; + + case EVPOpenComplete: + HandleOpenCompleteL(); + break; + + case EVPPrepareComplete: + HandlePrepareCompleteL(); + break; + + case EVPPlayComplete: + HandlePlayCompleteL(); + break; + } + } + } + +void RTestVclnt2PlayFile::HandleIdleL() + { + // Open iVideoPlayer + INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename); + iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviPlayControllerUid); + PrepareState(EVPOpenComplete, KErrNone); + } + +void RTestVclnt2PlayFile::HandleOpenCompleteL() + { + // Prepare iVideoPlayer2 + INFO_PRINTF1(_L("iVideoPlayer2->Prepare()")); + iVideoPlayer2->Prepare(); + PrepareState(EVPPrepareComplete, KErrNone); + } + +void RTestVclnt2PlayFile::HandlePrepareCompleteL() + { + // Add display window using default values - ie. video extent & window clipping + // defaulted to whole window + INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL()")); + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow); + + // trigger the video to start playing + StartPlayback(); + } + +void RTestVclnt2PlayFile::HandlePlayCompleteL() + { + iTestStepResult = EPass; + CActiveScheduler::Stop(); + } + +void RTestVclnt2PlayFile::StartPlayback() + { + iError = KErrTimedOut; + INFO_PRINTF1(_L("iVideoPlayer2->Play()")); + PrepareState(EVPPlayComplete, KErrNone); + iVideoPlayer2->Play(); + } + +#ifdef SYMBIAN_BUILD_GCE +// +// RTestMediaClientVideoDisplay +// + +/** + * RTestMediaClientVideoDisplay::Constructor + */ + + +RTestMediaClientVideoDisplay::RTestMediaClientVideoDisplay(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2AviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestMediaClientVideoDisplay::NewL + */ + +RTestMediaClientVideoDisplay* RTestMediaClientVideoDisplay::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError) + { + RTestMediaClientVideoDisplay* self = new (ELeave) RTestMediaClientVideoDisplay(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +/** + * RTestMediaClientVideoDisplay::DoTestStepPreambleL + */ + +TVerdict RTestMediaClientVideoDisplay::DoTestStepPreambleL() + { + return RTestVclnt2AviPlayerStep::DoTestStepPreambleL(); + } + +/** + * RTestMediaClientVideoDisplay::DoTestStepPostambleL + */ + +TVerdict RTestMediaClientVideoDisplay::DoTestStepPostambleL() + { + return RTestVclnt2AviPlayerStep::DoTestStepPostambleL(); + } + +/** + * RTestMediaClientVideoDisplay::FsmL + */ +void RTestMediaClientVideoDisplay::FsmL(TVclntTestPlayEvents aEventCode) + { + if (FsmCheck(aEventCode)) + { + switch (aEventCode) + { + case EVPIdle: + HandleIdleL(); + break; + + case EVPOpenComplete: + HandleOpenCompleteL(); + break; + + case EVPPrepareComplete: + HandlePrepareCompleteL(); + break; + + case EVPPlayComplete: + HandlePlayCompleteL(); + break; + } + } + } + +void RTestMediaClientVideoDisplay::HandleIdleL() + { + // Open iVideoPlayer + INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename); + iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviPlayControllerUid); + PrepareState(EVPOpenComplete, KErrNone); + } + +void RTestMediaClientVideoDisplay::HandleOpenCompleteL() + { + // Prepare iVideoPlayer2 + INFO_PRINTF1(_L("iVideoPlayer2->Prepare()")); + iVideoPlayer2->Prepare(); + PrepareState(EVPPrepareComplete, KErrNone); + } + +void RTestMediaClientVideoDisplay::HandlePrepareCompleteL() + { + // trigger the video to start playing + StartPlayback(); + + TInt displayId = iScreen->GetScreenNumber(); + TRect clipRect = TRect(iWindow->Size()); + TRect cropRegion = clipRect; + + // ========================== + + iMediaClientVideoDisplay = CMediaClientVideoDisplay::NewL(displayId); + + RSurfaceManager surfaceManager; + User::LeaveIfError(surfaceManager.Open()); + + RSurfaceManager::TSurfaceCreationAttributesBuf bf; + RSurfaceManager::TSurfaceCreationAttributes& b=bf(); + b.iSize.iWidth = 320; + b.iSize.iHeight = 240; + b.iBuffers = 1; + b.iPixelFormat = EUidPixelFormatXRGB_8888; + b.iStride = 320 * 4; + b.iOffsetToFirstBuffer = 0; + b.iAlignment=4; + b.iContiguous=ETrue; + + TRect cropRect(0, 0, 320, 240); + TVideoAspectRatio par(1,2); + TSurfaceId surfaceId; + + User::LeaveIfError(surfaceManager.CreateSurface(bf, surfaceId)); + + iMediaClientVideoDisplay->SurfaceCreated(surfaceId, cropRect, par, cropRegion); + INFO_PRINTF1(_L("iMediaClientVideoDisplay->SurfaceCreated()")); + + delete iMediaClientVideoDisplay; + iMediaClientVideoDisplay = NULL; + + // ================== + + iMediaClientVideoDisplay = CMediaClientVideoDisplay::NewL(displayId); + + TRect videoExtent = clipRect; + TVideoRotation rotation = EVideoRotationNone; + TReal32 scaleWidth(100.0f); + TReal32 scaleHeight(100.0f); + TInt horizPos(EHorizontalAlignCenter); + TInt vertPos(EVerticalAlignCenter); + + TReal32 widthPercentage(50.0f); + TReal32 heightPercentage(50.0f); + TReal32 widthP; + TReal32 heightP; + RWindow newWindow; + TVideoRotation videoRotation(EVideoRotationClockwise180); + + iMediaClientVideoDisplay->AddDisplayWindowL(iWindow, clipRect, cropRegion, videoExtent, scaleWidth, scaleHeight, rotation, EAutoScaleBestFit, horizPos, vertPos, iWindow); + INFO_PRINTF1(_L("iMediaClientVideoDisplay->AddDisplayWindowL()")); + + iMediaClientVideoDisplay->SetRotationL(*iWindow, videoRotation, cropRegion); + INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetRotationL()")); + + if (iMediaClientVideoDisplay->RotationL(*iWindow) != videoRotation) + { + ERR_PRINTF1(_L("iMediaClientVideoDisplay->RotationL() returns an unexpected value. Test aborted.")); + + iTestStepResult = EInconclusive; + CActiveScheduler::Stop(); + } + else + { + INFO_PRINTF1(_L("iMediaClientVideoDisplay->RotationL()")); + } + + iMediaClientVideoDisplay->SetScaleFactorL(*iWindow, widthPercentage, heightPercentage, cropRegion); + iMediaClientVideoDisplay->SetScaleFactorL(widthPercentage, heightPercentage, cropRegion); + INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetScaleFactorL()")); + + iMediaClientVideoDisplay->SetRotationL(EVideoRotationClockwise90, cropRegion); + INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetRotationL()")); + + iMediaClientVideoDisplay->GetScaleFactorL(*iWindow, widthP, heightP); + INFO_PRINTF3(_L("iMediaClientVideoDisplay->GetScaleFactorL() %df %df"), &widthP, &heightP); + + iMediaClientVideoDisplay->SetVideoExtentL(*iWindow, videoExtent, cropRegion); + INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetVideoExtentL()")); + + iMediaClientVideoDisplay->SetWindowClipRectL(*iWindow, clipRect, cropRegion); + INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetWindowClipRectL()")); + + iMediaClientVideoDisplay->SetAutoScaleL(EAutoScaleBestFit, horizPos, vertPos, cropRegion); + INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetAutoScaleL()")); + + iMediaClientVideoDisplay->RedrawWindows(cropRegion); + INFO_PRINTF1(_L("iMediaClientVideoDisplay->RedrawWindows()")); + + iMediaClientVideoDisplay->SurfaceParametersChanged(surfaceId, cropRect, par); + INFO_PRINTF1(_L("iMediaClientVideoDisplay->SurfaceParametersChanged()")); + + iMediaClientVideoDisplay->RemoveSurface(); + INFO_PRINTF1(_L("iMediaClientVideoDisplay->ReplaceSurface()")); + + iMediaClientVideoDisplay->RemoveDisplayWindow(*iWindow); + INFO_PRINTF1(_L("iMediaClientVideoDisplay->RemoveDisplayWindow()")); + + surfaceManager.CloseSurface(surfaceId); + surfaceId = TSurfaceId::CreateNullId(); + surfaceManager.Close(); + + delete iMediaClientVideoDisplay; + iMediaClientVideoDisplay = NULL; + } + +void RTestMediaClientVideoDisplay::HandlePlayCompleteL() + { + iTestStepResult = EPass; + CActiveScheduler::Stop(); + } + +void RTestMediaClientVideoDisplay::StartPlayback() + { + iError = KErrTimedOut; + INFO_PRINTF1(_L("iVideoPlayer2->Play()")); + PrepareState(EVPPlayComplete, KErrNone); + iVideoPlayer2->Play(); + } + +#endif + +// +// RTestVclnt2PerformActionDuringVideoPlayback +// + +/** + * RTestVclnt2PerformActionDuringVideoPlayback::Constructor + */ +RTestVclnt2PerformActionDuringVideoPlayback::RTestVclnt2PerformActionDuringVideoPlayback( + const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2PerformActionDuringVideoPlayback::HandlePlayCompleteL + */ +void RTestVclnt2PerformActionDuringVideoPlayback::HandlePlayCompleteL() + { + if (iActionError != KErrNone) + { + ERR_PRINTF2(_L("Playback event left with error %d."), iActionError); + iTestStepResult = EFail; + } + else + { + iTestStepResult = EPass; + } + + CActiveScheduler::Stop(); + } + +/** + * RTestVclnt2PerformActionDuringVideoPlayback::StartPlayback + */ +void RTestVclnt2PerformActionDuringVideoPlayback::StartPlayback() + { + RTestVclnt2PlayFile::StartPlayback(); + + iActionError = KErrNone; + TRAP(iActionError, DoThisActionDuringPlaybackL(*iVideoPlayer2)); + } + + +// +// RTestVclnt2AddWin +// +/** + * RTestVclnt2AddWin::Constructor + */ +RTestVclnt2AddWin::RTestVclnt2AddWin(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2AddWin::NewL + */ +RTestVclnt2AddWin* RTestVclnt2AddWin::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + { + RTestVclnt2AddWin* self = new (ELeave) RTestVclnt2AddWin(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +/** + * RTestVclnt2AddWin::HandlePrepareCompleteL + */ +void RTestVclnt2AddWin::HandlePrepareCompleteL() + { + // retrieve video size + TSize videoSize; + iVideoPlayer2->VideoFrameSizeL(videoSize); + + if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0505")) == 0) + { + // create a clipping rect partially out of screen + TRect windowRect(iWindow->Size()); + windowRect.SetWidth(windowRect.Width() * 2); + + // Add the display window with a partially out of screen clipping rect + TRAPD(err, iVideoPlayer2->AddDisplayWindowL(iWs, + *iScreen, + *iWindow, + TRect(iWindow->Size()), + windowRect)); + if (err != iTestExpectedError) + { + ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an unexpected error. Test failed.")); + + iTestStepResult = EFail; + CActiveScheduler::Stop(); + + return; + } + + // create a clipping rect completely out of screen + windowRect.SetRect(TPoint(0, 0), iWindow->Size()); + windowRect.Move(windowRect.Width() + 10, 0); + + // Add the display window with a completely out of screen clipping rect + TRAP(err, iVideoPlayer2->AddDisplayWindowL(iWs, + *iScreen, + *iWindow, + TRect(iWindow->Size()), + windowRect)); + if (err != iTestExpectedError) + { + ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an unexpected error. Test failed.")); + + iTestStepResult = EFail; + CActiveScheduler::Stop(); + + return; + } + else + { + // Reset the expected error to KErrNone as all expected failure tests have been completed. + // Any error that appears after this should fail the test + iTestExpectedError = KErrNone; + } + + // after failing to add window display with a partially & a completely out of screen + // clipping rect, proceed to add a valid clipping rect below + } + + if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0401")) == 0 || + iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0505")) == 0) + { + // shrink both the video & window size by half + TRect videoRect(videoSize); + videoRect.SetHeight(videoSize.iHeight / 2); + videoRect.SetWidth(videoSize.iWidth / 2); + + TRect windowRect(iWindow->Size()); + windowRect.SetHeight(iWindow->Size().iHeight / 2); + windowRect.SetWidth(iWindow->Size().iWidth / 2); + + // ensure the rect is within the boundary of the window + TRect finalRect(windowRect); + finalRect.Intersection(videoRect); + + // add display window using this valid clipping rect + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, finalRect, finalRect); + } + else + { + // Invalid test case + User::Panic(_L("RTestVclnt2AddWin"), KErrArgument); + } + + // Start video playback + StartPlayback(); + } + + +// +// RTestVclnt2RemoveWin +// + +/** + * RTestVclnt2RemoveWin::Constructor + */ +RTestVclnt2RemoveWin::RTestVclnt2RemoveWin(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError, + TBool aAddBack) + : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError), + iAddBack(aAddBack) + { + } + +/** + * RTestVclnt2RemoveWin::NewL + */ +RTestVclnt2RemoveWin* RTestVclnt2RemoveWin::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TBool aAddBack) + { + RTestVclnt2RemoveWin* self = new (ELeave) RTestVclnt2RemoveWin(aTestName, aSectName, aKeyName, aExpectedError, aAddBack); + return self; + } + +/** + * RTestVclnt2RemoveWin::HandlePrepareCompleteL + */ +void RTestVclnt2RemoveWin::HandlePrepareCompleteL() + { + // retrieve video size + TSize videoSize; + iVideoPlayer2->VideoFrameSizeL(videoSize); + + // shrink both the video & window size by half + TRect videoRect(videoSize); + videoRect.SetHeight(videoSize.iHeight / 2); + videoRect.SetWidth(videoSize.iWidth / 2); + + TRect windowRect(iWindow->Size()); + windowRect.SetHeight(iWindow->Size().iHeight / 2); + windowRect.SetWidth(iWindow->Size().iWidth / 2); + + // ensure the rect is within the boundary of the window + TRect finalRect(windowRect); + finalRect.Intersection(videoRect); + + // add display window using this valid clipping rect + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, finalRect, finalRect); + + // trigger the video to start playing + StartPlayback(); + } + +/** + * RTestVclnt2RemoveWin::DoThisActionDuringPlaybackL + */ +void RTestVclnt2RemoveWin::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer) + { + // Play the video clip using a specific display window & video clipping setting + // first + TTimeIntervalMicroSeconds duration = aPlayer.DurationL(); + + // After a quarter of the clip's duration + User::After(duration.Int64() / 4); + + // remove the original display + aPlayer.RemoveDisplayWindow(*iWindow); + + + if (iAddBack) + { + // Add the window using default values to continues + aPlayer.AddDisplayWindowL(iWs, *iScreen, *iWindow); + } + } + + +// +// RTestVclnt2WinPos +// + +/** + * RTestVclnt2WinPos::Constructor + */ +RTestVclnt2WinPos::RTestVclnt2WinPos(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2WinPos::NewL + */ +RTestVclnt2WinPos* RTestVclnt2WinPos::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + { + RTestVclnt2WinPos* self = new (ELeave) RTestVclnt2WinPos(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +/** + * RTestVclnt2WinPos::DoThisActionDuringPlaybackL + */ +void RTestVclnt2WinPos::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer) + { + TSize windowSize(iWindow->Size().iWidth / 2, iWindow->Size().iHeight / 2); + + // shrink the window clipping rect by half the height & width + aPlayer.SetWindowClipRectL(*iWindow, TRect(windowSize)); + } + + +// +// RTestVclnt2VideoExt +// + +/** + * RTestVclnt2VideoExt::Constructor + */ +RTestVclnt2VideoExt::RTestVclnt2VideoExt(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2VideoExt::NewL + */ +RTestVclnt2VideoExt* RTestVclnt2VideoExt::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + { + RTestVclnt2VideoExt* self = new (ELeave) RTestVclnt2VideoExt(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +/** + * RTestVclnt2VideoExt::DoThisActionDuringPlaybackL + */ +void RTestVclnt2VideoExt::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer) + { + TSize windowSize(iWindow->Size().iWidth / 2, iWindow->Size().iHeight / 2); + + // shrink the video extent by half the height & width + aPlayer.SetVideoExtentL(*iWindow, TRect(windowSize)); + } + + +// +// RTestVclnt2ClipRect +// + +/** + * RTestVclnt2ClipRect::Constructor + */ +RTestVclnt2ClipRect::RTestVclnt2ClipRect(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2ClipRect::NewL + */ +RTestVclnt2ClipRect* RTestVclnt2ClipRect::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + { + RTestVclnt2ClipRect* self + = new (ELeave) RTestVclnt2ClipRect(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +/** + * RTestVclnt2ClipRect::DoThisActionDuringPlaybackL + */ +void RTestVclnt2ClipRect::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer) + { + TRect clipRect; + if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0405")) == 0) + { + // shrink the current window clipping rect by half the height & width + clipRect.Resize(iWindow->Size().iWidth / 2, iWindow->Size().iHeight / 2); + } + else if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0503")) == 0) + { + // grow the current window clipping rect by double the width + clipRect.Resize(iWindow->Size().iWidth * 2, iWindow->Size().iHeight); + } + else if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0504")) == 0) + { + // move the current window clipping rect to be out of the window + clipRect.SetSize(iWindow->Size()); + clipRect.Move(TPoint(iWindow->Size().iWidth + 1, 0)); + } + else + { + User::Panic(_L("RTestVclnt2ClipRect"), KErrArgument); + } + + // change the window clipping of the display window + TRAPD(err, aPlayer.SetWindowClipRectL(*iWindow, clipRect)); + if (err != iTestExpectedError) + { + if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0503")) == 0 || + iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0504")) == 0) + { + // for negative tests, stop the test if the failure is not expected + ERR_PRINTF1(_L("iVideoPlayer2->SetWindowClipRectL() did not failed as expected. Test failed.")); + + iTestStepResult = EInconclusive; + CActiveScheduler::Stop(); + + return; + } + else + { + // fail only if error is returned for positive tests + User::LeaveIfError(err); + } + } + else + { + // Reset the expected error to KErrNone as all expected failure tests have been completed. + // Any error that appears after this should fail the test + iTestExpectedError = KErrNone; + } + } + +// +// RTestVclnt2Scale +// + +/** + * RTestVclnt2Scale::Constructor + */ +RTestVclnt2Scale::RTestVclnt2Scale(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2Scale::NewL + */ +RTestVclnt2Scale* RTestVclnt2Scale::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + { + RTestVclnt2Scale* self = new (ELeave) RTestVclnt2Scale(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +/** + * RTestVclnt2Scale::DoThisActionDuringPlaybackL + */ +void RTestVclnt2Scale::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer) + { + // Change the scale factor during playback + aPlayer.SetScaleFactorL(*iWindow, 150, 150); + } + +/** + * RTestVclnt2Scale::HandlePrepareCompleteL + */ +void RTestVclnt2Scale::HandlePrepareCompleteL() + { + // Continue to setup the video utility and then trigger playback + RTestVclnt2PerformActionDuringVideoPlayback::HandlePrepareCompleteL(); + + TReal32 scaleFactor = 50.0; + + // set scale factor to less than 100% + iVideoPlayer2->SetScaleFactorL(*iWindow, scaleFactor, scaleFactor); + + // get scale factor + TReal32 widthScale; + TReal32 heightScale; + iVideoPlayer2->GetScaleFactorL(*iWindow, widthScale, heightScale); + + if (widthScale != scaleFactor || heightScale != scaleFactor) + { + ERR_PRINTF1(_L("iVideoPlayer2->GetScaleFactorL() returns unexpected values. Test aborted.")); + + iTestStepResult = EInconclusive; + CActiveScheduler::Stop(); + + return; + } + } + + +// +// RTestVclnt2Viewport +// + +/** + * RTestVclnt2Viewport::Constructor + */ +RTestVclnt2Viewport::RTestVclnt2Viewport(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + const TSize& aViewportSize, + TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError), + iViewportSize(aViewportSize) + { + } + +/** + * RTestVclnt2Viewport::NewL + */ +RTestVclnt2Viewport* RTestVclnt2Viewport::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + const TSize& aViewportSize, + TInt aExpectedError) + { + RTestVclnt2Viewport* self = new (ELeave) RTestVclnt2Viewport(aTestName, + aSectName, + aKeyName, + aViewportSize, + aExpectedError); + return self; + } + +void RTestVclnt2Viewport::HandlePrepareCompleteL() + { + // retrive original video size + TSize videoSize; + iVideoPlayer2->VideoFrameSizeL(videoSize); + + // crop the top left quarter of the video + TRect cropRegion; + if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0508")) == 0) + { + // Crop the right half of the video + cropRegion.SetHeight(videoSize.iHeight); + cropRegion.SetWidth(videoSize.iWidth / 2); + cropRegion.Move(cropRegion.Width(), 0); + } + else + { + cropRegion.SetWidth(iViewportSize.iWidth == -1 ? videoSize.iWidth : iViewportSize.iWidth); + cropRegion.SetHeight(iViewportSize.iHeight == -1 ? videoSize.iHeight : iViewportSize.iHeight); + } + + TRect videoExtentRect; + TRect clipRegion; + + if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0508")) == 0) + { + videoExtentRect.SetRect(TPoint(0, 0), videoSize); + clipRegion.SetRect(TPoint(0, 0), videoSize); + clipRegion.SetWidth(clipRegion.Width() / 2); + clipRegion.Move(clipRegion.Width(), 0); + } + else + { + // Calculate the video extent to be exactly the same size as the cropped video picture, + // placed at the center of the window + TInt offsetX = (iWindow->Size().iWidth - cropRegion.Width()) / 2; + TInt offsetY = (iWindow->Size().iHeight - cropRegion.Height()) / 2; + videoExtentRect.SetRect(TPoint(offsetX, offsetY), cropRegion.Size()); + + // Set the window clipping region to the top vertical half of the cropped image, originating + // from the top left corner of the window + clipRegion = videoExtentRect; + clipRegion.SetHeight(videoExtentRect.Height() / 2); + } + + HandlePrepareCompleteL(cropRegion, videoExtentRect, clipRegion); + + if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0508")) == 0) + { + // Align the image to the left of the window + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, 0); + } + // trigger the video to start playing + StartPlayback(); + } + +void RTestVclnt2Viewport::HandlePrepareCompleteL(const TRect& aCropRegion, + const TRect& aVideoExtent, + const TRect& aClipRect) + { + iVideoPlayer2->SetCropRegionL(aCropRegion); + + // get the video crop region to ensure the crop region is set + TRect currentCropRegion; + iVideoPlayer2->GetCropRegionL(currentCropRegion); + + if (currentCropRegion != aCropRegion) + { + ERR_PRINTF1(_L("iVideoPlayer2->GetCropRegionL() returns an unexpected value. Test aborted.")); + + iTestStepResult = EInconclusive; + CActiveScheduler::Stop(); + } + + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, aVideoExtent, aClipRect); + } + +// +// RTestVclnt2InvalidViewport +// + +/** + * RTestVclnt2InvalidViewport::Constructor + */ +RTestVclnt2InvalidViewport::RTestVclnt2InvalidViewport(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2InvalidViewport::NewL + */ +RTestVclnt2InvalidViewport* RTestVclnt2InvalidViewport::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + { + RTestVclnt2InvalidViewport* self = new (ELeave) RTestVclnt2InvalidViewport(aTestName, + aSectName, + aKeyName, + aExpectedError); + return self; + } + +/** + * RTestVclnt2InvalidViewport::HandlePrepareCompleteL + */ +void RTestVclnt2InvalidViewport::HandlePrepareCompleteL() + { + // retrive original video size + TSize videoSize; + iVideoPlayer2->VideoFrameSizeL(videoSize); + + // set the crop region to be completely out of the video image bound + TRect cropRegion; + cropRegion.SetRect(TPoint(videoSize.iWidth, videoSize.iHeight), TSize(100, 100)); + + // continue playback even if this fails + TRAPD(err, iVideoPlayer2->SetCropRegionL(cropRegion)); + if (err == iTestExpectedError) + { + // the invalid crop area is not supposed to be set + INFO_PRINTF1(_L("iVideoPlayer2->SetCropRegionL() returned expected. Test continues.")); + + // reset the expected error. Any error that appears after this should fail the test + iTestExpectedError = KErrNone; + } + else + { + // the invalid crop area is not supposed to be set + ERR_PRINTF1(_L("iVideoPlayer2->SetCropRegionL() didn't leave with expected error. Test cannot be continued.")); + + iTestStepResult = EInconclusive; + CActiveScheduler::Stop(); + return; + } + + // get the video crop region to ensure the crop region is set + TRect currentCropRegion; + iVideoPlayer2->GetCropRegionL(currentCropRegion); + + if (currentCropRegion != cropRegion) + { + // the invalid crop area is not supposed to be set + ERR_PRINTF1(_L("iVideoPlayer2->GetCropRegionL() returns an unexpected value. Test cannot be continued.")); + + iTestStepResult = EInconclusive; + CActiveScheduler::Stop(); + return; + } + + // setup the display then trigger the video to start playing + RTestVclnt2PlayFile::HandlePrepareCompleteL(); + } + + +// +// RTestVclnt2Rotation +// +/** + * RTestVclnt2Rotation::Constructor + */ +RTestVclnt2Rotation::RTestVclnt2Rotation(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2Rotation::NewL + */ +RTestVclnt2Rotation* RTestVclnt2Rotation::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + { + RTestVclnt2Rotation* self = new (ELeave) RTestVclnt2Rotation(aTestName, + aSectName, + aKeyName, + aExpectedError); + return self; + } + +/** + * RTestVclnt2Rotation::HandlePrepareCompleteL + */ +void RTestVclnt2Rotation::HandlePrepareCompleteL() + { + // call parent's HandlePrepareCompleteL to finish off all preparation + RTestVclnt2PlayFile::HandlePrepareCompleteL(); + + // set the video to be displayed upside-down + TVideoRotation videoRotation(EVideoRotationClockwise180); + iVideoPlayer2->SetRotationL(*iWindow, videoRotation); + + // retrieve the rotation setting, and check if it's been properly updated + if (iVideoPlayer2->RotationL(*iWindow) != videoRotation) + { + ERR_PRINTF1(_L("iVideoPlayer2->RotationL() returns an unexpected value. Test aborted.")); + + iTestStepResult = EInconclusive; + CActiveScheduler::Stop(); + + return; + } + } + +// +// RTestVclnt2Settings +// +/** + * RTestVclnt2Settings::Constructor + */ +RTestVclnt2Settings::RTestVclnt2Settings(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2Settings::NewL + */ +RTestVclnt2Settings* RTestVclnt2Settings::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + { + RTestVclnt2Settings* self = new (ELeave) RTestVclnt2Settings(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +/** + * RTestVclnt2Settings::HandlePrepareCompleteL + */ +void RTestVclnt2Settings::HandlePrepareCompleteL() + { + // retrieve the current frame size + TSize frameSize; + iVideoPlayer2->VideoFrameSizeL(frameSize); + + TRect cropRegion(frameSize); + // shrink the crop region to half its original height + cropRegion.SetHeight(cropRegion.Height() / 2); + iVideoPlayer2->SetCropRegionL(cropRegion); + + TRect videoExtentRect; + videoExtentRect.SetWidth(cropRegion.Width()); + videoExtentRect.SetHeight(cropRegion.Height()); + + videoExtentRect.Move((iWindow->Size().iWidth - videoExtentRect.Width()) / 2, + (iWindow->Size().iHeight - videoExtentRect.Height()) / 2); + + TRect clippingRect(videoExtentRect); + clippingRect.SetWidth(clippingRect.Height() / 2); + + // add display window using this valid clipping rect + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, videoExtentRect, clippingRect); + + // Scale the movie with best fit scaling, and vertically center the picture + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleBestFit); + + // Start video playback + StartPlayback(); + } + + + +// +// RTestVclnt2SettingsAndAlignments +// +/** + * RTestVclnt2SettingsAndAlignments::Constructor + */ +RTestVclnt2SettingsAndAlignments::RTestVclnt2SettingsAndAlignments(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2SettingsAndAlignments::NewL + */ +RTestVclnt2SettingsAndAlignments* RTestVclnt2SettingsAndAlignments::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + { + RTestVclnt2SettingsAndAlignments* self = new (ELeave) RTestVclnt2SettingsAndAlignments(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +TVerdict RTestVclnt2SettingsAndAlignments::DoTestStepPreambleL() + { + iCount = 0; + return RTestVclnt2PlayFile::DoTestStepPreambleL(); + } + +/** + * RTestVclnt2SettingsAndAlignments::HandlePrepareCompleteL + */ +void RTestVclnt2SettingsAndAlignments::HandlePrepareCompleteL() + { + TRect cropRegion; + SetCropRegionL(cropRegion); + + AddDisplayWindowL(cropRegion); + + if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0418")) == 0) + { + SetContentOffsetL(); + } + else if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0419")) == 0) + { + SetContentAlignmentL(); + } + + SetScaleFactorL(); + + // Start video playback + StartPlayback(); + } + +/** + * RTestVclnt2SettingsAndAlignments::HandlePlayCompleteL + */ +void RTestVclnt2SettingsAndAlignments::HandlePlayCompleteL() + { + iCount++; + + if (iCount == KSettingsAndAlignmentTest) + { + iTestStepResult = EPass; + CActiveScheduler::Stop(); + } + else + { + HandlePrepareCompleteL(); + } + } + +/** + * RTestVclnt2SettingsAndAlignments::SetCropRegionL + */ +void RTestVclnt2SettingsAndAlignments::SetCropRegionL(TRect& aCropRegion) + { + // retrieve the current frame size + TSize frameSize; + iVideoPlayer2->VideoFrameSizeL(frameSize); + + // Framesize is used in this case as crop region is not returning default values + aCropRegion.SetRect(TPoint(0, 0), frameSize); + + // set the crop region + switch (iCount % KSettingsAndAlignmentTest) + { + case 0: + // set the crop region to the top half of the image + aCropRegion.SetHeight(aCropRegion.Height() / 2); + iVideoPlayer2->SetCropRegionL(aCropRegion); + break; + + case 1: + // set the crop region to the left half of the image + aCropRegion.SetWidth(aCropRegion.Width() / 2); + iVideoPlayer2->SetCropRegionL(aCropRegion); + break; + + default: + // set the crop region to the bottom, right quarter of the image + aCropRegion.SetHeight(aCropRegion.Height() / 2); + aCropRegion.SetWidth(aCropRegion.Width() / 2); + aCropRegion.Move(aCropRegion.Width(), aCropRegion.Height()); + iVideoPlayer2->SetCropRegionL(aCropRegion); + break; + } + } + +/** + * RTestVclnt2SettingsAndAlignments::SetContentOffsetL + */ +void RTestVclnt2SettingsAndAlignments::SetContentOffsetL() + { + switch (iCount % KSettingsAndAlignmentTest) + { + case 0: + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 0, 100); + break; + + case 1: + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 100, 0); + break; + + default: + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 100, 100); + break; + } + } + +/** + * RTestVclnt2SettingsAndAlignments::SetContentAlignmentL + */ +void RTestVclnt2SettingsAndAlignments::SetContentAlignmentL() + { + switch (iCount % KSettingsAndAlignmentTest) + { + case 0: + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 0, EVerticalAlignCenter); + break; + + case 1: + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, 0); + break; + + default: + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, EVerticalAlignCenter); + break; + } + } + +/** + * RTestVclnt2SettingsAndAlignments::SetScaleFactorL + */ +void RTestVclnt2SettingsAndAlignments::SetScaleFactorL() + { + switch (iCount % KSettingsAndAlignmentTest) + { + case 0: + iVideoPlayer2->SetScaleFactorL(*iWindow, 1, 200); + break; + + case 1: + iVideoPlayer2->SetScaleFactorL(*iWindow, 200, 1); + break; + + default: + iVideoPlayer2->SetScaleFactorL(*iWindow, 200, 200); + break; + } + } + +/** + * RTestVclnt2SettingsAndAlignments::AddDisplayWindowL + */ +void RTestVclnt2SettingsAndAlignments::AddDisplayWindowL(const TRect& aCropRegion) + { + TRect videoExtentRect(iWindow->Size()); + TRect clippingRect(iWindow->Size()); + + switch (iCount % KSettingsAndAlignmentTest) + { + case 0: + videoExtentRect.SetWidth(aCropRegion.Width()); + if (iWindow->Size().iWidth > videoExtentRect.Width()) + { + videoExtentRect.Move((iWindow->Size().iWidth - videoExtentRect.Width()) / 2, 0); + } + clippingRect = videoExtentRect; + break; + + case 1: + videoExtentRect.SetHeight(aCropRegion.Height()); + if (iWindow->Size().iHeight > videoExtentRect.Height()) + { + videoExtentRect.Move(0, (iWindow->Size().iHeight - videoExtentRect.Height()) / 2); + } + clippingRect = videoExtentRect; + break; + + default: + clippingRect.SetHeight(clippingRect.Height() / 2); + clippingRect.SetWidth(clippingRect.Width() / 2); + clippingRect.Move(clippingRect.Width(), clippingRect.Height()); + break; + } + + iVideoPlayer2->RemoveDisplayWindow(*iWindow); + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, videoExtentRect, clippingRect); + } + + +// +// RTestVclnt2SecDisplay +// +/** + * RTestVclnt2SecDisplay::Constructor + */ +RTestVclnt2SecDisplay::RTestVclnt2SecDisplay(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2SecDisplay::NewL + */ +RTestVclnt2SecDisplay* RTestVclnt2SecDisplay::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + { + RTestVclnt2SecDisplay* self = new (ELeave) RTestVclnt2SecDisplay(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +/** + * RTestVclnt2SecDisplay::DoTestStepPreambleL + */ +TVerdict RTestVclnt2SecDisplay::DoTestStepPreambleL() + { + TVerdict verdict = RTestVclnt2PlayFile::DoTestStepPreambleL(); + if (verdict == EPass) + { + // make a 2nd device for this session + iSecondScreen = new (ELeave) CWsScreenDevice(iWs); + User::LeaveIfError(iSecondScreen->Construct()); + } + + return verdict; + } + +/** + * RTestVclnt2SecDisplay::DoTestStepPostambleL + */ +TVerdict RTestVclnt2SecDisplay::DoTestStepPostambleL() + { + delete iSecondScreen; + + return EPass; + } + +/** + * RTestVclnt2SecDisplay::HandlePrepareCompleteL + */ +void RTestVclnt2SecDisplay::HandlePrepareCompleteL() + { + // Add display window using default values - ie. video extent & window clipping + // defaulted to whole window + INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL()")); + iVideoPlayer2->AddDisplayWindowL(iWs, *iSecondScreen, *iWindow); + + // trigger the video to start playing + StartPlayback(); + } + + +// +// RTestVclnt2CropRectPause +// +/** + * RTestVclnt2CropRectPause::Constructor + */ +RTestVclnt2CropRectPause::RTestVclnt2CropRectPause(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2CropRectPause::NewL + */ +RTestVclnt2CropRectPause* RTestVclnt2CropRectPause::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + { + RTestVclnt2CropRectPause* self + = new (ELeave) RTestVclnt2CropRectPause(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +/** + * RTestVclnt2CropRectPause::DoThisActionDuringPlaybackL + */ +void RTestVclnt2CropRectPause::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer) + { + TRect cropRegion; + aPlayer.GetCropRegionL(cropRegion); + + // change the crop region and continue to play the clip + cropRegion.SetHeight(cropRegion.Height() / 2); + aPlayer.SetCropRegionL(cropRegion); + } + + + +// +// RTestVclnt2Overlay +// +/** + * RTestVclnt2Overlay::Constructor + */ +RTestVclnt2Overlay::RTestVclnt2Overlay(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2Overlay::NewL + */ +RTestVclnt2Overlay* RTestVclnt2Overlay::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + { + RTestVclnt2Overlay* self = new (ELeave) RTestVclnt2Overlay(aTestName, + aSectName, + aKeyName, + aExpectedError); + return self; + } + +/** + * RTestVclnt2Overlay::DoTestStepPreambleL + */ +TVerdict RTestVclnt2Overlay::DoTestStepPreambleL() + { + TVerdict verdict = RTestVclnt2PlayFile::DoTestStepPreambleL(); + if (verdict == EPass) + { + TFontSpec fontSpec; // use default fonts + fontSpec.iHeight = 20; + + // Get a font to draw overlay text + if (iScreen->GetNearestFontToDesignHeightInPixels(iFont, fontSpec) != KErrNone) + { + // if no font can be retrieved, abort the test + ERR_PRINTF1(_L("Cannot retrieve font to perform test. Test aborted.")); + + return EInconclusive; + } + + iGc->Activate(*iWindow); + iGc->UseFont(iFont); + } + + return verdict; + } + +/** + * RTestVclnt2Overlay::DoTestStepPostambleL + */ +TVerdict RTestVclnt2Overlay::DoTestStepPostambleL() + { + iGc->DiscardFont(); + iGc->Deactivate(); + + return RTestVclnt2PlayFile::DoTestStepPostambleL(); + } + +/** + * RTestVclnt2Overlay::HandlePrepareCompleteL + */ +void RTestVclnt2Overlay::HandlePrepareCompleteL() + { + TRect rect(iWindow->Size()); + TInt baseline = (rect.Height() + iFont->AscentInPixels()) >> 1; + + // Draw the overlay text if needed + iGc->SetBrushStyle(CGraphicsContext::ENullBrush); + iGc->SetBrushColor(KRgbRed); + + iGc->SetPenStyle(CGraphicsContext::ESolidPen); + iGc->SetPenColor(KRgbBlue); + + iGc->DrawText(_L("Overlay Testing"), rect, baseline, CGraphicsContext::ELeft); + + // setup the display window and trigger the video to start playing + RTestVclnt2PlayFile::HandlePrepareCompleteL(); + } + + +// +// RTestVclnt2AddWin2 +// + +/** + * RTestVclnt2AddWin2::Constructor + */ +RTestVclnt2AddWin2::RTestVclnt2AddWin2(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2AddWin2::NewL + */ +RTestVclnt2AddWin2* RTestVclnt2AddWin2::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + { + RTestVclnt2AddWin2* self = new (ELeave) RTestVclnt2AddWin2(aTestName, + aSectName, + aKeyName, + aExpectedError); + return self; + } + +/** + * RTestVclnt2AddWin2::HandlePrepareCompleteL + */ +void RTestVclnt2AddWin2::HandlePrepareCompleteL() + { + // add the display window for the player to use for displaying the video + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow); + + // Add the same display window again + TRAPD(err, iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow)); + if (err != iTestExpectedError) + { + ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an unexpected error. Test failed.")); + + iTestStepResult = EFail; + CActiveScheduler::Stop(); + + return; + } + else + { + INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an expected error. Test continues.")); + + // reset the expected error. Any error that appears after this should fail the test + iTestExpectedError = KErrNone; + } + + // trigger the video to start playing + StartPlayback(); + } + +// +// RTestVclnt2AddWin2WithSettings +// + +/** + * RTestVclnt2AddWin2WithSettings::Constructor + */ +RTestVclnt2AddWin2WithSettings::RTestVclnt2AddWin2WithSettings(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2AddWin2WithSettings::NewL + */ +RTestVclnt2AddWin2WithSettings* RTestVclnt2AddWin2WithSettings::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + { + RTestVclnt2AddWin2WithSettings* self = new (ELeave) RTestVclnt2AddWin2WithSettings(aTestName, + aSectName, + aKeyName, + aExpectedError); + return self; + } + +/** + * RTestVclnt2AddWin2WithSettings::HandlePrepareCompleteL + */ +void RTestVclnt2AddWin2WithSettings::HandlePrepareCompleteL() + { + TRect windowRect(iWindow->Size()); + windowRect.SetHeight(windowRect.Height() / 2); + + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, windowRect, windowRect); + + // Add the same display window again with default values + TRAPD(err, iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow)); + if (err != iTestExpectedError) + { + ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an unexpected error. Test failed.")); + + iTestStepResult = EFail; + CActiveScheduler::Stop(); + + return; + } + else + { + INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an expected error. Test continues.")); + + // reset the expected error. Any error that appears after this should fail the test + iTestExpectedError = KErrNone; + } + + // trigger the video to start playing + StartPlayback(); + } + +// +// RTestVclnt2ContOffset +// + +/** + * RTestVclnt2ContOffset::Constructor + */ +RTestVclnt2ContOffset::RTestVclnt2ContOffset(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + iHeapSize = 2000000; //~2MB + } + +/** + * RTestVclnt2ContOffset::NewL + */ +RTestVclnt2ContOffset* RTestVclnt2ContOffset::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + { + RTestVclnt2ContOffset* self = new (ELeave) RTestVclnt2ContOffset(aTestName, + aSectName, + aKeyName, + aExpectedError); + return self; + } + +/** + * RTestVclnt2ContOffset::HandlePrepareCompleteL + */ +void RTestVclnt2ContOffset::HandlePrepareCompleteL() + { + // call parent's HandlePrepareCompleteL to finish off all preparation + RTestVclnt2PlayFile::HandlePrepareCompleteL(); + // Set the content offset before starting to play the video. + INFO_PRINTF1(_L("iVideoPlayer2->SetAutoScale()")); + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 100, 100); + + if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0409")) == 0) + { + // Set the content alignment after setting the content offset + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, EVerticalAlignTop); + } + } + +// +// RTestVclnt2ContOffsetAtPlay +// +/** + * RTestVclnt2ContOffsetAtPlay::Constructor + */ +RTestVclnt2ContOffsetAtPlay::RTestVclnt2ContOffsetAtPlay(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError) + { + iHeapSize = 2000000; //~2MB + } + +/** + * RTestVclnt2ContOffsetAtPlay::NewL + */ +RTestVclnt2ContOffsetAtPlay* RTestVclnt2ContOffsetAtPlay::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + { + RTestVclnt2ContOffsetAtPlay* self = new (ELeave) RTestVclnt2ContOffsetAtPlay(aTestName, + aSectName, + aKeyName, + aExpectedError); + return self; + } + +/** + * RTestVclnt2ContOffsetAtPlay::DoThisActionDuringPlaybackL + */ +void RTestVclnt2ContOffsetAtPlay::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& /* aPlayer */) + { + // Change the scale factor during playback + INFO_PRINTF1(_L("iVideoPlayer2->SetAutoScale()")); + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 10, 10); + } + + +// +// RTestVclnt2Align +// +/** + * RTestVclnt2Align::Constructor + */ +RTestVclnt2Align::RTestVclnt2Align(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError) + { + iHeapSize = 2000000; //~2MB + } + +/** + * RTestVclnt2Align::NewL + */ +RTestVclnt2Align* RTestVclnt2Align::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + { + RTestVclnt2Align* self = new (ELeave) RTestVclnt2Align(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +/** + * RTestVclnt2Align::HandlePrepareCompleteL + */ +void RTestVclnt2Align::HandlePrepareCompleteL() + { + // Continue to setup the video utility and then trigger playback + RTestVclnt2PlayFile::HandlePrepareCompleteL(); + // Set the content offset before starting to play the video. + INFO_PRINTF1(_L("iVideoPlayer2->SetAutoScale()")); + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, EVerticalAlignCenter); + } + +/** + * RTestVclnt2Align::DoThisActionDuringPlaybackL + */ +void RTestVclnt2Align::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& /* aPlayer */) + { + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, EVerticalAlignCenter); + iVideoPlayer2->RemoveDisplayWindow(*iWindow); + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, TRect(10, 10, 100, 100), TRect(0, 3, 4, 220)); + + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignRight, EVerticalAlignCenter); + iVideoPlayer2->RemoveDisplayWindow(*iWindow); + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow); + + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, EVerticalAlignTop); + iVideoPlayer2->RemoveDisplayWindow(*iWindow); + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, TRect(10, 10, 100, 100), TRect(0, 5, 5, 200)); + + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, EVerticalAlignTop); + iVideoPlayer2->RemoveDisplayWindow(*iWindow); + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow); + + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignRight, EVerticalAlignTop); + iVideoPlayer2->RemoveDisplayWindow(*iWindow); + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, TRect(0, 0, 100, 100), TRect(0, 5, 5, 200)); + + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, EVerticalAlignBottom); + iVideoPlayer2->RemoveDisplayWindow(*iWindow); + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow); + + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, EVerticalAlignBottom); + iVideoPlayer2->RemoveDisplayWindow(*iWindow); + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, TRect(0, 0, 100, 100), TRect(0, 5, 300, 230)); + + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignRight, EVerticalAlignBottom); + iVideoPlayer2->RemoveDisplayWindow(*iWindow); + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow); + } + + +// +// RTestVclnt2AutoScale +// +/** + * RTestVclnt2AutoScale::Constructor + */ +RTestVclnt2AutoScale::RTestVclnt2AutoScale(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError) + { + iHeapSize = 2000000; //~2MB + } + +/** + * RTestVclnt2AutoScale::NewL + */ +RTestVclnt2AutoScale* RTestVclnt2AutoScale::NewL(const TDesC& aTestName, + const TDesC& aSectName, + const TDesC& aKeyName, + TInt aExpectedError) + { + RTestVclnt2AutoScale* self = new (ELeave) RTestVclnt2AutoScale(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +/** + * RTestVclnt2AutoScale::HandlePrepareCompleteL + */ +void RTestVclnt2AutoScale::HandlePrepareCompleteL() + { + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow); + // Set the content offset before starting to play the video. + INFO_PRINTF1(_L("iVideoPlayer2->SetAutoScale()")); + iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleClip); + + // trigger the video to start playing + StartPlayback(); + } + +/** + * RTestVclnt2AutoScale::DoThisActionDuringPlaybackL + */ +void RTestVclnt2AutoScale::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer) + { + aPlayer.SetAutoScaleL(*iWindow, EAutoScaleBestFit); + aPlayer.SetAutoScaleL(*iWindow, EAutoScaleNone); + aPlayer.SetAutoScaleL(*iWindow, EAutoScaleStretch); + } + +// +// RTestVclnt2OldController +// + +RTestVclnt2OldController::RTestVclnt2OldController(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2OldController::NewL + */ +RTestVclnt2OldController* RTestVclnt2OldController::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + { + RTestVclnt2OldController* self = new (ELeave) RTestVclnt2OldController(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +void RTestVclnt2OldController::HandleIdleL() + { + // Open iVideoPlayer using a controller that does not support surfaces. + INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename); + iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviNonGcePlayControllerUid); + PrepareState(EVPOpenComplete, KErrNone); + } + +void RTestVclnt2OldController::HandlePrepareCompleteL() + { + TRAPD(err, RTestVclnt2PlayFile::HandlePrepareCompleteL()); + + if (err != KErrNotSupported) + { + ERR_PRINTF1(_L("AddDisplay did not leave with KErrNotSupported.")); + iTestStepResult = EFail; + } + else + { + iTestStepResult = EPass; + } + + // Stop the test. + CActiveScheduler::Stop(); + } +// +// RTestVclnt2NoFile +// + +RTestVclnt2NoFile::RTestVclnt2NoFile(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2NoFile::NewL + */ +RTestVclnt2NoFile* RTestVclnt2NoFile::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + { + RTestVclnt2NoFile* self = new (ELeave) RTestVclnt2NoFile(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +void RTestVclnt2NoFile::HandleIdleL() + { + iTestStepResult = EFail; + TRAPD(err, iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow)); + + if (err != iTestExpectedError) + { + ERR_PRINTF1(_L("AddDisplayWindowL did not leave with KErrNotReady.")); + User::Leave(KErrGeneral); + } + + TSize windowSize = iWindow->Size(); + TRect videoExtent(-5, -5, windowSize.iWidth + 5, windowSize.iHeight + 5); + TRect windowClipRect(5, 5, windowSize.iWidth - 5, windowSize.iHeight - 5); + TRAP(err, iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, videoExtent, windowClipRect)); + + if (err != iTestExpectedError) + { + ERR_PRINTF1(_L("AddDisplayWindowL did not leave with KErrNotReady.")); + User::Leave(KErrGeneral); + } + + TRAP(err, iVideoPlayer2->SetWindowClipRectL(*iWindow, windowClipRect)); + + if (err != iTestExpectedError) + { + ERR_PRINTF1(_L("SetWindowClipRectL did not leave with KErrNotReady.")); + User::Leave(KErrGeneral); + } + + TRAP(err, iVideoPlayer2->SetVideoExtentL(*iWindow, videoExtent)); + + if (err != iTestExpectedError) + { + ERR_PRINTF1(_L("SetVideoExtentL did not leave with KErrNotReady.")); + User::Leave(KErrGeneral); + } + + // reset the expected error to KErrNone as any error happens after this is unexpected + iTestExpectedError = KErrNone; + + // The video should still play when we try to play the video. Perform + // the basic play test now. + RTestVclnt2PlayFile::HandleIdleL(); + } + +// +// RTestVclnt2PlayAfterRemoveWin +// + +RTestVclnt2PlayAfterRemoveWin::RTestVclnt2PlayAfterRemoveWin(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2PlayAfterRemoveWin::NewL + */ +RTestVclnt2PlayAfterRemoveWin* RTestVclnt2PlayAfterRemoveWin::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + { + RTestVclnt2PlayAfterRemoveWin* self = new (ELeave) RTestVclnt2PlayAfterRemoveWin(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +void RTestVclnt2PlayAfterRemoveWin::HandlePrepareCompleteL() + { + // Don't add a window. Just play the video. + StartPlayback(); + } + +void RTestVclnt2PlayAfterRemoveWin::HandlePlayCompleteL() + { + switch(iPlayAttempt) + { + case 0: + { + TSize windowSize = iWindow->Size(); + TRect videoExtent(-5, -5, windowSize.iWidth + 5, windowSize.iHeight + 5); + TRect windowClipRect(5, 5, windowSize.iWidth - 5, windowSize.iHeight - 5); + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, videoExtent, windowClipRect); + iVideoPlayer2->RemoveDisplayWindow(*iWindow); + iVideoPlayer2->Play(); + PrepareState(EVPPlayComplete, KErrNone); + break; + } + case 1: + // Removing the window again should have no effect. + iVideoPlayer2->RemoveDisplayWindow(*iWindow); + iVideoPlayer2->Play(); + PrepareState(EVPPlayComplete, KErrNone); + break; + case 2: + // The previous play commands should have no effect when we try to add a + // display window and render to surfaces. Use the base class to do this. + RTestVclnt2PlayFile::HandlePrepareCompleteL(); + break; + default: + // Use the parent handler after we have tried the above play commands. + RTestVclnt2PlayFile::HandlePlayCompleteL(); + break; + } + + iPlayAttempt++; + } + +// +// RTestVclnt2NoGce +// + +RTestVclnt2NoGce::RTestVclnt2NoGce(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2NoGce::NewL + */ +RTestVclnt2NoGce* RTestVclnt2NoGce::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + { + RTestVclnt2NoGce* self = new (ELeave) RTestVclnt2NoGce(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +void RTestVclnt2NoGce::HandleIdleL() + { + // Open iVideoPlayer + INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename); + iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviPlayControllerUid); + PrepareState(EVPOpenComplete, KErrNotSupported); + } + +void RTestVclnt2NoGce::HandleOpenCompleteL() + { + iTestStepResult = EPass; + CActiveScheduler::Stop(); + } + +// +// RTestVclnt2Alloc +// + +RTestVclnt2Alloc::RTestVclnt2Alloc(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2Alloc::NewL + */ +RTestVclnt2Alloc* RTestVclnt2Alloc::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + { + RTestVclnt2Alloc* self = new (ELeave) RTestVclnt2Alloc(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +TVerdict RTestVclnt2Alloc::DoTestStepPreambleL() + { + INFO_PRINTF1(_L("RTestVclnt2Alloc::DoTestStepPreambleL()")); + + // Call RTestMmfVclntAviStep::DoTestStepPreambleL instead of the immediate parent's + // DoTestStepPreambleL as there is no need for CVideoPlayerUtility setup. + // Similarly, there is no need to initialize CVideoPlayerUtility2, as it will be + // created in each alloc iteration. + return RTestMmfVclntAviStep::DoTestStepPreambleL(); + } + +TVerdict RTestVclnt2Alloc::PerformTestL() + { + iVideoPlayer2 = CVideoPlayerUtility2::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality); + ResetState(); + iError = KErrNone; + TVerdict result = RTestVclnt2AviPlayerStep::DoTestStepL(); + delete iVideoPlayer2; + iVideoPlayer2 = NULL; + return result; + } + +/** + * RTestVclnt2Alloc::DoTestStepL() + */ +TVerdict RTestVclnt2Alloc::DoTestStepL() + { + TVerdict allocTestStepResult = EPass; + TInt err = KErrNone; + TBool result = EFalse; + + //>>>>>>>>>>>>>>>>>>>>>>>>Test Method Call<<<<<<<<<<<<<<<<<<<<<<<<<< + if (PerformTestL() != EPass) + { + err = iError; + } + + if (err != KErrNone) + { + INFO_PRINTF2(_L("Test error, returned error code = %d"), err); + User::Leave(err); + } + else + { + //Check the iAllocTestStepResult + if (allocTestStepResult != EPass) + { + result = ETrue; + } + } + + TInt failCount = 1; + TBool completed = EFalse; + allocTestStepResult = EPass; + TBool reachedEnd = EFalse; + for(;;) + { + __UHEAP_SETFAIL(RHeap::EFailNext, failCount); + __MM_HEAP_MARK; + + //>>>>>>>>>>>>>>>>>>>>>>>>Test Method Call<<<<<<<<<<<<<<<<<<<<<<<<<< + TVerdict verdict = EFail; + TRAP(err, verdict = PerformTestL()); + if (err == KErrNone && verdict != EPass) + { + err = iError; + } + + completed = EFalse; + if (err == KErrNone) + { + TAny* testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test + if (testAlloc == NULL) + { + reachedEnd = ETrue; + failCount -= 1; + } + else + { + User::Free(testAlloc); + } + + //Check the iAllocTestStepResult + if (allocTestStepResult != EPass) + { + result = ETrue; + } + + completed = reachedEnd || result; + } + else if (err != KErrNoMemory) // bad error code + { + completed = ETrue; + result = EFail; + } + + __MM_HEAP_MARKEND; + __UHEAP_SETFAIL(RHeap::ENone, 0); + + if (completed) + { + break; // exit loop + } + + failCount++; + } + + failCount -= 1; // Failcount of 1 equates to 0 successful allocs, etc + + if (err != KErrNone || result) + { + allocTestStepResult = EFail; + TBuf<80> format; + if (result) + { + format.Format(_L(" Bad result with %d memory allocations tested\n"), failCount); + } + else + { + format.Format(_L(" Error(%d) with %d memory allocations tested\n"), err, failCount); + } + Log(format); + } + else + { + TBuf<80> format; + format.Format(_L(" Completed OK with %d memory allocations tested\n"), failCount); + Log(format); + } + + return allocTestStepResult; + } + +// +// RTestVclnt2InvalidScaleFactor +// +RTestVclnt2InvalidScaleFactor::RTestVclnt2InvalidScaleFactor(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError) + { + } + +/** + * RTestVclnt2InvalidScaleFactor::NewL + */ +RTestVclnt2InvalidScaleFactor* RTestVclnt2InvalidScaleFactor::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError) + { + RTestVclnt2InvalidScaleFactor* self = new (ELeave) RTestVclnt2InvalidScaleFactor(aTestName, aSectName, aKeyName, aExpectedError); + return self; + } + +void RTestVclnt2InvalidScaleFactor::HandlePrepareCompleteL() + { + INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL()")); + iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow); + + // Try to scale the video to an invalid values + TRAPD(err, iVideoPlayer2->SetScaleFactorL(*iWindow, 0, 100)); + if (err != KErrArgument) + { + User::Leave(err == KErrNone ? KErrGeneral : err); + } + + TRAP(err, iVideoPlayer2->SetScaleFactorL(*iWindow, 100, -100)); + if (err != KErrArgument) + { + User::Leave(err == KErrNone ? KErrGeneral : err); + } + + // trigger the video to start playing + StartPlayback(); + }