diff -r 000000000000 -r a2952bb97e68 mmappcomponents/mmmtpdataprovider/tsrc/mtpdataprovidertestmodule/src/cmmmtpdataprovidertestmoduleblocks.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmappcomponents/mmmtpdataprovider/tsrc/mtpdataprovidertestmodule/src/cmmmtpdataprovidertestmoduleblocks.cpp Thu Dec 17 08:55:47 2009 +0200 @@ -0,0 +1,1348 @@ +/* +* Copyright (c) 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: Test module method implementations +* +*/ + + +// INCLUDE FILES + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "cmmmtpdataprovidertestmodule.h" +#include "cmmmtpdataprovidertester.h" +#include "cmediamtpdataprovidertester.h" +#include "cabstractmediamtpdataprovidertester.h" +#include "logging.h" + +// MACROS + +#ifdef LOGGER +#undef LOGGER +#endif +#define LOGGER iLog +#ifdef PRINTTESTMODULEIF +#undef PRINTTESTMODULEIF +#endif +#define PRINTTESTMODULEIF( p ) TestModuleIf().Printf( 0, KTestModuleName, p ); +#ifdef PRINTTESTMODULE +#undef PRINTTESTMODULE +#endif +#define PRINTTESTMODULE( p ) this->SetResultDescription( p ); + +// MEMBER FUNCTIONS + +void CMmMtpDataProviderTestModule::Delete() + { + PRINTF0( ">CMmMtpDataProviderTestModule::Delete()" ); + delete iDataProviderPlugin; + delete iPluginTester; + + if ( iRequest != NULL ) + { + PRINTN0( "Delete request" ); + delete iRequest; + } + REComSession::FinalClose(); + PRINTF0( "CMmMtpDataProviderTestModule::RunMethodL" ); + + static TStifFunctionInfo const KFunctions[] = + { + // Copy this line for every implemented function. + // First string is the function name used in TestScripter script file. + // Second is the actual implementation member function. + ENTRY( "LoadPlugin", CMmMtpDataProviderTestModule::LoadPluginL ), + ENTRY( "PrepareEnvironment", CMmMtpDataProviderTestModule::PrepareEnvironmentL ), + ENTRY( "CleanEnvironment", CMmMtpDataProviderTestModule::CleanEnvironmentL ), + ENTRY( "OpenSession", CMmMtpDataProviderTestModule::OpenSessionL ), + ENTRY( "CloseSession", CMmMtpDataProviderTestModule::CloseSessionL ), + ENTRY( "ObjectEnumeration", CMmMtpDataProviderTestModule::ObjectEnumerationL ), + ENTRY( "StorageEnumeration", CMmMtpDataProviderTestModule::StorageEnumerationL ), + ENTRY( "StartTransaction", CMmMtpDataProviderTestModule::StartTransactionL ), + ENTRY( "CancelTransaction", CMmMtpDataProviderTestModule::CancelTransactionL ), + ENTRY( "CompleteTransaction", CMmMtpDataProviderTestModule::CompleteTransactionL ), + ENTRY( "GetObjectInfo", CMmMtpDataProviderTestModule::GetObjectInfoL ), + ENTRY( "GetObject", CMmMtpDataProviderTestModule::GetObjectL ), + ENTRY( "GetObjectPropValue", CMmMtpDataProviderTestModule::GetObjectPropValueL ), + ENTRY( "GetObjectPropList", CMmMtpDataProviderTestModule::GetObjectPropListL ), + ENTRY( "GetObjectPropDesc", CMmMtpDataProviderTestModule::GetObjectPropDescL ), + ENTRY( "SendObjectInfo", CMmMtpDataProviderTestModule::SendObjectInfoL ), + ENTRY( "SendObject", CMmMtpDataProviderTestModule::SendObjectL ), + ENTRY( "SetObjectPropValue", CMmMtpDataProviderTestModule::SetObjectPropValueL ), + ENTRY( "SetObjectPropList", CMmMtpDataProviderTestModule::SetObjectPropListL ), + ENTRY( "DeleteObject", CMmMtpDataProviderTestModule::DeleteObjectL ), + ENTRY( "CopyObject", CMmMtpDataProviderTestModule::CopyObjectL ), + ENTRY( "MoveObject", CMmMtpDataProviderTestModule::MoveObjectL ), + ENTRY( "RenameObject", CMmMtpDataProviderTestModule::RenameObjectL ), + ENTRY( "GetPartialObject", CMmMtpDataProviderTestModule::GetPartialObjectL ), + ENTRY( "SetObjectReferences", CMmMtpDataProviderTestModule::SetObjectReferencesL ), + ENTRY( "GetObjectReferences", CMmMtpDataProviderTestModule::GetObjectReferencesL ), + ENTRY( "GetObjectPropsSupported", CMmMtpDataProviderTestModule::GetObjectPropsSupportedL) + }; + + const TInt count = sizeof( KFunctions ) / + sizeof( TStifFunctionInfo ); + + TInt result = RunInternalL( KFunctions, count, aItem ); + PRINTF1( "RegisterObserver( iTestObserver, iTestConnChannel, iDataProviderPlugin ); + } + else + { + PRINTE0( "Missing parameter: plugin name" ); + result = KErrArgument; + } + + PRINTN1( "Exiting LoadPluginL with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::PrepareEnvironmentL( CStifItemParser& /*aItem*/ ) + { + PRINTM0( "PrepareEnvironment" ); + + TInt result = iPluginTester->PrepareEnvironmentL(); + if ( result != KErrNone ) + { + PRINTE0( "Preparing environment failed" ); + } + PRINTN1( "Exiting PrepareEnvironmentL with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::CleanEnvironmentL( CStifItemParser& /*aItem*/ ) + { + PRINTM0( "CleanEnvironment" ); + + TInt result = iPluginTester->CleanEnvironmentL(); + if ( result != KErrNone ) + { + PRINTE0( "Cleaning environment failed" ); + } + PRINTN1( "Exiting CleanEnvironmentL with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::OpenSessionL ( CStifItemParser& aItem ) + { + PRINTM0( "OpenSession" ); + + TInt result = KErrNone; + if ( iSessionOpen ) + { + PRINTE0( "OpenSession failed, session already open" ); + result = KErrNotReady; + } + else + { + iSessionId++; + TInt sessionId; + result = aItem.GetNextInt ( sessionId ); + if ( result == KErrNone ) + { + PRINTN1( "Got session id parameter: %d", sessionId ); + iSessionId = sessionId; + } + else + { + PRINTN1( "GetNextInt returned %d", result ); + } + + TMTPNotificationParamsSessionChange param = { iSessionId, *iTestConnChannel } ; + if ( iPluginTester->OpenSessionL_prepare( param ) ) + { + iDataProviderPlugin->ProcessNotificationL( EMTPSessionOpened, ¶m ); + result = iPluginTester->OpenSessionL_checkresults(); + if ( result == KErrNone ) + { + iSessionOpen = ETrue; + } + else + { + PRINTE0( "OpenSession result check failed" ); + } + } + else + { + PRINTE0( "OpenSession prepare phase failed" ); + result = KErrGeneral; + } + } + + PRINTN1( "Exiting OpenSession with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::CloseSessionL ( CStifItemParser& aItem ) + { + PRINTM0( "CloseSession" ); + + TInt result = KErrNone; + if ( !iSessionOpen ) + { + PRINTE0( "CloseSession failed, session not open" ); + result = KErrNotReady; + } + else + { + TMTPNotificationParamsSessionChange param = { iSessionId, *iTestConnChannel }; + if ( iPluginTester->CloseSessionL_prepare( param ) ) + { + iDataProviderPlugin->ProcessNotificationL( EMTPSessionClosed, ¶m ); + result = iPluginTester->CloseSessionL_checkresults(); + if ( result == KErrNone ) + { + iSessionId = 0; + iSessionOpen = EFalse; + iTransactionId = 0; // start transaction numbering from beginning + iTransactionOpen = EFalse; + } + else + { + PRINTE0( "CloseSession result check failed" ); + } + } + else + { + PRINTE0( "CloseSession prepare phase failed" ); + result = KErrGeneral; + } + } + PRINTN1( "Exiting CloseSession with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::ObjectEnumerationL( CStifItemParser& /*aItem*/ ) + { + PRINTM0( "ObjectEnumeration" ); + + TInt result = KErrNotReady; + + TBool complete = iTestObserver->ObjectEnumerationComplete(); + if ( complete == EFalse ) + { + CMTPStorageMetaData* physicalStorage( CMTPStorageMetaData::NewLC() ); + CMTPStorageMetaData* logicalStorage( CMTPStorageMetaData::NewLC() ); + if ( iPluginTester->ObjectEnumerationL_prepare( physicalStorage, logicalStorage ) ) + { + TUint32 physicalStorageId; + physicalStorageId = iTestObserver->StorageMgr().AllocatePhysicalStorageIdL( 0, *physicalStorage ); + physicalStorage->SetUint( CMTPStorageMetaData::EStorageId, physicalStorageId ); + TUint32 logicalStorageId; + TRAP_IGNORE( logicalStorageId = iTestObserver->StorageMgr().AllocateLogicalStorageIdL( 0, physicalStorageId, *logicalStorage ) ); + logicalStorage->SetUint( CMTPStorageMetaData::EStorageId, logicalStorageId ); + iTestObserver->SetPendingOperation( CTestObserver::EObjectEnumeration ); + iDataProviderPlugin->StartObjectEnumerationL( KMTPStorageAll ); + iTestObserver->WaitForPendingOperation(); + result = iPluginTester->ObjectEnumerationL_checkresults( iTestObserver->ObjectMgr() ); + if ( result != KErrNone ) + { + PRINTE0( "ObjectEnumeration result check failed" ); + } + } + else + { + PRINTE0 ( "ObjectEnumeration prepare phase failed" ); + result = KErrGeneral; + } + CleanupStack::PopAndDestroy( 2 ); // logicalStorage, physicalStorage + } + else + { + PRINTE0( "Object enumeration already run in this session" ); + result = KErrGeneral; + } + + PRINTN1( "Exiting ObjectEnumerationL with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::StorageEnumerationL( CStifItemParser& /*aItem*/ ) + { + PRINTM0( "StorageEnumeration" ); + + TInt result = KErrNotReady; + TBool complete = iTestObserver->StorageEnumerationComplete(); + if ( complete == EFalse ) + { + if ( iPluginTester->StorageEnumerationL_prepare() ) + { + iDataProviderPlugin->StartStorageEnumerationL(); + complete = iTestObserver->StorageEnumerationComplete(); + if (complete) + { + result = KErrNone; + } + } + else + { + PRINTE0( "StartStorageEnumeration prepare phase failed" ); + result = KErrGeneral; + } + } + else + { + PRINTE0( "Storage enumeration already run in this session" ); + result = KErrGeneral; + } + return result; + } + +TInt CMmMtpDataProviderTestModule::StartTransactionL( CStifItemParser& aItem ) + { + PRINTM0( "StartTransaction" ); + + TInt result = KErrNone; + if ( iSessionOpen ) + { + if ( iTransactionOpen ) + { + PRINTE0( "StartTransaction failed, transaction already open" ); + result = KErrGeneral; + } + else + { + if ( iRequest != NULL ) + { + PRINTN0( "Delete previous request" ); + delete iRequest; + iRequest = NULL; + } + iRequest = new TMTPTypeRequest(); + iTransactionId++; + iTransactionOpen = ETrue; + iTestObserver->SetPhaseL( EUndefined ); + } + } + else + { + PRINTE0( "StartTransaction failed, session not open" ); + result = KErrNotReady; + } + + PRINTN1( "Exiting StartTransactionL with result %d", result ); + return result; + } + +// Notify that the current transaction has been cancelled. +// Affects: +// Response code of GetObject response phase +// Also default response code of other operations +// (EMTPRespCodeIncompleteTransfer) +// Outcome of SendObject/SendObjectInfo (should rollback) +TInt CMmMtpDataProviderTestModule::CancelTransactionL( CStifItemParser& /*aItem*/ ) + { + PRINTM0( "CancelTransaction" ); + + TInt result = KErrNone; + iTransactionOpen = EFalse; + TMTPTypeEvent eventDataSet; + eventDataSet.SetUint16( TMTPTypeEvent::EEventCode, EMTPEventCodeCancelTransaction ); + iDataProviderPlugin->ProcessEventL( eventDataSet, *iTestConnChannel ); + + PRINTN1( "Exiting CancelTransactionL with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::CompleteTransactionL( CStifItemParser& aItem ) + { + PRINTM0( "CompleteTransaction" ); + + TInt result = KErrNone; + if ( iSessionOpen ) + { + if ( !iTransactionOpen ) + { + PRINTE0( "CompleteTransaction failed, transaction not open" ); + result = KErrNotReady; + } + else + { + iTransactionOpen = EFalse; + TMTPTransactionPhase phase = iTestObserver->SetPhaseL( ECompletingPhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + } + } + else + { + PRINTE0( "CompleteTransaction failed, session not open" ); + result = KErrNotReady; + } + return result; + } + +TInt CMmMtpDataProviderTestModule::GetObjectInfoL( CStifItemParser& /*aItem*/ ) + { + PRINTM0( "GetObjectInfo" ); + + if ( !iTransactionOpen ) + { + PRINTE0( "Running GetObjectInfo without open transaction" ); + return KErrGeneral; + } + + TMTPTransactionPhase phase; + TInt result = KErrNone; + + iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId ); + TUint32 objectHandle = 2; + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter1, objectHandle ); + iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeGetObjectInfo ); + + if ( iPluginTester->GetObjectInfoL_prepare( *iRequest ) ) + { + phase = iTestObserver->SetPhaseL( ERequestPhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + phase = iTestObserver->SetPhaseL( EResponsePhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + if ( iTestObserver->iResponseCode != EMTPRespCodeOK ) + { + PRINTE0( "GetObjectInfo request failed" ); + PRINTE1( "Response code: 0x%x" , iTestObserver->iResponseCode ); + result = KErrGeneral; + } + else + { + result = iPluginTester->GetObjectInfoL_checkresults( static_cast ( iTestObserver->iMMTPTypeData ) ); + if ( result != KErrNone ) + { + PRINTE0( "GetObjectInfo result check failed" ); + } + } + } + else + { + PRINTE0( "GetObjectInfo prepare phase failed" ); + result = KErrGeneral; + } + + PRINTN1( "Exiting GetObjectInfoL with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::GetObjectL( CStifItemParser& /*aItem*/ ) + { + PRINTM0( "GetObject" ); + + if ( !iTransactionOpen ) + { + PRINTE0( "Running GetObject without open transaction" ); + return KErrGeneral; + } + + TMTPTransactionPhase phase; + TInt result = KErrNone; + + iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId ); + TUint32 objectHandle = 2; + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter1, objectHandle ); + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter2, KMTPFormatsAll ); + iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeGetObject ); + + if ( iPluginTester->GetObjectL_prepare( *iRequest ) ) + { + phase = iTestObserver->SetPhaseL( ERequestPhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + phase = iTestObserver->SetPhaseL( EResponsePhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + if ( iTestObserver->iResponseCode != EMTPRespCodeOK ) + { + PRINTE0( "GetObjectInfo request failed" ); + PRINTE1( "Response code: 0x%x" , iTestObserver->iResponseCode ); + result = KErrGeneral; + } + else + { + result = iPluginTester->GetObjectL_checkresults( const_cast( static_cast( iTestObserver->iMMTPTypeData ) ) ); + if ( result != KErrNone ) + { + PRINTE0( "GetObject result check failed" ); + } + } + } + else + { + result = KErrGeneral; + PRINTE0( "GetObject prepare phase failed" ); + } + + PRINTN1( "Exiting GetObjectL with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::GetObjectPropValueL( CStifItemParser& aItem ) + { + PRINTM0( "GetObjectPropValue" ); + + TMTPTransactionPhase phase; + TInt result = KErrNone; + + // get supported properties and test with them all + RArray properties; + iDataProviderPlugin->Supported( EObjectProperties, properties ); + + for ( TInt i = 0; i < properties.Count(); i++ ) + { + switch ( properties[i] ) + { + //case EMTPObjectPropCodeObjectFileName: // 0xDC07 + case EMTPObjectPropCodeName: // 0xDC44 + case EMTPObjectPropCodeArtist: // 0xDC46 + //case EMTPObjectPropCodeGenre: // 0xDC8C + //case EMTPObjectPropCodeParentalRating: // 0xDC94 + //case EMTPObjectPropCodeComposer: // 0xDC96 + //case EMTPObjectPropCodeOriginalReleaseDate: // 0xDC99 + case EMTPObjectPropCodeAlbumName: // 0xDC9A + //case EMTPObjectPropCodeEncodingProfile: // 0xDEA1 + //case EMTPObjectPropCodeDescription: + //case EMTPObjectPropCodeWidth: // 0xDC87 + //case EMTPObjectPropCodeHeight: // 0xDC88 + //case EMTPObjectPropCodeDuration: // 0xDC89 + //case EMTPObjectPropCodeUseCount: // 0xDC91 + //case EMTPObjectPropCodeSampleRate: // 0xDE93 + //case EMTPObjectPropCodeAudioWAVECodec: // 0xDE99 + //case EMTPObjectPropCodeAudioBitRate: // 0xDE9A + //case EMTPObjectPropCodeVideoFourCCCodec: // 0xDE9B + //case EMTPObjectPropCodeVideoBitRate: // 0xDE9C + //case EMTPObjectPropCodeFramesPerThousandSeconds: // 0xDE9D + //case EMTPObjectPropCodeKeyFrameDistance: // 0xDE9E + //case EMTPObjectPropCodeTrack: // 0xDC8B + //case EMTPObjectPropCodeDRMStatus: // 0xDC9D + //case EMTPObjectPropCodeNumberOfChannels: // 0xDE94 + //case EMTPObjectPropCodeScanType: // 0xDE97 + //case EMTPExtObjectPropCodeOmaDrmStatus: + result = StartTransactionL( aItem ); + if ( result != KErrNone ) + { + break; // transaction cycle is broken, better to abort + } + iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId ); + TUint32 objectHandle = 2; + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter1, objectHandle ); + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter2, properties[i] ); + iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeGetObjectPropValue ); + + if ( iPluginTester->GetObjectPropValueL_prepare( *iRequest ) ) + { + phase = iTestObserver->SetPhaseL( ERequestPhase ); + PRINTV1( "Testing with property 0x%x" , properties[i] ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + phase = iTestObserver->SetPhaseL( EResponsePhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + if ( iTestObserver->iResponseCode != EMTPRespCodeOK ) + { + if ( iTestObserver->iResponseCode == EMTPRespCodeAccessDenied ) + { + PRINTN1( "Could not access value for property 0x%x", properties[i] ); + } + else + { + PRINTE0( "GetObjectPropValue request failed" ); + PRINTE2( "Property code: 0x%x, response code: 0x%x", properties[i], iTestObserver->iResponseCode ); + result = KErrGeneral; + } + } + else + { + result = iPluginTester->GetObjectPropValueL_checkresults( iTestObserver->iMMTPTypeData, properties[i] ); + if ( result != KErrNone ) + { + PRINTE0( "GetObjectPropValue result check failed" ); + } + } + } + else + { + PRINTE0( "GetObjectPropValue prepare phase failed" ); + result = KErrGeneral; + } + + result = CompleteTransactionL( aItem ); + break; + } + // don't allow errors in any request + if ( result != KErrNone ) + { + break; + } + } + properties.Close(); + PRINTN1( "Exiting GetObjectPropValueL with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::GetObjectPropListL( CStifItemParser& aItem ) + { + PRINTM0( "GetObjectPropList" ); + + if ( !iTransactionOpen ) + { + PRINTE0( "Running GetObjectPropList without open transaction" ); + return KErrGeneral; + } + + TMTPTransactionPhase phase; + TInt result = KErrNone; + + iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter1, KMTPHandleAll ); + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter2, KMTPFormatsAll ); + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter3, EMTPObjectPropCodeUndefined ); + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter4, 0x00FF0000 ); // mediadb group + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter5, 0 ); // depth + iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeGetObjectPropList ); + + if ( iPluginTester->GetObjectPropListL_prepare( *iRequest ) ) + { + phase = iTestObserver->SetPhaseL( ERequestPhase ); + iTestObserver->SetPendingOperation( CTestObserver::EGetObjectPropList ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + result = iTestObserver->WaitForPendingOperation(); + if ( result != KErrNone ) + { + PRINTE0( "GetObjectPropList asynchronous operation failed" ); + } + else + { + phase = iTestObserver->SetPhaseL( EResponsePhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + if ( iTestObserver->iResponseCode != EMTPRespCodeOK ) + { + PRINTE0( "GetObjectPropList request failed" ); + PRINTE1( "Response code: 0x%x", iTestObserver->iResponseCode ); + result = KErrGeneral; + } + else + { + result = iPluginTester->GetObjectPropListL_checkresults( static_cast( iTestObserver->iMMTPTypeData ) ); + if ( result != KErrNone ) + { + PRINTE0( "GetObjectPropList result check failed" ); + } + } + } + } + else + { + PRINTE0( "GetObjectPropList prepare phase failed" ); + result = KErrGeneral; + } + + PRINTN1( "Exiting GetObjectPropList with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::GetObjectPropDescL( CStifItemParser& aItem ) + { + PRINTM0( "GetObjectPropDesc" ); + + TMTPTransactionPhase phase; + TInt result = KErrNone; + + // get supported properties and test with them all + RArray properties; + iDataProviderPlugin->Supported( EObjectProperties, properties ); + + for ( TInt i = 0; i < properties.Count(); i++ ) + { + if ( properties[i] < 0xde99 ) // some problem with these + { + result = StartTransactionL( aItem ); + if ( result != KErrNone ) + { + break; // transaction cycle is broken, better to abort + } + iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter2, KMTPFormatsAll ); + iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeGetObjectPropDesc ); + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter1, properties[i] ); + TInt result = KErrNone; + if ( iPluginTester->GetObjectPropDescL_prepare( *iRequest ) ) + { + phase = iTestObserver->SetPhaseL( ERequestPhase ); + PRINTV1( "Testing with property 0x%x", properties[i] ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + phase = iTestObserver->SetPhaseL( EResponsePhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + if ( iTestObserver->iResponseCode != EMTPRespCodeOK ) + { + PRINTE0( "GetObjectPropDesc request failed") + PRINTE2( "Property code: 0x%x, response code: 0x%x", properties[i], iTestObserver->iResponseCode ); + result = KErrGeneral; + } + else + { + result = iPluginTester->GetObjectPropDescL_checkresults( static_cast( iTestObserver->iMMTPTypeData ), properties[i] ); + if ( result != KErrNone ) + { + PRINTE0( "GetObjectPropDesc result check failed" ); + } + } + } + else + { + PRINTE0( "GetObjectPropValue prepare phase failed" ); + } + + result = CompleteTransactionL( aItem ); + // don't allow errors in any request + if ( result != KErrNone ) + { + break; + } + } + } + properties.Close(); + + PRINTN1( "Exiting GetObjectPropValueL with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::SendObjectInfoL( CStifItemParser& /*aItem*/ ) + { + PRINTM0( "SendObjectInfo" ); + + if ( !iTransactionOpen ) + { + PRINTE0( "Running SendObjectInfo without open transaction" ); + return KErrGeneral; + } + + TMTPTransactionPhase phase; + TInt result = KErrNone; + + iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId ); + TUint32 objectHandle = 0; // send to storage root + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter2, objectHandle ); + iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeSendObjectInfo ); + + if ( iPluginTester->SendObjectInfoL_prepare( *iRequest ) ) + { + phase = iTestObserver->SetPhaseL( ERequestPhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + phase = iTestObserver->SetPhaseL( EResponsePhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + if ( iTestObserver->iResponseCode != EMTPRespCodeOK ) + { + PRINTE0( "SendObjectInfo request failed" ) + PRINTE1( "Response code: 0x%x", iTestObserver->iResponseCode ); + result = KErrGeneral; + } + else + { + result = iPluginTester->SendObjectInfoL_checkresults(); + if ( result != KErrNone ) + { + PRINTE0( "SendObjectInfo result check failed" ); + } + } + } + else + { + PRINTE0( "SendObjectInfo prepare phase failed" ); + result = KErrGeneral; + } + + PRINTN1( "Exiting SendObjectInfoL with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::SendObjectL( CStifItemParser& /*aItem*/ ) + { + PRINTM0( "SendObject" ); + + if ( !iTransactionOpen ) + { + PRINTE0( "Running SendObject without open transaction" ); + return KErrGeneral; + } + + TMTPTransactionPhase phase; + TInt result = KErrNone; + + iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); + // the transaction id should be one greater than the id for send object info + iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId ); + // parameter 1 (storage id) is set in prepare function + TUint32 objectHandle = 0; // send to storage root + iRequest->SetUint32(TMTPTypeRequest::ERequestParameter2, objectHandle ); + iRequest->SetUint16(TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeSendObject ); + + if ( iPluginTester->SendObjectL_prepare( *iRequest ) ) + { + phase = iTestObserver->SetPhaseL( ERequestPhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + phase = iTestObserver->SetPhaseL( EResponsePhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + if ( iTestObserver->iResponseCode != EMTPRespCodeOK ) + { + PRINTE0( "SendObject request failed" ); + PRINTE1( "Response code: 0x%x", iTestObserver->iResponseCode ); + result = KErrArgument; + } + else + { + result = iPluginTester->SendObjectL_checkresults(); + if ( result != KErrNone ) + { + PRINTE0( "SendObject result check failed" ); + } + } + } + else + { + PRINTE0( "SendObject prepare phase failed" ); + result = KErrGeneral; + } + + PRINTN1( "Exiting SendObject with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::SetObjectPropValueL( CStifItemParser& aItem ) + { + PRINTM0( "SetObjectPropValue" ); + + TMTPTransactionPhase phase = ERequestPhase; + TInt result = KErrNone; + + // get supported properties and test with them all + RArray properties; + iDataProviderPlugin->Supported( EObjectProperties, properties ); + + for ( TInt i = 0; i < properties.Count(); i++ ) + { + switch ( properties[i] ) + { + //case EMTPObjectPropCodeObjectFileName: // 0xDC07 + case EMTPObjectPropCodeName: // 0xDC44 + case EMTPObjectPropCodeArtist: // 0xDC46 + //case EMTPObjectPropCodeGenre: // 0xDC8C + //case EMTPObjectPropCodeParentalRating: // 0xDC94 + //case EMTPObjectPropCodeComposer: // 0xDC96 + //case EMTPObjectPropCodeOriginalReleaseDate: // 0xDC99 + case EMTPObjectPropCodeAlbumName: // 0xDC9A + //case EMTPObjectPropCodeEncodingProfile: // 0xDEA1 + //case EMTPObjectPropCodeDescription: + //case EMTPObjectPropCodeWidth: // 0xDC87 + //case EMTPObjectPropCodeHeight: // 0xDC88 + //case EMTPObjectPropCodeDuration: // 0xDC89 + //case EMTPObjectPropCodeUseCount: // 0xDC91 + //case EMTPObjectPropCodeSampleRate: // 0xDE93 + //case EMTPObjectPropCodeAudioWAVECodec: // 0xDE99 + //case EMTPObjectPropCodeAudioBitRate: // 0xDE9A + //case EMTPObjectPropCodeVideoFourCCCodec: // 0xDE9B + //case EMTPObjectPropCodeFramesPerThousandSeconds: // 0xDE9D + //case EMTPObjectPropCodeKeyFrameDistance: // 0xDE9E + //case EMTPObjectPropCodeTrack: // 0xDC8B + //case EMTPObjectPropCodeDRMStatus: // 0xDC9D + //case EMTPObjectPropCodeNumberOfChannels: // 0xDE94 + //case EMTPObjectPropCodeScanType: // 0xDE97 + //case EMTPExtObjectPropCodeOmaDrmStatus: + result = StartTransactionL( aItem ); + if ( result != KErrNone ) + { + break; // transaction cycle is broken, better to abort + } + iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId ); + TUint32 objectHandle = 2; + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter1, objectHandle ); + iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeSetObjectPropValue ); + + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter2, properties[i] ); + TInt result = KErrNone; + if ( iPluginTester->SetObjectPropValueL_prepare( *iRequest ) ) + { + phase = iTestObserver->SetPhaseL( ERequestPhase ); + PRINTV1( "Testing with property 0x%x", properties[i] ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + phase = iTestObserver->SetPhaseL( EResponsePhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + if ( iTestObserver->iResponseCode != EMTPRespCodeOK ) + { + PRINTE0( "SetObjectPropValue request failed" ); + PRINTE2( "Property code: 0x%x, response code: 0x%x", properties[i], iTestObserver->iResponseCode ); + result = KErrGeneral; + } + else + { + result = iPluginTester->SetObjectPropValueL_checkresults( static_cast ( iTestObserver->iMMTPTypeData ) ); + if ( result != KErrNone ) + { + PRINTE0( "SetObjectPropValue result check failed" ); + } + } + } + else + { + PRINTE0( "SetObjectPropValue prepare phase failed" ); + } + + result = CompleteTransactionL( aItem ); + break; + } + // don't allow errors in any request + if ( result != KErrNone ) + { + break; + } + } + properties.Close(); + + PRINTN1( "Exiting SetObjectPropValueL with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::SetObjectPropListL( CStifItemParser& aItem ) + { + PRINTM0( "SetObjectPropList" ); + + if ( !iTransactionOpen ) + { + PRINTE0( "Running SetObjectPropList without open transaction" ); + return KErrGeneral; + } + + TMTPTransactionPhase phase; + TInt result = KErrNotReady; + + iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId ); + iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeSetObjectPropList ); + + if ( iPluginTester->SetObjectPropListL_prepare( *iRequest ) ) + { + phase = iTestObserver->SetPhaseL( ERequestPhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + phase = iTestObserver->SetPhaseL( EResponsePhase ); + iTestObserver->SetPendingOperation( CTestObserver::ESetObjectPropList ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + result = iTestObserver->WaitForPendingOperation(); + if ( result != KErrNone ) + { + PRINTE0( "SetObjectPropList asynchronous operation failed" ); + } + else + { + if ( iTestObserver->iResponseCode != EMTPRespCodeOK ) + { + PRINTE0( "SetObjectPropList request failed" ); + PRINTE1( "Response code: 0x%x", iTestObserver->iResponseCode ); + result = KErrGeneral; + } + else + { + result = iPluginTester->SetObjectPropListL_checkresults( static_cast( iTestObserver->iMMTPTypeData ) ); + if ( result != KErrNone ) + { + PRINTE0( "SetObjectPropList result check failed" ); + result = KErrGeneral; + } + } + } + } + else + { + PRINTE0( "SetObjectPropList prepare phase failed" ); + result = KErrGeneral; + } + + PRINTN1( "Exiting SetObjectPropList with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::DeleteObjectL( CStifItemParser& aItem ) + { + PRINTM0( "DeleteObject" ); + + if ( !iTransactionOpen ) + { + PRINTE0( "Running DeleteObject without open transaction" ); + return KErrGeneral; + } + + TMTPTransactionPhase phase; + TInt result = KErrNotReady; + + iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId ); + TUint32 objectHandle = KMTPHandleAll; + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter1, objectHandle ); + iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeDeleteObject ); + + if ( iPluginTester->DeleteObjectL_prepare( *iRequest ) ) + { + iTestObserver->SetPendingOperation( CTestObserver::EDeleteObject ); + phase = iTestObserver->SetPhaseL( ERequestPhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + result = iTestObserver->WaitForPendingOperation(); + phase = iTestObserver->SetPhaseL( EResponsePhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + if ( iTestObserver->iResponseCode != EMTPRespCodeOK ) + { + PRINTE0( "DeleteObject request failed" ); + PRINTE1( "Response code 0x%x", iTestObserver->iResponseCode ); + result = KErrGeneral; + } + else + { + result = iPluginTester->DeleteObjectL_checkresults( iTestObserver->ObjectMgr() ); + if ( result != KErrNone ) + { + PRINTE0( "DeleteObject result check failed" ); + } + } + } + else + { + PRINTE0( "DeleteObject prepare phase failed" ); + result = KErrGeneral; + } + + PRINTN1( "Exiting TestDeleteObjectL with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::CopyObjectL( CStifItemParser& aItem ) + { + PRINTM0( "CopyObject" ); + + if ( !iTransactionOpen ) + { + PRINTE0( "Running CopyObject without open transaction" ); + return KErrGeneral; + } + + TMTPTransactionPhase phase; + TInt result = KErrNone; + + iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId ); + TUint32 objectHandle = 3; + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter1, objectHandle ); + // parameter 2 (storage id) set in prepare function + TUint32 parentObjectHandle = 0; // copy to root directory + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter3, parentObjectHandle ); + iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeCopyObject ); + + if ( iPluginTester->CopyObjectL_prepare( *iRequest ) ) + { + phase = iTestObserver->SetPhaseL( ERequestPhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + phase = iTestObserver->SetPhaseL( EResponsePhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + if ( iTestObserver->iResponseCode != EMTPRespCodeOK ) + { + __TRACE( KError, ( _L( "CopyObject request phase failed, response code: 0x%x" ), iTestObserver->iResponseCode ) ); + result = KErrGeneral; + } + else + { + TUint32 handle = iTestObserver->iResponse.Uint32( TMTPTypeResponse::EResponseParameter1 ); + PRINTV1( "Copied object handle: %d", handle ); + CMTPObjectMetaData* metaData = CMTPObjectMetaData::NewLC(); + iTestObserver->ObjectMgr().ObjectL( handle, *metaData ); + result = iPluginTester->CopyObjectL_checkresults( metaData ); + if ( result != KErrNone ) + { + PRINTE0( "CopyObject result check failed" ); + } + CleanupStack::PopAndDestroy( metaData ); + } + } + else + { + PRINTE0( "CopyObject prepare phase failed" ); + result = KErrGeneral; + } + + PRINTN1( "Exiting CopyObject with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::MoveObjectL( CStifItemParser& aItem ) + { + PRINTM0( "MoveObject" ); + + if ( !iTransactionOpen ) + { + PRINTE0( "Running MoveObject without open transaction" ); + return KErrGeneral; + } + + TInt result = KErrNotReady; + TMTPTransactionPhase phase; + + iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); + // the transaction id should be one greater than the id for send object info + iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId ); + TUint32 objectHandle = 3; + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter1, objectHandle ); + // parameter 2 (storage id) is set in prepare function + TUint32 parentHandle = 0; // move to root directory + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter3, parentHandle ); + iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeMoveObject ); + + if ( iPluginTester->MoveObjectL_prepare( *iRequest ) ) + { + phase = iTestObserver->SetPhaseL( ERequestPhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + phase = iTestObserver->SetPhaseL( EResponsePhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + if ( iTestObserver->iResponseCode != EMTPRespCodeOK ) + { + PRINTE0( "MoveObject request failed" ); + PRINTE1( "Response code: 0x%x", iTestObserver->iResponseCode ); + result = KErrGeneral; + } + else + { + CMTPObjectMetaData* metaData = CMTPObjectMetaData::NewLC(); + iTestObserver->ObjectMgr().ObjectL( objectHandle, *metaData ); + result = iPluginTester->MoveObjectL_checkresults( metaData ); + if ( result != KErrNone ) + { + PRINTE0( "MoveObject result check failed" ); + } + CleanupStack::PopAndDestroy( metaData ); + } + } + else + { + PRINTE0( "MoveObject prepare failed" ); + result = KErrGeneral; + } + + PRINTN1( "Exiting MoveObject with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::RenameObjectL( CStifItemParser& aItem ) + { + PRINTM0( "RenameObject" ); + + TInt result = KErrNotReady; + TMTPNotificationParamsHandle param; + + if ( iPluginTester->RenameObjectL_prepare( param ) ) + { + TUint32 handle = param.iHandleId; + iDataProviderPlugin->ProcessNotificationL( EMTPRenameObject, ¶m ); + User::After( 10000 ); + CMTPObjectMetaData* metaData = CMTPObjectMetaData::NewLC(); + iTestObserver->ObjectMgr().ObjectL( handle, *metaData ); + result = iPluginTester->RenameObjectL_checkresults( metaData ); + if ( result != KErrNone ) + { + __TRACE( KError, ( _L( "Result check failed with error %d" ), result ) ); + } + CleanupStack::PopAndDestroy( metaData ); + } + else + { + PRINTE0( "RenameObject prepare phase failed" ); + result = KErrGeneral; + } + + return result; + } + +TInt CMmMtpDataProviderTestModule::GetPartialObjectL( CStifItemParser& aItem ) + { + PRINTM0( "GetPartialObject" ); + + if ( !iTransactionOpen ) + { + PRINTE0( "Running GetPartialObject without open transaction" ); + return KErrGeneral; + } + + TMTPTransactionPhase phase; + TInt result = KErrNone; + + iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId ); + TUint32 objectHandle = 2; // first enumerated object + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter1, objectHandle ); + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter2, 0 ); + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter3, KMTPHandleAll ); + iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeGetPartialObject ); + + if ( iPluginTester->GetPartialObjectL_prepare( *iRequest ) ) + { + phase = iTestObserver->SetPhaseL( ERequestPhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + phase = iTestObserver->SetPhaseL( EResponsePhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + if ( iTestObserver->iResponseCode != EMTPRespCodeOK ) + { + PRINTE0( "GetPartialObject request failed" ); + PRINTE1( "Response code: 0x%x", iTestObserver->iResponseCode ); + result = KErrGeneral; + } + else + { + result = iPluginTester->GetPartialObjectL_checkresults(); + if ( result != KErrNone ) + { + PRINTE0( "GetPartialObject result check failed" ); + } + } + } + else + { + PRINTE0( "GetPartialObject prepare phase failed" ); + result = KErrGeneral; + } + + PRINTN1( "Exiting GetPartialObjectL with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::SetObjectReferencesL( CStifItemParser& /*aItem*/ ) + { + PRINTM0( "SetObjectReferences" ); + TInt result = KErrNone; + PRINTN1( "Exiting SetObjectReferences with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::GetObjectReferencesL( CStifItemParser& /*aItem*/ ) + { + PRINTM0( "GetObjectReferences" ); + TInt result = KErrNone; + PRINTN1( "Exiting GetObjectReferences with result %d", result ); + return result; + } + +TInt CMmMtpDataProviderTestModule::GetObjectPropsSupportedL( CStifItemParser& /*aItem*/ ) + { + PRINTM0( "GetObjectPropsSupported" ); + + if ( !iTransactionOpen ) + { + PRINTE0( "Running GetObjectPropsSupported without open transaction" ); + return KErrGeneral; + } + + TMTPTransactionPhase phase; + TInt result = KErrNone; + + iRequest->SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestTransactionID, iTransactionId ); + iRequest->SetUint32( TMTPTypeRequest::ERequestParameter1, EMTPFormatCodeMP3 ); + iRequest->SetUint16( TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeGetObjectPropsSupported ); + + if ( iPluginTester->GetObjectPropsSupportedL_prepare( *iRequest ) ) + { + phase = iTestObserver->SetPhaseL( ERequestPhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + phase = iTestObserver->SetPhaseL( EResponsePhase ); + iDataProviderPlugin->ProcessRequestPhaseL( phase, *iRequest, *iTestConnChannel ); + if ( iTestObserver->iResponseCode != EMTPRespCodeOK ) + { + PRINTE0( "GetObjectPropsSupported request failed" ); + PRINTE1( "Response code: 0x%x", iTestObserver->iResponseCode ); + result = KErrGeneral; + } + else + { + result = iPluginTester->GetObjectPropsSupportedL_checkresults( static_cast( iTestObserver->iMMTPTypeData ) ); + if ( result != KErrNone ) + { + PRINTE0( "GetObjectPropsSupported result check failed" ); + } + } + } + else + { + PRINTE0( "GetObjectPropsSupported prepare phase failed" ); + result = KErrGeneral; + } + + PRINTN1( "Exiting GetObjectPropsSupportedL with result %d", result ); + return result; + }